From cf8ac6aa0108976a796fe12f47e5a676d9768a88 Mon Sep 17 00:00:00 2001 From: David Bailey Date: Thu, 25 Jan 2024 15:26:45 -0700 Subject: [PATCH 1/8] Updated sea ice example --- examples/coupled_model/config.yml | 11 + examples/nblibrary/adf_quick_run.ipynb | 2 +- examples/nblibrary/seaice.ipynb | 374 +++++++++++++++++++++++++ 3 files changed, 386 insertions(+), 1 deletion(-) create mode 100644 examples/nblibrary/seaice.ipynb diff --git a/examples/coupled_model/config.yml b/examples/coupled_model/config.yml index b7c37d2..7a36fc8 100644 --- a/examples/coupled_model/config.yml +++ b/examples/coupled_model/config.yml @@ -90,6 +90,13 @@ compute_notebooks: - 1850pAD - 1850pSASU + seaice: + parameter_groups: + none: + cases: + - b.e23_alpha16g.BLT1850.ne30_t232.073c + - b.e23_alpha16g.BLT1850.ne30_t232.075c + ########### JUPYTER BOOK CONFIG ########### @@ -126,6 +133,10 @@ book_toc: chapters: - file: land_comparison + - caption: SeaIce + chapters: + - file: seaice + ##################################### # Keys for Jupyter Book _config.yml # ##################################### diff --git a/examples/nblibrary/adf_quick_run.ipynb b/examples/nblibrary/adf_quick_run.ipynb index 93c28d5..d7eaf00 100644 --- a/examples/nblibrary/adf_quick_run.ipynb +++ b/examples/nblibrary/adf_quick_run.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "4d0264e2-c116-4e18-af33-0ce3adabcd60", "metadata": {}, "outputs": [], diff --git a/examples/nblibrary/seaice.ipynb b/examples/nblibrary/seaice.ipynb new file mode 100644 index 0000000..63a54c0 --- /dev/null +++ b/examples/nblibrary/seaice.ipynb @@ -0,0 +1,374 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "7e7f10ae-61c8-45f1-9d5c-9be60632b556", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import xarray as xr\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.path as mpath\n", + "from matplotlib.gridspec import GridSpec\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "import nc_time_axis\n", + "import cftime\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "270b0ff5-779c-4293-8d06-bd91eb8eee2b", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "parameters" + ] + }, + "outputs": [], + "source": [ + "CESM_output_dir = \"/glade/campaign/cesm/development/cross-wg/diagnostic_framework/CESM_output_for_testing\"\n", + "cases = [\"b.e23_alpha16g.BLT1850.ne30_t232.073c\",\"b.e23_alpha16g.BLT1850.ne30_t232.075c\"]\n", + "\n", + "begyr1 = 1\n", + "endyr1 = 38\n", + "begyr2 = 1\n", + "endyr2 = 38" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3f591cc-dd67-4a3f-abe7-bfc740743db1", + "metadata": {}, + "outputs": [], + "source": [ + "# Read in two cases. The ADF timeseries are needed here.\n", + "\n", + "case1 = cases[0]\n", + "case2 = cases[1]\n", + "\n", + "cbegyr1 = f\"{begyr1:04d}\"\n", + "cendyr1 = f\"{endyr1:04d}\"\n", + "cbegyr2 = f\"{begyr2:04d}\"\n", + "cendyr2 = f\"{endyr2:04d}\"\n", + "\n", + "ds1 = xr.open_dataset(CESM_output_dir+\"/\"+case1+\"/ts/\"+case1+\".cice.h.\"+\"aice.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", + "ds2 = xr.open_dataset(CESM_output_dir+\"/\"+case2+\"/ts/\"+case2+\".cice.h.\"+\"aice.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", + "ds3 = xr.open_dataset(CESM_output_dir+\"/\"+case1+\"/ts/\"+case1+\".cice.h.\"+\"hi.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", + "ds4 = xr.open_dataset(CESM_output_dir+\"/\"+case2+\"/ts/\"+case2+\".cice.h.\"+\"hi.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", + "ds5 = xr.open_dataset(CESM_output_dir+\"/\"+case1+\"/ts/\"+case1+\".cice.h.\"+\"hs.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", + "ds6 = xr.open_dataset(CESM_output_dir+\"/\"+case2+\"/ts/\"+case2+\".cice.h.\"+\"hs.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", + "\n", + "TLAT = ds1['TLAT']\n", + "TLON = ds1['TLON']\n", + "tarea = ds1['tarea']\n", + "\n", + "months = ds1.time.dt.month\n", + "seasons = xr.full_like(months, fill_value=\"none\", dtype=\"U4\")\n", + "seasons.name = \"season\"\n", + "seasons[months.isin([1, 2, 3])] = \"JFM\"\n", + "seasons[months.isin([4, 5, 6])] = \"AMJ\"\n", + "seasons[months.isin([7, 8, 9])] = \"JAS\"\n", + "seasons[months.isin([10, 11, 12])] = \"OND\"\n", + "\n", + "# Make a DataArray with the number of days in each month, size = len(time)\n", + "month_length = ds1.time.dt.days_in_month\n", + "weights_season = month_length.groupby(seasons) / month_length.groupby(seasons).sum()\n", + "weights_monthly = month_length.groupby(\"time.year\") / month_length.groupby(\"time.year\").sum()\n", + "\n", + "aice1_ann = (ds1['aice'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", + "aice2_ann = (ds2['aice'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", + "hi1_ann = (ds3['hi'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", + "hi2_ann = (ds4['hi'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", + "hs1_ann = (ds5['hs'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", + "hs2_ann = (ds6['hs'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", + "\n", + "aice1_seas = (ds1['aice'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "\n", + "aice1_seas[0::4,:,:]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "da24abe2-7b48-4c3d-b8a5-95847029bd74", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_diff(field1, field2, field_min, field_max, case1, case2, proj):\n", + " # make circular boundary for polar stereographic circular plots\n", + " theta = np.linspace(0, 2*np.pi, 100)\n", + " center, radius = [0.5, 0.5], 0.5\n", + " verts = np.vstack([np.sin(theta), np.cos(theta)]).T\n", + " circle = mpath.Path(verts * radius + center)\n", + "\n", + " # set up the figure with a North Polar Stereographic projection\n", + " fig = plt.figure(tight_layout=True)\n", + " gs = GridSpec(2, 4)\n", + "\n", + " if (proj == \"N\"):\n", + " ax = fig.add_subplot(gs[0,:2], projection=ccrs.NorthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, 90, 45], crs=ccrs.PlateCarree())\n", + " if (proj == \"S\"):\n", + " ax = fig.add_subplot(gs[0,:2], projection=ccrs.SouthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, -90, -45], crs=ccrs.PlateCarree())\n", + "\n", + " ax.set_boundary(circle, transform=ax.transAxes)\n", + " ax.add_feature(cfeature.LAND,zorder=100,edgecolor='k')\n", + "\n", + " field_diff = field2-field1\n", + " field_std = field_diff.std()\n", + "\n", + " this=ax.pcolormesh(TLON,\n", + " TLAT,\n", + " field1,\n", + " cmap=\"Blues_r\",vmax=field_max,vmin=field_min,\n", + " transform=ccrs.PlateCarree())\n", + " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", + " plt.title(case1,fontsize=10)\n", + "\n", + " if (proj == \"N\"):\n", + " ax = fig.add_subplot(gs[0,2:], projection=ccrs.NorthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, 90, 45], crs=ccrs.PlateCarree())\n", + " if (proj == \"S\"):\n", + " ax = fig.add_subplot(gs[0,2:], projection=ccrs.SouthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, -90, -45], crs=ccrs.PlateCarree())\n", + "\n", + " ax.set_boundary(circle, transform=ax.transAxes)\n", + " ax.add_feature(cfeature.LAND,zorder=100,edgecolor='k')\n", + "\n", + " this=ax.pcolormesh(TLON,\n", + " TLAT,\n", + " field2,\n", + " cmap=\"Blues_r\",vmax=field_max,vmin=field_min,\n", + " transform=ccrs.PlateCarree())\n", + " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", + " plt.title(case2,fontsize=10)\n", + "\n", + " if (proj == \"N\"):\n", + " ax = fig.add_subplot(gs[1,1:3], projection=ccrs.NorthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, 90, 45], crs=ccrs.PlateCarree())\n", + " if (proj == \"S\"):\n", + " ax = fig.add_subplot(gs[1,1:3], projection=ccrs.SouthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, -90, -45], crs=ccrs.PlateCarree())\n", + "\n", + " ax.set_boundary(circle, transform=ax.transAxes)\n", + " ax.add_feature(cfeature.LAND,zorder=100,edgecolor='k')\n", + "\n", + " this=ax.pcolormesh(TLON,\n", + " TLAT,\n", + " field_diff,\n", + " cmap=\"seismic\",vmax=field_std*2.0,vmin=-field_std*2.0,\n", + " transform=ccrs.PlateCarree())\n", + " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", + " plt.title(case2+\"-\"+case1,fontsize=10)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "28a0da20-6bad-45d7-a61a-43d55ea2acd2", + "metadata": {}, + "outputs": [], + "source": [ + "plot_diff(aice1_ann[::-25,:,:].mean('time'),aice2_ann[::-25,:,:].mean('time'),0.,1.,case1,case2,\"N\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c58f985-814d-4429-9917-fb0c15a4b2ee", + "metadata": {}, + "outputs": [], + "source": [ + "plot_diff(hi1_ann[::-25,:,:].mean('time'),hi2_ann[::-25,:,:].mean('time'),0.,5.,case1,case2,\"N\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d32f3af9-8d4d-4908-b12b-0c355d4644af", + "metadata": {}, + "outputs": [], + "source": [ + "plot_diff(hs1_ann[::-25,:,:].mean('time'),hs2_ann[::-25,:,:].mean('time'),0.,0.5,case1,case2,\"N\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab99806f-31e8-41a1-8e1d-752c0d4325dc", + "metadata": {}, + "outputs": [], + "source": [ + "plot_diff(aice1_ann[::-25,:,:].mean('time'),aice2_ann[::-25,:,:].mean('time'),0.,1.,case1,case2,\"S\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab1c8910-677e-4345-8f06-ec3f7a4a9f07", + "metadata": {}, + "outputs": [], + "source": [ + "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "\n", + "ds_area.plot()\n", + "ds2_area.plot()\n", + "\n", + "plt.ylim((0,25))\n", + "plt.xlabel(\"Month\")\n", + "plt.ylabel(\"NH Sea Ice Area $m x 10^{12}$\")\n", + "plt.legend([case1,case2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90d62f0a-e43b-4bad-a759-0133bc2860aa", + "metadata": {}, + "outputs": [], + "source": [ + "ds_area.sel(time=ds_area.time.dt.month.isin([10])).plot()\n", + "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", + "\n", + "plt.ylim((0,25))\n", + "plt.xlabel(\"Year\")\n", + "plt.ylabel(\"NH September Sea Ice Area $m x 10^{12}$\")\n", + "plt.legend([case1,case2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45366ccd-555b-49aa-93a2-51b83e802d16", + "metadata": {}, + "outputs": [], + "source": [ + "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "\n", + "ds_area.plot()\n", + "ds2_area.plot()\n", + "\n", + "plt.ylim((0,25))\n", + "plt.xlabel(\"Month\")\n", + "plt.ylabel(\"SH Sea Ice Area $m x 10^{12}$\")\n", + "plt.legend([case1,case2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68400aca-aa0c-47f1-b7de-2c34dca5ac70", + "metadata": {}, + "outputs": [], + "source": [ + "ds_area.sel(time=ds_area.time.dt.month.isin([10])).plot()\n", + "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", + "\n", + "plt.ylim((0,25))\n", + "plt.xlabel(\"Year\")\n", + "plt.ylabel(\"SH September Sea Ice Area $m x 10^{12}$\")\n", + "plt.legend([case1,case2])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de2232e9-2705-4894-b98a-a93082ae7f79", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "##### Add the data values manually from the datafile.\n", + "##### Create an xarray object with the NSIDC values and the years from 1979 to 2022.\n", + "\n", + "seaice_index = [4.58,4.87,4.44,4.43,4.7,4.11,4.23,4.72,5.64,5.36,4.86,4.55,4.51,5.43,4.58,5.13,4.43,5.62,\\\n", + " 4.89,4.3,4.29,4.35,4.59,4.03,4.05,4.39,4.07,4.01,2.82,3.26,3.76,3.34,3.21,2.41,3.78,3.74,\\\n", + " 3.42,2.91,3.35,3.35,3.17,2.83,3.47,3.47]\n", + "\n", + "# Convert to m^2\n", + "seaice_index = np.array(seaice_index)\n", + "#seaice_index *= 1e12\n", + "\n", + "nsidc_time = [cftime.datetime(y, 10, 15) for y in range(1,45)]\n", + "\n", + "nsidc_index = xr.DataArray(data=seaice_index,coords={\"time\":nsidc_time})\n", + "\n", + "nsidc_index\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00fc5097-af7d-4cf2-94ab-bb4e0a63960c", + "metadata": {}, + "outputs": [], + "source": [ + "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "\n", + "ds_area.sel(time=ds_area.time.dt.month.isin([10])).plot()\n", + "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", + "nsidc_index.plot()\n", + "\n", + "plt.ylim((0,25))\n", + "plt.xlabel(\"Month\")\n", + "plt.ylabel(\"Sea Ice Area $mx10^{12}$\")\n", + "plt.legend([case1,case2,\"NSIDC\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b9a9ad99-e580-4188-a328-950c84eb1b62", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:cupid-analysis]", + "language": "python", + "name": "conda-env-cupid-analysis-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 7d39c846b31ae5f24e722be61c22f55903bf4881 Mon Sep 17 00:00:00 2001 From: David Bailey Date: Thu, 25 Jan 2024 16:14:20 -0700 Subject: [PATCH 2/8] Additional cleanup in the sea ice notebook --- examples/nblibrary/seaice.ipynb | 734 ++++++++++++++++++++++++++++++-- 1 file changed, 694 insertions(+), 40 deletions(-) diff --git a/examples/nblibrary/seaice.ipynb b/examples/nblibrary/seaice.ipynb index 63a54c0..4b5e0ff 100644 --- a/examples/nblibrary/seaice.ipynb +++ b/examples/nblibrary/seaice.ipynb @@ -1,8 +1,16 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "351f2902-54b0-463c-9d61-23574844481f", + "metadata": {}, + "source": [ + "### Sea Ice Diagnostics for two CESM3 runs" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "7e7f10ae-61c8-45f1-9d5c-9be60632b556", "metadata": { "editable": true, @@ -20,14 +28,12 @@ "from matplotlib.gridspec import GridSpec\n", "import cartopy.crs as ccrs\n", "import cartopy.feature as cfeature\n", - "import nc_time_axis\n", - "import cftime\n", - "import os" + "import cftime" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "270b0ff5-779c-4293-8d06-bd91eb8eee2b", "metadata": { "editable": true, @@ -51,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "d3f591cc-dd67-4a3f-abe7-bfc740743db1", "metadata": {}, "outputs": [], @@ -77,17 +83,9 @@ "TLON = ds1['TLON']\n", "tarea = ds1['tarea']\n", "\n", - "months = ds1.time.dt.month\n", - "seasons = xr.full_like(months, fill_value=\"none\", dtype=\"U4\")\n", - "seasons.name = \"season\"\n", - "seasons[months.isin([1, 2, 3])] = \"JFM\"\n", - "seasons[months.isin([4, 5, 6])] = \"AMJ\"\n", - "seasons[months.isin([7, 8, 9])] = \"JAS\"\n", - "seasons[months.isin([10, 11, 12])] = \"OND\"\n", "\n", "# Make a DataArray with the number of days in each month, size = len(time)\n", "month_length = ds1.time.dt.days_in_month\n", - "weights_season = month_length.groupby(seasons) / month_length.groupby(seasons).sum()\n", "weights_monthly = month_length.groupby(\"time.year\") / month_length.groupby(\"time.year\").sum()\n", "\n", "aice1_ann = (ds1['aice'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", @@ -97,14 +95,19 @@ "hs1_ann = (ds5['hs'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", "hs2_ann = (ds6['hs'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", "\n", - "aice1_seas = (ds1['aice'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", "\n", - "aice1_seas[0::4,:,:]" + "aice1_seas = (ds1['aice'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "aice2_seas = (ds2['aice'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "hi1_seas = (ds3['hi'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "hi2_seas = (ds4['hi'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "hs1_seas = (ds5['hs'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "hs2_seas = (ds6['hs'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "da24abe2-7b48-4c3d-b8a5-95847029bd74", "metadata": {}, "outputs": [], @@ -186,50 +189,115 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "28a0da20-6bad-45d7-a61a-43d55ea2acd2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_diff(aice1_ann[::-25,:,:].mean('time'),aice2_ann[::-25,:,:].mean('time'),0.,1.,case1,case2,\"N\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "2c58f985-814d-4429-9917-fb0c15a4b2ee", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_diff(hi1_ann[::-25,:,:].mean('time'),hi2_ann[::-25,:,:].mean('time'),0.,5.,case1,case2,\"N\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "d32f3af9-8d4d-4908-b12b-0c355d4644af", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_diff(hs1_ann[::-25,:,:].mean('time'),hs2_ann[::-25,:,:].mean('time'),0.,0.5,case1,case2,\"N\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "ab99806f-31e8-41a1-8e1d-752c0d4325dc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnsAAAHVCAYAAACJyj2UAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd5wU5f3H388zbevtVXpviqIYQRQQFQtYEew1GluMRn/2hrFGTayxtxiNJfYYsWuMHSuCDRU7SJV6XN2dmef3xzMzu0c99OAO3A+vebE3Mzvz7N7u57718xVKKUURRRRRRBFFFFFEERskZGsvoIgiiiiiiCKKKKKItYeisVdEEUUUUUQRRRSxAaNo7BVRRBFFFFFEEUVswCgae0UUUUQRRRRRRBEbMIrGXhFFFFFEEUUUUcQGjKKxV0QRRRRRRBFFFLEBo2jsFVFEEUUUUUQRRWzAKBp7RRRRRBFFFFFEERswisZeEUUUUUQRRRRRxAaMNTL2dthhB0455ZS1tJTWw5FHHsnYsWPX6Dk9evTgb3/721pZTxFFFNG2UeTCPIpcWEQRbR+tGtlbuHAhJ510EhtttBGJRIJu3bpx8skns2TJkibnjRkzhm7duhGLxejYsSOHH344s2bNaqVVtxxmz57NIYccwkYbbYSUcqV/PBYvXsyJJ55Ix44dicVi9O/fn2efffYX3fuee+5BCBFtqVSKQYMG8e9//7vJecv+UXv11VebPG9F2z333ENDQwNHHnkkm222GaZprvQPyAMPPMDAgQNJJBJ07NiR3/3udyxYsGCl6wy3hoaGJte55ZZb6NmzJ7FYjEGDBvHGG2/8ovenOViwYAG77rornTp1wnEcunbtyh//+Eeqq6ubnPfJJ5+w/fbbE4/H6dy5M5dccgnNnVJ40UUXscUWWzTZ11Lfm48++oiDDz6Yrl27Eo/H6d+/P9dff/1q19TY2MhJJ51EZWUlyWSSMWPG8OOPP0bHV/UZef/999fovfu1oMiFRS4scuGqsaFyIbDC47fddluz3pfmolWNvVmzZjFr1iyuvvpqPvnkE+655x6ef/55jj766CbnjRw5kkceeYQvv/ySxx9/nG+++Yb99tuvlVbdcmhsbKSqqorx48czcODAFZ6TzWbZZZdd+P7773nsscf48ssvufPOO+ncufMvvn9JSQmzZ89m9uzZTJ48mdGjR3PAAQfw5ZdfrvQ5w4YNi54ze/ZsDjjgAHbdddcm+w488EA8zyMej3PyySez8847r/Bab775Jr/97W85+uij+eyzz3j00Ud5//33OeaYY1a6znCLxWLR8YcffphTTjmF8ePHM3nyZEaMGMFuu+3G9OnTf/F7tCpIKdl7772ZMGEC06ZN45577uG///0vxx9/fHROdXU1u+yyC506deL999/nxhtv5Oqrr+baa6/92fdtqe/NpEmTqKqq4v777+ezzz5j/PjxnHvuudx0002rvP8pp5zCE088wUMPPcSbb75JTU0Ne+65J57nAct/RmbPns0xxxxDjx49GDx4cLPfu18TilxY5MIiF645NgQuDHH33Xc3Oe+II4742e/LCqHWANtvv7068cQT1YknnqgymYwqLy9X48ePV77vr/Q5EyZMUFtuuaVyHEf17NlTXXTRRSqXy630/EceeUTZtr3Kc5588kklhFDZbHa1a3ZdVx111FGqR48eKhaLqX79+qm//e1vTc454ogj1N57771Gr7N79+7qsssuU7/73e9UKpVSXbt2VbfffnuT65511lmqb9++Kh6Pq549e6rzzz9/pWvefvvt1f/93/8tt//WW29VvXr1WuVrra6uVocccohKJBKqQ4cO6tprr13p9ULcfffdKpPJNNnneZ6yLEs98sgjq11XiGXfuzU556qrrlK9evVqsu+GG25QXbp0WeU6l8WQIUPU8ccf32TfxhtvrM4555yVPufCCy9UAwcOVPfee6/q3r27KikpUQceeKCqrq6OzvF9X/31r39VPXv2VLFYTG2++ebq0UcfXeVarr/++ibrv+WWW1Qmk1ENDQ3RviuuuEJ16tRpld8bpfRrB5psd9999wrPbanvzQknnKBGjhy50uOLFy9WlmWphx56KNo3c+ZMJaVUzz///Aqfk81mVbt27dQll1yy0usqtfx7p5RSb775ptpuu+1UPB5XpaWlatSoUWrhwoWrvM66QJELi1y4LIpc2BRFLlweK+NCQD3xxBMrvZdSv5wL1ziy989//hPTNHn33Xe54YYbuO666/j73/++wnNfeOEFDjvsME4++WSmTp3K7bffzj333MNll1220usvWbKEkpISTNNc4fGFCxfywAMPMGzYMCzLWu16fd+nS5cuPPLII0ydOpULLriA8847j0ceeeQXv85rrrmGwYMHM3nyZE444QT+8Ic/8MUXX0TH0+k099xzD1OnTuX666/nzjvv5LrrrlvtmgsxYcIEhg4dyoknnkj79u0ZMGAAl19+eeQ5AJx22mm89dZbTJgwgZdeeok33niDDz/8cI3u43ke//znPwHYcsst1+i5PxfDhg3jxx9/5Nlnn0Upxdy5c3nsscfYY489mpxXU1ND9+7d6dKlC3vuuSeTJ0+OjmWzWSZNmsSoUaOaPGfUqFFMnDhxlff/5ptv+M9//sPTTz/N008/zWuvvcZf/vKX6Pj555/P3Xffza233spnn33GqaeeymGHHcZrr722wuvNmjWLf//732y//fbRvrfffpvtt98ex3GifaNHj2bWrFl8//33q1zfgQceyOmnn86mm27aJFKwIrTU92bJkiWUl5ev9PikSZPI5XJN3u9OnToxYMCAlb7fEyZMYP78+Rx55JErve6K3rspU6aw0047semmm/L222/z5ptvstdeezX57LcmilyYR5ELfxmKXPj9Ktf3a+DCP/7xj1RWVrLVVltx22234ft+dKxFuLDZZqHSnk3//v2bWOFnn3226t+//wrPHzFihLr88sub7LvvvvtUx44dV3j+/PnzVbdu3dT48eOXO3bWWWepRCKhALXNNtuo+fPnr8nSm+CEE05Q++67b/TzirzZ1b3O7t27q8MOOyz62fd91a5dO3Xrrbeu9L5XXnmlGjRo0AqPrcxr3GijjZTjOOqoo45SH3zwgXrwwQdVeXm5uvjii5VS2pO1LKuJl7V48WKVSCRW680CKplMqmQyqaSUynGc5byltenNKqXUo48+qlKplDJNUwFqzJgxTbytt99+W913331qypQp6vXXX1f77ruvisfjatq0aUop7UkB6q233mpy3csuu0z169dvpWu68MILVSKRaOK9nnnmmWrrrbdWSilVU1OjYrGYmjhxYpPnHX300erggw9usu+ggw5S8XhcAWqvvfZS9fX10bFddtlFHXvssU3OD9e87LVXts6BAweu8pyW+t5MnDhRWZalXnzxxZWe88ADDyjbtpfbv8suu6jjjjtuhc/Zbbfd1G677bbCY6t67w4++GA1fPjwla6lNVHkwiIXLosiFxa5UKmfx4WXXnqpmjhxopo8ebK6+uqrVSKRUJdeeml0vCW4cI0je9tssw1CiOjnoUOH8tVXX63Qwpw0aRKXXHIJqVQq2o499lhmz55NXV1dk3Orq6vZY4892GSTTbjwwguXu9aZZ57J5MmTefHFFzEMg9/+9rfNLuy87bbbGDx4MFVVVaRSKe68887V1jA053Vuvvnm0WMhBB06dGDevHnRvscee4xtt92WDh06kEql+NOf/rTGtRO+79OuXTvuuOMOBg0axEEHHcT48eO59dZbAfj222/J5XIMGTIkek4mk2GjjTZa7bXT6TRTpkxhypQpTJ48mcsvv5zf//73PPXUU2u0xp+LqVOncvLJJ3PBBRcwadIknn/+eb777rsmdR7bbLMNhx12GAMHDmTEiBE88sgj9OvXjxtvvLHJtQp/VwBKqeX2LYsePXqQTqejnzt27Bj9/qZOnUpDQwO77LJLk8/vvffeyzfffNPkOtdddx0ffvgh//nPf/jmm2847bTTVru2Fe3/OWip781nn33G3nvvzQUXXMAuu+yyxutY2fv9448/8sILLyxXQxNiVe9d6M22VRS5sMiFLYUiF/66ufD8889n6NChbLHFFpx++ulccsklXHXVVdHxluDCFcc5Wwi+73PxxRezzz77LHessKh06dKl7LrrrqRSKZ544okVhlYrKyuprKykX79+9O/fn65du/LOO+8wdOjQVa7hkUce4dRTT+Waa65h6NChpNNprrrqKt59991f/PqWXacQIgq9vvPOOxx00EFcfPHFjB49mkwmw0MPPcQ111yzRvfo2LEjlmVhGEa0r3///syZM4dsNrvSL0tzyF9KSZ8+faKfN998c1588UX++te/stdee63ROn8OrrjiCoYPH86ZZ54Z3T+ZTDJixAj+/Oc/07FjxxWueauttuKrr74C9OfCMAzmzJnT5Lx58+bRvn37Vd5/Vb+/8P9nnnlmuQLwwjQEQIcOHejQoQMbb7wxFRUVjBgxgj/96U907NiRDh06rHBtwGrXtzq01Pdm6tSp7Ljjjhx77LGcf/75q7xnhw4dyGazLFq0iLKysiavadiwYcudf/fdd1NRUcGYMWNWer2VvXfxeLy5b0WbR5ELi1y4KhS5sMiFhdhmm22orq5m7ty5tG/fvkW4cI0je++8885yP/ft27fJFzDElltuyZdffkmfPn2W26TUt66urmbUqFHYts2ECROaEN/KEH55GxsbV3vuG2+8wbBhwzjhhBP4zW9+Q58+fZbzRn7p61wR3nrrLbp378748eMZPHgwffv25YcffmjWcwsxfPhwvv766yb5+2nTptGxY0ds26Z3795YlsV7770XHa+uro4IYE1hGAb19fU/67lrirq6uuhzUHh/WDlBK6WYMmVKRH62bTNo0CBeeumlJue99NJLK/zCNRebbLIJjuMwffr05T67Xbt2Xenzlv1sDh06lNdff51sNhud8+KLL9KpUyd69Oix2nXYtr3CSFFLfW8+++wzRo4cyRFHHLHK+rEQgwYNwrKsJu/37Nmz+fTTT5d7v5VS3H333fz2t79tVk3ZsuvbfPPNefnll1f7vNZCkQuLXNhSKHJhj9Wu49fEhZMnTyYWi1FaWgq0DBeucWRvxowZnHbaafz+97/nww8/5MYbb4w8tHPPPZeZM2dy7733AnDBBRew55570rVrV/bff3+klHz88cd88skn/PnPf2bp0qWMGjWKuro67r//fqqrqyNdnqqqKgzD4L333uO9995j2223paysjG+//ZYLLriA3r17r9aTBejTpw/33nsvL7zwAj179uS+++7j/fffp2fPnj/7dTYHffr0Yfr06Tz00ENstdVWPPPMMzzxxBPLnTdlyhRAF97+9NNPTJkyBdu22WSTTQD4wx/+wI033sj//d//cdJJJ/HVV19x+eWXc/LJJwM6/XDEEUdw5plnUl5eTrt27bjwwguRUjbxcJf93YD+AIaeVn19PS+99BIvvPACF1xwQZM1husqROjBrQpTp04lm82ycOFCli5dGl0j1Eraa6+9OPbYY7n11lsZPXo0s2fP5pRTTmHIkCF06tQJgIsvvphtttmGvn37Ul1dzQ033MCUKVO4+eabo/ucdtppHH744QwePJihQ4dyxx13MH369CYpkBW9/lUhnU5zxhlncOqpp+L7Pttuuy3V1dVMnDiRVCrFEUccwbPPPsvcuXPZaqutSKVSTJ06lbPOOovhw4dH5HXIIYdw8cUXc+SRR3LeeedFv78LLrigWamLHj168N133zFlyhS6dOlCOp0mm822yPcmJLdRo0Zx2mmnRZ8FwzCoqqoCYObMmey0007ce++9DBkyhEwmw9FHH83pp59ORUUF5eXlnHHGGWy22WbLyUr873//47vvvlth2qI57925557LZpttxgknnMDxxx+Pbdu88sor7L///lRWVjbr97g2UeTC5qHIhUUuhCIXrowLn3rqKebMmcPQoUOJx+O88sorjB8/nuOOOy6KnLYIF65Jgd/222+vTjjhBHX88cerkpISVVZWps4555yoePeII45Q22+/fZPnPP/882rYsGEqHo+rkpISNWTIEHXHHXcopZR65ZVXlmunDrfvvvtOKaXUxx9/rEaOHKnKy8uV4ziqR48e6vjjj1c//vhjs9bc0NCgjjzySJXJZFRpaan6wx/+oM4555wmhZ4rKkpe1etUShclX3fddU3uNXDgQHXhhRdGP5955pmqoqJCpVIpdeCBB6rrrrtuudb5Fb327t27Nzln4sSJauutt1aO46hevXqpyy67TLmuGx1fkdzAkCFDmrTbL/u7WbaV3XEc1a9fv+Wuvf32269wjeHrXFXBcffu3Vf43ELccMMNapNNNlHxeFx17NhRHXrooU1+t6eccorq1q2bsm1bVVVVqVGjRq2wmPfmm29W3bt3V7Ztqy233FK99tprTY4v+/pXVOx73XXXNXnvfd9X119/vdpoo42UZVmqqqpKjR49Orr2//73PzV06FCVyWRULBZTffv2VWeffbZatGhRk+t+/PHHasSIEcpxHNWhQwd10UUXrVZqIERDQ4Pad999VWlpaSQ30FLfmwsvvHC1n7/vvvtOAeqVV16J9tXX16s//vGPqry8XMXjcbXnnnuq6dOnL7f2gw8+WA0bNmyFr6u5792rr76qhg0bphzHUaWlpWr06NHLndMaKHJhkQuLXFjkwpbgwueee05tscUWKpVKqUQioQYMGKD+9re/LScd80u5UCjVzMreXxF22GEHtthii/V2BFBtbS2dO3fmmmuuWWlhfBFFFFHE6lDkwiKK2DCwVhs0ilg3mDx5Ml988QVDhgxhyZIlXHLJJQDsvfferbyyIoooooh1hyIXFlHEitGq49JaAscff3yTdvDC7dc0eunqq69m4MCB7LzzztTW1vLGG2+0ibqmIlaNTTfddKWf3wceeKC1l1fEeoQiF2oUuXD9RJEL1y7W+zTuvHnzVjo8vaSkhHbt2q3jFRVRRPPxww8/kMvlVnisffv2TbSviihiVShyYRHrM4pcuHax3ht7RRRRRNvC66+/zlVXXcWkSZOYPXs2TzzxBGPHjl3lc1577TVOO+00PvvsMzp16sRZZ531q4pGFVFEERse2hIXrvdp3CKKKKJtoba2loEDB3LTTTc16/zvvvuO3XffnREjRjB58mTOO+88Tj75ZB5//PG1vNIiiiiiiLWHtsSFxcheEWsFDQ0N1NfX09DQ0GTLZrPYtk0sFmuyxePxZolhFtGyCH8nq4NawQggx3GWU9BfFkKI1XqzZ599NhMmTODzzz+P9h1//PF89NFHvP3226tdWxFFtFUopairq1uOBxsaGnBddzkejMViJBKJZgnvFtGyaA4X/lwehNbnwmI3bhFrjMbGRqZNm8bnn3/ON998w8yZs/hhxo9M+/o7apYsYsGCn2hsyCvPCyEwLBvDsJDSwPc9PC+Hl8s2UYd3YnEqKqpIZcro16cn3bt2oXPnTvTu3Zv+/fvTr1+/Zn2pimgeGhoa6Nmz53IjjFaEVCpFTU1Nk30XXnghF1100S9ex9tvv82oUaOa7Bs9ejR33XUXuVyu+IeviDaLJUuW8MUXX/D555/zww8/8P3305k5azZfffs9NdWLWLxwAa6br0OThoFhWBimBULiey6+l9PnFHBhMpWmsqodJZly+vXpSY/uXenUqVM06qtHjx7NnmBSxOrRXC5cmzwIa5cLi8ZeEavEjBkzmDhxIh98MImJ737A999+w+xZPyKkSbK0HZ6RJosDZgJhVkGsO6JHEseIgTRBmgiRrxZQgEB/8ExAKR98F3wX5TXwU66Wn2rq+PaDefDO99g0kq1diN+wCOW7dOzUhR69ejN8m8EMGjSIYcOGrXJkTxErRzabZc6cOUz7dgYlJSUrPa+6upp+vboyY0bT81rK8J4zZ85yszHbt2+P67rMnz9/hXNBiyhiXcL3fT7//HMmTpzIhx9O5q13JzFz+ncsXPATTiKNnaygzotpHrQSCKsbomRjZEUi4EIDhNGEC0HXUUnAUAqUD8oDP0cuV8cst46ZC2r5fO4PiNe/wBaNiOwS6qp/wpAGVR26sPlmA9hmyJZsvfXWbLPNNtF4rSLWDM3hwrXNg7B2ubBo7BURwXVdPvzwQ95++22ee+FlJr49kZrqRSRLO5I1y/CtUoQzELv/DmClyAXh7F/yIRJCgmGDYSOsBMTKmxz3CY1CBbkafmpYxLxvF/HBl89h3/UvahfNJpUpY9jQYew2eieGDh3KlltuiWkWP9rNRbokTbpk5Z1uCh1xKCkpWaVR+EuwsuH1zRmjVEQRLY2amhreeecd3nrrLZ5+7iU+/mgyvucRK+1EgygBpwxZti1Ox3KEGSMH/JL4sxAChAEYARcmlzsnnAprKQ/VWM1PDYv47+R5vPbBw8hrb6Ju6QLadezGrqN2ZPvtRjBs2DD69etX/A6tAVbFheuCB2HtcWHxL+KvHPPnz+e5557jwYcf4+WX/4vr+cTLutIoyxEV22J3bYdr2JEH2loQQoCdxrDTQDcAXMDunKWhbh4vT57Df9+6DlV/DpYh2XGnnTn4wP3Ybbfdihpbq4FSTTJIKzy+NtGhQ4fl0ifz5s3DNE0qKirW7s2LKCLAV199xTPPPMO9DzzCx5Pfx0mU0GhWIBIdkN32wIhX4Aqj1f9oCmEgYmUQKwN0tsQD7FwdC2vn8MCzU/j3069Qt3gm6ZIyxo3bm/32GcvIkSOJx+Otuva2jlVx4broblibXNjan9siWgHTpk3jkUce4d4HHubrL6eSLOtIvdURo+vuWIl2eEKsNx8MYdgY6S6Q7gJoL0jVzeXFD37gjbfPpe7II+ndb1N+e+gBHHDAAfTr16+VV9z20NrG3tChQ3nqqaea7HvxxRcZPHhwsV6viLUG3/d56623ePiRR3n40X+zaP5cYmXdaHQ6YfQ7EN8p/UXRunUNYSUwSntBaS9ygNnJpbZmJvc++Tb3PvAwuA1sPXQ4hx9yAPvtt1/RCV4BWtvYW5tcWOzG/ZVg/vz5PPjgg1x/0+18/82XOOW9yMY6Y5R0X2HKYEOBytXiVf+A3TCTxoXf0rPPxvzfH3/PQQcd9Ksnu+rqajKZDD/OW7Tamr0u7cpYsmRJs9IXNTU1fP311wD85je/4dprr2XkyJGUl5fTrVs3zj33XGbOnMm9994LaLmBAQMG8Pvf/55jjz2Wt99+m+OPP54HH3yQfffdt2VebBFFBJg2bRp3330Pt9/5D+pqa6CkJ36iKzLdBWHYrb28tQKlFKphIX71DzjZmTQsnsXwETtw0om/Z8899/zVKyE0hwvXlAehbXFh0djbgJHL5ZgwYQI33HQbb7z+ComyzjTGe2KU9kGYv74vt3Ib8BZ/jVP/HXWLZjJiu5Gc/MfjGTNmzK8yghQS3Iy5qzf2urZvPsm9+uqrjBw5crn9RxxxBPfccw9HHnkk33//Pa+++mp07LXXXuPUU0+NhETPPvvsoqhyES2GxYsXc//993P9TbfzzVefE6/oTS7ZG1nSHSF/fV2tfuMS/EVfYtd9h5utY//99+eE449j6NChv8oav+Zw4ZryILQtLiwaexsgFixYwO23385frroW10OTWlk/pJNp7aW1GWiym4ZV+w2WAWefeRrHH3885eXlq3/yBoKQ4KbPWb2x163DmpFcEUW0BUybNo2/Xnk19957L8opR5T2+9U6uytCWPYiqr9CLf6aLl27c/GF53HAAQdg2xtmlHNFaA4Xru88WDT2NiB8/vnnXPHXq/jXAw/gZDqRK+mPLOmxXLt/EXko5eNXf48//2Oo/4lDDzuMc846g/79+7f20tY6QoL7Yc7C1Rp73TuUr7ckV8SvC0opXn75ZS669AomvvkaMtMbo2ogMlGcDbwqKC+Lt/BL7KWfI3E58/RT+cMfjqeqqqq1l7bW0RwuXN95sGgFbACYNGkS226/E5sO2Jx/PfU2Rq+x+F33wMj0Khp6q4EQEiPTC6v3WIxeY3lgwkQ2HbA5226/Ex9++GFrL2+dICxKXtVWRBFtHUopHn/8cbr37Mvo3ffmnS+rsfsfjtV9l6Kh1wwIw8as2gyv5/40VgzjrzfeTYeOnTn6mOOYNWtWay9vnWBD5sGiJbAe49NPP2XnUbsxZOuhvPP5Qk1s3XZCJjZ8T2xtQCaqsLrthN3/MN75fCFbDdmGnUfvzqefftraS1urKBp7RazPUErxzDPP0Ltvfw485Ehmu52x+h+O1XHrDbr5bG1BCIGR6YHfZXfMPvvw4ITX6da9Byed9H/89NNPrb28tYoNmQeLxt56iGnTprHX3vswcIvf8OrkmVgbH4rVebgWJS7iF0NYSazOw7E2PpRXP/yRgVv8hjFj9+Wrr75q7aWtJahV/oP1nOWK2GDx8ssvs8mALRgz7gBm1FdibnwoZtVmCLm+iEe1bch4Jarzzhi9xvGPh56lU5dunHX2OSxatKi1l7aWsOHyYNHYW4+wePFijvv9CfTfZFOee/NLrI0OxuqyXdF7XUsQVhKry3ZYGx3Ms298wcb9N+G435/AkiVLWntpLQpfrX4rooi2hK+++oph2+7AqF335OtFcayND8Vst0XRyFtLkIkq/C6jkd334Oa7HqFjp67cfPPNeJ63+ievR9iQebBo7K0HUEpxzz330LlrD+568CnMvvtjdRuJsNe/ItH1EcIuweo2ErPv/tz14FN07tqDe+65hw2mt0k1YyuiiDaA2tpazjzrbDbeZFPe+3KBNvLaD95g9fHaGmSyA37X3fE7jeTMcy+k78YDePvtt1t7WS2HDZgHi8ZeG8dHH33EZlsM4pjjTyZXuQ1WrzHI2K9HHqQtQcbKsXqNIVuxNUf//iQ2/81gPvroo9Ze1i/GqpO4YQqjiCJaD0op/v3vf9Oley+uveVezF7jsLpsX5RQaSUYJd3xe+7HjJoM247YngMOOpR58+a19rJ+MTZkHiwae20UDQ0NnHTS/7HloK34Yo7A7HeQ1of6FQpetiUIITBK+2BtdDCfz4YtB23FySefQkNDQ2sv7WejmMYtoi1j1qxZjNhhJ/Y/6HBqEgOw+uxTbEJrAxDSxOwwGGujg3j8+Xfo1r0nd99993qd8diQebBo7LVBTJ48mb4bbcpd9z+O2Xc/rE5Di2mKNgZh2FidhmL23Y+b73qQvhsPYMqUKa29rJ+HYhq3iDaKBx98kF59+vHOJ7OwNjoYs6J/0eFtYxB2CXbP3fA7juQPfzyFXUbvvv527W7APFg09toQXNfl4osvZfBWWzMnW4nffa9iyraNQ8bKsfruw5zGcgYNHsIll1yK67qtvaw1QjGNW0Rbw8KFC9lr73047Iij8duPwOq+czFl28ZhZHpAr/145f2v6NGrLxMmTGjtJa0xNmQeLBp7bQRff/01m28xmL9eexNm77GYHbZCiF/fzMb1EUIYmB2GYPYey1+uuYnNfzOYb775prWX1WwUdfaKaEt48cUX6dGrL8++Ohmr34EYpb1be0lFNBPCjGN1H02ufCvG7XcgBx18GEuXLm3tZTUbGzIPFo29NoCnnnqKTQcMZNpchd9jXFHtfT2FTLTD7zGOaXMUmwzYnKeffrq1l9QsFGv2imgL8H2f8/90AbvtsRf1JQOxeu5elJVaDyGEwCjfCKvvATz69GtsvMnmfPnll629rGZhQ+bBorHXivA8j7POPoex++yH6rAtVpcRRZ2o9RxCmlhdRqDab8ve4/blnHPPWw+0qIpFe0W0LhYvXszInUZxxdU3YPYeh1mxSbE2bz2HsNNYvfdibraczQb+hieeeKK1l9QMbLg8WDT2WgkLFy5kxPY7cc0Nt2P23gejrG9rL6mIFoRR1hez9z5c9bdb2W7kzixcuLC1l7RSFNO4RbQmPvnkE/ptPIA3P/waq89+yHhlay9p3ULI/Fb48wYAISRWp6HQcXv2O+BgTjv9zDbt/G7IPLhhfKLWM4Tk9u6n07H67oeMV7T2kopYC5DxCqy++/HOxz/Qb+MBbXbGrs9q0hetvcAiNlg89NBDbDloKxaJzlg99/j1NGEUGnhC5Ddp5B8bVv4caTTdCq+xHsAo7Y3ZZx9u+/u9DBuxA4sXL27tJa0Qq+TC1l7cL8T68UnZgPDqq68yeKttWCy7YPXYDWE4rbOQQpJY9nGhh1nEL4IwHKweu7FYdmHQVlvz2muvtfaSlkOxG7eI1sCVV17FoYcfgeiyc9CQtgGnbQuNu9CgW9aACzfD0pvlQCwFhql/Nu38VmgUric8LWPl+N335oPPZrD5FoP58ccfW3tJy2FD5sH141OygeDhhx9m511G47fbGqvjkNYht5WlC0ISKjyv8JxVbSs6b2X3Xdk5qzu+HkMIgdVxCH7V1uy08ygefvjh1l5SUxRL9opYh/B9nxP/eBLnnn8RZq8xWrJjQ8PKjLtCw80wmxpwpg1WLG/kxZIQT0Fpe3AS4CTzW2gQhtdcTzhTGDZWz92ZtdRmwOa/4bPPPmvtJTXFBsyDxW6AdYRrr72OM88+B6PrLq1DbssZV4GhqVT+MWjyUAUB62WPr+jnQiMxLGwovJ9hrngNygevQJMuvG50ngG+1/S433brPVYHs2ITPDPBIYf9llmzZnPqqae09pKA1Xeare9daEW0HWSzWfY74GCeeeFlzD7jkE5pay+pZRE5vwVcFkbfhIBUWWComYERWMCJtYvyxmEYvQu3ZBk01OjzlK8NwbpqzYfK189zs/p/1bYTjkJIzK4jqZnzHoO22pr/vvg82267bWsvC1g1F67vPFg09tYylFKcetoZ3HjzrZg990ImO6zbBSxLPsvulwVGX2joCSNPGstWpRoFxqBSTZ8PEN6m0MArTDWsLJopDWisa2o4hueHJBY+183m79fGiW1ZGJkeCHMvzjj7PKbP+JFrr7mq1dNXq0tRrO/piyLaBpYuXcqOu+zKh598jdV7H4SVaO0l/TKszIEOj4WGmpMEM4joOUkwbaRhIA2JECL//U9nQEC2vhEhJUIKpJTR8VyhIacU2HFtIHoeyFyB4We0eadYZzu2xrWS7LDjzjzy0L/YZ599WntZq+TC9Z0Hi8beWoRSij+edDK33flPzN77IGOl6+7mK/IwV/TzsvtUkG5QSj9elmAMs6mhJaQmlkJ7pdBrjbxaqQ3DFa0jJMVMO01eIfyCKGGhd2zFoLE2v8Y2TmzLQiY7YPYexw0330Eul+XGG65vXYNvdSmK9ZvjimgDqK2tZdvtd+TTr+dg9d57/Rz/WMiZoVNa6Gwuy1PSgGRpPl1rWBixOIZhYJgGQgoMM+/choZfMp3URl9DNjqmlMJyLHKNOZRS+L6P8i2UFxh5ngt2TEf7PBdEwZe2DTvEZuUAPDPB/gcezCMP/Yt99923dRe0Ki5cz3mwaOytJSilOOXU07ntznswe++97tIVUcTOyBtjhT8XdnKF+yF/TKmCxwWGH+Sjdb6nvdTIkxT6HNPOk51RYOyF9wuNwNAQDGpOQi/Xsi1EeQVKKeoXLwbfDe6d0ddpqMmvW/nB/RXkGvLrDu+1osdtCDJWhtl7DLfecTemaXHdtVe3msGnVpPGXd8lB4poXdTV1TFih5349Ks5WL12R0irtZfUfCzrFIc/h1xY6ACHfCsNXWtnWDr6FqRtDdPAdmykIZGGjIw+fWkBgiaRPNux8X2fXGMuuJXCtMymBp9VQa6+HrJ1NOngdbMFvFfwGsI1tiFONEp7gRAccNAhPPH4o4wZM6bV1rIqLlzfebBo7K0FKKU46+xzuOnWOzB7jW0dQw+CL74oqKsraNuXBaF+aYAMPG3lgzSDFG7BY8suMKgCQlFGkEIwdFFxSIZRp1je05XJEizbwjCNiPTqa+oxzMDQcyyklNH7lyxJUr2oGpT+WUhBtlBwOpbKpzAKI3teLnjttt5f+DrbWARQOqWYvcZw4y23Y9sWV/71L62yjmIat4i1hfr6erbfcRc++mIGVs891w9DL3KACwy5yEkW2qkNYQZqCiFfgq7Lk4Y+ZpiYltnEuIslY0gpkVJimBIpBa7rB5G9/KWVAuELDMPAzbnBPoVlW2Qbsyhf4eZcXNNCiaS+n+dqTjRtyNbrC4WcqFSbbeIwMj1B7cg+++7PhCefYPfdd2+VdRTTuEWsEc7/0wVce/3NmL32Xnep29DIWrYZImSPQiMvJC8htDEHOhIHTSN8pp2v27PjmjSU0oZdmDowPIiX5J9XYOylMilU4A5JKTEts8DYM8mUJTBNA8MQZLNetFTfVygFyXSMpUvqgpchoDTN0sV6zqLnenhhCiMsVgbIFRZGL9Nh3Abr/GSsDLPXGK657kZs2+bPl16y7hdRTOMWsRbQ0NCga/Q+/Q6r154Io40aeivjStNePqsBujM25JBYSv8fOMIyXQECjCBbIaUkmUlGKVohRFSrJ6XAsiRCgOMYUUTPdX18X+H7ChmsxTAlnpvnLcu2aGxojFLBDXUNKN/ClwbUV4MqMEJNW0f6oMDxpU3xIBDMQFaM2Xsczzw9gdGjR6/7RRTTuEU0F1dffQ1/ufJazF5jkLGydXvzMIpXaPAVGnkApqW/5GEadtnnWIGoqfL1Y9/DSKRQvk4b2DEb3/PxfR/f80mkE/nomxCUtSvVT1dE5+ilCUzLwDAkpilwHBMz8GotyyCVEtFLqK/PRRybStnU1ORrVxKpGDVL6vS10wlqFteg/ELSKoH6pdqIzdblo5shVIE6ZhshOxkrx+w1hiv+eg1lpaWcfvpp6/T+xW7cIloanuex55hxvDdlGlavvdpmjV5hSrawhCWM3IX/h8adUpDI6H2+h1VSFjmz6dI0Sqkmzm1JWX6ub2EK0DBEIJEnMAwZPY6o2NDrymbdpqlD2yCX86PzXNdASonv6ahgY30jQjp4KqVPcJLa8ANoqNX/5xqDBbXNRg6jtA8oxR577c0br73C0KFD1+n9i924RTQLjz/+OGefe5429NblVIzCGrjw58jIC37FptmUxDw3qL0z9f9WTHumcU1asUQsKAJWxJIxlK/wPI9EOoGX8/B9n9KKdGDUaZJr1y4ZkJD2TD3Pxysw9gxDG3eGIbBtI0hl6J+lyBNgzDGpb8hLsiQSdmAAquh+vq+00en52tDMpKitDggt8tCDVHIY7TPtPNm5WfDahrEHetqG2WN3zjrnXHr37sXYsWPX2b2LadwiWhp/POn/eOWNd7H67NP2DL2wfhjynKitrLyxF8sbaiRKwfeIl5ZGxpxSKspcKKUoLU9FGQmATMYJRmypJhwJNEnXSlnQjRtcN0Q8rvk8lws5FGzbwHU151lWnPr6HG7ORUgR8bVvmVFzh4LlndrC+ubCx20ERllflNvATrvsyicffUjv3r3X2b2LadwiVot3332XAw8+FKPrTshE+3V3YyGJJFAKa+asIIwf1pyEpBYYddhx/bM0MB0nMvBAE04ilcD3fZLpeERaZWXxwIBTVFQk8Dw/OpZJOfhK4fmKnKuNPN9XxGP5j5ghRUR0ptQerRSCRtdDBO28RiDlErMM6rNuRITxmDYAfd/HcZLU1GQ14aYdllY3NH1PSpLUVtci0xX4ddX596WxTr8vucbgffHbFNnJZHuMLjux/wEH8dabrzNkyJB1c+NiGreIFsR11/2NO/5+N2affdrm+LPCLEZYqmI5utbNieufE6UAJDIl0dNKyktAQGVlMnJmfV+RTjuRURePW9FjL3BEfV9hFnTdhlmQFSGbdZfbZ1nawAthmpJcTl87mbSpr5f4vh+lc8NMCwB2hmxjtukFC8tZlCLSM20jPAhgVm1GNruE4duN5LOPJ1NRsY6CJ8U0bhGrwrfffsuOO49CtNsKI9Nr3d68sM5k2VRtmJI1zXwhseVg2ZqQwm4vJ+7guR7xVFwTSCpP0JlMDCGgsiyBQuF6itKkrQ07T5FwTE1oClxfG3+WIXF9v4mnW7hUIURk1AnANmW03y1IydqWNlCzgWfrmJL6rIfnKxzHpK4ujPbpmyRTDrU1jU086DoBIpXBq6vR9TUNNVqioKE2383bhiJ8Rmkv3NxSdtxpFJ98PJmePXuu9XsW07hFtBQmTJjAGWedrTVFnUxrL6cpwskVoXyTkGAHvBhL65rkWAp8j0QmDQrSZWmEEJSWxbVzKgWV5XFcT+F6PpmkTS50bG1TO7uBkef5EtOQweMwIth0Sf4yOyzLRgZE2Zj1CvYbKKUio88wJNmsh5SKVEpnPkxTn4MCy7ForG8k15jDsi2wS8llc2AntGyVF1w7dHaV3+aMGbPTcH76/nlG7jSa9955k1hs7TsOxTRuESvFokWL2Hb7HWmM9cCqGtg6i2gylieM7MWCzrF8hE+aFkIK/eUXEE9q486O2ShfkUja+L6KDLzy0nh0i7KUrZsmYiaep/CUImYZ5FwfX+kAtylNbTspheuJ5YgtNOoUkHP9Feorm4YuVA7Tv74Cwxa4Qeo2GRNk3bzHDBCLWdTX56L0bpO3JrhJvRCadKEgoqeCppPA2Gsj9Stm1UAaGqsjr7asbO3WfhbTuEW0BCZNmsS++x2A0WXHdS8evzqEygDK1536ZjBqLIjgOakkqUwK3/NxXVenaH1FScCF6bSDaUo6lSeimrmYZeD6Pq6nMA2B62mjLut6WIZEAW6Q/fBV3vG1zLzqgD6/qbMZ8qJtycjRDZ9vWQbZrBuVv2SzHr6vcBxD99HZcRoavMjhtWM2jXWN0f0AXJL670PDUq2y0FCbb9rz3DYT4RNCYHXfmc++fpIDDjqUJ594bK3LU23Iady22Ye9nsD3fcbusz9zq8HsPHzdLyBM4YYDsX1P150UauoVDNz2fR8pJU7CoaJ9GYlUjEQqTmlpnJJMjHTaoWuXDJkSh0xJjEzCJpOw6VKRJBWzaJ+JkbQNUjGT8qSNY0ritkFpwiITt4jbJrYlsU1JacImk7QpSVik43qzTO3pmlIQtw1iVtPNNCRWcNyxDGzLwDREtN8IHttBY0cybulzTInjGMRiJqWlMeJxi3jCIRa3iSVjxJIxMhUZnLiDjAWzJe249vJDHazw/WwjMDsPZ241jNv3wCZ1PGsFqhnbGuKWW26hZ8+exGIxBg0axBtvvLHK8x944AEGDhxIIpGgY8eO/O53v2PBggVrfuMiWgULFixgl9G7Q+WWQVdlG4RhaSPHsMBykGXtcVJJ2nXvRKYigzQkpRUpevRuR1lZnG7dS8lkYnTvnKG8xKEsZZOMmZQlHbqUx8kkLJIxi3YlDumYRdw2KElYlCUdbMvANiVx26Q0aVOecihP62vEbQMr4DTHMkjGzCZbeMwyJOm4RTJmErMNYraBY0lMU3Ne+L9lGcTjFpZlYNsmsZhBPG7ixB1iiRhOwsGJO9iOreWvLBNp2zrKBzrTUTierQ3xoJAWVo/deeb5l7jqqqvX/g1bmAeh7XBh2/mtroe44oq/8Obb72N12xmxrr8goacafkkNS3eNhY0aBdE+aWkhz1gihuVYQfpWUVLikMk4pFI2HTukyZQ4lCQsMkmbrhVJko5JVUmMdMykMmkRMwUxU5K0JY4hsE1B2jGImRLbFDimoCRmkombxKzgnAIDzjRkZLxJKZbb7MAYNKRu2DCE0M81dNo3rPMzpMAxDUwpsC19PB6zME2JbZvYtkEm4xCPW2RK49iONuacuCY9y7Z0uibTTr9nkdHXdgaKCyGxuu3MGxPf5Yor1q7+Xpi6WNW2Jnj44Yc55ZRTGD9+PJMnT2bEiBHstttuTJ8+fYXnv/nmm/z2t7/l6KOP5rPPPuPRRx/l/fff55hjjmmBV1fE2kbo9C5xUxjtftPay1kehTXMQmiH2LTxcznSpWl8z6esPEGv3pVUVCSoLE9QXhanLO3oLWVTmrTpUZUiEzcpjRtYUhAzBeVxE9uUxCxJWdLCMQ1sS+KYklQs7+RaZsCBMjDkgn2WIbENiSnzW9w2idsmlqkdXCswGhOOiW0aZJLakXZsg2TSJpm0sW2DZNLCsiSJhI1lGZSUOMTjJqXlKZyEgx2zsWPa4DPDhr1ERv9v2toQLtRIbSMQVgKz2yjOHX8+EydOXKv3akkehLbFhUKt9bDBhonXX3+dkTvtrEWTE+3W/QLCjjIhC76sdn6IdlCTIkwL0zIRQujIliGp6pAhk9HCnsm4PpaOW/hKkYpZJBwTCcRtGRhdYBkCP+gDWVGJm68UUogm6YrwNM9X0RclfBx+7HwKOtaiTrfg+cGTvCDd4Xk+nq+ilK4XdLh5SjeFKKXTJp6ncF2PbNZDKWhoyOG6ivq6xkCPSlFfW6871xpqoW4JuLmgliVIY7SRlK5fNxf32yd59X8vM2LEiBa9dnV1NZlMhjc/+5FUumSl59UsrWbbTbswY8YMSkry5zmOg+M4y52/9dZbs+WWW3LrrbdG+/r378/YsWO54oorljv/6quv5tZbb+Wbb76J9t14441ceeWVzJgx4+e+vCLWES699M9cdPnVWH32R5jLfx5aFYUi71ZMd9kaJmZ5B8ralWHZFu3bJzFNg6pSXRMWswwSjq6/S8W0o5iy8w1lmgvzfOeHFSG+IuerKM2b8/QxTykMIfBUnrcKuS2seQaWK0MBIp4Lj7gBASsFja7mqfpG/X9jY158OZv1gs5dvd/3FQ31WRpqG/B9n4a6BrycqyWq3KwWYQ5Tum42z4FtJK3r/vQRidrP+Xra51RVVbXotZvDhWvKg9C2uLDtmO/rEebOncueY8YhOwxtHUMPmoojSyOQDVD5KJ9pR+rtAKZt4iQcKttnsCwDyzKIOQapuEWnsgTpmEWHTJyUY5KwtKcaMyUxU5CwZRBZExHZWYbAkPkMsu601WQYPUZv+rg2FPV18p25EjACgVHTkE2ebxj5Jg4ZFEeHaWD9ODyef46WeNEyL45j6tSvaeA4Bk7MJlmSxLJ1dBNAOAkd3Yun8p4ttBnPVibaI9sPZY+9xjFv3ry1c5NmpnG7du1KJpOJthWRVTabZdKkSYwaNarJ/lGjRq3UKx82bBg//vgjzz77LEop5s6dy2OPPcYee+zRYi+xiLWDV199lYsuvgSz2+i2aeiF2Q/D0p22iQyx9l10ejNmE4+bxOMWJUmbkoRNp7IEpSmHdMykJG6RsCUJO8xcSGKW5j3bkBiSiAstQ/NRzJSYAYfFLH1+zJSa+wKeMwL+CiakRZxnSJGP+Jn57EeUDRGaf23TiGr2HNPAMXX6OO4YZNIOtq3TuZalS1sMQ4s327aB7Vgk0olI4N60rXwZixXTqd0wW9Sa87pXAKNyc2ooZa+x++J5a8kZbyEehLbHhcUGjTWE7/vsOWYf6kQFZsWA1llEaIiEciqhcRc+tmI6VYnuygprN6TU+namKUnGLDIJS4sam2EdncSSIaEIpAAr6JoNw9iKvBcq0eeEEblCT1eimcxXChOBD/go7V0IgVAglQJ0xDCc2x0aeKHHG14z6/oYElxPYUgRFD8rpF4ASurrmAa4Xl6/KpQ5yOU8bFtiWRLlKwzLwLRNGusbyXrJpt6sYWp5ljbSpWtUDqCudhZ7jBnHuxPfiMbKtRSa2427Io92WcyfPx/P82jfvqn8UPv27ZkzZ84Krz9s2DAeeOABDjzwQBoaGnBdlzFjxnDjjTeu+YspYp1h7ty57LX3PsiOw5CJlo20/CKERl5kxDiQLAUhMJNp4qk4hmmQSOjSj8qSGKVJWxtbhuaNsEwFtEEH2lgDAs4L+Q5ABVynMxWGFIRCK54PyHy2Q6ngAujzQ46KshlhdoO8DJUKvp9SiijyZ0gDz1eYUqsgGGgez7k+tmnTmPOi62oJQd29a5oyaIDT4ynra+txc4Fx11irlRu8nH7PlK8zHW0EQgisriP5+JP/cPHFl3LJJRe1+D2a043bHB6EtseFbSN8sR7h+uuv58OPP8PsukOrDa4H8iG1MH1r2rqzzIphWCaWY5EqTUV1akopEgmLRMKiXUUSu6BmJGEblMZNHEPXmtimJjtL5j1OXUcXeKcijNLlo3ohMcngeHgsFEuW5B/nX0KePE2pt+jaQte3yMj41J5t5PGKvLcLOronC9ZiFnrGpsQ0dS2LaUosW/s4tmPjxBySpSWYsZiu44sFnWqhqn4bgBACs+tIPvvsC2644YYWv75qxj+AkpKSJtvKSC5cc5N7rEJbbOrUqZx88slccMEFTJo0ieeff57vvvuO448/vuVeZBEtCqUUhxx+BJ7TDqNi09ZeTh7R2MjA0AsEkmWqDJkqjbpsE8kY6bRNr64ZbDNfN2cHNcm2qQ2/hKUdYCOIvukonz5umxLLEMQtGdQX57fCjIdVwJ9hNiPkRsiLLBdyqSm18qgIjpvLRP5CJz2sX9Y1zDJqggtr+2KOgW3rzIZlSeJxK8h26L8RdszGdmykGUT4DEtnOcLHbaxpQxgOXscduezyy/nwww9b/PotzYPQdriwGNlbA3z99decdfa5mN13axuq8L6XD7mbju6wIjBi4voD6MQdkkm9Px63iMd0d5cUQhf92gaGDNOsAruArEyZr9PLefqB5+v6k9DLMUTTaN+yEIHhphQIpZAIfKEf68CeiDSooNBrDmRXAktRKJCWgev5aLr0cYNpb6Yh8XyFFBJPKWQYWcTHMMxIgFQr2euRbYYhaAxEmrMNWT0Gzk/j+x4Y2bwGXxsRXRaGjdt+O8486xz22muvllWVX12n2RpU9VZWVmIYxnKe67x585bzcENcccUVDB8+nDPPPBOAzTffnGQyyYgRI/jzn/9Mx44dm7+AItYJHnzwQV599Q2sjQ5qXae3EFFEz8zPtXXikKrA9zxSpTqqV14ep11lEiEgFbN0o5epG8pEUJ/sBNE80xA4hsQPvgQRlwX/W1KQ8xWWAYbSXOYpnX3wfHB9zXmWDLOiCl8J8MFv8rY1rXdWwTX04+VfqmGI6D6FZfdSaC4UloyigLZpUBfU7IWbaUrq6nKYlolp65Ruve/no3lmMGFJGpBrCPiwhX9fPxMyUYWs+g1j9z2Qr7/8DNtuwb/Fq+LCNXz9bY0L24a5vh7A9332PeBgVKYfMtW59RYSElphA0Egs6J8hRNzomheaOjFYiaVlUk6VCZJx3UDRtw2Am8RnGAWY8wUUSojFqR27YAAo8he8H9hFC5aWqjvHNSWyFX8DSisUwm7bfPRwXy0D5pG+ULP1TENLFMSs4yorkUGHrhj6g7dmG1ozzeoYQnrXHTXroFpGZiWSTwVz9fxxdL6prGkTmW0kegegJHujMr0Y5/9D8L3W84AbWbJXrNg2zaDBg3ipZdearL/pZdeYtiwYSt8Tl1d3XKpacPQ73uxf6ztYe7cuRx97PEYnbdDmPHVP2FdIIw8hQ1rTkJ/hxMZnESMqi7t6Ni1gnTaoaw0rqVQUg4px6QsaZGwdJQs7RhBZE9vsaDTNmEZJG0jqNuTTeqWDZlPuRoBB+k6YnCCCKFtLp8pCWv48rV5oVqB5jkR1vgZTc8zCpzxkBtFkPXQs3bzfOnYWgImHbdIp5xIrSAWM4nFTBKpOImUruEzLTNfEmQ5OmMETdUd2giM9lsya94SLrjwoha9bkvxILQ9LixG9pqJG264gU+nfoXV74DWXUg4wNqwgmIOHd0Lo3qmrfWV4nErSNvq/cm4STqua/TitkHcMrAMHSPTxp2uVYlZoiBVK4IaEoGHitKxBJE9GUT0dAo1eBwYeErlU7q+0jUtRlCfVygyuqzJYhRYiGFNSj7wp2v1hClwPZ+YNMiKoB4l52EZRJ26JoGgaaBg7yuBUrKgjsUI5kvG9NxdX+H7etaub3fArVmi39twhnD43rcyzI7b8OnUh7nxxhv5v//7vxa5pq6zXDmRrOrYinDaaadx+OGHM3jwYIYOHcodd9zB9OnTo1TEueeey8yZM7n33nsB2GuvvTj22GO59dZbGT16NLNnz+aUU05hyJAhdOrU6ee/sCJaHEopDj38SHJ2e6y2pqcnjSCq50Aig5UqQSlFPBknkXQCBQJBedohHbdIOQZCaGc3ZuXr80LnN27rZgvNgOEffP1dCCN7vqeC7IOuLw4zIPgB5wS8ma/305zqhVHAAkrRPJfPdJhW/o++F6oXBN2+htQizrrzVwXcqpACHEsGtc06E6KC+ICjJEZCp3EbG13cQNg+lzWQhsS0TF2/53tB7bILpqe7dMPxksg2wYNCGBhdRnLVVVdzwP77seWWW7bIdVfFhWvKg9C2uLBo7DUD33zzDWeedQ5Gt13bRvoWiMahBUafaZqUlJeQSGnF91jMxHHMSFol4WidpphlRDV1lizwEGVYW9c0IieDNKsh9fc/lBWQAnRCNSAhpQ2+kNTCZg4AExmleqXKpzZ8mk68WDYbZMg88YWnCSGQSmEaOk1hBl6QKYUeU+T6ARH62lsGPEUwtkgXOedyHkpJfN9ASj2CSAXyBqapmzbcXFIbetmGfPFyGwgyCcPG6DKSM848m7322otevVpgPF8LpnEBDjzwQBYsWMAll1zC7NmzGTBgAM8++yzdu3cHYPbs2U10po488kiWLl3KTTfdxOmnn05paSk77rgjf/3rX9f8tRSxVvHwww/zyquvYW10cGsvZXkoPxqBZiRSJNIJPfM7qQXjy9IOpiG1ALIlsQ2dgQg7ZsPyFV2zrHnFCOrpfBU6rfm0aSi/AnmH2JAC3wsb1vK8GO6wDL3PC43BAsc3F5BcuI6QeyEYJekpMLRB6QOWqRs2fKWNQImI1mUa+rk6ygeur7nPEgLXlHiegW37mKbEdRWe50Xp+Mb6RlRkOFta6aGxPu/8thHIRBWicgvG7XcQX33xacukc1swjQttiwuLOnvNwHY77MzET+dgdd2htZeSRxhud5JQUkm6qpLSyhJSKf2B12F6LeppSEEypiN7ccuIalMcMyQ8iFk6bQvacCo0vEL9KP04X08XRefU8uncfHcZkY5UqDnlFVwr5+eJc0UIr19o9C2r0ecG5JrzfHLB6KFG14s0rcLZlb7S0T7X1Zs2+rQGVX29S7Yxh+/7NNY30ljXSLa2Rs/SrVmkjb02or0HkJvxCsM268Trr7y0+pNXglBb6uUp01ers7fTFt1YsmRJky60In5dWLp0KZ26dKexbCuMsr6tvZw8wvSiYeomq/LOpCvKSGaSAJSWxqmsSNC5IkFJ3CZhSySa8+JWPqrnGDpdC3kVghBemBEIHoc/h7zkBrV6nq/rmwu180KEP4eOb2joFer0BbGzpi8v4FMhtOOqr6XIuk1nkof6fYXafSE/+gHvup5PztMj3hqzHo2NLrW1WZZWN+LmXOpr67Wz29Cga/WUr5UJGut0hM/Ntpk6ZgDle+S+epS/XHx2VOf2c9AcLlzfebDtJOHbKJ5//nneeustzI5bt/ZS8gjJTRrai40nSJYkI0MvkbBIJmxSwZid0qRNacKOtKF0B1coEqrTFaHRZxlh51j+fyl0vYkuNA5r+LRRaBl6coYhRdChJqL9tqm95rB7zQo6fK2oRo+g0y1f52cGW/hzuEbLWHkNoBkVVsug1kXrYIXTOHQnncx36xoy6FAzC2r4ZF6T0NT1K0YsridrOMFotTZUs2J23Ia33nyTF1544RdfSwWpi5VtRX+wCIALL7qEOj+OLO3T2kvRKBRMDsXk42nsZIJYMobyFWVluiGjIu0EmQ1dh2wa+n8nqKWzgvpkS+qongw4w5KhsHxQMxcqBQjNW0aBYxxG1kKOLdxCnrTCqUIyz5Nh7bRp5Pk1TNWaRl4KywjWaBv6/glLYkq0jl/Iy0a+ji/s/o26ewOeNURQJ11Qv2w7JrFwyoYTlAVF05nCCJ/V5vT3hDQwOg1n/J8ubBEd0lVx4frOg8U07iqQy+U46pjjke0Ht51C5BCGGSjCpwOBUF14G4oJJxwzmKWot1A/yhR5cnKMUNhYRDIAhVIpACIgiawbpHIVWEJ3mtEkmhekLhDRyF69P9R7FnhSFaQwiDrXGl0wKIwGKvJtEQIEQSpZp0xcP59KCXWqpNBpYSOwRD2h8JUfFS7nXD/S4gtfhwwMP9NU+L6B5yl8zwx0qDy92XHtzeayQQrD0DpUrQxhxpHtB/O7Y47nh2+nYVnWz79YC6dxi9jw8M0333D9Dddj9hrXNrpvw0a1sIFKGpoPHS2aXpKJU16eoH15nLKkE9TnaUMudBzTQc1ezNRGnd0kdZt/jabQna/4Ph552hNCYJCX0ch5CksKvCAbYcumGQ4j+Nn1Q/1Qnd0QUkfsDAKeK+BjfZ+mk4t8pbBNnc6NW5JcwI25oDNYBVE3qYIUsxT4fiCbZQbGpKewTRWVthiGpK4ui5tzcHMuRtbAj4T7vSCT5OUjfaLtRPeMdFeysY6cevqZPHDfP3/ZxVo4jduW0HZCFW0QN954I/MWLsWobCXx5JUhJLZ4CiOe0PMOLUku52tjz9LzGe2gW9UKI1wBP+a7yESkKRV6kaGmlBmQnynyXWaQr+/Ld6Hl5VXC+pbCyF7oucZtSdLWnW7hFnaoxUyJE0QBDanTK+HUDh1RzHvKK9Isit6WsHstaAwxjbAzV2/hcPHQazaCGb1aikULLhumxDANrS5vmVqc2kkGEzacNhXhMyoHMG9BNTfddNMvuo5qxlbErxvHHX8iItO37YgnC9G0lMWKgRNH2DES6QSxmEkqYRG3zUA7VEurhLIqaccgZklKHDOaV2tKScwwoshbuJki5CBZoA1aEEEjP0bNCCJtdhBhCyNxtqGd6jz/NtXlCzkrjPyZQTTODpQRwmstO7UjzLpEEzsCzjekCJx8GenzRZmaiMNlNM0jnCvuxEycmJ4fLs3AgQwjqG00ugdgdhrGQw8+yOTJk3/RdTZkHixG9laC+fPnc974PyE77YQQbUR+ozB9a9lgx7Edm2Q6QTxukUppbb2YpUU203ErKtANDadCYgnD+0ZAaJBv5w8jZh5KHyuQFwijbKGdFaZXwzQBEBmN4f6w3sVXCl8q3TQhRVTropT2jNOOJsScp4iZ+l4Nrp6Hm/VUJMmitaoUfhjZk+G0jIJ1BJ60IJy0oY1T2zTwgjoXZcrlDMiGBg/X1B1qhmngWTa+HYdYFrygUy3XsBZ/0c2DEAay43DOPe98Dj/8cCorK3/WdTxU1O23suNF/Hrx8ssv8+qrr2JtdEhrL6UpQvFkJ8i6OEkS6QROzCaRsEnGdEOaHYx9BC0vFRpFeYMuMHrIS6KENXJKQU7ppi/f11zohyovQuD6fpQNEQh8qb8rtqEjfCG1hPV5nh9mFQi0+zSP6SkdeR5SQZOFZegsihU0ZgSXx/XzznbOy0cFCZ6T8/T5QuiThdAiza6vwNUc6vmKuG1QnwXPUFiWzgrlcjZuzsXNuWTdYKJGmM41LDByQbde24nuSSeDqNiMI353LB9Nfv9nR59XxYXrOw8Wjb2VYPz5F5Kz22GXdGvtpeShfP1ls+MgDcx4gngqjhOopMcdg5K4Tcw2NMkFaQk7ILb8VAtIBJE20GkKK4jiFY4YQwiEUmgF0IImCikig88vEP8Ma+0EwezI4HpyGcJzlcL1fS2TolSQ9lCYUkV1fWHjxtJGj7gQ1Of86PlmQICgSU53tWnDzzQELvlzhdCduODjibCDDnwhECIwAgHPC3WsJFL6mKaJa7h4hodhGvh2Qqdz62vWwS+6+TBKupGdX8X48y/k9ttu/lnXUGrFwq2Fx4v4dcL3fY457gRku0EIK9Hay8lD657ox3YchMRI6IlB6bRNacom6eioXszMz6eN2zKIvEmd0pVhBkFzpWPIyBgD3YxhoA09Qwg8wnnfmjdsw0AIP1iSNt7CRgyptB6BUWB4+ME+pXQzhuupoLs2/yXThqaIpnKEyLph2YvmSql0ejlmBmLyAhwRyL8EsIJIZcin4GPaBjnPJ2YberyaFfCwp7MbsZiB5+p0ruu6+KH8lJC6JiecqqH8NhXuMtsPYurn/+LJJ59k7NixP+saq+LC9Z0Hi8beCjB79mzuuutOzF7jWnspK4cd14aUIbEsLRrsmEYTsU4rSB9AfkJGPlUQFAhLnYowCwhJFIg6hmnSvKRKMN82TK8GqQxBkCIOUh2GCFMgEim11xs+P+f75Hypu8iCezR6Po6hmyyUUiQsfU1LCrJe2InrEQsU4h1DBNdSQYewNkBdH1QQrZSelmBxfYURqNYrQ6Kkwst5TRTqQ8HSsMg51J3yXA/f9PG8wODz3PwM3TZQuwdgdtiau+66k4suPP9nKawXjgJa2fEifp2YMGECM36chbnxyNZeyoohhP5OJjI4MYd4MkZJSYxkzMKxDOK2LgkJnVud3ZCRcaebwvTPekSZnnYRSke5fn6qhSBfzxfE5FAQieB6QSG/jgiqJnV3+SyHbFJ64hkqcnrDGFk4/9sMshVmtFafhpyPY+ajeYYSQS2gNjJznsI2tLOc81Qk11KX87Fsg5wvI8UC31d4Af/bpkIGOqyu62M7Jm5cG3wNbgHXhXWSQgR1k20nuicMG1H1G0494xz23nvvnxXdWxUXru88WDT2VoBLLr0Mkl1+dn2KVz0dNX8KqnExRs8xyFhpyy4w+KJphfWg1qygi0sbXfm0LRClbxO2jDpXTZE39AojcJBPu4aGm6vyGnoKogaKqNYkVHGX+dqUMLpnCJlPHQdEqQ0+P/JCGzwvMha9oIA55/uU2BZLcy6l8bBIWRt0bhRZJBInFSLwlH1BoxtEJIPRarZhUp91EULr8VmGJKv8qGjaNySG4Qf1e35k8Bmmged5GIaBbzngxXWzRig82gaITiaq8JJduPTPl3HLzWtev+cpVp3GXb85roifCaUUp55xDqJyC4T8eX8q3J8+RiyZBkIge45FtPREmmBihhWL4SS0cHImqbMbccsgEcirxC0dyQtLVkJntLAxwypwcn2VN/SE0M0OInCYo30IGkPxUUAEkTYZGG5NmyzyGRMjuE9oLLq+Hxl7EshJFa0zNCqznq/lYKxgHFoUTSxICwdNIGHWw5KCnKGNvgSSxvCLbGqD07EM3SwX1O8JoXA9SSJhRTXMnuvhuR7KtnDraoOUbjA3vA1JUYUwKjZl+hf389RTTzFmzJg1fv6quHB958GisbcM5syZw5133oHxC6J63qIviXkLEKagYeHnyE5DW2ZxYaGs5YAdx7RMZDAeJ9RRCrtPY5bewshe2LBgG4KEZQTEF3SfyeU9IEOIqKZEBXV/PtqRK9SPsgOZgjyB6kieIQS2NCIDzrEkCduIUgd1WS/Qv9PEWpfzdFFyYFiaUlCX83CVronJ+rpupqZRE0zOU01m6IadvaYUiEAZXgqTrOvj+jpt4SuDrOsHaV8R1AxqotQyBEFHrm9or9cz8T0fz/P0ZA3fx7Ni4GQ16fleoDvV+gaf0X4wd9xxBxde8KeVzl1cGYpp3CJWhKeeeorpM37E2niHn3+RBVOoLEswe/YcrJofMUq6/7JFhV24ERfaiHiaWDJGqiRBSYlT0JwmSQRb3NRRPVng4IbyTmFzWTjdIuQ3Qwh8odOlhpE/N4zweEphBT2O2kENDLjAsAvrAH3yIvJGEEnU49c0Py3N5TQPBuc1eF4gFyUix9cQHq5SSM+nXnk4htTGKLr+Thugej2e1A5x4XQOKUI5F0l1gweWQWPWI2YbuL7CsWSQ0jUKZuiaZMpTWI5F3dI6PWHIdwNRwFyBw/vLfqUtCSFNZOUWnHK6Fp1f0+jehpzGbRtthW0Il112BSQ7/+yonl8/H1k/h8aGRhoaGhB2umUWVmjoxVLY8TiWY2GaeuxXNPTakMQtg5gZdIGZ4aY923jQoWUFhBdG4iQiIiJTyMhzDVMXRnB+SEIyih7KQKNKe8gJyyBpmiRNk7hlkA7m8PpK8f2iWjba6XQyCYuqEocOmRgdSmPM+uZjJj7/OI5XR3naJhO3SDkmHUpitE/GSNsmUgjipkGJo2f6xi0Z6fuFHbxxS3f5ZmIGmZiBbYhINNUyZH72ZNDVa0Z6WvqxZWnNKcvSqXHHMbAcC8u2dIeuYSBMKzC2Y21qdq5MtEMlOvPny65Y4+eqZvwr4teFMKonf0FUz1s0DT9Xz6JFiwEQ9i8UohUyLzllOboLN11JqjRFSVma0tIYiZguZ4lbuvM/bmtOso28vEoY4SscC2kEtcZyGeMgfE6Y5jXDho6AJwvr/sLraK0+I+rsjRkGKdskY9ukLAtPKb5dUsO2486jNGnRPhmjXcqhKuHw9otPMuOj90gpl7RlURXX+7ukE2RsS3O4qbnNWmZzAh1VU2oNvqQtSTqStGNQEnBizJSUBP+HBmzcNiLFAseU0SzxUIs0FreJJ+PEEjFkPK1rJO1YkM5teyaEUbkpP0yfzrPPPrvGz92QebAY2SvAvHnzuOXWWzB7//yonr90Jm5DdfSznezQEkvTsByIp5GJEi234ljYdv7LZpkSO/iShwO8jbCBF0FZMDotJCcoqCUh3zkb/Sx0JM9TesxZ6LH66GicFdTqOdKIZACkEHpKh2WQdDSJ1GVdpv1Uy/6HXwpA1xGnAKDcBrxFX+LOfBOA84XkxXc+47En/s3f73qU9/73EJ4RpyJRihQ60rekoLDZMpqOHQrD7CKUVhH6nKWNHo6h0yWuJ6L0hYuOdrph1TUSgok7oYfn+wrl23qcWjA/17ViUL80mkuM8ttESsPsMJhbb72VC/40nqqq5jsr4USAVR0v4teF5557ju+++xZ7kxE/+xr+4q/xPZcGz8Ww4gin9JctKtIWTerHyTLS5aWUV2WoqEiQSTuUxG3ScYuSmEHaMUjbBjHTKHBuQzF5TXSOYUSTgwS6/VY7uuEcW33rvEoBEJS45HwtNuophSGMaDpQWKMcM4yodMU2JcmYSXV9jqkLqjn9xKsB2HL3s/V71bAYb8FneD9NAcBKteP+517hX3ffxjPPvc8nE59gcX0DXTOlzKipA0AK3ewW9IVgCD3CMoTnK0wlcIVugpNCIDytU6pFnGUUrSr8itsriG7V1TTo1x0ecBLg5nS9ZBupXQ4hpBVF93bfffc1iu6tigvXdx4sGnsFuOWWW7EsB+I/X0tKFNTnmR2HIuM/Tw6j6UUDjzZZCqlynLhWOo/FHWzbxLJ0etQxtSfpmLo2z5T5OjzLkNiG0aSmTpCfhwsFhl5B92yI6KEIBEZFvt5Fa0Dp+yVsk5gtKYlbdNtiHHiNyLJ+4OdQDQsRsQpU/Ty8RV/B0m/AyzF27O4MGLAxf/7zteyydX+klPi+z6DNNgagtKyMPfY5hENOPJuM7aAas0h8TWCGCEhOk1vYhQsEo4QUSdugPudTGjOpkZKcp1PD9Vk3iAz6mIaktsFdbkqHCshUpzD8IIrq6/q9cIxQGyEBmWiPG2/PrbfexgUX/KnZzyumcYtYFlddcy2YSYT8BWLdThnwHQBGjz1+mRhzUJtHQkcHzfIOxFNxMuUltG+fojIToyRhk3BMyuMm3csc0rYZRd6UCuqLgxITQT4SF0qn6M+5nqcd8lxorIXNbcEpKKWzKErprltfKUy0cLwp8lFAw9BRts223hPhlGGkO6OyNSi3DhGrwF/yLf6Sb/CXfEc8EefIE37Hjz/OYsKEFzhw+4Ek4g5ubS39e+rGqy7denDAUX9kxLhDAEGd6xaINKsoVWcIgSroKHZ9RaPrB+Uv+nzHEPh+UNJi6P99Q2AHs8xDNDS4xBJOxH/1SkHtonzNspBtopSlEEbFpnz7+b1MnDiR4cOHN/t5G3Iat2jsBXBdlwlPPUnOrsIuICXlZQHd6dMcyEQ7DDuJkBLREoYeaEPPSYIQOMkEsUSMeDJGOm2TTNpkUg6ZhEVZ0qY0rj3aEkenF8OmiZhhNNGTCutDljXwRIFniNC6Uioc2E2+YFkgIkPPCsYKxWwdTXzowQe59Jr7cX98VV9m7iSEu1S38Afo3KUz+xxyGCeddAxVVRUATJz4Pv/73xtcf/2fUQoe//czHH3UwXz44Sfccuvfee2lp3noqf+hnCRLc25+SDjgmAa1OZeYIal3vSj6pxQYUtfymYYWbjaDlIxlykByIJCC8XTkT0qxXDrH962I7BobGoNUUqP2bH2vaYFMK8KoHMA1193Aeeedi2k27+tdNPaKKMQXX3zBD999jVG1RZP9KlcHptNs3VGZ6oRa+BmGk0LYqV+2KGlo5yqXhUwV0pCUVWZo1y5JVWmc0oRNSdykJKZTloaAhGlginwWQxY4uIKgnIMCXU6Rb0xTqsAJRnfrh4wQiZgE3xvh66wHgIWOAkopyDXUce+/7uW2Ox/DnfO+fk6yA17tnCYvbfOBAzjk4PM48siDcByHurp6Xn/9HTzP5+mn7+Mf/3gIUGy33VBeeOEVrr3oDN57/UUuuul+bENS53pNVBO04xt03KLX54UTjoLGuazrBRqsAl8JLGRBJNPHUjJynNNpOyoVCrMbjX5JQc1efZvhvxDCsBFlG/OXK6/hqSeLxh4Ujb0IEyZMoH27cuQ3C6N9ym3A//YJlJdFdh2FTK1e1kKYcaxNjmy5hUUzH1OQqsjvlnryQ0UmRiqmDb2qlEVZQqcuwg4zMzDEbCmjzlyBwBZ5uYAwmlVo4ETduAiU0KFtoUJC1HVuodcshNbysw3JgGEHkPvumeg6nTp1oCRTwti9DyeVSnL++Vdw221Xc8ABY5bz9B988DbdJeZocejDD98fgL32Gs3ee+/KyJHj2H6nsTz/4tPYsTj1rodEN5wYQpIwDWqXLGL219PosdmWZIWPED5CSEwZ1lxIXKEwDRXxUy4w9nwF2ZxHzhP5qKcMvX5FQ10gdmqZZN0Y2NkglZFrM6lcWdKD2llv8dRTTzFuXPPKEfzVpHH99Z3lilgjXH/jTSxctBji9dE+v3Yu7rdPYiQqkF1HN8t4M0q6Yww4pmUW5XtBnV4cM54glUnRvn2KqtIYZUmbkrhF2tH1aBUJK6hvM6KoHOSNvVBQHqVLX8LjikCEGH3MjxxbvSs6r6BcRKlCKWSCdKo29rbebrcoLQswcOAApJQcddTJvPXW+zz99Es8/fT9DBy4aZOXmkjE+fTT14nHY0gp+dvfLo2O7bPPHvTt24vLLruOKW/+l42H7IAK5Kxihk5Zpy0LheLH77+l0c1R2qUn5Fw8Q6GUJOd52GagsCCFlqVCBwYcSyHzPnkUBEindUlL2LCmfEW2UJGgjfBfIYzKATz79MPMnTu32U1rq+LC9Z0Hi8ZegLv/+U/22GMnnn/+ZdSPr4PhIJZMIxWT9O3blw8mPYnVawwy1WndLSocMhtLQiyNHXNw4g7xVJzS0hiZEp26KE3YtE+bVCRMUrYZjTkLZ+FaUkY1dWEKIzTypMoTnVlQbKtEaOrpcwV6moZCBR1t+Ro9GQzxrs95+LWzad+hPVdcfh6ffPI5J574OyoqyqPrHnfc4Sud42rbK4+ebrHFALr36MYP33/C6K36IMo24rQLz+b6m55GZWsQVpLfHzaUGy88HZTPpXc9zkZbbhN5vFJAScwg62pR0vqcjyc0uTuGwA2il44paXR9pHT1sHApqK/XNSl2LCzoA9/zcd0YOKGxp9oE2QkhEeWb8OfLr2q2sVfU2SsixNKlS6mvW8ToUTvw2OPP4gpQjUug+hs23bQvc+fMZ+E3j2P0PRBhxtbNosIyFicJ8RKdvi1Lkk5auj4vbpEJInplcZNSxyJhmlHNXIhQ8D3S0wyMsuiUAudTCi2kHEqfFDqmSoSFbgKPYJpQwXlKKWobXWTDXMbttxebbroRQghOPvnY6DqHHLIvN910BYax4ihpMrlyAesDDxzLZZddxxnHHYLppKB8ADLZAaSJcusRdgnegs/xfppCPJHk3v9+iBlLYkmBMiDp6GhnzlMoA0DiS13TrFTQtGZIDNFUi7SkxMF1fTzPQfkKz4vjeTlwgw7dxto1+KWufUinFJHqxG233c6FF17QrOcUdfY2cEydOpVh22zOoYfuR11dA+PHX44Ti7HvAbtzwgm/o1ev7gzcYifmLfl23Rp7EM1+lE4cO2ZjOzbxuEk8romuNGHTIW1RmTRJhmPSLDOqMRHoCNxyXWaFhbxKIQsMPb/gZz/Qhgp0OKOPuxEYkuFMXUMKttrzHGTtD2yz8xDGjdudceN2X+7lrMzQaw7+9/JjzJw5h2ef/S+33X4vV510eJPjN17wCHvvvRtPPvkci6d/jb3VMBQmru+T9XwMX2FJPQA8HZN4PtRmvUi6JWFJFtd7WKaPKQWNOQ8pBImEHZF0WLPneZ6u3atbHIRB/TajPWVUbMLkD+/l888/p3///qs9v5jGLSLEvffey1FHH0rf3t0wTZN//etxOnbqyCEnH8Uf/3g0CxYsYvDgXRC1szAyvdb+ggoNvWQGO5kgmU6SStnU1rtYRpaEY9K11KYsbpKxLVKWNvRMKbFMETVUFEboQvYTQkTRO0W+RAV0PXD4B76wvCXMeiDQQu3LlCIKIdhp7Cm4NXPZZptBHH30ocu9rFCI+eega9dOfPzxa8yePZf773+Uhx76D9nZTZskDMNgp51G8PLLb5BdPJ9klxJsw2BJY5ZQe7RcmBH3LW30yPkCM2aS87VDXNfo0pDzAoNYG7GxmB6n5rlajqreS6FC+alcQ54L2whkxQCu+dsNjB9/XrPKWopp3A0cN99yG2eddRRCCI477nD2229PEokEsZgTnTNs6CCefP5dlNJpwbWOsCDZSUAigx2ztfyHaWCakphj0qEsTnlCt9SH8gJljhVIA4gmnizQhOAgMOTIFywrFH4wjSIkuXBOpB9E+sLUhvb+dFTPMSX1WQ9v7iTc2gWceOLv1spbUl5eRnl5GZtt1p/TTjue2bPnMnPmHLp168z338+gtDRD//592XjjD/j3/X9nu132xE6XBzWFWjWwLudiqXwKRgrdxGEGnm7MlGQ9xcI6l3pTYhgSKQULhH5OVLfi+fieT4OTzKcy3GybIDthxpGZ3lz3txu54/ZbVnt+sRu3iBDPvfA8hx56HQA33/wXzj//VNq3r4qMk0ymhIrKShYvnbn2jb1QbioazaWIJ+PEExauq+tnY5ZBacwk7RgkLZNkYOjFLT1NqLDQrtCwE0FGIkRYixyKvof7QDSN6ESqBOTHShZ8PyxTsuXuZ+LNfJWy8lL222/NhX2bg65dO9G1ayeGDPkNf/nLn5gxYyY1NbW0b9+OadO+ZqON+lBXV8+QIaO587o/86cb7qXe9Sl1bHK+T3XWxSgQZg41/cL/c75inlLRZCEpBLUNORzHxPN8fN8BBXVLa/Ov345rDvTcVufAELKkO3Wz3mx2WUuxG3cDhuu6LFgwi0xJvgalvLxsufMOPHAsTzzxLPzwIka3nX+29lSzEBp6dhziafCDKJLnI6TANLUeUnVdjm6lTiCxIgINKS0lEOk+yYCYUFEdWviZNQoaNEJiQ2oS8xSRRxx2b4WjgEIv1/P1OJ7hY8/Dq/4Bd857nHvuyWy11W/W3nsTwLIsunXrQrduXQDo3DlfT3nddRdz2GEn8NYrL1JTX0+mvIqydh3os/kgUrZFzvejrrUS26Q66+qpS8GIoUX1LmlHy8mYgSZXfdaNpFhqljYGXbpKRxy8HHheIDbqrmC16x6yfGMe+Ne/uOXmG1br0Qa/6lUeL2LDx6effsqOI7dusq9jx6a1TkIIjvjt/lx77a0IO4nZbsu1s5jQ0DNtXauXKMEoKSeejEecZZoymAMeiMMH5SXh2EhZkMON6m8hmDakuU87vHk1gijCBwVGX2DwKR3FC51kr+C8kBu22eNs3NnvQs1M/vH4P8hkWkhndRVIJOJstFGf6OcuXfJceOih+/LAA4+z3ZuvsnjG96QyZXTt25/effrxU30DWc/HlJLyhE5b17keOU9R3eBRkTSpzfqYhiCb80jETO3sqrBRT2DHHbJeKm/cCQl+bZshDSEkomwjbr39rmYZe6viwjbykn42fvXG3iuvvMKYMaNWe94uu2zPfffdwu9+dzLeD89h9Njzl0kJrA7K18KVThJpWdiOjWnpX5eUgqX1OdJxiwV1Lh3Sli7ONbR4sSkNpCRq0tBk1JTQQrIDoq6r0FvVLKg7ucIKZD3zOv9xV0qP8Bl9oK6F8Jd8R+fOnTjzzD+uvfekmRg+fAgAV/7p1KiGBsCKl7LNzrvQoWtPttpuJ/r23xwFlMfsYHSbj2vo96HB9GlwtTB1Y9YjFbMiQo8nwu40bYDnvCTU1+ibG+Za92yVUuDW6brSlTgdMtUJf47i1VdfZeedd17t9dQqvNZVHStiw8H99z/Ascftt9rzzj//VISAa665FZSP2X5wyy9GBflROw6JEmS6jEQ6oZsRcj5KuUghaMxpORHPV9F8b18pZNA41sSQCzISYaRKCO3wNrmtyk+bCH/Whfki+mvv+eARNqzp/xWK4ePOA0DW/sB+B4xh++2Htfz7sobYffedeeCBx7nk2P2bcmG6A8N22Zmqrr3YYbcxVLbrAFKQMI3IKoh5koTlUxLTU48MGTau6Tenri5HMp1ECEEjaEOvUQbOr7tOxkkq5UOuFqzUSv8ey9I+/O/lx6iurqakZNXC3qviwvWdB9ue/PU6xgP/eogdd9y2WefuvvtO3HzzX3CXTEdlq1d7vlIKd+YbuHM/bP6CQo/WsLTUQLYO27ERUiCkCLqhtFwIQMyUJCwTO9C8i5tGpCWl0F6sZejxQZap6+tMQwZRq3CyhIiOhx6xEdThiSDFC2G7hn7sKh9PKR69L9BzMxxmzpzFY4891fzXupZQWprhySfv5cYbL+e77z7g++8/5Omn7+fQA3elevrnPH7b1Zx10GiuOv8UHrvrBuYurUV6OVK2SYltEbe16nxZXNc+lsRNMgmbTMLWReFph1Q6RiyhNyMW1000dlxHImCtKMsr3yM38y3cz++m8bN7cGf8b6XnCiHxU7246x//XO11w9TFqrYiNmwopfhi2lQqyjOrPVcIwfnnn8YRRxyIWPx5867vNpD77lm86unNX1RBDWwynSSZTpIucaJpQZYpWVqf4/PZS/l2YSNSaIkpM1AdiOZxF2Q5wqyH5sX8ZhYc049lwc9Sb+GUCSuMHObfu1AGSr9BJg8++ATffvtD81/rWsIuu2zPP/5xPffccwOzZn3Ct9++zz/+cT177rwlsz59h8euv4ST9hjGtRefy+vP/QfX98HL0SHp0KUkRkVSN7/0roxTkrCpLHECw1mQStkkS3RndDTGTgotS2Xaa3W6kMouxf3hBbKf3EHj1HvxFkxd6bkyVk4sXcmECRNWe90NmQd/1cZeY2MjnldLzGmehh7AjjtuixACb+Hn2qsg8AaWURFXysed+SbuTx/jzn4bv3Z2824QtrFLQw+ctmIopVj64etYtoVlm3i1C3nvrjuJ2ya9KxycYFSZKWTktTYx1oSe/5onLX3cDHT3LENGBqFtySZdtiEphirzMvg+54Lh3WHjh9lhCAjJlCmfNvu9XJvYbruhHHbY/mQyJWQyaYYP35rrrruUV199gq+/fpdRo0dS/d3HPHTTXzlp5y3Zf3APTt5nB9576mGqHJtkMES9a6lNWcKkNJGPoMXjFsmk/szkFeWT2uCzYjq6tzbg1uL9NIWR2+nIJdZqUkQlvXniiX/T2Ni4ytNUM7YiNmy8//77jB61ZtMydtlle3L11XjV06PvgVIeapkmJeU24v3wHN6S7/BnvITymzlxwYpBPIVIluJ5HqVlcTp1LGHmy8/Qrl2KqhIHq3Y2T193KyWOrlk2A14zjZD78gafUcCLtpk3+sImM1nQbCaDbo6Q70I7xgyc5JA7XU8bAYV2gOio38cvvvh6jd7PtQHLshg3bnf23ns3YjGHsrJSxo3bnX/843ree/c5XnnlCbbeanMWfPYmt43/I8dsN4DDh/bhT8fsx+fvTyRhGWRiJoYUtE/rhsCe7dOUpB3SaYdk0iKZjpMoLUGkyjUP2gVd2mupvt2vmYm76Gt2CgI1wll1xK4x1p1bbv/7aq+7IfPgrzqN+/zzz7PPPnus0XPKy8s4++yT+MtfbkDN/xgjXkauZh4AZvdRupzXdxELP8arXUAqlaSmpqCIdXUIC5INE5w4MpbEtEzSw3fBdkyM6m/56PYTcZJpjOzvWdyQpCoeihvna/VQeWcrTF9E0gDogdwUpDkgrFURYOjpFJ4f1KQoPYEjJLXw+XsefFH+ufXzQPmMHj1yjd7P1kBZWSkPP3QHAC+//AZPP/0iG23Um3femcRfzj+FIf99llOvuhPLMsn5OTIxrddVk7KxTBmNmEsknXyjhq/wG2v1m27FgIYWT+cKuwQz043pM2bqHau5tki0R1oxXnjhBcaMWXmheDGNW8T9DzzAGWcctUbPGT16JCO2G8obrz+FaccRTgm5pXORiSqMdluC8lHZGljwEW62jsrKchYtrmEZZboVI4zq+Z5uykjGcV0PKyhN6VKZ5KsXH+Dtf15Fj82H4Jh6dnY40iwSTy7gPsMQkdxKXlsvjzAOpVDL0XXU1BEs3TYFfk6Qc32223d8k3P9mhk4sRjbbjtkjd7P1sAWWwzguecexPd97r77QaZOnUa/fr14+OEJXHDsfhxxynh2PPT3ZGJGNEe4ttGlPO1gmZL6+hxCQLIkiZSSmrol+sJhhsPNrhXBZZnpjWFPZMmSIMO2GhUEWdqX995+kAULFlBRUbHS8zbkNO6v2th74j//4eqrzlnj55111h/Zdtut+eijz/jii6+4775HQQjcH16Mzhk2fGv2GXcSZ5xxEQAiuXpB5sjQKyA6J+5gB5HHXNbDWfIdAI21S6n+/jPSG3Um5/ukpRmQUT4iFyZdC1XjpWat6LEI9QgIyvOkTgFKX2EIhSe0+LACLF/qeZBKsKQx750rpfDnTaJL185Rvdz6gp12GsFOO2lP/Pjjj+T55//HwQf/ng/++zRb7zqWhGlE9T1lWRNTShbX6EhZMmmjFNQtrdNEYMf1RaXQJCdEi7uDsmoQX3/9NMBqhW2FELiJHvzjnvtWaez5wbaq40VsuFBKMXPWdErSyTV6nmmaPPLwnfzvf28wdeqXvP32B/zvf3Px637C//4FQEuMHHbYfiQScW677Z8Y5Rs3r7ktiOqRLMNJOMSTMVIph5zns92xh9OlPM7kbz8G4PuP38Pws9TmXNKOGejeqcDIK+S+IIIX8GQTm1OBEoGRF9Tihd/dZUvBBCKqcXb9pl9w5TXCwk8ZN243SkrWfnNGS0FK2UQi5thjD+eii67ilhv/wna7jiVZ2QEhoDbrU5qwor81tWkn6tgVQlC3tBQ/jDK4evrU2hinJgwLUbkl77//FkIaq9V8lE4JVqYD//nPfzj66KNXet6quHB958FfbRrX933q66sxzTWvKxBCMHz4EE444Xdce+0lWjtOKSZPfpkZM6bw448f8czT93P00Yey9967YqU7rL6ZIwx3F0quxEtwcy5OwmH+Wy9RUZmgwyZbRU/JLp5LwjIodewo2hR6X5HOXkEjhtCWX1C/oo/la1R0OrcwtWEEtXtmkB4J07kKhSUlf/+7NpT96u9xl/zAFZeft1KR0PUFu+66I0OHbsU7Lz1F0jJxTC1rIxFkYgblCYM+HdJUZmKBsaeIp+LEEjFkPBmEUmW+fq+F61ZkqhPWgGNwNv89ZtXA1Z4v0t159ZX/4fsrpyrfV6vdithwMXXqVLYdPuhnPTcWc9h9950544wTo+as7t278t13HzBjxhRmzvyY66+/jAsvPJN27arAaIYQcyi14iuMWJzGukbcnEcqadOxLM7rd95Hh7TFRltuEz0lXruIEtvCMPKCyQLt+AryqVndgJGfkRtuUhYIJwf/5flTNOFRyEu1JByDh+49P9rvznkfQ3icf/6pP+v9bCuQUnL22SdhWSYfvPK85kHToEPaIu0YUVlLOmGTSmmJspALgSDD4azV2j2z3RY4mx+PPeBYLSq9GjTanXjksf+s8pwNmQd/tcbelClT2HLLAb/4OqZpsuOO2yKl5IknniOZTDRRP6+tq4fm1KiERoI0AgkPPR7IMA18z2eTffYlkbChYC7loK22Jm2ZevqFlFHBcBiJinSlCtO4Be0W5jKGnY4IhmOF8tcKI4Vh3YunFDWuyzHH/AWVrUbNfoMdRm7LHnvs8ovfz9bGV199yzfffEc8mdLpa6knkKQdg9KgYcOQgsqSGEJAOu2QziSiPwjE0tpQjwVREiFbvG5FCNls6R+RbE9dXR0fffTRKs/bUOtUilg9nnvuOYZs/cs7agcPHkgqlWLGj7P4+OOppFLJSKs0l8vheh74zZAmCo0DwwgmNXgIKZi/oI7quhznXXWKlj8JvgPd+21C906dCrIZBcaZypeygAhq+ZqmeUN+LNQmjWqdRb7RIxSpB53GtQw9P9YJ1utVT8ef/zFnn/XHJlJQ6yteeeVNstkcsVQKQ4hI3SHlSFK2QVnKpjRpIwSkUjbpkhiJdAIRT2tn1ymYArKWaveENBDNNCZluitvvfk6nrfqlO+GyoO/WmPvueee44rLr+eQQ//A999Px/M8rrzyxp/VQbXTTtvh+z6XXnoNhx9+IqCbP4466hT++9JrUNUMIg3nDIZzVnMNsGQu0pB4rkdDQ454zESqgCyFQWWPvsRNQ4soFxhtK6tZCS24SFZgmdqUUE3d0051dL5WXxFYpm7iMIUkZZo8ftV+uF89QruKNDffdMXalaJZR7j77gfxlOSY0y/ADmb/AjiGJGaGszd1qqhTRZLKigRSCtJlaVKZFHYykS+WTJQ07dBtBQhhYGW68vzzz6/0HF+p1W5FbLh48JHH2XnHcZxzzqXU1dUzd+5PXHbZddTV1a/+yQUwTZORI4eDgr33/i23334vANOn/8huux3M4sVLMdv/ZvUXCoV5G2rxF89FKUVjfSOGIajKxPB8hWNIKoKv1Y9LEohYItAQ1Z/VMEsrAu5b1lgrNPQingzGPsrIuMuneyNnLnquPifhaPUDd94Uct8+zY47jeCkk1aeJlyfcOWVNzNomxHssMd+kdEbMzUfCgElMZOypE1ZyiGV0g0bQgjiqbg2+GCtR/fWBCLRjpzr8f7776/0nA2ZB3+1xt6DjzzBUtGel/73Hvvtfyw33/wPrrjiBo77/RmrTHmtCEcddTA33HA5Simef/5/vPXWu/z1rzfxnyefx+q+C0Zpn9VfBLSRt4w+Ud3CRZiWieOYpOMWHXr2Dc71INeIIST1rhepn4dzH5sYekH6NqrZg8ggVOTbzUOxTM9vWqRaSH4ISNoGdUsWsveee7DVoM14840n6dRp9WH09QGvvvY2g4duT7sOnbSKgJRRdA8gaUuSjqR92qKqJEbHsjjl5XFKMjFSmSSGYWCkMhAvIRr1JIQmu3UxeWUFyDodefDRJ1Z6vGjs/XpRX1/Px5MnkU324c67HuTUU//E2WdfytVX38LVV69++sqyuOGGyzjllOMAOO+8y1iyZCnH/f5MvvxmFmbvsQh71V2TEULHF8hWL6GhroFYzGTOonrqcj62KajsuREA3vxPSVomhhBkPZ/GnObDaErGCspYQohl/wma1PUtG90TIs+HocTLNx++gztrIn/4wxE8+K/bmjWWq61j0aLFfPrp52y321gcx4nKhBxDUpmwSNoSiTZ6S5N2pPyQKY3nLxJL5TMc0Gr8F91eSIx0l1/k+K7P+FUaezU1NUz9dApmxyHIHnvy/Q8zufDCK5HJDkz6YAo33vj3Neq88X2f+fMXArqG5Zprb+O6627DaDcYo6zfmi1O+Vpfz/fAsBB2DMvWzRe1DTkWLlgQnXribiPYZYfd2HOfU1Aosq4fKcKHaYkmdSYFkx5Bf7A9Xz8v6+bFSRVaSDnUmiokzNCg/HTiK7iNdfzznzdSVla6Zq+xDSOVSrK0rg7X1++jKbV2lyW1PI1jSCSCkphB+7RO67YvT0RFyiXlJRimgbRjkMhAslRrJpp23uhbx5Dpbnz60YfU1NSs8LjfjK2IDRNvvPEGyohjddkOo/MOPPLIkzz55HOIZAduuOFO3n77gzW6nlKKr776FiEE3bt3YffdD+G99z5EdN4RmWjX/AuFxFW/FGzdjbt4cQMlCQsp9EivWXPm6HO8BnYYMpith+3KsL3OIOv5QW+UHoNoB7XIppRBtC9c6zJC8QWZjrCspbBeL5RoiUpk0PqkL054mD59e/LnP5/7i2Z/tyU4joNpmiypqQXydY+h05uyDVKOEXTpCkpTNiVBZK+kvIRkSRIjEejvxVP55rVWRi7WiQcfWYXju5ptfcav0th74403kHYa6WSQsTJkl50xku2xeuyG2W4LLrroKvbY41Bee20iS5eu+A9kiGeeeYnBg0dxySVXA1BbW8frb07C6j4Ko/3PK3pG+fpLUleNaZnULKmlsdFFSqFnvSarcBybLfp3wp3zHt68SYzc73y222c8vg85z28iJloor+IHETzfV7jBuLOw+DQUijc0U+aNQ5UnRim0AZSrq8a2bSory3/ea2yjmDt3Pk5aC8uG0U9LSny0Qr8UgrgtI2O6Q4nuRquqTJLJxJCGJFORIVWa0gaeaUMyA6myvNEXdlyvI0gng7RTvPnmmys8rtTqtzXFLbfcQs+ePYnFYgwaNIg33nhjlec3NjYyfvx4unfvjuM49O7dm3/84x9rfuMi1ggvvfQSJDvrZq2yfpgdtsIq74Pde29koh177HEIp5xyPlOmfEo2m13pdVzX5brrbmezzXbgmWdeQinFd99NZ9oP87H67IeR7rxmCwulAQwLsvUIKYjHLeYsqift6HKShx6djJAGnTp1oFuZr/VMl3zLdvuMZ+CuZ+nvbtRcJgtq95reJozauIFQfV6AOS+zlC+HKZw5rrnyqRcm0rVLp2h+8IaAxYuXkMvlMNMZTJlvejGkwAlq9xK2JGlLypIW5SmH8pRDSYlDWVlcDwEQQju8oZRYK5azhDDSXZn2xScrdXxbmgeh7XDh+h9v/hl49913IZ73Mo1MD4xMDwDMTsMRqa588NFbjB17BEIIevTszlaDB1JbW8f3P/zI8b8/nCFDtuTvf3+AO++8r8kMRqN8Y8yOQxFWYtnbNh9C6po9O05u0TwarU7kcj6LljTQuV2K7U66jFevPoG99hpFTU0d0+bmC04H73k2X79yLVLoujsptMxRmJ4FPeqnEGGTkREYNz46BRJ+wF0/CGErdDeuFFx9/V1svunGGxTBua7LjzN+ZPjuHfGVT8ywdfRTQSzoMnaVwkaSsBSGhKWNHu0ycWxDUluXJZ12aGw08FyPTFU5jfWNNCwKfgFOEhproWZRcMNswCLrwGeMt+Pdd99l1113Xe6Qp5aZALCC42uChx9+mFNOOYVbbrmF4cOHc/vtt7PbbrsxdepUunXrtsLnHHDAAcydO5e77rqLPn36MG/ePFy3bcwZ3pDx3EuvIgo6Gc0Oeekk2WssxvxPuf9fT/LPfz6MaVlsuslGbL55f77/4Udy2Rxnn/1HystLOfucy3j3nQ+ijIg0LWTVIIyqLZpdQL8cvBx4JkiDxrpGbNsgbhvELd0Ycf8Dl/H0P9rzzxv+wuOP/4N99z0KpfJcuOmoM5gz8Qayrh8Za4UIP9ZhdC+qdw4b1II6PuU3rfWDwCH2QQqFbPyJgQNXP3JzfUJYu96xfUdynq6RdINmGUvq+mVfKRpyELckNY3aECwviVFfn6OsMkNjfSPCMFGxlJbScbNALC/Jsi54bxkIO41hJ/nwww/Zbrvtlju+Ki78ORM02hIXCrW+KwX+DAzddgc++N5bpXSFUj6qYRF+3TxU/Txk4wKUMFEYeNXfAyClgR+IORrtB2OUb4R0SltmkYalvaGKLlglZXTt3YHy8gRdqlKk4xb/veZUnOrp7LTjcG69/T6sjQ5FWE11sma9dX2kB+UrRdbVfUWen09xALiepruIC5U2AJXS+30/n+wwpaC2dim/6duZc885iTPOOKFlXm8bwTHHnMbjjz9FqiTDzfc/Rb9NNiPr+bi+ojqbI+f71LserlLUZj0acnpo+IxF9SyqyTJjdjW5nIdSsGRxHQCN9Y001jeSa8yhGuv077ZhKSyaExh8a5/03HkfsVUvi4lv5EesVVdXk8lkuPalj4knV64JVl+7lNN22ZwlS5asdrYkwNZbb82WW27JrbfeGu3r378/Y8eO5Yorrlju/Oeff56DDjqIb7/9lvLyDStS3JbheR7xRArRc29kvHKl5ynfRdXPx6+bh183D9NdhCeTCK8Ot2YuAKadwM3qz7vZeTuMsr6r1T5bLQwrKIXIUNa9O6mSBAM3aUeHTJyN28WpStpUORb7jtiEfcftynvvTebzb+cje++7XLPYvHduwPVUFK0P6690U0eoSxq83uD/oJm3yR//Jg1vwPMvvMgBY3fjueceYpttfmYmpw2irq6eocP2YPoPM+jWux93PvEqyjAjx7/GdVlUn6PB9alu8KjN+sxZ0kBtg0tNQ44fZ1ZTW9NI3dI6ctkcjUsW69Kkhhqonh9I63hrRYNvdTBmvcTFZx3H6aefHu1rDheuKQ9C2+LCDScs00wopfhoymRkov0qzxNCIuMVmBX9sbpsj9F7H8xeY7B67YG90UHYfcZhbXwozoCjcAaegNVx65Yz9KJFSKhZhOVYVC+px3V18bFpCLbc6zC++PxLunXrQiadwpvxMn7DIrylM8lN/x/utxOo6jGIjpuNofPgwzBQJGwD25Q4pgza6INxQgWK8oXvU/jFDjvaTEPgWJLvpn2O77lsvfWW1NTUcttt97Bo0eKWfe2thDvvvIbbbruamuolzJszS9eqBO9NKD1gSoFEFys7pv7DURK3sS1JZUUCyzJwHJPSsgTlFSliiRhlVWVkKjIYiRR2IgGJUihtD+nKdZLekMl2TP30oxXWovpq9RtoQizcVjSGLZvNMmnSJEaNahrpGDVqFBMnTlzh2iZMmMDgwYO58sor6dy5M/369eOMM86gvn7NukGLWDN8+eWXKOUjYqv+oyKkiUx2wKzaHLv7zsje+2P13B2j9z7YffQm+x2Ms+nviG1xImbVZr/c0CsUl5cGtdW1xGIm8xbVk3QMcr4uq6jzFPseegz33fcIxx//W9zaeTqd27gEb9FX5L5/ntx3z1DeYyhvvfY/vvvmGwQqqr/Lj1YLdPYKZKcg7OjVj0PpqfBnTyk++WgSpmmyxRYD+P776dx11wNr3ODXFpFIxHl74jOMGTOa6d9MQ3muluoKXrwl9d8RIOrQLUnYlKccLU1VmaS8Ikk8FddDAUw7L8dS1U1H+sLf8Tpu3Gg0ynjp5ddWeKyleBDaHhf+6oy96dOn01hfi1iFJ7s6yHgFMtUJYacRZnztSI4oX0f27Bi2Y2NaJqYpaXQ9sjmfPr/Zhs2225Urr7qZ8877Pxx/Edkv/kXum//QJV3Lbtv3p9KYQ+6758h++TAdqsq48borqa+p1qkQ28A2VyxL4CkVybCE4qGWKREI6ho9DjzrQaxEGePHX8G4cUdy7rmXceqpf9ogSE4IwZ57ar3AhYt1ujXU3woNX8gX67q+ImFLpICypB4hVFWZJJ12KC9PkEhYVFalSKZsYskYVZ2qSJWmsOMOZlk7cOI6grGWa/hEvJLq6sXMmDFjuWOrG/4dpi+6du1KJpOJthV5pvPnz8fzPNq3b+pMtW/fnjlhQf0y+Pbbb3nzzTf59NNPeeKJJ/jb3/7GY489xoknntgCr7yIleH9998nnumI+Jl/bIWQyFRHvZmxX1a6siKYtp6z6ns4MYelSxtJJ2zmLGnANgQ1ORdDCH77+5Mpr2zHffc9xumn/wH/pylkP7+f3A8vskWfNCO36o5TM5W9dh/FlpttRGVVBx57+EEaGxvzMlWIfNQucG5DfbVIgiXcp6DB9bFNyV8f/AzfV5x44tkMHboHZ5xxEXfd9a+WfR9aCYlEnEMO2ReAxUuWRO+BbpDxsWReqzVuSRKWrossTzkYhsCyJBWVKZy4Q/vunchUlUO8BJkshfJO0K5Hq9Qwi0R7pkz5cIXHWooHoe1x4a+uZu+9994jUdoBt5mitK0GIbUMSyxFXU0dJWUpamqyVJXG8ZTCkoLtjj2f23+/F2eeeRGVVZXstONwTj75WH7zm82QUqKUYtasOUyfPpNHHnmSP198IRdfcD4y05P777yGnUbvrtMXYT2fgpyrAq29fARo7ty53HzN5RjK5eE352OUdEN0Hsknn/wbAKNyM5588nmuvPImzjnn5NZ6x1oMyWSCdDrN9OnfRxPPDCEwhUTiR7U+rq8CIxASlqTR9WmfibNgaaOWbTEktaZLOmVT3+CiVB1eUASeyuhRZwvr66CuWtcnrWa+4y+BkBbJ0o689957y9eKrK74ODg2Y8aMJukLx3FWfr8VRIpX5hT5vo8QggceeIBMRjfHXHvttey3337cfPPNxONto5NvQ8PEt9+mXpa1zT8C4RQNzwM7QWNDIx26lLO0Lkv3dinm17qUxkyEgKy0WBDfirnvP81770+mQ4d2HHjgWA49dF/69OkJ6JT199/P4Ouvv+P2O+7j6CMPwzjWgUw/Xn7yH2w5aMsmdXlRPZ8iklxRwKQP3ufWm2+gXbsq7nxxHjJWjuywNf/+9zMYThKjtA9nnXUx/fr1Yvvth7XSm9dyCMWhf5o5nU4dO5OTPq6nJyjVux62IWjI+TimoDYLtmXQ6PqUpx2SMYv5i+qoqErhuj6mZZApT7PopyV4yRh11bWQ8WDx3IIuiLUfMJDxKuZ+M5OffvqJqqqqpgdXxYU/gweh7XDhry6yN2nSJHJmWWsvY/XwPR3Zq1uC7djU1zViWZL5SxowpWBpo0e8tBKj975Y3Xamy+bDmDDhBe688/4CYVFB584dGTp0MNdddymffPIqf/nLeHq3lxy8/1iO+e2BCOUFNSzgBhpV9VkP19NyLI05n0f+dR8P/vNO3nn7NXLfPkVu9juIRAfsvvthb3QQZqehSMNm9uy5rfuetRBc18X3PSa/9Uqkwu8phZT5iF5oDPuB4Q26UNmQgpKERWVJDMc2ooHhtm1QXh4nnbaxbIN4MoZlW5R2CKJ7dhDhC6eorAXkzDImTZq03P7mpnFLSkqabCsiucrKSgzDWM5znTdv3nIeboiOHTvSuXPniNxA17Uopfjxxx9/wSsuYlV4+ZU3EbGfn+FYaxBS/8U1bbAdcBuJJWLU1eVIJ2yq67LETIHrK2pzLg2uz4Qnb8fqdxDHnnUJFR17cP31d/DGG+9ElzQMg969ezB69Ej+/fg/eOutZzj5j7+jXMxh5LZDuP7aqwPx+Pwfe18pXN+n0fVpcH08X/Gn887m0Yf+xcP/egDv68fxlnyLUbUFVs89MPseGCkwzJ37Uyu8cS2PqqoKAN5+42WtLShkNKFER/h0eY+vwDF0eUvMMojbJo4licctysriZDIx2rdPEYuZlFVlKCkvwUnE9MShdj0hXb7OUrrCjJHMVDF58uTljrUUD0Lb48I26dStTbz7wUd4Zknbf+HS0MX7JZU6sldeQn19jmTSZt6SBnq3TxEzJSddfgZxS9K9zOHNR3/Dvdf+mY8//pwDDxxD37696Ny5Iz16dCWTKaFDh3Ycd9xvOe643zJhwvMcdfSpXHDe2Zz/56vIuT41DS7b7H3ucktx52jF8XvuvoH//vc1LrroKvBymJ23RQhBbtZETANOPvnYdf0u/WIopbj55n/w9tsfsNNOI+jTpyeXX349dXX17H/AgUghUBKkD76vI3xhakcp3eTSoJQWWHW1ZyuEIOf5xIWgPutiGRJsaGjQ8jklJQ41NVmUQtfz9dmY6kXVeDO/0jUtjXWQrdeR3Rb0dD2zhPcmTVl+v7+abtw1mAlp2zaDBg3ipZdeYty4cdH+l156ib333nuFzxk+fDiPPvooNTU1pFI64jlt2jSklHTp0qXZ9y5izTB39gxEx01aexkrhmEGuigeIpbCzbqk0w7VtVk6lSf4qdalMmWR830MKbCFyZOPXoNjGBx6+DH85Zw/cNppF/Dssy+z664j6d69a8SF8XiMTTbpxwUXnM555/0fl156LX8672z69OnLmL3H4vmKnOfTdcQpyy2rcapO/73zzjOcetoFPP3UC5iBcL5SCvXDs/Tu04u9916+672tY8mSpVx++XUsWLCIffbZk4aGBsaPvwLDjjNm991wTIPGQMPQ9X1cpbAMQYOrx0rWAzFLd+3GLAOlFJWZGDX1OSxT0pj1ovSu60pSmRSGadBQ24Dv5aDcgtrFWltxLUf4hFPKtGnTlqunWxUXrgkPQtvjwjZv87Q0pv/wLcJp5kSL1oTv6dxBYx2+YdFY30gyaVFfnyMRM1lYm0UIh4QlycQMZn72IfdcfTEAX3wxjUsuuaZJDd2gQVtwxRXnsdVWvwFgzJhdOe7YSdzx9zu55y13lXWHRrstEdVfc8IJZ/Piiw9jWRbjx1+OUbkpOKWIJdM47rjD6d27x1p9S1oS8+cv4OGHn+SHH37kzjvvA+DZZ18GFGY8w50PPctmg4dqDa4gXSuEjvCF75QQupPZlOFgdIElAVPi+yqSuAkjBWERuO/7OI6J5+UAiWEZxBIxatv3wrRM3MU/Qb2lO9fCMXotQH7CyfDDd98ut7/Qa10R1nT+92mnncbhhx/O4MGDGTp0KHfccQfTp0/n+OOPB+Dcc89l5syZ3HuvHqd1yCGHcOmll/K73/2Oiy++mPnz53PmmWdy1FFHFVO4awkLFy6kZmk1To/S1l7KihEYelgxlOcST8VpbHTp2D5FXaNLacLE8xWNno8diJ4nLAPTENx/2w088+TjgJ7v+vLLr0fZDtM02XPPUVx22bl06tQB0zS56KIzefnlNzj02DOwL395lcuyeo/B/fIhrrrqZu7+x/UcccRJvPDfN6C0D6phIbmlc7jszjtWm9prS/j00y/4739f4+GH/8MXX3yNtJM8/vjTAFglXZjwygd07tJVC80LyAWpRlMIssrHMgSNrtKGXtbDMiSu52NbBr7SjRuNOY+c65NIWBiG1I6vIXFiDm7WxU2W4Dc2BHI7rnZ2Ya0ZfQ0kmfr5F8vtXxUXrikPQtviwl+Vsef7Pj9O/wHRaz1pkTcsyDUi40myDVlcV3/Jsjk/GI+mB3L7CpJlOtxeVVXJuHG7scUWA/jii6944YXX+PLLr/jo06/Yc6/DefONCfTt2wvQM31vu+2fuLPfweo0dKXLENJAdNmJTz79N1deeTMHHrg348dfDm4D3qL3cRtr2X//vdbJW9JSOOHEc3n5v68jTRvDSWF03QXMOPw/e+cdJ1dV/uHnlmm7m900SCEBAqFKD0VAiqiAdEUIgoCiCFKk+hNsKBZERBEpAkqTIkivSpDQQg+hBkJCet1snXrbOef3x7l3ZjabbAq72ZL78LmfCTN3Zs7Mzrzznrd8XxlgZIaz6Y67a9kaqVM7vpQIpbAMQzt8VSr8kRFIWEZ592dZBgjK3WsAmXQCyxIIIRFCkUya+L7Etm2S6SSWbRF4AcaQjfGl0JFd3+m212ykBrNgzrxONSNKdRyPtyJrq840ceJEmpubufzyy1myZAk77LADTz31FJttthkAS5YsYf78+eXz6+rqmDRpEueeey677747w4YN4/jjj+c3v/nNWr7CmDVl5syZpGvqwep9odtORGUMCd2ckazJIIWktjZJ0QkYMThDIBQ5V1BTq891AkFt2Hg2ehMt4Lzrrjty8MEHMmbMKN588x2eevo5mpY388RTk3nvvY949dUnSCaTGIbBIYd8kQ//9DdEdh5W/WarXlpqMOaofbjppjs5+OADOeigL/DkU89iA2rJSwweMpgDD+w/tXqlksNRR51CNldASkGifjTm2ENQXjvYtZipeoZuPBoF+IEkYeoJQkIKpNJdzTLoaB9MQ2c4hBuQTlqU3ADLNKhJ27T7AsOAurok7YFEmIJUJoUtbEpSaU2+INAzdX1XO3094fAl6/lw+kedru7KFq6LSl1fsoUbVM3e4sWL8XwPI9mw+pN7G8PQO9tUDdLzSKaTuK52FEzTwLZM8q7A8fW0jFGbjuOyG+6hrQg33/xP/u/Hv2bQoEFMmfI4Z599GjLwkMrkkUeeKj/Fl760Hz/+8bnIpndRQddOhVmzMebwnbn+htsqU0XMBKJ9Nslkkh122K4n341uZ86c+VAzEmPUfpij98dID8FINWDWbIRhGBx14i91OkdKHCHxhCzX8NimUe5UTlja+bNMysYvItIxtC2jKrqnpW4sK5pjbGDZph6xZprloevUDdNTN1K1nWX/1xEjWY/nuSxevLjD9YFc/bG2nHXWWcydOxfXdZk6dWoHAdPbb7+d559/vsP52267LZMmTaJYLLJgwQKuvvrqOKrXg8ycOZNETR+sXY5qtiwbpBaSVVKRqcsQBJLajI7o2Zae5OAI2aFT0vUlR37jRH582e94f/ocrrzyr/zx6r/xla8cwIcfvMAee+yMsAcze/Yc3nrr3fLT/vSn5/OFL+wFjW+udonW8B2x60Zxw423k8vlsewkSkn87CK+eOC+/SqqVywWaW1thcFbY4/9Emy0O1hJjJqRmCndhPDF435WzmYU/ABfSiRRKYtO4SasSJKlasCAGTW8hDbPMDBNE8sy9XWWiWmZJFIJLMvCtEzt4NcN1l3Y0dSNHqjjM1KDmTVzVqfru9sOQt+xhRuUszdz5kysVP26K7qvT6I0hlvETqfxXA/LMrBtE88XeKFwL0DBk7SWAnba50Aef2M6Dz83lUJQw29/+2eefHIS119/K1L4mHaKfL7Y4WmOPfYIlBTI0uoLis3McNywjsMwTGTz+yinBc/zaGlp7Yl3ocf45WUXkRQt+POewZ/zFO4Ht+K+eyPBR7cjC0t57z9XAeAIgS9lh8hedVpWKq2/JyTYYR2ftYJzZhh6XFN0n3Q6QSplh4ZPO3x2wkZKiZJKp9+rU7dW98zbNEwbKzWImTNndrhercF/MQOLTz75hILoo860aVVqH5IZPd5RSNJpm0AoUraJ42tRc6kUbqC/ozk3wAskgYDTzz6fTxY0khz/NebNnc8PzvoxTz/9P9588x1MqVOEhULFFpqmybHHHo6fX9ZhCsfKMAwDlRrGG29M4667H8RINSA/1coEn346p2fekx5i2LChnH/+GcjmD7Ut/PQx3Pduwn33BsSs+1GBw+uP/b7sTEcpXAhVCkKHToUbXtDZJhOwLT1uLpXQ4yVN02BQbaK82a2psRlUn8GyLSxbl7IYlg2mXWnWMIweadwwkg0sWbwQ3/c7XD+Q7eAG5ezNnj2bmvphvb2MNUPJcnQvKBYwTZMgkASB1KFxT+D6AicMoUsUScvkmJN+RXrjsdgjdG3evHm6g8dM1KKUJJXqmLYZM2Y0tm2jnFU7a0HjOzjvXI90s1gb78rb0xdjbbIfQfNHnH32acyZ8xbDh/eT9zXk8MO/wqKF7zB//jTef/9F/va3P3Lttb9jk5FD2XtMK0op/KqO20hjStLRyEElvC+ptNlH8zUzKRs7FHBNJawwmocWsg6NXtTxaydshBBIIXX6trper5uMXc2g4Xz66acdrlvTbtyYgcN7H3yEmerjGY6U1u1LZVIIIfR3MtDdsSnbIO9JfKEIok0YCicQWos0kGx/8I947dk7sIbviGEYPPHEJP24dWP1465gC6OaY+W0rXJJwfxJOO9cj1E7kpI1knnLXKjfCj+/jLvuuoGnn/5Xt78NPc1ll13MsmUfMn/+NKZMeZJrr/0dV175C5TTyulfHU0gZRhNNalLJMpRPqtsExXJUIc1EloG/fMVbWZTCYuEbWKbJrU1CZJJLTxvWQaWpZ09O2GTqc1gZVbQa+yBNK6RrMMwjQ4pVBjYdnCDcvYaGxsRxmdUdl9fGGZlnEwpi+/5mKaB6wocT9c92JbW0iv6EsdXNDsed9z2E5odF7N+HKPHjecXv7gSgHueeA4Sg5jySsc0RTqdYtddd4LW6Six8kHn0Rg2sfQ1jOJSzHFH482fTDKZZOzY0Qwe3Md/NFaBaZoMGlTHmDGjmDjxaE4++Th+/esf88Lk5/j9b3/Fiy9NxndK4cQMfViGUU5V2KZB5PMlrMoIJtOAlG2WUxfppEXC0sPb00ndrWsYkExWIsxR9MKyLKS3gqPXjRMNhZlm+fKOUVwpK11oKzsGgFZ2zAo0LV8O3S2C3B1UZ12UxEjVoJQiU5PC9yWZlIUfyLK2m1CKki8oCaHHGIaf2YIjePb+X5OwDC79619wXY8HHnicwcM3ZtL/nsa0Erz22lsdnnq33XYikUwglneW5IiQQkeCgvnPopL1WFscwwv//gMAm202lpqaPhotXQ2JRIJBg+rYfvutOfnk4/j+90/mtNO+yQ1//j133n0Hr77+GoEQpCyT+mSCjGWVN7zVqVvQG92kbZblWSLh5XRC3ydha0kWyzJJJCxq63S9cjTBpEy17etmh88wTFKZQWtlC/u7HdygnL3ly5fjye5JifU40YfbdyCZwSk6uI5HImHih51NvpC4QpX/iAVPaMkP2+Kfd/ycH9/8IN/99XXc89QrfPvHd6IatuKVKW+wdGljh6c655zvEBSbUU7LSpdSPW0kKCxD+UXefPNNUqkUkydP6YlX32scccTBfO973+L2G/7IZad/g6P32oZ3XtIdegnTxEBH8EwqaVyrk7HTl7ZldlTlD6+PunK1w2frjL2USCkRgcBIpMLZkatTO157PJXobODiyN4Gx/yFizGsPrjxNUIF40RV3ZsCISSZjI0fFk4lLAPHVzi+nvZT9ANKgaAYBGU7mLRMHF9y0K47cd3DL3Dh72/kgf+8wmGnXgF1Y7n33kc7PHVtbQ0nnXgsqv3TVRbjm/XjKv92GlF+kba2NgBeeGHlI7D6K7/4xcXsussO/OWnP+S8bx7K/rtsxby5s0mYJmnLwjIMMrZZcfrCLEXS0jV86XDDG6VzbUv/f4Qd6o9qhy/VUREiPQjStd2+2a3GStbQ1NTU4bqBbAc3KGdv0eKl0BcN3Koo1+0VsG0bKSSeJ7Ask2TCIhASKXW60ROSQCocISkGAk9Ihg8dysFHfI3TfnI3sthIsOB5gE5jzT78cAZWMg2GgWib1SnCp7xc+d9m3WjEJ3ez1157kcvl+O9/J/Peex/29Dux3jAMg6uuuoyFC97h5Zef4EsH7c3/nXkSTzzwT0xkeS5uNCcXIkOgxZVVOGrOlx27uhJhesMyjLIWX7n2RSlEIBCBTlUpKXWhcuTwK9l9O1szxZx5HcU5y+L1XRwxA4tSIffZ59d2N6uopU7XplEKgkDqNK4vKPmSoi/Ldk8o8ISebuNJgRteHwhJ0jTZbvzWfOuEkzjie38maJ6ObJ+NscImDeCjj2Zh1o1G5hchsnM7OX3KywJgWAmUDHA/vI3DDz8cgJ/97AocZ+VzUvsjtbU1PDvpfmbPfpMnnribTTau46LvfI1XXnmBlG1SE0bjTMMgaVXey5W8reWNbjph6XnjpkFNGN2LmtWiqJ6SSjfn9LDxMezOWY6BbAc3KGdvzryF0NcMXFdEtVqegxBCa7AF2sGTUpGwTGxT76CS4b+BcIYrJC1LK8JLQbDkNWpqanjrrUmMHj2yw9PMnDkH4Tl4nzyAP/e/iIXPdbjdzAzD2ngCdqaBpN/EZZddzOTJD3Pffbdw+OFfIZ3uR+/pGlJTk+Fzn9uGf955HUceeTDX//IibvrNj7Sel23rLlrToCbR+SsUOXqR9p4M2/nLXWmmUQ5ggN7hKqkqzRkqbNAI54J2K3aGlpbmDlcJteoUrpCVTseYgUO2vVVLDfVFooakVG2Hq5WCdNJCKkXJC7BMPdfWFwrHl+FGtxLhKwUCR0h8qbANg7wboPwicunr7LXXBCY9c98Kj694++13Cdrn43/6KP7sJxFN73dcWsMWmEO3wzQtRg2xuPHGq3jppcf5zW8u5eSTj1sneY6+zpAhg9l33z157NE7aajPcMl3vsYLj/+bVBjdS4W/PaZRSema0OH/y7XMpm7YSNpWuW45qmNOZVJIIfV7GI1Oi7IcPYAwUp0ie13awn7+t92gnL18rh2jrxq4VSEFqNARCDvSIoMSffQiZ6LD3ZQ2XgnT5ILv7Y3MLaBYLDJ27OhOTxEVKv/kJ+ex2WZjEYXlKC+PzC9GtM8hmHkf6eIMjjvmICZN+jfnnvs9dtllBw4++EDuuusGtt56yx59C3qTZDLJ7bdfy09+ch4P/eufZLPt1CS0kUuaOk1rmeiURVirYqJtlQidviiNmwrPMQ2DVNJCCFV23u2kbs5QssrQRTV73ejw6d3sCqmLNThiBg7FYhHPc/u+LQx/5A3DoLZWO4BS6fIIP5B4gSKImqhQeqyZkLjh4QmJKwSuEBQDQaAk++9sI/0iNTVphg0b2vHplGLUKL0RvvXWv+jHLSxG+QVkfhHB8nfxPvk3I9JtnP2Dk3nufw9wwgnHsMMO23L22adx7bW/I5MZeBvfiLFjRzPl5cfZf/+9ufPv1yGkosa2qhy6SlSvOiMbbWwN9O2ZpE3SNklYJpm0lvqV4e+bViToxkxGF/hyJSUtqzn6MxuUqHJLSzPUbNHby1g7lITahg5ij5l0ovxlskyj3ClqGmBFNWJoZ9A2DfY+4Ct8bre9+PDt13nvvensvvsuHZ7ixhv/wA03XIlhGKTTaX7xiytxp99Rvv1zO2zHY4/ewdChfVCXaz0R6QguX7qIzUdsRNYLCKQsh/ZNo9KkYZkGEj1rWN9mYBoKGUb2gLDgV4W1etqZL/+No+aMwNdRjmDljTPrhJWmpbljZE8qVW4uWRld3RbT/2hqagpbJfuQoHJZXy+M6iW105Spy5RLHlaUm5SKckOGUgZm+BAq1N1zpSARXSm1IPB3zvk/Jt1zC6+99jZBEGDblZ9A0zR5993nynb2nnse5tlnn8dtq3Svn3TSsVxzzW863G9DwjAMdtxxO155/T5yjoOdSJAwdd1e2jYpyIrNMwwVCs0bKCOsbZZgW5BJ6sheNKFICG0Lk6kkXrFUUatXSqf3uzvDAUgzyZKlHee5d2UL+7sd3KA+sZ7nYdT1A429asIPWKW+S4fCM0kbA8opQdvSTl/CrBTBmoZBxrbIWEmaly7i618/nAkTdl7p00SPf+653+PYY4/grbfeYZNNRtHQUM+WW27e5Ti1DYEvfWk/6hsa+OEZFzLzwylICfNyBaQKsE2DQKgwyqfTtELqtK0KU+qmYWBboDyt1yRlx0OnLkIZFxl0NG7daOwM08bzV6jJXE09Sj+3cTEr4LoulmVjrIeh82tFF+sxDMhkEphhlCiZsBBhqYRUlUhS5OhZUO6eF2F0PWmZpBwtCP/b3166SoctsnX3338zM2bMYvr0T9hmm/EMHlzPJpuM6taX3B85/vijuP76Wznp+LN59X93sSSvFQv8MLKXtk2KvsQ0DCRR+QrYmBiGtnc+sry5LdvBMLJXzmyUj54xQIZpUyp1HCbQlS3s73Zwg3L2HMfrETXu9UG6tpIeiAxeXTpBTcIkZev29kjuwwQsUxfQ1tg2Pz37WyxdvJBTTvntGjlto0eP5Kij+t8g754kmUwyetQIZi5YzGtTXmSLz+3eQSVAKt184VNxzg2jo4GINqrlmsuESalUGdGTTCfxHLfSmNMTqQzD7FRE3tXw7+j2mIFDEAQo1Yc3b+W29a5tdU3C7BRtib4xdlguYRhgKl1PVsi2ccF3voZt23z964evwTIMtt12K7bddqt1eRUDlk03HQOAbJvFzI8+ZNDYLUlbJm4gy12rUb2eK3R0TwUKZYQSU2ETW1TqkskkyGbdcqlSVLrU4xgmuUKpw1Vd2cL+bgf7p+ezjlim6rfO3ooYhoEdCozXJi3StlkRuzRNUqZJQzKBIXxeeuF5DjhgHw44oP/MbOyL/OQnP0QUlnLiMYdw1y3XYptm+QclQinKo4Mq6vKVusqkbWqDEs7HlSszINFuNtrhQjd+bo1O3XKx9MqGRRAE2Ik+us9fyfQZWHnEJfpcVn8+o2+JIpyGEEb9kqZFW+Ni5s+by89/fiENDfU9s/4NgMGDGzj11ImIlo/45mH78Ml7UzsoC6xq0kTk3AVSYRrghd3V2haG9XpKYabCWtIejOppzE4TNAayHRwYns8aIoSgo2pjP8C0wKxIdUS2sKzlFnZBRbV7dnikbBPhOey97cYEboGjjjqk915DFS+99Fq/7Vh7+eXXSSaTfPmrR3HEcaeW3/dISb66k6v6NVbvZKtfedSx2/HKFdMYqnJ9d2CY4fegeh1dG7h++ueKWQVBEPTNkZHVET3DBCuBaZpkalOd6vWiYv/qiQ0VPUujnOI1DG0jZ374Dicc9gVAT8/pbfL5AlOnvtvby1gnlFK8/vo0hgwZwknfP58tP7dLedMrFQipDxn+DSIHT0hV3vRGclUrOvHlzNN6aNAgFHzu+NoGrh3c8Jy9/hbZM4xOa46+EJXLSreTbZphnZ5NTSbDt757FgB/+MP1ve5kTZnyOkcddTL33/9Yr65jXXnk0f8iGrbnjzfdRW3D4LAmaOW6UtUoKqnaTreF11dkV6JO3B5K5RomcoX6v2iQfFdHzMAhCALMvmYHO3lzFaPWeaNbaUrT/68vo42XZRjlHzYDfe4mm4zFrNNKBH/4w3U9/GJWzznnXMKXv/yN3l7GOjF37nw+/vgT8oP34XsX/hzLskKpFaPsxIlQ+7DiLHW0f2W7V3VdpxKjnrY7hokfdIzsDWQ72Me+8T2LFKKzUenLmJbuTgt3uBXDF94c2sOoENk2DeoSNkPTSRoyCWrSCS78+e9JDNmyU7i6N2hpaQOgsXF51yf2UQYPbgDh0F7y8YTu7rPDTjTTqPw9ViSK4FWiftH1lLvQogaNstRKJCoandhdGAYiCFayvq6PmIFDEAR9d9Mbrcu0wE5i2zaeF5RnrJpmpRbPMMAX+rNpRddRyd0Yhp56k7Ethm60EYktj8FK1uC6vS98PHPmnN5ewjpTHo8pHLxw4xiNRYsCrb5U+EIf1U5SuVZPdbSF1ZR19qBnI3yGied1/F0cyHawj37jewbLttdPeLi7MEywbLBsDFMPjDZNA4OOu1rL1MYubVvUJxPUpm1q0xaZpMWQugTSTCGlIpfL9+KL6f8sW9aIkRxEY8mlzfVC4WotaB0NAl9ZDZ++1JUsspzKCIuVpUQKSeAHBH6gx+OJQB/drLEHgBTYiY4jA8vlgV0cMQOHZDKJksHqT1xfRA5etQNq6NmqhmlgmtHYrTByZ3Z0+qLaWKvqu2cYRvh9hJRtYZsmrz56BaadJpuN7eBnYelSvVk3koMo+gJfytCxNkgnzHLN8qqcpMjJW5Wjp0q5ivxUTxof2TnTN5Dt4Abl7NXU1ILo/QjXGhOlcE0L0zSxbEuPlqmK8LmBwgkUgZQIqahNaScvnbAoZFvZatfDsYbtSDaX5+ab/9nbr6hf47lasqToByzKOxQDUa6RjIRFta6U/vtE3VvVqYyCGyBEpUEj6kCTQuoyAylAiJ4rTpY+mZqOkwm6nJ6xmk7dmP7HoEGDCPzej26ViSYFRYRhO8M0MMN5qnrKQsd0btGTHUooDPT3Lvq0RsLnCctg6YLZ7LX/sbDxHkye/DKvvTZ1fb26AUd1ZLTgB7hC4EtVzi4lyhOCOjbXRBtcpfQElIgV07tlG9gD2nodkD4jNx7e4aqBbAc3KGcvU1OLkt0oUNvTSAGJJJZt4Xt+B6NXcgMcX5XTh5HGnpCKlG1SzOfYccvRBAueQxYWI5XB9Omf9PYr6rdMmfIGpVIJEno3m3UEHy0vkDBN6pI2maSWwLFMyn8TCOtXhEQqhR9ISk6A4/i4riCf9xBCVI5iXkf0oqhL9WzcbkJJX296qq+L07gbFHV1dQS+h+oHWY4odWsYBq4nylG8ipB85+5yCBs4TB31e/PVlzlsv13w5z9LlOSdPn3GenoFA49Jk57X/0jUUfAFC7MurY5HQzJJQ8qmLmWRssyycxQ1rEmlCIRu1pBRw4aUFIt+RWNUUVXG0rOTNJT0OnVlD2Q72Ef773uG2tpalnv9KLIHum4lYWMn7HLdCmgjZpsVUeXI2dPnQEP9IAzT1uma5vcYsfFQzj77O8yZM49zzv0ps2fP5eab/sh++32+l19g/+Cjj2YCYA0ezwVn/bF8/dtPXslHy7PYYXopER4rbgLLhi4Q5cie53p4jofv+uHw76rURU/U6wEIn9razjNHu3qafm7jYlagrq5O/0P6YKV6dzErIoUuXXGLGIM6Tuwp92wYBn4gy524Rri5UlSiF7p+T9vL2kGVH3S58Dl232NXjj76UCZPfpnzzvs5Q4cO5v77b2HjFaI8MSvnww9nYGWGYqYaOO8HV5Wvf/+/V5FfElDKe+VNbxSbE1Lhh3NvdSlLpZY5CHRWQwRCl7IIv2MKt6ccPhkwuJOzF4sqDwhMK9m/0rhhg4bneNQ11JFImLhuQMkLGJRJlJ0Lk/CyKk5rWxZavxwCp51f/fLnbL31lmy73b6Uii5KCRYtWtprL62/kUyGdW4r1ngAadvClVIPZo+EXI3K7UKGUT2vksINAllJ3wYCL9de6b6tll3pbkMnfUy745is1XWa9fcutJiOlJ190YecPSm0vavCMAycokOmJoXjBKTDOaqRoxd9xwKhEBZ4QuqSCkuXULhCkPcCcrls+TFF4HH7bX/h449n8vWvfweABQsWdirUj1k1yWQS0+48Azhb8hmUsEnbJk4gw8BEVXOGDMfYBaLs6FVfSimRuWbwvZ6xfSsiPAYNGtTxqi5sYX+3gxtUGre+fhBK9qMvtZ0E3yGRTGBaJkIobNvEtkxdrBx2gfpSlQd/E+oc5XI5LeUB2HaCf/zjLr75zTMoFoqcfumvARg/fvMeWbaUkmeeeZ4LLvg5r7zyZo88x/qmrE1XVQbw3n+uwg90irbo69t9oWfj+kKVU00i3M0WCh6+L3DdgELeRQSiMiJI+HoGblC1q+0BY6ekz4iNOg+AH8jpi5iOWJZFMpnqF7ZwdRN/3KDjdySSOZJUxMzb29o6nPOb3/yZM8/8P5KpNMefeympVIpNNhnZvQsPKRSK3HvvQ5x11v+xfHnz6u/QD9C1xR1rPmc+d3WHqFjR03+XKGUbbXqjcyJh+WLRr8wGr5abWjHD0QOkElVR7pCBbAc3KGdv3GZjICit/sS+QCgqip0kmU6STCWwLAPLMsMWd5OiJ3GFCkPmuvusveSTc3yS6RoOPvQwdtltd4LA580332HBsnZ+dPUtHH7MCdTWDeLKP1zfI0u/8sq/MnHi6dx++7/4xjdO4z//ea5Hnmd9Mnv2PAzTQpZaAHjzid/TWvBoLLjaoEU71HAnG0UdPF+nbf2wISMIJIW8h+/5iEDX6gXFQucUbk81aAQlhg4d1uGqeILGhkd9w5C+awvDwvwg3w6AU/LKTRklr1K074rOH0yhFH5YIyaUIlCSrT63M5ttuRW77/9lAP71r4exN9qcH938IJ/baQKu63L99bd2/8uQkokTT+ess37Mvfc+zNFHn8KMGbO6/XnWN7NmzUXJAOXpruY3Hv89bQUfxxc0OS4S1amW0vOF/nuIaCYuOE5Qnp4hAkEpm+to/6BHo3uWdBk+vGPqfiDbwQ3K2dtyi80xZbG3l7FmGIaO9iRrMC0T3wtIJm1sW88gdHxRac4IxVgUuhbCCySeUNx278M8/uwU/vy3O7j9oWe57+nX+PrR32DE0KF883vn8uyk52ltbev2pX/wwccAXHzxxZRKDieeeGa/39X+5Cfn84Uv7ImY9yTSbWOPIy5BSoUnJFnPR0iF42vD5IQzIqHShdvS5uB5IjRuopzCdQtFXYxc3YUbeLpRowewZJHtthnf4boOw8hXcvT3HW1MZwYP2wjl9zEJErmCDuoKJROuW/lO+EJiUtkPRbpuXtgM5QqJJyV5LyDRMJxbn3iVX/7lNr7/sz/w58emcOFf72Lr7Xdk+z32Yce99uOuux7s9pfjuh6zZs0hlUpx+OGH8dFHn/CDH/xftz/P+ua22/7C8MEZxLynUDJgzyMvwRcKRwgCKct/E8eXobhyZYKQF0gCUbErUQq3mCvq37vqpowe7saVXp6xY8d2uK4rW9jf7eAG5eyNHTuWJE5vL2PNCMekmakMIhAkU4nyhy1hmSRsLebrBnon6whJMRDkfJ9sKaCt6JEtBZQ8wRFfO4499/o8qYRVFgFub17OFltszpAhg7t96b/73U8A2HPPPZk9ezaGYXDPPQ/yySezAfA8v999cTKZNPfcfSObjh2NnPskL919EY6Q5Ujeirs/qcAJU7tKhfp6UpLPueVpGVKG6YrA00fk9PUgCZyVGriBnL6I6cx2W48vR2b6BFH3RfT5D6VhnKJTJbmiHUHX7/gdKYZORRQUCsKoni8kvpTkfB9HCBKpFF874duMH7clYwdlqEvY2IZBrmU5n//8bt3+kjKZND//+YW4rsstt/yde+65h2nT3mfKlDfK3cD98bu1xRabcf99N2EGWfYbvZBP/3cVUikaSy5CQc4VutM2PN/zRYcJGlIpXDeo1OyVpwdJCIKKTexBlFI4hVbGjBnT6fqBagc3OGePoNDby1gzpIBkGlnKYdkW6bSFbZskExaphInni7AurKoZQOl2dk8KWos+BTeg4AZ62HTVh9Uy4dknH2L27Lk98gGOHtPzPMaNG8eJJ57IL395Fb/5zZ8A+M1v/sRvf/vnbn/enqaurpa/33I1QamNn/30JziBIOcHBEpR8GQYVdU/OpUiZEVze0kXJwtVEVD2ApxCSe9mRaCjepHT15MpDL/QydmL07gbHuO3HIch+pAtXNEOhfqikZNXKun6QscT5eCfG+gylugz6gQSX1TkPXwpcYTEFZK8H1AKBIGSmIZB0jJJmCZL5s9m7syPeyTDAbpmD8A0TY477jg23XRTjjjipPLtQ4duzTPPPN8jz92T7Ljj9vzo4rN49j9PctM/bqe55CKkorngI6R2wKXUenpRdsOtcsqh0pxRzBUpT82IMhvQsw0awkUEfidnbyDbwQ3K2RszZgxesb23l7F6DDNszvAw0nUkU0k8T5JMWtihOnkyYZGwDLxA6eheaNQcISgFAqEkudDZyzsBQVV9Sz6XpbVFp1V7YozalClvALDFFlsAcOCBB3Y65+qrb+Tmm+/s9ufuKT79dC4XXXQZRxzxLYYNH87XTvpeeeRPILRT5wQyHPYdFYfrDjUpda1eseCVJ2aUCiXwimHK1ge3oKMZPVyU7BXbV2Lg1GqPmIHFppuOJWn0IWHlaqLPWymLaZq4jqsF5N0Aw9B1e64vy5spJ5Dl0gkRfl59oa8LpMKTMozyaSdQhDW2hgGNS5cA0Nae65GXMnXqewwdOpSamhps2+YLX/hCp3NOOOH7TJv2fo88f3ejlGLKlNeZeML3+d3vrmHHXXZlvy8fRpvrUwoEUhE62pVxaIGUeL7Ogiil8LygHBDI55xydA8pwCutl3EVystRUzuoU4PGQLaDG5SzN3bsWDyniBJ9XFg52rqmMtgJGyklmYxNELaz25b+swmpSIZCvhDWrUjdlVsKBK4QuKET6IXG0DDg6l9fCsAVV/yUZDK5shWsM0uXNvKzn13BSSedxN577w3AySefzHPPPUexqHdwQRDwjW98gz//+SY+/LDvi5u+//509trrUO68+1FOOv087nziVbbZcVcKQYBQinZH4IrQ8Qt/fJRSFBxfd+tKRTbrEPgBvutTzBcrUTynWNWB2wPj0apQwsNziyuJ7MXO3obG2LFjMYM+Vr9cPb4qlGIpFUpYloXrCq2v58tOkT3QEfVoFqsfbriAcuNUoBSeEBSDAD+sKzOAP//4DAB+fXn319I9++yL3H//o1x55ZVliY8//elPvPHGG/i+LmXJ5XKMGTOGn/70Ctra+n4g4u9/v5sjjvgWk19+n8uuvJYb7vkveSuFEwiaCwEFT9JcDMpRvUBoRy+QulbP9US5rKVY1IGGcoo031qxgz2M8guMHDmq0/UD2Q5uUM7e0KFDqamtQ7l9/EtlJcqDwKWU2AkbzxOkUhVZxKRtkrS1eK+QlB05AIneXSkVNW3owmXdCQUT9tibZDLJry7/E/l896Zy7rzzPoJAcu2111bWmkzyxS9+kUwmo1+eZXH11VczYsQojjzyW7z33ofduobu5l//egTDznDfyx/y7XN/zKAhw2hzPZRS5F2dri15uinGC7RBKIY1KUIqWlpKKKkQgaCQLehJGVEThlsAt9h5N9sTsituOzW1dQwZ0lGstpxB6eKIGVhsscUWuPnmvlWHZJiVzY5hgGlh2RZGOEHDjMZwYeAFUT2s/s5FP8SRPYwi6+UpDiqc3KDAl1LLVgFfOvIbAPz4kt92+8u59tpb+MIXvsB3v/vd8nUjRoxgjz32wLa1La+rq+OOO+5gxoxP+drXvt3nHb7b77gPq2ELXnxnJod8/VsEpkXeD1he8Cn6kraSdvAKbuTwVZo23LBBTSkVduLqshalFCq7fL05egDKbWOTsZt2vn4A28ENytkzDIMxm22Bclp6eymrJjJ4VgKUqorsJVAKbNMgaZvI0IiZhq7BixwLnabQYsq6SFlH+6RS5bTjMSecwnX/uAenVOKMMy5m5szZn2nJLS2tXHnlX/n83odxzz0PkUgkGDp0aJf32XTTTZk8eTJbbjmer3/9NObPX/SZ1tCTTHvnA75w0JcZXj8IA8j5Pr6U5EM5gZyrU0RuEI0AqhQiZ7OOjiz4AYVsAek54DtQykIpV6UpVWXkesjgKaeZsZtv2Um7rKtOXFn1emIGDttttx2+50Bf6cit/sxXNWmYpolbcjFNA9cNME0DX1TO9XxZ1hoNqjomZbWYbxjdk0qV5+dKpbAti7Mu+Q3HnHwGr736Jj/5yW/J5T7b+zFjxizOP/9nTNj9K3zyyadstNFGq9UK/OIXv8hzzz3HggVLmDjx+z1SWtMdSCn5aPoMfn7peTrKKhRLiiXyXoATSEq+VonwwmxGwQ3K3a1FJyjbkkhbT0pFIVugmC10lJuK/t2DKKeZ/ffdayWvceDawQ3K2QPYZ689kE4flQGJUhiRkrxlIwKBbesUrmXpSJ6UioRtliN6SkUjg7QRC6TSYXMlyztaoapEfoXkR+eeDsB/J73IxBPOwPPWLbW9fHkzn9/7cK7649+Y8fFM5s1bSGtrK+ldzl7tfYcMGcJ//vMfampqOe/8n5VFoPsa+XwRM11Ds+OVowWlQHecFb1Q6iEI5z+iu3ClgvaCVzb0+fY8fqmkHT3fBaegI3vVRq6HkaVm9tlrj87X90Aa94YbbmDcuHGk02kmTJjASy+9tEb3mzJlCrZts8suu6z1c8asOel0muEjNulbtrB60yMCMAz8YgHLsvDcAMsy8cL5uIFQeL7AC2vzIiIJlmqqP77mCoN0F8+bzSP/vAmAm2+5m0svXfcI34svvsoXvnAU/7z7YWZ/Opdly5bzyFNrpjG688478/jjjzN16rtce+3f13kNPYnjuCilaBImTSWXJsfFE5KWosDxFVkn0A2CvsAX2uHzhSzXV0opcV0d3fO8KkH5qClNqfUW3TPcVnbaaadO1/dEGrev2MINztnbY/fdyNAzxbjdQiRBYFogBZZtEfgBlmUgwu7bhG0ShP8WoXGLCpMlWkVeqqh2JXL+9DmG3tpywsmnASB8j7lz5nHzzf9cp+U+9NATNDW1YG/9TZLbnYQ96vNYQ7YCILPrOZ2OFa8f8+XLWGrvyPOTp/C7313z2d+/HmDTsaN5adL/yLoeQimKQYCioqdX8itOta5J0fUq0ei0QjbsNpMC2pfriJ4UnWdA9jAZI88eu3eWmOjuNO59993H+eefz09/+lOmTZvGfvvtx1e/+lXmz5/f5f3a29s55ZRT+NKXvrR2TxizTuyyy06oUh/KcqwY5fZcsBJafsU0cBxfN2qE0itBGGnxfF0PFulcCqmIgn9mOLM6mqkbRf6iEpfRY8exyabj9HWGzT33PMjUqe+u0/JvvvmfkBpCYvvTSG51LNbwHbGGbrtSO7gyW3jQWXfDsJ34zW/+xOTJL6/TGnqSVCpJw+DB3HjNP0hYWtu1tRQQSF23DFpHT0iF44myoyfC8iHXFXpMpFSUCi759rxuzIgkV/z1I4umlASvlR133HElt3VvGrcv2cINztnbaaedEMWm3l7Gqgn19QCwEviej2EaeJ7ANI1yKrZ6JJd2+ir1KVDpSgvCy6hxQ0qdyjjqa8eFZxoYNaP45a/+yPTpn6z1cvUIOhFqAg7GHjGBxGYHrzJ1ERm5aqyGcZiDt2TKK2+t9fOvDyZOPBo/vwyxbAHFIMA0jPKYprwrytHW6P13QpX/QsGjvb2q4zHfXJEWkEJHL3pYV68aUVi+0t2sCNfe1bE2/OlPf+K73/0u3/ve99huu+245pprGDt2LDfeeGOX9zvjjDM48cQTy409MT3LfvvsRUK09fYyOhNthExDlzug9fYASiVdCxulcv2qqF6gKlG9aokPAMswsCK9Pipp3qRtc9zJOsshjQRWZginnHIurrv2ncoNDYMAnWYxa0eSGLM/9ojdV3n+ymyhPWpvEuk6Xn/97bV+/p7GsiwmHn8kNf58vFDOxjSg3dHlLF74t3B8XafnhvIrSlHuwFVKp3EjYXkRCMg26b/zetr0KjcLKLbaaqtOt3WnHYS+ZQs3OGdvhx12oJRvQwV9VFw5+sBbOrIX1awYhv7C2KYZqpDLcnt7IPVM1orkR0dDF/ldKpQAlgq233Fnbrv734BCFhZj2Bmuu+7va12wvd9+ezOofhByzmOowEH5BWR+id49rQVmeigfvP9RZQZtH6KlpQ2ATTcZQ8I08YQu8M65Iuzyk2W5BzcQ5WohwwDLMsAAr1DUdZgQ6uqtZEJGtXp8N6MCh1KhnR122KHzbWvwH0A2m+1wrOwH0fM8pk6dysEHH9zh+oMPPphXXnllleu77bbb+PTTT7nssss+4yuNWVN22mknLL+tt5fRkRUj3YZBqaAbnIoFHyEkpZLuZPXCCJ8nKl25fpXuXtVD6Fq98v8b4dQhfc3hx57IH/56K3hZgmILixcv4cEHn1jrpR9xxMGIYjNiwXMoJZFOC7K0doEFwzBQycG8+27fbFpraWlj1KhRJEyTdieg3dGTnPwwolfydG2eF6Zug0CnbUH/WUuloKwzWswXkfnW9daUEaGcZsZtsVW5SabDbd1kB6Hv2cINztkbPHgwQ4aPRBYbe3spK0fJDrV7QfhByud1/VfJ05GlKIXhhgKipkFlRmv0UOFOykDvas0wrQhatuCwI48uP+0Jp53Bvfc+zDnnXLJWDt+YMaOY9Mz92LKAXPg/5NzH8WY9hGj5eK1etlGzEfl8ngUL+k6jxieffMr3v38RP/7xr0kmk9gmFIMA2zQohj80JU+nKPwgqktRuL6gGBaTZ9uKlPIl/YtTypUnA3Sihw2eLDYycvQYGhoaOj/1GqZxx44dS0NDQ/m44oorOj1WU1MTQghGjBjR4foRI0awdOnSla5t5syZXHLJJdx9990rNcAxPcNuu+1GoX1Z35Oiihw+zwFHN0w4RYdSoUSx6FMoeBQdvVnyhcQPpJ69KkEondUoP5SKVAlgZVZNoahvGMzOu1eK9Xc/4Cucc86l3H33A2u17K9+9UvccsvVBC0zCJa8gffxvXgz7kO6bWv1OCo1jGnT+pazN2nSCxx3/Pd44IHHSacztHs+lqmnZThhY4bra1kVN9Cb3yCQof1QeJ7ADTt0UWid0eqUfblubz3IrpQa2W3XXVd+WzfZQeh7tnCDtKyHHvwl/v2/GVDfufW61zFM/YE3LRA+pl2P53jUDKohl3ORUlETSrAkbRNsU9fsSV2P5wuFZepUrR3uXLX7Z+gPa1irortG4c/X3cRHH33MWf/3M7bcdAy/uuR8Dj/8Kxx22JfXeMnbbDOe4447knsffBa/oGuAVHE5DFuz+yvhIRe9qF/+ajrX1hczZszie9+7kKbmdo7/1mkcc/zJqHQdXsnFFRITg5aiTl+44TigkifK6SPDMMoOehnTqgqzrufdbGExXzhgv1XcSNcOfnjTggULqK+vL1+dSqVWeZcV/45KqZX+bYUQnHjiifzqV79i6623XvUaYrqdsWPHUj94OMXiMqxBY1d/h/WJFHpjlKoBJ49rGKQyKZySRzptUyr5pEM7mLJNAqn1LROWhS8UKUvPx00bXcczohKMEaM24YxzL8YcsjFfP+4UrvzJOfzkp1ewzz57MG7cZmu87GOPPYLLL/8TC1srET1VXA6pwWv2sktNiOXvYm8yeo2fs6eZPPllvv3tHzJu/Dacfu6P+NJx38YPGzPssKRFKUXJDbSjJ7VzFwUbqp2+UqGEW3IrNczFrJaeWo9kRDNfPfQrK7+xK1u4DnYQ+o4t3CCdvS9/6SAef+ZlembU/GdASTBs7fD5HqTrkIFP4Js6OqSgpiZBruSTSdr4gcS3Fa4pSUsD2zLKCvG2pev7LCo7kqhIOerKzZZ8TjrltLKi/He+812efOhffOtbZ/GnP13ObrvtyPjxW1BTkykvccmSZSxZsoyPPvqEt97Shcxnn30aO+/8Oe68835MO4kMPFBr/u7KuU8g3Bz//e/9bLZZ7//o3Hnn/Vx40WUMHz6cK6+7lV333I/2kk+bqyMg7W5Aa1GUC5GDMH2hFARCUvICiiVf1weZBk4uX6490h2467/rOC2aOOzQlXdIC6kwuqhHiWpV6uvrOxi5lTF8+HAsy+q0c21sbOy0wwXI5XK89dZbTJs2jXPO0TVMUuofD9u2eeaZZzjooIO6fM6YdeeQr3yJB5+f2becPSVBGYBVdgSMGr3pTaaTlEratjhuQDqRwg0kqYRFICRCmggDAtlRksoytP6oFW6Aq0tbAqXwpMHZ/3eZdlQCyRnnXcq0117ky185nhtvuJLNNx/LFlts1iHaMn36JziOw6uvvsWHH37MxhtvxEUX/YAJE3Zi8aQ3y7NhUWtWmqL8AuLTRxi9ySieeea+bngjPxtSSn74w59y990PsP2OO/Ozv97JoKEbk/V9luc9sq6g4AoKjh/W6ekGtSDUQBRCIYRECEWp5OO6ASh0rZ5TKkdt1ydK+hRaF7H//vuv9PaubOHa2EHoe7Zwg3T29t9/f0qti7BHBxhmH3oLDDOUHPAgXatD23YK0zTxPZ9MbYZCwaOmJknR1QYvlbBIJywcX5EwK3UrSklqElZ5lyKq6vgi5y6Q0Fb0sULtvkQyyYNPPMNRhxzIBRf8HIBMJsMPf/g9tt9+a3bddSeOPuZU5syeCxgk64bj5Zfz0ENPakOYzPCDC37EX6+8nKv/8Av2Oegw9v/6T1f7spWpa9meeupZ9txz5eH19cW0ae9z/gU/54RvfYefXH4VnrJYlnfwpdQzcH3t1LUUA4qeoORVZAa8QI9lUgpyOY/WlgLZltDJK+XW+w42QsmAYuvCVRq41XWarU0ZZzKZZMKECUyaNImvfe1r5esnTZrE0Ucf3en8+vp63n+/46ioG264geeee44HHniAcePGrfmTx6w1X/nyQTz1v1f73sY3alxK6KiJLOUwatL4rk8qraf+OE6Al7YxwhIWK1QmSNtmmMoNN7wKJAaEZRbK0EoFpiGxDCvcpCnyQo9jUwrGbL4Ff7v7cc745uFMnKgbOMaO3YTzzjudMWNGs8kmozjggKORUmJaNlhppJdn+vQZvPrqW+y374EI3+edqW/wxMPXM2TEJuxxxCVdv2YziUKxeNES3nnnA0aPHtlT7+4acdNNd3D33Q/yy6uuY/8jTqDd85mXLeIEkuZCgC+0lp4M37+iE+D7Ipz0pJ29IJB4YR2fFJJivojneBWjolTHeeA9jCwsY8jQYWy++eYrvb0rW7i2/SN9zRb2IU9n/bHllluSrh2EX1yGUbdJby+nQlSvZxg6hRGm/aSUKKlwHRfTMnEc7aDVpXV0LxAmIEkKrcNnm2EHlCVJmAa+lJiG7vCVSqdvhVBg6VZ509Q7XMswSCRSPD35VVqbl7Nw/lweeeDfXHXVXzto4Nmb7Ic1eEtmvfQ3zv3+qTzywH28884HfOWwI7ng4kv57hlnk0jVohRMeeR3lDxB3g845qRfrfRlW2O/grKmcO21t3DqqcevVdqku3n66f9hWkku+/01SGWQzblIpSgGAk8IGvM+TcWAbMnHF3oMUFSUHAjtROt0u56B62az4OTWW6fZypCFZdTUNpRnFXe6XXWtIbW2+lIXXnghJ598Mrvvvjt77703N998M/Pnz+fMM88E4NJLL2XRokXceeedmKbZqWlk4403Jp1Or7SZJKZ72X///Sm1ndX3Nr4RUSoXcEoOqUwKz9Wiw5lMAscLx6gFkpStm6eENMvSK1GQJhCVbEe1wLxvaNkkW+m6Zhk2uJmGwYjNtuKxV2bQvGwRSxbM5Z5/XMfFF/+yvDTDsrnl7gfZ/fP7omTAKccexqRJLwBw6OHH8M2TTiabzVFbV4cC3nriSopeQMETfPWEX3R6qYaVwB5/LFunP+GSS3/LwQcf2Ks1rI8++l922f9LfOGIiSwtOeS9gIVtHnkvbERT2snOljyd4Qh0XR5QllgJAh3Z831BKV+qpEiVDFO43TvBaXXI/GL23nufVZYLdWUL10Vnry/Zwg2uQQN0KnO//fZD5hf39lI6E20tDVM7e4GHaZoYhoEItPyK4wS4ntBFsYGeyxqEo7o8oQV+JVp3yhUSN5yg4Uv9/0Iq3ECWNZGEVFoPKVSgVwqGDtuYnXfbk19d8UfmLGnl7PMuAuC0M87h/Tf/w8cv3EggFX++8XZenKqbMb535jmkEyZDGxpIWGb5pdimybBMiifv/RVP/+tyHrm7Y5eRYaexx+zP8I1H8vOfX7ne3/Jqtt56S4Tv4Odb8IXCCQSOEAgpaSr65FxJztEdt4FQlFxRjuo5bkA+7xEEkmIxoK2pTRu1KHW7Hnew1ajCYvbbf7+uDVxXyvFraeQmTpzINddcw+WXX84uu+zCiy++yFNPPcVmm2knfsmSJavVmYpZP2y11Vak0jWovtiwFkmwuEVw8shiDtdx8V0f3wsolbTTZxjghSLnQqpwTnXVqDRZMauBqtIfLW/ipE5BCokIv5+RQ6gMgxGjN2XC3gdwza0P8MpHi9ltz88DcPX1f2e/gw5mSEM9Gw0byn9feJ1rbrwNgCOOOhrLNEI5ltAOWgYJy6Q2YfHkvb/iwbt+wWP3/LLDSzbTQ/nuJVewaOFibr31nvXxLq+Sbbcdz4dvTS3L3Cxq93T6tuThBZKiG5Av+RRKAcWiT6kU4DiVo1j0KRY8SkWXYq5YlltRTr5XUrgAGdnEEYcdssrbu7SF6+Ds9SVbaKg+NRxx/XHLLbfwgwsvIzH+6729lAqRg2fZYCchmYZULVb9UOyETaY2QyqTom5QimHDaqirSVCTshlckySZsKhNmiRMg9qkRcIySNl6t1qXshiUsDENg/pkAsOApGmStExM08A2tfCoZRqkkxZWeJ1panECs8pJiFLAZXmRqksj0jgIO7IcX1Bw9QxEM1S9ty2j7GwaRrST0pJaj911C9f+/ufMmfMWtbU16/e9D/nPf57jm988gzseeJqtdv48Wc+nxfXIuQEfN5Yo+RLXF+QcHy/sQis5AUJIfF+QzbqUih759rzeyeZbtJCy8HutXs+f9RA3/ulXnH766R2uz2azNDQ0sO8Vz2Cna1d5/8ApMOXSg2lvb1+jWpWY/sWRxxzL06/NIzHq8729lM6EM8JJpKFhI6zaetI1aeoa6kimbDKZBEOHZhg6KEUmaZO0TeozCdIJk/qURco2SIZ2MGWbWEbFntmmgW2aGEDCNMvngNblM9B2MGnp2yIbaYaXCcvENHSjXCTcLBVQVYAvld6EB1ILPwupdPdwIMMoY1hig96Mo+/O787/DoXWRTw76d+98a6jlOIXv7iSv910J3dM+YRPWn2yjiBbCmgtuLpePAwclJyAtrYSQujGDD8UlBeBbtLwPR+n4BAEAdJ19Ka3bZl+Iie/3myiEh7eh7cy4+OPOmnsrYkt7O92cIOM7AEceeSRyMIylN87dVSrJNqCSgGBD4aB8IOyAKXvVXZQhahQOVKUF6o8IzLarYJ2vLKejysExSCg6AtcIcsjv4Kq+/hh27wM9QoUldC2QmGaeuTQisYvcvSM8HzDgIRlkk5Y2JaJCh26aOeUsEKHMhQ7tQyDPfbZD9/3e01j6oknnuFb3zqLPT6/DxP23Ju8H1AKBC1FnwVtHq7QjRglT0urFN2AkhNQLHqUSloSIggkvutTbMvq4d6RjtR6HPJdjfKLyMIyjjzyyFWfo9Rqj5iBy8knToTc3N5exsqp7i5zi4hiHsMw8NyKXEyp5NOSc3HCMV2ekPhClS+Voip9S3mz6ksduQ+UwhUCV+rzo2lDZWesqmC/2h4GVTPIo3P0rHKzXEfoh6UdoipCpKjYUNMI72MYJEyThGlSY9vsuff+vPfuh72mO/qLX1zJddf9g6+dcgZ5YYSjOKEl79KSc8mVfFxf4rh6g+v7UmecSh4iEHiOh1tycYoOTtHRUT3f141qhXZtD9d3Cjc3nxGjxqxUTDliINvBPliksX4YOXIk47fZnjnZudjDtu/t5VRQqipcZuqalUx9eadk2ZaWbAtTGMWMHRaVejTUJpEKXFOSsAwsQ4XixtqnNw1JIH0ytoVUipqEhREYpMPdrG0aYcTNAAsMQ2Goyk44rHkO1xYul47/r58nMmKqPK5IoYjslmka5VZ8fb5O9Y4Li2aXLVverW/pmqCU4oor/sq++x3A3+95hCU5n2IQUBKCRe0ebY528gpugBcqw/uBxHH8stRALuvglnTKAin04ZV6LaIHILJzGb/t5xg5ctXF3qsb8t3fB4DHdM2hhx6KctuRbhvmGkqErDeiMgjf1fYwU69F5k2DUsHFMAwyGf0zVvL05jedsDAMg5SlZ2Ukbe2seIGWpRKGgWWCFY6OVEohDQMzdPpSlm7asKpCIVJVIiMGoWYpFbuoQtmraPRupLmpx1nKcldw9FWKzKVlGGUHMtJCzSQsNhk7Ft/3aWlpY6ON1lDDqptobm7h+htu4/vnXcJh3z2PDxsLtJUC5jcVaCt4YeOF0PNtpa5RFoFABILA15Myorm3gR/ohozA01E8EY5Fixpw1qNdlO1zOPl7E7s+pwtb2N/t4AYb2QM47dSTUO1zensZHSlrAqgw9eeD7xL4AULoL5Tn+mX5gXzRp+Box8/zhR4EHu4oo0snkGUdKl/qMTeulBR9QaBkeQJE1LEbCFne0ZaLmcPIXlmdNDroqE4ffR0sM6pRqXiBUfrDtgxMk3IkUEcHYcEiLag8ePD6DZHn8wW+//2LmD79Y84890J8pVPcTiDIuQGWaZB3ApyqiF6+6OM4PqWSXxZ6lUISeAFBrg0KrboAuZd3g6p9Dt899aSuz4kjexs09fX17L7n3si+ZgsjpKjYRSeH7zjlTEIQSLJZV9eHObqb1g1Flt2wjtnxQ6dLVjIf0f9H0TsVRvuEUgRKO2da/1d/9hWqQ6dmlOmIHLrIqQuE0nXUgQybRVT4WDq1q1Dll2KGnmGUMrYMne0AmL9wEbZtd5C9Wh/Mnj2PY475NoMG1XPA104i5wW0OQHZUvjeujqT4TgBuZweB+l7fidHL5qSEXhBxcErtOnDLYT1y+vPriglULl5fOMbx67mvIFrBzdoZ++YY46B4qK+oyCvZFVLetSZa4LwkYFfMXB+gOf6tLSUdPqwFJTTi1BJ5zq+LDt8nqhy/JROX/gyTOUqhRAVoxRIRRAarsgQAuXbKxV7K3sN+sKIXMCwpiWqjYlStqah62VStkXS0pczp78HwIQJO/fQG7xyLr/8ap566jluuvWffPHLB+s6vEAfS3M+81pK+sfDF/q9DWTZyXNdvcMttBfIteUotmfDwvIoquf3WlRPCQ+Ki/TnvKvz1Jopx8cMXL5zyomkvb4zvaYDUXNTUIkQuaWoUSPc6HqCUsmnOetS8gJ8IXECfbQ5AUVf4viynNKN0rtlm1Zl54TUDW6RnYs2wbLqR1+GDSBB6ORF48K8UFdOSFW+jAr7TVOXtuh/V2qlo410wtKbTMs0mDvjA7b/3DbrvXb5pG+dRVN7kT/c+hCJhqEUfUF7KaC95NGa98jnPYpFX18WdIo28AI81ysrEEihteGEEMhSTqdu862VeeDVv3HrCZlfTENDPbvvvupZxTCw7eAG7extu+22DBs+Eplb0NtL0Rhmx9quMKqHr4tao1B5VLsH4Lq63T0ycu0Fj5wTVEYHhbtXL5DlnW10nSMEhbAurSREuejWD2tdAlHRjVPRDpjwgx95ddVfhBW+DKZRSekmrCidW6mfMQxtAC3TIJUweO7pRxgyZDD19YPW1zuOlJLHn5jEkcedyOFfO56mrKvTtX7A0pxPU0EP+1ZA3vEplnRELx8avkKuRCFb0H8T19cRvUKbllvpZWRuAcM2Gsk222zT9XlddeKuJsUbMzA46qijKLQs6Hs1zBEi0I5eiFt0wpnhBr6vm6M8T+jOXF/i+uH88HJ0Tzt+7Y7ACyoduVCp4avGlxIpKdczRw6hUJXIYLTx88LMSRCqIvhClZsXVvzulMtaynWE+vmTpqnLZQzItrfwxpTJbDp2/cqCzZkzj48/+oTjz7mU0VttTykQNBV0x21LziWfdykUPEpFn1LRRfjh75EQ+ndAqnLq1vd8LZwshf79cot689sL6VvQKdyjjjwS01zNRJUBbAc3aGcP4HunnUyiMLu3l6FZ8QugwkaNsEtXSt2kIYWuq/M93agRGblIisUwjPIINS1BQDktK6SuLYkMTSQU7EuJI7ThkpJKoXOgO2cjA1dO7cpKIfPKon3RNdHUDgWEuqagKnUvpqE7gD944wUmPf0Ev/71j9fTm6255pqbWbpkKad/9zSUoqwJWAq0pl7O8Sl5gpIbUChqFfhSKcD3JZ6ju27z7XmKbW26IaPQpmtTfLdi2HqJRGE2p592ymrPi9O4MaNHj2a7z+2MaJvZ20tZOUrqza/naKfByeGWXHKtOXwvsoFalqro6kyHH9otqaDky7JN9EUl2yGVKk+6qLa+SoGkYtu0k1dx4CI7KMONbhTZK9vCqooX0PbOwChLWyn0zHKpFElLS2sZhq43vPuW61iyaCG/+tX/rbe3NwgCLv7Rr7CTNZx67NdxhKDN0Sncppxb3tyKQOKWXNySLi0KouZBISr/L6Vuxii2QzEHpRU6btf3qEgpsItzOeXkrstZIE7jDmhOO+00nJbZfWNHGwkqV8eMldI7I9/RrexSlTtzdTpX11J4nsDzw6HggXb6oroUCGdAVqUstLOmGw2EUhR8ndYtBAFuIPDCHasfOoCBqMgHBKLjbrc62qfo7PhVInxGOUKonUDdFDIobXP2909jwoRd+PrXj1hvb/fzz0/h17++mov+7yd8bucJZQe3GAhaHZ9MwtT1eY5PruSXU0XZrEMhW6CQLeBl25HZZsi3VLrMeqnzthrlF3FaZnPaaaetwcmrSV30bxsXs4ZcfMG5pIqf9u0fNd8t6+5FeK6H7wvyeQ/XDXDcANcXtBc97YSpSOJEb3x9qSqZihVeaiSZoqBcb1eO5pXTuVEDRpTxUOUZu1F6V67k+xNZRqUob6hdIbHMygi3ubM+4ea//pEzzzyVLbbYrOffz5Arr/wrk5+bwg2334OrEhT8gJwbpnCzDu3tDvmcjqZGenlCaGmVKADhuR6e4xGUijp1W8pB4FaabJTqFbsos/OoydRw4IEHrv7kAWwHN3hnb8stt2SHnXZFtH7S20up1OwpWSlINgwtweK7ulEj0I0aUX1EEARks27o7GlVc9fXDppbVTOiC4xDx4/weiopVV9Kcp6PJ3QDR94Lyo6dkKrs8EXRvep6l0hwMoogVvuqpqGlWSKHL9rBgj7HMAzaszmWLVvGGWecTCaT7tG3uKmpmSeeeIYFCxZz8cWXs9uEPbjo0stozXssz7q0ez5Zz2dpzufTxgK5kh82Y+gpGbmsSyFboFQo4eQLVan2MN3eByJ6AKJ1BjvuvNsqp2ZUE6dxYwCOO+44glIbqtTU20tZOUqF0b2S/t9iO07RwS26eI5XHtXleYKSWxGdjxrXItsFlcka1ZjQwdGttlOKKk28sqMYdtdW3162jR03vVFET4b10DIsowHCNLDEwGDhPJ1lOuec73b/+7cCs2bN4amnnuXDD2fwpz/9jdPOuoBtJuzHkkKJNkewLBfQlNXNMMWCrpGMGi+i2rwomue5HrJUCKN57ZXmNN/Vjh702gY4UZjJD8/5wWpTuDCw07gbrPRKNRedfw4/OO/HCLXzKqcMrBeM6l5/oa1PlMaVAkwrdJaMcn2EIQyCUMw3kTDxAkEyYSKkWdUppqNrCZMqJ62Sqgik1s8DMKTCl4IaG4q+IC0VQprYlu6itUydjjCV0l20ofNmKAPTUJWULVXPJSsp3YRlaK2r8HtvGrBs8UIANtlkVI++vbNnz+PLXz6O1tbW8nXjt0pQDOsf21yPNtdjSdZjWd4nGzp6XpgmKhR8PTZOgVco6ro8rwS+t967y7pCKUWy+CkXnX/VGp/fVTSnT0d6YrqNuro6jj76azz6/IdQs1FvL6czkYyUFOAUIIzQFcPPZyqTwvP0lCHL0ofj6/SuaRr4ZqVeLiKQWugddBq32h1QCqShsCKJlcihAyz0vF3T0AnZyOEDMMJNbKShV47mqaruXaXCUpZK168XSJYsXkAikWDjjYf36Fv5xBPPcMqp56KqxmAGQUDOC2gqeSzOeizPOixtLrJoYVvZ0ZNSBxhUFB2VEhmISkYj8Cqp9nKWo3ciegDKL+C0zOU73/n2mp3fhS3s73Zwg4/sARx77LH4xTZUqZdHBnWoa6gKkUmhd0hesRwyj3SMlNRdT7ZtEAS6MDlK50b1KVF0L6iaFxkZH6hEp6O6FBXuOj0p8KSsqL9HR2SwRFWUL5IoCHewVD1ytfNnRN24pm7OkAree2cqhmGw7bbje+yt/fTTuRxy6AnkXYPktify88uvAGDWzBk8eP/95N2AZsdjad5jcdanLe+SzbtlseRs1iXXVihH9Si2gVPUjl4kkdMH0rcAqtiIX2zn2GO7lhkon7+aNG4/t3Exa8G55/wA1T4LJYPeXkrXBJ6W8Ci06RIK0EK+YXd8+fC1DEv1aMhqIl28qNO2uoYPOm+OO0y9CFO5K47Uim4jOj+q75MVyZdI8N7A6BABfG/a22y99ZZYltVjb92TT07i29/+IVbDFvz9yVc59pu6rveOm/7CjLlzWNDm0Zh1WdJSZMH8Vp2a9YOKvEr4mxP9DuGFG18nr1O3ZW3RyID0nk0ULTPYdbc9y+PJVsdAtoNxZA+ora3l+IkTeeC/U6FmRG8vJ/xUSVBG5YgEek2LwDQxTAPDNJCmxJQmnidJJiWeF+DYJumkheOL8m5ksGkjTB3li2pEfKGjc1IpjGh+pKGlAJBarwoiUWWJEUYeLVMriygz3OFKhWXp9ejxagqljI4OparOTBvlTLVlGrihGOpzz73MUUcdQjKZJAgC5syZz9Sp77L11luy2247rfZty2ZzOI6L63qMHj2ibDDffvs9vvnNH1A7aDCPPfcMY0aPRkjFAYccydSp09huzy8wp71AU9FjYZtHc86hKeeWo5JtrUUK7QU810N44Y9MNLczqkfpI44egNH+McdNnEhNzZrJNkipMLpIUfT39EXMmrPvvvvS0DCYtvbZWEO27u3ldKY6uhf9vxQUc0O00lOYadDRPZP2goeQCRRa9sQydfOabRqh42fo9G31U6hQc4/IZoWi8AosDJShkErPhay+bySzHNk5oRQmRujs6Q2xkJX0rrlCEsk0wAsCWlrbePXVt/j85ydgGAalksMHH3zEp5/OY5999mDTTbvu0lVK0drahh/q3o0cuXH5tnvueZDzzvs5ex30Vf5w7W3UZFLs+JtrOfDoE5nf2EgxPZRlrR7L2kq0tBTLjl5UJx41CarI5kmhayh9T9fnBV5FRL6XHT2d4ZjFhedfs8b36coW9nc7GDt7IT+66ALu+9eeWBvtgZHonbmsHVjZNsL3wCwhrQSBaWCaJmZKO35a0TwgkTBJJLQmXNTmH4S7SUuCDI2cZWrDFWgLph26cCdqGQYS3alLILEMgVIWKImyzHKDhRnudspGS0kwInmBMH0bvoyyKGmU6qiSZTn0yK/z1OMPcfrpF3Lxjwaz+eZjmTlzNsVCZZzOQQftx9lnf4cJE3ampaWVzTYby5Ily7j55n8yY8Ys3nl3OsuWLiufv/HGG/PEE//kv/+dzG9++2e23X4nbrz9X4waOQonrGkcsvFYdjlwY1odj2V5l7ktLsvaHRrbHbI5HdXL53XRcamtrSyBg+d0nnXbB+r0AJRfRLTM4P8uvnvN78Nq0rj9vTI5Zo0xDIOfXvojfvKrqxCDt+rdspZVsaLDF3hQaMWxLF2XVXb6jEpK1zTIJEU401YfdtisYQpF0gJfgmFp508CKL1plYbCUNqJ1KncSvpWqjDNG95mhCldfX9QRrVGn3YMjTD9q0+JHD9tl08762Lef/sNDjvsm2wyZhMGD27g449mlMempdJpjjryYC655Ifl+uZRo0Ywdeq73HXXA8z6dC7vvjudXDZbfrv2+vzu3H7bX7jiir9w5533c/Txp/CT31yNnUyiULS7PkO3+hz5jcYzr9VlcUuRJcvytLUWy1IqUUOGFFWah1E2wylU7CH0mY2vzM4loYI1znBA17awv9vB2NkL2Xnnndltwp5MnfMBiVF79vZyOnblRqlcgMDSnbl2EmFrjSPTMlFShXpTukDZS0lsS2ILgyDczWokpmEipBGmUbVBC6TENs3yrjba2ZoGOIFEWnofK5QW/4yickppoxqlNnQUUO+cy88YGbqooLn8GhXKNKipreW2fz3CrI+n8/jD/2bJkiV86dCv8bmdJ7Djrnvw5KMP8PC/7uDYYyudpSNHjWTpkqXYyQwqvRGnn3oSn9thJxoa6rFti3PP+C577nkIhmHwrdPO5Ce//B3JVJr2kpZSsQyDxqJLu+fRWPCZ3+qypM2hKevQ2laivd0l316gmCviNS0ODZyvL6M6lF7SjOqKoOl9JuzxeXbaafWR0IjVpSj6e/oiZu347ne/y48v/Skyvxhr0PrVeltjVnT4sk1Iy8YJZUwioiifbZn4gcQ0dE2fGyhGDLKxAoVlhLO8zXAOrhn+MBoGEoWptDOnsxQ6ywFmueksGh+kpVUIJaaqhJqNsHFjhZfQMVCkd9BjNt+Sh56bytRXnuelyc9QKhY57BvfZoeddmXTLbbi3luv49abb+bf/36sfM9tttmKGTNmksgM5otf3J/v/uArbLHVtqTTKZobl3HphWez3Xb7UjdoEL/4/V/4xonf0Q0rQukaPcdlYbvL/DaXRc0FljTmaW0p4hQcfM8vO3sqmoRRFrgOQAbl6GpvzgBfGYnsh1z644tJpVJrfJ+ubGF/t4OG6u9Vh93IpEmTOPLor8NWJ2KYid5bSNSoYRhljb0ORyoDmXrMTC21g2qxkzaWbZFIJqipiY4kDbVJMkmLTMomnbCoSVrUJEyStp6Hm7AMklZFyd0KZ9QaVA/qNkiFA7pNExKmiW1oQxepvRthDR7oCRlRdC8i0uUjqn0Jo3ymoZs+Ugk9YcMMh25EX7ggLB7Wu+WApx55gFQyQUNDA489/AD/vv9+/vzXGzh24kllYVPbNKhN2SyYP5dnn53EHp/fj7HjttSdeb6k5AvyXkAxCMh6PouyHstyAY3tJZZnHVpbS7Q0F8m2ZCnl8roOJddcSdVWG7Ny2LJvGDclfZh5D0889jBf/vKXV3t+NpuloaGB7X70MFaqdpXnCbfAR1d9jfb2durr1+8ou5je4f/+7xKuv+0B5JhDe3spXRPJVZkW1AyGQUOxaweRrkmTrkmTqU1RV5ekri7FoNoEg9IJ0kmLVMJi47okhgE1CZPBGUvbOlvbv7St2zIiu5QwTUyMslyUaRhlO2hVOXyRvh5UJFuscExate1bWcDUNsyy+LyBjj4GUpUzIFGEsq15Oc889QTDNtoI4fs8eM+tTHnlNZ5+4TU2GzdeO6XhOmzT4L1pb/HJxx9y4FeOoLZhsK5fFIpCENBUcpnf7jK72WFxS5HFjXmalhco5AqVWj3XrdQlu0W96S3XKKuOdrGPZDhkYRly3hM0Ll3MkCFDVnv+mtjC/m4HY2evCqUU48ZvyyJvJPbwHXt3MdUOX7WjZ5hgJyFdC5l6ahrqSaQS2AkbO2GTTNnU1iapqUnQMChFTcomk7RIJyxqUzbphElNwiRtGyRtE8uEROTshQ4eEDp64Xgz0yRlmuHu1ywfkZNoGB2dvCi1Gxm3KD1cvWuK0rhRWsW2zPI0DSnDzrWwYw10M0fU+Zu0TFIJEwMDNxBIBblSgEKF6RqrHKUs+YKCo9PaOV87ea6QtLs+i9o9Frd7tORdWnIubW3a0WtvbsfJ5fU0jEjTq5e7ytaEYPn7bJJaypxZH69R+i0ycNtevHpn7+M/9l8jF7P2LF26lE3GbIo9/ljMzLDeXs7qMS1IZiAzCGqHYNfUksqkyNRmqKlLM2hQkkGDUjTUJqlN2aQSFumkRW3SojZpli8jZytpmqFdNDEJnb3QaYtsXyLc4UY2zzB0d6+KFA6MSllMhKwqe4maMyIbZxja4RNKkQqzJ9Gm2DAodw0nypvsym2RjRVVGqhWmMY2CGujA4njC3yhhfRbPY/FWZdZTQ6Lmgu8/1EjhawunfEcD9/ztTiyV9J1yr6nI3uRcwcVg96HInoAxqJnOfUbX+bGG65bo/PXxBb2dzsYp3GrMAyD317+C04/63zksM+VGxJ6hWg2bkT05TIJtd0cMC18L4NpmZimiTAFQWBSLPpl0eKkbRIIk8DSkzB8qUIjBtKX1CTNsvCyruUzyg0cUoE0QKI7dJO6EK/clWZKSFkWtmGgIt+UigZVRaBUdUhjGGjnUIVr1Pp8smzMOghbUhEyJfx3YCmKnihHDKN6FyEV0gQhA2zTJOf4WIbBkryDZRgUAz0Zo90NWNTusaTdpTnn0pJ1mD+vlXybFmotO3qlnO6CDvrI7OQuUEqSyH7I7/527VrXWcXSKzErMnLkSCaecAIPT3obMgf29nJWTyT74RTAMAjo+Lk1DLAsEzs8TNPACgyKRsVpMg1QyiRh6UaJpG2SNLW9lOHj2aaJUIKEMssNblE61xcSyzBww1FpoKWtlNIRNiOMDJroTEjlW6rC5wZPibL4fSLcYMuwPCba/Coly45gytavJbJ/vpDlSR3CUBDoCJ8Tzvp2hMA2TKY35Znd7ACwoKnAh6Gj55ZcfM9HeY5+07yS/q3xHJ3d8F06qUZAn3L0pNuO3zyLS37837W+70CWXomdvRU4/vjjOfe8i8i3zsQa2vVM0fVC5PWYVscaPt+DVC2+45Q7cw3TwHM8DCNFEOj6vfaCpw2cMChIRTph0e4IpDJJJ0wcX5K0dU+ZZRiYCgKhdKdtJEsgdG0d6B2uMiQSnf51hUCZFkYYiYuMUvWOthzhCzHQzqGN1tsThtamqtxeIdLok2Ea2Agfv7yhVFrrSYSOXxTRcwJfTwTxA/JBQNEXWAZ8uKzEsqyLaUBju0Nru8OCeS3k2/O47W1a+d0wtSho9SzHPo5snUlNyua4445b6/sKofR4ga5uj9nguOznP+W+f+2APWxXzFRDby9n9XRw+ExEsQ2H0fq2KA0a6oWWvIBhg9IYhkFbIDENg6IvSYclLumEiZCSvBLYpkE6YWIbBilLS7OkTBVG9ky80Bj5UqLCSwPd4KZCp82XofYe4aWkXCZjYiDLSgWVTa6htH6pZRgIFTpxSHwZqR5oB7O6ZCaajASVqKIjBMVAC+W7UtJcCJjb6rKgqcDS5XmWN+qRj07R0ZE8P9TJc0tgWfqyWlqqj2c4zOZ3OPKoY9ZYbqWarmxhf7eDsbO3AolEgquvuoKzz7sYOXg8htlzekerJYruKalrgo0qKRYs/YU0DDyjY1GyZVt4nkkiYeH7gmzRIxC6bs80ojFlld2sIRS+gIRVMRCBVGFKA+ywAcMT2pilLBNDN+oiAalEZXcrde2cYYBXlbItp2ONSopXgN52Su1YBkJ3ulnhTtVAp0XCLIVOV1QJNKMi46afyBUST/r4QhEoiYlBPgjIuQFtpYDlhYBloX7UssY8uaxLtjVLMVcMI3n58nuqld/99fFX/swoKbBb3uaa6/9MIrH2taZxg0bMythmm234+rHH8cTkqbDJQb29nNWz4sZMKUTzYgrOEEzTJG+aWJbOfNTXp7EMg5qUTTpp0VLQc2lDJXuKvsQ2dU1zwjIoeBLL1LYvaRsI20KogKRl4gt9rid0k5srtCPkC4mQkEnqVHBU/2dFncKh82caRofIn167jtYT3q7r/mRZiDmqAzSU/jmIbKQIN9oKhSckpUBQ8AMU8ElTiZRtsKjdY/7yAouX5Vi2pF3PF3Y9rZcXZTI8p2PHbfh+9mUnD0A6LQTNM7j6qofX6f4DuUEjdvZWwimnnMIvfvUbljZ/gL3Rzr27mKjrDAlGleMZCS2HTRyuYeCWXFKZFJZlYdkWyaTAtk08W2KZompcmXaoXKGoFSZpW5GydWetbRlaPA8wwzmP2CY2OhWhlJZxkWH3WtSc5irZKaqnlE5jRIXNkdGyyylfI1RiR6ccVEV5PnIYo3qY6sHhRlV3mx/uYqNLT0gcIfGlNnRNeZ/lhQCpoDmvHb2ly3I0LcuSbckiC226Js9zKoaujxu0FRHNH7DxsCGcdNLqB32vjDiNG7Mqrr7q9zy85XisITti9sWpGitSLcdihT9vhkmu2dQzdF2fTF2m49hGoOQJqEni+IJ0wiJlGzp9qwwKHuVmNscX2CbkLIGQkAojgTqlC57QNXFReYovFAVPlGv1bEufn7LNckOcWb40yrXSUUmNbZgYhgLTDG2gtnWmoZ3LtG1iGWZ5JKZlmLhClEexLco5SBSL2n3mNRVZ1FSgpaVI07J2PaqyuR1VaKvU4kWKAytrSOsHWM1v8a1vf5vx49dNoD9O425gWJbFjdf9hW8c/03U0O0wrGRvL6mj1AdURqn5XqW2L12HW3K1w2TpyF4iYWkNPsvANAWB0BMx/ECSSVpVI1RMHKXKRi1hGZSkJJ3QjmZgaCOl0w1SGx9RSdtGxctRrZ4IU6tQSV9YpoEK12oYiiCUaAmoNIUIJXW0MSxe1tep8m1RFC9QshyB9ISuYYmcPDfQ71NbKaClJGjOezS2OyxelqNpeR4pJPn2PDIfRfOKHcVA+xFKeFgt73Djv/+1zqr7SnYtGNrP3pKYbmTTTTflB2f+gFv/9SSypo935kZEIyZFAKpEpODuWnaVDl90GGSLPvU1OiKeSujvkFImRSAVRJkGg6JP6ACqciNHwdP/9oXSTl/YmOELXbtsmwYlvzKLHGBw2iJpR5FDiRMoahJ6JKVlGGEXsIEKIGVbCClJmGY54+FKiUk46s2PmjsMbMPAlRI7zLBk3YBleR8hFc+9sxiAxmV5rTTQ1gb5Zl0eVMzqSykqNrAfNKStiCwsRbbN53e//fU6P0ZXtrAfvRUrJXb2VsHhhx/OVlttzUfLppEYtVfvLqaczlVVX8KqeLNvVqwX4IR3My2TZNIkCFvtLdOgOjEZ7Wyj3Ww6YSKVNmqRJItUkiJQkzQJpKI2aWEqkKHBkVR2oVEBs6py9JTS3WMSXfMgDIUvjbJ8QTGQ5doVO+wG9qSO4vlS35YwTfwwhREoWdYMLEqh08VC4oaHYUDBEzTmApblPKRUtORdmlqLtLU5FLIFlFQEhZzuMItSF/1sBxsRNE5j+6234bDDDlvnx4jTuDFd8ctf/oKbb/k7KrcQa9CY3l7OmhF9l4XU/86jMyDmcIxQkN4teeRyHvX1WoctaowoOD7phEUyYVFQiqRtkbB1d25RJzpQyiRQ2rHKuTJM9QZlh08qhW3o9G80Is0PJCnbpODqeb22qRvoahImQiqc0BYmbYOUZVL0K6ljV0jqkpaOLgY6zRw5maDlYzyhN8U5V9BSCmgrapHjT5dmWb68gBSS9uZ23LYWyLVo+1f+TakqGepnTh6EzTPNb/LDiy5ixIh1n4IVp3E3QAzD4KYb/8p+B3wRNXwHjMSqpSnWC+UvnwlqJQKWgQueC4kkKIUDesKGaWInbD3OzIBkUv/JHV/gJixKCYtMshIRKvqQsvROViqdvkjbBp5Q1KctAicgExqnhGXihgZMBirsDtPRPVHuKNO7zUiawDIqu1fTNMq70PLM3DAqGO1URehAGhAWOuvX64ZpCldIiuG0kKIvaSvplG1LKaDkBSxuKRIEkvlzmgmCgFK+hMouh0K7rs+DflObtyLKL6Ca3uOmh5//TJMO4jRuTFcMGzaMn/30Un7/578h6kb3rkrBuhCNmsy3Ik0LxxiCU3DI1GWAyqY3m3WorU2SSdsEQpEOO1zTCYUoKdJJKyxlATe0mTq7ICl62t4VLd0glrZNSkLiBhIvENimieMLWgsCP5C6i9c0SNlaFiuTtLBMg5IvsC1Tp2dNcHxdYhN1/tYkTAqeIG2buEJHFaVSBEKRtE2WZV0ySYvmnEtr3sUyDT58bxEiEOSXL4e2ZdrJM8xw3GNVN63R/5y8CJmdi+m2cumlP/5MjxOncTdQ9tlnH7761cN47rVXUZusXqR2vVAW9KXy5Qw8sBKdolMlw8CyrbKzVwkIdk73Ob4gk7RJ2SaupzvXkpZJyVd4ttahaikGDEpZuIHQ9SklgQjlAIRS1CZN8p5AKUjbWi+qLVD4QpVr7myTsmMS1bskw7bfSBbGMHSUMKphcYUkYRoU/ICEZeIEQtfZ+IKCp19vdNlWEmRLPu1Fj0AoHCdg8eIsTtHRQ7yL7bpbzyv1WycvIlj0Eocdfjh77733Z3qc2NmLWR0XX3wRf/nrDbQ3T8cevkNvL2ftiRy+5oW6TrduCEWlUFLpBi2GIMOpEkEgaRMOmUyC2kyC9oJHJmnRXtSXNSlb18slLLywbMXx9eZTCL98m5QKx9cTO1pyLo4TkM06uK6+zrZNMpkE9fUp6tIJEmEtX8kTWJZ2BBO2SaMbkEnZeOFjpWyL5YEoTwVJ2CZFN6Ap65C0TZpbS2SzLpZl0NqUJ9eWQ0kFxXbt6K2qXKWfOnpK+FjLX+NPf/zDZ9a/i529DZi/33wjm22+JWrQPKz6tW/l7lGUDJ2+aJfWMQSvDAMnFFu2bAvDMCgWfWpqEmQyNqZp4AeStJAkbQsIABspFQmlDUg6oe/nlwJqUxatxYB0Qqd0A6HrUPxwh9lWEiilU72+DHRqwq9050ZOXBTlyyT0RI+EZZBJmKQTBtlAkQyLoyPnzw9V6BOWgecEWCYUff0ai74k6+gC6GxJO2+uL3B8QTbv0dRURAQCEQjdcda2rKMoaD9FZOdhOUu45aaXP/NjKal/9Lq6PWbDJpPJcNedt3L4kcegGsb1fqZjXYi+824R0D/eYWyfpiWKdG2afHuBdE2amtokvi9pbS2RTFo0CUVNTQJRmyTvBAzKJCi6AZmkhRdoqZW8E5AteKRTFktKfrnrt73dobWlSK41R+AHBEGgawfR2ZdMXYZMbYZB9SnSaZt0OoFtm+TzLrW1SZIJi8Z2h1TCpFAKSCUtPfLNEyRsk5LjY5ombW0lWpv1iEfLtnCKuqBH5tt02rYsDt8/nbpVESx7i603H8v3v//9z/xYXdnC/m4HY2dvNYwcOZI/Xf0HfnTpZci6TTDMPviWRU5f9c4jbJ/3fRe/dgimZWKYYaTPDpXVw460KNJW8gJKriCVMMkWpa5ZcbRBq00n8IQkk7DIe7peREgtbgwQCIkXaM2+1qJPIHQTiKJS9Ay6+FWERcxe0qZVKRJ2pGBvhU5jpVHEC7vcdJRRkrSMcr1KwZO0FrWDlw0vcyWfoqtrVVw36Fhs27ywX3aYrYiSPvbyV7jqj39g5MiRn/3xuhj+Hd0eE3PooYdy8MEHM+nVKSQ2O7i3l7P2lOv4wqkQgYcq5aG2gZJSlPJF7GQC3/NpaxIkkgnSNWlEIEimkzQ3SRoGZ6ivT5PLu9TVJlneJqirSZDNe2UHbeFCB9/1sRM2i+Y34zkeTlurboLwtTixNK2ykoLn1uEUHdqaDNI1aS2Sb5nYts28/HJq6mpIpmw8L6CuLkkiYeG6AbatLy3LINtW0p21ShHk23WmJ/C0bmgpH/5G9F+btypkqRnV/D7/mvRW2YH+LHRlC/u7HeyDnkvf48wzz+Ta62/i02VvkRj1+d5eTtdEu1c7qb/svgVuAc9JkkgmUFLh2RZB4OH7glRKR/KKRUUyqWtV8iVFMmGSdwLSYW2K4wtqUjYFJyBh65o9P9BTL7xQlNQLBLmS/rL4QurGDKUdMCH19a4nKJV8lILa2iR1mQQNNQnyJR/L0mmMdEI7fU4Q6laFKYuahC5aTlkGeVc3Z7QXPJpzru7GDdMjjuOTz+upF4EvyLZk8bKtWiAU+n2lbbD0LcaPHcMPfvCDbnm8OI0bs6b845a/sfkW4xHZ+Vj1m/b2ctYNpXQqE3Sts1sIr5cEQQopJLKYxU3XIQKBU3TI1GYIAn2fXNZlUH2KlpYSNTUJmpoK+L4kCGR5zFi+LY90S1q/MzOo0hARNdhV67faSdxEGgYNxffqEIWsdtaUwkimyTa3Y4eOZ+PCIjV1NSSSCQI/6BDB89uaoNCmMz1SVJzLfiKGvLYopQgWvsDZZ5/NTjvt1G2PGadxN2Asy+K+e+5kwu57Igdv1XdnRUaafFELvWWDECB8/FwbOSmpqasp7xwhjLQJvUNMpQSuG5DJJBBCkUpZSJmgUPKpq0ng+IKUbSGdSkFwwZHlubd+oKN5hqE7b6PImp7mIZBS4fsSz/WRUpLOpEinLerr0wypT2NbBgUnwAzn20a1KClb1wmmEzrCuNTxSVgmy7MOSsGyZTnaWgqkMimcosPQ4YMoFLSz55ZcveOzEpBIg1XS3bf9lGgne98zb3bLThbiNG7MmjN69GiuuvIKLv35r5F1ozDMtRfx7nWU1ErEUSdqMaslrBJJcIvItqVgJ6BtGaVEGlIZii0OZOpZ3tpEauhGZFtMautraW3KaqfLsnAdF8/xdG1ce6PecHslyDZ1ziYIv9L9Gnjl+bPCtPT97AQ4BZRlg2kTyIC8nYBkhnzzYkjX6VnAvqNtW/tykEElVRtNXIokVfp5NmNliObpNKQlV/zuN932mHEaN4ZddtmFc889l5tvvxe56dG9O1mjKyKHT0nt8Jm+dm6sBFJIRCAoZLVjhIJCzse0TCzborUpj5208X2J6/jU1qVobCwweHCabNZl8OA0RQKSCUvXu3h6fqTjCYTQOyLPE+TzLq4rcEseqUxSO3x+oHdNUunZi1IhhcRzbVqbCyzNpKirS+rpHrZJW5tDJmNTU5Mkl3NpaEiTStnMW5wlk0nQ2FjAsgyWLWrGMAwKLa0YiRTKc2hb3ka6Jo1TdPSMx0RKG1fL1obUMOiPEXklBcGCZ/nhD3/Izjt3n9h3HNmLWRvOOeccbvnHHXy8+BUSYw7o7eWsGyvqlqpSxVGKZpYZhnbEim3aocq3QqoWN98K9cMpLV0AdcN0qjTwtAPWtkw/DlQuV7kGWbmUVKJwpqUdQcOAILTlpqXteSmv7VgkF2WY+n7QcW5tWWuwfzehrQrptmEsf517HnmI2truqx8dyJG9ftZD37v84corGLXRYIIlr/X2UromcvSgSotPOz6u4+IUnfJRypco5Uu0NrbillycgsOyBcspZAvMn7WYbEuWOZ8soWl5jlkzl9Pe7rCsMU/JCSgWfRqbijhOQLHosXRpngXzmsnnXHJtetZia2MbLctaykdrYyvZliy55lZaljazfNFyirkihWyB1pYC82YtZe6sZeTa8rS1FJn10WJam3IsWtjGzBnLaFpe4P2357J8cTNzpn1IsXEphVkfQusS1PL5UMqiWpdQWvgpqr0RWhZB62K98821aOPXVx311RAseY0txmzMlb//Xbc+bmTgujrWlhtuuIFx48aRTqeZMGECL7300irPfeihh/jKV77CRhttRH19PXvvvTf//e/aDzGPWT9YlsXjjz6ImfsU0T63t5ezbkQ1bNE4MBFOjoiiYMLXNtQPx4ZFXayFVijlYOmn2vlbPANyzTp9umx2xWFbWycrktKCjusJa/wQQUVBwC3qNXglHUWMIoMrRu4GWCQvQilBMP9ZTj31VA49tHuFvrvbDkLfsYVxZG8tSCaTPPX4w+yw486I+k2xBo3t7SV1TRS6L+UgXQteUacJApdiUEuxtQ0zmcZO2HiFvN69hmkBrzkLdpKCrw2e09pMYtBgWhtbaRjWwJKFAVJI6hrqCPyAYq5IKpOiVCiRD/I6kiclpmUhhdCPW103IgIw9ESNUrtHKVOvd6xKYdgJVCmnnTIrQTEX1p4k0noXbRjaeYuIdramrk8svw7TCgejh68t2iH3w05ckVuA0fYRT7z0Lslk90506e407n333cf555/PDTfcwL777stNN93EV7/6VaZPn86mm3au83rxxRf5yle+wu9+9zsGDx7MbbfdxpFHHsnrr7/OrrvuutavJ6bnGTduHH+/+W9853s/wKw5vn9250a2aEV9uejjvirnKXLknLyOnnmlSto08HpgnVKLQ6/y9u5/yr5MsPQtNhlex1//8uduf+zuTuP2JVtoqP4em+wF/va3v3H2eT8isfVEDDvd28tZNYZZdqCwk2E6M4BUBlK1OiWQymgDZSf1UQpH5/ierhsJwp1v5Cxl6vT/1w0r74oTdfX4pZJ2sLySvj1VU6kdFL5+vGpnL/rYWbZ+vlSNvizl9PWmrYdJuiXt3CXTer2RQxcRpVuq61MMo186dKtCBQ7+J/dxw7V/5Iwzzui2x81mszQ0NLDxqXdiJmtWeZ70ijTecQoLFizooGOVSqVIpVKdzt9rr73YbbfduPHGG8vXbbfddhxzzDFcccUVa7S2z33uc0ycOJFf/OIXa/GKYtYnSimOOuZYnnp+KolxR3wmYe+YmDVB5hcj5j7JtLffYscdd+y2x10TW7i2dhD6li2M07jrwBlnnMGB+++Lv2By387jRxE0GUbW3KJ2lArt0LQAnJxOP+Rb9dG8UDtX2SbttEUDsqPDK+malFJepyzyeuyOv3AmLJ+n0xlOQR/ty/Xj5FvBC1MhUVoi8MI0SSiB4Bb1fdsb9f97JV0nk2+tPG/7cv3vUraSaokil9FlpDU4kBw9pfAXTOaLB3yhW3SkVvUca5K+GDt2LA0NDeVjZcbK8zymTp3KwQd3lOY4+OCDeeWVV9ZoPVJKcrkcQ4cO/ewvLqbHMAyDf95xKw0JF9H0Xm8vJ2aAowKHYMH/uOoPv+9WR6/Dc3STHYS+ZwvjNO46YBgG9917F1tvtwO5xrexR0zo7SWtmuqJG5ETFEXXpKh0pgaejohF6uphmrUcMQs8HSkEXcwMkHP07VH0sDqdWv08vrNquRPDAFZwzqLi4hUjdH3Yr+4pRONUGhIF7rv3rh6LnEgpQa46TSTD21a2o12RpqYmhBCd5lOOGDGCpUuXrtF6rr76agqFAscff/wanR/TewwePJgnHnuI/Q/4IjIzHLNuk95eUswARCmJP38S++2zJ+eff36PPU9XtnBt7CD0PVsYR/bWkeHDh/PcpP9A07T+V6Rc3QVWfUSFwdWp1uj66DYpKlG6ctTQrdwW/X/1deXHW8lRHaWrnmwxwCJ064JonwNN7/DcpP8wbFgPyv2oNTiA+vr6DseqjBzQyTFV4Vip1XHvvffyy1/+kvvuu4+NN954nV5OzPpln3324bq//oVg3n9RXra3lxMzAAmWvMbIepPHHnmwZ8sFutkOQt+xhbGz9xnYZZdd+OedtyMWPIt0Wnp7Od1HtTNYfRn9e3VO24rXDdCusJ5EOi2IBf/jrn/ewS677NKjz9Wd3bjDhw/HsqxOO9fGxsZOO9wVue+++/jud7/L/fffz5e/3EdmUcesEWeeeSanfOsk/LlPowao3EdM7yBaZmBnZ/D8c8985tm3q6M7u3H7mi2Mnb3PyAknnMAF5/8Qa9EkVOD09nJiBgAqcAjmPs2FF5zHxIkTe/75pER2caguUrwrkkwmmTBhApMmTepw/aRJk9hnn31Web97772Xb3/729xzzz0cfvjh6/xaYnqPm2+6gR23GUew4H99u5Y5pt8gi42IxS/y6CMPsdVWW/X483VlC9fGDkLfs4Wxs9cN/OHK37PHhJ3x5z2D2sBTjzGfDSUF/rxn2G/v3bny92vWrfXZn3QNjrXgwgsv5O9//zu33norH330ERdccAHz58/nzDPPBODSSy/llFNOKZ9/7733csopp3D11Vfz+c9/nqVLl7J06VLa29u749XFrCcSiQST/vsk9VYOsezN3l5OTD9HeTmCuU/zm8t/xSGHHLKennQ1x1rSl2xh7Ox1A6Zp8vijD7H5yDqC+f9DxWnLmHVAKUkw/1k2H1nHY4882G3j0Fb/vN0rqjxx4kSuueYaLr/8cnbZZRdefPFFnnrqKTbbbDMAlixZwvz588vn33TTTQRBwNlnn82oUaPKx3nnndetrzOm59loo414YfKzWO3TCZo+6O3lxPRTVFDCn/04Jxz/dS655Mfr73m7WVS5L9nCWGevG2lsbGSnXSbQ5A/G3mT/WHcqZo2JhnoPT2V5b9pb66U5IdKWqj/uZoxEZtVr80tk//192tvbe7xmJmZg8Morr3DAgQdhjD4Aa0jPp99iBg5KePifPsaX99+dp554FMvq+YlHa2IL+7sdjCN73cjGG2/M66++TG2whGDpG729nJh+RLD0DerkMl5/5aX13oXaE+PSYjZs9tlnHx5/7BHEoucR2Xm9vZyYfoKSAn/u00zYcTyPPfLgenH0Ojz/ALaDsbPXzWy22Wa8OuVFErmPCZa/29vLiekHBMvfJZGbwatTXiyH99cr3VyzFxMDcOihh3Ln7bci5j+DLCzp7eXE9HEiLb3xY4bw3LP/Wa2kSc8sYjVHPyZ29nqA7bffnhcm/w+jaWrs8MV0SdD4LkbTVF6Y/Czbbbddr6yhq07c6IiJWRdOOukk/vLnqwnmPInML+7t5cT0UZQUBPOeYVS9ZMqLz1FXV9cr6xjIdjB29nqIPffck5dffB6rZRrBsrd6ezkxfZBg6VvYre8w5aUX2HPPPXttHXEaN6YnOeecc7ju2j8TzH0S8OksnwAAwSlJREFUkVvQ28uJ6WMoGeDP/Q+bDU8w7a3XGT58eO+tZQDbwdjZ60H23HNP3njtFVK5j/EXv9rvPywx3YNSCn/xq6QKH/P6a1PYY489en09A9nIxfQ+P/jBD7jtH7cg5j6tJ8PExBA2Y8x5km03HczUN19lo4026t31DGA7GDt7PcxOO+3E1Ldep9abR7Do5X7/gYn5bCilCBa9RJ0/n6lvvs5OO+3U20tCSbXaIybms3LKKadw/333Ihc8i2id2dvLielllHDxZz/BLtuM4fVXX2Lw4MG9vaQBbQdjZ289sM022/DO228y2FhOMH8SSga9vaSYXkDJgGD+JAYbTbzz9ptss802vb0kII7sxaw/jj32WJ54/FHU4hcIGt+NP1sbKMrL4X/6CPtM2JaXe7FGb0UGsh2Mnb31xLhx4/jgvbfZenQN/qePovxiby8pZj2i/CL+p4+y9egaPnx/GptvvnlvL6mCUqs/YmK6iUMPPZSXX3qBVO4DgoUvoFQ8dWhDQhaW4s96kBOPPZznnv0vmcyqNT7XOwPYDsbO3npk5MiRvP3Waxz2pb3xZz2ALDX39pJi1gOy1IQ/6wGO+Mo+vP3Wa6sdgr3eUXL1R0xMN7LXXnsx/YN3GdPg489+Ip4rvoEgWmcSzHmcK3/7K+684zYSiURvL6kjA9gOxs7eeiadTvPYIw/yk/+7gODThxHtc3t7STE9iGifQ/DpI/zsxxfxyEMPkE6ne3tJnZFi9UdMTDez6aab8sG7U9l/j+3xZz2EdNt6e0kxPYRSCn/JG7D0JR5/9GEuvviivjlhagDbwdjZ6wUMw+DXl/+Ke+66A7XwWfwlr8fzdAcYSkn9d134P+656w5+9avL+qZxgziNG9Nr1NXV8ewzT3H26acQzHoQ0fZpby8ppptRgYM/92kaxALefusNDjvssN5e0qoZwHYwdvZ6kYkTJ/L21DcZkWjSdXxevreXFNMN6OLjRxmRaOLtqW8yceLE3l5S18Rp3JhexLIsrr32Gu6/9y6MpS/iL3ghbmIbIMj8YvxP7ueA3bdm5owP2WGHHXp7SV0zgO1g7Oz1MjvuuCOffPwBxx95EP7M+2MNqn6OaJ+DP/PfHH/kQXzy8QfsuOOOvb2k1SPlatIX/dvIxfQPjj32WGZ89CFbj7Qw5z2KdFp6e0kx64hSkmDpW4i5T3L1lZfzv0lPM3To0N5e1urp0hb2bzsYO3t9gNraWu6955/cedstsOg5/IUvxTvbfoaSAf7Cl2DxZO687Rbuveef1NbW9vay1pDV7Wb7t5GL6T9svvnmvDvtTb7/nRMJZj1I0Dy930tebGgoL48/+3GGGot4843XOP/88/tuCUsnBq4djJ29PsRJJ53E9A/fZ/zGYM55EJFb1NtLilkDRG4R5pwHGb8xTP/gPU466aTeXtLaEdfsxfQhEokE1/z5ap564jEy2XcJZj+OdLO9vayY1aCUImj6APXp/Xztq19g1ozp7Lrrrr29rLVjANvB2NnrY4wfP54P33ubX192CWr+0/gLJqMCt7eXFbMSVODiz5+Mmv80v/nlpXz43tuMHz++t5e19sTduDF9kEMOOYT5cz/lhGMOIvjkPoLGd+JGtj6KdFrxP32EQaWPeezRh3ngvnsZNGhQby9r7RnAdjB29voglmVx0UUXMfOTj9l962H4n/wL0Ta7t5cVU4Vom43/yb/YfdthzPzkYy688EIsy+rtZa0bcYNGTB9l8ODB3HXn7Tz3v2cYquZpiZZYn7TPoJQgWPYWwcx/c/q3vsb8ubM45JBDentZ684AtoOxs9eH2XzzzXl1ygvcevN1WI0v4c9+PDZ0vYwsNePPfhyr8SVuvfk6Xn35hb41DWNdiNO4MX2cAw44gLmffsJ5Z5xMMOtB/IUvooJSby9rg0UphWifgznnIUYmm3hlykv87cbr+szYs3VmANvB2Nnr4xiGwamnnsqiBfP43olHakO3YDLKL/T20jYolF/Anz+ZYNaDnH7SkSxaMI9TTz21HxUed0Gcxo3pB2QyGf509VV88P677LPDCPyP7yZY9nbczLaekcXlWAufwm58iT/89ufMnvkRe+21V28vq3sYwHYwdvb6CUOHDuVvN17HjI+nc9Ae4/Bn3EOw9E2U8Ht7aQMaJXyCpW/iz7iHg/YcxyczPuLGG67rHzICa0qcxo3pR2y33Xa8OHkSk/77FGNrWghm3Ito/STu2u1hlJeDRZMRsx/mjFO/wZJFCzjnnHP63sizz8IAtoOxs9fPGD9+PM88/QQvPv8cWw4pEcy4i2DZVJSImzi6EyVcgmVT8T++iy2HOrz0wmSeefoJttxyy95eWvcj1eqPmJg+xkEHHcSsT6Zz681/JZOdRvDJfaHT179/lPsa0m1HLX4Jb8Y9HLzvdnw6ayZ/uvoqGhoaentp3c8AtoOxs9dP2Xffffnow3d5/JEH2GYjD/+jf+IveQ3lF3t7af0a5Rfxl7yG/9E/2XYjjycfe5CPPniHffbZp7eX1nNIATLo4ujf6YuYgYtpmpxyyiksW7yA6/70GwYV3ieYcQ9B04eo+HP7mZClZlj8HP6Mezlkn614751pPPrwA2y22Wa9vbSeo0tb2L8/T7Gz148xDIOvfvWrfPDuVJ5/bhJ7jK/D//gu/IUvxkPF1xLptuEvfBH/47vYY3wdzz83ifffncqhhx46MOryuiJu0Ijp56TTac4880yWLVnAHX+/no2NeQQf30XQ+DYqcHp7ef0GpRQyvxhj0TMEsx7k+K9+nlkzP+HRhx/o+6POuoMBbAdjZ2+AsN9++/Hqy8/z1puvc/Be4whm3Ie58ClE68x4h7sKlBSI1pmYC54kmHEfB+81jrfefJ1XX36e/fbbr7eXt/6Ia/ZiBgi2bXPSSSexYO4sHrz/LrYZ7uJNvwN/3iRkfnFc17cKVOAQNL6DNfcBjEXP8N0TDmPB/LnccfutbLHFFr29vPXHALaDdm8vIKZ72XXXXXnqiUdpbGzk1ltv5Y9//iv55a8iBm2FMXQ7zNTg3l5it6CEB0pi2Om1vq902lCtH2FmP6F+UD0XX3wup512GhtvvHEPrLQfsLpOs3izENPPME2To48+mqOPPprp06dz7V+v5/Y77iAghTFke6yh26yT7ehrKKVAOGDYGNbaNUoopVCFJZjZjwlaZrHt9jtyyZVX841vfIN0uv+/N+tEV7awn9tBQ8VbnQGNlJLJkydz1Z/+wrP/fZp0wwjc1BjMhvGY6cG9vby1RgUOct5T+LklGIaJOWgsJgFYacxND8YwVh6slk4bsn0WKWcBTraRrxzyVS6+8Dy++MUvYpobZoA7m83S0NBAasJ5GHZqleepwMWd+hfa29upr69fjyuMiek+SqUSDzzwAFf84U/MmP4+mWGb46bHYjVsgWFnent5a40sNiLn/4fAyWEl0qiaUViyhKrbDHvE7iu9j3bwliLaZpF0FmAi+Na3vsUPzz2b7bfffj2/gr7DmtjC/m4H48jeAMc0Tb70pS/xpS99idbWVh5//HFuufVOXp1yP4lBw3FTYzEbxmGkh/X52jQlBWL+f8kYea65/vfkcnmeeOJZ6uvreOqpZ0kMWYBVr4uHlVIopxnZPoeUu4Ag38Te+x7A6af9niOPPJLBgwf37ovpU6wuRdG/0xcxMaB1+k4++WROPvlk5s6dywMPPMDN/7iTT6e/RGboprjpTbHqN8dI9n1hYOXlkPOeZvttNuPCC8/g7bff5+1p7+N7Pm+88SbW8J0wrKQ+VwpkYQmyfTZk55BJmRxxxFGcesqVHHTQQSSTyV5+NX2Jrmxh/7aDcWRvAyWbzfLEE0/w99vuZMpLLyCUBTWjMAaNwawbg5Gs73POn79oCkbrhzzyyG3su29FxPPll1/nyCO/hT3ucPALqPxCKC7GMiT77ncAp592Kocffni/3I31JOXd7K5nYVhdRPaEizvthn67o42J6YoFCxbw4IMPcvM/7mDG9PfIDBqGnxqJqhmNWbdJn4v6KaWQnz7IRvUmzz33ICNGbFS+7fe/v5Y//vnvmJsdjsovIhU0UmqZT7qmlq8fczSnnvItDjjggIGljdcNrIkt7O92cMPMX8VQX1/PiSeeyHOT/kMu287z//sPP/3hiWw9OIv45F+Ys/8FiycTNL6DzC/qEzp+ZmEup512QgdHD+DxJyZR39BAMPdpth6S5WfnncTz//svuWw7z036D9/85jf75ZdzvdED3bg33HAD48aNI51OM2HCBF566aUuz3/hhReYMGEC6XSaLbbYgr/97W/r+mpiYtaKsWPHcv755zP9/Wm0tLRw7z//wfeOO4Cx9lzcD2/Dn3k/cvGLBM3TkcXG3m948/P4+WX8/vc/7eDoCSGY/PwrmEgSi//DPtvU8ruf/ZD33p1Gvr2Ff955O1/+8pdjR68reqAbt6/YwjiyF9OJQqHAlClTePnll3nu+Sl8/PGHNC9fRm3DRqjUMDyzXkf+koMwkvWQqO2RKKBSSkfqvCyy1ESw6CWuu/4PjBw5grenTmPOvEWUSpIdtt+O/fbbjy984QvU1NR0+zoGKuXd7M5nrD6y9+5Na7yjve+++zj55JO54YYb2Hfffbnpppv4+9//zvTp09l00007nT9nzhx22GEHTj/9dM444wymTJnCWWedxb333suxxx77mV5jTMxnobGxkcmTJzPllVeZ/OIUZs/8GKdUombwCHx7CMKObKE+sFI9YwulQPk5lJdDtM1CNk/n2WcfYcHChbwz7T2WLGtBKZs9d5/AAQccwK677optx1Vaa8qa2MK1tYPQt2xh7OzFrBHLly9n2rRpTJs2jdfemMpHH39CU+NSWpobMU2LdN1QzGQd0kwSKJtA2fpLY6XKtSMrQwkPhIsSLrYRYBsBpvSQXh4n34KUgrr6oYwYNZrPbbc1e++1B7vuuiu77rorG2200SofN2b1lA3c9qdCF38jhIc7/Q4WLFjQwcilUilSqc6Gca+99mK33XbjxhtvLF+33Xbbccwxx3DFFVd0Ov/HP/4xjz32GB999FH5ujPPPJN3332XV199dR1fXUxM96OUYu7cuUybNo2pU6fy5tR3WbBgPosWLiCXbSORTJOqGwJ2LZIEvrKQRjK0hUkMc+VRNaUkyMgWeiRCW2hIF+G0U8q3Y5omI0aOZsjw4UzYdSf23H13dt11V3baaSfq6vp+nWFfZo1s4VraQehbtjB2/WPWiI022oiDDz6Ygw8+uMP1ruuyYMEC5syZw8KFC2lra6O1tZWWllaWNzWzvKmJJcuayKQ6G7mS6zO4oYFNx2zBRsOHMXToEIYMGcLgwYMZM2YM48aNY+zYsav8IsV8NpLJJCNHjmTp9DtWe25dXR1jx47tcN1ll13GL3/5yw7XeZ7H1KlTueSSSzpcf/DBB/PKK6+s9LFfffXVTp+rQw45hH/84x/4vh+nnWL6DIZhMG7cOMaNG8fXv/71DrflcjnmzZvHnDlzWLp0adkWNje30Li8iQWLliJFaaWP6/mCTUaPYKPhwxg+rGILhwwZwmabbca4ceMYNWoUlmWtj5e5wbGmtnBN7SD0PVsYO3sxn4lUKsX48eMZP358by8lZi1Jp9PMmTMHz/NWe65SqlN6amVOeFNTE0IIRowY0eH6ESNGsHTp0pU+9tKlS1d6fhAENDU1MWrUqNWuLyamtxk0aBA77LDDhjFpYoCxprZwTe0g9D1bGDt7MTEbMOl0ukcEVFc0iCszkqs7f2XXx8TExPQEA90Wxt24MTEx3cbw4cOxLKvTzrWxsbHTjjVi5MiRKz3ftm2GDRvWY2uNiYmJ6Sn6mi2Mnb2YmJhuI5lMMmHCBCZNmtTh+kmTJrHPPvus9D577713p/OfeeYZdt9997heLyYmpl/S52yhiomJielG/vWvf6lEIqH+8Y9/qOnTp6vzzz9f1dbWqrlz5yqllLrkkkvUySefXD5/9uzZqqamRl1wwQVq+vTp6h//+IdKJBLqgQce6K2XEBMTE/OZ6Uu2MK7Zi4mJ6VYmTpxIc3Mzl19+OUuWLGGHHXbgqaeeYrPN9Ci7JUuWMH/+/PL548aN46mnnuKCCy7g+uuvZ/To0Vx77bWxxl5MTEy/pi/ZwlhnLyYmJiYmJiZmABPX7MXExMTExMTEDGBiZy8mJiYmJiYmZgATO3sxMTExMTExMQOY2NmLiYmJiYmJiRnAxM5eTExMTExMTMwAJnb2YmJiYmJiYmIGMLGzFxMTExMTExMzgImdvZiYmJiYmJiYAUzs7MXExMTExMTEDGBiZy8mJiYmJiYmZgATO3sxMTExMTExMQOY2NmLiYmJiYmJiRnAxM5eTExMTExMTMwAJnb2YmJiYmJiYmIGMLGzFxMTExMTExMzgImdvZiYmJiYmJiYAUzs7MXExMTExMTEDGB63Nk78MADOf/883v6adY73/72tznmmGPW6j6bb74511xzTY+sJyYmZt0YyN/LdbG/hmHwyCOP9Mh6YmJieod+F9lraWnh3HPPZZtttqGmpoZNN92UH/7wh7S3t3c476ijjmLTTTclnU4zatQoTj75ZBYvXtxLq+4+lixZwoknnsg222yDaZqrNORtbW2cffbZjBo1inQ6zXbbbcdTTz31mZ779ttvxzCM8lFXV8eECRN46KGHOpy34g/M888/3+F+Kztuv/12HMfh29/+NjvuuCO2ba/Smb777rvZeeedqampYdSoUXznO9+hubl5leuMDsdxOjzODTfcwLhx40in00yYMIGXXnrpM70/a0JzczOHHnooo0ePJpVKMXbsWM455xyy2WyH895//30OOOAAMpkMm2yyCZdffjlKqTV6jl/+8pfssssuHa7rru/Nu+++yze/+U3Gjh1LJpNhu+224y9/+ctq1+S6Luf+P3tnHhZV9cbxD8MAA4yACgiKCoaKioaKCriXmpqZqaXlkpVbZrmklmVppWZlabZpm2ZaVmbmnppS7opKiohJSopCioosMsIw9/fHmTvDsIss1u98nmeembn33HPPvTP3znfe97zv++yzeHp64urqSt++fUlMTLSsL+47cujQIUu7wtYvXry4VOelMklISOCpp54iICAAZ2dn7rrrLmbOnEl2dralTWm/C/9GTpw4wYABA/D398fOzq5IMX3hwgWGDh1KzZo1cXFxISQkhMOHD9/WvmfNmmXz/XB3d6djx4789ttvNu3yi/yi7ht5H5GRkaW+By9cuJDGjRvj7OxM3bp1mTRpks09KP847ezs8PHxselDURRmzZpF7dq1cXZ2pkuXLpw4ceK2zk9pOHXqFF27dqVWrVrodDoaNGjAjBkzyMnJsWn322+/0bp1a0ubW7kWCzOYlNd1ExkZyYMPPoivry+urq6EhISwcuXKEsd07do1hg0bhru7O+7u7gwbNozU1FTL+uK+I5cuXbqlc1fZaKt072Xg4sWLXLx4kfnz59O0aVP+/vtvxo4dy8WLF1m9erWlXdeuXXnppZfw9fXlwoULTJkyhYEDB7J3794qHP3tc/PmTby8vHj55ZdZsGBBoW2ys7Pp3r073t7erF69Gj8/P86fP0+1atVue/9ubm6cOnUKgPT0dJYuXcojjzzCiRMnaNy4caHbREREkJSUZHk/YcIE0tLSWLp0qWWZu7s7ubm5ODs789xzz/Hjjz8W2tfu3bsZPnw4CxYs4IEHHuDChQuMHTuWkSNH8tNPPxU6ThWdTmd5/d133zFx4kQ+/vhj2rdvz5IlS+jVqxexsbHUq1fv1k9MKdFoNDz44IPMnj0bLy8v4uPjeeaZZ7h69SrffPMNAGlpaXTv3p2uXbty6NAh/vzzT0aMGIGrqyvPP/98mfZbXtfN4cOH8fLyYsWKFdStW5e9e/cyevRo7O3tGT9+fJH7nzhxIuvXr2fVqlXUrFmT559/nj59+nD48GHs7e0LfEcAXnnlFbZv305oaKjN8qVLl9KzZ0/Le3d39zKdk4okLi4Ok8nEkiVLCAwMJCYmhlGjRpGZmcn8+fOB0n0X/q3cuHGDBg0a8PDDDzNp0qRC21y7do327dvTtWtXNm/ejLe3N3/99RceHh63vf9mzZqxfft2QPzRmT9/Pn369CExMbHI78ugQYNsvlf9+/cnODiY119/3bKsRo0aXLx4scR78MqVK3nxxRf58ssviYiIsFzDgM02eccJYG9vb9PP22+/zXvvvceyZcto1KgRs2fPpnv37pw6dapc7udF4eDgwPDhw2nVqhUeHh788ccfjBo1CpPJxNy5cwE4e/YsvXv3ZtSoUaxYsYI9e/Ywbtw4vLy8GDBgQJn2W17Xzd69e2nRogUvvPACtWrVYuPGjQwfPhw3NzceeOCBIvf/2GOPkZiYyJYtWwAYPXo0w4YNY/369UDB7wgI0WowGPD29i71uasSlAqmc+fOyjPPPKM888wziru7u1KjRg3l5ZdfVkwmU5HbrFu3TmnVqpXi5OSkBAQEKLNmzVJycnKKbP/9998rjo6Oxbb5+eefFTs7OyU7O7vEMRuNRuXJJ59U/P39FZ1OpzRq1EhZuHChTZvHH39cefDBB2/pOOvXr6/MmTNHeeKJJxS9Xq/UrVtXWbJkiU2/06ZNUxo2bKg4OzsrAQEByowZM4occ+fOnZUJEyYUWP7JJ58oDRo0KPZY09LSlMcee0xxcXFRfHx8lPfee6/I/lSWLl2quLu72yzLzc1VHBwclO+//77EcankP3e30uadd95RGjRoYLNs0aJFip+fX7HjzE/btm2VsWPH2iwLCgpSXnzxxSK3mTlzpnL33Xcry5cvV+rXr6+4ubkpgwYNUtLS0ixtTCaT8tZbbykBAQGKTqdTWrRoofzwww/FjuX999+3Gf/HH3+suLu7KwaDwbLszTffVGrXrl3sdaMo4tgBm8fSpUsLbVte1824ceOUrl27Frk+NTVVcXBwUFatWmVZduHCBUWj0ShbtmwpdJvs7GzF29tbef31122WA8pPP/1U5L4URVF2796tdOrUSXF2dlY8PDyUHj16KFevXi2yff369ZXXX39defTRRxVXV1fF19dXWbRoUbH7UBRF+fLLL5WgoCDFyclJady4sfLRRx8V2/7tt99WAgICim2T/7tQHCkpKcrgwYOVOnXqKM7OzkpwcLDyzTff2LTJfy2W5lgB5bPPPlP69eunODs7K4GBgcrPP/9sWV+a+2Ne6tevryxYsKDA8hdeeEHp0KFDscd48eJFpXfv3opOp1P8/f2VlStXFtmfinqd5uXcuXMKoBw8eLDEcamUdB8rrs0zzzyj3HPPPTbLJk+ebHO8hY0zLyaTSfHx8VHmzZtnWWYwGBR3d3dl8eLFRW6n3jvfeecdxcfHR6lRo4Yybtw4m2v45s2bytSpU5XatWsrLi4uStu2bZWdO3cWe6yTJk2yGf+0adOUoKAgmzZjxoxRwsLCiu1HUcSx579PFbX/8rpuevfurTzxxBNFro+NjVUAZf/+/ZZl+/btUwAlLi6u0G0uXbqkODg4KMuXLy923/nPnaKIe2vr1q0VJycnpWbNmspDDz1UbB+3S6W4cb/66iu0Wi0HDhxg0aJFLFiwgM8//7zQtr/88gtDhw7lueeeIzY2liVLlrBs2TLmzJlTZP/Xr1/Hzc0NrbZwQ+XVq1dZuXIlERERODg4lDhek8mEn58f33//PbGxsbz66qu89NJLfP/997d9nO+++y6hoaEcPXqUcePG8fTTTxMXF2dZX61aNZYtW0ZsbCzvv/8+n332WZH/Hoti3bp1hIeH88wzz1CrVi2Cg4OZO3cuubm5ljaTJ09mz549rFu3jm3btrFr1y6OHDlyS/vJzc3lq6++AqBVq1a3tG1ZiYiIIDExkU2bNqEoCv/88w+rV6/m/vvvt2mXkZFB/fr18fPzo0+fPhw9etSyLjs7m8OHD9OjRw+bbXr06FGi5fevv/5i7dq1bNiwgQ0bNvDbb78xb948y/oZM2awdOlSPvnkE06cOMGkSZMYOnRoAReSysWLF1mzZg2dO3e2LNu3bx+dO3fGycnJsuy+++7j4sWLJCQkFDu+QYMG8fzzz9OsWTOSkpJISkpi0KBBhbYtr+vm+vXr1KhRo8j1hw8fJicnx+Z8165dm+Dg4CLP97p160hJSbFYQ/Iyfvx4PD09adOmDYsXL8ZkMlnWRUdHc++999KsWTP27dvH7t27eeCBB2y++4Xxzjvv0KJFC44cOcL06dOZNGkS27ZtK7L9Z599xssvv8ycOXM4efIkc+fO5ZVXXrFcD4VR0nkq7LtQHAaDgdatW7NhwwZiYmIsVogDBw4Uu11pjvW1117jkUce4dixY/Tu3ZshQ4Zw9epVoOz3x/ysW7eO0NBQHn74Yby9vWnZsiWfffaZTZvhw4dz8eJFIiMj+fHHH/n0008t7rLScvPmTZYtW4aHh0eR3ofypkOHDhw+fJiDBw8CcObMGTZt2lTgPnX69Glq165NQEAAgwcP5syZM5Z1Z8+eJTk52ea6cXJyonPnziXep3bu3Mlff/3Fzp07+eqrr1i2bBnLli2zrH/iiSfYs2cPq1at4tixYzz88MP07NmT06dPF9pffHw8W7ZsKXCfyn8Pve+++4iKiirRZTllyhQeeeQRevbsablPRUREFNq2vK6bkvrZt28f7u7utGvXzrIsLCwMd3f3Is/38uXLcXFxYeDAgUX2W9i527hxI/379+f+++/n6NGj/PrrrwU8GOVOhUpJRfzzadKkiY1F4oUXXlCaNGlSaPuOHTsqc+fOtVn29ddfK76+voW2T0lJUerVq6e8/PLLBdZNmzZNcXFxUQAlLCxMSUlJKfNxjBs3ThkwYIDlfWGWvZKOs379+srQoUMt700mk+Lt7a188sknRe737bffVlq3bl3ouqL+VTZu3FhxcnJSnnzySSUqKkr59ttvlRo1aiivvfaaoijCqufg4GBjcUpNTVVcXFxKtOwBiqurq+Lq6qpoNBrFycmpgOWoIi17iqIoP/zwg6LX6xWtVqsASt++fW3+te7bt0/5+uuvlejoaOX3339XBgwYoDg7Oyt//vmnoijCqgQoe/bssel3zpw5SqNGjYoc08yZMxUXFxcbS97UqVOVdu3aKYqiKBkZGYpOp1P27t1rs91TTz2lPProozbLBg8erDg7OyuA8sADDyhZWVmWdd27d1dGjRpl014dc/6+ixpncRYDRSm/62bv3r2Kg4ODsnXr1iLbrFy5UnF0dCywvHv37sro0aML3aZXr15Kr169Cix/4403lL179ypHjx5V5s+fr7i4uChvvPGGZf2jjz6qtG/fvsixFEb9+vWVnj172iwbNGhQoftXqVu3bgEr2htvvKGEh4cX2j4+Pl5xc3NTPvvsswLrivsu3Cq9e/dWnn/+ecv7wix7JR0roMyYMcPyPiMjQ7Gzs1M2b95c5H7z3x/zUpQFzcnJSXFyclKmT5+uHDlyRFm8eLGi0+mUr776SlEURTl58qQCKIcOHbJsc/r0aQUo0bKn0Wgs9yk7OzvFzc2twPgr0rKnKMLj4ODgYLlPPf300zbrN23apKxevVo5duyYsm3bNqVz585KrVq1LNfbnj17FEC5cOGCzXajRo1SevToUeSYHn/8caV+/fqK0Wi0LHv44YeVQYMGKYoivot2dnYF+r333nuV6dOn2ywLDw9XnJycFEAZPXq0kpuba1nXsGFDZc6cOTbt1TFfvHixyPHlHWdJvwPldd388MMPiqOjoxITE1Nkmzlz5igNGzYssLxhw4YFNIlK06ZNC3yuKsWdu/DwcGXIkCFFjqUiqBTLXlhYGHZ2dpb34eHhnD59utB/24cPH+b1119Hr9dbHqNGjSIpKYkbN27YtE1LS+P++++nadOmzJw5s0BfU6dO5ejRo2zduhV7e3uGDx9e6knuixcvJjQ0FC8vL/R6PZ999hnnzp277eNs0aKF5bU6ITfvP9XVq1fToUMHfHx80Ov1vPLKKyXuNz8mkwlvb28+/fRTWrduzeDBg3n55Zf55JNPAPEvMycnh7Zt21q2cXd3L9W/3mrVqhEdHU10dDRHjx5l7ty5jBkzxjKnoaKJjY3lueee49VXX+Xw4cNs2bKFs2fPMnbsWEubsLAwhg4dyt13303Hjh35/vvvadSoER988IFNX3k/KxCTofMvy4+/v7/NXBlfX1/L5xcbG4vBYKB79+4239/ly5fz119/2fSzYMECjhw5wtq1a/nrr7+YPHlyiWMrbHlZKK/r5sSJEzz44IO8+uqrdO/e/ZbHUdT5TkxM5JdffuGpp54qsG7GjBmEh4cTEhLC888/z+uvv84777xjWa9a9gpj5cqVNp9L3oCc8PBwm7bh4eGcPHmy0H4uX77M+fPneeqpp2z6mz17doHPGYTloWfPnjz88MOMHDmywPqSvgtFkZuby5w5c2jRogU1a9ZEr9ezdevWEu8XpTnWvPcpV1dXqlWrZnOfKsv9MT8mk4lWrVoxd+5cWrZsyZgxYxg1apTlPnXq1Cm0Wq2N1yAwMJDq1auX2Hfjxo0t96nDhw/z9NNP8/DDDxMVFXVLYywrkZGRzJkzh48//pgjR46wZs0aNmzYwBtvvGFp06tXLwYMGEDz5s3p1q0bGzduBChgHS7LfapZs2Y28//y3qeOHDmCoig0atTI5vv722+/Ffj+fvfddxw5coRvvvmGjRs3WubNFTe2wpaXhfK6biIjIxkxYgSfffYZzZo1K3afhY27qPO9b98+YmNjC71PQfHnrrj7VEVxxwVomEwmXnvtNfr3719gXd4J9unp6fTs2RO9Xs9PP/1UqJvJ09MTT09PGjVqRJMmTahbty779+8vcLPLz/fff8+kSZN49913CQ8Pp1q1arzzzjslukdKQ/5x2tnZWdxQ+/fvZ/Dgwbz22mvcd999uLu7s2rVKt59991b2oevry8ODg42F3uTJk1ITk4mOzu7yAuyNEJYo9EQGBhoed+iRQu2bt3KW2+9VezE1/LizTffpH379kydOtWyf1dXVzp27Mjs2bPx9fUtdMxt2rSxuCg8PT2xt7cnOTnZpt2lS5eoVatWsfsv7vNTnzdu3EidOnVs2uV1yQL4+Pjg4+NDUFAQNWvWpGPHjrzyyiv4+vri4+NT6NiAEsdXEuV13cTGxnLPPfcwatQoZsyYUew+fXx8yM7O5tq1azY/1JcuXSrUdbN06VJq1qxJ3759SzyesLAw0tLS+Oeff6hVqxbOzs5Ftu3bt6+Niyb/Z5Sfon6w1M/5s88+s+kPCk6wv3jxIl27diU8PJxPP/200P6K+y4Ux7vvvsuCBQtYuHAhzZs3x9XVlYkTJ9pELpaW/Mda3Pe8vO6Pvr6+NG3a1GZZkyZNLMFZRd2PSnOfcnR0tLlPtWzZkrVr17Jw4UJWrFhxS+MsC6+88grDhg2ziJTmzZuTmZnJ6NGjefnll9FoCtpZXF1dad68ueU+pUbmJicn23wXyuM+ZW9vbwmOyoter7d5X7duXQCaNm1Kbm4uo0eP5vnnn8fe3r7I+5RWq6VmzZrFjq8kyuu6+e2333jggQd47733GD58eLH79PHx4Z9//imw/PLly4We788//5yQkBBat25daH/Fnbvi7lMVRaVY9vbv31/gfcOGDQt80UDM/Tp16hSBgYEFHuoFkpaWRo8ePXB0dGTdunU2IrAo1BvEzZs3S2y7a9cuIiIiGDduHC1btiQwMLDQf+y3c5yFsWfPHurXr8/LL79MaGgoDRs25O+//y7Vtnlp37498fHxNnOZ/vzzT3x9fXF0dOSuu+7CwcHBMp8ExDktar5GSdjb25OVlVWmbW+VGzduFLhRque3uB+H6Ohoy03A0dGR1q1bF5intG3btiLnjZSGpk2b4uTkxLlz5wp8d9ULv6jxgfW7GR4ezu+//27zo71161Zq166Nv79/ieNwdHQs1GpeXtfNiRMn6Nq1K48//nixc2lVWrdujYODg835TkpKIiYmpsD5VhSFpUuXMnz48FLNrz169Cg6nc4SwdmiRQt+/fXXQttWq1bN5jPJe8Mt7NoNCgoqtJ9atWpRp04dzpw5U+BzDggIsLS7cOECXbp0oVWrVixdurTQH/j83Op96sEHH7RYsRs0aFCqa/hWjrWo/Zbl/pif9u3bF4iY//PPP6lfvz4AQUFBGI1Gm/m28fHxNqkwboU74T6lKEqR96mbN29y8uRJy30qICAAHx8fm+smOzub33777bbuUy1btiQ3N5dLly4V+P7mT/2SF0VRyMnJsYw/PDy8wD1069athIaGluraLeo+VV7XTWRkJPfffz/z5s1j9OjRJfYRHh7O9evXbX4XDxw4wPXr1wuc74yMDL7//vsirXqFjS/vuSvuPlVRVIpl7/z580yePJkxY8Zw5MgRPvjgA4u1avr06Vy4cIHly5cD8Oqrr9KnTx/q1q3Lww8/jEaj4dixYxw/fpzZs2eTnp5Ojx49uHHjBitWrCAtLc2SX8fLywt7e3sOHjzIwYMH6dChA9WrV+fMmTO8+uqr3HXXXSVa9UC4CpYvX84vv/xCQEAAX3/9NYcOHbK5kd/qcZaGwMBAzp07x6pVq2jTpg0bN260SSeiEh0dDYgv3OXLl4mOjsbR0dHyL/npp5/mgw8+YMKECTz77LOcPn2auXPn8txzzwHiR+/xxx9n6tSp1KhRA29vb2bOnIlGo7H5h5//swHxpVX/zWVlZbFt2zZ++eUXXn31VZsxquPKi/pPrDhiY2PJzs7m6tWrpKenW/pQ88Y98MADFlfPfffdR1JSEhMnTqRt27bUrl0bEJPLw8LCaNiwIWlpaSxatIjo6Gg++ugjy34mT57MsGHDCA0Ntfx7PHfunI07uLDjL45q1aoxZcoUJk2ahMlkokOHDqSlpbF37170ej2PP/44mzZt4p9//qFNmzbo9XpiY2OZNm0a7du3twi5xx57jNdee40RI0bw0ksvWT6/V199tVTuEX9/f86ePUt0dDR+fn5Uq1aN7OzscrluVKHXo0cPJk+ebPku2Nvb4+XlBYib9b333svy5ctp27Yt7u7uPPXUUzz//PPUrFmTGjVqMGXKFIv7Ki87duzg7Nmzhd5E169fT3JyMuHh4Tg7O7Nz505efvllRo8ebbGcTp8+nebNmzNu3DjGjh2Lo6MjO3fu5OGHH8bT07PIc7Znzx7efvtt+vXrx7Zt2/jhhx8sbjUQgQJ16tThzTffBESOtOeeew43Nzd69erFzZs3iYqK4tq1a0yePJmLFy/SpUsX6tWrx/z587l8+bKlL/UaKM13oTgCAwP58ccf2bt3L9WrV+e9994jOTmZJk2aFLtdScdamv2WdH/Mzs4mNjbW8vrChQtER0ej1+stFrdJkyYRERHB3LlzeeSRRzh48CCffvqpxZITFBREt27dGD16NJ988gkODg48//zzODs721wH+T8bAKPRaPlupqen89133xEbG8sLL7xgcyzquPJSr169YifyQ8n3YNWa1LJlS9q1a0d8fDyvvPIKffv2tfw5nTJlCg888AD16tXj0qVLzJ49m7S0NB5//HFAWOMmTpzI3LlzadiwIQ0bNmTu3Lm4uLjw2GOPFXv8xdGoUSOGDBnC8OHDeffdd2nZsiUpKSns2LGD5s2b07t3b1auXImDgwPNmzfHycmJw4cPM336dAYNGmQJ6Bo7diwffvghkydPZtSoUezbt48vvviCb7/9tlTj8Pf355dffuHUqVPUrFkTd3d3Ll++XC7XjSr0JkyYwIABAyzfBUdHR8tne/DgQYYPH86vv/5KnTp1aNKkCT179mTUqFEsWbIEEKlX+vTpU2CK03fffYfRaGTIkCEFjqs0527mzJnce++93HXXXQwePBij0cjmzZuZNm1aqc5dmajoSYGdO3dWxo0bp4wdO1Zxc3NTqlevrrz44ouWQIbHH39c6dy5s802W7ZsUSIiIhRnZ2fFzc1Nadu2rfLpp58qiqIoO3fuLBCyrT7Onj2rKIqiHDt2TOnatatSo0YNxcnJSfH391fGjh2rJCYmlmrMBoNBGTFihOLu7q54eHgoTz/9tPLiiy/aTHovLECjuONUlMInBN99993KzJkzLe+nTp2q1KxZU9Hr9cqgQYOUBQsWFEgjUtix169f36bN3r17lXbt2ilOTk5KgwYNlDlz5thM2C0s9Urbtm1tUo/k/2zyp/VwcnJSGjVqVKDvzp07FzpG9TiLm5hbv379QrfNy6JFi5SmTZsqzs7Oiq+vrzJkyBCbz3bixIlKvXr1FEdHR8XLy0vp0aNHoYENH330kVK/fn3F0dFRadWqlfLbb7/ZrM9//IUFPixYsMDm3JtMJuX9999XGjdurDg4OCheXl7KfffdZ+l7x44dSnh4uOLu7q7odDqlYcOGygsvvKBcu3bNpt9jx44pHTt2VJycnBQfHx9l1qxZJaZdUTEYDMqAAQMUDw8PS+qV8rpuCkuZkP/7d/bs2QKpFLKyspTx48crNWrUUJydnZU+ffoo586dKzD2Rx99VImIiCj0uDZv3qyEhIQoer1ecXFxUYKDg5WFCxcWSB0TGRmpREREKE5OToqHh4dy3333FTi/ealfv77y2muvKY888oji4uKi1KpVq0Aqkc6dOyuPP/64zbKVK1cqISEhiqOjo1K9enWlU6dOypo1axRFKTwFTv7vcmm/C0Vx5coV5cEHH1T0er3i7e2tzJgxQxk+fHiB+1L+AI2SjpVC0tu4u7tbArFKc39UvwP5H/nv9evXr1eCg4MVJycnJSgoyHKfV7l48aLSq1cvxcnJSalfv77yzTffKN7e3japR/J/Nvm/oy4uLkrz5s0LBMIVda9Rj7O44IuSroGcnBxl1qxZyl133aXodDqlbt26yrhx42w+20GDBim+vr6Kg4ODUrt2baV///7KiRMnbPZjMpmUmTNnKj4+PoqTk5PSqVMn5fjx4zZt8h9/YffXCRMm2Jz77Oxs5dVXX1X8/f0VBwcHxcfHR3nooYeUY8eOKYqiKKtWrVJatWql6PV6xdXVVWnatKkyd+7cAkEQkZGRSsuWLRVHR0fF39+/2GDD/Fy6dEnp3r27otfrLfeL8rpuHn/88RK/f+o9Ub3/KYq4poYMGaJUq1ZNqVatmjJkyJBCr8fw8HDlscceK/S4SnvufvzxR8v9w9PTU+nfv3+pz11ZsFOUUkYsSIqlS5cuhISE/GvLLmVmZlKnTh3efffdUpumJRLJvwt/f38mTpz4ry1hmZiYSN26ddm+fXulT3CXSP7N3HEBGpLK4ejRo8TFxdG2bVuuX79uyRL/4IMPVvHIJBKJRLBjxw4yMjJo3rw5SUlJTJs2DX9/fzp16lTVQ5NI/lX862rjlgdjx461CTnP+8g7Z+u/zvz587n77rvp1q0bmZmZ7Nq1q9h5TZI7g2bNmhX5/S1N/UfJv4NevXoV+TlXadmlSiQnJ4eXXnqJZs2a8dBDD+Hl5UVkZGSpAgAkVUtR3938aY8klcP/pRv30qVLRRYbd3Nzs9S4k0juRP7+++8iM9TXqlWrQmtmSiqPCxcuFBk9WqNGjRKDCCSSqiQ+Pr7IdXXq1KmS9CP/z/xfij2JRCKRSCSS/xf+L924EolEIpFIJP8vyAANiUTyn0FRFK5du0ZSUhL//PMPGRkZGAyGAg+NRoNOpyvwcHd3t1QxyV9NQFIxGAyGUlX9cHR0LFUicIlEUhAp9iQSyb+K9PR04uLiOHnyJCdjYzn1559cvHiRpKQkS0lAV1dXfHx8qFatmlXMOTmh0+lwcnJCURSr+Lt5E4PBQFZWFtevX7f0odfr8fHxwdfXl7p169KkSROaNGlCUFAQDRs2xNHRsapPxb8eg8GAl7MzGaVo6+Pjw9mzZ6Xgk0jKgJyzJ5FI7lhSU1M5cOAAe/fs4cCBA5yIjSUxMZGaNWsK8RUURFBQEH516lgscr6+vrdllctrHUxOTiYpKYmEv/8W4jIujri4OLKzs7nrrrtoHhxMeEQEERERtGrVqkANZEnxpKWl4e7uzvNAcWfuJvAucP36ddzc3CpncBLJfwgp9iQSyR1DcnIyv/zyC3t272bvvn3ExsYSEBBARHg4YWFhNA8OpkmTJpbSbFWByWTi3LlznDx5kug//mDfvn3s3beP9PR0QkNDiQgPp2OnTtxzzz3SFVwCqth7FSjOXmcAXkeKPYmkrEixJ5FIqgyTyURUVBQbN2xg46ZNREdH07p1azp36kR4WBjh4eEl1lO+E1AUhdOnT1uE346dOzl37hxdOnfm/j59uP/++7nrrruqeph3HKrYm0XJYm8WUuxJJGVFij2JRFKp5ObmEhkZyTcrV7Jh40Zu3rzJfT16cH/v3vTq1atKrXblyZ9//snGTZvYuGkTv//+Ow0aNKDfgw8ydNgwgoODq3p4dwSq2HudksXeq0ixJ5GUFSn2JBJJpRATE8PXy5ez8ptvyMnJYfCgQfR/6CEiIiL+8xUR0tLS2L59Oz+sXs3an3+mSZMmDBs6lEcfe+xfYbmsKFSxN5eSxd5LSLEnkZQVKfYkEkmFkZ6ezrKlS1m6bBknT56k34MPMmzoULp37/6fF3hFcf36dX788Ue+XrmS3bt30+3eexk1ejQPPvgg9vb2VT28SkUVe/MoWey9iBR7EklZkWJPIpGUO2fPnuWDRYv44ssvCQoKYsyoUQwcOFD+UOfj3LlzrFi5ksVLlmBvb89zzz7Lk089hbu7e1UPrVJQxd5bQHHFs7KAF5BiTyIpK7KChkQiKRcUReH333+n/0MPERQUxIULF9iyaRMH9u3jySeflD/ShVCvXj1emj6dM/HxvD1vHqt//BE/Pz8mPPdcsbVF/2toS/GQSCRlR4o9iURy20RGRtKxY0cefPBBGjZsyOlTp/hu1SrCw8Oremj/CrRaLQ8//DB7du3i123bSElJITg4mGFDh/5fiD5NKR4SiaTsyGtIIpGUmX379tGtWzf69etHz/vu41xCAm/Nm0e9evWqemj/Wtq2bcvKFSs4eeIEDg4OBAcHM2rkSM6dO1fVQ6swpNiTSCoWeQ1JJJJbJjo6mj7330/37t0Ja9eOs3/9xYyXX6ZatWpVPbT/DAEBAXz5xRcci44mMzOTxo0b8+z48SQnJ1f10Mod6caVSCoWKfYkEkmpuXr1Kk+PHUtERASNGzfm7F9/MfuNN6hevXpVD+0/S6NGjfhm5UoO7t9PYmIijRs3ZuGCBRiNxqoeWrkhLXsSScUiryGJRFIiJpOJz5YsoVGjRpw7d45j0dG8O3/+vzYBsgmN5fFvoXnz5vy0Zg1rVq9myaef0rJlS37//feqHla5IMWeRFKxyGtIIpEUS1RUFOHh4cydN48vP/+cDevXExgYWNXDspBXuBUl4sq67k7k3nvv5Y+jRxk+bBj3338/Q4cMISkpqaqHdVvYU7wL9/8r+6BEUv7c+Xc2iURSJdy8eZMXpk2jc+fO9LzvPmJjYujbty92dnZVNqaSRF1RbW91H3c6jo6OTJ0yhbjYWIxGI02aNOHrr77i35o2VVr2JJKKRc57lUgkBfjjjz8YNmwYjo6OHDpwgKZNm5b7PooSVRpMJbapaArbrzquvOvyjrUqqFOnDqu+/ZZ169YxaswYfl63jsVLluDp6Vml47pVShJ0UuxJJLeHvIYkEomF3Nxc5r35JhEREfR/6CH27dlTIUKvOKrapVq4U9hU6PqiXMiVPfa+ffsSc+wYJpOJ4OBgNmzYUKn7v12kZU8iqVikZU8ikQCidNejjz7KlStXiNyxgzZt2pT7Pu5UF2lZLXT5tzOhKdQCWB77KgkvLy9+XL2aFStWMHToUB55+GHeX7QIZ+fiCpHdGZSUXkX+UEkkt8edeeeVSCSVyvbt22nVqhXBzZpxJCqq3IVeeVi7jEbxKGxZccsLWw8UarW7XfJbAAujIi1/dnZ2DBs2jGPR0ZyIjaV9+/acPXu2QvZVnkjLnkRSschrSCL5P0ZRFN6aN49+/frxzltvsWTxYlxcXMqt/+KETV4BVpg4K0qwlUbgFYdF4N3KjkrbeVH7KoSKtHLWq1ePnb/+SkR4OKGhoWzdurXC9lUe2JXiIZFIyo60jksk/6ekpaXxxIgRHD5yhN927qR169bl1ndxQia/ltJqrcvyvi5u2/xoi7mT5V1XqMjL2zDvMr2+8J3qdKXfed79msl7bvK6fcsbR0dHPvzgA9q1bUv//v2Z/uKLTH/pJTSaO+8/vhZwKGG9RCIpO/Iakkj+D0lISKB3797UqV2bqIMHyz16Uw1eyEtekZf/WRV9BkPBvorSUnmXq9sXtt4iptQdpaaKHRVmqTMYxCMjQzxCQgoO2MfHdie3KP7yz+lTnytK9A0bNozg4GD6DxzIkSNHWLFy5R03j09G40okFYud8m9NzCSRSMpEdHQ0vXr1YuCAASxcsAB7+/JNWVuUVU8VcnkFXWGWurzWPq3W9jUUXKeSdz2Axpht3aHRKJ63b4f4eKvg69bNulNV4KWkQGIiJCRAfDyZSUm4vvaatXOdDnr2tA7Aw8Mq+PIPohRUtNhTuXLlCg8+9BAA69ato0aNGhW6v9KQlpaGu7s7PwOuxbTLBB4Erl+/jpubW+UMTiL5DyHFnkTyf8Svv/5K//79eWn6dKZNnVohCZKLsuhlZFiftVrrs2rR02qFBlP1VEYGeHoWFHSqWFS3LeyhMWaLziIjITlZPBISICEBZd8+MoBswGR+ZAN127SBxESykpK4BFwC4oEM4BGEdckRcHJwEBa/sWMhMBCCg60DAltLXylFX2Xl7svKyuKxIUM49eefbNmyhXr16lXYvkqDKvY2UrLYux8p9iSSsiLFnkTyf8K3K1cycvRoPvnoI4YPH17u/Rcl8gwGobtUVJGXmip0UUqKeNZqhSbT6axiz8NDTJ0zGMRrrda2vdqPXi+EoV4PLlqz0NuyRVjy4uIgJoYrWVkkAseA60AOVvdgnuHhD6QgRF5efAAX8/qObdqAnx/4+wvB17OndeCFib1SiL7856+iRF9ubi7jn32WdevXs2XLFpo3b14h+ykNqtjbTMlirxdS7EkkZUXO2ZNI/g9Y9P77zHjlFX784Qd69uxZrn2X5LZVhV5KivW9KuxUK158vHhOSBCiLSVFPHt6ivbqs05nKwhTUoTA8/DI403dYhZ4cXGQkMC1Q4dIAM4ACRQUcflJKGJ5svn5KpBw6BA9Dh3CG7Br3lwo0379ip48mD8QpBAKm8tXEYLP3t6ejz/6iDp16tCxY0c2btxI+/bty30/t0JJEbcyGlciuT2k2JNI/uN8+MEHvDpzJtu3bqVt27bl3n/+YAx1ipwq5lJSbMVdYqJ4TkiwFXp6vXit14u2qtgD8ezhYXX3gq1mUtcBEBUFMTHiERdHHPAX8Ddwa4lTCicV4frdBAQBrY4fx2nZMmHlU82Lfn7WaF51sHkDPW7RvVveos/Ozo4ZL7+MZ82a9O7dmy1bthAeHl6u+7gVHCg+Gre4dRKJpGSk2JNI/sN88tFHvDxjBr9s3lwhQi+/VU8VXMnJwrCm0wlxp9dbxV1MjHiOi7MGtsbHi+fERKtwU+MlMjKEpzQx0aqlQDznteo1MMTC6hjYvx9iYrh5/jyXgUTgPLZCT4NwyeqBpsAO83I/INC8TmveZlMhx20EagAG4E+g9smT1Fy7FoKCxBw+dbKhXl9QneYNP65ixo4dS67JRK9evdhaQX8GSoMdxUfcSsueRHJ7VP3dRiKRVAifLVnCC9Ons2XTJsLCwsq176Lm56WmCsOa0ShEnWql0+utIi86WryPixOaSLX0pafnYGfngE5nFYGqJkpIsBV5fn6ijYeHeK69f43oKC4ODAYyz5/nKkKUNcAahGEHVAMaIcSaJ2D/9NN07NMHunQRrthu3aw7y8gg9YUXABGc4YaYs7ffvG0NhFtYB2KQ5m3UwZk8vdFg4lyixnJMjqVIzZL//FZkPr5nxo3DaDRy3333sX379nLNt1haZOoViaRikWJPIvkPsuzLL5k8ZQqbNmwgIiKi3PsvzHULVkEXGWkVdapQi44W65KSriDkUSbXrrkCauoXexTFhFarsYnY9fGxuoLBaukLDgaXlHPw4WKxMCFBKMvERFw7dsTVHIXrk55ODcTNTgd4AA7du4uI2pAQLnV7jC1bYP8U2BK/leTdMH++2JdPIOh/mYZeDxGrnhMq08ODHmPGYO/lBWFhZK1fL/LWpaZa07rodNCnDwDnEjWWeYpGI3h6ajAarXqytCKuIgXfhOeeIzc3l+7du7Njxw5CQkIqZD9FoUXWxpVIKhJ5DUkk/zE2btzI+OeeY8O6dXTs2LHC96emqEtNFYa17duF+FPduKdPm3B21pCVdRbhVFXjLj0R9jITVtuNPenpmWRkuHL58iXAjeRkHUajMLhptRAWJvp1iT8mVKWaQ0+rFSpNfR8fDwkJOMfHE6BOAvTzE49+/TAFtyAqCpbNsnh+ycmJBzJ55hkDkI2zc0f0erG/LVsWWY7XeHg0rbTHwMcHJ09veHGa6LdLF1i1yuKv1qSm4tmhB6mpQodmZFjnNKqWycLIH6yhUpGCb/KkSWRnZ9OzZ08OHDhA/fr1K2Q/hSEtexJJxSJTr0gk/yGOHDlCly5d+OKzz3j44YcrbD95RYiaPy8mBjZsEKJm+3Y4f/4SwmoXixB48QhH6DWgunlrX4Tou2Zu4wjEmdtlAg3w9a2Hn5+w5r34onh24QbZWhccUy5aql58HNnUkqrF01OIQk3iOfYm1kOvF2JUFV3791syspCefgSRVc8bIUYzEYlZshG2wMaAteJEx47B6HRit4MHC4Pi9u0wZYrwJE8bfE4MYtUqEbQREgIeHuyNdrGcK4NBHIc6Vhdd0QKuslKygKiV/Oxzz7EzMpI9e/bgUZQaLSfU1Cv7EPMniyIDCEemXpFIyooUexLJf4Rz584RFhbGpIkTmTplSoXtJ6/4UKuPRUUJobN2rVi+eXOqucUh4Lj5da75WXXdqj/aqrCzR8RdGoBWqLPkRo3yICxMiCM1vcqWLWJL1TW6apV1fp+npzD4eXhYdJYlTUtqqtXje/myyTy+a+b9ZyIEXjZwBWFPcjaP19c8rjSgo3lsmLdpCqTg5eXN5cupPPusBwCL5mdzw+hIVBR0CrzIOWNtNa8zRqM1YDcoCGp43BliD8BoNPJQ//7cyMpi8+bNODo6lrxRGVHFXhQli71QpNiTSMqKFHsSyX+A69ev06FDBzq0b8/HH31UIZUxoPDo2+RkIaK2bxeiKyEBrl37A/gVyAJOIQSdG1DLvKWaeNgTIQKrI4RUBJBJ166BFkGkPoKCxBZ+fsIqFxUlhJxqqVPHoc6P02qFQNTprKlgMjJEIIgQeDmI7HsG8xjyJvgwAYexClR1mStCDBoQoR+5QDBC9Lman3MRAtBA164BJCfDjBlCDHfoYJ27qB6fmrFFTTNTlJirrLJqABkZGXTu2pXmwcEsXbaswr5Pqtg7QslirxVS7EkkZUWKPYnkX05ubi69evZEq9Wy7uef0VZgSo/87lt1bh7A4sXi+dtvDcBWhHVsJyIznQ5QKzV4IyxlAG2ANMLDG5OYKApR+PtbYy2io4V1bsYMCA0FTUYaaLWcS3EhPl5Y61JSrIIvMdFaZk3NeqLXi2Vq7ERGBiiK6qpVxVw2QmyCsDDmIsTdfvM6e4Q172+sFr9r5uWuWF3Qnubjy8Uav5tG9ertSE2F8eOFaFWrg+QVpKroMxrBUVv1gi8pKYl24eGMHjWKGa+8UiH7UMXeUUSUdFGkAy2RYk8iKSsyQEMi+Zcz89VXSbxwgQP79lWY0CusSoZap1a1pmVkwPr1l8xrjwMH8rTWIcRUfYQw8gPc6NXLF53Ol8GDhdUrMVG0/vBDq5vTwwPa+pyD7ebEfEYj9fz9qddBT5rBkZgYIQoDA60uUrDOh8ubjNlq/RNBIunpalIWR4RtSYMQcKobt6d5/KnmY+gO7DK3aYw14OQKQuipwq86QvCJOYrXrkUCznz+eTv8/YVwTU0VQjZvdTXVFe3hoSlS8KmfR0ULPl9fXzasW0dEhw60bdeOHj16VNi+ZDSuRFKxyGtIIvkXs3nzZt5ftIgD+/ZRrVpxtpHyI2/NW7VcWVSUmhj5CkIApefbKhUhqAIBPXZ2rRg4UFi5Xh95TnS2IZLaoaFkB7di5Egh9pKTIcL/IhiMItdK3hpsBgNuQGiomAunztFTrXtq+ha93lqqLW8AhzgODUajjoQEobjUMmxabR08PYXVUpR087UIRw+PR9i82YCzsw69Hi5f/sN8XKewunKrAzrs7BxQlKYI0XeGrKwLnDzpilbroaYEtMmxnJiYx/Ws1aDT2Ubm5k15UxmCr0WLFny4aBFDhgzh6NGj+Pn5Vch+ZDSuRFKxSDeuRPIv5dy5c7Rs2ZL3Fyxg6NChFbafwubpqXPgdu8Wy1atgm3bVKver8B3lq2teACjaNJEpDPp1k24bTt9PlwoMz8/YfLy9xcPrdY6Ac/Hx7rjvArJnFX5XKLG4tbdvdtaT9ccqGuxPKamWrtQUevzqg+DwZoDT7UG6nRieOpQgoNFJK+/P6xYIZYFBYlo5OPHM7Gzc8Xf3zpUNd+golxBuH/VqOT6tGkjUsv07CkOX6sV/fv4WOce5iV/WpbKcOk+NXIkcadOERkZiYND+RUvU924sZTsxm2KdONKJGVFWvYkkn8h2dnZPPLIIwzo379ShR5Y3beqeFq2TLXq/Y1wcYotbQlEzGVrYClQMXfEnzBypOhELS+hKqqUFIv6Mvk3EIJGDakF2ygMoxEPD0fLHLgRI8TqmBhrBC5Y3aV5taIq/vz8rMvyCj41H56/v1iuVuzw8RHFNlJTxSHkreXr7+/KsmViLGquQXWOnkgifQ0RBZwJnOPQoSygDTqdryVyWLUiqpbJ/J9JXoFXGRa+DxYtIiwigukvvsj8d98t9/5lbVyJpGKR1nGJ5F/IS9Onc/PmTRa9/36F7aOwkmh5jWsGgxBBwcGQlZWKcGPGA9GF9BYCNKVhwzr07Alzh8aKPC2JiUKRhYaKpHXChyo2MaunjAy4YdBYk+RFR1tDa82T9LRaS3ELS/qVDh2siYtVXajW01WDN3Q6awBHRoY12EOt7ZuYaJ2TaDQKN3FwsBium95EvZhNOEZupV7kcly2r2PyyDT6d7nKusUXGTlSWPtUoSisidcQOf1yzY8zwBHgV/btu8ALL6QTFSX2vWGDdb+FfTYaTJVi1QNwcXFh9fff89nnn7N+/fpy719TikdZ+PjjjwkICECn09G6dWt27dpVbPvffvuN1q1bo9PpaNCgAYvVqCMzy8yRyfkfhrymYonkDkRa9iSSfxm7d+/mk8WLORIVhS7v7P5ypDCLXl4yMqzBFMJy9jdwFhHEkJivdSBwP48+WpPAQFFkglnLRAceHlbTmmo6y/M+26gBA7gkn7HmWwGr9S80FAwGXPz8cPH3JyNDYymvZjAI0adGDasPVTzl1ZWqCzevoFUtgqplzcdHiEBLUEVCgm2ZNr1e+JDNobW9e/ak9woPPl4mkinrdHDokB6rCzfX/GwA/kBEB7uyYcMj6HRCrKr1hVVxWtRnVBnWvUaNGvHB++8zevRoTpw4QY0aNcqt74qYs/fdd98xceJEPv74Y9q3b8+SJUvo1asXsbGx1KtXr0D7s2fP0rt3b0aNGsWKFSvYs2cP48aNw8vLiwEDBljaubm5cerUKZttK+o6lEjKCyn2JJJ/ETdu3ODJJ5/k9ddeo3HjxhW2n/y1b8EqNlQjhiqahCj6AyH4CuN+AgJq0q+fuVrEik+FaFMnp3XpYlVeGRlC2ZjDZh31ehx1OmHNU32z6kS6wECrn9RohPh4Guj1oPOnnodQSEajJm93ltJu6vGolj312NQhgLDIeXhYU7modXqjosSwG/j5CcGq+otVXy6I15GRoNMxYkR/wsKEuzs6uho5OY0R+QcNiECOVOA0kAL04tq1LWzZ0hOtVpTXjYsT+8vvzs1PZQi+YcOG8f0PPzBxwgSWf/11ufVrR/GCTs3yl5aWZrPcyckJJyenQrd57733eOqppxg5ciQACxcu5JdffuGTTz7hzTffLNB+8eLF1KtXj4ULFwLQpEkToqKimD9/vo3Ys7Ozw0eddiCR/EuQYk8i+RfxyowZeHp6MnHChCrZv+oOVYXSsmUiv52Yj+cNxOTbYijQgH794BGf34UIWrhQKCm1JIaaBC8lxTa7cHS0dT2IrM1qYj2dTigv1bKmhtmCdaKepydNgzwJCtIQGCgWR0eLZ9UopxoTdTqrcU4NwoiPF+s8Pa2iUI1AFprTkXohIdbxREVZ5x8ajZZQZZe4I7Ty8yOljzchIbB6tQObN9dGuHOTEMLPhIhkXgHU4/x5X7ZsuduSekY1fKqfQVFUtOCzs7NjyeLFBLdowfr163nggQfKpV8tpUu9UrduXZvlM2fOZNasWQXaZ2dnc/jwYV588UWb5T169GDv3r2F7mPfvn0F0svcd999fPHFF+Tk5FgCUzIyMqhfvz65ubmEhITwxhtv0LJly+IOTyKpcqTYk0j+Jezdu5fFS5ZwJCoKe3v7Ct9fYdY9EDrG01NotW7dhOXp9OkAxPyzS+aHDlFhojleXgFMmQJ0GSk2DAqyumG1WqGq8ogjS6bmvNmHVZ+quo2np1imWvX8/a1WQZGozhIZodFq8fd3sbh11RJrBoNVM6oaU53fFxNjtaapw1LduKqlMD4ejP5u6Dv0xzvwmDgZW7ZYj0FVavHxoNUSEuKNp6cQmrt31yE9/RDCpXsJEYuqpqs5B2zm7Nk9vPPOg3TsWIfQUOvYS6KiBV+dOnVY+N57jBkzhg4dOlC9evWSNyqB0rpxz58/bxONW5RVLyUlhdzcXGrVqmWzvFatWiQnJxe6TXJycqHtjUYjKSkp+Pr6EhQUxLJly2jevDlpaWm8//77tG/fnj/++IOGDRuWdJgSSZUhxZ5E8i/AYDDwxBNP8NqsWRXqvs2PKvjyigc3swHN01NjKWN2+nQtRFUJX0TC4VZAIN27NyEkBGrvX2Odo6dawkBY6/z8sKgg1Zym04n3ao00EApLFXpq6QnVzJiaCkFBmHr2tszNw2jVhmK8EBYmXqt57dTIV40xG4xGbuCCizabFoFCDd7Q1cAl5ZwQbqmpQCrnPFtZcgCqRkStfwshIgPbUiPxmJi7p9dbIzPi4vD298czxI2UFHGI8+f3IynpY+AfxHy9vOxFJHQ+zK5dNYmM1FnSu9wJDB8+nO9/+IFJEyey7Kuvbru/0oo9Nze3W0q9kr/Mm6IoxZZ+K6x93uVhYWGEqV8ioH379rRq1YoPPviARYsWlXpcEkllI8WeRPIvYOGCBbi4uDBp4sRK37eNlUjNTwJ4eLjkCXKIRVSU+Bvhzg2kTZt72brsIoSF8fc75/EA3JOTreazuDhysrLQXL6MvZcXmZcvkwa4XbuGq52daOPvb42WUIWeXi8CM1QxBdClC6aQViQnC2+qarVT59qpxj51cw8Ps8AzGCA5w3J4LoZka1I+vR6X5P1CdOr1Qqzq9dTT7od+/WgQ4sGfiS4YjcIQqc5hDAtrgaMqQPNaJnfvRhMcjL9/PXXIfPtta2APBcUeiPQsfsBxPvywDf7+1qoiFVgRr1TY2dmx+JNPaNKsGWPGjiU8PPy2+iutG7e0eHp6Ym9vX8CKd+nSpQLWOxUfH59C22u1WmrWrFnoNhqNhjZt2nD69OlbHKFEUrnI1CsSyR3OxYsXmTN3LosWLqwU922xmCMcTDoXi9FqwwYQrsivEHPQ7IFOYvmIEZw9fx4jYMkgkpxM5tGjnMrKIhG4CJy9fJmLiJCFa8A1RSE3J8dawkKdj2cwWMWTVV1BUJAlViJv9K2aoSVvcmVL7r28YbnqseWNQomLE0JPneynpn5JTBTzDiMjaRS/iaZ+aXh6WoVYaiqk+TUVQlWdyK8m24uKsqSr6dMHwsPbAV8Adxdysq8gRDSkp8eYAzwKT8VSFdStW5dpU6cyYcIETKbbcxuXd+oVR0dHWrduzbZt22yWb9u2jYiIiEK3CQ8PL9B+69athIaGFplIWlEUoqOj8fX1LXS9RHKnIC17EskdzkvTp9O7Vy86duxY1UOxzoNLuURsijcrVkBOTgwQhxB6DwHw6KMOeK9ahLJtGyZE7QwdQGoqN9PTuWTewtG83MX80CFuShnm52qpqUJBBQba5k3x8BDPanK91FQ8PFwICbHmzFNr4porq1lEH6hVMVwsHmMfH3BMuSiEnRqyq2aNVucLqhEd6rply4RfdfduGoWEiDl7OgN4+oiUMUadtYwHWMyNjtEH8Qxpi6enSONiMOg4erQPIk+hId8JPwXUAuzZt8+NZcvq2Ux7LIrKiMwFmPL883zx5Zd8/dVXPP7EE2XupyJSr0yePJlhw4YRGhpKeHg4n376KefOnWPs2LEATJ8+nQsXLrB8+XIAxo4dy4cffsjkyZMZNWoU+/bt44svvuDbb7+19Pnaa68RFhZGw4YNSUtLY9GiRURHR/PRRx+VYYQSSeUhxZ5Ecgdz8OBBfli9mtiY/FGuVYQqhHQ64uNFdhGRRPksYr5eFw4fDqDV7kXCzAZ4Iqx62UByejonERnmzgM1EULQiJA5GvN7b/Nreva0RreqrlSdTjwHBwvV5uMDiYm46eJx8/HB28MDk783qkcuJsYa7KsegsFg9QoHBorngQNro1ET7gUHC39wSooabiw2VMN41ZDe6GihvGJiRPvQUAgMxDFvaQ411FedX5iRgSPZeHg4EhIitGR8fDvS0wchrKN5uQL8hCgW5sDXX7sRGOjB0KHWYiNViYuLC++89RYTJk2i/8CBZa7PbKfVFj+XTlFu2aQ5aNAgrly5wuuvv05SUhLBwcFs2rSJ+vXrA5CUlMS5c+cs7QMCAti0aROTJk3io48+onbt2ixatMgm7UpqaiqjR48mOTkZd3d3WrZsye+//07btm1v8YglkspF1saVSO5QFEWhffv2dO/WjdcKSS9RJRgMFsH1ze56jB0L6ekrEPPL2vPoo4/wzfi9wrebkABbtnDl2jVSELPSLiAseiCyy9VDiDsNwqqnQ8xS8wFc27QRrtCwMKFq1KK3qanWlCw9e1pLeajhtj17kqatQUyM8MSuXi102OXLqtUs1zwaB7y8XAkNFfPn/P2tEbmqwdAx46oQdAkJVtUYHy/EW94iu2qkCgihqM5LjI4WHaspWTw8hLo0C8pjyd5s2SJE8+bNmcBGRPqV/DggoptbUb36o3z4oRhzSeneKsO6pygKnbt2pX1EBG/Om3dL26q1ca/rdLgVI/bSFAV3g0HWxpVIyoi07Ekkdyhr164lISGBaVOnVvVQrKjWFYPBMu9MBBnYAw/xzbJsWLjbEiWRde0aSQgH7w1EMTU1HMIRkV1OTZOrijwtwsrnajRaVZjBIJSNallTIyIyMsRzaKgoOREaCjodUfuxiL2MDFXoGQB77OyqWQJ6VcuY6uJVcyOrWV0igrVWE6CaUTnPhjk5OdwAOHsWt7NnsQsIsI5LTdYXHy9e798v/LZxcULA6vW0CNaTEORCQgKEh7uyb19fnJ0fISvre2xFXw4i8XI2165VZ9mynnh4iEMuKdlyRWNnZ8fC996jQ6dOPDdhQtnmr2m1UIzYQ9okJJLbQoo9ieQORFEUXn/9dV6YNg1XV9cy93HmzBlq166Ns7Pz7Q8qX0BDi0AT48dr0GqbsGFDE1asAMY+Cfv3c+XkSTRYM++dA/JnN9MgBKAeqyvX0fyo2bIl9OtnnZwWFSXStGRkkG4O+NABmuPHcfLyskRH3PBrZKktq4q93bsxjyIRyEJRMrl82RWoDTTGx0dDdLQwWKrxH6rBLjLQDa22E9NGXsWSbyU52fLawccH99RUcpKShBtSp7MGlajzDcGaSzAxUQjHuDjLvMOePdtaSgR37KjDwwN2736Ea9cyES5cFRPCXf4r27YFEhwcaDEoVrU7t1WrVvTo3p2333qLBeYKFLeEkxNoipmZZzJZk2tLJJJbRoo9ieQOZP369SQnJzN61KgybR8XF8f9D/ThzJmzDB0yhK/Nk9DLTN6gBTWvSUoKEZ6pRCz0hA+1MHEi15YuJREh7K4ibjBqmuX8+CDm8ZkQws8TEaRRy9lZWOhACKboaFixgvNnz5IKXAe8gBrm/p1SUsS4goPZvdsaQKuW2VWUHIRtMRGIxLZ276McOtQc8MPOzsMSNJGYKPTc7t3idXx8DUJDazB6fgjMni3UlbojPz8c1AgQ9fx4eFjXq8Vt86StISVFdB4WhqNWS8+erUhJsWaaAVi//lEgE9ia78ydQojAqaxdCyNGiLEWRmUFagC8+sordOjUiRdefPHWy4lptSWLPYlEUmbknD2J5A5DURRCQ0MZOmRImfPq7dq1i05dulC/vh8GQzbJF5PKPiC1uoU6Tw2sZcq2b4foaM6fPEkq8CdiLp4TYmbcJazBGXkJNre5aX5fy/w+EERFhoEDhckqOVnM/0tM5GR6OqnqkBAWwHqAb3g4zJgB3brxZ4IjcXFCH65aBSdPpiJqzv4N/IhI7LKUatV0pKf3NfcWADRE5AnMBpojSpilIpzMdwNuTJqkIzBQDM179xpxLtRcL2p0sJq+JSNDrFPTtYA12V9QkDXdS1CQeISFcUNXg7VrxdhBGDN37jwHrAaOI4I1VDoCz/Puuxo8PIQ7Xa0yVxiVJfj6PvggjRo1Yv6775aqvWXOXp06uBUj9tJMJtwvXJBz9iSSMiItexLJHcbGjRtJTExkzOjRZdo+MzOTEU+KNBjJyZfo2OHWUrYUsAalpooIAjUi2JyZOH3MGFYhXLGp+fqoiZjFZ0TcZPKKvbsQIs0EXAbUf5u+QPVq1bCEqEZFWSJgj2dl8be5nbu5TxNCTPqaE+ddzXC0TOfbvVt4TkVgwzXgCMImmImSK2YL2tk/i7CSbUWIqRMI+2JdhJjqSvPm3Tl+fC9wigULBtK1azU8POCxwf2E2PX0FOclOdlq8TQarRG9ycniWfXTqrXW1JQsalWR1atxCQ0lNLSVZXFYGBiN9di1q5f5yJPMx3IJ2AX4sXjxo8yeLQRit26l+XQrlldfeYXOXbsy7YUX8Pb2Lv2GTk5QXA7J3NzbH5xE8n+MFHsSyR2EoijMnDmToUOG4OLiUqY+7OzsOHs2AQCjMZd+/frd0vYFrEA6HXz+uRjfzp3YVasGGRm8V0wfV7DmTsubOa4GQuz5IoqEgbgJ5ZofZGQI5RISIvYbFcU/WVkkm9eLEAth1athfqjJ9dRA3eRkEQuRk6Na7u4H2qPkPm8zRiX3XpKSmrJg4d98uXQpV65cQQipm4AbWu0y2rfvxvHjl4EngbOkprYAIC1Dg5sacevhYU30rM7N8/ERj+BgcUyqlVItzAtC/KmTA318wGCgUWAayYFuluIbYWGQmtqE48dVwarW0gWI5PTp5mzYEMzEibY5oauK0NBQunTuzHvvvsu8t94q/YZabfFir7jgDYlEUiJS7EkkdxAHDx4kJeUfevfuXeY+XFxc8Pevz9mzCYS2bs0z48aVfUBqqbKBA7n+zDPsB9LS00uV5NaEEGWq2AsDmplf5yAcpOlANayRuVcUhZparSUk9srlyyQiLIc3EELvCuCK1Y2LhweEhNDALxtwRKeD9PRDwMvs/DWT9xctYuKERpw5c4af162jTu3aaLValnz6KTt27qRaNT0DBz7A2LGPM3PmW2zYsA34i/DwMBYvXmwe8Y/Y27ty9OgkHn/8NW7e1EB8ijUIIz5ePPv45CmYaxZ2aqqVoCDRJioKMjLI7tYbxy3rLJU2Lhq90Rmtgb+JiaKbkBCIj48gK8ucKBBXxFy+JOB3tmwJtqRhUaOMC34WlTd3b+qUKQx4+GFmzppV+sAgKfYkkgpFij2J5A7i0yWfkJaWwT1du1qWpaWlsXHjRh5++GG0pTTdTJwwkcjISHr36lVy4+JQI0gXLiQFEVV7sZSb1kSIOnV+XSDgV60aeHpy7exZS+WMTIQr14AI2nC5fBnd5csYEAIvA+u8PyPCwncTEcWrAWtdtJQUPD1r8+abV/h6eRzfffcdPXtv5+bNm6z9+Wc0Go1NWa/w8DbMmfMSjzzSFw8PdwAmThzDhQvJPPRQb556aghvvfUBw4Y9jNFo5OOPl/L117MxGvdib/8KymE3IVLUuYxxcUJtqUV5VZduaiqmgY9YUrsk0Im4REhdCN269UULpMSIpqpmVFO/qDEeWVmZ5jMFIuX0WfPrU1y+fJLIyCaW5NBVTefOnfH19WXVqlU8UdqqGjqddONKJBWIFHsSyR3C5cuXyTUZSE29zsGDB2nXrh2ZmZk81L8/O3bu5LPPP+e7Vavw8vIqsa/nnn2W55599vYHZQ40yDl9mquUXui5INKp5CBCH3wRiU7UahgahGhzQYg41fqXjLgpOSKEnmrVM2AVfSas0bjVHRysefiAsWOhVy9HRo4axc2bIvyjSZNGdO3anoCA+jz2WH8mTHiZDh3a8fjjgwqMu3Xru9mxY43l/WuvTbO8XrRoLklJl9i+fQdwBbvWgxg2bDrx8SId4O5oYbx75cn9fDFkCEN1OgKfeQaCgy1CLiPDmnovIUEkfE5MtK3moWZ2UT3E+/eDg4MrOTkNEPZQX8TcvVTza19WrxYeYzWfc1ViZ2fHM08/zUcffcSIESOKrYxhwd6+6n3QEsl/GHl1SSR3CF98/jmTJj3NoUNH6dajB7179WLT5s3k5OQwZ85LLFiwhMeGDGHb1vypOCoAgyFPsrlIEhGhC6VFg9U964ewRTk7O0NGBplJSaQhom/tEfnyUhDiThV+LuZ1BqwRu6plz4hI63IVuJ6Tg3t0NPTsyabo2oSEQNfOsWzefJN1677mxo0smjdvQu3a1lQgn31W3GzD4hk8uB9//HGCK1eO4+p6BienMwwcEMTVq1fp2sUeNzc3gu97g7S0NHZ37Mj23bth8GDLXEK1ypqajUVND5OcLAyDasqYmBirVzgrK918hrIAZ4Tgc0OIvbPAfvz8elpiP9SKb1XJ0KFDeWH6dMuflhLJm+FaIpGUO/LqkkjuAHJzczl2/Ahjn36YX375nmnTXuOPP47x7LNPMmhQP+rXr4tGY8esWfPJzs7G0dGx4gajukXVKIGQEALWrmVXVlapu8hACDZPhLtVb+43PSkJA0K46bEGZlzHWuxeFXxq/j1XhNTJG+iRZn6fDaDXkx0aQfIKmDbFxJinv6R6dQ/atWtV7udpwIA+DBjQh6Skf/j006/ZsmUHK1Z8jbu7G0ZjLtevp/Hggz3JzLxBbGwqyoQB2C1ciP7F1y1eXTUln4+PNf1eaqolwwyJiaAomVy7BufPi4ofivI3IjDjb/MZq45wqicBsZw+fTeRkb4W73FV182tVq0ajw8fzkcfflg6safTFT/gW6yLK5FIbJFiTyK5A9i6dSsDB94PgF7vyscfv12gTevWd3Pz5k3WrFnD4MGDK24wal64/fuFClm8mD+ysmxSEZeED0KshQB2zs5C6CmKJSmyAtghZEs2wuWbjrAEZpFHyCFuUkUFhHgCdOmC4/7feXJEB3744Qc+/fRT5s2bUaGC2Ne3FjNnTmHmzCmoqUoVRSEnJwcnJye++GIlW7bM4uW9e5k7aBAuhqv4+9dQcz9bsraows/PTyzfvVtNz+dKeroBSENRriHsnJlYz1hecoGzREf7EhwsInjBGlVtKlU4Tfkz7umnadm6NYs++ACPknzLJblxZTpYieS2kGJPIrkD+HntGubMnVJsm9at76ZPn+4MHT6c7Oxshg8fXjGD8fQUQi8yEiIj2XX5siVZsj+QUMLmHkAPIKBhQ1EJw8MDNmzA8fx5QEgTVX6oKVQuIdy6BvNrHbbBGXmteiDkzg1z2+wxY6ibm8u1a9cYPmIEAwb0YfToCjo3haDOSbOzs8PJyQmAJ598jI8+Wsaqn9Zz4fJlLiY54u1djeDgB/D17YxOZ4/BIKYbinyA4rQPHmzNx7x/v47oaB2KcgRr1Q83hDXPF5Hs+Qxi/l59AgPFqY6PF7rJx0dE4FZWFG5+mjRpQnBwMD/99FPJgRoluXGl2JNIbgsp9iSSKiYrK4tc003si4tGBDQaDUuXLmLy5Fd5/Ikn8PHxoUePHqXah9FoLF0kr+pTjI+H5GQuX75MKkJq+AEdsIo9D4QAdEEILxAizh6zxU3NMxcaCiEhOG3fzo0ffsCEsPr5mfvQICyBKYgAkAxzv3qEqMsoZJgmhMwJAu6uWxeA2NhYDAYDAwb0KV1QQAViZ2dHx45tWb78e27eTKdWLS9OnbrKN98spHr16jRq2JBaPi25fPlN/vijOgaDCM4ICxMCMCNDaJ+4OMjKqo+Qu5kIsecK1De/9zM/nyEmpg7BwcI1rKb1yzNVsVz5559/iIqK4ubNm/Tv37/IdoMHDeLbb74pWezpdODgUPT6Eq4NiURSPFVj35dIJBY2btzII4/0LbkhoNVqef/9Ofj712PT5s2l2mbmrFnU8vXl5MmTpdmBUAtbthCzaxdfIlL5ghB8/nmatgDaYhV6IESYB2ZLXGKisBAmJIgfc39/GlerZqmBa0D827T38sIhIABfX19qY57fhxB8xc3U8lD3nZoKQEBAAFqtlldfvYVkvhXIu+++xuHD24mK2saOHWv444+d/PLL94wbN4KABnVYt24Jb73lQ3JSSw4e/ImoqD288MIx3N0VRoyAnj1FlG+TJjWBVkBThNDzRczZuxshq/0AR86fz2H3biEQ4+KEbq8IF+6MV16hbv369OnblwEPP8yNGzeKbDvokUfYGRnJP//8U2QbwGrZK+4hkUjKjBR7EkkVs3nTBkJD7y51ezs7Ozp3Dmf511/z888/c/78ea5cucLmzZu5du2apd3NmzeZPWcOr7/xBjduZPLyjBkld67m1QsLoxoF3aezzc//AO8Au83v1VofWoQI8wAhGkEkEd6wAVavJjc9HTtzezfAztdXWAD9/CAoCN82beiLqE5b29ymKHRAuJp6BahduzZPPvkkmZlFi4/KRKvV0qBBfZydRWisnZ0dbdu2ZMqUcXzyydv8/PNyxo0birOLA5mZ/Tl6tAMpKXczenQzVq36lZAQGDFCnJ7mzXUIp3d1RESuBiH07kakq/YD7C1BIFFRwhWceCsTLUvJqVOn0Otd6dOnOwEB/sVWeqlbty5hYWGsXr26+E7VOXtFPaRlTyK5LeTfJYmkCklLS8PZxf6W3Y6zZk3l0KFo+uVzofXu1Qs/Pz8Atv+6nYQEUVHWYLhJ48aNS9f57t0wYwbLilidCyzTaMgymagO9MJa+swEdAccAgKE2NPpRD6R5GRunj1LKtYEIpbsIJ6eYrKZWbS5BgbSYft2ci5f5gBwHvgz3xjaAr3mzIEXX7Qsy8rKYs2aNTz6aL/SHWcV06lTOJ06hWM0GtmxYzcuLs5kZ2ezYMESJk7sQXb2ary9HyIkRBhIfX2bkJTkgJiz54aDgwc+Ph6WvM4+PlhqA6ekCLew0QjZRg2O2vKbtzfhuedY/eOPbNiwDVdXVxRFKfb7++jgwXzz7bc888wzRXeq00FxATUaaZeQSG4HeQVJJFXIli1bGDDggVvezsPDnd271/PHHzv55pvF1K5dC4DI3yI5cHAfBw/to3nzxuzZs4EOHUTqiwnPPVd8pwaDmKvn4cG3RUyIn5mbSy6QY15/CfgLMa9Og7DExYE1kZy5ZFjuvn1kIOb7pSBy510Ga/K5sDDo0AH69BHmrIkTcRg2jA7OzgRj6z4Gc3LnmBibZe++9x7Xr18vNFnynYxWq6VHjy506NCOe+7pyM8/L+feezvy5psv0bq1YkmlIrzVvghXbiI5OZfw8BDrunUTz0ajeGRkCGPq7t3WAJDyon379kyaOJHQ1q0ZPWpUiX9UBvTvz759+4p35Uo3rkRSoUixJ5FUITt3/EqLFk3KtK2dnR316vnRq9e99O/fB63WnpkzpxIZ+RM7d/7EsmUfEBTUkNdffwGAhISEkjuNj4foaEKKWP2avT2OgI/5B/5UHouLFjHfrikIM1NIiBB8GRkYsE2pkoJIv5KpKELo+fhAz55kd7iHGx16WKN4w8KoB0RgdRWDmD+489tvhcIxH9ub8+YxZsxw7rrLv+TjvIPRaDQ89lh/rl6N4+TJf/DzE6ciK8uEqEmixixvteig5GQh8FJShAaOi7NmzjEYIC1DjcvV3PY8Pjs7O957910OHTzIe+++W2L7WrVq0bJlS7Zt21Z0Iyn2JJIKRYo9iaSKUBSFxAt/c/FiCZPXS0GPHl0wGnN5550P2bPnoM26bdsisbe3x7OkwqlGoxBZ3brRpFo1xhfTNNFcY3agyUQQIkq3KVALOAZCnXh4WH6otZgteQipooo+A4gADh8f0GpJSRGiBYDISK7s3MlVhDj0zzeGI8DRpCQSExMZ+MjD1KzhwbRpxY3630FWloE333yfGjVqkZ1d02Kpc3bWICSzGpGbxNGjvxITIwTd0aOnOH/+HElJ50hOFgJw3jxYvBi2b7fdR3mIvluhR/fu/LJlS9EN5Jw9iaRCkWJPIqkiTp48yZ49+2nZ8h6mTXsdRVF4++0PmDJl1i33FRoaQt26dbhy5Rp9+w5j1679AEyd+hpvvrmIaVOnEhgYWLrOjEaYMYMbQL0Smo6JjaURcK+DAz2BJkDrXr3E/DvVp5iSggYxR0+94eiwVtEgJgZWrYJ586i9fTneLz4JEydy/fhxbiCqZaRSMDLXE/BwcqJl69YkJp5n5TefUK2ann87R44c4/TpMyxatIbERAd27xans0MHEJa9XITYMwBbuHz5PXMebD0QC5zh2rVDXLuWRFLSORIThfBLSMgjpM2Ul7WvJO7r0YNt27djMhUxd1Ct8VbcQyKRlBlpG5dIqohftmyhdatQunfvzgsvvkhWVhYrV/6Ioijcc09Heve+t9R9OTvr2LdvE337DuPIkWO8//6nnDuXyOefr+D9hQt5dnwpLF7qD6q5UOufiIJchdEQOA1817QpLwPMn4+Tvz93bdggBF5CglAoZoudiYLJkVVrX82kJDRLl1puRhmIHHopCBuWCRGHmm3eRhV9QUA/oxG93oVt277H07Nmycf4L+DAgSM4Ojrj5taWmzeFYSsqSsSx1K1bj/PndQg3bn1gD+DA5cvLEZG5exBJlh2BxwEDmzf/zebNYRw44IBWK6yAqtG1sggPDyczM5Njx44REhJSsEFJrtrc3Aobm0Ty/4C07EkkVcQvv/zC/fffz7SpU3lh2jRWrFhNs6ZN6XnffUydOov9+w+Xuq+sLANffLGSP/44gZ2dHVevpjJ+/HQeHz6cZ8ePLznaV609ajAIV258PG2LaR7crx8AM4Gw0NZM/OsvEVzh4SH6SEiAtWth8WKUQ4e4iNV9a8Lqwr2JCLY4h3DL7gC2AicQFr16QDVE/GkCttY9L+BYbi7PPvvUf0boAdSp40t2dhZeXtfw9BTaW02h0q0bNGniDQQC3ggLXzxCGicBrRFJluOBVxC1dOOBeNq1M7BwIXz+ubDwmdMTWqhI656joyP3dO1atCtXunElkgpFWvYkkiogNzeX3Xv28PZbIgHwnNmzcXR0pP9DD1GzZk0GDBxIr16D6d//frp160TLls1p2LAB9vb2ZGRk4uyss1Tc2Lz5VyZNeoVLl1IsdVr//vsC36xYweDBg0uX1sUcNYtOJ8Raz55Ui4qCrKxCm9uvXQtA3773sW9fFFFRh5k7Zw4u8+bByJEcP3QIb4S71gXhYExD2JsMiLq4183PDoiAiyisefW0iACOS4jo3guFjEFNEe3rW6vk4/sXceJEHL6+Pvj6elK7tgi6UI2lQUGqLvcETiFEnwE4hBB7TRFiT2UF4j+9A3CaBQvs8fK63yL25s0TH71q1FUFX0WUWLvnnnv45ZdfeCFPuhwL0lUrkVQoUuxJJFWAWs2iWbNmANjb2/P6a69Z1u/bu5cvvviCBe8vZM2ajQDo9a7UqFGdc+cSadw4kJEjhxIXd5ovvliJnZ2dReiNGTOGOW+8Qc2aZbB2qTW6tm/ndFaWTSm0vDQFmgG7f9/PpOefZubMt8nKyhIJdj//nOaffy78jpGREBOD1/z5uBw9iiNC2OUgRGAWcAWIRkgWV3P/qQhh+CdwlYLJnQFSly+H4cMJCQm+9eO8g0lPz8De3p7Jk7fz/PMd0GqdLUEanp6iAt3p07lAAELwOSCSLWcjMh7md3magO8t7y5fvsKbb54BRmE01iEwEKZMqfjjate2LbPnzCk8L19JblwZjSuR3BbSjSuRVAEHDx6kdevWRdbDtbe3Z/To0Zw8EUvq1avs2L6dV2a8wsMDH+GzJUvw8qzF1Kmz+OGH9XS7914URWHJJ59w7coVFn/8cdmFnlqk1c+PBAoXeiBuHBHA1dTr6PWuuLq6MDOPWAVQLl8WyiQuDqZMwbV5czwRc+3cEFa7RPM+auTZLgtrTdxYc7v8hABfLV9ORESb/5xlb8yY4Tg6almzpgevvjqKwEBh3UtJwRJsIQQeQGOgASL/ni9CRrfCKpsLYzXCaT6Tzz4TZ3f/ftsWFeHSDQkJITU1tfAUQDL1ikRSocgrSCKpAg4dPEib0NBStXV3d6dr16507drVsmzkyJElVi64ZYxGq09vyxZLjdqiqAM00Gh4f8FiJk0ay+uvz8etWjXq1a3L9z/8wO49e/Dy8qRL5y40c3IieMIEevr54XX4MHVnzECrKCRjzRynRYQWlHRTqokQg8nJyfjW9uTmzZu8/vq7+Pn58vTTT9zuWahygoIacujQViIiemNnl03PniJAA6zBFV5erly+XBshl6sjgjXSEDMgcyjd//hLwAe88MJQvviisSWeRsWEplzduTqdjhYtWnDo0CECAgJsVzo5Fe/GLSLJt0QiKR1S7EkkVcDBQ4d4YerU2+qjXIVeXsyhn/GXL5fYtJfJxOLzFzl+LJbu3Tuz8P2FGAw3adu2FbNmTeWffy6ze/cBNm3eRGrqderVq8vk8c8yMDaWu//8E+8HHyQWMQNNDeBQI2+L4gowPjcX47ff8tjQoTRsGEZ6usgp0qhRIPfe2/G2T0FVo9FoaNGiGcnnzxMfby2FptcLsSey6FTj8uX2wFmE+zYY+BXhxm0O7C3Fnv4A/mD//nWEhAg3cV4jmir4ymsuX9s2bTh44ACPPPKI7QrpxpVIKhTpxpVIKhmDwcCxY8do06ZNVQ/FFoNB+Ar1ehJPnqQ00+W9gBUrVrDll51s2/YbtWp5s3btV2zZsopx457gtdem8euvP3L2bBS7d2+gbdsQnp8+Hf/mzen72Wf8+vV+7m3ThlDEP0/VfVsYq+01vKfVcuSBB4iPj2fw4MGMGDGCrCwDSz75hLZt2jBs2DgMhpvldUaqlPr1/Yj76yyTJwuBpdUKN25KigjU8PeHunV1CJets/nRB7gXIZ9blXpfn33Wl9atN1qqcBjzhD3ndenernu3TWgoh1QzZV6kG1ciqVCk2JNIKpmTJ0+i1+vx9/ev6qFYUX/dtVrYsoVaiPlypeHUkCFMyspiGMC5RAb0f4Kff95coF2zZo357LP3+Ouvg7zxxgucORvP449H8J2/PwkUHoQBoh5vOhCTa8LdtxYxJ44R2rYtu3fv5svPPyf54kVGjRqFt7c3NWpUx9HRoYie/j3k5uZy4sQpLl/+h+RvP2LsWOHlTE0VFj6dzprG0MurHiIq1wFn5zoIl+4gIAzogpjLV5pb/RLCwkTmnehosS+jUfwHyMvtCL5WrVrxxx9/WIKJLKhu3KIeTk5l3qdEIpFuXImk0jl9+jQNGzasODfsraJWugARTOHnxwGEPCit084RuAswmUxss7NjxIjnaNasMa1ataBu3drUrVuH1q3vpmHDBri7uzF27AhGjhzKuHEv8MSGDYxGzDwDIe7y83p6Ou9Wq0ajRg344ov3GTZsHL3uv5/IHTsIDQ1l8+bNbNi4keXLP0Sj+ff9h/3ii5W89tp8GjSoT9++Pdm6NZKDB48wZswrNGvblh0HhIs1Lk6IsJAQ4c719xdizGCoaZny5umpIyVFR1ZWINAGEeu8ESGnUyhaVsPp0+8Bh2nXbhgBAT3ZskV8Nfz8hAv5dgkMDOT69eukpKTg5eVlXSHduBJJhSKvIImkkjl9+jQNS1u6rDJJSbEEaHhReqGXl/X29qTl5qLRaDhx4hSnTv0FgNEsJu+7rytLlszH3d0NrVbLjBmT+OGHdQQvWcLIkSOL7NfFxYXvV63ikcGD2bDhF1at+pSwsF4sXbaM1q1bs3TZMpo0acQDD9xXhlFXDVlZBqZPn01i4kV+/XUXAN5evsydu5Cwdu3YtnYt9w4dCt7gF9IOsI2h8fAQ/QQFCSGoWv5SU9UKGYEkJMC1a10RVYu/M+85sZhRRZqfP+bs2XU0bjyLli292bDBVuyVNXhDr9fj6+vL6dOnpdiTSCqRf99fYInkX45q2btjUFOuqBa+3btxKWNXjzzxBBqNhp4972HBgjf45ZfvmD9/Fo0bB6LRaNi/7zDTp8+2tK9btw7du3dh0vPPF56SIw8PP/wwI0aM4IUX3iA9PQNvbxGJu3PnTn5YvZoRIwaVcdRVw8qVP7Jy5Y94uHvx8MCBrFm9mq2//ILhxg1279rFvX36cD49HTw9CQ0V7lsfH0sFOjw8hNDz8RFiz5wxh+Bg8d7HB4YOhYAADeAH9AU8oFSzMUGIwo+Jj4fVqyE+vnyOu2HDhpw+fdp2oXTjSiQVihR7Ekklc8dZ9lQXrtEIMTGg07G/+C2KpPbnn7NwwQKuXkln0qRXGDx4DPXq1WHNmqWYTCa6du1KZKQ1StTOzo4vv1yIRmPH0mXLSux//ttvk5l5gx07dnHlyjWqV6/O77uEVax+/bplHHXV4OCgxWQy4ebmRo0aNbiYlMSOHTs4cOAAN2+KIJO6Bw5wfMIE9HrrHL3gYGvBE71eaCFPT/Haz88q9Pz9xbI+faBjRw9EhO5DCId5afMwumEwCKGp/h9QKevcvYaBgZz+80/bhTJAQyKpUOQVJJFUMnecZU/FbFnLWr8exzJ2oQGuTphAT2BZbCxBTZuyY8duxo4VaWZyc3MxmWzdf3q9KyEhwZaqIkVx48YNPDw88Pevz4svziYtLZ1r164x/913LX3/m3jssf6cOhXPgQNHyM7O4culS8nJyQHgnq5d2bFzLIrDUP4Emvdsy/wtB5kxQ2xrMFiFnlYrxJ1er87fE+/VNqoAjI/XkZRUGxiH1aWbhsjLVxSeZpdw4WvL4s5t2LAhR44csV0o3bgSSYUiryCJpBK5ceMGly9fLphUtqpJTraYbrSU3tFXHI0aNcJbq+XEiTguXUoBYP2GWGrVokBC6MaNA9mxY0+RiaIPHDhAWEQEAMuXLeN0fDwNAgL4ef16QkKC2bFjzZ0T8FJKHBwcmDv3Zcv79PQMUlKusH37LqZNew14HBIT6V+rFsqhQ9QwXGTevNrMn28NmlCFnpqDLyhIuHcTEoTbNf8cv6Qkb0Qevh6IHHvVEdWHYyl8lmYdi1gsr9K1Af7+rPnpJ9uFJSVVzmtSlEgkt4x040oklUhKSgoajYYaNWqU3LiyMRohMhITlNmNmxc7OzvGG43s2XPIvOQDNq5/n3/+ucyhQ9E2bXv06MJff53hw48+KrSvli1bWl4PHzGCRg0bMmLECPz8/MjIyPzXCb3CqFZNT0BAfZ588lHatAnBz+9lnnxxPismTmTVNzdQ6tTBbf9Whg61BmdotUL0qW5bDw/h5g0MFOJPnY6p14sIXrBHuHCb4+AwAVEHpRYiLx+In4S8PwvbLGJP3Wd+btWd6+3tTUpKiu1C6caVSCoUKfYkkkrk8uXL1KhRo8iauFVC3uAMg4HysqG8Zm9PABCbnc0fQJMm42nVSiT63b79N5u299zTAXf3agUn7ptxcHCwEXRarZYln33Gvn37iI8/y4kTp8pp1FWPvb09n3++kLvvbsqOHasYvnAho0eHcbVmTdiwgUaJO5g4UYi3vMEaIJa56bItoi80VAg/nU58zF5eGnr1cuWhh2qaxZ8nolJxdcDb/NrNPBIN4Mr69fHlZtUD8PT05HL+6ixS7EkkFYq8giSSSiQlJQVPT8+SG1Y2RiPs3w8ZGeVi1VM5C/wFdAL27blGk2atsbOzo1Gju2zanThxiuvX06levTrPjB9PRHg4Q4YMsaxXFIXhw4bx2++/4eXlzaNDhmBvb4+Dg7iFTZkyi82bvy3HkVct9erVYcWKjwE4fjyW/v2fpKmmFt92784927eTHHgPqnFMDVj19AQXbkBKKo08dfj51SAmRuik5GRh+UtNtUbv6vVw6JArQtypARuZCDdvJsKZ7wq4snt38da9W8HT05P09HRLEIrNQRSFdONKJLeFFHsSSSVSIJlsVaNa9PIkVr5dc78G0CNS9zZFJFzu2rIlU599lqSkZFav/rJA/dqEhHMAvP7GGwB8/MkntG7dmqCgIACSkpKw02i4evUaiYkXmD9/FkOGDMTR0YE9ew6i17ve5qjvXJo3b8qaNUuZMmUWPQcMYP/XX5MYLax2+/Mocw8PSDO64EYqJCbi4mMkONibjAyruPPxEekU1Tl8HTsGsmtXLOJT0pkfBkThOkegMQ0b+uLvL/pQ5wDeDjVrCmF55coV9GryPnv74ju+kyzhEsm/ECn2JJJKJCUlBc+apU17UYlERVnEXllvCnqgBqJwlx5wMfdVG8ht0YKvt/wKQFpaeoFt77orgE6dwmnTJoTatX14/vmZrFu/nsjISP65dInlXy8nIyOdp59+nEceeZAGDepbtu3YMayMI/730Lx5E9av/5patZox94ck/vwTdu8W1jo1F7alrJm+Nm5qvkQPD7Qd7iE11TYP3/btohqH0FddETZYV4TAcwQczO99LSlf1DmAtyv4HBwc8PDwICUlxSr2ZDSuRFKhyCtIIqlErl69SvXq1UtuWFmoxU/N8/bSDx2iLKEO/ogZX40Qgk8HZCBmhNnZ2UHbtoypP47XX29HbOwpHnqot832TZs24ueflwNw/XoamzZt55VXXyU3NxcPD3eaNm3E++9/RkBAff5fcXR05K67/NE5HeL48RXMmjWU8eOFDtLrxSMhQTw39fMQn21KCo4xR/D298czpAYaYzYA3bo5kpysek41CNetPVbB52feq0i9ogo9KKi7ylJJo0aNGly9etVaH7okN25OcelhJBJJSUixJ5FUIjk5OTjdKdUA8iZTzsiAjAyyET/7t0JtoBUQhLDaoNWSm5WFFrBr2RJWrMD055+cWTySunXrMG3a+GL7c3d3Y/XqLzEYbnLz5k3c3d2Kbf//xIABfViy5GuU3K9x84AuXaBvHxMXk63O94QEaBponsSXmioW6HRoVFWIeFJFnBB5SQiJntdd6gm4WjRYeU6bc3R0tOQUBKQbVyKpYGQ0rkRSiRiNRrR3mksqz5w9I7deE9cDaAA4NG8u/H1GI/Z2dlSvVk34GoOCeGf5clYcP87QoQOEICwFOp2TFHr58POrTVpaGgMGDiQ9fasoYWYw2OgkHx+Eb1dNwJeaaimBcTFZw8VkDYmJ4iMXQi4TYcnLND8MiG9BdaC6pSZuvqmdt4VWq7XUSzYvqJBo3I8//piAgAB0Oh2tW7dml7naSlH89ttvtG7dGp1OR4MGDVi8eHGBNj/++CNNmzbFycmJpk2b8lP+nIESyR2IFHsSSSVizMm5M8WeuSZWNuLn/lbQY76RBAaKrL6hoTBiBAwezLF4F9LOnmVvdjauri5Mm/ZseY/+/4pHH30IRVFY89NPaDTPkZEB6HRkZEB0tGgTGIg1Sbafn3WynqcnGRliVXy8WC2+ivbmhwHIMj9ygZp4eWlKTLtSlrJplSH2vvvuOyZOnMjLL7/M0aNH6dixI7169eLcuXOFtj979iy9e/emY8eOHD16lJdeeonnnnuOH3/80dJm3759DBo0iGHDhvHHH38wbNgwHnnkEQ4cOHDL45NIKpM77FdHIvlvYzQa0ZVn0rLbRU25YjbZmCi+eFZ+NIibyBXALzFRiIrQUOFfDA5m2XxITHyVdRs3ApCVZcDZuWqP/+efN+PjU4t27VpV6TjKwtatkeZX7RkyZB0pKXApRUN8PBZrXUoKuKniyBzNrEZWZGSIuXq2lj1XhH1Wtbiq8/fO4ePTqlyrZ6gUEHslzdnLFnMN09LSbBY7OTkVOS3ivffe46mnnmLkyJEALFy4kF9++YVPPvmEN998s0D7xYsXU69ePRYuXAhAkyZNiIqKYv78+QwYMMDSR/fu3Zk+fToA06dP57fffmPhwoV8++1/J/WP5L+HtOxJJJXIHefGVefrmS17RiClxI3ydYFZIBoMYp5Yt27s1ffg9c9rs307JCa+xfhnngEKJlOuCkaMeI6ePQdV9TDKxMGDR6ld25eff95NcHANUlKEuEtNFet374a1ayHNvwUEBWHyqW0tlJucjFZrncZnNIp5e02aOAAhQGOEQ742ItymHiEh1qTM5fm1zS/2TGhKfADUrVsXd3d3y6Mw0QaQnZ3N4cOH6dGjh83yHj16sHfv3kK32bdvX4H29913H1FRUZb5hUW1KapPieRO4Q761ZFI/vvk5uai0dxB/7GMRpGLIzraMmfvxi1sbgLSMNuEPDwgNJQz/vfQLwwuX44BooGuPPN0Oz786KP/62ja8sDHx4t//rnE/XbrSfV5wKLV1ZQoiYlC/MXHg7+/IwAeHho0ZmGlGtBU4abXC2PsyZO+CJHngJDurgQEtLLk5/P0LF+xp9FobMReSXMB1XXnz5/Hzc06j7Moq15KSgq5ubnUqlXLZnmtWrVITk4udJvk5ORC2xuNRlJSUvD19S2yTVF9SiR3ClLsSSSViLOzM1lZWVU9DEH+hMoGAwYg9Ra7yQGcQKiGDh0YPx4uX34CMQcsE1hHePhctFotW7dGEhwcVK6H8f/EmTPnaNSoIfZ3381wzuHhUY/t24XX3GAQufPMJY4JDhZGPZ0OXIxG0OsxpFjr6arpWvz8wNm5JllZdRDyPQtws9TEzZt2pTDKknolKysLFxcXy3uDARwdi26v5hB0c3OzEXslkb9msqIoxdZRLqx9/uW32qdEcidwB5kYJJL/PtXc3MjIyKjqYVhRgzPMppNb/9kWM74ACAriokdTNm9+BzGLLxOw55lnvIn87TfGjh3LB4s+s52rJbll0tPTMfnVA62WvqnLLdUtPD3FR6m6ac3ZdIRQ8vAAHx8MBlE/d/SIbB7reZXgYCEKs7LSgVqo5dHAEx+fvOlZyrdEbUZGBtWqVbO8z/+/o7DHreDp6Ym9vX0Bi9ulS5cKWOZUfHx8Cm2v1WotVT+KalNUnxLJnYIUexJJJaLX60lPL1hBokpQfX8qRiPZt9iFWiUjFWDtWmp7ZgN501sc4KOPPuK9BQvYtm0bN7OzMZlM5Obmcu7cBdtca5JiuXEji1WrfqJd23ZoMJGmrw0DBzJwIDTyu2GpXZuaKmJu4uKEO1erBTw9uZqqQa+HepyD1ath/37a6mMZMQJatqyGqJFrj0iqXN0i9Eqar1eWaNz09HRr9QwgN7d4oZd7i8kfHR0dad26Ndu2bbNZvm3bNiIiIgrdJjw8vED7rVu3EhoaakkXVFSbovqUSO4UpNiTSCoRvV5/Z1n2VHON+Vc1+BY3v4FIxesN4OPDmURHoF2eFs4AXLhwgcTE83z77RIuXkzm/vuHcPfdXRgw4MnyOIr/C7RaezIzb9Cxo6gr7KY3gU6Ho9YEH36ITgcdOlgjcpOTsUTeXkzWkJwMTYNMIoIjKsqiBmsYL4ncfLghPk1funatVmqxVxYyMjJsxJ5axKW4x60yefJkPv/8c7788ktOnjzJpEmTOHfuHGPHjgVEJO3w4cMt7ceOHcvff//N5MmTOXnyJF9++SVffPEFU6ZMsbSZMGECW7du5a233iIuLo633nqL7du3M3HixDKfC4mkMpBz9iSSSkSv15OReauZ7CqBkBBhDioD3oC7ry+EhhIZCbbJW8Tr69ev06lTOJ06hdO792McP34SADe3akhKh52dHYqioMsflODvDwYDniOmWeboabUQEyPEXpcu4r2PDzB/PqxYIbYLCwODgT+D+uLpCc7OGrKy3GjSpCY+PmIun4dHQaF3u8LPZDKRmZlpI/ZKG6BxKwwaNIgrV67w+uuvk5SURHBwMJs2baJ+fREklJSUZJNzLyAggE2bNjFp0iQ++ugjateuzaJFiyxpVwAiIiJYtWoVM2bM4JVXXuGuu+7iu+++o127dgX2L5HcSUixJ5FUInq9vkCusCrF01M8m39Nb9XU7wLUBGFSGjiQyPmAjTNY9Ovi4sJvv+3lvvsGcejQUaAN3t4i0XJF8d13P7NkyVd4etbk++8/q7D9VBbJyZfRaDSYTHlmVmq1XFcU3H198fAQQdU+PsKVm5Ii5uPFxwvh1sjjEkRHk3v8OPYODmJi34wZ+PiIbTw94fx54b5VH/lz7JWHhe/GjRsoilKoG7cobtWNqzJu3DjGjRtX6Lply5YVWNa5c2eOHDlSbJ8DBw5k4MCBZRuQRFJFSDeuRFKJFDbBu0rJF6AB0PMWNr8BnAdLSYbAQIA+eVrcBdQhM7MGAIcPXwDaAnW5dKkN33//M/v2Rd3eMRTC1q2RjB07haNHj7NtWyQ9ejzMtWup5b6fysTOzo5qele+XrGC69evw9q1JCoKlwAiI0lIsIq0jAzhvlVFX2gosGoVrF7NJeCfnByup6dDRgZuhksEBgph16SJxjL3L78Lt7xcuUlJSTg6OuLh4WFZVhFuXIlEYkWKPYmkEqlbty5JSUl3TkSq0Siy5hqNIgkvtxaRq8U8Xy8wEEJDiYsDkXlPpTrQCmgGdMNkaoeI+sxBpPjA4tItT7y9hcVy9OjRdOzYkUOHovnwwy/LfT+ViZ+fL6t//JITsScYPWYMpr598QsIEDdxDw8iI4Vgi4uzCqToaPFeqwViYjick0M0IvthKqBmZVateHmtfKoLV6st3woaiYmJ+Pn52eSbLO9oXIlEYosUexJJJeLr64uiKCQlJVX1UASqZS+Pde9WInIbAHfZ2VlMSR06gLNzT6BjvpYOqMEaVkT65rCw8i9bFhISTEREGy5evMjvv//OyJEj+eqr71izZqOlzfnzF8t9vxVN69Z3s2jRHL7/4QcecnDg0Nmz3PXbb5zJ8CbFXPokIwOysnIwGIR1LyQEEcQRFUUKkGx+AJYszD4+Yupfly6ivWrZy2N8KzfOnz+Pn5+fzTIp9iSSikWKPYmkEnFwcMDX15fExMSqHooVs1UPgwHX6tVLLfbqAYHAZUWBoUO54VmP5GT1h7m4xLdNzc9iblRW1s2yjrxYMjNvWOZHjh8/nitXrvLUUxMt61u06MyJE6cqZN8VScuWLQD4xc6OZsA5/06sWiVE3pYtqsszG0W5hL+/uZSawcCBo0c5jSiHpwEuAjnr18Pq1cTEiK+Av7+Y3xccLF6rFCe2bjWpcuKFC9TNJ/Zu3izehXuzYr4iEsn/DVLsSSSVTN26dTl//nxVD0P451TTjdEoTDpGIyXZ2YIQci0QaFO9Ol7h4eDpiYvOREiIOeqTELAkcvHI10MuoHDrtTpKT0xMHCdOnKJnTzEDsVmzZviIgQHQunVrAB58cDjZ2beaXbBqOHHiFCNGPEvLlvegt7dntKJgvK6wZYuoiRsTIwSfoiQBSUCmpXYunp6kIlJd30AIvXNAAkCXLoSEWMWeWg+3PJMo5+X8+fPUrVvXZpm07EkkFYsUexJJJePn58f5O8my5+Nj/UUNCiIN8CmiaTBijl4XoKOzMwwdCj17cqNDDw5GaSxuQ/AFOiHcuQ3z9FANYVtKAq7j6upCUFDe9bePoig8++x0goIaM3nyZAC0Wi3nzp3DZDKhKApRUVHExMRw9eo1Ro6chMFwZ5uOjEYj/fuP4PjxU/Q0mTiam0vPjQqRkbB4MWzebCA6WgTYijJ114A0kpPh7YEHycnKIq/T2gDEAf4A0dFEBF0lLMxaRq20Qq8spdLOnz+PnxR7EkmlIsWeRFLJNGrYkDgRyVD1qL+iQUGW15nkmdOVBx2gB7o6O+Pl5QWDB4uUK3364JJxySw0VOzNWzRABGy4IpK0NAcGImRGYzIzb/DFFyvL7XBu3rzJ0aPHiY6OYfbsOTjlyUnn4OBgU8O0WbNmrFmzhm3bfmfYsGe4eQf7Cvfti+LSpRS+X/UdG6tVY/krCmvXwsiRcPToBeAPzp+P4dq1Kwgpdxa4xNChgE6HFmHJy08iiEjq1FSLobcwkVeeVr64U6do1KiRzTLpxpVIKhYp9iSSSqZ5ixYcj4mp6mEI1DBLnc6cn8PWDpcXAxAGwhI4YgRMmQIdOnDVvxV/pnpb6rAGB0PDhnUAP4Toq4mwBTY399IAGA/4o9XqmTNnARMmvGybP+4WuXr1GlOmzMLHJ5h77x1Q8gZm+vXrx/r169m1az/Tpr1e5v1XNH//Ldz+IV98Ad26sXo1fPbZWS5fjgS2AjsR4joF2I+QcadJSICLni2w65g/YEZwAiA5mWy/BkDhCZSLEnllseplZGRw5swZmjdvbrNcWvYkkopFij2JpJJp0aIFMTExtyVuyhU/P2t+jS5dAOhdSLOmCCnBwIHQpw/ZgU35M6M2iYnCfRgTYw4GAHNUbiBwN0Lk1QIaI+br/Y0I4PgLozEDk8nE8uXfs2LF6jINX1EUBg8ew5o1mwgKCrIsz0hLg1Kc427durFo0SKWL/+eTZt+LdMYKpqsrJtoNFp44QVeClrDyZMngT8QQS5ngNoIgXcS4cJNARqzc6eJ2vOe48CuXYX226dlS1FVoxDKO78ewIkTJ/D09KRWrVo2y6XYk0gqFin2JJJKplGjRmRnZ3P27NmqHoqVoCDLZC2nXr3QUzCe9gZwV0CAUHQhIURHi8n/cXFC6On1wiMIwh3YrRt4eQUA7YEmCOteJ4QF6hpgdeXd3aIFs2cv4NKllFse+tWr1zh06CjvL1jAyRMnSLl0iY8+/JAuZuGKyVTiY+STT3J/796MHDnxjpy/FxLSDJPJyLYGDejWDUSOwt/Nj0zEOc1FCL40RB7DVObM0cDgwYXOwWwAqOZYR23hori8AzSOHz9O8+bNbdzpIN24EklFI8WeRFLJODg40KRJE44fP14l+zeZL3sTGstrdDoRWdGtG+j1NPH1pV6+7bqAUHcDB3JD62ax6BmNYnHeKgc6nUjM26EDdO3qQcOGjenY0RUvr+4I8dccsMfe3guAP44dA+x48cXZt3w81at7oNe7smfvXhRFoWbNmox7+mnq1KlT6j40Gg1Tp0whK8tgcZneSYSGhuDt7ckvEyZw770xCKveNUQKbEdEQEwqcBphOc0Caop5lP7+FGYzNYIQexkZZBttfwpKEnllceECHI+JoXlwcIHl0rInkVQsUuxJJFVA8+BgjlWB2Msr9PIuM2kdhULT6YRZrkMHBtjZiWhNhJXvBsDEieDnR3y8EHoZGWK9mpM5KAiSk4VY8PMTDw8P0a3BAD17QpMmDojKGveSmxuKKKkG93Tpwvr1v5hr55YejUbDlCnjWPLpp7zy6qtcuHCBOXPn8vvvv99SP6rF6Vb3XxmkpWVw6VIKl1MaIFy0mYhEKiBmUqYB6vfJHnF+U4mMBAYOtGQ2zIsRxIfVoQNQ0G2bV/CVl4XveEwMzVu0KDgWKfYkkgqlArIoSSSSkmjbrh1bNm+u6mHYYPKpjSY5WczJMydo67NzJ4mINB0ZIPy1MTEYA5vi4SG0gk4n8rPt3y+Mg56eYllyshCDKSnixzo6WniAhUBMMveoRXUYf/fDH9jbV+P++4ewfv0K2rUrfWWNCRNGk5JylTlz55KcnMwXX35JUFBjTp6ILXUfLi4uKIrCmTOFxa1WDVevXmPYsPHs23cIgJUrTUAkakJqay7DvxHBLwaE2MvEwaEfs2cDiQOJ2revQN8jAZYtA6MRbZ5yaIUFaeTHhOaWrXtGo5GDBw+ycOHCAutu3oR8nt0C6yUSSdmRlj2JpAro1KkTu/fsITc3t6qHAuSxnAQFCbUWGgrjx1PztdeogQjOcAQyf/oJEhJo5XHGEqmpzqtS03YEB4tnf39ryS01rcfp0yaSknIQlihVLNQCHgQCyM2NwGRy5sUX3+DChVsrKTdoUD8Azpw5A8DZswml3vbGjRv0HyCieO+6q/4t7beiiI39k8cff5Z9+/5AUT4EPgD+xCr0QJSg0yHm6GVjteo1ICfnLHFxcO3553Ext1Zv+JbZkuZyeUVZzspzzt7Ro0dxdHQkWLpxJZJKR1r2JJIqoHnz5mg0Gv744w9atSr/2rC3gvpDajSCo2qm0+tFGYXUVOo+8QSmpUstlRcaLlsGUVH0Wfw9q82TwTw8hD6Mjxd6Uau1Rubq9Xl/rHMRbsjj5udqQDrWuWeQmxvMsWNRDBz4JAMG9CEgoD733dcVvd4VgCtXrvLll9+QnZ3Db7/t4+LFZPr06c7s2dMBcHYR0ubmzZuYTCY0mpL/0779zjts3rKFBQveYMiQgWU9leXG9u2/M2TI0+Tm1kRRugBbEJVIUvO06oKQ4QbEuVTn7uUCNWnZMoDBg6H6bAdq5ORgQoi9DHNLOwcH4VfX69FqxWdUWtdtWebs/b5rFx07dCj08yhJ0EmxJ5HcHlLsSSRVgL29PR3at+f3XbuqXOzlJduoAX0N8eNrAO3gJ3FJSKC+ry9nk5LQAMrJk9gFBlJj1cd06zmOlBSIihKCLzhYiDtPT2Ht8/SEDRusQRxCmGQiLFL1ERap9HyjqInJ1JLTp+N5663FGI0Gatb0ok+fe2jQoD7HjsXy448bcHd3p3evXhw6dJwlS5azceN2AMY99hh2kZF0unGDaw4OaAH3EiyoPbp35/U33uDFF2fTsWMYd93lX56n9ZbIzs5m7NipdLv3XjZttkNY66BgeTlXhDv8IuI8VkO4xO0BP+LioNGUvvyYk0MaqpQWknGAszN8+KFFRWkwodVqLKKqIsqk/f7773Tq3LnQdVLsSSQVi3TjSiRVRKdOnW45iKC8yWvVU19nZIj5dqmp4pkZM2DFCgLq1qUGYFe3rlB2GRk08MsmMNBaYis4WMz39/cXFr5H+on1/v6gKCaEMLmCcOP+jbBCFYY3ubkRGI3dgXu5ds2Rr776gZkz3+bHHzfw1rx5LFx4hVXffcuWLQdo2/ZxEhNFQbB7BzzKhnfeYVpAAG7AJeCKvb2wYoWFFbq3iIgIziUk4O7uxvz5H9/2eb0dLl5M5sqVq2zanIJV6OXnUYS7NhZRLeNvhPC7hhDU2WRlpYKnJw0QlU8czY8QsM2WrNXaBOxUBCaTiV27d9OpU6dC18vUKxJJxSItexJJFdGpc2fefuedUrsaywMNJpsfdtV9p6KmT1Hz5Wm1EB3tSP9gPxg/nmqRkSLSwsNDqDmDAXAkMNBqydMknsNbjdxIMDBxYluio6FuXQ3nz/sB8QiR54YQJw4Iy1RRuGAytQJuAueoVu0e1q2fSN++9phiYmHVWu5r58YLXeaQnu6OyaRhk/84es/2wCEjgxtjxuAHFiX6zSpRw3fsWNi9W7if164Fg6Eely5NZdWqaTz33CiaNCnfmr2lpX79uvj4eJOcfIWiqxRfQczVs0ekWclEnNNrQDegNV995QEJ/iQgIm9zEbbAzs2bw4svClXu4QFYvxcVVQ83JiaG7OxsWrZsWeh6oxHsi9K1SMueRHK7SMueRFJFhIaGYjKZOHjwYKXtM78Fp7AfUXMgLnFxVuvepvhGQhh4eIgqG6q5zjy5399fLPL0NHeanCz8t8nJuG35njWzjjF2LAjbkifCKuWIqPxQnNDLixPQkPT08+zZ8wsLF8IZXVOYNYsb8xbxwgsvMWPGM2zfLvToXv/H+LPLaO7+8UexeWgo6HRs3y7czgkJQo9u3y50K8Brrz2Hg4MLW7fuLO0pLXeOHYslK+smoBTT6iJwCpFXT3WDq4kOM4Fshhs+JWfmTHSIf/V1gQgQ5e48PUVTs0m3tJa9subX27hpE/d07Yq2CDUpAzQkkopFWvYkkipCq9Vyf+/erP35Z8KKcC9W/BgKunJTUy1BmhYL3/bt0GHWaNw8PYWS8vMTgkGvx1NnDcYAhB9YTayXmCjaxcXxUj8tgYFNmTGjHadPmwBvrO7czFsc+RGSkhoweHAwISEaevYUhjsfH7H7tWuFWE1IAH///iw/fJgdqa24J/AcU/yt1T727xcaMDVVDHn8eCe+/bYVx4+fLPM5vR1OnYqnd+9HuXlTh5p/sHDisYo7FQ9EsuqHeOstb/D3JwZhA6yBqFDc2NlZKHMPD3ESzLkV81t8y5u1P//MmDFjilx/8yYoxWjb7OwKGJRE8n+EFHsSSRXS76GHmDFjBvPefLNS9pf/R70wi4mnpzVZspoXLyMDFi+GkSP7UyM+Xlju4uIgNBRNyiVqqLV1jVitRt26CZWYkSHmy/n40MUTFi6ELVs0xMREsHPnBURE6aFbOAoPhAszm0OHMtHpXElNFULPwwNmzwZF+YNDhxIB2LWrFyEhrUTuYIMBg0EYHdV5hZ6e4jhHjzTB/v1kZ3uRmppyC+MpP7766js0Gntyc8Mo/vacX+iBCHrxY+XKOjzmuRWmTMENUZG4FWDftSuMH289aBWjUSTVLoayWvQALl68yOHDh3nggQeKbGM0QnEzGaRlTyK5PaTYk0iqkPvuu48hQ4Zw6tQpGjduXOn7zz9nD4Q20+utQk+19EVGwtChiCCHqChriK1eL8Sf2lFQkLUSR0iIWBcfDzod3oEe+PtrGDwYVq+GmJg6XL78EMLKt7GUo05FBCPEApns2qVDpG7JQriGz5jXH0HMUtMRHX0vPXsC/v5sXyh06urVwvXs4QHz5iHMgGFhOGiOUb9+u7KczjKTm5vLxIkzWLFiNRDErd+aewKteeihdgQHA1uiuXn8OFpEQIZ9y5biw8tb0kQN0qiI0Ns8rFu3joiICLy8vIpsI8WeRFKxSLEnkVQher2ebvfey8/r1jFt6tSqHg4gtICnp5oqRXhjU1KER3bePBg5shMtOuhgyxaxMDDQmlhPza7s58dFQw1qdzCLiuRksS45GT+/2vj7C8G1cCGMHx9MRkYwOTmOiDloarRuca7ds+ZHIOCHEHog5rGl5mmXCVQnKkqI1bg4R7p1EyI2MVG4cYOChHbV6Rrw3rQc/vzrDOOefbJ8TmYp2bFjt1notUCkpCktGkRARggdO7ZjzditsHgtREbi5OxMfa1WfJjz5mETNg02Iq8wN+7tWPPy8vO6dTzYt2+xbQwGMBWzO+nGlUhuDxmgIZFUMf0eeog1P/1UKfsq7bws1aqnGoBSU4U4WrFCZGKxCIX9+0VIq8EgGqWkCBEYHY1eD0cSvbloqMFVn6bg50eavjZ6PbgY03hyhAl/f1i1CgYPBmfnJxB2qPbmR2nGGo+1fNgBCuaiAzhiKd8WEyOOQ63f6+Mj9E9KCrRvv5Qff5yIoigEBVVuJO7PP29Gq9UD9W5xy0954IHxfPRRBL8vPCI+i+3bxWfh5ycmJE6ZUtCal/c1pf9e3Cqpqans2LmTB/v1K7Zdbm7xwRl3SKEZieRfi7TsSSRVTP/+/Rk/fjxxcXEEqWGhVYjRKERQSopV9KkBG1lZMaxfD2tGtKL/YL1Qf4mJQjQEBlon+yUm4qbVAi1ISBCCKsFYAz8/0Y+3VkTshoXVRpN6FZ1OrFu16hHOnt1rHokrsB/hki2JoiJ6HYBMjh414eOjwWCw1u2Njxce6YwMMc8PvsLePppBg/rTtm3hKUIqgo0bt7Fy5Y9AM6CYArEF6IKvrzezZkErXSz0G2y1oIaGiibBwSJ6Wi1YDIW6bfNb9srLqrdq1SpCQkIIDAwstp3RWHxtXOnGlUhuDyn2JJIqpkaNGjzYty/Lvvqq0gI1VAr7EdXphDhTAzNUA5CiGIB/gJNMnBhMyoxGjB4xQvhiExKs2ZTVjZKTaeV/iT9TvYmJEf36+Jg1h1lFalJSwGCgk78P/mPrMXs2dOkSgV4PMTERnD9/LzCH0gm+wshBiMZYNm8WpcQiI71RlEycnV2Ji4NDh0zAr0AO3t46Xn55Uhn3detcupTC2LFTsbOrjaIE3MKWPejadTyrV0ONZe+J8OOEBNuixKGhQujlnZtXiAtXpbwEXl6WfvUVTzzxRIntDIbirXc5pc3OI5FICkWKPYnkDuDJp55ixIgRzH7jjSJzkVUE+QM0VAueh4fVupeSorZJRMyJO8P58+8zZswjJExvwNyJE4WFz9+fc/6dSEj0xtMTPP3rodeL2Fm1b0v9VTXHi04nTGwJCdTzS4RUPb9/LixQH29vhIdHPUaMWEJOziGsQRmJiLl416BUAmU/onZsc8CAongAzhgMEcTFAWxGBHY406JFU2rXLiqRcfmQnHyJL75YiU6n4/jxWDIyMoEOlN6q1xRf3/HMmgU1Vn0sIk0SEsQHFhwsLKyBgdbXeefpQYUHZKjExMRw7NgxBg8eXGJbadmTSCoWKfYkkjuAbt26odVq2bJlC3369Kmw/ZSUT02dzpWRYRV7akQu1EJUvTiDmCu3nzfffJKEhO58E6qHxER0QVhq5WZkCL0RHGwp1IBeLx6WqA/VhAjiWc37YjAwLjSVi35tmTcPVq9uw759mYiEzKcQ4u0aooJELMUnZr4GnEOIxCRz25ooyjXS03WIPH+t0Wr/ws+vfRnOaulJSbnCQw+NIDn5Mjk5OWRmqkEoKYgE06Uhi6SkHGJiHOgUGiryyPTrZwmMITVVnFc1CXZea14l/pFYumwZA/r3x0P98IshN7d4sSfn7Ekkt4cUexLJHYC9vT0jHn+cL5curVCxVxjq779qPVE1gaenbX1SX9//tXfnUVHX+x/Hn6ijKCBDIoIrFCbiYOBFQVLDJXPP3K4LppVmt6tW95bdtpv+fpnLr8zutU0t9WipqWmpSV4SzT3UUFH0SkKCgYqypqODzO+PD19mQDbZBvD9OGfOwMx3+cxwjr36LO+PE8nJf0KFqxhU79q/Wbv2HO+99zda5lxQpfZyLFPHjhxRucPdXV3TaIR62ZmWsi1xcZaEaTRaVoWkpEBSEi1djzB27PN513Pgl18eQgW831B15W6gduO4XMInNKGCnrWrea9pe8luJyfnNzp3nlop32lRrl1LY+jQiaSlZZKe7o/aEeQ0kIgKo2UJe2NwcQljzRoY5HkaPl2jgp7BQP6ExJwc9cdzt+qhrMaQB3Dr1i1Wr1nDunXrynS80VhyE6VnT4iKkbAnRA0x+amn8PX15eLFi7Rq1arK7lNc7572H1stM+j1lil4eZ1tpKZ2xGTqT8EdHEwMGABvvtmW1q1VTtMWdhiNasMNHx/LytcCO2xoN0tPt4wpW2/lkZRES/svGDLkaRwdwdvbgW3bgrhxQ4/q4WuImpN3DBX8sii7uLxzkoFb1K+vZ/nyr3B2dqJPn55kZmZx5Eg0Bw5EYWdnx7RpT+LlVXxZlIyMTGJiYrl8+Sq3bpm47z49oaEh6HQ6zpw5x7hxz5GYmMrt20GAI6owdE9U4CxtNexgPDymMX06jBoFDybtgjUR6nsKDVWHaOm8iNW21R32tmzZgoODA6Fa20pRWpiTsCdExdiZzSVtUiOEqE6PDxuGj48PC+bPr/J7Fd5JQ3sYjeo5O9tSriQmRtXFi4uDxMSrQOFJ9/1p3Hg6Q4aocxMS1Kvu7mraGKj1At7eagVsvbj/Wi6uDemCZbw3O9tS3M/REZ57jguevYiLU72FW7bAwYO5eHjUIzn5IrA/rx3nUTX6Yor51DrUULA9KqzexhISs6hf/zdu344vcEbbtm0wmUxcunSZ7t278uKLz3LxYjKenm0wGHyYNet/OHjwCMnJl+6425gxj+Pt7cmiRZ9hMnlx+/YTeffrCwQDz1D6vMO2bN++hEHB1yybFmvfm6en+mJbt1bfkzEvgFdTweSimM1mgrp3Z/y4cbz4UsmLXTIzM3F2dqZLlwzq129a7HG3b2dy7JgzGRkZNG1a/HFCiKJJ2BOiBtm3bx+DBw8m8bffqvw/aoV796yDntbplppqyWRnzlgeWVkfolawWusCDAM8UAHmd6AlzZu3IjhYjTRqpd8CA/MCX1ycCnTa0K11r156uuoWdHVVW69NmaLes7fnQnpTNm5Up23cCJGRf6Bq7B1FFVv+iaLn8bmhNhBzQQW9uLx2aj2CTkBH4CKqx+8d1q3rhJ9fNnPnruPHH9/i0qU7Q93rr73G4g87cv16O9SecVHAD0AkDXUNaP/gDE6dGg9kA+3o2FGtvI2NLbnYMCzn+HE3Osd9o/4IWoAzGtX34uOjHtbz4mzUm6fZs2cPw0eMIDExEUdHxxKP1cKer2/pYe/0aQl7QpSXDOMKUYM8/PDD+Pr6svzzz/lbKb0ilc06R2gjgXq96qXLySk4pBsbG4xa5Wq9y8Ux4CSqMLILanjSgytXHmL37q7o9So8rlunQt/ixQ8Sp3+QEL5XN/DxsRRo1oo0a0OTR46o9/MWdbR1deVvUwL5+UxTNTSMA5GRDVFBMx218jYJNb9PK9vikPf6Q1jCXgdgc97nyEWFvp/zjvcA4njpJQP+/k74+0/l0iU/oBmqBM2/6NjRldjYLN6ddz8wGi8vexwd4eTJ31A7e7zKLdMYTp3ywMXFgyFDVNB9803Iyiot6G1i/34dnVN2Fgx6Wk1DrUaO9R/Q+tlG3nv/ff7y3HOlBj1rOTlQUreDLNAQomIk7AlRg9jZ2fHKK6/w4osvMmP6dHQ6XZXdq/DcPW1elDadTluV6+mp3ouJIX+bM/BFzTcLL3RVE6pXy9pJsrL+YPXqXrRpU48GDVSAHDBADemmDxnEgCFQL+mCmn+WkKBCnVYE2N5ehT5t2wttft+ZMwQGdiMmRlvQG5f3OJN3Xy9UqOuJGrJtBzyEk5Mb9vbqFmbzZVQgPAnspOCQajKwn+TkNJKTvdmxowPduwej10N2dnv27m1FbOxi4Bm8vELzh6yTkkDtVfsHqtfQhIuLB0uWqK2Cp0yBrKxFpfx13uWtt3SEBN5SG4RoK1y0nTDIe83VVQU+raaNjYPe6dOn+U9EBEuXLbur8yTsCVG1JOwJUcM8/vjjvPrqq6xfv56wsLAqvZd14CtcocNotJRo0+bwRUerXrnsbCcSE3ujFknEF3f5PPHAF4CJxMRQnJx0+St2k5IsizkSEtoya7orv7t3oeWAAWoz2/R0NdTburVKZ66ulsDj7k69nFscOtQwb8rfJdSqXC2wmVDz9xqi9tD1xc/PDYPBUt7vzBk3rlwxocJeUXPn0vIe8cBtDh68CrQlIMCBgQO9cHX9EE9PtUOctiAlOxtcXDywt5+Ou7v6nFOmqO9SzTXcjkpwxQlj3DgDw4djCbjanDzrUir5FaqxPNvY+4sWMWH8eDw8PO7qvJs3oV4Ja1RK2jdXCFE6mbMnRA20fOlSFr73HqdOnqzS3j1NUatzC8/di4sruFAjJgaysn5EBbmyrIJ1Ap4DuqKGUHNRCypcsbNrhaen6u3TagJHRKiMo23M0TLhANf9QwBoknqB/xrbEhcH//gHnDwZB6xFlWS5jJqbZ4+qDeiR97gfO7uO+PurnJSerj5LWloccAA1fHuhiHZ7oIZ/m6GGqB3y2u9GQIBD/nQ5d3fVVr1ejTobjSqvxsaa6NhRR1wcmEyvU/ziEYDnmThxAGFh0L9frmpg3jzF/Id1Krf+3cbi4uLwe+ghoqOj6dChQ5nO0ebstWiRQb16xc/Fy83N5NIlmbMnRHlJ2BOiBsrJycFgMPDSCy8wbdq0Kr9fcYWWtR699HTVyZSQUDDwnTxpBL4D1pTxTq1RK2KnosJTEqoHzg1oTfPm9ly58gcuLg75O3/FxMCNG3/Qpo0Dnp6wd+9V2rRpRmLij6ihUj9U4DxezD275N3XDTWU65LXBiNwK+85Kq8tp7GUlHEAZuQd0x7VS+iGnV0zPD1VxgoOViPP/fqp76NHD3VmQoKalxcdDefO7UXV9VtN0YtGwujdewyRkSbmzNExfDh0NuRq48GW7tXCw7Q1JORpxo4bh5OTE8uWLy/zOVrYa9as9LB39aqEPSHKS8KeEDXUpk2bmDFjBufOnsXBwaHK71dc757aPaNg4NOqf8TEQHz8BdSWY9vv4m4eQBiq9+0qKlA5APfnPRtRgSwT1QOYidplwghE5v3ejuIDXnHq5Z3XOO/e5N07Pu9+jqgN3nxQPZCt895viJp/54JamNKBoUM74Oio5uH16GHpCXV3VyFv0qTLwJRS2hNG9+5jCAtT5wUGQlt9pmV3EeutzmpYuLN29OhReoWG8t///veuakRqYc/RMQM7u+JDnNmcSXa2hD0hykvCnhA1lNlsJjg4mMeHDeP1116rtvsWDn3Wu5lpFVGSkixhb98+uHLlLGqxRuFyLKUZhxp2tUeFPFfUEOn9qGDWEBW2YlC9eFpplar2ECpIDkD19vnktSsaFU4fQvX2dQT8aN7cntatVWDbsSMdeB/LNm0lWcDQoR0ZO1YNYd9n/L3gKtsaHPCsPdq/P126dGHBwoV3dZ4W9uztSw97RqOEPSHKq3b8SyLEPcjOzo758+czfPhwpj37LM2aNauW+xZepVt47r9WksXRUc2pc3WFbds6kJxsRNWRO3wXd1ub92xAhb5bqKB3GxXuvFGBzw0VupLK85HKQesx1FYbFw5tx/Me9YD2XLniy5Urm+/yHh8C7TAYVO/gffpcyHYscR6e9nepZ7WYxPpvVa/UAs2VLyIigiNHj/L1hg3lvkZOTsl740qXhBAVIz17QtRwAwcMwNvbm3//61/Vet/CZVm0labaog1HR/V7UpJaiLBuHcTHx6B66HZwZ1mWu6UHHkYtumiHCoAxVF/gq0qD6dlzGu7u8PLLKuw1bFB8UCtuTqU1WwS9nJwcArt1Y9zYsbz6j3/c9flazx6U3rMH0rMnRHlJz54QNdziDz8kICCASU8+SWBgoE3aYL3wU9vkQhtt1Hr5VMk3A1u2wI4do1D16+5mHl9h6Vbnl7SCtbaxB8Ly5+kZDOp7LUugK4otQp7m30uWYDQaS90WrXQmzOaiFq9Y3hdClF/5/nURQlSbDh068MrLL/Pc889zuxqry9Yjt0CQ0AKfNoyrhT1HR1UqpV8/dVxYGIwe7Qb8GTXnTVh4AWEMHepAYCAMGVKxEnm2DHqJiYn88+23+eSTT2jUqFEFr3a7DI+qkZaWxsSJE3F2dsbZ2ZmJEyeSrq1KKobZbGb27Nm0bNmSxo0bExoayqlTpwocExoaip2dXYHH2LFjq+xzCFESCXtC1AKvvf46mZmZfPTxx7Zuyh3VP7QAqNWZ8/dXiw0GDtQDTwD/h1p9KwACAobh41Nwp7O7VTiI28LMF15gxBNP0Lt370q4mu3C3vjx44mOjiY8PJzw8HCio6OZOHFiiecsXLiQRYsWsWTJEqKionB3d+fRRx8lK6tgvcmpU6eSnJyc//jss8+q7HMIURIZxhWiFrC3t+fjjz9mxIgRjBwx4q7KW1RU4QUbRdFCn6urqhpiMGhz/DzYuzcTNfduY7W0t2aLJzoaVq5U4fhuaH8HW4c8gO+++46f9u7lzJkzpR9cJiZKHqqtmmHc2NhYwsPDOXToEEFBQQAsW7aM7t27c/bs2SKLQ5vNZhYvXswbb7zBiBEjAFi1ahUtWrTgq6++KlAXs0mTJrjf7R9aiCogPXtC1BL9+vVj2NChTJ8xg+peV6X1JBUVNKzr/TZooEJM69bg46NCn07XAbXYQgCYzVtISrKUtClJ4e+9JgS9jIwMZrzwAgvnz6d58+aVdNVcSu7VU587MzOzwOPmzZsVuuvBgwdxdnbOD3oAwcHBODs7c+DAgSLPiY+PJyUlhf79++e/1qhRIx555JE7zvnyyy9xdXWlU6dOvPzyy3f0/AlRXSTsCVGLfLB4MYcOH2bFihW2bkqRrOv/urqq4dzhwwGCgbJtoVW7lfQZPYBRgIHwcFWcOifH8q51oKsJw7TFmT5jBj4dOvDUM89U4lXLNozbpk2b/Ll1zs7OzJs3r0J3TUlJwc3N7Y7X3dzcSElJKfYcgBYtWhR4vUWLFgXOmTBhAmvXrmX37t289dZbbNq0Kb8nUIjqJsO4QtQizZs3Z9WqVYwcOZKePXvSvn17WzepWA0aWFbpqnIsetSOFHWhdIqmHpBL+/bfce7cVdq3b8a5c/HAWSAUOMbQoSG4usKKFSb8/HScPJmL0WhZhVvwajUz4Gm++uorwn/4gRMnTlCvXmX2FZRtGDcxMbFA6ZXiFobMnj2bOXPmlHjHqKgoQNWzLMxsNhf5urXC7xc+Z+rUqfk/GwwG2rdvT2BgIMeOHaNLly4lXluIyiZhT4hapn///kydMoXxYWEc2LcPnU5Xrfcvbg5f4eCi16vt1Xr0gJgYBxo0eIPIyFjUHrGllVJxArKAp4GdVDwg1kPtoeuLCp6tUbt1NEUVb96Rdx9tX1xf4BJqtwyAvqiizl1RQS6Jjh3XYm8P77yjdhVxdW1GRAR4enoRE+PFkCHg4xNCaqoa1p48WYder9qSnV1rNsfIl5CQwF/++ldWr16Nh0dlL7gpbRGGeq9p06ZlqrM3ffr0Ule+enp6cuLECS5dunTHe1euXLmj506jzcFLSUkp8D1cvny52HMAunTpgk6n49y5cxL2RLWTospC1EJGo5GgoCCGDB7M3HfesUkbCgc+rf6e9rPRqAJNaiocOQLLl6th3XXr1B6wy5ZlActwcvobWVnbUUO9PwInadz4f7lx4wI6XVtMpuOALx4eOpKTL6AC2tuo7cr0wNd5LRiT97M30CvvPQ9gDSqs3U/z5m1xdVWlYhwdVTtTUyEy8iouLs1IS0tH1QesB2Ty6KMe+dvETZ6swuuhQzB/vrqjwWD5zNpxrVuroKsVnramfSdanUJrNblXLycnh9A+ffAzGPjk008r7bqWosrHUQG/OFnAQ5VeVDk2NhZfX18OHz5Mt27dADh8+DDBwcGcOXOm2AUaLVu25KWXXmLWrFkA3Lp1Czc3NxYsWFBggYa1mJgY/Pz82LNnD7169aq0zyBEWUjYE6KWOnXqFEFBQXy7eTN9+/a1SRsK77JR+LlBA0vAMRpVsDpzRoWkmBgVjKKjVfjat0+FKX9/9V6PHuo9V1cVFgMD1TF6vVoEsnKlOk+vh61bL9K+fStatwZPTwgP14o8q2O0RSMGg6U2YIMGKpylpqr7pKerNtrbq1qBKSmWvYBDQy2fwdPT8hm1wKipSG9dTQ57b8+ezdcbNnD06FGaNGlSade1hL0jQEm1aLKBwCrZQWPgwIH8/vvv+WVRnn32Wdq1a8fWrVvzj/Hx8WHevHk88cQTACxYsIB58+axYsUK2rdvz7vvvsvu3bs5e/YsTk5O/Prrr3z55ZcMGjQIV1dXTp8+zd///ncaN25MVFQU9evXr9TPIERpJOwJUYut+PxzXnn1VaIOH8bLy8smbSgp8Fm/rvVoac/Z2SospaaqwJadrYJWaqpavODpqX5PSVFhLSVFHZ+UZCnoHB1tKfIcHW3Z0aNBA0vh55QU9bOrq7qO9dazWg9kaqpaPQyW9qWnqzZZn3M3Ya64/WtLO7am2bJlC09Onsz+/fvx8/Or1Gtbwt7PlB72ulVJ2Lt27RozZ87ku+++A2DYsGEsWbIEvRpzB9T8vBUrVjB58mRA9e7NmTOHzz77jLS0NIKCgvjoo48wGAyAmlsYFhZGTEwM2dnZtGnThsGDB/P2229z3333VWr7hSgLCXtC1HIvzJxJ5O7dHNi3D8eKVOqtgKKGdIv7XQtT1u8VDoJFva6FQa1HTvs5JcXys729CoPWxZ61XrzSdqqwDoCF21nekKcpKezV5KAXExNDSI8erPziC0aMGlXp17eEvYOUHva6y964QpSThD0hajmTycSAAQPQOzuz4euvK3mVZNkVF2gKh7iiXrcOU8W9bs16eLjwedr72iII69eqUllCW+HvqCYHvatXr9ItOJiJYWHMLmVla3lZwt4eSg97j0jYE6KcJOwJUQdcvXqVrl27MnnSJP751ls2a0dpw5UlKSncVbWy7BJS2vl1SU5ODgMGDcLJ0ZFN33xTZf8DYQl7uyg97PWRsCdEOdWyxf9CiKI0a9aMb7/9lpCQELwfeIDx48fbpB1a6ClPcLJF0KtoSKtrIQ/UfLS/Tp9OSkoKmw8erKaeYjOU+F1Kn4QQFSFhT4g6ws/Pj40bNzJixAj0ej2DBg2yWVus93G1fq7I9YACe8NW9j6xpV1La39dDHjW3nzrLXaEh7N//36cnEoqh1KZbgEl1Yu8VU3tEKJuku3ShKhDHnvsMb5YvpwxY8eyf/9+m7al8H6uxe3zWtT7hR+Fr1n45+pQk7cwqyyLPviAz5YuZefOnbRp06Ya71y27dKEEOUjPXtC1DF/HjeOtLQ0hgwbxp7ISDp37mzrJt2huMAnbGfVqlXMnjOHXbt24aPVoak2ZdtBQwhRPhL2hKiDnnv+ea5eu8ZjAwfy0+7dNXoPXWF7W7Zs4fnp09m6dSuBgYE2aEHZ9sYVQpSPhD0h6qjX33iDjIwMeoWGErFzJ506dbJ1k0QNtH79ep6eMoUvV6+mT58+NmpFLiX33knPrxAVIWFPiDrKzs6OBQsX0qRJEx7p3Zud4eGyAbsoYMWKFcx44QU2btzIwIEDbdgSGcYVoipJ2BOiDrOzs2P2nDk4ODjQp18/vt+2jZCQEFs3S9QASz76iNffeINt27YRGhpq49bIMK4QVUnCnhD3gFdmzcLBwYHHBg7k282bbThcJ2qCBQsXMn/BAnbu3ElwcLCtm4P07AlRtSTsCXGPeP6vf8WhSROGPv44Hy9ZwqRJk2zdJFHNTCYTL770Ehs3bSIyMhJ/f39bNymPhD0hqpKEPSHuIZOeeopWbdowevRoYs+c4d25c222l66oXunp6YweM4ZLly/z888/065dO1s3yYos0BCiKsm/8kLcY/r168ehQ4f4ZvNmRo4axR9//GHrJokqFhcXR/eHH8be3p79+/fXsKAHljl7JT2EEOUlYU+Ie1CHDh04dOgQGZmZ9OjVi8TERFs3SVSR3bt3E9S9O4MHDWLLt99W4xZod0N20BCiKknYE+Iedd999/HDDz8Q1K0b/l26sHXrVls3SVSi27dv887cuQweOpQF8+bx3vvvU79+fVs3qxgS9oSoSjJnT4h7mE6n49PPPuORXr2YMHEizzz9NPPnzaNRo0a2bpqogOTkZMKefJLExET27dtHQECArZtUChMl/+dIhnGFqAjp2RNCMG7CBI4dO8ZPe/cS0qMH586ds3WTRDmFh4fzUEAALT08OHr0aC0IemBZoFHcQxZoCFEREvaEEAB4e3tz4MABevXsyZ+6dmXFihWYzWZbN0uU0fXr1/n7yy8z+s9/5v8WLGD1mjU1dH5eUWQYV4iqJGFPCJGvUaNGfLB4MWvXruXNf/6T/o89xvnz523dLFGKXbt20dnfnwMHDxIVFcWkp56ydZPu0q0yPIQQ5SVhTwhxh8GDB3P69Gm8vb3p7O/P+4sWkZOTY+tmiULS0tKYMnUqjz/xBC/MnMm+ffvw8fGxdbPKQXr2hKhKEvaEEEVydnbmk08/ZceOHSxdtozuDz/ML7/8YutmCcBsNrNhwwZ8DQZ+//13YmJimDFzZg1ebVua3DI8hBDlJWFPCFGinj17cvz4cR7r35+QHj14+plnuHjxoq2bdc+Kiorikd69mT5zJu8tXMj277+vgUWS75aJkodwZTWuEBUhYU8IUSp7e3vemTuX06dPc/36dTp07Mjbs2eTnZ1t66bdM3777TcmhIUR2qcPvXr2JC4ujgkTJ2JnZ2frplUCGcYVoipJ2BNClJmXlxfr1q8nIiKCH3fton2HDixduhSTSXpeqsq1a9f4x2uv0bFTJ3Q6HWfPnuWduXNr0UrbspBhXCGqkoQ9IcRdCw4OZu/evSxZsoT3P/gA7wcfZMlHH3Hjxg1bN63OSE5O5pVZs2jn5cXRo0fZv38/K1etonXr1rZuWhWQ1bhCVCUJe0KIcrGzs2PkyJGcPn2a9957j8+/+ALP++9n3vz5ZGRk2Lp5tdb58+f5y/PPc7+3N+fOnSMiIoL/RETUkuLI5SXDuEJUJQl7QogKqV+/PqNHj+bYsWOsXLmS73fsoK2nJ6/MmiU7cZSR2Wzmp59+Ytz48XTs1ImsrCyioqLY8u23BAUF2bp51UB20BCiKknYE0JUCjs7OwYOHMjevXvZtm0bFy5cwNC5M30ffZT169dz65YMxRV29epVPli8GF+DgeEjRuDu7k5sbCxrvvwSg8Fg6+ZVI1MZHkKI8rIzy35IQogqcvnyZVauWMHSZcvIzMxk8qRJhE2YgJ+fX61eRWoymTh8+DAJCQn07dsXd3d3srOzy7RoIicnhz179rBi5Uo2btpEt27dePbZZxk1ahT29vbV0PqaIzMzE2dnZ2Ai0LCEI28Bq8nIyKBp06bV0zgh6hAJe0KIKpebm0tkZCTLli5l67ZttGrVilEjRzJq5EgCAgJqVfAzmUwMHjKE/0REAKDT6dDpdFy/fp2NX3/NyJEjizxn165dbNy0ic1btqDT6fjzmDE8O20avr6+1f0RagxL2BtP6WHvKwl7QpSThD0hRLW6fv064eHhbNywga3btuHm5sbIESNU0eaQEBo3bmzrJhbLbDYzddo0Vq1axapV/6Zr1wA2b/4ek8nE6tVf09HHwOZvvgHUEG1kZCTbv/+eb7/7jiZNmjByxAhGjR5NSEhILd7tovJYwt5oQFfCkSZgg4Q9IcpJwp4QwmaMRiM7d+7km02biPjxR1JTUwkJCaFP79707dOHwMBAdLqSQkD12r59O0OGDWPJknlMmDAq//Xc3FweeKAbgwcNpkWLFuyKjOTEiRN06tSJR/v1Y9To0QQFBVGvnkyTtmYJeyMpPextkrAnRDlJ2BNC1Ahms5lz586xa9cufoyIIHL3boxGIwEBAQT4+9MlIICAgAB8fX1tFgBffuUVvt6wnhMndue/ZjTeZN26zbz//ic0aNCQR/v1o2+/foSGhtKiRQubtLO2sIS94ZQe9rZI2BOinCTsCSFqpNzcXE6dOsWxY8c4dvQov0RHEx0dzc2bNzEYDHg/8ABeXl54tmuHl5cXXl5etG3bttIWOWRmZhIfH09CQgLxCQnEx8fzzebN9O37MO3ateHChYtgrk/Llm3o8qc/0bVrV9q2bVsp975XWMLeIEoPe99L2BOinCTsCSFqjdzcXH799VeOHz/O+fPniT9/Pj+MJSQkcPPmTZycnNDr9bi4uKDX69E7O6PX62nY8M4FAGazmRs3bpCenk56Rgbp6emkpaWRnp7OjRs3aNq0qQqSnp60a9eO+x94AG9vbwICAvDw8LDBN1C3WMJeP6BBCUfmABES9oQoJwl7Qog6ITc3l0uXLnHt2rX8wGYd3orbv7dx48YFw2Hez25ubri4uFTzp7i3GI1GvLy8SElJKfVYd3d34uPj77nyNEJUBgl7QgghbMZoNJap4HbDhg0l6AlRThL2hBBCCCHqMKkDIIQQQghRh0nYE0IIIYSowyTsCSGEEELUYRL2hBBCCCHqMAl7QgghhBB1mIQ9IYQQQog6TMKeEEIIIUQd9v85YIt4qYCYtgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot_diff(aice1_ann[::-25,:,:].mean('time'),aice2_ann[::-25,:,:].mean('time'),0.,1.,case1,case2,\"S\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "ab1c8910-677e-4345-8f06-ec3f7a4a9f07", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", @@ -245,10 +313,71 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, + "id": "cbf46c87-c3be-4a9e-90e8-e2a6633109e3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAG2CAYAAACDLKdOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABy70lEQVR4nO3dd3xT9f4/8FfSNmlL2nQv6IQySgGBMlqZKgW9DMGf4GK4viAoICLKRdnjOlFRFFAoIF5EBS8qF6zsWtYtLVQqZRUKtKXQldKVNvn8/jg0EDpom3SF1/PxyCPJOSef8zk5Sc47nykTQggQERERWQh5Y2eAiIiIyJwY3BAREZFFYXBDREREFoXBDREREVkUBjdERERkURjcEBERkUVhcENEREQWhcENERERWRQGN0RERGRRGNwQERGRRWlSwc2yZcvQo0cPODg4wMPDA48//jiSk5ONtpkwYQJkMpnRrXfv3o2UYyIiImpqmlRws3//fkyZMgWHDx9GdHQ0ysrKEBkZiYKCAqPthgwZgvT0dMNtx44djZRjIiIiamqsGzsDd9q5c6fR83Xr1sHDwwNxcXHo16+fYblSqYSXl1dDZ4+IiIiagSYV3NwtLy8PAODi4mK0fN++ffDw8ICTkxP69++PJUuWwMPDo8p0SkpKUFJSYniu1+uRnZ0NV1dXyGSy+sk8ERERmZUQAvn5+fDx8YFcXnXlk0wIIRowXzUmhMCIESOQk5ODgwcPGpZ///33UKlU8Pf3R0pKCt59912UlZUhLi4OSqWy0rTmz5+PBQsWNFTWiYiIqB5dvnwZrVq1qnJ9kw1upkyZgt9++w0xMTHVHkB6ejr8/f2xefNmjBo1qtJt7i65ycvLg5+fHy5fvgxHR0ez552IiIjMT6PRwNfXF7m5uVCr1VVu1ySrpV577TVs374dBw4cqDawAQBvb2/4+/vj7NmzVW6jVCorLdVxdHRkcENERNTM3KtJSZMKboQQeO2117Bt2zbs27cPgYGB93xNVlYWLl++DG9v7wbIIRERETV1Taor+JQpU/Dtt9/iu+++g4ODAzIyMpCRkYGioiIAwM2bNzFz5kwcOnQIFy9exL59+zBs2DC4ublh5MiRjZx7IiIiagqaVJubqoqZ1q1bhwkTJqCoqAiPP/444uPjkZubC29vbwwcOBCLFi2Cr69vjfej0WigVquRl5fHaikiIqJmoqbX7yZXLVUdOzs77Nq1q4FyQ1Qzer0eWq22sbNBRNTs2djYwMrKyuR0mlRwQ9TcaLVapKSkQK/XN3ZWiIgsgpOTE7y8vEwah47BDVEdCSGQnp4OKysr+Pr6VjugFBERVU8IgcLCQmRmZgKASR2FGNwQ1VFZWRkKCwvh4+MDe3v7xs4OEVGzZ2dnBwDIzMyEh4dHnauo+FeTqI50Oh0AQKFQNHJOiIgsR/mfxdLS0jqnweCGyEScn4yIyHzM8ZvK4IaIiIgsCoMbovvMgAEDMH369MbOhtlNmDABjz/+eK1eExAQgE8++aRe8kNEjYfBDRGZJDs7G6+99hratWsHe3t7+Pn5YerUqcjLyzPabvjw4fDz84OtrS28vb0xduxYpKWlNVKuzSc9PR3PPPMM2rVrB7lcXmXgmJubiylTpsDb2xu2trbo0KEDduzYYdK+o6KiIJPJDDeVSoXu3btj69atRtvdHdDu27fP6HWV3aKiolBcXIwJEyagU6dOsLa2rjJ43LRpE7p06QJ7e3t4e3vj+eefR1ZWVpX5LL8VFxcbpbNy5UoEBgbC1tYW3bt3x8GDB016f2oiKysLQ4YMgY+PD5RKJXx9ffHqq69Co9EYbZeYmIj+/fvDzs4OLVu2xMKFC+85Nlu5+fPn44EHHjBaZq7vzYkTJ/D000/D19cXdnZ26NChAz799NN75qmkpASvvfYa3Nzc0KJFCwwfPhxXrlwxrK/uM3Ls2LFavXeNgcENEZkkLS0NaWlp+PDDD5GYmIioqCjs3LkTL774otF2AwcOxJYtW5CcnIyffvoJ58+fx//7f/+vkXJtPiUlJXB3d8ecOXPQpUuXSrfRarUYNGgQLl68iB9//BHJyclYs2YNWrZsafL+HR0dkZ6ejvT0dMTHx2Pw4MEYPXo0kpOTq3xNRESE4TXp6ekYPXo0hgwZYrRszJgx0Ol0sLOzw9SpU/HII49UmlZMTAzGjRuHF198EadOncIPP/yAY8eO4aWXXqoyn+U3W1tbw/rvv/8e06dPx5w5cxAfH4++ffvi0UcfRWpqqsnvUXXkcjlGjBiB7du348yZM4iKisIff/yBSZMmGbbRaDQYNGgQfHx8cOzYMaxYsQIffvghPv744zrv11zfm7i4OLi7u+Pbb7/FqVOnMGfOHMyePRuff/55tfufPn06tm3bhs2bNyMmJgY3b97E0KFDDR0l7v6MpKen46WXXkJAQADCwsJq/N41GnEfysvLEwBEXl5eY2eFmrGioiKRlJQkioqKGjsrtdK/f38xZcoUMWXKFKFWq4WLi4uYM2eO0Ov1Vb5m+/btolu3bkKpVIrAwEAxf/58UVpaWuX2W7ZsEQqFotpt/vOf/wiZTCa0Wu0981xWViZeeOEFERAQIGxtbUXbtm3FJ598YrTN+PHjxYgRI2p1nP7+/mLJkiXi+eefFyqVSvj6+opVq1YZpTtr1iwRHBws7OzsRGBgoHjnnXeqzHP//v3FtGnTKiz/8ssvRVBQULXHqtFoxDPPPCPs7e2Fl5eX+Pjjj6tMr9y6deuEWq02WqbT6YSNjY3YsmXLPfNV7u73rjbbfPDBByIoKMho2WeffSZatWpVbT7v1rNnTzFp0iSjZe3btxdvv/12la+ZN2+e6NKli9iwYYPw9/cXjo6OYsyYMUKj0Ri20ev14r333hOBgYHC1tZWdO7cWfzwww/V5uXTTz81yv/KlSuFWq0WxcXFhmXLli0TPj4+1X5vhJCOHYDRbd26dZVua67vzeTJk8XAgQOrXJ+bmytsbGzE5s2bDcuuXr0q5HK52LlzZ6Wv0Wq1wsPDQyxcuLDKdIWo+N4JIURMTIzo16+fsLOzE05OTiIyMlJkZ2dXmUZ1v601vX6z5IbITIQQKNSWNcpN1HKKuPXr18Pa2hpHjhzBZ599huXLl+Prr7+udNtdu3bhueeew9SpU5GUlIRVq1YhKioKS5YsqTL98nlfrK0rH0orOzsbmzZtQkREBGxsbO6ZX71ej1atWmHLli1ISkrC3Llz8c9//hNbtmwx+Tg/+ugjhIWFIT4+HpMnT8Yrr7yC06dPG9Y7ODggKioKSUlJ+PTTT7FmzRosX778nnm+0/bt2xEeHo4pU6bA09MToaGhWLp0qeFfMgDMmDEDf/75J7Zv347o6GgcPHgQx48fr9V+dDod1q9fDwDo1q1brV5bVxEREbhy5Qp27NgBIQSuXbuGH3/8Ef/4xz+Mtrt58yb8/f3RqlUrDB06FPHx8YZ1Wq0WcXFxiIyMNHpNZGQkYmNjq93/+fPn8fPPP+PXX3/Fr7/+iv379+Nf//qXYf0777yDdevW4csvv8SpU6fw+uuv47nnnsP+/fsrTS8tLQ1bt25F//79DcsOHTqE/v37Q6lUGpYNHjwYaWlpuHjxYrX5GzNmDN544w107NjRqFSsMub63uTl5cHFxaXK9XFxcSgtLTV6v318fBAaGlrl+719+3bcuHEDEyZMqDLdyt67hIQEPPzww+jYsSMOHTqEmJgYDBs2zOizXx84iB+RmRSV6hAyt3HmPktaOBj2ipp/nX19fbF8+XLIZDK0a9cOiYmJWL58OV5++eUK2y5ZsgRvv/02xo8fDwAICgrCokWLMGvWLMybN6/C9llZWVi0aBEmTpxYYd1bb72Fzz//HIWFhejduzd+/fXXGuXXxsYGCxYsMDwPDAxEbGwstmzZgtGjR5t0nI899hgmT55syN/y5cuxb98+tG/fHoB0cSwXEBCAN954A99//z1mzZpVo7wDwIULF7Bnzx48++yz2LFjB86ePYspU6agrKwMc+fORX5+PtavX4/vvvsODz/8MABpwmAfH597pp2XlweVSgUAKCoqgo2NDVavXo3WrVvXOH+miIiIwKZNmzBmzBgUFxejrKwMw4cPx4oVKwzbtG/fHlFRUejUqRM0Gg0+/fRTPPjggzhx4gSCg4Nx48YN6HQ6eHp6GqXt6emJjIyMavev1+sRFRUFBwcHAMDYsWOxe/duLFmyBAUFBfj444+xZ88ehIeHA5A+vzExMVi1apXRRfjpp5/Gf/7zHxQVFWHYsGFGQXBGRgYCAgIq5K18XWBgYJX5s7Ozg0qlgrW1Nby8vKrczlzfm0OHDmHLli347bffqtwmIyMDCoUCzs7OFY6pqvf7m2++weDBgyudpLq69+79999HWFgYVq5caVjWsWPHKvNmLiy5IboP9e7d22gsifDwcJw9e7bSf1NxcXFYuHAhVCqV4fbyyy8jPT0dhYWFRttqNBr84x//QEhISKWBz5tvvon4+Hj8/vvvsLKywrhx42pc6vTVV18hLCwM7u7uUKlUWLNmzT3bY9TkODt37mx4LJPJ4OXlZRj+HQB+/PFH9OnTB15eXlCpVHj33Xdr3Q5Er9fDw8MDq1evRvfu3fHUU09hzpw5+PLLLwFIwU9paSl69uxpeI1arUa7du3umbaDgwMSEhKQkJCA+Ph4LF26FBMnTsQvv/xSqzzWVVJSEqZOnYq5c+ciLi4OO3fuREpKilG7i969e+O5555Dly5d0LdvX2zZsgVt27Y1CoCAiuObCCHuOeZJQECAIbABpCH7y89fUlISiouLMWjQIKPP74YNG3D+/HmjdJYvX47jx4/j559/xvnz5zFjxox75q2y5XVhru/NqVOnMGLECMydOxeDBg2qdT6qer+vXLmCXbt2VWgPVK6696685KahseSGyEzsbKyQtHBwo+27vuj1eixYsACjRo2qsO7OBqH5+fkYMmQIVCoVtm3bVmmxuZubG9zc3NC2bVt06NABvr6+OHz4sOFfdVW2bNmC119/HR999BHCw8Ph4OCADz74AEeOHDH5+O7Op0wmM0yEevjwYTz11FNYsGABBg8eDLVajc2bN+Ojjz6q1T68vb0rzHbcoUMHZGRkQKvVVnmhrEngJ5fL0aZNG8Pzzp074/fff8d7772HYcOG1SqfdbFs2TI8+OCDePPNNw37b9GiBfr27YvFixdXOj+QXC5Hjx49cPbsWQDS58LKyqpCqUFmZmaF0py7VXf+yu9/++23Co2376xiAgAvLy94eXmhffv2cHV1Rd++ffHuu+/C29sbXl5eleYNwD3zdy/m+t4kJSXhoYcewssvv2xU2lgZLy8vaLVa5OTkGJXeZGZmIiIiosL269atg6urK4YPH15lelW9d+XTKTQ0BjdEZiKTyWpVNdSYDh8+XOF5cHBwpfO4dOvWDcnJyUYX0LtpNBoMHjwYSqUS27dvNwp6qlJ+4S4pKbnntgcPHkRERISh+ghAhX/elanNcVbmzz//hL+/P+bMmWNYdunSpRq99k4PPvggvvvuO+j1esMEq2fOnIG3tzcUCgVat24NGxsbHD161FDsr9FocPbsWaOqk5qysrJCUVFRrV9XF4WFhRXaiJS/v1UFZ0IIJCQkoFOnTgCkKUy6d++O6OhojBw50rBddHQ0RowYUee8hYSEQKlUIjU1tVbv492fzfDwcPzzn/+EVqs1TLfy+++/w8fHp0J1VWUUCkWlpaLm+t6cOnUKDz30EMaPH19tW7hy3bt3h42NDaKjow3Vuunp6fjrr7/w/vvvV9jfunXrMG7cuBq1j7s7f507d8bu3buNqpUbQvP4JSYis7p8+TJmzJiBiRMn4vjx41ixYoWhNGL27Nm4evUqNmzYAACYO3cuhg4dCl9fXzz55JOQy+U4efIkEhMTsXjxYuTn5yMyMhKFhYX49ttvodFoDONcuLu7w8rKCkePHsXRo0fRp08fODs748KFC5g7dy5at259z1IbAGjTpg02bNiAXbt2ITAwEBs3bsSxY8eqbetwr+OsiTZt2iA1NRWbN29Gjx498Ntvv2Hbtm0VtktISAAgNZq9fv06EhISoFAoEBISAgB45ZVXsGLFCkybNg2vvfYazp49i6VLl2Lq1KkApKql8ePH480334SLiws8PDwwb948yOVyo9Kcu88NIF1MyksVioqKEB0djV27dmHu3LlGeSzP153K/3FXJykpCVqtFtnZ2cjPzzekUT5uy7Bhw/Dyyy/jyy+/xODBg5Geno7p06ejZ8+ehjZDCxYsQO/evREcHAyNRoPPPvsMCQkJ+OKLLwz7mTFjBsaOHYuwsDCEh4dj9erVSE1NNarequz4q+Pg4ICZM2fi9ddfh16vR58+faDRaBAbGwuVSoXx48djx44duHbtGnr06AGVSoWkpCTMmjULDz74oCFweeaZZ7BgwQJMmDAB//znPw3nb+7cuTWqlgoICEBKSgoSEhLQqlUrODg4QKvVmuV7c+rUKQwcOBCRkZGYMWOG4bNgZWUFd3d3AMDVq1fx8MMPY8OGDejZsyfUajVefPFFvPHGG3B1dYWLiwtmzpyJTp06Vejyv2fPHqSkpFRaJVWT92727Nno1KkTJk+ejEmTJkGhUGDv3r148skn4ebmVqPzWCfV9qWyUOwKTubQnLuCT548WUyaNEk4OjoKZ2dn8fbbbxu6tI4fP17079/f6DU7d+4UERERws7OTjg6OoqePXuK1atXCyGE2Lt3b4WuruW3lJQUIYQQJ0+eFAMHDhQuLi5CqVSKgIAAMWnSJHHlypUa5bm4uFhMmDBBqNVq4eTkJF555RXx9ttviy5duhi2qawreHXHKYTUFXz58uVG++rSpYuYN2+e4fmbb74pXF1dhUqlEmPGjBHLly+v0K25smP39/c32iY2Nlb06tVLKJVKERQUJJYsWSLKysoM6yvrCt6zZ0+jrtB3n5u7uxkrlUrRtm3bCmn379+/0jyWH2d1XcH9/f0rfe2dPvvsMxESEiLs7OyEt7e3ePbZZ43O7fTp04Wfn59QKBTC3d1dREZGitjY2Ar7+uKLL4S/v79QKBSiW7duYv/+/Ubr7z7+8q7gd1q+fLnRe6/X68Wnn34q2rVrJ2xsbIS7u7sYPHiwIe09e/aI8PBwoVarha2trQgODhZvvfWWyMnJMUr35MmTom/fvkKpVAovLy8xf/78e3YDL1dcXCyeeOIJ4eTkZOgKbq7vzbx58+75+UtJSREAxN69ew3LioqKxKuvvipcXFyEnZ2dGDp0qEhNTa2Q96efflpERERUelw1fe/27dsnIiIihFKpFE5OTmLw4MEVtrmTObqCy4SoZR9SC6DRaKBWqw3d7ojqori4GCkpKYYRValpGTBgAB544IFmO71CQUEBWrZsiY8++qjKhpxElqi639aaXr9ZLUVE1ATEx8fj9OnT6NmzJ/Ly8rBw4UIAMKnNCdH9il3BiajRTZo0yair7p23JjGUewP58MMP0aVLFzzyyCMoKCjAwYMH67ddAplFx44dq/z8btq0qbGzd19itRSrpaiOWC1lPpmZmVVOtufo6AgPD48GzhFRzV26dAmlpaWVrvP09DQah4fujdVSRGQRPDw8GMBQs+Xv79/YWaC7sFqKiIiILAqDGyIiIrIoDG6IiIjIojC4ISIiIovC4IaIiIgsCoMbovvMgAEDMH369MbOhtlNmDABjz/+eK1eExAQ0GxHMCaiqjG4ISKTZGdn47XXXkO7du1gb28PPz8/TJ06FXl5eUbbDR8+HH5+frC1tYW3tzfGjh2LtLS0Rsq1+aSnp+OZZ55Bu3btIJfLqwwcc3NzMWXKFHh7e8PW1hYdOnTAjh07TNp3VFQUZDKZ4aZSqdC9e3ds3brVaLu7A9p9+/YZva6yW1RUFIqLizFhwgR06tQJ1tbWVQaPmzZtQpcuXWBvbw9vb288//zzyMrKqjKf5bfi4mKjdFauXGkY26R79+44ePCgSe9PTWRlZWHIkCHw8fGBUqmEr68vXn311QrjLiUmJqJ///6ws7NDy5YtsXDhwipnPb/b/PnzDRONljPX9+bEiRN4+umn4evrCzs7O3To0AGffvrpPfNUUlKC1157DW5ubmjRogWGDx+OK1euGNZX9xk5duyYYbvK1n/11Vc1el/qE4MbIjJJWloa0tLS8OGHHyIxMRFRUVHYuXNnhfmQBg4ciC1btiA5ORk//fQTzp8/j//3//5fI+XafEpKSuDu7o45c+agS5culW6j1WoxaNAgXLx4ET/++COSk5OxZs0atGzZ0uT9Ozo6Ij09Henp6YiPj8fgwYMxevRoJCcnV/maiIgIw2vS09MxevRoDBkyxGjZmDFjoNPpYGdnh6lTp1aYLbpcTEwMxo0bhxdffBGnTp3CDz/8gGPHjuGll16qMp/ltzsHaPv+++8xffp0zJkzB/Hx8ejbty8effRRpKammvweVUcul2PEiBHYvn07zpw5g6ioKPzxxx9GI2NrNBoMGjQIPj4+OHbsGFasWIEPP/wQH3/8cZ33a67vTVxcHNzd3fHtt9/i1KlTmDNnDmbPno3PP/+82v1Pnz4d27Ztw+bNmxETE4ObN29i6NCh0Ol0ACp+RtLT0/HSSy8hICAAYWFhRmmtW7fOaLvx48fX+X0xm2qn1bRQnBWczKE5zwo+ZcoUMWXKFKFWq4WLi4uYM2dOtTMcb9++XXTr1k0olUoRGBgo5s+fL0pLS6vcfsuWLUKhUFS7zX/+8x8hk8mEVqu9Z57LysrECy+8IAICAoStra1o27at+OSTT4y2qWxW8Hsdp7+/v1iyZIl4/vnnhUqlEr6+vmLVqlVG6c6aNUsEBwcLOzs7ERgYKN55550q89y/f38xbdq0Csu//PJLERQUVO2xVjYreFXplVu3bl2FGcp1Op2wsbERW7ZsuWe+ylU3K/i9tvnggw9EUFCQ0bLPPvtMtGrVqtp83q1nz55i0qRJRsvat29vNCv63cpnBd+wYYPw9/cXjo6OYsyYMUKj0Ri20ev14r333hOBgYHC1tZWdO7cWfzwww/V5uXTTz81yv/KlSuFWq0WxcXFhmXLli0TPj4+95wZ/O6Z23FrVvDKmOt7M3nyZDFw4MAq1+fm5gobGxuxefNmw7KrV68KuVwudu7cWelrtFqt8PDwEAsXLjRaDkBs27atyn0JIURMTIzo16+fsLOzE05OTiIyMlJkZ2dXub05ZgVnyQ2RuQgBaAsa51bLWVTWr18Pa2trHDlyBJ999hmWL1+Or7/+utJtd+3aheeeew5Tp05FUlISVq1ahaioKCxZsqTK9MuHRre2rnwQ9OzsbGzatAkRERGwsbG5Z371ej1atWqFLVu2ICkpCXPnzsU///lPbNmyxeTj/OijjxAWFob4+HhMnjwZr7zyCk6fPm1Y7+DggKioKCQlJeHTTz/FmjVrsHz58nvm+U7bt29HeHg4pkyZAk9PT4SGhmLp0qWGf8kAMGPGDPz555/Yvn07oqOjcfDgQRw/frxW+9HpdFi/fj0AoFu3brV6bV1FRETgypUr2LFjB4QQuHbtGn788Uf84x//MNru5s2b8Pf3R6tWrTB06FDEx8cb1mm1WsTFxSEyMtLoNZGRkYiNja12/+fPn8fPP/+MX3/9Fb/++iv279+Pf/3rX4b177zzDtatW4cvv/wSp06dwuuvv47nnnsO+/fvrzS9tLQ0bN26Ff379zcsO3ToEPr37w+lUmlYNnjwYKSlpeHixYvV5m/MmDF444030LFjR6NSscqY63uTl5cHFxeXKtfHxcWhtLTU6P328fFBaGhole/39u3bcePGDUyYMKHCuldffRVubm7o0aMHvvrqK+j1esO6hIQEPPzww+jYsSMOHTqEmJgYDBs2zOizXx84/QKRuZQWAkt9Gmff/0wDFC1qvLmvry+WL18OmUyGdu3aITExEcuXL8fLL79cYdslS5bg7bffNhQ1BwUFYdGiRZg1axbmzZtXYfusrCwsWrQIEydOrLDurbfewueff47CwkL07t0bv/76a43ya2NjgwULFhieBwYGIjY2Flu2bMHo0aNNOs7HHnsMkydPNuRv+fLl2LdvH9q3bw9AujiWCwgIwBtvvIHvv/8es2bNqlHeAeDChQvYs2cPnn32WezYsQNnz57FlClTUFZWhrlz5yI/Px/r16/Hd999h4cffhiAVNTv43Pvz1NeXh5UKhUAoKioCDY2Nli9ejVat25d4/yZIiIiAps2bcKYMWNQXFyMsrIyDB8+HCtWrDBs0759e0RFRaFTp07QaDT49NNP8eCDD+LEiRMIDg7GjRs3oNPp4OnpaZS2p6cnMjIyqt2/Xq9HVFSUYf6msWPHYvfu3ViyZAkKCgrw8ccfY8+ePQgPDwcgfX5jYmKwatUqowDm6aefxn/+8x8UFRVh2LBhRkFwRkYGAgICKuStfF1gYGCV+bOzs4NKpYK1tTW8vLyq3M5c35tDhw5hy5Yt+O2336rcJiMjAwqFAs7OzhWOqar3+5tvvsHgwYPh6+trtHzRokV4+OGHYWdnh927d+ONN97AjRs3DN+b999/H2FhYVi5cqXhNR07dqwyb+bCkhui+1Dv3r0hk8kMz8PDw3H27NlK/03FxcVh4cKFRjMdv/zyy0hPT0dhYaHRthqNBv/4xz8QEhJSaeDz5ptvIj4+Hr///jusrKwwbty4GjfK/OqrrxAWFgZ3d3eoVCqsWbPmnu0xanKcnTt3NjyWyWTw8vJCZmamYdmPP/6IPn36wMvLCyqVCu+++26t24Ho9Xp4eHhg9erV6N69O5566inMmTMHX375JQAp+CktLUXPnj0Nr1Gr1WjXrt0903ZwcEBCQgISEhIQHx+PpUuXYuLEifjll19qlce6SkpKwtSpUzF37lzExcVh586dSElJMWqz0rt3bzz33HPo0qUL+vbtiy1btqBt27ZGARAAo3MFAEKICsvuFhAQYDQxpbe3t+H8JSUlobi4GIMGDTL6/G7YsAHnz583Smf58uU4fvw4fv75Z5w/fx4zZsy4Z94qW14X5vrenDp1CiNGjMDcuXMxaNCgWuejqvf7ypUr2LVrV4X2QIAU/IeHh+OBBx7AG2+8gYULF+KDDz4wrC8vuWloLLkhMhcbe6kEpbH2XU/0ej0WLFiAUaNGVVh3Z4PQ/Px8DBkyBCqVCtu2bau02NzNzQ1ubm5o27YtOnToAF9fXxw+fNjwr7oqW7Zsweuvv46PPvoI4eHhcHBwwAcffIAjR46YfHx351MmkxmK1Q8fPoynnnoKCxYswODBg6FWq7F582Z89NFHtdqHt7c3bGxsYGVlZVjWoUMHZGRkQKvVVnmhrEngJ5fL0aZNG8Pzzp074/fff8d7772HYcOG1SqfdbFs2TI8+OCDePPNNw37b9GiBfr27YvFixfD29u70jz36NEDZ8+eBSB9LqysrCqUGmRmZlYozblbdeev/P63336r0Hj7ziomAPDy8oKXlxfat28PV1dX9O3bF++++y68vb3h5eVVad4A3DN/92Ku701SUhIeeughvPzyy0aljZXx8vKCVqtFTk6OUelNZmYmIiIiKmy/bt06uLq6Yvjw4fc8nt69e0Oj0eDatWvw9PSEnZ3dPV9TH1hyQ2QuMplUNdQYt1r+ezx8+HCF58HBwUYX33LdunVDcnIy2rRpU+Eml0s/IRqNBpGRkVAoFNi+fbtR0FOV8gt3SUnJPbc9ePAgIiIiMHnyZHTt2hVt2rSp8M/b1OOszJ9//gl/f3/MmTMHYWFhCA4OxqVLl2r02js9+OCDOHfunFFbhDNnzsDb2xsKhQKtW7eGjY0Njh49aliv0WgMF//asrKyQlFRUZ1eW1uFhYWGz8Gd+weqDs6EEEhISDAEPgqFAt27d0d0dLTRdtHR0ZVebGsqJCQESqUSqampFT67d1ev3J0/4PZnMzw8HAcOHIBWqzVs8/vvv8PHx6dCdVVlFApFpaWi5vrenDp1CgMHDsT48eOrbQtXrnv37rCxsTF6v9PT0/HXX39VeL+FEFi3bh3GjRtXo/Zx8fHxsLW1hZOTEwAp2N29e/c9X2duLLkhug9dvnwZM2bMwMSJE3H8+HGsWLHCUBoxe/ZsXL16FRs2bAAAzJ07F0OHDoWvry+efPJJyOVynDx5EomJiVi8eDHy8/MRGRmJwsJCfPvtt9BoNIYxQtzd3WFlZYWjR4/i6NGj6NOnD5ydnXHhwgXMnTsXrVu3vmepDQC0adMGGzZswK5duxAYGIiNGzfi2LFj1bZ1uNdx1kSbNm2QmpqKzZs3o0ePHvjtt9+wbdu2CtslJCQAkBrNXr9+HQkJCVAoFAgJCQEAvPLKK1ixYgWmTZuG1157DWfPnsXSpUsxdepUAFLV0vjx4/Hmm2/CxcUFHh4emDdvHuRyuVFpzt3nBpAuPuWlCkVFRYiOjsauXbswd+5cozyW5+tO5aUV1UlKSoJWq0V2djby8/MNaZSP2zJs2DC8/PLL+PLLLzF48GCkp6dj+vTp6Nmzp6HN0IIFC9C7d28EBwdDo9Hgs88+Q0JCAr744gvDfmbMmIGxY8ciLCwM4eHhWL16NVJTU42qtyo7/uo4ODhg5syZeP3116HX69GnTx9oNBrExsZCpVJh/Pjx2LFjB65du4YePXpApVIhKSkJs2bNwoMPPmgIXJ555hksWLAAEyZMwD//+U/D+Zs7d26NqqUCAgKQkpKChIQEtGrVCg4ODtBqtWb53pQHNpGRkZgxY4bhs2BlZQV3d3cAwNWrV/Hwww9jw4YN6NmzJ9RqNV588UW88cYbcHV1hYuLC2bOnIlOnTpV6PK/Z88epKSkVFol9csvvyAjIwPh4eGws7PD3r17MWfOHPzf//2foWRs9uzZ6NSpEyZPnoxJkyZBoVBg7969ePLJJ+Hm5laj81gn1falslDsCk7m0Jy7gk+ePFlMmjRJODo6CmdnZ/H2228burSOHz9e9O/f3+g1O3fuFBEREcLOzk44OjqKnj17itWrVwshhNi7d2+Frq7lt5SUFCGEECdPnhQDBw4ULi4uQqlUioCAADFp0iRx5cqVGuW5uLhYTJgwQajVauHk5CReeeUV8fbbb4suXboYtqmsK3h1xymE1BV8+fLlRvvq0qWLmDdvnuH5m2++KVxdXYVKpRJjxowRy5cvr9CtubJj9/f3N9omNjZW9OrVSyiVShEUFCSWLFkiysrKDOsr6wres2dPo67Qd5+bu7sZK5VK0bZt2wpp9+/fv9I8lh9ndV3B/f39K33tnT777DMREhIi7OzshLe3t3j22WeNzu306dOFn5+fUCgUwt3dXURGRorY2NgK+/riiy+Ev7+/UCgUolu3bmL//v1G6+8+/vKu4Hdavny50Xuv1+vFp59+Ktq1aydsbGyEu7u7GDx4sCHtPXv2iPDwcKFWq4Wtra0IDg4Wb731lsjJyTFK9+TJk6Jv375CqVQKLy8vMX/+/Ht2Ay9XXFwsnnjiCeHk5GToCm6u7828efPu+flLSUkRAMTevXsNy4qKisSrr74qXFxchJ2dnRg6dKhITU2tkPenn35aREREVHpc//3vf8UDDzwgVCqVsLe3F6GhoeKTTz6p0JV93759IiIiQiiVSuHk5CQGDx5c4f29kzm6gsuEqGUfUgug0WigVqsN3e6I6qK4uBgpKSmGEVWpaRkwYAAeeOCBZju9QkFBAVq2bImPPvqo0n/NRJaqut/Wml6/WS1FRNQExMfH4/Tp0+jZsyfy8vKwcOFCAMCIESMaOWdEzQ8bFBNRo5s0aZJRV907b3e2ubB0H374Ibp06YJHHnkEBQUFOHjwYP22SyCz6NixY5Wf302bNjV29u5LrJZitRTVEaulzCczM7PCRIXlHB0d4eHh0cA5Iqq5S5cuobS0tNJ1np6eRuPw0L2xWoqILIKHhwcDGGq2/P39GzsLdBdWSxEREZFFYXBDZKL7sGaXiKje3DnYZV2xWoqojmxsbCCTyXD9+nW4u7ubZY4ZIqL7lRACWq0W169fh1wuh0KhqHNaDG6I6sjKygqtWrXClStXcPHixcbODhGRRbC3t4efn1+FaT1qo9bBTVFREbKzsytMQnbq1KkGmcacqClRqVQIDg6usqcEERHVnJWVFaytrU0uCa9VcPPjjz/i9ddfh4uLC4QQWLNmDXr16gUAGDt2LI4fP25SZoiaIysrqxpPxEhERPWvVmU+ixcvxvHjx3HixAmsXbsWL7zwAr777jsAbFRJRERETUOtSm5KS0sNs4yGhYXhwIEDGDVqFM6dO8fGlERERNQk1KrkxsPDAydPnjQ8d3V1RXR0NP7++2+j5URERESNpVbBzcaNGyuMIqpQKPDvf/8b+/fvN2vGiIiIiOqiVtVSrVq1qnLdgw8+aHJmiIiIiExlthGK4+LizJUUERERUZ2ZLbgZOXKkuZIiIiIiqrNaVUuNHj260uVCCGRnZ5slQ0RERESmqFVw88cff2Djxo1QqVRGy4UQOHDggFkzRkRERFQXtQpuBgwYAJVKhf79+1dY17VrV7NlioiIiKiuZOI+HFpYo9FArVYjLy8Pjo6OjZ0dIiIiqoGaXr/N1qCYiIiIqCmo9azgd7py5Qq+/PJLxMbGIiMjAzKZDJ6enoiIiMCkSZPg6+trrnwSERER1Uidq6ViYmLw6KOPwtfXF5GRkfD09IQQApmZmYiOjsbly5fx3//+t0kO7sdqKSIiouanptfvOgc3PXr0QJ8+fbB8+fJK17/++uuIiYnBsWPHapzmsmXLsHXrVpw+fRp2dnaIiIjAe++9h3bt2hm2EUJgwYIFWL16NXJyctCrVy988cUX6NixY433w+CGiIio+an3Njd//fUXJk2aVOX6iRMn4q+//qpVmvv378eUKVNw+PBhREdHo6ysDJGRkSgoKDBs8/777+Pjjz/G559/jmPHjsHLywuDBg1Cfn5+XQ+FiIiILEid29x4e3sjNjbWqFTlTocOHYK3t3et0ty5c6fR83Xr1sHDwwNxcXHo168fhBD45JNPMGfOHIwaNQoAsH79enh6euK7777DxIkT63YwREREZDHqHNzMnDkTkyZNQlxcHAYNGgRPT0/IZDJkZGQgOjoaX3/9NT755BOTMpeXlwcAcHFxAQCkpKQgIyMDkZGRhm2USiX69++P2NjYKoObkpISlJSUGJ5rNBqT8kVERERNV52Dm8mTJ8PV1RXLly/HqlWroNPpAABWVlbo3r07NmzYUOV0DTUhhMCMGTPQp08fhIaGAgAyMjIAAJ6enkbbenp64tKlS1WmtWzZMixYsKDOeSEiIqLmw6Su4GPGjMGYMWNQWlqKGzduAADc3NxgY2NjcsZeffVVnDx5EjExMRXWyWQyo+dCiArL7jR79mzMmDHD8Fyj0bCbOhERkYUyyyB+NjY28Pb2hre3tyGwuXz5Ml544YU6pffaa69h+/bt2Lt3L1q1amVY7uXlBeB2CU65zMzMCqU5d1IqlXB0dDS6ERERkWWqtxGKs7OzsX79+lq9RgiBV199FVu3bsWePXsQGBhotD4wMBBeXl6Ijo42LNNqtdi/fz8iIiLMkm8iIiJq3upcLbV9+/Zq11+4cKHWaU6ZMgXfffcd/vOf/8DBwcFQQqNWq2FnZweZTIbp06dj6dKlCA4ORnBwMJYuXQp7e3s888wzdToOIiIisix1HsRPLpdDJpOhupfLZDJDQ+MaZaaKdjPr1q3DhAkTANwexG/VqlVGg/iVNzquCQ7iR0RE1PzU+wjFLVu2xBdffIHHH3+80vUJCQno3r17rYKbhsLghoiIqPmp9xGKu3fvjuPHj1e5/l6lOkRERET1oc5tbt58802jaRHu1qZNG+zdu7euyRMRERHVSZ2rpZozVksRERE1P/VeLVWOE1YSERFRU2JycNO3b98Kg+oRERERNRaTg5uwsDD06tULp0+fNloeHx+Pxx57zNTkiYiIiGrF5ODm66+/xgsvvIA+ffogJiYGZ86cwejRoxEWFgalUmmOPBIRERHVmEkTZ5abN28eFAoFBg0aBJ1Oh8GDB+PYsWPo1q2bOZInIiIiqjGTS27S09MxdepULFq0CCEhIbCxscFTTz3FwIaIiIgahcnBTVBQEA4ePIgffvgBcXFx2Lp1KyZPnoz33nvPHPkjIiIiqhWTq6XWrVuHp556yvB88ODB2Lt3L4YOHYpLly5h5cqVpu6CiIiIqMZMLrm5M7Ap161bN8TGxmLfvn2mJk9ERERUKyaX3OTm5uKbb75BRkYGAgMD8cADD6BLly4ICAjAn3/+aY48EhEREdWYycHNqFGjkJiYiB49euC///0vzpw5A71ej6CgIHTt2hXff/+9OfJJREREVCMmBzdHjhzB/v37ERYWBgAoKSnBqVOncOLECZw4ccLkDBIRERHVhsnBTWhoKOTy2013lEolunXrxq7gRERE1ChMblD83nvv4d1330VxcbE58kNERERkEpNLbgIDA5Gfn48OHTrg6aefRq9evdC1a1f4+fmZI39EREREtWJyyc0TTzyBy5cvY+DAgTh69ChefPFFBAYGwtXVFQ899JA58khERERUYyaX3CQlJeHw4cPo3LmzYVlqairi4+ORkJBgavJEREREtWJycNOjRw/cvHnTaJmfnx/8/PwwYsQIU5MnIiIiqhWTq6WmT5+O+fPnIycnxxz5ISIiIjKJySU3TzzxBAAgODgYw4cPR+/evdG1a1d07twZSqXS5AwSERER1YbJwU1KSgoSEhJw4sQJJCQk4L333sPFixdhZWWF9u3b4+TJk+bIJxEREVGNmBzc+Pv7w9/f36h9TX5+PhISEhjYEBERUYOTCSFEY2eioWk0GqjVauTl5cHR0bGxs0NEREQ1UNPrt8kNiomIiIiaEgY3REREZFEY3BAREZFFYXBDREREFsXk3lLlkpKSkJqaCq1Wa7R8+PDh5toFERER0T2ZHNxcuHABI0eORGJiImQyGco7X8lkMgCATqczdRdERERENWZytdS0adMQGBiIa9euwd7eHqdOncKBAwcQFhaGffv2mSGLRERERDVncsnNoUOHsGfPHri7u0Mul0Mul6NPnz5YtmwZpk6divj4eHPkk4iIiKhGTC650el0UKlUAAA3NzekpaUBkEYuTk5ONjV5IiIioloxueQmNDQUJ0+eRFBQEHr16oX3338fCoUCq1evRlBQkDnySERERFRjJgc377zzDgoKCgAAixcvxtChQ9G3b1+4urri+++/NzmDRERERLVRL3NLZWdnw9nZ2dBjqqnh3FJERETNT02v32Yb5+ZOLi4u9ZEsERER0T2ZZYTigwcP4rnnnkN4eDiuXr0KANi4cSNiYmLMkTwRERFRjZkc3Pz0008YPHgw7OzsEB8fj5KSEgBAfn4+li5danIGiYiIiGrD5OBm8eLF+Oqrr7BmzRrY2NgYlkdEROD48eOmJk9ERERUKyYHN8nJyejXr1+F5Y6OjsjNzTU1eSIiIqJaMTm48fb2xrlz5yosj4mJ4Tg3RERE1OBM7i01ceJETJs2DWvXroVMJkNaWhoOHTqEmTNnYu7cuebIIxERkcUq0+lxOiMfcZdyEHcpB1kFJRjW2QePd20JWxurxs5es2RycDNr1izk5eVh4MCBKC4uRr9+/aBUKjFz5ky8+uqr5sgjERGRxcgrKkV8ag6OX8rB/y7lIOFyLgq1OqNt/jyXhQ9/T8b48AA819sfzi0UjZTb5smkQfxKS0sRGRmJVatWoVWrVkhKSoJer0dISIhhvqmmiIP4ERFRQxBC4FJWIeJuBTLHL+XgTGY+7r7yOthao5ufM7r7O8PGSo6Nhy4iLa8YAGBrI8eT3X3xYp9ABLi1aISjqL2smyVwVSnNnm5Nr98mj1Ds7u6O2NhYBAcHm5JMg2JwQ0REdSWEQG5hKW7cLMH1myW4cVOL6/kluHGzBDfK728tyyooQamu4mU2wNUe3fylYCbM3wXBHirI5bdH9S/V6bEjMR2rD1zAqTQNAEAmAwaHeOHlfoHo7t+0BsvVlulx7GI29p7OxL4z13E5uxAn5kWavVqtwYKbN954AzY2NvjXv/5lSjINisENERHVRnGpDtsT0rDh8EWcTs9Hmb7ml06FlRydWqnR/VYw083PGe4ONSvVEELg0IUsrDlwAXuTrxuWd/Nzwv/1C8KgEC9YyRtnqqO03CLsS76OvcmZiD13AwV3VK1ZyWXYMjEc3f2dzbrPBgtuXnvtNWzYsAFt2rRBWFgYWrQwLjL7+OOPTUm+XjC4ISKimrieX4KNhy9h0+FLyCrQGq1T29nATaWAm0oJNwcl3FVKw3N3B6XRcoW16RMCnL2Wj68PpmBb/FVodXoAgL+rPcaHB8DHyRZlegGdXqBMJ93rhJCW6fQo0wvobz3X6wUcbG3g0kIB11v5dWmhgLO9otpAqVSnR9ylHOxNzsS+09eRfC3faL27gxID2rpjYHsPPNjGDWo7mypSqrsGC24GDhxYdeIyGfbs2WNK8vWCwQ0REVUnKU2Db2JS8MuJNEMg4aO2xfiIAPyjszfcHZRQWjdOT6bM/GJsPHQJGw9fQm5hqdnSlckAF3uFIehxVSnheivoOXMtHzFnbyC/pMywvVwGdPVzxsB27hjQzgMh3o5GVWv1ocGCm+aIwQ0REd1NrxfYczoT38Sk4NCFLMPyrn5OeLFPIIZ09IK1lVmmZDSLQm0Zfoq7gt8S06HTC1jJZbducljLZZDLZLCWy2BldeteJq2Xy2TQFJciq0CLrJslyCrQ1jhIcmmhwIC27hjQ3gP9gt3gZN+wvbiaRHCTkJCABx54oL6SrzMGN0REVK6gpAw/xl3Buj9TcDGrEIDUZuTRUC+80CcQ3fzM226kKSrV6ZFTqEXWTS2yC7S4cbPE8DiroASejrYY0M4DnVuq6710pjo1vX6bPM7N3fLy8rBp0yZ8/fXXOHHiBHQ63b1fRERE1IAyNcWIv5yLwxey8FPcFWiKpeoWR1trPN3LD+PCA9DSya6Rc9lwbKzk8HCwhYeDbWNnxSzMFtzs2bMHa9euxdatW+Hv748nnngC33zzjbmSJyIiqpPiUh3+upqHhMu5iE/NRcLlXFzNLTLaJtCtBZ5/MABPdGuFFkqz/++nBmbSGbxy5QqioqKwdu1aFBQUYPTo0SgtLcVPP/2EkJAQc+WRiIioRoQQSLlRYBTI/J2uqdB1WyYD2no44AFfJ0R29MTAdh6NWt1C5lXn4Oaxxx5DTEwMhg4dihUrVmDIkCGwsrLCV199Zc78ERHRfUyvF9AUlyK7QIucQi1yCkqRXahFToHWcJ9TWGp4fl1TYtSjp5ybSomufk54wNcJXf2c0LmVE1QsobFYdT6zv//+O6ZOnYpXXnmlWY1OTERETVPWzRL8nZ6PpPQ8JKVpkJSuwfnrBdDVYsA8AFBayxHaUm0IZB7wdUJLJzvIZCyZuV/UObg5ePAg1q5di7CwMLRv3x5jx47FmDFjzJk3IiKyQHq9QGp2IZLSNYYgJilNgwxNcZWvUSmt4dzCBi72CjjfGnvF2V4BlxY2cG6hgIu9Ak720vgsAa4tzDJoHjVfJncFLywsxObNm7F27VocPXoUOp0OH3/8MV544QU4ODiYK59mxa7gRESm0+kFsm6W4GZJGQpKdLfuy1CgLUN+8a3HJWW4WaKT7rVluJZXjL/TNUZD9d8pwNUeIT6O6OijRoi3I9p6OcBNpWi0AfOoaWmUcW6Sk5PxzTffYOPGjcjNzcWgQYOwfft2cyVvNgxuiIjq7kpOIb47korvj12uMCVBTSms5Wjv5YAQb0eE+DgixNsR7b0d2Q6GqtWog/jpdDr88ssvWLt2LYMbIiILoNcLHDx3AxsPXcKe09dQ3gxGJgNUCmu0UFqjhdIKKqU1VLbWaKGwhkpZvtwaKqUVWiit4dJCgQ7ejghya9GkRvul5qFJjFDcVDG4ISKqmdxCLX6Mu4JvD18yjN4LAA+2ccXY3v54pIMngxRqMDW9fje5T+SBAwcwbNgw+Pj4QCaT4eeffzZaP2HCBMhkMqNb7969GyezREQWKvFKHmb9eAK9lu7G4t/+xsWsQjgorTEhIgB/zOiPTS/1xpBQbwY21CQ1ucrNgoICdOnSBc8//zyeeOKJSrcZMmQI1q1bZ3iuUDTsxF1ERE2ZEAKn0jSITroGnV7AXmkFexsr2CuspceKW48Vxo+treTY+VcGNh6+hBOXcw3ptfdywLjwADze1Qf2iiZ32SCqoMl9Sh999FE8+uij1W6jVCrh5eXVQDkiImoeMvKK8XPCVWw9fgVnrt00KS0bKxke6+SNceH+6ObnzDFiqFlpcsFNTezbtw8eHh5wcnJC//79sWTJEnh4eFS5fUlJCUpKSgzPNRpNQ2STiKjeFWrLsOtUBrYev4qYczdQ3opSYS3HIx084K5SolCrQ2GpDoUlZdJjrQ6FWuPHpTrphT5qWzzb2x9jevjCTaVsxCMjqjuzBDcHDx7EqlWrcP78efz4449o2bIlNm7ciMDAQPTp08ccuzB49NFH8eSTT8Lf3x8pKSl499138dBDDyEuLg5KZeVfxGXLlmHBggVmzQcRUWPR64U0m/Xxq/jvX+kovGPMmJ4BLhjVrSUe7eQNtZ1NjdMs1elRVKqDSmHNOZao2TM5uPnpp58wduxYPPvss4iPjzeUkOTn52Pp0qXYsWOHyZm8052jIIeGhiIsLAz+/v747bffMGrUqEpfM3v2bMyYMcPwXKPRwNfX16z5IiKqb+cy87H1+FX8HH8VaXm3R/P1d7XHqK6tMLJrS/i52tcpbRsrOWzYOJgshMnBzeLFi/HVV19h3Lhx2Lx5s2F5REQEFi5caGry9+Tt7Q1/f3+cPXu2ym2USmWVpTpERE1ZcakO//0rHZsOp+J/l3IMyx1trTG0iw+e6NaSbWKI7mJycJOcnIx+/fpVWO7o6Ijc3FxTk7+nrKwsXL58Gd7e3vW+LyKihnLxRgG+O5qKH/53GTmFpQAAK7kMA9u5Y1S3VniovQdsbTglAVFlTA5uvL29ce7cOQQEBBgtj4mJQVBQUK3Tu3nzJs6dO2d4npKSgoSEBLi4uMDFxQXz58/HE088AW9vb1y8eBH//Oc/4ebmhpEjR5p6KEREjapUp8fuv69h05FUHDx7w7DcR22Lp3v6YUwPX3g42jZiDomaB5ODm4kTJ2LatGlYu3YtZDIZ0tLScOjQIcycORNz586tdXr/+9//MHDgQMPz8rYy48ePx5dffonExERs2LABubm58Pb2xsCBA/H999832Uk6iYjuJT2vCP8+ehnfH0vFNY3UblEmAwa0dcezvfwxsL0HrNjIl6jGzDL9wpw5c7B8+XIUF0sN3JRKJWbOnIlFixaZnMH6wOkXiKix6fUCB85ex6Yjqdj99+25mtxUCowO88XTPf3g61K3xsFElqrB55YqLCxEUlIS9Ho9QkJCoFKpzJFsvWBwQ0SNQa8XiEvNwW8n0/Hfv9INpTQA0CvQBc/29seQjl5QWLPXElFlanr9NrlaatmyZfD09MQLL7yAsLAww/K1a9fi+vXreOutt0zdBRFRs1VdQONga40nurXCs738EOzJqnUiczE5uFm1ahW+++67Css7duyIp556isENEd13qg1olNYYFOKJf3T2Rp9gNyit2eOJyNxMDm4yMjIq7Ybt7u6O9PR0U5MnImpwsedu4PO953A9vwRO9jZQ29nA0c4GTnYKqO1soLazhpO94vbyW9uk3CioOqDp6Il/dGJAQ9QQTA5ufH198eeffyIwMNBo+Z9//gkfHx9TkyciajB/Xc3DeztPG3XDrisGNESNx+Tg5qWXXsL06dNRWlqKhx56CACwe/duzJo1C2+88YbJGSQiqm8XbxTgw9+T8etJqbTZxkqGZ3r6YVCIF/KLS5FbVIq8W7fcwlJoyh8XaaXlhaXQFJcxoCFqIkwObmbNmoXs7GxMnjwZWq0WAGBra4u33noLs2fPNjmDRET1JTO/GJ/tPovNRy+j7FZf7BEP+OCNQe1qPUeTTi8gAzjpJFETYLau4Ddv3sTff/8NOzs7BAcHN+m5nNgVnOj+pikuxer9F/BNTAqKSqUZtfu3dcesIe3Q0UfdyLkjoqo0WFfwciqVCj169DBXckREZldcqsO3hy/hi73nDPM1PeDrhLeGtEd4a9dGzh0RmYvZghsiooaUW6hFgVaHMp0epTo9SnXCcF9W/lyvR9mt5ZmaYqw5mIKruUUAgNbuLfDm4PYY3NGTM2oTWZg6BzejRo2q0XZbt26t6y6IiIwIIXDw7A2sPnABMefq1qPJy9EWrw8KxhPdWsHaiiMBE1miOgc3ajXrpYmoYWjL9Pj1ZBpWH7iA0xn5huUKazls5DLYWMthLZfDxkoGGys5rK1ksJHLYWMtg7VcDoWVHAprOfq1dcO48ADY2rAXE5Elq3Nws27dOnPmg4iogvziUvz7aCrWxlxEhkaamNdeYYWnevjh+QcDOLEkEVWKbW6IqMlJzyvCuj8v4t9HUpFfUgYAcHdQYkJEAJ7r5Q+1vU0j55CImjIGN0TUZPydrsGaAxew/USaYdyZNh4q/F/fIIzo6sNB8YioRhjcEFGj0pbpsS85E98eScWBM9cNy3sHueD/+gVhQFsPDoxHRLXC4IaIqnSzpAzfH7uMbw9fgrZMj4c7eCAyxAu9glxgY0JPI71e4H+XcrAt/ip2JKYjr0gac0YuAx7r5I3/6xeEzq2czHQURHS/MdsIxUlJSUhNTTVMwVBu+PDh5kjerDhCMVH1rmmKERV7EZsOX4KmuKzCekdbazzU3gORHb3Qv607Wihr9j/pzLV8/Bx/Ff9JSDOMNwMAno5KjHigJcb29mcjYSKqUoONUHzhwgWMHDkSiYmJkMlkKI+VygfF0ul0pu6CiBrImWv5WHPgAn5OuIpSnfRdDnJrgZf6BsHTUYnopGuITrqGrAItfk5Iw88JaVBYy9GnjRsiQzzxcAdPuDsYT72SkVeM7SeuYlt8Gv5O1xiWOyitMSTUCyO7tkSvIFdYseqJiMzE5JKbYcOGwcrKCmvWrEFQUBCOHj2KrKwsvPHGG/jwww/Rt29fc+XVbFhyQ3SbEAKHLmRhzYEL2Jt8u81LjwBnvNw3CI908DRq86LTC8Sn5uD3pGvYdSoDl7IKDetkMqC7nzMiO3pCbWeD/ySk4dCFLJT/ythYyTCgnQdGdm2Jh9p7cLwZIqqVml6/TQ5u3NzcsGfPHnTu3BlqtRpHjx5Fu3btsGfPHrzxxhuIj483Jfl6weCGCCjT6bHjrwysOXABiVfzAEjByZCOXni5XxC6+TnfMw0hBM5m3sTvpzLwe9I1nLySV+l2PQNcMKKrD/7RyRtO9gqzHgcR3T8arFpKp9NBpVIBkAKdtLQ0tGvXDv7+/khOTjY1eSIyk5IyHS5nFyE1uwCnM/Lx3ZFUXMmR2r3Y2sjxZHdfvNgnEAFuLWqcpkwmQ1tPB7T1dMCrDwUjLbcIf/wtVV1pikoR2dELw7v4sB0NETUok4Ob0NBQnDx5EkFBQejVqxfef/99KBQKrF69GkFBQebIIxHVUF5RKVKzCnEpuwCXsgoNj1OzCpGuKcbd5bSuLRQYFx6AseH+cGlheomKj5MdxoUHYFx4gMlpERHVlcnBzTvvvIOCggIAwOLFizF06FD07dsXrq6u+P77703OIBFVTlumx/8uZePAmRs4kpKFlBsFyC0srfY1LRRW8HNtAX8Xe/Rr645R3Vqy3QsRWRyzdQW/U3Z2NpydnQ09ppoatrmh5kgIgZQbBThw5joOnr2BQxeyUKit2BvRTaWEv6s9/F3s4edqD39Xe/i5tIC/qz1cWyia7PeSiBqAXg9cigGK8wC5NSCzAuTlt/Ln1oBcbvzcxhZQOko3q8YbIq/B2txUxsXFpT6SJbrvaIpLEXvuBg6cvYEDZ64b2siUc1Mp0DfYHX2D3dDB2xF+LvY1HnOGiO4z5/cA0XOBjETT0rGxl4IcW0dA6XDXY/Xtx12eBuwbJx4wy6/gwYMHsWrVKpw/fx4//vgjWrZsiY0bNyIwMBB9+vQxxy6IqqXXS712jqfmIDkjH+28HPBYJ2+o7ZrXBIs3S8pw8kou/ncxBwfOXEf85Vzo9LcLVxVWcoQFOKNvsDv6tXVDBy9HTk1ARNVLPwFEzwMu7JWeKx0Bjw6AXgfoywChu/W4iuf6MqC0CCi79eeqtFC63cyofr/tHmu+wc1PP/2EsWPH4tlnn0V8fDxKSkoAAPn5+Vi6dCl27NhhciapfpTp9Ei5UYDka/lIzpBuZ67lA5Aahnqr7dDSyVZ67CQ99lbb1bpkQAiB4lI98otLkV9ShjKdgIeDEk72NnWuIskrLEX85RwcT81FfGoOElJzDbNHl5u3/RQe6eCBkV1boX9bdyis6z5dQLniUh2OX8qBprgMrZzt4OtiX+cAqkynR/K1fCRczkVCai5OXMnF2cybFRr9Brm3QL9bwUzvIFfYK1gyQ0Q1kHMR2LMYSPxBem6lAHq8DPSbWbego0wLlOQDJRrpVqy5/bxYA5TkSc+Lb61vpMAGMEObm65du+L111/HuHHj4ODggBMnTiAoKAgJCQkYMmQIMjLuEdk1gvutzY0QAml5xTiTkY/TGflIztAg+dpNnM+8Ca1OX+v01HY28Lkj2FHZWiO/uBQ3i8uQX1yG/BLp/mZJqXRfXGaY4flOSms5PB1t4eVoC0+1LTwdlPBS20rL1NJyD0clbORynLt+E8cv5eB4qhTQnMu8WSE9OxsrdPFVo72XI2LP38CZa7e3cba3wfAuPhjZrRW6tFLXOKgq1elx8koeYs/dQOz5LMSl5kBbZvyeOdhaw9fZHq2c7dDK2R6+Lsb3KqU1hBC4mluEhMu5OHE5FwmXc5F4NQ/FpRXf/5ZOdnjAzwl92rihb7AbWjmzGzUR1UJBFnDwQ+DY14Du1pRInUYDD80BnAMaNWumarBB/Ozt7ZGUlISAgACj4ObChQsICQlBcXGxKcnXC0sPboQQOH/9JqKTMrEvORNJ6RrkVzI/EADYK6zQ1tMB7b0c0M7LAe08HWAllyEtrwhpucVIyy1CWm4R0vOKcTW3qMp0akIuA1RKa1jJZci5R6+eOymt5SgpqxgEBLjao5ufM7r6OaGrnzPaeznA+tZkjkIInErTYNuteYxu3CwxvC7IrQVGdm2Jx7u2rDD+il4vcDojH7HnpWDmaEo2bt5VIuTpqISX2g5Xcwpx46bxXGqVcbK3gbVcVum2DkprdPF1wgO+Tuji64Quvmp4ONjW6H0xyDoPXD4KtOwGuLer3WuJyHJoC4EjXwIxn0glJwAQNBAYtADw7tKoWTOXBmtQ7O3tjXPnziEgIMBoeUxMDMe5aUBlOj3iLuXgj7+v4Y+/M5Fyo8BovbVchtbuKrT1uhXIeErBTEsnu1q12cgvLjUEOuWBT6FWBwdbGzgoreFgaw0HWxuobG89VkrPHWytYa+wMpSYlJTpkKkpwTVNMTI0xcjIK771uATX8m4t0xRDW6ZHSZkedjZW6NxKjW7+zoaAxk2lrDKfMpkMoS3VCG2pxuxH2yPm3A1si7+KXacycOFGAT6KPoOPos+gR4AzRnZtBQGB2HNZOHQhC9kFxkGIk70NwoNcEdHGDRGtXRHk1sJwHEVaHa7kFOJKThEul99nS/dXcgqRU1hq6J5tLZehg7cjuviq8YCvMx7wdUKQW4vat5nR64Ar/wOSfwOS/wvcOHN7nV8E0H08EDICsLGrXbpE1DzpyoAT3wF7lwH5adIyr07AoIVA64caN2+NxOSSm/fffx/r16/H2rVrMWjQIOzYsQOXLl3C66+/jrlz5+LVV181V17NxlJKbm6WlOHgmeuITrqGPcmZRmOcKKzkCG/tikc6eKBnoCsC3VqYpc1JQxJCILewFLlFpfB1tjOUypjiZkkZdv6VgW3xVxB7PqtC+xZAKs3qGeiCB1u7Iby1K0K8695oN7+4FFdzi1Bcqkd7L4e6jymjLZQaAybvAJJ3AoU3bq+TWwOeHaUeEOJWCZetGuj8FNB9AuAZUrd9ElHTJQRw/TRw9ncg4TvpMQA4+QEPvQuE/j+pO7eFabBqKQCYM2cOli9fbqiCUiqVmDlzJhYtWmRq0vWiuQY3pTo9rmmKsS9ZCmgOnc8yajPjZG+Dh9p54JEQT/Rr6w4VuwRXKz2vCP9JSMN//8qArbUcEa3d8GAbV3Ru5dQ0AsH8a8CZnVLpzIW9QNkdVbxKNRA8CGj/GNDmESmY0aQB8ZuA4xuAvNTb27bqKZXmdBwJKGo+tQLVQnEecHqH1HvEORBwbQ24BPH9JvPSFgIpB6SA5my08ffczhno9ybQ4yXAuupS7eauQYMbACgsLERSUhL0ej1CQkIM8001RU0luDmdocG+5OvILy5FQYkON0vKUKgtw80SHQpKylBQUnZrmbTu7oasAODvao9BHTwxKMQT3f2dzVK60WyV3AQuHwGuHAO0BQAEDEUzQtzx/O57AD5dgU7/r/F+FHRlUvVSRiKQcRJIPQxcjZPyWM7JT+pa2e4xwD8CsKqil5ZeB5zfCxyPkgIj/a02Q0pHoNOTUmmOd+cqXquXejwU5dxxy5XuhR6wtpWqu+51X/64KQwYqEkH0o4D104Bal+g9UDAwcv0dEuLpYtM4g/AmV2ArqTiNg7egGsbKdBxbQ24tJbunQOlQdHupNcDxblAYTZQlA0UZt3x+NZzbYGUd7Wv9HlwunVvqzb9eKhpyk6RApmzu4CUg8afM2tbIKAvEBwJdB4N2Dk1WjYbSoMHN81JYwY3Qgj8eS4Lqw6cx8GzN+79grvIZEBXXyc8EuKJyBBPtHZXVd7zR68H0hOAC/ukMQtsnaQfQMPtjuc2dk3jIlRb2gIpmLkYI33p047fvpDXhYM30HsyEPa8NABVfSm5CWQmSWNPlAcz15Iqvzj6dJOCmfaPAR4htT9P+deAhE3A8fVSt1BDul2lC61REJMjlUDATD8J1ra3SzEMF/Y20mOVZ/185opygLR44OrxW/dxQH56xe08OkpBTuuBUjslRQ17pOl1wMWDUkCT9IsUCJZzaycFjTkXgaxzUl6qJJMCFJXH7YCmOPd2tWJtKdXGwY4h+PEDPEMbdURZqqWiHOm34Wy0FDRnnTVer/YD2kZKAU1A35p/di1EvQc3R44cQXZ2Nh599FHDsg0bNmDevHkoKCjA448/jhUrVkCpbHrFY40R3JTq9Pj1ZBpWH0jB3+lSK3a5DHiovQdaOdujhdIKLZTWUCmt0UJhbXhevsxeYSWtU1rDpqrSmZKbUvXFmZ3Amd+BgsyaZU5uczvQsXOSfhi9uwA+DwBeXYAWrmZ5D0ymLbwdzFw8KF247g5m1L6A/4NAC7dbF89bF9Dyx5XdlxUDiT/evgjaqqWxIHpNAlTupuW5vPFvaiyQflIKZrLOodIAQqGSGgF6dZYukq0fBhy9Tdu/IR964OIBIC4K+PtXQH+P3mo2LaRibjtn6TNh5yS17SktlgbyqvS+WBrYqyYBpkJVsTTDyU8KiOTWUqmU3Ea6KMutbz22MV6nLwUy/pI+B2nHpYAm+3zFfcnkgHsHwCtUKh1LS4DR+2+lBPx6Sw0vWw8EPDsZt1UQQgqUEn8E/vrJeOAyx5ZA6BNSiZhXJ+OArTAbyL4g9WbLPi+d96zz0rLyniyVvjcO0vgg9i6A3a17e1fpscIeyM8AclOlW95lqUSnOmo/IHwy0PW5+g3aG1PuZeBcNHD2D+lc+fUGer8CtOrR9P646XVA3hUpCM5Jke6zU24/L84z3l5uDfiFS8FMcKTUI7KpHVMDqvfg5tFHH8WAAQPw1ltvAQASExPRrVs3TJgwAR06dMAHH3yAiRMnYv78+XU6gPrUkMFNfnEpNh+9jLV/piA9T2ozYWdjhTE9fPFin8AKXZFrLeeiFN2f2Sld9HV39PRROACtB0gXqOI8qXqhOO/W7dbjmvxTLA927ryZo1i/OmUl0sXgerJUnXAx5lYwc9dF2bEVENhX+gcT0Adw9q/7/k5uAf789PY/JWtboOtYIOLV2o0NUXADOPeHVGVxbrf0Xt9N5SVdDL073w5onAMbpgFgwQ0g6WfpmA0BjLNUmlcezJhSPacrkwKeghu3LurnjS/wual1L6GoCecAoGV3qdSrZTfp83pn25eCLCBlvzQU/fm9gOaK8evt3YCgAdIt74pUSnNn0GTrBHR8XBo3xC+89udMiNvvTcH1W+95eQDjDFjXcnb2kptSPnNTpTYYuanSxT7vMnD9zO3SJaVaKpXsNRFw9KndPpqaMi1w+fCt6ppo4PrflW/n000qjQ0ZUfv31RxyLkml5+knbgcvuan3/gPg2Er6/LWNlO5Z7WhQ78GNt7c3fvnlF4SFhQGQGhXv378fMTExAIAffvgB8+bNQ1JSUl2Sr1cNEdyk5RYhKvYi/n0k1TByrptKiecfDMCzPVrCSaGX/u3qS++YuMz6rlslP5q6MuDK0VulM7tut5Av5xwItHsUaDtYKm6v7gstBKC9eVfgkwvcOCt9GdNPVP5PGABaeNwOdNzbST/Odk53XCjV0jHdS9Gt/d1IlgKZG2ekW87Fyi+Aji2lQCbwVjDj5G/efzF6vdTF+uDHUmkAIJ2f0FHAg9Olf/+VvSY9/tYP7e9SCcKdJQO2TkBgP6kqyLuzFMioPMyX5+amTAvkXrqjJONW0KNJk4JzXZn0vdCV3hr+/dZjUXGSULTwkAKZlrcCGZ9utRsVVQhp3+WBzsWD0nfibtZ2UtVgpyelErXGuFDWRWkRcPJ7IPbz20G73EY6johXpV52zYUm7fZ37MJ+QJt/e51MLpXSBA8CvLsCp7YBiVtu/9lTeUkNbcOel0p160tBllRCemGfdLuzKvhOVgrpt8s5AHAJlO6dA6XHTv73XVVTbdR7cGNra4uzZ8/C19cXANCnTx8MGTIE77zzDgDg4sWL6NSpE/Lz86tLplHUW3Cz/TXkX7+MjKxc3Lx5EwpoYQstWljp4GRTBqWsFLLygKYmZPK7gh0r6cJQescYNjIrqXFp28FA2yFSmwZzXuyL86Si//JgJ/2EFIjU5J+3Un27SuPO0gGZ7FZAcwa4ea3617u3lYIn3963SmYCGqZIVgjpQhezXLrwlQuOlIIcjw7S8rPRUinNnV2zASmACR4kbd8yjG0ezEGvvzXPza1gB+L258lcyrTA1f9J5zbloBSkhz4hBTbNuUpHr5capMauAC79eXt564eAiNekgd7q63slhNTGrPwP2Y0zUrBoYydNwGhjJ13Myx/fudymhRTEnN8LXPvLOF17N6mnYPAg6TjuDmpvXgfi1kmj9Jb/zlgpgc5PAr1eqfyPSm1pC6Uq5wv7pIAr46TxepmVFHT59b7dkNw5QCo5q8mfP6qg3oMbf39/bNy4Ef369YNWq4WTkxN++eUXPPzwwwCkaqr+/fsjOzu7bkdQj+ojuNEUl6L4g1B46Go73YQMtW7AaecsXTTbDpa+1HbOtdynibSFUlVReoJ0y7kklfgU3eplo61lQOvgIwUxbrdu7u2k+/pqdFpb6SekET+Tfr4jqLvrvCkcpPYawZHSD6652soQmduVOODQCiDpP7c/z56hUpDTcZR5SqVKi6Wq5PKA5s4uy3Umk0rpgiOB4EekEpqaVAmWaaWSnCNfSu1xygX0ldrltB1SdaChK701d1K+VKJXPm9S+gkpoLly1LgpACA1Vg/qL1Un+Uc076C4Car34GbixIlITEzEe++9h59//hnr169HWloaFArpi7Fp0yZ88sknOHbsWN2OoB7VR3AjhMAHHy3Bjdx8dPB1x8BQPwR4ukj/UKxtpTYMNnbSvXX5va30j14I49lX9WWVPL+1DJAaYjblkgBd6a2qrju6ERfl3AqAcqT1rm1uBTPBgG0zGWso67z0zzfhO6lnk0fI7dIZ315Vd80maopyLgKHv5LGRSovDXbwlqq1HVveuvkA6lbS/b1GvM6/JlUZndkplbTcWcJsbQsE9gfaDZHGXSqfZbq04NZ90a2Zpm/da+94DEhBQuuHTKtSEkKapuTwSuDvX25XczoHAO7tbwcxdwYyd44tVRW1761gZqBU/Xw/Vzk3gHoPbq5fv45Ro0bhzz//hEqlwvr16zFy5EjD+ocffhi9e/fGkiVL6pJ8vaqvaqnEK3lwsrcxvZEwNW1FudKPXn03qiZqCEU5wP/WAUdWGfcEu5udixTwqG8FPeUBUN5lKaC5Gme8vYP3reryR6WLflNqR5J7WaquiouqvMH/3axtpRIYpcOtnn6BUrAWNED6s9kUSpjvEw02zk1eXh5UKhWsrIyL9bKzs6FSqQwlOU1JUxnEj4ioySgrAU7/CmSelhrvaq5I93lXjUthquPTTarmaTtY6mzQ1C/62gJpoEttwa3gxRFQqowDGaUDS2WbEA7iVw0GN0RENSSEVM2suXor2LkV9JQHQEqH22OwsDST6lmDzQpOREQWTCa73euxOXUdp/vafTwREREREVkiBjdERERkURjcEBERkUUxS5ub3bt3Y/fu3cjMzIRebzxy7dq1a82xCyIiIqIaMTm4WbBgARYuXIiwsDB4e3tD1tS7/hEREZFFMzm4+eqrrxAVFYWxY8eaIz9EREREJjG5zY1Wq0VERIQ58kJERERkMpODm5deegnfffedOfJCREREZDKTq6WKi4uxevVq/PHHH+jcuTNsbIyHqf74449N3QURERFRjZkc3Jw8eRIPPPAAAOCvv/4yWsfGxURERNTQTA5u9u7da458EBEREZkFB/EjIiIii2K2iTOTkpKQmpoKrVZrtHz48OHm2gURERHRPZkc3Fy4cAEjR45EYmIiZDIZhBAAbre30el0pu6CiIiIqMZMrpaaNm0aAgMDce3aNdjb2+PUqVM4cOAAwsLCsG/fPjNkkYiIiKjmTC65OXToEPbs2QN3d3fI5XLI5XL06dMHy5Ytw9SpUxEfH2+OfBIRERHViMklNzqdDiqVCgDg5uaGtLQ0AIC/vz+Sk5NNTZ6IiIioVkwuuQkNDcXJkycRFBSEXr164f3334dCocDq1asRFBRkjjwSERER1ZjJJTfvvPMO9Ho9AGDRokW4dOkS+vbtix07duCzzz6rdXoHDhzAsGHD4OPjA5lMhp9//tlovRAC8+fPh4+PD+zs7DBgwACcOnXK1MMgIiIiC2FycDN48GCMGjUKANC6dWskJSXhxo0byMzMxEMPPVTr9AoKCtClSxd8/vnnla5///338fHHH+Pzzz/HsWPH4OXlhUGDBiE/P9+k4yAiIiLLYJZB/A4ePIjnnnsO4eHhuHr1KlxcXPDtt98iJiam1mk9+uijWLx4sSFgupMQAp988gnmzJmDUaNGITQ0FOvXr0dhYSEn7yQiIiIAZghufvrpJwwePBh2dnaIj49HSUkJACA/Px9Lly41OYN3SklJQUZGBiIjIw3LlEol+vfvj9jY2CpfV1JSAo1GY3QjIiIiy2RycLN48WJ89dVXWLNmjdGM4BERETh+/LipyRvJyMgAAHh6ehot9/T0NKyrzLJly6BWqw03X19fs+aLiIiImg6Tg5vk5GT069evwnJHR0fk5uaamnyl7p5tXAhR7Qzks2fPRl5enuF2+fLleskXERERNT6Tgxtvb2+cO3euwvKYmBizdwX38vICgAqlNJmZmRVKc+6kVCrh6OhodCMiIiLLZHJwM3HiREybNg1HjhyBTCZDWloaNm3ahJkzZ2Ly5MnmyKNBYGAgvLy8EB0dbVim1Wqxf/9+REREmHVfRERE1DyZPIjfrFmzkJeXh4EDB6K4uBj9+vWDUqnEzJkz8eqrr9Y6vZs3bxqVBKWkpCAhIQEuLi7w8/PD9OnTsXTpUgQHByM4OBhLly6Fvb09nnnmGVMPhYiIiCyATJRP422iwsJCJCUlQa/XIyQkxDAlQ23t27cPAwcOrLB8/PjxiIqKghACCxYswKpVq5CTk4NevXrhiy++QGhoaI33odFooFarkZeXxyoqIiKiZqKm12+zBTfNCYMbIiKi5qem1+86V0u98MILNdpu7dq1dd0FERERUa3VObiJioqCv78/unbtivuw8IeIiIiaqDoHN5MmTcLmzZtx4cIFvPDCC3juuefg4uJizrwRERER1Vqdu4KvXLkS6enpeOutt/DLL7/A19cXo0ePxq5du1iSQ0RERI3GbA2KL126hKioKGzYsAGlpaVISkqqc4+p+sYGxURERM1PTa/fZpkVHJCmRJDJZBBCQK/XmytZIiIioloxKbgpKSnBv//9bwwaNAjt2rVDYmIiPv/8c6SmpjbZUhsiIiKybHVuUDx58mRs3rwZfn5+eP7557F582a4urqaM29EREREtVbnNjdyuRx+fn7o2rVrtTNyb926tc6Zqy9sc0NERNT81PsgfuPGjas2qCEiIiJqDCYN4kdERETU1JittxQRERFRU8DghoiIiCwKgxsiIiKyKAxuiIiIyKIwuCEiIiKLUqfeUjNmzKjxth9//HFddkFERERUJ3UKbuLj42u0HcfBISIiooZWp+Bm79695s4HERERkVmwzQ0RERFZlDqPUHy3pKQkpKamQqvVGi0fPny4uXZBREREdE8mBzcXLlzAyJEjkZiYCJlMhvJ5OMvb2+h0OlN3QURERFRjJldLTZs2DYGBgbh27Rrs7e1x6tQpHDhwAGFhYdi3b58ZskhERERUcyaX3Bw6dAh79uyBu7s75HI55HI5+vTpg2XLlmHq1Kk17llFREREZA4ml9zodDqoVCoAgJubG9LS0gAA/v7+SE5ONjV5IiIioloxueQmNDQUJ0+eRFBQEHr16oX3338fCoUCq1evRlBQkDnySERERFRjJgc377zzDgoKCgAAixcvxtChQ9G3b1+4urri+++/NzmDRERERLUhE+Xdm8woOzsbzs7OTXaEYo1GA7Vajby8PDg6OjZ2doiIiKgGanr9Nts4N3dycXGpj2SJiIiI7snk4GbhwoXVrp87d66puyAiIiKqMZODm23bthk9Ly0tRUpKCqytrdG6dWsGN0RERNSgTA5uKhvHRqPRYMKECRg5cqSpyRMRERHVSr1MnOno6IiFCxfi3XffrY/kiYiIiKpUb7OC5+bmIi8vr76SJyIiIqqUydVSn332mdFzIQTS09OxceNGDBkyxNTkiYiIiGrF5OBm+fLlRs/lcjnc3d0xfvx4zJ4929TkiYiIiGrF5OAmJSXFHPkgIiIiMguzDOK3e/du7N69G5mZmdDr9Ubr1q5da45dEBEREdWIycHNggULsHDhQoSFhcHb27vJTrlARERE9weTg5uvvvoKUVFRGDt2rDnyQ0RERGQSk7uCa7VaREREmCMvRERERCYzObh56aWX8N1335kjL0REREQmM7laqri4GKtXr8Yff/yBzp07w8bGxmj9xx9/bOouiIiIiGrM5ODm5MmTeOCBBwAAf/31l9E6Ni4mIiKihmZycLN3715z5IOIiIjILOptbikiIiKixsBB/IiIiMiicBA/IiIisigcxI+IiIgsCgfxIyIiIovCQfyIiIjIonAQPyIiIrIoHMSPiIiILAoH8SMiIiKLUq+D+CUkJNRn8kREREQVmD24ycvLw8qVK9GtWzd0797d3MkTERERVctswc2ePXvw3HPPwdvbGytWrMBjjz2G//3vf+ZKnoiIiKhGTGpzc+XKFURFRWHt2rUoKCjA6NGjUVpaip9++gkhISHmyiMRERFRjdW55Oaxxx5DSEgIkpKSsGLFCqSlpWHFihXmzBsRERFRrdW55Ob333/H1KlT8corryA4ONiceSIiIiKqszqX3Bw8eBD5+fkICwtDr1698Pnnn+P69evmzBsRERFRrdU5uAkPD8eaNWuQnp6OiRMnYvPmzWjZsiX0ej2io6ORn59vznwSERER1YhMCCHMlVhycjK++eYbbNy4Ebm5uRg0aBC2b99uruTNRqPRQK1WIy8vD46Ojo2dHSIiIqqBml6/zTrOTbt27fD+++/jypUr+Pe//23OpA3mz58PmUxmdPPy8qqXfREREVHzY/L0C5WxsrLC448/jscff7w+kkfHjh3xxx9/GO2PiIiICKin4Ka+WVtbs7SGiIiIKlWvc0vVl7Nnz8LHxweBgYF46qmncOHChWq3LykpgUajMboRERGRZWp2wU2vXr2wYcMG7Nq1C2vWrEFGRgYiIiKQlZVV5WuWLVsGtVptuPn6+jZgjomIiKghmbW3VGMoKChA69atMWvWLMyYMaPSbUpKSlBSUmJ4rtFo4Ovry95SREREzUhNe0vVuc1NTat26jt4aNGiBTp16oSzZ89WuY1SqYRSqazXfBAREVHTUOfgxsnJCTKZrMr1QgjIZDLodLq67qJGSkpK8Pfff6Nv3771uh8iIiJqHuoc3Ozdu9fwWAiBxx57DF9//TVatmxploxVZebMmRg2bBj8/PyQmZmJxYsXQ6PRYPz48fW6XyIiImoe6hzc9O/f3+i5lZUVevfujaCgIJMzVZ0rV67g6aefxo0bN+Du7o7evXvj8OHD8Pf3r9f9EhERUfPQ7Ma52bx5c2NngYiIiJqwZtcVnIiIiKg6Zg1uqmtgTERERNQQ6lwtNWrUKKPnxcXFmDRpElq0aGG0fOvWrXXdBREREVGt1Tm4cXR0NCqpee6558ySISIiIiJT1Dm4iYqKMmM2iIiIiMyjzsGNXC6/ZxsbmUyGsrKyuu6CiIiIqNbqHNxs3bq1yuAmNjYWK1asQDOftoqIiIiaoToHN48//niFZadPn8bs2bPxyy+/4Nlnn8WiRYtMyRsRERFRrZmlK3haWhpefvlldO7cGWVlZUhISMD69evh5+dnjuSJiIiIasyk4CYvLw9vvfUW2rRpg1OnTmH37t345ZdfEBoaaq78EREREdVKnaul3n//fbz33nvw8vLCv//9b4wYMcKc+SIiIiKqE5moY6tfuVwOOzs7PPLII7Cysqpyu6Y4iJ9Go4FarUZeXh4cHR0bOztERERUAzW9fte55GbcuHGcboGIiIiaHA7iR0RERBaFs4ITERGRRWFwQ0RERBaFwQ0RERFZFAY3REREZFEY3BAREZFFYXBDREREFoXBDREREVkUBjdERERkURjcEBERkUVhcENEREQWhcENERERWRQGN0RERGRRGNwQERGRRWFwQ0RERBaFwQ0RERFZFAY3REREZFEY3BAREZFFYXBDREREFoXBDREREVkUBjdERERkURjcEBERkUVhcENEREQWhcENERERWRQGN0RERGRRGNwQERGRRWFwQ0RERBaFwQ0RERFZFAY3REREZFEY3BAREZFFYXBDREREFoXBDREREVkUBjdERERkURjcEBERkUVhcENEREQWhcENERERWRQGN0RERGRRGNwQERGRRWFwQ0RERBaFwQ0RERFZFAY3REREZFEY3BAREZFFYXBDREREFoXBDREREVkUBjdERERkURjcEBERkUVhcENEREQWhcENERERWRQGN0RERGRRGNwQERGRRWm2wc3KlSsRGBgIW1tbdO/eHQcPHmzsLBEREVET0CyDm++//x7Tp0/HnDlzEB8fj759++LRRx9FampqY2eNiIiIGplMCCEaOxO11atXL3Tr1g1ffvmlYVmHDh3w+OOPY9myZfd8vUajgVqtRl5eHhwdHeszq0RERGQmNb1+WzdgnsxCq9UiLi4Ob7/9ttHyyMhIxMbGVvqakpISlJSUGJ7n5eUBkN4kIiIiah7Kr9v3KpdpdsHNjRs3oNPp4OnpabTc09MTGRkZlb5m2bJlWLBgQYXlvr6+9ZJHIiIiqj/5+flQq9VVrm92wU05mUxm9FwIUWFZudmzZ2PGjBmG53q9HtnZ2XB1da3yNYAUIfr6+uLy5cusvrJgPM/3B57n+wPPs2UTQiA/Px8+Pj7Vbtfsghs3NzdYWVlVKKXJzMysUJpTTqlUQqlUGi1zcnKq8T4dHR35JbkP8DzfH3ie7w88z5aruhKbcs2ut5RCoUD37t0RHR1ttDw6OhoRERGNlCsiIiJqKppdyQ0AzJgxA2PHjkVYWBjCw8OxevVqpKamYtKkSY2dNSIiImpkzTK4GTNmDLKysrBw4UKkp6cjNDQUO3bsgL+/v1n3o1QqMW/evApVWmRZeJ7vDzzP9weeZwKa6Tg3RERERFVpdm1uiIiIiKrD4IaIiIgsCoMbIiIisigMboiIiMii3BfBzcqVKxEYGAhbW1t0794dBw8eNKwTQmD+/Pnw8fGBnZ0dBgwYgFOnThm9vqSkBK+99hrc3NzQokULDB8+HFeuXDHaJicnB2PHjoVarYZarcbYsWORm5vbEIdHt5h6nlevXo0BAwbA0dERMpms0vPH89z4TDnP2dnZeO2119CuXTvY29vDz88PU6dONcw3V47nufGZ+n2eOHEiWrduDTs7O7i7u2PEiBE4ffq00TY8zxZMWLjNmzcLGxsbsWbNGpGUlCSmTZsmWrRoIS5duiSEEOJf//qXcHBwED/99JNITEwUY8aMEd7e3kKj0RjSmDRpkmjZsqWIjo4Wx48fFwMHDhRdunQRZWVlhm2GDBkiQkNDRWxsrIiNjRWhoaFi6NChDX689ytznOfly5eLZcuWiWXLlgkAIicnp8J+eJ4bl6nnOTExUYwaNUps375dnDt3TuzevVsEBweLJ554wmg/PM+Nyxzf51WrVon9+/eLlJQUERcXJ4YNGyZ8fX35u32fsPjgpmfPnmLSpElGy9q3by/efvttodfrhZeXl/jXv/5lWFdcXCzUarX46quvhBBC5ObmChsbG7F582bDNlevXhVyuVzs3LlTCCFEUlKSACAOHz5s2ObQoUMCgDh9+nR9Hh7dYup5vtPevXsrDW54nhufOc9zuS1btgiFQiFKS0uFEDzPTUF9nOcTJ04IAOLcuXNCCJ5nS2fR1VJarRZxcXGIjIw0Wh4ZGYnY2FikpKQgIyPDaL1SqUT//v0RGxsLAIiLi0NpaanRNj4+PggNDTVsc+jQIajVavTq1cuwTe/evaFWqw3bUP0xx3muCZ7nxlVf5zkvLw+Ojo6wtpbGNOV5blz1cZ4LCgqwbt06BAYGwtfXFwDPs6Wz6ODmxo0b0Ol0FSbU9PT0REZGhmHyzarWA0BGRgYUCgWcnZ2r3cbDw6PC/j08PCpM8EnmZ47zXBM8z42rPs5zVlYWFi1ahIkTJxqW8Tw3LnOe55UrV0KlUkGlUmHnzp2Ijo6GQqEAwPNs6Sw6uCknk8mMngshjJbda31l7pVGTdMh86mP83yvfdQ1Hao7c51njUaDf/zjHwgJCcG8efOq3Ud16VD9MMd5fvbZZxEfH4/9+/cjODgYo0ePRnFxcZVpVJUONT8WHdy4ubnBysqqQhSemZkJT09PeHl5AUCV6wHAy8sLWq0WOTk51W5z7dq1Cvu/fv16hX8XZH7mOM81wfPcuMx5nvPz8zFkyBCoVCps27YNNjY2hnU8z43LnOdZrVYjODgY/fr1w48//ojTp09j27ZtAHieLZ1FBzcKhQLdu3dHdHS00fLo6GhEREQgMDAQXl5eRuu1Wi3279+PiIgIAED37t1hY2NjtE16ejr++usvwzbh4eHIy8vD0aNHDdscOXIEeXl5hm2o/pjjPNcEz3PjMtd51mg0iIyMhEKhwPbt22Fra2uUHs9z46rP77MQAiUlJQB4ni1eY7RibkjlXQq/+eYbkZSUJKZPny5atGghLl68KISQuhSq1WqxdetWkZiYKJ5++ulKu4K3atVK/PHHH+L48ePioYceqrQreOfOncWhQ4fEoUOHRKdOndilsAGZ4zynp6eL+Ph4sWbNGgFAHDhwQMTHx4usrCzDNjzPjcvU86zRaESvXr1Ep06dxLlz50R6errhxu9z02HqeT5//rxYunSp+N///icuXbokYmNjxYgRI4SLi4u4du2aYT88z5bL4oMbIYT44osvhL+/v1AoFKJbt25i//79hnV6vV7MmzdPeHl5CaVSKfr16ycSExONXl9UVCReffVV4eLiIuzs7MTQoUNFamqq0TZZWVni2WefFQ4ODsLBwUE8++yzlY6TQvXH1PM8b948AaDCbd26dYZteJ4bnynnubybf2W3lJQUw3Y8z43PlPN89epV8eijjwoPDw9hY2MjWrVqJZ555pkKXbx5ni2XTAghGqfMiIiIiMj8LLrNDREREd1/GNwQERGRRWFwQ0RERBaFwQ0RERFZFAY3REREZFEY3BAREZFFYXBDREREFoXBDREREVkUBjdE1CQJIfDII49g8ODBFdatXLkSarUaqampjZAzImrqGNwQUZMkk8mwbt06HDlyBKtWrTIsT0lJwVtvvYVPP/0Ufn5+Zt1naWmpWdMjosbB4IaImixfX198+umnmDlzJlJSUiCEwIsvvoiHH34YPXv2xGOPPQaVSgVPT0+MHTsWN27cMLx2586d6NOnD5ycnODq6oqhQ4fi/PnzhvUXL16ETCbDli1bMGDAANja2uLbb79tjMMkIjPj3FJE1OQ9/vjjyM3NxRNPPIFFixbh2LFjCAsLw8svv4xx48ahqKgIb731FsrKyrBnzx4AwE8//QSZTIZOnTqhoKAAc+fOxcWLF5GQkAC5XI6LFy8iMDAQAQEB+Oijj9C1a1colUr4+Pg08tESkakY3BBRk5eZmYnQ0FBkZWXhxx9/RHx8PI4cOYJdu3YZtrly5Qp8fX2RnJyMtm3bVkjj+vXr8PDwQGJiIkJDQw3BzSeffIJp06Y15OEQUT1jtRQRNXkeHh74v//7P3To0AEjR45EXFwc9u7dC5VKZbi1b98eAAxVT+fPn8czzzyDoKAgODo6IjAwEAAqNEIOCwtr2IMhonpn3dgZICKqCWtra1hbSz9Zer0ew4YNw3vvvVdhO29vbwDAsGHD4OvrizVr1sDHxwd6vR6hoaHQarVG27do0aL+M09EDYrBDRE1O926dcNPP/2EgIAAQ8Bzp6ysLPz9999YtWoV+vbtCwCIiYlp6GwSUSNhtRQRNTtTpkxBdnY2nn76aRw9ehQXLlzA77//jhdeeAE6nQ7Ozs5wdXXF6tWrce7cOezZswczZsxo7GwTUQNhcENEzY6Pjw/+/PNP6HQ6DB48GKGhoZg2bRrUajXkcjnkcjk2b96MuLg4hIaG4vXXX8cHH3zQ2NkmogbC3lJERERkUVhyQ0RERBaFwQ0RERFZFAY3REREZFEY3BAREZFFYXBDREREFoXBDREREVkUBjdERERkURjcEBERkUVhcENEREQWhcENERERWRQGN0RERGRRGNwQERGRRfn/cxGyEN4tIdQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ds_area_ann = (ds1.tarea*aice1_ann).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area_ann = (ds2.tarea*aice2_ann).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "\n", + "ds_area_ann.plot()\n", + "ds2_area_ann.plot()\n", + "\n", + "plt.ylim((0,25))\n", + "plt.xlabel(\"Year\")\n", + "plt.ylabel(\"NH Annual Mean Sea Ice Area $m x 10^{12}$\")\n", + "plt.legend([case1,case2])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "id": "90d62f0a-e43b-4bad-a759-0133bc2860aa", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAG2CAYAAAB20iz+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB/WUlEQVR4nO3dd1zU9R8H8NexDvDgENmKDPdeOMCJCytXVpo5f5lpbs0cWe6RDc0sTa1cWWqOsjJHORFXCC4SUVFAQARkb+7z++Mrpyf77gDB1/PxuAd33/H5fr7H9+7e38+UCSEEiIiIiKogg4rOABEREVFZYaBDREREVRYDHSIiIqqyGOgQERFRlcVAh4iIiKosBjpERERUZTHQISIioiqLgQ4RERFVWQx0iIiIqMpioENERERV1nMb6KxYsQJt27aFhYUF7OzsMHDgQAQHB2tsM3r0aMhkMo1Hhw4dKijHRERE9Lx5bgOdkydPYuLEiTh37hyOHj2KnJwc9O7dG6mpqRrb9enTB1FRUerHwYMHKyjHRERE9LwxqugMFObQoUMarzdv3gw7Ozv4+/ujS5cu6uVyuRwODg7lnT0iIiKqBJ7bQOdZiYmJAABra2uN5SdOnICdnR2srKzQtWtXLFu2DHZ2doWmk5mZiczMTPVrlUqF+Ph41KhRAzKZrGwyT0RERHolhEBycjKcnJxgYFB4BZVMCCHKMV9aEUJgwIABePToEU6fPq1evmvXLigUCri4uCA0NBQff/wxcnJy4O/vD7lcXmBaCxcuxKJFi8or60RERFSGwsPDUatWrULXV4pAZ+LEifjzzz/h6+tb5MlERUXBxcUFO3fuxKBBgwrc5tkSncTERNSuXRvh4eGwtLTUe96JiIhI/5KSkuDs7IyEhAQolcpCt3vuq64mT56MAwcO4NSpU0UGOQDg6OgIFxcXhISEFLqNXC4vsLTH0tKSgQ4REVElU1yzk+c20BFCYPLkydi/fz9OnDgBNze3YveJi4tDeHg4HB0dyyGHRERE9Lx7bruXT5w4ET/++CN++uknWFhYIDo6GtHR0UhPTwcApKSkYObMmTh79izu3r2LEydOoF+/frCxscGrr75awbknIiKi58Fz20ansKKozZs3Y/To0UhPT8fAgQMREBCAhIQEODo6wtvbG0uWLIGzs3OJj5OUlASlUonExERWXREREVUSJf39fq6rropiZmaGw4cPl1NuiEpGpVIhKyurorNBRFTpGRsbw9DQUOd0nttAh6iyycrKQmhoKFQqVUVnhYioSrCysoKDg4NO49wx0CHSAyEEoqKiYGhoCGdn5yIHryIioqIJIZCWloaYmBgA0KmTEQMdIj3IyclBWloanJycYG5uXtHZISKq9MzMzAAAMTExsLOz07oai7edRHqQm5sLADAxMangnBARVR15N47Z2dlap8FAh0iPOF8aEZH+6OM7lYEOERERVVkMdIheYN26dcO0adMqOht6N3r0aAwcOLBU+7i6uuLLL78sk/wQUcVhoENEehMfH4/JkyejQYMGMDc3R+3atTFlyhQkJiZqbNe/f3/Url0bpqamcHR0xIgRIxAZGVlBudafqKgovPXWW2jQoAEMDAwKDSITEhIwceJEODo6wtTUFI0aNcLBgwd1OvaWLVsgk8nUD4VCgTZt2mDfvn0a2z0b3J44cUJjv4IeW7ZsQUZGBkaPHo1mzZrByMio0EByx44daNGiBczNzeHo6Ij//e9/iIuLKzSfeY+MjAyNdNatWwc3NzeYmpqiTZs2OH36tE7vT0nExcWhT58+cHJyglwuh7OzMyZNmoSkpCSN7a5evYquXbvCzMwMNWvWxOLFi4sd+y3PwoUL0bJlS41l+vrcXL58GUOHDoWzszPMzMzQqFEjrFmzptg8ZWZmYvLkybCxsUG1atXQv39/REREqNcXdY1cvHixVO9dRWCgQ0R6ExkZicjISHz++ee4evUqtmzZgkOHDmHMmDEa23l7e2P37t0IDg7G3r17cfv2bbz++usVlGv9yczMhK2tLebNm4cWLVoUuE1WVhZ69eqFu3fvYs+ePQgODsamTZtQs2ZNnY9vaWmJqKgoREVFISAgAD4+Phg8eDCCg4ML3cfLy0u9T1RUFAYPHow+ffpoLBsyZAhyc3NhZmaGKVOmoGfPngWm5evri5EjR2LMmDG4fv06fvnlF1y8eBHvvPNOofnMe5iamqrX79q1C9OmTcO8efMQEBCAzp0746WXXkJYWJjO71FRDAwMMGDAABw4cAA3b97Eli1b8Pfff2P8+PHqbZKSktCrVy84OTnh4sWLWLt2LT7//HOsWrVK6+Pq63Pj7+8PW1tb/Pjjj7h+/TrmzZuHuXPn4uuvvy7y+NOmTcP+/fuxc+dO+Pr6IiUlBX379lV3snj2GomKisI777wDV1dXeHh4lPi9qzDiBZeYmCgAiMTExIrOClVi6enpIigoSKSnp1d0Vkqla9euYuLEiWLixIlCqVQKa2trMW/ePKFSqQrd58CBA6J169ZCLpcLNzc3sXDhQpGdnV3o9rt37xYmJiZFbvPbb78JmUwmsrKyis1zTk6OePvtt4Wrq6swNTUV9evXF19++aXGNqNGjRIDBgwo1Xm6uLiIZcuWif/9739CoVAIZ2dnsWHDBo10Z82aJerVqyfMzMyEm5ub+OijjwrNc9euXcXUqVPzLV+/fr1wd3cv8lyTkpLEW2+9JczNzYWDg4NYtWpVoenl2bx5s1AqlRrLcnNzhbGxsdi9e3ex+crz7HtXmm0+++wz4e7urrHsq6++ErVq1Soyn89q166dGD9+vMayhg0bijlz5hS6z4IFC0SLFi3Etm3bhIuLi7C0tBRDhgwRSUlJ6m1UKpVYuXKlcHNzE6ampqJ58+bil19+KTIva9as0cj/unXrhFKpFBkZGeplK1asEE5OTkV+boSQzh2AxmPz5s0Fbquvz82ECROEt7d3oesTEhKEsbGx2Llzp3rZ/fv3hYGBgTh06FCB+2RlZQk7OzuxePHiQtMVIv97J4QQvr6+okuXLsLMzExYWVmJ3r17i/j4+ELTKOq7taS/3yzRISoDQgikZeVUyEOUcvq6rVu3wsjICOfPn8dXX32F1atX47vvvitw28OHD2P48OGYMmUKgoKCsGHDBmzZsgXLli0rNP28eWiMjAoetis+Ph47duyAl5cXjI2Ni82vSqVCrVq1sHv3bgQFBWH+/Pn48MMPsXv3bp3P84svvoCHhwcCAgIwYcIEvPfee7hx44Z6vYWFBbZs2YKgoCCsWbMGmzZtwurVq4vN89MOHDgAT09PTJw4Efb29mjatCmWL1+uvnsGgBkzZuDMmTM4cOAAjh49itOnT+PSpUulOk5ubi62bt0KAGjdunWp9tWWl5cXIiIicPDgQQgh8ODBA+zZswevvPKKxnYpKSlwcXFBrVq10LdvXwQEBKjXZWVlwd/fH71799bYp3fv3vDz8yvy+Ldv38avv/6KP/74A3/88QdOnjyJTz75RL3+o48+wubNm7F+/Xpcv34d06dPx/Dhw3Hy5MkC04uMjMS+ffvQtWtX9bKzZ8+ia9eukMvl6mU+Pj6IjIzE3bt3i8zfkCFD8P7776NJkyYapWUF0dfnJjExEdbW1oWu9/f3R3Z2tsb77eTkhKZNmxb6fh84cACxsbEYPXp0oekW9N4FBgaiR48eaNKkCc6ePQtfX1/069dP49ovCxwwkKgMpGfnovH8ipmLLWixD8xNSv7RdnZ2xurVqyGTydCgQQNcvXoVq1evxtixY/Ntu2zZMsyZMwejRo0CALi7u2PJkiWYNWsWFixYkG/7uLg4LFmyBOPGjcu3bvbs2fj666+RlpaGDh064I8//ihRfo2NjbFo0SL1azc3N/j5+WH37t0YPHiwTuf58ssvY8KECer8rV69GidOnEDDhg0BSD+UeVxdXfH+++9j165dmDVrVonyDgB37tzBsWPHMGzYMBw8eBAhISGYOHEicnJyMH/+fCQnJ2Pr1q346aef0KNHDwDSZMZOTk7Fpp2YmAiFQgEASE9Ph7GxMTZu3Ig6deqUOH+68PLywo4dOzBkyBBkZGQgJycH/fv3x9q1a9XbNGzYEFu2bEGzZs2QlJSENWvWoGPHjrh8+TLq1auH2NhY5Obmwt7eXiNte3t7REdHF3l8lUqFLVu2wMLCAgAwYsQI/PPPP1i2bBlSU1OxatUqHDt2DJ6engCk69fX1xcbNmzQ+EEeOnQofvvtN6Snp6Nfv34aAXF0dDRcXV3z5S1vnZubW6H5MzMzg0KhgJGRERwcHArdTl+fm7Nnz2L37t34888/C90mOjoaJiYmqF69er5zKuz9/v777+Hj41PgBNpFvXeffvopPDw8sG7dOvWyJk2aFJo3fWGJDtELrkOHDhpjVXh6eiIkJKTAuyx/f38sXrwYCoVC/Rg7diyioqKQlpamsW1SUhJeeeUVNG7cuMAg6IMPPkBAQACOHDkCQ0NDjBw5ssSlUd9++y08PDxga2sLhUKBTZs2Fdt+oyTn2bx5c/VzmUwGBwcH9RD0ALBnzx506tQJDg4OUCgU+Pjjj0vdbkSlUsHOzg4bN25EmzZt8Oabb2LevHlYv349ACkQys7ORrt27dT7KJVKNGjQoNi0LSwsEBgYiMDAQAQEBGD58uUYN24cfv/991LlUVtBQUGYMmUK5s+fD39/fxw6dAihoaEa7TQ6dOiA4cOHo0WLFujcuTN2796N+vXrawRDQP7xU4QQxY6p4urqqg5yAGnagLz/X1BQEDIyMtCrVy+N63fbtm24ffu2RjqrV6/GpUuX8Ouvv+L27duYMWNGsXkraLk29PW5uX79OgYMGID58+ejV69epc5HYe93REQEDh8+nK/9UJ6i3ru8Ep3yxhIdojJgZmyIoMU+FXbssqJSqbBo0SIMGjQo37qnG5MmJyejT58+UCgU2L9/f4FF6zY2NrCxsUH9+vXRqFEjODs749y5c+q77cLs3r0b06dPxxdffAFPT09YWFjgs88+w/nz53U+v2fzKZPJ1JO0njt3Dm+++SYWLVoEHx8fKJVK7Ny5E1988UWpjuHo6JhvVuZGjRohOjoaWVlZhf5oliQINDAwQN26ddWvmzdvjiNHjmDlypXo169fqfKpjRUrVqBjx4744IMP1MevVq0aOnfujKVLlxY4X5GBgQHatm2LkJAQANJ1YWhomK80ISYmJl8pz7OK+v/l/f3zzz/zNfx+uhoKABwcHODg4ICGDRuiRo0a6Ny5Mz7++GM4OjrCwcGhwLwBKDZ/xdHX5yYoKAjdu3fH2LFjNUohC+Lg4ICsrCw8evRIo1QnJiYGXl5e+bbfvHkzatSogf79+xeaXmHvXd6UDuWNgQ5RGZDJZKWqPqpI586dy/e6Xr16Bc4r07p1awQHB2v8mD4rKSkJPj4+kMvlOHDggEYAVJi8H/HMzMxitz19+jS8vLzUVUwA8t2RF6Q051mQM2fOwMXFBfPmzVMvu3fvXon2fVrHjh3x008/QaVSqSd/vXnzJhwdHWFiYoI6derA2NgYFy5cUFcNJCUlISQkRKN6paQMDQ2Rnp5e6v20kZaWlq9NSd77W1igJoRAYGAgmjVrBkCaRqVNmzY4evQoXn31VfV2R48exYABA7TOW+PGjSGXyxEWFlaq9/HZa9PT0xMffvghsrKy1FO+HDlyBE5OTvmqtApiYmJSYGmpvj43169fR/fu3TFq1Kgi287ladOmDYyNjXH06FF11W9UVBSuXbuGTz/9NN/xNm/ejJEjR5aoPd2z+WvevDn++ecfjarn8lA5vomJqMyEh4djxowZGDduHC5duoS1a9eqSynmzp2L+/fvY9u2bQCA+fPno2/fvnB2dsYbb7wBAwMDXLlyBVevXsXSpUuRnJyM3r17Iy0tDT/++COSkpLU42jY2trC0NAQFy5cwIULF9CpUydUr14dd+7cwfz581GnTp1iS3MAoG7duti2bRsOHz4MNzc3bN++HRcvXiyybURx51kSdevWRVhYGHbu3Im2bdvizz//xP79+/NtFxgYCEBqcPvw4UMEBgbCxMQEjRs3BgC89957WLt2LaZOnYrJkycjJCQEy5cvx5QpUwBI1U+jRo3CBx98AGtra9jZ2WHBggUwMDDQKOV59n8DSD8seaUN6enpOHr0KA4fPoz58+dr5DEvX0/LuxMvSlBQELKyshAfH4/k5GR1GnnjwvTr1w9jx47F+vXr4ePjg6ioKEybNg3t2rVTtzFatGgROnTogHr16iEpKQlfffUVAgMD8c0336iPM2PGDIwYMQIeHh7w9PTExo0bERYWplEFVtD5F8XCwgIzZ87E9OnToVKp0KlTJyQlJcHPzw8KhQKjRo3CwYMH8eDBA7Rt2xYKhQJBQUGYNWsWOnbsqA5i3nrrLSxatAijR4/Ghx9+qP7/zZ8/v0RVV66urggNDUVgYCBq1aoFCwsLZGVl6eVzc/36dXh7e6N3796YMWOG+lowNDSEra0tAOD+/fvo0aMHtm3bhnbt2kGpVGLMmDF4//33UaNGDVhbW2PmzJlo1qxZvmEEjh07htDQ0AKrrUry3s2dOxfNmjXDhAkTMH78eJiYmOD48eN44403YGNjU6L/o1aK7JP1AmD3ctKHyty9fMKECWL8+PHC0tJSVK9eXcyZM0fdTXbUqFGia9euGvscOnRIeHl5CTMzM2FpaSnatWsnNm7cKIQQ4vjx4/m6z+Y9QkNDhRBCXLlyRXh7ewtra2shl8uFq6urGD9+vIiIiChRnjMyMsTo0aOFUqkUVlZW4r333hNz5swRLVq0UG9TUPfyos5TCKl7+erVqzWO1aJFC7FgwQL16w8++EDUqFFDKBQKMWTIELF69ep8XaULOncXFxeNbfz8/ET79u2FXC4X7u7uYtmyZSInJ0e9vqDu5e3atdPoXv3s/+bZrstyuVzUr18/X9pdu3YtMI9551lU93IXF5cC933aV199JRo3bizMzMyEo6OjGDZsmMb/dtq0aaJ27drCxMRE2Nrait69ews/P798x/rmm2+Ei4uLMDExEa1btxYnT57UWP/s+ed1L3/a6tWrNd57lUol1qxZIxo0aCCMjY2Fra2t8PHxUad97Ngx4enpKZRKpTA1NRX16tUTs2fPFo8ePdJI98qVK6Jz585CLpcLBwcHsXDhwmK7lufJyMgQr732mrCyslJ3L9fX52bBggXFXn+hoaECgDh+/Lh6WXp6upg0aZKwtrYWZmZmom/fviIsLCxf3ocOHSq8vLwKPK+SvncnTpwQXl5eQi6XCysrK+Hj45Nvm6fpo3u5TIhS9kWtYpKSkqBUKtVd+Yi0kZGRgdDQUPVIrvR86datG1q2bFlpp3hITU1FzZo18cUXXxTaCJSoKirqu7Wkv9+suiIies4EBATgxo0baNeuHRITE7F48WIA0KmNCtGLit3Liei5Mn78eI3uv08/novh5MvJ559/jhYtWqBnz55ITU3F6dOny7YdA+lFkyZNCr1+d+zYUdHZeyGx6opVV6QHrLrSn5iYmEInArS0tISdnV0554io5O7du4fs7OwC19nb22uM80PFY9UVEVU5dnZ2DGao0nJxcanoLNAzWHVFREREVRYDHSIiIqqyGOgQERFRlcVAh4iIiKosBjpERERUZTHQIXqBdevWDdOmTavobOjd6NGjMXDgwFLt4+rqWmlHTiaiwjHQISK9iY+Px+TJk9GgQQOYm5ujdu3amDJlChITEzW269+/P2rXrg1TU1M4OjpixIgRiIyMrKBc609UVBTeeustNGjQAAYGBoUGkQkJCZg4cSIcHR1hamqKRo0a4eDBgzode8uWLZDJZOqHQqFAmzZtsG/fPo3tng1uT5w4obFfQY8tW7YgIyMDo0ePRrNmzWBkZFRoILljxw60aNEC5ubmcHR0xP/+9z/ExcUVms+8R0ZGhkY669atU4+d0qZNG5w+fVqn96ck4uLi0KdPHzg5OUEul8PZ2RmTJk3KN67T1atX0bVrV5iZmaFmzZpYvHhxobOzP2vhwoXqSVDz6Otzc/nyZQwdOhTOzs4wMzNDo0aNsGbNmmLzlJmZicmTJ8PGxgbVqlVD//79ERERoV5f1DVy8eJF9XYFrf/2229L9L6UJQY6RKQ3kZGRiIyMxOeff46rV69iy5YtOHToUL75mby9vbF7924EBwdj7969uH37Nl5//fUKyrX+ZGZmwtbWFvPmzUOLFi0K3CYrKwu9evXC3bt3sWfPHgQHB2PTpk2oWbOmzse3tLREVFQUoqKiEBAQAB8fHwwePBjBwcGF7uPl5aXeJyoqCoMHD0afPn00lg0ZMgS5ubkwMzPDlClT8s1qncfX1xcjR47EmDFjcP36dfzyyy+4ePEi3nnnnULzmfd4ejC4Xbt2Ydq0aZg3bx4CAgLQuXNnvPTSSwgLC9P5PSqKgYEBBgwYgAMHDuDmzZvYsmUL/v77b40RuZOSktCrVy84OTnh4sWLWLt2LT7//HOsWrVK6+Pq63Pj7+8PW1tb/Pjjj7h+/TrmzZuHuXPn4uuvvy7y+NOmTcP+/fuxc+dO+Pr6IiUlBX379kVubi6A/NdIVFQU3nnnHbi6usLDw0Mjrc2bN2tsN2rUKK3fF70pcsrPFwBnLyd9qMyzl0+cOFFMnDhRKJVKYW1tLebNm1fkTMwHDhwQrVu3FnK5XLi5uYmFCxeK7OzsQrffvXu3MDExKXKb3377TchkMpGVlVVsnnNycsTbb78tXF1dhampqahfv7748ssvNbYpaPby4s7TxcVFLFu2TPzvf/8TCoVCODs7iw0bNmikO2vWLFGvXj1hZmYm3NzcxEcffVRonrt27SqmTp2ab/n69euFu7t7keda0OzlhaWXZ/PmzflmUs/NzRXGxsZi9+7dxeYrT1Gzlxe3zWeffSbc3d01ln311VeiVq1aRebzWe3atRPjx4/XWNawYUON2duflTd7+bZt24SLi4uwtLQUQ4YMEUlJSeptVCqVWLlypXBzcxOmpqaiefPm4pdffikyL2vWrNHI/7p164RSqRQZGRnqZStWrBBOTk7FzmD+7AzzeDx7eUH09bmZMGGC8Pb2LnR9QkKCMDY2Fjt37lQvu3//vjAwMBCHDh0qcJ+srCxhZ2cnFi9erLEcgNi/f3+hxxJCCF9fX9GlSxdhZmYmrKysRO/evUV8fHyh2+tj9nKW6BCVBSGArNSKeZRyVpetW7fCyMgI58+fx1dffYXVq1fju+++K3Dbw4cPY/jw4ZgyZQqCgoKwYcMGbNmyBcuWLSs0/bzh2Y2MCh6IPT4+Hjt27ICXlxeMjY2Lza9KpUKtWrWwe/duBAUFYf78+fjwww+xe/dunc/ziy++gIeHBwICAjBhwgS89957uHHjhnq9hYUFtmzZgqCgIKxZswabNm3C6tWri83z0w4cOABPT09MnDgR9vb2aNq0KZYvX66+ewaAGTNm4MyZMzhw4ACOHj2K06dP49KlS6U6Tm5uLrZu3QoAaN26dan21ZaXlxciIiJw8OBBCCHw4MED7NmzB6+88orGdikpKXBxcUGtWrXQt29fBAQEqNdlZWXB398fvXv31tind+/e8PPzK/L4t2/fxq+//oo//vgDf/zxB06ePIlPPvlEvf6jjz7C5s2bsX79ely/fh3Tp0/H8OHDcfLkyQLTi4yMxL59+9C1a1f1srNnz6Jr166Qy+XqZT4+PoiMjMTdu3eLzN+QIUPw/vvvo0mTJhqlZQXR1+cmMTER1tbWha739/dHdna2xvvt5OSEpk2bFvp+HzhwALGxsRg9enS+dZMmTYKNjQ3atm2Lb7/9FiqVSr0uMDAQPXr0QJMmTXD27Fn4+vqiX79+Gtd+WeAUEERlITsNWO5UMcf+MBIwqVbizZ2dnbF69WrIZDI0aNAAV69exerVqzF27Nh82y5btgxz5sxRF0e7u7tjyZIlmDVrFhYsWJBv+7i4OCxZsgTjxo3Lt2727Nn4+uuvkZaWhg4dOuCPP/4oUX6NjY2xaNEi9Ws3Nzf4+flh9+7dGDx4sE7n+fLLL2PChAnq/K1evRonTpxAw4YNAUg/lHlcXV3x/vvvY9euXZg1a1aJ8g4Ad+7cwbFjxzBs2DAcPHgQISEhmDhxInJycjB//nwkJydj69at+Omnn9CjRw8AUnWAk1Px11NiYiIUCgUAID09HcbGxti4cSPq1KlT4vzpwsvLCzt27MCQIUOQkZGBnJwc9O/fH2vXrlVv07BhQ2zZsgXNmjVDUlIS1qxZg44dO+Ly5cuoV68eYmNjkZubC3t7e4207e3tER0dXeTxVSoVtmzZop5PasSIEfjnn3+wbNkypKamYtWqVTh27Bg8PT0BSNevr68vNmzYoBHMDB06FL/99hvS09PRr18/jYA4Ojoarq6u+fKWt87Nza3Q/JmZmUGhUMDIyAgODg6Fbqevz83Zs2exe/du/Pnnn4VuEx0dDRMTE1SvXj3fORX2fn///ffw8fGBs7OzxvIlS5agR48eMDMzwz///IP3338fsbGx6s/Np59+Cg8PD6xbt069T5MmTQrNm76wRIfoBdehQwfIZDL1a09PT4SEhBR4l+Xv74/FixdrzMg8duxYREVFIS0tTWPbpKQkvPLKK2jcuHGBQdAHH3yAgIAAHDlyBIaGhhg5cmSJG3R+++238PDwgK2tLRQKBTZt2lRs+42SnGfz5s3Vz2UyGRwcHBATE6NetmfPHnTq1AkODg5QKBT4+OOPS91uRKVSwc7ODhs3bkSbNm3w5ptvYt68eVi/fj0AKRDKzs5Gu3bt1PsolUo0aNCg2LQtLCwQGBiIwMBABAQEYPny5Rg3bhx+//33UuVRW0FBQZgyZQrmz58Pf39/HDp0CKGhoRptXDp06IDhw4ejRYsW6Ny5M3bv3o369etrBEMANP5XACCEyLfsWa6urhqTZjo6Oqr/f0FBQcjIyECvXr00rt9t27bh9u3bGumsXr0aly5dwq+//orbt29jxowZxeatoOXa0Nfn5vr16xgwYADmz5+PXr16lTofhb3fEREROHz4cL72Q4B0I+Dp6YmWLVvi/fffx+LFi/HZZ5+p1+eV6JQ3lugQlQVjc6lkpaKOXUZUKhUWLVqEQYMG5Vv3dGPS5ORk9OnTBwqFAvv37y+waN3GxgY2NjaoX78+GjVqBGdnZ5w7d059t12Y3bt3Y/r06fjiiy/g6ekJCwsLfPbZZzh//rzO5/dsPmUymbro/dy5c3jzzTexaNEi+Pj4QKlUYufOnfjiiy9KdQxHR0cYGxvD0NBQvaxRo0aIjo5GVlZWoT+aJQkCDQwMULduXfXr5s2b48iRI1i5ciX69etXqnxqY8WKFejYsSM++OAD9fGrVauGzp07Y+nSpXB0dCwwz23btkVISAgA6bowNDTMV5oQExOTr5TnWUX9//L+/vnnn/kafj9dDQUADg4OcHBwQMOGDVGjRg107twZH3/8MRwdHeHg4FBg3gAUm7/i6OtzExQUhO7du2Ps2LEapZAFcXBwQFZWFh49eqRRqhMTEwMvL69822/evBk1atRA//79iz2fDh06ICkpCQ8ePIC9vT3MzMyK3acssESHqCzIZFL1UUU8SnlXee7cuXyv69Wrp/FDnKd169YIDg5G3bp18z0MDKSvk6SkJPTu3RsmJiY4cOCARgBUmLwf8czMzGK3PX36NLy8vDBhwgS0atUKdevWzXdHrut5FuTMmTNwcXHBvHnz4OHhgXr16uHevXsl2vdpHTt2xK1btzTaLty8eROOjo4wMTFBnTp1YGxsjAsXLqjXJyUlqQOB0jI0NER6erpW+5ZWWlqa+jp4+vhA4YGaEAKBgYHqIMjExARt2rTB0aNHNbY7evRogT+8JdW4cWPI5XKEhYXlu3afrYJ5Nn/Ak2vT09MTp06dQlZWlnqbI0eOwMnJKV+VVkFMTEwKLC3V1+fm+vXr8Pb2xqhRo4psO5enTZs2MDY21ni/o6KicO3atXzvtxACmzdvxsiRI0vUni4gIACmpqawsrICIAW+//zzT7H76RtLdIhecOHh4ZgxYwbGjRuHS5cuYe3atepSirlz5+L+/fvYtm0bAGD+/Pno27cvnJ2d8cYbb8DAwABXrlzB1atXsXTpUiQnJ6N3795IS0vDjz/+iKSkJPUYJLa2tjA0NMSFCxdw4cIFdOrUCdWrV8edO3cwf/581KlTp9jSHACoW7cutm3bhsOHD8PNzQ3bt2/HxYsXi2wbUdx5lkTdunURFhaGnTt3om3btvjzzz+xf//+fNsFBgYCkBrcPnz4EIGBgTAxMUHjxo0BAO+99x7Wrl2LqVOnYvLkyQgJCcHy5csxZcoUAFL106hRo/DBBx/A2toadnZ2WLBgAQwMDDRKeZ793wDSD1FeaUN6ejqOHj2Kw4cPY/78+Rp5zMvX0/JKMYoSFBSErKwsxMfHIzk5WZ1G3rgw/fr1w9ixY7F+/Xr4+PggKioK06ZNQ7t27dRtjBYtWoQOHTqgXr16SEpKwldffYXAwEB888036uPMmDEDI0aMgIeHBzw9PbFx40aEhYVpVIEVdP5FsbCwwMyZMzF9+nSoVCp06tQJSUlJ8PPzg0KhwKhRo3Dw4EE8ePAAbdu2hUKhQFBQEGbNmoWOHTuqg5i33noLixYtwujRo/Hhhx+q/3/z588vUdWVq6srQkNDERgYiFq1asHCwgJZWVl6+dzkBTm9e/fGjBkz1NeCoaEhbG1tAQD3799Hjx49sG3bNrRr1w5KpRJjxozB+++/jxo1asDa2hozZ85Es2bN8g0jcOzYMYSGhhZYbfX7778jOjoanp6eMDMzw/HjxzFv3jy8++676hKzuXPnolmzZpgwYQLGjx8PExMTHD9+HG+88QZsbGxK9H/USpF9sl4A7F5O+lCZu5dPmDBBjB8/XlhaWorq1auLOXPmqLvJjho1SnTt2lVjn0OHDgkvLy9hZmYmLC0tRbt27cTGjRuFEEIcP348X/fZvEdoaKgQQogrV64Ib29vYW1tLeRyuXB1dRXjx48XERERJcpzRkaGGD16tFAqlcLKykq89957Ys6cOaJFixbqbQrqXl7UeQohdS9fvXq1xrFatGghFixYoH79wQcfiBo1agiFQiGGDBkiVq9ena+rdEHn7uLiorGNn5+faN++vZDL5cLd3V0sW7ZM5OTkqNcX1L28Xbt2Gt2rn/3fPNt1WS6Xi/r16+dLu2vXrgXmMe88i+pe7uLiUuC+T/vqq69E48aNhZmZmXB0dBTDhg3T+N9OmzZN1K5dW5iYmAhbW1vRu3dv4efnl+9Y33zzjXBxcREmJiaidevW4uTJkxrrnz3/vO7lT1u9erXGe69SqcSaNWtEgwYNhLGxsbC1tRU+Pj7qtI8dOyY8PT2FUqkUpqamol69emL27Nni0aNHGuleuXJFdO7cWcjlcuHg4CAWLlxYbNfyPBkZGeK1114TVlZW6u7l+vrcLFiwoNjrLzQ0VAAQx48fVy9LT08XkyZNEtbW1sLMzEz07dtXhIWF5cv70KFDhZeXV4Hn9ddff4mWLVsKhUIhzM3NRdOmTcWXX36Zr3v8iRMnhJeXl5DL5cLKykr4+Pjke3+fpo/u5TIhStkXtYpJSkqCUqlUd+Uj0kZGRgZCQ0PVI7nS86Vbt25o2bJlpZ3iITU1FTVr1sQXX3xR4N00UVVV1HdrSX+/WXVFRPScCQgIwI0bN9CuXTskJiZi8eLFAIABAwZUcM6IKh82Riai58r48eM1uv8+/Xi6jUZV9/nnn6NFixbo2bMnUlNTcfr06bJtx0B60aRJk0Kv3x07dlR09l5IrLpi1RXpAauu9CcmJibfJIp5LC0tYWdnV845Iiq5e/fuITs7u8B19vb2GuP8UPFYdUVEVY6dnR2DGaq0XFxcKjoL9AxWXREREVGVxUCHSI9e8JpgIiK9enpgTW2x6opID4yNjSGTyfDw4UPY2trqZc4bIqIXlRACWVlZePjwIQwMDGBiYqJ1Wgx0iPTA0NAQtWrVQkREBO7evVvR2SEiqhLMzc1Ru3btfFOLlAYDHSI9USgUqFevXqE9LoiIqOQMDQ1hZGSkcwk5Ax0iPTI0NCzxJJFERFT22BiZiIiIqiwGOkRERFRlMdAhIiKiKouBDhEREVVZDHSIiIioymKgQ0RERFVWqQOd9PR03L9/P9/y69ev6yVDRERERPpSqkBnz549qF+/Pl5++WU0b94c58+fV68bMWKE3jNHREREpItSBTpLly7FpUuXcPnyZfzwww94++238dNPPwHgZIZERET0/CnVyMjZ2dmwtbUFAHh4eODUqVMYNGgQbt26xUkMiYiI6LlTqhIdOzs7XLlyRf26Ro0aOHr0KP777z+N5URERETPg1IFOtu3b4ednZ3GMhMTE/z88884efKkXjNGREREpKtSVV3VqlWr0HWmpqY6Z4aIiIhIn/Q2js6rr76qr6SIiIiI9KJUJTqDBw8ucLkQAvHx8XrJUJ4VK1Zg3759uHHjBszMzODl5YWVK1eiQYMGGsddtGgRNm7ciEePHqF9+/b45ptv0KRJE73mhYiIiCqnUgU6f//9N7Zv3w6FQqGxXAiBU6dO6TVjJ0+exMSJE9G2bVvk5ORg3rx56N27N4KCglCtWjUAwKeffopVq1Zhy5YtqF+/PpYuXYpevXohODgYFhYWes0PERERVT6lCnS6desGhUKBrl275lvXqlUrvWUKAA4dOqTxevPmzbCzs4O/vz+6dOkCIQS+/PJLzJs3D4MGDQIAbN26Ffb29vjpp58wbtw4veaHiIiIKp9StdHZt29fgUEOkD8w0bfExEQAgLW1NQAgNDQU0dHR6N27t3obuVyOrl27ws/Pr9B0MjMzkZSUpPEgIiKiqqlSTOophMCMGTPQqVMnNG3aFAAQHR0NALC3t9fY1t7eXr2uICtWrIBSqVQ/nJ2dyy7jREREVKFKVXX1rIiICKxfvx5+fn6Ijo6GTCaDvb09vLy8MH78eL0FEZMmTcKVK1fg6+ubb92zIzILIYocpXnu3LmYMWOG+nVSUhKDHSIioipK60DH19cXL730EpydndG7d2/07t0bQgjExMTg119/xdq1a/HXX3+hY8eOOmVw8uTJOHDgAE6dOqUxjo+DgwMAqWTH0dFRvTwmJiZfKc/T5HI55HK5TnkiIiKiykHrQGf69Ol45513sHr16kLXT5s2DRcvXtQqfSEEJk+ejP379+PEiRNwc3PTWO/m5gYHBwccPXpU3RA6KysLJ0+exMqVK7U6JhEREVUtWrfRuXbtGsaPH1/o+nHjxuHatWvaJo+JEyfixx9/xE8//QQLCwtER0cjOjoa6enpAKQqq2nTpmH58uXYv38/rl27htGjR8Pc3BxvvfWW1sclIiKiqkPrEh1HR0f4+flpDOD3tLNnz2pUKZXW+vXrAUhd2p+2efNmjB49GgAwa9YspKenY8KECeoBA48cOcIxdIiIiAiADoHOzJkzMX78ePj7+6NXr16wt7eHTCZDdHQ0jh49iu+++w5ffvml1hkTQhS7jUwmw8KFC7Fw4UKtj0NERERVl9aBzoQJE1CjRg2sXr0aGzZsQG5uLgDA0NAQbdq0wbZt2wqdMoKIiIioPMhESYpOipGdnY3Y2FgAgI2NDYyNjXXOWHlJSkqCUqlEYmIiLC0tKzo7REREVAIl/f3WaRydPMbGxjq1xyEiIiIqC2U2MnJ4eDjefvvtskqeiIiIqFhlFujEx8dj69atZZU8ERERUbG0rro6cOBAkevv3LmjbdJEREREeqF1oDNw4EDIZLIiu4EXNecUERERUVnTuurK0dERe/fuhUqlKvBx6dIlfeaTiIiIqNS0DnTatGlTZDBTXGkPERERUVnTuurqgw8+QGpqaqHr69ati+PHj2ubPBEREZHOdB4wMDk5uVLPLcUBA4mIiCqfkv5+69y9vHPnzoiOjtY1GSIiIiK90znQ8fDwQPv27XHjxg2N5QEBAXj55Zd1TZ6IiIhIazoHOt999x3efvttdOrUCb6+vrh58yYGDx4MDw8PyOVyfeSRiIiISCt6metqwYIFMDExQa9evZCbmwsfHx9cvHgRrVu31kfyRERERFrRuUQnKioKU6ZMwZIlS9C4cWMYGxvjzTffZJBDREREFU7nQMfd3R2nT5/GL7/8An9/f+zbtw8TJkzAypUr9ZE/IiIiIq3pXHW1efNmvPnmm+rXPj4+OH78OPr27Yt79+5h3bp1uh6CiIiISCs6l+g8HeTkad26Nfz8/HDixAldkyciIiLSms6BTmFcXV1x5syZskqeiIiIqFg6V10lJCTg+++/R3R0NNzc3NCyZUu0aNEC1apVQ/Xq1fWRRyIiIiKt6BzoDBo0CFevXkXbtm3x119/4ebNm1CpVHB3d0fLli2xe/dufeSTiIiIqNR0DnTOnz+PkydPwsPDAwCQmZmJ69ev4/Lly7h8+bLOGSQiIiLSls6BTtOmTWFg8KSpj1wuR+vWrTmODhEREVU4nRsjr1y5Eh9//DEyMjL0kR8iIiIivdG5RMfNzQ3Jyclo1KgRhg4divbt26NVq1aoXbu2PvJHREREpDWdS3Ree+01hIeHw9vbGxcuXMCYMWPg5uaGGjVqoHv37vrIIxEREZFWdC7RCQoKwrlz59C8eXP1srCwMAQEBCAwMFDX5ImIiIi0pnOg07ZtW6SkpGgsq127NmrXro0BAwbomjwRERGR1nSuupo2bRoWLlyIR48e6SM/RERERHqjc4nOa6+9BgCoV68e+vfvjw4dOqBVq1Zo3rw55HK5zhkkIiIi0pbOgU5oaCgCAwNx+fJlBAYGYuXKlbh79y4MDQ3RsGFDXLlyRR/5JCIiIio1nQMdFxcXuLi4aLTHSU5ORmBgIIMcIiIiqlAyIYSo6ExUpKSkJCiVSiQmJsLS0rKis0NEREQlUNLfb50bIxMRERE9rxjoEBERUZXFQIeIiIiqLAY6REREVGXp3OsqT1BQEMLCwpCVlaWxvH///vo6BBEREVGp6Bzo3LlzB6+++iquXr0KmUyGvE5cMpkMAJCbm6vrIYiIiIi0onPV1dSpU+Hm5oYHDx7A3Nwc169fx6lTp+Dh4YETJ07oIYtERERE2tG5ROfs2bM4duwYbG1tYWBgAAMDA3Tq1AkrVqzAlClTEBAQoI98EhEREZWaziU6ubm5UCgUAAAbGxtERkYCkEZMDg4O1jV5IiIiIq3pXKLTtGlTXLlyBe7u7mjfvj0+/fRTmJiYYOPGjXB3d9dHHomIiIi0onOg89FHHyE1NRUAsGTJEvTr1w+dO3dGjRo1sGvXLp0zSERERKStMpnrKj4+HtWrV1f3vHqeca4rIiKiyqdc57o6ffo0hg8fDk9PT9y/fx/W1tb48ccf4evrq4/kiYiIiLSic6Czd+9e+Pj4wMzMDAEBAcjMzAQAJCcnY/ny5TpnkIiIiEhbOgc6S5cuxbfffotNmzbB2NhYvdzLywuXLl3SNXkiIiIirekc6AQHB6NLly75lltaWiIhIUHX5ImIiIi0pnOg4+joiFu3buVb7uvry+7lREREVKF0DnTGjRuHqVOn4vz585DJZIiMjMSOHTswc+ZMTJgwQR95JCIiItKKzuPozJo1C4mJifD29kZGRga6dOkCuVyOmTNnYtKkSfrIIxEREZFW9DaOTlpaGoKCgqBSqdC4cWP1tBDPO46jQ0REVPmUyzg62dnZ8Pb2xs2bN2Fubg4PDw+0a9eu0gQ5REREVLXpFOgYGxvj2rVrlWIEZCIiInrx6NwYeeTIkfj+++/1kRciIiIivdK5MXJWVha+++47HD16FB4eHqhWrZrG+lWrVul6CCIiIiKt6BzoXLt2Da1btwYA3Lx5U2Mdq7SIiIioIukc6Bw/flwf+SAiIiLSO73MXl6YwMDAskyeiIiIqEh6D3QSExOxbt06tG7dGm3atNF38kREREQlprdA59ixYxg+fDgcHR2xdu1avPzyy/j333/1lTwRERFRqekU6ERERGDp0qVwd3fH0KFDUb16dWRnZ2Pv3r1YunQpWrVqpVPmTp06hX79+sHJyQkymQy//vqrxvrRo0dDJpNpPDp06KDTMYmIiKjq0DrQefnll9G4cWMEBQVh7dq1iIyMxNq1a/WZN6SmpqJFixb4+uuvC92mT58+iIqKUj8OHjyo1zwQERFR5aV1r6sjR45gypQpeO+991CvXj195kntpZdewksvvVTkNnK5HA4ODmVyfCIiIqrctC7ROX36NJKTk+Hh4YH27dvj66+/xsOHD/WZtxI5ceIE7OzsUL9+fYwdOxYxMTFFbp+ZmYmkpCSNBxEREVVNWgc6np6e2LRpE6KiojBu3Djs3LkTNWvWhEqlwtGjR5GcnKzPfBbopZdewo4dO3Ds2DF88cUXuHjxIrp3747MzMxC91mxYgWUSqX64ezsXOb5JCIiooohE0IIfSUWHByM77//Htu3b0dCQgJ69eqFAwcO6CVtmUyG/fv3Y+DAgYVuExUVBRcXF+zcuRODBg0qcJvMzEyNQCgpKQnOzs7FTvNOREREz4+kpCQolcpif7/1Oo5OgwYN8OmnnyIiIgI///yzPpMuEUdHR7i4uCAkJKTQbeRyOSwtLTUeREREVDWVycjIhoaGGDhwoN5Kc0oqLi4O4eHhcHR0LNfjEhER0fNJ57muylJKSgpu3bqlfh0aGorAwEBYW1vD2toaCxcuxGuvvQZHR0fcvXsXH374IWxsbPDqq69WYK6JiIjoefFcBzr//vsvvL291a9nzJgBABg1ahTWr1+Pq1evYtu2bUhISICjoyO8vb2xa9cuWFhYVFSWiYiI6Dmi18bIlVFJGzMRERHR86NCGiMTERERPU/0EuicPn0aw4cPh6enJ+7fvw8A2L59O3x9ffWRPBEREZFWdA509u7dCx8fH5iZmSEgIEA9Rk1ycjKWL1+ucwaJiIiItKVzoLN06VJ8++232LRpE4yNjdXLvby8cOnSJV2TJyIiItKazoFOcHAwunTpkm+5paUlEhISdE2eiIiISGs6BzqOjo4aY93k8fX1hbu7u67JExEREWlN50Bn3LhxmDp1Ks6fPw+ZTIbIyEjs2LEDM2fOxIQJE/SRRyIiIiKt6Dxg4KxZs5CYmAhvb29kZGSgS5cukMvlmDlzJiZNmqSPPBIRERFpRW8DBqalpSEoKAgqlQqNGzeGQqHQR7JljgMGEhERVT4l/f3WuURnxYoVsLe3x9tvvw0PDw/18h9++AEPHz7E7NmzdT0EERERkVZ0bqOzYcMGNGzYMN/yJk2a4Ntvv9U1eSIiIiKt6RzoREdHw9HRMd9yW1tbREVF6Zo8ERERkdZ0DnScnZ1x5syZfMvPnDkDJycnXZMnIiIi0prObXTeeecdTJs2DdnZ2ejevTsA4J9//sGsWbPw/vvv65xBIiIiIm3ppXt5fHw8JkyYgKysLACAqakpZs+ejblz5+qcQSIiIiJt6a17eUpKCv777z+YmZmhXr16kMvl+ki2zLF7ORERUeVTbt3L8ygUCrRt21ZfyRERERHpTOtAZ9CgQSXabt++fdoegoiIiEgnWgc6SqVSn/kgIiKiKub2wxRcCI3H0Ha1KywPWgc6mzdv1mc+iIiIqIrwv/cIG07extH/HkAGoGMdG9SuYV4hedFbGx0iIiKqPLJyVPj3bjzslaaoY6v7/JQqlcA/N2Kw4eRt/HvvkXp5j0b2yFapdE5fWwx0iIiIXiARj9Lw84Uw7LoYjtgUaVgYN5tq6N7QDj0a2qGtmzWMDUs+nnBmTi5+DbiPjafu4PbDVACAiaEBXm1VE2O7uKGunUWZnEdJ6a17eWXF7uVERFTV5aoETt18iB/P3cPx4BioHv/yW1czQXJGNrJzn4QCFnIjdGlgi56N7NCtvh2qVzMpMM3E9Gz8dD4Mm8+EIiY5U9rX1AjD2rvgfx1dYW9pWqbnVO7dy4mIiOj5EpeSid3/RuCnC/cQHp+uXt6xbg0Mb++Cno3tkZmjgm/IQ/z9XwyO34hBXGoW/rwShT+vRMFABrRxqY7uDe3Rs5Ed6topEJ2UgR98Q/HzhXCkZOYAAByVpni7oxvebOcMC1PjijrdArFEhyU6RET0nIpPzYLcyADmJoaQyWQl2kcIgX/vPcKP5+7hr6vRyMqV2sdYmhrh9TbOGNahdqFtclQqgcCIBPzz3wP8818MbkQna6yvaWWGB0kZyHlcJNTA3gLvdnFHvxZOMDHSefrMUinp77feAp2goCCEhYWpp4HI079/f30kX2YY6BAR0fMmMS0bU3cF4ETwQwCAkYEMlmbGUJoZw9LUCJZmxk+9fvzXzAgZ2Sr88m+4RoDSopYSwzq4oF9zJ5iZGJYqHxGP0nD8Rgz+/i8GZ2/HqYOmDu7WGNe1DrrVty1xAKZv5Rbo3LlzB6+++iquXr0KmUyGvOTyTjw3N1eX5MscAx0iInqehDxIxtht/+JuXJrWaZgaG6B/CycM7+CC5rWs9JKv1MwcXLwbD1sLOZo4VfxYeuXWRmfq1Klwc3PD33//DXd3d1y4cAFxcXF4//338fnnn+uaPBERVYAHSRlISMuGjcIE1c1NYGBQMXftL5q/gx5g2q5ApGTmoFZ1M2wc4QFXG3MkpmcjKT3n8d9s6W9GtubyjGxk5qjQrb4tXmtdC0pz/baVqSY3QrcGdnpNszzoHOicPXsWx44dg62tLQwMDGBgYIBOnTphxYoVmDJlCgICAvSRTyIiKgc5uSp8dewWvj4Wou6ZYyADrKvJYaMwga2FHDYK6bmNQo4aTz13takGhZx9XLQhhMC6E7fx+ZFgCAG0d7PG+uFtYP24x5O5iREcK74QpVLS+YrMzc2FQiE1arKxsUFkZCQaNGgAFxcXBAcH65xBIiIqH+HxaZi6MwCXwhIAAEozYySmZ0MlgNiUTMSmZOZrnPo0cxNDDO/ggnc6ucGujLsWVyXpWbn4YM9l/HElCgAwooML5vdrXKqxbKhwOgc6TZs2xZUrV+Du7o727dvj008/hYmJCTZu3Ah3d3d95JGIiMrYrwH38dGv15CSmQMLUyMse7UZ+rdwQnauCvGpWXiYLAU6cSlZ6qAnVv08CzFJGYhLzcLGU3ewxe8uBnvUwrgudeBsXTHD/pdUVo4KMckZiE7MQHRSBtKycpGdq0JOrkB2rgrZj//m5KqQ9czznFwValubY0DLmlpPb3A/IR3vbvsX1yOTYGQgw+IBTfFW+4qbF6oq0rkx8uHDh5GamopBgwbhzp076Nu3L27cuIEaNWpg165d6N69u77yWibYGJmIXmTJGdmY/9t17A+4DwDwcKmOL99siVrVS/fDLYTAieCH+Pr4Lfg/Hv7fyECGAS1r4r1udVDXTvcpBkorIzsX0YkZiErMQHRSuvT38esHSdLf2JRM6KPvsYdLdQxqXQuvNHMscduYi3fjMX67P+JSs1CjmgnWD2+Ddm7WumfmBVHu3cufFh8fj+rVq1dYl7PSYKBDRC8q/3uPMG1XAMLj02FoIMOU7vUw0bsOjHSoMhFC4NydeKw7cQunQ2IBADIZ8FJTB0z0rlvmvXWyc1U4fiMGu/+NwPHgGOSqiv+JMzE0gL1SDgdLUyjkRjAyNICJoQGMDGUwNjR4/JCeGxnKpHUGBjA0AM6HxuPMrVh1eyYTIwP0bGSHQa1qoWsD20Krn36+EIb5v11Ddq5AY0dLbBzZptTB5YuuQgOdyoSBDhG9aHJVAt8cv4U1/4QgVyVQq7oZ1rzZEm1c9FuaEBiegG+O38LRoAfqZd4NbDGpe129H+tWTDJ2/xuBfZci1PM3AVI3ayelGRyUpnBQmsJRaQoHpRkcLPOem8Jax15l0YkZ+C3wPvZduo/gB0/aMFlXM0H/Fk54tVVNNK+lhEwmQ3auCkv+CMK2s/cAAK80c8RnbzSHuQkbcZdWuQY6p0+fxoYNG3D79m3s2bMHNWvWxPbt2+Hm5oZOnTrpmnyZYqBDRC+S+wnpmL4zEBfuxgMABrR0wpKBTWFZhsP234hOwrrjt/HHlUh1yUcHd2u808kdzWspYWsh16oGIDkjG39eicKuf8MR8LgBNQDYKEzwWutaeL1NLdS1U5Rb7YIQAkFRSdh/6T5+DYxEbEqmel0d22oY1LoWToc8xLk70ns/s3d9TPSuWylqP55H5Rbo7N27FyNGjMCwYcOwfft2BAUFwd3dHevWrcMff/yBgwcP6pJ8mWOgQ0Qvit8vR+LD/VeRnJEDhdwISwY2wautapXb8UNjU/HtidvYFxChOYmkqRHq2CpQx1aBunYK1LGthrp2CtS2Ns9XjSaEwIXQeOz+NwIHr0YhPVsalNbQQAbvBnYY7FEL3g3tKrzHUk6uCr63YrHv0n0cCYpGRrZKva6aiSG+fLMVejW2r8AcVn7lFui0atUK06dPx8iRI2FhYYHLly/D3d0dgYGB6NOnD6Kjo3VJvswx0CGiqu5hciZWHrqBPf4RAICWzlb46s1WWvcU0lVkQjo2nb6D4zdiEBafhsKa0RgbyuBSoxrq2ipQx64ajA0N8GvAfY0Rg+vYVsNgD2e82rom7Cyezy7tyRnZ+OtaNH4NuI/UrFx89npz1Le3qOhsVXrlFuiYm5sjKCgIrq6uGoHOnTt30LhxY2RkZOiSfJljoENEVVXEozRsOnUHOy+GIzNHBZkMmORdF1N61KvwEo88mTm5uBubhtsPU3ArJkX9987DVHVpzbOqmRiiXwsnvOHhjNa1rVj184IqtykgHB0dcevWLbi6umos9/X15Tg6REQV4FZMCr49eRu/BtxXzzLdwtkK815u9Nx1X5YbGaKBgwUaOGiWcKhUApGJ6bj9MBW3Y1Jw62EKEtKy0L2hPV5u5sDGu1RiOl8p48aNw9SpU/HDDz9AJpMhMjISZ8+excyZMzF//nx95JGIiErg2v1ErDtxC39di1aPDdOxbg1M7FYXnnVqVKqSDwMDGWpVN0et6uboWt+2orNDlZjOgc6sWbOQmJgIb29vZGRkoEuXLpDL5Zg5cyYmTZqkjzwSEVERLoTG45vjt3Dy5kP1sl6N7TGhWx20ql29AnNGVPH0No5OWloagoKCoFKp0LhxY/X8V887ttEhospICIETNx9i3fFbuHhXGonYQAb0b+GE97rVzVcVRFTVlFsbnTzm5ubw8PDQV3JERFSA1Mwc/HklClvP3sX1yCQA0si+r3vUwvgudSqsJxXR80rrQOf8+fOIj4/HSy+9pF62bds2LFiwAKmpqRg4cCDWrl0LuVyul4wSEb2ohBC4FJaA3RfD8ceVSKRmSb2RzE0MMax9bbzT2R32nC2cqEBaBzoLFy5Et27d1IHO1atXMWbMGIwePRqNGjXCZ599BicnJyxcuFBfeSUieqHEpmRi36UI7P43ArdiUtTL3WyksWPebOuM6tVMKjCHRM8/rQOdwMBALFmyRP16586daN++PTZt2gQAcHZ2xoIFCxjoEBGVQk6uCqdCHmLXxXD881+Munu4mbEhXm7miCFtndHWtXJMmkz0PNA60Hn06BHs7Z8MX33y5En06dNH/bpt27YIDw/XLXdERC+Ie3Gp2P1vOPb4R+BB0pM5klo4W2GIhzP6tXCERRnOR0VUVWkd6Njb2yM0NBTOzs7IysrCpUuXsGjRIvX65ORkGBvzQ0lEVJTkjGzM/+069gfcVy+rbm6MV1vVwpC2zuw9RaQjrQOdPn36YM6cOVi5ciV+/fVXmJubo3Pnzur1V65cQZ06dfSSSSKiquja/URM+ukS7salQSYDOtezxRAPZ/RsbAe5kWFFZ4+oStA60Fm6dCkGDRqErl27QqFQYOvWrTAxedIo7ocffkDv3r31kkkioooUHp8GU2ND2FropxepEAI/nruHJX/8h6xcFZyUplj7Viu0cXm+pmcgqgp0HjAwMTERCoUChoaadx/x8fFQKBQawc/ziAMGElFhkjOy8cWRm9h29i6MDA0wooMLJnSrgxoK7QOepIxszNl7BQevRgMAejayw+dvtICV+fP9XUn0vCm32csrOwY6RPQsIQQOX4/GwgNBiE7K0FhXzcQQb3dywzud3aE0K107xMvhCZj08yWEx6fD2FCG2X0aYkwnN/agItICA50SYqBDVDpCCAghTbpYFUU8SsPCA9fx938xAIDa1uZYOrApBIDPDwfj6v1EAIDSzBjjurpjtJdrsTNpCyGw+cxdrPjrP2TnCtSqboav32qNls5WZXw2RFUXA50SYqBDVHLXIxMx6acAmJsY4scx7avUYHU5uSpsPnMXq47eRHp2LowNZRjXpQ4mda8LU2Opaj6vpOfzIzfVA/jZKOSY3L0u3mznXGAD4oS0LHyw5wqOBj0AAPRp4oCVrzcvdWkQEWlioFNCDHSISubw9WhM2xmI9Gxp+oH2btbYPqY9TIwMKjhnugsIe4QP91/Df1HS3FFtXatj+avNUM++4K7duSqBXwPu48t/biI8Ph0AUNPKDFN71sOgVjVhZCi9J5fCHmHyTwG4n5AOE0MDzHulEUZ6urCqikgPyiXQyc7ORu/evbFhwwbUr19f22QqFAMdoqIJIfDtyTv49PANCAG0c7NGUGQSUjJzMNijFla+1rzS/nAnZWTjs0PB+PH8PQghVUd9+HJDvNHGuURVc1k5Kuz6Nxxr/wlBTLI0yJ+7bTXM6FUfkQnp+PRQMHJUAi41zPH10NZoVktZ1qdE9MIotxIdW1tb+Pn5oV69erokU2EY6BAVLjMnFx/uu4a9lyIAACM6uGBBv8Y4HRKLMVsvQiWAD19uiHe7VK4xs4QQ+PNqFBb9HoSHjwOUQa1q4sNXGsFGix5V6Vm52H7uLtaduI2EtGyNda80d8Qng5pxVGMiPSu3QOf999+HsbExPvnkE12SqTAMdIgKFpeSiXHb/fHvvUcwNJBhQb/GGOnpql7/vW8olvwRBJkM2DjCA70a2xee2HMgIzsX1yOTcCUiAX//9wBnbsUBkCbIXDawKbzq2uh8jOSMbHzvG4rvTociK1eF+X0bY1j72pW2xIvoeVZugc7kyZOxbds21K1bFx4eHqhWrZrG+lWrVumSfJljoKM/v1+OxL24VLzZrrZWd8Wku8S0bPx2+T6a1VSipbOV1j+wNx8k4+0tFxHxKB0Wpkb45q3W6FLfVmMbIQTm/XoNP50Pg7mJIfaM90Jjp+fjM5SrEgiJScaV8EQERiTgcngCgqOT1RNkAoCJoQHe61YH73Wro25srC8pmTnIzM7VabwdIipauQU63t7ehScuk+HYsWO6JF/mGOjoxw++oVj8RxAAaZblEZ4ueLeLOwOecvR30AN8uP+quq1IXTsFBnvUwqutapVqRN/jwTGY/FMAUjJz4FLDHN+P8kBdu4Ib5WbnqjB68wWcuRUHJ6Upfp3UEXYWplqfQ3pWLj49fAMHr0bBzNgQSjNjWJoZQ/n4YWX+5HneOiszE5gYGeBGdBIuhyfgcngirkUmIi0rN1/6NgoTtKhlhea1rNC/pRPcbKoVkAsiqgzY66qEGOjobvOZUCz6XQpynK3N1L1QzIwNMbxDbbzbpY7ehs6n/BLSsrD49yDsezwppKPSFPGpWcjMUQEADA1k8G5gh8EeteDd0A7GhgX3khJC4Iczd7HszyCohNSr6tvhbYrtQp6Ylo1X153BndhUtHS2ws53O2hVQhIQ9gjv776MO7Gppd63INVMDNGslhItnK3QopYVWjhbwUlpymokoiqiXAOd06dPY8OGDbhz5w5++eUX1KxZE9u3b4ebmxs6deqka/JlioGObrb63cWCA9cBABO962Bm7wY4EfwQX/4TgsvhCQAAU2MDDG/vgne7uut0t0/5HX1civMwORMGMuCdzu6Y0as+snJV+P1yJH75NwKBj/8PgFSi8WqrmnjDwxn1n+o6nZ2rwvzfruPnC2EAgCEezlgysGmJu46HxqZi4DdnkJiejf4tnLDmzZYlDiiyclRYeywE3xy/BZUA7C3lWNS/CWoo5EhMy0ZievGPtMwc1LVToPnjgKZFLSXcbRUwrKKDGhJROQY6e/fuxYgRIzBs2DBs374dQUFBcHd3x7p16/DHH3/g4MGDuiRf5hjoaG/b2buY/5sU5LzXrQ5m+TRQ/7gJIXDi5kOs+TtE/UMrNzLAsPYuGN/VHXaWZR/wpGTm4PC1aHjVrQFHpVmZH688PUrNwqLfr+PXwEgAUpfmz15vgTYu1fNtG/IgGb/4R2DfpfuITclUL2/hbIU32tRC1/q2mLXnCs7eiYNMBsx7uZFW0xL43Y7FyO8vIEclML1nfUztWXxPzJsPkjF9VyCuR0rj1wxo6YTF/ZtCac4eSkQVKjMZSIx4/Ah/8jwpEnBuB3SbCxhW7Oe03AKdVq1aYfr06Rg5ciQsLCxw+fJluLu7IzAwEH369EF0dLTWaZ86dQqfffYZ/P39ERUVhf3792PgwIHq9UIILFq0CBs3bsSjR4/Qvn17fPPNN2jSpEmJj8FARzvbz93Dx79eAwCM71oHs/s0KPCHUQiBUyGx+PLvmwgISwAgBTxvta+N97rWKZOAJ1cl8Mu/4fj8yE3EpmTCzkKOXeM8q0x7jMPXozFv/zXEpkilOGO7uGN6z/rFVhdl56pwIvghfvk3HMduxGg0zAWkqp6vhrZCj0ba9576+UIY5u67CgBYO7QV+rVwKnC7XJXAD76h+OxIMLJyVLAyN8aygc3wSnNHrY9NRKWUmwOEHAZibz4V1DwObDISi97XrQsweBtglv/mqryUW6Bjbm6OoKAguLq6agQ6d+7cQePGjZGRkVF8IoX466+/cObMGbRu3RqvvfZavkBn5cqVWLZsGbZs2YL69etj6dKlOHXqFIKDg2FhUXDjyWcx0Cm9H8/dw0ePg5xxXdwx56WGxd79CyFw+nHAc+mpgGdou9oY5eWqtyDkdMhDLPvzP9yITgYgtU/JVQk4WJpi57sd4FqJg51HqVlYcOA6DlyWSnHq2inw2evN0ap26b9oYlMy8WvAfez+Nxw3H6SgppUZvhvlgUaOun8GlvwRhO99QyE3MsCucZ755nMKj0/D+7sv48LdeABA94Z2+GRQs3Ip5SOix0JPA4fmAA+uFb6NqRWgdAaUtZ48DE2A48uArBTApj7w1i7A2r3csv20cgt06tSpgw0bNqBnz54agc62bdvwySefICgoSJfkn2RUJtMIdIQQcHJywrRp0zB79mwAQGZmJuzt7bFy5UqMGzeuROky0Cmdn86H4cP90h372M5u+PDlRqWq4hBCwPdWLL78OwT+9x6pl3esWwNvtXNBr8b2Wk0pEPIgGcsP/ofjwQ8BSCPcTulRD680c8SI788jJCYFjkop2HGpUfmCnUPXovHRr1cRm5IFAxkwrmsdTO1RT+du0UII3H6YAgelGRTyoiemLKlclcDYbf/i2I0Y2CjkODCpI5yszCCEwK6L4VjyRxBSs3JRzcQQH/dtjCFtndlAmKi8JIQBRz4Cgn6TXptaAfV9ngpo8v7WBOSFFBhEXwV+GgIk3QfMawBv/gTU7lBup5Cn3AKdTz/9FFu3bsUPP/yAXr164eDBg7h37x6mT5+O+fPnY9KkSbok/ySjzwQ6d+7cQZ06dXDp0iW0atVKvd2AAQNgZWWFrVu3FphOZmYmMjOftFNISkqCs7MzA50SeLpaYkwnN3z0SumCnKcJIXDmVhx+OBOK48ExyLsKbRRyDPaohaHtasPZ2rzYdGJTMvHl3zfx84Vw5KoEjAxkGOnpiimd7GF161fgxh/IkNfAt3dscCjRBSkWdfDz+E4lSrskHiZnIioxHe62Cr0FCnkS0rIQHJ2MH8+H4ffHpTj17BT47I0Whc96nRoH3DoK1O0JVNN9ADxtpWTm4PX1frgRnYxGjpZYP6w1Fv8RhGM3pBnB27la4/M3WqB2Df38H4ioGFlpwJkvgTNrgJwMQGYAtPkf4D0PqFaj9OklR0vBTlSgVMozYB3Q/A1957pI5drrat68eVi9erW6mkoul2PmzJlYsmSJrkmrPRvo+Pn5oWPHjrh//z6cnJ60A3j33Xdx7949HD58uMB0Fi5ciEWLFuVbzkCnaLsuhmH2XinIebujGz7uq32Q86yIR2nYeSEcu/4NVw/HL5MBXerZYlj72uje0E49SWKejOxcbD5zF98cv4WUzBwAgE9jO8xvk4Wat3cCV/cC2fm7KScLM/xnWB8NPHpCWb8jUMsDMC39/EO5KoHvfe/g8yM3kfW4G7ej0hR17RSoa6dAPTuLx38VxXbPTsnMQciDZNx8kIzg6BSExCQjODpZPR4OABjIpLZQUworxYkPBc5+AwT8COSkA9VdgVG/A1a1S31u+hLxKA0DvzmD2JQsyGSAENIgfTN96mNMJ3f2iCIqD0IA1/YCR+dLJTAA4NoZ6PMJ4NBUt7SzUoF97wI3/pBed5sLdJ0tfYGXg3IfRyctLQ1BQUFQqVRo3LgxFAqFPpJVKyzQiYyMhKPjkwaMY8eORXh4OA4dOlRgOi9qiU5KZg7++e8B5EYGqG9vAZca1Ur8Q7P7Yjhm77sCIYDRXq5Y0K9xmVQ1ZOeq8HfQA/x0IQynQ2LVyx0sTTGkrTPebOcMB0tT/H4lCiv/uoH7CdJ4Pe0cjbGy/g243fsFiL7yJEGb+kDLYdKHMfw8VBH/wiBf8CMD7BpJvQic20sPa/ciP6i3H6bgg18uq9saWZgaITkjp9Dta1QzQZ3HQU9dOwUsTY0REpOCkAfJCH6QjIhH6YXuW6u6GRo7WmKid120KKgU574/cOYr4L8DgJACLhjKgdxMqQh61IEKqz8HAP97jzB00zlk5ajQ2NESq4e0RAOHkrWfIyIdRV0G/poDhPlJr5W1gd5LgMYD9BeMqFTA3wsAv6+k180GA/3XAsZl3+auQgYMzEuqLH4E9VV19ayq3kYnPD4NW/3u4sjF65iq2oIIYYcfc3oiycgade0UaGBvgfoOFuq/zw6o9su/4Zi1t+yDnGfdjU3FzxfDsOffCMSlZgGQSjWcrc1xLy4NgEB3iwjMd7oAl8hDkOUFMIZy6UPs8T+gtqfmh1mVi9g7gdi2exdc06+jvVEIaooH+Q/u1Bp49VvAtoHG4ryeQp8fCUZmjgoKuRE+eqURhrR1RmJ6Nm7FpKgfIY//5gVjxbGzkKOBgwXq21ugvr0C9e0tUM/eouDqMJVKqp468xVwz/fJ8ro9Aa/JQI16wLb+QNwtwMJJCnZs9DTpbmwIsH+81PW0Xi+gwUuAcwfAsPBqO/97jxDyIBmDWtfSqv1ViaTFAyYKwKjo0rNykZ0O7B4JPLoHvPK51DuFXly5OUD0ZeCuL3D3jHTj5dZF+rw6tQIMyuAzkRoLHFsC+G8FIAAjM6DTdKDjFMC4jIba8N8C/Pk+oMqRvhPe3FHm1eflGuh8//33WL16NUJCQgAA9erVw7Rp0/DOO+/omrRaYY2Rp0+fjlmzZgEAsrKyYGdn98I3RhZC4EJoPH44E4qjQQ9gIHLwo8kKdDD4DwCQJQzxu8oLP+T0wXXhprGvQm6E+vYKNHCwgIWpMTadvgMhgJGeLljUv0m5NxrNzMnF4esP8NP5ezh3Jx4KpOENk3N4z+I07FKDn2xoUx9oMxpoMRQwty4yzajEdLy58RzuxaWhpXUWNvcQqB4XAIRfACIvAblZgJEp0HMh0G4cYGCA2w9TMGvPFXUD6s71bPDJa81R06roL420rBzcjknFrYfJUgD0IAXJGdLgdnkBTX17i2KrtwAAOZnA1V8Av7XAwxvSMgMjoNkbUoBj/9SwCskPpGDn4Q2gmp0U7Ng1Kv4YRbn+K/DbJCArWXO5qZUU9NTvI315m1npdpySUKmk0qzgP4Ebf0rdYwGpYaSFE2DhAFg6AhZPPxwASyfA3KZsflwAqZpg7xipqgAAIAM8JwLdPy6XO1x6DuTmSCUpd08D984A987m/8zkMa8B1OkO1O0l/VXYFrxdSahygYR7QPBfwImVQObj7uFNXwN6LZYaGJe128eB3aOkY1d3Bd76BbCtX2aHK7dA5+OPP8bq1asxefJkeHp6AgDOnj2Lr7/+GlOnTsXSpUu1TjslJQW3bt0CII3Xs2rVKnh7e8Pa2hq1a9fGypUrsWLFCmzevBn16tXD8uXLceLEiRe2e3lmTi7+uByFH86EqgdgA4ANtr/AJ3k/hIkFZHYNgYiL6nX3la1xsNqr2JfSDCGx6fnGVgGA4R1qY8mAphXXMyYpCrh1FCnX/oLpveMwyn1cSlJU6U0xIhOkYCcsPg1uNtWw890OsLc0lY7120Tg9j8AAOHaBT87zcGiU0n5SnHK7f1ITwD8NwPnvgVSHo9LZWIBeIwG2r8n9Y4oSGossG0g8OCq9IU68jfAoVnpj5+bLdXvn1snvXbpKAWVt/4GQo4A6U96z8HASPpfNHhJCnxq1Cn98QqTkwmEnpICm+CDQEoBpXElYWAkBT7t3pUCRH3+H48vB06ulI7R4CXgv9+l5XaNgUEbtXv/SXs5mYBRGU8/k5v9JLC5ewYIOyt1vX6aqVL63Lh2AkyqAbf+Ae6cADKTNLdzbCndNNTtCdT0KLikNDNZKlmNDZEC/LjHz+NuSTdpeRyaAy+tBFy89H3GRXsYDOx4Qwq6TJXA4O2Ae9cyOVS5BTo2NjZYu3Ythg4dqrH8559/xuTJkxEbG1vInsU7ceJEgZOGjho1Clu2bFEPGLhhwwaNAQObNi15A6uqEOjEpmRix7kwbD93Tz3yramxAQa1roUpNf6Fw7Fp0oZDdgCN+gIR/wLn1gNBv0rFjABgVRs5bcfhrvOr+O+RDDcfN45t5GiJKd3rwaA8G46qcqU8hhyRHk+3uwFKVXpTlPsJ6Riy4SwiHqXD/XGwY2dpKt2V//s9VIc/gkFOOpKEGRZkj0as+0B88nqLYktx9CI7A7h9TPqh/O/Aky9OC0egw3vS+ZekEXVaPLD9ValnhKkVMPJXqbi8pBLvA3v+B4Sfl157TQF6LHjyBZybA0RcAG4eAoIPAbHBmvvb1Je6rrp1BRR2UsBlblPy0o30BCDkqNTY8dbfmj8gJhbSj0LDV6QfBlUukBwp9QZJevw3OeqpRzSQEgPgqa+8rrMB7w9L/n4U5cpuYN9Y6Xn/r4HWI6S76wOTgdSHUs+U7h8BnpMAA/3Olk4FuLQd+GOa1PD2pZX5qqJ1FnsLOL5Uuj4LDGw6SYGNayeptPXZ/3lutnTTGXJUuraf/Z4zVQLu3kDN1kBCuBTUxIZI13hhjEylauq27wCtRlTcdZYaC+x8S/reMDAC+q4GWo/U+2HKLdCpXr06Lly4gHr1NNsA3Lx5E+3atUNCQoIuyZe5yhzoBEUmYfOZUPwWGImsXKkhqoOlKUZ6uWBo29qonhgE/OAjdSXsMgvoPk8zgcT7wMXvpNKCvLtyEwug1XCg/bvl24g1Lf5JCcGtvzVLCSADarYB6vWWfticWuntLjw8Pg1vbjyH+wnpqGNbDT+/2wE1qsmx+Uwodh8+gZUG36CVgVSqKBr1h6zvl9p1xSyJzGTp/P/7Hbh5RLPXmG0jqfSh2Rulb4eSngDseF36UpUrgeF7Aee2xe93+ziw9x0gLVbab+A6KVAuSvwdKeC5+Rdwz+9JIP0s42rS+5gX+Jg/fp63LDtDSuOur2YaCgeg4ctScOPaufR367nZUrBzZRfwz+Pel13nAN5zS5fOs8LOAVv7SXfUHadKVQV5Uh4Cv0+RSqEA6c7+1W8rtEdclXfPT/p/5F07BkZA+/FSYGuq4/d8Wjxw8lPg4qYn6ZtaSQFNXqlNQYFNcZKjpZKeW39LNzkZCYVvW81Ouomwqff4b33Apq7UAeF5CaKzM6TS8Wt7pNdDdwEN+uj1EOUW6EyePBnGxsZYtWqVxvKZM2ciPT0d33zzjS7Jl7nKGOjkqgQ++es/bDodql7WwtkKYzq54aWmDtLs1KmxwMZu0lDe9XyAoTsLb5eQlSZ98Z9b/9QduUwqeu84DajdvmxOJDECCPxZ+nG//++TXkOAdDdTt6cU3NTpoVvddTHC49MwZMNZRCZmoJ6dAkozY/z7uC1OlzrVsbb2CSjPfyF9qVWzAwZ8LZVS6ENavPQD+N/vUmCR+6RHICxrAo36AY36S8XPugR3mcnAjsFS7wsTBTDsl8KLtFUq4PQX0uinEFJ1y+BtpQ98MxKlL+6bh4Doa0BanPRQZZcuHduGQIOXgYZ99dt402+tNHAaIHWL7TZHu3TiQ4Hvekjn1rCvVFT/bB6FAC5tAw7NlQJYuSXw0qdAizfLrSvuCyMhDNjoLQXoDV4BIJ4EmdXsgF6LgOZvlv46ys2WbgxPfPIkCKnnA3SbDTjquVFxbo7UXjDkqFQ1Vd1V6mSQF9BU4LQLpSIEcGIFEHVFapys5yCsTAOdGTNmqJ/n5ORgy5YtqF27Njp0kEZGPHfuHMLDwzFy5EisXbtWi+yXn8oW6CRnZGPKzwHqEYBfae6IMZ3c0PrpaQByc4DtA6U6Y+s6wNhjJWsgKoR0J3FuvdSrJ0/zN6U7VAvt50DSkJMpdUU89YU05kse+6aPS216A7XaFtmTR9/uxaXizY3nEJUojQVVzcQQ815pjKHtHrfFiQwE9o970gi49SjAZzkg12IYhaQoqSrmvwNSnb7IfbLOug7QuL8U4Di11u+PYFYq8PObUjsXY3Mp+H227jwtXjrPkCPS61YjgJc/019PDSGkdglpcdLghmmxj5/HPgmE0uKkHxX3blLJjT7b+TzrzFfA0Y+l597zgK6zSrd/egLwfW/pBsGxBfC/v6Q2GIWJvwPsGydV9wFSG7O+X+pUBUtPyUqVSrGjr0ptVN4+DJiYSwHDX7OB+NvSdrXaAS9/WrJqXCGkKsijH0vtYACpzZXPMqkBMRVPlVsmJU1lGugU1G6mwMRlMhw7dqy0yZersgp09vhHID41E//r6CaVsOhBWFwaxmy9iJCYFMiNDPDF4Bbo27yASRMPfQic+0a6c3/nH8CuYekP9vAm4LcGCNgBQEh3oN7zpLpfXQKQkKPAX7OkL3xA6obYcqjU66CwRrXl5G5sKib+dAkOlqZYNKAJalV/ZtTe7HTgnyXSewtId1mvbtAc+jw3+0kbkaT7j9uKRD15nhQplbI9zb6ZFNg07i+VXpTlHX52OrBruFQ8bmQq3WXV7Smtu39J6jGRGCate+ULqRqzqvP9UhoHBAC8PwK6flCy/XKzpUaXd45LPb3GHpN6ehW7Xw5wZrVUMqDKkarjBn7z5P+gL7k5wKO7UhD28IZUVV23h1Q6VhVLkYQAfhkttT2sZguMPQ5YOT9Zn5MpNag/+dnjamGZ1G6kx4LCq6OjrwKHP5RuDgApXe950g1AOd6IUcEqZBydyqgsAp1HqVno9vkJJKZno6GDBZa92hRtXHS7Yzt3Jw7v/eiPR2nZsLeUY9NIDzSvZZV/w6cbRA7eLv146iLCHzj4PhAZIL22bwq8/Dng4lm6dB7dk74w8kbQVDgAvZcCzV6vfF+6oaeAXydIAYvMQGowmP5ICmJSHkCjsWtharV7XC3Vt/wH9MvJlAKam39JDWQHb5MCsUNzpTYm1d2kZY7NyzdfFcl3NfD3Qul594+ALsUEO0IAf84A/v1BKh17+5BUolMakQHSqLJ5XeNbDpfSMKv++GEl/TW1kqpyC/thzckE4m5LwUzsTenvw8e9cZ7uhZOnTnegz8oy7fZbIU59BhxbChgYS6OCF/YdlRQp9SK8+ov02lQpBbgebz95j5MfSOPQBPwIQEg9PD0nAJ1m6N7Gh/SGgU4JlUWgo1IJ7LkUgRUH/8OjNKk9wpttnTG7T8OSjZfyjJ0XwvDRr9eQoxJoXkuJjSM84KAsoNdK1GXgex+pOqjzTKDHx7qeikSVC1zaCvy96EnddIu3pLpuhV3R+2ZnSNVUp794PL+KodRrSB+NAitSRqI04ujln/KvMzCW7uwta0q9pCydpOd5f63dKnQeKgBATpY03st/BwDIoA7OGvaVGh1rMS1GpXd61ZMGyt0/BrrMLHzbc+ulmZ8hkyY0bPiydsfMSpMCrAsbit9WbqkZ/BiZSlUx8aGa1Z9PMzKTGqzaNpSq1AJ3SMGPgZH0Oewyq3J/DvPc+FPq5QMA/dZIvRKLc88PODhLGn4BkG7iei+RSjZ9Vz/pSdXkVWlMrequZZBx0kW5BjoZGRm4cuUKYmJioFKpNNb1769jiUIZK7M2Ooc+RGbqI5yNEjgXJfAIFsiRW6Fv+ybo1rIBZOY1pHp5Q+NCk8jJVWH5wRv44YzU6Lhvc0d89noLmJkUUNeZGve48XGYVA301i7914mmxgH/LJQaVQJST5zu8wCPMQXfbd48IlVTPXrcaNq1s9TeQ9eB654noaekcSMsnZ4EMmU5IJ0+5eZI7XGu7ZEC0F6LpK7Pla2ETZ9OfwH887jHVI/5QOf3829z87DU1kmopFJJr8m6H/fOSeD6PqlkMP2R1PYnPUF6Xthgc0+TW0rdp20aSH9tG0olNsramtdi3G2pZPXm4ylyFPZS+7vmQyrv//1BEPB9LykwaTtWGo26pFS5UqncsaX5ezk5tQb6rKiQWbmpZMot0Dl06BBGjhxZ4Hg5MpkMubmF3Gk8J8os0FndNH9bjIKYWADm1QEza+nuv0EfoFF/JBlYYPJPATh5U2p0PL1nfUzpUbfgQepyc4AfBwGhJ6Vqh3ePl22r/Ih/paG+owKl1/bNpC+XvC+ER3elapC8ng4WjtIPQtPXKu+XaVWlypWqO+0alm58nars1OdStQUgtd/o/KTzBaKvSY1ds1KkBun91pT9NZ2bLZUg5gU+GY//ZqVKpQy2DaVRn0uTj5tHgEOzn2or117qBebUUv/5L0tp8cAmb+k7x7UzMGJ/kTePhUqNezxlwhbphqXnQqDp65XjhuUFVm6BTt26deHj44P58+fD3l5PvXLKUZkFOpe2S6PYpj0C0uOhSotDzIMoZCTGQolkKJEKA1nBb70wMMZZg1b4Oa0dfA09sPSNDnileRGNHI98JHWVNa4GvPM3YN9Yf+dRGFWu9KXwz+Ind0Ith0ljg/iulqqp8orHu84G5JzIkSqRvPYegPSj12m61Mh8Uw8gKUIaAHH4Xu1+VJ8XOZnSjPenPgOy0wDIpCqfHvNL3gssN0cqsX1wHYj5TxrXqG4PqcdTmQeAT93gWbkA757QvfdaSoxUbVvWoymTXpRboGNpaYmAgADUqVOGXUDLUHl3L494lIaFB4Jw7L8oWCIVjZTZeL+zLTxsAcRcR+ql3aj26IZ6e5WRGQwaviI12q3TI/9gcVf3SG0tAOCNrUCTgWV+DhpSY6U2BgHbNZe7dpYaLWvT44voeXDyM2nkW0BqrBp8UBrbpEY94J2jlWcsk+Ik3pe6TufNz2VWXWqQ3eZ/T6q/hZB6Dz4IAmIeBzUPrkvVtk+P/ZRH4SAN7lmvtzRMQFm0A/prNnD+28c3eEc153qjF0K5BTpvv/02OnbsiDFjxuiSTIWpqHF0jlyPxsID1xH5eNwWnyb28HCxxspDN+AmwjHWyh+vmZyDYeK9JzuZWknjbjR7XRqBMyYI+K6X1Pi40wyg54Jyy38+4RekxpmpD6U74CaDWE1Fld/JTx8PnPiYmTUw9p/y7ylXHu76So1zY65Lrx2aSVVaD4Kk75rCRuo1Npeqz+waS1Vqd05ojuptYCz1gMobI8umvu7fDZe2AwcmSc+H/Cj1YKQXTrkFOmlpaXjjjTdga2uLZs2awdhYsyh3ypQpuiRf5ipywMDUzBx89U8IvvMNRe5Tk2n2a+GEz15vDlMjA6kHwLU9wLV9TyZ0BKR2L0JIy+r0kEa6fR6G/haCAQ5VLSdWAieWSz/YI38DXDtWdI7KTm4O8O/3UnCXkai5TmYI1KgrdSawbyIFNnaNpHaBT7dlycmUZu0OOSo13M4bpC+PlcuToMetc+kHoww7D2x5RRphu9uH0sjE9EIqt0Dnu+++w/jx42FmZoYaNWpoNJaVyWS4c+eOLsmXuedhZOQb0Un4aP81BIQnYFqPepjUvYBGx6pc6Y7r2h4g6MCTu6vqrtLAWBxZlajshByVBourbI11tZUaC5zfILW1ywtqbOqXfDLWp8Xdlt6/kMPSd9jTY/vIDIHqLo+nN6gnBVI29aTXCrv8N02JEdL0Dqkx0tQob2xlg+EXWLkFOg4ODpgyZQrmzJkDg0p4wT0PgQ4ACCGQlpWLavISjLaZkwXc/ke6a2rzv7IdIp+ISF+yUqUhGW4eloKfpIjCt5VbagY+NnWlUayjAqWenmMOFz3dBlV55RboWFtb4+LFi2yMTEREJSeE1JMtLgSIDZHmkYoNkV4nhGlO8vs08xpSDyvO/v7CK+nvt86TdYwaNQq7du3Chx9+qGtSRET0opDJHo8g7gi4ddFcl5MpjfGTF/jE3pL+ZiQC/b5ikEOlonOgk5ubi08//RSHDx9G8+bN8zVGXrVqla6HICKiF4mRXGroXJVGUacKo3Ogc/XqVbRqJY2oeu3aNY11BY7iS0RERFROdA50jh8/ro98EBEREemdXrpJnT59GsOHD4eXlxfu378PANi+fTt8fX31kTwRERGRVnQOdPbu3QsfHx+YmZnh0qVLyMyUhgNPTk7G8uXLdc4gERERkbZ0DnSWLl2Kb7/9Fps2bdJoiOzl5YVLly7pmjwRERGR1nQOdIKDg9GlS5d8yy0tLZGQkKBr8kRERERa0znQcXR0xK1bt/It9/X1hbt7FZz4joiIiCoNnQOdcePGYerUqTh//jxkMhkiIyOxY8cOzJw5ExMmTNBHHomIiIi0onP38lmzZiExMRHe3t7IyMhAly5dIJfLMXPmTEyaNEkfeSQiIiLSis5zXeVJS0tDUFAQVCoVGjduDIVCoY9kyxznuiIiIqp8ym2uq7CwMDg7O8Pc3BweHh751tWuzTlJiIiIqGLo3EbHzc0NDx8+zLc8Li4Obm5uuiZPREREpDWdAx0hRIFzWqWkpMDU1FTX5ImIiIi0pnXV1YwZMwBIE3d+/PHHMDc3V6/Lzc3F+fPn0bJlS50zSERERKQtrQOdgIAAAFKJztWrV2FiYqJeZ2JighYtWmDmzJm655CIiIhIS1oHOnmzlv/vf//DV199BQsLC+R14CqoKouIiIiovOncRmfz5s3YvXs3mjZtClNTU5iamqJp06b47rvv9JE/IiIiIq3p3L18/vz5WLVqFSZPngxPT08AwNmzZzF9+nTcvXsXS5cu1TmTRERERNrQecBAGxsbrF27FkOHDtVY/vPPP2Py5MmIjY3VKYNljQMGEhERVT4l/f3WueoqNzc330CBANCmTRvk5OTomjwRERGR1nQOdIYPH47169fnW75x40YMGzZM1+SJiIiItKZzGx0A+P7773HkyBF06NABAHDu3DmEh4dj5MiR6vF2AGDVqlX6OBwRERFRiegc6Fy7dg2tW7cGANy+fRsAYGtrC1tbW1y7dk29HbucExERUXnTOdDJG0+HiIiI6HmjcxsdIiIioueVXgKd06dPY/jw4fD09MT9+/cBANu3b4evr68+kiciIiLSis6Bzt69e+Hj4wMzMzMEBAQgMzMTAJCcnIzly5frnEEiIiIibekc6CxduhTffvstNm3aBGNjY/VyLy8vXLp0SdfkiYiIiLSmc6ATHByMLl265FtuaWmJhIQEXZMnIiIi0prOgY6joyNu3bqVb7mvry/c3d11TZ6IiIhIazoHOuPGjcPUqVNx/vx5yGQyREZGYseOHZg5cyYmTJigjzwSERERaUXncXRmzZqFxMREeHt7IyMjA126dIFcLsfMmTMxadIkfeSRiIiISCs6z16eJy0tDUFBQVCpVGjcuDEUCoU+ki1znL2ciIio8inp77de5roCAHNz8wJnMSciIiKqKFq30Tl//jz++usvjWXbtm2Dm5sb7Ozs8O6776rH1CEiIiKqCFoHOgsXLsSVK1fUr69evYoxY8agZ8+emDNnDn7//XesWLFCL5kkIiIi0obWgU5gYCB69Oihfr1z5060b98emzZtwowZM/DVV19h9+7deskkERERkTa0DnQePXoEe3t79euTJ0+iT58+6tdt27ZFeHi4brkjIiIi0oHWgY69vT1CQ0MBAFlZWbh06RI8PT3V65OTkzWmhCAiIiIqb1oHOn369MGcOXNw+vRpzJ07F+bm5ujcubN6/ZUrV1CnTh29ZJKIiIhIG1p3L1+6dCkGDRqErl27QqFQYOvWrTAxMVGv/+GHH9C7d2+9ZJKIiIhIGzoPGJiYmAiFQgFDQ0ON5fHx8VAoFBrBz/OIAwYSERFVPuU2YKBSqSxwubW1ta5JExEREelE50k9iYiIiJ5XDHSIiIioymKgQ0RERFUWAx0iIiKqsrQOdJKSkkr0KEsLFy6ETCbTeDg4OJTpMYmIiKjy0LrXlZWVFWQyWaHrhRCQyWTIzc3V9hAl0qRJE/z999/q1892cyciIqIXl9aBzvHjx9XPhRB4+eWX8d1336FmzZp6yVhJGRkZsRSHiIiICqR1oNO1a1eN14aGhujQoQPc3d11zlRphISEwMnJCXK5HO3bt8fy5cuLzENmZiYyMzPVr8u6eo2IiIgqTqVujNy+fXts27YNhw8fxqZNmxAdHQ0vLy/ExcUVus+KFSugVCrVD2dn53LMMREREZUnnaeAyGNhYYHLly+Xe4nO01JTU1GnTh3MmjULM2bMKHCbgkp0nJ2dOQUEERFRJVJuU0A8rajGyeWhWrVqaNasGUJCQgrdRi6XQy6Xl2OuiIiIqKJoHegMGjRI43VGRgbGjx+PatWqaSzft2+ftocotczMTPz333/o3LlzuR2TiIiInl9aBzqWlpYaJTjDhw/XS4ZKY+bMmejXrx9q166NmJgYLF26FElJSRg1alS554WIiIieP1oHOlu2bNFjNrQTERGBoUOHIjY2Fra2tujQoQPOnTsHFxeXis4aERERPQe0DnQMDAyKbZMjk8mQk5Oj7SGKtXPnzjJLm4iIiCo/rQOdffv2FRro+Pn5Ye3atdBThy4iIiIirWgd6AwcODDfshs3bmDu3Ln4/fffMWzYMCxZskSXvBERERHpRC8DBkZGRmLs2LFo3rw5cnJyEBgYiK1bt6J27dr6SJ6IiIhIKzoFOomJiZg9ezbq1q2L69ev459//sHvv/+Opk2b6it/RERERFrTuurq008/xcqVK+Hg4ICff/4ZAwYM0Ge+iIiIiHSm9RQQBgYGMDMzQ8+ePWFoaFjoduU5YKA2SjqENBERET0/ynwKiJEjR1b4lA9ERERERanUAwYSERERFUUvva6IiIiInkcMdIiIiKjKYqBDREREVRYDHSIiIqqyGOgQERFRlcVAh4iIiKosBjpERERUZTHQISIioiqLgQ4RERFVWQx0iIiIqMpioENERERVFgMdIiIiqrIY6BAREVGVxUCHiIiIqiwGOkRERFRlMdAhIiKiKouBDhEREVVZDHSIiIioymKgQ0RERFUWAx0iIiKqshjoEBERUZXFQIeIiIiqLAY6REREVGUx0CEiIqIqi4EOERERVVkMdIiIiKjKYqBDREREVRYDHSIiIqqyGOgQERFRlcVAh4iIiKosBjpERERUZTHQISIioiqLgQ4RERFVWQx0iIiIqMpioENERERVFgMdIiIiqrIY6BAREVGVxUCHiIiIqiwGOkRERFRlMdAhIiKiKouBDhEREVVZDHSIiIioymKgQ0RERFUWAx0iIiKqshjoEBERUZXFQIeIiIiqLAY6REREVGUx0CEiIqIqi4EOERERVVkMdIiIiKjKYqBDREREVRYDHSIiIqqyGOgQERFRlcVAh4iIiKosBjpERERUZVWJQGfdunVwc3ODqakp2rRpg9OnT1d0loiIiOg5UOkDnV27dmHatGmYN28eAgIC0LlzZ7z00ksICwur6KwRERFRBZMJIURFZ0IX7du3R+vWrbF+/Xr1skaNGmHgwIFYsWJFsfsnJSVBqVQiMTERlpaWZZlVIiIi0pOS/n4blWOe9C4rKwv+/v6YM2eOxvLevXvDz8+vwH0yMzORmZmpfp2YmAhAesOIiIiocsj73S6uvKZSBzqxsbHIzc2Fvb29xnJ7e3tER0cXuM+KFSuwaNGifMudnZ3LJI9ERERUdpKTk6FUKgtdX6kDnTwymUzjtRAi37I8c+fOxYwZM9SvExIS4OLigrCwsCLfKKLKJikpCc7OzggPD2e1LFUpvLYJkH7rk5OT4eTkVOR2lTrQsbGxgaGhYb7Sm5iYmHylPHnkcjnkcnm+5Uqlkh8YqpIsLS15bVOVxGubSlJAUal7XZmYmKBNmzY4evSoxvKjR4/Cy8urgnJFREREz4tKXaIDADNmzMCIESPg4eEBT09PbNy4EWFhYRg/fnxFZ42IiIgqWKUPdIYMGYK4uDgsXrwYUVFRaNq0KQ4ePAgXF5cS7S+Xy7FgwYICq7OIKjNe21RV8dqm0qj04+gQERERFaZSt9EhIiIiKgoDHSIiIqqyGOgQERFRlcVAh4iIiKqsKhPorFu3Dm5ubjA1NUWbNm1w+vRp9TohBBYuXAgnJyeYmZmhW7duuH79usb+mZmZmDx5MmxsbFCtWjX0798fERERGts8evQII0aMgFKphFKpxIgRI5CQkFAep0cvMF2v7Y0bN6Jbt26wtLSETCYr8Jp1dXWFTCbTeDw7hxyRvul6bY8bNw516tSBmZkZbG1tMWDAANy4cUNjG35vE0QVsHPnTmFsbCw2bdokgoKCxNSpU0W1atXEvXv3hBBCfPLJJ8LCwkLs3btXXL16VQwZMkQ4OjqKpKQkdRrjx48XNWvWFEePHhWXLl0S3t7eokWLFiInJ0e9TZ8+fUTTpk2Fn5+f8PPzE02bNhV9+/Yt9/OlF4c+ru3Vq1eLFStWiBUrVggA4tGjR/mO4+LiIhYvXiyioqLUj+Tk5PI6TXoB6ePa3rBhgzh58qQIDQ0V/v7+ol+/fsLZ2Znf26ShSgQ67dq1E+PHj9dY1rBhQzFnzhyhUqmEg4OD+OSTT9TrMjIyhFKpFN9++60QQoiEhARhbGwsdu7cqd7m/v37wsDAQBw6dEgIIURQUJAAIM6dO6fe5uzZswKAuHHjRlmeHr3AdL22n3b8+PEiA53Vq1frO/tEhdLntZ3n8uXLAoC4deuWEILf2ySp9FVXWVlZ8Pf3R+/evTWW9+7dG35+fggNDUV0dLTGerlcjq5du8LPzw8A4O/vj+zsbI1tnJyc0LRpU/U2Z8+ehVKpRPv27dXbdOjQAUqlUr0NkT7p49oujZUrV6JGjRpo2bIlli1bhqysLJ3PgaggZXFtp6amYvPmzXBzc4OzszMAfm+TpNKPjBwbG4vc3Nx8k3ja29sjOjpaPeFnQevv3bsHAIiOjoaJiQmqV69eYBp529jZ2eU7vp2dXb5JRYn0QR/XdklNnToVrVu3RvXq1XHhwgXMnTsXoaGh+O6773Q7CaIC6PPaXrduHWbNmoXU1FQ0bNgQR48ehYmJCQB+b5Ok0gc6eWQymcZrIYTGsuLWF6S4NEqaDpEuyuLaftb06dPVz5s3b47q1avj9ddfV5fyEJUFfVzbw4YNQ69evRAVFYXPP/8cgwcPxpkzZ2BqalpgGoWlQ1VXpa+6srGxgaGhYb7oPCYmBvb29nBwcACAQtcDgIODA7KysvDo0aMit3nw4EG+4z98+DDfXQeRPujj2tZWhw4dAAC3bt3SKR2igujz2lYqlahXrx66dOmCPXv24MaNG9i/fz8Afm+TpNIHOiYmJmjTpg2OHj2qsfzo0aPw8vKCm5sbHBwcNNZnZWXh5MmT8PLyAgC0adMGxsbGGttERUXh2rVr6m08PT2RmJiICxcuqLc5f/48EhMT1dsQ6ZM+rm1tBQQEAAAcHR11SoeoIGV5bQshkJmZCYDf2/RYRbWC1qe8borff/+9CAoKEtOmTRPVqlUTd+/eFUJI3RSVSqXYt2+fuHr1qhg6dGiB3ctr1aol/v77b3Hp0iXRvXv3AruXN2/eXJw9e1acPXtWNGvWjN0UqUzp49qOiooSAQEBYtOmTQKAOHXqlAgICBBxcXFCCCH8/PzEqlWrREBAgLhz547YtWuXcHJyEv3796+Qc6YXg67X9u3bt8Xy5cvFv//+K+7duyf8/PzEgAEDhLW1tXjw4IH6OPzepioR6AghxDfffCNcXFyEiYmJaN26tTh58qR6nUqlEgsWLBAODg5CLpeLLl26iKtXr2rsn56eLiZNmiSsra2FmZmZ6Nu3rwgLC9PYJi4uTgwbNkxYWFgICwsLMWzYsAK76hLpk67X9oIFCwSAfI/NmzcLIYTw9/cX7du3F0qlUpiamooGDRqIBQsWiNTU1PI8TXoB6XJt379/X7z00kvCzs5OGBsbi1q1aom33norX7dxfm+TTAghKrJEiYiIiKisVPo2OkRERESFYaBDREREVRYDHSIiIqqyGOgQERFRlcVAh4iIiKosBjpERERUZTHQISIioiqLgQ4RERFVWQx0iOi5J4RAz5494ePjk2/dunXroFQqERYWVgE5I6LnHQMdInruyWQybN68GefPn8eGDRvUy0NDQzF79mysWbMGtWvX1usxs7Oz9ZoeEVUMBjpEVCk4OztjzZo1mDlzJkJDQyGEwJgxY9CjRw+0a9cOL7/8MhQKBezt7TFixAjExsaq9z106BA6deoEKysr1KhRA3379sXt27fV6+/evQuZTIbdu3ejW7duMDU1xY8//lgRp0lEesa5roioUhk4cCASEhLw2muvYcmSJbh48SI8PDwwduxYjBw5Eunp6Zg9ezZycnJw7NgxAMDevXshk8nQrFkzpKamYv78+bh79y4CAwNhYGCAu3fvws3NDa6urvjiiy/QqlUryOVyODk5VfDZEpGuGOgQUaUSExODpk2bIi4uDnv27EFAQADOnz+Pw4cPq7eJiIiAs7MzgoODUb9+/XxpPHz4EHZ2drh69SqaNm2qDnS+/PJLTJ06tTxPh4jKGKuuiKhSsbOzw7vvvotGjRrh1Vdfhb+/P44fPw6FQqF+NGzYEADU1VO3b9/GW2+9BXd3d1haWsLNzQ0A8jVg9vDwKN+TIaIyZ1TRGSAiKi0jIyMYGUlfXyqVCv369cPKlSvzbefo6AgA6NevH5ydnbFp0yY4OTlBpVKhadOmyMrK0ti+WrVqZZ95IipXDHSIqFJr3bo19u7dC1dXV3Xw87S4uDj8999/2LBhAzp37gwA8PX1Le9sElEFYdUVEVVqEydORHx8PIYOHYoLFy7gzp07OHLkCN5++23k5uaievXqqFGjBjZu3Ihbt27h2LFjmDFjRkVnm4jKCQMdIqrUnJyccObMGeTm5sLHxwdNmzbF1KlToVQqYWBgAAMDA+zcuRP+/v5o2rQppk+fjs8++6yis01E5YS9roiIiKjKYokOERERVVkMdIiIiKjKYqBDREREVRYDHSIiIqqyGOgQERFRlcVAh4iIiKosBjpERERUZTHQISIioiqLgQ4RERFVWQx0iIiIqMpioENERERVFgMdIiIiqrL+D7W03qwlsMm3AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ds_area.sel(time=ds_area.time.dt.month.isin([10])).plot()\n", "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", @@ -261,10 +390,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "45366ccd-555b-49aa-93a2-51b83e802d16", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", @@ -280,28 +430,503 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "68400aca-aa0c-47f1-b7de-2c34dca5ac70", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "ds_area.sel(time=ds_area.time.dt.month.isin([10])).plot()\n", - "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", + "ds_area_ann = (ds1.tarea*aice1_ann).where(ds1.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area_ann = (ds2.tarea*aice2_ann).where(ds2.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "\n", + "ds_area_ann.plot()\n", + "ds2_area_ann.plot()\n", "\n", "plt.ylim((0,25))\n", "plt.xlabel(\"Year\")\n", - "plt.ylabel(\"SH September Sea Ice Area $m x 10^{12}$\")\n", + "plt.ylabel(\"SH Annual Mean Sea Ice Area $m x 10^{12}$\")\n", "plt.legend([case1,case2])" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "de2232e9-2705-4894-b98a-a93082ae7f79", "metadata": { "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 44)>\n",
+       "array([4.58, 4.87, 4.44, 4.43, 4.7 , 4.11, 4.23, 4.72, 5.64, 5.36, 4.86,\n",
+       "       4.55, 4.51, 5.43, 4.58, 5.13, 4.43, 5.62, 4.89, 4.3 , 4.29, 4.35,\n",
+       "       4.59, 4.03, 4.05, 4.39, 4.07, 4.01, 2.82, 3.26, 3.76, 3.34, 3.21,\n",
+       "       2.41, 3.78, 3.74, 3.42, 2.91, 3.35, 3.35, 3.17, 2.83, 3.47, 3.47])\n",
+       "Coordinates:\n",
+       "  * time     (time) object 0001-10-15 00:00:00 ... 0044-10-15 00:00:00
" + ], + "text/plain": [ + "\n", + "array([4.58, 4.87, 4.44, 4.43, 4.7 , 4.11, 4.23, 4.72, 5.64, 5.36, 4.86,\n", + " 4.55, 4.51, 5.43, 4.58, 5.13, 4.43, 5.62, 4.89, 4.3 , 4.29, 4.35,\n", + " 4.59, 4.03, 4.05, 4.39, 4.07, 4.01, 2.82, 3.26, 3.76, 3.34, 3.21,\n", + " 2.41, 3.78, 3.74, 3.42, 2.91, 3.35, 3.35, 3.17, 2.83, 3.47, 3.47])\n", + "Coordinates:\n", + " * time (time) object 0001-10-15 00:00:00 ... 0044-10-15 00:00:00" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "##### Add the data values manually from the datafile.\n", "##### Create an xarray object with the NSIDC values and the years from 1979 to 2022.\n", @@ -323,10 +948,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "00fc5097-af7d-4cf2-94ab-bb4e0a63960c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", @@ -348,6 +994,14 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfc18c63-fc78-45c3-a402-cfa57a6827cd", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 884bdb044b7a888ff036f19ee3a426ad9c737101 Mon Sep 17 00:00:00 2001 From: David Bailey Date: Thu, 25 Jan 2024 16:14:53 -0700 Subject: [PATCH 3/8] Additional cleanup in the sea ice notebook --- examples/nblibrary/seaice.ipynb | 673 ++------------------------------ 1 file changed, 26 insertions(+), 647 deletions(-) diff --git a/examples/nblibrary/seaice.ipynb b/examples/nblibrary/seaice.ipynb index 4b5e0ff..9154507 100644 --- a/examples/nblibrary/seaice.ipynb +++ b/examples/nblibrary/seaice.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "7e7f10ae-61c8-45f1-9d5c-9be60632b556", "metadata": { "editable": true, @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "270b0ff5-779c-4293-8d06-bd91eb8eee2b", "metadata": { "editable": true, @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "d3f591cc-dd67-4a3f-abe7-bfc740743db1", "metadata": {}, "outputs": [], @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "da24abe2-7b48-4c3d-b8a5-95847029bd74", "metadata": {}, "outputs": [], @@ -189,115 +189,50 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "28a0da20-6bad-45d7-a61a-43d55ea2acd2", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_diff(aice1_ann[::-25,:,:].mean('time'),aice2_ann[::-25,:,:].mean('time'),0.,1.,case1,case2,\"N\")" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "2c58f985-814d-4429-9917-fb0c15a4b2ee", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_diff(hi1_ann[::-25,:,:].mean('time'),hi2_ann[::-25,:,:].mean('time'),0.,5.,case1,case2,\"N\")" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "d32f3af9-8d4d-4908-b12b-0c355d4644af", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_diff(hs1_ann[::-25,:,:].mean('time'),hs2_ann[::-25,:,:].mean('time'),0.,0.5,case1,case2,\"N\")" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "ab99806f-31e8-41a1-8e1d-752c0d4325dc", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot_diff(aice1_ann[::-25,:,:].mean('time'),aice2_ann[::-25,:,:].mean('time'),0.,1.,case1,case2,\"S\")" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "ab1c8910-677e-4345-8f06-ec3f7a4a9f07", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", @@ -313,31 +248,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "cbf46c87-c3be-4a9e-90e8-e2a6633109e3", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds_area_ann = (ds1.tarea*aice1_ann).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area_ann = (ds2.tarea*aice2_ann).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", @@ -353,31 +267,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "90d62f0a-e43b-4bad-a759-0133bc2860aa", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds_area.sel(time=ds_area.time.dt.month.isin([10])).plot()\n", "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", @@ -390,31 +283,10 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "45366ccd-555b-49aa-93a2-51b83e802d16", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", @@ -430,31 +302,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "68400aca-aa0c-47f1-b7de-2c34dca5ac70", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds_area_ann = (ds1.tarea*aice1_ann).where(ds1.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area_ann = (ds2.tarea*aice2_ann).where(ds2.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", @@ -470,463 +321,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "de2232e9-2705-4894-b98a-a93082ae7f79", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray (time: 44)>\n",
-       "array([4.58, 4.87, 4.44, 4.43, 4.7 , 4.11, 4.23, 4.72, 5.64, 5.36, 4.86,\n",
-       "       4.55, 4.51, 5.43, 4.58, 5.13, 4.43, 5.62, 4.89, 4.3 , 4.29, 4.35,\n",
-       "       4.59, 4.03, 4.05, 4.39, 4.07, 4.01, 2.82, 3.26, 3.76, 3.34, 3.21,\n",
-       "       2.41, 3.78, 3.74, 3.42, 2.91, 3.35, 3.35, 3.17, 2.83, 3.47, 3.47])\n",
-       "Coordinates:\n",
-       "  * time     (time) object 0001-10-15 00:00:00 ... 0044-10-15 00:00:00
" - ], - "text/plain": [ - "\n", - "array([4.58, 4.87, 4.44, 4.43, 4.7 , 4.11, 4.23, 4.72, 5.64, 5.36, 4.86,\n", - " 4.55, 4.51, 5.43, 4.58, 5.13, 4.43, 5.62, 4.89, 4.3 , 4.29, 4.35,\n", - " 4.59, 4.03, 4.05, 4.39, 4.07, 4.01, 2.82, 3.26, 3.76, 3.34, 3.21,\n", - " 2.41, 3.78, 3.74, 3.42, 2.91, 3.35, 3.35, 3.17, 2.83, 3.47, 3.47])\n", - "Coordinates:\n", - " * time (time) object 0001-10-15 00:00:00 ... 0044-10-15 00:00:00" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "##### Add the data values manually from the datafile.\n", "##### Create an xarray object with the NSIDC values and the years from 1979 to 2022.\n", @@ -948,31 +348,10 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "00fc5097-af7d-4cf2-94ab-bb4e0a63960c", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", From 456eb466d66215479097b22661e3c6e228a380dc Mon Sep 17 00:00:00 2001 From: David Bailey Date: Thu, 25 Jan 2024 16:40:34 -0700 Subject: [PATCH 4/8] Additional cleanup in the sea ice notebook --- examples/nblibrary/seaice.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/nblibrary/seaice.ipynb b/examples/nblibrary/seaice.ipynb index 9154507..99ec274 100644 --- a/examples/nblibrary/seaice.ipynb +++ b/examples/nblibrary/seaice.ipynb @@ -5,7 +5,7 @@ "id": "351f2902-54b0-463c-9d61-23574844481f", "metadata": {}, "source": [ - "### Sea Ice Diagnostics for two CESM3 runs" + "## Sea Ice Diagnostics for two CESM3 runs" ] }, { From 38fe532569cfb8e7ab675128796aeba27634cbb5 Mon Sep 17 00:00:00 2001 From: David Bailey Date: Fri, 26 Jan 2024 14:04:39 -0700 Subject: [PATCH 5/8] Generalize the dataset read --- examples/nblibrary/seaice.ipynb | 109 +++++++++++++++++--------------- 1 file changed, 58 insertions(+), 51 deletions(-) diff --git a/examples/nblibrary/seaice.ipynb b/examples/nblibrary/seaice.ipynb index 99ec274..0a1b016 100644 --- a/examples/nblibrary/seaice.ipynb +++ b/examples/nblibrary/seaice.ipynb @@ -52,7 +52,8 @@ "begyr1 = 1\n", "endyr1 = 38\n", "begyr2 = 1\n", - "endyr2 = 38" + "endyr2 = 38\n", + "nyears = 25" ] }, { @@ -72,37 +73,27 @@ "cbegyr2 = f\"{begyr2:04d}\"\n", "cendyr2 = f\"{endyr2:04d}\"\n", "\n", - "ds1 = xr.open_dataset(CESM_output_dir+\"/\"+case1+\"/ts/\"+case1+\".cice.h.\"+\"aice.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", - "ds2 = xr.open_dataset(CESM_output_dir+\"/\"+case2+\"/ts/\"+case2+\".cice.h.\"+\"aice.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", - "ds3 = xr.open_dataset(CESM_output_dir+\"/\"+case1+\"/ts/\"+case1+\".cice.h.\"+\"hi.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", - "ds4 = xr.open_dataset(CESM_output_dir+\"/\"+case2+\"/ts/\"+case2+\".cice.h.\"+\"hi.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", - "ds5 = xr.open_dataset(CESM_output_dir+\"/\"+case1+\"/ts/\"+case1+\".cice.h.\"+\"hs.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", - "ds6 = xr.open_dataset(CESM_output_dir+\"/\"+case2+\"/ts/\"+case2+\".cice.h.\"+\"hs.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", + "ds1 = xr.open_mfdataset(CESM_output_dir+\"/\"+case1+\"/ts/\"+case1+\".cice.h.\"+\"*.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", + "ds2 = xr.open_mfdataset(CESM_output_dir+\"/\"+case2+\"/ts/\"+case2+\".cice.h.\"+\"*.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", "\n", "TLAT = ds1['TLAT']\n", "TLON = ds1['TLON']\n", "tarea = ds1['tarea']\n", "\n", - "\n", "# Make a DataArray with the number of days in each month, size = len(time)\n", "month_length = ds1.time.dt.days_in_month\n", "weights_monthly = month_length.groupby(\"time.year\") / month_length.groupby(\"time.year\").sum()\n", "\n", - "aice1_ann = (ds1['aice'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", - "aice2_ann = (ds2['aice'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", - "hi1_ann = (ds3['hi'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", - "hi2_ann = (ds4['hi'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", - "hs1_ann = (ds5['hs'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", - "hs2_ann = (ds6['hs'] * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", - "\n", - "\n", - "aice1_seas = (ds1['aice'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", - "aice2_seas = (ds2['aice'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", - "hi1_seas = (ds3['hi'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", - "hi2_seas = (ds4['hi'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", - "hs1_seas = (ds5['hs'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", - "hs2_seas = (ds6['hs'] * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", - "\n" + "\n", + "ds1_ann = (ds1 * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", + "ds2_ann = (ds2 * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", + "\n", + "\n", + "ds1_seas = (ds1 * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "ds2_seas = (ds2 * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "\n", + "h1_ann = ds1_ann['hi']\n", + "h2_ann = ds2_ann['hi']" ] }, { @@ -112,7 +103,7 @@ "metadata": {}, "outputs": [], "source": [ - "def plot_diff(field1, field2, field_min, field_max, case1, case2, proj):\n", + "def plot_diff(field1, field2, vmax, case1, case2, title, proj):\n", " # make circular boundary for polar stereographic circular plots\n", " theta = np.linspace(0, 2*np.pi, 100)\n", " center, radius = [0.5, 0.5], 0.5\n", @@ -135,14 +126,15 @@ " ax.set_boundary(circle, transform=ax.transAxes)\n", " ax.add_feature(cfeature.LAND,zorder=100,edgecolor='k')\n", "\n", - " field_diff = field2-field1\n", + " field_diff = field2.values-field1.values\n", " field_std = field_diff.std()\n", "\n", " this=ax.pcolormesh(TLON,\n", - " TLAT,\n", - " field1,\n", - " cmap=\"Blues_r\",vmax=field_max,vmin=field_min,\n", - " transform=ccrs.PlateCarree())\n", + " TLAT,\n", + " field1,\n", + " vmax = vmax,\n", + " cmap=\"Paired\",\n", + " transform=ccrs.PlateCarree())\n", " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", " plt.title(case1,fontsize=10)\n", "\n", @@ -161,7 +153,8 @@ " this=ax.pcolormesh(TLON,\n", " TLAT,\n", " field2,\n", - " cmap=\"Blues_r\",vmax=field_max,vmin=field_min,\n", + " vmax=vmax,\n", + " cmap=\"Paired\",\n", " transform=ccrs.PlateCarree())\n", " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", " plt.title(case2,fontsize=10)\n", @@ -184,7 +177,9 @@ " cmap=\"seismic\",vmax=field_std*2.0,vmin=-field_std*2.0,\n", " transform=ccrs.PlateCarree())\n", " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", - " plt.title(case2+\"-\"+case1,fontsize=10)\n" + " plt.title(case2+\"-\"+case1,fontsize=10)\n", + "\n", + " plt.suptitle(title)\n" ] }, { @@ -194,7 +189,10 @@ "metadata": {}, "outputs": [], "source": [ - "plot_diff(aice1_ann[::-25,:,:].mean('time'),aice2_ann[::-25,:,:].mean('time'),0.,1.,case1,case2,\"N\")" + "field1 = ds1_ann['aice'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "field2 = ds2_ann['aice'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "\n", + "plot_diff(field1,field2,1.0,case1,case2,\"Sea Ice Concentration\",\"N\")" ] }, { @@ -204,7 +202,10 @@ "metadata": {}, "outputs": [], "source": [ - "plot_diff(hi1_ann[::-25,:,:].mean('time'),hi2_ann[::-25,:,:].mean('time'),0.,5.,case1,case2,\"N\")" + "field1 = ds1_ann['hi'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "field2 = ds2_ann['hi'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "\n", + "plot_diff(field1,field2,5.0,case1,case2,\"Sea Ice Thickness (m)\",\"N\")" ] }, { @@ -214,7 +215,10 @@ "metadata": {}, "outputs": [], "source": [ - "plot_diff(hs1_ann[::-25,:,:].mean('time'),hs2_ann[::-25,:,:].mean('time'),0.,0.5,case1,case2,\"N\")" + "field1 = ds1_ann['hs'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "field2 = ds2_ann['hs'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "\n", + "plot_diff(field1,field2,0.5,case1,case2,\"Snow Depth (m)\",\"N\")" ] }, { @@ -224,7 +228,10 @@ "metadata": {}, "outputs": [], "source": [ - "plot_diff(aice1_ann[::-25,:,:].mean('time'),aice2_ann[::-25,:,:].mean('time'),0.,1.,case1,case2,\"S\")" + "field1 = ds1_ann['hs'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "field2 = ds2_ann['hs'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "\n", + "plot_diff(field1,field2,1.0,case1,case2,\"Sea Ice Concentration\",\"S\")" ] }, { @@ -234,10 +241,10 @@ "metadata": {}, "outputs": [], "source": [ - "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", - "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds1_area = (tarea*ds1.aice).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area = (tarea*ds2.aice).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "\n", - "ds_area.plot()\n", + "ds1_area.plot()\n", "ds2_area.plot()\n", "\n", "plt.ylim((0,25))\n", @@ -253,10 +260,10 @@ "metadata": {}, "outputs": [], "source": [ - "ds_area_ann = (ds1.tarea*aice1_ann).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", - "ds2_area_ann = (ds2.tarea*aice2_ann).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds1_area_ann = (tarea*aice1_ann).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area_ann = (tarea*aice2_ann).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "\n", - "ds_area_ann.plot()\n", + "ds1_area_ann.plot()\n", "ds2_area_ann.plot()\n", "\n", "plt.ylim((0,25))\n", @@ -272,7 +279,7 @@ "metadata": {}, "outputs": [], "source": [ - "ds_area.sel(time=ds_area.time.dt.month.isin([10])).plot()\n", + "ds1_area.sel(time=ds1_area.time.dt.month.isin([10])).plot()\n", "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", "\n", "plt.ylim((0,25))\n", @@ -288,10 +295,10 @@ "metadata": {}, "outputs": [], "source": [ - "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", - "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds1_area = (tarea*ds1.aice).where(TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area = (tarea*ds2.aice).where(TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", "\n", - "ds_area.plot()\n", + "ds1_area.plot()\n", "ds2_area.plot()\n", "\n", "plt.ylim((0,25))\n", @@ -307,10 +314,10 @@ "metadata": {}, "outputs": [], "source": [ - "ds_area_ann = (ds1.tarea*aice1_ann).where(ds1.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", - "ds2_area_ann = (ds2.tarea*aice2_ann).where(ds2.TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds1_area_ann = (tarea*aice1_ann).where(TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area_ann = (tarea*aice2_ann).where(TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", "\n", - "ds_area_ann.plot()\n", + "ds1_area_ann.plot()\n", "ds2_area_ann.plot()\n", "\n", "plt.ylim((0,25))\n", @@ -353,10 +360,10 @@ "metadata": {}, "outputs": [], "source": [ - "ds_area = (ds1.tarea*ds1.aice).where(ds1.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", - "ds2_area = (ds2.tarea*ds2.aice).where(ds2.TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds1_area = (tarea*ds1.aice).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area = (tarea*ds2.aice).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "\n", - "ds_area.sel(time=ds_area.time.dt.month.isin([10])).plot()\n", + "ds1_area.sel(time=ds1_area.time.dt.month.isin([10])).plot()\n", "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", "nsidc_index.plot()\n", "\n", From d8182f134d83dbf4756c8d096c48e39dad093491 Mon Sep 17 00:00:00 2001 From: David Bailey Date: Fri, 26 Jan 2024 16:39:05 -0700 Subject: [PATCH 6/8] Change contour plots to loops using the YAML dictionary --- examples/nblibrary/cice_masks.yml | 70 +++++++++++++++++++++++++++++++ examples/nblibrary/cice_vars.yml | 24 +++++++++++ examples/nblibrary/seaice.ipynb | 68 +++++++++++++----------------- 3 files changed, 123 insertions(+), 39 deletions(-) create mode 100644 examples/nblibrary/cice_masks.yml create mode 100644 examples/nblibrary/cice_vars.yml diff --git a/examples/nblibrary/cice_masks.yml b/examples/nblibrary/cice_masks.yml new file mode 100644 index 0000000..ea3c179 --- /dev/null +++ b/examples/nblibrary/cice_masks.yml @@ -0,0 +1,70 @@ +--- + +#**************************************************************** +# Boundary areas for regional masks: +# Northern Hemisphere: +# Lab Lab Sea +# GIN GIN Sea +# Bar Barents/Kara Sea +# ArcOc Arctic Ocean +# Sib Siberian Sea +# Beau Beaufort Sea +# CArc Central Arctic +# Bering Bering Sea +# Okhotsk Sea of Okhotsk +# Hudson Hudson Bay +# CAArch Canadian Archipelago +# +#Southern Hemisphere: +# Wed Weddell Sea +# Ross Ross Sea +# Ind Indian sector +# Pac Pacific sector +# BAm Bellingshausen-Amundsen Sea +# +#****************************************************************** +Lab_lat: [50.,78.] +Lab_lon: [284.,35.] +GIN_lat: [65.,80.] +GIN_lon1: [315.,360.] +GIN_lon2: [0.,15.] +Bar_lat: [66.,80.] +Bar_long: [15.,100.] +ArcOc_lat1: [80.,90.] +ArcOc_lat2: ArcOc_lat1 +ArcOc_lat3: [68.,90.] +ArcOc_long1: [243.,360.] +ArcOc_long2: [0.,100.] +ArcOc_long3: [100.,243.] +Sib_lat: [68.,80.] +Sib_long: [100.,192.] +Beau_lat: [68.,80.] +Beau_long: [192.,243.] +CArc_lat: [80.,90.] +CArc_long: [0.,360.] +#--------------------------------------------------------------- +# These Arctic regions are more complicated geographically +# and will be defined by polygons rather than min,max lat,lon +#-------------------------------------------------------------- +Lab_poly_lat: [50., 64., 74., 78., 78., 50.] +Lab_poly_long: [295., 292., 280., 280., 315., 315.] +Bering_poly_lat: [56., 60., 68., 68., 58., 52.5, 52.5] +Bering_poly_long: [162., 162., 178., 200., 204., 190., 180.] +Okhotsk_poly_lat: [44., 44., 46., 51., 60., 64., 60., 55., 44.] +Okhotsk_poly_long: [142., 145., 150., 157., 162., 168., 140., 133., 142.] +Hudson_poly_lat: [50., 66., 66., 70., 70., 68., 62., 60., 50.] +Hudson_poly_long: [265., 265., 274., 274., 290., 290., 292., 295., 295.] +CAArch_poly_lat: [67., 80., 80., 70., 67.] +CAArch_poly_long: [243., 243., 281., 281., 275.] +# ------SH regions------------------ +Wed_lat: [-90.,-50.] +Wed_long1: [300.,360.] +Wed_long2: [0.,20.] +Ross_lat: [-90.,-50.] +Ross_long: [160.,220.] +Ind_lat: [-90.,-50.] +Ind_long: [20.,90.] +Pac_lat: [-90.,-50.] +Pac_long: [90.,160.] +BAm_lat: [-90.,-50.] +BAm_long: [220.,300.] diff --git a/examples/nblibrary/cice_vars.yml b/examples/nblibrary/cice_vars.yml new file mode 100644 index 0000000..79f01d5 --- /dev/null +++ b/examples/nblibrary/cice_vars.yml @@ -0,0 +1,24 @@ +--- + +aice: + - limits: [0.0, 1.0] + - title: "Sea Ice Concentration" +hi: + - limits: [0.0,5.0] + - title: "Sea Ice Thickness" +hs: + - limits: [0.0,0.5] + - title: "Snow Depth" +Tsfc: + - limits: [-30.0,10.0] + - title: "Surface Temperature" +albsni: + - limits: [0,100] + - title: "Snow Ice Albedo" +flat: + - limits: [-50.,50.] + - title: "Latent Heat Flux" +fsens: + - limits: [-50.,50.] + - title: "Sensible Heat Flux" + diff --git a/examples/nblibrary/seaice.ipynb b/examples/nblibrary/seaice.ipynb index 0a1b016..8fd6685 100644 --- a/examples/nblibrary/seaice.ipynb +++ b/examples/nblibrary/seaice.ipynb @@ -28,7 +28,8 @@ "from matplotlib.gridspec import GridSpec\n", "import cartopy.crs as ccrs\n", "import cartopy.feature as cfeature\n", - "import cftime" + "import cftime\n", + "import yaml" ] }, { @@ -92,8 +93,13 @@ "ds1_seas = (ds1 * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", "ds2_seas = (ds2 * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", "\n", - "h1_ann = ds1_ann['hi']\n", - "h2_ann = ds2_ann['hi']" + "with open('cice_masks.yml', 'r') as file:\n", + " cice_masks = yaml.safe_load(file)\n", + "\n", + "with open('cice_vars.yml', 'r') as file:\n", + " cice_vars = yaml.safe_load(file)\n", + "\n", + "\n" ] }, { @@ -103,7 +109,7 @@ "metadata": {}, "outputs": [], "source": [ - "def plot_diff(field1, field2, vmax, case1, case2, title, proj):\n", + "def plot_diff(field1, field2, vmin, vmax, case1, case2, title, proj):\n", " # make circular boundary for polar stereographic circular plots\n", " theta = np.linspace(0, 2*np.pi, 100)\n", " center, radius = [0.5, 0.5], 0.5\n", @@ -132,6 +138,7 @@ " this=ax.pcolormesh(TLON,\n", " TLAT,\n", " field1,\n", + " vmin = vmin,\n", " vmax = vmax,\n", " cmap=\"Paired\",\n", " transform=ccrs.PlateCarree())\n", @@ -153,6 +160,7 @@ " this=ax.pcolormesh(TLON,\n", " TLAT,\n", " field2,\n", + " vmin=vmin,\n", " vmax=vmax,\n", " cmap=\"Paired\",\n", " transform=ccrs.PlateCarree())\n", @@ -189,49 +197,31 @@ "metadata": {}, "outputs": [], "source": [ - "field1 = ds1_ann['aice'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - "field2 = ds2_ann['aice'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - "\n", - "plot_diff(field1,field2,1.0,case1,case2,\"Sea Ice Concentration\",\"N\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2c58f985-814d-4429-9917-fb0c15a4b2ee", - "metadata": {}, - "outputs": [], - "source": [ - "field1 = ds1_ann['hi'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - "field2 = ds2_ann['hi'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - "\n", - "plot_diff(field1,field2,5.0,case1,case2,\"Sea Ice Thickness (m)\",\"N\")" + "for var in cice_vars:\n", + " print(var,cice_vars[var])\n", + " vmin=cice_vars[var][0]['limits'][0]\n", + " vmax=cice_vars[var][0]['limits'][1]\n", + " title=cice_vars[var][1]['title']\n", + " field1 = ds1_ann[var].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + " field2 = ds2_ann[var].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + " plot_diff(field1,field2,vmin,vmax,case1,case2,title,\"N\")" ] }, { "cell_type": "code", "execution_count": null, - "id": "d32f3af9-8d4d-4908-b12b-0c355d4644af", + "id": "17591ebc-5360-479f-93bc-6ba8847df5c1", "metadata": {}, "outputs": [], "source": [ - "field1 = ds1_ann['hs'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - "field2 = ds2_ann['hs'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - "\n", - "plot_diff(field1,field2,0.5,case1,case2,\"Snow Depth (m)\",\"N\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ab99806f-31e8-41a1-8e1d-752c0d4325dc", - "metadata": {}, - "outputs": [], - "source": [ - "field1 = ds1_ann['hs'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - "field2 = ds2_ann['hs'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - "\n", - "plot_diff(field1,field2,1.0,case1,case2,\"Sea Ice Concentration\",\"S\")" + "for var in cice_vars:\n", + " print(var,cice_vars[var])\n", + " vmin=cice_vars[var][0]['limits'][0]\n", + " vmax=cice_vars[var][0]['limits'][1]\n", + " title=cice_vars[var][1]['title']\n", + " field1 = ds1_ann[var].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + " field2 = ds2_ann[var].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + " plot_diff(field1,field2,vmin,vmax,case1,case2,title,\"S\")" ] }, { From 51653f2babe2ea118f72eddd5b820264db5cdf66 Mon Sep 17 00:00:00 2001 From: David Bailey Date: Wed, 21 Feb 2024 16:04:50 -0700 Subject: [PATCH 7/8] Updated sea ice notebook --- examples/coupled_model/config.yml | 4 +- examples/nblibrary/cice_vars.yml | 55 +++- examples/nblibrary/seaice.ipynb | 410 ++++++++++++++++++++++++++---- 3 files changed, 406 insertions(+), 63 deletions(-) diff --git a/examples/coupled_model/config.yml b/examples/coupled_model/config.yml index 7a36fc8..aa3b781 100644 --- a/examples/coupled_model/config.yml +++ b/examples/coupled_model/config.yml @@ -94,8 +94,8 @@ compute_notebooks: parameter_groups: none: cases: - - b.e23_alpha16g.BLT1850.ne30_t232.073c - - b.e23_alpha16g.BLT1850.ne30_t232.075c + - b.e23_alpha16g.BLT1850.ne30_t232.059 + - b.e23_alpha16b.BLT1850.ne30_t232.054 ########### JUPYTER BOOK CONFIG ########### diff --git a/examples/nblibrary/cice_vars.yml b/examples/nblibrary/cice_vars.yml index 79f01d5..00e6d61 100644 --- a/examples/nblibrary/cice_vars.yml +++ b/examples/nblibrary/cice_vars.yml @@ -1,24 +1,53 @@ --- aice: - - limits: [0.0, 1.0] + - levels: [0.05,0.10,0.15,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.85,0.90,0.95,0.99] - title: "Sea Ice Concentration" hi: - - limits: [0.0,5.0] - - title: "Sea Ice Thickness" + - levels: [0.05,0.1,0.25,0.5,0.75,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0] + - title: "Sea Ice Thickness (m)" hs: - - limits: [0.0,0.5] - - title: "Snow Depth" + - levels: [0.01,0.03,0.05,0.07,0.10,0.13,0.15,0.20,0.25,0.30,0.35,0.40,0.45,0.50] + - title: "Snow Depth (m)" Tsfc: - - limits: [-30.0,10.0] - - title: "Surface Temperature" + - levels: [-40.,-37.,-34.,-31.,-28.,-25.,-22.,-19.,-16.,-13.,-10.,-5.,-3.,-1.] + - title: "Surface Temperature (C)" albsni: - - limits: [0,100] + - levels: [5,10,15,20,30,40,50, 60, 65, 70, 75, 80,85, 90] - title: "Snow Ice Albedo" flat: - - limits: [-50.,50.] - - title: "Latent Heat Flux" + - levels: [-18.,-16.,-14.,-12.,-10.,-8.,-6.,-5.,-4.,-3.,-2.,-1.,0.,2.] + - title: "Latent Heat Flux (W/m^2}" fsens: - - limits: [-50.,50.] - - title: "Sensible Heat Flux" - + - levels: [-30.,-25.,-20.,-15.,-10.,-5.,-2.5,0,2.5,5,10,15,20,25] + - title: "Sensible Heat Flux (W/m^2)" +congel: + - levels: [0, 0.5, 1 ,1.5 ,2 ,2.5,3,4,5,6,7,8,9,10] + - title: "Congelation growth (cm/day)" +frazil: + - levels: [0.0,0.02,0.04,0.06,0.08,0.10,0.12,0.14,0.16,0.18,0.20,0.22,0.24,0.26] + - title: "Frazil growth (cm/day)" +snoice: + - levels: [0.0,0.01,0.02,0.03,0.04,0.05,0.06,0.08,0.10,0.12,0.14,0.16,0.18,0.20] + - title: "Snow-ice growth (cm/day)" +meltb: + - levels: [0.05,0.1,0.25,0.5,0.75,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5,5.0] + - title: "Bottom Melt (cm/day)" +meltt: + - levels: [0.05,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0,1.1,1.2,1.3] + - title: "Top Melt (cm/day)" +meltl: + - levels: [0.01,0.04,0.08,0.12,0.16,0.2,0.24,0.28,0.32,0.36,0.4,0.44,0.48,0.52] + - title: "Lateral Melt (cm/day)" +dvidtt: + - levels: [-3.6,-3.0,-2.4,-1.8,-1.2,-0.6,0.0,0.6,1.2,1.8,2.4,3.0,3.6,4.0] + - title: "Volume tendency due to thermodynamics (cm/day)" +dvidtd: + - levels: [-3.6,-3.0,-2.4,-1.8,-1.2,-0.6,0.0,0.6,1.2,1.8,2.4,3.0,3.6,4.0] + - title: "Volume tendency due to dynamics (cm/day)" +daidtt: + - levels: [-3.6,-3.0,-2.4,-1.8,-1.2,-0.6,0.0,0.6,1.2,1.8,2.4,3.0,3.6,4.0] + - title: "Area tendency due to thermodynamics (%/day)" +daidtd: + - levels: [-3.6,-3.0,-2.4,-1.8,-1.2,-0.6,0.0,0.6,1.2,1.8,2.4,3.0,3.6,4.0] + - title: "Area tendency due to dynamics (%/day)" diff --git a/examples/nblibrary/seaice.ipynb b/examples/nblibrary/seaice.ipynb index 8fd6685..49d50f3 100644 --- a/examples/nblibrary/seaice.ipynb +++ b/examples/nblibrary/seaice.ipynb @@ -23,13 +23,15 @@ "source": [ "import xarray as xr\n", "import numpy as np\n", + "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "import matplotlib.path as mpath\n", "from matplotlib.gridspec import GridSpec\n", "import cartopy.crs as ccrs\n", "import cartopy.feature as cfeature\n", "import cftime\n", - "import yaml" + "import yaml\n", + "import pandas as pd" ] }, { @@ -48,12 +50,12 @@ "outputs": [], "source": [ "CESM_output_dir = \"/glade/campaign/cesm/development/cross-wg/diagnostic_framework/CESM_output_for_testing\"\n", - "cases = [\"b.e23_alpha16g.BLT1850.ne30_t232.073c\",\"b.e23_alpha16g.BLT1850.ne30_t232.075c\"]\n", + "cases = [\"b.e23_alpha16g.BLT1850.ne30_t232.075\",\"b.e23_alpha16g.BLT1850.ne30_t232.078\"]\n", "\n", "begyr1 = 1\n", - "endyr1 = 38\n", + "endyr1 = 102\n", "begyr2 = 1\n", - "endyr2 = 38\n", + "endyr2 = 48\n", "nyears = 25" ] }, @@ -75,7 +77,7 @@ "cendyr2 = f\"{endyr2:04d}\"\n", "\n", "ds1 = xr.open_mfdataset(CESM_output_dir+\"/\"+case1+\"/ts/\"+case1+\".cice.h.\"+\"*.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", - "ds2 = xr.open_mfdataset(CESM_output_dir+\"/\"+case2+\"/ts/\"+case2+\".cice.h.\"+\"*.\"+cbegyr1+\"01-\"+cendyr1+\"12.nc\")\n", + "ds2 = xr.open_mfdataset(CESM_output_dir+\"/\"+case2+\"/ts/\"+case2+\".cice.h.\"+\"*.\"+cbegyr2+\"01-\"+cendyr2+\"12.nc\")\n", "\n", "TLAT = ds1['TLAT']\n", "TLON = ds1['TLON']\n", @@ -86,12 +88,20 @@ "weights_monthly = month_length.groupby(\"time.year\") / month_length.groupby(\"time.year\").sum()\n", "\n", "\n", + "#seasons = xr.full_like(months, fill_value=\"none\", dtype=\"U4\")\n", + "#seasons.name = \"season\"\n", + "#seasons[months.isin([1, 2, 3])] = \"JFM\"\n", + "#seasons[months.isin([4, 5, 6])] = \"AMJ\"\n", + "#seasons[months.isin([7, 8, 9])] = \"JAS\"\n", + "#seasons[months.isin([10, 11, 12])] = \"OND\"\n", + "#weights_season = month_length.groupby(seasons) / month_length.groupby(seasons).sum()\n", + "\n", "ds1_ann = (ds1 * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", "ds2_ann = (ds2 * weights_monthly).resample(time=\"YS\").sum(dim=\"time\")\n", "\n", "\n", - "ds1_seas = (ds1 * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", - "ds2_seas = (ds2 * weights_monthly).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "#ds1_seas = (ds1 * weights_season).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", + "#ds2_seas = (ds2 * weights_season).resample(time=\"QS-JAN\").sum(dim=\"time\")\n", "\n", "with open('cice_masks.yml', 'r') as file:\n", " cice_masks = yaml.safe_load(file)\n", @@ -99,7 +109,7 @@ "with open('cice_vars.yml', 'r') as file:\n", " cice_vars = yaml.safe_load(file)\n", "\n", - "\n" + "print(ds1['aice'])\n" ] }, { @@ -109,13 +119,18 @@ "metadata": {}, "outputs": [], "source": [ - "def plot_diff(field1, field2, vmin, vmax, case1, case2, title, proj):\n", + "def plot_diff(field1, field2, levels, case1, case2, title, proj):\n", " # make circular boundary for polar stereographic circular plots\n", " theta = np.linspace(0, 2*np.pi, 100)\n", " center, radius = [0.5, 0.5], 0.5\n", " verts = np.vstack([np.sin(theta), np.cos(theta)]).T\n", " circle = mpath.Path(verts * radius + center)\n", "\n", + " \n", + " if (np.size(levels) > 2):\n", + " cmap = mpl.colormaps['tab20']\n", + " norm = mpl.colors.BoundaryNorm(levels, ncolors=cmap.N)\n", + "\n", " # set up the figure with a North Polar Stereographic projection\n", " fig = plt.figure(tight_layout=True)\n", " gs = GridSpec(2, 4)\n", @@ -136,12 +151,11 @@ " field_std = field_diff.std()\n", "\n", " this=ax.pcolormesh(TLON,\n", - " TLAT,\n", - " field1,\n", - " vmin = vmin,\n", - " vmax = vmax,\n", - " cmap=\"Paired\",\n", - " transform=ccrs.PlateCarree())\n", + " TLAT,\n", + " field1,\n", + " norm = norm,\n", + " cmap=\"tab20\",\n", + " transform=ccrs.PlateCarree())\n", " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", " plt.title(case1,fontsize=10)\n", "\n", @@ -160,9 +174,8 @@ " this=ax.pcolormesh(TLON,\n", " TLAT,\n", " field2,\n", - " vmin=vmin,\n", - " vmax=vmax,\n", - " cmap=\"Paired\",\n", + " norm=norm,\n", + " cmap=\"tab20\",\n", " transform=ccrs.PlateCarree())\n", " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", " plt.title(case2,fontsize=10)\n", @@ -190,6 +203,132 @@ " plt.suptitle(title)\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1441e33-06c5-491e-8dee-11f698e7e37b", + "metadata": {}, + "outputs": [], + "source": [ + "def vect_diff(uvel1,vvel1,uvel2,vvel2,angle,proj):\n", + " uvel_rot1 = uvel1*np.cos(angle)-vvel1*np.sin(angle)\n", + " vvel_rot1 = uvel1*np.sin(angle)+vvel1*np.cos(angle)\n", + " uvel_rot2 = uvel2*np.cos(angle)-vvel2*np.sin(angle)\n", + " vvel_rot2 = uvel2*np.sin(angle)+vvel2*np.cos(angle)\n", + " \n", + " speed1 = np.sqrt(uvel1*uvel1+vvel1*vvel1)\n", + " speed2 = np.sqrt(uvel2*uvel2+vvel2*vvel2)\n", + "\n", + " uvel_diff = uvel_rot2-uvel_rot1\n", + " vvel_diff = vvel_rot2-vvel_rot1\n", + " speed_diff = speed2-speed1\n", + " \n", + " # make circular boundary for polar stereographic circular plots\n", + " theta = np.linspace(0, 2*np.pi, 100)\n", + " center, radius = [0.5, 0.5], 0.5\n", + " verts = np.vstack([np.sin(theta), np.cos(theta)]).T\n", + " circle = mpath.Path(verts * radius + center)\n", + "\n", + " # set up the figure with a North Polar Stereographic projection\n", + " fig = plt.figure(tight_layout=True)\n", + " gs = GridSpec(2, 4)\n", + "\n", + " if (proj == \"N\"):\n", + " ax = fig.add_subplot(gs[0,:2], projection=ccrs.NorthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, 90, 45], crs=ccrs.PlateCarree())\n", + " if (proj == \"S\"):\n", + " ax = fig.add_subplot(gs[0,:2], projection=ccrs.SouthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, -90, -45], crs=ccrs.PlateCarree())\n", + "\n", + " ax.set_boundary(circle, transform=ax.transAxes)\n", + " ax.add_feature(cfeature.LAND,zorder=100,edgecolor='k')\n", + "\n", + " this=ax.pcolormesh(TLON,\n", + " TLAT,\n", + " speed1,\n", + " vmin = 0.,\n", + " vmax = 0.5,\n", + " cmap=\"tab20\",\n", + " transform=ccrs.PlateCarree())\n", + " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", + " plt.title(case1,fontsize=10)\n", + "\n", + " intv = 5\n", + " ## add vectors\n", + " Q = ax.quiver(TLON[::intv,::intv].values,TLAT[::intv,::intv].values,\n", + " uvel_rot1[::intv,::intv].values,vvel_rot1[::intv,::intv].values,\n", + " color = 'black', scale=1.,\n", + " transform=ccrs.PlateCarree())\n", + " units = \"cm/s\"\n", + " qk = ax.quiverkey(Q,0.85,0.025,0.10,r'10 '+units,labelpos='S', coordinates='axes',color='black',zorder=2)\n", + "\n", + " if (proj == \"N\"):\n", + " ax = fig.add_subplot(gs[0,2:], projection=ccrs.NorthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, 90, 45], crs=ccrs.PlateCarree())\n", + " if (proj == \"S\"):\n", + " ax = fig.add_subplot(gs[0,2:], projection=ccrs.SouthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, -90, -45], crs=ccrs.PlateCarree())\n", + " \n", + " ax.set_boundary(circle, transform=ax.transAxes)\n", + " ax.add_feature(cfeature.LAND,zorder=100,edgecolor='k')\n", + "\n", + " this=ax.pcolormesh(TLON,\n", + " TLAT,\n", + " speed2,\n", + " vmin = 0.,\n", + " vmax = 0.5,\n", + " cmap=\"tab20\",\n", + " transform=ccrs.PlateCarree())\n", + " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", + " plt.title(case1,fontsize=10)\n", + "\n", + " intv = 5\n", + " ## add vectors\n", + " Q = ax.quiver(TLON[::intv,::intv].values,TLAT[::intv,::intv].values,\n", + " uvel_rot2[::intv,::intv].values,vvel_rot2[::intv,::intv].values,\n", + " color = 'black', scale=1.,\n", + " transform=ccrs.PlateCarree())\n", + " units = \"cm/s\"\n", + " qk = ax.quiverkey(Q,0.85,0.025,0.10,r'10 '+units,labelpos='S', coordinates='axes',color='black',zorder=2)\n", + "\n", + " if (proj == \"N\"):\n", + " ax = fig.add_subplot(gs[1,1:3], projection=ccrs.NorthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, 90, 45], crs=ccrs.PlateCarree())\n", + " if (proj == \"S\"):\n", + " ax = fig.add_subplot(gs[1,1:3], projection=ccrs.SouthPolarStereo())\n", + " # sets the latitude / longitude boundaries of the plot\n", + " ax.set_extent([0.005, 360, -90, -45], crs=ccrs.PlateCarree())\n", + " \n", + " ax.set_boundary(circle, transform=ax.transAxes)\n", + " ax.add_feature(cfeature.LAND,zorder=100,edgecolor='k')\n", + "\n", + " this=ax.pcolormesh(TLON,\n", + " TLAT,\n", + " speed_diff,\n", + " vmin = -0.2,\n", + " vmax = 0.2,\n", + " cmap=\"seismic\",\n", + " transform=ccrs.PlateCarree())\n", + " plt.colorbar(this,orientation='vertical',fraction=0.04,pad=0.01)\n", + " plt.title(case2+\"-\"+case1,fontsize=10)\n", + "\n", + " intv = 5\n", + " ## add vectors\n", + " Q = ax.quiver(TLON[::intv,::intv].values,TLAT[::intv,::intv].values,\n", + " uvel_diff[::intv,::intv].values,vvel_diff[::intv,::intv].values,\n", + " color = 'black', scale=1.,\n", + " transform=ccrs.PlateCarree())\n", + " units = \"cm/s\"\n", + " qk = ax.quiverkey(Q,0.85,0.025,0.10,r'10 '+units,labelpos='S', coordinates='axes',color='black',zorder=2)\n", + "\n", + " plt.suptitle(\"Velocity m/s\")" + ] + }, { "cell_type": "code", "execution_count": null, @@ -197,14 +336,20 @@ "metadata": {}, "outputs": [], "source": [ + "with open('cice_vars.yml', 'r') as file:\n", + " cice_vars = yaml.safe_load(file)\n", + "\n", + "\n", "for var in cice_vars:\n", " print(var,cice_vars[var])\n", - " vmin=cice_vars[var][0]['limits'][0]\n", - " vmax=cice_vars[var][0]['limits'][1]\n", + " vmin=cice_vars[var][0]['levels'][0]\n", + " vmax=cice_vars[var][0]['levels'][-1]\n", + " levels = np.array(cice_vars[var][0]['levels'])\n", + " print(levels)\n", " title=cice_vars[var][1]['title']\n", " field1 = ds1_ann[var].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", " field2 = ds2_ann[var].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - " plot_diff(field1,field2,vmin,vmax,case1,case2,title,\"N\")" + " plot_diff(field1,field2,levels,case1,case2,title,\"N\")" ] }, { @@ -216,12 +361,14 @@ "source": [ "for var in cice_vars:\n", " print(var,cice_vars[var])\n", - " vmin=cice_vars[var][0]['limits'][0]\n", - " vmax=cice_vars[var][0]['limits'][1]\n", + " vmin=cice_vars[var][0]['levels'][0]\n", + " vmax=cice_vars[var][0]['levels'][1]\n", + " levels = np.array(cice_vars[var][0]['levels'])\n", + " print(levels)\n", " title=cice_vars[var][1]['title']\n", " field1 = ds1_ann[var].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", " field2 = ds2_ann[var].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", - " plot_diff(field1,field2,vmin,vmax,case1,case2,title,\"S\")" + " plot_diff(field1,field2,levels,case1,case2,title,\"S\")" ] }, { @@ -234,6 +381,33 @@ "ds1_area = (tarea*ds1.aice).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area = (tarea*ds2.aice).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "\n", + "ds1_vhi = (tarea*ds1.hi).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-13\n", + "ds2_vhi = (tarea*ds2.hi).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-13\n", + "\n", + "ds1_vhs = (tarea*ds1.hs).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-13\n", + "ds2_vhs = (tarea*ds2.hs).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-13\n", + "\n", + "fig = plt.figure(figsize=(10,10),tight_layout=True)\n", + "\n", + "ax = fig.add_subplot(3,1,1)\n", + "ds1_vhi.plot()\n", + "ds2_vhi.plot()\n", + "\n", + "plt.ylim((0,10))\n", + "plt.xlabel(\"Month\")\n", + "plt.ylabel(\"NH Sea Ice Volume $m x 10^{13}$\")\n", + "plt.legend([case1,case2])\n", + "\n", + "ax = fig.add_subplot(3,1,2)\n", + "ds1_vhs.plot()\n", + "ds2_vhs.plot()\n", + "\n", + "plt.ylim((0,1))\n", + "plt.xlabel(\"Month\")\n", + "plt.ylabel(\"NH Snow Volume $m x 10^{13}$\")\n", + "plt.legend([case1,case2])\n", + "\n", + "ax = fig.add_subplot(3,1,3)\n", "ds1_area.plot()\n", "ds2_area.plot()\n", "\n", @@ -250,9 +424,36 @@ "metadata": {}, "outputs": [], "source": [ - "ds1_area_ann = (tarea*aice1_ann).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", - "ds2_area_ann = (tarea*aice2_ann).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds1_area_ann = (tarea*ds1_ann['aice']).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area_ann = (tarea*ds2_ann['aice']).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", + "\n", + "ds1_vhi_ann = (tarea*ds1_ann['hi']).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-13\n", + "ds2_vhi_ann = (tarea*ds2_ann['hi']).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-13\n", "\n", + "ds1_vhs_ann = (tarea*ds1_ann['hs']).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-13\n", + "ds2_vhs_ann = (tarea*ds2_ann['hs']).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-13\n", + "\n", + "fig = plt.figure(figsize=(10,10),tight_layout=True)\n", + "\n", + "ax = fig.add_subplot(3,1,1)\n", + "ds1_vhi_ann.plot()\n", + "ds2_vhi_ann.plot()\n", + "\n", + "plt.ylim((0,10))\n", + "plt.xlabel(\"Year\")\n", + "plt.ylabel(\"NH Annual Mean Sea Ice Volume $m x 10^{13}$\")\n", + "plt.legend([case1,case2])\n", + "\n", + "ax = fig.add_subplot(3,1,2)\n", + "ds1_vhs_ann.plot()\n", + "ds2_vhs_ann.plot()\n", + "\n", + "plt.ylim((0,1))\n", + "plt.xlabel(\"Year\")\n", + "plt.ylabel(\"NH Annual Mean Snow Volume $m x 10^{13}$\")\n", + "plt.legend([case1,case2])\n", + "\n", + "ax = fig.add_subplot(3,1,3)\n", "ds1_area_ann.plot()\n", "ds2_area_ann.plot()\n", "\n", @@ -263,11 +464,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "90d62f0a-e43b-4bad-a759-0133bc2860aa", + "cell_type": "markdown", + "id": "dad0ad61-9566-4e49-8262-1516174fe322", "metadata": {}, - "outputs": [], "source": [ "ds1_area.sel(time=ds1_area.time.dt.month.isin([10])).plot()\n", "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", @@ -304,8 +503,8 @@ "metadata": {}, "outputs": [], "source": [ - "ds1_area_ann = (tarea*aice1_ann).where(TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", - "ds2_area_ann = (tarea*aice2_ann).where(TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds1_area_ann = (tarea*ds1_ann.aice).where(TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_area_ann = (tarea*ds2_ann.aice).where(TLAT<0).sum(dim=['nj','ni'])*1.0e-12\n", "\n", "ds1_area_ann.plot()\n", "ds2_area_ann.plot()\n", @@ -325,22 +524,86 @@ }, "outputs": [], "source": [ - "##### Add the data values manually from the datafile.\n", - "##### Create an xarray object with the NSIDC values and the years from 1979 to 2022.\n", + "### Read in the NSIDC data from files\n", + "\n", + "path_nsidc = '/glade/campaign/cesm/development/pcwg/ice/data/NSIDC_SeaIce_extent/'\n", + "\n", + "jan_nsidc = pd.read_csv(path_nsidc+'N_01_extent_v3.0.csv',na_values=['-99.9'])\n", + "feb_nsidc = pd.read_csv(path_nsidc+'N_02_extent_v3.0.csv',na_values=['-99.9'])\n", + "mar_nsidc = pd.read_csv(path_nsidc+'N_03_extent_v3.0.csv',na_values=['-99.9'])\n", + "apr_nsidc = pd.read_csv(path_nsidc+'N_04_extent_v3.0.csv',na_values=['-99.9'])\n", + "may_nsidc = pd.read_csv(path_nsidc+'N_05_extent_v3.0.csv',na_values=['-99.9'])\n", + "jun_nsidc = pd.read_csv(path_nsidc+'N_06_extent_v3.0.csv',na_values=['-99.9'])\n", + "jul_nsidc = pd.read_csv(path_nsidc+'N_07_extent_v3.0.csv',na_values=['-99.9'])\n", + "aug_nsidc = pd.read_csv(path_nsidc+'N_08_extent_v3.0.csv',na_values=['-99.9'])\n", + "sep_nsidc = pd.read_csv(path_nsidc+'N_09_extent_v3.0.csv',na_values=['-99.9'])\n", + "oct_nsidc = pd.read_csv(path_nsidc+'N_10_extent_v3.0.csv',na_values=['-99.9'])\n", + "nov_nsidc = pd.read_csv(path_nsidc+'N_11_extent_v3.0.csv',na_values=['-99.9'])\n", + "dec_nsidc = pd.read_csv(path_nsidc+'N_12_extent_v3.0.csv',na_values=['-99.9'])\n", + "\n", + "jan_area = jan_nsidc.iloc[:,5].values\n", + "feb_area = feb_nsidc.iloc[:,5].values\n", + "mar_area = mar_nsidc.iloc[:,5].values\n", + "apr_area = apr_nsidc.iloc[:,5].values\n", + "may_area = may_nsidc.iloc[:,5].values\n", + "jun_area = jun_nsidc.iloc[:,5].values\n", + "jul_area = jul_nsidc.iloc[:,5].values\n", + "aug_area = aug_nsidc.iloc[:,5].values\n", + "sep_area = sep_nsidc.iloc[:,5].values\n", + "oct_area = oct_nsidc.iloc[:,5].values\n", + "nov_area = nov_nsidc.iloc[:,5].values\n", + "dec_area = dec_nsidc.iloc[:,5].values\n", + "\n", + "jan_ext = jan_nsidc.iloc[:,4].values\n", + "feb_ext = feb_nsidc.iloc[:,4].values\n", + "mar_ext = mar_nsidc.iloc[:,4].values\n", + "apr_ext = apr_nsidc.iloc[:,4].values\n", + "may_ext = may_nsidc.iloc[:,4].values\n", + "jun_ext = jun_nsidc.iloc[:,4].values\n", + "jul_ext = jul_nsidc.iloc[:,4].values\n", + "aug_ext = aug_nsidc.iloc[:,4].values\n", + "sep_ext = sep_nsidc.iloc[:,4].values\n", + "oct_ext = oct_nsidc.iloc[:,4].values\n", + "nov_ext = nov_nsidc.iloc[:,4].values\n", + "dec_ext = dec_nsidc.iloc[:,4].values\n", + "\n", + "print(dec_ext)\n", + "nsidc_clim = [np.nanmean(jan_ext[0:35]),np.nanmean(feb_ext[0:35]),np.nanmean(mar_ext[0:35]),np.nanmean(apr_ext[0:35]),\n", + " np.nanmean(may_ext[0:35]),np.nanmean(jun_ext[0:35]),np.nanmean(jul_ext[0:35]),np.nanmean(aug_ext[0:35]),\n", + " np.nanmean(sep_ext[0:35]),np.nanmean(oct_ext[0:35]),np.nanmean(nov_ext[0:35]),np.nanmean(dec_ext[0:35])]\n", + "\n", + "plt.plot(nsidc_clim)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dcfc33a9-1dce-4dc7-95e3-dbdccee3575a", + "metadata": {}, + "outputs": [], + "source": [ "\n", - "seaice_index = [4.58,4.87,4.44,4.43,4.7,4.11,4.23,4.72,5.64,5.36,4.86,4.55,4.51,5.43,4.58,5.13,4.43,5.62,\\\n", - " 4.89,4.3,4.29,4.35,4.59,4.03,4.05,4.39,4.07,4.01,2.82,3.26,3.76,3.34,3.21,2.41,3.78,3.74,\\\n", - " 3.42,2.91,3.35,3.35,3.17,2.83,3.47,3.47]\n", + "aice1_month = ds1['aice'].groupby(\"time.month\").mean(dim=\"time\",skipna=True)\n", + "aice2_month = ds2['aice'].groupby(\"time.month\").mean(dim=\"time\",skipna=True)\n", "\n", - "# Convert to m^2\n", - "seaice_index = np.array(seaice_index)\n", - "#seaice_index *= 1e12\n", + "mask_tmp1 = np.where(np.logical_and(aice1_month > 0.15, ds1['TLAT'] > 0), 1., 0.)\n", + "mask_tmp2 = np.where(np.logical_and(aice2_month > 0.15, ds1['TLAT'] > 0), 1., 0.)\n", "\n", - "nsidc_time = [cftime.datetime(y, 10, 15) for y in range(1,45)]\n", + "mask_ext1 = xr.DataArray(data=mask_tmp1,dims=[\"month\",\"nj\", \"ni\"])\n", + "mask_ext2 = xr.DataArray(data=mask_tmp2,dims=[\"month\",\"nj\", \"ni\"])\n", "\n", - "nsidc_index = xr.DataArray(data=seaice_index,coords={\"time\":nsidc_time})\n", "\n", - "nsidc_index\n" + "ext1 = (mask_ext1*tarea).sum(['ni','nj'])*1.0e-12\n", + "ext2 = (mask_ext2*tarea).sum(['ni','nj'])*1.0e-12\n", + "\n", + "plt.plot(ext1)\n", + "plt.plot(ext2)\n", + "plt.plot(nsidc_clim)\n", + "\n", + "plt.ylim((0,25))\n", + "plt.xlabel(\"Month\")\n", + "plt.ylabel(\"Climatological Seasonal Cycle Ice Extent $m x 10^{12}$\")\n", + "plt.legend([case1,case2,\"NSIDC\"])\n" ] }, { @@ -353,12 +616,15 @@ "ds1_area = (tarea*ds1.aice).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "ds2_area = (tarea*ds2.aice).where(TLAT>0).sum(dim=['nj','ni'])*1.0e-12\n", "\n", - "ds1_area.sel(time=ds1_area.time.dt.month.isin([10])).plot()\n", - "ds2_area.sel(time=ds2_area.time.dt.month.isin([10])).plot()\n", - "nsidc_index.plot()\n", + "ds1_sep = ds1_area.sel(time=(ds1_area.time.dt.month == 9))\n", + "ds2_sep = ds2_area.sel(time=(ds2_area.time.dt.month == 9))\n", + "\n", + "plt.plot(ds1_sep)\n", + "plt.plot(ds2_sep)\n", + "plt.plot(sep_area)\n", "\n", "plt.ylim((0,25))\n", - "plt.xlabel(\"Month\")\n", + "plt.xlabel(\"Year\")\n", "plt.ylabel(\"Sea Ice Area $mx10^{12}$\")\n", "plt.legend([case1,case2,\"NSIDC\"])" ] @@ -369,7 +635,28 @@ "id": "b9a9ad99-e580-4188-a328-950c84eb1b62", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "\n", + "latm = cice_masks['Lab_lat']\n", + "lonm = cice_masks['Lab_lon']\n", + "\n", + "lon = np.where(TLON < 0, TLON+360.,TLON)\n", + "\n", + "mask1 = np.where(np.logical_and(TLAT > latm[0], TLAT < latm[1]),1.,0.)\n", + "mask2 = np.where(np.logical_or(lon > lonm[0], lon < lonm[1]),1.,0.)\n", + "mask = mask1*mask2\n", + "\n", + "ds1_lab = (mask*tarea*ds1.aice).sum(dim=['nj','ni'])*1.0e-12\n", + "ds2_lab = (mask*tarea*ds2.aice).sum(dim=['nj','ni'])*1.0e-12\n", + "\n", + "ds1_lab.plot()\n", + "ds2_lab.plot()\n", + "\n", + "plt.ylim((0,10))\n", + "plt.xlabel(\"Month\")\n", + "plt.ylabel(\"Labrador Sea Ice Area $m x 10^{12}$\")\n", + "plt.legend([case1,case2])" + ] }, { "cell_type": "code", @@ -377,6 +664,33 @@ "id": "cfc18c63-fc78-45c3-a402-cfa57a6827cd", "metadata": {}, "outputs": [], + "source": [ + "uvel1 = ds1_ann['uvel'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "vvel1 = ds1_ann['vvel'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "uvel2 = ds2_ann['uvel'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "vvel2 = ds2_ann['vvel'].isel(time=slice(-nyears,None)).mean(\"time\").squeeze()\n", + "ds_angle = xr.open_dataset(\"/glade/derecho/scratch/dbailey/ADF/b.e23_alpha16g.BLT1850.ne30_t232.075c/ts/angle.nc\")\n", + "angle = ds_angle['ANGLE']\n", + "\n", + "vect_diff(uvel1,vvel1,uvel2,vvel2,angle,\"N\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8116dbe6-6052-4d4e-8cf1-8a9feaf7d48e", + "metadata": {}, + "outputs": [], + "source": [ + "vect_diff(uvel1,vvel1,uvel2,vvel2,angle,\"S\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5199b36e-614d-4242-9dd0-a402a7a24fa9", + "metadata": {}, + "outputs": [], "source": [] } ], From 0d44205865eb0bdddf3999b3763e7ec950b66ba9 Mon Sep 17 00:00:00 2001 From: David Bailey Date: Wed, 21 Feb 2024 16:08:07 -0700 Subject: [PATCH 8/8] Reset the ad notebook --- examples/nblibrary/adf_quick_run.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/nblibrary/adf_quick_run.ipynb b/examples/nblibrary/adf_quick_run.ipynb index d7eaf00..93c28d5 100644 --- a/examples/nblibrary/adf_quick_run.ipynb +++ b/examples/nblibrary/adf_quick_run.ipynb @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "4d0264e2-c116-4e18-af33-0ce3adabcd60", "metadata": {}, "outputs": [],