diff --git a/docs/documentation/index.rst b/docs/documentation/index.rst index 20fe5a60d..70239f562 100644 --- a/docs/documentation/index.rst +++ b/docs/documentation/index.rst @@ -22,6 +22,7 @@ Parcels has several documentation and tutorial Jupyter notebooks and scripts whi ../examples/documentation_indexing.ipynb ../examples/tutorial_nemo_curvilinear.ipynb ../examples/tutorial_nemo_3D.ipynb + ../examples/tutorial_croco_3D.ipynb ../examples/tutorial_NestedFields.ipynb ../examples/tutorial_timevaryingdepthdimensions.ipynb ../examples/tutorial_periodic_boundaries.ipynb diff --git a/docs/examples/tutorial_croco_3D.ipynb b/docs/examples/tutorial_croco_3D.ipynb new file mode 100644 index 000000000..f937799be --- /dev/null +++ b/docs/examples/tutorial_croco_3D.ipynb @@ -0,0 +1,322 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CROCO 3D tutorial" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This tutorial will show how to run a 3D simulation with output from the CROCO model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start with loading the relevant modules and the data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import parcels\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import xarray as xr\n", + "\n", + "example_dataset_folder = parcels.download_example_dataset(\"CROCOidealized_data\")\n", + "file = os.path.join(example_dataset_folder, \"CROCO_idealized.nc\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simulation will be a very simple, idealised flow: a purely zonal flow over a sloping bottom. This flow (which is somewhat unrealistic of course) nicely showcases that particles stay on their initial depth levels, even though the sigma-layers slope down. \n", + "\n", + "This flow has been created by first running the example from the [Shelf front example on the CROCO website](https://croco-ocean.gitlabpages.inria.fr/croco_doc/model/model.test_cases.shelfront.html). Then, we took the restart file are manually replaced all the `u`-velocities with `1` m/s and all the `v`-velocities with `0` m/s. This way we get a purely zonal flow. We then started a new simulation from the restart file, and CROCO then automatically calculated the `w` velocities to match the new zonal field. We saved the `time=0` snapshot from this new run and use it below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we create a FieldSet object using the `FieldSet.from_croco()` method. Note that CROCO is a C-grid (with similar indexing at MITgcm), so we need to provide the longitudes and latitudes of the $\\rho$-points of the grid (`lon_rho` and `lat_rho`). We also need to provide the sigma levels at the depth points (`s_w`). Finally, it is important to also provide the bathymetry field (`h`), which is needed to convert the depth levels of the particles to sigma-coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "variables = {\"U\": \"u\", \"V\": \"v\", \"W\": \"w\", \"H\": \"h\"}\n", + "\n", + "lon_rho = \"x_rho\" # Note, this would be \"lon_rho\" for a dataset on a spherical grid\n", + "lat_rho = \"y_rho\" # Note ,this would be \"lat_rho\" for a dataset on a spherical grid\n", + "\n", + "dimensions = {\n", + " \"U\": {\"lon\": lon_rho, \"lat\": lat_rho, \"depth\": \"s_w\", \"time\": \"time\"},\n", + " \"V\": {\"lon\": lon_rho, \"lat\": lat_rho, \"depth\": \"s_w\", \"time\": \"time\"},\n", + " \"W\": {\"lon\": lon_rho, \"lat\": lat_rho, \"depth\": \"s_w\", \"time\": \"time\"},\n", + " \"H\": {\"lon\": lon_rho, \"lat\": lat_rho},\n", + "}\n", + "fieldset = parcels.FieldSet.from_croco(\n", + " file,\n", + " variables,\n", + " dimensions,\n", + " allow_time_extrapolation=True, # Note, this is only needed for this specific example dataset, that has only one snapshot\n", + " mesh=\"flat\", # Note, this is only needed for this specific example dataset, that has been created on a 'flat' mesh (i.e. in km instead of in degrees)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can use this Fieldset to advect particles as we would normally do. Note that the particle depths should be provided in (negative) meters, not in sigma-coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Output files are stored in croco_particles3D.zarr.\n", + "100%|██████████| 50000.0/50000.0 [00:00<00:00, 79485.48it/s]\n" + ] + } + ], + "source": [ + "X, Z = np.meshgrid(\n", + " [40e3, 80e3, 120e3],\n", + " [100, -10, -130, -250, -400, -850, -1400, -1550],\n", + ")\n", + "Y = np.ones(X.size) * fieldset.U.grid.lat[25]\n", + "\n", + "\n", + "def DeleteParticle(particle, fieldset, time):\n", + " if particle.state >= 50:\n", + " particle.delete()\n", + "\n", + "\n", + "pset = parcels.ParticleSet(\n", + " fieldset=fieldset, pclass=parcels.JITParticle, lon=X, lat=Y, depth=Z\n", + ")\n", + "\n", + "outputfile = pset.ParticleFile(name=\"croco_particles3D.zarr\", outputdt=5000)\n", + "\n", + "pset.execute(\n", + " [parcels.AdvectionRK4_3D, DeleteParticle],\n", + " runtime=5e4,\n", + " dt=100,\n", + " output_file=outputfile,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we plot the particle trajectories below. Note that the particles stay on their initial depth levels, even though the sigma-layers slope down. Also note that particles released above the surface (where depth >0) or below the bathymetry are not advected (due to the `DeleteParticle` kernel)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [ + "nbsphinx-thumbnail" + ] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAGGCAYAAABIeJQgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADJhklEQVR4nOydd1gTWRfG3yT0LqAgiqCu3XXt3VVAwIYVG3asa8G+9oK69l5QQcWKHXtX7Fiw90aVKr23JOf7g00+QhJIKALu/T3PEDJz75kzM8nMm3PvPZdDRAQGg8FgMBgMRrHCLW0HGAwGg8FgMH5FmMhiMBgMBoPBKAGYyGIwGAwGg8EoAZjIYjAYDAaDwSgBmMhiMBgMBoPBKAGYyGIwGAwGg8EoAZjIYjAYDAaDwSgBmMhiMBgMBoPBKAGYyGIwGAwGg8EoAZjIUpL9+/eDw+GIFxUVFVStWhWjRo1CWFhYse5r5cqVOHv2rNT6O3fugMPh4M6dO0rZE/keFBRULP6V1j4tLS0xcuTIAssV9jwpQ1BQEDgcDvbv3y9eVxrnGQBGjhwJS0tLhcoKhUIcOnQInTt3hrGxMVRVVVGpUiX06NEDFy5cgFAoBPD/4xMtXC4XFSpUgI2NDa5fvy7X/tWrV9G9e3dUrFgR6urqMDc3x4gRI/Dhwwe5de7fv48BAwagSpUqUFNTg76+Ptq2bYudO3ciNTVVomxqaipWr16NJk2aQEdHB9ra2mjcuDFWrlwpVfZnsXTpUnA4nJ9q383NTeKzV1wEBQWhe/fuMDQ0BIfDwbRp02R+1pWxp2jdkj6Psiit7ywAvHr1Ct27d0e1atWgqakJQ0NDtGnTBocPH5Yq26lTJ4nvoq6uLn777Tf0798fp06dEn9vS5rSuEay8PLywubNm2Vu43A4WLp06U/1RxYqpe1AecXT0xN169ZFeno67t27h1WrVuHu3bt4+/YttLW1i2UfK1euhKOjI3r37i2xvmnTpnj06BHq169fLPspSbp3745Hjx6hcuXKxWbzzJkz0NPTKzZ7xU1JHHNxkpGRgd69e+P69esYNGgQdu7cCVNTU0RHR+Pq1avo378/jh8/jl69eonrTJkyBU5OThAIBPj06RNcXV3RrVs3+Pj44M8//5Sw//fff2PdunXo0qUL3NzcYGJigi9fvmDjxo1o2rQpvLy80LdvX4k6S5YswbJly9C2bVssX74cNWvWRFpaGnx9fbF06VJ8+fIFmzZtAgBERUWhc+fO8Pf3h4uLC9auXQsA8PHxwYoVK3D06FHcvHkTJiYmJXwmfy5jxoxBly5dJNa5ubnB2NhYoR8dyjB9+nQ8efIE+/btg6mpKSpXrgxTU1M8evQINWvWLNZ9lQVK8zubkJAAc3NzDB48GFWqVEFqaiqOHDmCYcOGISgoCAsXLpQoX6NGDRw5cgRAzo+NwMBAnD17Fv3790eHDh1w4cIF6Ovr//TjKA28vLzw7t07TJs2TWrbo0ePULVq1Z/vVF6IoRSenp4EgPz8/CTWL1q0iADQ4cOHi7yPtLQ0IiLS1tamESNGFNmeCJHvgYGBxWazLHP79m0CQLdv3y6xfQQGBhIA8vT0LLF9KMqIESPIwsKiwHJ//fUXAaADBw7I3P7lyxd6/fo1Ef3/+NatWydR5u7duwSAhg8fLrHey8uLANBff/0lZTclJYWaNWtGWlpa5O/vL15/4sQJAkCjR48moVAoVS8pKYmuXbsmfm9nZ0cqKip0//59qbL3798nFRUVsre3z+cMlAxLliyhn31LbdCgAXXs2LHY7f7222/UtWvXYrOnzPekNM5jWaRVq1Zkbm4usa5jx47UoEEDmeX37dtHAGjAgAEl7ltZuUbdu3dX6J5XmrDmwmKidevWAIDg4GAAgKurK1q1agVDQ0Po6emhadOm2Lt3LyjPfNyWlpbo0aMHvL290aRJE2hoaMDV1RUcDgepqak4cOCAODzcqVMnAPKbwZ48eQIHBwcYGRlBQ0MDNWvWlKnw83Lz5k3Y2NhAT08PWlpaaNeuHW7duiVRJjo6GuPGjYO5uTnU1dVRsWJFtGvXDjdv3szXtqwwfKdOndCwYUP4+fmhQ4cO0NLSQo0aNbB69WqFwt2ymgs/ffqELl26QEtLC8bGxpgwYQKSk5MLfbzfvn3DqFGjUKtWLWhpaaFKlSpwcHDA27dvC/Qv7zGLrpesJW/z3vHjx9GmTRtoa2tDR0cH9vb2ePnypcx91KlTB+rq6qhXrx4OHjxYoF8AEBkZiT179sDe3h7Dhw+XWaZWrVpo1KhRvnaaN28OICeqlJt//vkHFSpUwPr166XqaGtrY9u2bUhLSxNHpQBg2bJlqFChArZu3SqzCUJXVxd2dnYAgGfPnuH69esYPXo02rdvL1W2ffv2cHZ2xrVr1/D8+XO5/k+bNg3a2tpISkqS2jZw4ECYmJggOztbvE7R65IXoVCItWvXom7dulBXV0elSpUwfPhwhIaGSpW9evUqbGxsoK+vDy0tLdSrVw+rVq0Sb8/bRGNpaYn379/j7t27Ep+nlJQUGBgYYPz48VL7CAoKAo/Hw7p162T6K/qsfvv2DVeuXBHbDQoKktvk9/XrVzg5OaFSpUriz+OOHTsKPDcAcOnSJTRu3Bjq6uqoXr26zM+NPOR1G+jUqZP4XgnkXIMVK1agTp060NTUhIGBARo1aoQtW7aIyxT1PvX+/XvY2dlBS0sLFStWxKRJk3Dp0qUidVcwNjaGiorijU2jRo1Ct27dcPLkSfFzSB43btxAr169ULVqVWhoaOC3337D+PHjERMTI1VWkWvUpEkTdOjQQWq9QCBAlSpVJCLXWVlZWLFihfg7UbFiRYwaNQrR0dFS9b28vNCmTRvo6OhAR0cHjRs3xt69ewHkXJ9Lly4hODhY4p4qQlZz4bt379CrVy9UqFABGhoaaNy4MQ4cOCBRRvQdOHr0KBYsWAAzMzPo6emhc+fO+Pz5c77nVRZMZBUT3759AwBUrFgRQM7NbPz48Thx4gS8vb3Rt29fTJkyBcuXL5eq++LFC8yePRsuLi64evUq+vXrh0ePHkFTUxPdunXDo0eP8OjRI7i5ucnd/7Vr19ChQweEhIRg48aNuHLlChYuXCj1EMzL4cOHYWdnBz09PRw4cAAnTpyAoaEh7O3tJYTHsGHDcPbsWSxevBjXr1/Hnj170LlzZ8TGxhbmdCEyMhJDhgzB0KFDcf78eXTt2hXz5s2T2Q+hIKKiotCxY0e8e/cObm5uOHToEFJSUjB58uRCH294eDiMjIywevVqXL16FTt27ICKigpatWql9BdN1Lybezl48CBUVVXRoEEDcbmVK1di8ODBqF+/Pk6cOIFDhw4hOTkZHTp0kOjLtH//fowaNQr16tXD6dOnsXDhQixfvhw+Pj4F+nL79m1kZ2dLNUErS2BgIACgdu3a4nURERESDxtZtGnTBpUqVcKNGzfEdd69e5dvndyI6uXnv2ibqKwsnJ2dkZaWhhMnTkisT0hIwLlz5zB06FCoqqoCUPy6yOKvv/7CnDlzYGtri/Pnz2P58uW4evUq2rZtK/FA27t3L7p16wahUIhdu3bhwoULcHFxkSnGRJw5cwY1atRAkyZNxJ+rM2fOQEdHB87Ozjhy5AgSExMl6ri5uUFNTQ3Ozs4ybYo+q6ampmjXrp3YrrxmtA8fPqBFixZ49+4dNmzYgIsXL6J79+5wcXGBq6trvufm1q1b6NWrF3R1dXHs2DGsW7cOJ06cgKenZ771lGXt2rVYunQpBg8ejEuXLuH48eMYPXo0EhISCqyryH0qIiICHTt2xOfPn7Fz504cPHgQycnJMu8/+SEUCsHn8xEdHQ03Nzdcu3YNc+bMUcpGz549QUS4f/9+vuX8/f3Rpk0b7Ny5E9evX8fixYvx5MkTtG/fXuLHhaLXaNSoUXjw4AG+fv0qsf769esIDw/HqFGjxMfYq1cvrF69Gk5OTrh06RJWr16NGzduoFOnTkhPTxfXXbx4MYYMGQIzMzPs378fZ86cwYgRI8QC0s3NDe3atRM3Y4sWeXz+/Blt27bF+/fvsXXrVnh7e6N+/foYOXKkuMtBbubPn4/g4GDs2bMH7u7u+Pr1KxwcHCAQCPI9t1KUdiitvCFqcnv8+DFlZ2dTcnIyXbx4kSpWrEi6uroUGRkpVUcgEFB2djYtW7aMjIyMJJpELCwsiMfj0efPn6XqyWsulNUMVrNmTapZsyalp6cX6LuouTA1NZUMDQ3JwcFByt8//viDWrZsKV6no6ND06ZNk2tb0X0S5YS8AdCTJ08kytavX1+hZh4LCwuJ8zJnzhzicDj06tUriXK2trYS50mZ480Ln8+nrKwsqlWrFk2fPl28XlYzSEHNslFRUVSjRg1q0KABxcfHExFRSEgIqaio0JQpUyTKJicnk6mpqbgJQCAQkJmZGTVt2lTicxQUFESqqqoFhs5Xr15NAOjq1av5lst7fGvWrKHs7GzKyMigV69eUZs2bahy5coSx/j48WMCQHPnzs3XZqtWrUhTU1OpOiImTJhAAOjTp09yy3z8+FFuk2VumjZtSm3btpVY5+bmRgDo7du3RKT4dSGSbkIR+TFx4kSJuk+ePCEANH/+fLEtPT09at++vczmUnn2ieQ3F/r7+xOXy6VNmzaJ16Wnp5ORkRGNGjVK7j5EWFhYUPfu3SXWyfqs29vbU9WqVSkxMVGi7OTJk0lDQ4Pi4uLk1m3VqhWZmZlJ3LOSkpLI0NBQoaaovPcBER07dpQ4Jz169KDGjRvna6so96nZs2cTh8Oh9+/fS5Szt7dXqrvC+PHjCQABIDU1NXJzc5N5bPKaC4mIrly5Iv6+KopQKKTs7GwKDg4mAHTu3DnxNkWvUUxMDKmpqYk/0yIGDBhAJiYmlJ2dTURER48eJQB0+vRpiXJ+fn4EQHzMAQEBxOPxaMiQIfn6nl9zIQBasmSJ+P2gQYNIXV2dQkJCJMp17dqVtLS0KCEhgYj+/3zt1q2bRDlRt4ZHjx7l61NeWCSrkLRu3RqqqqrQ1dVFjx49YGpqiitXrog72/r4+KBz587Q19cHj8eDqqoqFi9ejNjYWPz48UPCVqNGjSQiAsry5csX+Pv7Y/To0dDQ0FC4nq+vL+Li4jBixAjw+XzxIhQK0aVLF/j5+YlHarVs2RL79+/HihUr8PjxY4lfO4XB1NQULVu2lFjXqFGjAsPcsrh9+zYaNGiAP/74Q2K9k5OTxHtljpfP52PlypWoX78+1NTUoKKiAjU1NXz9+hUfP35U2kcRqamp6N69OzIyMnDlyhUYGBgAyIlE8vl8DB8+XMI3DQ0NdOzYUdzk8PnzZ4SHh8PJyUkiNG5hYYG2bdsW2q+CmDNnDlRVVcUh9nfv3uHChQsKj2bMDRGV6Mgk+rdJvqB9jBo1Cr6+vhKRSU9PT7Ro0QINGzYEoPh1kcXt27cBQKpJq2XLlqhXr544curr64ukpCRMnDix2M5LjRo10KNHD7i5uYnPh5eXF2JjY5WOsMgjIyMDt27dQp8+faClpSVxfrp164aMjAw8fvxYZt3U1FT4+fmhb9++EvcsXV1dODg4FIt/Ilq2bInXr19j4sSJuHbtmswmYnkocp+6e/cuGjZsKDUQafDgwUr5OX/+fPj5+eHSpUtwdnbG5MmTlWo+BSDVHUUeP378wIQJE2Bubg4VFRWoqqrCwsICAMT3N2WukZGRERwcHHDgwAFxU2p8fDzOnTuH4cOHi5s9L168CAMDAzg4OEh8Xho3bgxTU1Px9+nGjRsQCASYNGmSUsefHz4+PrCxsYG5ubnE+pEjRyItLU0qCtazZ0+J96IuFMo+o5jIKiQHDx6En58fXr58ifDwcLx58wbt2rUDADx9+lTch8TDwwMPHz6En58fFixYAAASIVEARR7RImrLVnYkhagp0dHREaqqqhLLmjVrQESIi4sDkNMnZcSIEdizZw/atGkDQ0NDDB8+HJGRkYXy2cjISGqdurq61LlRhNjYWJiamkqtz7tOmeOdMWMGFi1ahN69e+PChQt48uQJ/Pz88McffxTKRyBHuDk6OuLLly+4fPmyxJdd5FuLFi2kfDt+/Li4aUnUPKvI8cqiWrVqAP7f3KcoU6dOhZ+fHx48eID169cjOzsbvXr1kmguVtR2cHCw+NiV9UeR8qJ+NXlvpnkZMmQI1NXVxX2MPnz4AD8/P3HTBqD4dZGF6NzI+n6bmZmJtxf2+1sQU6dOxdevX8XNpjt27ECbNm3QtGnTYrEfGxsLPp+Pbdu2SZ2bbt26AYDc8xMfHw+hUFjoz7EyzJs3D+vXr8fjx4/RtWtXGBkZwcbGBs+ePSuwriL3qdjYWJkjWZUd3VqtWjU0b94c3bp1w86dOzFu3DjMmzdPZl8leYgEgJmZmdwyQqEQdnZ28Pb2xt9//41bt27h6dOnYkEsOjZlr5GzszPCwsLEn7ejR48iMzNT4kdGVFQUEhISoKamJvWZiYyMFH9eSuI7ERsbK/e7KNqem7zXXl1dHYD087sgWAqHQlKvXj1x59+8HDt2DKqqqrh48aLELwBZOa+Agn9xF4SoH1h+/TdkYWxsDADYtm2buON+XkQ3CmNjY2zevBmbN29GSEgIzp8/j7lz5+LHjx+4evVqEbwvOkZGRjLFXt51yhzv4cOHMXz4cKxcuVJie0xMjDj6pCzjxo3DrVu3cPnyZamom8i3U6dOiX9RykL0xVfkeGVhZWUFVVVVnD17FhMmTFDY96pVq4o/76J+EEOHDsWSJUuwfft2ADliokGDBrh+/TrS0tJk9rF69OgRoqKi0L9/f3Gd33//Pd86ubG1tcX8+fNx9uxZqXQGIkTfM1tb23xtVahQAb169cLBgwexYsUKeHp6QkNDQyICoeh1kYXoWkVEREg9LMLDw8W2C/v9LQhra2s0bNgQ27dvh46ODl68eFGoPo/yqFChAng8HoYNGyY34lC9enW5dTkcTqE/xwCgoaGBzMxMqfUxMTHicwsAKioqmDFjBmbMmIGEhATcvHkT8+fPh729Pb5//65QX8D8MDIyktn3tbA/QEW0bNkSu3btQkBAgPgzUhDnz58Hh8ORSquSm3fv3uH169fYv38/RowYIV4v6lcsQtlrZG9vDzMzM3h6esLe3h6enp5o1aqVRITP2NgYRkZGcp8Zurq6ACS/EwX9WFIUIyMjRERESK0PDw8X+1YSsEhWCSBKUsrj8cTr0tPTcejQIaXsKBrZqV27NmrWrIl9+/bJvOnIo127djAwMMCHDx/QvHlzmYuamppUvWrVqmHy5MmwtbXFixcvlDqmksDKygrv37/H69evJdZ7eXlJvFfmeDkcjviXi4hLly4VOuHswoUL4enpKR4wkBd7e3uoqKjA399frm8AUKdOHVSuXBlHjx6VaBoIDg6Gr69vgX6YmppizJgxuHbtmtwRif7+/njz5k2+doYMGYJOnTrBw8NDIny+YMECxMfHY9asWVJ1UlNT4eLiAi0tLUyfPl28ftGiRYiPj4eLi4vM5o6UlBRx4tPmzZvDzs4Oe/fuxcOHD6XKPnjwAPv27UOXLl3QrFmzfI8ByGkyDA8Px+XLl3H48GH06dNHQkQrel1kYW1tDQBSwsbPzw8fP36EjY0NAKBt27bQ19fHrl27FG7uEVHQPcLFxQWXLl3CvHnzYGJiIha3xYGWlhasrKzw8uVLNGrUSOa5kRUJAnJGmrZs2RLe3t7IyMgQr09OTsaFCxcU2r+lpaXU5/TLly/5DkwxMDCAo6MjJk2ahLi4uGJJPioadJN3EMSxY8eKZPf27dvgcrmoUaOGQuU9PT1x5coVDB48WBzxlYXoR33e+9vu3bsl3it7jUSC++zZs7h//z6ePXsmNcCiR48eiI2NhUAgkPl5qVOnDgDAzs4OPB4PO3fuzPeYlWn9sLGxgY+Pj1hUiTh48CC0tLTk/vAuKiySVQJ0794dGzduhJOTE8aNG4fY2FisX79e6kNdEL///jvu3LmDCxcuoHLlytDV1RV/CPOyY8cOODg4oHXr1pg+fTqqVauGkJAQXLt2TZy4Li86OjrYtm0bRowYgbi4ODg6OqJSpUqIjo7G69evER0djZ07dyIxMRFWVlZwcnJC3bp1oaurCz8/P1y9elUqqWRpMG3aNOzbtw/du3fHihUrYGJigiNHjuDTp08S5RQ9XiDnZrB//37UrVsXjRo1wvPnz7Fu3bpCha9PnjyJf/75B46Ojqhdu7ZEPxV1dXU0adIElpaWWLZsGRYsWICAgAB06dIFFSpUQFRUFJ4+fQptbW24urqCy+Vi+fLlGDNmDPr06YOxY8ciISEBS5cuVbiZZePGjQgICMDIkSNx7do19OnTByYmJoiJicGNGzfg6emJY8eOFZjGYc2aNWjVqhWWL1+OPXv2AMjph/LixQusX78eQUFBcHZ2homJCT5//oxNmzbB398fXl5eEg+O/v37Y9GiRVi+fDk+ffqE0aNHi5ORPnnyBLt378bAgQPFTfAHDx5E586dYWdnBxcXF7FY8fHxwZYtW1C3bl2Fs5Lb2dmhatWqmDhxIiIjIyWaCgEofF1kUadOHYwbNw7btm0Dl8tF165dERQUhEWLFsHc3FwsNHV0dLBhwwaMGTMGnTt3xtixY2FiYoJv377h9evX4kihLH7//XccO3YMx48fR40aNaChoYHff/9dvH3o0KGYN28e7t27h4ULF8r80VQUtmzZgvbt26NDhw7466+/YGlpieTkZHz79g0XLlzId8Tr8uXL0aVLF9ja2mLmzJkQCARYs2YNtLW1xc32+TFs2DAMHToUEydORL9+/RAcHIy1a9dKRX0cHBzQsGFDNG/eHBUrVkRwcDA2b94MCwsL1KpVq8jnQHT/6dq1K5YtWwYTExN4eXmJ7z9cbv6xjHHjxkFPTw8tW7YUfw9PnjyJ48ePY/bs2VLHk56eLtG0FxAQgLNnz+LixYvo2LEjdu3ale/+6tati5o1a2Lu3LkgIhgaGuLChQsyR+Mqe42cnZ2xZs0aODk5QVNTEwMHDpTYPmjQIBw5cgTdunXD1KlT0bJlS6iqqiI0NBS3b99Gr1690KdPH1haWmL+/PlYvnw50tPTMXjwYOjr6+PDhw+IiYkRf+d+//13eHt7Y+fOnWjWrBm4XK7cHz5LlizBxYsXYWVlhcWLF8PQ0BBHjhzBpUuXsHbt2pJL4KpUN3mG3GSkedm3bx/VqVOH1NXVqUaNGrRq1Srau3ev1AgWWaN4RLx69YratWtHWlpaBEA8YkZeks1Hjx5R165dSV9fn9TV1almzZoSI+HkjXq7e/cude/enQwNDUlVVZWqVKlC3bt3p5MnTxIRUUZGBk2YMIEaNWpEenp6pKmpSXXq1KElS5ZQamqqQucr76gdWSNkFE2mKWtU0YcPH8jW1pY0NDTI0NCQRo8eTefOnZN5ngo6XiKi+Ph4Gj16NFWqVIm0tLSoffv2dP/+famRS4qMLhSNCpO15D3es2fPkpWVFenp6ZG6ujpZWFiQo6Mj3bx5U6Lcnj17qFatWqSmpka1a9emffv2KXz+iHJGSx44cICsra3J0NCQVFRUqGLFitS1a1fy8vIigUAgcXx5k5GK6N+/P6moqNC3b98k1l++fJm6detGRkZG4nM8bNgwqRFYubl79y45OjpS5cqVSVVVlfT09KhNmza0bt06SkpKkiibkpJCK1eupMaNG5OWlhZpaWlRo0aNaMWKFZSSkqLQORAxf/58AkDm5ubi486LItdF1ug/gUBAa9asodq1a5OqqioZGxvT0KFD6fv371L7uHz5MnXs2JG0tbVJS0uL6tevLzFKTJb9oKAgsrOzI11dXZmfJyKikSNHkoqKCoWGhip8ThQdXSha7+zsTFWqVCFVVVWqWLEitW3bllasWFFg3fPnz1OjRo1ITU2NqlWrRqtXr1Y40aVQKKS1a9dSjRo1SENDg5o3b04+Pj5S39ENGzZQ27ZtydjYWLyf0aNHU1BQkLhMUe9T7969o86dO0vcfw4cOEAAxIl95bFv3z7q0KEDGRsbk4qKChkYGFDHjh3p0KFDUmVFIx5Fi7a2NtWoUYMcHR3p5MmTcj+/eRHdL3V1dalChQrUv39/CgkJkRqRR6T8NWrbti0BkDsyMDs7m9avX09//PEHaWhokI6ODtWtW5fGjx9PX79+lSh78OBBatGihbhckyZNJD5DcXFx5OjoSAYGBsThcCR8knUsb9++JQcHB9LX1yc1NTX6448/pD6Toudr7ucBUeETT3P+dYbBYDAYvxhZWVmwtLRE+/btpXKCMUqWcePG4ejRo4iNjS32CCKj/MCaCxkMBuMXIzo6Gp8/f4anpyeioqIwd+7c0nbpl2bZsmUwMzNDjRo1kJKSgosXL2LPnj0l0kTLKF8wkcVgMBi/GJcuXcKoUaNQuXJluLm5FVvaBoZsVFVVsW7dOoSGhoLP56NWrVrYuHEjpk6dWtquMUoZ1lzIYDAYDAaDUQKwFA4MBoPBYDAYJQATWQwGg8FgMBglABNZDAaDwWAwGCUA6/heAgiFQoSHh0NXV7dEJ8JlMBgMBoNRdIgIycnJMDMzKzCBrDIwkVUChIeHF9t8SwwGg8FgMH4O379/L9aJqZnIKgFEk1x+//4denp6pewNg8FgMBiM/EhKSoK5ubn4+V1cMJFVAoiaCPX09JjIYjAYDAajnFDcXXxYx3cGg8FgMBiMEoCJLAaDwWAwGIwSgIksBoPBYDAYjBKAiSwGg8FgMBiMEoCJLAaDwWAwGIwSgIksBoPBYDAYjBKAiSwGg8FgMBiMEoCJLAaDwWAwGIwSgIms/wARienw9Y9BRGJ6abvCKC8khgGB93JeGQwFiEyNxNOIp4hMjSxtVxiMMgPL+P6Lc9wvBPO830JIAJcDrOr7Owa2qFbabjHKMi8OAhemAiQEOFzAYQvQdHhpe8Uow3h/9YbrI1cISQguh4slbZagb62+pe0Wg1HqsEjWL0xEYrpYYAGAkID53u9YRIshn8Sw/wssIOf1wjQW0WLIJTI1UiywAEBIQrg+cmURLQYDTGT90gTGpIoFlggBEYJi0krHIUbZJ87//wJLBAmAuIDS8YdR5glJChELLBFCEuJ78vdS8ojBKDswkfULU91YG9w8c13yOBxYGmuVjkOMso9hzZwmwtxweIBhjdLxh1HmqaZXDdw8nxkuhwtzXfNS8ojBKDswkfULU1lfE6v6/g7ev7OK8zgcrOzbEJX1NUvZM0aZRb9KTh8sDi/nPYcHOGzOWc9gyMBU2xRL2iwRCy1RnyxTbdNS9ozBKH04REQFF2MoQ1JSEvT19ZGYmAg9Pb3SdgcRiekIikmDpbEWE1gMxUgMy2kiNKzBBBZDISJTI/E9+TvMdc2ZwGKUO0rquc1GF/4HqKyvycQVQzn0qzBxxVAKU21TJq4YjDyw5kIGg8FgMBiMEoCJLAaDwWAwGIwSgIksBoPBYDAYjBKAiSwGg8FgMBiMEoCJLAaDwWAwGIwSgIksBoPBYDAYjBKAiSwGg8FgMBiMEoCJrHxwc3ND9erVoaGhgWbNmuH+/ful7RKDwWAwGIxyAhNZcjh+/DimTZuGBQsW4OXLl+jQoQO6du2KkJCQ0naNwWAwGAxGOYBNqyOHVq1aoWnTpti5c6d4Xb169dC7d2+sWrUq37plbVodBoPBYDAY8imp5zaLZMkgKysLz58/h52dncR6Ozs7+Pr6SpXPzMxEUlKSxFKWiEhMh69/DCIS00vVRlmzw3yRT1SoP949vICoUP9StQEgZx7FwHs5r6Vth/kil8jIV3j6cg8iI1+Vqg0gZx7FpxFPEZkaWep2mC8la6e4fCkp2NyFMoiJiYFAIICJiYnEehMTE0RGSl/IVatWwdXVVWr9wIEDoaqqWmJ+KkJgTCr8o1PE7830NWGgpZxPCWnZCM/10K6srwEDLbX/FyBAMhxK//+ba0NCejaikjLE7030NKCvqZq7ikIkpmcjKjmXHd1cdkRw5NfnyPDFVE+GDXmVc/uSlo3IPHYKc36LaqM47agmBKJSVgg4yLksCSqVQJoVlLLBSY+HAf+H2Ea6pim09Csq7QvS4yQf/vpVAE3D0rEjZaNqEXwJLZqd4rBRjHYiUsPxWZAqfl+Lpw1TLeXmMYxMi8TX3DY0jGFqVE9pXyLTIvE1/uv/7VSopbQvxWWH+VKydvLaqGNYB5W1KyvtCwBkZ2cXql5BsOZCGYSHh6NKlSrw9fVFmzZtxOv/+ecfHDp0CJ8+fZIon5mZiczMTPH7pKQkmJubY/bs2dDU1ASXywWPxwOXyxUvud8ruk3Z/+PSsjHh8EsQhwNwuOBwuACH8++S+33OK4fLBfDv/xwuwOXKKPvvNk7ubfkoGka5whSx8FV3AZfDbgsMxYjk8WBvbgYhuw8wShkuh4tr/a4VaqLykmouZJEsGRgbG4PH40lFrX78+CEV3QIAdXV1qKurS63v1asXtLS0IBAIIBQKxUvu9/lty/s+OztbKTuB0clIDw4BCQUAEUAEIiFMdFWhzuOASAgSCkFE/74Kc8oIBeJ1mdl8xKVk/FuXABICJIS+Bg9qPE5OvdwHzZEOInHAQZZAiPi0rBw/ct2MDbXUoKaS02rNU1WDipp6zqKqDt6/r6J16lo6yFLVxacEDnja+uBq6oOrmnPe29U0QkVddQlfcv98yL0+OjkDjwPipK5X6xqGMNLJcx3z0RoxKZl4Eihtp1X1CtJ25BCbkokngfFFslGcdkxjQ8CNkz7or6q1kalqoJAN9ewE1Mr+IrU+2egP6FaopLAvSIsDwp9LrzdrBmgpEW0pDjtybTQthC8vimZHro1SOC8AQtIjIeQkKr5fBqOEEJIQ35O/F0pklRRMZMlATU0NzZo1w40bN9CnTx/x+hs3bqBXr14K21mxYgVUVHJOMYfDAYfDgYqKClRVVcWv8v4vaJ26unqB5ZpkCHAh/jmIowLwVMDhcsHjqcJ72p+oaqQnUZbLld09LyIxHe1W+0CY67nL43DwYK4VKutrKnwuCrJDRMjMzER6erp4ycjIkHifmJiIbyFhePX8KfhpSRCmJYD4WeCAgx+/GSFVQw3GxsaoWLEiKlWqJH41MzODpaUldHR08vVl08DGxXJMmwc1UdhOcdgoTjtRoQYQeMwDL1cki09c6I04BpOqNRW04Q+BRzMpG2l9PKGroA0AOU1zmxvmCHsRHB4w8FBOc9/PtCPXxuFi8kUJO2XpvACoFvkK3KtDJSJZXCKc7bwXJia/K2QjKuotet8cXSQbABCVFoXeZ3tDiP8fE5fDxdleZ2GiJf0DuSTtMF9K1o48G+a65gr78TNgzYVyOH78OIYNG4Zdu3ahTZs2cHd3h4eHB96/fw8LC4t864rCjnFxcahQ4f99WYRCIfh8PrKzs6VeC7OuoLJ8Ph9vQmJx52MEhAIBOCRACwt9VDNQlyonFArlHk94Qjo+RiSBwAEHQD0zPZjpa0g0ExIReDxevqLPPyYd9/3jAVUNqGjqwunPeujevBYMDQ1RoUIFGBoaQl9fX67gE18bvxDM934HARF4HA5W9m2IgS2qgc/nIzY2FtHR0fjx4wd+/PiB6OhohIWFISgoCKmpOf09tLS0kKFhBN8oHrj6laBmYIpVwzthaLtaCnwyFPPlZ9soTjtPT29G0zeuUOEIwScuXjRagpb9pv10GwCAFweBC9MAEuQIAIfNQNPhpWOH+SIX75uz4Bp6FUIOB1wiLKnaBX07r//pNgDA+6s3XB+5QkhCcDlcLGmzBH1r9S0VO8yXkrVTXL4AJddcyERWPri5uWHt2rWIiIhAw4YNsWnTJvz5558F1hNdrG7duoHLld9nSXTqRds5HI646TG/RU1NTaFyoiU+Q4CoFCF+q2wAi0oG4uiaMkQkpiMoJg2WxlpyIyOiJs38xF94XDK+hcVCk9LAyUpDXFwc4uPjxa+JiYkSgo+IoKWlBUNDQ1StWhUNGzZEgwYNoGFoiu/xmfn6I4+UlBQEBQXh+btPePXhK9JiIxATGYasrCwQEQwNDVG9enVUr14dNWvWRI0aNVC5cuV8o30FnZuCKA4bxWknKtQfMcGfYGxRV+EIVknYAJATcYkLAAxrKBepKQk7zBe5REa+wveI5zCv3Aympo1LzQaQM+Lse/J3mOuaF6npqDjsMF9K1k5x+cJEVjlCdLHOnTsHY2NjaGpqQlNTE1paWuL/NTU1wePxJOoJBAJkZWWJO9JnZmZKvZe1KFIm9yIQCMT7zCv08sLhcAoUdcpuNzQ0hLGxcYERK5F/6enpiIuLQ0hICN69e4f3798jMDAQQqEQFSpUEAuvBg0awMLCQiG7+e0vPj4egYGBCAwMREBAAPz9/REREQEigoqKCqpVq4YaNWqIBVj16tWhqVl4QcNgMBiM0oWJrHKE6GKtXr0aRIS0tDSJvkXp6elIS0sTR2xyCx0iEr/yeDwJUSZLqOV9L6+MhoZGocSHUCgsUMQpKwTj4uIQHR0tPm41NTWYmZnBzMwMVapUEf9vZmYGfX39fEcvxsbG4v379+IlODhYnH5DJLyaNm0qc8BCYcjOzkZISIhYfAUEBCAwMBDp6TkpLoyNjcXiS/RasWJFNgKTwWAwyjBMZJUjRBdr9uzZMDQ0hI6ODrS1taGjoyPxf97XvM14AoFApjjL77289RkZGVL9rkRiTgSPx5Mp2pQRdLlFnaLCIiMjA5GRkQgPD0dYWBjCw8PFS2JizqglIkLVqlXRqVMndOrUqUDR9OPHD7Hw8vPzQ1RUFGrVqgVra2t07NgRhoaFyClUAESE2NhYsfgSCTGRoFRXV0f16tUlBJiFhQXU1NQKNs5gMBiMEoOJrHKE6GLdv38fHA4HKSkpSE1NRWpqqvh/Wa98Ph/A/5vucke4NDU15Yqzgl7V1NQUEjx8Pr9AAaeIyEtLS0NGRobUMYjeq6qqwtLSUiLiY2lpma/YICIEBQXh9u3buHPnjlg0WVlZoWPHjjA2Ns732IgI3759g4+PD+7evYu4uDg0bNgQ1tbW6NChA3R1dQs8P0UlIyMDQUFBEgIsODhYnATP1NRUfE5E5yX3wAkGg8FglAxMZJUjRBfL3t4eqqqq0NHRgZ6eHvT09KCrqyv+P/eSe72Ojo5Efy1Rv6SCRJq819yJUvOirq6ulGjL/b+WllahmsGysrIQFBQEf39/8RIUFITs7GxwOBxUrlwZNWvWFC81atSAvr6+hA2RaLp9+zbu3r2LmJgY1K1bVyy6ChInRIT379/Dx8cH9+/fR2pqKpo0aQJra2u0bdv2p/exIiJERkZKNEP6+/sjPj4n95W2traE+KpRowbMzc2l+vUxGAwGQ3mYyCpHiC5WbGwsKlSogLS0NKm5DZOTk2W+T0xMREpKSk4y0DyXhsfjyRVm8gRcfs12RISsrCyFomx5X1NSUpCeni7lY25f5Qk1c3NzNGzYUGYndaFQiMjISAkB5u/vj8TERGhqaqJXr17o2bOnTNH1+fNn3L59G/fu3UN8fDwaNGggbl4sKFIlEAjw6tUr3L59Gw8fPkR2djZatmwJW1tbtGjRolAjMouTlJQUBAYGSgiw0NBQCAQCcLlcVK1aVaovmCgvGIPBYDDyh4mscoToYnXv3l1KRHA4HOjr68PAwAAVKlSAgYGB3EVPT08iUsHn86XEmTzhJvpf1CE7L1paWgqJNNE6XV1dpYQGn8+XKd5SUlIQHByM9+/fIygoCEKhECYmJuIRgg0bNoSZmZlMYZiQkIBz587h3Llz4PF46NOnDxwcHGQKKFGk6s6dO7h+/TqMjY3h7OyMdu3aKRR9y87OxtOnT3Hjxg34+flBS0sLVlZWsLW1xW+//VamOrILBAKEhoZKRMECAgKQkpIzZ6WBgYGE+KpZsyZMTU2LNAqTwWAwfiWYyCpHiC7W+fPnYW5uDiMjIxgaGkJLSwtCoRDJyclISEgQL/Hx8RL/JyYmIiEhQZwzKnd/Jh6PJxZpspbcwk1XV1fmg1TU/JicnIzExESxIJMn4ETrBQKBROSKw+GAy+XmK85krc/dzEhE4k7qovQMYWE5k/CK8mKJBFjFiv+fYDguLg5nz57FhQsXoKamhr59+6JHjx7Q1taWeU0CAgLg6emJR48ewdbWFsOHD0flyopPJJqYmIg7d+7gxo0b+PbtG8zNzWFrawsbGxsYGRkpbKc0SEhIkGqGFKWkUFVVhYWFhVRKCg0NjdJ2m8FgMH4aTGSVI0QXa9WqVUhNTUVcXBzi4uLEGcdF8Hg8GBoaikWYvP+1tLTEdfh8PpKSkiREWl5xJnqflJQks8lRkSiagYEBdHR0Cox28Pl8pKSkyBVp8oSburo6/vjjD7Ro0QLNmzeXGi1IRAgLC8O7d+/ES3h4OPr37w8nJycJMRUTE4MzZ87g4sWL0NbWRr9+/dC1a1eJ8yZCIBDgxo0bOHDgALKzszF06FB0794dqqqqCl9fAAgJCcHNmzdx69YtxMfH448//oCtrS3atWsncx7Lskp2djaCg4OlUlJkZmaCiFCxYkWpZkhjY+MyFcljMBiMosJEVjkidwqHqlWromLFiuI59UT/q6vnTG0jynYeFxeH2NhYxMbGit+L1uXt+6SqqiohwuSJNFmdt/l8vpQYyyvYREtycrJ4v6JXVVVVhaJoIpEm72GckZGB169f49mzZ3j27BmioqKgra2NJk2aoEWLFmjWrJlUmoXMzEycPHkSR44cQf369TFx4kTUrCmZSfzHjx/w9vbGpUuXoK+vD0dHR3Tp0kVmZCYmJgaHDx/GpUuX0LhxY4wePRp169ZV7mIjpx/Z69evcePGDfj6+oLD4aB9+/awtbXF77//Xm4FCREhJiZGKgoWExMDIoKGhobMlBTKClYGg8EobZjIKkeILta9e/eQnp6OmJgYREdHIzo6Wvx/VlaWuDyXy4WhoaGUGMv9XldXV/ywzsrKQnx8vFiQyRNnojQKItTU1AqMmhkZGeUbicnKykJiYqJU5EyeSAMgIRDV1NRQr149dOjQAW3btpXoT5WSkoJXr17Bz88Pz549Q3x8PPT19dGsWTM0b94crVu3FoslPz8/uLm5ITExEWPHjoW9vb1U1C0yMhKnTp3C2bNn0bt3b4wdO1bmsRERnj17hn379iE4OBj9+vXDgAEDCp3WIT09HQ8ePMCNGzfw9u1bVKxYETY2NujcuTOqVCnC9CdljIyMDHFW/NwpKUSpSESjRHOPijQwMChdpxkMBkMGTGSVI0QXq0uXLtDR0UGlSpVgYmIic9HW1oZAIEB8fLyUEMstzpKSkgD8P4Gojo6OTDEm+t/IyEhqeL8o27pIhOV+zb0+MzNTIlGphoaGQpEzRZJqpgQH49XtO3gSEoyn798jOTkZtWvXRocOHdChQwdUqlRJonxCQgJevHgBPz8/3LhxA7169cLYsWPBS0hAVlAwEnW0ceDCBdy8eRM9evTAqFGjpB7kAoEAXl5e2L9/PwYPHowRI0ZAVVUV2ZGRyAoKhpqlBVRNc+a8SktLg7e3N44fPw4TExOMGzcOLVq0yDcaJctObn78+IFbt27h5s2bCA0NRd26dWFra4uOHTuKhVxBNhSlrNgRCoX4/uYNvjx5gpDMTIT8m6RVlFxWVkqKqlWrspQUDAajVGAiqxyR+2Kpqqrix48fiIqKkrmkpaWJ66mqquYryETRLCJCamqqlCjL/T42NlY8R6EwMxO8rCxUqloVJhYWUoJM9L+83FAZGRmI+vQJUe8/IFlTA0kcjoQ4E/0vSqoJ5ESHNDU1YWRkhAoGBqigqwdN/2/gXL+OOmpqqKKmDuNJE6FjZYUvAYF4+PwZfJ8/R3R8PMyMjdG2cWO0bdQIFiYmAAEQCsDPzsapW7dw4NgxWKelo6+eHtR4PFQYNgyaHdrj8qNHOHzxIipXqoTxg53we/16AI8HjooKODwesoVCHD59GsfOnkX/+vXx5/0H4BEBXC5MFi6EQb++OWKKywW4XHz99g0eHh548+YN+vbtCycnJ6noVsKpU4hYvAQQCgEuF5WXucLA0VHuZ0OUauLGjRu4e/cuMjIy8IeODn5/8gQN1NShwuMVaEMeyvqSn53AFZuQrmEEzYxYVF84XWk7BdmQl5JCKBSKU1KIR0IaV0EFLVNUqV4ROhUK3yE/JT4DCT/SYVBJs9B2isPGr+gLAEQGhCHscxCq1LGEaY3CRWyLwwYAJMfGID4iHBUqm0HXKP9ExSVth/lSsnaKyxcmssoRhb1YWVlZMgWZaJ2o+Q3IaWKsWLGiXEFmYGAADoeD6F27ELNlK7KEQiQIBMju+CdSq1ZFTFISYpOTEZuUhJikJMQlJSE9VxMmABhoa8NYXx96SUnQ/PwZFbg8GKqooEr79qhcty50AVBGOoRpaaC0dAjTRUsahGlpSE9JRXxKCuLT0pAoFCBBIECCQIgPGRkIy86GhZoq2mhpo5WWFnRyRTAis7PxPD0dz9PTEJadDT0uD001NdFZVxcVVVTAJ8KlpCScTUpEV1099NbXh1quSNO3zEwcTYhHeHY2euvrw1pHF6q5tmcJhTiVmIgbKckYoG8Ae11dcOVFqjgcZAK4kZKCS4kJMFVTwwDjimigrQ0CQHkGMwAAV08PHAXTI2Tx+Xj14wd801LxPiMDmlwuWmlqoW2lSrDU1FS4PxcJhRDm+nyI3dfVVdgXkZ1AgzYIqOEAcLgACWEa+QQVMkIBroJ9y4SEeI2qiDRt9X8bUU9Re1wf8PLkN5OFQCBAVHQEvocH4+2Lj3j36hNikyOQlZ0BnQrqMDYxgnkVC1Q1qwZzM0uYV6mGikYm+Z6r8K8J+Pw4Uvy+TmtTmNUyQE6VnHri6pxcL7lshn2Jx0ffiBzRzwHqtzND1boV/q37/3IcTs52Ts6fPOs5+P4hDm/vhort/N6pKqrVN8x5nwuZN+Z/b9ffP8bh7d0wsY2Gf1bJ8YXERXIi0QQQSGI9iHJsExD2JQGfHv//mOr+e16U5c2tawh95w2RoSr1e6FBJxulbLy/cwthH86JbdTvNBidR/VV2pf3d2/Bx3OXeB5Y61ET0KCjcr4Ulx3mS8nayWvDdtwU/G5tp7QvABNZ5YqSuli54fP5iImJkRshS0hIgDAzE2m+vgAAAy4PRio8GPNUYKSiAiMeT/xqwONJiQwhEZL+FWZxfD7iBQLECwSIEwgQL8h5nywQgkA5DxMA6lwOKvB4qMDjwZCn8v//VXiowFOBAY8nFjtEhJDsbDwSCvEkNQUZQiEaGxigvbExGhlUAI/HA4fHBThcJAgEeB4Xi6NBwWhhoA8nIUGNw0E2ES4kJeJCUhJ6WVigj4UlVIVCkEAAEgiQnJEB78hI3IqLhUtlMzTR1AT4fBCfDxAhQyjEsYQE3E9NwWCDCrDJp6O+iG+ZmTiZmIDArCzY6+qiq64etIox31SyQIAnaWl4lJaKkKxsVFZVQRstbbTR1obBT2hKy1A3gG/r5TniqIySlpmC2KRwRCdFIDY5HNGJEUhKjwOREDyuCgx1TGCsVxnGemYw1qsMI93KUFVh80OWFCRMRmbiHsiRhQzGT4PD5WLs9n2FimgxkVWO+BkiSxFSHz9ByMiREBIhQSBArECAGD4fSVWqIJ7LQXR6OmLS0pGQmQlhro+Bvro6KmpqwlhLE4ZCgl54uFiUGfJ44HE40LGzhXqNGuBqaoGrqQmulibSORzEZ2UjLjMDcenpiE1NRUxyCmKTEhEdGYmQS5fAFwrBAQettbVgrauHjg/uQ9XUFNnZ2Xjy5Ik4+aeenh6sra1hZ2cHS0tLADnC7PCuXdgxaxZGGxqivXZORvNsDgePxozGicuXMWzYMAwdOlQicWp8fDzmzJkDdXV1rFy5EhqpqfhmbZPTrAYgVSjEkYQEvK1dC9OmT0cXa+ucikIhIBSChASQ5P/paWk47uWFwxs2wFxVFQMNKqCWujrA5aLavr1QkTWXogwBx4+JQcjIUbnCDMixsd8TKsbGCA4Lw60HD3Db1xcJiYn4o0ED2LRrh7bNmkl04ufHxCBkxEgZdvbL9kUO399G4toV6QS2xhW50NRTLDVFelImYqKFUusrVdWAlqHiWejTU7IQFZAktd6khh40dWSLJr4gGz9iIxAZG4rI6FBExoQiLOo7UpJyIo46GgaoqG8GI93KqFO3FqpVtYCudoV/xbUoBJRLLhCBCMhIzUbM9xSp/RlV0Ya6luq/RXPV/zdUlPtyEAFZ6dlIiJI+vwYmmlDTyJXsN89nJffbrHQ+4iPTkBdDM22oa6n8W54jjqgBHHF9UTSNAyAjLRs/gqSjnybV9aCho/gI0YSIL4j6ekDh8gxGSTJg8UqYN2ikdD0mssoRZUVkZUdGSogJAACXi998bsntzExEiI+PF0fEwj5/xvslSxCbzUfsvxEsIQCt1q3BUVeHvr6+3CbLSpUqSQznF/UZyuDz8Sg9HU/q1EYkj4dWrVqhZ8+eaNasmTiSFB8fDx8fH1y/fh2BgYGoXbs2xowZg8aNGyP00CG4Tp+O0KwszKhkgharV8HA0RFZWVnYt28fTp48iVGjRmHw4MESHal9fHzwzz//YMaMGWiXni7Vf4lja4tNmzbhyZMnmD17NqxFYisfEk6dwp2/5+BEfBxCs/lwGjUSI9etUyqZp6J9qYRCIV6+fImbN2+KU0V06NABnTt3RqNGjZB4+nSR+2SlxGfgwLyHyN3OxQFh+Kp2CvfXKQ4bIjsH5/tKCBUOFxj+T9tC2REKCSkZiYhJCkdscgSqtlRBaEQIoqOjAUAiJYUoKauFhQXU1dWL3Zei2ClLvgA5/aiOzJsAyUgWBwNdN8PEUrF+VVFBYTi+ZFqRbABAclws9s+YIJk0mcvFyA07oWuoeNLg4rDDfClZO/JssEjWf4CyIrKA4ukMLc8GESExMVFux/7o6GjxpM/iEZE6OmhSrRp6OzmhQs2aEAqFePr0Kc6dO4cXL16gZs2a6NmzJ6ysrMSRGiLC169fsWTJEtStWxfz588HYmPx/v4DLPXch0bNm2Pu3Lni5KOZmZnYs2cPvL29MWbMGAwYMEAsttLT0+Hq6orw8HCs+vtvGKSmQc2imoTojI2Nxfr16/H+/XssWrQILVq0yPf8ZEdGIis4BFnGRjh9+zZOnTqF+vXrY/z48ahTp45C51hkI68v+ZGWliaRKsLY2BhWLVrgzxo1YdmieaFHF354GI47hz+BKCfy0WloXdRvZ/bTbYjtHPkEEuYIgE5DSs5Oenq6eOJyUVLWkJAQcWJWnkAD/BgtGOpUhrG+CboPaw+r3s2UnteyOI7pZ54XRbjmfgLvbh2CqD9VQ5thsB834KfbAIC3Ptdxw2M7SCgEh8uF7djJheqnUxx2mC8la6e4fAGYyCpXlCWRBRTuAV4SNlJSUhAZGYk7d+7gwoUL0NbWhqOjI7p27Soe2fj161ecP38ed+7cgY6ODrp3745u3brB0NAQRIRjx47B09MTGzduRMOGDUFEuHDhAjZv3oxJkyahb9++4mhYRkYGdu/ejatXr8LDwwNVq1YV+/LixQvMnTsXQ4cOxbBhw2T2xYqIiMDy5cuRkJAAV1dX1KpVS+Fjff78Odzd3REeHo6hQ4eiT58+CqW4KApRUVHiVBFhYWGoV6+eOFWEspNFp8RnIPFHOvSLOPqtqDbKih1RhPfDm8/48OYLohPCER4VKp6kGwBMTExQrVo1malVjIyMJMTYr3h+IwPCEP4lGGa1LYo0urCoNoCcEWcJkeEwMC366Lei2mG+lKyd4vKFiaxyRFkTWWWVqKgonD59GpcvX4ahoSEGDBgAOzs7sRiJiYnB5cuXcenSJaSlpeGvv/5Ct27dEBERARcXFzRt2hSzZ8+GiooKMjIysH79evj5+WHVqlWoX7++eD9fvnzBxIkTMXfuXHTu3Fm8ns/nY+PGjfD19cWmTZtQvXp1mX5++fIFS5cuhYGBARYvXgxTJURmUlISjhw5gjNnzqBp06YYO3asVJb6koCI8OnTJ9y4cQP37t1DZmYmWrVqBVtbWzRv3pzloypmRHNwhoSEyEw+HBsbK07SCgAqKiowNjYWizBDQ0NoaGhAXV0d6urqUFNTE/8vb1FTU4Oqqmq5nVGAwShLMJFVjmAiS3nCwsJw8uRJXL9+HZUrV8bAgQNhbW0t/vWfnp6O2bNnQ1tbG//88w94PB4OHjyIo0ePYvPmzeLpcEJCQjB37lyYmppiyZIl0P83ZUBaWhomT56MmjVrYt68eRLZ4b99+4bp06fD2toaLi4ucgXI06dPsXz5cjRp0gSzZs1S6toSEZ48eQJ3d3fExcVh+PDhcHBw+GlT0OQeWPDs2TPo6OigU6dOsLOz+ymijyFJdnY2YmNjxWIsLi4OmZmZEktWVpbUurzbc+emYzAYhSc7OxtXr15lIqs8wERW0QgMDMSJEyfg4+OD6tWrY9CgQejQoQN4PB6OHTuGQ4cOwd3dHVWqVEFoaCimTJmCDh06YOrUqWKBdOvWLaxcuRLDhw/HsGHDwOVyQUTw8PDAtWvX4OHhITE3IhHB09MTJ06cwNq1a9GokezRKUSEa9euYcOGDXBwcMD48eOVnhA6Pj4ehw4dwvnz59GmTRuMGTMGFhYWhT9hhSAxMRG3b9/GjRs34O/vj2rVqsHW1hY2NjZSc0YyGAzGrw6LZJUjmMgqPr58+YLjx4/j3r17cHR0xPjx4/H582dMmjRJ3PxHRNizZw/OnDmDrVu34rfffgOQ88tk+/btePDgAQ4ePAhtbW0AOf2lZs+ejbVr16J58+YS+4uIiMDMmTNRo0YNLFy4UO4oQaFQCC8vL+zbtw9jxozBoEGDpOZOLAgiwoMHD+Dh4YHU1FSMHDkS3bp1K5WmvODgYNy4cQM+Pj6Ij49HkyZNYGtri7Zt2yotIhkMBqO8wURWOYKJrOKHiODq6or4+Hhs2LABWVlZcHFxgbm5ORYuXAgej4egoCBMmTIF9vb2mDhxolj03L17FytXrsThw4dRsWJFAEBcXBzGjRsHW1tbjBs3Tqpfy9mzZ7Ft2zasXLkSrVq1kutXZmYmdu7cicuXL2PWrFmwtbUtVB+ZmJgY7N+/H1euXEHHjh0xevToUptMWpQq4saNG/D19QWPx0OHDh1ga2uLhg0bsj5ADAbjl4OJrHIEE1klx9GjR3Hy5Ens378fenp68PT0xLlz5+Du7o5KlSpBKBTCzc0N169fx9atW8WJTN++fYupU6di79694g7uQqEQq1evxtevX7Fjxw5xCggRcXFxmDFjBszMzLBkyZJ8IzqJiYlYv3493rx5g0WLFklFyBRFKBTizp072LNnD/h8PpydnWFnZ6d0lKw4SUtLw/3793Hjxg28e/cOlSpVgo2NDWxtbWFmpvxwfwaDwShrlNhzmxjFTmJiIgGgxMTE0nbll8TX15dsbGwoMDCQiIhev35N1tbWdP/+fXGZr1+/UteuXcnd3Z2EQiEREQUHB5OVlRW9ePFCwt7NmzfJxsaGPn/+LHN/3t7eZGNjQ8+fPy/Qt/DwcPrrr79oyJAh9PXr10IeYQ4RERG0cuVKsra2ppUrV1JkZGSR7BUXkZGRdPjwYRo5ciTZ2dnR1KlT6eLFi5ScnFzarjEYDEahKKnnNotklQAsklXyBAcHY/To0Vi2bBnatm2LpKQkTJw4EX/88QdmzZoFDocDgUCAzZs34+3bt9i7dy94PB5iY2MxdOhQzJo1CzY2/5+MNCwsDGPGjMGYMWPQr18/qf3FxMRg2rRpqFmzJhYsWFBgzitR2ocKFSpg8eLFMDExKfSxCoVC3LhxA/v27QOPx8Po0aNhZWVVqtEtEUSEjx8/4saNG7h79y6ysrLQunVrliqCwWCUK1hzYTmCiayfQ1JSEkaNGoV+/frByckJRAQ3NzfcuXMH7u7uqFChAgDAy8sLt27dgoeHB7hcLtLS0jBixAj069cPgwYNEtvLzs7GnDlzwOFwsHr1apnpFU6cOAEPDw+sX78ef/zxR4E+PnnyBCtWrEDTpk0xa9Ys6OrqFumYw8LCsG/fPty5cwddu3bFyJEjYazE3IQlTVZWllSqCCsrK9ja2qJmzZqsPxeDwSiTMJFVjmAi6+chEAjE4mXp0qXgcrnw8/PDnDlzsGbNGvGUOPv378ejR4+wc+dOcLlc8Pl8TJ48GXXr1sW0adMkbJ48eRKenp7Ys2ePzD5HUVFRcHFxwe+//445c+YUmOuKiHD16lVs3LgRPXv2xPjx44uc/V0gEODKlSvw9PSElpYWxo4diw4dOpQ5EZOQkCCRKsLCwoKlimAwGGUO1ierAAIDA8nZ2ZksLS1JQ0ODatSoQYsXL6bMzEyJcsiZGEti2blzp0SZN2/e0J9//kkaGhpkZmZGrq6u4n49isD6ZP18du7cSUOGDKG0tDQiIoqLiyNHR0favn27+Nrt3r2bJk+eLH4vFAppyZIl9Pfff5NAIJCw9+nTJ7K2tqaHDx/K3J9QKKTDhw+TnZ0dvXv3TiEf+Xw+HTx4kKysrMjLy0tqn4UlODiYFi1aRDY2NrR582aKi4srFrslQWBgILm7u9OgQYOoS5cuNG/ePPLx8aGMjIzSdo3BYPyHKann9i8jsq5cuUIjR46ka9eukb+/P507d44qVapEM2fOlCgHgDw9PSkiIkK8iB7MRDkn2sTEhAYNGkRv376l06dPk66uLq1fv15hX5jIKh1u3LhB9vb2FBERQUQ5QmjNmjU0ZcoUsbDatm0bzZgxQ0I079y5k0aOHElZWVkS9hITE8nR0ZHc3d3l7jMsLIz69etHq1evpuzsbIX8TE9Pp40bN1Lnzp3p2rVrSgn4/MjKyiJvb2/q3bs3jRw5knx9fYvNdkkgEAjo2bNntGrVKnJwcKDevXvThg0b6M2bN2XabwaD8evBRFYhWLt2LVWvXl1iHQA6c+aM3Dpubm6kr68v8ct61apVZGZmpvCNv6yJrKyICEp59Jiy/hUfvzIfP34kKysrev36tXjdqlWrJETyhg0baO7cuRLXUyRO8o6QEwgEtHjxYpo0aZJUVFSEUCgkT09Psre3p48fPyrsa0JCAs2fP5969uxJfn5+CtdThG/fvtGcOXPI1taWduzYofRnMTshg9K/xVN2QuEjTMraSE1NpatXr9LMmTOpS5cuNGzYMDpw4ACFfAossi+F8aekbPyKvhARxX7/QZ8evKHY7z9K1QZRzncrICCAEhISSt0O86Vk7RSXL2x0YSFYuHAhrl69imfPnonXcTgcVKlSBRkZGahevTpGjx6NcePGiUdqDR8+HImJiTh37py4zsuXL9G0aVMEBATInUQ4N2WpT1bCqVOIWLwEEAoBLheVl7nCwNGxVH0qaWJiYjBixAj89ddf6NGjB4gIf/31F2xtbcUjB1etWoXMzEwsXbpUXO/BgwdYtmwZDh8+jEqVKknY9Pb2xt69e+Hp6Sm1TcT379/FU/xMmzZN4ZF14eHhWL58OZKTk7F06VJxxvriICsrC2fOnMGRI0dgamqK8ePHo1mzZvnWSbodgqRrweL3mk0rQd1Suc9xZlAS0l/8+L+NJsrb+BEbjetXrsPnjg+iU+NQ06gaOtt0hlUXG2hrahVsIK8/L//vj1bTSlCvrg9wAIDz72vOv+BwxKtzb8/0T0Dqk0ixDe3WlaFRu8L/6/z7mrceJ/c6DgfpH2ORcjc0p7MCB9DpWBWa9Y1yjOa9G+e9Pf/7Nv1jHFLu57LR3gwatQ0ByukDCAIg/Pc158e0+P+cMjnbMwMSkfY8Svq8KMnzF89xO9wPxAE4BHSs3FyhgSG5ef36Ne5GPBPbsG7YHq16/am0L69evcKVK1dAROBwOOjatSsaN25cKnaYLyVrJ68NBwcHNG3aVGlfANbxXWn8/f3RtGlTbNiwAWPGjBGvX7FiBWxsbKCpqYlbt25h8eLFmDdvHhYuXAgAsLOzg6WlJdzd3cV1wsPDUaVKFfj6+qJNmzZS+xJN2CoiKSkJ5ubmpS6ysiMj8c3aJkdgieBy8ZvPLaiampaaXz+DzMxMTJo0CfXr18f06dPB5/MxYMAAzJkzB61btwYAuLq6QlVVFfPnzxfXe//+PaZMmQIPDw+piZPfvXsHFxcXrFu3Tq5QoX/nRzx79iy2bNmCWrVqKezz58+fsXTpUhgZGWHRokVFSvsgz767uzvev3+Pfv36YfDgwdDR0ZEow0/MROSqp8W63+KAiPA1Nhj3g/zw5PtrZAv4aGJWHx0sm6ORaR3wuCxVRGmRigwcU38IKltjLhj/QTgcDqZNmwZ9feV/KPxnRdbSpUvh6uqabxk/Pz+JDNvh4eHo2LEjOnbsiD179uRbd8OGDVi2bBkSExMB5Iis6tWrY/fu3eIyYWFhqFq1Kh49eiR+QCviY2mLrNTHTxAycqTU+moHDkC7Vcuf79BPhoiwZs0apKSkYMWKFUhKSkK/fv2wa9cu1KxZE0SEBQsWwMjICDNnzhTX+/79O0aOHIl169ZJ/SqKi4uDs7Mz+vfvjyFDhsjdt2iKHzs7O0yaNEmpnFaPHz/GihUr0KxZs2JJ+5CXjIwMnDp1CkePHoWFhQXGjx8vjjpk+CcgxuOtVB1VCz3wtPMfRSlCkJqN7OCkItkoyI5AnfDs2xvcfe+L10EfoKOhjfb1WqJjgzaoblJNMTvmuuBpqQDIFTAS/SN6L8z5R5DGBz8yVcqGSkVNcNR5/68jFNUn/H+YDYntCbP4ECZlS9nh6qqCo/qvHY7ES050LBfCbAGEiVlSNniGGuBq8MTRtP9H0DiS0TZuznthOh/ZoSmyz4sS1ykkPhznEx8qXJ7BKElGjBihUItTXv6zIismJgYxMTH5lrG0tBRP5BseHg4rKyu0atUK+/fvL/Dh9vDhQ7Rv3x6RkZEwMTEpVHMhi2SVbaZOnYpOnTqhT58+YgF18uRJGBoagogwe/ZsWFhYYMqUKeI68fHxcHJywrx58/Dnn5JNFnw+H/PmzQMArF69Wm6zoFAoxK5du3DlyhVs3bpVqS8+lUDaB1m8f/8eu3fvxrdv3zBw4ED0te+FxC1vJZutOIDp3JZQ0Vdsomh+YiYiVz8tkg1l7cTHx4tTRQQEBMDS0lKcKkKXq1Vkf0rjmMqDLwAQFxqNbR47JCJZHAImjBqHCmaK5XCLD4/BLk/3ItkAcu69O3bsQO7HGofDwaRJk5S6FxeHHeZLydqRZ4NFskqQsLAwWFlZoVmzZjh8+LBCfWK2b9+O2bNnIyEhAerq6ti5cyfmz5+PqKgo8UNtzZo12Lp1K0JDQxXKQ8T6ZJUtsrKy0Lt3b2zevBm1a9fGy5cvsWjRIpw+fRrq6uogIkydOhUNGzbEuHHjxPVSUlIwZMgQ/PXXX+jSpYuU3SNHjuDUqVPYu3dvvjmf/P394eLiAgcHB4wfP16pXFYCgQBeXl7w9PTE2LFjMXDgwBLJ9J6Wlobjx4/j5MmTsNQzg6NuR9Q2sgQ4QIW+taDdQjlRnuoXiXjvr+I+Q4WxURQ7gYGBuHHjBm7fvo2EhAQ0NK2Nlpk10dSsAdRV1crlMZVVXwDg0enbuP7mrrg/lV2jjmjTz+qn2wCAFy9e4MKFC0Xup1McdpgvJWunuHwBWJ6sAgkLC6PffvuNrK2tKTQ0VCJFg4jz58+Tu7s7vX37lr59+0YeHh6kp6dHLi4u4jIJCQlkYmJCgwcPprdv35K3tzfp6emV6xQOWRERlPL4yX9idKE8QkNDycbGhlJSUoiI6NKlSzR8+HDxCEOBQEATJkygffv2SdRLT0+nAQMG0MmTJ2XaffbsGVlZWdHbt2/z3b9AIKBNmzZRz549KTg4WGn/RWkfbG1t6fr160rXV4aXL1/S+NHjqKuVHR302F/oHFZlZfQbn88nPz8/WrF4GXW37kK9uvekjRs30tu3b5VOFVFWjqms+ULERhcyX0rHTlkfXfjLiCxPT0+ZiUZz68grV65Q48aNSUdHh7S0tKhhw4a0efNmqfxGb968oQ4dOpC6ujqZmprS0qVLWTLSX4Dbt2/TsGHDxNfSzc2NFi1aJN4uEAho9OjRdPjwYYl6WVlZNGLECCkBJiIqKoq6detG3t7eBfrw+fNn6tKlC+3Zs6dQuaByp3149uyZ0vWVISkpiXbv3k12dnY0c+ZMuRNolzdSUlLoypUrNGPGDLK3t6fhw4fTgQMHKDw8vLRdYzAYpQRL4VCOKEvNhQxJ1q9fD3V1dXH/q9mzZ6N+/foYNWoUgJzmuVGjRsHBwQH9+/cX1xMKhXBxcUGtWrUwdepUKbtZWVmYMWMGjIyMsGTJknyb9AQCATZt2gRfX19s27YNVapUUfo4SjLtQ16ICM+ePYO7uzuioqIwdOhQ9O7du0T6iJUGkZGRuHXrFm7evInw8HDUr18fnTt3RocOHdj3l8H4j8D6ZJUjmMgquxARhgwZgsmTJ6Nt27YQCoUYOnQoRo8eDRsbGwA5HduHDx+OgQMHolevXhJ158+fDy0tLSxcuFBm36o9e/bg+vXr2LNnT4HX/sOHD5g+fTqGDBmCYcOGFWrewZJO+5CXxMREHD58GGfPnkXz5s0xbty4Qo3kKasQET5+/IibN2/i/v37SE1NRePGjWFtbY22bdtCS0u5/FwMBqN8wERWOYKJrLJNUlIS+vTpAy8vL5iYmCA9PR19+vTB+vXr0bBhQwBAdnY2Bg8ejIkTJ8La2lqi/urVqxEbG4u1a9fKFEa+vr5YtGgRdu3aVWCeLD6fj7Vr1+Lly5fYtm0bTAs56lOU9qF58+aYOXNmsad9yAsR4dGjR/Dw8EBCQgJGjBiBHj16QEVFpUT3+7MRCAR4/fo1fHx84Ovri6ysLDRv3hzW1tZo1aoV1NUVH4XHYDDKLkxklSOYyCr7fPjwAXPmzMGZM2egoqKCHz9+YNCgQThy5AgqV64MIGfEXf/+/bF06VK0aNFCor6bmxvevn2L7du3yxzFGhYWBmdnZ0yfPl3myMS8vH37FjNmzICzszMGDRpUqKgWEeHKlSvYuHEjevfujXHjxv2UJr24uDgcPHgQFy9eRNu2bTFmzBhUq1at4IrlkOzsbDx//hw+Pj548uQJiAitW7eGtbU1mjdv/suJTAbjvwITWeUIJrLKB8ePH8ezZ8+wbt06ADlNby4uLvD29oa2tjaAnOYxR0dHbNmyBfXr15eof+jQIVy/fh379u2Dqqp08saMjAxMmjQJtWvXxt9//12gcMrOzsaqVavw8eNHbNmyRe70PQUhEAhw5MgRHDhwAGPHjsWAAQNKJO1DXogI9+7dw549e5Ceno5Ro0ahS5cuCk8vVB7JzMzEkydP4OPjg2fPnoHD4aBmzZqoV68e6tevj3r16sHYWPE8TwwGo3RgIqscwURW+WH69Olo3769eE7De/fuYfv27Th69KhYHERFRWHw4MHw9PSEhYWFRP0zZ87Ay8sLBw8ehKamppR9IsLWrVvx7Nkz7N69W6E+PS9fvsTs2bMxYcIEOBYhp1lGRgZ27tyJq1evYvbs2ejcuXOhbSlLdHQ09u/fj6tXr8LKygrOzs4wMzP7afsvLfh8PgIDA/Hx40d8/PgRHz58QGxsLACgatWqEuKrSpUqhYpYMhiM4oeJrHIEE1nlh+zsbPTq1QsbN25E3bp1AeQkGfXz88PmzZvF5YKDg+Hs7Czux5WbGzduYOvWrfDy8pLbF8rHxwerVq2Ch4cHLC0tC/QrKysLy5cvR1BQEDZv3gwjI6NCH2NiYiLWrl2L9+/fY/HixYVO1lcYhEIhfHx8sHfvXhARnJ2d0blz558SWStLEBFCQ0MlxFd4eDiICMbGxqhVqxYMDAygq6sLPT09iUW0TktLi4kyBqOEYCKrHMFEVvkiIiICQ4cOxblz58QTJq9YsQJ6enpwcXERl/v48SNcXFxw8uRJGBgYSNh4+PAhli9fDi8vL7nZ3wMDAzF27FgsXLgQnTp1Usg3Pz8/zJ07F1OnTkXPnj0LdXwiwsPDsWzZMqSmpmLp0qVSE2CXNBEREfD09MStW7dgZ2eHUaNGFbpJ9FciOjoa/v7+SExMRHJyMpKSkqSW5ORkpKbmzJ0oumVzOBxxpmsGg1E0srOzcfXqVSayygNMZJU/7t+/j927d+PQoUPih9eoUaMwePBg2Nvbi8v5+flh6dKlOHnypFTTn6iZ7/Dhw3JHCaampmLcuHFo06YNJk2apNADMiMjA0uXLkVUVBQ2btyIChUqFOlYP336BFdXV1SsWBELFy786UJHIBCI+7KpqalhzJgx6NSpExMLDAaj1GCRrHIEE1nlk40bN4LL5WLatGkAcsRN7969sWXLFtSpU0dc7vbt29i+fTuOHTsm1eH906dPmDhxosz+WyKICKtXr0ZAQAC2b9+ucBqAR48eYeHChZg1axa6du1auIPMhSjtQ4sWLTBjxowST/sgi9DQUOzduxf3799Ht27dMGLEiCI1jTIYDEZhYHMXliPYtDrlE6FQSE5OTnTv3j3xuvDwcLK2tqa4uDiJsmfOnKFhw4aRQCCQshMYGEhWVlb06dOnfPd38eJFsre3p7CwMIV9TEtLoxkzZtDYsWOLPFcXUc4xX7p0iTp37kzbt2+nzMzMItssDNnZ2XTu3Dnq06cPDRs2jO7fv1+oaYcYDAajMLC5C8sRTGSVX5KSksja2lpiHjs/Pz/q1auX1ByXnp6eNHnyZJliIDw8nGxsbOjVq1f57u/Tp09kbW1Njx49UsrPe/fukZWVVbFNFs3n8+nAgQNkbW1NR48elSkefxaBgYE0f/58srGxoa1bt1J8fHyp+cJgMP4bsLkLyxGsubB88/HjR8yaNQtnz54VNwceP34cjx8/xqZNmyTKbt68GXFxcVi2bJmUnbi4OAwePBhLly5FmzZt5O4vMTERY8aMQdeuXeHs7Kywn6mpqZg3bx74fD7WrFlTLM19GRkZcHNzw9WrV/H333//1LQPecnOzsb58+dx8OBBGBsbY9y4cWjZsiXru8VgMIod1ierHMFEVvnn1KlTePz4MdavXy9et3DhQlSvXh2jR4+WKLto0SIYGhpi+vTpUnaSk5Ph5OSEqVOn5itYhEIhlixZgsTERGzYsEFmclN53LlzB8uWLcOiRYtgZWWlcL38SEhIwNq1a/Hhw4efnvZBFt++fYO7uztevXqFvn37YsiQIaXSh4zBYPyaMJFVjmAi69dAJIwcHBwA5AghJycnTJo0CR06dBCXIyK4uLigefPmGDFihJSd9PR0DB06FMOHD5eYcFoWp0+fhqenJzw9PVGxYkWFfU1OTsacOXOgqqqKlStXijPWF5WwsDAsW7YMaWlppZL2IS+ZmZk4c+YMjhw5AjMzM4wfP77UBSCDwSj/sI7v5Yiy1icrOS6dvn+Ko+S49NJ2pVyRkZFBtra2FBISIl6XnJxMnTt3psDAQImyAoGAhg0bRmfOnJFpKzMzk4YOHUqHDx8ucL9v3rwhKysrevHihdI+X79+naytren+/ftK181Neno4xcb5Unp6Tt+0jx8/0oABA2jy5MkUFRVVKBvF5YuIDx8+0LRp08je3p727NlDKSkpJe5PcR1TWaK4jikg4TtdDn5MAQnfS9UGEVFYeibdj0uisPSiDeQoDjvMl5K1U1y+sD5Z5YiyFMn68DAcdw5/AhHA4QCdhtZF/Xa//vQmxcW3b9/g4uKC8+fPiyf/DQoKwtixY3HmzBlx8lIgpw/RoEGDMGnSJFhbW0vZEggEmDhxIpo0aYIJEybku9/Y2FjxZNGDBw9WyufExETMmjULenp6WLFihczpfvIjPPwEPn5aAEAIgIt6df+BmdkAADlpJFasWIGWLVvmm/YhPxvF5YuI9PR0nDx5EseOHUONGjUwfvx4/P7778XuT3EdEwBkZEQgLT0IWpqW0NCoXGo2iuuYdny4ihWRlUAcLjgkxByTaIytq1x/Po9PN7EmqmKRbADAiYg4LPga9u8RAf/UqoIBlWUnCC5pO8yXkrWT18b6OuZwMitcChjWXFiOKCsiKyU+Awfn+yL3FeZwgeH/tIVOBY1S86u8cezYMbx9+xb//POPeN39+/fFcxzmniImLS0N/fv3h6urK5o3by5li4gwa9YsVKpUCXPmzMl3v3w+H3PnzgWPx8PKlSuVnmj58uXL2LBhA/755x+0bt1aoToZGRF46NsBQO7bAgdGRlbg8TTFx3DvXiAOH3oNG5sa6OfYAKqq//dNIEhHbOxtKdu5bShCYex8+RKDUyffIzQ0CV261oKd3W9QVc2WYYeDisa24KlogQNuzhcDHHDAAThccMTvuQCHAwE/HRGRp6TOS9Wqw6Gqoi+uwwEvp2M+hwcOh/evvf//z+HwkJD4DBER3v/a4qBy5X4wMGiRyzQBIBAI///y/vseAIiQkPgcUVHnxTYqVeoKPd3fQSQEER8EIYgEIBIA/74SCUD4//98fgp+/LgkdV6MjTsrdZ0is7gYFj8ExPlvTZXEKHvwAPi1qQ8zDTWl6zKRVY4oKyIr9HM8zm16KbW+9/QmqFKnaFnD/2tMmDABffv2hZ2dnXjd3r17ERQUhOXLl0uUTUhIQP/+/bF161bUq1dPyhYRYfny5cjMzMSKFSsKHC136NAhnDlzBnv37lU623t8fDxmzJgBExMTLF26FBoa+YvruPhHePlyqEK2BQLCrZspuH49Gd176KFjR21wuWVj5F96uhB3bqfg3r1UmFdTRY8eeqhWTfkbL6Ng3qMhVnJcS9sNBgMAcLpxTbSroPygGCayyhFlRWSxSFbxkZaWhp49e+LQoUOoXPn/TTPTp09Hq1atMGjQIInyUVFRGDx4cL6Z3zdv3oyAgABs3ry5wAmTnz17hjlz5mDbtm2oX7++0v6fO3cO27Ztw+rVq2VG2ETkRLL+RE7zkQgOqltOhapqns/yv+IwIyMLBw/cwt27b/HXxO5o1cocgYGbkTfqU736NKiq6ivsc3Z2YrHYefnyHTzcdyEmhg8bGx20a68NNTUuLC0nQUVFByBR1EgIgvDfV0i8z+YnIyzssJQvpqZ9wONp/hsxylWfhP9GjUT2cv7PyopFUpL0Dx89vT+gqloBAOdfy5x/zy8n195y1mVlxSEx8ZmUjQoV2kNDwzQnasbh/RtVy1lyIm2513MhEKQjOMRd6pgsLSdDVUXx+1ZYRib6hraSiGRxSYAjZn4wK0DUiwjPyIBTeEspGzebVIKFnuLdGyIys/Hnk08Sn14ugHut6qKyuuIjdovDDvOlZO3IssEiWf8RyorIAv7tk3XkE0iYI7A6DWF9sgrLx48fMWfOHJw5c0bcdMfn8+Ho6IiFCxdKiZegoCCMHj0aR48elTs/4L59+/DgwQO4u7uL+3zJIyoqCs7Ozhg3blyBoxRlERsbi2nTpsHS0hKLFi2CmprsG1Fh++kkJCRgzZo1+PjxI/76qzVUVPcqbaO4fJFl59nzefDxScKD+6lo2bIzZszYiN9+++2n+iJbxHLRru09hftVFYcNEcV1ft0+XMWKyIoQcnjgkgALTaMxsX6Xn24DALzCYzH783cIkPPQXVfIfjrFYYf5UrJ2issXgImsckVZEllATkQr8Uc69CtpsghWETlw4ACCg4OxePFi8br4+Hg4Ojri8OHDElEuAPjw4QOmTp2KU6dOQV9fdvTlxIkT8Pb2xoEDBwqcxzArKwvTp09HpUqVsGjRogIjYLI4deoUdu/ejXXr1qFx48Yyy2RkRCA9PRiamhZKP7hFaR+Sk2Mxe/Zg1KvXttAds4vqiyw7GhrV8PZtKNzd3RETE4OhQ4eiV69eCuUmKw5fymIn/OI4v4GJofiSGI7a+maorl+11GwAQHhGFgLTM1FdU71QUY3itMN8KVk7xeULE1nliLImshjFi7OzM4YPH45OnTqJ133+/BlTp07FmTNnpEbzPX36FK6urjh58iS0tLRk2rx8+TLc3d1x5MgRhXJcubu7w8fHBx4eHoVKyvnjxw9MnToV9erVw7x585RKfqooHz9+hKurKypVqoSFCxfKjeaVJgkJCTh8+DDOnTuHli1bYuzYsbC0tCzx/RaHsCkuccRgMFierHJFWcuTxShekpOTydramn78+CGx/urVqzRixAiZcxneunWL+vXrR1lZWXLt3rlzh7p27arwXH0PHjwgGxsb+vr1q1L+ixAKheTl5UW2trb09u3bQtlQBF9fX+rWrRstXbqUkpOTS2w/RUEoFNKDBw9oxIgR1KdPHzpz5ky+14rBYPxasDxZ5QgWyfr1efPmDZYuXYpTp05JNNlt3rwZmZmZMtMznD17FmfOnIGnp6fcZj4/Pz8sWLAAR44cUSjje2hoKEaPHo0ZM2bA3t6+UMcSERGBqVOnokmTJpg9e3aBfcMKAxHh0qVL2Lx5M/r06YOxY8fK7RNW2sTGxuLw4cO4dOkS/vjjDzg7O8scJcpgMH4dSuq5zRKbMBiFoFGjRrC3t5eY2xDImYrH398fFy5ckKrTu3dvdOrUCdOmTYO83zYtWrTAxo0bMWjQIISGhhboR9WqVXH27FkcP34c69evl2s3PypXrozjx4+jatWq6NGjBz5+/Ki0jYLgcDjo0aMHrl27Bh0dHXTp0gXHjx+HUCgsuPJPxsjICFOnTsW1a9cwaNAgbN++Hd26dcOePXuQlJRU2u4xGIxyBItklQAskvXfgIgwbNgwTJw4EW3bthWvz8zMRJ8+fbB27Vo0bNhQqt7GjRuRmJgIV1f5uYX8/f0xduxYeHh4KDRfIBFhy5YtePnyJXbu3Cm371dBhIWFYcqUKWjXrh2mTZumdAJURcnIyMCOHTtw/fp1/P3337CxsSmR/RQX6enpOHPmDI4fPw5DQ0OMGjUKHTp0KDDHGYPBKB+wPlnlCNYn679DQkICWVlZUWxsrMT6qKgosrKyoujoaJn1FixYQJs3b87X9vfv38na2lqp/lI3b94kW1tbCg4OVrhOXoRCIe3Zs4e6du1KX758KbQdRYiPj6e5c+dSr169CjVXY2kQEBBAixcvJhsbG1q5ciWFhoaWtksMBqOIlNRzm4msEoCJrP8Wfn5+1L9/f6kO769evaIePXrI7EAtFApp0qRJdODAgXxt//jxg2xtbenp06cK++Pv70+dO3emu3fvKlxHFsHBwdSzZ0/avHkzCQSCItkqiNDQUBo7diwNGzaM/P39S3RfxQWfz6fr16/TkCFDqG/fvnT69GnKzCzaJLUMBqN0YB3fyxGsufC/x5YtW8DhcODi4iKx/syZM7h58yZ27NghVUcoFGLEiBFwdHTMN7loYmIiBg8ejDlz5qBjx44K+ZOamopx48ahbdu2mDhxYqGbtYgI7u7uuHDhArZu3YoaNWoUyo6iiNI+mJiYYOHChQp1/i8LxMXFwcvLC1evXoWKigpatWqFP//8E82bNy8w9xmDwSh9WHOhAlhYWOTMrJprmTNnjkSZ4OBg6tGjB2lpaZGRkRFNmTJF6tfnmzdv6M8//yQNDQ0yMzMjV1dXmcPy5cEiWf89hEIhDRgwgPz8/KS2LVu2jHbs2CGzXmZmJvXp04du376dr/2UlBTq1asXXbp0SSmf/vnnHxo7dixlZGQoXE8WAQEB1KNHD3JzcyvxqBbR/9M+LFu2rMymfZBHeno63b17l5YvX049e/akHj160OLFi+nmzZuUkpJS2u4xGAwZsOZCBbCwsKBly5ZRRESEeMl9g+bz+dSwYUOysrKiFy9e0I0bN8jMzIwmT54sLpOYmEgmJiY0aNAgevv2LZ0+fZp0dXVp/fr1CvvBRNZ/k9jYWLKysqKEhASJ9UKhkIYMGUI3b96UWS81NZW6du0qU6DlJiMjgwYNGkTHjh1Tyq8LFy5Qly5dKDw8XKl6eREIBLR161bq2bMnBQUFFcmWIgiFQrpw4QLZ2NjQjh07ym3eqqysLHry5AmtW7eO+vbtS127dqW///6bLl68qHBONAaDUbIwkaUAFhYWtGnTJrnbL1++TFwul8LCwsTrjh49Surq6uIT6+bmRvr6+hK//FetWkVmZmYKR7OYyPrv4uvrS0OGDJH6rKSmppKtra3cxKHx8fHUuXNn+vDhQ772s7OzydnZmfbs2aOUXx8/fiQrKyt6/PixUvVk8fXrV+rWrRt5eHgoFeEtLHw+nzw9Pcna2pqOHz/+U/ZZkvD5fHr16hVt3bqVBgwYQPb29jR+/HhasmQJbdu2jY4dO0a3bt2iN2/eUHh4eLkVlwxGeYL1yVIAS0tLZGZmIisrC+bm5ujfvz9mz54tTnq4ePFinDt3Dq9fvxbXiY+Ph6GhIXx8fGBlZYXhw4cjMTER586dE5d5+fIlmjZtioCAAFSvXl1qv5mZmcjMzBS/T0pKgrm5OeuT9R9l7dq10NfXx/jx4yXWh4aGYsSIEfD29pY5j2FUVBQGDx6M/fv3o1q1anLtC4VCTJs2DdWrV8f06dMV9isxMRGjR49G9+7dMWrUKMUPSAYCgQBbtmzB/fv3sW3bNlStWvh55hQlPT0dO3bswI0bNzBnzhxYW1uX+D5/BkSE0NBQ/PjxA9HR0YiJiUF0dLR4iY2NRXZ2trg8j8eDkZERKlasCENDwxJLs8Fg/JfIyMjAwoUL2dyF+bFp0yY0bdoUFSpUwNOnTzFv3jz06tULe/bsAQCMGzcOQUFBuH79ukQ9dXV17N+/H4MHD4adnR0sLS3h7u4u3h4eHo4qVarA19cXbdq0kdrv0qVLZeY8YiLrv4lQKISjoyOWLl2KRo0aSWx7/Pgx1q1bhxMnTsh8OAYFBcHZ2RnHjh3Ld64/IsKiRYugqqqKxYsXK9yxXSAQYMmSJUhJScG6deuKPGfhp0+fMH36dAwaNAjDhw//KXmj4uPjsWbNGnz+/BlLliyRO8n1rwqfz0dsbCxiYmIQFxdXJhO6MhjljdTUVHTv3v2/1/F9yZIlUp3Z8y7y+rKcOnWKAFBMTAwREY0dO5bs7OykyqmqqtLRo0eJiMjW1pbGjRsnsT00NJQA0KNHj2TuJyMjgxITE8XL9+/fWXPhf5wfP36QtbW1zE7bBw8epFmzZsmt++7dO7K1tZXq2yWLNWvW0IwZM5RuQjtx4gT16NFDbh4vZcjOzqbVq1eTo6Njkft9KcP3799p7NixNHz4cAoICPhp+2UwGL8eJdVcWOan1Zk8eTI+fvyY7yIrqzYAtG7dGgDw7ds3AICpqSkiIyMlysTHxyM7OxsmJiZyy/z48QMAxGXyoq6uDj09PYmF8d+mYsWKWLx4sVRKBwAYNmwYuFwuDhw4ILNugwYNsGLFCgwZMgTp6en57ufvv/9G7dq1MX78eAgEAoX969+/P/755x8MGDAAr169UrieLFRUVDBnzhwsXboUI0eOhJeXV6Gm91GWqlWrwt3dHXPnzsXcuXMxdepUREdHl/h+GQwGQ2GKVbKVMS5cuEAAxNmvRR3fc//aPnbsmFTHdwMDA4m0DqtXr2Yd3xmFwtXVlfbv3y+1ns/nU79+/cjX11du3Zs3b1K/fv0U6vh85MgRcnJyUjoZZkxMDDk4OCg9YlEeWVlZtHz5cho4cCBFRUUVi01FefjwIXXt2rVcpn1gMBilCxtdWAC+vr60ceNGevnyJQUEBNDx48fJzMyMevbsKS4jSuFgY2NDL168oJs3b1LVqlUlUjgkJCSQiYkJDR48mN6+fUve3t6kp6fHUjgwCgWfzycHBweZowYTExPJ2tqaQkJC5NY/ffo0jRgxQqHcVOfOnaO+fftSWlqaUj5mZ2fT9OnTac6cOcTn85WqK49Xr15R586d6cSJE8ViT1GEQiGdP3++3Kd9YDAYPxcmsgrg+fPn1KpVK9LX1ycNDQ2qU6cOLVmyhFJTUyXKBQcHU/fu3UlTU5MMDQ1p8uTJUoka37x5Qx06dCB1dXUyNTWlpUuXsmSkjEITHh5ONjY2Up9FIqJv376Rra1tvkkq9+7dSy4uLgp9Bm/evEndu3cv1GfvwIED1KdPn2LL3ZSZmUmLFy+mIUOGFEvfL2Xg8/m0d+/eXybtA4PBKFmYyCpHMJHFyMu1a9do/PjxMrf5+PiQk5NTvkJg/fr1tGTJEoX25evrS3Z2duIBH8rw9OlTsrKyKjBflzI8e/aMbGxs6MyZM8VmU1HS0tJo7dq1ZGdnR7du3frp+2cwGOWD/2zHdwbjV8DOzg5GRkY4evSo1DYrKyu0b98ey5cvl1t/5syZyMrKwtatWwvcV5s2bbB27VoMGDAAERERSvnZokULeHl5YebMmTh//rxSdeXRrFkzXLp0CU+ePMHIkSMRFxdXLHYVQVNTE7Nnz8axY8dw/fp19OnTp8gd/RkMBkNRfqk8WWUFNkE0QxZ8Ph89e/bEli1bUKtWLantkydPhpWVFfr16yezPhFh0qRJaNOmDYYNG1bg/r58+YIJEyZg3759sLS0VMrXzMxMTJ06FVWqVMGCBQvA5RbP77EnT55g/vz5mDFjBrp3714sNpUhNDQUrq6uyMrKwtKlS2UmF2YwGP89Suq5zURWCcBEFkMe379/x+jRo3HhwgWoq6tLbMvOzkbfvn2xfPlyuQk2BQIBRowYgQEDBqBnz54F7i8kJAQjR46Em5sb6tatq7S/u3btwp07d+Dh4QFdXV2l68siPT0dixYtQkJCAjZs2CAz+31J8+HDByxduhRmZmZYsGABKlas+NN9YDAYZYdSFVlJSUlKG/4viwsmshj5ceHCBdy8eRNbtmyR2hYbG4v+/fvj6NGjcvOyZWVlYeDAgZg6dSo6depU4P4iIyMxdOhQrFu3Dk2aNFHa3/v378PV1RW7d+9GzZo1la4vj4cPH2Lx4sWYM2cO7Ozsis2usj78888/aNu2LaZPnw5tbe1S8YPBYJQuJfbcVqTjFofDIS6Xq/DC4/HI39+/WDuPlSdYx3dGQcyYMYO8vb1lbnv//j117dpVatRrblJSUqhLly707NkzhfYXGxtL9vb29ODBg0L5GxISQra2tnT9+vVC1ZdHamoqTZ06lcaPH09JSUnFaltRhEIhnTt3jmxsbGjnzp0s7QOD8R+kVCeI5nK5OH36NAwNDRURbejWrRvevXuHGjVqFIMMLH+wSBajILKysuDg4IDdu3fL7C916dIlnD17Fu7u7nLnA4yPj0f//v2xfft2hZoCk5OT4eTkBBcXF9ja2irtc3p6Ov766y/8/vvvmDFjRrHOU3j37l24urpi4cKFpTbxM5/Px8GDB3H48GFMmDABjo6OxdYXjcFglG1KtbmwevXqePbsGYyMjBQy2rBhQ1y5cgXm5uZFdrA8wkQWQxECAwPx119/4fz581BTU5PavnbtWqiqqmL69OlybURGRsLJyQn79+9HtWrVCtxnRkYGhg4diiFDhqBPnz5K+0xE2LRpE968eYOdO3dCU1NTaRvySElJwZw5c8DlcrFq1Sro6OgUm21lSE9Px86dO3HlyhVMmjQJvXr1+ikTXzMYjNKjVJsLGcrBmgsZinLy5Em5k0ULhUIaOXIkXb58OV8bAQEBZGVlpfA0NllZWTR06FA6cOCA0v6KuH79Otna2oqnrCpObty4QVZWVnT37t1it60MycnJtGrVKrKzs6NLly6xhKYMxi8My5PFYPyCODo6Ij09HZcuXZLaxuFwsHPnTmzduhWfPn2Sa6N69erYunUrhgwZotAgFVVVVezfvx++vr7YsWNHofy2tbXFzp074ezsjPv37xfKhjw6d+6Ms2fP4siRI5g+fTrS0tKK1b6i6OjoYO7cuTh58iSePXuGbt264ebNmz9l8msGg/FrUKgUDk+fPsWdO3fw48cPCIVCiW0bN24sNufKK6y5kKEMGRkZcHBwgKenJ6pWrSq1PSIiAkOGDMHp06dRoUIFuXYeP36MFStW4OTJkwo14xER/v77bxgaGmLevHmF8j0lJQVjx47Fn3/+iQkTJhR7s9qVK1ewbt06rFixAm3bti1W28oSHx+PDRs24NWrV/j777/x559/lqo/DAaj+CgzebJWrlyJhQsXok6dOjAxMZG4qXI4HPj4+BSbc+UVJrIYyvLlyxdMnz4d586dg4qKitT258+fY9myZTh9+rTM7SJu3ryJ3bt3w8vLC6qqqgXul4jwzz//ICUlBatWrSqUSBIKhVi5ciVCQ0OxdetWmf3LikJCQgJmzpwJIyMjLFu2DBoaGsVqX1liYmKwdu1afP78GXPnzkWbNm1K1R8Gg1F0yozIMjExwZo1azBy5Mhic+JXg4ksRmE4cuQIPn36JHd6nRMnTuDhw4cy82vl5vTp07hw4QL27dun8Oi4LVu24MuXL9i2bVuhR9RduHABO3fuxL59+2BqalooG/lx/vx5bNmyBatWrULLli2L3b6yREZGYvXq1QgJCcGCBQvQrFmz0naJwWAUkpJ6bit9N+VyuWjXrl2xOcBgMHIYMmQIoqKicPPmTZnbBwwYAH19fXh4eORrp1+/fujQoQOmT5+ucP+hqVOnonnz5nB2dgafz1fadwBwcHDAhg0bMGTIEPj5+RXKRn707NkTJ06cwPbt27FgwQJkZmYW+z6UwdTUFJs3b8bWrVuxd+9eDBgwAE+fPmV9thgMhhilI1lr165FeHg4Nm/eXEIulX9YJItRWNLS0uDg4IAjR47IjAYJhUI4OTlh4sSJBfYJWr9+PVJTU7FkyRKF93/q1CmcPHkSBw4cKHSzXEJCAkaPHo2ePXtixIgRhbJREKdPn4abmxvWrVuHpk2blsg+lCUoKAg7d+7Eixcv0KhRI/Tr1w+tW7dmubYYjHJAmWkuFAqF6N69O758+YL69etL9fvw9vYuNufKK0xkMYrC+/fvMW/ePJw5cwY8Hk9qe0pKCvr06QN3d/cCJzieN28eKleuDBcXF4X3f/XqVezcuRNHjhwpdK4qgUCARYsWIT09HevWrcu3H1lhiY6OxtSpU1G7dm3Mnz+/2PuCFRYiwps3b3D69Gk8fvwYtWrVQr9+/fDnn3+WyHlgMBhFp8w0F06ZMgW3b99G7dq1YWRkBH19fYmFwWAUjQYNGqB3795YtWqVzO06OjrYs2cPxo4di+Tk5HxtrVy5Eh8/fsThw4cV3n+XLl0wa9Ys9O/fHwkJCcq4LobH42HlypVo06YN+vbti9jY2ELZyY+KFSviyJEjqFevHrp37443b94U+z4KA4fDwR9//IFly5bh+vXrcHFxwePHj+Hg4IAxY8bg8uXLpd7UyWAwfg5KR7J0dXVx7NgxdO/evaR8KvewSBajqBARRo4cidGjR8ttFhR1gj927Fi+TVICgQAjRozAwIED4eDgoLAPz549w7x583DkyBFUqlRJ6WMQ8fr1a0yfPh2bN29Go0aNCm0nPyIjI+Hi4oI//vgDc+bMKbMRo6CgIHh7e+PWrVswMjJCnz59YG9vDy0trdJ2jcH4T1NmmgstLCxw7do1heZK+6/CRBajOEhOTkavXr1w/PhxVKxYUWaZffv2wd/fH//880++trKysjBo0CBMnToVHTt2VNiHDx8+YPLkyThw4ECRpsmKiYmBs7Mzhg0bhv79+xfaTn4QEY4cOYJDhw5h06ZNqF+/fonsp7gIDw/H2bNncfXqVXA4HJibm6Nq1aqoUqWK+LVKlSrQ1tYubVcZjF+eMiOyPD09cfXqVXh6erJfX3JgIotRXLx69QrLli3DqVOn5EarZsyYgebNm8PJySlfW6mpqXB0dMQ///yjVGfxgIAAjB49Gu7u7qhVq5ZS/ucmOzsbs2fPhra2NpYtWyazv1lxEB4ejilTpqBVq1aYOXNmie2nOMnKykJERARCQ0MRFhaG0NBQ8f+ijPccDgeVKlVC1apVxSLM1NS0zEbtGIzyREpKCtq2bVv6IqtJkybw9/cHEcHS0lKq4/uLFy+KzbnyChNZjOLEzc0NaWlpmDVrlsztfD4f/fv3x/z589GiRYt8bcXHx6N///7YsWMH6tSpo7APYWFhGD58ODZv3ozff/9dKf/zsn//fly8eBF79+4tsX6cRARPT0+cOHECW7ZsUepYyypCoRA/fvwQi7CwsDBERkZKzbrBYDCUJzMzE+vXry99keXq6prvdmWGi/+qMJHFKE6ICEOGDIGLiwtat24ts0xCQgL69u2Lw4cPw8zMLF97oml6lG0CjImJgZOTE1asWFHkZKBPnz7FvHnzsGPHjhLtehASEoIpU6agU6dOcHFxKRdRLQaD8fMpM82FjIJhIotR3IhEVH7zF3758gVTpkzB2bNnC5y7MDAwEGPGjMGxY8fk9veSRWJiIpycnDBr1ixYWVkpdQx5iYiIgLOzMyZNmoQePXoUyVZ+EBE8PDxw7tw5bNmyBb/99luJ7YvBYJRPmMgqRzCRxSgJ/Pz8sGHDBhw9elTuHIPXr1/HkSNHsH///gLnIXz37h1mzJiBU6dOKfU5TUtLw5AhQzB69Ogii6PMzEy4uLjA3NwcCxYsKPYJpnMTFBSEKVOmwN7eHhMnTmRJQhkMhphSzZNlaGiImJgYhY1Wq1YNwcHBhXaKwWBI06JFC7Rq1Qrbt2+XW8bOzg5NmzbFmjVrCrTXsGFDLFu2DE5OTkhPT1fYDy0tLRw7dgxHjhzB8ePHFa4nC3V1dezatQuGhoYYMmQIUlJSimQvPywtLXHu3DlwOBz06tULQUFBJbYvBoPBABSMZHG5XBw4cEDhTqqDBw/G27dvUaNGjSI7WB5hkSxGSUFEGDBgAObOnSt3QmIiwvjx49GjRw/07NmzQJs3btyAh4cHvLy8lBqpxufzMX78eLRu3Rpjx45VuJ487t27h2XLlsHd3b3E7x3+/v5wcXFBr169MHbs2BKNoDEYjLJPqTYXFias/u3bNyaymMhilACxsbHo378/zp49K/fzlZWVhT59+mD16tUKjQY8deoULl++jD179ij1fRcKhZg+fTosLCwwY8YMhevJIyQkBGPGjMHff/+Nzp07F9lefgiFQmzduhV37tzBtm3bipQHjMFglG9Yn6xyBBNZjJLmwYMH2LVrFw4dOiQ3ChMdHY2BAwfixIkTMDY2LtDmnj178O7dO2zatEmpyA4RYfHixeByuVi6dGmRo0JpaWn466+/0LhxY0ybNq3Eo0yfP3/GtGnTMGDAAIwcOZJFtRiM/yBlZu5CBoNR+rRv3x4NGjTAnj175JapWLEiNm/ejJEjRyIrK6tAm2PGjEGVKlWwfPlypXzhcDhYvnw5dHR0MHPmTBT1d5uWlhb2798PgUAAZ2dnpfqLFYY6derg4sWLiImJQf/+/REeHl6i+2MwGP8dfhmRdefOHXA4HJmLn5+fuJys7bt27ZKw9fbtW3Ts2BGampqoUqUKli1bVuQHB4NR3MyZMweXLl3C27dv5ZZp1KgRRo8ejalTpyr0GZ49ezbS0tLy7VyfX906depg/PjxEAgEStfPDYfDwaxZszBo0CD06tUL379/L5K9guDxeJg9ezaWLVuGUaNG4eDBg+w7z2AwiswvI7Latm2LiIgIiWXMmDGwtLRE8+bNJcp6enpKlBsxYoR4W1JSEmxtbWFmZgY/Pz9s27YN69evx8aNG3/2ITEY+cLlcuHu7o5p06YhNTVVbrk+ffqgSpUqcHNzU8juqlWr8O7dOxw5ckRpn8aPHw8rKysMHz5coehZQdjb28PNzQ2jRo3CgwcPimyvIOrXr49Lly4hKioKffr0QWBgYInvk8Fg/MLQL0pWVhZVqlSJli1bJrEeAJ05c0ZuPTc3N9LX16eMjAzxulWrVpGZmRkJhUKF9p2YmEgAKDExsVC+MxjK4OPjQ87OzvmWEQqFNHToULp586ZCNvl8Pjk5OdGFCxcK5dP58+epb9++lJqaWqj6eUlKSqKBAwfSrl27isWeInz9+pUcHBxow4YNlJ2d/dP2y2Awfj4l9dz+ZSJZeTl//jxiYmIwcuRIqW2TJ0+GsbExWrRogV27dknM/fXo0SN07NgR6urq4nX29vYIDw9neXUYZRIrKyuYm5vj4MGDcstwOBzs3r0ba9aswdevXwu0yePx4OnpiT179uDevXtK++Tg4IBJkyZhwIABSEpKUrp+XnR1deHl5YWoqCj89ddfxRIlK4jffvsN586dg6GhIbp3747Xr1+X+D4ZDMavRaGmbxcKhfj27Rt+/PghNTnpn3/+WSyOFZW9e/fC3t5ealj28uXLYWNjA01NTdy6dQszZ85ETEwMFi5cCACIjIyEpaWlRB0TExPxturVq0vtKzMzE5mZmeL3xfFQYTCUYdGiRejVqxdatmwpdy5ALS0teHp6Yvjw4fD29i4w752amhqOHDkCR0dH6OrqokmTJkr5ZG1tDS0tLfTv3x9eXl4wMjJSqn5euFwuFi9ejHPnzqF3797w9PQUfzdLCg6Hg5EjR6Jr166YOXMmzM3NsXjx4gKnLWIwGAwAyjcXPnr0iKpXr05cLpc4HI7EwuVyizXMRkS0ZMkSApDv4ufnJ1Hn+/fvxOVy6dSpUwXaX79+Penp6Ynf29ra0rhx4yTKhIaGEgB69OiRUj6y5kLGzyQsLIxsbGwoLS0t33KPHz+mvn37Ep/PV8hubGws2djY0OfPnwvl1+vXr8nGxobCw8MLVV8W79+/JysrK6nvfklz/vx5sra2Jh8fn5+6XwaDUbKUVHOh0nmyGjdujNq1a8PV1RWVK1eWyimjaFZ4RYmJiSlwSh9LS0toaGiI3y9fvhzbtm1DWFgYVFVV86378OFDtG/fHpGRkTAxMcHw4cORmJiIc+fOicu8fPkSTZs2RUBAgMKRLHNzc5Yni/HTuXr1Ks6dO4edO3fmW+7w4cN4/fo11q1bp5DdiIgIDBkyBAcOHChU0s4vX75gwoQJ2Lt3r8zvUGGIj4+Hs7Mz+vbti2HDhhWLTUVISkrCwoULkZGRgTVr1sidsJvBYJQfSiy/pbKqTEtLi75+/VqsSq84EQqFVL16dZo5c6ZC5bdt20YaGhriju5ubm5kYGBAmZmZ4jKrV69mHd8Z5YY5c+bQsWPHFCq3f/9+he36+/uTtbU1RUdHF8qv4OBgsrKyog8fPhSqviz4fD79/fffNGPGjJ/eOf3hw4dkbW1NJ0+eVPjewGAwyiYl9dxWWmRZWVnRlStXitWJ4uTmzZsEQOaN/Pz58+Tu7k5v376lb9++kYeHB+np6ZGLi4u4TEJCApmYmNDgwYPp7du35O3tTXp6erR+/XqFfWAii1GaZGVlUZcuXejbt2/5luPz+eTo6EgPHz5U2PabN2/I1taWkpKSCuVbZGQkde7cmZ4/f16o+vLw8vIiBwcHiomJKVa7BZGRkUFLly6l/v370/fv33/qvhkMRvFRqiLr9evX4sXb25vq169Pnp6e9OzZM4ltr1+/LlbnCsPgwYOpbdu2MrdduXKFGjduTDo6OqSlpUUNGzakzZs3S/0CfvPmDXXo0IHU1dXJ1NSUli5dqtQvVSayGKVNUFAQ2draSqQikUViYiLZ2NhQSEiIwrZ9fX2pR48elJ6eXijf4uLiyN7enu7fv1+o+vJ48eIFderUid68eVOsdhXh/fv31LVrV1q3bh3FxcX99P0zGIyiUap9srhcLjgcjtwMyKJtHA6nyJmefwXY3IWMssC5c+dw+/ZtbN68Od9yAQEBGD9+PM6ePQttbW2FbF+/fh179uyBl5cXVFSUH6SckpICJycnTJo0Cfb29krXl0d0dDRGjRqFUaNGoV+/fsVmVxGEQiHOnj2LgwcPwtDQEGPHjkXr1q3ZXIgMRjmgVCeIDg4OVtighYVFkRz6FWAii1FWmDZtGjp16oTevXvnW+727dvw8PDA4cOHweUqlj7v5MmTuHr1Kjw8PBSuk5uMjAwMHz4cgwYNQt++fZWuL4/s7GzMmDED+vr6WLZsWaF8Kyr+/v7w8PDA8+fP0adPHwwdOpTdCxiMMkypiqzc3Lt3D23btpX69crn8+Hr61tm8mSVJkxkMcoKmZmZcHBwgIeHR4E/gHbt2oWoqCgsWbJEYfseHh74+PEjNmzYUKiITXZ2NsaMGQNra2uJ6a2Kg7179+LKlSvYu3dvsY96VpTMzEycPXsWR44cgampKcaPH49mzZqVii8MBkM+ZUZk8Xg8REREoFKlShLrY2NjUalSJdZcCCayGGULf39/TJ48GefPny8wpcnkyZPRqVMnODo6Kmx/zZo1yM7OFif0VRahUIjJkyejfv36mDx5cqFsyOPRo0dYsGABdu7ciTp16hSrbWX5/Pkz3N3d8e7dOzg6OmLw4MHQ0dEpVZ8YDEYOJfXcVjqOLup7lZfY2FiF+3MwGIyfR82aNTFq1CgsWrSowLKbNm3CgQMH8PLlS4Xtz5kzB8nJyQpPQJ0XLpeLHTt24Pv371i5cqXcvp+FoU2bNjh8+DCmTp2Ky5cvF5vdwlCnTh1s2LAB586dg6amJgYOHIiJEyey6XoYjF8YhSNZoj4T586dQ5cuXSTm9hMIBHjz5g3q1KmDq1evloyn5QgWyWKURSZOnIiePXuiS5cu+ZaLjY1F//79cfToUYWnrSEiTJgwAR07doSTk1Oh/CMirFq1ComJiVi9enWxdhjPyMjAlClTUKNGDcydO7fMdEZ///49du/ejS9fvsDAwAA1atRAzZo1xa9VqlQBj8crbTcZjF+eUm8uHDVqFADgwIEDGDBggMTcXWpqarC0tMTYsWNhbGxcbM6VV5jIYpRF0tPT4eDggAMHDqBKlSr5lv3w4QNmzpyJs2fPSvygyg+BQIBhw4ZhyJAh6N69e6H93L59Oz58+IDt27cXa6d1IsKOHTvw6NEjuLu7l7nIe3JyMgIDA+Hv74+AgAD4+/sjLCwMAoEAPB4P5ubmEiKsRo0aZe4YGIzySqmLLBGurq6YNWsW+3LnAxNZjLLKp0+fMGvWLJw9e7bA1AuXL1/G6dOnsWfPHoUjP5mZmRg4cCBmzpyJDh06FNrPAwcOwMfHB3v27CmwH5my3LlzBytWrICHh0exTfFT0ggEAnz//h0BAQFiARYQEIC0tLQyE5VjMMoz2dnZuHr1aumLLBE/fvzA58+fweFwULt2bamO8P9lyprISo6NQXxEOCpUNoOuEYs0/tc5dOgQvn37BldXV7llIhLTERiTiite7jDQUsfMmTMVtp+SkgJHR0fMmL8EOlVqobqxNirraxZcMQ/e3t44duwY1mzbjYgUQaHtiBAdU3VjbWTGR2Hs2LGYN28erK2tC2WjuHwprJ2y5AsARIX6Izr4Aypa1IdJ1ZqlZgMAkBgGxPkDhjUB/fyjtiVuh/lSsnaKyZcyE8lKSkrCpEmTcOzYMfFIQh6Ph4EDB2LHjh2lNlS6LFGWRNZbn+u44b5NPGDBdtwU/G5tV6o+MUqf0aNHY8iQITIFxrZbX7HxxhcQABBB85E77Bx64/fWnaTK5r17UE4tPP4YjKOrZsDQbiLUDKuga0NT/GFukKucbPLau3jlKm57H4Sxw2zw1DRh39AUf1Q1kFk3P16HJuDau0gQAA4Ahz8qo1FlLRxYMx816zeCg9NoqPC44HE5UOFywONyocLlgCt+z8Hdzz+w614AiAAOB5jRuTZ6Na4CFR4Hqjwu1Hhc8f+qPI7cCNNxvxDM834LIQFcDrCq7+8Y2KKaUseT18bKPr+jX7OqyOILcxZBzmtmnvc56wTidfe/xuD081DxeenZ2AzNLJSf8Fr11SEMiNwAHocgIA5Om04Fv+FApWyovDuOfpFbxDZeNpyP5r0mKe0LXnkBV/4GSAhwuEDXtUDjQvQTLA47zJeStZPXhsMWoOlw5X1BGRJZAwYMwKtXr7Bt2za0adMGHA4Hvr6+mDp1Kho1aoQTJ04Um3PllbIispJjY+AxaZTEaC0Ol4ux2/exiNZ/nNTUVPTs2RNeXl4SndsjEv/X3n2HRXF9fQD/zrKwFBEFDIiiQKKvXVF+Gnsk9oIVjRVLBIwNUUQURVGCqChWQBHBihXUaOw9EitYiZpYEGElaGhK3/v+Ydi4ArqVheV8nmefhJk75569IbuHmTt3ctDB/5xEEcQK85F6aBmM7SdD29RS6j4Ks94g7ZdAmPZzB7+6/L9vuUkPkXF1L0wdPKClq9wlDxhjyLx2EAVvX8Gk5xRwfB2lxebzPhRcfC0OOlo8aGvxAA4QZuSWaFvPWA98Hg8ixiBiH4pVkehDfgz4bzsDCotESM8pUFqeijLHG/wmmAEtTnl3hRIiF04LcLsn1xktVX1vy/w8jGPHjuHkyZPo1KmTeFuvXr2wZcuWL961RMrXPynJJW6HZyIR0oXJVGRVcQYGBggKCoKzszOio6PFE8yfpb0rcZaJ4+ugz0++uLFtMXrPWgndah/OVpd2poYD8HdWHi7/mQa+oQlMek9H2rHVqDXQE9+1/Bq1DAUftS39TE9x2NSsXFx6nAbduk3AdRmLtBh/mA6Yg262DfCVoa7U77U4zqf+Z1UTRno6KGo0BYl3r+LhiQDYjZkPgZEpCkUMRSL27z9FyM4tRHIpxZGA/6EwKigqWWAUihgKRUWAFPVQ4tscqd+PNLR4Hwo7Hf6/Ly0eBPz/fhbweXifX4QHyZkljv3W2hgm1aS72QEAzN68hNZbKrBIBcCKgLdPFbuEqWQyF1kmJialXhI0MjJCzZqyn2YmqlOztkWJZ05yPB5qmFuoMStSUTRv3hz9+/dHQEAAvLy8AADWpgbgcYDoo+9MLY7DxsndkGJfG4sXL8bBgwc/Oxk9JSMHHZefg4gB2jVrw/j7yXjzSyAWzf0VDepKP3fz4zgC829g3N0VaUdWYrrLfvyvWUO54nz8ntaNtP1oDlJbPHnSD66urvBauhQdOnSUKsYFj+9Q20gPjH0oyAqKRCgoKv6nCIVFDPn//rOgSITkjBy47LglcVmUxwEbRtrC1FAXPO5D8cpxAI/jPvyMj37mAWlZ+RgXfk0iFx4HnJjZBZbG+tDhf7jsKe+4rPmhlUxzs14nGaFoyzyJM1lFjIc3Ey7hKwsbqWKkJj+FybbOCsUAAGQmAxvbfrh8VIzTAqZeA6rL8LmnjDiUi2rjlBXDWIbfl3Ig8/3R3t7ecHd3R0pKinibUCiEh4eHVIsdkvJjaGKKHs7Twf17loLj8dBj8jQ6i0XEfvzxRzx8+BBXrlwBANQ20oP/kObQ+vd0khbH4echzVDbSA+tW7fGmDFjvjgJ/tMYemY2mLdgAdynTEJubsmzQdLG0a1VDyvWboTnDFc8fvxY7jgfv6ePNWjQANHR0QgKCsLmzZsl/jj5UgyO+3BpUF+HDyM9bZhWE6C2kR4sjfXxda1q+D9zQzSrY4SeTcyx/JM4/kOao28LC7S1NoadlTHa1K+J1vVqopVlDbSoWwPN6xqhWR0jNLGojkbm1dGpgWmJXPyHNEdDc0Po6WhJVWDJMi5fYlb3a9xqsRiF7MPnTCHj4VYLH3xl1RzQMZDq9ZVVc4VjQMcAMG3wYV4O9+/aYpwWMCDow/byjkO5qOc9VaCzWIAcc7JsbW3x559/Ii8vD/XqfZismZiYCIFAgAYNGki0vX37tvIyrUQqypysYllv0pAuTEYNc7q7kJSUmZmJQYMGYf/+/TAxMQHw4SzH87T3sDLVL/Gl6+PjAwsLC7i4uHw27qcxTp48ia1bt2L37t1fXD7ic3GSk5MxduxYrFmzBi1atJA7TllEIhGWL1+OP//8Exs2bIC+vr7MMZSVi6pjKDPO66S/kPbiD5jWb6TQ3YWKxgDw7x1nTz+c1VD47jcF41Auqo2jpFwqzMT3z932/SlZHjSrSSpakUXIl9y+fRs///wz9u/f/8V1l0QiEUaPHg0XFxd89913MvWzb98+nDx5Elu2bFFoodG0tDSMHj0aS5Yswbfffit3nM85e/Ys/P39sWnTJjRsKP3lSUJI5VNhiizyZVRkkcpow4YNyM/Ph7u7+xfbvnv3DgMHDsTmzZthYyPbHIjNmzfjjz/+QGBgoEILaWZmZmLUqFFwd3eXaa0rWbx69QrOzs6YMGGCTA/NJoRULhXmAdEAkJ6ejrCwMHh5eeHt27cAPvwl/OrVK6UlRggpX1OnTsX169dx/fr1L7Y1MDDA1q1bMXnyZGRlZcnUj7OzM7766iv4+fnJmyoAoHr16ti3bx82btyIo0ePKhSrLHXq1EFMTAx+//13zJo1C/n5+SrphxCimWQusu7evYuGDRsiICAAq1atQnp6OgAgOjpafIcSIaTy4TgOwcHBmDdvnvj/68+pX78+fH19MWnSJIhEoi+2/5inpycyMzOxadMmObP9QF9fH3v27EFUVBR2796tUKyyaGtrY9WqVejcuTMGDhyIpKQklfRDCNE8MhdZ7u7uGD9+PJ48eQJd3f/WqunTpw8uXbqk1OQIIeWrZs2a+PnnnzFlypQSa6yVpmPHjujTpw+8vb1l6ofjOAQEBODOnTsKF0c6OjrYvn07Lly4gM2bNysU63OGDBmCdevWYcKECTh9+rTK+iGEaA6Zi6wbN26UeldRnTp1IBQKlZIUIUR9vv32W7Rp0wbBwcFStZ8wYQLy8vKwa9cumfrhOA6bNm3CL7/8guPHj8uTqpiWlhZCQkLwxx9/YOXKlQrF+pwGDRrgyJEj2Lt3L5YuXSrzGTxCSNUic5Glq6uLzMySqwQ/evQItWrVUkpShBD1cnd3x9mzZxEfHy9V+4CAABw4cECq+Vwf09LSwrZt2xAaGorLly/Lkel/eDweAgMD8e7dOyxcuFCqM3Hy0NPTQ1hYGOrUqYNhw4bhzZs3KumHEFL5yVxkDRw4EL6+vigo+PCsCI7jkJiYiHnz5mHo0KFKT5AQUv54PB5CQ0Mxe/ZsqSa28/l8bNu2DV5eXjLfACMQCLBr1y74+flJXdSVheM4LF68GDVr1oSbm5tKzzRNnDgRixYtgqOjI65du6ayfgghlZfMSzhkZmaib9++ePDgAbKysmBhYQGhUIj27dvj+PHjMDAwUFWulQYt4UA0xeXLlxEWFoaIiAipllt48uQJpk2bhpiYGOjpybaw5du3bzF8+HAEBweXWNhYHmFhYfj9998REhIi0+KnskpPT4eLiws6d+6MqVOnKrQsBSFEPSrcOlnnzp3D7du3IRKJ0Lp1a3Tv3l1pSVV2VGQRTeLn5wdzc3NMmjRJqvanT5/Gjh07EBkZKXPBkZycjDFjxmD79u2oW7euPOlK2Lt3Lw4fPoxt27ZBIJD+oceyYowhMDAQsbGx8Pb2hq2trcr6IoQoX4UrskjZqMgimqSoqAhDhgyBn58fmjVrJtUx69atQ3Z2NubPny9zf3/99RecnZ2xd+9emJoq/hioY8eOISwsDLt27ZJ4RI4qPH/+HCtWrEBqairmzJmjstXoCSHKVSEWIxWJRAgPD0f//v3RrFkzNG/eHA4ODti+fbvKJpkSQtRLS0sLoaGhmDlzJt69eyfVMdOnT0diYiIOHz4sc39ff/011qxZg9GjR8u80Glp+vXrh5kzZ2LYsGHIyMhQON7nWFlZYdOmTVi7di327t2LgQMH4uLFi/T5SEgVJfWZLMYYBgwYgOPHj6Nly5Zo1KgRGGNISEjAvXv34ODggJiYGBWnWznQmSyiic6cOYO9e/diy5YtUrXPz8/H4MGDsXz5cjRv3lzm/q5evYrly5dj3759Emvyyev69evw9vbG7t27lXKGTBqpqalYs2YN7t69ixkzZqBnz540Z4uQCkhl39tMSuHh4czQ0JCdO3euxL6zZ88yQ0NDFhkZKW04jZaRkcEAsIyMDHWnQohSeXt7sx07dkjdPjU1lXXr1o2lpqbK1d+JEyfY8OHDWUFBgVzHf+ru3bvM3t6eJSUlKSWetN68ecMWL17MevbsyWJiYlhRUVG59k8I+TxVfW9Lfblwz549mD9/Prp161Zin729PebNmyfzYoSEkMrFx8cHUVFRePTokVTta9WqhaCgIEyYMEGu5/716tULQ4cOhaurq1KWY2jevDlCQ0MxduxYPH36VOF40jI2NoaPjw/279+PP/74Az179sTevXtRVFRUbjkQQsqf1EXW3bt30bt37zL39+nTB3fu3FFKUqXx8/NDhw4doK+vjxo1apTaJjExEQMGDICBgQFMTU0xY8aMEh/s9+7dQ9euXaGnp4c6derA19e3xHyJixcvok2bNtDV1YWNjQ1CQkJU9bYIqVT4fD5CQ0Mxbdo05ObmSnVMixYtMHnyZMyYMUOuuUnDhw9H27Zt4eHhoZS5Td988w0iIyMxefJkPHjwQOF4sqhevTo8PT1x5MgRpKSkoEePHoiMjBSvO0gI0SxSF1lv376FmZlZmfvNzMzwzz//KCWp0uTn58PR0RFTpkwpdX9RURH69euHd+/e4cqVK4iKisLBgwcxe/ZscZvMzEz06NEDFhYWuHHjBtavX49Vq1Zh9erV4jbPnj1D37590blzZ8TFxWH+/PmYMWMGDh48qLL3RkhlUqdOHcyaNQtz5syR+piBAweiXr162LBhg1x9Ojs7o1atWvD395fr+E9ZWlpiz549cHNzw82bN5USUxb6+vpwc3PD8ePHkZOTAwcHBwwYMADTp0/Hpk2bcP78ebx+/ZomzBNSyUk98V1LSwtCobDMR+e8fv0aFhYWKj/9HRERATc3N6Snp0ts//XXX9G/f3+8fPkSFhYWAICoqCiMHz8eqampqF69OoKDg+Hl5YXXr1+L18xZvnw51q9fj6SkJHAcJ/4rMyEhQRzb1dUVd+7cQWxsrFQ50sR3UhXMnTsXbdu2xbBhw6RqzxiDk5MTxo0bJ9e6eowxeHp6wtrausw/tmSVnp6OkSNHwsvLC126dFFKTHkVFRXhxYsXSEhIwMOHD5GQkIDXr18DACwsLNC4cWM0btwYTZo0gaWlJXg8mR/YQQgpg6q+t6VeBpkxhvHjx5e5oF9eXp7SkpJHbGwsmjVrJi6wgA/zOfLy8nDr1i1069YNsbGx6Nq1q8R76NWrF7y8vPD8+XNYW1sjNjYWPXv2lIjdq1cvbN26FQUFBdDW1i7Rd15ensT7L+3ZjoRoGj8/PwwYMACtW7eGjY3NF9tzHIfQ0FAMGjQI9evXl3lVd47jEBAQABcXF+zZswcjR46UN3WxGjVq4MCBAxg1ahTevXuHPn36KBxTXlpaWrCxsYGNjQ369esn3s4YQ0pKirj4Onr0KBITE8EYg6GhYamfSYQQ2cgzZ1QaUhdZTk5OX2wzbtw4hZJRhFAoLHE5s2bNmtDR0YFQKBS3sbKykmhTfIxQKIS1tXWpcczMzFBYWIi0tDTUrl27RN/+/v5YsmSJEt8NIRWftrY2QkJC4OLigqNHj0JHR+eLx+jp6SE8PBzjxo3DwYMHy5xfWRaO47Bp0yaMHTsWRkZG6Nu3r5zZ/8fAwAB79+6Fk5MTsrOz4ejoqHBMZeI4DhYWFrCwsMD3338vsS87O5smzxOiBJmZmdi3b5/S40pdZG3btk3pnS9evPiLxcmNGzdgZ2cnVbzS1p9hjEls/7RN8dVSWdt8zMvLC+7u7uKfMzMzYWlpKVXOhFRmVlZWcHV1xbx58yTmNn5OnTp14O/vjwkTJuDAgQPQ0tKSqU8+n4+IiAgMHz4c1atXR6dOneRJXYKuri527dqFH3/8EVlZWZg4caLCMctDtWrV1J0CIRpBVevXqfWi/rRp05CQkPDZl7SP8TA3NxefsSr2zz//oKCgQHxmqrQ2qampAPDFNnw+HyYmJqX2LRAIUL16dYkXIVXF4MGDUVhYiCNHjkh9TPFcLk9PT7n6FAgE2LVrF5YtW6a0u5r5fD7Cw8Nx+/ZtrFmzRikxCSFVm1qLLFNTUzRq1OizL2lXem7fvj3u37+PlJQU8bZTp05BIBCgTZs24jaXLl2SuPZ66tQpWFhYiC8jtm/fHqdPn5aIferUKdjZ2dHcB0LKsHLlSqxfvx6JiYlSHzN69Ghoa2sjIiJCrj6rVauGXbt2wd3dHX/++adcMT7F4/Gwfv16ZGRkwMPDQylrcxFCqjClLm2qQi9evGBxcXFsyZIlrFq1aiwuLo7FxcWxrKwsxhhjhYWFrFmzZuz7779nt2/fZmfOnGF169Zl06ZNE8dIT09nZmZmbOTIkezevXvs0KFDrHr16mzVqlXiNk+fPmX6+vps1qxZ7OHDh2zr1q1MW1ubHThwQOpcacV3UhU9efKE9e7dm+Xn50t9TFFRERs2bBi7cuWK3P0mJSWxbt26KX0V99DQUDZu3DiWl5en1LiEkIpHVd/blabIcnJyYgBKvM6fPy9u8+LFC9avXz+mp6fHjI2N2bRp01hubq5EnLt377LOnTszgUDAzM3N2eLFi5lIJJJoc+HCBWZra8t0dHSYlZUVCw4OlilXKrJIVbVnzx7m5eUl0zGZmZnM3t6evXjxQu5+nzx5wuzt7VlaWprcMUpz+PBh5uDgwDIzM5UalxBSsajqe1vqdbKI9GidLFKVubi4YMiQIejVq5fUxzx9+hQuLi6IiYmBgYGBXP3euXMHc+fOxYEDB2BoaChXjNJcvXoVPj4+2LFjB8zNzZUWlxBScajqe5tWsyOEKNWaNWuwcuVKifmRX2JjY4MFCxbgxx9/lHseVMuWLbFo0SKMHj1aqev2dejQAevXr8eoUaPw+PFjpcUlhGg+KrIIIUqlr6+P9evXw9nZWaY1nL777jt899138PX1lbvvjh07YsqUKXByckJhYaHccT7VqFEj7Ny5Ez/99BOuXbumtLiEEM1GRRYhROkaN26MYcOGwc/PT6bjXFxc8ObNG+zfv1/uvvv06YNBgwbhp59+Uuqz/ywsLHDw4EEsW7YMx44dU1pcQojmoiKLEKISTk5OeP78OS5cuCDTcatXr8aOHTtw+/Ztufv+4Ycf0Lp1a8ydO1ephZaRkREOHDiAPXv2qGSBZkKIZqEiixCiMuvWrYOvr6940V9pFK+dNWfOnBILA8vC1dUVNWvWxPLly+WOURqBQIDt27fj7t27WLZsmVKLOEKIZqEiixCiMtWqVUNQUBBcXFxkmtBubGyMjRs3YsKECcjNzZW7fy8vL7x58wahoaFyxygNj8fD6tWroauri+nTp9PzAwkhpaIiixCiUi1atEDv3r2xcuVKmY5r3Lgxpk+frtDcKo7jsHLlSty4cQN79+6VK8bnYs+ZMwft27fH6NGjkZOTo9T4hJDKj4osQojKOTs74969e7h69apMx/Xt2xdNmjRBYGCg3H1zHIeQkBBER0fjxIkTcscpy+jRozFp0iQMHToUb9++VXp8QkjlRUUWIUTlOI7Dxo0b4e3tLXMhMnv2bDx8+BDHjx+Xu38+n4+IiAhs2rQJv/32m9xxytKjRw8sW7YMw4YNw+7du2meFiEEABVZhJByYmRkhBUrVsDV1VWmIoTjOGzatAnr16/Hw4cP5e5fV1cXu3btgq+vL+7cuSN3nLK0bt0av/76K5KTk9GnTx/ExsYqvQ9CSOVCj9VRAXqsDiFlW7t2LQBg5syZMh0nFAoxatQo7N+/HyYmJnL3/+bNGwwfPhyhoaH45ptv5I7zOX///TeWLFmCjIwMLFu2DPXr11dJP4QQ5aDH6hBCNMKMGTPw22+/4ebNmzIdZ25ujsDAQEyYMAEFBQVy929iYoLt27fD2dkZr169kjvO59SqVQsbNmyAl5cXZs2ahfnz5yMrK0slfRFCKi4qsggh5ap4IvrcuXORkZEh07G2trYYO3Ys3N3dFcqhTp06CA0Nxbhx4/DmzRuFYn1OkyZNcOjQIXTp0gWDBg1CWFgYLfdASBVCRRYhpNwZGxvDz89PruUZHB0dYWJiovDaVw0aNEBgYCBGjx6N7OxshWJ9Se/evXHy5EkUFBSgd+/eOHfunEr7I4RUDFRkEULUon379mjZsqVcxdKiRYtw8eJFmR/Z86lWrVrB29sbo0ePRl5enkKxvoTP52PKlCnYv38/fv31Vzg6OuLx48cq7ZMQol408V0FaOI7IdIRiUQYNmwYfHx80LJlS5mOfffuHQYNGoTQ0FDY2NgolMfx48exY8cO7NixA3w+X6FY0vrrr7/g7e0NMzMzLFq0CMbGxuXSLyGkJFV9b1ORpQJUZBEivb///hsjRozAkSNHUK1aNZmOTUxMxMSJE3Ho0CGF/1/bs2cPzp07h82bN4PjOIViyeLSpUtYt24dcnJyYGpqilatWsHW1hYtW7ZEzZo1yy0PQqoyKrIqESqyCJHNxYsXERERgfDwcJkLnKtXr2LNmjWIioqClpaWQnkEBwfj6dOnWLFiRbkWWsX+/vtvxMfHi1/p6enQ09ND8+bNxcWXpaWlWnIjRJNRkVWJUJFFiOx8fX1Rr149jB8/XuZjIyIi8OjRI/j7+yuch5+fHwBgwYIFCsdShvfv3+P+/fuIj49HXFwcEhMTwePx0KBBAzRt2hQ6OjrqTpGQSi8nJwcuLi5UZFUGVGQRIruioiIMHjwYy5cvR5MmTWQ+fs6cOWjVqhXGjBmjUB6MMSxYsADGxsaYM2eOQrFUpaioCH/++ScSEhJQWFio7nQIqfTev38PJycnKrIqAyqyCJFPSkoKxo4diyNHjkBfX1+mY4uKiuDo6AhPT0+0a9dOoTwYY/Dw8EC9evUwY8YMhWIRQio+WvGdEKLxateuDU9PT7kWG9XS0sK2bdswf/58hVdy5zgOK1euxF9//YXg4GCFYhFCqi4qsgghFUqPHj1gYmKCPXv2yHyskZERQkJCMHHiRLx//16hPDiOQ1BQEO7du4ewsDCFYhFCqiYqsgghFc6SJUuwY8cOPHnyROZjGzRoAA8PD7i4uMi8mvynOI7Dhg0bcP36dURGRioUixBS9VCRRQipcPh8PkJDQ/HTTz8hNzdX5uO7d++Odu3a4eeff1Y4Fx6Ph5CQEFy8eBG7d+9WOB4hpOqgIosQUiFZWlpixowZmDt3rlzHT506FUlJSYiJiVE4Fx6Phy1btuDEiRPYv3+/wvEIIVUDFVmEkAprwIAB0NbWxqFDh2Q+luM4rF27FmFhYbh7967CuWhpaSE8PBzR0dFKKdwIIZqPiixCSIXm7++P0NBQPHv2TOZjdXR0EBERATc3N6SmpiqcC5/PR2RkJHbv3o1jx44pHI8QotkqTZHl5+eHDh06QF9fHzVq1Cix/86dOxg5ciQsLS2hp6eHxo0bY+3atRJtnj9/Do7jSrxOnDgh0e7ixYto06YNdHV1YWNjg5CQEFW+NULIZ+jo6CAkJARTpkxBfn6+zMebmppi3bp1mDBhglzHf0pbWxs7duxAeHg4Tp48qXA8QojmqjRFVn5+PhwdHTFlypRS99+6dQu1atXCzp078eDBAyxYsABeXl7YsGFDibZnzpxBSkqK+GVvby/e9+zZM/Tt2xedO3dGXFwc5s+fjxkzZuDgwYMqe2+EkM+ztrbG5MmT5X7UTbNmzeDi4oLp06crfMchAAgEAuzatQvBwcE4d+6cwvEIIZqp0q34XnzqPz09/Yttp06dioSEBPGH4PPnz2FtbY24uDi0atWq1GM8PT1x5MgRJCQkiLe5urrizp07iI2NlSpHWvGdENWYPn06evfujX79+sl1vL+/PwwMDJS2ivv79+8xYsQIeHh4oEuXLkqJSQgpf7TiuxwyMjJgbGxcYruDgwO++uordOzYEQcOHJDYFxsbi549e0ps69WrF27evImCggKV5ksI+byVK1ciKCgISUlJch0/b9483Lp1C6dPn1ZKPvr6+oiKikJAQACuXr2qlJiEEM2hsUVWbGws9u3bBxcXF/G2atWqYfXq1Thw4ACOHz+O77//HiNGjMDOnTvFbYRCIczMzCRimZmZobCwEGlpaaX2lZeXh8zMTIkXIUT5dHV1sXHjRri4uMj1YGSO4xASEoJVq1bh8ePHSsnJwMAAUVFRWLp0KX7//XelxCSEaAa1FlmLFy8udSL6x6+bN2/KHPfBgwcYOHAgFi1ahB49eoi3m5qaYtasWWjbti3s7Ozg6+uLn376CStWrJA4nuM4iZ+Lr6h+ur2Yv78/jIyMxC9LS0uZcyaESKdhw4YYPXo0Fi9eLNfxenp62LZtG6ZMmSLVtANpGBoaIioqCmvXrsXChQuRl5enlLiEkMpNrUXWtGnTkJCQ8NlXs2bNZIr58OFD2NvbY/LkyfD29v5i+2+//Vbi0R3m5uYQCoUSbVJTU8Hn82FiYlJqDC8vL2RkZIhfL1++lClnQohsRo0ahdTUVLkv+1lYWGD58uWYMGGCXGfESmNkZIQ9e/bA1tYWffv2pcuHhBDw1dm5qakpTE1NlRbvwYMHsLe3h5OTE/z8/KQ6Ji4uDrVr1xb/3L59exw9elSizalTp2BnZwdtbe1SYwgEAggEAvkTJ4TILCgoCA4ODmjevDnMzc1lPv5///sfHB0d4enpicDAQKXlNWTIEHTr1g1z585FVFQUfv75Z1SrVk1p8QkhlUelmZOVmJiI+Ph4JCYmoqioCPHx8YiPj0d2djaADwVWt27d0KNHD7i7u0MoFEIoFOLvv/8WxyheRDAhIQGPHj3CqlWrsG7dOkyfPl3cxtXVFS9evIC7uzsSEhIQHh6OrVu3Ys6cOeX+ngkhZdPX18e6devg7OyMoqIiuWKMGjUKAoEA4eHhSs2tZs2a2LJlCxwcHODg4FBiLT5CSBXBKgknJycGoMTr/PnzjDHGfHx8St1fv359cYyIiAjWuHFjpq+vzwwNDVmbNm3Yjh07SvR14cIFZmtry3R0dJiVlRULDg6WKdeMjAwGgGVkZCjylgkhUggPD2dLly6V+/iioiLm6OjIrly5osSs/pOdnc3c3d3Z+PHjWVpamkr6IIQoRlXf25VunazKgNbJIqT8MMYwYcIETJw4Ue61qrKysjB48GBs3boV9evXV3KGH1y/fh3z58/H5MmTMXz48DJvpCGElD9aJ4sQQkrBcRzWr1+PJUuWSEwPkIWhoSG2bNmCH3/8UTwFQdnatm2L48eP49GjRxgxYgRevXqlkn4IIRUHFVmEkErP0NAQgYGBcHV1hUgkkiuGtbU1vL29MXnyZLljfImOjg4WLVoEHx8fTJo0CZs3b1ZZX4QQ9aMiixCiEVq1aoXu3btj9erVcsfo2rUr7O3t4ePjo8TMSmratCmOHTuG3NxcODg44OHDhyrtjxCiHjQnSwVoThYh6sEYw+jRozFjxgx8++23csfx8PBAkyZNMGHCBCVmV7rnz58jICAAiYmJ0NfXh52dHdq1awc7Ozta+oGQcqKq720qslSAiixC1CcjIwNDhgzBgQMHULNmTbliiEQijBkzBhMnTkT37t2VnGHZsrOzcevWLfz++++4efMmsrOzYWlpiXbt2qFdu3Zo3LgxtLS0yi0fQqoKKrIqESqyCFGvGzduIDAwEHv27JH7Lr6cnBwMGTIEK1asQPPmzZWcofSSkpJw7do1XLt2DQ8fPgTHcWjWrBnatWsHW1tbWgiZECXIyspCw4YNqciqDKjIIkT9goKCoKWlJbHYsKz+/vtv8UPkLSwslJid/AoLC3H//n1cu3YNd+/eRUFBgbpTIqTSy8/PR2RkJBVZlQEVWYSoH2MMI0aMgKenJ9q0aSN3nCdPnmDq1Kk4dOgQzZEiREPROlmEECIDjuMQEhICDw8PZGZmyh2nQYMG8PHxgZOTk9IeJk0IqRqoyCKEaCxjY2MsXboUU6dOhSIn7Tt27Ijhw4dj5syZCsUhhFQtVGQRQjRax44d0bRpU4SFhSkUZ8SIEahfvz5WrVqlpMwIIZqOiixCiMabO3cujh8/jnv37ikUx8PDA0+fPsX+/fuVlBkhRJNRkUUI0Xg8Hg+hoaFwc3PDu3fv5I5T/JzEPXv24LffflNihoQQTURFFiGkSvjqq6/g7e2NGTNmKBSHz+cjMjISixcvxpMnT5SUHSFEE1GRRQipMrp16wZLS0ts375doTiGhoaIjIyEq6sr0tLSlJQdIUTTUJFVBRRm5CH3r3QUZuSpOxVSSWRkZODZs2fIyMhQdypKt3DhQuzfvx9//PGHQnEsLCwQFBSEcePGIScnR0nZVV7Cd0JcT7kO4TuhWmNUtDiUi2rjKCsXVaHFSFWgIi1G+u6GEP8cegIwABxQc0gDGPzPXK05kYrt9u3bOHr0KBhj4DgOAwYMQOvWrdWdllIlJydj3LhxOHr0KPT09BSKdfr0aURERGDHjh3g8arm360HHx+Eb6wvRBCBBx682nnB4WsHmWIc+esI/K/5KxSjosWhXFQbRyIGx4NPex8MaTBE5lwAenZhpVJRiqzCjDwIl1//UGAV4wDzeW3BN6LnnZGSMjIyEBQUJLEWFMdxcHNzg5GRkRozU76TJ08iJiYGwcHBCscKDw/Ho0ePEBAQoITMKhfhOyF6HegFEUTqToVUcTyOh5NDT8LcQPYTCbTiO5FZYVqOZIEFAOzf7YSU4u3btyUW22SM4e3bt2rKSHV69eqFGjVqYO/evQrHmjhxInR0dBAYGFjlFitNzEykAotUCCImwsusl+pOQwJf3QkQ1eGb6gEcSpzJ4psqdnmEaC5jY2NwHFfiTJaxsbEas1IdX19fDBw4EHZ2dvj6668VjrVixQqMGjUKmzZtQs2aNZWUZcVWr3o98DgeROy/QovH8RAzMAZm+mZSxXj9/jUGxQySKNZkjVHR4lAuqo1TVgxLQ0up8ygPdCZLg/GNBKg5pMGHQgsQz8miS4WkLEZGRhgwYAA47sMvTfGcLE27VFhMW1sbISEhmDJlCvLyFLsxhOM4eHp6YtasWRg6dCiuXLmipCwrNnMDc/i09wGP+/B1Ujw3xtrIGvra+lK9rI2s4dNBsRgVLQ7lop73JM+lQlWiOVkqUFHmZBUrzMhDYVoO+KZ6VGARqWRkZODt27cwNjbW2ALrY0eOHMG5c+cQFBSklHiZmZmYNm0avvnmGyxYsABaWlpKiVuRCd8J8TLrJSwNLeX+olNGjIoWh3JRbRxl5UIT3yuRilZkEUK+bNasWejatSsGDRqklHiMMWzfvh379+9HSEgI6tatq5S4hBDlo4nvhBCiQgEBAQgODsaLFy+UEo/jODg5OWH16tWYOHEiYmJilBKXEFJ5UJFFCCEAdHR0sGnTJri4uKCgoEBpcRs2bIijR4/i8uXLmDZtGi1cSkgVQkUWIYT86+uvv8akSZMwf/58pcYVCAQIDAxEv379MGDAADx48ECp8QkhFRMVWYQQ8hFHR0cUFhbi4MGDSo/dp08f7Ny5EwsWLMDmzZur3JpahFQ1VGQRQsgnVqxYgfDwcIWfb1gac3NzHDp0CBkZGRg1ahT++ecfpfdBCKkYqMgihJBPaGtrIywsDFOnTkVWVpbS4/N4PHh4eIjX1Dpx4oRS54ERQiqGSlNk+fn5oUOHDtDX10eNGjVKbcNxXIlXSEiIRJt79+6ha9eu0NPTQ506deDr61vilP3FixfRpk0b6OrqwsbGpkQMQojmq127NpYsWQIXFxeVXdZr27YtYmJicOPGDQwZMgQDBgyAr68vLly4QBPkCdEAleaxOvn5+XB0dET79u2xdevWMttt27YNvXv3Fv/88UKKmZmZ6NGjB7p164YbN27g8ePHGD9+PAwMDDB79mwAwLNnz9C3b19MnjwZO3fuxG+//YaffvoJtWrVwtChQ1X3BgkhFU6nTp1w69YtrF69WvwZoWzVq1fHwoULAXz4nLt58yYuXbqEtWvXIj8/H61atUKXLl3QoUMHGBoaqiQHQohqVLrFSCMiIuDm5ob09PQS+ziOQ3R0dJmLCQYHB8PLywuvX7+GQPBh5fPly5dj/fr1SEpKEj8W48iRI0hISBAf5+rqijt37iA2NlaqHGkxUkI0B2MMTk5OmDhxIr777rty7buoqAh37tzBpUuX8NtvvyE7OxtNmjRBly5d0KlTJ5iYmJRrPoRoKlrx/V9fKrLq1KmD3NxcWFtbY9KkSXB2dgaP9+Gq6Lhx45CRkYHDhw+Lj4mLi0Pr1q3x9OlTWFtbo0uXLrC1tcXatWvFbaKjozF8+HC8f/8e2traJfrNy8uTeO5ZZmYmLC0tqcgiREO8e/cOAwcORGRkJOrUqaO2PEQiEf744w9cunQJly9fRnp6epV4ZA8hqlZQUIATJ04o/Xu70lwulMbSpUvx/fffQ09PD2fPnsXs2bORlpYGb29vAIBQKISVlZXEMWZmZuJ91tbWEAqF4m0ftyksLERaWhpq165dol9/f38sWbJENW+KEKJ2BgYG2LRpE3788UccPnwYOjo6asmDx+OhSZMmaNKkCVxdXdWSAyGaqPhMlrKpdeL74sWLS52s/vHr5s2bUsfz9vZG+/bt0apVK8yePRu+vr5YuXKlRBuO4yR+Lj6R9/F2adp8zMvLCxkZGeLXy5cvpc6ZEFI5NGzYEK6urpgzZ466UyGEVBJqPZM1bdo0/PDDD59t8+mZJ1l8++23yMzMxOvXr2FmZgZzc3MIhUKJNqmpqQD+O6NVVhs+n1/m/AeBQCCe40UI0VwDBw7EtWvXsHPnTowZM0bd6RBCKji1FlmmpqYwNTVVWfy4uDjo6uqKl3xo37495s+fj/z8fPHp/lOnTsHCwkJczLVv3x5Hjx6ViHPq1CnY2dmVOh+LEFK1LF26FEOGDEGLFi3QokULdadDCKnAKs06WYmJiYiPj0diYiKKiooQHx+P+Ph4ZGdnAwCOHj2KLVu24P79+/jrr78QFhaGBQsWwNnZWXyWadSoURAIBBg/fjzu37+P6Oho/Pzzz3B3dxdfCnR1dcWLFy/g7u6OhIQEhIeHY+vWrXSJgBACANDS0kJYWFiZN+AQQogYqyScnJwYgBKv8+fPM8YY+/XXX1mrVq1YtWrVmL6+PmvWrBkLCgpiBQUFEnHu3r3LOnfuzAQCATM3N2eLFy9mIpFIos2FCxeYra0t09HRYVZWViw4OFimXDMyMhgAlpGRodB7VpacnGT25u1VlpOTrO5USCXxKiePXX6byV7l5Kk7lQrr+vXrbNiwYayoqEjdqVQI+SkpLDv2d5afkqLWGBUtDuWi2jjKykVV39uVbgmHyqAirZOVnLwPCX8sACACwEPjRn6wsBiu1pxIxbY7+Q3mPHr5728MsOr/LDHKgtZjKs2WLVuQmpqKBQsWqDsVtfpn/wEIfXwAkQjg8WDmvQA1ylivsCzpMTF4vcxPoRgVLQ7loto4n8ao7bsENYYNkzkXgNbJqlQqSpGVm5uC3652wYcCqxgPHTtcgq5uyaUoCEnOzYdd7EOJ3xgtADfaN4GFrnqWLajIGGNwdnaGo6Mjevbsqe501KJAKMSf9t9/+KIjRJ14PHxz7iy0zc1lPlRV39uVZk4Wkd37nOeQLLAAQIScnBdqyIZUBk9z8kr8xhQBeJaTV1rzKo/jOKxbtw6BgYF4/vy5utNRi/znL6jAIhWDSIT8F4nqzkKCRi1GSiTp61nhQx0teSZLT6++ehIiFZ6NnqDEb4wWAGs9WqKkLHp6eggNDYWzszOOHDkCXV1ddadUrnSs6gM8nmShxePB5tgv0P5kYeeyFLx+jaf9+isUo6LFoVxUG6esGDr160mdR3mgM1kaTFe3Nho38sN//5k/zMmiS4WkLBa6Olj1f5YoflCLFoCV/2dJlwq/wMrKCu7u7hg/fjxycnLUnU650jY3R23fJR8KLUA8N0ZgbQ2evr5UL4G1tcIxKlocykU970meS4WqRHOyVKCizMkqlpubgpycF9DTq08FFpFKcm4+nuXkwVpPQAWWDM6cOYMVK1YgLCwM9epVrL+oVa1AKET+i0To1K8n9xedMmJUtDiUi2rjKCsXmvheiVS0IosQUn6ePn0KFxcXLFq0CJ07d1Z3OoQQKdDEd0IIqQRsbGwQHR2N4OBgBAcHg/6OJaTqoiKLEEKUrFq1ati1axfevn2LKVOmIC+P7s4kpCqiIosQQlSA4zgsWLAA/fv3x+DBg5GSkqLulAgh5YyKLEIIUaH+/ftj9erVGDNmDK5fv67udAgh5YiKLEIIUbFGjRrh4MGDCAgIQGRkpLrTIYSUEyqyCCGkHNSoUQP79u3D48eP4ebmhoKCAnWnRAhRMSqyCCGknGhpacHPzw8dO3bE0KFDkZaWpu6UCCEqREUWIYSUM0dHRyxduhTDhw/HnTt31J0OIURFqMgihBA1aNmyJfbt24eFCxdi8+bNePv2rbpTIoQoGRVZhBCiJqampjh06BC0tLQwdepU9OnTBwsWLMCFCxdobS1CNAA9VkcF6LE6hBB5FBUVIS4uDqdPn0ZsbCy0tLTQpUsX9OjRA02bNgXHcepOkRCNRM8urESoyCKEKMO7d+9w+fJlnD59Gg8ePICZmRm6d++O7t27o3Ztetg7IcpCRVYlQkUWIUQVhEIhzp49izNnziAlJQU2NjbQ09NTd1qEVHp5eXnYuHEjFVmVARVZhBBVY4whMTER+fn56k6FkEovOzsbrVu3Vvr3Nl9pkQghhJQbjuNQv359dadBiEbIzMxUSVy6u5AQQgghRAWoyCKEEEIIUQEqsgghhBBCVICKLEIIIYQQFaAiixBCCCFEBajIIoQQQghRASqyCCGEEEJUgIosQgghhBAVoCKLEEIIIUQFqMgihBBCCFEBKrIIIYQQQlSAnl2oAsXP3FbVs5AIIYQQojzF39fF39/KQkWWCmRlZQEALC0t1ZwJIYQQQqSVlZUFIyMjpcXjmLLLNgKRSITk5GQYGhqC4zh1p4PMzExYWlri5cuXqF69urrTqTBoXMpGY1M6Gpey0diUjsalbBVpbBhjyMrKgoWFBXg85c2kojNZKsDj8VC3bl11p1FC9erV1f6LXBHRuJSNxqZ0NC5lo7EpHY1L2SrK2CjzDFYxmvhOCCGEEKICVGQRQgghhKgAFVlVgEAggI+PDwQCgbpTqVBoXMpGY1M6Gpey0diUjsalbFVhbGjiOyGEEEKICtCZLEIIIYQQFaAiixBCCCFEBajIIoQQQghRASqyNJC/vz84joObm5t4G2MMixcvhoWFBfT09PDdd9/hwYMH6kuyHL169QpjxoyBiYkJ9PX10apVK9y6dUu8v6qOTWFhIby9vWFtbQ09PT3Y2NjA19cXIpFI3KYqjM2lS5cwYMAAWFhYgOM4xMTESOyXZgzy8vIwffp0mJqawsDAAA4ODkhKSirHd6EanxubgoICeHp6onnz5jAwMICFhQXGjRuH5ORkiRiaODZf+p35mIuLCziOQ1BQkMR2TRwXQLqxSUhIgIODA4yMjGBoaIhvv/0WiYmJ4v2aNDZUZGmYGzduYPPmzWjRooXE9hUrVmD16tXYsGEDbty4AXNzc/To0UP8CCBN9c8//6Bjx47Q1tbGr7/+iocPHyIwMBA1atQQt6mqYxMQEICQkBBs2LABCQkJWLFiBVauXIn169eL21SFsXn37h1atmyJDRs2lLpfmjFwc3NDdHQ0oqKicOXKFWRnZ6N///4oKioqr7ehEp8bm/fv3+P27dtYuHAhbt++jUOHDuHx48dwcHCQaKeJY/Ol35liMTExuHbtGiwsLErs08RxAb48Nn/99Rc6deqERo0a4cKFC7hz5w4WLlwIXV1dcRuNGhtGNEZWVhZr0KABO336NOvatSubOXMmY4wxkUjEzM3N2fLly8Vtc3NzmZGREQsJCVFTtuXD09OTderUqcz9VXls+vXrxyZOnCixbciQIWzMmDGMsao5NgBYdHS0+GdpxiA9PZ1pa2uzqKgocZtXr14xHo/HTpw4UW65q9qnY1Oa69evMwDsxYsXjLGqMTZljUtSUhKrU6cOu3//Pqtfvz5bs2aNeF9VGBfGSh+bESNGiD9jSqNpY0NnsjTI1KlT0a9fP3Tv3l1i+7NnzyAUCtGzZ0/xNoFAgK5du+Lq1avlnWa5OnLkCOzs7ODo6IivvvoKtra22LJli3h/VR6bTp064ezZs3j8+DEA4M6dO7hy5Qr69u0LoGqPTTFpxuDWrVsoKCiQaGNhYYFmzZpVmXEqlpGRAY7jxGeKq+rYiEQijB07Fh4eHmjatGmJ/VV5XI4dO4aGDRuiV69e+Oqrr9CuXTuJS4qaNjZUZGmIqKgo3L59G/7+/iX2CYVCAICZmZnEdjMzM/E+TfX06VMEBwejQYMGOHnyJFxdXTFjxgxs374dQNUeG09PT4wcORKNGjWCtrY2bG1t4ebmhpEjRwKo2mNTTJoxEAqF0NHRQc2aNctsUxXk5uZi3rx5GDVqlPg5dFV1bAICAsDn8zFjxoxS91fVcUlNTUV2djaWL1+O3r1749SpUxg8eDCGDBmCixcvAtC8saEHRGuAly9fYubMmTh16pTEde1PcRwn8TNjrMQ2TSMSiWBnZ4eff/4ZAGBra4sHDx4gODgY48aNE7erimOzd+9e7Ny5E7t370bTpk0RHx8PNzc3WFhYwMnJSdyuKo7Np+QZg6o0TgUFBfjhhx8gEomwadOmL7bX5LG5desW1q5di9u3b8v8HjV5XACIb6oZOHAgZs2aBQBo1aoVrl69ipCQEHTt2rXMYyvr2NCZLA1w69YtpKamok2bNuDz+eDz+bh48SLWrVsHPp8v/iv8078CUlNTS/yFrmlq166NJk2aSGxr3Lix+E4Wc3NzAFVzbDw8PDBv3jz88MMPaN68OcaOHYtZs2aJz4ZW5bEpJs0YmJubIz8/H//880+ZbTRZQUEBhg8fjmfPnuH06dPis1hA1Ryby5cvIzU1FfXq1RN/Hr948QKzZ8+GlZUVgKo5LgBgamoKPp//xc9kTRobKrI0wPfff4979+4hPj5e/LKzs8Po0aMRHx8PGxsbmJub4/Tp0+Jj8vPzcfHiRXTo0EGNmatex44d8ejRI4ltjx8/Rv369QEA1tbWVXZs3r9/Dx5P8iNAS0tL/NdmVR6bYtKMQZs2baCtrS3RJiUlBffv39f4cSousJ48eYIzZ87AxMREYn9VHJuxY8fi7t27Ep/HFhYW8PDwwMmTJwFUzXEBAB0dHfzvf//77Geyxo2N+ubcE1X6+O5Cxhhbvnw5MzIyYocOHWL37t1jI0eOZLVr12aZmZnqS7IcXL9+nfH5fObn58eePHnCdu3axfT19dnOnTvFbarq2Dg5ObE6deqwX375hT179owdOnSImZqasrlz54rbVIWxycrKYnFxcSwuLo4BYKtXr2ZxcXHiO+SkGQNXV1dWt25ddubMGXb79m1mb2/PWrZsyQoLC9X1tpTic2NTUFDAHBwcWN26dVl8fDxLSUkRv/Ly8sQxNHFsvvQ786lP7y5kTDPHhbEvj82hQ4eYtrY227x5M3vy5Albv34909LSYpcvXxbH0KSxoSJLQ31aZIlEIubj48PMzc2ZQCBgXbp0Yffu3VNfguXo6NGjrFmzZkwgELBGjRqxzZs3S+yvqmOTmZnJZs6cyerVq8d0dXWZjY0NW7BggcQXZFUYm/PnzzMAJV5OTk6MMenGICcnh02bNo0ZGxszPT091r9/f5aYmKiGd6NcnxubZ8+elboPADt//rw4hiaOzZd+Zz5VWpGliePCmHRjs3XrVvbNN98wXV1d1rJlSxYTEyMRQ5PGhmOMsfI4Y0YIIYQQUpXQnCxCCCGEEBWgIosQQgghRAWoyCKEEEIIUQEqsgghhBBCVICKLEIIIYQQFaAiixBCCCFEBajIIoQQQghRASqyCCGEEEJUgIosQgj5iJWVFTiOA8dxSE9PBwBERESgRo0aSu9r/Pjx4r5iYmKUHp8Qol5UZBFCNE5RURE6dOiAoUOHSmzPyMiApaUlvL29P3u8r68vUlJSYGRkpMo0sXbtWqSkpKi0D0KI+lCRRQjROFpaWoiMjMSJEyewa9cu8fbp06fD2NgYixYt+uzxhoaGMDc3B8dxKs3TyMgI5ubmKu2DEKI+VGQRQjRSgwYN4O/vj+nTpyM5ORmHDx9GVFQUIiMjoaOjo1DsN2/eoG3btnBwcEBubi4uXLgAjuNw8uRJ2NraQk9PD/b29khNTcWvv/6Kxo0bo3r16hg5ciTev3+vpHdICKno+OpOgBBCVGX69OmIjo7GuHHjcO/ePSxatAitWrVSKGZSUhJ69uwJOzs7hIeHg8//72N08eLF2LBhA/T19TF8+HAMHz4cAoEAu3fvRnZ2NgYPHoz169fD09NTwXdGCKkM6EwWIURjcRyH4OBgnD17FmZmZpg3b55C8R4/foyOHTuie/fuiIyMlCiwAGDZsmXo2LEjbG1tMWnSJFy8eBHBwcGwtbVF586dMWzYMJw/f16hHAghlQcVWYQQjRYeHg59fX08e/YMSUlJcsfJyclBp06dMGjQIKxbt67U+VotWrQQ/7uZmRn09fVhY2MjsS01NVXuHAghlQsVWYQQjRUbG4s1a9bg8OHDaN++PSZNmgTGmFyxBAIBunfvjmPHjpVZrGlra4v/neM4iZ+Lt4lEIrn6J4RUPlRkEUI0Uk5ODpycnODi4oLu3bsjLCwMN27cQGhoqFzxeDweduzYgTZt2sDe3h7JyclKzpgQommoyCKEaKR58+ZBJBIhICAAAFCvXj0EBgbCw8MDz58/lyumlpYWdu3ahZYtW8Le3h5CoVCJGRNCNA0VWYQQjXPx4kVs3LgRERERMDAwEG+fPHkyOnTooNBlQz6fjz179qBp06biZRoIIaQ0HJP3k4YQQjSQlZUV3Nzc4ObmVm59chyH6OhoDBo0qNz6JISoHp3JIoSQT3h6eqJatWrIyMhQaT+urq6oVq2aSvsghKgPnckihJCPvHjxAgUFBQAAGxsb8Hiq+1s0NTUVmZmZAIDatWtLXNokhFR+VGQRQgghhKgAXS4khBBCCFEBKrIIIYQQQlSAiixCCCGEEBWgIosQQgghRAWoyCKEEEIIUQEqsgghhBBCVICKLEIIIYQQFaAiixBCCCFEBajIIoQQQghRgf8H8w0G03JL6nUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n", + "ds = xr.open_zarr(\"croco_particles3D.zarr\")\n", + "\n", + "ax.plot(ds.lon.T / 1e3, ds.z.T, \".-\")\n", + "\n", + "dsCROCO = xr.open_dataset(file)\n", + "for z in dsCROCO.s_w.values:\n", + " ax.plot(fieldset.H.lon / 1e3, fieldset.H.data[0, 25, :] * z, \"k\", linewidth=0.5)\n", + "ax.set_xlabel(\"X [km]\")\n", + "ax.set_xlim(30, 170)\n", + "ax.set_ylabel(\"Depth [m]\")\n", + "ax.set_title(\"Particles in idealized CROCO velocity field using 3D advection\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A CROCO simulation with no vertical velocities" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It may be insightful to compare this 3D run with the `AdvectionRK4_3D` kernel with a run where the vertical velocity (`W`) is set to zero. In that case, the particles will not stay on their initial depth levels but instead follow sigma-layers." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Output files are stored in croco_particles_noW.zarr.\n", + "100%|██████████| 50000.0/50000.0 [00:00<00:00, 82825.22it/s]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import copy\n", + "\n", + "fieldset_noW = copy.copy(fieldset)\n", + "fieldset_noW.W.data[:] = 0.0\n", + "\n", + "pset_noW = parcels.ParticleSet(\n", + " fieldset=fieldset_noW, pclass=parcels.JITParticle, lon=X, lat=Y, depth=Z\n", + ")\n", + "\n", + "outputfile = pset.ParticleFile(name=\"croco_particles_noW.zarr\", outputdt=5000)\n", + "\n", + "pset_noW.execute(\n", + " [parcels.AdvectionRK4_3D, DeleteParticle],\n", + " runtime=5e4,\n", + " dt=100,\n", + " output_file=outputfile,\n", + ")\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(6, 4))\n", + "ds = xr.open_zarr(\"croco_particles_noW.zarr\")\n", + "\n", + "ax.plot(ds.lon.T / 1e3, ds.z.T, \".-\")\n", + "\n", + "dsCROCO = xr.open_dataset(file)\n", + "for z in dsCROCO.s_w.values:\n", + " ax.plot(fieldset.H.lon / 1e3, fieldset.H.data[0, 25, :] * z, \"k\", linewidth=0.5)\n", + "ax.set_xlabel(\"X [km]\")\n", + "ax.set_xlim(30, 170)\n", + "ax.set_ylabel(\"Depth [m]\")\n", + "ax.set_title(\"Particles in idealized CROCO velocity field with W=0\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The algorithms used" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When using `FieldSet.from_croco()`, Parcels knows that depth needs to be converted to sigma-coordinates, before doing any interpolation. This is done under the hood, using code for interpolation (in this case a `T` Field) like\n", + "```python\n", + "sigma = particle.depth / fieldset.H[time, particle.depth, particle.lat, particle.lon]\n", + "temp = fieldset.T[time, sigma, particle.lat, particle.lon]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the `AdvectionRK4_3D` kernel, Parcels will replace the kernel with `AdvectionRK4_3D_CROCO`, which works slightly different from the normal 3D advection kernel because it converts the vertical velocity in sigma-units.\n", + "\n", + "In particular, the following algorithm is used (note that the RK4 version is slightly more complex than this Euler-Forward version, but the idea is identical)\n", + "\n", + "```python\n", + "# calculate local sigma level of particle, by scaling depth by local ocean depth H\n", + "sigma = particle.depth / fieldset.H[time, particle.depth, particle.lat, particle.lon]\n", + "\n", + "(u, v, w) = fieldset.UVW[time, particle.depth, particle.lat, particle.lon, particle] \n", + "\n", + "# scaling the w with the sigma level of the particle\n", + "w_sigma = w * sigma / fieldset.H[time, particle.depth, particle.lat, particle.lon]\n", + "\n", + "lon_new = particle.lon + u*particle.dt\n", + "lat_new = particle.lat + v*particle.dt\n", + "\n", + "# calculating new sigma level\n", + "sigma_new = sigma + w_sigma*particle.dt \n", + "\n", + "# Converting back from sigma to depth, at _new_ location\n", + "depth_new = sigma_new * fieldset.H[time, particle.depth, lat_new, lon_new]\n", + "```" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "parcels", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/parcels/application_kernels/advection.py b/parcels/application_kernels/advection.py index 9defaaad1..8c5df40d1 100644 --- a/parcels/application_kernels/advection.py +++ b/parcels/application_kernels/advection.py @@ -4,7 +4,14 @@ from parcels.tools.statuscodes import StatusCode -__all__ = ["AdvectionRK4", "AdvectionEE", "AdvectionRK45", "AdvectionRK4_3D", "AdvectionAnalytical"] +__all__ = [ + "AdvectionRK4", + "AdvectionEE", + "AdvectionRK45", + "AdvectionRK4_3D", + "AdvectionAnalytical", + "AdvectionRK4_3D_CROCO", +] def AdvectionRK4(particle, fieldset, time): @@ -40,6 +47,51 @@ def AdvectionRK4_3D(particle, fieldset, time): particle_ddepth += (w1 + 2 * w2 + 2 * w3 + w4) / 6 * particle.dt # noqa +def AdvectionRK4_3D_CROCO(particle, fieldset, time): + """Advection of particles using fourth-order Runge-Kutta integration including vertical velocity. + This kernel assumes the vertical velocity is the 'w' field from CROCO output and works on sigma-layers. + """ + sig_dep = particle.depth / fieldset.H[time, 0, particle.lat, particle.lon] + + (u1, v1, w1) = fieldset.UVW[time, particle.depth, particle.lat, particle.lon, particle] + w1 *= sig_dep / fieldset.H[time, 0, particle.lat, particle.lon] + lon1 = particle.lon + u1 * 0.5 * particle.dt + lat1 = particle.lat + v1 * 0.5 * particle.dt + sig_dep1 = sig_dep + w1 * 0.5 * particle.dt + dep1 = sig_dep1 * fieldset.H[time, 0, lat1, lon1] + + (u2, v2, w2) = fieldset.UVW[time + 0.5 * particle.dt, dep1, lat1, lon1, particle] + w2 *= sig_dep1 / fieldset.H[time, 0, lat1, lon1] + lon2 = particle.lon + u2 * 0.5 * particle.dt + lat2 = particle.lat + v2 * 0.5 * particle.dt + sig_dep2 = sig_dep + w2 * 0.5 * particle.dt + dep2 = sig_dep2 * fieldset.H[time, 0, lat2, lon2] + + (u3, v3, w3) = fieldset.UVW[time + 0.5 * particle.dt, dep2, lat2, lon2, particle] + w3 *= sig_dep2 / fieldset.H[time, 0, lat2, lon2] + lon3 = particle.lon + u3 * particle.dt + lat3 = particle.lat + v3 * particle.dt + sig_dep3 = sig_dep + w3 * particle.dt + dep3 = sig_dep3 * fieldset.H[time, 0, lat3, lon3] + + (u4, v4, w4) = fieldset.UVW[time + particle.dt, dep3, lat3, lon3, particle] + w4 *= sig_dep3 / fieldset.H[time, 0, lat3, lon3] + lon4 = particle.lon + u4 * particle.dt + lat4 = particle.lat + v4 * particle.dt + sig_dep4 = sig_dep + w4 * particle.dt + dep4 = sig_dep4 * fieldset.H[time, 0, lat4, lon4] + + particle_dlon += (u1 + 2 * u2 + 2 * u3 + u4) / 6 * particle.dt # noqa + particle_dlat += (v1 + 2 * v2 + 2 * v3 + v4) / 6 * particle.dt # noqa + particle_ddepth += ( # noqa + (dep1 - particle.depth) * 2 + + 2 * (dep2 - particle.depth) * 2 + + 2 * (dep3 - particle.depth) + + dep4 + - particle.depth + ) / 6 + + def AdvectionEE(particle, fieldset, time): """Advection of particles using Explicit Euler (aka Euler Forward) integration.""" (u1, v1) = fieldset.UV[particle] diff --git a/parcels/compilation/codegenerator.py b/parcels/compilation/codegenerator.py index e7eef09cc..c8b746c9e 100644 --- a/parcels/compilation/codegenerator.py +++ b/parcels/compilation/codegenerator.py @@ -80,12 +80,13 @@ def __init__(self, field): class VectorFieldEvalNode(IntrinsicNode): - def __init__(self, field, args, var, var2, var3, convert=True): + def __init__(self, field, args, var, var2, var3, var4, convert=True): self.field = field self.args = args self.var = var # the variable in which the interpolated field is written self.var2 = var2 # second variable for UV interpolation self.var3 = var3 # third variable for UVW interpolation + self.var4 = var4 # extra variable for sigma-scaling for croco self.convert = convert # whether to convert the result (like field.applyConversion) @@ -107,12 +108,13 @@ def __getitem__(self, attr): class NestedVectorFieldEvalNode(IntrinsicNode): - def __init__(self, fields, args, var, var2, var3): + def __init__(self, fields, args, var, var2, var3, var4): self.fields = fields self.args = args self.var = var # the variable in which the interpolated field is written self.var2 = var2 # second variable for UV interpolation self.var3 = var3 # third variable for UVW interpolation + self.var4 = var4 # extra variable for sigma-scaling for croco class GridNode(IntrinsicNode): @@ -285,9 +287,10 @@ def visit_Subscript(self, node): elif isinstance(node.value, VectorFieldNode): tmp = self.get_tmp() tmp2 = self.get_tmp() - tmp3 = self.get_tmp() if node.value.obj.vector_type == "3D" else None + tmp3 = self.get_tmp() if "3D" in node.value.obj.vector_type else None + tmp4 = self.get_tmp() if "3DSigma" in node.value.obj.vector_type else None # Insert placeholder node for field eval ... - self.stmt_stack += [VectorFieldEvalNode(node.value, node.slice, tmp, tmp2, tmp3)] + self.stmt_stack += [VectorFieldEvalNode(node.value, node.slice, tmp, tmp2, tmp3, tmp4)] # .. and return the name of the temporary that will be populated if tmp3: return ast.Tuple([ast.Name(id=tmp), ast.Name(id=tmp2), ast.Name(id=tmp3)], ast.Load()) @@ -300,8 +303,9 @@ def visit_Subscript(self, node): elif isinstance(node.value, NestedVectorFieldNode): tmp = self.get_tmp() tmp2 = self.get_tmp() - tmp3 = self.get_tmp() if list.__getitem__(node.value.obj, 0).vector_type == "3D" else None - self.stmt_stack += [NestedVectorFieldEvalNode(node.value, node.slice, tmp, tmp2, tmp3)] + tmp3 = self.get_tmp() if "3D" in list.__getitem__(node.value.obj, 0).vector_type else None + tmp4 = self.get_tmp() if "3DSigma" in list.__getitem__(node.value.obj, 0).vector_type else None + self.stmt_stack += [NestedVectorFieldEvalNode(node.value, node.slice, tmp, tmp2, tmp3, tmp4)] if tmp3: return ast.Tuple([ast.Name(id=tmp), ast.Name(id=tmp2), ast.Name(id=tmp3)], ast.Load()) else: @@ -371,7 +375,8 @@ def visit_Call(self, node): # get a temporary value to assign result to tmp1 = self.get_tmp() tmp2 = self.get_tmp() - tmp3 = self.get_tmp() if node.func.field.obj.vector_type == "3D" else None + tmp3 = self.get_tmp() if "3D" in node.func.field.obj.vector_type else None + tmp4 = self.get_tmp() if "3DSigma" in node.func.field.obj.vector_type else None # whether to convert convert = True if "applyConversion" in node.keywords: @@ -382,7 +387,7 @@ def visit_Call(self, node): # convert args to Index(Tuple(*args)) args = ast.Index(value=ast.Tuple(node.args, ast.Load())) - self.stmt_stack += [VectorFieldEvalNode(node.func.field, args, tmp1, tmp2, tmp3, convert)] + self.stmt_stack += [VectorFieldEvalNode(node.func.field, args, tmp1, tmp2, tmp3, tmp4, convert)] if tmp3: return ast.Tuple([ast.Name(id=tmp1), ast.Name(id=tmp2), ast.Name(id=tmp3)], ast.Load()) else: @@ -421,6 +426,8 @@ def __init__(self, fieldset=None, ptype=JITParticle): self.fieldset = fieldset self.ptype = ptype self.field_args = collections.OrderedDict() + if isinstance(fieldset.U, Field) and fieldset.U.gridindexingtype == "croco" and hasattr(fieldset, "H"): + self.field_args["H"] = fieldset.H # CROCO requires H field self.vector_field_args = collections.OrderedDict() self.const_args = collections.OrderedDict() @@ -456,7 +463,7 @@ def generate(self, py_ast, funcvars: list[str]): for kvar in self.kernel_vars + self.array_vars: if kvar in funcvars: funcvars.remove(kvar) - self.ccode.body.insert(0, c.Value("int", "parcels_interp_state")) + self.ccode.body.insert(0, c.Statement("int parcels_interp_state = 0")) if len(funcvars) > 0: for f in funcvars: self.ccode.body.insert(0, c.Statement(f"type_coord {f} = 0")) @@ -819,6 +826,16 @@ def visit_FieldEvalNode(self, node): self.visit(node.field) self.visit(node.args) args = self._check_FieldSamplingArguments(node.args.ccode) + statements_croco = [] + if "croco" in node.field.obj.gridindexingtype and node.field.obj.name != "H": # TODO needs to be sigma + statements_croco.append( + c.Assign( + "parcels_interp_state", + f"temporal_interpolation({args[3]}, {args[2]}, 0, time, H, &particles->xi[pnum*ngrid], &particles->yi[pnum*ngrid], &particles->zi[pnum*ngrid], &particles->ti[pnum*ngrid], &{node.var}, LINEAR, {node.field.obj.gridindexingtype.upper()})", + ) + ) + statements_croco.append(c.Statement(f"{node.var} = {args[1]}/{node.var}")) + args = (args[0], node.var, args[2], args[3]) ccode_eval = node.field.obj.ccode_eval(node.var, *args) stmts = [ c.Assign("parcels_interp_state", ccode_eval), @@ -830,12 +847,22 @@ def visit_FieldEvalNode(self, node): conv_stat = c.Statement(f"{node.var} *= {ccode_conv}") stmts += [conv_stat] - node.ccode = c.Block(stmts + [c.Statement("CHECKSTATUS_KERNELLOOP(parcels_interp_state)")]) + node.ccode = c.Block(statements_croco + stmts + [c.Statement("CHECKSTATUS_KERNELLOOP(parcels_interp_state)")]) def visit_VectorFieldEvalNode(self, node): self.visit(node.field) self.visit(node.args) args = self._check_FieldSamplingArguments(node.args.ccode) + statements_croco = [] + if "3DSigma" in node.field.obj.vector_type: + statements_croco.append( + c.Assign( + "parcels_interp_state", + f"temporal_interpolation({args[3]}, {args[2]}, 0, time, H, &particles->xi[pnum*ngrid], &particles->yi[pnum*ngrid], &particles->zi[pnum*ngrid], &particles->ti[pnum*ngrid], &{node.var}, LINEAR, {node.field.obj.U.gridindexingtype.upper()})", + ) + ) + statements_croco.append(c.Statement(f"{node.var4} = {args[1]}/{node.var}")) + args = (args[0], node.var4, args[2], args[3]) ccode_eval = node.field.obj.ccode_eval( node.var, node.var2, node.var3, node.field.obj.U, node.field.obj.V, node.field.obj.W, *args ) @@ -845,12 +872,13 @@ def visit_VectorFieldEvalNode(self, node): statements = [c.Statement(f"{node.var} *= {ccode_conv1}"), c.Statement(f"{node.var2} *= {ccode_conv2}")] else: statements = [] - if node.convert and node.field.obj.vector_type == "3D": + if node.convert and "3D" in node.field.obj.vector_type: ccode_conv3 = node.field.obj.W.ccode_convert(*args) statements.append(c.Statement(f"{node.var3} *= {ccode_conv3}")) conv_stat = c.Block(statements) node.ccode = c.Block( [ + c.Block(statements_croco), c.Assign("parcels_interp_state", ccode_eval), c.Assign("particles->state[pnum]", "max(particles->state[pnum], parcels_interp_state)"), conv_stat, @@ -891,7 +919,7 @@ def visit_NestedVectorFieldEvalNode(self, node): statements = [c.Statement(f"{node.var} *= {ccode_conv1}"), c.Statement(f"{node.var2} *= {ccode_conv2}")] else: statements = [] - if fld.vector_type == "3D": + if "3D" in fld.vector_type: ccode_conv3 = fld.W.ccode_convert(*args) statements.append(c.Statement(f"{node.var3} *= {ccode_conv3}")) cstat += [ diff --git a/parcels/field.py b/parcels/field.py index 7546a2783..633b6fc80 100644 --- a/parcels/field.py +++ b/parcels/field.py @@ -60,7 +60,7 @@ def _deal_with_errors(error, key, vector_type: VectorType): else: raise RuntimeError(f"{error}. Error could not be handled because particle was not part of the Field Sampling.") - if vector_type == "3D": + if vector_type and "3D" in vector_type: return (0, 0, 0) elif vector_type == "2D": return (0, 0) @@ -411,7 +411,7 @@ def from_netcdf( that case Parcels deals with a better memory management during particle set execution. deferred_load=False is however sometimes necessary for plotting the fields. gridindexingtype : str - The type of gridindexing. Either 'nemo' (default) or 'mitgcm' are supported. + The type of gridindexing. Either 'nemo' (default), 'mitgcm', 'mom5', 'pop', or 'croco' are supported. See also the Grid indexing documentation on oceanparcels.org chunksize : size of the chunks in dask loading @@ -487,6 +487,7 @@ def from_netcdf( depth_filename = depth_filename[0] netcdf_engine = kwargs.pop("netcdf_engine", "netcdf4") + gridindexingtype = kwargs.get("gridindexingtype", "nemo") indices = {} if indices is None else indices.copy() for ind in indices: @@ -494,10 +495,10 @@ def from_netcdf( raise RuntimeError(f"Indices for {ind} can not be empty") assert np.min(indices[ind]) >= 0, ( "Negative indices are currently not allowed in Parcels. " - "This is related to the non-increasing dimension it could generate " - "if the domain goes from lon[-4] to lon[6] for example. " - "Please raise an issue on https://github.com/OceanParcels/parcels/issues " - "if you would need such feature implemented." + + "This is related to the non-increasing dimension it could generate " + + "if the domain goes from lon[-4] to lon[6] for example. " + + "Please raise an issue on https://github.com/OceanParcels/parcels/issues " + + "if you would need such feature implemented." ) interp_method: InterpMethod = kwargs.pop("interp_method", "linear") @@ -509,7 +510,13 @@ def from_netcdf( _grid_fb_class = NetcdfFileBuffer - with _grid_fb_class(lonlat_filename, dimensions, indices, netcdf_engine) as filebuffer: + with _grid_fb_class( + lonlat_filename, + dimensions, + indices, + netcdf_engine, + gridindexingtype=gridindexingtype, + ) as filebuffer: lon, lat = filebuffer.lonlat indices = filebuffer.indices # Check if parcels_mesh has been explicitly set in file @@ -523,6 +530,7 @@ def from_netcdf( indices, netcdf_engine, interp_method=interp_method, + gridindexingtype=gridindexingtype, ) as filebuffer: filebuffer.name = filebuffer.parse_name(variable[1]) if dimensions["depth"] == "not_yet_set": @@ -851,6 +859,9 @@ def search_indices_vertical_z(self, z): else: raise FieldOutOfBoundSurfaceError(0, 0, z, field=self) elif z > grid.depth[-1]: + # In case of CROCO, allow particles in last (uppermost) layer using depth[-1] + if self.gridindexingtype in ["croco"] and z < 0: + return (-2, 1) raise FieldOutOfBoundError(0, 0, z, field=self) depth_indices = grid.depth <= z if z >= grid.depth[-1]: @@ -1195,7 +1206,7 @@ def interpolator3D(self, ti, z, y, x, time, particle=None): if self.gridindexingtype == "nemo": f0 = self.data[ti, zi, yi + 1, xi + 1] f1 = self.data[ti, zi + 1, yi + 1, xi + 1] - elif self.gridindexingtype == "mitgcm": + elif self.gridindexingtype in ["mitgcm", "croco"]: f0 = self.data[ti, zi, yi, xi] f1 = self.data[ti, zi + 1, yi, xi] return (1 - zeta) * f0 + zeta * f1 @@ -1372,6 +1383,8 @@ def eval(self, time, z, y, x, particle=None, applyConversion=True): """ (ti, periods) = self.time_index(time) time -= periods * (self.grid.time_full[-1] - self.grid.time_full[0]) + if self.gridindexingtype == "croco" and self is not self.fieldset.H: + z = z / self.fieldset.H.eval(time, 0, y, x, particle=particle, applyConversion=False) if ti < self.grid.tdim - 1 and time > self.grid.time[ti]: f0 = self.spatial_interpolation(ti, z, y, x, time, particle=particle) f1 = self.spatial_interpolation(ti + 1, z, y, x, time, particle=particle) @@ -1708,12 +1721,17 @@ def __init__(self, name: str, U: Field, V: Field, W: Field | None = None): self.U = U self.V = V self.W = W - self.vector_type: VectorType = "3D" if W else "2D" + if self.U.gridindexingtype == "croco" and self.W: + self.vector_type: VectorType = "3DSigma" + elif self.W: + self.vector_type = "3D" + else: + self.vector_type = "2D" self.gridindexingtype = U.gridindexingtype if self.U.interp_method == "cgrid_velocity": assert self.V.interp_method == "cgrid_velocity", "Interpolation methods of U and V are not the same." assert self._check_grid_dimensions(U.grid, V.grid), "Dimensions of U and V are not the same." - if W is not None: + if W is not None and self.U.gridindexingtype != "croco": assert W.interp_method == "cgrid_velocity", "Interpolation methods of U and W are not the same." assert self._check_grid_dimensions(U.grid, W.grid), "Dimensions of U and W are not the same." @@ -1773,7 +1791,7 @@ def spatial_c_grid_interpolation2D(self, ti, z, y, x, time, particle=None, apply U1 = self.U.data[ti, yi + 1, xi + 1] * c2 V0 = self.V.data[ti, yi, xi + 1] * c1 V1 = self.V.data[ti, yi + 1, xi + 1] * c3 - elif self.gridindexingtype == "mitgcm": + elif self.gridindexingtype in ["mitgcm", "croco"]: U0 = self.U.data[ti, yi, xi] * c4 U1 = self.U.data[ti, yi, xi + 1] * c2 V0 = self.V.data[ti, yi, xi] * c1 @@ -1784,7 +1802,7 @@ def spatial_c_grid_interpolation2D(self, ti, z, y, x, time, particle=None, apply U1 = self.U.data[ti, zi, yi + 1, xi + 1] * c2 V0 = self.V.data[ti, zi, yi, xi + 1] * c1 V1 = self.V.data[ti, zi, yi + 1, xi + 1] * c3 - elif self.gridindexingtype == "mitgcm": + elif self.gridindexingtype in ["mitgcm", "croco"]: U0 = self.U.data[ti, zi, yi, xi] * c4 U1 = self.U.data[ti, zi, yi, xi + 1] * c2 V0 = self.V.data[ti, zi, yi, xi] * c1 @@ -2041,6 +2059,8 @@ def spatial_c_grid_interpolation3D(self, ti, z, y, x, time, particle=None, apply if self.U.grid.gtype in [GridType.RectilinearSGrid, GridType.CurvilinearSGrid]: (u, v, w) = self.spatial_c_grid_interpolation3D_full(ti, z, y, x, time, particle=particle) else: + if self.gridindexingtype == "croco": + z = z / self.fieldset.H.eval(time, 0, y, x, particle=particle, applyConversion=False) (u, v) = self.spatial_c_grid_interpolation2D(ti, z, y, x, time, particle=particle) w = self.W.eval(time, z, y, x, particle=particle, applyConversion=False) if applyConversion: @@ -2167,7 +2187,7 @@ def eval(self, time, z, y, x, particle=None, applyConversion=True): if applyConversion: u = self.U.units.to_target(u, x, y, z) v = self.V.units.to_target(v, x, y, z) - if self.vector_type == "3D": + if "3D" in self.vector_type: w = self.W.eval(time, z, y, x, particle=particle, applyConversion=False) if applyConversion: w = self.W.units.to_target(w, x, y, z) @@ -2189,7 +2209,7 @@ def eval(self, time, z, y, x, particle=None, applyConversion=True): if ti < grid.tdim - 1 and time > grid.time[ti]: t0 = grid.time[ti] t1 = grid.time[ti + 1] - if self.vector_type == "3D": + if "3D" in self.vector_type: (u0, v0, w0) = interp[self.U.interp_method]["3D"]( ti, z, y, x, time, particle=particle, applyConversion=applyConversion ) @@ -2206,7 +2226,7 @@ def eval(self, time, z, y, x, particle=None, applyConversion=True): ) u = u0 + (u1 - u0) * ((time - t0) / (t1 - t0)) v = v0 + (v1 - v0) * ((time - t0) / (t1 - t0)) - if self.vector_type == "3D": + if "3D" in self.vector_type: return (u, v, w) else: return (u, v) @@ -2214,7 +2234,7 @@ def eval(self, time, z, y, x, particle=None, applyConversion=True): # Skip temporal interpolation if time is outside # of the defined time range or if we have hit an # exact value in the time array. - if self.vector_type == "3D": + if "3D" in self.vector_type: return interp[self.U.interp_method]["3D"]( ti, z, y, x, grid.time[ti], particle=particle, applyConversion=applyConversion ) @@ -2234,7 +2254,7 @@ def __getitem__(self, key): def ccode_eval(self, varU, varV, varW, U, V, W, t, z, y, x): ccode_str = "" - if self.vector_type == "3D": + if "3D" in self.vector_type: ccode_str = ( f"temporal_interpolationUVW({x}, {y}, {z}, {t}, {U.ccode_name}, {V.ccode_name}, {W.ccode_name}, " + "&particles->xi[pnum*ngrid], &particles->yi[pnum*ngrid], &particles->zi[pnum*ngrid], &particles->ti[pnum*ngrid]," diff --git a/parcels/fieldfilebuffer.py b/parcels/fieldfilebuffer.py index fcf13b392..dc3eb0948 100644 --- a/parcels/fieldfilebuffer.py +++ b/parcels/fieldfilebuffer.py @@ -35,6 +35,7 @@ def __init__( self.cast_data_dtype = kwargs.pop("cast_data_dtype", np.float32) self.ti = None self.interp_method = interp_method + self.gridindexingtype = kwargs.pop("gridindexingtype", "nemo") self.data_full_zdim = data_full_zdim if ("lon" in self.indices) or ("lat" in self.indices): self.nolonlatindices = False @@ -92,7 +93,7 @@ def parse_name(self, name): def lonlat(self): lon = self.dataset[self.dimensions["lon"]] lat = self.dataset[self.dimensions["lat"]] - if self.nolonlatindices: + if self.nolonlatindices and self.gridindexingtype not in ["croco"]: if len(lon.shape) < 3: lon_subset = np.array(lon) lat_subset = np.array(lat) @@ -105,6 +106,9 @@ def lonlat(self): else: xdim = lon.size if len(lon.shape) == 1 else lon.shape[-1] ydim = lat.size if len(lat.shape) == 1 else lat.shape[-2] + if self.gridindexingtype in ["croco"]: + xdim -= 1 + ydim -= 1 self.indices["lon"] = self.indices["lon"] if "lon" in self.indices else range(xdim) self.indices["lat"] = self.indices["lat"] if "lat" in self.indices else range(ydim) if len(lon.shape) == 1: @@ -142,6 +146,8 @@ def depth(self): if "depth" in self.dimensions: depth = self.dataset[self.dimensions["depth"]] depthsize = depth.size if len(depth.shape) == 1 else depth.shape[-3] + if self.gridindexingtype in ["croco"]: + depthsize -= 1 self.data_full_zdim = depthsize self.indices["depth"] = self.indices["depth"] if "depth" in self.indices else range(depthsize) if len(depth.shape) == 1: diff --git a/parcels/fieldset.py b/parcels/fieldset.py index c21c1f79a..4bf1c5717 100644 --- a/parcels/fieldset.py +++ b/parcels/fieldset.py @@ -271,8 +271,8 @@ def check_velocityfields(U, V, W): "C-grid velocities require longitude and latitude dimensions at least length 2" ) - if U.gridindexingtype not in ["nemo", "mitgcm", "mom5", "pop"]: - raise ValueError("Field.gridindexing has to be one of 'nemo', 'mitgcm', 'mom5' or 'pop'") + if U.gridindexingtype not in ["nemo", "mitgcm", "mom5", "pop", "croco"]: + raise ValueError("Field.gridindexing has to be one of 'nemo', 'mitgcm', 'mom5', 'pop' or 'croco'") if V.gridindexingtype != U.gridindexingtype or (W and W.gridindexingtype != U.gridindexingtype): raise ValueError("Not all velocity Fields have the same gridindexingtype") @@ -409,7 +409,7 @@ def from_netcdf( Method for interpolation. Options are 'linear' (default), 'nearest', 'linear_invdist_land_tracer', 'cgrid_velocity', 'cgrid_tracer' and 'bgrid_velocity' gridindexingtype : str - The type of gridindexing. Either 'nemo' (default) or 'mitgcm' are supported. + The type of gridindexing. Either 'nemo' (default), 'mitgcm', 'mom5', 'pop', or 'croco' are supported. See also the Grid indexing documentation on oceanparcels.org chunksize : size of the chunks in dask loading. Default is None (no chunking). Can be None or False (no chunking), @@ -681,6 +681,71 @@ def from_mitgcm( ) return fieldset + @classmethod + def from_croco( + cls, + filenames, + variables, + dimensions, + indices=None, + mesh="spherical", + allow_time_extrapolation=None, + time_periodic=False, + tracer_interp_method="cgrid_tracer", + chunksize=None, + **kwargs, + ): + """Initialises FieldSet object from NetCDF files of CROCO fields. + All parameters and keywords are exactly the same as for FieldSet.from_nemo(), except that + the vertical coordinate is scaled by the bathymetry (``h``) field from CROCO, in order to + account for the sigma-grid. The horizontal interpolation uses the MITgcm grid indexing + as described in FieldSet.from_mitgcm(). + + The sigma grid scaling means that FieldSet.from_croco() requires a variable ``H: h`` to work. + + See `the CROCO 3D tutorial <../examples/tutorial_croco_3D.ipynb>`__ for more infomation. + """ + if "creation_log" not in kwargs.keys(): + kwargs["creation_log"] = "from_croco" + if kwargs.pop("gridindexingtype", "croco") != "croco": + raise ValueError( + "gridindexingtype must be 'croco' in FieldSet.from_croco(). Use FieldSet.from_c_grid_dataset otherwise" + ) + + dimsU = dimensions["U"] if "U" in dimensions else dimensions + if ("depth" in dimsU) and ("H" not in variables): + raise ValueError("FieldSet.from_croco() requires a field 'H' for the bathymetry") + + interp_method = {} + for v in variables: + if v in ["U", "V"]: + interp_method[v] = "cgrid_velocity" + elif v in ["W", "H"]: + interp_method[v] = "linear" + else: + interp_method[v] = tracer_interp_method + + # Suppress the warning about the velocity interpolation since it is ok for CROCO + warnings.filterwarnings( + "ignore", + "Sampling of velocities should normally be done using fieldset.UV or fieldset.UVW object; tread carefully", + ) + + fieldset = cls.from_netcdf( + filenames, + variables, + dimensions, + mesh=mesh, + indices=indices, + time_periodic=time_periodic, + allow_time_extrapolation=allow_time_extrapolation, + interp_method=interp_method, + chunksize=chunksize, + gridindexingtype="croco", + **kwargs, + ) + return fieldset + @classmethod def from_c_grid_dataset( cls, @@ -760,7 +825,7 @@ def from_c_grid_dataset( Method for interpolation of tracer fields. It is recommended to use 'cgrid_tracer' (default) Note that in the case of from_nemo() and from_c_grid_dataset(), the velocity fields are default to 'cgrid_velocity' gridindexingtype : str - The type of gridindexing. Set to 'nemo' in FieldSet.from_nemo() + The type of gridindexing. Set to 'nemo' in FieldSet.from_nemo(), 'mitgcm' in FieldSet.from_mitgcm() or 'croco' in FieldSet.from_croco(). See also the Grid indexing documentation on oceanparcels.org (Default value = 'nemo') chunksize : size of the chunks in dask loading. (Default value = None) diff --git a/parcels/include/index_search.h b/parcels/include/index_search.h index bb42b2db6..7aaa63970 100644 --- a/parcels/include/index_search.h +++ b/parcels/include/index_search.h @@ -26,7 +26,7 @@ typedef enum typedef enum { - NEMO = 0, MITGCM = 1, MOM5 = 2, POP = 3 + NEMO = 0, MITGCM = 1, MOM5 = 2, POP = 3, CROCO = 4 } GridIndexingType; typedef struct @@ -105,6 +105,11 @@ static inline StatusCode search_indices_vertical_z(type_coord z, int zdim, float *zeta = z / zvals[0]; return SUCCESS; } + if ((z > zvals[zdim-1]) && (z < 0) && (gridindexingtype == CROCO)){ + *zi = zdim-2; + *zeta = 1; + return SUCCESS; + } if (z < zvals[0]) {return ERRORTHROUGHSURFACE;} if (z > zvals[zdim-1]) {return ERROROUTOFBOUNDS;} while (*zi < zdim-1 && z > zvals[*zi+1]) ++(*zi); diff --git a/parcels/include/parcels.h b/parcels/include/parcels.h index e4d8431e3..645cf90fc 100644 --- a/parcels/include/parcels.h +++ b/parcels/include/parcels.h @@ -505,11 +505,11 @@ static inline StatusCode temporal_interpolation_structured_grid(type_coord x, ty (interp_method == BGRID_VELOCITY) || (interp_method == BGRID_W_VELOCITY)) { // adjust the normalised coordinate for flux-based interpolation methods if ((interp_method == CGRID_VELOCITY) || (interp_method == BGRID_W_VELOCITY)) { - if ((gridindexingtype == NEMO) || (gridindexingtype == MOM5) || (gridindexingtype == POP)) { + if ((gridindexingtype == NEMO) || (gridindexingtype == MOM5) || (gridindexingtype == POP)) { // velocity is on the northeast of a tracer cell xsi = 1; eta = 1; - } else if (gridindexingtype == MITGCM) { + } else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { // velocity is on the southwest of a tracer cell xsi = 0; eta = 0; @@ -670,7 +670,7 @@ static inline StatusCode temporal_interpolationUV_c_grid(type_coord x, type_coor status = getCell2D(U, xi[igrid], yi[igrid], ti[igrid], data2D_U, 0); CHECKSTATUS(status); status = getCell2D(V, xi[igrid], yi[igrid], ti[igrid], data2D_V, 0); CHECKSTATUS(status); } - else if (gridindexingtype == MITGCM) { + else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { status = getCell2D(U, xi[igrid], yi[igrid]-1, ti[igrid], data2D_U, 0); CHECKSTATUS(status); status = getCell2D(V, xi[igrid]-1, yi[igrid], ti[igrid], data2D_V, 0); CHECKSTATUS(status); } @@ -683,7 +683,7 @@ static inline StatusCode temporal_interpolationUV_c_grid(type_coord x, type_coor status = getCell3D(U, xi[igrid], yi[igrid], zi[igrid], ti[igrid], data3D_U, 0); CHECKSTATUS(status); status = getCell3D(V, xi[igrid], yi[igrid], zi[igrid], ti[igrid], data3D_V, 0); CHECKSTATUS(status); } - else if (gridindexingtype == MITGCM) { + else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { status = getCell3D(U, xi[igrid], yi[igrid]-1, zi[igrid], ti[igrid], data3D_U, 0); CHECKSTATUS(status); status = getCell3D(V, xi[igrid]-1, yi[igrid], zi[igrid], ti[igrid], data3D_V, 0); CHECKSTATUS(status); } @@ -702,7 +702,7 @@ static inline StatusCode temporal_interpolationUV_c_grid(type_coord x, type_coor status = getCell2D(U, xi[igrid], yi[igrid], ti[igrid], data2D_U, 1); CHECKSTATUS(status); status = getCell2D(V, xi[igrid], yi[igrid], ti[igrid], data2D_V, 1); CHECKSTATUS(status); } - else if (gridindexingtype == MITGCM) { + else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { status = getCell2D(U, xi[igrid], yi[igrid]-1, ti[igrid], data2D_U, 1); CHECKSTATUS(status); status = getCell2D(V, xi[igrid]-1, yi[igrid], ti[igrid], data2D_V, 1); CHECKSTATUS(status); } @@ -714,7 +714,7 @@ static inline StatusCode temporal_interpolationUV_c_grid(type_coord x, type_coor status = getCell3D(U, xi[igrid], yi[igrid], zi[igrid], ti[igrid], data3D_U, 1); CHECKSTATUS(status); status = getCell3D(V, xi[igrid], yi[igrid], zi[igrid], ti[igrid], data3D_V, 1); CHECKSTATUS(status); } - else if (gridindexingtype == MITGCM){ + else if ((gridindexingtype == MITGCM) || (gridindexingtype == CROCO)) { status = getCell3D(U, xi[igrid], yi[igrid]-1, zi[igrid], ti[igrid], data3D_U, 1); CHECKSTATUS(status); status = getCell3D(V, xi[igrid]-1, yi[igrid], zi[igrid], ti[igrid], data3D_V, 1); CHECKSTATUS(status); } @@ -1236,6 +1236,8 @@ static inline StatusCode temporal_interpolationUVW(type_coord x, type_coord y, t status = temporal_interpolationUV(x, y, z, time, U, V, xi, yi, zi, ti, valueU, valueV, interp_method, gridindexingtype); CHECKSTATUS(status); if (interp_method == BGRID_VELOCITY) interp_method = BGRID_W_VELOCITY; + if (gridindexingtype == CROCO) // Linear vertical interpolation for CROCO + interp_method = LINEAR; status = temporal_interpolation(x, y, z, time, W, xi, yi, zi, ti, valueW, interp_method, gridindexingtype); CHECKSTATUS(status); return SUCCESS; } diff --git a/parcels/kernel.py b/parcels/kernel.py index c20bcc264..81c838d41 100644 --- a/parcels/kernel.py +++ b/parcels/kernel.py @@ -25,6 +25,7 @@ from parcels.application_kernels.advection import ( AdvectionAnalytical, AdvectionRK4_3D, + AdvectionRK4_3D_CROCO, AdvectionRK45, ) from parcels.compilation.codegenerator import KernelGenerator, LoopGenerator @@ -193,6 +194,10 @@ def __init__( # Derive meta information from pyfunc, if not given self.check_fieldsets_in_kernels(pyfunc) + if (pyfunc is AdvectionRK4_3D) and fieldset.U.gridindexingtype == "croco": + pyfunc = AdvectionRK4_3D_CROCO + self.funcname = "AdvectionRK4_3D_CROCO" + if funcvars is not None: self.funcvars = funcvars elif hasattr(pyfunc, "__code__"): diff --git a/parcels/tools/exampledata_utils.py b/parcels/tools/exampledata_utils.py index a57b2b4c3..7a1192f3d 100644 --- a/parcels/tools/exampledata_utils.py +++ b/parcels/tools/exampledata_utils.py @@ -72,6 +72,7 @@ "field_0065557.nc", ], "WOA_data": [f"woa18_decav_t{m:02d}_04.nc" for m in range(1, 13)], + "CROCOidealized_data": ["CROCO_idealized.nc"], } diff --git a/tests/test_advection.py b/tests/test_advection.py index d2c283b66..4b0525efa 100644 --- a/tests/test_advection.py +++ b/tests/test_advection.py @@ -1,4 +1,5 @@ import math +import os from datetime import timedelta import numpy as np @@ -19,6 +20,7 @@ ParticleSet, ScipyParticle, StatusCode, + Variable, ) ptype = {"scipy": ScipyParticle, "jit": JITParticle} @@ -193,6 +195,44 @@ def test_advection_RK45(lon, lat, mode, rk45_tol): print(fieldset.RK45_tol) +@pytest.mark.parametrize("mode", ["scipy", "jit"]) +def test_advection_3DCROCO(mode): + data_path = os.path.join(os.path.dirname(__file__), "test_data/") + fieldset = FieldSet.from_modulefile(data_path + "fieldset_CROCO3D.py") + assert fieldset.U.creation_log == "from_croco" + + runtime = 1e4 + X, Z = np.meshgrid([40e3, 80e3, 120e3], [-10, -130]) + Y = np.ones(X.size) * 100e3 + + pclass = ptype[mode].add_variable(Variable("w")) + pset = ParticleSet(fieldset=fieldset, pclass=pclass, lon=X, lat=Y, depth=Z) + + def SampleW(particle, fieldset, time): + particle.w = fieldset.W[time, particle.depth, particle.lat, particle.lon] + + pset.execute([AdvectionRK4_3D, SampleW], runtime=runtime, dt=100) + assert np.allclose(pset.depth, Z.flatten(), atol=5) # TODO lower this atol + assert np.allclose(pset.lon_nextloop, [x + runtime for x in X.flatten()], atol=1e-3) + + +@pytest.mark.parametrize("mode", ["scipy", "jit"]) +def test_advection_2DCROCO(mode): + data_path = os.path.join(os.path.dirname(__file__), "test_data/") + fieldset = FieldSet.from_modulefile(data_path + "fieldset_CROCO2D.py") + assert fieldset.U.creation_log == "from_croco" + + runtime = 1e4 + X = np.array([40e3, 80e3, 120e3]) + Y = np.ones(X.size) * 100e3 + Z = np.zeros(X.size) + pset = ParticleSet(fieldset=fieldset, pclass=ptype[mode], lon=X, lat=Y, depth=Z) + + pset.execute([AdvectionRK4], runtime=runtime, dt=100) + assert np.allclose(pset.depth, Z.flatten(), atol=1e-3) + assert np.allclose(pset.lon_nextloop, [x + runtime for x in X], atol=1e-3) + + def create_periodic_fieldset(xdim, ydim, uvel, vvel): dimensions = { "lon": np.linspace(0.0, 1.0, xdim + 1, dtype=np.float32)[1:], # don't include both 0 and 1, for periodic b.c. diff --git a/tests/test_data/CROCO_idealized.nc b/tests/test_data/CROCO_idealized.nc new file mode 100644 index 000000000..a68eeebcb Binary files /dev/null and b/tests/test_data/CROCO_idealized.nc differ diff --git a/tests/test_data/fieldset_CROCO2D.py b/tests/test_data/fieldset_CROCO2D.py new file mode 100644 index 000000000..eef89cb34 --- /dev/null +++ b/tests/test_data/fieldset_CROCO2D.py @@ -0,0 +1,22 @@ +import os + +import parcels + + +def create_fieldset(indices=None): + file = os.path.join(os.path.dirname(__file__), "CROCO_idealized.nc") + + variables = {"U": "u", "V": "v"} + dimensions = { + "U": {"lon": "x_rho", "lat": "y_rho", "time": "time"}, + "V": {"lon": "x_rho", "lat": "y_rho", "time": "time"}, + } + fieldset = parcels.FieldSet.from_croco( + file, + variables, + dimensions, + allow_time_extrapolation=True, + mesh="flat", + ) + + return fieldset diff --git a/tests/test_data/fieldset_CROCO3D.py b/tests/test_data/fieldset_CROCO3D.py new file mode 100644 index 000000000..3fdde70fc --- /dev/null +++ b/tests/test_data/fieldset_CROCO3D.py @@ -0,0 +1,24 @@ +import os + +import parcels + + +def create_fieldset(indices=None): + file = os.path.join(os.path.dirname(__file__), "CROCO_idealized.nc") + + variables = {"U": "u", "V": "v", "W": "w", "H": "h"} + dimensions = { + "U": {"lon": "x_rho", "lat": "y_rho", "depth": "s_w", "time": "time"}, + "V": {"lon": "x_rho", "lat": "y_rho", "depth": "s_w", "time": "time"}, + "W": {"lon": "x_rho", "lat": "y_rho", "depth": "s_w", "time": "time"}, + "H": {"lon": "x_rho", "lat": "y_rho"}, + } + fieldset = parcels.FieldSet.from_croco( + file, + variables, + dimensions, + allow_time_extrapolation=True, + mesh="flat", + ) + + return fieldset diff --git a/tests/test_fieldset_sampling.py b/tests/test_fieldset_sampling.py index 9262b7ccb..d0fac898a 100644 --- a/tests/test_fieldset_sampling.py +++ b/tests/test_fieldset_sampling.py @@ -1,3 +1,4 @@ +import os from datetime import timedelta from math import cos, pi @@ -616,6 +617,21 @@ def test_sampling_out_of_bounds_time(mode, allow_time_extrapolation): pset.execute(SampleP, runtime=0.1, dt=0.1) +@pytest.mark.parametrize("mode", ["scipy", "jit"]) +def test_sampling_3DCROCO(mode, npart=10): + data_path = os.path.join(os.path.dirname(__file__), "test_data/") + fieldset = FieldSet.from_modulefile(data_path + "fieldset_CROCO3D.py") + + SampleP = ptype[mode].add_variable("p", initial=0.0) + + def SampleU(particle, fieldset, time): + particle.p = fieldset.U[time, particle.depth, particle.lat, particle.lon, particle] + + pset = ParticleSet(fieldset, pclass=SampleP, lon=120e3, lat=50e3, depth=-0.4) + pset.execute(SampleU, endtime=1, dt=1) + assert np.isclose(pset.p, 1.0) + + @pytest.mark.parametrize("mode", ["jit", "scipy"]) @pytest.mark.parametrize("npart", [1, 10]) @pytest.mark.parametrize("chs", [False, "auto", {"lat": ("y", 10), "lon": ("x", 10)}])