diff --git a/Figures.ipynb b/Figures.ipynb index d7144f3..904b155 100644 --- a/Figures.ipynb +++ b/Figures.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -36,123 +36,9 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 5, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " dt n_cuda_devices n_processes n_time_steps nx ny \\\n", - "11 0.00001 1 1 202.0 4096.0 4096.0 \n", - "7 0.00001 2 2 202.0 4096.0 4096.0 \n", - "14 0.00001 3 3 202.0 4096.0 4096.0 \n", - "0 0.00001 4 4 202.0 4096.0 4096.0 \n", - "5 0.00001 5 5 202.0 4096.0 4096.0 \n", - "8 0.00001 6 6 202.0 4096.0 4096.0 \n", - "2 0.00001 7 7 202.0 4096.0 4096.0 \n", - "1 0.00001 8 8 202.0 4096.0 4096.0 \n", - "15 0.00001 9 9 202.0 4096.0 4096.0 \n", - "9 0.00001 10 10 202.0 4096.0 4096.0 \n", - "6 0.00001 11 11 202.0 4096.0 4096.0 \n", - "12 0.00001 12 12 202.0 4096.0 4096.0 \n", - "3 0.00001 13 13 202.0 4096.0 4096.0 \n", - "4 0.00001 14 14 202.0 4096.0 4096.0 \n", - "10 0.00001 15 15 202.0 4096.0 4096.0 \n", - "13 0.00001 16 16 202.0 4096.0 4096.0 \n", - "\n", - " outfile slurm_job_id t_init \\\n", - "11 /work/martinls/220879/ShallowWaterGPU/mpi_out_... 220879.0 5.507971 \n", - "7 /work/martinls/220880/ShallowWaterGPU/mpi_out_... 220880.0 5.721808 \n", - "14 /work/martinls/220881/ShallowWaterGPU/mpi_out_... 220881.0 5.717571 \n", - "0 /work/martinls/220882/ShallowWaterGPU/mpi_out_... 220882.0 6.074582 \n", - "5 /work/martinls/220883/ShallowWaterGPU/mpi_out_... 220883.0 6.108083 \n", - "8 /work/martinls/220884/ShallowWaterGPU/mpi_out_... 220884.0 5.634954 \n", - "2 /work/martinls/220885/ShallowWaterGPU/mpi_out_... 220885.0 5.070476 \n", - "1 /work/martinls/220886/ShallowWaterGPU/mpi_out_... 220886.0 4.180240 \n", - "15 /work/martinls/220887/ShallowWaterGPU/mpi_out_... 220887.0 4.341784 \n", - "9 /work/martinls/220888/ShallowWaterGPU/mpi_out_... 220888.0 5.299585 \n", - "6 /work/martinls/220889/ShallowWaterGPU/mpi_out_... 220889.0 6.026560 \n", - "12 /work/martinls/220890/ShallowWaterGPU/mpi_out_... 220890.0 6.275554 \n", - "3 /work/martinls/220891/ShallowWaterGPU/mpi_out_... 220891.0 7.103848 \n", - "4 /work/martinls/220892/ShallowWaterGPU/mpi_out_... 220892.0 8.413395 \n", - "10 /work/martinls/220893/ShallowWaterGPU/mpi_out_... 220893.0 9.477692 \n", - "13 /work/martinls/220894/ShallowWaterGPU/mpi_out_... 220894.0 9.881657 \n", - "\n", - " t_nc_write t_sim_init t_sim_mpi_init t_step t_step_mpi \\\n", - "11 3.687433 41.936742 0.002744 1.654766 1.635376 \n", - "7 3.692994 22.107036 0.002273 23.791452 1.607910 \n", - "14 3.710237 37.115577 0.002727 10.057041 1.693726 \n", - "0 3.825206 45.152544 0.002787 1.858922 1.732544 \n", - "5 3.833911 45.100539 0.002747 1.893753 1.798096 \n", - "8 3.779569 21.815326 0.003427 20.156193 1.755737 \n", - "2 3.902169 41.552375 0.003021 1.923522 1.733032 \n", - "1 3.880948 25.252051 0.003020 1.858470 1.778198 \n", - "15 3.870645 25.595168 0.002387 1.857388 1.771851 \n", - "9 3.858673 25.574244 0.003054 1.863774 1.784302 \n", - "6 3.944965 26.100656 0.002582 1.899902 1.745728 \n", - "12 3.932847 29.110549 0.003453 4.618246 1.801758 \n", - "3 3.973085 33.206754 0.003094 1.944592 1.778198 \n", - "4 3.987867 28.638798 0.003963 2.088098 1.781616 \n", - "10 3.998516 28.688051 0.002921 1.876371 1.801880 \n", - "13 3.955760 30.579091 0.002603 1.924463 1.780518 \n", - "\n", - " t_step_mpi_halo_exchange t_step_mpi_halo_exchange_download \\\n", - "11 0.0 0.038208 \n", - "7 0.0 0.040833 \n", - "14 0.0 0.039368 \n", - "0 0.0 0.038696 \n", - "5 0.0 0.037964 \n", - "8 0.0 0.038269 \n", - "2 0.0 0.038757 \n", - "1 0.0 0.038025 \n", - "15 0.0 0.037292 \n", - "9 0.0 0.037842 \n", - "6 0.0 0.038269 \n", - "12 0.0 0.037842 \n", - "3 0.0 0.037415 \n", - "4 0.0 0.038818 \n", - "10 0.0 0.038269 \n", - "13 0.0 0.038330 \n", - "\n", - " t_step_mpi_halo_exchange_sendreceive t_step_mpi_halo_exchange_upload \\\n", - "11 0.016968 0.039429 \n", - "7 0.159668 0.046143 \n", - "14 0.139648 0.041931 \n", - "0 0.083252 0.044800 \n", - "5 0.036621 0.040771 \n", - "8 0.090393 0.043579 \n", - "2 0.100586 0.042480 \n", - "1 0.054260 0.041016 \n", - "15 0.061646 0.039795 \n", - "9 0.066345 0.039734 \n", - "6 0.152771 0.040283 \n", - "12 0.051697 0.040100 \n", - "3 0.163818 0.039673 \n", - "4 0.111450 0.041382 \n", - "10 0.072327 0.040405 \n", - "13 0.062927 0.041321 \n", - "\n", - " t_total \n", - "11 53.170382 \n", - "7 55.784859 \n", - "14 57.047498 \n", - "0 57.329107 \n", - "5 57.349928 \n", - "8 51.902805 \n", - "2 52.942312 \n", - "1 35.602447 \n", - "15 36.094733 \n", - "9 36.997667 \n", - "6 38.400811 \n", - "12 44.374620 \n", - "3 46.639225 \n", - "4 43.558686 \n", - "10 44.496923 \n", - "13 46.773383 \n" - ] - } - ], + "outputs": [], "source": [ "def read_profiling_files(profile_dir_path=\".\"):\n", " profiling_data = pd.DataFrame()\n", @@ -162,14 +48,12 @@ " for json_filename in json_filenames:\n", " with open(os.path.join(profile_dir_path, json_filename)) as json_file:\n", " profiling_data = profiling_data.append(json.load(json_file), ignore_index=True)\n", + " profiling_data = profiling_data.sort_values(by=[\"n_processes\"], ignore_index=True)\n", "\n", " profiling_data.n_processes = profiling_data.n_processes.astype(int)\n", - " profiling_data = profiling_data.sort_values(by=[\"n_processes\"])\n", + " profiling_data = profiling_data.sort_values(by=[\"n_processes\"], ignore_index=True)\n", "\n", - " return profiling_data\n", - "\n", - "profiling_data = read_profiling_files(\"output_dgx-2/2022-04-26T155207/\")\n", - "print(profiling_data)" + " return profiling_data" ] }, { @@ -181,96 +65,94 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.083251953125\n", - "11 0.016968\n", - "7 0.159668\n", - "14 0.139648\n", - "0 0.083252\n", - "5 0.036621\n", - "8 0.090393\n", - "2 0.100586\n", - "1 0.054260\n", - "15 0.061646\n", - "9 0.066345\n", - "6 0.152771\n", - "12 0.051697\n", - "3 0.163818\n", - "4 0.111450\n", - "10 0.072327\n", - "13 0.062927\n", - "Name: t_step_mpi_halo_exchange_sendreceive, dtype: float64\n", - "11 4.906475\n", - "7 0.521407\n", - "14 0.596154\n", - "0 1.000000\n", - "5 2.273333\n", - "8 0.920999\n", - "2 0.827670\n", - "1 1.534308\n", - "15 1.350495\n", - "9 1.254830\n", - "6 0.544946\n", - "12 1.610390\n", - "3 0.508197\n", - "4 0.746988\n", - "10 1.151055\n", - "13 1.322987\n", - "Name: t_step_mpi_halo_exchange_sendreceive, dtype: float64\n" + " t_init t_total outfile \\\n", + "0 1.248385 20.045867 /work/martinls/230527/ShallowWaterGPU/mpi_out_... \n", + "1 1.687006 21.810200 /work/martinls/230528/ShallowWaterGPU/mpi_out_... \n", + "2 2.178354 24.593490 /work/martinls/230530/ShallowWaterGPU/mpi_out_... \n", + "3 2.690906 25.624513 /work/martinls/230531/ShallowWaterGPU/mpi_out_... \n", + "4 3.629718 26.697773 /work/martinls/230532/ShallowWaterGPU/mpi_out_... \n", + "5 4.364927 27.958164 /work/martinls/230533/ShallowWaterGPU/mpi_out_... \n", + "6 5.628270 29.105025 /work/martinls/230534/ShallowWaterGPU/mpi_out_... \n", + "7 6.777608 30.504384 /work/martinls/230535/ShallowWaterGPU/mpi_out_... \n", + "\n", + " t_sim_init t_nc_write t_full_step t_mpi_halo_exchange \\\n", + "0 1.880793 12.403532 4.007889 0.0 \n", + "1 2.117109 12.576457 4.909249 0.0 \n", + "2 2.050483 12.774502 7.045701 0.0 \n", + "3 2.216515 13.096246 7.060501 0.0 \n", + "4 2.259021 13.178762 7.057118 0.0 \n", + "5 2.455840 13.353797 7.218295 0.0 \n", + "6 2.354878 13.576300 6.985424 0.0 \n", + "7 2.688699 13.492631 6.996821 0.0 \n", + "\n", + " t_mpi_halo_exchange_download t_mpi_halo_exchange_upload \\\n", + "0 3.883057 0.025879 \n", + "1 4.622559 0.027954 \n", + "2 3.596680 0.027832 \n", + "3 6.201660 0.028931 \n", + "4 3.875732 0.027222 \n", + "5 4.124268 0.028076 \n", + "6 4.145630 0.028564 \n", + "7 5.710327 0.030151 \n", + "\n", + " t_mpi_halo_exchange_sendreceive t_mpi_step nx ny dt \\\n", + "0 0.015381 0.017944 8192.0 8192.0 0.000001 \n", + "1 0.122803 0.018860 8192.0 8192.0 0.000001 \n", + "2 3.337158 0.019775 8192.0 8192.0 0.000001 \n", + "3 0.542480 0.019165 8192.0 8192.0 0.000001 \n", + "4 0.423584 0.020264 8192.0 8192.0 0.000001 \n", + "5 2.685059 0.019531 8192.0 8192.0 0.000001 \n", + "6 0.510254 0.019775 8192.0 8192.0 0.000001 \n", + "7 0.753418 0.018982 8192.0 8192.0 0.000001 \n", + "\n", + " n_time_steps slurm_job_id n_cuda_devices n_processes \\\n", + "0 200.0 230527.0 1 1 \n", + "1 200.0 230528.0 2 2 \n", + "2 200.0 230530.0 3 3 \n", + "3 200.0 230531.0 4 4 \n", + "4 200.0 230532.0 5 5 \n", + "5 200.0 230533.0 6 6 \n", + "6 200.0 230534.0 7 7 \n", + "7 200.0 230535.0 8 8 \n", + "\n", + " git_hash \\\n", + "0 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "1 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "2 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "3 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "4 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "5 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "6 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "7 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "\n", + " git_status \n", + "0 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "1 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "2 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "3 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "4 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "5 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "6 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "7 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - ":23: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", - " fig.show()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } ], "source": [ - "fig, ax = plt.subplots(figsize=(8,6))\n", + "# DGX-2\n", + "#weak_scaling_profiling_data = read_profiling_files(\"output_dgx-2/weak_scaling/2022-06-09T134809/\")\n", "\n", - "# FIXME! Sort AND give new indices\n", - "print(profiling_data[\"t_step_mpi_halo_exchange_sendreceive\"][0])\n", - "print(profiling_data[\"t_step_mpi_halo_exchange_sendreceive\"])\n", - "print(speedup(profiling_data[\"t_step_mpi_halo_exchange_sendreceive\"][0], profiling_data[\"t_step_mpi_halo_exchange_sendreceive\"]))\n", + "# HGX\n", + "weak_scaling_profiling_data = read_profiling_files(\"output_hgx/weak_scaling/2022-06-16T162931/\")\n", + "##weak_scaling_profiling_data = read_profiling_files(\"output_hgx/weak_scaling/2022-06-16T170630/\")\n", "\n", - "ax.plot(profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", - " speedup(profiling_data[\"t_total\"][0], profiling_data[\"t_total\"]), label=\"Total\")\n", - "\n", - "ax.plot(profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", - " speedup(profiling_data[\"t_step_mpi_halo_exchange_sendreceive\"][0], profiling_data[\"t_step_mpi_halo_exchange_sendreceive\"]), label=\"MPI send/recv\")\n", - "\n", - "ax.plot(profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", - " speedup(profiling_data[\"t_step\"][0], profiling_data[\"t_step\"]), label=\"Simulate\")\n", - "\n", - "#ax.plot(nproc, speedup, label=\"Actual\")\n", - "\n", - "ax.plot(nproc, np.ones(len(nproc)), label=\"Ideal (constant)\", linestyle=\"dotted\")\n", - "\n", - "ax.set_xlabel(\"Number of cores/GPUs\")\n", - "ax.set_ylabel(\"Efficiency\")\n", - "ax.legend(loc=\"upper left\")\n", - "fig.show()" + "print(weak_scaling_profiling_data)" ] }, { @@ -282,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -293,7 +175,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -304,22 +186,91 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 9, "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - ":25: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", - " fig.show()\n" + " t_init t_total outfile \\\n", + "0 8.105802 127.329448 /work/martinls/230507/ShallowWaterGPU/mpi_out_... \n", + "1 8.391940 106.173041 /work/martinls/230508/ShallowWaterGPU/mpi_out_... \n", + "2 8.316061 89.259504 /work/martinls/230509/ShallowWaterGPU/mpi_out_... \n", + "3 9.480870 82.180610 /work/martinls/230510/ShallowWaterGPU/mpi_out_... \n", + "4 9.948056 74.482449 /work/martinls/230511/ShallowWaterGPU/mpi_out_... \n", + "\n", + " t_sim_init t_nc_write t_full_step t_mpi_halo_exchange \\\n", + "0 5.656313 88.769145 23.461966 0.0 \n", + "1 5.297291 72.174575 19.195057 0.0 \n", + "2 5.045456 58.199751 16.024106 0.0 \n", + "3 5.172412 52.463597 13.905023 0.0 \n", + "4 4.827947 46.293962 12.370357 0.0 \n", + "\n", + " t_mpi_halo_exchange_download t_mpi_halo_exchange_upload \\\n", + "0 21.429688 0.028931 \n", + "1 15.628418 0.031372 \n", + "2 13.573486 0.030273 \n", + "3 11.412964 0.030151 \n", + "4 10.445801 0.030762 \n", + "\n", + " t_mpi_halo_exchange_sendreceive t_mpi_step nx ny dt \\\n", + "0 1.946533 0.019531 41984.0 10496.0 0.000001 \n", + "1 2.726074 0.021606 41984.0 8396.0 0.000001 \n", + "2 1.489014 0.020386 41984.0 6997.0 0.000001 \n", + "3 1.407959 0.019775 41984.0 5997.0 0.000001 \n", + "4 1.264648 0.021240 41984.0 5248.0 0.000001 \n", + "\n", + " n_time_steps slurm_job_id n_cuda_devices n_processes \\\n", + "0 200.0 230507.0 4 4 \n", + "1 200.0 230508.0 5 5 \n", + "2 200.0 230509.0 6 6 \n", + "3 200.0 230510.0 7 7 \n", + "4 200.0 230511.0 8 8 \n", + "\n", + " git_hash \\\n", + "0 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "1 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "2 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "3 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "4 0f0cbad2dd661c59f9a2c43740eda12d90cca413\\n \n", + "\n", + " git_status \n", + "0 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "1 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "2 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "3 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n", + "4 M Figures.ipynb\\n M dgx-2_strong_scaling_benc... \n" ] - }, + } + ], + "source": [ + "# DGX-2\n", + "#strong_scaling_profiling_data = read_profiling_files(\"output_dgx-2/strong_scaling/2022-06-09T160712/\")\n", + "\n", + "# HGX\n", + "strong_scaling_profiling_data = read_profiling_files(\"output_hgx/strong_scaling/2022-06-16T152945/\")\n", + "\n", + "print(strong_scaling_profiling_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7AAAAFzCAYAAAAHXuXxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACcA0lEQVR4nOzdd3hUVf7H8fdJ7yEkoYUWWqihgyIi2JBFrCAqNrCsDdT92XZXV2yri727sgoW7BVRUUFQaUrv0ltIgIRAQhpp5/fHkEgNgczkziSf1/Pkmdy5d+79JCLDd84952ustYiIiIiIiIh4Oz+nA4iIiIiIiIhUhgpYERERERER8QkqYEVERERERMQnqIAVERERERERn6ACVkRERERERHyCClgRERERERHxCQFOBzhRcXFxtnnz5k7HEBGRGmLhwoUZ1tp4p3P4Mr03i4iIO1X03uxzBWzz5s1ZsGCB0zFERKSGMMZscTqDr9N7s4iIuFNF7826hVhERERERER8ggpYERERERER8QkqYEVERERERMQn+NwcWBEREfF+RUVFpKSkUFBQ4HQUqUFCQkJo3LgxgYGBTkcREYeogBURERG3S0lJITIykubNm2OMcTqO1ADWWnbv3k1KSgqJiYlOxxERh+gWYhEREXG7goICYmNjVbyK2xhjiI2N1ai+SC2nAlZEREQ8QsWruJv+TImIClgRERERERHxCSpgRUREpMbZvXs3Xbp0oUuXLjRo0ICEhITy7cLCwkOOff7558nLyzvuOfv378+CBQuOum/o0KFs3LixyrknT57Mk08+WeExqampDB06FIAlS5bw7bffVvm6B3vxxRdp164dI0aMOCTP2LFjefrppyt9nokTJ3L77beXb6elpXHuuecCsHLlSs4880zatGlD69atefTRR7HWAjBlyhQeeughN/5EIlKTeKyANca8ZYzZZYxZcYz9xhjzojFmvTFmmTGmm6eyiIiIyJGO9V5tjBltjFljjFlpjBnnVL6qiI2NZcmSJSxZsoSbb76Zu+66q3w7KCjokGMrW8Aey8qVKykpKaFFixZVjc0FF1zA/fffX+ExjRo14tNPPwWqXsAWFxcf8dyrr77Kt99+y6RJkyqVp7KmTp3KwIEDyc/PLz/v2rVrWbp0KXPmzOHVV18FYPDgwUyePLlK/01EpOby5CrEE4GXgXeOsX8Q0PrAV2/gtQOPIiIiUj0mcth7tTFmAHAhkGyt3W+MqVfVizz89UpWpWZX9TSHaN8oioeGdDih10yfPp27776b4uJievbsyWuvvcZ///tfUlNTGTBgAHFxccyYMYNbbrmF+fPnk5+fz9ChQ3n44YcrPO+kSZO48MILy7cjIiK44447mDJlCqGhoXz11VfUr1+fLVu2MGrUKNLT04mPj2fChAk0bdr0kHNNnDiRBQsW8PLLL3PdddcRFRXFggUL2LFjB+PGjWPo0KFs3ryZ888/n0WLFvGvf/2L/Px8Zs2axd///neGDx9efq6CggJuueUWFixYQEBAAM8++ywDBgxg4sSJfPPNNxQUFJCbm8tPP/1U/pqbb76ZjRs3csEFFzBq1ChiYmLK8xxsw4YN3HbbbaSnpxMWFsb48eNp27Zthb+nqVOn8tBDD/H+++9z2mmnlY/GhoWF8fLLL9O/f39uu+02jDH079+fKVOmcNlll1X8H1VEah2PjcBaa38BMis45ELgHesyD6hjjGnoqTwHKygq4Ze16YyYci1frv8SgKLSIkZOHcnXG74GIL84n5FTRzJ101QA9hXuY+TUkUzbMg2APQV7GDl1JDO3zQQgIz+DkVNHMmv7LAB25O5g5NSRzE2dC8C2fdsYOXUk83fMB2BT1iZGTh3Jkl1LAFi3Zx0jp45kRYbrQ/A/Mv9g5NSR/JH5BwArMlYwcupI1u1ZB8CSXUsYOXUkm7I2ATB/x3xGTh3Jtn3bAJibOpeRU0eyI3cHALO2z2Lk1JFk5GcAMHPbTEZOHcmegj0ATNsyjZFTR7KvcB8AUzdNZeTUkeQX5wPw9YavGTl1JEWlRQB8uf5LRk4dWf47/XTtp9zwww3l2x/+8SE3T7u5fPu9Ve8xevro8u2JKyZy14y7yrf/t/x/3PPzPeXbry99nft//fMT35cXv8wDsx4o335+4fOMnTO2fPvp+U/z2LzHyrf/8/t/+M/v/ynffmzeYzw9/8/bnsbOGcvzC58v335g1gO8vPjPN+f7f72f15e+Xr59z8/38L/l/yvfvmvGXUxcMbF8e/T00by36r3y7Zun3cyHf3xYvn3DDzfw6dpPy7dHTh2pP3v6swfoz15V/uxJ1R3jvfoW4Elr7f4Dx+yq9mAeUFBQwHXXXcdHH33E8uXLKS4u5rXXXmPMmDE0atSIGTNmMGPGDAAef/xxFixYwLJly/j5559ZtmxZheeePXs23bt3L9/Ozc3llFNOYenSpfTr14/x48cDcPvtt3PNNdewbNkyRowYwZgxY46bOy0tjVmzZjFlypQjRkKDgoJ45JFHGD58OEuWLDmkeAV45ZVXAFi+fDkffPAB1157bfkKvnPnzuXtt98+pHgFeP3118t/H3fddRfHctNNN/HSSy+xcOFCnn76aW699dYKf46SkhLWrFlD+/btWbly5SG/L4CWLVuSk5NDdrbrg44ePXrw66+/VnhOEfEe1lqKS4+8o8MTnOwDmwBsO2g75cBzaYcfaIy5CbgJOOKTypOxOzuHxe/cQ27bGvGeLCIi4k5tgNONMY8DBcDd1tr5hx90Iu/NJzpS6gklJSUkJibSpk0bAK699lpeeeUV7rzzziOO/fjjj3njjTcoLi4mLS2NVatWkZycfMxzp6WlER8fX74dFBTE+eefD0D37t358ccfAVfR+PnnnwNw9dVXc++99x4390UXXYSfnx/t27dn586dlf55AWbNmsXo0a4P8Nq2bUuzZs1Yu3YtAOeccw5169Y9ofOVycnJYc6cOQwbNqz8uf3791f4mt9++43evV032llrj7macNnz9erVIzU19aTyiUj1K7bFTNsyjUGJgzx/MWutx76A5sCKY+z7Buh70PZ0oPvxztm9e3dbVaUlJTbjoSZ2/nOXVflcIiLi24AF1oPvhd7+dfh7NbACeBEwQC9gE2AqOsfR3ptXrVp1Av8VPOuhhx6yTz31lD399NPLn5s2bZq9+OKLrbXWNmvWzKanp1trrd24caNt2bKlzczMtNZae+2119oJEyZYa60944wz7Pz58484f3Jyst20aVP5dnh4ePn3n3zyib322muttdbGxsbawsJCa621hYWFNi4u7ohzTZgwwd52223l1/7kk0+OOO+mTZtshw4djjj+cBdeeKGdPn16+Xbfvn3t0qVLK3zN4b+Pg48t+z1mZWXZBg0aHPP1R/tZHnjgAfv5559ba60dP368vfrqqw85dsOGDbZx48bl25MnT7YjRow46nm96c+WSG23fd92m1eUZ621dt/+fba0tNQt563ovdnJVYhTgCYHbTcGquWjNuPnx7aQtsRnr6yOy4mIiPiSFODzA/+G+B0oBeIczlRlBQUFbN68mfXr1wPw7rvvcsYZZwAQGRnJvn2uaQzZ2dmEh4cTHR3Nzp07+e6774577nbt2pWftyJ9+vThww9dt/hPmjSJvn37nuyPU+7g7Ifr168fkyZNAmDt2rVs3bqVpKSkKl8zKiqKxMREPvnkE8A1GLJ06dIKXzN9+nTOOussAEaMGMGsWbOYNs01PSE/P58xY8YcMiK9du1aOnbsWOWsIuI52YXZXPHNFYyb71rrLyIoolp6NTtZwE4GrjmwGvEpQJa19ojbhz0lLz6ZJiUp5O/bW12XFBER8QVfAmcCGGPaAEFAhpOB3CEkJIQJEyYwbNgwOnXqhJ+fHzff7Jovf9NNNzFo0CAGDBhA586d6dq1Kx06dGDUqFGcdtppxz334MGDmTlz5nGPe/HFF5kwYQLJycm8++67vPDCC1X9sRgwYACrVq2iS5cufPTRR4fsu/XWWykpKaFTp04MHz6ciRMnEhwcXOVrgqsAf/PNN+ncuTMdOnTgq6++Ouax6enphISEEBUVBVC+sNVjjz1GUlISnTp1omfPnoe03JkxYwaDBw92S1YR8YyooCju6HYH13W4rlqva+yBnltuP7ExHwD9cX1quxN4CAgEsNa+blzl+cvAeUAeMNJae/Tmagfp0aOHPVYPthOxcNpHdJ91E2vO+4CkU/5S5fOJiIhvMsYstNb2cDqHE47xXv0u8BbQBSjENQf2p2OcAjj6e/Pq1atp166d+0N7ofz8fAYMGMDs2bPx9/d3Oo7Xee+990hJSal0O56dO3dy5ZVXMn369KPur01/tkS8TUFxAU/+/iSXJV1G+9j2HrtORe/NHlvEyVp7xXH2W+A2T13/eBI6nMa+X0PZuX0LVb+ZRkRExPdU8F59VbUG8XGhoaE8/PDDbN++3S2LTdY0V111Yn+ctm7dyjPPPOOhNCJSFblFucxNnUtS3SSPFrAVcXIVYkfVb5BAr4C36VfSgH5OhxERERGfNnDgQKcj1Bg9e/Z0OoKIHGbdnnW0qtOK2NBYvrjwC8ICwxzL4uQcWEcZY+jQOIYV27OcjiIiIiIiIuKVVu1exWVfX8bHaz4GcLR4hVpcwAIMCV/NM3tGk7/nxPqqiYiIiIiI1Abt6rbjzu538pcW3rFuUK0uYJvG16Gj32ZSVs12OoqIiIiIiIhX2Jm7k7tm3EVGfgbGGK7tcC2RQZFOxwJqewHb8TRKrSFnw+9ORxERERE3i4iIOGR74sSJh7RqOZrKHONuM2fO5Pzzz6/Wa1bkzjvv5JdffgGgf//+JCUlkZycTNu2bbn99tvZu3fvIcf/9a9/Zfbs2Vx33XUkJibSpUsXunTpQp8+fcqPKSoqonv37mzevPmI/q5jx47l6aefBuDuu+/mp58qXPRaRKrBnv17WLRrERv3bnQ6yhFqdQFbLy6WzSaBoF1LnI4iIiIi4rjMzEzmzZtHv35/LnE5adIkli1bxrJlywgODubCCy885DW//fYbp5xyCgBPPfUUS5YsYcmSJcyZM6f8mFmzZh1S0B7L6NGjefLJJ93004jIiVq9ezUAbeu2ZeqlU+nVsJfDiY5UqwtYYwxp4e1omLsaPNQPV0RERLzP119/Te/evenatStnn302O3ceuR7Gli1bOOuss0hOTuass85i69atRxyTm5vLqFGj6NmzJ127duWrr74CYMyYMTzyyCMAfP/99/Tr14/S0lLWr1/P2WefTefOnenWrRsbNmwAICcnh6FDh9K2bVtGjBiBPfDvkkceeYSePXvSsWNHbrrppvLn+/fvz3333UevXr1o06YNv/76KwB5eXlcdtllJCcnM3z4cHr37k1Zj94ffviBU089lW7dujFs2DBycnKO+Hk+/fRTzjvvvKP+zoKCghg3bhxbt25l6dKlgKsna5s2bY7b/3bq1KkMGjSowmMAmjVrxu7du9mxY8dxjxUR9/pi3RcMnzKcJQcG90IDQp0NdAy1uoAFyErox5zituTl7XM6ioiISM01YfCRX7+Pd+0rzDv6/sWTXPtzdx+5rxLy8/PLb2ft0qUL//rXv8r39e3bl3nz5rF48WIuv/xyxo0bd8Trb7/9dq655hqWLVvGiBEjGDNmzBHHPP7445x55pnMnz+fGTNmcM8995Cbm8uTTz7JRx99xIwZMxgzZgwTJkzAz8+PESNGcNttt7F06VLmzJlDw4YNAVi8eDHPP/88q1atYuPGjcyePbs8w/z581mxYgX5+flMmTKl/NrFxcX8/vvvPP/88zz88MMAvPrqq8TExLBs2TIefPBBFi5cCEBGRgaPPfYY06ZNY9GiRfTo0YNnn332iJ9n9uzZdO/e/Zi/U39/fzp37swff/wBwHfffXdIwXvPPfeU/75HjBhR/vyMGTPo37//Mc97sG7dupX//CJSfc5LPI/7et1Hp7hOTkepUK3tA1smsMtwblzWkk/Ti+kR7nQaERERcZfQ0FCWLFlSvj1x4sTy0ciUlBSGDx9OWloahYWFJCYmHvH6uXPn8vnnnwNw9dVXc++99x5xzA8//MDkyZPL53AWFBSwdetW2rVrx/jx4+nXrx/PPfccLVu2ZN++fWzfvp2LL74YgJCQkPLz9OrVi8aNGwPQpUsXNm/eTN++fZkxYwbjxo0jLy+PzMxMOnTowJAhQwC45JJLAMrnloLrVt077rgDgI4dO5KcnAzAvHnzWLVqFaeddhoAhYWFnHrqqUf8PGlpacTHx1f4e7UH3bX2/fffM2HChPLtp556iqFDhx5yfGpqKnXr1iUsLAxjzFHPefDz9erVIzU1tcIMIuIey9KXMXHlRP5z+n8IDQhlRLsRx3+Rw2p9AZvcOBqAlVt20qN5XYfTiIiI1FAjvzn2vqCwiveHx1a8/ySMHj2av/3tb1xwwQXMnDmTsWPHHvc1Ryu+rLV89tlnJCUlHbFv+fLlxMbGlhdjtoLpSsHBweXf+/v7U1xcTEFBAbfeeisLFiygSZMmjB07loKCgiNeU3Z8Rdew1nLOOefwwQcfVPgzhoaGHnKNw5WUlLB8+XLatWtHXl4ee/fupVGjRhWe87vvvmPgwIEAxMbGsmfPnkP2Z2ZmHvIBQkFBAaGh3nnrokhNk5qbyurdq9mVv4uEiASn41RKrb+FuH5UCJNCn+LU3251OoqIiIhUk6ysLBISXP9Ye/vtt496TJ8+ffjwww8B10JGffv2PeKYgQMH8tJLL5UXjosXLwZc82efeeYZFi9ezHfffcdvv/1GVFQUjRs35ssvvwRg//795OXlHTNjWSEZFxdHTk4On3766XF/rr59+/Lxxx8DsGrVKpYvXw7AKaecwuzZs1m/fj3gmiu7du3aI17frl278mMOV1RUxN///neaNGlCcnIyM2bMYMCAAcfNdPD814iICBo2bMj06dMBV/E6derUQ363a9euPWKlYhFxn6KSovLFms5rfh5fXvSlzxSvoAIWgMKIBBLy/oDSUqejiIiISDUYO3Ysw4YN4/TTTycuLu6ox7z44otMmDCB5ORk3n33XV544YUjjnnwwQcpKioiOTmZjh078uCDD2Kt5frrr+fpp5+mUaNGvPnmm9xwww0UFBTw7rvv8uKLL5KcnEyfPn0qXKyoTp063HjjjXTq1ImLLrqInj17HvfnuvXWW0lPTyc5OZn//Oc/JCcnEx0dTXx8PBMnTuSKK64gOTmZU045pXwe68EGDx7MzJkzD3luxIgR5T9fbm5u+UJVh89/hUPnwHbp0oX9+/ezbt062rZtW37MO++8w2OPPUaXLl0488wzeeihh2jZsiXgKpLXr19Pjx49jvuzisjJGTd/HCO/H0lmQSYAwf7Bx3mFdzEV3c7ijXr06GHL5q+4yw/vPc256x8l76Z5hDVq59Zzi4iIdzPGLLTW6l/LVXC09+bVq1fTrp3eU6tbSUkJRUVFhISEsGHDBs466yzWrl1LUFBQpc/Rt29fpkyZQp06dSo8rlu3bvz2228EBgYe85hZs2bx3nvv8frrr1fq2l988QWLFi3i0UcfPeYx+rMlUjU7cnewZNcSzks8+orj3qCi9+ZaPwcWIKplL1gPO1bPoYUKWBEREfFReXl5DBgwgKKiIqy1vPbaaydUvAI888wzbN269bgF7KJFi457rr59+x711utjKS4u5v/+7/8qfbyIVM7kDZNZnr6cf/T+Bw3CG3h18Xo8KmCBFu26kTc1mPzN84HrnY4jIiIiclIiIyOp6p1qvXv3dlOaEzds2DDHri1Sk23J3sLGrI3sL9lPSEDI8V/gxVTAAvXqRPBcwBWE0Z4OTocRERERERGpoj0Fe8jan0Xz6Obc1uU2SmwJgX7HvuXfV6iAPWBl06vYlJHLX50OIiIiIiIiUgXWWkb/NJrcolw+u+Az/IwffqZmrN+rAvaATo3CSV3zOzl72hIR08DpOCIiIiIiIifFGMM9Pe/B3/jXmMK1TM36aaqgV50cvg36B+m/f+Z0FBERERERkRNSUlrCswueZdLqSQB0ju9Mx7ia11NZBewBLZM6sdeGs3+Le1v0iIiIiIiIeJoxhs3Zm0nZl+J0FI9SAXtAvahQ/vBrTeTupU5HERERETeIiIg46vPXXXcdn3766Umdc+zYsTz99NNH3ff888/zzjvvHHGNG264gVWrVp3U9SorPT2d887z3bYYInLy1u5Zy96CvfgZP57p/wz39brP6UgepQL2IBlRHWiwfxMU5jkdRURERHxIcXExb731FldeeeUR+/73v//Rvn17j147Pj6ehg0bMnv2bI9dR0S8T05hDqO+H8WT858EqBGrDB+PCtiDJXTFn1Jyty52OomIiEiNMnLqSL5c/yUARaVFjJw6kq83fA1AfnE+I6eOZOqmqQDsK9zHyKkjmbZlGuBqBTFy6khmbpsJQEZ+xgld21rL7bffTvv27Rk8eDC7du0q37dw4ULOOOMMunfvzsCBA0lLSwNg/Pjx9OzZk86dO3PppZeSl1fxh9s//fQT3bp1IyDgyPUx+/fvX96bNSIign/+85907tyZU045hZ07dwKuEdRLL72Unj170rNnz/JC9Pfff6dPnz507dqVPn36sGbNGgAmTpzIsGHDGDJkCOeeey4AF110EZMmTTqh342I+LaIoAgeO+0x/q/7/zkdpdqogD1IdNv+XFN4HytLmjgdRURERNzkiy++YM2aNSxfvpzx48czZ84cAIqKihg9ejSffvopCxcuZNSoUfzzn/8E4JJLLmH+/PksXbqUdu3a8eabb1Z4jdmzZ9O9e/fjZsnNzeWUU05h6dKl9OvXj/HjxwNwxx13cNdddzF//nw+++wzbrjhBgDatm3LL7/8wuLFi3nkkUf4xz/+UX6uuXPn8vbbb/PTTz8B0KNHD3799dcT/wWJiE/JLsxm9PTRzE2dC0D/Jv2JD4t3OFX1URudg7RNbMovpZ3pt6uYXklOpxEREak5Jpw3ofz7QL/AQ7ZDA0IP2Y4MijxkOyYk5pDtuNC4E7r2L7/8whVXXIG/vz+NGjXizDPPBGDNmjWsWLGCc845B4CSkhIaNmwIwIoVK3jggQfYu3cvOTk5DBw4sMJrpKWl0a5du+NmCQoK4vzzzwege/fu/PjjjwBMmzbtkHmy2dnZ7Nu3j6ysLK699lrWrVuHMYaioqLyY8455xzq1q1bvl2vXj1SU1Mr8ysRER8WYALYmbeTnXk7nY7iCBWwB4mPDOaMyFSil8+D0x91Oo6IiIi4iTHmiOestXTo0IG5c+cese+6667jyy+/pHPnzkycOJGZM2dWeP7Q0FAKCgqOmyMwMLA8i7+/P8XFxQCUlpYyd+5cQkNDDzl+9OjRDBgwgC+++ILNmzfTv3//8n3h4eGHHFtQUHDE60Wk5pi/Yz5d63UlLDCM9we/T4Bf7SzldAvxYS6KWMWwXS9C/l6no4iIiIgb9OvXjw8//JCSkhLS0tKYMWMGAElJSaSnp5cXsEVFRaxcuRKAffv20bBhQ4qKiio1r7Rdu3asX7/+pDOee+65vPzyy+XbS5YsASArK4uEhATANe+1ImvXrqVjx5rX81FEYE3mGkZ9P6q8x2ttLV5BBewRTEI3APLUD1ZERKRGuPjii2ndujWdOnXilltu4YwzzgBct/N++umn3HfffXTu3JkuXbqUz4999NFH6d27N+eccw5t27Y97jUGDRrEL7/8ctIZX3zxRRYsWEBycjLt27fn9ddfB+Dee+/l73//O6eddholJSUVnmPGjBkMHjz4pDOIiPex1gKQVDeJcf3GcXnbyx1O5DxT9kvxFT169LBlK/l5wq/L13H6Zz3Y0uVuml30oMeuIyIi3sEYs9Ba28PpHL7saO/Nq1evrtSc0Jrk4osvZty4cbRu3dqR6/fr14+vvvqKmJgYR65fXWrjny2pnTZnbeaB2Q/w777/pmlUU6fjVKuK3ps1AnuYdolN2VRan9Lti5yOIiIiIj7kySefLG/DU93S09P529/+VuOLV5HaJMAvgOzCbDILMp2O4lVUwB4mLiKYdQFtCN+71ukoIiIi4kOSkpLo16+fI9eOj4/noosucuTaIuI+pbaUWdtnAdA4sjFfXPAFXep1cTaUl1EBexRTm97FlUEvOB1DRETEp/naNCXxfvozJTXd1xu+5pZptzB/x3wA/P38HU7kfWrv8lUVaNG0KZ//sZbsgiKiQgKdjiMiIuJzQkJC2L17N7GxsUdtYSNyoqy17N69m5CQEKejiLidtRZjDINbDCYkIIQe9bU0w7GogD2KTgnRPBDwLrtmbiHqvFudjiMiIuJzGjduTEpKCunp6U5HkRokJCSExo0bOx1DxK3mbJ/Da0tf47WzXyMiKIKBzQc6HcmrqYA9ik6N61DPbwVBa7NABayIiMgJCwwMJDEx0ekYIiJeL9A/kKLSInKKcogIinA6jtfTHNijqBsexPrANtTduwI010JERERERNworyiPualzAejZoCfvD36fBuENHE7lG1TAHkN2TDIRpdmwZ7PTUUREREREpAZ5YdELjP5pNBn5GQD4GZVllaVbiI8hoGl3yIC8zfMJq6tboEREREREpGrKFmu6tcutnNn0TOJC45yO5HNU6h9Dozbd2Vxan9R0NQ4WEREREZGqeXfVu9w5405KbSnRwdH0btjb6Ug+SQXsMXRsEkf/wueYFnKO01FERERERMTHBfoF4u/nT2FJodNRfJoK2GOICQ+icUwoy7dnOR1FRETEI4wxbxljdhljVhxl393GGGuM0f1tIiInKTUnleXpywEYnjScZ854hpAA9TKuChWwFbik7mb+ue5y2LXa6SgiIiKeMBE47/AnjTFNgHOArdUdSESkprDWcv+v9/OPWf+gpLQEYwzGGKdj+Twt4lSBho2a0Gj7TvI2zSesXjun44iIiLiVtfYXY0zzo+x6DrgX+Kp6E4mI+D5rLRaLn/FjbJ+x+OGHv5+/07FqDI3AVqBx62T22VCyNvzmdBQREZFqYYy5ANhurV3qdBYREV9TUlrCA7Mf4KXFLwHQIroFzaObOxuqhtEIbAU6JsSwojSRFmmLnY4iIiLiccaYMOCfwLmVOPYm4CaApk2bejiZiIhv8PfzJ8Q/hCC/oPKWOeJeKmArEBMexKbgNvTI+QaKCyEgyOlIIiIintQSSASWHvhHV2NgkTGml7V2x8EHWmvfAN4A6NGjh63uoCIi3mTRzkU0CG9Ao4hGPHDKAypcPUi3EB9Hev2+fOs/AApznI4iIiLiUdba5dbaetba5tba5kAK0O3w4lVERP6UV5THnTPu5NmFzwKoePUwjcAeR1DrM7ljQyPOIII6TocRERFxI2PMB0B/IM4YkwI8ZK1909lUIiK+oaS0BH8/f8ICw3jxzBdpUaeF05FqBY3AHkenhGgMpfyxfoPTUURERNzKWnuFtbahtTbQWtv48OL1wEhshlP5RES81Z6CPVwz9Rq+3fgtAF3qdSEqKMrhVLWDCtjj6JQQzauBL9B66gino4iIiIiIiBeICIwgOiiaYP9gp6PUOipgjyM6LJAdwS2IydsE+zUPVkRERESktpq6eSp5RXkE+gfyylmvcFazs5yOVOuogK2E/Hqd8aMU0tQST0RERESkNlq/Zz33/nwvH675ENBiTU5RAVsJYYm9AMjbPN/hJCIiIiIiUp2KS4sBaBXTijcHvsm17a91OFHtpgK2ElonJpJi48jZ+LvTUUREREREpJqsyVzDBV9ewMrdKwHo2aAn/n7+Dqeq3VTAVkLHRtH8p+hy5tQZ4nQUERERERGpJvFh8TQIb0CAUfdRb6ECthKiwwJZFnM2U3PbOB2l5snZBdlpTqcQEREREQGgqLSIL9Z9gbWWuiF1eWvgWyTVTXI6lhygAraSujQKI3DrLMjc5HSUmuXp1vBsW6dTiIiIiIgA8MPmH/jXnH8xL22e01HkKDQWXkldGgQzct2/yFuYR9g5f3c6joiIiIiIuFFRaRGBfoH8JfEv1A+rT48GPZyOJEfh0RFYY8x5xpg1xpj1xpj7j7I/xhjzhTFmmTHmd2NMR0/mqYqk5o1ZX9qIvM1ayMmtzrgPMFBS5HQSEREREamlpm+ZzkVfXkRGfgbGGBWvXsxjBawxxh94BRgEtAeuMMa0P+ywfwBLrLXJwDXAC57KU1UdE6JZalsQmr4UrHU6Ts1QXAilJYCFfZoHKyIiIiLOaBzZmGZRzfAzmmHp7Tz5X6gXsN5au9FaWwh8CFx42DHtgekA1to/gObGmPoezHTSokIC2R7ajvDC3ZCd6nScmiH9D/j1adf3BVnOZhERERGRWmVPwR6mbJwCQFLdJF49+1XqhtR1OJUcjycL2ARg20HbKQeeO9hS4BIAY0wvoBnQ+PATGWNuMsYsMMYsSE9P91Dc4ytq0MX1TeoixzLUKNnbXY83/AQNOjmbRURERERqlbdWvMXDcx5mV94up6PICfBkAWuO8tzh994+CcQYY5YAo4HFQPERL7L2DWttD2ttj/j4eLcHrazoFt25aP8j7G7Yz7EMNUpZARt9+OcaIiIiIiKeUVhSCMBtXW7jnUHvUC+snsOJ5ER4soBNAZoctN0YOOTeW2tttrV2pLW2C645sPGA1/ap6dCkHktsK5bv3O90lJohazv4BcD3/4A5LzudRkRERERquFeXvMqo70dRWFJISEAI7WLbOR1JTpAnC9j5QGtjTKIxJgi4HJh88AHGmDoH9gHcAPxirc32YKYq6ZAQRSezkYhfH4fSUqfj+L7s7RDZCHasgG2/OZ1GRERERGq41jGtSYpJwhz1ZlHxBR7rA2utLTbG3A58D/gDb1lrVxpjbj6w/3WgHfCOMaYEWAVc76k87hAVEki/qB30SJkImaMhrpXTkXxblyuh1dmw5H0tjCUiIiIiHrFuzzp25O7g9Manc06zczin2TlOR5Iq8FgBC2Ct/Rb49rDnXj/o+7lAa09mcLeSBl1hC66FnFTAVk2L/q7HjT/DhumORhERERGRmuk/8//DjtwdnNroVAL8PFr+SDXQf8ETFN8imfzNQbB5PqHJlzkdx3eVlsK2eRDfFqIawb4dUFIE/oFOJxMRERERH1dSWkKJLSHIP4h/9/03gIrXGkKdek9QhyaxrLDNKdy6wOkovi0vAyYMguWfQnwSJHSD/fucTiUiIiIiPq6ktIQ7ZtzBw3MfxlpLvbB6Wmm4BtHHECeoQ6MoPi5tSdK+xWAtGE0APylZKa7H6ARoOxg6DXU2j4iIiIjUCP5+/nSK60R0cLTTUcQDVMCeoMiQQD6uM4p58TGMV/F68soWbYpSD1gRERERqbqftv5E48jGtIlpw187/9XpOOIhuoX4JLRtHM/y7V7b7cc3ZG93PUY3hqJ8eP10WPCWs5lERERExCflF+fz+G+P89+l/3U6iniYRmBPQqeEaLqseIKcH+YRce4/nY7jm7JSwD8YwmJd27s3QMY6ZzOJiIiIiE/JL84nxD+E0IBQxp87noQI3d1X02kE9iR0SoimldmOXT3F6Si+q+vVMGyiaw6xMa65sGXzYkVEREREjiOzIJPhU4bz7qp3AWgR3YJg/2CHU4mnqYA9CR0SollmWxC2dw0UFTgdxzfFt4G2f/lzO6rRn/NiRURERESOo05wHbrV60bbum2djiLVSAXsSYgIDmBnRHv8bQnsWO50HN+0egqkr/1zOypBBayIiIiIVMhay6TVk9hTsAc/48fYPmPp1bCX07GkGqmAPUl+jbu7vkld5GwQX1RaAh9fA0s/+PO5Jr2gaW9XayIRERERkaPYkr2FZxc8yxfrv3A6ijhEizidpCbNWjF3TXs6FPkR5XQYX5OzC2yJa95rme7Xub5ERERERA6TW5RLeGA4zaOb89H5H9GyTkunI4lDNAJ7kpKb1OGKogeYH3uB01F8T1kLnajGzuYQEREREa+3cvdKBn02iDnb5wDQKqYVxhiHU4lTVMCepPYNozAGlqfshdJSp+P4lrLVhqMa/fnc7g0wriWs1O0gIiIiIvKnxKhETml0Ck2imjgdRbyACtiTFB4cwKC6adww9yzY/KvTcXxL2Qhs9EEjsGF1IS8DsrY7k0lEREREvEZeUR5vLHuDotIiwgLDGNdvHE0iVcCKCtgqqduoNRGl+7SQ04lKvhxGfgehMX8+F1IHAsO0ErGIiIiIMC9tHq8seYX5O+Y7HUW8jArYKmjRrClbSutRsGWB01F8S3gsNOsDB89dMOZAK50U53KJiIiIiKP2Fe4D4MymZ/LFhV/Qp1EfhxOJt1EBWwXJjaNZZltgt2sE9oQs+QA2/nzk81GNNAIrIiIiUktN2TiFv3z+F7ZmbwWgRXQLhxOJN1IBWwXtG0WxzLYkNC/V1RpGKmf6w7DsoyOfbzcEWp9b/XlERERExHFd63Wlf5P+xIbGOh1FvJj6wFZBWFAA2+r04lu/Yv5itRJxpZQUwb4drtuFD9frxurPIyIiIiKOSctJ4/vN33Ndx+tIiEjg0dMedTqSeDmNwFZRWNMuPJR/GTaivtNRfMO+HYCF6KMUsABFBVBSXK2RRERERMQZX67/kv8u+y87cnc4HUV8hArYKkpOiCZ73z4yNq9wOopvKGuhc7QR2PXT4fH6WtVZREREpAaz1pK1PwuAm5Jv4pMhn9AgvIHDqcRXqICtok6No3kkYCLRHw4Ba52O4/2yDqwyfLQCtmwUO1u9YEVERERqqmcWPMNV315FblEu/n7+NI5s7HQk8SGaA1tF7RtG86VNZPj+mbB3K8Q0czqSd2t/ITTu6Vpx+HBlz2klYhEREZEa64wmZxAWGEZoQKjTUcQHaQS2ikKD/NlTp5NrQ7e+Hp9/oKvI9w88cl9oDASEqoAVEakmxpi3jDG7jDErDnruKWPMH8aYZcaYL4wxdRyMKCI1xKKdi5i8YTIAPRv05NYut+JnVIrIidOfGjcIa9qZQgLUD7YyFr4Ni987+j5jXIs7ld1mLCIinjYROO+w534EOlprk4G1wN+rO5SI1DwTV07kreVvUVRa5HQU8XG6hdgNOjSJY9XKprTbuoBgp8N4u4UTXSOtXa86+v7eN7v2i4iIx1lrfzHGND/suR8O2pwHDK3WUCJSYxSWFFJYUkhEUASP9X0MgEC/o9yFJ3ICVMC6QceEaMYVX84dbTrT2+kw3i57O9TvcOz96gUrIuJNRgEfHW2HMeYm4CaApk2bVmcmEfEBpbaUv/74V0IDQnnlrFeICopyOpLUELqF2A3aN4ziNzoxqyDR6SjerbgQcnZBdAUrzRXvh90boLSk+nKJiMgRjDH/BIqBSUfbb619w1rbw1rbIz4+vnrDiYjX8zN+DGk5hItaXYQxxuk4UoOogHWD0CB/2saHELjuG0hd4nQc77UvFbBHb6FTZvF78FI3yNlZbbFERORQxphrgfOBEdaqR5yIVN7n6z5n/o75AFzS+hLObX6uw4mkplEB6yYdEupwQ/p/sMdaoEhco68cWKjpWMpGZ7PUC1ZExAnGmPOA+4ALrLV5TucREd+xv2Q/E1ZM4NO1nzodRWowzYF1k45N6rJ8RXO6bl1AkNNhvFWTXvDALtdqw8dS3gt2O9CzWmKJiNRWxpgPgP5AnDEmBXgI16rDwcCPB277m2etvdmxkCLi9fYU7CEqKIpg/2DeGvgWMSFakFM8RwWsm3RMiGZBaUt6pP/omusZoDL2qI73eym7vVi9YEVEPM5ae8VRnn6z2oOIiM/aU7CHYV8PY0jLIdzR7Q7iwzQnXjxLtxC7SfuGUaygJf6lhbBrldNxvNPCiTDt4YqPCY2BgNADI7AiIiIi4s1iQmK4tPWlnNtMc12leqiAdZOQQH+yYzq5NlIXOxvGW6393vVVEWPgL+Og/YXVk0lERERETkhRaREvLHqB7TmuAYdbutxCu9h2DqeS2kIFrBvVa9qGi/1ewHa7xuko3ikrpeIFnMp0u8Y1X9ZXWAslxU6nEBEREakWu/J28dGaj/hp609OR5FaSAWsG3VqXIfFefGkZhc6HcU7ZW+vuIVOmX07YOtvns/jLlPvh0djXYWsiIiISA21K28XAAkRCXx14Vdc3f5qhxNJbaQC1o06Na5DJ7OR0i9vh8Jcp+N4l6J8yNtduQL29zdgwiAoLfF8LndY8JbrsSjf2RwiIiIiHrIiYwWDPx/M1E1TAbRYkzhGBawbtW0QSUO/vTTZ/CmkLXM6jnfJ2w0RDaBOk+MfG9UIbMmBvrE+IL4ttDobgsKcTiIiIiLiEUl1kxieNJyeDdTmUJylAtaNQgL9yY3r7NpIXeRsGG8T3RjuXgOdLz/+sVGNXY++sBKxtbBnM8Q016i7iIiI1Ch7C/by+LzHySvKI9AvkLt73k1saKzTsaSWUwHrZo2bNGcHsdjtKmBPWlQj16MvFLB5u2F/Nsz/H/zwoNNpRERERNxmzZ41fLn+S5ZnLHc6ikg5FbBu1rFxNItLWlCybYHTUbzL4vfgwxGVm9daNk82O9WzmdwhNAZGL3KNwGasdTqNiIiISJXtyN0BQO+GvZl66VR6N+ztcCKRP6mAdbPkhGiWlrZkf4nVoj4HS1kAW+aAn//xjw2rC8MmQtIgj8eqMj9/iG0JzU6DjHVOpxERERGpki/WfcH5X5zPmsw1ALplWLxOgNMBapqkBpFcai/Ar+Nd3BsY6nQc75G9vXI9YAGMgQ4XezaPu6z9wTUHNq41LJkEBVkQEu10KhEREZGT0r9Jf7bt20aL6BZORxE5Ko3AullIoD9JDaJYvj3L6SjeJWv7n4szVUbaUlj3o+fyuMvyT2DOSxCX5NrWKKyIiIj4mPV71vOf3/9DqS0lJiSGMd3GEOgf6HQskaNSAesBnRKiGbztGexXo52O4j2yUyo/Agsw91WYcpfn8rhL5kaomwiNukD/f0B4nNOJRERERE7Ibzt+47tN35XPfRXxZipgPaBT42iCS3IoWfuD01G8Q3EhxLZy9UutrKhGsC+tcos+OSlzI9Rt4crb/z7XYk4iIiIiXq7UlpKa41ow88q2V/LlhV/SKKKRw6lEjk8FrAd0SohmVWkzAnJ3QP4ep+M4LyAIbvwJet1Y+ddENYLSYshN91yuqsrfC/mZrgIWIC8T0tc4GklERESkMp747Qmu+vYqsvZnYYyhTkgdpyOJVIoKWA9IahDJNtPQtZG50dkwvir6wHzZLC/uBZu1zfVYVsB+fQd8eKVzeUREREQqaVjSMG5KvomooCino4icEBWwHhAc4I9f7IGiZrcKWFZ8Bv/tBzknMJoadeAWlmwvLmAbdIJ/pEGrs13bcW0gc5PrlmkRERERLzNz20zeWvEWAG1i2nB528sxxjgbSuQEqYD1kNgmbfmNjtjgCKejOC9jnWtV4ZAT+IQvrg1c/yO0OMNzudwhKAwCQ1zfxyeBLdGou4iIiHiln7b+xA+bf6CwRB+2i+9SH1gPadUojuEL/sH8RmcS73QYp2WlQHg9CAiu/GsCQ6FJL89lcoff3oD92dDvbtd2XGvXY8ZaqHcCC1aJiIiIeEhuUS75xfnEhcbxz1P+ibWWIP8gp2OJnDSNwHpIYlw4ABt37XM4iRfI3n5iLXTK/PENrJ7i/jzusvIL2PDTn9uxZQWsFnISERER51lruenHm7hrxl1Yawn2DyYkIMTpWCJVohFYD0mMC+eugE/o9MmdcP86p+M4KzvV1UbnRM17DUqKoN357s/kDpkbofXZf24HR8Al/3P1hBURERFxmDGGGzvdSGhAqOa6So2hAtZDGtUJpcCEEVawy9VKJzTG6UjOadQV6nc88ddFNYItc92fxx0KcyFnx58rEJdJHuZMHhERERFco65vrniTZlHNOKfZOfRv0t/pSCJuValbiI0xJ1F91G7+fob8yGaujdq+qM/Fr0Of20/8dVEJsC8VSkvdn6mqMje5HmMSD30+KwWWfwrWVn8mERERqfWKS4uZsW0Gs7fPdjqKiEdUdgT2dWNMEDAReN9au9djiWoQU7cF5OEqdhK6Ox3H90Q1gtJiyE2HyPpOpzlUfiaExR45Arv2e/jmb9D0lD972YqIiIh42Pac7cSGxBISEMIb57xBWECY05FEPKJSI7DW2r7ACKAJsMAY874x5hyPJqsBwhu6FvUp3b3B4SQOWj8NxrWEtGUn/tqyAjA7xb2Z3CGxH9y7ERp2PvT5uDaux4y11Z9JRGo1Y0yQMSbZGNPpwIfOIlJLZO3P4vIpl/P0gqcBCA8M15xXqbEqvQqxtXYd8ABwH3AG8KIx5g9jzCXHeo0x5jxjzBpjzHpjzP1H2R9tjPnaGLPUGLPSGDPyZH4Ib9W0fixvFZ9HRvhJLGBUU2SlQF7Gyc0BTuwHd62Chl3cHsttDn9ziE9yPaargBWR6mOMGQxsAF4EXgbWG2MGOZtKRKpLdHA0d3S7g2vbX+t0FBGPq+wc2GRjzHPAauBMYIi1tt2B7587xmv8gVeAQUB74ApjTPvDDrsNWGWt7Qz0B56pSZ8at4gL55Hia1gZdbrTUZyTtR2MH0Q2PPHXBoW72u/4+bs/V1VN+Rv89PiRz4fHQ0i0RmBFpLo9Awyw1va31p4BDOAY788iUjPkF+fz4OwHWZPpat83tM1QmkQ1cTiViOdVdgT2ZWAR0Nlae5u1dhGAtTYV16js0fQC1ltrN1prC4EPgQsPO8YCkcZ1j0MEkAkUn+DP4LVcvWAtaSlbnY7inOztENEA/E9ywes5L8Hqr92byR3W/QB7txz5vDEQl6QCVkSq2y5r7fqDtjcCu5wKIyKel1uUy7y0eSxNX+p0FJFqVdmq4i9AvrW2BMAY4weEWGvzrLXvHuM1CcC2g7ZTgN6HHfMyMBlIBSKB4dZaL1xy9uTUDQ/itpDvufLXd6DPFgit43Sk6pe93TWKerLmv+laAKvdEPdlqqqiAtet0Ycv4FTmghchOKp6M4lIbbfSGPMt8DGuD4eHAfPLpvlYaz93MpyIuM+6PetoVacVcaFxfHXhV4QFarEmqV0qOwI7DQg9aDvswHMVOdrM8cN7iwwElgCNgC7Ay8aYI/7lb4y5yRizwBizID09vZKRnWeMoSiqqWujtrbSSTwD2h8+8H4CohJcRbA32bsFsMcuYOu1q1rRLiJy4kKAnbjWqOgPpAN1gSHA+c7FEhF3WpGxgmFfD+OzdZ8BqHiVWqmyI7Ah1tqcsg1rbY4x5nj/x6TgWrW4TGNcI60HGwk8aa21uBac2AS0BX4/+CBr7RvAGwA9evTwqQab/nGtIBtXAZvQzek41e/0v1Xt9VGNYNs892Rxl7IesMcqYHPSYekH0HYwxLasvlwiUmtZa2vUIogicnQdYjtwV/e7GJSoNdqk9qrsCGyuMaa8+jLGdAfyj/Oa+UBrY0zigYWZLsd1u/DBtgJnHThnfSAJ17ydGiOigWsF4qL0dQ4ncUBpCRTvr9o5ohMgOw1KvezO8gadjl3A7s+GHx+ErXOrN5OI1FrGmAnGmLcO/3I6l4hU3Y7cHdw5404yCzIxxnBth2sJDwx3OpaIYyo7Ansn8IkxpmwEtSEwvKIXWGuLjTG3A98D/sBb1tqVxpibD+x/HXgUmGiMWY7rluP7rLUZJ/5jeK9mDWLZbmMJT1tHHafDVLddq+D1vjB8ErQ7yTvYohLAlkDeboiId2++k5V0nuvrWOo0A/8gLeQkItVpykHfhwAXc+RdTyLig3YX7GbxrsVs3LuRug3qOh1HxHGVKmCttfONMW1xjZAa4A9rbVElXvct8O1hz71+0PepwLknlNjHJMaF80LxJQyL70FPp8NUt6wDc1cj6p/8ObpdA91Hnvwqxk7wD4C6LdULVkSqjbX2s4O3jTEfcPy1KkTES1lr+SPzD9rFtqNDbAemXjqV0IDQ479QpBao7C3EAD2BZKArrp6u13gmUs3SPDacj0sG8HtgD6ejVL/sFNdjVRY0Cgj2vuL1f2cfvQfsweLbaARWRJzUGmjqdAgROTmfr/uc4VOGszx9OYCKV5GDVKoyMMa8C7TEtWJwyYGnLfCOZ2LVHOHBATSPhMKtC6EoAQJr0V9A2angF1C1EdiiAvj+79B6YMW37VaXkiLYvsi1unJF4trAmu9cx/sHVk82Eam1jDH7cL0vmwOPO4D7HA0lIidtUOIgCkoK6BDXwekoIl6nskNbPYD2B1YLlhM0JGINd216GHa1cvU0rS2ytkNkQ/DzP/lz+AfB4vcgONI7Ctisba45ucdawKnMaXdAv3tUvIpItbDWRjqdQUSqZsmuJby76l2ePP1JwgLDGNFuhNORRLxSZQvYFUADIM2DWWos/3otYQ+u9iu1qYBtMxAadq7aOfz8XK10srykF2xZP9/jFbDB+rekiHjewR0CjsZau6i6sohI1aTmpPJH5h9k5GfQMKKh03FEvFZlC9g4YJUx5negvC+KtfYCj6SqYaIbtoY1kL9jLaGdnE5TjTpe4p7zRCW4bkf2BuU9YBMrPs5a+P4frg8sOg31fC4Rqa2eOfAYgutuqaW4biNOBn4D+jqUS0QqoaikiA1ZG2hbty1/afEXzmp2FsH+wU7HEvFqlS1gx3oyRE3XrEEsqbYuwTvWUWtmwFoLeza5is+AKv5FHJUA235zT66qimwI7YYcf16vMbD6a8jNUAErIh5jrR0AYIz5ELjJWrv8wHZH4G4ns4nI8T3x+xNM3TSVby/5ljohdVS8ilRCpVYhttb+DGwGAg98Px/QbUmVlBgXwebSBpC5weko1Sc3A17sCgsmVP1cdZqC8XMVxU5rdz4Mf89VoB5PXGvIWOP5TCIi0LaseAWw1q4AuhzvRcaYt4wxu4wxKw56rq4x5kdjzLoDjzGeiSwiN3a6kbF9xlInpI7TUUR8RqUKWGPMjcCnwH8PPJUAfOmhTDVO45hQXi69lO8b3eJ0lOrjjhY6Zc56EO5YUrmi0dOKCyt/bFwSZKyD0lLP5RERcVltjPmfMaa/MeYMY8x4YHUlXjcROHyFvPuB6dba1sD0A9si4iZfrPuCJ357AoCGEQ05t/m5DicS8S2V7QN7G3AakA1grV0H1PNUqJom0N+PHTE9mFXYxuko1adszmqUGwpYb1FaAk82hZ+fqtzxca2hKA/2ecn8XRGpyUYCK4E7gDuBVQeeq5C19hcg87CnLwTePvD928BF7gopIrB131Y2ZG1gf8n+4x8sIkeo7BzY/dbaQnNgBMwYE4Crz5xUUvu6lnrbp0F2I4iqBSvLla0aHN3YDedKgSl/gz63Q2K/qp/vZGWnQnE+hMdV7vj4JIhoADm73PN7EBE5BmttgTHmdeBba21V5y7Ut9amHThvmjFGH1iLVNHu/N3kFOXQLKoZt3e5HYslwK+y/wwXkYNVdgT2Z2PMP4BQY8w5wCfA156LVfN0iszhX3n/pnTzbKejVI/sFPALhLBKFnsV8Q+Cdd/Drj+qfq6qqGwLnTLNToO710BChV0uRESqzBhzAbAEmHpgu4sxZrKHr3mTMWaBMWZBenq6Jy8l4tOstdw2/Tb+b+b/UWpL8ffzV/EqUgWV/b/nfuB6YDnwV+Bb4H+eClUTRSe0gZWQk7aGqGSn01SDtudDTKKrj2tVhcW5ithsh3vBlhewx2mhU8Yb5uyKSG3xENALmAlgrV1ijGl+kufaaYxpeGD0tSGw62gHWWvfAN4A6NGjh+7KEjkGYwz397qfIP8g/Iwb/l0kUstVqoC11pYC4w98yUloVj+OVFsX/x3riHI6THVo0sv15Q5+fq72Nd5QwPoHndi83umPwr4dcNErnsslIgLF1tos454PziYD1wJPHnj8yh0nFalNikuLeXbhszSJbMIVba+gS70uTkcSqTEqLGCNMR9bay8zxiznKHNerbW1YSzRLVrEh7OhtAGt9mx0Okr12PY71GkGkcfpl1pZ0Y3/XBjKKc36QGAY+PlX/jU5O2DdD57LJCLissIYcyXgb4xpDYwB5hzvRcaYD4D+QJwxJgXXSO6TwMfGmOuBrcAwj6UWqaH8jB9bs7di0N1YIu52vBHYOw48nu/pIDVdvchgfvZrSOechU5H8bzSUpjwF9eiS2ePdc85GyQ7v5pv0iDX14mIawOL34P8PRCqVooi4jGjgX8C+4H3ge+Bx473ImvtFcfYdZb7oonUHmsy19AgvAHRwdE8N+A5Av0CnY4kUuNUWMCWrUKIa7GnNGttAYAxJhRw09Ba7WCM4fs6V7AofARPOh3G03LTobTIvS10Bjn8W7MW9myC6KbgfwILL8QluR4z1rnvlmoRkcNYa/OAfxpj/m2tzXU6j0htlF2YzcjvRzKgyQAe7/u4ilcRD6nsTPJPgNKDtksOPCcnILR+S+Zm1XU6hudlp7gea1LrmJyd8GJXWPDWib0urrXrMWOt+zOJiBxgjOljjFkFrD6w3dkY86rDsURqlaigKB4/7XHu6n6X01FEarTKFrAB1trCso0D3wd5JlLN1SbGjwF7v6Bo2yKno3hWWQ/YqEbuO+e23+G1vrBjhfvOeSLKViCOrWQLnTIxzaFJbwgMdXskEZGDPAcMBHYDWGuXAg42zhapHbL2Z3HrtFv5Pe13AAY0HUBcqBtaCIrIMVW2gE0/0GMOAGPMhUCGZyLVXM3jIxkb+DbZy79xOopnla0WHOXGEVi/ANi5HPZucd85T0TmJtdjTCVb6JTx84frf4COl7o/k4jIQay12w57qsSRICK1iL/xJz0/nZ15O52OIlJrVHYy383AJGPMy4ABtgHXeCxVDdWsfiypti7sXOd0FM9KGgQR9SDMjbdLl82ndWol4syNYPyhTtOTe7216gsrIp60zRjTB7DGmCBcqxCvdjiTSI31e9rvdKvfjYigCD4Y/AEBfiewPoaIVEmlRmCttRustacA7YH21to+1tr1no1W8zSPC2dzaQP89mxyOopnxTR3jTi6s2ALjwe/QOd6wWZudBWv/iexIMOCt2BcIhTvd38uERGXm4HbgARgO9DlwLaIuNmq3au4/ofr+WjNRwAqXkWq2fH6wF5lrX3PGPO3w54HwFr7rAez1TjRoYHsCGhEcu58p6N41rpprv6vDTq575x+fhDV8M/5tdWt+7XQdvDJvTY4ytVGZ/cGqN/evblERABrbQYwwukcIjWZtRZjDO1j2zOu3zjOaqpuUyJOON4IbNiBx8hjfMkJyo1oRkRJFhRkOR3Fc74eA3M9sPhl63MhtqX7z1sZLfpDp6En91qtRCwiHmaMaWGM+doYk26M2WWM+coYc4KrzonIsWzM2shV311Fyj5Xp4VBiYMI8td6piJOON49D2XVwiprrdrmuMHaxsM4fd2Z/BoS7XQUzygphn07INqNPWDLDH7G/eesjMJcSF3sGlE+mf9usa1cjypgRcRz3gdeAS4+sH058AHQ27FEIjVIoAlkX+E+MgsyaRxZg9oEivig443A/sUYEwj8vTrC1AaN6tdjW45hX0GR01E8I2cn2JI/F12qCXathomDYcuck3t9UDhEN1UBKyKeZKy171priw98vQdYp0OJ+LJSW8qs7bMAaBLVhC8u+ILk+GSHU4nI8QrYqbja5SQbY7IP+tpnjMmuhnw1Tou4MO4P+IDM3z92OopnlLfQ8UABu+wT+E9zyEl3/7krUtYDtm4V7sbrepWrH6yIiGfMMMbcb4xpboxpZoy5F/jGGFPXGOPGJeFFao8v13/JLdNuYeHOhQD4+/k7nEhE4Pi3ED9grb3HGPOVtfbCaklUw7WIjyDZfzZF6/ygXw1cbyPLNTfEI7cQB4a4FkPK3g4R8e4//7FkbgQM1Gl28ufof5/b4oiIHMXwA483HXgsWwZ+FK6RWM2HFamkssWahrQcQnhgON3qdXM6kogc5HgjsHMPPGq01U2axoax2TYgYO9Gp6N4RquzYNQPUNcDiy1FNXI9Vncv2MyNrhHlwJCqnWf/PrXSERG3Msb0NMY0sNYmWmsTgYeBFcDXQPcDz6t4FamkX1N+5dqp15JXlEegXyADmw8s774hIt7heAVskDHmWqCPMeaSw7+qI2BNExzgT3pgApF525yO4hkh0dC0d9WLvaOJOrBoQnX3gs3cCHUTq3aOrb/BE41h86/uySQi4vJfoBDAGNMPeAJ4G8gC3nAwl4hPCvALoKikiJyiHKejiMgxHO8W4ptx9ZWrAww5bJ8FPvdAphovL7IZkXt/dLXSqWmrEa+aDP5BkHSe+88dHg9+gdU/AvuXp6G0uGrnKJs/m7EOWp1d9UwiIi7+1trMA98PB96w1n4GfGaMWeJcLBHfkVeUx7KMZZzS8BRObXQqvRv2xs8cb4xHRJxSYQFrrZ0FzDLGLLDWvllNmWq+ui3ZuyeC6Ow0TE0rYGc/D8FRnilg/fyg+7VQr737z12RRl2qfo7wOAipA+lrqn4uEZE/+RtjAqy1xcBZ/DkHFo7/IbWIAM8ufJbJGyYz9dKp1A2pq+JVxMtV+H/ogVUMsda+aYwZdti+f3syWE22v+Uguux/g/TQ5k5Hcb+s7Z5ZwKnM4Gcgedjxj3OX7FRY+hHkZR7/2IoYA/FJrhFYERH3+QD42RjzFZAP/ApgjGmF6zZiETkGa12dpm7vcjsvn/kydUO0YLeILzjeR0yXH/T94b1gPTDEVju0qBcBwMb0XIeTuFlxoasPrKd7wBYVePb8B9s6D764yT3zbuNaqxesiLiVtfZx4P+AiUBfW/Yvctf7+2incol4u7dXvs1dM++i1JZSJ6QOvRr2cjqSiFTS8QpYc4zvj7YtlZQYF85DAW8TPvdpp6O41740wHq2gP3pMfhPMyj/N5qH7dnkeoyp4iJOAJ2GwRn3Qmlp1c8lInKAtXaetfYLa23uQc+ttdYucjKXiDcL8Asg0C+QotIip6OIyAk63vwYe4zvj7YtldQoOpR2ftuISavmxYg8rWyU0pO3EIfFQXGB65be8FjPXadM5kaIqA/BEVU/V4v+ri8RERGpdin7Usjan0WHuA5c2fZKrmx7pVrkiPig4xWwnY0x2bhGW0MPfM+BbQ/0Sakd/PwMmcFNaJ/3m9NR3KtJb7hrJYR6cA5JeS/YlGoqYDf9uYJwVZWWwu51EBgKdZq655wiIiJyXNZa7vvlPnKKcvjiwi+0UJOID6vw/15rrb+1NspaG2mtDTjwfdl2YHWFrIkKIpsRVbrX1UqnpvDzh+jGEBTmuWuU3Z5cXa103FnAYuH10+H38W46n4iIiFTEWkupLcUYwyOnPcJLZ76k4lXEx2mJfafEtYRMKM7YQEDjbk6ncY8Vn7sWcTrlFs9do+z2ZHcsqlQZN06H0hL3nMvPH2JbaSEnERGRalBcWswDsx8gISKB0V1H07JOS6cjiYgb6CMoh4Q2bMuq0makZ+51Oor7LP8UFr3j2WuEx8Opt0P9jp69TpmoRlCnifvOp5WIRUREqoW/8SfEP4QQf816E6lJVMA6pF6LZP5S+AR/BFVTIVYdslP+nKPqKX7+MPBxaHqKZ68DkLoEfn0G8ve475zxSbBnc/W2AhIREalFFuxYwI7cHRhjeOjUh7gx+UanI4mIG6mAdUhi3IFesBk1qBds1nbP94AFKMxzXcvTNv0C0x9x7znj2oAtda1uLCIiIm6VW5TLnTPv5LmFzwFolWGRGkhzYB0SExbI4yHv0u33fdD3G6fjVF1RAeRluBZx8rSvboO0JTBmsWevk7nRtaJyaIz7ztn8dLjiw+r5PYmIiNQSJaUl+Pv5Ex4YzstnvkyrOq2cjiQiHqIRWIcYY4gPsTTKWe50FPfI2QnGr3pGYKMauVYhth5uRZy5EeomuveckfUhaRCERLn3vCIiIrVUZkEmV393NVM3TwWgS70uRAS5oX+7iHglFbAO2h/VjOjSrJrRSiemGTyQDp2Gev5a0Y2huADyMj17nT3ubKFzkK3zYP00959XRESkFooMjCQqOIpgv2Cno4hINVAB6yC/WNftLQU71zucxE38AyCgGt48yhaK8mQrnZIi2LfTMwXsL0/BtIfdf14REZFawlrLd5u+I784n0D/QF476zUGNB3gdCwRqQYqYB0U2agNABlbVjmcxA1WfglT/galpZ6/VtSB+aOeLGD9A+EfqXDaHe4/d1wSZKyrnt+ViIhIDbR2z1ru++U+Pl7zMaDFmkRqExWwDopv1o7pJV3Zvr8G9Cfb9Aus/AL8quGPVGwLGPiEqyWNJ/kHQFC4+88b1xqK811th0RERKTSikuLAUiqm8SbA9/kqnZXOZxIRKqbClgHNWsQy/VF9zDfv4vTUaouu5pa6IBrVeBTb/XM7b1l/vjGNaJcvN/95y4rvNPXuv/cIiIiNdQfmX9wwZcXsHr3agB6NuiJv5+/w6lEpLqpgHVQWFAADaND2JxeAxZxytoO0dVUwIJrheBdf3ju/Bt/hmUfg3+Q+88d57p1nAwVsCIiIpUVFxpHg/AGBPipC6RIbaa/ARz298AP6LtmGrDZ6ShVk50CTXpV3/W+uNlVXF43xTPnL2uh44k5NeFx8NdfIVY96kRERCpSVFLElI1TuKjVRcSFxvHWwLecjiQiDtMIrMOCIuOoW7oHCrKdjnLyigshMAzqNK2+a5b1gvWUzI2evUW5YTIEhXnu/CIiIjXAd5u/419z/sWCnQucjiIiXkIFrMMC4loCkL19jcNJqiAgCP62CvreWX3XjEpwzbu11v3nLimGvVs9W8BunQcz/u2584uIiPiwotIiAIa0GMLE8ybSs0FPhxOJiLdQAeuwqIS2AGRsXe1wEh8TlQDFBZC/x/3nztsNkQ0gtqX7z10mZT78/B/Iy/TcNURERHzQ95u/56IvLyIjPwNjDN3rd3c6koh4ERWwDqvfzFXA5u3w4QV91nwH7w+v3mKsbMGoLA+0oomsD3etgK4eXJpfCzmJiIgcVdPIpiRGJ+JvtMKwiBxJBazDEurF8t+SIaw2Hhzt87Qdy2HtVM/0TD2WJr3hsnegTpPqu6Y7qYAVEREpl1mQyTcbvwGgXWw7Xj7rZWJCYhxOJSLeSAWswwL8/fiozg38VJzsdJSTl5UC4fEQEFx914xsAO0vdPWEdbfZL8In17n/vAer0xT8gyHdh+c+i4iIuMn4ZeN5eO7DZORnOB1FRLycClgv0DI2hLydG52OcfKyt7vmpFa3Tb9A6hL3n3frPM8Xln7+rjY6nrgFWkSkiowxdxljVhpjVhhjPjDGhDidSWqmwpJCAMZ0G8O7g94lLjTO4UQi4u1UwHqBy4sn8/a+GyjN2+t0lJOTtR2iG1f/db+4BX573f3n9XQLnTLX/wDDJnr+OiIiJ8AYkwCMAXpYazsC/sDlzqaSmuilxS9xww83UFRSRGhAKEl1k5yOJCI+wKMFrDHmPGPMGmPMemPM/UfZf48xZsmBrxXGmBJjTF1PZvJGgfGtAEj31ZWIoxpC/Y7Vf93oA6103Km0FPZsgrqJ7j3v0QRHgDGev46IyIkLAEKNMQFAGODBxttSW7WOaU3bum1Bb4UicgI8VsAaY/yBV4BBQHvgCmNM+4OPsdY+Za3tYq3tAvwd+NlaW+v6ikQ3dn3imLnNR+dDXv0FDPh79V83qpFr9Ned9qW52vPEVEMBu2s1fHYDZKz3/LVERCrJWrsdeBrYCqQBWdbaHw4/zhhzkzFmgTFmQXp6enXHFB+1ZtcyZqf8CsB5zc/jH73/QaBfoMOpRMSXeHIEthew3lq70VpbCHwIXFjB8VcAH3gwj9dq2LwdAAU7tSLtCYlKgOxUsNZ95yzMhSanQL127jvnsZQUwfJPYMcyz19LRKSSjDExuN6vE4FGQLgx5oi+YtbaN6y1Pay1PeLj46s7pvia0lLs0o94cvKVjJv1ACWlJU4nEhEf5ckCNgHYdtB2yoHnjmCMCQPOAz47xv4a/SlvfN0Ydti6mEwfXMhp06/wWl/Y9Uf1XzsqAYrzIX+P+84Z3wau/x6a9XHfOY8lthVgIGOd568lIlJ5ZwObrLXp1toi4HOgGv5SlJqqZOPPFI3vj/niJp4ojubNbvfj76ceryJycgI8eO6jzWg41lDZEGD2sW4ftta+AbwB0KNHDzcOt3kHYwyTIq+jKKABXZwOc6IyN8LO5RAYWv3X7nCRqx9sUET1X9sdgsJcfWzVC1ZEvMtW4JQDHy7nA2cBC5yNJL6q5Lu/c/vmT6jnF8LYi16nQfJw8NMaoiJy8jxZwKYATQ7absyxF4G4nFp6+3CZzQkXsHTbXo5Y6crbZW8HjGs+anWLauT+6355KxRkweWT3HveY4lLggwfnfssIjWStfY3Y8ynwCKgGFjMgQ+RRSolZ5frg+3gSPxbn0VyUQpxrQdh2l3hdDIRqQE8WcDOB1obYxKB7biK1CsPP8gYEw2cARwxv6Y2SapjSV++kP35PQkO9aERxaztEFEf/B1YgKG40DWHtH4HaNTFPefcsQwiG7rnXJXRoBNs3uuax6sViUXES1hrHwIecjqH+JjCPJj3Csx6nmnJg2l+2r20anU2t7Q62+lkIlKDeOweDmttMXA78D2wGvjYWrvSGHOzMebmgw69GPjBWpvrqSy+oGfpcj4MepSdG5Y6HeXEZG93tbNxgp8/TB4Nf0xxz/mshcxN1dMDtszZD8EN01S8ioiI7yotgcWT4KXu8NNj5CX24985f/DGcg3ci4j7eXIEFmvtt8C3hz33+mHbE4GJnszhC2KaJMF82JOyhqYdT3M6TuXV7wABwc5c28/fNVrqrlY6uelQmFO9BayIiIiv++4+mD+evIRuhF76JmHN+/C/rI0kRDj0AbeI1GiaRe8lGiS62rbs3+ljK9IOfBzO+pdz149qdGAerhtkbnI9VmcBW5QPE/4CC9+uvmuKiIhU1c5VkJXi+r7HKDIufJHhceG8n+96L20R3YJgf4c+4BaRGk0FrJeIioxmJ3Xx2+ODrXSc5M4CNjAEOlwC8UnuOV+lrhkKu1ZD6qLqu6aIiMjJ2rfDNX3n9dNg5hOu5+q3p26Xq+lWvztJMcd/Dy0uKeV/v25kX0GRh8OKSE2kAtaLZAQmEJG71ekYlbdzJfwnEdZPcy5DVAJkp7rmr1ZVw84wbALUaVr1c52I+CRIVysdERHxYvtzYOaT8GJXWPIB9L6Z0rMf5t1V77K3YC9+xo+H+zxMjwY9KjzN2p37uPjVOTz2zWqmLEurpvAiUpN4dA6snJiZTW5l7pZ9vOd0kMrKSoH8TAiOci5D3zvhtDHuOVdRgWsUtrrFtYY/vj3+cSIiIk75+UmY8xK0v8i1AGHdFmzeu5HnFj5HqS3l2g7XVvjy4pJSxv+6ied+XEtESACvjujGXzpV46r/IlJjqID1Iv7NejNr1R9kFxQRFeJAW5oTVTb3JcrBRRoi6rnvXBMGuW5Jrq4esGXikiDvHcjLhLC61XttERGRo7EW1v0I4XGQ0A36jIF2F0CTXuQW5RIOtKjTgo/P/5iWdVpWeKoN6Tn838dLWbJtL+d1aMBjF3ckLkLzY0Xk5OgWYi+SFFnIhX6z2LZ5g9NRKic7FYw/RDZwLkPubvh5nOt25qrK3OjqaVvdGnWB1ufC/n3Vf20REZHDpS2Ddy6E94fB3Fdcz0XUgya9WJ6+nPM+O495afMAaBXTCnOMVnAlpZb//bqRv7zwK5t35/LiFV157apuKl5FpEo0AutFWoZk80LQq8xf3xLatnU6zvFlb3e1sfHzdy5DcQHMeBzC410tfU5WXiYU7HWmhU7zvq4vERERJ2WlwE+PwdIPITQGzvsP9Bh1yCEt6rTg1Ean0iSySYWn2pSRyz2fLGXBlj2c3a4+/76kI/UiHZimIyI1jgpYL1I/sT0A+3etdzhJJTXu6eztw+AaMTV+VV+JeI8DLXQOV1oKfropQkREHLL8U1jxuWttib5/g9A6AOQV5fHuqne5vtP1hAeGM67fuGOeorTU8s7czTw59Q8C/f149rLOXNw14ZijtCIiJ0oFrBcJDo1kl4klcK+PtNLpeb3TCcA/wDUKnJ1atfOU94BNrHqmkzHpMlchfuWHzlxfRERqn5IiWPQ2RDSAdudD75uhw8UQ0+yQw2anzubVpa/StV5XejXsdczTbd2dxz2fLuW3TZn0T4rnyUuSaRCtUVcRcS8VsF5md1ACEXnbnI5xfNZCUT4EhTmdxLXwUtmCUicrtiX0GQ0xzd0S6YQFhasXrIiIVJ+92+CDK2Dnckge7ipgA0MOKV73Fe4jMiiSc5qdw5cXfkli9NE/5LXWMum3rfz729X4GcO4S5MZ1qOxRl1FxCN0v6KXyYtoRv2i7Vh39DX1pLxM+HdDmP8/p5O4CticnVU7R6OucO5jEBjqnkwnKq4N7Nni+lBARETEk9KWwv/Ohr1b4LJ34eL/HnHI5A2TGfz5YLbtc32ofqziNWVPHle/+TsPfLmC7s1i+P6uflzWs4mKVxHxGI3AeplNHW7nth/O5at9+6kf5cW33WQfGPEMd2Mbm5N14atVLzwzN7nm0zo1ohzfBrCwewM06OhMBhERqfkyN8Fbg1yLNI36Huq3P+phXet1ZUDTAcSGxB51v7WWj+Zv47FvVlNqLY9f3JErezVV4SoiHqcRWC/ToEkrdhDLxvRcp6NULOvAoknRDi/iBBAcUfWVkN88F6be5548JyOujesxY41zGUREpOaLaQ7974Mbph1RvG7P2c7bK98GoElkEx7u8zBhgUd+sJuWlc91E+Zz/+fL6ZgQxfd39mNE72YqXkWkWqiA9TItoi23+E8me/08p6NUrGzV36jGzuYASF8Dk8fAns0n9/r9+yB3F8Q4tIATQGwr6H4dRDd1LoOIiNRMpaUw49+wazUYA6fdAVENjzjs83Wf89+l/2Vn7tGn5Vhr+XRhCuc+9wu/b8rk4Qs68P4Np9CkrheshyEitYZuIfYyDaLDuC/wQ2ZujQYGOx3n2LK3g1+gq/+q0wqyXKsothtycoswZXpBC53AUBjygnPXFxGRmqmoAL68GVZ+ARio1+6Q3dZasguziQ6O5pbOt3BJ60uoH17/iNPsyi7gH18sZ9rqXfRsHsNTQzvTPC68mn4IEZE/qYD1Mn7B4aSbWAKzNjkdpWLN+kJgmHf0LY1q5Ho82ZWIMw+0LXKygAUoLYF9O7zjtmwREfF9eZmulYa3zYNzHoE+Y444ZNz8ccxJncMHgz8gLDCMhIhD34OstUxemsq/vlpJQVEJD57fnuv6NMffT7cLi4gzVMB6oT3BjYnO2+p0jIq1Ptv15Q0iGrh6qJ5sL9jyAtbBW4gBfvyXa1Xnf6R5xwcDIiLiu7K2w9tDXB/uDpvo6u96FP2b9Cc6OJqQgCMXjszI2c8/v1jO9yt30rVpHZ4e1pmW8REeDi4iUjEVsF4oP6o5CTtnUFxSSoC/lxYymZsgsoFzbWcO5h/gKmJPtoBtfS6E1oHgSLfGOmFxraG4ALK2OtePVkREaobwOKjfAS56FZqecsiuBTsWkJabxpCWQ+jdsDe9G/Y+4uXfLEvjwa9WkFNQzP2D2nLj6S006ioiXsFLq6PazdRtQTS5pOzMcDrK0ZWWwss9YeYTTif5U0wzKNl/cq9t0BF6jHJvnpMRl+R6zFjnbA4REfFda7933TocEAzD3z2ieAWYuHIiE1ZOoLi0+Ih9mbmF3P7+Im57fxGNY0L5Zkxfbj6jpYpXEfEaGoH1QsU9b6Ldkq68kW1p3sjpNEeRmw6lRd6xAnGZkd+5VlY8GRtnuorHo6zIWK3KW+mshdbnOJtFRER8i7Uw9xX44QHo/VcY9J9Ddu8v2U9xaTHhgeE83vdx/IwfAX6H/jPw+5U7+OcXy8nKL+KegUn8tV8L770TTERqLf2t5IUSG8RRTID39oLN9qIesGVOtngtyod3LoTF77o3z8kIj4WwWFdbIBERkcoqLYFv74Ef/gntL4Czxx6yu6S0hBt/uJH7f7kfay3RwdFEBv05bWZvXiF3friYv767kPpRIUy+vS+3DWil4lVEvJJGYL1QTGgAT4S8g1l3Cpx+l9NxjlTeA9aLCtgNP7k+eR76FoREV/51Zb1jnV6BuMw5j0CdZk6nEBERX1GYC59eD2u/gz6j4exHjlgI0N/PnyEthxATHIM57APf6at3cv/ny9mTW8idZ7fmtgGtCFThKiJeTAWsN/Lz41y/+azIKAG8sIDN8sICNn8vrJ/mynYiBWxZD9gYh1cgLtP1KqcTiIiILynMhfQ/4C9PQ68bD9n1ydpPaBndkm71uzGszbBD9uXsL+bhySv5ZGEKbRtEMuG6nnRMOIH3TxERh6iA9VJ7QxpTJ3+b0zGOrnlfGPiEa4VDb1FWTGenQv32lX+dt7TQKbN/H+xYDg07Q5AaxIuIyDFkboLoxhBRD26dB4GHtsHJL87n7ZVv0zm+M93qdztk35Jte7njw8Vsy8zjtgEtGXNWa4ID/KszvYjISVMB66UKoprTKHcGeYXFhAV52X+mBh1dX94k6sBqV9kpJ/a6zI0QUgfC6ro90knZMhfeHwajvj/qypEiIiJs+gU+vAq6XwvnPnpI8ZpZkEl0UDShAaG8NfAtYkNiy/eVlFpe/3kDz/24lvpRIXx406n0SvSS9z8RkUrSJAcv5RfbiniTzZbUHU5HOdL2Ra7G6N4ksgFgTrwXbJ/b4bJ3PBLppMQfWIlYCzmJiMjRLP0I3r3EtXL+YbcM787fzbDJw3ht6WsA1Aurh7+fa2Q1dW8+V46fx1Pfr2FgxwZ8e8fpKl5FxCd52dCelIlMSGL7ilh2pG6lXXMvalcD8NHVrtuIL/mv00n+5B8ICd1dfe9ORN0W3rOAE0B0EwgIcbXSERERKWMt/PIUzHgcmp8Ow9+D0DqHHBIbGsslbS7h7KZnH/L8d8vTuP/z5RSVlPLU0GSGdm98xGJOIiK+QgWsl4rtMZR2kyP4v/x4Bjgd5mClJbAvzbta6JS5cfqJHV9S5Gqf06K/9xSxfv4Q21oFrIiIHGrvFpj1PCRfDhe8BAFBABSVFvHy4pe5POlyGkY05LYut5W/JK+wmEenrOKD37eR3DiaFy7vSmKc1lcQEd+mAtZLhQb50yg6hE0ZXtYLNmcn2BLvWoH4ZO3dClPugote854CFiCuNaQucjqFiIh4g+L9rruLYprDTTNd7xEHjZ7uyN3Bx2s+pl5YPUa0G1H+/IrtWYz5cDGbMnK5pX9L7jq7DUEBmjkmIr5PBawXezzgDdK31AG86FZdb2yhU2b+m7BkEtz4U+WOL1+B2IuKV4C+d7n+wSIiIrVbVgpMGgY9r4eeN/y5TgKwK28X9cLq0SSyCZMvmkx8WDwApaWWN2dtYtz3fxAbHsykG3rTp6UXdQ0QEakifRTnxZqzg1Z5i7HWOh3lT2Wr/HrjLcSFubB9IRRkVe54by1gGyZDk55OpxARESelLYXxZ7mK2LotD9m1NH0pf/n8L/y45UeA8uJ1V3YB1074nce/Xc2Zbevx3R2nq3gVkRpHI7BerDA6kSY509mTV0Td8CCn47g0OQWGve19RR/8WVRnp0JIJZqxZ26EwHAIj/dsrhNVVACrv3b1s63fwek0IiJS3db+AJ9cB6ExrrZqh/U3b1+3PZcnXU73+t3Ln5u2aif3fraMvMJi/n1xJ67o1UQLNYlIjaQRWC8WEN+SeJPN5u1pTkf5U1RD6HARBHnhIhBltzWX3eZ8PJkbXYW4173BW/j8RlcRKyIitcuezfDhFRDbEm6YVl687inYw2PzHiO/OJ9A/0Du7nk3dUPqUlBUwoNfruCGdxbQICqEKaNP58reTVW8ikiNpRFYLxbVKAmWQsa2P6BNM6fjuGz61dXmxRtvcY1q5HrMrmQBe8l4yM/0XJ6TFRgKMc3UC1ZEpDaKaQ6XvgmtzobgiPKnV2euZvKGyQxsPpCeDVzvwavTshnzwWLW7crhxtMTuXtgEsEB/g4FFxGpHipgvVhMs44sKm3Njsx9Tkf507SxrjfUa75yOsmRIhtC01Mrd/swuPrnHdZDz2vEtYGMdU6nEBGR6lBUAF/fAV2vgsTTXXc6HZCWk0bDiIb0adSH7y75jtjQWKy1TJyzmSe++4OokEDeGdWLfm28bDqMiIiH6BZiLxbQoD33RD/NnIJEp6P8KTsVoho7neLo/ANh1NRD3viPKWcX/PQYZKz3eKyTEtcGdq9z9d0VEZGaKy8T3r0Iln0Iu1YdsuvTtZ8y5MshrNvj+kAzNjSWjJz9jJw4n4e/XkXfVnFMvfN0Fa8iUqtoBNbLJcZFeE8v2JJiyNnhnSsQn6idK+GXpyCxH8S1cjrNkeLaQHGBq1dtXS/6AENERNxnzxZ471LX3/VDJ0DHSw7ZfWbTM0nNSaV5VHMAZq7Zxd2fLCW7oJhHLuzA1ac001xXEal1VMB6udtyXmDfni2Ulv6Mn5/Db1L70sCW/jnX1Bt9d7+rlc4NP1Z8nLe20CnT/kJodZZ39tsVEZGqy0qBN89xfVh5zZfQrA8Aa/es5cv1X3JPj3uoG1KXMd3GUFBUwhPfruKt2ZtIqh/JpBtOIalBpLP5RUQcoluIvVxUcADtzCa27813OsqfiyN56y3EAFhI/+P4h+3ZBP7BEOmlxXhoHYhu7IUrJItIbWGMqWOM+dQY84cxZrUx5lSnM9UokY2g0zAY9UN58QowN3UuUzdNZWfeTgDW7dzHRa/M5q3Zm7iuT3O+uv00Fa8iUqupgPVygfVaEW+y2Zq2w+ko0KAT3DDdO1cgLhPVCPZnQ0F2xcdlbnLdmuvnxf8LzH8TFk9yOoWI1F4vAFOttW2BzsBqh/PUDCs+d7XK8fODgY9DvbaUlJaQmpMKwDXtr+HzCz6nflh93p23hfNfmkX6vv28dV0Pxl7QgZBArTIsIrWbF//rXQCiE5IAyNzmBS1VgsKhcY/Kr/LrhLJbbrNTKz4uO9V7bx8us/xTWPyu0ylEpBYyxkQB/YA3Aay1hdbavY6G8nXWwuwX4NOR8MvTh+x6/LfHufq7q9lXuA9jDKUlYdz4zkIe/HIFvVvE8t2dp3Nm2/oOBRcR8S6aA+vlohq1AaBg5zpgkLNh1k+Hgr3Q8VJnc1SkvIBNgXptj33cjT9BUV71ZDpZ8W1g1WSnU4hI7dQCSAcmGGM6AwuBO6y1XrKqoI8pLYXv/wG/vQYdLobBzxyye3jScNrWbUtkUCSz1mXwt4+XsDeviAfPb8/IPs2dXwNDRMSLaATWy5nYlvwadDrrckOdjgIL3oKfn3I6RcVimkPHoRASU/FxxrhGlL1ZXBvIz4Tc3U4nEZHaJwDoBrxmre0K5AL3H3yAMeYmY8wCY8yC9PR0JzL6hqIC+GyUq3jtfQtc+hYEBDN963QmrJgAQFLdJC5qOZQnvl3NVW/+RmRIAF/c1ofr+yaqeBUROYwKWG8XFM4niY/yXU5Lp5O4FnHy9hY6UQ1h6JvQuPuxj0lbBl/c4poH683iXKPvZHjB7eMiUtukACnW2t8ObH+Kq6AtZ619w1rbw1rbIz5efUiPqbTYNef1nEfhvCfK1174aetPTNsyjaLSIjam53DJa7P57y8bubJ3U6aMPp0Ojbx4uo6IiIN0C7EPSIwL58dlm9hfXEJwgIOLN2Rtdy3k5AtKisA/8Oj70pbC0vfhjHurN9OJimsDxv/483lFRNzMWrvDGLPNGJNkrV0DnAWscjqXT8lOg+BICI5wrTQcEEROYQ4FJQXEhcbx4CkPYozhq8U7efDLFQQH+vHfq7szsEMDp5OLiHg1FbA+4MK057kqaApbdp9Dm/oOLZ1fvB9yd3l5C50DJp7vKl6v/uLo+zM3gl8ARDep3lwnqk5T+OcOCAhyOomI1E6jgUnGmCBgIzDS4Ty+Y9dqeG+oa9X+YRMhIIhSW8oNP9xAsH8wE8+bCDaQsZNX8sHv2zilRV2eH96VBtEhTicXEfF6KmB9QFhsY+I3ZrEkdadzBWzZKKC330IMrlWSd68/9v7Mja7i0N/L//gbo+JVRBxjrV0C9HA6h8/ZMgc+uBwCQqDv38qf9jN+3JR8E5FBkWzfm88t7y1i+fYsbunfkv87pw0B/prVJSJSGfrb0gdEJ7hW092b4uBcyDrN4G+rod0Q5zJUVlRCxbfd7tnk/S10yix5Hz670ekUIiJSGau+gncugvB6cP2PlDboyH+X/pfpW6cDcGbTM8nLbs75L81ic0Yub1zdnfvOa6viVUTkBOhvTB8Q2qA1APt3rXUuhJ8fRDXy7h6wZaIawf5sKMg++n6/AIivoMWON9m7FZZ/AoVe3vJHRKS2K8yFb++Fhslw/Q8Q04zi0mJmbpvJnO1zKC21vDh9HddN+J0GUSFMHt2XczXfVUTkhHn5PZQClI8W+u1xcNXcddMgdTGc/n/lKyh6regD83SzUyEk6sj9N/5UvXmqIq4NYCFzg+8soCUiUptY6/oKCodrv4boxqTszyS+JJxg/2DGnzueoqJArn97PjPWpHNx1wQev7gjYUH6J5iIyMnw8kpEAAgKZ1q96/g5L9G5DGu/g7kve3/xCtAgGU67w/v7vFZGWSuddLXSERHxOiVF8OUtMP1h13Z8G/aU7mf4lOE8t/A5ADanlzDk5dnMWp/Boxd24NnLOqt4FRGpAh+oRgRgQ4cxfJ/Xhqz8ImcCZG13zS31BfFt4JxHoM5RVhlePQXeHgI5u6o/18mIbQUYyFjndBIRETnY/n3w/mWw9APXB6bWAhATEsOd3e/kqnZX8fGCbVzy2hxKSi0f/fVUrj61OcYYh4OLiPg2FbA+omWMPy3NdjZl5DoTIDvFN1YgLrM/B/Iyj3x+xzLY9KtvzOUFCAyBJr3Bz8H+vyIicqicXa6WbRt/hgteJq/P7Tww+0HW7nGtVTEk8RJe+TGTez9dRo9mMUwZ3ZduTWMcDi0iUjPoHhYf0SX1Q6YHP8HXaf3o0qRO9QfI2g4JPtRN4cWukHQeXPDSoc9nbnL1fw0IdibXybj+e6cTOKKoqIiUlBQKCgqcjiI1REhICI0bNyYwMNDpKOLLSopg4mDISoErPoA2A8nNS2de2jy61utKqG3MrZPUIkdExFNUwPqIP1vprIVe1byCblGBa1VfXxqBjU5wFd2Hy9wIdR2cSyyVlpKSQmRkJM2b65Y7qTprLbt37yYlJYXERP0dIFXgHwgD/gnRTVgXHkUra4kPi2fyRZP5fWMOQ16eRUmJ5Y2ru2uVYRERD9BHgj4iML4lAIXpDsyFDAyBB3bBqaOr/9on61i9YDM3+k4P2DIbZsDLvWDPZqeTVKuCggJiY2NVvIpbGGOIjY3ViL6cvLXfw4rPXN93uIilwQEM/XooX67/ktJSy/iftzNy4nwaRIXwtVrkiIh4jApYX3Gg6ArYu9mZ6/v5uwpZXxHV6MgCtrgQGnaGhG7OZDpZgaGQsQbSHewD7BAVr+JO+vMkJ23RO/DBFTDvdSgtBaBTXCf+1v1v9K4/gOvfns9z09ZyUZcEvrj1NJrH1YBV8EVEvJQKWF8RFE52YBxReVuwB1Y6rDYbZ8LXd0L+3uq9blVEJcD+LNcqkWUCguCaL6HbNY7FOillrXQy1EpHRKRaWQsz/wOTR0OL/qRe8ip3/vw39hTswc/40b3ORVz22qJDWuSEBmnRPRERT/JoAWuMOc8Ys8YYs94Yc/8xjulvjFlijFlpjPnZk3l83eL29/Fu4QB2Zu+v3gtvmw8LJ/jWwkctB8CgcUANGHEJqwtXfAQdL3U6Sa2xe/duunTpQpcuXWjQoAEJCQnl24WFhYcc+/zzz5OXl3fcc/bv358FCxYcdd/QoUPZuHFjlXNPnjyZJ598ssJjUlNTGTp0KABLlizh22+/rfJ1D/biiy/Srl07RowYcUiesWPH8vTTT1f6PBMnTuT2228v305LS+Pcc88FYOXKlZx55pm0adOG1q1b8+ijj5Z/sDdlyhQeeughN/5EUmtZC1PuhJn/hs5XwJUfsbukgMW7FrM5ezMfz1eLHBERJ3isgDXG+AOvAIOA9sAVxpj2hx1TB3gVuMBa2wEY5qk8NUFAp0tYZNuwMSOnei+cnQJhsa5bWX1Fw87Q+68QHPHnc7NfgJe6u24l9jVJ57lui5ZqERsby5IlS1iyZAk333wzd911V/l2UFDQIcdWtoA9lpUrV1JSUkKLFlWfm33BBRdw//1H/aywXKNGjfj000+BqhewxcXFRzz36quv8u233zJp0qRK5amsqVOnMnDgQPLz88vPu3btWpYuXcqcOXN49dVXARg8eDCTJ0+u0n8TEQCMgZA62NPuYtXpo8E/kE7xnfjqgm/46Fd/7v1sGT2bq0WOiEh18+QqxL2A9dbajQDGmA+BC4FVBx1zJfC5tXYrgLV2lwfz+LwW4fvp77eErTtb0adlXPVdOGu765ZcX1JaChlrISTqz8IvfS0U5rpuJRaf8vDXK1mVmu3Wc7ZvFMVDQzpU+vjp06dz9913U1xcTM+ePXnttdf473//S2pqKgMGDCAuLo4ZM2Zwyy23MH/+fPLz8xk6dCgPP/xwheedNGkSF154Yfl2REQEd9xxB1OmTCE0NJSvvvqK+vXrs2XLFkaNGkV6ejrx8fFMmDCBpk2bHnKuiRMnsmDBAl5++WWuu+46oqKiWLBgATt27GDcuHEMHTqUzZs3c/7557No0SL+9a9/kZ+fz6xZs/j73//O8OHDy89VUFDALbfcwoIFCwgICODZZ59lwIABTJw4kW+++YaCggJyc3P56aefyl9z8803s3HjRi644AJGjRpFTExMeZ6Dbdiwgdtuu4309HTCwsIYP348bdtWvLr61KlTeeihh3j//fc57bTTykdjw8LCePnll+nfvz+33XYbxhj69+/PlClTuOyyyyr+jypyNHmZsC8N6neAs8fyydpPePzbK3l/8PtEmURunbSE5duzuLV/S/7v3CT8/TTqKiJSnTx5C3ECsO2g7ZQDzx2sDRBjjJlpjFlojDnq5ERjzE3GmAXGmAXp6ekeiuv96u+ez8SgcexLWXX8g90peztEN67ea1ZVaRG82hsWvfvnc764ArF4hYKCAq677jo++ugjli9fTnFxMa+99hpjxoyhUaNGzJgxgxkzZgDw+OOPs2DBApYtW8bPP//MsmXLKjz37Nmz6d69e/l2bm4up5xyCkuXLqVfv36MHz8egNtvv51rrrmGZcuWMWLECMaMGXPc3GlpacyaNYspU6YcMRIaFBTEI488wvDhw1myZMkhxSvAK6+8AsDy5cv54IMPuPbaa8tX8J07dy5vv/32IcUrwOuvv17++7jrrruOmeumm27ipZdeYuHChTz99NPceuutFf4cJSUlrFmzhvbt27Ny5cpDfl8ALVu2JCcnh+xs14ccPXr04Ndff63wnCJHtWcLvHkuvH+5624dYzi/xfnc3+t+dqbHMuTlWWzOyOWNq7tz73ltVbyKiDjAkyOwR/tb/fDVhwKA7sBZQCgw1xgzz1p7yHKr1to3gDcAevToUc0rGHkPvzhXK53i9A3Ve2HjBzHNq/eaVRUQDOHxruK7TOZGaHW2c5nkpJ3ISKknlJSUkJiYSJs2rgW1rr32Wl555RXuvPPOI479+OOPeeONNyguLiYtLY1Vq1aRnJx8zHOnpaURHx9fvh0UFMT5558PQPfu3fnxxx8BV9H4+eefA3D11Vdz7733Hjf3RRddhJ+fH+3bt2fnzp2V/nkBZs2axejRrtZZbdu2pVmzZqxd6/qr+ZxzzqFu3bondL4yOTk5zJkzh2HD/pwxsn9/xfP6f/vtN3r37g24+rkea55h2fP16tUjNfUobbREKpK2DCYNheICFg16jPdn/4MnTn+CEP9QdqZ05x/TF5JUP5LXr+quVYZFRBzkyQI2BWhy0HZj4PB/UaQAGdbaXCDXGPML0Bmoff1CKiMmEYDArE3Ve91bZlfv9dwlKuHPArYwF3J2QN1EZzOJTwoPr9w/Vjdt2sTTTz/N/PnziYmJ4brrrjtu39HQ0NBDjgkMDCwvxPz9/Y86zxQq1xImOPjPhddOdPXyio6v7O/jaEpLS6lTpw5Lliyp9Gu+++47zjvvPAA6dOjAL7/8csj+jRs3EhERQWRkJOAaMQ8N9aE5++K8DTPgo6shJBpGTWb7vnWs2biGTZk7+PfXacxck84lXRN4/OJOWmVYRMRhnryFeD7Q2hiTaIwJAi4HJh92zFfA6caYAGNMGNAbWO3BTL4tOIKcwDii87dRVFLqdBrvF5XwZy/YogLochU06eVsJvFJBQUFbN68mfXr1wPw7rvvcsYZZwAQGRnJvn2udk3Z2dmEh4cTHR3Nzp07+e6774577nbt2pWftyJ9+vThww8/BFzzZvv27XuyP065g7Mfrl+/fkyaNAmAtWvXsnXrVpKSkqp8zaioKBITE/nkk08AV6G8dOnSCl8zffp0zjrrLABGjBjBrFmzmDZtGgD5+fmMGTPmkBHptWvX0rFjxypnlVrk9/EU1mnCH5e+BvXaMqTlEB7u/iaj3lzH7PUZPHpRR55RixwREa/gsQLWWlsM3A58j6so/dhau9IYc7Mx5uYDx6wGpgLLgN+B/1lrV3gqU02QH9mMZmYH2zKraYXNbfPhvaGwu5pvW3aHqEZ/jsCGx8JFr0BiP2cziU8KCQlhwoQJDBs2jE6dOuHn58fNN98MuOZzDho0iAEDBtC5c2e6du1Khw4dGDVqFKeddtpxzz148GBmzpx53ONefPFFJkyYQHJyMu+++y4vvPBCVX8sBgwYwKpVq+jSpQsfffTRIftuvfVWSkpK6NSpE8OHD2fixImHjOhWxaRJk3jzzTfp3LkzHTp04Kuvvjrmsenp6YSEhBAVFQVQvrDVY489RlJSEp06daJnz56HtNyZMWMGgwcPdktWqcGshYIDi8Nd8gaPd+zP9XP+Ttb+LD6av5XL31hISanl47+eytWnNFOLHBERL2FO9LYyp/Xo0cMeq5dibbB60S+M/mQ1f7/mIs5qV9/zF1z0Lky+He5Y6nvzYFMXu1ZQbjsYigsgIMTVFkF8wurVq2nXrp3TMTwuPz+fAQMGMHv2bPz9NbpzuPfee4+UlJRKt+PZuXMnV155JdOnTz/q/qP9uTLGLLTW9qhy2FrM596bS4pgyl2wYxmMnApBYWzP2c7SXSv5eVEDPlqwjb6t4njh8i7ERvhQD3QRkRqiovdmT86BFQ9o2PYU1tt9bMrIrZ4LZm8HDET6YA/SRl1dXwBT74f10+EuDfCLdwkNDeXhhx9m+/btR7TFEbjqqqtO6PitW7fyzDPPeCiN1Aj798En18H6aXzW7VLWL3mJ+3rdR2lhDK9+E8qK7du4bUBL/naOWuSIiHgjFbA+pk5pFteHziQjNQSohpYwWSkQUc83e6cW5sLWeVCvnWsF4sgGTicSOaqBAwc6HaHG6Nmzp9MRxJtlp8H7w2DnKhjyIlvsbjbuWcPUFdu4//PVlJRaxl/Tg3PaV8MdTiIiclI8uYiTeELODh60bxCyY2H1XC97u2sxJF+UswveuwQ2/ASZm9QDVkSktvvqNjL2bGLrxS9D92u5qePtxOXcys3vLaNRdChf395XxauIiJfTCKyvOdBKJzi7mlrphMf73tzXMpENXY+ZG10jySpgRURqNTv4GW6dORq2fMlDsYO546MlrN+Vw42nJ3L3wCSCAzQPXUTE26mA9TXBEeQGxRGbt53c/cWEB3v4P+Elb3j2/J4UGAJhcbBlLmBVwIqI1EbLPoGNM+CClzF1E7m3z8P8uGIvF786hzphgbx7fS9Obx3vdEoREakk3ULsgwqimtPcb0f1LeTky6IToCALzrgPEro7nUZ8TERExCHbEydOPKRdy9FU5hh3mzlzJueff361XrMid955J7/88gsA/fv3JykpieTkZNq2bcvtt9/O3r17Dzn+r3/9K7Nnz+a6664jMTGRLl260KVLF/r06VN+TFFREd27d2fz5s1H9HgdO3YsTz/9NAB33303P/30k2d/QPEN1sKvz1L8+Q08sXcxH6+exK7sAl74ppj/TiugX5t4pt7ZT8WriIiPUQHrg/zjWtLc7PR8AZu+Fl49FTbP9ux1PKls/u6Af0BsS2eziNQCmZmZzJs3j379/uy5PGnSJJYtW8ayZcsIDg7mwgsvPOQ1v/32G6eccgoATz31FEuWLGHJkiXMmTOn/JhZs2YdUtAey+jRo3nyySfd9NOIzyophm/+D6Y/jOlwKVsTkpmdsoXzXviV+Zszeeyijoy/pjt1w31wgUIRkVpOBawPChk4lnP3/8ezBWzmRpj1HOxaBX4+fKf5gH/CWQ9CXqbTSaSG+frrr+nduzddu3bl7LPPZufOnUccs2XLFs466yySk5M566yz2Lp16xHH5ObmMmrUKHr27EnXrl356quvABgzZgyPPPIIAN9//z39+vWjtLSU9evXc/bZZ9O5c2e6devGhg0bAMjJyWHo0KG0bduWESNGUNbj+5FHHqFnz5507NiRm266qfz5/v37c99999GrVy/atGnDr7/+CkBeXh6XXXYZycnJDB8+nN69e1PW3/OHH37g1FNPpVu3bgwbNoycnJwjfp5PP/2U884776i/s6CgIMaNG8fWrVtZunQp4OrL2qZNm+P2wJ06dSqDBg2q8BiAZs2asXv3bnbs2HHcY6UG++pW/lj2Dtl9bqPwgv8Sk3MzX83oSv2oEKaM7stVpzTDqC+4iIhPUgHrg0JiGhFep55nCtiM9TDpMnixGyz/GLqM8O1bbxt0hN/Hw7sXO51EqmrC4CO/fh/v2leYd/T9iye59ufuPnJfJeTn55ffztqlSxf+9a9/le/r27cv8+bNY/HixVx++eWMGzfuiNfffvvtXHPNNSxbtowRI0YwZsyYI455/PHHOfPMM5k/fz4zZszgnnvuITc3lyeffJKPPvqIGTNmMGbMGCZMmICfnx8jRozgtttuY+nSpcyZM4eGDV2LlS1evJjnn3+eVatWsXHjRmbPnl2eYf78+axYsYL8/HymTJlSfu3i4mJ+//13nn/+eR5++GEAXn31VWJiYli2bBkPPvggCxe6VjzPyMjgscceY9q0aSxatIgePXrw7LPPHvHzzJ49m+7dj/13hr+/P507d+aPP/4A4Lvvvjuk4L3nnnvKf98jRowof37GjBn079//mOc9WLdu3cp/fqmdsjpeysgmzXjQD4a8Mof3f0vlhr6JfHlbH1rVi3Q6noiIVIEPD63VYvl7uTvwU+akdQe6VP18BdmQl+Fa5CgoHHauhDPuhe4jIaph1c/vpOw02DAdmp/udBLxQaGhoSxZsqR8e+LEieWjkSkpKQwfPpy0tDQKCwtJTEw84vVz587l888/B+Dqq6/m3nvvPeKYH374gcmTJ5fP4SwoKGDr1q20a9eO8ePH069fP5577jlatmzJvn372L59Oxdf7PpAJiQkpPw8vXr1onHjxgB06dKFzZs307dvX2bMmMG4cePIy8sjMzOTDh06MGTIEAAuueQSgPK5peC6VfeOO+4AoGPHjiQnJwMwb948Vq1axWmnnQZAYWEhp5566hE/T1paGvHxFc8pLBsFBtfo8oQJE8q3n3rqKYYOHXrI8ampqdStW5ewsLBjjpod/Hy9evVITU2tMIPUQOlrYcss6DGKyFbn0n9jJp/9EkB0cBHvjOpFvzaa6yoiUhOogPVFfgFcvG8S2yjB2lEnfxtUxjr4/Q1Y8j4kdINrv3YVrHcuB78aMjif7hrloSjfY5coLbXs2rcffz9DUIAfwQF+BPr74e+n29PcauQ3x94XFFbx/vDYivefhNGjR/O3v/2NCy64gJkzZzJ27NjjvuZo/69aa/nss89ISko6Yt/y5cuJjY0tL8YOLvwOFxwcXP69v78/xcXFFBQUcOutt7JgwQKaNGnC2LFjKSgoOOI1ZcdXdA1rLeeccw4ffPBBhT9jaGjoIdc4XElJCcuXL6ddu3bk5f1/e3ceHlV5/n/8fWeBsIfKlhAURAQiJAGCUKREEH4gBATFFsVWcF+K2iqWXli1X/22FLCi2KubWopiwVKIgoVaAUtBi8gadshXpEjYBYGYMMk8vz9miCEQkgkhk5n5vK4r18zZnnM/k5ncuc95zpk8jh07RmJi4gXbXLRoEQMHDgTgsssu48svvzxr+dGjR886gJCfn0+dOnUu2KaEmc8/5vjsUUxoXI9bGrRi5spGLN/RkP4dmzN5ZIqudRURCSMqYENR7frk1WpKi7xcjp46zWX1a5e/TUmfLfdd35qzFKJrwTU3Q4/7vlkeLsUrQPzlvsf25V87F6gir2Phxn28vGQnOYfOHc4dHWXERhu1oqOoFRNFregoYs88lphXKybKt17M+eZ/89jtisZk6AxCjXH8+HFatvTdJOzPf/7zedfp1asXs2fP5vvf/z6zZs2id+/e56wzcOBApk+fzvTp0zEz1q1bR5cuXfj888954YUXWLduHYMHD2b48OH06NGDpKQksrKyGD58OAUFBRQVFZUZ45lCskmTJpw8eZK5c+eec3aztN69e/P222/Tt29ftmzZQnZ2NgA9e/bk4YcfZteuXVx11VXk5eWxd+9err766rO279ixI7t27TrvcF+Px8PEiRNp1aoVKSkpvPfee/Tt2/eC8YDv+tfnnnsO8N0ZOiEhgSVLlnDDDTdw9OhRFi9eXHzWGGDHjh3ceuut5bYrYWLTPJj/AFHxSexu2IInFq4l/1gKzw/vxOgel+taVxGRMKMCNkSdbnQFrfP383+HT1WsgP36S4ip4/tu1P3ZcHAb9HsKuo6B+mFcFF3WFh5ZD/FXVFmTRV7He9m5vLxkJ7sOnuTq5vV5OjOZmGjjdKGX00VePIWO00VFeIpc8bzThV48JR4L/I95pwuL1ys539eO/7HIcXfvNipga5Bnn32WW2+9lZYtW9KzZ08+++yzc9Z5+eWXueuuu5gyZQpNmzY9a6jsGT/72c947LHHSElJwTlH69atWbBgAXfffTdTp04lMTGR1157jTFjxrB69WreeOMN7r//fp5++mliY2P561//WmaM8fHx3HvvvXTu3JnWrVvTvXv3cvv10EMPceedd5KSkkKXLl1ISUmhUaNGNG3alBkzZnDbbbdRUFAAwPPPP39OATtkyBB+//vfc8899xTPGz16NLVr16agoID+/fsX36hq0aJF5xTU48eP5/nnny+eXrVqFTt37qRDhw7F82bOnMnDDz/M448/DsAzzzxD27a+u4x7PB527dpFenp6uX2VMPDxb1j1r5/TNSGF6fE/Z+unR+iY0Jjp49J0rauISJiyCw1Jq4nS09PdmWvQItnJtx/g681/Z1nmSr7bvVXZKx7Y7BsmvGEODJkKXe4ATz5ERUN0bPUFHAa8JQrXnQdP0q5ZfR7t347BnRKIusTDhZ1zeB0RNSx569atdOzYMdhhRJyioiI8Hg9xcXHk5ORwww03sGPHDmrVqvgQzN69e7Nw4ULi4+MvuF7Xrl1ZtWoVsbFl/y1asWIFb775Jr/73e8qtO/58+ezdu3a4jO2pZ3vfWVma5xzqngvQrByc/a/nuP23W/T+OTN7PnvtdzTuw3jB7WndsyF72otIiI124Vys87Ahqi6Ldphm/N5afFG3lz1ObVjoqgdE01cbBS1o6NI/3olfY7No+2pdXisNtuaDmLTvqbknfqM2jFRxMVG+7cp8TzWv31MdPH82GjD4fs++DNFlNc5vM7hip/7ijtXchml1vdSahvfMuccLRvXIaFRzb1ezet1/H1TLi994Ctcr2pWn+m3dWFI50tfuJ5hZkRHTu0qQZSXl0ffvn3xeDw45/jtb38bUPEK8MILL7Bnz55yC9i1a9eW21bv3r3PO/S6LIWFhcVnZiVMeb7G7d+Ma9mNT6LvwJMbTV5RV2be1U03ahIRiQAqYENUVK9xzHI30XnPcfILiyjwePEU5HH0VAwFnkIePfU6ddxJfs1oZnuu5+CeerCnENgS7NDPK/2KxgxNTeTGzi1o1iCu/A2qgdfrWLRpPy8t2cGOA98UroM7J0TUmVCJLA0aNOBiz6T16NGjiqIJnK59DXOnDpPzl5E87Q5Qm5+zNKce/TsO4Fe3pAR+PwgREQlJKmBDVUwt7su4yvd833rfMOHti+CRdVAnHo4vhAYJ/Dgqmh/jK8ZOF3kp8HgpKCyioNBLvsf3WFBYRP6Z+R7vWctOF3ox850BjDKI8j/6pr+ZZ2eWRfke4cy6Jdf/Zp0z2xuQ/cVxFmzYxzPvbubnCzbz7baXMTQlkUGdWhBft/rvHOn1OhZv3s9LH+xk+4ETtG1aj5f9Z1xVuIqIBMmRHJg1Eju1n5ymbTiWe4znhvfgDt2oSUQkoqiADVXeIpg10ncnYYDYupA6CopO+6YbJZ21elSUERcVTVxsNFCzrn3tc3VTHu57FTsPnGDBxlwWbNjHhHnZPJW1iT5XN2VoagIDkltQv/alfbuer3B9aVQamSmJKlxFRILIu2cVK+bdQbcTBTyR9yTxdbvyxn1daddcN2oSEYk0KmBDVVQ0nDwE9ZvDdY9C2mjfmdcQ1q55A348oAE/6t+Ozfu+YsHGfSzckMvSbQepHZNNvw7NGJqaSL8OzfyFeNXweh3/2Lyfl5bsZNv+E1ypwlVEpEaZuWIKLzSOo+HxHzDouoE8qRs1iYhELBWwoeyBf/sew2zolJnRqWUjOrVsxE8GdmDdf4+xYMM+3svOZdGm/dSrFc2A5OYMTU3kO+2aUiumct9b6/U63t+yn2kf+AvXJvWY9r00hqaqcBURqQm8p44yY91xpmz5Ppc1zuZ/R91HRvtmwQ5LRESCSAVsKAuzwvV8oqKMblc0ptsVjflZZjKrPjvCgg25LNqUS9b6fTSMi+HGTgkMTU2k55XfIia6/GLWOcc/Nh/gpSU72Zr7FW2a1OPF76UyLLWlClcRkZrA6+X9+Xcz4/AnbNn9JL3aJzN55CDdqElERKjcqSuRIIiOMnq1bcIvb+7M6on9+dPY7vRPbs572bnc8doqev5yCU+/s4nVu4/i9Z77/ca+wnU/Q15ewQNvriHfU8SL30vlnz/qw4guSSpe5Rz169c/7/wxY8Ywd+7cSrX57LPPMnXq1PMumzZtGjNnzqxUu4HIyspiy5bK35F89+7dvPXWW8XT2dnZjBkzpgoik5rEzKLNbJ2ZLazWHXvyOfCn26m36+8cpi4PDL6GV+9MV/EqIiKAzsBKiIqNjqJv+2b0bd+MfE8RH24/xIKN+3j70/8y8+PPSWgUR2aK78xsp8RGfLD1ANM+2MmW3K9ofVldfv3dVIalJlbojK1IdSgsLOT111+v0HejXqysrCwyMzNJTk6u1PZnCtjbb78dgM6dO7N371727NnD5ZdfXpWhSnA9CmwFGlbXDg8f3s3KN0dx07GtvFvnLqYPe4b2CfHVtXsREQkB+u9dQl5cbDSDOrXgN7d3Zc1TA3hpVBrXJDZixke7GfbKSlL/533ue2MNeacLeeHWVD74cQY3d01S8Rpixi4eS9auLAA8Xg9jF49lQc4CAL4u/Jqxi8ey+LPFAJw4fYKxi8fywecfAPBl/peMXTyWD//7IQCHvz4c0L6dc/zwhz8kOTmZIUOGcPDgweJla9asISMjg27dujFw4EByc3MB+OMf/0j37t1JTU3llltuIS8v74L7WLp0KV27diUmxndccdeuXfTv35/U1FS6du1KTk4OzjnGjx9Pp06d6Ny5M3PmzAHgww8/5Prrr2fkyJF06NCB0aNH45xvFMKECRNITk4mJSWFJ554go8++oh3332X8ePHk5aWRk5OTpmxjhkzhkceeYRevXpx5ZVXFp91njBhAv/+979JS0vjxRdfBGDo0KHMnj07oNdVai4zSwKGAK9W1z73HMnjp3NG84tGJ3ijzUR+8PhUFa8iInIOnYGVsFKvdgw3pbXkprSWHM/z8I8t+1mx8zB9rm7K8DSdcZXKmT9/Ptu3byc7O5sDBw6QnJzMXXfdhcfjYdy4cbzzzjs0bdqUOXPmMHHiRF5//XVuvvlm7r33XgCeeuopXnvtNcaNG1fmPlauXEm3bt2Kp0ePHs2ECRMYMWIE+fn5eL1e5s2bx/r169mwYQOHDx+me/fu9OnTB4B169axefNmEhMTue6661i5ciXJycnMnz+fbdu2YWYcO3aM+Ph4hg0bRmZmJiNHjgQgPj6+zFhzc3NZsWIF27ZtY9iwYYwcOZJJkyYxdepUFi78ZmRpeno6kyZN4sknn6zaF1+CZRrwJFDm99SY2X3AfUCVnHlvXC+WPB7nsVb7ua3/QxfdnoiIhCcVsBK2GtWN5bvprfhueqtghyJV4E+D/lT8PDYq9qzpOjF1zppuUKvBWdON4xqfNd2kTpOA9r18+XJuu+02oqOjSUxMpF+/fgBs376dTZs2MWDAAACKiopISEgAYNOmTTz11FMcO3aMkydPMnDgwAvuIzc3l44dOwJw4sQJvvjiC0aMGAFAXFwcACtWrCiOo3nz5mRkZLB69WoaNmzItddeS1KS7/uf09LS2L17Nz179iQuLo577rmHIUOGkJmZed59XyjW4cOHExUVRXJyMgcOHCgz/mbNmrFv375yX0up+cwsEzjonFtjZteXtZ5z7g/AHwDS09PPvfFAgBrExfLmQyOwCLhBoYiIVJ4KWBGRCjjfP9XOOa655ho+/vjjc5aNGTOGrKwsUlNTmTFjBh9++OEF269Tpw75+fnF7Z5PWfMBatf+5gY30dHRFBYWEhMTwyeffMKSJUuYPXs2r7zyCkuXLg0o1pLtXmj/+fn51KlTp8zlElKuA4aZ2WAgDmhoZm865+641DtW8SoiIuXReEoRkXL06dOH2bNnU1RURG5uLsuWLQOgffv2HDp0qLiA9Xg8bN68GfCdRU1ISMDj8TBr1qxy99GxY0d27doFQMOGDUlKSiIrKwuAgoIC8vLy6NOnD3PmzKGoqIhDhw6xfPlyrr322jLbPHnyJMePH2fw4MFMmzaN9evXA9CgQQNOnDhRvF6gsZbeHmDHjh106tSp3G2l5nPO/dQ5l+Scaw2MApZWR/EqIiJSESpgRUTKMWLECNq1a0fnzp158MEHycjIAKBWrVrMnTuXn/zkJ6SmppKWlsZHH30EwHPPPUePHj0YMGAAHTp0KHcfN954I8uXLy+efuONN3j55ZdJSUmhV69e7N+/nxEjRpCSkkJqair9+vVj8uTJtGjRosw2T5w4QWZmJikpKWRkZBTfcGnUqFFMmTKFLl26kJOTE3CsKSkpxMTEkJqaWtzmsmXLGDJkSLnbioiIiFwMu9CQsJooPT3dffrpp8EOQ0Qusa1btxZfExopRowYweTJk2nXrl2wQwlIQUEBGRkZrFixovguyjXV+d5XZrbGOZcepJDCgnKziIhUpQvlZp2BFRGpISZNmlT8NTyhZM+ePUyaNKnGF68iIiIS+vTfhohIDdG+fXvat28f7DAC1q5du5A7aywiIiKhSWdgRaTGCrVLHKRm0/tJREQk9KmAFZEaKS4ujiNHjqjokCrhnOPIkSPF36krIiIioUlDiEWkRkpKSmLv3r0cOnQo2KFImIiLiyMpKSnYYYiIiMhFUAErIjVSbGwsbdq0CXYYIiIiIlKDaAixiIiIiIiIhAQVsCIiIiIiIhISVMCKiIiIiIhISLBQu8OnmR0CPg92HBXUBDgc7CAuUjj0AcKjH+pDzaA+1BxV1Y8rnHNNq6CdiFXFuTlc3p+BiMQ+Q2T2OxL7DJHZ70jsM1RDbg65AjaUmNmnzrn0YMdxMcKhDxAe/VAfagb1oeYIl37I2SLx9xqJfYbI7Hck9hkis9+R2Geonn5rCLGIiIiIiIiEBBWwIiIiIiIiEhJUwF5afwh2AFUgHPoA4dEP9aFmUB9qjnDph5wtEn+vkdhniMx+R2KfITL7HYl9hmrot66BFRERERERkZCgM7AiIiIiIiISElTAXgJm1srMlpnZVjPbbGaPBjumyjKzaDNbZ2YLgx1LZZhZvJnNNbNt/t/Ht4MdU6DM7Ef+99EmM/uLmcUFO6aKMLPXzeygmW0qMe9bZvZPM9vpf2wczBjLU0YfpvjfTxvNbL6ZxQcxxHKdrw8llj1hZs7MmgQjtooqqw9mNs7Mtvs/H5ODFZ9UnVDPOZURDnkqUKGa1wIVDnkwUOGQNysjHHJtoIKZm1XAXhqFwOPOuY5AT+BhM0sOckyV9SiwNdhBXISXgMXOuQ5AKiHWFzNrCTwCpDvnOgHRwKjgRlVhM4BBpeZNAJY459oBS/zTNdkMzu3DP4FOzrkUYAfw0+oOKkAzOLcPmFkrYACwp7oDqoQZlOqDmfUFbgJSnHPXAFODEJdUvVDPOZUR0nkqUCGe1wI1g9DPg4GaQejnzcqYQejn2kDNIEi5WQXsJeCcy3XOrfU/P4EvGbUMblSBM7MkYAjwarBjqQwzawj0AV4DcM6dds4dC2pQlRMD1DGzGKAusC/I8VSIc245cLTU7JuAP/uf/xkYXp0xBep8fXDOve+cK/RP/gdIqvbAAlDG7wHgReBJoMbfCKGMPjwITHLOFfjXOVjtgUmVCvWcUxlhlKcCFZJ5LVDhkAcDFQ55szLCIdcGKpi5WQXsJWZmrYEuwKogh1IZ0/B96LxBjqOyrgQOAX/yD0l71czqBTuoQDjnvsB39GoPkAscd869H9yoLkpz51wu+A70AM2CHM/FugtYFOwgAmVmw4AvnHMbgh3LRbga+I6ZrTKzf5lZ92AHJBdtGqGdcyoj5PNUoMIwrwUq3PJgoEIyb1ZGmOTaQFVLblYBewmZWX3gb8Bjzrmvgh1PIMwsEzjonFsT7FguQgzQFfitc64LcIoQG6rjvzbmJqANkAjUM7M7ghuVAJjZRHyXC8wKdiyBMLO6wETg6WDHcpFigMb4LtMYD7xtZhbckKSywiTnVEbI56lAKa9FrlDNm5URRrk2UNWSm1XAXiJmFouveJ3lnJsX7Hgq4TpgmJntBmYD/czszeCGFLC9wF7n3Jmz33Px/aMQSvoDnznnDjnnPMA8oFeQY7oYB8wsAcD/GJLDPs3sTiATGO1C77vI2uL7x3GD//OdBKw1sxZBjSpwe4F5zucTfGftwuoGGREmHHJOZYRDngpUuOW1QIVFHgxUiOfNygiXXBuoasnNKmAvAf+RhteArc65Xwc7nspwzv3UOZfknGuN7+YKS51zIXWE1Dm3H/ivmbX3z7oB2BLEkCpjD9DTzOr631c3ENo3+HgXuNP//E7gnSDGUilmNgj4CTDMOZcX7HgC5ZzLds41c8619n++9wJd/Z+XUJIF9AMws6uBWsDhYAYklRcOOacywiRPBSrc8lqgQj4PBirU82ZlhFGuDVQW1ZCbVcBeGtcB38d3BHm9/2dwsIOKUOOAWWa2EUgDfhHccALjPyo/F1gLZOP7zP4hqEFVkJn9BfgYaG9me83sbmASMMDMduK7K9+kYMZYnjL68ArQAPin/7P9u6AGWY4y+hBSyujD68CV/tv3zwbujJCj+hJ+QjpPBSqU81qgwiEPBioc8mZlhEOuDVQwc7Mp34uIiIiIiEgo0BlYERERERERCQkqYEVERERERCQkqIAVERERERGRkKACVkREREREREKCClgREREREREJCSpgJWKZmTOzF0pMP2Fmz1ZR2zPMbGRVtFXOfm41s61mtuwStB1QH8wswcze9z9vZ2YLzSzHzNaY2TIz6+NfNsbMDvlvpb/FzO71z3/WzJ4o1eZuM6vyL8AWEZGaSbm53LaVmyXiqYCVSFYA3FzT/gibWXQAq98NPOSc61tF7V2MQcA/zCwOeA/4g3OurXOuG77vObyyxLpznHNpwPXAL8yseTXFKCIiNZtyc9VSbpawowJWIlkhvi9P/1HpBaWPcJrZSf/j9Wb2LzN728x2mNkkMxttZp+YWbaZtS3RTH8z+7d/vUz/9tFmNsXMVpvZRjO7v0S7y8zsLXxf7F46ntv87W8ys1/55z0N9AZ+Z2ZTSq1/TntmluU/4rrZzO4r2Tcz+18z22Bm/zlfwjKz5/yvSZS/z1v88U8tsdogYBEwGvjYOffumQXOuU3OuRml23XOHQRygCtKLyu1/3pm9p4/xk1m9r0LrS8iIiFLuRnlZpELiQl2ACJB9htgo5lNDmCbVKAjcBT4P+BV59y1ZvYovqOZj/nXaw1kAG2BZWZ2FfAD4LhzrruZ1QZWmn9oD3At0Mk591nJnZlZIvAroBvwJfC+mQ13zv2PmfUDnnDOfXqeOEu3d5dz7qiZ1QFWm9nfnHNHgHrAf5xzE/2vw73A8yX2PxloBIwFGgMjgA7OOWdm8f51ooH2zrktZnYPsLYiL6SZXYnv6O+uclYdBOxzzg3xb9eoIu2LiEhIUm5WbhYpk87ASkRzzn0FzAQeCWCz1c65XOdcAb4jlGeSXDa+xHjG2845r3NuJ75k2gH4f8APzGw9sAq4DGjnX/+T0gnSrzvwoXPukHOuEJgF9KlAnKXbe8TMNgD/AVqV2O9pYKH/+ZpSffgZEO+cu98554CvgHzgVTO7Gcjzr9fD359zmNl8/5HZeSVmf8//GvwFuN85dxRwZfTD4Xtt+5vZr8zsO8654+X0XUREQpRyM6DcLFImFbAiMA3f9Sr1SswrxP/5MDMDapVYVlDiubfEtJezRzWU/qPvAAPGOefS/D9tnHNnkuypMuKzCvajtOL2zOx6oD/wbedcKrAOiPMv9vgTIEBRqT6sBrqZ2bcA/En6WuBvwHBgsX+9G0s83wx0PdOAc24EMAb4Vol25/j738M5N98/7wi+o8glNQCOOed24DvKnQ380j9ES0REwtc0lJuVm0XOQwWsRDz/Eca38SXKM3bj+6MMcBMQW4mmb/Vfl9IW31Cc7cA/gAfNLBbAzK42s3oXagTf0dMMM2viHw50G/CvAGNpBHzpnMszsw5AzwputxiYBLxnZg3MrD7QyDn3d3zDsdL8690ALPE/fwu4zsyGlWinbgX2tRwYZmYNAPxHkTc454r8Q7XynHNvAlMpkYRFRCT8KDdfkHKzRDRdAyvi8wLwwxLTfwTeMbNP8P3xL+sI7IVsx5fMmgMPOOfyzexVfMOA1vqPHh/Cd7S0TM65XDP7KbAM3xHfvzvn3gkwlsXAA2a20R/Xfyq6oXPur/7E9S5wO77XJc4fy4/MrCmQ7x/yhXPua/PdGOPXZjYNOACcoMS1O2XsZ6OZvQKsMDMHHATu8S/uDEwxMy/gAR6saPwiIhKylJvL3r9ys0Qs+2Z0gohI4MzsDiDJOTcp2LGIiIiIcrOENxWwIiIiIiIiEhJ0DayIiIiIiIiEBBWwIiIiIiIiEhJUwIqIiIiIiEhIUAErIiIiIiIiIUEFrIiIiIiIiIQEFbAiIiIiIiISElTAioiIiIiISEj4/2liaWUzl8S4AAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -329,30 +280,108 @@ } ], "source": [ - "fig, ax = plt.subplots(figsize=(8,6))\n", + "fig, (ax_weak, ax_strong) = plt.subplots(1, 2, figsize=(16,6))\n", "\n", - "ax.plot(profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", - " speedup(profiling_data[\"t_total\"][0], profiling_data[\"t_total\"]), label=\"Total\")\n", + "t_total_no_init_or_file_io = weak_scaling_profiling_data[\"t_total\"] \\\n", + " -weak_scaling_profiling_data[\"t_init\"] \\\n", + " -weak_scaling_profiling_data[\"t_nc_write\"] \\\n", + " -weak_scaling_profiling_data[\"t_sim_init\"]\n", "\n", - "ax.plot(profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", - " speedup(profiling_data[\"t_step_mpi_halo_exchange\"][0], profiling_data[\"t_step_mpi_halo_exchange\"]), label=\"MPI\")\n", + "t_total_halo_exchange = weak_scaling_profiling_data[\"t_mpi_halo_exchange_download\"] \\\n", + " +weak_scaling_profiling_data[\"t_mpi_halo_exchange_sendreceive\"] \\\n", + " +weak_scaling_profiling_data[\"t_mpi_halo_exchange_upload\"]\n", "\n", - "ax.plot(profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", - " speedup(profiling_data[\"t_step_mpi\"][0], profiling_data[\"t_step_mpi\"]), label=\"Simulate\")\n", + "#ax_weak.plot(weak_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + "# speedup(t_total_no_init_or_file_io[0], t_total_no_init_or_file_io), label=\"Total (no init or file I/O)\")\n", "\n", - "#ax.plot(nproc, amdahls_speedup(0.9, nproc), label=\"Amdahls 90%\", linestyle=\"dashed\")\n", - "#ax.plot(nproc, amdahls_speedup(0.5, nproc), label=\"Amdahls 50%\", linestyle=\"dashed\")\n", - "#ax.plot(nproc, amdahls_speedup(0.1, nproc), label=\"Amdahls 10%\", linestyle=\"dashed\")\n", + "ax_weak.plot(weak_scaling_profiling_data[\"n_processes\"][0:].to_numpy(dtype=\"int\"), \n", + " speedup(weak_scaling_profiling_data[\"t_full_step\"][0], weak_scaling_profiling_data[\"t_full_step\"][0:]), label=\"Total (no init or file I/O)\")\n", "\n", - "#ax.plot(nproc, gustafsons_speedup(0.9, nproc), label=\"Gustafsons 90%\")\n", - "#ax.plot(nproc, gustafsons_speedup(0.5, nproc), label=\"Gustafsons 50%\")\n", - "#ax.plot(nproc, gustafsons_speedup(0.1, nproc), label=\"Gustafsons 10%\")\n", + "ax_weak.plot(weak_scaling_profiling_data[\"n_processes\"][0:].to_numpy(dtype=\"int\"), \n", + " speedup(t_total_halo_exchange[0], t_total_halo_exchange[0:]), label=\"Halo exchange (D/E/U)\", linestyle=\"dashed\")\n", "\n", - "ax.plot(nproc, nproc, label=\"Ideal (linear)\", linestyle=\"dotted\")\n", + "\"\"\"\n", + "ax_weak.plot(weak_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(weak_scaling_profiling_data[\"t_total\"][0], weak_scaling_profiling_data[\"t_total\"]), label=\"Total\")\n", "\n", - "ax.set_xlabel(\"Number of cores/GPUs\")\n", - "ax.set_ylabel(\"Speedup\")\n", - "ax.legend(loc=\"upper left\")\n", + "ax_weak.plot(weak_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(weak_scaling_profiling_data[\"t_mpi_halo_exchange_sendreceive\"][0], weak_scaling_profiling_data[\"t_mpi_halo_exchange_sendreceive\"]), label=\"MPI send/recv\")\n", + "\n", + "ax_weak.plot(weak_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(weak_scaling_profiling_data[\"t_mpi_halo_exchange_download\"][0], weak_scaling_profiling_data[\"t_mpi_halo_exchange_download\"]), label=\"Download (GPU->CPU)\")\n", + "\n", + "ax_weak.plot(weak_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(weak_scaling_profiling_data[\"t_mpi_halo_exchange_upload\"][0], weak_scaling_profiling_data[\"t_mpi_halo_exchange_upload\"]), label=\"Upload (CPU->GPU)\")\n", + "\n", + "ax_weak.plot(weak_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(weak_scaling_profiling_data[\"t_nc_write\"][0], weak_scaling_profiling_data[\"t_nc_write\"]), label=\"Write to file\")\n", + "\n", + "ax_weak.plot(weak_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(weak_scaling_profiling_data[\"t_init\"][0], weak_scaling_profiling_data[\"t_init\"]), label=\"Init\")\n", + "\"\"\"\n", + "\n", + "ax_weak.plot(nproc, np.ones(len(nproc)), label=\"Ideal (constant)\", linestyle=\"dotted\")\n", + "\n", + "ax_weak.set_xlabel(\"Number of ranks/GPUs\")\n", + "ax_weak.set_ylabel(\"Efficiency\")\n", + "ax_weak.legend(loc=\"lower right\")\n", + "#fig.show()\n", + "\n", + "##############################################\n", + "\n", + "#fig, ax = plt.subplots(figsize=(8,6))\n", + "\n", + "t_total_no_init_or_file_io = strong_scaling_profiling_data[\"t_total\"] \\\n", + " -strong_scaling_profiling_data[\"t_init\"] \\\n", + " -strong_scaling_profiling_data[\"t_nc_write\"] \\\n", + " -strong_scaling_profiling_data[\"t_sim_init\"]\n", + "\n", + "t_total_halo_exchange = strong_scaling_profiling_data[\"t_mpi_halo_exchange_download\"] \\\n", + " +strong_scaling_profiling_data[\"t_mpi_halo_exchange_sendreceive\"] \\\n", + " +strong_scaling_profiling_data[\"t_mpi_halo_exchange_upload\"]\n", + "\n", + "#ax_strong.plot(strong_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + "# speedup(t_total_no_init_or_file_io[0], t_total_no_init_or_file_io)*4, label=\"Total (no init or file I/O)\")\n", + "\n", + "ax_strong.plot(strong_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(strong_scaling_profiling_data[\"t_full_step\"][0], strong_scaling_profiling_data[\"t_full_step\"])*4, label=\"Total (no init or file I/O)\")\n", + "\n", + "ax_strong.plot(strong_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(t_total_halo_exchange[0], t_total_halo_exchange)*4, label=\"Halo exchange (D/E/U)\", linestyle=\"dashed\")\n", + "\n", + "\"\"\"\n", + "ax_strong.plot(strong_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(strong_scaling_profiling_data[\"t_total\"][0], strong_scaling_profiling_data[\"t_total\"])*4, label=\"Total\")\n", + " \n", + "ax_strong.plot(strong_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(strong_scaling_profiling_data[\"t_mpi_halo_exchange_sendreceive\"][0], strong_scaling_profiling_data[\"t_mpi_halo_exchange_sendreceive\"]), label=\"MPI send/recv\")\n", + "\n", + "ax_strong.plot(strong_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(strong_scaling_profiling_data[\"t_mpi_halo_exchange_download\"][0], strong_scaling_profiling_data[\"t_mpi_halo_exchange_download\"]), label=\"Download (GPU->CPU)\")\n", + "\n", + "ax_strong.plot(strong_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(strong_scaling_profiling_data[\"t_mpi_halo_exchange_upload\"][0], strong_scaling_profiling_data[\"t_mpi_halo_exchange_upload\"]), label=\"Upload (CPU->GPU)\")\n", + "\n", + "ax_strong.plot(strong_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(strong_scaling_profiling_data[\"t_nc_write\"][0], strong_scaling_profiling_data[\"t_nc_write\"]), label=\"Write to file\")\n", + "\n", + "ax_strong.plot(strong_scaling_profiling_data[\"n_processes\"].to_numpy(dtype=\"int\"), \n", + " speedup(strong_scaling_profiling_data[\"t_init\"][0], strong_scaling_profiling_data[\"t_init\"]), label=\"Init\")\n", + "\"\"\"\n", + "\n", + "#ax_strong.plot(nproc, amdahls_speedup(0.9, nproc), label=\"Amdahls 90%\", linestyle=\"dashed\")\n", + "#ax_strong.plot(nproc, amdahls_speedup(0.5, nproc), label=\"Amdahls 50%\", linestyle=\"dashed\")\n", + "#ax_strong.plot(nproc, amdahls_speedup(0.1, nproc), label=\"Amdahls 10%\", linestyle=\"dashed\")\n", + "\n", + "#ax_strong.plot(nproc, gustafsons_speedup(0.9, nproc), label=\"Gustafsons 90%\")\n", + "#ax_strong.plot(nproc, gustafsons_speedup(0.5, nproc), label=\"Gustafsons 50%\")\n", + "#ax_strong.plot(nproc, gustafsons_speedup(0.1, nproc), label=\"Gustafsons 10%\")\n", + "\n", + "ax_strong.plot(nproc[3:], nproc[3:], label=\"Ideal (linear)\", linestyle=\"dotted\")\n", + "\n", + "ax_strong.set_xlabel(\"Number of ranks/GPUs\")\n", + "ax_strong.set_ylabel(\"Speedup\")\n", + "ax_strong.legend(loc=\"upper left\")\n", "fig.show()" ] }, @@ -495,10 +524,10 @@ ], "metadata": { "interpreter": { - "hash": "d80e56d67bdb125526bdf12740b058f9c8b2e6eb30981cd0c9aaae49693d1172" + "hash": "5ec8a684eb355694b427c525a814c01edbb663f485e9b356374be21a7726d858" }, "kernelspec": { - "display_name": "ShallowWaterGPU_HPC", + "display_name": "Python 3.7.12 ('ShallowWaterGPU')", "language": "python", "name": "python3" }, @@ -512,7 +541,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.7.12" } }, "nbformat": 4, diff --git a/dgx-2_strong_scaling_benchmark.sh b/dgx-2_strong_scaling_benchmark.sh index e90f015..7414a7b 100644 --- a/dgx-2_strong_scaling_benchmark.sh +++ b/dgx-2_strong_scaling_benchmark.sh @@ -3,20 +3,36 @@ TIMESTAMP=$(date "+%Y-%m-%dT%H%M%S") # one node: 1-16 GPUs -sbatch --nodes=1 --gpus-per-node=1 --ntasks-per-node=1 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=2 --ntasks-per-node=2 --export=ALL,NX=8192,NY=4096,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=3 --ntasks-per-node=3 --export=ALL,NX=8192,NY=2731,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=8192,NY=2048,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=8192,NY=1638,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=8192,NY=1365,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=8192,NY=1170,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=8192,NY=1024,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=1 --ntasks-per-node=1 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=2 --ntasks-per-node=2 --export=ALL,NX=8192,NY=4096,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=3 --ntasks-per-node=3 --export=ALL,NX=8192,NY=2731,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=8192,NY=2048,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=8192,NY=1638,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=8192,NY=1365,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=8192,NY=1170,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=8192,NY=1024,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +# +#sbatch --nodes=1 --gpus-per-node=9 --ntasks-per-node=9 --export=ALL,NX=8192,NY=910,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=10 --ntasks-per-node=10 --export=ALL,NX=8192,NY=819,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=11 --ntasks-per-node=11 --export=ALL,NX=8192,NY=745,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=12 --ntasks-per-node=12 --export=ALL,NX=8192,NY=683,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=13 --ntasks-per-node=13 --export=ALL,NX=8192,NY=630,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=14 --ntasks-per-node=14 --export=ALL,NX=8192,NY=585,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=15 --ntasks-per-node=15 --export=ALL,NX=8192,NY=546,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=16 --ntasks-per-node=16 --export=ALL,NX=8192,NY=512,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=9 --ntasks-per-node=9 --export=ALL,NX=8192,NY=910,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=10 --ntasks-per-node=10 --export=ALL,NX=8192,NY=819,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=11 --ntasks-per-node=11 --export=ALL,NX=8192,NY=745,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=12 --ntasks-per-node=12 --export=ALL,NX=8192,NY=683,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=13 --ntasks-per-node=13 --export=ALL,NX=8192,NY=630,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=14 --ntasks-per-node=14 --export=ALL,NX=8192,NY=585,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=15 --ntasks-per-node=15 --export=ALL,NX=8192,NY=546,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=16 --ntasks-per-node=16 --export=ALL,NX=8192,NY=512,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +# one node: 4-16 GPUs +sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=41984,NY=10496,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=41984,NY=8396,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=41984,NY=6997,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=41984,NY=5997,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=41984,NY=5248,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job + +sbatch --nodes=1 --gpus-per-node=9 --ntasks-per-node=9 --export=ALL,NX=41984,NY=4664,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=10 --ntasks-per-node=10 --export=ALL,NX=41984,NY=4198,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=11 --ntasks-per-node=11 --export=ALL,NX=41984,NY=3816,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=12 --ntasks-per-node=12 --export=ALL,NX=41984,NY=3498,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=13 --ntasks-per-node=13 --export=ALL,NX=41984,NY=3229,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=14 --ntasks-per-node=14 --export=ALL,NX=41984,NY=2998,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=15 --ntasks-per-node=15 --export=ALL,NX=41984,NY=2798,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=16 --ntasks-per-node=16 --export=ALL,NX=41984,NY=2624,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job diff --git a/dgx-2_weak_scaling_benchmark.sh b/dgx-2_weak_scaling_benchmark.sh index 4146f07..a24ee65 100644 --- a/dgx-2_weak_scaling_benchmark.sh +++ b/dgx-2_weak_scaling_benchmark.sh @@ -3,20 +3,39 @@ TIMESTAMP=$(date "+%Y-%m-%dT%H%M%S") # one node: 1-16 GPUs -sbatch --nodes=1 --gpus-per-node=1 --ntasks-per-node=1 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=2 --ntasks-per-node=2 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=3 --ntasks-per-node=3 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=1 --ntasks-per-node=1 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=2 --ntasks-per-node=2 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=3 --ntasks-per-node=3 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +# +#sbatch --nodes=1 --gpus-per-node=9 --ntasks-per-node=9 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=10 --ntasks-per-node=10 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=11 --ntasks-per-node=11 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=12 --ntasks-per-node=12 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=13 --ntasks-per-node=13 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=14 --ntasks-per-node=14 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=15 --ntasks-per-node=15 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=16 --ntasks-per-node=16 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=9 --ntasks-per-node=9 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=10 --ntasks-per-node=10 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=11 --ntasks-per-node=11 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=12 --ntasks-per-node=12 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=13 --ntasks-per-node=13 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=14 --ntasks-per-node=14 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=15 --ntasks-per-node=15 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job -sbatch --nodes=1 --gpus-per-node=16 --ntasks-per-node=16 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +# one node: 1-16 GPUs +sbatch --nodes=1 --gpus-per-node=1 --ntasks-per-node=1 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=2 --ntasks-per-node=2 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=3 --ntasks-per-node=3 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job + +sbatch --nodes=1 --gpus-per-node=9 --ntasks-per-node=9 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=10 --ntasks-per-node=10 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=11 --ntasks-per-node=11 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=12 --ntasks-per-node=12 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=13 --ntasks-per-node=13 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=14 --ntasks-per-node=14 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=15 --ntasks-per-node=15 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=16 --ntasks-per-node=16 --export=ALL,NX=41984,NY=41984,NOW=$TIMESTAMP dgx-2_scaling_benchmark.job \ No newline at end of file diff --git a/hgx_scaling_benchmark.job b/hgx_scaling_benchmark.job new file mode 100644 index 0000000..f072fcf --- /dev/null +++ b/hgx_scaling_benchmark.job @@ -0,0 +1,58 @@ +#!/bin/bash +# See http://wiki.ex3.simula.no before changing the values below +#SBATCH -p hgx2q # partition (GPU queue) +#SBATCH -w g002 # HGX node +#SBATCH -t 0-00:10 # time (D-HH:MM) +#SBATCH -o slurm.%N.%j.out # STDOUT +#SBATCH -e slurm.%N.%j.err # STDERR +#SBATCH --reservation=martinls_11 + + +# For Linux 64, Open MPI is built with CUDA awareness but this support is disabled by default. +# To enable it, please set the environment variable OMPI_MCA_opal_cuda_support=true before +# launching your MPI processes. Equivalently, you can set the MCA parameter in the command line: +# mpiexec --mca opal_cuda_support 1 ... +# +# In addition, the UCX support is also built but disabled by default. +# To enable it, first install UCX (conda install -c conda-forge ucx). Then, set the environment +# variables OMPI_MCA_pml="ucx" OMPI_MCA_osc="ucx" before launching your MPI processes. +# Equivalently, you can set the MCA parameters in the command line: +# mpiexec --mca pml ucx --mca osc ucx ... +# Note that you might also need to set UCX_MEMTYPE_CACHE=n for CUDA awareness via UCX. +# Please consult UCX's documentation for detail. + +ulimit -s 10240 +module load slurm/20.02.7 +module load cuda11.2/toolkit/11.2.2 +module load openmpi4-cuda11.2-ofed50-gcc8/4.1.0 + +# Check how many gpu's your job got +#nvidia-smi + +mkdir -p output_hgx/$NOW + +## Copy input files to the work directory: +mkdir -p /work/$USER/$SLURM_JOB_ID/ShallowWaterGPU +cp -r . /work/$USER/$SLURM_JOB_ID/ShallowWaterGPU + +# Run job +# (Assumes Miniconda is installed in user root dir.) +cd /work/$USER/$SLURM_JOB_ID/ShallowWaterGPU +#mpirun --mca btl_openib_if_include mlx5_0 --mca btl_openib_warn_no_device_params_found 0 $HOME/miniconda3/envs/ShallowWaterGPU_HPC/bin/python3 mpiTesting.py -nx $NX -ny $NY --profile +#nsys profile -t nvtx,cuda mpirun -np $SLURM_NTASKS numactl --cpunodebind=0 --localalloc $HOME/miniconda3/envs/ShallowWaterGPU_HPC/bin/python3 mpiTesting.py -nx $NX -ny $NY --profile +#mpirun -np $SLURM_NTASKS numactl --cpunodebind=0 --localalloc $HOME/miniconda3/envs/ShallowWaterGPU_HPC/bin/python3 mpiTesting.py -nx $NX -ny $NY --profile + +export OMPI_MCA_opal_cuda_support=true +mpirun -np $SLURM_NTASKS $HOME/miniconda3/envs/ShallowWaterGPU_HPC/bin/python3 mpiTesting.py -nx $NX -ny $NY --profile + +cd $HOME/src/ShallowWaterGPU + +## Copy files from work directory: +# (NOTE: Copying is not performed if job fails!) +mkdir -p output_hgx/$NOW/$SLURM_JOB_ID +mv /work/$USER/$SLURM_JOB_ID/ShallowWaterGPU/*.log ./output_hgx/$NOW/$SLURM_JOB_ID +mv /work/$USER/$SLURM_JOB_ID/ShallowWaterGPU/*.nc ./output_hgx/$NOW/$SLURM_JOB_ID +mv /work/$USER/$SLURM_JOB_ID/ShallowWaterGPU/*.json ./output_hgx/$NOW +mv /work/$USER/$SLURM_JOB_ID/ShallowWaterGPU/*.qdrep ./output_hgx/$NOW + +rm -rf /work/$USER/$SLURM_JOB_ID diff --git a/hgx_strong_scaling_benchmark.sh b/hgx_strong_scaling_benchmark.sh new file mode 100644 index 0000000..f92c611 --- /dev/null +++ b/hgx_strong_scaling_benchmark.sh @@ -0,0 +1,20 @@ +#!/bin/bash + +TIMESTAMP=$(date "+%Y-%m-%dT%H%M%S") + +# one node: 1-8 GPUs +#sbatch --nodes=1 --gpus-per-node=1 --ntasks-per-node=1 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=2 --ntasks-per-node=2 --export=ALL,NX=8192,NY=4096,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=3 --ntasks-per-node=3 --export=ALL,NX=8192,NY=2731,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=8192,NY=2048,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=8192,NY=1638,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=8192,NY=1365,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=8192,NY=1170,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=8192,NY=1024,NOW=$TIMESTAMP hgx_scaling_benchmark.job + +# one node: 4-8 GPUs +sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=41984,NY=10496,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=41984,NY=8396,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=41984,NY=6997,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=41984,NY=5997,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=41984,NY=5248,NOW=$TIMESTAMP hgx_scaling_benchmark.job diff --git a/hgx_weak_scaling_benchmark.sh b/hgx_weak_scaling_benchmark.sh new file mode 100644 index 0000000..11b91d5 --- /dev/null +++ b/hgx_weak_scaling_benchmark.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +TIMESTAMP=$(date "+%Y-%m-%dT%H%M%S") + +# one node: 1-16 GPUs +#sbatch --nodes=1 --gpus-per-node=1 --ntasks-per-node=1 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=2 --ntasks-per-node=2 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=3 --ntasks-per-node=3 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP hgx_scaling_benchmark.job +#sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=8192,NY=8192,NOW=$TIMESTAMP hgx_scaling_benchmark.job + +# one node: 1-8 GPUs +sbatch --nodes=1 --gpus-per-node=1 --ntasks-per-node=1 --export=ALL,NX=20480,NY=20480,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=2 --ntasks-per-node=2 --export=ALL,NX=20480,NY=20480,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=3 --ntasks-per-node=3 --export=ALL,NX=20480,NY=20480,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=4 --ntasks-per-node=4 --export=ALL,NX=20480,NY=20480,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=5 --ntasks-per-node=5 --export=ALL,NX=20480,NY=20480,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=6 --ntasks-per-node=6 --export=ALL,NX=20480,NY=20480,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=7 --ntasks-per-node=7 --export=ALL,NX=20480,NY=20480,NOW=$TIMESTAMP hgx_scaling_benchmark.job +sbatch --nodes=1 --gpus-per-node=8 --ntasks-per-node=8 --export=ALL,NX=20480,NY=20480,NOW=$TIMESTAMP hgx_scaling_benchmark.job