From acec3634ab6f46cd7c1b9a358ee64c05e593f729 Mon Sep 17 00:00:00 2001 From: Chelle Gentemann <35538868+cgentemann@users.noreply.github.com> Date: Tue, 19 Oct 2021 14:03:01 -0700 Subject: [PATCH] updates --- Ch2_Intro_JypiterNotebook.ipynb | 4 +- Ch4a_Python_Tools.ipynb | 68 +-- Ch4b_Plotting_Tools.ipynb | 706 +++++--------------------------- Ch6_Ocean_Example.ipynb | 290 +++++++------ Ch7_Atmosphere_Example.ipynb | 359 ++++++++++------ 5 files changed, 555 insertions(+), 872 deletions(-) diff --git a/Ch2_Intro_JypiterNotebook.ipynb b/Ch2_Intro_JypiterNotebook.ipynb index c62538d..df704d6 100644 --- a/Ch2_Intro_JypiterNotebook.ipynb +++ b/Ch2_Intro_JypiterNotebook.ipynb @@ -76,7 +76,7 @@ "source": [ "## __Test this:__\n", "### change the type of this cell between __Markdown__ and __Code__, and then run it to see the difference\n", - "myvar = 5+6\n", + "myvar = 5 + 6\n", "print(myvar)" ] }, @@ -143,7 +143,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.10" } }, "nbformat": 4, diff --git a/Ch4a_Python_Tools.ipynb b/Ch4a_Python_Tools.ipynb index 3e4da01..d7ab952 100644 --- a/Ch4a_Python_Tools.ipynb +++ b/Ch4a_Python_Tools.ipynb @@ -26,13 +26,15 @@ "metadata": {}, "outputs": [], "source": [ + "# this library helps to make your code execution less messy\n", + "import warnings\n", + "\n", "import numpy as np\n", "import pandas as pd\n", "import xarray as xr\n", "\n", - "# this library helps to make your code execution less messy\n", - "import warnings\n", - "warnings.simplefilter('ignore') # filter some warning messages" + "xr.set_options(keep_attrs=True)\n", + "warnings.simplefilter(\"ignore\") # filter some warning messages" ] }, { @@ -54,8 +56,8 @@ "metadata": {}, "outputs": [], "source": [ - "ds = xr.open_dataset('./data/HadISST_sst_2000-2020.nc') # read a local netcdf file\n", - "ds.close() # close the file, so can be used by you or others. it is good practice.\n", + "ds = xr.open_dataset(\"./data/HadISST_sst_2000-2020.nc\") # read a local netcdf file\n", + "ds.close() # close the file, so can be used by you or others. it is good practice.\n", "ds # display the content of the dataset object" ] }, @@ -73,8 +75,10 @@ "outputs": [], "source": [ "# assign a string variable with the url address of the datafile\n", - "url = 'https://podaac-opendap.jpl.nasa.gov/opendap/allData/ghrsst/data/GDS2/L4/GLOB/CMC/CMC0.2deg/v2/2011/305/20111101120000-CMC-L4_GHRSST-SSTfnd-CMC0.2deg-GLOB-v02.0-fv02.0.nc'\n", - "ds_sst = xr.open_dataset(url) # reads the online file and display it the same way as local files\n", + "url = \"https://podaac-opendap.jpl.nasa.gov/opendap/allData/ghrsst/data/GDS2/L4/GLOB/CMC/CMC0.2deg/v2/2011/305/20111101120000-CMC-L4_GHRSST-SSTfnd-CMC0.2deg-GLOB-v02.0-fv02.0.nc\"\n", + "ds_sst = xr.open_dataset(\n", + " url\n", + ") # reads the online file and display it the same way as local files\n", "ds_sst" ] }, @@ -96,7 +100,7 @@ "metadata": {}, "outputs": [], "source": [ - "ds_sst.analysed_sst.plot() # note that we needed to choose one of the variable in the Dataset to be displayed" + "ds_sst.analysed_sst.plot() # note that we needed to choose one of the variable in the Dataset to be displayed" ] }, { @@ -105,7 +109,9 @@ "metadata": {}, "outputs": [], "source": [ - "ds.sst[0,:,:].plot() # in addition to choosing the variable, we choose a time to visualize the spatial data (lat, lon) at that time (zero or the first time entry)" + "ds.sst[\n", + " 0, :, :\n", + "].plot() # in addition to choosing the variable, we choose a time to visualize the spatial data (lat, lon) at that time (zero or the first time entry)" ] }, { @@ -123,7 +129,9 @@ "metadata": {}, "outputs": [], "source": [ - "ds.sst.mean(dim=['latitude','longitude']).plot() # we select a variable and average over spatial dimensions, and plot the final result" + "ds.sst.mean(\n", + " dim=[\"latitude\", \"longitude\"]\n", + ").plot() # we select a variable and average over spatial dimensions, and plot the final result" ] }, { @@ -141,7 +149,9 @@ "metadata": {}, "outputs": [], "source": [ - "ds.sst.sel(time=slice('2012-01-01','2013-12-31')).mean(dim=['time']).plot() # select a period of time" + "ds.sst.sel(time=slice(\"2012-01-01\", \"2013-12-31\")).mean(\n", + " dim=[\"time\"]\n", + ").plot() # select a period of time" ] }, { @@ -150,7 +160,9 @@ "metadata": {}, "outputs": [], "source": [ - "ds.sst.sel(latitude=slice(50,-50)).mean(dim=['time']).plot() # select a range of latitudes. \n", + "ds.sst.sel(latitude=slice(50, -50)).mean(\n", + " dim=[\"time\"]\n", + ").plot() # select a range of latitudes.\n", "# note that we need to go from 50 to -50 as the coordinate data goes from 90 to -90" ] }, @@ -167,7 +179,9 @@ "metadata": {}, "outputs": [], "source": [ - "ds_sst.analysed_sst.where(ds_sst.mask==1).plot() # we select, using .where, the data in the variable 'mask' that is equal to 1, \n", + "ds_sst.analysed_sst.where(\n", + " ds_sst.mask == 1\n", + ").plot() # we select, using .where, the data in the variable 'mask' that is equal to 1,\n", "# applied it to the variable 'analysed_sst', and plot the data. Try changing the value for mask - for example 2 is land, 8 is ice." ] }, @@ -186,10 +200,18 @@ "metadata": {}, "outputs": [], "source": [ - "# comparing 2015 and 2012 sea surface temperatures\n", - "(ds.sst.sel(time=slice('2015-01-01','2015-12-31')).mean(dim=['time'])\n", - "-ds.sst.sel(time=slice('2012-01-01','2012-12-31')).mean(dim=['time'])).plot() # note that in this case i could split the line in two\n", - "# makes it easier to read" + "# comparing 2012 and 2015 sea surface temperatures\n", + "ds2012 = ds.sst.sel(time=\"2012\").mean(dim=[\"time\"])\n", + "ds2015 = ds.sst.sel(time=\"2015\").mean(dim=[\"time\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "(ds2015 - ds2012).plot() " ] }, { @@ -214,11 +236,9 @@ "outputs": [], "source": [ "# same operation as before, minus the plotting method\n", - "my_ds = (ds.sst.sel(time=slice('2015-01-01','2015-12-31')).mean(dim=['time'])-ds.sst.sel(time=slice('2012-01-01','2012-12-31')).mean(dim=['time']))\n", - "# save the new dataset `my_ds` to a file in the directory data\n", - "my_ds.to_netcdf('./data/Global_SST_2015-2012.nc')\n", - "# explore the content of `my_ds`. note that the time dimension does not existe anymore\n", - "my_ds" + "my_ds = ds2015 - ds2012\n", + "my_ds.to_netcdf(\"./data/Global_SST_2015-2012.nc\") # save the new dataset `my_ds` to a file in the directory data\n", + "my_ds # explore the content of `my_ds`. note that the time dimension does not existe anymore" ] }, { @@ -258,7 +278,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -272,7 +292,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.10" } }, "nbformat": 4, diff --git a/Ch4b_Plotting_Tools.ipynb b/Ch4b_Plotting_Tools.ipynb index 6a1df3b..857ed68 100644 --- a/Ch4b_Plotting_Tools.ipynb +++ b/Ch4b_Plotting_Tools.ipynb @@ -15,21 +15,23 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# basic libraries\n", + "import warnings\n", + "\n", + "import cartopy.crs as ccrs\n", + "\n", + "# necesary libraries for plotting\n", + "import matplotlib.pyplot as plt # note that in both cases we import one object within the library\n", "import numpy as np\n", "import pandas as pd\n", "import xarray as xr\n", "\n", - "# necesary libraries for plotting\n", - "import matplotlib.pyplot as plt # note that in both cases we import one object within the library\n", - "import cartopy.crs as ccrs\n", - "\n", - "import warnings\n", - "warnings.simplefilter('ignore') # filter some warning messages" + "xr.set_options(keep_attrs=True)\n", + "warnings.simplefilter(\"ignore\") # filter some warning messages" ] }, { @@ -43,518 +45,27 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "Show/Hide data repr\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "Show/Hide attributes\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
xarray.DataArray
'sst'
  • time: 252
" - ], - "text/plain": [ - "\n", - "array([-3.30897331e-01, 4.54846382e-01, 3.00818443e-01, 1.29148483e-01,\n", - " 8.01112175e-01, -1.00877762e+00, -3.31048012e-01, -3.97064209e-01,\n", - " -3.38874817e-01, -3.19175720e-01, -4.45547104e-01, 1.49649620e-01,\n", - " 3.49483490e-01, 2.27182388e-01, 7.71281242e-01, 1.02271080e+00,\n", - " 1.36554623e+00, -8.92753601e-02, -1.98171616e-01, -3.17031860e-01,\n", - " -3.07672501e-01, -2.43781090e-01, -3.72982025e-01, -2.11442947e-01,\n", - " 6.04343414e-02, 1.31679535e-01, 2.71362305e-01, -1.52760506e-01,\n", - " 1.01775837e+00, 1.11868954e+00, -1.68485641e-01, -3.78059387e-01,\n", - " -3.19509506e-01, -2.73833275e-01, -6.25120163e-01, -6.94087982e-01,\n", - " -9.42012787e-01, -2.35974312e-01, -1.57097816e-01, 5.65128326e-02,\n", - " -8.33005905e-01, 7.19216347e-01, -1.31516457e-01, -1.88463211e-01,\n", - " -1.60152435e-01, -8.85782242e-02, 1.76785469e-01, -1.40716553e-01,\n", - " 3.80771637e-01, 4.51512337e-01, 4.52872276e-01, 7.53019333e-01,\n", - " 6.35172844e-01, 7.76444435e-01, -6.02464676e-02, -1.81871414e-01,\n", - " -1.54745102e-01, -1.44616127e-01, 9.26447868e-01, 7.74226189e-01,\n", - " 1.40981865e+00, 5.86309433e-01, 6.15759850e-01, 8.01628113e-01,\n", - " 5.05560875e-01, 1.79129314e+00, -4.17070389e-02, 1.00601196e-01,\n", - " -3.49731445e-02, -9.72738266e-02, 5.20937920e-01, 9.10547256e-01,\n", - " 1.43687248e-01, 2.08891869e-01, 3.59481812e-01, 1.13406658e+00,\n", - " 3.45243454e-01, -1.08886719e-01, -1.20860100e-01, 3.14006805e-02,\n", - " -1.38828278e-01, -1.95417404e-01, -5.52134514e-01, -6.87589645e-02,\n", - " -4.46586609e-02, 2.32618332e-01, -4.76045609e-02, -5.84993362e-02,\n", - " 1.43807125e+00, -3.24426651e-01, -1.87075615e-01, -3.28876495e-01,\n", - " -2.05194473e-01, -2.16888428e-01, 7.60424614e-01, -4.37872887e-01,\n", - " 5.76897621e-01, 8.21498871e-01, 9.83402252e-01, 5.02943993e-01,\n", - " -3.41018677e-01, -1.22421646e+00, -1.29365921e-01, -2.33255386e-01,\n", - " -2.19539642e-01, -2.35297203e-01, -3.17799568e-01, -2.10827827e-01,\n", - " 2.26475716e-01, -6.63522720e-01, -1.62494659e-01, -1.01596260e+00,\n", - " -1.25256920e+00, 2.66690254e-01, 2.68864632e-01, 1.79115295e-01,\n", - " 3.43954086e-01, -1.74370766e-01, -7.06786156e-01, -6.43065453e-01,\n", - " -1.00566292e+00, -7.40477562e-01, -5.96883774e-01, -1.25046825e+00,\n", - " -8.20542336e-01, -8.15141678e-01, -1.24084473e-01, -8.83731842e-02,\n", - " 5.24875641e-01, 3.83309364e-01, -4.90839005e-01, -8.28794479e-01,\n", - " -1.32228374e+00, -1.23059082e+00, -1.40923214e+00, -1.38831139e+00,\n", - " -1.43156815e+00, -9.79669571e-01, -2.33493805e-01, -2.24025726e-01,\n", - " -9.33818817e-02, 4.99567032e-01, 5.96946716e-01, -1.78184509e-02,\n", - " -1.02391911e+00, -4.07871246e-01, -1.15186119e+00, -5.45604706e-01,\n", - " -4.45263863e-01, 2.36883163e-02, -1.32392883e-01, 2.86050797e-01,\n", - " 5.06000519e-02, 4.54120636e-02, -7.22856522e-02, 3.20945740e-01,\n", - " 2.01607704e-01, 1.30550385e-01, -4.62534904e-01, -2.70747185e-01,\n", - " -1.08127594e-01, -9.84119415e-01, 1.46083832e-02, -7.34024048e-02,\n", - " -5.88932037e-02, -9.53493118e-02, 3.68225098e-01, 2.88352966e-02,\n", - " -3.86842728e-01, -5.89871407e-01, -2.30422020e-01, -4.67920303e-01,\n", - " -5.10611534e-01, -7.29843140e-01, 2.25609779e-01, 9.05000687e-01,\n", - " 1.43318176e-01, 5.00793457e-01, 6.71805382e-01, 6.15715027e-01,\n", - " 1.65065765e-01, -2.64510155e-01, -5.18951416e-02, -8.50521088e-01,\n", - " -5.83344460e-01, -3.63260269e-01, 1.63125992e-02, 1.28406525e-01,\n", - " 2.79020309e-01, 1.05409622e-01, 8.74489784e-01, 1.09649181e+00,\n", - " 2.77795792e-02, 5.51834106e-02, -2.36040115e-01, -3.56391907e-01,\n", - " -1.00806713e+00, -3.05541992e-01, 1.69708252e-01, 1.21448517e-01,\n", - " 1.39780045e-01, 3.89154434e-01, -5.84437370e-01, -6.20881081e-01,\n", - " -2.35655785e-01, 4.92454529e-01, 3.91243935e-01, 1.66019726e+00,\n", - " 1.48748493e+00, 1.15177441e+00, 5.53584099e-01, 1.09727859e-01,\n", - " 2.54249573e-02, 5.07860184e-02, 2.59017944e-03, 3.83799553e-01,\n", - " 1.38415432e+00, 7.78230667e-01, 5.61948776e-01, 1.53582478e+00,\n", - " 1.49139690e+00, 8.82372856e-01, 5.35593033e-02, 1.11961365e-03,\n", - " 5.51986694e-02, -2.03218460e-02, -2.22192764e-01, -3.59700203e-01,\n", - " 1.89393997e-01, -3.69663239e-01, 1.45672798e-01, -5.06082535e-01,\n", - " -8.53225708e-01, -3.05669785e-01, 3.61281395e-01, 2.76041031e-01,\n", - " 1.91179276e-01, 7.40022659e-02, -5.25636673e-02, 4.80451584e-01,\n", - " 1.76343918e-01, -6.84862137e-02, -3.47769737e-01, -7.32810974e-01,\n", - " -8.99991989e-01, 5.08675575e-01, 1.94899559e-01, 2.71512985e-01,\n", - " 2.78450012e-01, 5.64737320e-02, -4.55958366e-01, -5.26703835e-01],\n", - " dtype=float32)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 2000-01-16T12:00:00 ... 2020-12-16T12:00:00\n", - " month (time) int64 1 2 3 4 5 6 7 8 9 10 11 ... 2 3 4 5 6 7 8 9 10 11 12" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# open the dataset\n", - "ds = xr.open_dataset('./data/HadISST_sst_2000-2020.nc') # read a netcdf\n", - "ds.close() # close the file, so can be use by you or others. it is good practice.\n", + "ds = xr.open_dataset(\"./data/HadISST_sst_2000-2020.nc\") # read a netcdf\n", + "ds.close() # close the file, so can be use by you or others. it is good practice.\n", "\n", "# select north and southern hemispheres, and average spatially to obtain a time series\n", - "nh_sst = ds.sst.sel(latitude=slice(90,0)).mean(dim=['latitude','longitude'])\n", - "sh_sst = ds.sst.sel(latitude=slice(0,-90)).mean(dim=['latitude','longitude'])\n", + "nh_sst = ds.sst.sel(latitude=slice(90, 0)).mean(dim=[\"latitude\", \"longitude\"])\n", + "sh_sst = ds.sst.sel(latitude=slice(0, -90)).mean(dim=[\"latitude\", \"longitude\"])\n", "\n", "# calculate climatology\n", - "nh_clim = nh_sst.groupby('time.month').mean('time') # note the application of two methods, first groupby, and then the operation to perform over the group\n", + "nh_clim = nh_sst.groupby(\"time.month\").mean(\n", + " \"time\"\n", + ") # note the application of two methods, first groupby, and then the operation to perform over the group\n", "# calculate and explore the anomalies\n", - "nh_ssta = nh_sst.groupby('time.month') - nh_clim # in this case groupby 'aligns' the data with the climatology, but only substract the appropiate climatology data point\n", - "nh_ssta # Note that the new dataarray (one variable) has a new coordinate, but not dimension" + "nh_ssta = (\n", + " nh_sst.groupby(\"time.month\") - nh_clim\n", + ") # in this case groupby 'aligns' the data with the climatology, but only substract the appropiate climatology data point\n", + "nh_ssta # Note that the new dataarray (one variable) has a new coordinate, but not dimension" ] }, { @@ -572,31 +83,21 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAEKCAYAAACxGTlMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3ycx33mv7MdvZJgE0FSIqneQNmUrQJZti9xnFxcJVnuUZQ7+xzbsc+xrjiKcz7JiRzF7RLJJXJsRc7ZVuyzZMuSLUKVVAFFFfYGkGAFgUXdvjv3x7zz7rsVC+BdABTn+XzwWey77847+5aZZ55fE1JKDAwMDAwMDAwM5h6e+e6AgYGBgYGBgcGZCkPEDAwMDAwMDAzmCYaIGRgYGBgYGBjMEwwRMzAwMDAwMDCYJxgiZmBgYGBgYGAwTzBEzMDAwMDAwMBgnmCImIFBlSGE+KgQQlp/64p83u34/K1V7sfHy/TvnCm+v8ra76Mu9adPCPGjEp/9LyHEnOfWcZyLVVVsu9LzfIvbfShyLH3vdbvQVqMQ4q+FEDuEEJNCiLAQ4lUhxD1CiMWO/YJCiM8KIV4WQowLIcaEELuEED8QQqx1/P6p/npm22cDg4UA33x3wMDgDMI48CHgf+Zt/7D1WUOVj/9R1DP//Sof53TGw8CVwLH57sgcYSvq9+6YTSNCCC/wW2AV8FVgG1AHXAjcBCwDTlq7PwC8HfhbYAvgBc4D3gecDzxi9cmJzcB9wD2ObWOz6bOBwUKBIWIGBnOHB4EPCiG+JK1MykKIGuA9wM9QRMlgHiGlHAQG57sf1YZFnISUcgxFhmaLa4ErgD+WUv7Csf3/Af9bCOGxjrsGeBfwGSnl1x37/Rr4eyGER0qZye+TEALgiJTSjb4aGCwoGNOkgcHc4YdAJ3CVY9u7UIrAz4p9QQjxQcuEExNCnBJC/FAIsTRvnz4hxI+EEDcKIXZaZqEXhRBXOfbpQU2Wby5j2mkXQtxvmYqOCiG+IYQIlfoxQojPCyHiQohFeduFEOKAEOKBqU/J9CCE+NO88/E9IURr3j7SMm1+TgjRb52Ph4UQi62//yuEGBVCHBZC/GXedwtMk0KIDwghXhJCTFjfe1UI8WeOz+8TQgwIId4khHjB6lufEOJTJX5GpefZK4T4shDimBBiRAjxSyHEilmck68IIb4ohDgIJICLSpkmhRDvEkI8Y/3mMSHE80KIPyrxewD08Y4X+9AiV9PZz8DgjIEhYgYGc4d+4EmUeVLjw8C/AxP5OwshbkWRt53Au4EvAv8BeEIIUZ+3+9XA51BmzxtQ5O4hIUSz9fkngJeAV1BmnyutbU78ENhvHesfgU8Ct5X5Pd8HMsDH8ra/HVhNrhmpFIQQwpf/B4giO94J/B+UCeyPgP8K/B7wa0vhceJDwFtQv/FTqPPzL6hz/QpKhfwVcKcQ4h1lOncV8CPgCeCPUeaz7wDNebs2Av8G/MDarwf4hijuT1fpeb4NOAf4OPBp1DW7P69/0zknHwX+APi89Xq0xG/+FEq9PQl8xPrN/44yO5bCViAF3GORuJYS++1CmRTvtBYZHWXaNDA4MyClNH/mz/xV8Q81AUqyk2oYCAFLUZPX24Bua5+3Wt/xAieATXltXWXt9+eObX1Wmy2ObRus/T7g2NYDPF2mf3+dt/0hYI/j/Sprv486tt0H7EOZufS2B4FdFZyXPqu9kn95x04DX8pr483Wvn/s2CaBPYDPse3vre3/w7HNhyIb/1zkXKyy3n8eGJ7id9xnfefGvO2Poci3mOF5fiJvv89b25fN8JwcBWry9tX3Xbf1vhHlr/jgDO7zW1ALCoki6NuBv9P9dez3hyjzr77O+4FvAeeWaVsC/2u+nmHzZ/6q+WcUMQODucVPgCBqMroZZaL5XZH91gOLyVNApJRPoyb3a/P23yylDDvev2q9rpxG3x7Oe/9qBd//P8DZwPUAltn0D6lMDQPlG3RFkb/8gIK3oRT8+/OUs+dQCss1efs/JqVMOd7vsl5/ozdYn+8DzirTvxeAFsv0+06HwpiPNIXm5R+jzt/yvO2Vnudi++HYd7rn5BEpZbRE/zXeBNQD906xXwGklN9FncsPWt/3oMjjdiHEBY79fokike8GvgmMYCm2oopRwwYGCxWGiBkYzCGklOPAz1Gmsw8D98vifjHal6ZY9N5xx+caw3nHiVv/lvTxKoLhvPdxFGksCSnl88CLwH+yNt2CUvl+UOkxpZQv5v9R+Lt1+oN9QDLvrxFoy9s/nPc+UWZ7yXMkpXwCZZo7C2WeGxRC/FYIcXH+8aSUybxtJ6zXfCJW6Xkuth+O/k73nFQSCaq/M1DBvgWQUoallPdLKf+TlPI8lJm2EfjrvP0mpZT/LqX8cyllF4oApoE7Z3JcA4PTGSZq0sBg7vEvKLXDgwrtLwY9CS8p8tkSFPlZKPhHlG/QchQR+4mUMp9EzBZD1uvbKSRTzs9dh5Typ8BPLb+8blR6hkeEECscJLpFCOHPI2Pa/+lIlbo23XNSSV62U9brcuC1GfYre0ApfyGEeBmVlqLcfluEEI+i/NsMDM4oGCJmYDD3eAz4v8CIlHJ7iX12oxSVG4Hv6Y1CiDehIi+/NoPjxqlOrrIHgLuAf0WZzf6pCsd4DOV3tFJK+VgV2p8SUsoJVADEGuDrKPVIp7rwogIAfuz4yo3AIapHxKpxTp5F+XndisOMOxWEEO3AhJQylre9DqUmvmK9byCbNsO5nxdYy5mTv83AwIYhYgYGcwwpZZrSSpi9jxDiSyil6UeoyL3lwFeAvcA/z+DQO4BPCCFuQDlIj0spd8+gnfy+RoUQ9wGfBV6VUj472zaLHGO/EOKrwLeEEOtRUYwx1CT/NuC7UspNbh9XCPFllLK1CeXsvgL4c2CbVDnHNMaBv7UIyV7U9X0rKrChKhUCqnFOpJTjQojbgG8KIX6G8lEcBy4FYlLKb5b4ajfwj9Z98BTK76sTFbHaigqWAOX7uEkI8UOUb+RJVNDKLajkr/mRvAYGr3sYImZgsEAhpbxXCBFBpST4BUqp+BXwBUudmS6+ipoIv4tyyH4CNYG6gZ+giFilTvrThpTyvwkhdqLSPXwSZWo7jJrQ91bpsM+hiNfdKEJxEniUwuoIYygF7OvARSg189NSykp95WaEapwTKeW3hBDHUffd/Sifs53A35T52hbUffUWVMqLFhQZewF4m5TycWu/fahIyreicui1o+7rbcD7LDOwgcEZBVGlxZqBgcEZBCHEV1C5rpblm51e77BUoLdKKQuSrRoYGBhMBaOIGRgYzBhCiMtQKtungXvPNBJmYGBgMFvMWfoKIcT3hRAnhRCvObZdKoTYIoTYJlRJljfMVX8MDAxcwb+j/NV+C/zVPPfFwMDA4LTDnJkmhRDXoHwB/kVKeaG17VHgbinlr60yI1+QUnbPSYcMDAwMDAwMDOYZc6aISSmfpDBBoUQl+wNookTtMwMDAwMDAwOD1yPm20fsM8BvhBB3oUjhmyr5Unt7u1y1alXVOjU5OUldXV3V2jeYGuYazD/MNZh/mGsw/zDXYP7xergGvb29p6SUi4p9Nt9E7D8Dn5VS/kwI8X5U4sqitcaEELeikgzS0dHBXXfdVbVOTUxMUF9fX7X2DaaGuQbzD3MN5h/mGsw/zDWYf7wersF1113XX+qzOU1fIYRYBTzk8BEbBZqllFIIIYBRKWVjmSYA2LBhg3zxxepVeOnp6aG7u7tq7RtMDXMN5h/mGsw/zDWYf5hrMP94PVwDIUSvlHJDsc/mu+j3UeBa6/+3UL2kjAYGBgYGBgYGCw5zZpoUQjyAyuLdLoQYQIW6/ynwdSGED1Wa49a56o+BgYGBgYGBwXxjzoiYlLJUbb2uueqDgYGBgYGBwcJDMplkYGCAWCxW8FlTUxM7d+6ch15NH6FQiBUrVuD3+yv+znw76xsYGBgYGBic4RgYGKChoYFVq1ahXMazGB8fp6GhYZ56VjmklAwNDTEwMMDq1asr/t58+4gZGBgYGBgYnOGIxWK0tbUVkLDTCUII2traiqp65WCImIHBFOjtD/PtTfvo7Q/Pd1cMDAwMXrc4nUmYxkx+gzFNGhiUQW/fMDd+ZwvpjCTg83D/LRvp6myZ724ZGBgYGLxOYBQxA4My+M32EyTTkoyEZCrDlgND890lAwMDA4MqQAjB5z73Ofv9XXfdxe233w7A7bffXpBIftWqVZw6dWrWxzVEzMCgDM5dqhxEBeD3edi4pm1+O2RgYGBgUBUEg0EefPBBV8jVdGCImIFBGaxdrIjYW85dbMySBgYGBgsIbvvv+nw+br31Vu6++25X2qv4uHN6NAOD0wyJdBqAN65pNSTMwMDAYA7w17/czo6jY/b7dDqN1+vN2Wc8lmTX8XEyEjwCzl3SQEOodO6u85c18ld/eMGUx/7kJz/JxRdfzBe+8IWCz+6++25+9KMf2e+PHj1ayc+ZEoaIGRiUQTyVASBhvRoYGBgYzD/GYikyVqnsjFTvyxGxStHY2MiHP/xhvvGNb1BTU5Pz2Wc/+1k+//nP2+9XrVo16+OBIWIGBmWhCVgiLee5JwYGBgZnBvKVq2IJXXv7w9z83S0kUxn8Pg9fv/Ey16wWn/nMZ7j88sv52Mc+5kp7U8H4iBkYlEHCKGIGBvMCk7/PoBy6Olu4/5aN/MXb17vuv9va2sr73/9+vve977nWZjkYRczAoAwSaUPEDAzmGr39YW68d7PJ32dQFl2dLVW7Lz73uc/xrW99qypt58MQMQODMkhqImY57RsYGFQfWw4MkbTcAXT+PkPEDKqNiYkJ+/+Ojg4ikYj9XucTc6Kvr8+V4xrTpIFBGRjTpIHB3GPjmjZ0oRiTv8/g9Q6jiBkYlIEhYgYGc4+uzhaaa/34PIJ/+tAGo4YZvK5hFDEDgzKw01ekDREzMJhLZCQEfF5Dwgxe9zCKmIFBGRhnfQOD+UEsmUaIqfczMDjdYYiYgUEZJFPKYThuiJiBwZwhk5HEUxnSGYmUEmEYmcHrGMY0aWBQBjpa0ihiBgZzB73wSVmEzMDg9QxDxAwMyiBhfMQMDOYcsWQ2Xcx4LDWPPTE40/CVr3yFCy64gIsvvphLL72U5557ju7ubl588UV7n76+Pi688ELXjmlMkwYGZaCJWNIQMQODOUMslSViE/EUixqC89gbgwWNTXfAdbe50tTmzZt56KGH2Lp1K8FgkFOnTpFIJFxpuxyMImZgUAbGWd/AYO4RTTiImFHEDMrhiTtda+rYsWO0t7cTDCri397ezrJly1xrvxSMImZgUAYJy1nfEDEDg7lDLJl93ibihoidcfj1F+H4q/bbmnQKvGXoyj//wdRtLrkIfr88aXv729/Ol7/8ZdatW8db3/pWbrjhBq699loAbr75ZmpqagBIJBJ4PO7pWIaIGRiUgVHEDAzmHvmmSQODHIz0w+jh7Pv+p9Vr01nQ3DnjZuvr6+nt7eWpp55i06ZN3HDDDdx5pyJv999/Pxs2bACUj9g73/nOGR8nH4aIGRiUQcKaEIyzvoHB3MHprD8RT85jTwzmBXnKVXR8nIaGhuL73t4Et4+6dmiv10t3dzfd3d1cdNFF/OAHP3Ct7VIwPmIGBmWglTATQm9gMHeIO02TxkfMYI6we/du9u7da7/ftm0bnZ0zV9gqhSFiBgZlYEyTBgZzj6gzfYUxTdro7Q/z7U376O0Pz3dXFg6u/aJrTU1MTPCRj3yE888/n4svvpgdO3Zw++23u9Z+KRjT5BmO3v4wWw4MsXFNm6npVgTOPGImw7eBwdzAaZqcNEQMUGP1jfduJp2RBHwe7r9loxmzwbXUFQBdXV08++yzBdt7enpy3q9atYrXXnvNteMaInYGo7c/zAe+s4VkOmMe7BJIpFXUpJQqy7ffa4iYgUG1ETOmyQL8ZvtxktZ4lExl2HJgyIzXrxPMmWlSCPF9IcRJIcRrjm3/JoTYZv31CSG2zVV/DGDLgSHiqQwZmX2wDXLhNEka86SBwdxAK2INQZ8xTVpY0qhyWwnA7/OwcU3b/HbIwDXMpY/YfcDvOTdIKW+QUl4qpbwU+Bnw4Bz254zHxtWt9v/mwS6OhCOM3hAxA4O5gfYRW9QQNIqYhaDfC8BlK5tft9YLKeV8d2HWmMlvmDMiJqV8Ehgu9plQjjfvBx6Yq/4YwHnLGgFY11H/un2wZwtn2gpT5sjAYG4QT6YRAlrrAiaPmIVDQxEAzmqtfV2O1aFQiKGhodOajEkpGRoaIhQKTet7C8VH7GrghJRyb6kdhBC3ArcCdHR0FDjPuYmJiYmqtr9QEI4pYhHKRBk/+DI9B+e5Qw4slGswPhnDIyAj4Ymnn2VR7ZkTaLxQrsGZjDP1Guw5kMAvIDE5xlBCzus5WCjX4MXdMQAODJxYEP1xG0II6urqOHz4cMFnp1OgVDqdZnJykv7+/oq/s1CI2E1MoYZJKe8F7gXYsGGD7O7urlpnenp6qGb7CwW7j49Dz5PUNTTT3b1xvruTg4VyDTxPPUaDRzIaTXL5FW/g7EX1892lOcNCuQZnMmZ6DU73aOjHR1+j9uRRVi5rZ8exsXm9DxfKc/C3Lz8FjOGtaaC7+83z3Z05xUK5BtXCvBMxIYQPeDfQNd99OdMwFlMZq505ewxykUhlaKrxMxpNGh+xMxCnI6Hp7Q9z83e3EE9mCPpPz2joaCJNjd9LQ8hnfMRQitChYWWaHI2+fioNVPv5Ol2e33knYsBbgV1SyoH57siZhtGIeqBjhoiVRCKVoT7os/83OHOg8zal0vK0IjRbDgyRSGWQqHv2dExzEEtlCPm91Ad9xkcMCEeSTMRTeD2CkUhivrvjCnr7w9xwz2ZSGUmoCs+XTs8UT2UI+jz8658u3Od3LtNXPABsBtYLIQaEEH9ifXQjxkl/XqAVMUPEikNKSSKdoT5kETHjrH9GYcuBIZJpieT0Su+ycU0bXo/yp/F6xGkZDR1Lpgn6PNQFfUQSadKZ09eB2w30D00CsK6jgdFokkyVzsdcZu7fcmCIVCY3L5rb7dsJuRf48ztnipiU8qYS2z86V30wyIWWuJ3JEw2y0MTLKGILD3NhcrhiVbbd0ym9S1dnC3927dl86/F9vH/DWQtWBSiHWDJtK2IAE/EUTTX+ee7V/EGbJS9e3sTOY2NMJFI0htw9H739YW76zhZSc5Tge+OaNjsQyutx//nauKYNn1eQTEs8YmEvSM6cEDCDAoxFleRvfMSKQxMvQ8QWFnr7w9x07xa+9uhubv7ulqqt3tvqVQLNxpDvtDFLaixuUH33nCaRZvmIJzO2jxhwxpsndeqKC1c0AVm3Ejfx5J5BEnOY4Lurs4W1HQ0AfPyqVa4/X12dLXx4oyrYvbQ5tKCfX0PEzmAY02R56HIidUGVSDFuiNiCwJN7TpJIV3/C2H9yAlBh9Qt5EC+GSEI908dGY/Pck5khmkwT8nuoDyrVpxr1Jk+nAtr9wxE6GoMsaVT5qUaqQMScC/K5UoB1bkY91rqN5toAAAPh6IIOclgIzvoG8wR9Y8ZTGTIZicdz+q2eq2miyipiajLQpsrTJRLn9Yp11ioaqmPS0DhwSvnlTMZTp1UeI3ASseg892RmsE2TliI27nLkpHbkTqSqF1na2x/mN9uP8x8uWDLrtg8NRehsraO5Vo1Feux2ayySUvLknkEAljeH+MZNl8/J2KaVvX3WosdtOMtjvTIwwtVrF1XlOLOFIWJnMMYcK4R4KkNNwDuPvZk+evvD3KyjYqowmNpELJQ1TepIunRGmkLp84TlLbUAeAQ0hHw8s09NIG5fhwODanJIZSRxK4rvdEE0oSag01URi6W0j5g6526bJnWdXahOZKn2t0qkMtz3bB8PzDJib9/JCZY2hzgSVsR6JJrgxb5hbrhnC5LZj0X/+twhdh0fx+uBhpB/TsY0KSUj0SoTsViS+qCPyUSKrf0Ll4gZ0+QZDKdUWy0/sWrK/3owdYbpu4lEOlt4GJSM/sSekyTT0hRKn0fo8P33dq1gaDLB3Y/trYqv2P7BSfv/apjGqgmtiA1PJk5L14NYUqevUAqQ27nEtKO4872b2HJgiKRF9GY7Tmzef4rhSIIdR8f4y5+9AijT5GM7TpCWsx+LevvD/M9fvAaAlDA0GZ9xX6eDsViKdEbSXOvnyEi0Ks/YWDTF4sYgaxfX89LhhWuCNkTsDMaYY3CrxmCt5f9qOVU7w/R9XvdNVPEiitj5Sxvtz6vlR+EWeT2dfGCmA+0f02BFjVUrvcSBwQlqLBVsMn56kZloItvf46ehKhZLWD5itrO+u/49XZ0tXHpWM6Ci9n7+0hFXnxPn2CTE7Ijer149Dqj7PGW5R4xGkyxtytYznM1YtHn/KXQ2DCndNwOXgjZLbrDUtwOOhY9bGIslaQz5uXxlCy8cHOZbj+9dkOOhIWJnMMaiSfxeNVhUQxHTilW11KOuzhb++LJlAPz3d5znupyeddbPErHOtjoAVjTXVM2v5IZ7NnPXb2ZHXqtNgucTYUsRu+ocNfEI3CfFw5MJwpEkFy5XxHvcZSJQbUQcROzoaegnljVNaiLm/vjk9QjWtKvn+Ydb+l19Tro6W3j/hhUAhPxeLrNI30ygXSS8Qt3nAa+H0WiSoLVIaAjOLqpXl20TqHOSTGXswtvVXMzp53jDqlYA9g2Ou36M8ViKhpCP1jo/k4k0f//YngU5HhoidgZjLJpkcYNaVVVDEXPK/9VSj+oCaqBe3lzjett6ANSmyUQ6Y/uqJNKZqvhR6CSHs1V5qk2C5xNaEbt67SLa6gJcuLzRdVKs/cMuWq4m0NNNEZtMZPNunW6KWDojSaYlIZ+DiFVBpRmPpfB4BNpC6fZzUmuNTZFEmr2z8IHadWKctYvr+Yu3r+f+WzbSWhdgJJKg30ppMR5Psa5j5jVw/V5FAz7wxpXccMVZpKWyBmh/2NkuCktB+4ddsqIZn0dUxU9MK2LjMfX8LtTx0BCxBYpqm5XSGcl4XNnPoTpErKuzhYuWN1XVqV3L6NXIM6SJWG0gm75CTwgnx+M55h+34CSrsyGvc0GC5wsjkQSNIR8+r4fGGj+r2uur4KivzCSXnKXyNp1uPmLRRJo1i5Tac7o57OuxqCbgwesR1Pi9rpsmQY0dK5prbBOi32X3hhGHxeHF/uEZtTE4HueVgRH+6JJlfPK6c+jqbKG51s9IJMmh4awpb/8szHq7Tygl6ou/fy7rl6iI5Il4quqVJbSv56KGIB2NQX6z/YTr851WxN6wWo0PHrEwx0NDxBYgNu8/xfv/aXNVzUrjVg6xDlsRq06OrJqAl1Q6w+UrZy7Nl4POhTZeDSJmOesH/V4CXg+JVMY+HmSzXbuJrs4We/C+72NXzJhgdHW2sL6joSo13OYbI9GknR8o5PdWhRA/s/8UXiHs0jqnW0LRSCJNW12Allp/1VJYVGuxqN0kdJRqfag69SbHY0lWtdfxJ1etBuBbH3A3ZcNoNMnZi+pprw/S2zezc9Sz+yRSwnXnLra3NdX4GYkm6TsVobNNRRDPRk3ac2Kc5c01NIT8tgI5GU/lkJVq+OBqZfvw8CTHRmPsOznh+nw3HkvSWOPnDatV3996XseCHA8NEVuAePjV465Ew5SDzqrfYSli1ZjMADvCsFpRmfp3VMN0oRWxgNdDwKeImHNC6Bty37k0kcrYvmkdjbMztwZ8HlJpWTUSPF8IR5K0WPmUavwe4il3763e/jC/fPkoaSm57cFXgdNQEUumqQn4WNJUw7ER9xWx5w8O8d5/erYqZiutiIV8ioj5PYKXDo24egwpJRNxpZacv0z5Aa62FES3MBpJ0lTjZ0NnC0/vG5wRaX1w6wD1QS9xx/jZXOtnNJLk0HCEq9e24/fOzqy3+/i4rYRpf9jxWIrLVzZjWS352Jvcz3yvfcReOzqG5ZLm6nyXSGWIJTM0BH22VeOKVa0LjoSBIWILEnqVUw0nZA2dumKxlak55vJkpqEzJ1eDKEFWEavGRJmwCFHAZxGxdDrnd+iyI27C+TsGwrNrP57K2DmwXk8YiSRoqqIituXAkB1FpqPUTj9FLEWt38uyphBHq2Ca7Nk9iJTViVjV6nzQ76G3P8yxsRi7jo+7SvgmE2kyUuWh036mEZf9AEeiCZpr/SxpCnJyPDFtC8fzB4fYfGCYiXiam7/3nP29pho//cOTTMRTrGmvZ3V73YyJWDKd4cDgpJ0kucFR2zOaTGPd/vRXQf0fiSRpCPl409ntVTEPa6tPQ8hn++tNJhbmc2yI2AJEW52aZN6wurVqMqomMB0WEauWIqZVpWpNZHPhIxa0IpW0IuYRqv5g/7D7ipjzdxwenp1Jqdrnfr4wkqOIeV1XW/P99OD0O4eRRJqagJclTSGOV8E06axu4PZi0fYR83vZcmCoKmqJnqTrg35qq5Q0djSapLkmQCKlfsB0LRyPbj9h/+/8XnNtwCarnW21nLO4nn0nZxZx2D80SSKdYf0S5eyv04VMxlO26TDk9/DMvlO2md4tjEQUUe3qbOHjLpmHneZyPTc01vhtX8OFqmwbIrYAMTypJNs1i+qqJqNqRUybJmNVUk2SeYqC234lujqAfujcbF8TGb/DNDkeS1Ef9LGqvc6OWnITTh80NxQxOP3MalMhHEnQ4lDE3A406epsIeTzsKGzhftv2UjI7zmtzqGUkkgiTW3Ay7LmGsKRpOsLLWcOq2+77FsVc/iIbVzThtcqLeUm4dPKdkPIl+MX5SZGIkmaav1cvbYdmL6FQ5tM8x3MdTQsWERsUT2HhiMzeg52H1dKmibWdQ5FTBOx68/rYCyW4pWBkWm3Xw4j0aT9HF/ggnm4tz/Mzd/dYpvLXzioAiR0vsG6oJfJKgkOs4UhYgsQ2nYenqxe7qKxaK4iFquijxiogU+X/XDLrySTkUwktCKWtHNn/d1vdvOB78y+/YRlrs2aJjNWFI6fzrbqEDGn6fNweHZKhiZic5WgcS6Qsq6BnowUEXN3EZFKZ4ilMly9dhFdnS3UB/2u57GqZlR0Ip0hnZHUBrx2keivPbrb1WONOKpyuF2wWV/PkN9LV2cL77xkKV4huITIgKIAACAASURBVP9P3uga4RtzEDFNPtw0W8WSaeKpDE01fq5dr8rqXLNu0bQsHKutHGfvumx5zvd0vUkhYEVLLed0NJCRM/NZ3X1iHI/I5hJrcPiIjUTVPPQHFy0F4GuP7nH1HgpbPnSQTUM0GzK85cAQ8WS20soL/ZqIqbZrAz4iC3RBZYjYAsSwRcA0IasGtPKyuKF66SsgVxHbcmCIhFWSyA0zw3g8ZZstJuNpu31wp+SRLvId8Hnwez0kUpKJuKpd1tlay5GRqP373IJWDhuCvlkrYppIzrVZrZokQyu5tmky4HHdNJk1aagBvD7orklD10itVlS0Vr9qAj47Ee33nzno6rFGHGPT1kPu9j+riKnp6ZIVzaSlZM2imefKyofTf6jeoQK5BX2fNtf6qQ34CPk9rOuYXpoVvZB6z+Urcr6nycuSxhAhv5dzrPMyk2fuuQNDNNX62X50DMg1TerM97FkGgE8ve+U6/eQVsTsCgqzWDRuXNOGz4o493oEqyxfa03E6oI+o4gZVI6wZZqsJhEbjSbxegRNNX58HlG1qEYnEXPmtvJ6Zm9mcBYtH7fa106fHiFm3X5B1KSV0LU+5GNlWy3pjOToiLv+N3oyOHdpw6x9xObDNOm2KpmPsDU5tFh+lCGf+6ZJvUhptE0aPlfPYbWT7eqs+nUBL32nFJl3+1j6Opy7pMH1a6wDh3R5KZ3r8MS4e0EH9oIn5Lcj6tx01tdmveYadZ+21QUZmpzeeK6f32BesXndpg7qGrWUq4dePjYtotTbH+b5g8OEJ5P292r8XjxCnR9NJvecGEdrnm7eQyORpK3uuUGGuzpb+LNrzwbgwxs7abdSM9nPccD4iBlMA8PaNBmppmkyRWPIhxDKibFaecQSDjKgc1uBkttna2bQyoXfK5iIJenqbOE9l6uyIosbg7NuX0dN+r2CoNdDIpW2EwSuskodffNxd5Uf/ZvOW9rIqYn4jEmGlNJW9OZSEXNblcyHnnS0KlATUM76uiSLG9ApURprskTMzTx1G9e0Ybk9IVxYMOQjYitiXq48uzploEYiKlnpNesW8erAqKtk2GmahKz7xMkx94pRjztNkwH3FTGtGOr7tLUuYPv+VgqdsiLoy52mNXmZjKfp7Q+z9ZDy3ZqupWHLgaECgiWEoC6o8rZp8/M1axe5nhw6nZGMxbL5AN1SJZc1qZQ/Pq/HXqhrIlZrFDGD6UArYiORRMEE45bZZzSatCeaYBUizzS0/4ieyNLW7znigpLkjPzUD3CNtbo9NhpjcHx2A3cilSHg9SCEyOYRs5z19UP+s94BV+V6/TvOs4qLD8zQTyyZlrbZNn9wq6bp0G1VMh/ab9LprC8lrqboyCpi2jTpriLW1dnCJVbtweZaP5esaHKtbciaJmsDPpuIda+fnn/SVFARbwG6OltIpDP8zUM7XLuf9FgUtEyT2n3ixJh7ilg2atKHxyOodVktcZomAdrqp0/EdACVNtFqHLZSSbx2ZJSbv7uFltqAXaZpOkRJ75dP0uuDPiZiylk/4PVw5dltvO38Dmr8XtfuobFoEimh2bHYgdmr99oCc2w0ZpNtbfasC3iNj5hB5dAmyWRa5kyiL/QN875/etYV3xJdgwuUn028yqZJ/YBpyX7robCdo2mm0A/asuYauxZgOJKw1YYX+2ZWVkQjkcoQsFajtrO+lQRy13HlU+F2HqWJWAqvR7B2sfL7ODxDP7GE49w6/S6qXQy8q7OF93YpVbLDBVUyHyPRQiIGEHdR0bVX0jXVMU1qhPweTk0k+PxPXnb1Omin89qAl/qADyHgouVNrl4LnULEZ5Huf33ukGv3Uzwvs76uh3tylgsrJyZiKYTIOokr/yEXFTHrHnIqYkMTM1XEck2T+wcnEGTHnnAkQWdbLWcvqpsWUdKFyK88uy3ne/WWIjYaTdBU60cIwer2etIZ6do9pOe4ljp1frQf12yVZ63GH7eIWH3QZy8M64I+Wy1eaDBEbIEhk5GEI0k7rcSIwzz5u50nyEh3/D1Go9mIlZAvq4i5qZZkMpJUJhs1KaVkJJpkeXMNkUSaHcfGZtW+njCXN9cwEU/Z5+68JY2E/B5emGFZEY1EOp0lYl6dviJJQ8jPlWfPLCR9KkzE1eBxVqvy/5ipIuYk1k4SMRfFwLUqeXQ0Nm0VYCrYJh9HHjFwt3KDrYjVZP1X3I6aHIsmuWRFMwL4+bajrpLiqMM06fEI6gM+O0rQLYQjCZprAuw6rvJXubkgyc+sXxPw0hDycdJFRWzMmqQ91iTt9jXWju76Pm2biWnS9hHLnaavPLudoN+D15HWYklTiLa66S18tC/etesW5XxPl5QacUQ1NoR8JNIZ16pYaKKq/d2CPlVXdLYLHr0APTYWZSyWtAkeWD5iJqHr6x9ukJjxWIp0RrKmXSkizod37WL3kiieHItxcjxGb3/YzsXU2x/mpnvdU0tyVJl4mlgyQyKV4W3ndwDw/MHZKVZ6wtQ5jSYTKcKTCRY3Bjl7UR0Pv3p0Vr9BmyZBKWKRhPoN9UEfXZ0ttNUFuGBZo6smn7GYispcVB/E5xX8ctuRGf0G57l3rjKdARPV8E+C3MXDVpfIhX62dh4bw+sRttmwJqCuj6tETPuIhaoTNQkwGk3l9NlNUhyxTZOKyDSEfK6nMNGO1qXMW7NBLJnB6xF2zVVQ7gduKmLjsZSdqgHUuXLTbKWDofQxWuuCRJNpItMgAjYRy1PEuqz8dn/x9vX22NMY8ufkIKwETsLuRFYRS9qmQ9uHy6X7SC+osqk4hG0SnQ20InZiNM5YNJeI1VZJ2XYDhoi5BLeixbSj/tmLlTO4M3JSEw6PgO9/ZOYFoXv7wxwZibHnhCqymkpniCat9A9p99SSZA4RS9p5adYvaaCjIci/vXB41qQVHEQsniZs+dXtPj7BibE4N8/iWiTTMsc0qUlxvT24BjirtdZVk8+EFQzw0uER0mnJ833hGZFip6nOOfh0dbbYdeU6mkJVqUMZjiRYu7gen0fQ60JqA51/7muP7ubn245SF/AiLPuzVk3cdBYfiyXx5JmtVLkXFwMCYklWt9c5wu3dU1X1ZK/73xDy2z5RbkGX7+nqbGF5Sw1rO+pdW5BEk2lCPo99jUH5ibntI6YTfQK2g7pbGIkmaKrx279BV0uZjnlSq0/5zvqgnuNPXneOfb7VNZ5e//OLq2s4fcTcjGp0wo4qtVwM7OPOUpXUc04inaF/KJJ7jQNekmlpk7WFBEPEXIJb0WJ2Vn1LEXOqC5qkZWS29MpM+6qRTCkSFktmciYCnws1v5yJHifjaduBdWgizqmJBHtPTsxKeRuLJqkNeO2HeSKeJDyZYCKenTQT6Zlfi0QqY6/KtSIGWefPaigN2jRZLKJpOshVI3P7mEpLgj4PR8JRbnvw1aqkmFjSFOKC5U2utL1p10kSljk1nZF4HUpJKFAF02RUTdJOsxW4NwnFkmkSqQzrlzTwrQ9cDsBH3uxeUWV9LrTS0Vjj7n0qpbQKr6vnbnFDkI7GkGv9jyXTBeTAbUVMF/zWqHfbR8xh1gO1aAOmZZ60a25WMNY31vhy0vlU1n5umhANHZyi3Fdy83y5dR/ZaWhqs+dIEbHZLRicJOvAqQlb1QbsepPTUSXnCoaIuYSNa9psx1UhmDGJ0RGTZy8uNE0601m8NAulYePqViBrTljcECSWTHPh8kZ7n09ff86sB9ZknnlMk8rDwxEyVkjfbJQ37QOgB4mhiQSTiTTrFtfbRNXrmbn5LZ7KELAUF22iBIfJKuR3Na0BYOcpc5oQZ2LycSpi+avMcCTBxjXqHvjxC4ddd9rXiRq7Vrbw0qEw33x876za1+VPQKnB2nkbspOIm5UhxmIpO5kruBfRZbfvCKt/+/kdNIR8RF2cHApNk9M3W5WDdjHQC6CZqDFTtZ9PxBY3BDk5FnctTYlOQ6OhAjJc9BGL5hKxtvrpE7F4SvmoOpXBUmi0xqLpqLbRhBoj8omYTtcyEklkfcSC7hKxXcdGAdjrKFZeF/TO+ho4F6DJtMxRxOxSVgvQYd8QMZfQ1dnC+zaoaLHagJdLz5qZyUerXqvaahEiN4P1iPUQL2sK8dKhmdf9utAKl7/qnHbuv2UjS5pqiCXTOYPE4fDszQDO1YmziOwVq1vtSBb/LJS38ViKxpDffsC0Y/sFy5u4+/2XAPCJ7rNnTCgT6WzUpHNVWh/MOrC6bfLR6TG6Olt48zntNNf6Z2TySaSzg82Eo486oMGZ7sFtp/3wZIKWWj8ttX6Sacndj+2ZFdlbtyTrG9kQ8rGiucZ+ryfsmEtOxKCIUmOe2QrcI2Kjjog6IQTnLWlk17GZFW0uBk3EtNnWbeU2nOff0xB09zmIpdIFKRsWNQRJpDP2uZstxmNJ6vPMVm5n1m92qD1tdSr4ajpJXePJDKEKLR+aVE7nN+Qrp862JuIpJhPprGlyBu2XQm9/mAdfOgrAh773nD0uuLGwTaYztiAC5PmIqd+5EP3EDBFzEbV2YsA024+OzqgNrYi11wdpqvHnqGDDkQR1AS9vWN3K1kPhGa8OteR97XoVLVNj5RE7NZ6wfoeXJ/cMznr1qRWxoM/DRCxlJ+O88ux2/uyaNQDcfcOlMyZKYzGVC00TMZ3qoaU2YJO7VmsAnAkSqTRBh7O+hm2adMG5NB/jDpPJytZavELM6PxoRay51p8zeOpgkPOWNtoDlptRn6l0hrFYiubaAIMTypQ0W59Dp7I6Gk3l+JXYUZMJd/OIOYlYg8umyfyozPVLGth9fNw1tScST6kM6db1dXvBYKceqHUuSFxUxBLFTZMAJ1xK6ppvmqwLuluHsMA0Wa99xCrvfzyVKciqXwr6XpqOebKUj1hd0GfnICz0EZv9fbTlwJCt3DnHBTeCYuKpDB2NIdulJNdHrDrF3d2AIWIuYiSatG/Yp/aemlEbw5EEAZ+H2oCX1tqArZCBlbunLsBlK1s4MRbnq4/smpHKYOensR7AkN9DLJnh1KQaJH7vgiUcGYnSN8ui1tpHrKU2YIdDg0rid9EKpRjqNA0zwVg0lVMr7pCV6LClzm8/gNP1m3AiJ4+Y16mIVdFHzCoqrtqfucknbpGXtrpAjtyv76eLVzTxoSs7Abjng12u+fc4a0FuXO1ORF0ylUtQnH4ltmmyEh+xTXdUdLyxaCnTpDuqm47K1BP1uUsbGI+nXElyDBBJpm2zJGTvI7eInp2aoUabJt11dFeKWKFpEtxL6jpWzDSZSJNxKSDDGXEISnFzBvxUgngyXZF/GGSzx0/HBF3OR0xD36Nu1ILUcFaWKJZIdjZIWv6vS6wALudzbJeyOpNNk0KI7wshTgohXsvb/ikhxG4hxHYhxN/OVX+qgZFIkhUtNaxur+XHzx+aEUkKTyZorQ0ghKC51p9jmhyeVL43NZZsf88TB2Zk8rFLiFgPecgqE6Mjev74suUAfOXh2WXL1kpGS12AyUSK4UgCv1dlsdYP+Gx8V8Yt5UIPqANWbcaW2gABn4cav3dW7SfTMsdZXyOb1sBPNJmedWJaDR296iR6M83do83CbXXBHDVETwQttQHOt7L3r253r5iysxakzup+3bmLZxVRp/0+tLl/9/Fx+77UJqyKnPWfuLOi4+UrYnWWScMtsjFq+4ip63zuEnUd3DJPRhPpHHNTY8hPKiNdK2OWvcZaLfETSbj3HCgfsdypyS5z5ILDfjylgiWc6SvqrWsccSHoQ5fvaXIot0II2uoClZkmrQVDPJWpnIhZhEOT/EqQX1xdw0lQ9Titnwc3fGK7Oltoqw1wwdLc1D9uJE5OpNL4vR6WNir3hfzIWDCK2H3A7zk3CCGuA/4jcLGU8gLgrjnsz4xRKl/YaDSBzyM4NBzlcDg6o9QJYUv1Al2fLDuJjkQStNQFOG6tCmeaRFH70+hVZ8jnJZHK2CWBPB6BAH678+SsfHv0BNpS60dKODYSs/1immYgpedDO1XX5ZkmdYTSbKPFnIqY31vENOmi34SzHScRg5k5yGofsNa6AJOJbC1GbfpurQtkVUMXzVbZ/EAB+zxdelbzrBQ3TSp1qo2n952y70sdNTmlIvbU1yo+no6a1HA7arKYaRJg9wl3iFgkkbLNMOC8j9y5zjoNTUttVhED987P8GSc46OxnHHHLvztgiKWrTNZnUl6PJZbvkej4nqT1oIhXkQZLAWbKE3jGpfKI+a8d7QbQNDnwecRrihimYxK7K1dYzQagj4mErNTbnXKIVsRCxUq22e0IialfBLIz+D5n4E7pZRxa5+Tc9WfmULnC7vrN4VJT0ciSZWHaxapE8KTCVqtlWZzbSBHEQtbZUXefM4iYOYmn1ieb4B+EI+MRAj5Pbx8ODyr1AkayVRWEVPtR20CpjNOz9T5VkppO1X7vR6CPo9NUG0n4llGiylnfStq0hGFqaX8mRKlUkQ+vzZawyzMAZq8tNYHSDvUkOFIdhLVq2h3Hbmzpkm/V6mSsyUAWlmNpzJ4RO4CZErT5KY74PYm+N2X1fvbm9RfCTNlKp1hMpGeWdRkhaZPbdrTk2d90MfihgC/fHl2CYg1InmKmL6P3CLcI5FssIGzfTfuo97+MH2nIuwfnMwZX2sDPmr9Xn6388Ssz9GETcScWdfdI5OjeeWNNNrqg1MrYq/8xP53WoqYvaiagbN+vmnScV40mRRC2Bn3Z4tTk3FSGWmTJQ3tmzYboqRTDmnTp7NQfF3AXWXbTfim3qWqWAdcLYT4ChADPi+lfKHYjkKIW4FbATo6Oujp6alapyYmJkq2/9D+hK02xJMZHvjtC4yfrYjGydEIqxs9eD2QyiiWGxzpp6dnoOJjD5yKsLLBQ09PDxNDcYbGU3ZfBsciRMIJxg+O0hCAtpCHD54XYPzgy/QcrPz37R5WN/ruHa/hP7mTw/1q4Hhl/xHqvJLgyCG7lplXTP83aGw/pY4TDQ8CsP/4CO01gp6eHqKW38/W13bTMXmg4LvOa7Dq4AP0rb4p5/N4WpVPGjx6iJ6e4wQ9GeIpCHlh89NPqZ0SUfqPRux2dg+n2BvOcG6rl3Napl5pjk1EGB6M09PTw8EBdY5CXskTTzwBQP9x9UBvenozKxsrW7nuC6f538/HkBL8HvjCFSG7L4fH1X3Vv283PRP76Tup2u95ZgurmiprX+PVQ6q/46eOAfDopidpCgpePKgmgu1bn+P4pDresy++RPxw4VBQ7jkohS3Wedr9ylaG93kIejLsPniYnp6Zr7G2WechOHkcn4CUzN6Xzzw1gEfArn0H6fEcKfyyuBLP1T/hmqfeB8Bo43k0je2kR1wJRX7bRELdlycH+unpUZFdCcvX8dWde+hJ9JXsZ/cTd6p2p8D2vXECXnj26ScBdU8Mjic4OZ7gpnuezbknKr0Ge8Mptp5I09Xh4/hgAp8H+3t9g9Z99OzzDDRP7z4qhld2q/5veUY9ZzN5Dkrhof0JexGYcIyv+8JpIsk0Ww+NFJyj6aJvVI1LfXt30TO2D4CD1j321LPPcTjvWZtqLMrHE9Yz8NzLO2gb32dvT07EOBLOFL2eqw4+wKr+H2c33N7ED4Ef+d5DT8/UBFrft1tf3Um745jlsP2AGgue3/wMAUduvv6xLBF6bevz9AXUZz6ZYl//EXp6Zub/rKHP/+ChffTE++ztR60x69FNT9ISyiWglT4Hg0NRYinJy4dVVoGvPrITMXSQc1q89pzz6s499MSmMWHOAeabiPmAFmAjcAXwf4UQa2QRbVJKeS9wL8CGDRtkd3d31TrV09NDqfYbVof5+f7NpDJKAr3prSrDvZSS6GOPsPH8Vfzp8kY++a8v8YnrzuGWt6+f1rHjTz7KuauX0d19ITvYxyN9u3njm67G5xVEH/k1F65dQ3f3WpZve5KVrbXc8q4N0/59nj2D8PzzvHHDZVyxqpUTLxzi/p2vEhU1rGj3csu7ruKZked5sS/MfR9/w4zNSnLXSXjxBS5cu4rHD+9jNCHpWr2I7u4rkFLiffzXtC87i+7ucwu+m3MNev4jqz52T87nJ8Zi8NjvuPSC9XS/sZPWFzYxNhShraHG/t59B58nPJmgu/sqHn7lKHc88hIeAQFfuiKfJfH0b1m5ooPu7osY3XYEXttGc122ff++U3xr23Oce9FlvMHKzTYVtm/aR0buBiAtId7cSXf3OYAq6s4zm9nYdQlXr11E6MAQX9+6hXUXXMKbzmmvqH2Ng88chB07uPz8tfxy/w4u7noDq9vr2BzdSWB/H//h+m4ODUe4fXMPneecS7dVqNuJcs9BKex5cj+8tovfe8vVNIT8tPX20NDSSHf35dNqx4nYa8dg61bed/0b+YOrVQWIjWva7OtXu+k3LF66gu7u84s3cGofWNy8aWwnQMnfdWgoAo9v4vKLzrPPiZQS3+9+zeLlK4veqwA8/x3V7jVXg6c8QfjVqZdpHT5l92H7pn1A8XuikmvQ2x/m7x7bQiKd4fGBDEuaQnQurqe7+woA6vuGubt3M2vPv5hr1y0q21YleGjwZdrCpwqeg/UXXsobZxl927A6zE/3PosAAv7s+FruHE0Xz+47BZuf48oNl9l+jIH9p2Cr+g16m0bRsWjTHXDdbQVt9/aHuf+xLQD8/ECaG66/xL5Pn5rYwcvPHyp+Pbu74cit8J23qPef38cf3beb1roA93W/YcrflEpn4PFf07FiFd3days6D1sTuxF79/G2t3Tn5CrrOzUJz/YA8Ptv7bZTDbVve5K65lq6u6c/5zjx6PbjsLmXt715AxevyKZ5Gt12hB/s2MbFXW/g7EW5fqs516DEuQf4h+3PEI8mkROTgIrY1vdKJiPht79iyYpOurvXzeo3uI35jpocAB6UCs8DGWB6M84co6uzhXdevAyA2//oAvshiybTJNIZmmuzBaG1r1KlSFu2c+17oV/DkYRtDtAOso0h/4zNevnRMtpEORCO0lavfDHWLKonI2VlJKyESUb7iOnzIGXWJCmEqhc45W84slW9ZnIdgZ1JMSFrPnKec2WaVCvdx3cpRWY6qRSS6Yy9UtRRk/nZuGF6fhkbHOcz36ysTSa6Xbv9SqT0vGvg9BGDrFnNGQwyE7+SqRCOJPF5hMPPbfbJRPVv8Xs9BaVdwIr6LRfQMHqocFsJE6Xtv+W4zkKI0o7E2vT5q8+r919uLWv6hMKozI1r2uxSRzOpaLHlwJBtvk1aubZqcnzE3L3OI5FETgoRN33ELlqem+NQX2dnwuzZ5B6E7PNU7FmejKd4sW+Yv39sd6EJ9Eivet3+7yUDP5zXIpXnmtJaF7Dq1Za4V0cdiu7W+3jf+I/sXHBTwef1UBeYXnBSNJmmxu8tSBirTZONIZ9NwsCKjq3E9DmFiV77+S1pzDVNVlzPskzQTTKdob1OBWt5hXIp0feKx6MCxUxm/UL8HHgLgBBiHRAAZqd7zgH0A7yiJZtY0pmaIeuTMb0LPhpVTp6vHRmltz+cQ8TCkVwH2cYaf+Xt5z0YMWti09EymohFk2m7JlpjyM9kJZFQqXjJB8MZNanRXJP9v6nGz2iJKJ9VBx9QE9p3rlMbvtySM8GN5fl56IfYmUSxMZQt+6H9EUr61RUZPHLSV1ivztDumUxAOkKuMeQrUOXyJ4gsUaqg/bxr4IyadLYxPJkNBtED7nQiraaCnqT14O5Gig+dBqWUv0zI7y2fWX/ksHr9zKuwzooXun1U/eWtrG2Cn+ffU29lGy/AdbepdpZeqt4vOheu+cuSK3YozLre1dnCHe++CID/ct30K1psXNNmT5geoQJtah1+P277Ao5Yvqoa2QWJe/5Vb7+gI+c8dHW28BdvUyrGl/7wglkFf4wX8RHTOSBfOzrKTd/Zwjd+t88OtsqORZZa9ZOPqtciY8bGNW12/rZA3jijx9a7f7unuJ/bqOX+Ub8EXvgeH4o/QNBf+RTdWOOfdh6xfP8wcI6lgYLtFY11U0QnHx+L4fUIe9GvUZEv5inL7BornqczkcqwuDFYUBRdozYw+3qW1cBcpq94ANgMrBdCDAgh/gT4PrDGSmnxY+AjxcySCw36ZnTmFcoWMVVOyrUBb+UPhfVAP71X+VI9vktFKw6Oq5XDD57t4zlrZaWJWNN0Hrq8B0OvyIK+XEUMoN3K11Px4P3zT6jXdOF+NhFzPNBOoqSIWPHf0Lf6JjXBXaR8e7j+SzkT51arxNOxUXWO9KDqVMQUWU0iZbbUxcaz24qbJYsMHs7M+vo1ZxU9HcJtXWNdz24ykeYSq8KBdt7fcWTUOkauE/TEVKvcsWMFm+KpNF6PsK+jvmfDkWwwiFvO9E6EJ3Mn6UYXCk7r+8gZueqETkhcEiOHQHihYRl0XGg1Wjz6LquI5RIxj4BXB0ZLO4qPWWrG4C548qul+0JhegyAd168DCEgPYPhr6uzhRuvWAnAhlUtpNLSziIO2fupovGigoCDcCSR8xy7qbiNliDCAO+6XKXVmUk6Fyd0P4tFxu44OmYTfx1sZY9Fi/LM0k/cWaB+dnW2cNHyJhY3BAvGmRHrt33nyRJph0YHwF8H77wbxtUzXamzPuhnbRrO+onCUlL6mD6PyLnGYGW+n+oaP2klPkiUzkF5bDTG4oZgjtoG5S0ANhn+VpfacOfKospzIp0pqZyDSkVzRitiUsqbpJRLpZR+KeUKKeX3pJQJKeUHpZQXSikvl1I+Plf9mQ2yRCx7QXVIt05y2FipSSYZtUnAlgMqqFRHhWny9ZMXB/jyQzsAh2mypgKzHsCv/zL7v85Pkx816XgY9apNr9hLHkObZF77qXr/N20FD4ZOxOkkYk4loLEMEbMxphym2fc7e1Nvf5i/fWQXALf/v+309ofth9h5rMaQKrETT2XsjNZrF9cXkrDB3QWHTWck6Ywk4M2tNeksi6In04rkeusa64igdEZyfCxmR+F+7dHdfPdppuQJ5AAAIABJREFU5UBqmyanikbT1+DvrQnCYW5LWBFX9XmrzLCVi87+DS4XhA5HctufliJWggRkiVjxmnshv7d8+orRw9C4DLw+WGIRscGdRXfV6qDTdNjbH2ZgJFq6SH0yBpOD0HkVtJ5duh+6O3mKmP4NK1trc2rvTQd6XBgcjxckdK0LePGIChZVUlaUa02V7yk0TU5nQVK6bT2OFhKxJY0hFjcEeWWgTNWSCojkeJ4LAGRzxS1tCtkRdwV1aoU1Xb7/h+r1z54qqqoeH41x1TntBePMYSvhdEn3iNHD4AvCj7PBAH/72jVTmro1GkK+yuYcq61YMl2QugKUKT7k9zAWTebc62UVMT0WPf436v3/Xlqy3yfGYgURk7p9KK6I2WT4yv+iNizfUPTcJ1OZnOTb+agLuFtT1C3Mt2nytISeeCcdzHrUoYiBGsinNPmMHIY7zrLfrmhVpk6PUOazOmuAk0AqnUtqmmpU6ZqSpkP9YDz3T+r97U1qkN10Rzahq22azN4G7ZZcPGWm5utugy8Ng8caMGvbs9st2HnE6rKDar4iNj4lEbOUhsPPQWwMUH4Y+nxoPwxNWnJX6tr0lrST1TpLRtnn6NuWM2wekQHKmib1ynHKVeLDn7P/da7GjoSjbDlwingqQ0Zil/3Qk6jf6yHk95T2EdNmMb1S/68H7MEpbplV81eZw5FEET861f9SaTWmg5FIsuAaVETEJodKkgB9Lfwl1IGpFbHD0GQ9Zx3KBMjx14rump/jC9T9poWqohOovkf7n4bh/er/MmkyxqLJoorPOYvq2T9DIqYJ/sFTk6Qz0ja1gZV6YKp6kMko/P15Ux5HSkl4MsGBwQn7Pgn6PPi9whWzlV6Y5ZvFQP2Oi1c08/JAmTq7FRDJ/YMTeD2CV49kCZ1OX9FUG7An8ndftiJLptJJOLUXznoj1C9W2yYLI4FHI0mOj8Vy6qNqXL5StaXH9wL3iNEBWHYp/I9su/9rw+aihKMYtAWgLBxku5Rpsrc/zGQ8Td9QJGfhUfZZ1mPRkovV+0BDdnsejo/GCvzDoMJ6lqOWm8GRF+Hhzxd8nEhnSo4TYBSx0xdFBlJNwCZyFLE8IhbyM16uLtemO+AfLoSMtc/tTXyip4vP+H7Krdes4f5bNvL+DSvRGoCWcZ1EDMqscq+7DT6xJfteE6brbivMI+ZUxOqzPmgwhf/Q6EC2/5FC1z6tZNQHffbgNi1FLJNRitjyLsik4JefBoqXyCjmrG//hljSzt8Tdubxue42eM/3su//asQe9BJ5Kkwx06QQonx5F030Xviuen97Exd/t5PP+JSKOBCOsnZxdsDWzqRO59n6YAXmhlEHWbVgK2Kh7CozZTlyF1OsevvD3HTvFv6uSH686aBQEVPVB5LlfA1jY+pZKAF9LUqtdFVliDLtjxyCZmW6o3U1+GvhRAkiFk0iBNQ7iMzGNW148u633C9Z5//Dv4Bua+L5HyeLTqCZjGQ8nipOxDrqOTA4WX5xVQJ6ctEVevIn2LLlsjbdAV9ZYpvDypHIp/edIi3huQPD9n2inoMKzFYv/1v5zymdg0vjkhVNHBicLE44eu9Tr5nS90Jvf5iHXjlGOiNz7nP97O07OW4Hh+QEgAwfUGPdho9DnRV5OjFY0P6ekyop7/piRMwidb9/4dLi7hGjA9C0QqliNeqzShO6gvI7nXKs+PEH1KuUvOPUfUWJ2JYDQ/b4mlsL0kc8lbEXRkWhn4VkadPkibG4XSnBiYoSJ48chrrFytXghe8UfJyYQhGrDahSVgsNhoiVQwmp3lbEnETMdtbPZpsuS2Kuuw3+8BvZ92/6cwD+IfVePn39Oro6W+jqbKF7/SJqA17ecdESQn6PLSVPaToEGNqf/d9B+D711AY+6/+Z7XMTyjFNBitvf7gw/5dzEHf69mjpv7k231k/WTqTcmQI0gm44N0QqIftDwIqw3pjjZ/zlzbYA1pDEQfTRofJZMiqoxmO5CVUHNyV/f/gE/bkowcb7aOhX3ccHcuV66daJX76lez7T7/Cphv38g+p9wKKiDn9JBbVBwqycTdOVbA5NgoJKyP7oc32Zq2I1fiVWUoVXVfBIDlk1ZpAcyLvZpjEV0qpFLG6QlWypPl20x1w51nZgbsICdAm7lI+YiGfxza3FyCdhPGj0GwpYh4vLD6/jCKWoiHosx2uQfn9vOnsdppr/SUmUGvyaVwBzap+px0gkIfxeAopc6MyNdYubiCRztg1UwtQRu2JJNI4g99q80xOZYN7rrsNbv5Z9v0XD5VUYXQN3fyqHmXVEr0g+fdb1fsyRG80MgURs8pcveo0T+r2rYVafmCPE6UKToOapLcdGrF/z/5Bhzqpx4lF55ZVxHYdt4hYRyER06TnqrWFZktl3j5pK7eyroN9mWXT8xEr5zesz9HuX6n3f93Meyd+xE2R+wt23bimzY46zK8FCWWc6RMRNWYDSOt5zLvW47EkE/EUS4uYJivK3j96GNb/PpxzvXqfyX3unX69xVDnQmHxasAQsXLY+i/qdSL3gSvqrB9Vxbq1ma8imXjsCGjNa8s/Auphddrtr123iEgibWXVz51AoUKi9OZPQ5uVW+b2Ub7ctZl7xfvt3XKd9bPlgWCKbNy6/c/ugMs+ZLevB3Ht9Or3ZpUZJ9FoqlE18EpmUtarq5ZVsPoa9b+UHB6OMhJJctMbO+0BTStdQ45adFlVL2uaHInk/Z7BXUot8dXAc/fYk51WYZ7Zd4re/jB7jk/Y73Pk+qkUKx0JBbDjFznm7IFwhB1Hx6xzJDg+Fs/Jag0VFFR2hrwfyiqgShHz2qkXJuKpbORtXa4iNhZL5aiMM0mhAIoMJNKZAkUMplBu3/v97Pv/+H/g2i/mkIBkOoPXIwqcezVqAmVMk2NHQWaypklQfmInXoUiC4BSZsMVLTUELCfgwi9Z17hxGbRYRCzcV7w7ZZzRz1mscicV9ROLWuS/SFAMqLFodVudfQ3zfX8apiL0zhQfex8rudtaq4/55rWyBZuvu80yt1md++jDJYmetiwUI6qgitUD3PPE/uyCyDbRW6bVVVcX3EMal1lErlj0dH3Qy1Er+Of6cxdzcHAyu0g8uUt9q32dWhT6apRfYB72HB+nIeQrSjQ0EYsWG+/0WNekctel6xczSt20oib1s1x0YXvdbfBFx+IgoK7jI4s+WrBrV2dL0ajDKU2H+je8617o+pj6Py862U5dUeT8lE0TA8p8PjkIW38Aex9V2/LSxSTTckofsYghYqcH7AiNXyqVirvW5lxsfaM4b8hRK6Rbm5UaQxVENY4dUWYSsBWrnd4bco51oZVX5/mDw7lO77UV1Akc3g81rfC2L0PDEntzLK+GmdNHrLU2G2wAU0RaDR8AXwgalqpJCHImCtu3xytsH4x8HzEoQya1o/6/3Zyzklv5zaV8xvdTOydXb3+Yf9nSD8Adj+yyB2g9mI/m+IhlFbHe/jDD/a8SbjwXrvwk7P61/dlLVlTmb7af4ObvbuGJPYqM5ysB9VNNcHpw8tXAjl+w+lWlgnY0BhkIR9lxbIzV7XW8cXXuqlOjrOLmbH/llXD0JTVYoSLL7NxnFhHTdUtb84jSeCxJV2cL51rmlG9/4PJCwlFhNB2QEzVZUXmdYUeW683fLlB+kulMSUd9sHzESpH5EYtgaNMkqMjJ2Cg8UjhRF4toBLVYKXmM0SPqOQvUOhSxvuK7ljG9aSK2z0HE7LHoq6vUhiJBMaBMk611Ac5qUeOJ00cMrFQuUy0YhFeNR7seLnm9l1spe9634aycSXpKX8CRQ6Bz5m97oGT7o9EkDUEfvhKT6f7BSQTw5N7cBRFSZslv31Ml1UNNUd7dtbxA3dTuDe31Qbo6W5hMpDmhS+QM7lQkO1CLsl0vKmqa3H1inPUdDQW5uQBCgTIF6vWCTROxmkUsYsSObK8EjSE/6XIL21EHEUuoe+ye/dcXvZ+KRR02TJWmRLfftALqO9T/6dzn/vioOp/FTJNQJk0MZM/Ru+6Fm60gsY8/ahM9HWBVSjkHq7D46W6aFEKsFkJcJ4R4hxDiCiFE8bN5msOO0DjvD9UGbxA2fhKuu41MRtoXMt806cyR1VhTZnWiMXoEFp+rnKwtvLPtoZwVxHlLGxFCmZqcTu8Vmw7brCiuhqUQVKQulswnYur/llq/PQDWBrz4PGKK9g9Cy2rweLJEb+KE/bGeQLUvlRC5IeNTEzGLZHxuD7z3n9X//+kZ/vslT/M9742ss+R/p7kh7UiiqCfUY6MxEukMTTV+O6HicweGuPmep2icPMT+/n546i7sYfr2Jt754Hl8xvdTm3h5Lcf5fLm+cUrFyhqc3vQpOPIiF+xVyue6jgaOjCgidv7SRq4/T5k7hiO5kUpKcSunZFjtX/geReatwIB4KmOvpvUqUxccdt5H+j4FbD+rdUXMKpU4QWdTuBRG1JWdpMN9yu9j/Tvg5PaCj+OpTNnBtWzUpD4/TiK2xHLYf+4fC3Y/Eo4yHksW+MjVBrxEkuniz/PYEWhSqRVoWAreAIT7i3YnPxGxE/VBH8uaQjlEzB6LrvmC2rD4/KJ5yiKJNLVBn61Y1RUoYlPcRyOHoXE5XPRepYiVuN7a3eLDV3bmTtJTRYlrklTTBjt+XrL90RKKpMaWA0PF6+BOnIBUVCnngSL3r4XN+4fwegR//UcXFkltoO7VtYvr7czuB7R58uSurOIG6n7NM01KKdlzYryooz4oH0ePKFEXNY+IJWsWsUiMEvKVXoDko7GM33Bvf5iHn7R8SC/7sLIyALddXDzysxj02F1yvHP+Btt8m+s7fLxEMleN+nKKmL2oOks9Z6DcDixo14pypsnTNqGrEGKVEOKrQohDwD7gd8BDwHPAiBDiMSHE+4QQrz91TednkmnY8m0gN1Iy11k/YatUUMHqBJTi07gMalttZ/qWvGihuqCPNe11BZ9VZJocOgCta6wvLIVUDKQknszkSN5+r7LNOxPsCSGmNq8OO9pvsBSx8eP2x8l0dgJNZZRkvO1wNuKpIkXM41POsfrBmzhOb3+YS1c226aqUj4NemDqO6XKXWjFYSSS5OFXjnGWPIZPZLg/dT3fu/K39mHPjj/Aqti/8g+p99ommPdcvqK4XB+cQgkYHVBqySU35mxeu1gRsf6hCOcva7QHpr5TucWO66fKZj16RCkZ5/+xer9N+XzEHU6rulivVqzyfcQSqQyxZNo2GxTkaTphkaNwf1ll7PmDalIcdBTabQhWkGMq3Adef1b1hAJfw3K+MoqIlXAg1r5ajcuz2zouKLprb3+YXcfHORyOFgQs1Aa8pDPSNrfnYPSI8g8DtShpOgtGShCxWHkfqEUNQZ7df6owWEJPOCd3FM1TFkmkqPV7bfNRf56f2ZSK1eiAmuDW/0HW57BY/0soeg3lUhtAloj9wV22GlO0G5HC1B5OOJPX5pgWtap68Mls/4v4om05MMRFy5sKlGfIqtFrO+pZYxGx/YMTiExKpbhZ7MgjVleoiP1u50lGIsmcZLpOCCFKq7d60Wndp/HQImpEgjqK57srhlLqc29/mBvu2cwL27YB8PL6P1dJY5leMEDWNFniWR4dAISa07Qi5liYA2ztVymajo1GSx6jNNHTipuDiDlyKMYdFphSqAv6rJRGC0sVK0uehBBfB14G1gD/HTgfaEJlwF8CvAN4Gvgb4BUhxBVV7e1cY/y4MmNc9kH1PhHJuUkKFbHciEAoY5KRUj18jSssqbuDfWJV0bJI2jxZLB9XSRKTjCrflVaHIpaOQzSsFLE8yTvg9RBLpnMmgMZyAQeZDIQPqig0yCpiOSsUJRP39od55fAo8VQmZ4KrSBFrWGYpburB3r1vH7uOj7OsKVvVoJRPgw6rP6CJmDW4hiMJOhqDrBVqBdfnOYtL169RpI9sUk0P8GZHqZWicn3IP7UPl8cH38zWWuwLfYAv9V7Jpzw/AeD8pY12H2EaTtD2OVqqTCXt2bqmiVSGoDXIZjKSfScn7HD9/KhJUCHletGgBzTbLPaPb1I7f/1iOwVKPnr7w9zxa+XQ/DcP78gJeYcpFLHhg8qv5785EtPm+BqWV8Rq/F4S6YytiuZg5JBKkum3VuCb7oA7VjiOk52sS6ot/5+9Nw+z4yrv/D91971vd6tXyWpJlmULb9htbJlgLAOZELIHwmIIDwGTzAxZPJNfkvFkkjiEhEwCgUxgAgECCduEnxlIBkiMsSUv2JJtGe+2rLW1q1vdt+++3/P745xTt+reqrp1JTsy+c37PH6svl19blWd7T3f9/t+XzBLBjlvose6iBjIEJYLItYVLO13BPYs5Hj6RIHThXp/5mrhhERhRtb3/R1IRKzabPGdp+Q71Pp62jTX0BWhzx+F6ip89W3dzxwcGSd5D93+QNTTCMEdv+TZvpPGmtXm50b5eSXs+sX3XdediznliP3aY3CtTgqw85MqjRZPHFt15T/qBIeLJlNMZaIkI0EOLJWJV08AHTsilpqwIWJ7FnL8xy/Lcmx//9CCa9axK58xr7IBQ/IwXI9JOaB0y3/SjBudZNfBZVodwVpjiaqI8MAJIDXJikg5Zk262cAKCvljChEOOzpiexZy/MOjcs39pS884viOJJ/VjWZwVAkzz0jwIhh1RMS8Dm0aKa68zLTEBqFYDeBCIcQvCCG+KITYK4QoCiFaQohFIcQ9Qog/FEJcAvw2MPfS3/K/knU6cpM7/XQ3LfpPZpj52LQpP9CrrJ/tQcTAQ/6hXpAnQ82tSk+xKDJ9iBjAZbPSEdtv0e6JhQNEggH39vUJ1ESstKN0UnHEul2/ZyFHpdnmWA8S4KV8T/GkRNhMxK0fEdMqx3KD689UGshDK5zobnDqBPet7/8AgG/84LhtIjs5SbqeYi8ilqs0iIaDXGQcp4PB773nZ5nfMA7JSc6kpDMTMGTR4VvfsMWznIrmiLlvcMdg3avkhjApi1JfJr7GvTfvN7MnXzGbYdumccfQZzoWptRoyYK1bu0j5IZ2RgnT3j7CN5fexFsKX5Sb+/ECJ/M1vrL7CMGAwTMqQQC6fWANh2lHzAyLXfcf5C9Cyvm90SISrMxJ203e/4B6nK26nGejGyT/RoXPraYdejfTY9k55HMEml0n1yR2r9Pacd3NWhdudyJy6w2r0uyZb/WS5JtZEbfsnDsipuark7Ox6+Cy2c99masnn5AbvybV9zgxlUabfLVpOqO9dQ49Efp2S861i3/cpmHlVAYqX20S6JH3gO6BxHUe5A7DmouU1tTlnu33Krr3mq5HuVFFCgDpzBsBO1rSKNv+7h8ePkqzLViTcq4BrMdPR8i1Y+NEkoNnyiTLComxIWKTMuympDJsNSY77lnHMTfNOy1doawS0Y7YimM7TuYWmtymxvU6Y4njTLDtwjV0UlME6QzliA0s6ZY/2n0GHZq0OGJeGavmd0RD7pVE8ip8HgxJ8CI9bUPEupxkj9Ckzvx8mYUnPR0xIcRvCSF81X4UQnxHCHHHi3NbLwOrnAEEvOkj8IvflJ+95zv84L2H+XjrLYwmwn2hSWdujNug0lkycgHvJKcY6+QcEbGw4gnsOrBs0+7xVNfXGY3j2hHrQrm1pr20xa6Dy6Zemc1R8gpN6va1I5ZYI5GfguWE0pJFs91Ch74QMe3gRRLUg0nGhXS+2h6LndUy8TCLKpNy81Q3NHksV+WiwHHqgSRXX6i+IzVJMy4XkFtes8lZqqDH0rGQqd7vKIiat6Al6pQYjwTNOqWJcJBjKxVXVC8dDSGEx8JROC5FJm/PwzZVbuoPVnl9+h+5c/KXbE6wfG+iT6QR7Jl6fbD9fhW2balwgoM8gC1kFLQ7kuBxis4tAMKCrE7JzDSLNQaR9SPdWql95iIjYY4ri82NS6L767dOOtSoU45YryPTk+0GSESsmjMFiK32/KkCBrD3VH/4z7P4d7sF1/4KvO1L8udfvtfmxJTrLebGk47zDAb0Q/GkpF9kL5CITMI9Y7ZQbZKOhW3yHiAPJO2OcM9ezR02eUluqB4MRsSgG1rXCTiy/UMyuhCKdPvWsknvWcjxx9+R1RQ+cmd/Qe89Czl27JWhxj/5znPsWcjx3ub/4u+P/CiXPvtn8qJPW1TuU5PynVWlo2TtO6+i5HE3PmP+mC1kWwlL5ynRHAYRcw5Nas7ahuAZJtZdxPzcKM34BCNGhVTQf1mqgUW5rc6kAyI2UI8PqDZbnC7UnRHF1aNdGRqQ/Ww9+LcGc8R00pgnZeg8mB+OWNowjHcbhpFx+N2I+l3S6W9/qE2LG6anLcTAkyYKNpWJmZtjrdmm1uz0iZWCR2hSOyyaExCfYNLI2TLOtGkSdG/GnqdujNYQG+txxIon+8j62zaNE3UkonsgYqYjpjbQQECiVr0csVDA3clQBH7HZxCiy6HTH6WmmApIjpnbRO41axq8NTR5LFdhs3GceMfCV0lNEarKxfg33nCRr8LCOpPogf1n+IVPPchHrIKotQLU893FKT1N1UiQjARZVHysSrPNOz+3mz0LOZfQp0c4QL8j7ejp76nmaLQ7RNWGEAkFsG6b9tBnPyLWJ9gYScDoJrj5a/LnW+7pQzLm50b5mVfOYgBfvqUbMoqEAkRDHtUBdEhp1BLijtvfe8MHWR96woZaN0m33xsGy6yVBwcLgrOouG2/cM0FfX1vOnu9C3gPyRqwZE7aUbE9Czm++fgJBPAu1edWm58b5T9u3wzAR996Zfce6iU5jjKzFi5m18lod+RBYNOalGuxYz2OPn3fgf5NrvcZ0rMwthknK9RajmHVgePU5oitkwkNDrbqwxHTWoe6bBkg2x9T7TsQuXV4DuS61HuI23VwmY7ooolff+wYv33mJ9hQ+wp/2XqzvOj3V7rj3hR1lQji/Nwo794m+/1TvzjvunbEIw4cMSFkH5x5wfyoFJZrW7LuCweRj63m8v954oStj/UaPsMSIzOSqtKIyfvPdjyqFPSYFJt2QcSEkOCCHkPhGMRGbNJP83OjXDY7wuxIzPGQu2chx70vnKFUb7nU4rRUyADZzw6hSW9ETM7jv3/w8DlVEHmxzQ/B/t8DbxNC9B3vhBB54K3Af3ixb+y8mz5NpWctYb1TJlFxKhMzOWLdshzW0KQur+OGZGjtIbmJliNrGDNKjMX7L73hognHsNXIIMQqFOtuapZnqPWUtnBzlKSj53L/2hHLWDagTO/E6IaUnJyMQMAgHXVG9UKtogx9WkI+sdG1bI6XSYSDvtAqsBTQjoaYzMgFPFducGKlxCbjhP3i1CTx+hKxcKBPEHNQ+9/8wXE6osdZ7kVLUlOERYN4OMhjR7oLoJeAqqd2T2VZvSPVvn5XheNmQobu23dct94loUG2v3+pPzRp2upRuHC7LbzteK/REOlYiPkNY33vyBUZ1iRr7dD3OPOAL7K+vG/LBnfTbfDfLGTq3jBYZlZWa6h1+0EnKzil1ifcULcekjVg0RKzO2J+QjOvmJXn3Q3jlrOtft+ZtY59oLPAEpGga7Fj/Wx/9+Dh/k3OJEErpCo9DdFU372BO2LlWfi7sizRHqsj1m7IkK7Fas02jVbHM2sSMEOLZ6xVMnQGNzgiYoPQmG2bxola5odBt+RYEoUEByxrgoOo64QaN9s2uh8QHUOT1VyfEn05mKEhgsSGcMT2K1X/u59btPVxvtokRYUsJdrKkamZjph/Z6RbKsthLSqfkRxk64EkNdVH1g8FDTZNONT7xTs0b3Ta8tDZi4gVTpqHqboPROz4iuzLrzx85JwqiLzY5qyaZ7e3Ab/n8ftPAH8MfORFuaOXi1kRsdiI5McUT1KKykk0nYmZ2Re9qvrgFxEzzIW1EBxnDTBl9Icz9Ga66+Ay2zaNm4N4JB42JQn6bOWA3KS1haIye68oQ5O9QoGajG41KW3gcv/6tB+0DKH0tKzHpmyQ7ABIPTQnRyxaV5PQGkJKTZHtHGA6G/PlhOlnAFm6KRoKkogEuXzfX/Or+c+Z+pLcrnhJ619NopljIhFy1AFyMg3Xn8x337UZVso/qh5SLR7paUK0mApXTE5Ys9XxRPc8NzgTyehBxPLHabQDZtak7ts3X72ubwzp9g84cMQAybOprsi2LaiqkxXrLZs8iTZPDavcYUmm1whDeko6YkKg1Un9kPUBqo0eB7Lqwa/J6FD9CfOwojWjpjLRvstNjlgfIqYdMcs4zW6Q/+9BxLQz0BHuiK5j6MR09mZUyMewORn6Wn3adzLNk7QWnDbnkOmIaQmOaTj1lGM7haqzzpqnxpTmq2pHTG+mq0dhussJdDrQOpnO7jYRsXpRUknM8HY/IjY/N8pFU2mqjTYfe9sr+9aP3jUW4GuPSk5Z2qjSDiWxvd2k5kB1nX2NdHkdGuLhoClaC0iE1irlodai9Zd8gDOMkKr5d8T04c56GJyfGyVfabLWkO2U4rOMAJWIOogNkQwAsp8d+9iqIaYtNdUnhl5ptG3Z+VbT4d1mW/SF5iONZRkKtiFi05IuUVuF+Kgv+QpNwXCcB+fR/CBiFwH94j5dexa48MW5nZeRFU8CMptREgOld6+JhHqxrtTb3bT9YnczthacdrT8cTmQgnLRWQnIwaA5UL3mdNL1Dh0e7v8sMwvFk9R7BF3dbCTelTYwTYd8nvmG/Nka8knP2jaIZltyxAZ9h9MzxPQCZEXc0tNkWsuMDjgxW01vGnryjyYifDF2Mz9Z/1D3Io2WXPbzBOiwMTl8yvgTR1dNFPTf37hJ9lPv4qR4EzOBVVcUstc8M5V6ETcTETumEDF7H3uFPkv1lum42coFmc7eeskDNIJ9iJW2Yq1lq8Vp/Q53jpjKvNWOb2panqxrVsTQm6xvOmK9SENFOWJbf7r/j8x31R2vpws1DKNb+N72HWZosuc5NLIdtIzJxJhULn/q67ZL5+dGWZuNc9FkyrXP4yYXzfJclJgpAAAgAElEQVQ9Jo1hVh58UpM2J8N0xDxQ3Bu2SEfXKRGB1aOSFxZRKFx6RiI9Dir+eTdHzCs0qVFPExFTm6m16gRdCsag0GQ2HiZg0D2ErvSEt6MpiGZsfQuAgK0zade5Zp0f+t8AV4zUCGbX2i9OqYODBRGTlI9AH3/OavFwkFqjB7l9/z3dn9Va9NRF/5ElkSVc7ReNdbNtm8bNs6W1j/PVJusM2c5KWB78degzNQQHDWTN4yePrQ4Ob4Mcpz2IWLXZdh2n83Oj/Oa/k8lSH/yZS239FKup95DtCU2C2c8mR8xjrdi2yT0h53yaH0fMACY9fj/ps50fLiuelANJIz7pGSieMsVcp1SJhl0Hl/ngt54F4E/+uavqHg0FiYUD7kiAlYgOLCEH3WjH/8RwdGK0o+SUXZWeNhGxXvkKJ3PMatRZZ7NKjsEa8klPSy6LylYahGS4PgMQ1ZC8Ri4AUlNERZ3ZuAsK6GB6g9AE39FkmKeP50kbDjo2KtywMVbu/52L6dBhqyP4lRsvZCIdZf+i+vv8MclD0sRVhX5qnptbGMlqGa8NTi9+2llNTcrvyx+XNdcGvHuQ2W/aB9IJBLq8E9Alu2cv6Ar3ujpiTRdHbEBosmXh+piht+4C3lBcQzdzzZrUiNir3tf/R2b4qlsiarFYYzwZdRyzWqnedPb0PPuBIs9b55lhSJ7YiT197ZTqLa7bNOba57omqx0RU06X3njUWqRNUyR61fStdtPFcmy/+sI1/U5gT8Ye6WlZFsqhlmKhNig06YWIqZCtidzaEykGFfzWFggYjCUjnNFk/VxPeBv6+EPy3pqkov4PcZeqbPWMUZWOndViWclzsyA+1ebgA66jfEW9P3Gj3mqzJEZMzqofm58b5Yp1I0z3cLCkIybX08WAXIuKwSwdYZBo+Efc9izkOLZaZd9iySG8rR0xi6Pkgoh5HRiuV47RWNJ+GIrVVDvWRA8zU1/2s9b480LErr9Qtn/TJf0JOefT/DhQTwP/zuP3b8QbMfvhtMLJ7sIHphNTrEnkQMtM7D604pi2DwPKHBWO2ybgqbac9MkhTigjiqxvSxm/6Tb4fcsE6XWUFEcs5qOGmWd4td4fQu2VsPDjiHU6gsPL5e6kVhvcln2fkj//xVa7IwmsC7sLTvbdktogNK9kNBHhVKFGBsnJ+Afxhu7FymG6IOzwbAPaB5lt94atk9z7wpI8neVVCSvNLVHtT+KfIOu5wenFLylT3QkEIT1LZ/Uo7Y7wVTA4EDBM1O2CMZk1WLeKo1pQvT0LOU6LLPmlI73NANLJcApNuiJinY7cpJf3WS7u50A1Wt7IamwQIhYfo89S08gQX3ezPl2oO4YlwSFrUh9I1l8vf+7loGn0x2LNdodcpemIuGlzDk2ekM8QVgTSjB151s+d9HDEIqEAY8kIG9YkHIqWH5UFm7Vl+hMCzFupOpP1rWKf9+1d4n/cva87p3OHJUKo7z85KZ2YHkTMDE3GnYn8VhtPRruhyV7EDeQBrgcRc0Ns3Uz3ebBdhWiPWr5hyHC6pd5kL/fWyRw5Yjq7VtdnRM7BJZElWOl3hr3s4uk0nY6w9fGqQsSaIsCpluT+VdsGy6SJ1/3vN7sOLpu5LX0cR92X1kSb1KTkBta7tIdqo0087N4Hmse7qKNLaj/Y+vzH5c+fmLfsBzoELfebRlu+V689R691V67LvmycMPDniP0t8LuGYfxM7y8Mw/hZ4Dbgcy/2jZ13K57qccQUIlZvkYwGzXIYW6ZSZtp+pC9l3GUD0hkmliyZY80UHWEQdjiFulkmHqIjHIjcbsrV6RlE6TSi0/IdmgQXeYlaHmau7Gnfvok22sITydizkOPhQzlWys3uCUttcEfXqeFm3eCUIzMbyLu22WvamdSZVlpiJGNI1OqvGj9pknKF4n3MBP07Ynpip6MhyrUWr79kilK9xe9+8ymKi4fsDqu6/zH8E0Q91ay1E2Hls42sRSjektfJ0GramVyvHbFWjyNmBNmzEuPmz+zi8dU4p445Zxx5hyYd7r90WoYhrZZyLpXl9Sx6LLsiYgkHRywUkRupBRE7Xai51sBzzMyEPsK5iZTt/bb82YKUabmFibS7I+YamrQmA6hDoTaNiPUW+u61yXS0WztRm87Yc3SG7chno9Wh2my7IGKy3z/07ed49+cf5mN3vdCd07nD9jUpEJDP0xealO9nECIGkvO5rEOTGnGLWTTo0rO2d9TpCEqNlmsxcSfTjlioXel3xECp61sRscG6XH2hSegeyF9zq/lRrdVmiRGMyhno+JdamBmJs1Sq2zKfdWgybHRYVvVma402S2KUaH240GfQ6KlqoMe7qjzDH2YtEh8qEqD2NCGErADhMU7XpKIYRjeDWe8Hh+feKn/+/ZwFWOgNTSpEzMMRCwVlIpZnpY/zYANXaiHEZ4FvAN8wDOM5wzC+of57Hvg68I/qmn9bVjzRXZBA/rtRolkpkIqFSKkQwtrRBK/dsoZkpD+Tz1WHq16wi0wCK9UOOWMESs5hHydzdZT0onfRj9k/T89giA7jFPwhYl6Zn7UCbLyxp317tlJzAJJhTRnvPWGFWv3OZD0ueRk6tOfH9On92ZMF9ix05UHGgvLEVRAJUxenEJQb9oThv/19KlOpWG/xzs/t5lhOIgt3PHqM3MlD9oujKcoixljHv0hjUqWM2xx6vfg9rWT7rGGxzFrTufCDiEF3E71Apeza5CvyxyCzll2HV2m0OpwWo0ywwu3/9HSfM1astRxLx8jQZM8Y2vFh+AuLQKZ+hsdVqM+lVJaTaQekzxGrqPHkhIiByZnUNhQipq2Wh6nLuz9rpOynPyF//rXHzI1jSenZ+UHErGLRFE/YQ/TpWelkNmu2e0p6kPVBOoBWHqu8/9X+g5tLUoabqj7AC0oXTfezLXt41QFBHVl31qFJkJzPn1r5ghwze1QdWts8UOFb5cSUGy2E6B5s/JgO9UbaFYj1qTdJxMdycK422n28zF6LRwIOoUl1WLOEPzUiZogO3PUHvu95bTaOEN0sWZDcuw1BOReWy3IMVpsy9BkZMvT5M6+cJWDAl3RVAz3eL3y9vMh2cNYJDfId1VsdOsL7wBAOBhhLREztR22hlkJsA5Z1IBxTCWjyQNowyfrevOSBVSDOg/laqYUQ7wLeDuwFtgAXA88D7xBC3PzS3d75MaPTlIu4LWNPOmWhymmSkZCJiJXrLVoduHCyPyXXMTS548Pwp5Y4t1o8Xnv8s+SDYzZuzCDTC1afo6RPWFe81f65WmCnjJwvRMw1NNmqSySjd3HqQcQGbaDbNo2biFkgYNjQxFCrBIkJ2/WrAfn78SFCe/pkteN5mdKtN+u1MXmaLpEwn+9MM0RRxBkX/tt/5HDOTItvtjrc/fwit4bu4FDsZtYbapFWfSzu+RNOiywjQ6hlO6aM68Vv7bxq37L4jawlUDyBQYeIDx4gdBGx6ZE44aBhl4FQIorbNo1jGHBajDJmlNh7fJmbP2PniZRq7qHJSqNNy8o9u+k2eO+d3Z/1M7zhdhnGsjliPsn6vU5SZUVKuEQSLg++1kQVm+0Oy+U6k2lnRCwclOWy+qUHVmWh6V7TorSWLOIzKpTmhYjFwgEMoycpoEdPr3eemY6YR2gSpCyHbYPb8WH47xu6P2tH5pHPyaSMntCeWZ7JoY93H1qhl6P+n8Jf5wP3zjvzVUcu6EPECtWmzIvy4SyNJyN8tPFmOWY23KDaz9vREtE2Q4d6/jiNTzfTznek48ARA4mIab1GdGjSe0uNh4O0OsLM8AO667UFdau3OuRUAhcP/ZXve57JyvF7YlVxYHd8mA8/+Rq2IuWGfuuh6+D2ETY/+1csiiyhin9HDODStSN0RLdKSfeGHaIIPaKuVR9JJeB8YAi1ys59YAnTN02yvnf76ViYolu9zPNkvkn2QoivCSF+VghxqRDiFerfX3spb+58WbSuNspeRAyIVBdJx0LmoleqtzidrzlWk5eIWI+TdNNtcMvd3Z/V4vH5yNsphseHQsRcC3/rmHwvnK6e4f2hb/si67sibprTEMvaP49l5Cb67D8Cgx2x+blRvnLLdSSV/pHVkQ03SzBhV1jPdWLURJjRtn9HRstK6BO6Dg9NRRu0Qgk6BExHbLnUYEmMkBmi/d6qAT9+2Qx/2XoLG2pfpiPUzqT6uPIjv80S2aFTxqOhAI8cXukPB1YdHMbMOoxOkzUUfIcm9cY3lY4SDQX7Q5Mj65ifG2U2G6esSq9MGqs2Ycxas02j3XEl64NDCN1BeR5QJN/uPBgkg6LR3R17l+zvqJpzR8NALeISPTxTqiOEs4ZY93t6xDjbTYlsx7P9F6+5SP7fEvLTiNiEByJmGAaJcNBMCjI6TelMWEOTGh1TzqoOY/oJTS4V691yWTfdBu+7q3uBdmRe97uyD3pCk24Fv8E+D0COpevf91HFV7XPA3lgWCcdyXZ3bdEZmV5Zh9rWpCIU6y15aOgND0Mfz02PPSfE1s3ikaA80HQcOGIgHbFGydSxqjXbA/vAkc9Yy0suqSXztt5qkw8Oz2GaUTV4TTmdm27jXeu+Sw055t6/6W64Pc/Dc7/CElkClUWzTJMfMzXcSj0JU7W8rdYtYHHE5IG00vTniE32HhhQiJgWSrZaeroPEQv/W0PEDMNwGH0v3vUvV4s0tCNmPYXKxS9RXyIZDZkTulxvcapQY3rEwRGLhZzJ+g4Lx0q5QS06MRQilnFzlEyou9cRk8/w08GH+nTEnMxVgkPfv9MJJT0Nx6V+1iAkA+CaDWP83NVreeJo3hZaCrVKfQrruUqLRZElPURCw09dOWsTarx8neSRrAnXaUcy6vnkpFwu1VkiO1QmUa8Mxc3XrefCyRRbxwMEDHvdvUqjzaLIDpWQsWchx3KpwTMnCv2ZSrVVmLnK/gdKC2rGWPYdmmyqhfhMqU40FDBDk6aI4sgFtNodFgt1ptZuAGCSHEELitlFHIZQXdfj9FW39PzBjG0eDBJ0fVbVzrzvhSX7O6qseJbrITMjx3Kj7Kkhpi0RCdq5W3oeWLlJ5sVjUu7DwgNdKg0OTYKsh6dRru6hsCc0CeYGpMOYfhCxVkewUrFsok5ODPTx0ADzUOlE1rfOg6vXZ5nIROXBqlkGRN/1ZC+QmZmW7/Cjqq9NZ9WtlBtyHKk6rt37t/OHNCdoWLJ+khoBhLMjpkNvVTneqj7I+mYY3erQ14t97b/m2Gf4Ir/f/cChQLqTzWpELN/NCi9UqsSQY08nONRUaNLotMz792OOVQ1AHqrWX2f/LDFuk7vRh5hB0ZjJdLTLEVMWapWdw8PpGRN1NnXEBuw5qaiHruF5skEr9T7DMP6bYRjr3C4wDCNgGMaPG4ZxF/CBF/f2zo95IWKp5hKpaDc0eaZUJ19tOp6kNUesrxCu3oCuea/5Ua7coJFQnAOf5Ey9aH2zpwC2E9Qtb34SYcgu9xOadJXgqOsNyGViKGsMIFlre+OlM1Sbbe57oQuTh1qlPsRttdJgkdGhHaWvvL/rKF21Xjp3orpKLSjhdb1Inyk3WBJZokOIKOrvsMpQTGdizMaU87rljeZ1lUaLRTFKYgiCrKwVKc3GoxNCImKbX2f/AyUNMGMs+3r3exZyfH+/bPM3v/YE0FWojzRWlIjiOo7lqjTaHTZtlNpK08YK79o2Zz6zRhycNjrNNfzs/Qd7xqmaBzf8P/Y/SE/ZNujmgFqTuw/J+dpbAozqCiQ8UAWLlpiXqr62RCRE1ZpRajpiDogYSFTsjB0RS0dDA1ETq8PnKGzcQ6avNloYBgN5n5MqJGrlD5mo6qveb7+4RyIDvEOT0J0H60YTXadbo56WeQBYJCy64Uk/dSa1jacs9SZrBZj7EfsFPdIGZxOajIWCpLSqvvXQqTmad/5X+fOfbYTbR3hr6UuDOWJOiFi90Heo/fb4e3hj9O+7HzgUSHeyRCTESDzMydVuH7eqcpw+l3iVmeBQbbZZNtTcKPk//JvvvVdIvJbvP5gHghI13Pdd+Z1maNLbGZ5MRzlTsiC3aEfM4cCTmZVVCdrNbtHvAeteJhZ2Lyx+nmzQSn0DcAVw0DCMRw3D+JRhGH9gGMbvGIbxp4Zh/BNwCvgUcAfwZy/x/f6rmImIWRe/aBrCSTLNM6SiISIhqVx+cEmS7h1Dk7Ewzbag1uyBfvXi9Jr/LH9stik32nSSU/KUeNfv48cOKbXsO585ZUcCNPk2Yonj7/gwfHBMkj+BH/t/L/Z1woqHgzx0YLkHieknl5qL0+H75c+3j/BI8838u8W/Hfgc120aIxkJ8peWlPewQ8hntdpkUWSJrTw3sE2rWR0lfZKrl1Y5UJDDXzuay6U6S2Jk6JTxXkvHQt13ZOHpaUQs1K46agc5mWtplkZZOkm9i5PSFJv1iYjZyoq0O7SFMEOTVhHFg2fkmJpat0G2H1y1oZ0m4uCg03RKhUm+uGvBPk5rLshtalpuDqJ7X4O4huAg0lhZGRyaBCgcN2t/TnogYvFw0M7d0k6M0wYBfY7YmVKdNR78MG2JSMhEubp6epbQZHxUct8Uv63caJMIBwdWg5hUa5Qt7KOFc2/8HfvFlpCPNq/QpO1PraEfN76q1pt66JPmRydWqxSqTV9lZ8wQWbEmnYDeQ2FyQqIxT8mEFi/E1s0CAYOJiHI4rGNUczR7aq9+2nirr6xJ6HXE+hGxeqtDK+xcZmqQzYzEOGlBxNpVOc9emPhRk5pRbXTM5KRh6DBdB9gyhtpNqXDvNA9Sk3DqScBeisvLJtPRPuQ22HZxxPTBv3S6W+JoACL2QxeaFELsE0K8Famc/1VgGvhZ4JeA1wALwHuBjUKITwsh/AebX46mnImL9qskUHXSMUUa01Nk28tmWDIZDXJA1ehzCk12QzIuoUO1eGhF6WeLSmfnoU/4ut0nj/WXtJDta0TMsjipxaOalnH23e8+OPCEtWchx2qlyVPH8/YN1Lx/y8TQi9NVvyh/vj3PpZ1/4Pvrek7ajs+Rp9bsmOG3xw6eJtip9SENuUqDRZElWPPP4eq1k/kaAUPKV+Q7ksRdtHDESuFxjHoRvvfBs/6OdCxk6YPuO5KImHomnyHo+blRbrhoDZlYyJ6VqzfQXjQmMUYnGOUngw/5QsR6C75nomFTRyxa74ooHlAitXNrZcHmTbGirayTXticstIOL8uMJ2tZEUCOIyPYVXTXlp6Sp9x6ESHEwBD3/Nwoa0fjXDTVo1hfXXGWrtCmnZvdn+Z0oU4wYJihFyeLR4L2rMnaIEdsiyy9o/TMlop1T36YtmQkyI+f+TzcPsIrnvuo/PB/XtezFk1bOGJtEj64TxoRW7KGfdycyfSMqoHY7WOvrEnbnyoBXyGE4zyQjah3//y3ALnW7DtdYmGl4qsGoO6n1XxeHkic0Jj0NBx5CDg7RwxgTVg9vxMNQ78zNQ5qrcHyFTGn4vG1Qp8jWW92iIQjEEnD2lcNdc+z2TgnFCLW7ggCqg8iySyleotas0212aag1PV5xL/61FjCgSNWc9gPtGmeGF2O2EAuoz4wWMZpH1lfH/y/pSQ/PnYpH7h3nltDd/zbc8S0CSGOCiE+qgj6VwkhLhFCvEYI8WtCiG/90Dtg2pQzsXO7JJv3wsEiNc24yJlhyWQ0xOEzcpNxC00CfOq+Aw6IkiEnGfD9/fLUe5ezTqarXX/hGvPfNiTA5Ij1n6gaYTmY/YQmXcNiNY/QpGUyNgfoiFm/xypj8fi+w/IXvYhYpcmKhtObDsr4PkyTijNGlbIhHTGTI1auU4uqd/rAR8+qfYBUNEyw0Y/2VBptFlHPNMQp9MKJNB2BPStXb6C9RHHDoJaYYT6wn6iPhIxejttIImxxAj4mL/rkq3j/PVdxW/wbjKaikJ5mXSjPKcup22uju+lil/I6GgnoRXL0KffuD1pS0r3H0UQqylTGUoO00xlM1tffs/fbnCrUmEhFTU1AJ0v0OWJqHjiR9QHGFWFfoWISERssVhqPBPli7Galn/R2+aFVPwlsOlmDtJm0TTiFJmurkige6rkvnRDwva50Qr7aJBIKDFw70rGQqsPb6dIYelHPSMLG33Nda1xMIzPlgjqUeaEldHX4hglNAoyFlDPgtdapcVBtDCbr+0fE2pLHGxuBiR4S/ACzImLFWtMMr8ZScpyulBsyChNWa51yhv1YKBhgNBE2ZTCA7oHEyVHar5JBbh/hpq9exK2hO3whYmARde10JFnf6eD/7n+SP7/n2/zZtt18ovMLA5M90rEw1Wbbnrl6nu3fXmmil9BaySm2GEfNzSYVDZkbhRMipsMdX/j+4X5EKZo2NVEePrTMraE7+N/R27t/7IOcOT83yqY1STauSdqRgHpJKleH+k/f9VCGU2J04IIBHmExp9CkNrUpiVZdlqbxUWZn26ZxcwMMBQNcO63+xkrW3/Fh/uvD2/jPwX+QP//xtK/Qaq9px2MyUufaV2yyifudKTZoxScGtDDY0rGQPMFBvyMm1DPt/rTv9kbiYUr1ln3hcEPEgGpccoj8kvWtodtoKMDX0u/qE1F868y/cNek4jSmZ5g2VjlVsCJi7vyh126ZIBI0zHffRfX6uTFA9xT9yGe6ZUuGPeXWVmWY3wsRiyTM97fvdBEQnkhMPBy0a5UNRMSUI/Z9qQruHxELmWEcU08v0PP86Wk4LQualOvtgbwbkIevbCLcH5p04rhpHtruT5kfFaotV36Y1Uz9wVqzi4jFHDZprfN2+4iJZvitAajpIV1HzKF9lTTE7SP88j1XSyfAxwHUaqNB9a6cyPoWR0wIIUscDZhzcSfx4XqhDzGsN1WCSmzEVnfVj81m4+QqTaqNNquVJilVzi2RlvNuudSQiFw4KZ3wIW08FTVDnOb9g7OjdO2vyJ9vz3PHTz3Dx1tvIeGhrA+YEjLmOG2UMBADnWE/lVzAUl/3ZYSK/V9HzM1u/C99H9Xjk4waZZLKiUlaVNWd0qIX3EIyPRvQutEEH2+9hfl6d9HzS87cuCZJPBy0oyUOJyzzV6EMZRHzJV/hGharK0TPEa6Xi3qrIk+Jg4p+6+/51ddJEvifv+UKLhsTtrYAuOk23r/pbj6YUATZX7nf1/tx/L71WeLtEpNrJkjHQmbI5SdWvsBtud/rXugzU6nX0rGQufhZF49Ko8WSUAvHc//ku71swqHmp1NISW1A44u7ALjsM+uHvv9oOGCGJkMt9QyBAAeXSlw4oRDW9DTr6gc4ne8Sas3QpMM8MAyD2Wyc6ZFYzzjtD8kANj6U1gbyIuuDdABtFACdCeaWNak3a7XJ/eOZn2BX48089LnfdHXGXBExN7J+dk4eiPZ+h3qrTaHWGpgx2fs9nvpJtVUQgmrTHyIGWl2/h6w/AE3as5Djkzv2s3Cm7Jgx2fen1rJcTjxAvUmvUyG32/Mc+MBxPt56C2+6fNpXDUDDMBhPRqiXVF9FHZwAC03i9qsf5HOht/uSxrBaNqBDk96OmMmrHISImaHJHh0xJ0QsFFSOmP9KIiARMZCZk/lqk7Qq55YckYeSM+U6P7b0ee4s/LSkAMBQa92aVMTuiHlFSDRa3OmY/MrBoUkVQteOmFd2sqUPGi1/yWF6jXo5hSf/ryPmZg4bfC0q0ZKsUmXXjtiUAxoGcMNFEvrtD8kUbINqVBWkfttrL+9tYqBNpKN9mitejlg1mGLEKPtS1gfYNJHqD4vV7IiezdRztSqKdO/jhAKy9heoeod6E+0LTTboaJSsevY8MZpV6LQgmlEbuJyQf9F8Mx+99Ovd63w6w72WjoXMxa8XEVslhQgODk9ZzVHPzSkspjaggxveBsDCr50Y+v4jwYCJ8gbbZYikyVeanCk12DShuFzpGRLtPI12xyTUmjpNLhycqUzM7gCAGqc9i/eOD8t6cspG/3yCw7GbufrQp/CyPtFbrzqT0N2sN/8oABtqX2FD7St8rPlm17BYH0esugqBcLeGYq8FQzB2IdDl1HiJuWpLRHscsVEn/STlKNVWFSLmzxHrE3Wt5ftDqzs+DH/9avPH+c9v4AP3znPdkU8T8uHI2ORK3DK4wYZ4n1Z8w3daMnEHWTwc4NhJxbV02qQt7Rdr/tC8XssGHLImtYUTEAhBrSu9MzRZv9OR76iXI9bqyDX6LBAxU0tstSYdMXUozGblXFguNfhq8p28ffZfumXqhljrxlNRzthCkx4REt0v9YI5pgeN1Vg4SDoWMiNKjohbb/u1vCyp5wsRUweFl5Go6/91xPyYOj2veehDAPz4t66F20d4W+mLgHPGJMgK7yArvttDMvYsH73B/vobtipy5jW+b20yHWWlXDfrJQIyazLi7IhVAilGKPsOW2XjEYewmEOqsjY1MdpluXj4dcT0SbtQa1nQnl6yfpOADjVVzsERs5ywNCLWaHXIV5vEMy9GaDJsLn7WfrjkuU9yOPZOjLY6Tfo8hY4oRGzV5oi5hyYrIdkHUR9oZK9FQ0ELIlaBkXV852nJRTJHmApbJaiZGZHFWpN4OOja39MjMVsoUz5Dvn+D1g7SxW8C4Oivn2RD7Ss8f8mvet53OhayC8Z61Zm0mqV00KCwWDwcsmdNaifGKVtRI25LMsN37cenORy7mWsPDw5J94UmrX2s2/3u78qf//sGvrn0Jt5W+tLAdkGrlg8ITd50G/xul8NoOqmtt5ihYi/rImKW0KTTehTLmuuFHhtua2mv7VnIcXi5QqUgneZnnJYD7WA2a5IrNYSYq7aMdsQiDhmMhiHvv14wHatB/Lk+QddGCRx0yuqtzlkjYlpL7Eu7F/jB0VXzUJgdleN6pVynrjXPvDiULrYmGRkcmtRmSWjQjtggZxWUllgvIua05+jPFCLmZ1/LuOkankcbeNeGYbzbMIzBx7jB7fytYRiLhmE8bfnsdsMwjhuG8bj6703n+j0vianN4dnX/jUAz/zkP65r4uwAACAASURBVMHteXbMSCFKN+2hcDDAWDLChjXJ/pCMZVDlyg3i4aCcpPFsl1viwybSUTqiJ53YAxGrBNKEjTYx/JHdHcNibiElsCBiyhHzre5u+R7tZPQIuq5WmoRSapMcQoSwzywLRyYuEbGcQnYeP9WgEwjDBdd5NOBtqWiINFXa4ZQNNXxg3fvZUPsKQotP+jyFOiJi1VXcwsOVoHLEWv4kMqwWDQdMHbFQq0LJSPD7/yinbPPuP5ZOwPduB+DZ2Htl+HPHh2WdSY+MtOlMjNOFul1Tz2scKV2ojpJoGCjS2FtGyUTEBqArKgwapsWNWyY8w2KJSJBqs919hlrenR/Ww5H53ltfYEPtKxSv/y3v+0Eib7Vmh3ZH9Osn6XbfpZDb997Ja+Lf4J7p9w1sFyT/ZrFY6z5D1eUZwnEI2pd9A1nLcJDZEbGCdMKc0HNL35iOmEt0oddkgg/mgefhkw6bqnYwa6uU6s4F6QdZ2qhRJu58/2A6SlWfTkafoKtDnUmAerNt4YgN54hpov6dT5/ir+7eR8qoIowgyWSacNDge8+eZqXckPcSHx08R3psPBUlX+3qdnknb2XNa2rNNrFwwFd4WI5TH6HJYEiOL5Mj5gextYTOXybmZ5f8POCy2gxlXwDe6PD5x4QQr1T/fedF+J6XzIqGDM2kOpJAq09Y0yPufupk7wkU+tKVc5WmWYyaeNa5dI2LTfQSG6GbDOBgpYA82UWa/jZp17CY2wakPu+oZ/DDEYMuybtoQ8S63yGEYLXSIJJWmT7nEpq0pFunVT1QLSZ713OLLLcTLMU3nXXz6ViIFFWaIfsputJsEQ0FMIY8hWZ1H1R6ELHYiOMGUQ7Ivo82h1vAQTo8mu8SbFdYbkZNFOTjzTfzyRv3wDtkwsRP1T/EF9/4JNx0G8UBG930SIxGq0PO+gxOoUltczI0Fj4m+W6DuB96cTWLZftGxKSW2JSR401XzHiGxeKRIB1BtwRUzYVfZWtfIm6rq/J+/OiIaYX8SqOlHDEHDprmvlWWlXyF39Ck7E+zH2qr7lmf8Swrma3mjwLYsGYwudsm2+PlbMezci522pzO10jHQr6SDqCb4KPRnisvcgjf6ueqrlKsnZ0jlqJCSXg4n9GMcjIUR2wQIqbGsYmIuYRua61ON2uyVhiqDNGeha6sUbsj5DuKpnnsaJ5mW/Dw4RzHclXK9ZZ0wozhAmM6Y1UfXn2FJmt5OU599m8oaLB/sSj5ml7yGPrzIThirrJS59H89MDw8Q0HE0LcB5zD7nn+7blV2YEry1JfKakWPy843ZnDZUfE8tUGWaXPQiw7FNqjOSc2Z69ecpSuACgiF1LD5ynLOSw2ODQplJqz39Bk2pppVc3RCsblaUdZqd6i1RFkUgkZJqicAyJmgbozKtvuzmdkKEYAOZEiv3L2oq4yNFmhEbLrY1U0lycx6l16p8dcETGXhakUkH0TaQ7HLQGJiOmTbqhVIT3SdWTMsJ06QY8FyqaERdGl4Lc2PUdMoUkhulxDxz+4AiJposelIzZoHKWjlvEDMiPPCPTrV/WadsRYYTThzd3rKy5ey7sT9c32JeJ25NB+AI6ulL2vx0robqvQpBP/qRuirzRaA8sbadMZaf/j7n3sOXRGOUouzxDLshKWjuSsQqr2nS4N1PjqI+u79XEsCwio5WWZOJ9hSZCc1ZuvXU/GKNMxQly9aab/IgsiVqw1SZ0FRywhKhTxcMQ0IuZTIysUlELgpiNmOhlOiJgKTSKg4R/d3rZpnKAKlwcCBiOBGkYsY+M+CmDvqSInG3G53wzh6GkNN13EnlpeoZ4Oz25xhiuNwSWgQIadHzywTL7a4p2f3cWRE6rKxgBHrOmzkotrybXzaH6PCIOJAWdvv2oYxruBR4HfFEI4znLDMH4Z+GWAqakpdu7c+ZLdUKlU6mt/f67N5x9e5j1R+Pr3n2JP7W6ePSEX/aeee4Gd9cOObXXKdY6utLvtCcFrq3mOLq5ySH12+GSVcAB27tzJpaUWicpxHvH5fEsVOYHuf/QJjFNyoXl1cZkzyyVecGjj0LIMAfzgoZ3ks4NL7RxYlQvG/bv3UDgoh8t1q4sUOlmec2g/0K7xWuDIvqeAtezb+zw7C/sHfo8QgoABT+89wKn282SCCR6wtK+f8/SRg9SMOKuHnuX5sxwDE4sPcSnw8FN7WV2cZrXS5OgpqeUWAAqkmK2dPusxlqt1GKdKvhHkMUsbB4/UCXTanFitsabZ5kGf7bcU/+/xZ19grnEYgMuPHyTSCrHHoY0XTkvE9pmH7yV3sDLUvS+drFOutdi5cyfbmmWzPuI1U0HeuCFM8dATPFw+xrXATLjE43sX2Bk9xfHTVWIhXN/ZcTWO7nrgEZYmQwTadV7baXLwxDJHXP7m8tRFBA7t5NZQmeeeiRJedK+osHBKLqo7v7+LC9IBtux/mjWhNA/ed5/n8yZLx3kVMGOscGjv0+z0+I6jR+V8v+e+BxiPB7h25SSlVJxnPfoxmzvNK4HHnnkWuIx3f3Y3v/2qGJtH3TekIyfks+y4737e1q5x6NQKCz3fEWxVuAHY//Qj1Jo/xukTR9m5c7BI8MNH5DP83YOH+faup3kkAvuPLXHM4Rmuahg0qoukI7Al3eREXpaTesenH/R8Bq0J+NTz+1mpHCHYFvzAof2pU6fYCuy69072HcsS9xg/ThYpNUlTpRmM89C99/b9Pl04yDzw1MP3sVK8lOJKY+g5PVVdoSDi7Nixw7FywaXFBonKCXY/+hgAzz/9JOLEAGfM6LD/0AI7d55ibPkxrgAee2Y/hWPd7bjWbHP6xDGeL57iEuChnXdSj036vu+f3Rzi6/uaZMKCEaqUmgGiqwuEA6ALvZwq1PnCYzluC3V44O7v+FbyP5qTc3nHg4+wtCbExQt7GTUi7HJ4t9HaItcDzz/xMAunIohmZ2AffOtAw8zGrjU73L3nGX4JuHf3DxCBfmf6lXWBOHWYU80z1FqDx1BTtf3Ecy+wU62n59v8OmLfMAyj4XWBEOJ1Xr93sb8G/gjp6P0R8FGkUr9T+38D/A3ANddcI7Zv334WX+fPdu7cSW/7z+zYz4qQCEOaMgeZ5P7jRwH45sE2b3v9lY5hjV3V53n4gYPceOONciI3q3Bvi7mLLmPuBvkdH9yzk03TGbZvvxryd8C+Q33f72a1Zpvfuu9fGJvdwPbtilv2QJ3ZjVuYdWjj8SOLsApXXbIBLhn8HeuXSnxo173Mbd7K9qu0EnmD+NwWphza33N4hfYDQeIxebq98vLL2H7ZdN91TjZy/3cZnZxluhKjVMrY3sFTx/Jw3wNsu/oKYqUZpjNRps92DDx6CJ6Fa294A48+VuHbh/ZyohLgdRePM79hjM0HLyDbOO34/vxYpdHihQcriOSk7Rn+4dgexlolZjddCqd3sv3GG52J3g6WuvdORqfWsX274pcd+BMYWec4TvYu1+EMXHnRerhyuGfYXXuee44dZPv27bTvq1JLyL77xHu3d/k7pSV4BDal2hxNjLB9+zb++LF7WT+ZYvv2ecd2t6xW+dCue5ic28L269ZDaRHuh01br2TTtS73GHwM7v5Dbg0d5cGr/pxXH/2MK58uuG+JTz7+MBdf9kqu3TgGi38LzanB86i6Co/+OtPGCq/7kWvZPOmC3gD5x4/DM49z5fy1bJ5MwcMNEnNbmPT6juUL4In/xqQKBrQF1LNzbN++2fVP6s+cgif3cOUrNsOjsHHrVWy8ruc7hICHIlwwIZGUS7dsZvtrB4fTH71zLzy7HwGkhETnNl9+DZtf6fAMx+dYXTjAuvEMr9g8wc5jB3w/Q2rnnYxNr2XsVAhizuOUvVV4/i/ZdsXFVB/PcfWGNWzffuXAZ9Amnl9kdW8F4qPO7a+sh8fg8s0XUHs8wMUb17N9+9b+6zzs1J42S5U4r77htc4Cyfk7YP9htmy9DB55lOuvneeKdd4oafrB7zE+Ocn27VfA08vwFFx9/XaYvASAVrtD+1/+mS0XbuSSmRrshetfuRWm/WfVX3Vdk2/+0V3k6oKxVJ3U+Cy3/NzruerqHB+/6wXuVyLiOSGdr9fMXwpjG321PXemzB/v3snaCy9h+1Xr4NRnoOMy12p52AWXzE2Rqo2xJtxg+/bXeL+fjTm+dXiXGe5t1MpUgxFSF17jTB04MQeFYyTjWVLA9u3XD3yGyD3/zMTMBUOPh5fK/AaH9wLPDPhvaBNCnBZCtJUy/2eAa8+mnX8N27ZpnBpRGiLIaKCCQffk1267K0FPpiUnY9XkZPRD0auVpkmKJz46VLpyLBwkEwt1Q5Ptlqz75ZI1mVNlffwSQHXIdFXzAYRwLFILElK++bO7We0k2PPCYQAiIf+R7XQsbIYmmz2nM81HGE2EJe/nxciaVPIVAMV6i5965SwfuGkz2fGpc0oGiIeDpIwqFcPOp5EciaC8/06zWxPUh43Ew6xWLWehqju3Z9VQfX8WPLpoKECzLeg06wQ7DfatBtg8mbKTqNX3TkerZpmjQRyciXQUw+iSsgfyPgA2dBfsRCsH9/6p66U6HKYV1AfWmdQWG6EZjDNjrHTpAS6m+S3VRluFVj24ktpU6HM2IPvCj1ipTu9vaI0sp+8wDIiP0SnLdcePQDPITG7t+4+FtNadO0cs1ioylYny+q1TxCylsAY9gymw68FX1SHudiXHYrE+VGgSJFcpQ4V6yCv0Ca3KCo1W56w4YtFOhQIJe0ki23fIsFit5T8jMB4OenLENAfRJOvD0IT9kXiY+fXy/aapmu3Pz41y649uMfuyqGgMw6x3toLr+t7cqCqRtKQIKI6Yn/ejhZ9vuGgNBpBB9oFrtYV4Fqr+Q5MgMyeL9R++0ORtQohzq4TsYIZhzAghVACYnwOe9rr+fNrWmTRgUA2m+bnNSY5cvY6vP3aMZqvjuTBNmOUa6lIvzHQCFKm9I0noJj8lnoVWTSJnbvpEDt/RVSH20O0BVrUj5jMhQKf65lUZIJoVqcHlQMDddXCZeqtDIZAgJaST4ZcjBlLCQvJKVmmF7Cefx47IheLEalUu4PljvtvtM0uNw3Ssu8C9WpeMio+ekyNmGAYZo8oR7I5YVZNVLfwe102qx0biYXvmqpsiOpAXCToYBM7CWdWn/kYlTwwpC7Bla0/IIhiGSIpUu8jRlQp7Dq8oeQB3Dk44GGAiFTX1olxL32jb8WGb4/XK/3VN93MHVKxPpLGak/NokBkGxcgkU40VMynCzfQmUmm01DxoDnbEwnGIZdkqyqw1YvyPd1w9UCdLO3xNL0cMIDFuOmJJn2R9za368u4j3HbTDNyHO1k/liXRKTKtSkd9+ZZt7Dq4zLZN4wOfQTpiTUeNLGv7AKXVJdqdNFMeBdedbDwVpWZUqAZGcPwG9d4axRVgw9DljQCi7RIlsZ5yo03WKU8hloVmhVpNjjU/peNi4aCFZ9h/MH8xHDGAGy+e4OHDK0TbJVbaUfSxxNqXr09G4DsMtd6lVVUDs95kvQApl6hHIGAmNFQbbbNY+yCbnxvl1jdsYffBFTJGmSIJd+dfk/WDHSIJ/1n6LyeOmJ+7flH4YYZhfBV4CLjYMIxjhmG8D/gzwzCeMgzjSeAm4D+9GN/1UtizJwoIIJQcZSJU7avR57YwTfaS6XsKfhfrLTqiKxNhbq5DZE5OpmOW9hXK4rLB5Trq1OkTdQsFA6SjoS4a44FkbNs0jgEUSDKi0sqHccTSUeVsVFdpWYjuexZyfOIeyTP7rTueZLGdPDf5Cq3jZhhmPdCxZJhjOYUQxLPQLEOr7tGIt6Wo9mVblXVNQFOU1v8zjMTDXVTVfAbnDbrWhhJn9460Ds+T+2Th00Inzl3Pnu4jaNfDI+SWF2m2BTd/djflRnsg4mDTEnMqTG81JdOwf2uPfti9f+qovdanDVRZgeXB3ESA1dAa1gVzhAaMVY06VZrtwar6tptbyxqxzObJtC+xUu1UtXVCitt3JMZM1NNvNhrAe169AcDU4HIbR53oCGkqTKXlHLGWwhpk5kbnVsYKTAewmJNcVTcZIDcbT0ZIU6GMSyZnIAjREVpl+Y7ORkcs3CpTIm7Xj7NaT5a4H0csHulFxAxZbkiZlo+JhYPn5IhpxzbaqXDn/optDuu+vGTjevnBEGuFYRisSUbsZH03ZxtMJQBZE9V/H8zPjfKRX7iCNFWCkaT7uFNabq1Wa6jksP+/Zk2+QwgxI4QICyHWCSE+J4T4RSHE5UKIK4QQP21Bx1529uQxlQWYGjOdGD8Lk1lJXhcw7RGn0yG/rBURg6HCkzZEzNzgnImX1RaUjeRQEzsTD3elE1x0b0C+j0w8TFEkuGRUl6YZDhEr1KSOmDU0uevgsklYb7U7LFSiQ2f62MyyOZxclc7XSrnZrQd6Fo6SzdotEtRY7dgdMbMosJZUGCJ0mE2Eu1mTzZpEe1yQjEarQ8FIn1VoUkP7zy4cB6BInE5H9IUFCkaKEUrm94FzwW+r2dT1XbLFeu25Sz4AQEdvVC7aaymrIyZEt46hDztjrGHGGPyuElYNKKcSU26WmWG0dca3+r2uxdeueugnAcRHCagx6rdtgM2TKebGExw4olBlF0evFJDvfF1ieOQgHQtRrtblgcYzaxKqyiH0qyFm/nk4SNaoUCDpflE8S0c5tEOHJjtt0xGreIUm6WaJ+wkR22qWapqHRYZGCyrfv2+Jx8+oD8/CEdNzLU2FQifuHNo7y7UuFg7y2EKuKy/h5myDTWvNbwhd2+u2TpExytSDHn2sMkvDrZLv0GRfbdrzbH7u+iZ+yGUnXgx7+nieqUyUSHLs3OQlehAxjXKMWjliMCQiJrXKhBDeJUWQWSjVQGqo9m1OgAci1ukISvUWeRLE2nKTHiTEabVMLEyjWoZWjZaF9zE/JxdsrXw+PT0jCzrXh1+cAFuJqaO5rrCtWQ/0XB0xFR7Od+wbS67SYGG5wjNKBmUYnpvkiFm0n8B1Az1dqLFKisJZSHBoRGzrqKohScIx9B5NjzMasEsxDETEMjGTUzZonGprtDp8vPXztJNTntfFw0GCAYMr9v9P+MMstNV881G94BRjjIscdFw2W2Xa2ak0LIiYW1jPaplZxjrLvtEAUxNskLOXGCdYGx4RMwyDN2ydYnFJZln+wCV5erUjN7/ZqI8Qb4+lY2HaXvpSAOEYhOI0SvIZhuWIgRR0Xe14/F08a6JVQ4cmFYezKBKDHTE1HgYV/QYHjljPHNA0jO88dYp3flHRr8/CEdu2aQ3pcJuo0aIScAntmREY/2udrGpQ5uCZMu/87EPy2b0OJKpMU6XpvxSXtlQ0xEigSkF46NfFtIB12ffBX5ZE++FCxFaBG6wfGIbxTsMwDiql/E8ZhjFc8bwfQnvyeJ7L12aHFlxNRUMkIkGLSrB9ccqZiFhvaHI4Z6/abMsSLw3vkE+t2aYSTA+FuGUTVifAvdxEvtqk3REURJKQcpLCQ5L19X1ZQ5NVdUL8+fm1fPmWbVwwu07+4mwJ+5aF4w1OJGTN4TpbR0w5Gbl2l/OyZyFHrtLkqeN5fvmOA0O3P6KcYSFEd/w5OAF71Cl1qZXgyPHjAzWfei2qQivrk3KjaASTjqH3zOgEr8i2ee1Fa0zuwqCNbnokRr7alGiAB7JqtWa7w8dbb6GTmobMOtfrDMMgFQ1x58Qvwa0WqqmP6gXH26OEaEPZW87F5IjZQpM+ELH0LGOsko74Y3nozcqoufezvHBMzTPBwvJgfTKrXTAWJy3KNEWQd/zdE47j5ExbIrpT4bNxxEKImg9nOz5Ku7xCMGAw7qMgus06HRJUWWl56Xxlzfc4NCKm5nGRuDdZH6nLGA4aA8PbALFIsEeLzj4HvvqwpAUIoNYyaASHi2Bom58b5UvvklnWb77+Fc6Rm1BE6jIOsRbpqgYAoVYVQ7S9ke1Y9qwRMYCsUe0mmTm2rxyxdnEIROyHjyP2IcBMXzIM4xVItf19wFeBdwK/85Lc3cvESvUWB5ZKXL52RA2q4YQybXWzXBCxcwlN6mr1i8W6pbabc2iy1mrLLKMhnEnJT9LETPcNaLksrymQIKLK6wwbmgwrxX9raPK7z5wmGQnyJz93uVxMzNDe8IKlgA1Kd+T6nSsippzt5Wb3pP7ggTPmv5dbOmFiOI5Yo9WRKd01d6REL5I50oxQdM80cjGNYOqwWDQ16ryAx0eJtwp85BeuRFcsMcVaXUwjHh/97l5OnFaaVz4cMQCRnpZJAh6WjoUo1VpDh2SPNNWcKxz3vK4rtNoaiEraLDNDAMEk/sZrLBTEMMCoF+gYQVlc2sGO1uIEaJOhwm3/+6mhnO7VcpMRyuRJ0mz1h54BFpvSwVkT8lcOzWrpWAhDr0UD+ENGbZXJdJSgj9I3NqsXCCBYano4cPEsQbVmDe2IqXlcEoNDk0a94IsfBjo0qWgVPYjYF75/iEcO5wgYmIfDsylzpO3KNfKdrp/1kBCKDxfl0VUNAMZCykkfgIiJWp56q2OG3YexlCiz3B4gqgvE2yXflVzMteJlYn52yauBuyw/vx14VgjxY0KI3wBuBd72Utzc+bY9Czk+uWM/f/m9FxCCLtF6yJITstCulRtjmPISq6Ysg0VZH4Yrc5SSG9yS1RFzOYUWay2WWnGqxWHCYpFu1qQHt2dFO2IiSUTUidAcOjSpeUctVR7o0cMr/OPjx7lyXbar4xMfnmNlsx4ovY/rd66OmOqDpWYXKJ4bk5tpwABCEVmHcsjQJCh1fRON6XeQtm2U7yYvkmQpDZQZ6LVoWPaXUP0ciLvzk6jmOLrSFYz97/+y19MZ0KGAzz1wiH/Z8wLtkL16gpM1VHklIz0DxVOS/+ViqWhIFo3X7/XKmz3b1nagocbyg3/leV1XWb8zFFm/lZKq7xPCn1McCBgkwkFCjbxEhl205vYW5JgYNYq0PCR0nOyGLRNkjDJ5kXTN+j5Zlw5OhuHQNpBzOdbxThwCVCURudYNi97qQ+2ilyMWyxJuaEdsyNCkiYglKA8g64caeV/SDODCEQMePrTM7f/nWdlewODt167ny7dsI5IcPWtHzBcFID5cNZf5uVHeOi/R6U/83IWq/cFkfRiOywhAs0aYJkutwYhYvD0MRyxMqdEyhWPPt/m563HAelR8LfB/LD/vBNa/iPf0srA9Czlu/swu/vzOvXzm/kMAfOS7ezlaiwBiKH6SrYCp1tVR5Exd801vtHJQGWeFiH1p1wJHTyleUM/E231wmff93SNSRb4SoZBb8r3wjcTD5KsNxUFzDymtlOUzFlQWU5rKcFmTsRBZQy76rVDK1CWrNNo8srDSvV/tKJ1taNKr/p21/bN2xOQ7WmpGzeLK+j28a9scX75lG8Hk2FCOZDYunbq8yiqV99nvBMytkSHd0TXTpI0q8+v8qWVr0xwx7YiFE24Zb6PQabJnf1dGxEtPD+CI4uN1BCRFhVrAg4CrTCcCBNLTUh/PY0PKxMJSR0y/1x/59YHtt9odDtSUs/nMNzyv1eVpKk1rPVRvRA+gGpP8trH2mQFXdi0eCRFqFMwDiZPNXXABAKOUfGl7WW1+bpQL4g0qAefQM8CxmlxXAkNGAEDVW1WZ016b9CpJQo08J/O1brKMX1Nj9FQt4r6hxkeJNAuAGD5rUjkxJTE4NBlsFH2H3WLhgCNHbMfz3dB4uyOYzcZlv5wDItZdr73Dw8Ouda9YK597XVJRVgYgYkarSoQmsWEdMfXcS+2EmU3q1D5AQpR87zeZWAghoOTmYP8rm5+7XgLWAhiGEQTmgd2W30eAs0xfe/naroPL3eryylrtDi/ke4i0PmwiHWWpYOGIWRam1UqDTCzUheUDQbm4DzExTqjMv28/eZJv7HpefmgJTT56eIW3/80u7n5OOml5kmQo+z5BZxNhmm0hF49a3tTg6jUdmiyp4ugZo0LYJ1QMMjtzRJ2+X6jE+Z2vP2n2gS1zL3EOHK5OR2kbeSwc0bR8xnNExFbbMVMTaP+iRAf+y49f0g1/DhmaBIWgeoTFtATHJRtVEeQhn0E7YtSL1AmTSLg4S8pZ3TYTIBLyJ/T5hktkiRYDyBhVd7TNYjo0GVDFsymecr02pTOhtIPuQ9A1X22yQpq24Q8tiWt+Ty0PgfDAcClAWZWmGR3CEUtGg4RbRRtXstcu2iD7eC5R85TQcbPpSI1cJ8Gls86O0kJZPdtZOmJpBjtiJ+sxRgw5N8xkGb+mNumcSHRrjPZaPEtQNBkJtXyjJaapw3bRK2sykgQjSLhZJOakvO90S4qsL3S9VeXMXzgp+zrQO5cU2f2sbJBMDJyVI6aTyyp5Ndc8HTG5TmWokPCJGpqm+rggEiwWXOSE1HenRHmorEl4+dSb9HPXO4E/MAxjE/Cb6rMdlt+/Ajj84t7W+bdtm8YJWDgLenLMrVVlfoaUlyjWW1QbbXK5Myy3o3xl9xE+uWM/B5bKUujVaha43o89c0IOVgEkOhWagZgt5PPdZ0/bxOAKIkncaHD9nD+0JGs6AU25cATDjuESrbSczMgNMENZchx8WjoWYkQhYn/+RNh0XgynhQnj7EKTdXk65ugj7tcYxrmJuloWDz3R9y2WWDca72a3xYerDqCTOWyImMPidywnQ4XpsQn5wdCOmFwoA/UCJRHvIrW9phyxK8aFLz09gFdvXkMqGuTKC0Z49QUR4qnBYb1muyP5MiNSoZ6SuyOWjoVkworpiA12TIydf8qh2LsICrWRD8iyTJiO2KoUdPVhZSNNTYTJNP1nscbDQWIDHDGzD0ZbQzthAGlRZlUkzXnWa0eK0CJ0VlzMdDRM2kTE3NGYWGacEcpmRvRQoXSF9hRFoisu2vcFcoyNBipnEfrUiFjCXUfMMCA2QrhV9I32xCJBWaCk1bEhYtMZyYN66zUX2OfSuSBitZcGERtTVJpqUf2dp3yFcsSMmNkjkwAAIABJREFU8vChSdXHBRLdjOteU9+dMYbJmtSF6V8emZN+sNrfA74H7AfawK8LIaykgV8E7n4J7u282vzcKD+yeZwnjq7yO2/cSq7SYNumcTYLGcMfVl4C4D2ff5jfOH6MECH+6zeewkDO400TPQ5RfLiEgG2b1mDwAgJIB2p9k06rGQcMyT3YsmEdHIerJ/0N2hGLIzZbL7gqlq+UG6RjIRKZcahIRMw3R2zHh3n1vX/Kq9W+/1j0lwH4y9bP8+jGf8+tb9jSXZgCSujwbEKTGqo/eI/3dfHRcwh9qgWcOMVak4l0lP2LJVmfUFtiDFYXfDdp9kFV6qxJNKZ/+h5dkZvf2BqFIA35DBoRMxoFij4cMao55jde7tsRWD+WZDwZZaRVhcjgsF6j3ZGLa1qRjb0QsahCxKorcnEODU7mPnjZr3H1A9fw5No/I7P8uMyw9LB4JCizJtv+N8ZKo8MpMcb04vd9/00yGiJWKtIKeaB6ChmejQ5PpgeItYsURILnTxW5bG2/U3+62KAWSpM629Akij/oEb7tRLMkjTq/+KoZfuaajcM5lMrJKBJnuVS3zy9lB0phLgSizTzv/Oyu4ZBDNY8bwZg7IgYQGyFWLRIP+1vrNJesVqsRa1XhxOMALCtqxy03bLTXPD2n0KROmPBArLQjJoTv2rc6uaxRHlD9wfK7DJXhsybV2CuKhHsyUCCIiKbJtCp0hkTE/v7BBd48v+6sDjIvpg10xIQQhw3DuAS4FFgSQpzoueQPgHOoN/PytaBhsH4syc3XWShwp4fPatQaXLsPrZCOVFgUstMFcuy3e/kN8dGhHL35uVGuWp/lWK7Kj65LEM7bFz7d/K/etJkbL55kPl+G/438jtTkwPZHEg5EcQdbLjcYT0aIZ8bglJx4vjliN93G0St/gzv/4r3cEvpnNta+gkDyKb5sdcK0JYbjWJnmd0E7F0RMZbtViVKstWh3BAeWSvzIZstpf0hETPdBQfeBCxpzLFdhNBEmPqLKNQ35jiImR6xIgYQvR2wYm83GZPg0VDDrMHpZsyWkM286Yu6az+lYWGZCVVZ8oWHQ5WiK1BT4iIq9r/m/eOcLX+1+cLvagG78L64SGeVGizJjbCg85+ueQCJv8U6ZqgdHrEiCuAgwFRqeTI8QBOp5SoEUC6cKfb+uNdvkq02KqSSN5SUGB3ntlo5JREwQwHDJ+gQ4Xo9yIfBb26dIjw+5GZrIc9JMFOq1p1cMLgRGKJuhz4Gbbk95rcfCt8CjQNKlj2MZYqXSUGR9gFpZrfGH7wcgV+5J3DLbH+kmiAWGDa/6QMQSY7JsnVc5qh4bTcp1oVFy5kruWch1y2EpLuuIUR5K7w7o9jFJd0QM6ERGyFQqlH3uN8cVneer/x977x1u11Xe+X/26fXee25Vl3xV3KtcZLCxRAkwTAgEkoAhZAKEzAzJ/AgQgiAhzmSCmVBCSJgJpgxlMAmQACEEDNiSu1wkF7mp66rfXk65p+/fH2uvfdo+Z6+1z5VMMnqfx4+8z9l3nV1W+a7v+33f99Fj/NMTJzy59pfSlK7aNM2yaZpP1YMwwzAChmEkrM/1YuT/jdjcYl0xbmke8nzV1whMskiaxlDc1amm0NyIXhQLwOUre1ksVkgFCi2Dbv94muFkmPf/0oWWPkkPTPZGg7wv8F1u/MYo7P+J+NDBhTOTLdAfDxHvEYCjz5fTCklPRgLEEYMt7IcrV/W2HyCaIdeAuNa/qxWS7uiGinloX1ohTTWYAAwyhTInZxcplKuNO/aoFQnlkkRUWiIUwGdY7uEOIP3E7CKrUjHPQEm6Jo3CAmnzbACxqJhQHRJZOlmxUhHu7VBcsFwdGLFkJECxUqWSna7pCF1M5vHzJ4ch4F7b9f9GbuXm6PfI9V8sPlDIU5Yrljlt6kGZWNBHvNrZNXl6ocgcCfoND0CsmMEwK1wfGuOFM+mWr+9+XqQXOVOM8PyRY9puPcGILVIKJDqyLEezAnQkqx7uwdZwxZhqA8Q2rhWb6F4jq+76tMprsUVUdbjO+Bbvu2hn+3cc6SVazainr5BF3bONm8KZXAnDoLX4vJU53s4RqWOFBfCHIdApxYf+WJZgsbo4jyjRVAPbMtDt0z/dx9u+tItnZ8T778GDa9JiPYv+GGc6AbFwDz2oa8SkO97EgzbxLJjrVRuG8QrDMH696bMPAxlgzjCMnxiGoZBM59+ezedKrQuRBDEajNUtFw7bSUN7jBzLh4d5x41r7e+7dU0CrO6PkS6UKS8utCxwB8YzbBqpp7r17qEvFuKz5TfzD6/bC8uvFB86LEDTmSL98TA9qRoQ07FEWERaZf095CvwhqtXtt+leHEdbtsOb/vH2nGnRVSTlWyw/AJVKz1JOl/iwISYQBvcDbF+wFRm6Hw+gw+Fv8cHH74e9v3Iuv5WIHl8NseqVLSxsLiGSdekr5QmQwfXpIcNCcDy3qhITFuYh3CvnSKm3UJvM2IgWLGOjJjYbVdzM0pCfcAu3RXsXSZc7pX2mpHdY7PsG09zfHaR2enOyV9t23E7L//7TbzRb7klFTL9A/QFq4QodwRiJ+cWmTWT9NLKaLma1e+uKT/JPgcg9tAhsTDNm3GSpnpgj7SeSJAeI0ehk8YNOLBgMSReNj35BUzDT4kA0xlnIfcloyKy9NJUVZ/1sNiksB9X12Ssqs6IRYJ+3hf4Lmu+cWPtw9t6ef+D1/FH4e+1bl67qDeptOHxAMQiQb+437xIKFwPtncdnqZQrlI1Bch59LTQ1/UYXlyTVmLwcNwOSnOySrhXSwpz80bhMfCkTTwLpnLVHwbslNaGYVwPfBz4BvAh4Ergo2fl6l5kc2TEgjGhz9EASnbS0Fdtos+f54aLL+Cjr7vYDqdupaItsX6HnEnNtsbKU1XOLTQsVtWqycGJDBtH6tkYyYipDewGsX7BWdgLNdfkYF+KounXBmIBv49eX56TCHdpA3hsNq+uSdVdZVeuyRrFv5Av27uvRkZMHyh9NfQWXtP3Q7KDV4gPmoCkaZqcnF0UQCycBF/As2syWMqQJma/+xYLRsVO24Nr0kcVo5jlVD7IW++o7ZydwFipUq1VZ0gug/R427bthJ25GS1GLOAzCPUtB0zIto9srM8o3kOWM8lL3X9g23a+/bpn+MOS0Dzy/z3lyqABpPxi7HQCYqfmFpklQazsYYGuG/sT6QKfuqsxB9xKi6VfIE6vkdVeqBIWIzZbjrQF2eVKlefnrIXZS1Rgfh7DrNAXC9qBQs1mWiDmikH0XU/FDET7CfuNWrqJOpObiKlylLiZVRbrR4N+Plt+M/te+w+1D2+b570bd/Dt5Ntb/0ACsfs/o3f9YEXpLz0QAxE5aRRbNwFbRgfsAtUBv48rN64DhHtYmRHbcbvYsPz8TwH4eeW3uePwK9puYMqhHiGFUWTEXrZxCJ8BN4z2v+huSVADYpcD99Yd/xrwkGmav2Oa5meA/wa8/mxc3Itp1arJXK5o52+yzTC0yxyBlTT05lX4qiU4uYdwwM/LrXD+p0/ONU5WVo4mSupAZs2AAGLVQhqmD9qfn5hdZLFUaWLErIH99D+gYrGQn4DPEELxYgaWXdlyjmmazGaLDCRCjPRGWSBOn6EvIu7xFZi2EqE2gMdmi/Z3dFO1NQkkb/jPnc+LpgRo68CQtP+NBXwR8bwz+TIHJjIMJ8ON7JI9+akBpd1js4ynC7xwJs2ZyUaw8OiRaT53937ufmGCQrnK6v5YLfLzkEtQQpNJRixSzZI2o/S0A2IeI0tX9EVJWGkNcoceolip7ZydWBdbrA+QXN6REZORUL78rDIjNpsTmy1DaiWz7SMbt4wO4DcMfFRJGotU179S6TeyxTLHTav92aNKfyPrI54otNdXnZpbZJ4koaImiNlxO/zvl9iHRyO38sGHr+fhL3/AnofkvLdy+XJWRgraC9WTx+dIsMh4MdQWZI/N5OwySp7YZ4uxGoiHbKF7sy1UY1RNg5TRfgPZvv0MpNYRDrQyYrvHZnmrlWfyh/uypMx59fQVFhh58LmjDZ9PZwsMNEfQQ22+3v1/tG9BSfflBYjtuJ2HCr/KNfM/F8cW03vq+x9j89oUA1aA2O+/fAPXrF9O2Reix8ipZ9aX7mFrnn5D8h+4tPoP7B51nrdLwSQ9RlaZEfP5DPrjYS4YjL/oIAzUgFgfUD87vRT4Sd3xY1h5xv49WaZYpmrSyoiBpzJHQC2U+IjAtRdaQOOe5ycaJ6uovttndcrK3N7E+OwfF8eOrsmDP0PFDMOoFf4uZOCCm1vOWVgsU66a9MdDDPeEWTBjXG2qi5OlJY08GTNCPAhDnWrPRVNQKeoDpaKlRbnFpSqXh+LrthUW8Ft1C+9+foJdh6eJBP2Ni5FmLrRdh6dtgjRKnsn4hYBYEN5yxy4+87MD/Ndv7gEQjBgIMHL6Ka1LD/h9+H0QM3OkO7kmwTMQS1rRdBvSjwKd3QOlSrXJNdk+u34yEiBAGX9xAWJqDM5crig0OQmrqHimPRDbvDbF665YRp9PAMkVIx3KxtRZrljheNVKJ6IAxHaPzfLEfhFR+41DwbaM0qm5PPlgH8bcMaXrsG3bdnh7zUW/Ln8n6/J38lelN9lgWLr6rtq4jkBRr5IIiP6aNHIMMtcWZO8/k2betBi/p7+t3rhkS6wEvHenf4X/deDlnPr+x1pOncqVRNCJocfOA5ZbL0HYb7QAsV2HpylZOQJnq1FCRoV4QO0ZHZ0Sc9CeAyLGbeKi3xTtZEut3hFQq2fazgoLkHMZo3Kue+pbnc+rt23beduqu3g2KFjhDcVvsS5/Jy/ffSO7x2btBLhnFoSuqxBI0kNG3zVpbZyfnqqQLVbagvpysIch5ghp1DYeiIfaMqnn2lSA2GlgPYBhGGHgauDhuu+TQJtMa/92bb454329edUPFRpp3CpiEWoRDEqgdN+nlZuOP/RJjkZuJVqyrsvaofQ+8imgiV0KhNrWr2tnoYCPPUemoZRtk8xVdIGBRIiBeIg0MTaguUAAcWORDFFWJnwYnUKpvSZ1lUC1TS1O2+TkdO//1GsfoJDGmD0MwIOHpjgxu8ixmVwT2NarDrBldMBmq+Lk2R+53IpMmrLdZTL57SoLlKu655qtz1/EhynE+k4bEWkexsFIMkyPr5Ep3bJ+oK17oFiuY8QSy6BSaPvOE+EAfbIcj4ZrMhUL1qKHOwAxEDq/uGmxK+2KcTdZtlBm0jeI6QsoAbFdh6dJWr8xV4231WednFukGkkJllpDxgDUNiSI6HAQIFyC4alMQSSajqfArGoLxbeMDpBkkQt8421B9r7xNGkr+TOHfq7euGRLVl0PwGjhzgYQUG/TmSJzZoKRmce1rh8QzzWUJOynJY/YltEBWxaVRtxDr0/NA7DP2hzHDQFSftz7FgBmckWbSbJtx+1wxy21Y0WNoW2FNMy7zMNyLjrwU7U2LUvFQoQrlgvdmoRK5SoPHpwiawExqTXM+5Nc59uvn1S3mGYx0Gd372I75jyQJGyUCWmUK+2Ph9pG255rU3kqPwb+0jCMlwP/E8gC99d9fwUix9i/K5MpJ5yBmAdGbMft8LfX1o5v6+X377uWD4T+sTUruZzgd39Fvf1t2/n1oe/XtS/0Q39jvplkOMCB8UztOm7rrbk9FQb27rFZTs/nOT4hXGInsq27GplVvz8eJuD3kfMl7L/Vsbi5SNaMsCLRpmvK6//XD4rjT23UnJgyQuPnlmNKvoPHvqjWbr3lncXTDWBbAoW9akzA5rUp7vydLdy0foA4eZ4cL/G2L+3CdNiEX7D3c+KZHLP2S5qT94BVyDdDjESncHMPjFjgvv/Jj0Mfto+PRm7lWydfzebDf+d4fqli1iZvmcLinv/heG5PJEifka5dm4KdnsszmyuxZ8bqD5n2GjQQrFuPnR9LjanIFStEQkGMvjUw6547bsvoAClLX5k1Ym31WafnFzFkPypqRh1KF/31v8vn3noVhgHXrkmx6/A0u8dmmcoWGUyEPdW+BdFfU1Y/ageyHz08QyIaoRJ0j551tKIV+WYt0k7M23SmwDxx4vP79du3GLGQAyO2eW2Kj8a+z9HIrfxp4GsAvPvhVyqNs1s2CXZUuuivXL/Klna0MGLbtsMf1fUZhSjdxntQCOQIhCHoXm6s2VKxEJFqllzqIvuzYMDHJValhrUDMQ5PZjkznyfni7PRd7JdU+2tkKbatxa5F/P7DMfxUAiIPhTRiL4dSITsdevFNhUg9jEgj0jq+k7gd0zTrL/6d9JYFPzfhc1ZjFhLKDFoZ74HxMB5xw9qx9aAuvFdn27NSq64iDTbxt7GXfHusVnu3z9FulCusTFyN7ns8obr6DSwpVtMppY46KANlhTvxS/8LdzWy408DcDm/7NOCwREzJzNiDmavH4Z/fiun+lNTMUshBUqCnh5BxIk5gRgPRq5laORW3lf4LutZUvCvWD4tDRcm9emuGk0QcCokjGjlMpVXrB211ettuqtBf08vfG/imdylSX81Zy8+60FtOiPNlSXaDEvAQ3btvPnvX9mH67L38kHL72v7bUJjZgU61tJah//suO5iUiAlFU0XoUR2z02y9hMjoMTGW796lOiELsLI5aMBO3qD+pArEw8HIDUOiVGbPPaFK/bJFjN11+ccgQx1Xs+zv25N/L6yS+ID25fqbchsV30H+J1V6xg66YhHjw8bQdOHJ3KCCAmNyQPaAjFrXHQVxVzpNMcsHtsluuPfYEnq7+Gv2SBZw9sTy51sR1lKBm9+kjcqWyx5v7UNSviMOIQNZkvVfiL3BtYl7+TPwh8BICfbPmG0ji7acOgSKxtvdar1q9iIV+TdrRYuEfMFTom5yLptm73bO2NebbzeQ6WigWJmTmMtbXoz79+y9WstQLH/sPlYrz++b88y2RJyCX0qxtkiCf7+MNrw/gNg/9w+fLG8WBd/+husTm79h+uVr5+4Zr8xXDmub5d0zSnTNN8GZACUqZpfq/plF8D/vvZuLgX0+YWBbBw1IhF+zwKxVvp/c1rU7x324Za59pxO3zhZbUTNAbGaFJMFtULX8ddz57hPV9/3C5t1LJbVNTQQE2kLIv4rlk+0nKOpHgrt3yYz9+ym6+VXwXA+sKdfP6W3WogoFIiaJbImO75nLykEQFsd0NH23E7fPHltWPVd7BtO/xxLa3B7t8+yudv2c3wL/8ZH2gG2z6fY61IN9uySjybLGH8Ph9V0yQW8vOhV4tdaa5Up6NQdJ01W8ongFjJ7+K+jva5MkhOtiJWW9QMo3OZkVKDWL+zJisRDpCyGLHn5txrQNaPh1K5SjqQ6ijWh2ZGTNE1WayIaDEVIGYtLC8//EkAfu/Quxz73uS172dd/k7uvfqvxAe/e5/mhkS66AVIWW9F9MrAidPzBeEms4XiX1VrF1rGQflPZluu7Z4Xxvls+c2sy9/JE9UN4kMPbE9s0y38wSs3AvDxN4rN5W984WE+ddc+Hv7yB/jNn1zBy/x7rfY1gV4xAyGpESuL2pCWHZzIUDVhZV+UI9kIAMmqmvvWMAyGk2FGQiUhEfEH7PnTEYjJuWLF1WrXDeIZ/umcqJkL7Z+t3NgOX9r5PAfriwZJsMiZfG2sLe+N2EmSBxMh3hf4Lp8/8HKuKQrXsO7GnGIGwkku7A9wyYoeppqBk3X9e17yeQAOvuFflK+/Px5mIV+269m+mKYMs03TnDdNsyWG1zTNmSaG7N+F2YyYk2sy0ie0KorJOG2TQKxTxN627fDhOp++xsBYExc6hvvjr+F3v7Hbpl1b2BgQQu6IGuuzeW2KX7lqBQlL0zC6ojUb/4ylEeuPh9gyOsCCISbwSMBUDn1/8pAQr2aJ8O19xc67J495rCikHTVuDbZtO3z4eO1YZ4Eo1qKzJMi+9YY1rWD7tt5axKTGAnHVsJWV24jyS5eMcGJ2kStW9fLE8TkkeWWDbskKlfSiV/v84vyK3+U5RVMiI3epfaJFJ1sWFmPrK5XXcvGyno6Fd4tlS6y/43b43FW1Lxye2d6T8/RZ0XG/9/0jrrvva9aIPiSDBfw9yxQYsQA9uoxYoSwyivetFe+8U9oYa2E5folId3HHlf/k2PfueUFcZxqL3dXekGTFIh0QIOK1lwn2Qj6LUrliATGPKSLrNp1OOhwJrn0GzBlq2dwbzDStsZzgpo3C1dcbDbLr8DTlqokJ/FXpTbxx+F/5e14t/kZnHJeLIhgonCBTFJG9X3/4qM20ySCo11+1glnrHSSq6vncBhJhTAvoQe0ZtdQdlhbtg/71yu0DQn7SumS3b1/TBqMQMiqMZWpSlcl0gTkrSfLYdM4G25425iBc6Fb6jUtX9PDsqYUGQCztcEY8t4lxdYJE6vFms0V1YHiWTJPv/H/HpEbMMXxfMw+XbXJycovYCyX1qWhgZVQsaF/dU9vp+4CXbhhs1WnEBkBD2HjJih5ilmvSybU3nS2SCAcIB/wCuL1U5Lq6820O5Yna2NOHBPjJEKVSpXMSSc3qALYVM2quyXBSaMl0Tb7jTa9tf06T2FgP6AkQsG7FMI+NzfDcqQWuXpNiy+gAoYCvUW/oMalrjwW4q0EXZtJj/qGhkJio7xr8LUZ6wiyoMGLymY20d6nvOjxtuyYnyu1F7tLWW4mUX3HJCN989xaSAytcGb6eSJBeGRCgKtavZ8RASScWqYjfKJRbF53dY7N87AfPAHDHY9a71R0HBQsEWIrzzWtTrEnFWD+c4OvvvJ50ocLrpr8GX6iLkNZhlCxt0l2VzUw6uH9OzC4SD/l5/6s2cfmm9e7BM81WyokggnCSFX2in56aX2TLBTWXdNDvIxrwUwxZ70ln42xtqI5lA9x3Uvzdn/7zc3zqLuG6vXf/JCG/j9dcuoxZU1x7TKP+6GAihFE3F8nyRo7pK8CbDEDORRt/yf3cSB/Eh7SaHwiK93pwvraQTGUKNolx4+gAkYAPA5izwGoogH5hd6tvXLqyl7lcyS5PJG332Cxf3i2ezbcf2Kvs/pTPeipTbChp9WLYeSDWxuZyRaJBf2PZCslk3CU0AfzlBZqaBmvH5DbpeKGigWVhMZjHCyH8PgO/AaGgr7FgtrRYv9hFK05Og4kwcUtc6nT9B8Yz+H2GPQjWrBIZra/sV5/8Ni8TwGeRCAGfy4CVbIQXJkBl0jcMAVaXXaHZvsWIXfkb7ud60aFZQOyKC1YyvlCgXDW5Zk2qljS43gXqESjJ6C+znYBXjoMfvV8cf+YirXHQH7Dc2IE4pYrZwIg1Z9pvEOsDDF/ctt0towP0G2kKZpByIOo64cvN1q9cuUI8r/iwIiOWo2r4lcHDYrFS04iBUrH3UCXLnBkj7zB8dh2eplwRAG2mYrmPvYyDpg3J+uE44YCPdQPivR+89Pe9M8PWXPePlZeJha7OTNPkgQNTbL1wmN97+UYGh1cI9kkn8lMGG4STDMRDhAI+Ts4tsm6w1mf/4o2XUzFNKpL513lG1vUfmDOpLwVsIljavSfmWT+c4MJlSXK+OBXTIFJSB2IDiTCBcraVEXPSJIM3ICaDhi7/9c7ngZhP/R3SBTlYf0AAsX1zQpgPFiNmyXpu3jTEN39nCx989YXcdJlwH3/rNy9Vz9tlmg0b50utIIBnTzUyj7sOTzNdEe89UU0rV4Hoj4dYxjQrfvBmtes5i6ZZgfP/HZvLOWTV37Zd/LfvJ/Ct34B33w2rrnVuwMkKaeEKcIvYA4uKHtW75tlp+oEFYvgN+LXr1vCr17SpLB8bAEwxOcXddygDiZAt1m/O1Lx7bJaHDok0Cm/70i4BBKQGrUOm8ma7dEAsuL90zUau8kU6D1h/UExiXpiARKvGzdFiA9C3xv285vbBXYcGAgyHNd0y1i73qvWr8N8/T6WK7ZLcvLZJ2G2n+NBlxIQGymgHxOQ4OHI/fO0/wjv+GUZvcT63zT3kzDC7j6fx+TJ2tu0HD07xji8/iokAX99895bG9BVQA2L5+RbX4Oa1KRZ6isznEnzz3Te6TvhzzZHRiRHRn8qFtrX5khYjVgwkiXRKr1Jn2WKZtaFYHSN21PVvQuUsh80hipVWcLJldAC/z6BcNcn5rX7mhRluctGv6Ivy5PE5GzgNxkNirBt+dReXNKufpokxlW5kxA5OZDizkLfLzBAbFEBMo+i0zfaEe/D5DFb0Rjg1l+f4bI0tCQd9TGeLmNEBWECMA4W5TrQvxvG6FcsI7oVyVaQbkraQL3HTql4iQT/rBpPMzSeIaFQ4GEyECZazmOEUBiJ1BdCavkJaNAXTh5TbF/dgPSOVZ+ohE0CfpSWdr4S5aFmSmWyRqUyRqJUAPB7y1+akJ0fhBbhqUEOPVS4I6UMoAVW4eFkPPgOePTnPqy+t6UW3jA7wN1YKkX5/Tplx2/jc37Ar8lcgSfDbrPnkljbF3c+inWfE2tjcokOdSWkxby4f1ULHgKfIzJNnRI/KmFEqVZMVfdEOtRrlPajtHgbiYTvvTTMTUJ/LytYnxQe12gdsAfHrr7uQDSmFxH9eoleLGfV3EOvXu36oiaCVIjP79XWGFiN2LGvYBMJ779zjTMfruiYtpuvtC18C4H9P/1Znpst+x+pgG6CQmydDFBNRwSJbEELoHz51ioppNmTaL1WqjUkaRyxR8cQLjm0vD4r6iyq77nk7MloCMZldv30dSakRy/vVXWm5guWajPaJPvvMP7r+jb+cJUPUkRGTmk0D+OK7XmaVstLNp5dpGccr+qLM5kocnxVAfCARFsxwpBeW67HzNhAzoy0C6/sOiP5ykwRiXvqR9C5YY3lFX5RTc4scn6klbj08mWU6U8AvwZfWXCSA2PqVI3zouggfePWFfPyNl/OyjUNUTeHO2rRM/PZwMsycmaCwoH79g4kQMRbtElYz2SLhgK99vUpPrsnGZ9TRIn3injUSZPf6xXqQJsb6oQRDybCFK34DAAAgAElEQVSlESvRFws15oH0ElxVB7ZBVCRYP5RoYcQG4iHyhCgYYW69okeZcTO2fYS3FuuqM+oGiyyhnQdibWzeiRGTJhc4Lz57VRDgYYcy2iN2G4tG1L2QqSZb0sCINe2kpdamIUN6zMPkV9AAMSAmJ09MgGL7XoBYncvE1aIpETZe1gihtoDY7tO1CbNd5nJt16Slw7q7540AfGjtdzpPTDFrAc3qPaPlkTI5IvgNkReoakKhXGVNv9D61PejhhJHUGPEJp5zbLuXtKgK0EF3Jq0lV6Cd1LW9Tizo95Hy5Vj0qQOxbNES6wOk1sKpJ1z/JlDKkDajjhoxEMxcMhJg8wUDHjckrYmZV1paq2dOCmZnULIz0T4Y0GPnpVusFIgz2cSI/ejpU6RiQcYXrM+99KOmucIGYhaI7I+H2D+eZjZXIpCUQE9j41wHAjak/HbQzV+/5So7nYrfEFKMR4/MMEuS4ydOKOuThNQjT94nXHoz2SL98VD7JNaRPsEC61Q4sIGYIiMGWrrnaFU864wZZXQowWAizGSmYFWraFo7vcgkHDa1y3sjPHJkuuE537tfbJz8sRTLguqBSb3RIL0eyvCdDTsPxNrY3KJDnUlpHl0+ekBMP2v5ymiJSiDKf/ulS90Lmcb0GLFULGSnr2gGMjL69+1b1tbpk/TaB+rceqpAzMMCVFAU64MAk15YT1C7h5iXyUk8oytGV7aK81va99ZPE1ZW97hbuZBYP2BoM2L9gQJDg0O8/5cu5Ldfug4Qrp5UXLgDL1neY/ejUrnaWD+ud7V4thPO5bMS1QVW+6YYX3CP5Gx1Tapl10/5FskoAjHTNMkVK8TDFtMh3ZMuZhTTZIlSaEOYZgplEmEL3HlJMF1wZsQAnjohFuMBWWLMC9CzQEAo3tfAiO0+OsOeY3PM5kq1NCuSserARLa2LxdpixHrjTC+kOfoVJb+eIhLV/TYi3W01wM732ZTeHgqa2Ohz/xsP/+05wRV02TWTNBLRlmfNJAIkTDyLCKe+awFxNpaNAWYUNAIEGt6Rh0tog/EDGsuyhBldCjOUDLMlMWIpZYCiDWtB0ICM02mUOHWL9aqlOzcN8G6gRiBeL9W+z6fwYilq+b631W/rrNg54FYG3PUiEmL9CIWIC9ATFEDEenzJM70R3oaUyW0M5uxUruHUMBHf6BIwRcVwQR19vSJOUJ+H3/yHy+p/W4gJJKWenAHqLtve/UWoHJBFFN3S18hLTYgQIzOLlTnHrxENVrtXzm6slWc32zBKASi2v00YWaZMHuJBV2AmM8vJlgNHSBgJ2l877YNXLZS6DLS+TKzlk4mamlLQIj1g/VifcMQrFgbRixsCabPzLuzjPOLJQxDsEuAEOuDa86sHiNrl7Vxs2KlSqVqcsupLws373NWUmeXCESjkCbvi5F30IiBKCafiEgg5qHkmkP08Io+kcpirzWeeyL1QE83QlwAsUgi1SDWv/dADWzV0qx4cE02jbMVfVGqJjx+dJbVqSijg3FOzwswHk9ZmlCdDUnReVO46/A0ppWdsVypYiLmxnkSpIy0sj5JBj9lEM98WgmIobcm5DVck55ch6L9jBkls1hmyGLEZnNFeptJDC/phux3LN7BrsPTVC09hix19PChKe4/MCWy+XvYMIyErHli64c7n3iW7TwQczDTNIVGrB0Q8/kFCNBmxBY0XZPzmpFEC+pAzwNjlQqUyButKQ2ePD7HxcuTrXXEYv16i7SOWw/0GTGZTVxFSA8CiJlVPbCnw+p5YayKWZHaJBhtTQbsZB4W6ZiZ5VB1JXE3IAYWa6gLxGrMcNJa7BcWS3bY+zFL52OaZqtrEgQQG3+2cWxY+rZQXvTnm7653jWSc2GxRDIcsDOz24zY/p90vPwessrZ2nMWpfXcJqvawRusUk6/93hnt28xQ8EXp9AmxVpWZusHy23VvVh/WU8EnwGzuRIDiTo3me6GB8Q79gXpSyYaGLENVuLYhtyGUiOmNVc06ockm3d4Ksuq/hijQ7Xx19fTB/6QpmvSeS5qThPzpmtW8c13b2H92jWMBHLK+qSBmJ+4USBdFUBsNncWgFjTM+poNiOm3v6JMzKXXZT3/N/HKVaqpPNlJtIFB0bMQ7qhpuuXzx5E9Go06OMdX3mUctXk58+NM0dcu58OWik4lNecs2TngZiDFasCcbd1TYKlHzrLYn2z4piNf0naD8VFuLIWECuQs3Zw0ipVk2dOznPlaoecSvFBTXfAgrgmv2L+Lt0FSFeDpskaAkLX4A8pRsZ6cU1mG/I/uVqsX3vDEK1mWSBGXOU1xAf1x0ExbQNVyUal82U7l9JEukC+VKFksUEhf9O9Dl8q7umnf1L7bNt2+O0f24efv2W3q/B2Llds3GwFwkoJTBNmljmV6g8IwATUNGKDIoyfqQPt/6hchHKeYiBOoQ0jls43uSa1xfqtaVwCfh/LesT4boje8+SaFBGQg8lIAxAbTor237x5VY3JDcUt5lZzroAGRkza6lSM0aEayBxIRqwNgwfXZNMzckoTs3ltiqsvHMVXySsnT5YpXGYr4nnMZBzqTNabV8bKytzvah7SAZ2ZnKRs+sgTolSuMmO955msg0ZM1rP0Ita33oF89u/YshaAv91xyJ4jKlWT08Wo9jjoD+RZRGPNOUt2zoCYYRhfMQxjwjCMZxy++6BhGKZhGIPn6no6WbYkXm5b1yQIRulsa8RAD2jkF9TDvw1De5Hu8eXJmI1A7PBkhmyxwhWrHBYwXbZEJ6IRxORUyqmL3W13g6pr0qPOTfkde3BNqlQGaPiNlDZQCpXSpIkxkVNwycYGPLkmmxmxdL5sa7YATszm7NIjjowYwMN/0/j5mdrUcmbeXSM2v1iqbbZkbjQ53tq5Dkt5QmaRmYoaEJM1CmNSIzZglfOZ7gDErH5aCsQdoyYBsvUaMV2gVK2IcePA2kpAMxCvS98hNWg67HxesP9DiRAz2SIVK6xaCvffffNoI3sUH9RnxHxBO82IdKsCrO6PNjBig4mQNV9rCsUDUUcQ48hEa47lQFmwvrPlEMVylXShzMGJTHuxvydGTMdDos9YrYlXyBDFbxgEAz6uqXsejjWadTcMTa5JsCKGr16Jz6jlXpPsav/AsDYQ6/MtksallNs5sHPJiH0VeE3zh4ZhrAZeBRxr/u7Fsqy1HjiWN5LmlRHTEaLD2Rt4oC1GTxh5FqqNQOz7T54EIOhUHDqmyZboCOmhTnegOHnouia9BBzoRmWCvmtSJwu5Ztj77rFZgqUFFswYdzztUmYKLEbMi2uymRErMZcr2jnFjs3UgFiLy3v4Eud2x5+BaIpvhN7CGUWxvi3Ul5n7L3uTOG4Xym5ppabKekAsHqpjr+JDMLW//R9ZbE8lEHfMIwZOYn2NiDo5DhzGmg3Emhmxarn2dypmbToHk2GqZm3RlEBsKNGUp023HzVtamOhgO0OW52KsbwnQshv4DNE3jLtCGjduUh3LFsgY6oYZMc+4eJ78OBULYCh2by6JnU8MKAF6IdDRaLJPpsdrNfHOddo1pRJtHEP1wdE1FeOGRlZprcxB3rJsVCNvuj1Js8ZEDNN8z7AqZf+FfAhQGO7dXZNMmJt84iBtcPSFIpXimd1YGgFA4A2WxIjz1wlbO9ud4/N8nf3Hgbgj/7p6dYJRGrEVHfShbQ6SAJ91tCra1IHKOlMfsGYcGNquyY1GDFN1vORQxMkjUUWiLmXmYIa2FYFAeWiqNPqwIjN5kpctkK4SI5N5yg6MWI7bodPbagd1zNX48/AyGX8bNm7lKIm551yBQ5ZbJtcBJrNAmKTJUUgVpCuybr8UAMbYepg+z+yfrsSStKuDGemUKcRsyPqFGsd2huS1n4kgVgDUPKk71mAcC+DVjvSPTmZKRD0G63PPeaBEWsaZ3LxX8iXeOL4HKWKyEn39i8/wixJfeZZi53XZLetdzxZDPH9J8Rm1qRDKhov64GOhyQYEcnGdYIyCmnCsT6bHRxK1vqMo5tVNxdaG/dwvU6voXKMDVbVn1GcHGlidqDQi2UvamZ9wzBeD5w0TfOptvlTaue+B3gPwMjICDt37jxr1/Xc+CJgcM8jT1A84QzG1s9kWZ6Z4AHF6wgW53kpcODYOCcV/iaeOcJ1wDO7H2TqmBqQuSk7w+mpeQ4pXtMl2SqJzHEeVTz/0uICOfr40c920hM2+JdDNZdDsVTlWz9/jPT62gBcfWae9ZUC99/9EyoB94XryonjGGaVJ3fuJJPJuL7j/uljXAHseegeFnpPu7Y/OPkIlwGPPf082cPuC7W/vMjNwKG9j3J8fpXr+QBXjh/HV63whOIzvdEfZ+bQs+wLqp1/1cQJwOBJxfYvmMywOjfDfTt2KOnKEjNiMU+bcfw+k/DcGDt3nmh7/srTc2w0Kzxw979QDrpP+oHSAjcBB46d4eTOnVRNEwPYu+8gE3MlVoUChPzw0NP7SS4cAeB7Dz9P/vRBkeTXuBG2/oDByYe57NlP8MylHyaROcpRrufm05/h1IpXYy7Ocmyq4tp/puazZCOFhvMGJ8tcBuy+61ukeza2/E3P/AtcA0yWo9x9z46a0L+NPTEhkNTze59k8ZgAY5tKcQanHuGhNtfXO/ccVwNzi1Vypdb7ME2TTL7M9JmT7Nw5ybLTZ7gI2LXzLvJR96oR0dwJbgCeO3SciUxj29lJ4Q546LkxvlQ4xYaUn6GJk1wKPHb/z8km1rm2D7B5+hSF8CDHD4jo1rsffIzxQT/PHCiQDMJ9993bcP5F6TJ9cyfZpdivLzt5lEjJx+PW+QdnKxydEmP6D/7+CW5aEbB39sVSlRcmS2wunmn7zFvaPz1GuAi7FeeieOYo1wHPPv4Akwrzdd/sU1wFjM1XOFYUjJgP8Bu0HXM3+SOcPvA0h0y1e7h68gQVf4SnVeciX5TpI8+zX/H8K88cw1et2nNdua4W1NH9z7Fzel/D+ZdmysRyJ3lMsf31h55nhS/M/ffd3/IOPnhNiBdmKlzU7yd95Cl2HoHh8VNcAjx630/JxVcr/cam7BRpM8pH/u+9bFkWUEskfhbsRQNihmHEgI8CChVJwTTNO4A7AK699lpz69atZ+W6do/N8qO7HgLgG8+Xee1N1zpHwhiPwYkfsvWml6gJs2cOw0Ow8bJr2HjVVvfz5zfA43DZ6ErYrHB+tQo7F1m9/hJWqz6bzA/guRdQfZb5XSUyZpTNV13LppEkyQtm+ccDD4kQ7qCPt77yusZn9cQJOPw1bt58iUhk6Wb7ApAYZuvWrezcudP9uk4kYS9cc/EobFK4hydPwbNw3Uu2Qv8F7uebJjwcZv3yPtarPtP9AYiNKD9TnlvO8r4Iy1XP3xeAxDL19oNPw7HvsvXGzWq749kxeAZectkoyyNR3v3GV3Q+/+kJOPglbrr64poQ3a39B2Hjpdew8eqtACTuvYv+kZXkjoxxyYa1nC5NUI3FCK9cATzBnvEKz86YjWk6qjfDs5/gsswDMPYA6375g3BvkdWbX8PVk+t48NRBbrr5ZQSa9WWWmaZJ7qc/5uL1a9m69aLaF1Or4NlPsHl1DKzra7ADJXgCFswYm7e81FkLU2fzT56EPU9y80tusBMfE9oLP/0ZW6+/oubSqrf9RXgSeodXUh7ztbzrXLGMedddXHrherbesh5eyMK+z7Hlyk1q9WlPPQGPwiVXXsclFzW2ve/eQ/DcCzwzVeHAvHjml64BnoPrLtsA625ybx/gKZPkylFedfMN3P7ovaxcfyFbr17FV488yiqjyNatTe0UfgaP7VLv10c/BfHl9vnP7jgIiIW/asLylSuIjJ+gVK4SDPhYt/5CQnvvYestt6gFuhz5JCSWq89FC6fgcbh0dDlcq3APz2fgKZiqxDi16GfbhQNcu66fLaMD7SMv9wyyejCpPr8/a8DgWvVn+uwIK/qirFCe6/wtc13fAz9lLldi643XiZQS9Tb/XThwRP16Fv4JZnsd34FjCwcr8Pynuf7yjbBmi9JPzD9WYoF+7jlW5oFTVff8m2fJXsyoyfXABcBThmEcBVYBewzDWNbxr86y7To8jZRllCttaGKoS8apSkVrJNcD/bwrdhZiTY3Y4qyyWylYzpGlFgW1eW2KVCzE5St7nDuwbn4gHX0V6EcS6abHkIW/dbUlWvegqTV0KNbc0XS1K5Zr4hVXbVTbHerWFHVwD/dEgpyaW6RcNUnFQqzuj3F8JscPnzoFtHHZ+Pwwug3GHhDH45ZQf+QyRnojVE3hBmtnuWKFctVs1YH2XyAidyedE8bKvjZPvKFYeTvLFpo0YiBckwDTbdyTdRGBTnnEMpa7syF9Rd21uVqhVQQtTQZMNDxzr24xSyMG8IMnTrF7bJbJdKFVHwZCI1ZeVNeh1ekMQbirwsHWtBJSv7R8+QoRha7qetNJNQT6rkmpESuFmF8s8abNqxRT0ehqxDTWA900JQ7uW+mKbqsR67L9juZBV+0rpkmbsYayai+GvWiMmGmae4FheWyBsWtN09RU/i6tbRkdIOSDitkhYznU/NG5GUgqYEddIBaKixpyqh1XJu9T1QSAmDxkniynnXm9Vav4y1myRJm2EjSapkmmWOYlGwY7FBZHQzeR9ibWV31GRWfNQUfTza7vJfJTp5ivrkasvhyXSlZ3uVBFemksc9zGdOsEOiS8TUYCdu6wvliQNf0xHjw4RaZQwqAp55S0HbfD4R214+/8J/Hv8z9k2Yr3ACJycnmvs0u8pbyRNJ8fBje1rWUp+9qCGWdBoYxSTqavCNeBWjuFxX5YfX3rH1lzhT/aS6HSqlXLWAAwWS/Wr7s2V+ugEXvlxSP8nweP2EzSltEBiFq/owpiTNNeRA+cEfdy7/5Jdh2ZJhr02zrABrPLHE2p9e9CGgbW24cytcGuw9MNrJI9L83VlVyTz6uT6W4KgxGh+VQFAdY7zppRfAbcvGHI/W90ow7zmmAy0gdpd4mHbQ5AKWIF1hydyjakFAHEmlm2UnwEFTSWDkmHO5oHjVismiXni3WuUHIO7JwBMcMwvoVgFAcNwzgB/Klpml8+V7+vapvXpvjQdREKfWs708RRTaZBF4gZhl5Yum770AiU3IBYSSyUWTPMtMU05IoViuUq/e3cM3FdtiSjv4MDvahJw2+HvCuZbnSsTvoK2f6Jx/Ta142aBPV7aABiCpN+/QKqYrYAtxGIPWcV8k3FQqzpj7JYqnByrsL7XrmRoN/XOha3bRf/7fk6/PPvixxFpSy84k8YsWoldhLsy+SxjgE5wxfBsV3Of2g9nwViSoyYnb6ivphz31qRemHP1+Hqt7f+kQVWfeEkxUqGStVs0KLZLFuDWB+NcSDTuLT2U0dAI1NjqQK9cl5UsAj3sOuI6HeSYSuUqw2ibtvqAb2KjMEBBMicXo6mWx9YN2pS/obOphPIEGFZb4SDkxl3l1g01Tnatt6qVbHx1NqY97Vngp2s6R3sHpvludNiHL/za4+1eknqGSsVIFbIeAveUn3HlRL+Sp7XbL6QfM+Fndf7s2znDIiZpvlWl+/XnaNLcbUNKT9bt27ofFJMN0rGg+tQh8rVKfAqTcdtZU3eOaJ2KLr8N9UuI7RO4e9qVSykOiDDHxADVfkZWZOrajJUEM+oLj9VR5OTnxfXpGm6X5dp6u/UY7oLkGRWVYGYfMe6rsl6IBYkawGWVDyIzyqE3BMJ8JL1A1x/QYdd6tW/KYBYqebSWtYrUqx85/ETDCUjDZPr7rFZdh2etlM/OFbPGLoI9n7H2TWSn8M0/BQJqrkmi2VCAV+jVs0fEC7Q4484/5H1jIKxJHCaxVKFfWfSPHhwipduGKRYFkxlosU1qSpj6JxPrwXQhK2Sbh42hVvWDOAzhG4r4Pe1B2K6hb91mWfdnIC64wyEXEUjfUXV8JMnxOm5PG/70i53fZIOI6ZbLg6sjb8i61kpi8153Xqz6/C0HSAv3XyNQKxuw9Czwv03imnoWal48dT1U8VnZHmRVo6M8N4tLuv9WbbzmfW9mjYjplH3y/4NjYGXr19AFU1ncqor3TNlATAZ8tuWEQv3iJ2/yiLtkLxPyXTKHBU1d1igpxErtc/P1NaiKcEeqGhjSouA6d01qWKSEVMF9MGIWLBUF1AHjZhMYQEiEWS+KIBGOl/mHV95tHMus52faDy+rZfBTw3zvsB3ueeFiYa8TLvHZnnrHbv49E/38T9+JKL5HBmxIUu8/5OPtH6Xn8cwK9b1KbgmCxXiIQetndSJVcqtSWOtfIPRsBhXuw5P89Y7dvGZn+3n1i/u4qkTor/bQCwYFWlQdDYkoN5PfT7BrGjLJHrZvDbFO28SgTHvf9UmgDaMmAagdwABrqazcfbSPmgyYhmK/hhgdE5b0dC+lYdLJR2Ql415tE/8nYpmuNi6oWrW6bW4+XQZK12NmM+np3OTBdR1WMOzZOeBmFfTZhq87lB0GTEPAtM9X3c/1xp45WCcx47MsHtslmk3RkyK3Q/e7d5+m5wxrqZT5sihvp6r2QENbVKc15tOnUm7fX1WUg+IWWyJrmtSOzGwBtMADc+oAYhFgxyZzuIzXPIqSZOJWG+zrvu2eT5/y24+W35zy98/cGCSYqVK1YRypUOuQJm5/wmHcVE3HlUYsWMzWSpVswYmZQb/fT8Sx38+APd+ohGMWUJxCeAeOTxtJ5wsVarsPSHu1S76rStjkKA/qNGPupiL3nCVYDUOToh335ERe/rb7u170XrqbJy9bgp1cvYVM/jCSSKdgEuzRVMiB59KGSUvUpVIHyIfnQIr5rCeOZV/ajBtIOaBldQJaMh7AKtnyV7UPGL/pi0Ys2o1argmDb+ab1xatK9zKZSG9r24Jq2Bv+9f3c+1Ju/jGR8HFjK87Uu7eM/NowCdi9XGBuDM0wrtewCqoMeIedF9xAYAU/xG3GWitO9BM2ACRD/qW6PYvsYz8gfF9ehETYaSavXppOlkRXdYIHoiNTDUGw3aCRsbBOMatmV0AMMQxEH936/prwEPv88QUZNObG5qnUhuWa7TmO24XQAmy45GboWfAoUPt61nuXtslvsPTFE1qbmepLYNBCDDAMzGNiydoaxPeeGyJD6fYWvFVqTEHBKvDwCIam5IAhG9d6zTftM7vmhZkljIz8+eHwccsurLc/2hxgAMxfaVLNIr5l+VDYPDZkHJNDVioVgP3/z11gCD9u3XAZmQS1keL8Fb9ZrbqMu1tHkHHXV6XlzoZ9NDUvDwjM6SnWfEvJpurUZJs+rok3RKQniZnMJJEZmp1L6YnNJWrclSucpeSxTd1jUJ7uClqX1tIKZDRXvSfVjXv/P2zueBfuZ+0GTE2ke7dbRoCo7cr3ZufkHPvQ16WdELabGJ8dVAhCxz1BMJEPD73HfW7eyWDwNiMbhubYrBRKjh7+tLJb1k/QB+n9HqNtxxO/z3/hoIk5n7Af7oqH3aheW/5/brd3UsKr7r8DTVJs1Mw+8AdkGR+goBlmtSZuNfNxDnpRtEP3zXSy9gwNr4JMN1bJ7OXOFlHHhixMQCF/D7uGp1nx0g4ciIGUaNFXNt38NcJ+drFaDkpX2orQdKrj3xDhzrVrYzHSDjSZOsEX3r5RnpVEKplMQY1JWS/BtlxM4DsW4s2g85HX+35guPaNSQyy+IHZ/qIr3jdvgzq4YctC9yLM3aJeYNsRsPBnz0x0P4fUaDa6mh/dt64ch9iu17dE3qDDzdOo1QA0qPfVGhfQ87aR26vuDBNSl/Y+JZtXPzc/o7xPigumvSQfch+0+9i1trgZJWB4ouXNZDuWo2/P2hyVoqiCeOzdEXDdJS0UO6Ord9VBy///lazcnjj9Zdc5AFF9fkdevEbxs4uJ62bRfA8dUfF8d/NFb7HesZScYrW6zYFSxi4QCZfBmfAZFg3fQd0RFya6ZAga4YMailkYiF/LVoT2lyrkiLvHGuc4XXTVtsAMYedD/Pa/uS3VYCMl7YHqsvP/x5hfalxEDXNYka4PYC9MJJsUZpAUndjbnGOGgITHpx7TwQ68a0GDHNnC5g7VBUffYLeoybXHCWXSGO2xU5ttsXA+ONWy4E4DO/dhWhgJ9ULITPqcyLbP+G/6zVvqdnlJlUO1c3TxnUGDHV9kFTrG9N3k9+y/1cmxHzCCZVLD/vgREbgPQZNRGxAxsjgZhblnodG06GmcuVyJdq2r5DkxlW9kXpj4dIF8qda8le8gbx73P/XPts7CERfHLTB+iJBFzF+gOWC+41ly1zZva2ba/1d9l35P+Hk0SD4rksFst2sezJdMGuM9kAIrWAkmbEIegxYg6BQ9fUsZItwRdyrlhrZdtXnis8iOlV0j943RTq6Ia9sJISiD11p/u5Z50Rk2ySxj0YhnoAmufgLY1MA14C3M6SnQdi3Vi0TzNZqYfJD9R3KF4oVpVktGCDgGs2ihpefbEgs9ki/fEOixlAwsrZ6yYw1Y3kkhbpA7Msiqq7me7kt+N2+MLLaseqO3UvuW8O/sz9XF3GTTINh+4Rx27XD96BmFlRi/x0GAdSI5ZySiXh0YZ7BAiSAAYEENswnOBGi5nq6QTEhjZBbAie+37ts2O7YMVV8MqP4TPg2VMLHSM691vJTP/L1vXtmT35Los1tk5oY3pqjFihwoR1H1OZAtlCuZbMVZpO6gEvQSvRPo2s9K1Axo8AjXO5UkMka8tvKLXvITAJ1DckuptCOc6+97vi+G+ucR9nXsCwm26roX2vYn3U3rPnjbOiC91L4JNsPzet5kXy2o/Ogp0HYt1YtB/mj6ud6wWIyYH3wF+5n5tf8CY6TIyoRU9ZC8WKIaHjODG7yEyuSMqNxYhbQCwzodS+viZAB6xqugO2bYc/rmPb3HbqRQ+MWCCkfs+6GjGblfwv4tjt+sEbENPJru+wANmuyaVkxHqEllECmGrV5NBElvVDCW5cL4DY/GKpc2qMG2K6ZBQAACAASURBVN4jwNdPPgKlPJzaA2u2sHtslsNTWY5MZduDCmDfeBrDgA3DHfqD3Dw1MGILEE7YYv25xZKtr5rK1BixBov2CeZcJbrXk0asVyNib0EEA9TV4N17qra4t42EjfSpjQVd5lkCpRf+RRwruz4V25fj7N1WdPit33YfZ4UF/U3hZy+rHbvdQ34BMLyVjHvme+7ndgPETu7RaF+X9bTuoZjufB6IuS4YEwFNL7KdB2LdWKxf5JtRyuviBYhZnWrP1xTaX/DOiJUX3SdwS2S9LBXHZ8CJ2ZzFiLksnokR8a8bEPM6uf7oA+L405s6T0yVklhIdBegQKjmPnQzXW2JvAc5aSjq9LTvQQZMlNpnmrdNpx/J6//Be8XxX1+pwAQ4acTERHhsJtsZGGnYsCUIn7Cy659eyLNYqrB+OE6PVbLHDUgJ96QJuz4vQFilCGte0lmEX2f7x9Os6Y/ZgMrRZH+X/b+uPJAU6x+3yj8BTGWKZArlWuoKabYQWoHN8KIR02LnW/vQltEBIgGXVA3RPlFyzbV9TRAggdLNHxTHH5t12VB53RQqVrGQiZl11gN5DwEr6l7FfRtOitxaqhaMieCtIzvdz+0m3dDcUffzvGxqQa/KhNc18yzY+fQV3ZhcoAsKpSS6cU2qWGEBEh7qpSdGxOSXnYLkSPvzrF100O9jeW+UE7OLzOaK7XOI2e1bNdSybYBYU1oA/kLcw7q1b4GtW9u3K9MAHH0Qvvof4B0/gNEO53sFMSCekYpWrJgBwycmNBWT93DHNrHQ3+ayiHrOb1THWPWuan+eaeoxYvL6TzwOX3qFYAI2vbrz3zhUHhibFkzfnrE5tQzjCjbSxIgdsnJYbRhK8PhYbaF0zAAubWgTjFwO43vhvk+Kz9ZsYUvUwG+lk+iUXmP/eIZNIy5jvlkjVsqJ8RhOErXKIh21ns/q/ihT6QJ9sWAtmau0+og6NxecJ7dYnX6oZ7lL+87lh775Oy6pGiJ9IilypdSZpfAKAiRz2662bvNc9EmRnsd1LpKmGgFdLoggqZOPu7fZbPFBNS+MF5Ah89EpMdtpoZf0OSQr7mSq7lVd12Tzu/trS/t8S/v0Mp69SGfBzjNiXkwyAT/7E3H8idWemADX3/jfN9aOVahoVTdpvdmM1ZnO5xWzghEAVqaiHJ/NMZsrdU5d0dD+uPP3cqe3+T+JY2und/SCjhWx6tpXdH3KgS2jOHUsOaI2gcgEhDopSkA9IKCYFTtWv6YLLy7BsMsEW8wIEOBFI6bSPjiOgxcsLZVyhnEF64+FCPgMJtKCEZPJRNcPJ9gyOuieSFOO8fG94ljq7B75ApvXpnjTNSJJ6dffeb0jqCiUKxyZynKhGxBr1ojVsao+n0HYD2PTghG7ZHkP6UKZmWyxBsTkdX7fCopR0Sd50YhJoPfQ37if22aBc42EVZUZFDPeQIDbOJBz0XW/I45156Jwr9iIuTFixS7motgApC5wP083OEz2IwnCXN23C6IiiG77e7+t1r7uplO+u3feJY7f/o9q7uFfEEbsPBDzYvKl3/odcfyun3V+6dWK2OnpUtEfmxEDG9So6Inn1NuXJsX66TZAyW4/Y0ejrOqL8sLpNJWq6c6IycnPLbJRp7C2Y/tuGjRLX7X/x/q/kRhxB6pg53/Stvig2oRQsBZQXaCnquFqKPh9FtoHR53eSzcoACNN8/kMBhNhxhcEI7br8DThgI+xqaxanjI5xq3cZLbd+wm4rZe3LYrItQsGnd/34UmRUX/TMk1GrEkbE/bXXJMXLxefnZhdrGnE5HW+Z6c4fsud7guQlzQuEiQ9+U33c72w/1Drd25Rb7ogQJrsp1mXucjt+3bm81lidJe5rF4PqGvxQbXxmdcEYrIfrd4ijlUjV3Xbf+Vt4vgjp85OZKxOzdJfIEbsvGuyG7Pdbi4DV3aqdkV+25nPL4BGOzZJmmnWIkB0TZURqxt4q1JR0gWRQ8k1atIfFC5ct3tYnIWeDm6zdhbpFQxRO9entG4mv8SwAHpuhbmLHtJjgNjlVhQWlmJWLRqo2VQZMS/ZuEEs6v6Qey6xclHo9JrEuhIYKWcYV7SRnjAT6QK7x2b5+fPjIsP9lx+xwZfS72zbboGveWsXL8Dq8adPwbNPMJMtOiYovetZMZ7KFZf3ZQMxyYhZ78ACSmG/wUJRCNIku1apmq2uSdWgmHJBgJgTmm4xLZlEGqw6tJ5+w40R8zqW44rzdXYSeld7+w237PrNLjSZLLiTC63eYoMwuc/9vEJaPZ9WQ/sum6Bur7++n/Y7MHvN7f+lOEfbPaxUP3mhs1TjHNp5INaNqU5+cuKQ7g3d3+i0e+12YEgg1o4Rc2j//YAv8Kt8tvxmtUi3xIg7UMrNwPIr3dtqNsOwGKsOk2vXz2iZyPJccMk670V7A2LyKy9CMde5dEkxoxYN5NQ+KAAxj4yYzIrutguV7oajrVn+lYGRhg0lI5yYzfHwoakWcb3WbzWzYtSqScxkWwHH7rFZ/vaegwB85Ht7WTsQb/97/qCIMJQArEmILqsY9cdDLOuN2H/WCsQUQYZkho9quMV0x0/Bo0zCLY9V1yBA8RllJmDlZvf2nMwtt+S27bDqOvjmm8Sxmy602eKKVSwKaZg9otc2iMCeTlH0Uhf6v24UHhjd65dSkuykMxCT7f/rH8Kjd9jtH925k3Uq7Uf6rFJWCs/oPCP278RUqe5u2ZhOO5tt2+GqW2viRN2BEYyIzttJw7VtO/zlqNhl3DbPQwen+OyXBLvnGjUJgjl0A6uLM7Dyar1rl+bGGm7bLuo4/uC/imPtyaMOrHYCKV7SAkCjay/Uod5kfa4pHYv0Ck2NWz/1CsRATOBuk59X1tajDfeE2XNs1hbu+7y6PuUiXwfI+hPtgdiuw9OULeSnBPxCidq7baonGgmIWpTDyTCDdTUaW6ImA6HO41ial7lo23bY+mH48yHBprmNn7zH9+zGiMm56O9ugjN79cdxtB8w3IFMdgLiW/Xarv+N+ROdz1Gty+pk8UFr0+YS+ep1rMUGBGvtxv67zeftzJaSuPRT1UodzebzWaWsFBmx8xqxfwcWCItFq1On1BXdN1tixL3Te+20Db/RwTVZKTfQ7atSNdZGmRHrNPBMU7Svmiaipf1hBcati2dkBwQo6Oi8MmLQfoGQQteDPxfHun3IMNQKc9tATMMNJc2t3uSO20V6C2m69+DBRpIRZrJFpi2w9J6XjXYXkVnHutiMmIMLbsvoAHIJUwJ+4aSDRqyRERtKhhtcoC15xKDmQm9nO26vbdhA7x0YRm0R7dT+bb21SiC671g1s7uK/sfJ/AGxSHfakJSLYhzIMa9rKhoxOU5e+j799m0NlMtcIecq3XcQGxQRnZ2AXLUi5tM1L1G/bmmq6Yxy05Bcod8+qNW+rZREhPLpp7z9xhLbeUasW4u7gIBt22H4YvjOb4ljbTZmSLTfaYciB/5Vb9drW1pypLNYPzcNmLDhVQAs643gM6BqwkBCAYjFhzu7Dks5sQvTKcXT0P4QnHqy8zm5KaFjuukP9Nt3i/yUVkzDjAd3gJ1eos0ELpmAv75KuBt0+xCouTQkEPOyS4wPdnaFbNsu3D13/po49nIPmiaz6//r3tOs6Y/x4ddevGRtyyCVmUwrENu8NkU87Gf9UIKP/fKl7sAvnKjTiDUDMTHmh5JhIkE/iXBA5BELO0QMJkY6g4xt22HNDfCNN4pjL3NRINL++23bYfNvwWcu9ta+ikbMNMVYXn2DXtvS4kOdn5H8zg10tjOVwuK5KcFQv/I2/fbr2fPU2tbvt22Ha98p8iqC/juo3xS2Y8blenDZr+q1DepepNw0LL+i8zmdfsNt4y1ZWweZxIth5xmxbi3hAjLAO40LYnKtFDvvEuXA9wIyQGigOjFictBc85uAqBfXHxMFv58/pUCBJ4ZF1GihjWtNXn9XjNhkZyF7bloAnm0f0W8/qQjECmn14tr1php12A2r12mXKHfRP/5DcfypDXBbL+uOKNS/tNsfcF+A0qfV21sCk0ldnz4xz/UXeOxbbSzo95GMBJh1YMSyhTKZQoVXX7ZMjX0L99QAmA2GLSBmbZUlGzZobXwSYYcgmbiCBEC1LquTxYch4sL4eo04BOFeDcY6z3WFBTEfXvzL3n4jPtR5QyI31V6BWDQlXIedKhBkJ8WY141+BrWoQFk83YvFXTaFUOtjXp6RHbyloBnWqfNbbyquSZX6zefQzgOxbi0+5O4Wy4wLAeHLPqTfvgqVKzudV0ZJMmLtKgQ0TU67x2aZyRWpVE3e9uVH3LOh2wLNNvcgGT2v158YEbUOO7kEstPeB3akT7Bpbu7VdkDTzVQifUpWsMC6l7U/p5PFB9svkjK0/Np3iWPd/EkgFojCQuean2kL7N/8h+rtdmFSGwZwwxIDMYCBeMh2e9bbyTmxCK/si6o1FErA9AEBhu/5c/HZXyyD23r5jbxIkTOUkEBM/Bt3ZMSGFSICrTHoxS2msumUv++VnXcrLi5BlAQkuhYbcGHErPa9uiZVCn9np71fv6yS0WnTtmBteK55h3779lx0FsGqklRl2vt6oCKT+FydHvkcyCTc7DwQ69ZUJr/MuOi0L/+ofvsq4sbctMg35kXbA4IRqxTa70Rlp7auZdfhaRuzKSXgdEu62i0jppJLLDddm8R0zY7M7FAd4M/6armNdAd2pE8kau00eciJ8fI3qV93vcWH3HeJaYVcaW3blwtEp536aTFJvuKPvf+Ohg3XaapuuKD73GTNloqHmF0KIBZOCuH1bfNwWV003W3z/KTn14Fa7UwJxJLtGLHCQmc2JjMO/rBHt5jl1utU0k324Zvfr98+WMXFO7H/Vv+KewUyLq7JbtgeqM1hnRil3JT3uchNIwawcFL8u83DehNTGMfdgtWEyzso5USUumdGbEAA4XZl+7Zth7fUsf0qNXjPsp0HYt1afEi4EzoxAZmJLjqtIiMW7derK1ZvMqlru99o0k1sGR0grJOAM+4idu+aEXNh3EBMfl4HNnTexW3bDu99rHasO7ANw3LtddqFdqtdGRAReZ0W6fRptazdju0rLBDp05B0KY+zhDaQCGMgUj1MphXqbOq2344Rm7WAWEoViNVpxJoWqGxJgB4J+EzE8dFpB/ZVpcpEZlL0ZS9uscSw2Gx0ZHu67KeujJhsvwsglp9rn7evW7ZHpcxRdso7IxZOWnkTOwCZ9GnhgfFyDyrjuFuwGncJKrE9PB7n6/ggYHbup24yk3Ns54FYt6aSmyYzXgNUuqYyuea6cLvV/0Y7RiQzIQa/Jd5Uykze0L4LmOyaEZPPqMM7yHXhDgBxD50CGrod2G4aK6kJ8Tz5KSR1TZ+BtS/12L6Czi19ugb6z4E9eVws6JlCWc2FrmmpmDMjdmpukYDPYDjZQdheb/VRk5lJGNgICAnAQ6fErv7j//o8dz5yjLufF2Pog995uvV+5Djo6HqbqCWi1jWl9icF4+YlehjcGbFuXZN2P23D+GSnhE7NS2JmUGTEpr2PY5mzrxNjtWCNM90SUCCYWX/YhRFrXA+0zc2L1C0QU2L1rN8/RzIJNzsPxLo1pV3ohHcgFk2JCJuOrskuhI1QKxb+6Bedv89OiYmjbhftWjeu3uKDwnXa7hnJnYtqQdhmS7i4byslwVp2C1Y7vQO5k7723d7ajw24iIgna+d5MTegVK2I++tU+L2TKYmIz7gXjF5C23V42u6yS1XDst76EyFmskXMJlfdyblFlvVG8PsUWadQUgi8K2XRj9bdBIjrl4loy5UqP37mNFXrt8oVh/tRZcTiXbiU3NrPTnkXooM7Iyb7bzeMGLQHApkJ7yAJ3BmxckG4j726JkH8rZtrssdj6gc71U2HsZKZbFkPtCwxbCWnzjp/v1RArCOrNy762jmSSbjZeSDWrbntEqtVaxfqcfIzDLUdhFe3HtQW3xd+6Px9dsL7xAdiZxYbgAN3OX+fmxGLUUCzmLU0KaZv55rMden6BLHDzE23d2nIxcmLDhDOvmvSjRHLTomAB6+uQ7ddaKUsntE5dE1uGR0gFFjaGpb11h8LUaxUyRYbtSin5hbV9WFQY4/yc6KvWnPFltEBgj7s63/tZcs734+Kiz4zvgSMWCcgNtndXKHCiIUSENR4vvXmBsS6mavBnRHrltEDS+95FiUAblGH2cnuwKpbRRp7vu6W9XRxr3olR86Cnc8j1q257RIXZ0WCvG5euhsbk5sWZTO8WrgHAlGxK3eybBe7aGmJkfbJ8xZnvLNhYO3iOkR0dbuLBmtyNsWzcNptZsYFc+k1YMJtF5qb6s7l47ZLlKklvLoOoynBerab/DLjgHlOXZNnq4altP66XGL1JYdOzi7qgT7pBps9Cpj2Ird5bYoPXReh0LfWvv4LlyXb348dtNJuU1ixhOJeGTEFCUC3i3SkT7AllZJIddDSfpdaT7cNSWbSOT+XqgUjwrXZTp+0FHNRbBCmD7X/fuE0rH95d+27uSa7Xc+gfZmjbrMAqLgmu9FtnwU7D8S6NXtgtwFiEkB189Ljw+1zw8is9F47rUr9tswkDHWZDLPT5JybgViXi6RMfOvYfpdUN9Qmnp2fgNd/rvX7zKR4x14DJmKDYvKulEUG8Gbr1uXjlkhR9lOvO2mfT7ABbYHeme7a92hno4alNBuI5YqsGRDVJsqVKmcW8upCfaiB65nD4t+6sbIh5Wfr1g32ccf7kZU+OjHDZrULmUS/EIF3ZMSmYegib+1DXXb9eWewkpvqDsS4jYPsJKy61nv70Lnwd1MEuifrtGnLL4jE0l5dkyDmydmj7b/PTMLI5d7bd6tU0m0WAHvT6QImV3gsqXcW7LxrslsLxUWR1LY7LAnEumXE2kx+hbSIZPIKMmQOqbVCl9IS8WdaLJBXd4ZMFnp4h9W+Q2qHxS7KG0mLd2ANl8IdIN/fnq85f58Z7w5sy/fXTlvSrcsn3CPct+0Yq24ZMehcRmkp2v8FMxuIZWsR02cW8lRNWKHjmgw1AbFuN21tx4E1h3gdyz6feMft5iI5V3TTT92y63fNuHWouyoZw26ZkliHMkdLMRfZEdAOkcD2OOsSiLUDkkvxjl1dk11mAQiExZhyY8S69fIsoZ0HYkthnYpay8+7AmIjYgA75UVZCrYHoHel8+eFtMgx5nXyk0BPFkz+44nW1A7dMHrSEkMwfdj5u6VkxNpZZry7ge2Wh0sGTHg1GW118B7n7yVj1U0/jQ2234UuxQLxC2Y1IFbTDZ6aE4ujJ42YdDd1048SI+1dh3bagS6BXrtNZzEr5A3d9FO3epPdJEOFmhjdCYhJxrCb64fOjJjtmuzGvdpBA7VgeU66CYqJD4rM8+XWiGAhtSl1uVlwYyW7dD+DeL7tNoXFrACyv0CuyfNAbCmsU73JpXBNJoaFkNppcNvCxi47bs9KwGgFe92KxKVJ3cX8idbvloIRS4yIMkpOZY661RzsuB0+e1nt2InV61Zz4Ja/p5vcQ9LigzC+1/m79Gnxjp10OaoW6+/AiJ2xcht1eQ+/QObEiJ2cywEaOcSgphGzGbEuxlonF729KexmLurQ/lLMFZ0YMVlnshsQA6IPjj3c+vlSzXWx/s6MmC/g3e0GtXng3k+2fmcDsW4YsQ6Rn7ZrtYs+5FbmqNssANBZ57YU42CJ7ZwBMcMwvmIYxoRhGM/UffbnhmE8bRjGk4Zh/NQwjH+b2+VOpT8y40II71VkLdsH2PHx1u+WlBEzWwfHUk1OfRYQay4MXSlbqSWWwDUJziLZ3LRwSXgFGZLVk2k+mt231arlvu2GTepQumQp3AHQ+e/TZ7p3G3bSrqRPi+fjJbfRL6glwgGCfoOZbIndY7N8fsdBHjsq+t+KXo8aMX/YW9F1afFhmDvu/F12CRagTkExS6F/6sSIyTqT3c5F8SGYcRC7L8XzAXdGLNaF1hNq43jPV1u/k1rirqImO2wKu3VvS0uMwJH7nL/rNgsAdE4HJNe0X6CoyXPJiH0VeE3TZ580TfMK0zSvAv4F+Ng5vJ6ls/hQe3GjZEq6GXiyw+z+Sut33bI90npWiX9leQxp3WZRliYZsdmxxs/lhOuVEZMatJ/8kTj+5GgrW7UUbBK032UuzgjGspuBLSfXJ+9s/a5bl498Rocst6QTo5c+XQOaXk3uQp1c6Oc4meu5MMMw6I+H2D++wNu+uItP/3Qf33rkGOGAj+dOL6g3FLIYscWZJZgrhoSUwEk/lJnoHuhJRsypzFG3We+hxhQ5AbGl0FdBezYns8SMmBM7n+0y2AA63//CaRHB7DW9B3SOOlyq9SAxJOqrOlm3Ccqh86Zwqe5hCe2cATHTNO8DZpo+q5+t4kCHIma/wJYYriVkbLZuRdzQeYFfKkZMgoxm16G9e+jyHpLLhUh2rgmIdZvjS7JVssTQr/wvBw3aEgxsEKyhUzu2+7kbJsC6/wM/bf2u25B3+Yy2Ws/ko2dan9FSMWLgzEqmz5zziMlzYZGAn0ePzJIvV6maYgIrlKu87Uu71DP517PlXbOeHXJ9ZSe7B3rxYVEHUFYCaG4floYRe/YHrd91W2dSbkie/ntx3LwhWSr2X47ldmCym7lox+3wt5trx833sHBKuD67sU4aNPsZnaU1zS743a1rsl/MOU4bhqUIoFtie9HTVxiG8RfAO4B5YFuH894DvAdgZGSEnTt3nrVrymQyWu2vODXLJuChn/8zxXAjoLhu/Ai52HKe9Xi96458i3Vjf1/7wEovcXTtWzh6wVu54PATrDb83Pfwnq4m2EBpgZuAg3vu5cRkTb+w9uhjXADc+9gzmL4XPLcPcH14iMz+x3kuuNP+rGf+ea4Bnj5wgpmZ2ue67wCzwlbg+O4fc2i+MfDg2okx8pFhnumyz2xYMFlWWOSBpnZSM09yJfDEgVPMT3r/jZv8cQKVbMt9Jxf2sRl4+vAZZua9tz88XuAS4NGffuf/b+/Mw6SqrgT+u9AssjTQzdLQQAPNJlsUERBFujE6asZo4mRGx2+SSWaS6EwSM/mSmfSYzBg1Q2JiYgyfGo2TMWrMnrgQzaK0WwyyikgLsgo0NHS3su9954/zLu9V9Vr1bnV1dZ/f99X3qt6ruu+9Ovfde+45557Lkb6jz+w3Dae5+NA+ttcfZ1vk3KnKYMjefUwFli99msP9xiQcu7B+B3vzSng7g89te7Pp3dO8U3+sydHjiZMNPP6n5RwsbVuS4vndetK94QR1x7rzRhoyaNRO3C3pBVw7ATDjnSryGnqzKoYMhu2p42xg549vZNPETyUcG739NcYBL65YT0P3TWmfY363nnTf9mKj+y6sXcZ0YGXVNg7uqmzqpy1jLoCyJyja/Ucmb1jMX+Y8wLGzhsl/d2tkuZ47JbeV++9SfQ6G7anhbGBZ5TMc7ZPYFs2u28HB/uOpSlcGwT3MXnYTfY5WU1kWUVgrKzmveiP9D++L1T/2OPEeFwJ1zy/mjdpEhWjM1hWUAC8sXysxnynSWn+Wd/IQF9nTbNr9HjtjtEWj9hyg1J7mpeee5XReonXwTJ+24k1stw0p30MmyLoiZq29BbjFGFMBfAb472a+9wDwAMCsWbNsWVlZxq6psrKSNpWflINr3qsflzfRHFzLDtF3zNS2ldcUZWXAD+C702H/O2LJAMYELw78GuoHU1berA7bNqyFZWcxfmgfxkevdclTsLM3Cxa+P175ADsm0+fouwyNlr/hKKyGGXMXQHE40muzDKKsLGJUj/2MSv7dyuP0Gz0xfRk4erwOu56mbO5M6B1x77xeA2vh3PmXQ2Fp6uUm1aOyyqvljatHG47CKpgxtzzhP0qZXf2h6jvMLi2EyWXh/gO74cUGxkyby5jzw/3pPgfnr7g58fpPHoXKgxT3PERxBp/b9ubNpZuwSENugBkjB1C15yCnTzfQI68b17///LbnMFs+AA7vo7BkcsJ/3mYZuHbiQDV852y48tsw+5NhOwFQdRqGlMZ7DjadgrfuZmT1EkZ+KsmN/syzUJ3PxZdcln75ACsL4eDuxte5cjusg/MuvhwGjkq//C0GNixm7qQiGLcg/O8e+ZC475Pa2HSfgzmv/Yu8ifYHrx6hz9ipDIv7HOydDet/2/i6loulMpaMT5+EP0Nh/arG5Rz4NWyHsvJL0ivb/derH4Un/hU+twYKxob1tG4zvALjp89m/DnhuVPuD1btgC0PM/+8KY0T9D79BOwt9NOneSLriliEnwBLaEYR65CUV8irdpOYi6++F869ITx+6oTECuzbGP9cheNEEUvmqIcZJiDWtAHFTbsmTzURb5IOA0ugek3ivrgLfkeZcCm8tUSUSmcdtNZjjFgwuj1QnaiIxZ0Z6+rRM/8By+6XFB95vcLjvmJjCsbJNjkr95nUEmm6Dt31nzoOdwyF+V+ES74aKT9IjbHtpfTK76DMHVdI7x7dOHlKFK//umoqQHqZ/Hv197OChZPhviZG+of3QnHMJJYtXV/cCSWtJZf2kZUewo45OUxiz7rG300F9xwcrIG7JsIVd8KcT4fHTx2XtBA1b8Y7D0DRNFj/W0ng2ju/bYm520r3YIWQJl2rLayqkAqDgoz69VsSs+vHzQKQ/D98b4ZsExKUd6wcYpBlRcwYM8Fa6yL2PgjE831li0FjZFubpHC5Srv95fjnKCiVKddRJQOk4vpQYkAUjeRg/YMtLK2UKoNKRHE8fjCMi3FTpOMsceQomg6rHxHFwsW8uYS3zS2vlApnFLFdMDSSPdzNjHVB1+ky9mJRxHaugDEXhvt9BEGD/MdnFYRpEhxnst7HjBFzyuPe9Yn7kzu8TkJzSyillcnf1Z24sZjGSK62fUlNacNpUehrmwmQbgutdfZxk606Reb3t8Cri+GrtYkznQ/XSpxpnEB0kIlJpnvixKGDNaKolqZp6YniZJj87x3w3gAAE2FJREFUX7sYNx8DEpfZvuZNKLlA/repH4J758j+wKqXMs3JuORC2P5K4/3pKHoQDgrrtwCR/zxuzLOrQ4dr4VulcNkdMO+zid/pYMsbQTsqYsaYx4EyYLAxZidi+brSGDMJaAC2Aze21/V4pXueVJxkRayl9SFTpbBUZkMdqU/Mo3OkTpIQ+mDASNgcZMD3OcJyDIzMnCwK8nI5a0/vAU3/JhWGBWXWvBkqYm4U7TL7x8GV6XL1OHwEQQOUzJPttpeSFLGgA+rZN175IA1g8tT9uBaxKEMmJypimahHHQhvSyi5mYw+ZnKNXwgbkyZ9HAlm9r7TRP6stuI6uW9NEKUlubM/XCvpJeJSPFO2e9fD8Pcllt9wsunfpEL3PLH+RwcILr/eRf8Wv3xjZAZyo4F5C4tQp4prP2vWiSIGjVMDpYOT8U9vgLeebizjb4yWdEPpKnqO/kUyeE3ONnBmQoaHWZMAe5rIm3h4b7y1mTNAe86avN5aO9xa28NaO9Ja+5C19lpr7bQghcVV1tpdrZfUQSmZl/jgLV0ED0bitppKGZAKBUHsUXIneqSu8QOfLvkj4NAemf1ZXgGfXRUeS86dlQ5Rl4CbwfTK3bLvawPj/T8Aw8Q1lPDw+Wz8+g8HTBMpPmokriIuZw2Sjmdr0oj5iKcOCEShr4802EsXhYqTDyVg2rXSuB4/JJ/LK6TRcw2fj3rUGXFJXX3IYMhk6WyiuaxaWh8yVZwSkMzhfc2nJEgFtwZg9erE/c0lC06HgSWJFjHnlmzu3lJlXBnURSYsLF0EP5gffo7bH+QXS3sRbeucpXvezemVGWXIJNlGs+sfqRclzAfGBIPCJOu8rywAIH3m7rWN9x/aC/Xb4pfvEc2s74vBk6SDcxW3vALm3Ag9ZDHg2B2QCwKPxvecPtV84sB0yC8W69qhwFW1e03L30+VgWNk++52+R/++73wgfPRQZ81EAaMklEiSCP30KXh8biNX15PsXw1lWutuUXZU2XMfNj5Gjx3W7jPV1wGSOO3f6fkmXLWquU/lGO3F8ZXhodOka2LUTp2AHatko5JaR7nqvfhMnGLbjsZLF0E980Lj8d9DoZNk0WZo4OP06daXtsvFQaNFSVjVzAQbEsevFQZWJJkEVsnbYePEAmAweOlnYgOSBZ+JTwet70zRuRQE4lrq98inoXLbmv+d23F1aGoouQsblM/HL98kNgwV76T8R+D2NJFI+PLeNq1YqQ4eTTcd/wQnDwCu5anX24GUEXMF0Mmiek/WnGrV0PRDD/lDyyRxs9ZxJYuko7TBskzfTROA4KkrvsDRaN6jSwUPf9L6ZcZpU+BxMK88Uv5/N47/hpvx7BpsKVS3pdXwMTLw3gEH8pe/ojGrsnmlupIh7ELxL3z0l2Z6YAKSgErVqtZn5B9gycG5Xv4f4aeLVtnZdv+itTRsQvC9UaVxrgYMR9BxM6a4eLEyivgnBvCZKlx5Vw0XQZsLgbKd1tkjFjFqleF1//vESuuL+v8oZqwk96zLgxt8IF7pqJWsX0bYMDopr+fDkXToWY9PP91+Vy/JWzr4uKuPxpr6CzpF3vqDwrGSpkNDWGuw4lXyDEfMi6aLnWyJhIq4TNcyCOqiPli8ATZ1gaj0NOnxCw64lw/HVBeTxg4OrSIlVcECTqDuCQvSoYLRg9mTu5eI+6+S77S/G9SwRiZ2FC9Uj7vCrYzP+anfBDXwpE6sficPgnbXvZrjckvDhVVpyg5l4kPRankgjA/T3kFfOT/wmM+ZFwYNNT3zpGZXRC6tuNct2PQWIn9cIrYlhfA5MGo2eqObAlnGfZhkckfCT36hhYxayX2c+zF8csG6eAgdIuVV8D1PwuP+6inI86FvVURRamZNVLTxcWrvrdD2op9b/lzSwIUBv1BsiI2ZKK/AcmwaZJI/MU75bNXRcz1Z5GwF6eIuclpcSkYJ3HPUW9CU0tPpcvwwAiyJ5iotXQRfH9meNxHe+2JjpS+IrcpTKq4tRvkISmeCTP+1s85CkoTK+rm56V8p9DEZUCgiK16RMzP1a/DNE9maMfAktCcvmulWNyu/La/8l0nseMvohCcOCTWGF/TlfNHhDFc5RUw4hx4/Dr5HDeAtbnA9p795D584Brq8z8JK/5XRoy37pdz+1CUunWTGaVvLYHLF8HWF8CeSkzHoYQky/y2QBGLM5mhWzfp8J01o/Zt6exKy0PXcRwKJ8hSSTVvAH8n++rST+DaJCNmQsMp+N2X4OrFsCeI9Zn3OT/lR+NVTx4GrF+LWME48WC4/qAhsCCOme9vQOLaOpBB53s7YPpH/JTds68M/KNpUN7dKnGyPfv4OUd05uSAkWK8qN8Ko+b4KX9gibhqXZxYeYUMdNxyeHHba4+oIuaLXv1kJOpyhrn4Bhd46oPCUtjxmoxwjx+QNAfzvwDjL239t22hV750+luWysNxfL8oGj5oTsnoP1ysfb7L//HV4fuxF8PUa+KfA8Qidnx/mIJjywui8J062vpvW8PNWNq1Eh5cCDOug7U/g/P/Sc7hA5fCYvmDMhPTuZN8WquGToE1j4kVIzmVhZKIkzkEI3RPncOQyVD1lLx3M4bHlSfmbEqX7nmibEfzbtW9LVa98z8Zv3wIZ06ufkQUsd1rJS3HZbf7Kf/MDO5tYfqWqGITlx69RZFx7tv970gb4dzGcUlu724PZgnWeHzeBk9KVMTqt4b5v3xwRhHbKm30/ndkUtK5/+CnfGMkNGjjs+G+mnVST32HxMREXZM+GTJRLAAg8WG98sPZjj4oKIUTB+EPXxWrjD0tjauvTtSYsKF29zHckyLmYgC+GDRM59wga6Kd/UG/5Uc7sh59ZBZi3AXRozj37Z++JtstleJO9Bn/5LLnr/0pYEUh86kouQbwfddlJm7LWV3uvyjc14HcAF2CIZPEinpsv7glew/wo4Q5hk1PDBSv3QSF4/3V0/wRiYvQ71kbupp80G+YhAD87ovw5Gdk3/dn+q2jhRMkNALCAbovRcy1d1OCAebf/1y2F3qyGIJca93bkoMOxCLmsw7lF4tHZM1j8rkuiK8uHO/vHEUzJD2Pu4e96yXcpoPFq6oi5pPBkyQYsKFBXDPD3yduAl+4DvTV74cB3L7yobh4JxeL8XSQT6fqaT/lO9yssDWPieuheGbL30+X/JEyO2bsAs/lBrnElj8oI+l9VRKD5jv+ad7nwnihYR7cSVHcDNwLb/Z73a4O/eGWxsc0bUXr+Owc3CShR/9G8tL5SjtwpvxpMpv394Gs6zaF4RlxcfXIzd6+dYC4WY8d8FM+SLtcMBa6Razxvuvo4ImSNqShIXQTuyB4XzhLv1NmfMWIgShip44F7tujotD4tIh16y6WyR3L5LNzb6ezTFxzOCtn7UZRxvZWiQu6g7VDqoj5xAU4vvWUNCI+3ZKQWEGrnpStD7ceNG1RAn+B+lHm3CTWMIi3dmJzLPgylAVxAOM9ZMqO4uLoQNyS4D81w9JF8Od74Oi78tmXNcl1cGuDwOrFs/xaAJLrUFP1SWkeH52Dk/GjQWznztf8xRdGcR3cq4tFQTq0x18H6urRZ1bI5/HBmoBzb/JTvmNgCTScgNKFfst1DA4sOwd2Ssxw36F+rfMgYSkmD9Y/KWElPvLQOVwKi+e/HiZe9WkRg0TFsX6zeJF83IN7Dn4b5Ii/dy7cViCDcx9xkp7RGDEfJPvrf/5R2UYTBvo+h8st5TtTeXKnnInyl90Xfl48y3/5TcWK+Sg/uezffEq2VUsSM4DHJVNxQ5kqtzU6mBugU5Ms4yg+n+Vh05AZ2za0ZAz2ZBFzuPI2/Um2Pl2TINapzc/BB+6C13/W+vfbSnI7cXegtLrVE3zSqx9MvkLiAXv0ib+6RxRnvVv3y3DSli9FrLmY4X5Ffu4h+TkYPQ/m3ih9s0v83YFQRcwHTujJlavqCakEPhq+pjrRTHSm7hzlFZkrv7xCEt/eMSRz5YP/63dlv7sNvhdRvBb+p79zdBaiylcHcwN0Kc5YJz0+C8ntnFtBZHMlnH2Vn3M4zrkhdLu5APu4JF//PRHPhY+62kgZNrJm5nGPrtUoU64RRczn6gkgCbL7FYm10+XH9OWadP/RzpXww4Vw1T2SOzFTSw/t+IvkODTdQktfB0Jdkz458/AluWZyrSNqj+v15VLNBmseT/ycyUD0TFmTMm2lyrU63xnJlIyd6/AjD8vnETOlg7v8f/yeZ+miUAkDP8ugQfMu9EzV2UElftbgbI4Jl4UJgX2RHKf3hyBEZdkP/J7HxQiv/BHs3+E3UN9x3j9KAuLVj8qEN1/pNzyiFjHftIcbxp0j0+fS8psm01bDps6VK+UqHYeojDPxLEy6UrbVq2RWpu9ccc5qcvIofL0oN+MNSy6U1SUcmQj1aMrFF7d8999bKwqwc0P7bjeMkQlVbpa+z0B9x1/fDZueE0XPdEzbkypivnEVNZNKRlQRyCRafnbKVhTfZKK+5vWU5Js7lvmflRmlh6ccek2R6cHgx38nW6fQ5FIoBkClU/JseA7wp0gCfOh++O5UsVplQhEzBiZ/AJbdH65808HomOphZ0A76q6BBqIrXZlr7mv9Oz7ItHU70/gMom9Pyivkv8+kGzd/hOTDBL95N6NM8ZTQO0OoIqYocVCFW+mqtOfafZ3hOcv1UIxM4GLRNj8nn79Z4r8OLV0EP7o8/NwBk0ura1JRFEVJnWylQ8lVcjkUAzKj6LVHHcqBeqoWMUVRFEVRWqYzWCU7KKqIKYqiKPHQWEklLu2ZcaCDoYqYoiiKEg+1lihxaY861EHrqSpiiqIoiqIoWUIVMUVRFEVRlCyhipiiKIqiKEqWUEVMURRFURQlS6gipiiKoiiKkiWMtTbb15Ayxph9wPYMnmIwUJvB8pXWURlkH5VB9lEZZB+VQfbpDDIosdYOaepATipimcYYs8JaOyvb19GVURlkH5VB9lEZZB+VQfbp7DJQ16SiKIqiKEqWUEVMURRFURQlS6gi1jQPZPsCFJVBB0BlkH1UBtlHZZB9OrUMNEZMURRFURQlS6hFTFEURVEUJUuoIqYoiqIoipIluoQiZowZZYxZaoypMsa8aYy5OdhfYIz5ozHm7WA7KPKbCmPMJmPMBmPMX0X2n2eMeSM4do8xxmTjnnINnzKIHH/SGLOuPe8jl/H8HFwfPAdrjTHPGmMGZ+Oeco1UZWCMKQy+f8gYszhSTh9jzBJjzFtBOd/I1j3lGr5kEBzraYx5wBizMZDFtdm4p1wjDRlcaoxZGbQ5K40xCyNl5X6fbK3t9C9gODAzeN8f2AhMAe4Evhzs/zLwzeD9FOB1oBcwFtgMdA+OvQZcABjgGeCKbN9fLrx8yiA4/mHgJ8C6bN9brrx8yQDIA/YCg4Pv3Qncmu37y4VXGjLoC1wE3AgsjpTTBygP3vcEXtK2qH1lEBz7GnBH8L6beyb05V0G5wIjgvfTgF2RsnK+T+4SFjFr7W5r7arg/UGgCigGrgYeDr72MHBN8P5q4KfW2uPW2q3AJmC2MWY4kG+tfdVKDfhx5DdKC/iSAYAxph/wBeCO9ruD3MejDEzw6huMPvOB6na7kRwmVRlYaw9ba18GjiWVc8RauzR4fwJYBYxsl5vIcXzJIOATwKLgew3W2lzP/t4upCGD1dZa18a8CfQ2xvTqLH1yl1DEohhjxiDa9TJgmLV2N0jFAIYGXysGdkR+tjPYVxy8T96vpEBMGQDcDtwFHGmHy+2UxJGBtfYkcBPwBqKATQEeapcL70S0UQZtKWcgcBXwnP+r7NzEkUHwvwPcboxZZYz5hTFmWAYvt1OShgyuBVZba4/TSfrkLqWIBZaUXwGft9YeaOmrTeyzLexX2khcGRhjzgHGW2t/k5EL7AJ4kEEPRBE7FxgBrAUqvF9oJyYFGbRWTh7wOHCPtXaLr+vrCniQQR5ihXzFWjsTeBX4tsdL7PSkKgNjzFTgm8Cn3a4mvpZzfXKXUcSCzuNXwGPW2l8Hu2sC0ybBdm+wfycwKvLzkcjIfyeJ5n+3X2kDnmRwAXCeMWYb8DIw0RhTmfmr7xx4ksE5ANbazYE74OfAvHa4/E5BijJojQeAt621d/u/0s6LJxnUIVZ5Nyj8BTAzA5fbKUlVBsaYkch//VFr7eZgd6fok7uEIhbEsTwEVFlrvxM59CTwseD9x4AnIvuvC3zQY4EJwGuBqfSgMWZuUOZHI79RWsCjDO6z1o6w1o5BAmg3WmvL2uMech1fMgB2AVOMMUOC712KxHgorZCGDFoq6w5gAPB539fZmfElg2AQ8hRQFuy6BFjv9WI7KanKIHADLwEqrLWvuC93mj4527MF2uOFdNgWcaGsCV5XAoVIXMXbwbYg8ptbkFliG4jMwgBmAeuCY4sJVifQV/vJIHJ8DDprMisyQGaQVQVlPQUUZvv+cuGVpgy2AfXAIcQCMAUZ+dtABq6cf872/eXCy5cMgv0lwItBWc8Bo7N9f7nwSlUGwFeAw5HvrgGGBsdyvk/WJY4URVEURVGyRJdwTSqKoiiKonREVBFTFEVRFEXJEqqIKYqiKIqiZAlVxBRFURRFUbKEKmKKoiiKoihZQhUxRVEURVGULKGKmKIoiqIoSpb4f28L6Bgk/QQrAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plt.figure(figsize=(10,4))\n", - "plt.plot(nh_sst.time, nh_sst, '.-',label='NH') # the basic method plot() is used for line plots.\n", - "plt.plot(sh_sst.time, sh_sst, '+-', c='tab:orange', label='SH')\n", + "plt.figure(figsize=(10, 4))\n", + "plt.plot(\n", + " nh_sst.time, nh_sst, \".-\", label=\"NH\"\n", + ") # the basic method plot() is used for line plots.\n", + "plt.plot(sh_sst.time, sh_sst, \"+-\", c=\"tab:orange\", label=\"SH\")\n", "plt.grid(True)\n", "plt.legend(loc=0)\n", - "plt.ylabel('SST (C)', fontsize=14)\n", - "plt.title('Monthly Hemisphheric SST', fontsize=16)\n", - "plt.show() # note that we didn't use this before, but it a necesary line to finalize and properly display a figure" + "plt.ylabel(\"SST (C)\", fontsize=14)\n", + "plt.xlabel(\"Time (year)\", fontsize=14)\n", + "plt.title(\"Monthly Hemisphheric SST\", fontsize=16)\n", + "plt.show() # note that we didn't use this before, but it a necesary line to finalize and properly display a figure" ] }, { @@ -608,36 +109,28 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plt.figure(figsize=(12,4))\n", - "pos = nh_ssta.where(nh_ssta>=0) # select only positive values \n", - "neg = nh_ssta.where(nh_ssta<0) # select only negative values\n", - "dates = nh_ssta.time.dt.year + (nh_ssta.time.dt.month-1)/12 # make a list of time steps using year and month\n", - "plt.bar(dates, pos.values, width=1/13, color='tab:red', edgecolor=None) # plot positive values\n", - "plt.bar(dates, neg.values, width=1/13, color='tab:blue') # plot negative values\n", - "plt.axhline(color='grey') # plot a grey horizontal line at y=0\n", + "plt.figure(figsize=(12, 4))\n", + "pos = nh_ssta.where(nh_ssta >= 0) # select only positive values\n", + "neg = nh_ssta.where(nh_ssta < 0) # select only negative values\n", + "dates = (\n", + " nh_ssta.time.dt.year + (nh_ssta.time.dt.month - 1) / 12\n", + ") # make a list of time steps using year and month\n", + "plt.bar(\n", + " dates, pos.values, width=1 / 13, color=\"tab:red\", edgecolor=None\n", + ") # plot positive values\n", + "plt.bar(dates, neg.values, width=1 / 13, color=\"tab:blue\") # plot negative values\n", + "plt.axhline(color=\"grey\") # plot a grey horizontal line at y=0\n", "plt.grid(True, zorder=0)\n", - "plt.ylabel('SST anomalies (C)')\n", - "plt.title('Northern Hemisphere SST anomalies')\n", - "plt.xticks([*range(2000,2021,1)], rotation=40)\n", - "plt.autoscale(enable=True, axis='x', tight=True)\n", - "plt.show()\n" + "plt.ylabel(\"SST anomalies (C)\")\n", + "plt.xlabel(\"Time (year)\", fontsize=14)\n", + "plt.title(\"Northern Hemisphere SST anomalies\")\n", + "plt.xticks([*range(2000, 2021, 1)], rotation=40)\n", + "plt.autoscale(enable=True, axis=\"x\", tight=True)\n", + "plt.show()" ] }, { @@ -656,66 +149,65 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# import functions to label coordinates and add color to the land mass (otherwise is white)\n", - "from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter\n", + "import calendar # this library give us quick access to names and numbers related to dates\n", + "\n", "import cartopy.feature as cfeature\n", - "import calendar # this library give us quick access to names and numbers related to dates\n", + "from cartopy.mpl.ticker import LatitudeFormatter, LongitudeFormatter\n", "\n", "# select a region of our data\n", - "region = np.array([[30,-40],[25,120]]) # numpy array that specifies the lat/lon boundaries of our selected region\n", - "io_sst = ds.sst.sel(latitude=slice(region[0,0],region[0,1]),longitude=slice(region[1,0],region[1,1])) # select region\n", + "region = np.array(\n", + " [[30, -40], [25, 120]]\n", + ") # numpy array that specifies the lat/lon boundaries of our selected region\n", + "io_sst = ds.sst.sel(\n", + " latitude=slice(region[0, 0], region[0, 1]),\n", + " longitude=slice(region[1, 0], region[1, 1]),\n", + ") # select region\n", "\n", - "for mon in [1,7]: # select two months of data to plot: month 1 and month 7\n", - " moname = calendar.month_name[mon] # get the name of the month\n", - " tmp = io_sst.sel(time=ds.time.dt.month==mon).mean('time') # select only one monthh at a time in a temporal object\n", + "for mon in [1, 7]: # select two months of data to plot: month 1 and month 7\n", + " moname = calendar.month_name[mon] # get the name of the month\n", + " tmp = io_sst.sel(time=ds.time.dt.month == mon).mean(\n", + " \"time\"\n", + " ) # select only one monthh at a time in a temporal object\n", "\n", " # create and set the figure context\n", - " fig = plt.figure(figsize=(8,5)) # create a figure object, and assign it a variable name fig\n", - " ax = plt.axes(projection=ccrs.PlateCarree()) # projection type - this one is easy to use\n", - " ax.coastlines(resolution='50m',linewidth=2,color='black') \n", - " ax.add_feature(cfeature.LAND, color='black')\n", - " ax.set_extent([region[1,0],region[1,1],region[0,0],region[0,1]],crs=ccrs.PlateCarree()) \n", - " ax.set_xticks([*range(region[1,0],region[1,1]+1,20)], crs=ccrs.PlateCarree()) # customize ticks and labels to longitude\n", - " ax.set_yticks([*range(region[0,1],region[0,0]+1,10)], crs=ccrs.PlateCarree()) # customize ticks and labels to latitude\n", + " fig = plt.figure(\n", + " figsize=(8, 5)\n", + " ) # create a figure object, and assign it a variable name fig\n", + " ax = plt.axes(\n", + " projection=ccrs.PlateCarree()\n", + " ) # projection type - this one is easy to use\n", + " ax.coastlines(resolution=\"50m\", linewidth=2, color=\"black\")\n", + " ax.add_feature(cfeature.LAND, color=\"black\")\n", + " ax.set_extent(\n", + " [region[1, 0], region[1, 1], region[0, 0], region[0, 1]], crs=ccrs.PlateCarree()\n", + " )\n", + " ax.set_xticks(\n", + " [*range(region[1, 0], region[1, 1] + 1, 20)], crs=ccrs.PlateCarree()\n", + " ) # customize ticks and labels to longitude\n", + " ax.set_yticks(\n", + " [*range(region[0, 1], region[0, 0] + 1, 10)], crs=ccrs.PlateCarree()\n", + " ) # customize ticks and labels to latitude\n", " ax.xaxis.set_major_formatter(LongitudeFormatter(zero_direction_label=True))\n", " ax.yaxis.set_major_formatter(LatitudeFormatter())\n", - " plt.grid(True, alpha=0.5) # add a grid. the alpha argument specify the level of transparency of a plot figure\n", + " plt.grid(\n", + " True, alpha=0.5\n", + " ) # add a grid. the alpha argument specify the level of transparency of a plot figure\n", "\n", " # the core: the data to plot\n", - " plt.contourf(tmp.longitude,tmp.latitude, tmp,15, cmap='RdYlBu_r') # contourf (filled contour plot) takes the 1D lat and lon coordinates for the 2D data. cmap specify the colormap to use.\n", - " cbar=plt.colorbar()\n", - " cbar.set_label('SST (C)') # color bar label\n", - " plt.title(moname+' SST (2000-2020)')\n", - " fig.savefig('./figures/map_base_'+moname+'.png') # save your figure by usinig the method .savefig. python recognized the format from the filename extension. \n", + " plt.contourf(\n", + " tmp.longitude, tmp.latitude, tmp, 15, cmap=\"RdYlBu_r\"\n", + " ) # contourf (filled contour plot) takes the 1D lat and lon coordinates for the 2D data. cmap specify the colormap to use.\n", + " cbar = plt.colorbar()\n", + " cbar.set_label(\"SST (C)\") # color bar label\n", + " plt.title(moname + \" SST (2000-2020)\")\n", + " fig.savefig(\n", + " \"./figures/map_base_\" + moname + \".png\"\n", + " ) # save your figure by usinig the method .savefig. python recognized the format from the filename extension.\n", " plt.show()" ] }, @@ -770,7 +262,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.10" } }, "nbformat": 4, diff --git a/Ch6_Ocean_Example.ipynb b/Ch6_Ocean_Example.ipynb index 93b3d88..957a29a 100644 --- a/Ch6_Ocean_Example.ipynb +++ b/Ch6_Ocean_Example.ipynb @@ -19,18 +19,21 @@ "outputs": [], "source": [ "# Import libraries\n", - "import warnings # this library helps to make your code execution less messy\n", - "warnings.simplefilter('ignore') # filter some warning messages\n", + "import warnings # this library helps to make your code execution less messy\n", + "\n", + "warnings.simplefilter(\"ignore\") # filter some warning messages\n", + "import dask\n", + "import fsspec # these libraries help reading cloud data\n", + "import hvplot.pandas # this library helps to make interactive plots\n", + "import hvplot.xarray\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", - "import xarray as xr\n", - "import matplotlib.pyplot as plt \n", - "import hvplot.pandas # this library helps to make interactive plots\n", - "import hvplot.xarray\n", - "import fsspec # these libraries help reading cloud data\n", "import s3fs\n", - "import dask\n", - "from dask.distributed import performance_report, Client, progress" + "import xarray as xr\n", + "from dask.distributed import Client, performance_report, progress\n", + "\n", + "xr.set_options(keep_attrs=True)" ] }, { @@ -41,10 +44,13 @@ "source": [ "# Input parameters\n", "# Select either a range of lat/lon or a point. If a point, set both entries to the same value\n", - "latr = [19, 20] # make sure lat1 > lat2 since no test is done below to simplify the code\n", - "lonr = [-158, -157] # lon1 > lon2, range -180:180. resolution daily 1km!\n", + "latr = [\n", + " 19,\n", + " 20,\n", + "] # make sure lat1 > lat2 since no test is done below to simplify the code\n", + "lonr = [-158, -157] # lon1 > lon2, range -180:180. resolution daily 1km!\n", "# time range. data range available: 2002-06-01 to 2020-01-20. [start with a short period]\n", - "dater = ['2012-01-01','2019-12-31'] # dates on the format 'YYYY-MM-DD' as string" + "dater = [\"2012-01-01\", \"2019-12-31\"] # dates on the format 'YYYY-MM-DD' as string" ] }, { @@ -67,9 +73,11 @@ "outputs": [], "source": [ "# first determine the file name using:\n", - "# the s3 bucket [mur-sst], and the region [us-west-2], and the folder if applicable [zarr-v1] \n", - "file_location = 'https://mur-sst.s3.us-west-2.amazonaws.com/zarr-v1'\n", - "ds_sst = xr.open_zarr(file_location,consolidated=True) # open a zarr file using xarray, similar to open_dataset but only reads the metadata\n", + "# the s3 bucket [mur-sst], and the region [us-west-2], and the folder if applicable [zarr-v1]\n", + "file_location = \"https://mur-sst.s3.us-west-2.amazonaws.com/zarr-v1\"\n", + "\n", + "# open a zarr file using xarray, similar to open_dataset but only reads the metadata\n", + "ds_sst = xr.open_zarr(file_location, consolidated=True)\n", "\n", "# look at the datarray structure, description and attributes\n", "ds_sst\n", @@ -84,6 +92,24 @@ "It takes a while, given the high resolution of the data. So, be patient.... and if you're only testing, might want to choose a small region and a short time period first. " ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "sst = (\n", + " ds_sst[\"analysed_sst\"]\n", + " .sel(\n", + " time=slice(dater[0], dater[1]),\n", + " lat=slice(latr[0], latr[1]),\n", + " lon=slice(lonr[0], lonr[1]),\n", + " )\n", + " .mean(dim={\"lat\", \"lon\"}, skipna=True)\n", + ") # .load() # skip 'not a number' values and keep attributes\n", + "sst" + ] + }, { "cell_type": "code", "execution_count": null, @@ -91,21 +117,31 @@ "outputs": [], "source": [ "# decide if a point or a region was given.\n", - "if (latr[0]==latr[1]) | (lonr[0]==lonr[1]): # If we give it only one point\n", - " sst = ds_sst['analysed_sst'].sel(time = slice(dater[0],dater[1]),\n", - " lat = latr[0], \n", - " lon = lonr[0]\n", - " ).load()\n", - "else: # if we give it an area, it extract the area and average SST over the area and returns a time series of SST\n", - " sst = ds_sst['analysed_sst'].sel(time = slice(dater[0],dater[1]),\n", - " lat = slice(latr[0], latr[1]), \n", - " lon = slice(lonr[0], lonr[1])\n", - " ).mean(dim={'lat','lon'}, skipna=True, keep_attrs=True).load() # skip 'not a number' values and keep attributes\n", - "\n", - "sst = sst-273.15 # transform Kelving to degrees Celsius\n", - "\n", - "sst.to_netcdf('sst_example.nc') # we are saving the data. if we need to come back to analyze the same data, we do not have to acquire it again from the cloud.\n", - "sst # take a peak" + "if (latr[0] == latr[1]) | (lonr[0] == lonr[1]): # If we give it only one point\n", + " sst = (\n", + " ds_sst[\"analysed_sst\"]\n", + " .sel(time=slice(dater[0], dater[1]), lat=latr[0], lon=lonr[0])\n", + " .load()\n", + " )\n", + "else: # if we give it an area, it extract the area and average SST over the area and returns a time series of SST\n", + " sst = (\n", + " ds_sst[\"analysed_sst\"]\n", + " .sel(\n", + " time=slice(dater[0], dater[1]),\n", + " lat=slice(latr[0], latr[1]),\n", + " lon=slice(lonr[0], lonr[1]),\n", + " )\n", + " .mean(dim={\"lat\", \"lon\"}, skipna=True)\n", + " .load()\n", + " ) # skip 'not a number' values\n", + "\n", + "sst = sst - 273.15 # transform Kelving to degrees Celsius\n", + "sst.attrs[\"units\"] = \"celsius\" # don't forget to reset attributes to new units\n", + "\n", + "sst.to_netcdf(\n", + " \"sst_example.nc\"\n", + ") # we are saving the data. if we need to come back to analyze the same data, we do not have to acquire it again from the cloud.\n", + "sst # take a peak" ] }, { @@ -122,9 +158,9 @@ "metadata": {}, "outputs": [], "source": [ - "sst = xr.open_dataset('./sst_example.nc') # read a netcdf\n", + "sst = xr.open_dataset(\"./sst_example.nc\") # read a netcdf\n", "sst.close()\n", - "sst = sst.analysed_sst # sst has the same info downloaded above" + "sst = sst.analysed_sst # sst has the same info downloaded above" ] }, { @@ -144,20 +180,19 @@ "outputs": [], "source": [ "# matplotlib method#\n", - "print('matplotlib') \n", - "sst.plot() # this is all you need\n", + "print(\"matplotlib\")\n", + "sst.plot() # this is all you need\n", "\n", "# all the stuff here to make it look nice. try commenting them out\n", - "plt.ylabel('SST ($^\\circ$C)')\n", - "plt.xlabel('Year')\n", - "plt.title('Location: '+str(latr)+'$^\\circ$N, '+str(lonr)+'$^\\circ$W')\n", + "plt.xlabel(\"Year\")\n", + "plt.title(\"Location: \" + str(latr) + \"$^\\circ$N, \" + str(lonr) + \"$^\\circ$W\")\n", "plt.grid(True, alpha=0.3)\n", "plt.show()\n", "\n", "# hovplot method #\n", - "print('hovplot')\n", - "df = pd.DataFrame(data=sst.data, index=sst.time.data,columns=['SST (C)'])\n", - "df.index.name = 'Date'\n", + "print(\"hovplot\")\n", + "df = pd.DataFrame(data=sst.data, index=sst.time.data, columns=[\"SST (C)\"])\n", + "df.index.name = \"Date\"\n", "df.hvplot(grid=True)" ] }, @@ -177,15 +212,15 @@ "outputs": [], "source": [ "# Calculate the climatology\n", - "sst_climatology = sst.groupby('time.dayofyear').mean('time',keep_attrs=True,skipna=False) # Group by day, all years. skipna ignore missing values (NaN=Not a Number)\n", - "sst_climstd = sst.groupby('time.dayofyear').std('time',keep_attrs=True,skipna=False) # Calculate standard deviation. Keep data attributes.\n", + "sst_climatology = sst.groupby(\"time.dayofyear\").mean(\"time\", skipna=False) # Group by day, all years. skipna ignore missing values (NaN=Not a Number)\n", + "sst_climstd = sst.groupby(\"time.dayofyear\").std(\"time\", skipna=False) # Calculate standard deviation.\n", "\n", "# Creates a pandas dataframe (a table-like structure) to plot easily using hvplot.\n", - "df = pd.DataFrame(data=sst_climatology.data, index=sst_climatology.dayofyear.data,columns=['SST (C)'])\n", - "df['+Std']=sst_climstd.data+sst_climatology.data # add standard deviation time series +/-\n", - "df['-Std']=-sst_climstd.data+sst_climatology.data\n", - "df.index.name = 'Day of Year'\n", - "df.hvplot(color=['k','grey','grey'], grid=True, title='SST Climatology') # plot the climatology (black, and the standard deviation in grey)" + "df = pd.DataFrame( data=sst_climatology.data, index=sst_climatology.dayofyear.data, columns=[\"SST (C)\"])\n", + "df[\"+Std\"] = ( sst_climstd.data + sst_climatology.data) # add standard deviation time series +/-\n", + "df[\"-Std\"] = -sst_climstd.data + sst_climatology.data\n", + "df.index.name = \"Day of Year\"\n", + "df.hvplot( color=[\"k\", \"grey\", \"grey\"], grid=True, title=\"SST Climatology\") # plot the climatology (black, and the standard deviation in grey)" ] }, { @@ -195,14 +230,14 @@ "outputs": [], "source": [ "# Calculate the anomalies\n", - "sst_anomaly = sst.groupby('time.dayofyear')-sst_climatology \n", - "sst_anomaly_monthly = sst_anomaly.resample(time='1MS', loffset='15D').mean(keep_attrs=True,skipna=False) # calculate monthly anomalies/smoothing\n", + "sst_anomaly = sst.groupby(\"time.dayofyear\") - sst_climatology\n", + "sst_anomaly_monthly = sst_anomaly.resample(time=\"1MS\", loffset=\"15D\").mean( skipna=False) # calculate monthly anomalies/smoothing\n", "\n", "# Make a pandas dataframe for easy plotting with hvplot\n", - "df2 = pd.DataFrame(data=sst_anomaly.data, index=sst.time.data,columns=['SSTa (C)'])\n", + "df2 = pd.DataFrame(data=sst_anomaly.data, index=sst.time.data, columns=[\"SSTa (C)\"])\n", "\n", - "df2.index.name = 'Date'\n", - "df2.hvplot.area(x='Date', y='SSTa (C)', grid=True, title='SST Anomalies')" + "df2.index.name = \"Date\"\n", + "df2.hvplot.area(x=\"Date\", y=\"SSTa (C)\", grid=True, title=\"SST Anomalies\")" ] }, { @@ -227,40 +262,45 @@ "source": [ "# first, we define a function that take a threshold value, and analyze and plot our data\n", "def SST_above(thr):\n", - " \n", + "\n", " # first part - values above threshold\n", " # first plot the timeseries\n", - " plt.figure(figsize=(8,4))\n", - " plt.plot(sst.time,sst.data, lw=1)\n", - " a=sst>=thr # test when data is equal or greater than the threshold. a is a logical array (True/False values)\n", - " plt.plot(sst.time[a], sst.data[a],'.r', markersize=3) # plot only the values equal or above threshold\n", + " plt.figure(figsize=(8, 4))\n", + " plt.plot(sst.time, sst.data, lw=1)\n", + " a = (\n", + " sst >= thr\n", + " ) # test when data is equal or greater than the threshold. a is a logical array (True/False values)\n", + " plt.plot(\n", + " sst.time[a], sst.data[a], \".r\", markersize=3\n", + " ) # plot only the values equal or above threshold\n", " # all stuff here to make it look good\n", - " plt.ylabel('SST ($^\\circ$C)')\n", - " plt.xlabel('Year')\n", - " plt.title('Location: '+str(latr)+'$^\\circ$N, '+str(lonr)+'$^\\circ$W')\n", + " plt.ylabel(\"SST ($^\\circ$C)\")\n", + " plt.xlabel(\"Year\")\n", + " plt.title(\"Location: \" + str(latr) + \"$^\\circ$N, \" + str(lonr) + \"$^\\circ$W\")\n", " plt.grid(True, alpha=0.3)\n", - " plt.show() # display and finaiize this figure, so the next is not overwritten\n", + " plt.show() # display and finaiize this figure, so the next is not overwritten\n", "\n", " # second part - days per year above threshold\n", - " dts = sst[sst>=thr].time # select dates when SST is equal or greater than the threshold. note that this time is not a logical array, but the time values\n", - " hot_days = dts.groupby('time.year').count() # agregate by year, by counting \n", - " plt.bar(hot_days.year, hot_days) # bar plot of days per year\n", - " plt.xlim(int(dater[0][:4]), int(dater[1][:4])+1) # make it nice\n", - " plt.ylabel('No. days above '+str(np.round(thr,1))+'C')\n", + " dts = sst[sst >= thr].time # select dates when SST is equal or greater than the threshold. note that this time is not a logical array, but the time values\n", + " hot_days = dts.groupby(\"time.year\").count() # agregate by year, by counting\n", + " plt.bar(hot_days.year, hot_days) # bar plot of days per year\n", + " plt.xlim(int(dater[0][:4]), int(dater[1][:4]) + 1) # make it nice\n", + " plt.ylabel(\"No. days above \" + str(np.round(thr, 1)) + \"C\")\n", " plt.grid(True, alpha=0.3)\n", - " plt.show() # display\n", + " plt.show() # display\n", + "\n", "\n", "## Second, the actual analuysis: two examples ##\n", "### Maximum climatology threshold\n", - "thr = df['+Std'].max() # setting threshold as maximum climatological value: mean + 1 standard deviation\n", - "print('Max climatological SST = ',np.round(thr,1),'C')\n", - "SST_above(thr) # Call function we defined\n", + "thr = df[\"+Std\"].max() # setting threshold as maximum climatological value: mean + 1 standard deviation\n", + "print(\"Max climatological SST = \", np.round(thr, 1), \"C\")\n", + "SST_above(thr) # Call function we defined\n", "\n", - "### A relevant threshold. \n", + "### A relevant threshold.\n", "# For example, for hawaii (the select region), 28C is a relevant threshold for coral bleaching (https://coralreefwatch.noaa.gov/product/5km/tutorial/crw08a_bleaching_threshold.php)\n", "thr = 28\n", - "print('\\n\\nBiologically relevant SST = ',thr,'C')\n", - "SST_above(thr) # Call function" + "print(\"\\n\\nBiologically relevant SST = \", thr, \"C\")\n", + "SST_above(thr) # Call function" ] }, { @@ -283,39 +323,41 @@ "thr = np.percentile(sst_anomaly, 90)\n", "\n", "# Same plot as in our function above, but this time we are plotting the anomalies.\n", - "plt.figure(figsize=(8,4))\n", - "plt.plot(sst_anomaly.time,sst_anomaly.data, lw=1)\n", - "plt.axhline(y=0, c='k', zorder=0, alpha=0.5) # add a line to highlight the x axis \n", + "plt.figure(figsize=(8, 4))\n", + "plt.plot(sst_anomaly.time, sst_anomaly.data, lw=1)\n", + "plt.axhline(y=0, c=\"k\", zorder=0, alpha=0.5) # add a line to highlight the x axis\n", "\n", - "a=sst_anomaly>=thr # select data above the threshold\n", - "plt.plot(sst_anomaly.time[a], sst_anomaly.data[a],'.r', markersize=3)\n", + "a = sst_anomaly >= thr # select data above the threshold\n", + "plt.plot(sst_anomaly.time[a], sst_anomaly.data[a], \".r\", markersize=3)\n", "# all stuff here to make it look good\n", - "plt.ylabel('SST anomalies ($^\\circ$C)')\n", - "plt.xlabel('Year')\n", - "plt.title('Location: '+str(latr)+'$^\\circ$N, '+str(lonr)+'$^\\circ$W')\n", + "plt.ylabel(\"SST anomalies ($^\\circ$C)\")\n", + "plt.xlabel(\"Year\")\n", + "plt.title(\"Location: \" + str(latr) + \"$^\\circ$N, \" + str(lonr) + \"$^\\circ$W\")\n", "plt.grid(True, alpha=0.3)\n", "plt.show()\n", "\n", "# Now plot on the original data (not anomalies)\n", - "plt.figure(figsize=(8,4))\n", - "plt.plot(sst.time,sst.data, lw=1)\n", - "plt.plot(sst.time[a], sst.data[a],'.r', markersize=3) # plot only the values equal or above threshold\n", + "plt.figure(figsize=(8, 4))\n", + "plt.plot(sst.time, sst.data, lw=1)\n", + "plt.plot(\n", + " sst.time[a], sst.data[a], \".r\", markersize=3\n", + ") # plot only the values equal or above threshold\n", "# all stuff here to make it look good\n", - "plt.ylabel('SST ($^\\circ$C)')\n", - "plt.xlabel('Year')\n", - "plt.title('Location: '+str(latr)+'$^\\circ$N, '+str(lonr)+'$^\\circ$W')\n", + "plt.ylabel(\"SST ($^\\circ$C)\")\n", + "plt.xlabel(\"Year\")\n", + "plt.title(\"Location: \" + str(latr) + \"$^\\circ$N, \" + str(lonr) + \"$^\\circ$W\")\n", "plt.grid(True, alpha=0.3)\n", "plt.show()\n", "\n", "# Plot of marine heatwave days per year\n", - "dts = sst_anomaly[sst_anomaly>=thr].time\n", - "mhw = dts.groupby('time.year').count()\n", - "plt.bar(mhw.year,mhw)\n", - "plt.ylabel('No. days SSTa > '+str(np.round(thr,1))+'C')\n", + "dts = sst_anomaly[sst_anomaly >= thr].time\n", + "mhw = dts.groupby(\"time.year\").count()\n", + "plt.bar(mhw.year, mhw)\n", + "plt.ylabel(\"No. days SSTa > \" + str(np.round(thr, 1)) + \"C\")\n", "plt.grid(True, alpha=0.3)\n", "plt.show()\n", "\n", - "mhw # print the numbers of days" + "mhw # print the numbers of days" ] }, { @@ -333,10 +375,10 @@ "outputs": [], "source": [ "# Find out max and min SST values and the date when they occur\n", - "minv = sst.min() # find mininum SST value\n", - "mindate = sst[sst==minv].time.data # find when this min value occurred\n", - "maxv = sst.max() # find maximum SST value\n", - "maxdate = sst[sst==maxv].time.data # find when the max value occurred" + "minv = sst.min() # find mininum SST value\n", + "mindate = sst[sst == minv].time.data # find when this min value occurred\n", + "maxv = sst.max() # find maximum SST value\n", + "maxdate = sst[sst == maxv].time.data # find when the max value occurred" ] }, { @@ -345,23 +387,21 @@ "metadata": {}, "outputs": [], "source": [ - "# define a function that go back to the SST data in the cloud, but we now load a different subset \n", + "# define a function that go back to the SST data in the cloud, but we now load a different subset\n", "# an specific day, but now always a region: the region selected or a region around the selected point\n", - "def select_area(day): # the function input is a day\n", - " if (latr[0]==latr[1]) | (lonr[0]==lonr[1]): # if input data was one point\n", - " sst2 = ds_sst.sel(time = day, \n", - " lat = slice(latr-2,latr+2),\n", - " lon = slice(lonr-2,lonr+2)\n", - " ).load()\n", - " else: # if input data was a region\n", - " sst2 = ds_sst.sel(time = day,\n", - " lat = slice(latr[0], latr[1]), \n", - " lon = slice(lonr[0], lonr[1])\n", - " ).load()\n", - " sst3 = sst2['analysed_sst']-273.15\n", - " mask = sst2['mask'].where(sst2['mask']<2)\n", - " sst3 = sst3*mask\n", - " return sst3 # returns the data array of the region at the given date (the region is the defined at the beginning of the script)" + "def select_area(day): # the function input is a day\n", + " if (latr[0] == latr[1]) | (lonr[0] == lonr[1]): # if input data was one point\n", + " sst2 = ds_sst.sel(\n", + " time=day, lat=slice(latr - 2, latr + 2), lon=slice(lonr - 2, lonr + 2)\n", + " ).load()\n", + " else: # if input data was a region\n", + " sst2 = ds_sst.sel(\n", + " time=day, lat=slice(latr[0], latr[1]), lon=slice(lonr[0], lonr[1])\n", + " ).load()\n", + " sst3 = sst2[\"analysed_sst\"] - 273.15\n", + " mask = sst2[\"mask\"].where(sst2[\"mask\"] < 2)\n", + " sst3 = sst3 * mask\n", + " return sst3 # returns the data array of the region at the given date (the region is the defined at the beginning of the script)" ] }, { @@ -371,8 +411,15 @@ "outputs": [], "source": [ "# plot warmest day\n", - "msst = select_area(maxdate) # call function with day of warmest SST\n", - "msst.hvplot.quadmesh(x='lon',y='lat',coastline=True, clabel='T [C]', cmap='coolwarm', title=str(maxdate[0])[:10])\n", + "msst = select_area(maxdate) # call function with day of warmest SST\n", + "msst.hvplot.quadmesh(\n", + " x=\"lon\",\n", + " y=\"lat\",\n", + " coastline=True,\n", + " clabel=\"T [C]\",\n", + " cmap=\"coolwarm\",\n", + " title=str(maxdate[0])[:10],\n", + ")\n", "# this image plot also gives you extra information when you hover your cursor around" ] }, @@ -383,8 +430,15 @@ "outputs": [], "source": [ "# plot coolest day\n", - "msst = select_area(mindate) # call function with day of coolest SST\n", - "msst.hvplot.quadmesh(x='lon',y='lat',coastline=True, clabel='T [C]', cmap='coolwarm', title=str(mindate[0])[:10])" + "msst = select_area(mindate) # call function with day of coolest SST\n", + "msst.hvplot.quadmesh(\n", + " x=\"lon\",\n", + " y=\"lat\",\n", + " coastline=True,\n", + " clabel=\"T [C]\",\n", + " cmap=\"coolwarm\",\n", + " title=str(mindate[0])[:10],\n", + ")" ] }, { @@ -421,7 +475,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -435,7 +489,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.10" } }, "nbformat": 4, diff --git a/Ch7_Atmosphere_Example.ipynb b/Ch7_Atmosphere_Example.ipynb index bf1882f..3c47d2a 100644 --- a/Ch7_Atmosphere_Example.ipynb +++ b/Ch7_Atmosphere_Example.ipynb @@ -20,21 +20,44 @@ "source": [ "# Libraries\n", "import warnings\n", - "warnings.simplefilter('ignore') # filter some warning messages\n", "\n", + "warnings.simplefilter(\"ignore\") # filter some warning messages\n", + "\n", + "import os # library to interact with the operating system\n", + "from calendar import (\n", + " month_abbr, # function that gives you the abbreviated name of a month\n", + ")\n", + "from calendar import monthrange # gives the number of day in a month\n", + "\n", + "import dask\n", + "import fsspec\n", + "import hvplot.pandas\n", + "import hvplot.xarray\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", + "import s3fs\n", "import xarray as xr\n", - "from calendar import month_abbr # function that gives you the abbreviated name of a month\n", - "from calendar import monthrange # gives the number of day in a month\n", - "import matplotlib.pyplot as plt \n", - "import hvplot.pandas\n", - "import hvplot.xarray\n", - "import fsspec\n", + "from dask.distributed import Client, performance_report, progress\n", + "\n", + "xr.set_options(keep_attrs=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "import s3fs\n", - "import dask\n", - "from dask.distributed import performance_report, Client, progress\n", - "import os # library to interact with the operating system" + "\n", + "\n", + "@dask.delayed\n", + "def s3open(path):\n", + " fs = s3fs.S3FileSystem(\n", + " anon=True, default_fill_cache=False, config_kwargs={\"max_pool_connections\": 20}\n", + " )\n", + " return s3fs.S3Map(path, s3=fs)" ] }, { @@ -51,13 +74,26 @@ "metadata": {}, "outputs": [], "source": [ - "# Select region by defining latitude and longitude range. ERA-5 data has a 1/4 degree resolution. \n", - "latr = [39, 40] # Latitude range. Make sure lat1 > lat2 since no test is done below to simplify the code. resolution 0.25 degrees\n", - "lonr = [-125, -123] # lon1 > lon2. and use the range -180 : 180\n", + "# Select region by defining latitude and longitude range. ERA-5 data has a 1/4 degree resolution.\n", + "latr = [\n", + " 39,\n", + " 40,\n", + "] # Latitude range. Make sure lat1 > lat2 since no test is done below to simplify the code. resolution 0.25 degrees\n", + "lonr = [-125, -123] # lon1 > lon2. and use the range -180 : 180\n", "# time selection\n", - "mon = 5 # month to analyze\n", - "iyr = 1979 # you can select the initial year. by default, we set it to the start year of ERA5 dataset\n", - "fyr = 2021 # you can select the final year. by default, we set it to the end year of ERA5 dataset\n" + "mon = 5 # month to analyze\n", + "start_year = 1979 # you can select the initial year. by default, we set it to the start year of ERA5 dataset\n", + "end_year = 2020 # you can select the final year. by default, we set it to the end year of ERA5 dataset\n", + "\n", + "speed_attributes = {\n", + " \"long_name\": \"10 metre wind speed\",\n", + " \"nameCDM\": \"10_metre_wind_speed_surface\",\n", + " \"nameECMWF\": \"10 metre wind speed\",\n", + " \"product_type\": \"analysis\",\n", + " \"shortNameECMWF\": \"10m\",\n", + " \"standard_name\": \"wind_speed\",\n", + " \"units\": \"m s**-1\",\n", + "}" ] }, { @@ -78,48 +114,49 @@ }, "outputs": [], "source": [ - "tdt = list() # initialize a list to store the time index\n", - "\n", - "# v meridional component\n", - "print('Acquiring meridional wind v10m')\n", - "for iy, y in enumerate(range(iyr, fyr+1)): # for the selected year\n", - " file_location = 'https://era5-pds.s3.us-east-1.amazonaws.com/zarr/'+str(y)+'/'+str(mon).zfill(2)+'/data/northward_wind_at_10_metres.zarr'\n", - " # filename includes: bucket name: era5-pds, year: y (transformed to string type), month: mon, and the name of the variable with extenssion zarr\n", - " ds = xr.open_zarr(file_location,consolidated=True) # open access to data\n", - "\n", - " # generate time frame to obtain the whole month data (first to last day of selected month)\n", - " dte1 = str(y)+'-'+str(mon).zfill(2)+'-01'\n", - " dte2 = str(y)+'-'+str(mon).zfill(2)+'-'+str(monthrange(y, mon)[1]) #monthrange provides the lenght of the month\n", - " # select data region and time - meridional wind\n", - " vds = ds['northward_wind_at_10_metres'].sel(time0 = slice(dte1,dte2),\n", - " lat = slice(latr[1],latr[0],), \n", - " lon = slice(lonr[0]+360,lonr[1]+360)\n", - " ).mean(axis=0).load() # average before downloading it\n", - " if iy==0: # if the first year, create an array to store data\n", - " v10_dt = np.full((len(range(iyr, fyr+1)),vds.shape[0],vds.shape[1]), np.nan) # create an array of the size [years,lat,lon]\n", - " v10_dt[iy,:,:] = vds.data # store selected data per year\n", - " \n", - "# u component\n", - "print('Acquiring zonal wind u10m')\n", - "for iy, y in enumerate(range(iyr, fyr+1)):\n", - " file_location = 'https://era5-pds.s3.us-east-1.amazonaws.com/zarr/'+str(y)+'/'+str(mon).zfill(2)+'/data/eastward_wind_at_10_metres.zarr'\n", - " # note that each variable has a distintive file name\n", - " ds = xr.open_zarr(file_location,consolidated=True)\n", - "\n", - " # generate time frame to obtain the whole month data (first to last day of selected month)\n", - " dte1 = str(y)+'-'+str(mon).zfill(2)+'-01'\n", - " dte2 = str(y)+'-'+str(mon).zfill(2)+'-'+str(monthrange(y, mon)[1])\n", - " uds = ds['eastward_wind_at_10_metres'].sel(time0 = slice(dte1,dte2),\n", - " lat = slice(latr[1],latr[0],), \n", - " lon = slice(lonr[0]+360,lonr[1]+360)\n", - " ).mean(axis=0).load()\n", - " if iy==0: # if the first year, create an array to sttore data\n", - " u10_dt = np.full((len(range(iyr, fyr+1)),uds.shape[0],uds.shape[1]), np.nan)\n", - " u10_dt[iy,:,:] = uds.data # store selected data\n", - " \n", - " # append month-year time to the list\n", - " tdt.append(str(y)+'-'+str(mon).zfill(2)+'-01') # add first day of month\n", - " \n" + "%%time\n", + "\n", + "file_pattern = \"era5-pds/zarr/{year}/{month}/data/{var}.zarr/\"\n", + "years = list(np.arange(start_year, end_year + 1, 1))\n", + "months = [\"01\", \"02\", \"03\", \"04\", \"05\", \"06\", \"07\", \"08\", \"09\", \"10\", \"11\", \"12\"]\n", + "var_names = [\"northward_wind_at_10_metres\", \"eastward_wind_at_10_metres\"]\n", + "\n", + "# create empty list that can be used to store data\n", + "ds_era = []\n", + "\n", + "# loop over variables to read\n", + "for var in var_names:\n", + " # Get files\n", + " files_mapper = [\n", + " s3open(file_pattern.format(year=year, month=month, var=var))\n", + " for year in years\n", + " for month in months\n", + " ]\n", + "\n", + " # read in zarr data\n", + " ds = xr.open_mfdataset(\n", + " files_mapper,\n", + " engine=\"zarr\",\n", + " concat_dim=\"time0\",\n", + " combine=\"nested\",\n", + " coords=\"minimal\",\n", + " compat=\"override\",\n", + " parallel=True,\n", + " )\n", + "\n", + " # re-order latitudes and resample to month\n", + " ds = ds.sortby(ds.lat) # conform to lat -90 to 90\n", + "\n", + " ds_month = ds.resample(time0=\"1M\").mean(dim=\"time0\")\n", + " ds_era.append(ds_month)\n", + "\n", + "ds_era = xr.merge(ds_era)\n", + "\n", + "# calculate the wind speed and add attributes to this new variable\n", + "ds_era[\"wind_speed\"] = np.sqrt(\n", + " ds_era.northward_wind_at_10_metres ** 2 + ds_era.eastward_wind_at_10_metres ** 2\n", + ")\n", + "ds_era[\"wind_speed\"].attrs = speed_attributes" ] }, { @@ -129,13 +166,25 @@ "outputs": [], "source": [ "# Build a dataset from the selected data. not only a data array since we have 2 variables of the vector\n", - "mw10 = xr.Dataset(data_vars=dict(u10m=(['time','lat','lon'],u10_dt),\n", - " v10m=(['time','lat','lon'],v10_dt), ),\n", - " coords=dict(time=tdt,lat=vds.lat.values, lon=vds.lon.values-360),attrs=vds.attrs) \n", + "# mw10 = xr.Dataset(\n", + "# data_vars=dict(\n", + "# u10m=([\"time\", \"lat\", \"lon\"], u10_dt),\n", + "# v10m=([\"time\", \"lat\", \"lon\"], v10_dt),\n", + "# ),\n", + "# coords=dict(time=tdt, lat=vds.lat.values, lon=vds.lon.values - 360),\n", + "# attrs=vds.attrs,\n", + "# )\n", "# Add a wind speed variable\n", - "mw10['wsp10m'] = np.sqrt(mw10.u10m**2+mw10.v10m**2) # calculate wind speed\n", - "mw10.to_netcdf('ERA5_wind10m_mon'+str(mon).zfill(2)+'.nc') # saving the file for a future use, so we don't have to get data again\n", - "mw10 # taking a peek\n" + "# mw10[\"wsp10m\"] = np.sqrt(mw10.u10m ** 2 + mw10.v10m ** 2) # calculate wind speed\n", + "# mw10.to_netcdf(\n", + "# \"ERA5_wind10m_mon\" + str(mon).zfill(2) + \".nc\"\n", + "# ) # saving the file for a future use, so we don't have to get data again\n", + "\n", + "mw10 = ds_era.sel(\n", + " lat=slice(latr[0], latr[1]), lon=slice(lonr[0] + 360, lonr[1] + 360)\n", + ") # taking a peek\n", + "\n", + "mw10 # taking a peek" ] }, { @@ -155,9 +204,8 @@ "outputs": [], "source": [ "# simple plot of data, using the matplotlib function quiver to plot vectors\n", - "x,y = np.meshgrid(mw10.lon,mw10.lat) # generate an lat/lon grid to plot the vectors\n", - "plt.quiver(x, y, mw10.u10m[0,:,:], mw10.v10m[0,:,:]) \n", - "plt.show()" + "x, y = np.meshgrid(mw10.lon, mw10.lat) # generate an lat/lon grid to plot the vectors\n", + "plt.quiver(x, y, mw10.u10m[0, :, :], mw10.v10m[0, :, :])" ] }, { @@ -167,33 +215,54 @@ "outputs": [], "source": [ "# Now a more presentable plot\n", - "from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter\n", - "import cartopy.feature as cfeature\n", - "import cartopy.crs as ccrs\n", "from calendar import month_abbr\n", "\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "from cartopy.mpl.ticker import LatitudeFormatter, LongitudeFormatter\n", + "\n", "# Select a region of our data, giving it a margin\n", - "margin = 0.5 # extra space for the plot\n", - "region = np.array([[latr[0]-margin,latr[1]+margin],[lonr[0]-margin,lonr[1]+margin]]) # numpy array that specifies the lat/lon boundaries of our selected region\n", + "margin = 0.5 # extra space for the plot\n", + "region = np.array(\n", + " [[latr[0] - margin, latr[1] + margin], [lonr[0] - margin, lonr[1] + margin]]\n", + ") # numpy array that specifies the lat/lon boundaries of our selected region\n", "\n", "# Create and set the figure context\n", - "fig = plt.figure(figsize=(8,5)) # create a figure object, and assign it a variable name fig\n", - "ax = plt.axes(projection=ccrs.PlateCarree()) # projection type - this one is easy to use\n", - "ax.coastlines(resolution='50m',linewidth=2,color='black') \n", - "ax.add_feature(cfeature.LAND, color='grey', alpha=0.3)\n", - "ax.set_extent([region[1,0],region[1,1],region[0,0],region[0,1]],crs=ccrs.PlateCarree()) \n", - "ax.set_xticks([*np.arange(region[1,0],region[1,1]+1,1)], crs=ccrs.PlateCarree()) # customize ticks and labels to longitude\n", - "ax.set_yticks([*np.arange(region[0,0],region[0,1]+1,1)], crs=ccrs.PlateCarree()) # customize ticks and labels to latitude\n", + "fig = plt.figure(\n", + " figsize=(8, 5)\n", + ") # create a figure object, and assign it a variable name fig\n", + "ax = plt.axes(\n", + " projection=ccrs.PlateCarree()\n", + ") # projection type - this one is easy to use\n", + "ax.coastlines(resolution=\"50m\", linewidth=2, color=\"black\")\n", + "ax.add_feature(cfeature.LAND, color=\"grey\", alpha=0.3)\n", + "ax.set_extent(\n", + " [region[1, 0], region[1, 1], region[0, 0], region[0, 1]], crs=ccrs.PlateCarree()\n", + ")\n", + "ax.set_xticks(\n", + " [*np.arange(region[1, 0], region[1, 1] + 1, 1)], crs=ccrs.PlateCarree()\n", + ") # customize ticks and labels to longitude\n", + "ax.set_yticks(\n", + " [*np.arange(region[0, 0], region[0, 1] + 1, 1)], crs=ccrs.PlateCarree()\n", + ") # customize ticks and labels to latitude\n", "ax.xaxis.set_major_formatter(LongitudeFormatter(zero_direction_label=True))\n", "ax.yaxis.set_major_formatter(LatitudeFormatter())\n", "\n", "# Plot average wind for the selected month, color is the wind speed\n", - "plt.quiver(x, y, mw10.u10m.mean(axis=0), mw10.v10m.mean(axis=0),mw10.wsp10m.mean(axis=0), cmap='jet')\n", - "cbar=plt.colorbar()\n", - "cbar.set_label('m/s') # color bar label\n", - "plt.title('Wind for '+month_abbr[mon]+' ('+str(iyr)+'-'+str(fyr)+')')\n", - "#fig.savefig('filename') # save your figure by usinig the method .savefig. python recognized the format from the filename extension. \n", - "plt.show()" + "plt.quiver(\n", + " x,\n", + " y,\n", + " mw10.northward_wind_at_10_metres[0, :, :],\n", + " mw10.eastward_wind_at_10_metres[0, :, :],\n", + " mw10.wind_speed[0, :, :],\n", + " cmap=\"jet\",\n", + ")\n", + "cbar = plt.colorbar()\n", + "cbar.set_label(\"m/s\") # color bar label\n", + "plt.title(\n", + " \"Wind for \" + month_abbr[mon] + \" (\" + str(start_year) + \"-\" + str(end_year) + \")\"\n", + ")\n", + "# fig.savefig('filename') # save your figure by usinig the method .savefig. python recognized the format from the filename extension." ] }, { @@ -214,8 +283,8 @@ "metadata": {}, "outputs": [], "source": [ - "print('Latitude values: ', mw10.lat.values)\n", - "print('Longitude values: ',mw10.lon.values)" + "print(\"Latitude values: \", mw10.lat.values)\n", + "print(\"Longitude values: \", mw10.lon.values)" ] }, { @@ -225,8 +294,14 @@ "outputs": [], "source": [ "# select a point from the range of latitude and longitude values above\n", - "slat = 39 # selected latitude\n", - "slon = -124 # selected longitude" + "slat = 39 # selected latitude\n", + "slon = -124 # selected longitude\n", + "subset = mw10.sel(lat=slat, lon=slon + 360).load() # load data so we can run analytics\n", + "\n", + "# calculate annual averages\n", + "subset_year = subset.resample(time0=\"1Y\").mean(dim=\"time0\")\n", + "\n", + "subset" ] }, { @@ -236,34 +311,36 @@ "outputs": [], "source": [ "# Select data for an specific location, and do a simple plot of each variable\n", - "plt.figure(figsize=(12,8))\n", + "plt.figure(figsize=(12, 8))\n", "\n", "# meridional wind change\n", - "plt.subplot(2,2,1)\n", - "plt.plot(range(iyr,fyr+1),mw10.v10m.sel(lat=slat,lon=slon), 'bd-',zorder=2)\n", - "plt.axhline(y=0,c='k', alpha=0.4)\n", - "plt.ylabel('Wind speed (m/s)')\n", - "plt.title('Meridional wind (v), Lat='+str(slat)+', Lon='+str(slon))\n", + "plt.subplot(2, 2, 1)\n", + "plt.plot(subset.time0, subset.northward_wind_at_10_metres, \"bd-\", zorder=1)\n", + "plt.plot(subset_year.time0, subset_year.northward_wind_at_10_metres, \"rd-\", zorder=2)\n", + "plt.axhline(y=0, c=\"k\", alpha=0.4)\n", + "plt.ylabel(\"Wind speed (m/s)\")\n", + "plt.title(\"Meridional wind (v), Lat=\" + str(slat) + \", Lon=\" + str(slon))\n", "plt.grid(zorder=0)\n", "\n", "# zonal wind change\n", - "plt.subplot(2,2,2)\n", - "plt.plot(range(iyr,fyr+1),mw10.u10m.sel(lat=slat,lon=slon), 'go-',zorder=2)\n", - "plt.axhline(y=0,c='k', alpha=0.4)\n", - "plt.ylabel('Wind speed (m/s)')\n", - "plt.title('Zonal wind (u), Lat='+str(slat)+', Lon='+str(slon))\n", + "plt.subplot(2, 2, 2)\n", + "plt.plot(subset.time0, subset.eastward_wind_at_10_metres, \"go-\", zorder=1)\n", + "plt.plot(subset_year.time0, subset_year.eastward_wind_at_10_metres, \"rd-\", zorder=3)\n", + "plt.axhline(y=0, c=\"k\", alpha=0.4)\n", + "plt.ylabel(\"Wind speed (m/s)\")\n", + "plt.title(\"Zonal wind (u), Lat=\" + str(slat) + \", Lon=\" + str(slon))\n", "plt.grid(zorder=0)\n", "\n", "# wind speed change\n", - "plt.subplot(2,2,3)\n", - "plt.plot(range(iyr,fyr+1), mw10.wsp10m.sel(lat=slat,lon=slon), 's-',c='darkorange',zorder=2)\n", - "plt.axhline(y=0,c='k', alpha=0.4)\n", - "plt.ylabel('Wind speed (m/s)')\n", - "plt.title('Wind speed, Lat='+str(slat)+', Lon='+str(slon))\n", + "plt.subplot(2, 2, 3)\n", + "plt.plot(subset.time0, subset.wind_speed, \"s-\", c=\"darkorange\", zorder=1)\n", + "plt.plot(subset_year.time0, subset_year.wind_speed, \"rd-\", zorder=2)\n", + "plt.axhline(y=0, c=\"k\", alpha=0.4)\n", + "plt.ylabel(\"Wind speed (m/s)\")\n", + "plt.title(\"Wind speed, Lat=\" + str(slat) + \", Lon=\" + str(slon))\n", "plt.grid(zorder=0)\n", "\n", - "plt.tight_layout()\n", - "plt.show()" + "plt.tight_layout()" ] }, { @@ -280,18 +357,58 @@ "metadata": {}, "outputs": [], "source": [ - "# libraries for statistics and machine learning functions\n", - "from sklearn.preprocessing import PolynomialFeatures\n", - "import statsmodels.api as sm\n", - "\n", - "var='v10m' # select a variable from our Dataset\n", - "\n", - "x = np.array([*range(iyr,fyr+1)]).reshape(-1,1) # we generate an array of years, and transpose it by using .reshape(-1,1)\n", - "y = mw10[var].sel(lat=slat,lon=slon).values.reshape(-1,1) # selected variable\n", - "polf = PolynomialFeatures(1) # linear regression (order=1)\n", - "xp = polf.fit_transform(x) # generate a array with the years and a dummy / constant variable\n", - "mods = sm.OLS(y,xp).fit() # calculate regression model, stored in mods\n", - "print(mods.summary()) # each variable value can also be accessed individually" + "%%time\n", + "results = subset.polyfit(dim='time0',deg=1)\n", + "trend = xr.polyval(subset.time0,results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot data again with trends" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Select data for an specific location, and do a simple plot of each variable\n", + "plt.figure(figsize=(12,8))\n", + "\n", + "# meridional wind change\n", + "plt.subplot(2,2,1)\n", + "plt.plot(subset.time0,subset.northward_wind_at_10_metres, 'bd-', zorder=1)\n", + "plt.plot(subset_year.time0,subset_year.northward_wind_at_10_metres, 'rd-',zorder=2)\n", + "plt.plot(trend.time0,trend.northward_wind_at_10_metres_polyfit_coefficients, 'm',zorder=2,lw=4)\n", + "plt.axhline(y=0,c='k', alpha=0.4)\n", + "plt.ylabel('Wind speed (m/s)')\n", + "plt.title('Meridional wind (v), Lat='+str(slat)+', Lon='+str(slon))\n", + "plt.grid(zorder=0)\n", + "\n", + "# zonal wind change\n", + "plt.subplot(2,2,2)\n", + "plt.plot(subset.time0,subset.eastward_wind_at_10_metres, 'go-',zorder=1)\n", + "plt.plot(subset_year.time0,subset_year.eastward_wind_at_10_metres, 'rd-',zorder=3)\n", + "plt.plot(trend.time0,trend.eastward_wind_at_10_metres_polyfit_coefficients, 'm',zorder=2,lw=4)\n", + "plt.axhline(y=0,c='k', alpha=0.4)\n", + "plt.ylabel('Wind speed (m/s)')\n", + "plt.title('Zonal wind (u), Lat='+str(slat)+', Lon='+str(slon))\n", + "plt.grid(zorder=0)\n", + "\n", + "# wind speed change\n", + "plt.subplot(2,2,3)\n", + "plt.plot(subset.time0,subset.wind_speed, 's-',c='darkorange',zorder=1)\n", + "plt.plot(subset_year.time0,subset_year.wind_speed, 'rd-',zorder=2)\n", + "plt.plot(trend.time0,trend.wind_speed_polyfit_coefficients, 'm',zorder=2,lw=4)\n", + "plt.axhline(y=0,c='k', alpha=0.4)\n", + "plt.ylabel('Wind speed (m/s)')\n", + "plt.title('Wind speed, Lat='+str(slat)+', Lon='+str(slon))\n", + "plt.grid(zorder=0)\n", + "\n", + "plt.tight_layout()" ] }, { @@ -324,7 +441,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -338,7 +455,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.10" } }, "nbformat": 4,