From 63a5d72d98344ab11ff95a07a5a713a3aa5672a3 Mon Sep 17 00:00:00 2001 From: Gera Shegalov Date: Wed, 23 Oct 2024 14:52:44 -0700 Subject: [PATCH] Scala version extraction Signed-off-by: Gera Shegalov --- .../tpcds/notebooks/TPCDS-SF10.ipynb | 584 +++++++++--------- 1 file changed, 288 insertions(+), 296 deletions(-) diff --git a/examples/SQL+DF-Examples/tpcds/notebooks/TPCDS-SF10.ipynb b/examples/SQL+DF-Examples/tpcds/notebooks/TPCDS-SF10.ipynb index a081a889..6aa90e6d 100644 --- a/examples/SQL+DF-Examples/tpcds/notebooks/TPCDS-SF10.ipynb +++ b/examples/SQL+DF-Examples/tpcds/notebooks/TPCDS-SF10.ipynb @@ -11,7 +11,7 @@ "tags": [] }, "source": [ - "# TPC DS scale factor 10 - Apache Spark acceleration on GPU with RAPIDS Spark\n", + "# TPC-DS 10GiB - Apache Spark acceleration on GPU with RAPIDS Spark\n", "\n", "based on https://colab.research.google.com/github/LucaCanali/Miscellaneous/blob/master/Performance_Testing/TPCDS_PySpark/Labs_and_Notes/TPCDS_PySpark_getstarted.ipynb#scrollTo=6bab7772" ] @@ -30,13 +30,12 @@ "outputs": [], "source": [ "spark_version='3.5.0'\n", - "rapids_version='24.10.0'\n", - "scala_version='2.12'" + "rapids_version='24.10.0'" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "executionInfo": { "elapsed": 1630, @@ -77,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "executionInfo": { "elapsed": 1052, @@ -96,32 +95,13 @@ "from importlib.resources import files\n", "from pyspark.sql import SparkSession\n", "from tpcds_pyspark import TPCDS\n", + "import glob\n", "import os\n", "import pandas as pd\n", + "import re\n", "import time" ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "executionInfo": { - "elapsed": 12, - "status": "ok", - "timestamp": 1729291037060, - "user": { - "displayName": "Gera Shegalov", - "userId": "07399839501144323282" - }, - "user_tz": 420 - }, - "id": "CWaokrdGfsyo" - }, - "outputs": [], - "source": [ - "tpcds_pyspark_files = files('tpcds_pyspark')" - ] - }, { "cell_type": "markdown", "metadata": { @@ -164,9 +144,48 @@ "# Init a SparkSession with RAPIDS Spark" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Detect Scala Version used in PySpark package" + ] + }, { "cell_type": "code", "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "pyspark_files = files('pyspark')\n", + "spark_sql_jar_path, *_ = glob.glob(f\"{pyspark_files}/*/spark-sql_*jar\")\n", + "spark_sql_jar = os.path.basename(spark_sql_jar_path)\n", + "scala_version = re.search(r'^spark-sql_(\\d+.\\d+)-.*\\.jar$', spark_sql_jar).group(1)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Find spark-measure artifact" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "tpcds_pyspark_files = files('tpcds_pyspark')\n", + "spark_measure_jar_paths = glob.glob(f\"{tpcds_pyspark_files}/spark-measure_{scala_version}-*.jar\")\n", + "assert spark_measure_jar_paths, f\"No spark-measure artifact built for Pyspark's Scala version {scala_version}\"\n", + "spark_measure_jar_paths.sort(reverse=True)\n", + "spark_measure_jar_path, *_ = spark_measure_jar_paths" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": { "executionInfo": { "elapsed": 39420, @@ -185,8 +204,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "24/10/22 20:24:36 WARN Utils: Your hostname, e780a48-lcedt resolves to a loopback address: 127.0.1.1; using 10.112.215.249 instead (on interface enp36s0f0)\n", - "24/10/22 20:24:36 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n" + "24/10/23 14:46:45 WARN Utils: Your hostname, e780a48-lcedt resolves to a loopback address: 127.0.1.1; using 10.112.215.249 instead (on interface enp36s0f0)\n", + "24/10/23 14:46:45 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n" ] }, { @@ -203,10 +222,10 @@ "Ivy Default Cache set to: /home/gshegalov/.ivy2/cache\n", "The jars for the packages stored in: /home/gshegalov/.ivy2/jars\n", "com.nvidia#rapids-4-spark_2.12 added as a dependency\n", - ":: resolving dependencies :: org.apache.spark#spark-submit-parent-df1f6219-409d-4ff8-8387-c5192908c474;1.0\n", + ":: resolving dependencies :: org.apache.spark#spark-submit-parent-93f929a5-5993-4f3d-9421-bd096589e319;1.0\n", "\tconfs: [default]\n", "\tfound com.nvidia#rapids-4-spark_2.12;24.10.0 in central\n", - ":: resolution report :: resolve 73ms :: artifacts dl 2ms\n", + ":: resolution report :: resolve 69ms :: artifacts dl 3ms\n", "\t:: modules in use:\n", "\tcom.nvidia#rapids-4-spark_2.12;24.10.0 from central in [default]\n", "\t---------------------------------------------------------------------\n", @@ -215,15 +234,15 @@ "\t---------------------------------------------------------------------\n", "\t| default | 1 | 0 | 0 | 0 || 1 | 0 |\n", "\t---------------------------------------------------------------------\n", - ":: retrieving :: org.apache.spark#spark-submit-parent-df1f6219-409d-4ff8-8387-c5192908c474\n", + ":: retrieving :: org.apache.spark#spark-submit-parent-93f929a5-5993-4f3d-9421-bd096589e319\n", "\tconfs: [default]\n", "\t0 artifacts copied, 1 already retrieved (0kB/2ms)\n", - "24/10/22 20:24:36 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n", + "24/10/23 14:46:45 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n", "Setting default log level to \"WARN\".\n", "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n", - "24/10/22 20:24:38 WARN RapidsPluginUtils: RAPIDS Accelerator 24.10.0 using cudf 24.10.0, private revision bd4e99e18e20234ee0c54f95f4b0bfce18a6255e\n", - "24/10/22 20:24:38 WARN RapidsPluginUtils: RAPIDS Accelerator is enabled, to disable GPU support set `spark.rapids.sql.enabled` to false.\n", - "24/10/22 20:24:38 WARN RapidsPluginUtils: spark.rapids.sql.explain is set to `NOT_ON_GPU`. Set it to 'NONE' to suppress the diagnostics logging about the query placement on the GPU.\n" + "24/10/23 14:46:47 WARN RapidsPluginUtils: RAPIDS Accelerator 24.10.0 using cudf 24.10.0, private revision bd4e99e18e20234ee0c54f95f4b0bfce18a6255e\n", + "24/10/23 14:46:47 WARN RapidsPluginUtils: RAPIDS Accelerator is enabled, to disable GPU support set `spark.rapids.sql.enabled` to false.\n", + "24/10/23 14:46:47 WARN RapidsPluginUtils: spark.rapids.sql.explain is set to `NOT_ON_GPU`. Set it to 'NONE' to suppress the diagnostics logging about the query placement on the GPU.\n" ] } ], @@ -233,7 +252,7 @@ " .appName('TPCDS PySpark RAPIDS=ON/OFF')\n", " .config('spark.driver.memory', '5g')\n", " .config('spark.plugins', 'com.nvidia.spark.SQLPlugin')\n", - " .config('spark.jars', tpcds_pyspark_files.joinpath(f\"spark-measure_{scala_version}-0.24.jar\"))\n", + " .config('spark.jars', spark_measure_jar_path)\n", " .config('spark.jars.packages', f\"com.nvidia:rapids-4-spark_{scala_version}:{rapids_version}\")\n", " .getOrCreate()\n", ")\n" @@ -245,12 +264,12 @@ "id": "_4sYje2NiNA7" }, "source": [ - "# Verify SQL Acceleration on GPU can be enabled by checking the query plan and the GPU RAM in the \"Resources\" tab" + "# Verify SQL Acceleration on GPU can be enabled by checking the query plan" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -315,39 +334,6 @@ "sum_df.explain()" ] }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "executionInfo": { - "elapsed": 5, - "status": "ok", - "timestamp": 1729289104337, - "user": { - "displayName": "Gera Shegalov", - "userId": "07399839501144323282" - }, - "user_tz": 420 - }, - "id": "t7kj9OQnPuWA" - }, - "outputs": [], - "source": [ - "# https://github.com/LucaCanali/Miscellaneous/tree/master/Performance_Testing/TPCDS_PySpark/tpcds_pyspark/Queries\n", - "\n", - "# queries = None to run all (takes much longer)\n", - "queries = None\n", - "queries = [\n", - " 'q14a',\n", - " 'q14b',\n", - " 'q23a',\n", - " 'q23b',\n", - " # 'q24a',\n", - " # 'q24b',\n", - " # 'q88',\n", - "]\n" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -357,7 +343,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -389,11 +375,25 @@ "name": "stderr", "output_type": "stream", "text": [ - "24/10/22 20:24:46 WARN SparkSession: Using an existing Spark session; only runtime SQL configurations will take effect.\n" + "24/10/23 14:47:27 WARN SparkSession: Using an existing Spark session; only runtime SQL configurations will take effect.\n" ] } ], "source": [ + "# https://github.com/LucaCanali/Miscellaneous/tree/master/Performance_Testing/TPCDS_PySpark/tpcds_pyspark/Queries\n", + "\n", + "# queries = None to run all (takes much longer)\n", + "queries = None\n", + "queries = [\n", + " 'q14a',\n", + " 'q14b',\n", + " 'q23a',\n", + " 'q23b',\n", + " # 'q24a',\n", + " # 'q24b',\n", + " # 'q88',\n", + "]\n", + "\n", "demo_start = time.time()\n", "tpcds = TPCDS(data_path='./tpcds_10', num_runs=1, queries_repeat_times=1, queries=queries)" ] @@ -409,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -440,7 +440,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "24/10/22 20:24:47 WARN SparkStringUtils: Truncated the string representation of a plan since it was too large. This behavior can be adjusted by setting 'spark.sql.debug.maxToStringFields'.\n" + "24/10/23 14:47:33 WARN SparkStringUtils: Truncated the string representation of a plan since it was too large. This behavior can be adjusted by setting 'spark.sql.debug.maxToStringFields'.\n" ] }, { @@ -488,7 +488,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -528,12 +528,12 @@ "output_type": "stream", "text": [ "Job finished\n", - "...Start Time = 2024-10-22 20:24:49\n", - "...Elapsed Time = 9.78 sec\n", - "...Executors Run Time = 160.46 sec\n", - "...Executors CPU Time = 89.63 sec\n", - "...Executors JVM GC Time = 34.83 sec\n", - "...Average Active Tasks = 16.4\n", + "...Start Time = 2024-10-23 14:47:40\n", + "...Elapsed Time = 9.31 sec\n", + "...Executors Run Time = 149.86 sec\n", + "...Executors CPU Time = 85.31 sec\n", + "...Executors JVM GC Time = 30.7 sec\n", + "...Average Active Tasks = 16.1\n", "\n", "Run 0 - query q14b - attempt 0 - starting...\n" ] @@ -550,11 +550,11 @@ "output_type": "stream", "text": [ "Job finished\n", - "...Start Time = 2024-10-22 20:25:03\n", - "...Elapsed Time = 5.61 sec\n", - "...Executors Run Time = 97.64 sec\n", - "...Executors CPU Time = 58.69 sec\n", - "...Executors JVM GC Time = 25.94 sec\n", + "...Start Time = 2024-10-23 14:47:53\n", + "...Elapsed Time = 5.27 sec\n", + "...Executors Run Time = 91.68 sec\n", + "...Executors CPU Time = 55.95 sec\n", + "...Executors JVM GC Time = 24.74 sec\n", "...Average Active Tasks = 17.4\n", "\n", "Run 0 - query q23a - attempt 0 - starting...\n" @@ -572,11 +572,11 @@ "output_type": "stream", "text": [ "Job finished\n", - "...Start Time = 2024-10-22 20:25:10\n", - "...Elapsed Time = 8.77 sec\n", - "...Executors Run Time = 201.08 sec\n", - "...Executors CPU Time = 142.97 sec\n", - "...Executors JVM GC Time = 40.97 sec\n", + "...Start Time = 2024-10-23 14:48:00\n", + "...Elapsed Time = 8.73 sec\n", + "...Executors Run Time = 199.52 sec\n", + "...Executors CPU Time = 138.3 sec\n", + "...Executors JVM GC Time = 42.51 sec\n", "...Average Active Tasks = 22.9\n", "\n", "Run 0 - query q23b - attempt 0 - starting...\n" @@ -586,8 +586,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "24/10/22 20:25:24 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", - "[Stage 218:=> (2 + 64) / 66]\r" + "[Stage 218:> (0 + 64) / 66]\r" ] }, { @@ -595,22 +594,21 @@ "output_type": "stream", "text": [ "Job finished\n", - "...Start Time = 2024-10-22 20:25:20\n", - "...Elapsed Time = 10.68 sec\n", - "...Executors Run Time = 241.66 sec\n", - "...Executors CPU Time = 157.55 sec\n", - "...Executors JVM GC Time = 60.73 sec\n", - "...Average Active Tasks = 22.6\n", - "CPU times: user 103 ms, sys: 37.3 ms, total: 141 ms\n", - "Wall time: 42.8 s\n" + "...Start Time = 2024-10-23 14:48:10\n", + "...Elapsed Time = 8.83 sec\n", + "...Executors Run Time = 224.27 sec\n", + "...Executors CPU Time = 145.62 sec\n", + "...Executors JVM GC Time = 57.8 sec\n", + "...Average Active Tasks = 25.4\n", + "CPU times: user 85.1 ms, sys: 25.7 ms, total: 111 ms\n", + "Wall time: 40.3 s\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/home/gshegalov/gits/NVIDIA/spark-rapids-examples/.venv/lib/python3.10/site-packages/tpcds_pyspark/tpcds.py:243: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", - " results_pdf['timestamp'] = pd.to_datetime(results_pdf['timestamp'])\n" + " \r" ] }, { @@ -663,13 +661,13 @@ " q14a\n", " 30\n", " 838\n", - " 9779\n", - " 19488\n", - " 160456\n", - " 89631\n", - " 9277\n", - " 3040\n", - " 362\n", + " 9308\n", + " 18042\n", + " 149861\n", + " 85308\n", + " 7838\n", + " 2915\n", + " 271\n", " ...\n", " 551\n", " 0\n", @@ -687,13 +685,13 @@ " q14b\n", " 24\n", " 636\n", - " 5608\n", - " 8704\n", - " 97644\n", - " 58687\n", - " 2565\n", - " 1649\n", - " 210\n", + " 5272\n", + " 8360\n", + " 91678\n", + " 55951\n", + " 2927\n", + " 1578\n", + " 218\n", " ...\n", " 513\n", " 0\n", @@ -711,13 +709,13 @@ " q23a\n", " 18\n", " 621\n", - " 8765\n", - " 15382\n", - " 201084\n", - " 142969\n", - " 3432\n", - " 1429\n", - " 134\n", + " 8730\n", + " 15069\n", + " 199518\n", + " 138301\n", + " 2173\n", + " 1338\n", + " 107\n", " ...\n", " 2269\n", " 0\n", @@ -735,24 +733,24 @@ " q23b\n", " 21\n", " 690\n", - " 10684\n", - " 19596\n", - " 241665\n", - " 157549\n", - " 3374\n", - " 1718\n", - " 192\n", + " 8831\n", + " 17842\n", + " 224270\n", + " 145622\n", + " 3162\n", + " 1751\n", + " 120\n", " ...\n", " 4779\n", " 0\n", - " 1194344589\n", - " 1194344589\n", + " 1200330085\n", + " 1200330085\n", " 0\n", " 0\n", - " 1091584844\n", + " 1097570340\n", " 42452502\n", - " 22\n", - " 10\n", + " 25\n", + " 8\n", " \n", " \n", "\n", @@ -761,45 +759,45 @@ ], "text/plain": [ " query numStages numTasks elapsedTime stageDuration executorRunTime \\\n", - "0 q14a 30 838 9779 19488 160456 \n", - "1 q14b 24 636 5608 8704 97644 \n", - "2 q23a 18 621 8765 15382 201084 \n", - "3 q23b 21 690 10684 19596 241665 \n", + "0 q14a 30 838 9308 18042 149861 \n", + "1 q14b 24 636 5272 8360 91678 \n", + "2 q23a 18 621 8730 15069 199518 \n", + "3 q23b 21 690 8831 17842 224270 \n", "\n", " executorCpuTime executorDeserializeTime executorDeserializeCpuTime \\\n", - "0 89631 9277 3040 \n", - "1 58687 2565 1649 \n", - "2 142969 3432 1429 \n", - "3 157549 3374 1718 \n", + "0 85308 7838 2915 \n", + "1 55951 2927 1578 \n", + "2 138301 2173 1338 \n", + "3 145622 3162 1751 \n", "\n", " resultSerializationTime ... shuffleLocalBlocksFetched \\\n", - "0 362 ... 551 \n", - "1 210 ... 513 \n", - "2 134 ... 2269 \n", - "3 192 ... 4779 \n", + "0 271 ... 551 \n", + "1 218 ... 513 \n", + "2 107 ... 2269 \n", + "3 120 ... 4779 \n", "\n", " shuffleRemoteBlocksFetched shuffleTotalBytesRead shuffleLocalBytesRead \\\n", "0 0 878437913 878437913 \n", "1 0 1013592969 1013592969 \n", "2 0 1115089630 1115089630 \n", - "3 0 1194344589 1194344589 \n", + "3 0 1200330085 1200330085 \n", "\n", " shuffleRemoteBytesRead shuffleRemoteBytesReadToDisk shuffleBytesWritten \\\n", "0 0 0 875325021 \n", "1 0 0 529675847 \n", "2 0 0 1085198863 \n", - "3 0 0 1091584844 \n", + "3 0 0 1097570340 \n", "\n", " shuffleRecordsWritten avg_active_tasks elapsed_time_seconds \n", "0 62516924 16 9 \n", "1 40865273 17 5 \n", "2 41990073 22 8 \n", - "3 42452502 22 10 \n", + "3 42452502 25 8 \n", "\n", "[4 rows x 33 columns]" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -822,7 +820,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -854,31 +852,32 @@ "name": "stderr", "output_type": "stream", "text": [ - "24/10/22 20:25:34 WARN GpuOverrides: \n", + "24/10/23 14:48:22 WARN GpuOverrides: \n", "! cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.datasources.v2.OverwriteByExpressionExec\n", "\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - "24/10/22 20:25:35 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", - " \r" + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n", + "24/10/23 14:48:23 WARN MultiFileReaderThreadPool: Configuring the file reader thread pool with a max of 64 threads instead of spark.rapids.sql.multiThreadedRead.numThreads = 20\n" ] }, { @@ -886,12 +885,12 @@ "output_type": "stream", "text": [ "Job finished\n", - "...Start Time = 2024-10-22 20:25:32\n", - "...Elapsed Time = 6.63 sec\n", - "...Executors Run Time = 134.13 sec\n", - "...Executors CPU Time = 20.09 sec\n", - "...Executors JVM GC Time = 6.65 sec\n", - "...Average Active Tasks = 20.2\n", + "...Start Time = 2024-10-23 14:48:20\n", + "...Elapsed Time = 6.05 sec\n", + "...Executors Run Time = 123.47 sec\n", + "...Executors CPU Time = 17.23 sec\n", + "...Executors JVM GC Time = 7.43 sec\n", + "...Average Active Tasks = 20.4\n", "\n", "Run 0 - query q14b - attempt 0 - starting...\n" ] @@ -900,7 +899,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "24/10/22 20:25:42 WARN GpuOverrides: \n", + "24/10/23 14:48:30 WARN GpuOverrides: \n", "! cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.datasources.v2.OverwriteByExpressionExec\n", "\n" ] @@ -910,12 +909,12 @@ "output_type": "stream", "text": [ "Job finished\n", - "...Start Time = 2024-10-22 20:25:42\n", - "...Elapsed Time = 2.96 sec\n", - "...Executors Run Time = 90.89 sec\n", - "...Executors CPU Time = 13.46 sec\n", - "...Executors JVM GC Time = 9.7 sec\n", - "...Average Active Tasks = 30.7\n", + "...Start Time = 2024-10-23 14:48:30\n", + "...Elapsed Time = 2.85 sec\n", + "...Executors Run Time = 86.64 sec\n", + "...Executors CPU Time = 12.98 sec\n", + "...Executors JVM GC Time = 7.06 sec\n", + "...Average Active Tasks = 30.4\n", "\n", "Run 0 - query q23a - attempt 0 - starting...\n" ] @@ -924,7 +923,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "24/10/22 20:25:47 WARN GpuOverrides: \n", + "24/10/23 14:48:34 WARN GpuOverrides: \n", "! cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.datasources.v2.OverwriteByExpressionExec\n", "\n", " \r" @@ -935,12 +934,12 @@ "output_type": "stream", "text": [ "Job finished\n", - "...Start Time = 2024-10-22 20:25:46\n", - "...Elapsed Time = 3.33 sec\n", - "...Executors Run Time = 96.84 sec\n", - "...Executors CPU Time = 21.94 sec\n", - "...Executors JVM GC Time = 4.43 sec\n", - "...Average Active Tasks = 29.1\n", + "...Start Time = 2024-10-23 14:48:34\n", + "...Elapsed Time = 3.22 sec\n", + "...Executors Run Time = 98.1 sec\n", + "...Executors CPU Time = 22.08 sec\n", + "...Executors JVM GC Time = 4.58 sec\n", + "...Average Active Tasks = 30.5\n", "\n", "Run 0 - query q23b - attempt 0 - starting...\n" ] @@ -949,10 +948,10 @@ "name": "stderr", "output_type": "stream", "text": [ - "24/10/22 20:25:51 WARN GpuOverrides: \n", + "24/10/23 14:48:39 WARN GpuOverrides: \n", "! cannot run on GPU because GPU does not currently support the operator class org.apache.spark.sql.execution.datasources.v2.OverwriteByExpressionExec\n", "\n", - "[Stage 420:======================================> (36 + 14) / 50]\r" + "[Stage 420:===============================================> (43 + 7) / 50]\r" ] }, { @@ -960,14 +959,14 @@ "output_type": "stream", "text": [ "Job finished\n", - "...Start Time = 2024-10-22 20:25:51\n", - "...Elapsed Time = 5.0 sec\n", - "...Executors Run Time = 187.15 sec\n", - "...Executors CPU Time = 25.02 sec\n", - "...Executors JVM GC Time = 5.3 sec\n", - "...Average Active Tasks = 37.4\n", - "CPU times: user 60.8 ms, sys: 17.7 ms, total: 78.4 ms\n", - "Wall time: 25.4 s\n" + "...Start Time = 2024-10-23 14:48:38\n", + "...Elapsed Time = 4.79 sec\n", + "...Executors Run Time = 183.46 sec\n", + "...Executors CPU Time = 23.68 sec\n", + "...Executors JVM GC Time = 6.21 sec\n", + "...Average Active Tasks = 38.3\n", + "CPU times: user 45.8 ms, sys: 22.7 ms, total: 68.5 ms\n", + "Wall time: 24.3 s\n" ] }, { @@ -1027,21 +1026,21 @@ " q14a\n", " 30\n", " 862\n", - " 6627\n", - " 12982\n", - " 134135\n", - " 20095\n", - " 7859\n", - " 4073\n", - " 57\n", + " 6048\n", + " 10688\n", + " 123472\n", + " 17226\n", + " 7391\n", + " 3881\n", + " 36\n", " ...\n", " 718\n", " 0\n", - " 696329859\n", - " 696329859\n", + " 696421878\n", + " 696421878\n", " 0\n", " 0\n", - " 693773959\n", + " 693865654\n", " 18794\n", " 20\n", " 6\n", @@ -1051,21 +1050,21 @@ " q14b\n", " 24\n", " 661\n", - " 2959\n", - " 5783\n", - " 90892\n", - " 13457\n", - " 5387\n", - " 2913\n", - " 64\n", + " 2848\n", + " 4761\n", + " 86635\n", + " 12985\n", + " 3519\n", + " 2711\n", + " 86\n", " ...\n", " 695\n", " 0\n", - " 767417490\n", - " 767417490\n", + " 767451618\n", + " 767451618\n", " 0\n", " 0\n", - " 421580618\n", + " 421600742\n", " 15346\n", " 30\n", " 2\n", @@ -1075,23 +1074,23 @@ " q23a\n", " 18\n", " 589\n", - " 3332\n", - " 5160\n", - " 96842\n", - " 21942\n", - " 2211\n", - " 2011\n", - " 32\n", + " 3221\n", + " 5354\n", + " 98104\n", + " 22078\n", + " 2304\n", + " 2092\n", + " 79\n", " ...\n", " 1727\n", " 0\n", - " 897041986\n", - " 897041986\n", + " 897013287\n", + " 897013287\n", " 0\n", " 0\n", - " 878935367\n", + " 878908228\n", " 15223\n", - " 29\n", + " 30\n", " 3\n", " \n", " \n", @@ -1099,24 +1098,24 @@ " q23b\n", " 21\n", " 651\n", - " 5005\n", - " 8439\n", - " 187145\n", - " 25015\n", - " 2687\n", - " 2425\n", - " 43\n", + " 4794\n", + " 8100\n", + " 183457\n", + " 23683\n", + " 4522\n", + " 2527\n", + " 35\n", " ...\n", " 3774\n", " 0\n", - " 952892096\n", - " 952892096\n", + " 952869300\n", + " 952869300\n", " 0\n", " 0\n", - " 888404420\n", + " 888393294\n", " 16352\n", - " 37\n", - " 5\n", + " 38\n", + " 4\n", " \n", " \n", "\n", @@ -1125,45 +1124,45 @@ ], "text/plain": [ " query numStages numTasks elapsedTime stageDuration executorRunTime \\\n", - "0 q14a 30 862 6627 12982 134135 \n", - "1 q14b 24 661 2959 5783 90892 \n", - "2 q23a 18 589 3332 5160 96842 \n", - "3 q23b 21 651 5005 8439 187145 \n", + "0 q14a 30 862 6048 10688 123472 \n", + "1 q14b 24 661 2848 4761 86635 \n", + "2 q23a 18 589 3221 5354 98104 \n", + "3 q23b 21 651 4794 8100 183457 \n", "\n", " executorCpuTime executorDeserializeTime executorDeserializeCpuTime \\\n", - "0 20095 7859 4073 \n", - "1 13457 5387 2913 \n", - "2 21942 2211 2011 \n", - "3 25015 2687 2425 \n", + "0 17226 7391 3881 \n", + "1 12985 3519 2711 \n", + "2 22078 2304 2092 \n", + "3 23683 4522 2527 \n", "\n", " resultSerializationTime ... shuffleLocalBlocksFetched \\\n", - "0 57 ... 718 \n", - "1 64 ... 695 \n", - "2 32 ... 1727 \n", - "3 43 ... 3774 \n", + "0 36 ... 718 \n", + "1 86 ... 695 \n", + "2 79 ... 1727 \n", + "3 35 ... 3774 \n", "\n", " shuffleRemoteBlocksFetched shuffleTotalBytesRead shuffleLocalBytesRead \\\n", - "0 0 696329859 696329859 \n", - "1 0 767417490 767417490 \n", - "2 0 897041986 897041986 \n", - "3 0 952892096 952892096 \n", + "0 0 696421878 696421878 \n", + "1 0 767451618 767451618 \n", + "2 0 897013287 897013287 \n", + "3 0 952869300 952869300 \n", "\n", " shuffleRemoteBytesRead shuffleRemoteBytesReadToDisk shuffleBytesWritten \\\n", - "0 0 0 693773959 \n", - "1 0 0 421580618 \n", - "2 0 0 878935367 \n", - "3 0 0 888404420 \n", + "0 0 0 693865654 \n", + "1 0 0 421600742 \n", + "2 0 0 878908228 \n", + "3 0 0 888393294 \n", "\n", " shuffleRecordsWritten avg_active_tasks elapsed_time_seconds \n", "0 18794 20 6 \n", "1 15346 30 2 \n", - "2 15223 29 3 \n", - "3 16352 37 5 \n", + "2 15223 30 3 \n", + "3 16352 38 4 \n", "\n", "[4 rows x 33 columns]" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -1186,7 +1185,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": { "executionInfo": { "elapsed": 5, @@ -1209,14 +1208,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU and GPU run took: demo_dur=70.06181907653809 seconds\n" + "CPU and GPU run took: demo_dur=112.37040138244629 seconds\n" ] } ], @@ -1227,7 +1226,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1253,13 +1252,13 @@ "" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAAHcCAYAAAA0irvBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABaYklEQVR4nO3dd1QU1+M28GfpnQXpioCKBUuwBERFsKKisfcutggaayxfCxojQUXFHmOCWGKNGhUbsccOdiVoFEWjgAlNRYrsvH/423ldQYqCq8PzOWfPYe/cnbmzszP7cOfOrEwQBAFEREREEqOh7gYQERERlQaGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcojcEBgZCJpOpuxkfbN26dZDJZLh//36xXyuTyRAYGFjibSL6UNu2bYO5uTmeP38uljk6OmLQoEHqa1QJuX//PmQyGdatW/fB8xo0aBCMjIw+vFGfgF69eqFHjx7v/XqGHLw+qBflcfz4cfGDqHxoamqiYsWK6Ny5M65cuZJn3pmZmVi8eDHc3d1hamoKPT09VK1aFQEBAbh9+3ahbRs0aJDK8oyMjFCpUiV069YNv/32GxQKRZ7XKBQKrF+/Hu7u7jA3N4exsTGqVq2KAQMG4Ny5cyXxltFnRBl4Cns4Ojqqu6mfhF27dqFt27awsLCAjo4O7Ozs0KNHDxw9elSsc/z4cZX3TltbG5UqVcKAAQNw7969PPV27NiR77ICAgI+qVC9d+9edOjQAdbW1tDR0YG5uTmaNm2KkJAQpKenq9R1dHRUeQ+srKzg6emJXbt25anXvn37fJcXFRVV5C/23NxczJo1C6NHj5bMF/jnZOXKlflup1u3biEwMPC9/qEqismTJ+O3337D1atX3+v1WiXcns/Shg0bVJ6vX78ekZGRecpr1KiBly9fAgB69+6Ndu3aITc3FzExMVi1ahUOHDiAc+fOwdXVFQDw77//ok2bNoiOjkb79u3Rp08fGBkZITY2Flu2bMGaNWuQnZ1daPt0dXWxdu1aAMDLly/x4MED7N27F926dYO3tzd+//13mJiYiPXHjBmDFStWoGPHjujbty+0tLQQGxuLAwcOoFKlSmjYsOGHvF30mWnatGmez/LQoUPh5uaG4cOHi2XKL46XL19CS6vsHRoEQcCQIUOwbt061K1bF+PHj4eNjQ2ePHmCXbt2oUWLFjh9+jQaNWokvmbMmDH48ssvkZOTg0uXLmHNmjWIiIjA9evXYWdnp8a1KR6FQgE/Pz+sW7cOtWvXxqhRo2Bvb49nz57h7NmzmD59Ovbv348jR46ovM7V1RUTJkwAADx+/Bg//vgjunTpglWrVmHkyJEl2sa9e/ciNjZW5TMrJQ4ODnj58iW0tbXV3ZR8rVy5EhYWFnl6zW7duoXZs2fD29u7VP5Rqlu3Lho0aICQkBCsX7+++DMQKA9/f3/hXW9NXFycAEBYsGCBSvmePXsEAMLw4cPFMl9fX0FDQ0PYsWNHnvlkZmYKEyZMKLQtAwcOFAwNDfOdFhQUJAAQevToIZYlJCQIMplMGDZsWJ76CoVCSExMLHSZnxKFQiFkZGR8tOXNmjXrndv+cxIWFiYAEOLi4vKdbmhoKAwcOPCjtulTt2DBAgGAMHbsWEGhUOSZvn79euH8+fOCIAjCsWPHBADC9u3bVeosXbpUACDMmzevwHpKBR1rPiblsWTcuHH5rvvjx4+FH374QaXMwcFB8PX1VSl78uSJYGhoKFStWrXAekoXL14UAAhhYWGFtvGrr74SmjRpkqfcwcHhs/ksP3/+/KMsp6DvjfdVs2ZNwcvLK0/59u3bBQDCsWPHSnR5b75XCxcuFAwNDYVnz54Vez48XVVCmjdvDgCIi4sDAJw/fx4RERHw8/ND165d89TX1dXFwoULP2iZU6ZMQevWrbF9+3bx1FdcXBwEQUDjxo3z1Fd2KRcmNTUVgwYNgqmpKeRyOQYOHIgrV67k6Vb29vaGt7d3ntcPGjQoT6JXKBRYsmQJatasCT09PVhbW2PEiBFISUlRqafs2j506BAaNGgAfX19/Pjjj/Dy8sIXX3yRb3urVasGHx+fQtfrwIED8PT0hKGhIYyNjeHr64ubN28W+rqwsDA0b94cVlZW0NXVhYuLC1atWpWnnrLthw8fhqurK/T09ODi4oKdO3eq1MvJycHs2bPh7OwMPT09lCtXDk2aNEFkZKRKvb/++gvdunWDubk59PT00KBBA+zZsyfPcm/evInmzZtDX18fFSpUwNy5c/M9jVlUb4/JUY5Tun37Nvr16wdTU1NYWlpixowZEAQBDx8+RMeOHWFiYgIbGxuEhITkmWdWVhZmzZqFKlWqQFdXF/b29vj222+RlZVVpDZt374d9evXh76+PiwsLNCvXz/8888/KnWU4xD++ecfdOrUCUZGRrC0tMTEiRORm5tb4PxfvnyJoKAgVK9eHQsXLsz3FFL//v3h5uZW4HzePg6UhICAABgZGSEjIyPPtN69e8PGxkZcv6ioKPj4+MDCwgL6+vpwcnLCkCFDCpx/RkYGgoODUbNmTSxYsCDfdbe1tcXkyZMLbauNjQ1q1KhRousPvD7tf/DgQbRs2bJI9e/du4fu3bvD3NwcBgYGaNiwISIiIsTpgiDAwsIC48ePF8sUCgXkcjk0NTWRmpoqlgcHB0NLS0tlHFBR9k3laeITJ05g1KhRsLKyQoUKFd7Z5vzG5CQkJGDw4MGoUKECdHV1YWtri44dOxb51NC9e/fg4+MDQ0ND2NnZYc6cORAEQaVOUY7Njo6OuHnzJk6cOCGenvT29sa6devQvXt3AECzZs1UhnYoFeW4q9x37969i3bt2sHY2Bh9+/YVp7dq1QovXrzIc4wsCoacEnL37l0AQLly5QBA/MD379+/VJfbv39/CIIgbnwHBwcAr78U8jsoFkYQBHTs2BEbNmxAv379MHfuXDx69AgDBw78oHaOGDECkyZNQuPGjREaGorBgwdj06ZN8PHxQU5Ojkrd2NhY9O7dG61atUJoaChcXV3Rv39/XLt2DTdu3FCpe/HiRfHLtyAbNmyAr68vjIyMEBwcjBkzZuDWrVto0qRJoQeMVatWwcHBAdOmTUNISAjs7e0xatQorFixIk/dO3fuoGfPnmjbti2CgoKgpaWF7t27q+ycgYGBmD17Npo1a4bly5fjf//7HypWrIhLly6JdW7evImGDRsiJiYGU6ZMQUhICAwNDdGpUyeVMQ8JCQlo1qwZrly5gilTpmDs2LFYv349QkNDC1yn99GzZ08oFAr88MMPcHd3x9y5c7FkyRK0atUK5cuXR3BwMKpUqYKJEyfi5MmT4usUCgW++uorLFy4EB06dMCyZcvQqVMnLF68GD179ix0uevWrUOPHj2gqamJoKAgDBs2DDt37kSTJk1UvoyA1+M2fHx8UK5cOSxcuBBeXl4ICQnBmjVrClzGn3/+ieTkZPTp0weamprv9f4AeY8DJaFnz5548eKFypc08DqcKE9ba2pqIikpCa1bt8b9+/cxZcoULFu2DH379i10HN6ff/6J1NRU9O7d+4PWHXgd4B8+fFii6w8A0dHRyM7ORr169Qqtm5iYiEaNGuHQoUMYNWoUvv/+e2RmZuKrr74S9x2ZTIbGjRurfE6vXbuGtLQ0AMDp06fF8lOnTqFu3bri6dyi7ptKo0aNwq1btzBz5kxMmTKlWOvdtWtX7Nq1C4MHD8bKlSsxZswYPHv2DPHx8YW+Njc3F23atIG1tTXmz5+P+vXrY9asWZg1a5ZKvaIcm5csWYIKFSqgevXq2LBhAzZs2ID//e9/aNq0KcaMGQMAmDZtmjitRo0aAIp33H316hV8fHxgZWWFhQsXqnQOuLi4QF9fX2W7FFnJdCxJS1FOV82ePVt4+vSpkJCQIBw/flyoW7euAED47bffBEEQhM6dOwsAhJSUlA9qS2HdjpcvXxa7mZUGDBggABDMzMyEzp07CwsXLhRiYmKKtLzdu3cLAIT58+eLZa9evRI8PT3zdCt7eXnl2305cOBAwcHBQXx+6tQpAYCwadMmlXoHDx7MU+7g4CAAEA4ePKhSNzU1VdDT0xMmT56sUj5mzBjB0NCwwG7gZ8+eCXK5PM8pvISEBMHU1FSlPL/TVfmdLvPx8REqVaqkUqZsu/IzIAiCkJaWJtja2gp169YVy7744ot3dt8rtWjRQqhdu7aQmZkplikUCqFRo0aCs7OzWDZ27FgBgHgaRRAEISkpSTA1NX3v01UAhFmzZonPle/Jm6diX716JVSoUEGQyWQqpzFSUlIEfX19lXlv2LBB0NDQEE6dOqWynNWrVwsAhNOnT7/zfcjOzhasrKyEWrVqCS9fvhTL9+3bJwAQZs6cKZYNHDhQACDMmTNHZR5169YV6tev/85lCIIghIaGCgCEXbt2FVhPSXka6pdffhGePn0qPH78WIiIiBAcHR0FmUwmXLx4UaXeh5yuUigUQvny5YWuXbuqlG/btk0AIJw8eVIQBEHYtWuXAEBcdlEp13337t0q5a9evRKePn2q8njzVJaDg4PQunVrcdrVq1eFXr16CQCE0aNHq9T70NNVa9euFQAI169fzzPt7dNVyn3izc/bs2fPBCcnJ8HR0VHIzc0VBOH16UlNTU0hPT1dEITXpxodHBwENzc38TiTm5sryOVyleNrUfdN5SnjJk2aCK9evSpw/QTh/3+3KN+LlJSUfIdGFIVyX3hzOygUCsHX11fQ0dERnj59KghC8Y7NxT1dVZzjrrK9U6ZMeec6Va1aVWjbtm2h6/429uS8p1mzZsHS0hI2Njbw9vbG3bt3ERwcjC5dugCAeCWCsbFxqbZD+d/Fs2fPxLKwsDAsX74cTk5O2LVrFyZOnIgaNWqgRYsWebr437Z//35oaWnh66+/Fss0NTUxevTo927j9u3bYWpqilatWuHff/8VH/Xr14eRkRGOHTumUt/JySnP6SdTU1N07NgRmzdvFrtbc3NzsXXrVnTq1AmGhobvXH5kZKT4n+qby9fU1IS7u3ue5b9NX19f/DstLQ3//vsvvLy8cO/ePfE/PyU7Ozt07txZfG5iYoIBAwbg8uXLSEhIAADI5XLcvHkTd+7cyXd5ycnJOHr0KHr06IFnz56J7f3vv//g4+ODO3fuiNtx//79aNiwocppFEtLS5Wu3pIydOhQ8W9NTU00aNAAgiDAz89PLJfL5ahWrZrKFUbbt29HjRo1UL16dZX3X3lqp6D3PyoqCklJSRg1ahT09PTEcl9fX1SvXj1P7waAPANePT09VdqTn/fdX4cMGQJLS0vY2dnB19cXL168QHh4OBo0aFCs+RREJpOhe/fu2L9/v8opk61bt6J8+fJo0qQJgNfvPQDs27cvT+9oQZTr/vYVS9evX4elpaXK47///lOpc/jwYXHaF198ge3bt6N///4IDg5+n1V9J+VyzczMCq27f/9+uLm5ie8L8Hrdhg8fjvv37+PWrVsAXn8ucnNzcebMGQCve2w8PT3h6emJU6dOAQBu3LiB1NRUeHp6Aijevqk0bNiw9+oh09fXh46ODo4fP57ntH5RBQQEiH/LZDIEBAQgOzsbf/zxB4DiH5uL432Ou29+77zNzMwM//77b7HbUfYuoSghw4cPR/fu3aGhoQG5XI6aNWtCV1dXnK682unZs2fiweddXr58mefL0sbGpkjtUB703jw4a2howN/fH/7+/vjvv/9w+vRprF69GgcOHECvXr3EHTg/Dx48gK2tbZ4DXrVq1YrUnvzcuXMHaWlp7xwPlJSUpPLcyckp33oDBgzA1q1bcerUKTRt2hR//PEHEhMTCz0lqAwTyi/Vt715ZVp+Tp8+jVmzZuHs2bN5TgGmpaXB1NRUfF6lSpU8YxqqVq0K4PU5dxsbG8yZMwcdO3ZE1apVUatWLbRp0wb9+/dHnTp1AAB///03BEHAjBkzMGPGjHzblJSUhPLly+PBgwdwd3fPM/1Dtte7VKxYUeW58pYIFhYWecrf/DK8c+cOYmJiYGlpme98397+b3rw4AGA/NenevXq+PPPP1XK9PT08izHzMys0C+JN/fX4pg5cyY8PT2hqakJCwsL1KhRo1SuTOvZsyeWLFmCPXv2oE+fPnj+/Dn279+PESNGiJ83Ly8vdO3aFbNnz8bixYvh7e2NTp06oU+fPirHprcpjx1vBijg9WdZeZp1/fr1ea7QAyCetpTJZDAwMECNGjUKPd7lp6iX0QtvjSfJz7v2CeUplAcPHqBWrVqoV68eDAwMcOrUKfj4+ODUqVOYPXs2bGxssGzZMmRmZorHSmVgKs6+qfSu41lhdHV1ERwcjAkTJsDa2hoNGzZE+/btMWDAgCJ9P2hoaKBSpUoqZW8ei4DiH5uLo7jHXS0trQLHLAmC8F63W2DIeU/Ozs4FDoKrXr06gNf/DSn/C3iXrVu3YvDgwSplRdmZAYhjVKpUqZLv9HLlyuGrr77CV199BW9vb5w4cQIPHjwQx+58CJlMlm873x7kqVAoYGVlhU2bNuU7n7e/lN7sOXmTj48PrK2tsXHjRjRt2hQbN26EjY1NoYMRlYNwN2zYkO/BoaAvpbt376JFixaoXr06Fi1aBHt7e+jo6GD//v1YvHjxew3wbdq0Ke7evYvff/8dhw8fxtq1a7F48WKsXr0aQ4cOFec5ceLEdw6oftf2Lk35/Tf6rv9Q3/xcKBQK1K5dG4sWLcq3rr29fck0sID2FObN/bVTp05Ffl3t2rUL/Pwpe5+Ut554W0ZGhkoP1bs0bNgQjo6O2LZtG/r06YO9e/fi5cuXKmOalPfjOXfuHPbu3YtDhw5hyJAhCAkJwblz5955bxnlut+4cQMdO3YUy42MjMR1eztMKllYWBS6/+np6RW4/so6BVGO8UlJSSnwi7A4tLW14e7ujpMnT+Lvv/9GQkICPD09YW1tjZycHJw/fx6nTp1C9erVxWPU++yb7zqeFcXYsWPRoUMH7N69G4cOHcKMGTMQFBSEo0ePom7duu89X6XiHpuLO2+g6MddXV1daGi8++RSSkoKnJ2di90OhpxS0qFDBwQFBWHjxo2FhhwfH5/3GjUOvP4AyWQytGrVqtC6DRo0wIkTJ/DkyZN3hhwHBwccOXIEz58/VzkoxsbG5qlrZmaW72kA5X/fSpUrV8Yff/yBxo0bf9AOr6mpiT59+mDdunUIDg7G7t27i9QVXLlyZQCAlZVVka/OUNq7dy+ysrKwZ88elZ6Md3XjKv/Te/M/DuWVb29ecWZubo7Bgwdj8ODBeP78OZo2bYrAwEAMHTpU/O9LW1u70PY6ODjke9orv+2lLpUrV8bVq1fRokWLYv8npvycxsbG5vmPMDY2tkTCOvD6P3UzMzNs3rwZ06ZN++ABuEpvtj8/xVmHHj16IDQ0FOnp6di6dSscHR3zvedVw4YN0bBhQ3z//ff49ddf0bdvX2zZskXldOObPD09YWpqii1btmDq1KkFftG8DwcHB/EU0duU70th74EyiMXFxaF27dqFLi+/9/uvv/7KsyxPT08EBwfjjz/+gIWFBapXrw6ZTIaaNWvi1KlTOHXqlMqNDIuzb5aUypUrY8KECZgwYQLu3LkDV1dXhISEYOPGjQW+TqFQ4N69e2LvDZD3WFScY/O79t13lX/Icfdtr169wsOHD/HVV18V+7Uck1NKPDw80KZNG6xduxa7d+/OMz07OxsTJ04E8PryzJYtW6o8iuKHH37A4cOH0bNnTzHhJiQk5HtAyc7OxpEjR6ChoVFgL0C7du3w6tUrlUukc3NzsWzZsjx1K1eujL/++gtPnz4Vy65evZpnBHyPHj2Qm5uL7777Ls88Xr16lecKmYL0798fKSkpGDFiBJ4/f17oVVXA6xBpYmKCefPm5TtW4c32v035Zfdmz0RaWhrCwsLyrf/48WOVKyzS09Oxfv16uLq6iv/NvD2uwcjICFWqVBEvp7aysoK3tzd+/PFHPHnypMD2tmvXDufOncOFCxdUpr/rPzN16NGjB/755x/89NNPeaa9fPkSL168eOdrGzRoACsrK6xevVrlcvMDBw4gJiYGvr6+JdJGAwMDTJ48GTExMZg8eXK+PZQbN25UeZ+LwtbWFq6urti4cWOez3l0dDTOnTuHtm3bFmlePXv2RFZWFsLDw3Hw4ME8t7pPSUnJ027ljUkLulTfwMAA3377LW7cuIEpU6bku+5F7VnOT7t27fDo0aM8x8GsrCysXbsWVlZWhV41Vb9+fejo6CAqKqpIy7tw4QLOnj0rlr148QJr1qyBo6MjXFxcxHJPT09kZWVhyZIlaNKkifiF7enpiQ0bNuDx48cq/6QWZ9/8UBkZGcjMzFQpq1y5MoyNjYt864Xly5eLfwuCgOXLl0NbWxstWrQAULxjs6GhYb7HauV4yLenfchx9223bt1CZmamyo04i4o9OaVo/fr1aN26Nbp06YIOHTqgRYsWMDQ0xJ07d7BlyxY8efKkSPfKefXqlZjaMzMz8eDBA+zZswfXrl1Ds2bNVC6PffToEdzc3NC8eXO0aNECNjY2SEpKwubNm3H16lWMHTs2zxiKN3Xo0AGNGzfGlClTcP/+ffE+L2+PGQJeD7pctGgRfHx84Ofnh6SkJKxevRo1a9ZUuQW8l5cXRowYgaCgIFy5cgWtW7eGtrY27ty5g+3btyM0NBTdunUr0ntat25d1KpVSxzMWpRLSk1MTLBq1Sr0798f9erVQ69evWBpaYn4+HhERESgcePGKgeDN7Vu3Ro6Ojro0KGDGKx++uknWFlZ5XuQq1q1Kvz8/HDx4kVYW1vjl19+QWJiokoocnFxgbe3N+rXrw9zc3NERUVhx44dKoMEV6xYgSZNmqB27doYNmwYKlWqhMTERJw9exaPHj0Sb3H+7bffYsOGDWjTpg2++eYbGBoaYs2aNXBwcMC1a9eK9J6Wtv79+2Pbtm0YOXIkjh07hsaNGyM3Nxd//fUXtm3bJt4TKT/a2toIDg7G4MGD4eXlhd69eyMxMRGhoaFwdHTEuHHjSqydkyZNws2bNxESEoJjx46hW7dusLGxQUJCAnbv3o0LFy6Ig1SLQ7mPuLq6YtCgQbCzs0NMTAzWrFkDW1tbTJ06tUjzqVevHqpUqYL//e9/yMrKynP5fXh4OFauXInOnTujcuXKePbsGX766SeYmJigXbt2Bc57ypQpiImJwYIFC3D48GF07doVFSpUQEpKCi5duoTt27fDysqqSKfW3jZ8+HD88ssv6N69O4YMGYK6deviv//+w9atW3Hjxg2sX78eOjo6Bc5DT08PrVu3xh9//IE5c+YUui6bN29G27ZtMWbMGJibmyM8PBxxcXH47bffVHqqPDw8xDvCv3kn5aZNm4r/6L3dE1/UffND3b59Gy1atECPHj3g4uICLS0t7Nq1C4mJiejVq1ehr9fT08PBgwcxcOBAuLu748CBA4iIiMC0adPE01DFOTbXr18fq1atwty5c1GlShVYWVmhefPmcHV1haamJoKDg5GWlgZdXV3xvmLve9x9W2RkJAwMDIp0xiKPYl+PVQa8zx2P3yUjI0NYuHCh8OWXXwpGRkaCjo6O4OzsLIwePVr4+++/C3298tI65cPAwEBwdHQUunbtKuzYsUO8HFIpPT1dCA0NFXx8fIQKFSoI2tragrGxseDh4SH89NNP+d7N9G3//fef0L9/f8HExEQwNTUV+vfvL16q/valnhs3bhQqVaok6OjoCK6ursKhQ4fyXEKutGbNGqF+/fqCvr6+YGxsLNSuXVv49ttvhcePH4t1CrrcVGn+/Pkqd5UtqmPHjgk+Pj6CqampoKenJ1SuXFkYNGiQEBUVJdbJ7xLyPXv2CHXq1BH09PQER0dHITg4WPjll1/yXKKtbPuhQ4eEOnXqCLq6ukL16tXzXD48d+5cwc3NTZDL5YK+vr5QvXp14fvvvxeys7NV6t29e1cYMGCAYGNjI2hrawvly5cX2rdvn+cO2teuXRO8vLwEPT09oXz58sJ3330n/PzzzyV+CbnyslOld93ewMvLS6hZs6ZKWXZ2thAcHCzUrFlT0NXVFczMzIT69esLs2fPFtLS0vJtx5u2bt0q1K1bV9DV1RXMzc2Fvn37Co8ePSpSe4p7F+sdO3YIrVu3FszNzQUtLS3B1tZW6Nmzp3D8+HGxTmGXhr/t3LlzQvv27QUzMzNBS0tLKF++vDB06NA861CY//3vfwIAoUqVKnmmXbp0Sejdu7dQsWJFQVdXV7CyshLat2+v8vkuzK5du4R27doJlpaWgpaWliCXy4UmTZoICxYsEFJTU1XqFmVfVUpJSRHGjRsnODk5Cdra2oKJiYnQrFkz4cCBA0Vu286dOwWZTCbEx8fnacfbn+W7d+8K3bp1E+RyuaCnpye4ubkJ+/bty3e+X375ZZ7bMDx69EgAINjb2+f7mqLsm8pLyIt6Sf/bl5D/+++/gr+/v1C9enXB0NBQMDU1Fdzd3YVt27YVOi/lvnD37l2hdevWgoGBgWBtbS3MmjUrz3eGIBTt2JyQkCD4+voKxsbGAgCVy8l/+uknoVKlSoKmpmaey8mLctwt7FYp7u7uQr9+/Qpd7/zIBOED+iGpzLh//z6cnJwQFham9l/8DQ0Nxbhx43D//v08V/yok6OjI2rVqoV9+/apuylEkpObmwsXFxf06NEj39MrJE1XrlxBvXr1cOnSJfH0a3FwTA59VgRBwM8//wwvL69PKuAQUenS1NTEnDlzsGLFijyXu5N0/fDDD+jWrdt7BRyAY3LoM/HixQvs2bMHx44dw/Xr1/H777+ru0lE9JH17NmzSD8FQtKxZcuWD3o9Qw59Fp4+fYo+ffpALpdj2rRp73UpIRERlS0ck0NERESSxDE5REREJEkMOURERCRJZXpMjkKhwOPHj2FsbPxeP/xFREREH58gCHj27Bns7OwK/CmSMh1yHj9+XKI/DkhEREQfz8OHDwv80dYyHXKMjY0BvH6T3v7ZdyIiIvo0paenw97eXvwef5cyHXKUp6hMTEwYcoiIiD4zhQ014cBjIiIikiSGHCIiIpIkhhwiIiKSpDI9JoeIqCwSBAGvXr1Cbm6uuptClC9NTU1oaWl98O1dGHKIiMqQ7OxsPHnyBBkZGepuClGBDAwMYGtrCx0dnfeeB0MOEVEZoVAoEBcXB01NTdjZ2UFHR4c3QqVPjiAIyM7OxtOnTxEXFwdnZ+cCb/hXEIYcIqIyIjs7GwqFAvb29jAwMFB3c4jeSV9fH9ra2njw4AGys7Ohp6f3XvPhwGMiojLmff8rJvqYSuJzyk86ERERSRJDDhEREUkSQw4REX3Wjh8/DplMhtTUVHU3pUDFbefnsl6fMg48JiIq4xynRHzU5d3/wfejLu9TNGjQIISHh79zuoODA27fvo0nT57A1NT0I7ZMWtiTQ0RE9JGFhobiyZMn4gMAwsLCxOcXL16Ejo4ObGxseJn/B2DIISKiT55CoUBQUBCcnJygr6+PL774Ajt27Mi37n///YfevXujfPnyMDAwQO3atbF582aVOt7e3ggICEBAQABMTU1hYWGBGTNmQBAEsc7KlSvh7OwMPT09WFtbo1u3bsVqz/79+1G1alXo6+ujWbNmuH//vjjN1NQUNjY24gMA5HK5+NzS0jLP6ap169ZBLpdj3759qFatGgwMDNCtWzdkZGQgPDwcjo6OMDMzw5gxY1TuZp2VlYWJEyeifPnyMDQ0hLu7O44fP17k9/706dPw9vaGgYEBzMzM4OPjg5SUlCK/jzKZDLt371aZp1wux7p164rchvfF01Vq9LG7iN/E7mIi+pwEBQVh48aNWL16NZydnXHy5En069cPlpaWeepmZmaifv36mDx5MkxMTBAREYH+/fujcuXKcHNzE+uFh4fDz88PFy5cQFRUFIYPH46KFSti2LBhiIqKwpgxY7BhwwY0atQIycnJOHXqVJHa4+XlhYcPH6JLly7w9/fH8OHDERUVhQkTJnzw+5CRkYGlS5diy5YtePbsGbp06YLOnTtDLpdj//79uHfvHrp27YrGjRujZ8+eAICAgADcunULW7ZsgZ2dHXbt2oU2bdrg+vXrcHZ2LnB5V65cQYsWLTBkyBCEhoZCS0sLx44dUwlRBb2P6saQQ0REn7SsrCzMmzcPf/zxBzw8PAAAlSpVwp9//okff/wRw4cPV6lfvnx5TJw4UXw+evRoHDp0CNu2bVMJOfb29li8eDFkMhmqVauG69evY/HixRg2bBji4+NhaGiI9u3bw9jYGA4ODqhbt26R2uPl5YVVq1ahcuXKCAkJAQBx/sHBwR/0XuTk5IjzBoBu3bphw4YNSExMhJGREVxcXNCsWTMcO3YMPXv2RHx8PMLCwhAfHw87OzsAwMSJE3Hw4EGEhYVh3rx5BS5v/vz5aNCgAVauXCmW1axZU6VOQe+jujHkEBHRJ+3vv/9GRkYGWrVqpVKenZ0tBo835ebmYt68edi2bRv++ecfZGdnIysrK89dnhs2bKgy3sXDwwMhISHIzc1Fq1at4ODggEqVKqFNmzZo06YNOnfuDAMDgyK1JyYmBu7u7irTlYHoQxgYGIgBBwCsra3h6OgIIyMjlbKkpCQAwPXr15Gbm4uqVauqzCcrKwvlypUrdHlXrlxB9+7dC6xT0PuoqalZpPUqLQw5RET0SXv+/DkAICIiAuXLl1eZpquri7t376qULViwAKGhoViyZAlq164NQ0NDjB07FtnZ2UVeprGxMS5duoTjx4/j8OHDmDlzJgIDA3Hx4sVC21OatLW1VZ7LZLJ8yxQKBYDX752mpiaio6PzBI43g9G76Ovrf2CLX7fnzTE6wOseqY+BIYeIiD5pLi4u0NXVRXx8PLy8vPJMfzvknD59Gh07dkS/fv0AvB4kfPv2bbi4uKjUO3/+vMrzc+fOwdnZWQwDWlpaaNmyJVq2bIlZs2ZBLpfj6NGjaNWqVYHtAYAaNWpgz549eeb/sdWtWxe5ublISkqCp6dnsV9fp04dHDlyBLNnz35nncLeR0tLS/EKMgC4c+cOMjIyit2W98GQQ0REnzRjY2NMnDgR48aNg0KhQJMmTZCWlobTp0/DxMQEDg4OKvWdnZ2xY8cOnDlzBmZmZli0aBESExPzhJz4+HiMHz8eI0aMwKVLl7Bs2TJxDM2+fftw7949NG3aFGZmZti/fz8UCgWqVatWaHsGDhyIkSNHIiQkBJMmTcLQoUMRHR39Ua4melvVqlXRt29fDBgwACEhIahbty6ePn2KI0eOoE6dOvD1LfgilKlTp6J27doYNWoURo4cCR0dHRw7dgzdu3eHhYUFgILfRwBo3rw5li9fDg8PD+Tm5mLy5Ml5ep9KC0MOEVEZ9zlcbfndd9/B0tISQUFBuHfvHuRyOerVq4dp06aJp2aUpk+fjnv37sHHxwcGBgYYPnw4OnXqhLS0NJV6AwYMwMuXL+Hm5gZNTU1888034iBmuVyOnTt3IjAwEJmZmXB2dsbmzZvFQbcFtQcAKlasiN9++w3jxo3DsmXL4Obmhnnz5mHIkCEf4d1SFRYWhrlz52LChAn4559/YGFhgYYNG6J9+/aFvrZq1ao4fPgwpk2bBjc3N+jr68Pd3R29e/cW6xT0PgJASEgIBg8eDE9PT9jZ2SE0NBTR0dGlsq5vkwlvnygrQ9LT02Fqaoq0tDSYmJh89OXzEnIi+pgyMzMRFxcHJycn6Onpqbs5auXt7Q1XV1csWbJE3U35rJXm+1jQ57Wo39+8GSARERFJEkMOERFRGdW2bVsYGRnl+yjsHjqfA47JISKiMqc4P2sgZWvXrsXLly/znWZubl7o6z/195Ehh4iIqIx6+z4/UsPTVURERCRJDDlEREQkSQw5REREJEkMOURERCRJDDlEREQkSQw5RET0WTt+/DhkMhlSU1PV3ZQCFbedn8t6fcp4CTkRUVkXaPqRl5dWeB2JGzRoEMLDw9853cHBAbdv38aTJ09gavqRt4+EFLsn5+TJk+jQoQPs7Owgk8mwe/dulemCIGDmzJmwtbWFvr4+WrZsiTt37qjUSU5ORt++fWFiYgK5XA4/Pz88f/5cpc61a9fg6ekJPT092NvbY/78+Xnasn37dlSvXh16enqoXbs29u/fX9zVISIi+uhCQ0Px5MkT8QG8/iFN5fOLFy9CR0cHNjY2kMlkam7t56vYIefFixf44osvsGLFinynz58/H0uXLsXq1atx/vx5GBoawsfHB5mZmWKdvn374ubNm4iMjMS+fftw8uRJlV8sTU9PR+vWreHg4IDo6GgsWLAAgYGBWLNmjVjnzJkz6N27N/z8/HD58mV06tQJnTp1wo0bN4q7SkRE9IlTKBQICgqCk5MT9PX18cUXX2DHjh351v3vv//Qu3dvlC9fHgYGBqhduzY2b96sUsfb2xsBAQEICAiAqakpLCwsMGPGDLz5m9UrV66Es7Mz9PT0YG1tjW7duhWrPfv370fVqlWhr6+PZs2a4f79++I0U1NT2NjYiA/g9S+fK59bWlrmOV21bt06yOVy7Nu3D9WqVYOBgQG6deuGjIwMhIeHw9HREWZmZhgzZgxyc3PFZWVlZWHixIkoX748DA0N4e7uXqw7Ff/000+wt7eHgYEBOnfujEWLFkEul4vTAwMD4erqih9//FGs16NHD5Vffff29sbYsWNV5tupUycMGjSoyO14H8U+XdW2bVu0bds232mCIGDJkiWYPn06OnbsCABYv349rK2tsXv3bvTq1QsxMTE4ePAgLl68iAYNGgAAli1bhnbt2mHhwoWws7PDpk2bkJ2djV9++QU6OjqoWbMmrly5gkWLFolhKDQ0FG3atMGkSZMAvP7Z+8jISCxfvhyrV69+rzeDiIg+TUFBQdi4cSNWr14NZ2dnnDx5Ev369YOlpWWeupmZmahfvz4mT54MExMTREREoH///qhcuTLc3NzEeuHh4fDz88OFCxcQFRWF4cOHo2LFihg2bBiioqIwZswYbNiwAY0aNUJycjJOnTpVpPZ4eXnh4cOH6NKlC/z9/TF8+HBERUVhwoQJH/w+ZGRkYOnSpdiyZQuePXuGLl26oHPnzpDL5di/fz/u3buHrl27onHjxujZsycAICAgALdu3cKWLVtgZ2eHXbt2oU2bNrh+/TqcnZ0LXN7p06cxcuRIBAcH46uvvsIff/yBGTNm5Kn3999/Y9u2bdi7dy/S09Ph5+eHUaNGYdOmTR+8zh+iRMfkxMXFISEhAS1bthTLTE1N4e7ujrNnz6JXr144e/Ys5HK5GHAAoGXLltDQ0MD58+fRuXNnnD17Fk2bNoWOjo5Yx8fHB8HBwUhJSYGZmRnOnj2L8ePHqyzfx8cnz+mzN2VlZSErK0t8np6eXgJrTUREpSkrKwvz5s3DH3/8AQ8PDwBApUqV8Oeff+LHH39UORMAvP6pgokTJ4rPR48ejUOHDmHbtm0qIcfe3h6LFy+GTCZDtWrVcP36dSxevBjDhg1DfHw8DA0N0b59exgbG8PBwQF169YtUnu8vLywatUqVK5cGSEhIQAgzj84OPiD3oucnBxx3gDQrVs3bNiwAYmJiTAyMoKLiwuaNWuGY8eOoWfPnoiPj0dYWBji4+NhZ2cHAJg4cSIOHjyIsLCwQn+Ec9myZWjbtq34flatWhVnzpzBvn37VOplZmZi/fr14s9ELFu2DL6+vggJCRF7qtShRENOQkICAMDa2lql3NraWpyWkJAAKysr1UZoacHc3FyljpOTU555KKeZmZkhISGhwOXkJygoCLNnz36PNSMiInX5+++/kZGRgVatWqmUZ2dni8HjTbm5uZg3bx62bduGf/75B9nZ2cjKyoKBgYFKvYYNG6qMd/Hw8EBISAhyc3PRqlUrODg4oFKlSmjTpg3atGmDzp07w8DAoEjtiYmJgbu7u8p0ZSD6EAYGBmLAAV5/7zk6OsLIyEilLCkpCQBw/fp15ObmomrVqirzycrKQrly5QpdXmxsLDp37qxS5ubmlifkVKxYUeV3sDw8PKBQKBAbGyudkPOpmzp1qkrvT3p6Ouzt7dXYIiIiKozywpSIiIg8Pyipq6uLu3fvqpQtWLAAoaGhWLJkCWrXrg1DQ0OMHTsW2dnZRV6msbExLl26hOPHj+Pw4cOYOXMmAgMDcfHixULbU5q0tbVVnstksnzLFAoFgNfvnaamJqKjo6GpqalS781gVNo0NDRUxjsBr3ulSluJhhxlWktMTIStra1YnpiYCFdXV7GOMmEqvXr1CsnJyeLrbWxskJiYqFJH+bywOgUlRl1d3VL/ABIRUclycXGBrq4u4uPj4eXllWf62yHn9OnT6NixI/r16wfg9SDh27dvw8XFRaXe+fPnVZ6fO3cOzs7OYhjQ0tJCy5Yt0bJlS8yaNQtyuRxHjx5Fq1atCmwPANSoUQN79uzJM/+PrW7dusjNzUVSUhI8PT2L/fpq1arh4sWLKmVvPweA+Ph4PH78WDwldu7cOWhoaKBatWoAAEtLS/EqMuB1b9uNGzfQrFmzYrepOEr0ZoBOTk6wsbHBkSNHxLL09HScP39e7Kbz8PBAamoqoqOjxTpHjx6FQqEQu/Y8PDxw8uRJlZQXGRmJatWqwczMTKzz5nKUdUqiO5CIiD4dxsbGmDhxIsaNG4fw8HDcvXsXly5dwrJly/K914yzszMiIyNx5swZxMTEYMSIEXn+KQZefzGPHz8esbGx2Lx5M5YtW4ZvvvkGALBv3z4sXboUV65cwYMHD7B+/XooFApUq1atSO0ZOXIk7ty5g0mTJiE2Nha//vor1q1bV6rvU36qVq2Kvn37YsCAAdi5cyfi4uJw4cIFBAUFISIiotDXjx49Gvv378eiRYtw584d/Pjjjzhw4ECey9r19PQwcOBAXL16FadOncKYMWPQo0cPseOhefPmiIiIQEREBP766y98/fXXH+Umh8XuyXn+/Dn+/vtv8XlcXByuXLkCc3NzVKxYEWPHjsXcuXPh7OwMJycnzJgxA3Z2dujUqROA1+m2TZs2GDZsGFavXo2cnBwEBASgV69eYgLs06cPZs+eDT8/P0yePBk3btxAaGgoFi9eLC73m2++gZeXF0JCQuDr64stW7YgKipK5TJzIiIqgs/g5nzfffcdLC0tERQUhHv37kEul6NevXqYNm2aeGpGafr06bh37x58fHxgYGCA4cOHo1OnTiqXNAPAgAED8PLlS7i5uUFTUxPffPONOIhZLpdj586dCAwMRGZmJpydnbF582bUrFmz0PYAr8eo/Pbbbxg3bhyWLVsGNzc3zJs3D0OGDPkI75aqsLAwzJ07FxMmTMA///wDCwsLNGzYEO3bty/0tY0bN8bq1asxe/ZsTJ8+HT4+Phg3bhyWL1+uUq9KlSro0qUL2rVrh+TkZLRv3x4rV64Upw8ZMgRXr17FgAEDoKWlhXHjxpV6Lw4AyIS3T5IV4vjx4/k2bODAgVi3bh0EQcCsWbOwZs0apKamokmTJli5cqXKoKfk5GQEBARg79690NDQQNeuXbF06VKV84PXrl2Dv78/Ll68CAsLC4wePRqTJ09WWeb27dsxffp03L9/H87Ozpg/fz7atWtX5HVJT0+Hqakp0tLSYGJiUpy3oUQ4Tik8RZeW+z/4qm3ZRKQemZmZiIuLg5OTE/T09NTdHLXy9vaGq6srlixZou6mfHaGDRuGv/76S7ykPjAwELt378aVK1dKdDkFfV6L+v1d7J4cb2/vPIOH3iSTyTBnzhzMmTPnnXXMzc3x66+/FricOnXqqNyTID/du3dH9+7dC24wERERvbeFCxeiVatWMDQ0xIEDBxAeHq7SS/MpK1NXVxGpE3vuiOhT07Zt23d2KEybNg3Tpk3DhQsXMH/+fDx79gyVKlXC0qVLMXTo0I/c0vfDkENERGVOcX7WQMrWrl2Lly9f5jvN3NwcALBt27YC5xEYGIjAwMCSblqJYMghIiIqo96+z4/UlOgl5ERE9Okr5vUmRGpREp9ThhwiojJCeWfcjIwMNbeEqHDKz+nbd3QuDp6uIiIqIzQ1NSGXy8W7zhsYGOS5qRuRugmCgIyMDCQlJUEul+f5OYriYMghIipDlHegffvndYg+NXK5/IN/3JMhh4ioDJHJZLC1tYWVldVH+YFEovehra39QT04Sgw5RERlkKamZol8iRB9yjjwmIiIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCRJS90NICKSIscpEWpb9v0ffNW2bKJPCXtyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSSjzk5ObmYsaMGXBycoK+vj4qV66M7777DoIgiHUEQcDMmTNha2sLfX19tGzZEnfu3FGZT3JyMvr27QsTExPI5XL4+fnh+fPnKnWuXbsGT09P6Onpwd7eHvPnzy/p1SEiIqLPVImHnODgYKxatQrLly9HTEwMgoODMX/+fCxbtkysM3/+fCxduhSrV6/G+fPnYWhoCB8fH2RmZop1+vbti5s3byIyMhL79u3DyZMnMXz4cHF6eno6WrduDQcHB0RHR2PBggUIDAzEmjVrSnqViIiI6DOkVdIzPHPmDDp27AhfX18AgKOjIzZv3owLFy4AeN2Ls2TJEkyfPh0dO3YEAKxfvx7W1tbYvXs3evXqhZiYGBw8eBAXL15EgwYNAADLli1Du3btsHDhQtjZ2WHTpk3Izs7GL7/8Ah0dHdSsWRNXrlzBokWLVMIQERERlU0l3pPTqFEjHDlyBLdv3wYAXL16FX/++Sfatm0LAIiLi0NCQgJatmwpvsbU1BTu7u44e/YsAODs2bOQy+ViwAGAli1bQkNDA+fPnxfrNG3aFDo6OmIdHx8fxMbGIiUlJd+2ZWVlIT09XeVBRERE0lTiPTlTpkxBeno6qlevDk1NTeTm5uL7779H3759AQAJCQkAAGtra5XXWVtbi9MSEhJgZWWl2lAtLZibm6vUcXJyyjMP5TQzM7M8bQsKCsLs2bNLYC2JiIjoU1fiPTnbtm3Dpk2b8Ouvv+LSpUsIDw/HwoULER4eXtKLKrapU6ciLS1NfDx8+FDdTSIiIqJSUuI9OZMmTcKUKVPQq1cvAEDt2rXx4MEDBAUFYeDAgbCxsQEAJCYmwtbWVnxdYmIiXF1dAQA2NjZISkpSme+rV6+QnJwsvt7GxgaJiYkqdZTPlXXepqurC11d3Q9fSSIiIvrklXhPTkZGBjQ0VGerqakJhUIBAHBycoKNjQ2OHDkiTk9PT8f58+fh4eEBAPDw8EBqaiqio6PFOkePHoVCoYC7u7tY5+TJk8jJyRHrREZGolq1avmeqiIiIqKypcRDTocOHfD9998jIiIC9+/fx65du7Bo0SJ07twZACCTyTB27FjMnTsXe/bswfXr1zFgwADY2dmhU6dOAIAaNWqgTZs2GDZsGC5cuIDTp08jICAAvXr1gp2dHQCgT58+0NHRgZ+fH27evImtW7ciNDQU48ePL+lVIiIios9QiZ+uWrZsGWbMmIFRo0YhKSkJdnZ2GDFiBGbOnCnW+fbbb/HixQsMHz4cqampaNKkCQ4ePAg9PT2xzqZNmxAQEIAWLVpAQ0MDXbt2xdKlS8XppqamOHz4MPz9/VG/fn1YWFhg5syZvHyciIiIAAAy4c1bEZcx6enpMDU1RVpaGkxMTD768h2nRHz0ZSrd/8FXbcsuq7i9yxZub6LSU9Tvb/52FREREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJkpa6G0BEH0GgqRqXnaa+ZRNRmcaeHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpKkUgk5//zzD/r164dy5cpBX18ftWvXRlRUlDhdEATMnDkTtra20NfXR8uWLXHnzh2VeSQnJ6Nv374wMTGBXC6Hn58fnj9/rlLn2rVr8PT0hJ6eHuzt7TF//vzSWB0iIiL6DJV4yElJSUHjxo2hra2NAwcO4NatWwgJCYGZmZlYZ/78+Vi6dClWr16N8+fPw9DQED4+PsjMzBTr9O3bFzdv3kRkZCT27duHkydPYvjw4eL09PR0tG7dGg4ODoiOjsaCBQsQGBiINWvWlPQqERER0WdIq6RnGBwcDHt7e4SFhYllTk5O4t+CIGDJkiWYPn06OnbsCABYv349rK2tsXv3bvTq1QsxMTE4ePAgLl68iAYNGgAAli1bhnbt2mHhwoWws7PDpk2bkJ2djV9++QU6OjqoWbMmrly5gkWLFqmEISIiIiqbSrwnZ8+ePWjQoAG6d+8OKysr1K1bFz/99JM4PS4uDgkJCWjZsqVYZmpqCnd3d5w9exYAcPbsWcjlcjHgAEDLli2hoaGB8+fPi3WaNm0KHR0dsY6Pjw9iY2ORkpKSb9uysrKQnp6u8iAiIiJpKvGQc+/ePaxatQrOzs44dOgQvv76a4wZMwbh4eEAgISEBACAtbW1yuusra3FaQkJCbCyslKZrqWlBXNzc5U6+c3jzWW8LSgoCKampuLD3t7+A9eWiIiIPlUlHnIUCgXq1auHefPmoW7duhg+fDiGDRuG1atXl/Siim3q1KlIS0sTHw8fPlR3k4iIiKiUlHjIsbW1hYuLi0pZjRo1EB8fDwCwsbEBACQmJqrUSUxMFKfZ2NggKSlJZfqrV6+QnJysUie/eby5jLfp6urCxMRE5UFERETSVOIhp3HjxoiNjVUpu337NhwcHAC8HoRsY2ODI0eOiNPT09Nx/vx5eHh4AAA8PDyQmpqK6Ohosc7Ro0ehUCjg7u4u1jl58iRycnLEOpGRkahWrZrKlVxERERUNpV4yBk3bhzOnTuHefPm4e+//8avv/6KNWvWwN/fHwAgk8kwduxYzJ07F3v27MH169cxYMAA2NnZoVOnTgBe9/y0adMGw4YNw4ULF3D69GkEBASgV69esLOzAwD06dMHOjo68PPzw82bN7F161aEhoZi/PjxJb1KRERE9Bkq8UvIv/zyS+zatQtTp07FnDlz4OTkhCVLlqBv375inW+//RYvXrzA8OHDkZqaiiZNmuDgwYPQ09MT62zatAkBAQFo0aIFNDQ00LVrVyxdulScbmpqisOHD8Pf3x/169eHhYUFZs6cycvHiYiICAAgEwRBUHcj1CU9PR2mpqZIS0tTy/gcxykRH32ZSvd/8FXbsssqtW5vvT5qWzYC09S3bDXi/k1Ueor6/c3friIiIiJJYsghIiIiSWLIISIiIkliyCEiIiJJYsghIiIiSWLIISIiIkkq8fvkEBERlTW8ZcCniT05REREJEkMOURERCRJDDlEREQkSQw5REREJEkMOURERCRJDDlEREQkSQw5REREJEkMOURERCRJDDlEREQkSQw5REREJEkMOURERCRJDDlEREQkSQw5REREJEkMOURERCRJDDlEREQkSQw5REREJEkMOURERCRJDDlEREQkSVrqbgCpSaCpGpedpr5lExFRmcGeHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSJIYcIiIikiSGHCIiIpIkhhwiIiKSpFIPOT/88ANkMhnGjh0rlmVmZsLf3x/lypWDkZERunbtisTERJXXxcfHw9fXFwYGBrCyssKkSZPw6tUrlTrHjx9HvXr1oKuriypVqmDdunWlvTpERET0mSjVkHPx4kX8+OOPqFOnjkr5uHHjsHfvXmzfvh0nTpzA48eP0aVLF3F6bm4ufH19kZ2djTNnziA8PBzr1q3DzJkzxTpxcXHw9fVFs2bNcOXKFYwdOxZDhw7FoUOHSnOViIiI6DNRaiHn+fPn6Nu3L3766SeYmZmJ5Wlpafj555+xaNEiNG/eHPXr10dYWBjOnDmDc+fOAQAOHz6MW7duYePGjXB1dUXbtm3x3XffYcWKFcjOzgYArF69Gk5OTggJCUGNGjUQEBCAbt26YfHixaW1SkRERPQZKbWQ4+/vD19fX7Rs2VKlPDo6Gjk5OSrl1atXR8WKFXH27FkAwNmzZ1G7dm1YW1uLdXx8fJCeno6bN2+Kdd6et4+PjziP/GRlZSE9PV3lQURERNKkVRoz3bJlCy5duoSLFy/mmZaQkAAdHR3I5XKVcmtrayQkJIh13gw4yunKaQXVSU9Px8uXL6Gvr59n2UFBQZg9e/Z7rxcRERF9Pkq8J+fhw4f45ptvsGnTJujp6ZX07D/I1KlTkZaWJj4ePnyo7iYRERFRKSnxkBMdHY2kpCTUq1cPWlpa0NLSwokTJ7B06VJoaWnB2toa2dnZSE1NVXldYmIibGxsAAA2NjZ5rrZSPi+sjomJSb69OACgq6sLExMTlQcRERFJU4mHnBYtWuD69eu4cuWK+GjQoAH69u0r/q2trY0jR46Ir4mNjUV8fDw8PDwAAB4eHrh+/TqSkpLEOpGRkTAxMYGLi4tY5815KOso50FERERlW4mPyTE2NkatWrVUygwNDVGuXDmx3M/PD+PHj4e5uTlMTEwwevRoeHh4oGHDhgCA1q1bw8XFBf3798f8+fORkJCA6dOnw9/fH7q6ugCAkSNHYvny5fj2228xZMgQHD16FNu2bUNERERJrxIRERF9hkpl4HFhFi9eDA0NDXTt2hVZWVnw8fHBypUrxemamprYt28fvv76a3h4eMDQ0BADBw7EnDlzxDpOTk6IiIjAuHHjEBoaigoVKmDt2rXw8fFRxyoRERHRJ+ajhJzjx4+rPNfT08OKFSuwYsWKd77GwcEB+/fvL3C+3t7euHz5ckk0kYiIiCSGv11FREREksSQQ0RERJLEkENERESSxJBDREREksSQQ0RERJLEkENERESSxJBDREREksSQQ0RERJLEkENERESSxJBDREREksSQQ0RERJLEkENERESSxJBDREREksSQQ0RERJLEkENERESSpKXuBhARUQkLNFXjstPUt2yit7Anh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkib9dRURE9Dnjb5W9E3tyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkhhyiIiISJIYcoiIiEiSGHKIiIhIkko85AQFBeHLL7+EsbExrKys0KlTJ8TGxqrUyczMhL+/P8qVKwcjIyN07doViYmJKnXi4+Ph6+sLAwMDWFlZYdKkSXj16pVKnePHj6NevXrQ1dVFlSpVsG7dupJeHSIiIvpMlXjIOXHiBPz9/XHu3DlERkYiJycHrVu3xosXL8Q648aNw969e7F9+3acOHECjx8/RpcuXcTpubm58PX1RXZ2Ns6cOYPw8HCsW7cOM2fOFOvExcXB19cXzZo1w5UrVzB27FgMHToUhw4dKulVIiIios+QVknP8ODBgyrP161bBysrK0RHR6Np06ZIS0vDzz//jF9//RXNmzcHAISFhaFGjRo4d+4cGjZsiMOHD+PWrVv4448/YG1tDVdXV3z33XeYPHkyAgMDoaOjg9WrV8PJyQkhISEAgBo1auDPP//E4sWL4ePjk2/bsrKykJWVJT5PT08v6dUnIiKiT0Spj8lJS0sDAJibmwMAoqOjkZOTg5YtW4p1qlevjooVK+Ls2bMAgLNnz6J27dqwtrYW6/j4+CA9PR03b94U67w5D2Ud5TzyExQUBFNTU/Fhb29fMitJREREn5xSDTkKhQJjx45F48aNUatWLQBAQkICdHR0IJfLVepaW1sjISFBrPNmwFFOV04rqE56ejpevnyZb3umTp2KtLQ08fHw4cMPXkciIiL6NJX46ao3+fv748aNG/jzzz9LczFFpqurC11dXXU3g4iIiD6CUuvJCQgIwL59+3Ds2DFUqFBBLLexsUF2djZSU1NV6icmJsLGxkas8/bVVsrnhdUxMTGBvr5+Sa8OERERfWZKPOQIgoCAgADs2rULR48ehZOTk8r0+vXrQ1tbG0eOHBHLYmNjER8fDw8PDwCAh4cHrl+/jqSkJLFOZGQkTExM4OLiItZ5cx7KOsp5EBERUdlW4qer/P398euvv+L333+HsbGxOIbG1NQU+vr6MDU1hZ+fH8aPHw9zc3OYmJhg9OjR8PDwQMOGDQEArVu3houLC/r374/58+cjISEB06dPh7+/v3i6aeTIkVi+fDm+/fZbDBkyBEePHsW2bdsQERFR0qtEREREn6ES78lZtWoV0tLS4O3tDVtbW/GxdetWsc7ixYvRvn17dO3aFU2bNoWNjQ127twpTtfU1MS+ffugqakJDw8P9OvXDwMGDMCcOXPEOk5OToiIiEBkZCS++OILhISEYO3ate+8fJyIiIjKlhLvyREEodA6enp6WLFiBVasWPHOOg4ODti/f3+B8/H29sbly5eL3UYiIiKSPv52FREREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSdJnH3JWrFgBR0dH6Onpwd3dHRcuXFB3k4iIiOgT8FmHnK1bt2L8+PGYNWsWLl26hC+++AI+Pj5ISkpSd9OIiIhIzT7rkLNo0SIMGzYMgwcPhouLC1avXg0DAwP88ssv6m4aERERqZmWuhvwvrKzsxEdHY2pU6eKZRoaGmjZsiXOnj2b72uysrKQlZUlPk9LSwMApKenl25j30GRlaGW5QJAukxQ27Khpvdb3bi9yxZu77KF2/tjL/b1cgWh4HX/bEPOv//+i9zcXFhbW6uUW1tb46+//sr3NUFBQZg9e3aecnt7+1Jp46fMVJ0L/0GtSy+TuL3LFm7vsqUsb+9nz57B1PTdbfhsQ877mDp1KsaPHy8+VygUSE5ORrly5SCTydTYso8rPT0d9vb2ePjwIUxMTNTdHCpl3N5lC7d32VJWt7cgCHj27Bns7OwKrPfZhhwLCwtoamoiMTFRpTwxMRE2Njb5vkZXVxe6uroqZXK5vLSa+MkzMTEpUztFWcftXbZwe5ctZXF7F9SDo/TZDjzW0dFB/fr1ceTIEbFMoVDgyJEj8PDwUGPLiIiI6FPw2fbkAMD48eMxcOBANGjQAG5ubliyZAlevHiBwYMHq7tpREREpGafdcjp2bMnnj59ipkzZyIhIQGurq44ePBgnsHIpEpXVxezZs3Kc+qOpInbu2zh9i5buL0LJhMKu/6KiIiI6DP02Y7JISIiIioIQw4RERFJEkMOERERSRJDDhEREUkSQw4RERFJEkMOERERSdJnfZ8cKp6oqCjExMQAAGrUqIEGDRqouUVERFRcubm52LVrl8rxvFOnTtDS4lf623ifnDLg0aNH6N27N06fPi3+VldqaioaNWqELVu2oEKFCuptIJW4HTt2YNu2bYiPj0d2drbKtEuXLqmpVVRaoqKi3rm9d+7cqaZWUWm4efMmvvrqKyQkJKBatWoAgNu3b8PS0hJ79+5FrVq11NzCTwtPV5UBQ4cORU5ODmJiYpCcnIzk5GTExMRAoVBg6NCh6m4elbClS5di8ODBsLa2xuXLl+Hm5oZy5crh3r17aNu2rbqbRyVsy5YtaNSoEWJiYrBr1y7k5OTg5s2bOHr0aJF+wJA+L0OHDkXNmjXx6NEjXLp0CZcuXcLDhw9Rp04dDB8+XN3N++SwJ6cM0NfXx5kzZ1C3bl2V8ujoaHh6eiIjI0NNLaPSUL16dcyaNQu9e/eGsbExrl69ikqVKmHmzJlITk7G8uXL1d1EKkF16tTBiBEj4O/vL25vJycnjBgxAra2tpg9e7a6m0glSF9fH1FRUahZs6ZK+Y0bN/Dll1/i5cuXamrZp4k9OWWAvb09cnJy8pTn5ubCzs5ODS2i0hQfH49GjRoBeH1AfPbsGQCgf//+2Lx5szqbRqXg7t278PX1BQDo6OjgxYsXkMlkGDduHNasWaPm1lFJq1q1KhITE/OUJyUloUqVKmpo0aeNIacMWLBgAUaPHo2oqCixLCoqCt988w0WLlyoxpZRabCxsUFycjIAoGLFijh37hwAIC4uDuy4lR4zMzMxyJYvXx43btwA8HrcHXtppSE9PV18BAUFYcyYMdixYwcePXqER48eYceOHRg7diyCg4PV3dRPDk9XSZSZmRlkMpn4/MWLF3j16pU4+l75t6GhofiFSNIwdOhQ2NvbY9asWVixYgUmTZqExo0bIyoqCl26dMHPP/+s7iZSCerTpw8aNGiA8ePH47vvvsOyZcvQsWNHREZGol69ehx4LAEaGhoqx3Pl17ay7M3nubm5H7+BnzCGHIkKDw8vct2BAweWYkvoY1MoFFAoFGKg3bJlC86cOQNnZ2eMGDECOjo6am4hlaTk5GRkZmbCzs4OCoUC8+fPF7f39OnTYWZmpu4m0gc6ceJEket6eXmVYks+Pww5REREJEkck1MGvN19ef78eZw8eTLfwcgkPc2bN8eDBw/U3QwqJdy/yzbu3wXj7REl7MmTJ+jWrRvOnz+Pxo0bY/fu3ejfvz/2798PAHB2dsbx48dha2ur5pZSSdizZ0++5SdPnsS+fftgb28PAPjqq68+ZrOolDx58gTdu3fHuXPnuH+XAdy/3w9PV0nYgAEDcPfuXUyZMgWbNm3Cw4cPoampic2bNyM3Nxd9+vSBq6sr75siEcrBiQXt0hyYKB3cv8sW7t/vhyFHwuzs7LBz5040bNgQycnJsLCwQGRkJFq0aAEAOHr0KIYNG4a7d++quaVUEtq2bQtNTU388ssvsLKyEsu1tbVx9epVuLi4qLF1VNK4f5ct3L/fD8fkSFhKSgrKly8PADA3N4eBgQEcHBzE6VWqVMGTJ0/U1TwqYQcOHECLFi3QoEED7Nu3T93NoVLG/bts4f79fhhyJMzKykrlIBcQEABzc3PxeUpKCgwNDdXRNCol48aNw549ezB58mSMGDGCN4OTMO7fZQ/37+JjyJEwV1dXnD17Vnz+ww8/qBwE//zzT9SpU0cdTaNS5OrqiqioKMhkMri6uvIuxxLF/bts4v5dPByTU4ZduHABBgYGqFWrlrqbQqVkz549OHbsGKZOnapyHp+kj/u39HH/LhxDDhEREUkST1eVAY8ePcLz58/zlOfk5ODkyZNqaBGpQ2JiIubMmaPuZlAJ4/5NAPfvd2HIkbAnT57Azc0NDg4OkMvlGDBggMrBMDk5Gc2aNVNjC+ljSkhIwOzZs9XdDCoh3L/pTdy/88c7HkvYlClToKGhgfPnzyM1NRVTpkxBs2bNcPjwYfFH+3i2UjquXbtW4PTY2NiP1BL6GLh/ly3cv98Px+RIWPny5bFr1y64ubkBALKystC9e3c8fPgQR44cQU5ODuzs7HiHTIko6I6oynLeEVU6uH+XLdy/3w9PV0lYWlqa+B8dAOjq6mLnzp1wdHREs2bNkJSUpMbWUUkzNzfHTz/9hLi4uDyPe/fu8QZiEsP9u2zh/v1+eLpKwipVqoRr167B2dlZLNPS0sL27dvRvXt3tG/fXo2to5JWv359PH78WOWut29KTU3l6QsJ4f5dtnD/fj/syZGwtm3bYs2aNXnKlQdC3khKWkaOHAlHR8d3Tq9YsSLCwsI+XoOoVHH/Llu4f78fjsmRsFevXiEjIwMmJibvnP7PP/+88z8DIvp0cf8mKhxDThkwfvz4ItddtGhRKbaEPgZu77KF27ts4fYuHo7JKQMuX76My5cvIycnB9WqVQMA3L59G5qamqhXr55YTyaTqauJVIK4vcsWbu+yhdu7eBhyyoAOHTrA2NgY4eHh4tUYKSkpGDx4MDw9PTFhwgQ1t5BKErd32cLtXbZwexcPT1eVAeXLl8fhw4dRs2ZNlfIbN26gdevWePz4sZpaRqWB27ts4fYuW7i9i4dXV5UB6enpePr0aZ7yp0+f4tmzZ2poEZUmbu+yhdu7bOH2Lh6GnDKgc+fOGDx4MHbu3IlHjx7h0aNH+O233+Dn54cuXbqou3lUwri9yxZu77KF27uYBJK8Fy9eCF9//bWgq6sraGhoCBoaGoKOjo7w9ddfC8+fP1d386iEcXuXLdzeZQu3d/FwTE4Z8uLFC9y9excAULlyZRgaGqq5RVSauL3LFm7vsoXbu2gYcoiIiEiSOCaHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiIiIJIkhh4iIiCSJIYeIiIgkiSGHiMq87OxsdTeBiEoBQw4RfVJevHiBAQMGwMjICLa2tggJCYG3tzfGjh0LAJDJZNi9e7fKa+RyOdatWyc+f/jwIXr06AG5XA5zc3N07NgR9+/fF6cPGjQInTp1wvfffw87OztUq1YNc+bMQa1atfK0x9XVFTNmzCiFNSWi0saQQ0SflEmTJuHEiRP4/fffcfjwYRw/fhyXLl0q8utzcnLg4+MDY2NjnDp1CqdPn4aRkRHatGmj0mNz5MgRxMbGIjIyEvv27cOQIUMQExODixcvinUuX76Ma9euYfDgwSW6jkT0cWipuwFERErPnz/Hzz//jI0bN6JFixYAgPDwcFSoUKHI89i6dSsUCgXWrl0LmUwGAAgLC4NcLsfx48fRunVrAIChoSHWrl0LHR0d8bU+Pj4ICwvDl19+Kb7Oy8sLlSpVKqlVJKKPiD05RPTJuHv3LrKzs+Hu7i6WmZubo1q1akWex9WrV/H333/D2NgYRkZGMDIygrm5OTIzM8Xf+gGA2rVrqwQcABg2bBg2b96MzMxMZGdn49dff8WQIUM+fMWISC3Yk0NEnxWZTIa3f3IvJydH/Pv58+eoX78+Nm3alOe1lpaW4t/5/aBhhw4doKuri127dkFHRwc5OTno1q1bCbaeiD4mhhwi+mRUrlwZ2traOH/+PCpWrAgASElJwe3bt+Hl5QXgdVB58uSJ+Jo7d+4gIyNDfF6vXj1s3boVVlZWMDExKdbytbS0MHDgQISFhUFHRwe9evWCvr5+CawZEakDT1cR0SfDyMgIfn5+mDRpEo4ePYobN25g0KBB0ND4/4eq5s2bY/ny5bh8+TKioqIwcuRIaGtri9P79u0LCwsLdOzYEadOnUJcXByOHz+OMWPG4NGjR4W2YejQoTh69CgOHjzIU1VEnzn25BDRJ2XBggV4/vw5OnToAGNjY0yYMAFpaWni9JCQEAwePBienp6ws7NDaGgooqOjxekGBgY4efIkJk+ejC5duuDZs2coX748WrRoUaSeHWdnZzRq1AjJyckqY4OI6PMjE94+uU1E9Inx9vaGq6srlixZUurLEgQBzs7OGDVqFMaPH1/qyyOi0sOeHCKi//P06VNs2bIFCQkJvDcOkQQw5BAR/R8rKytYWFhgzZo1MDMzU3dziOgD8XQVERERSRKvriIiIiJJYsghIiIiSWLIISIiIkliyCEiIiJJYsghIiIiSWLIISIiIkliyCEiIiJJYsghIiIiSfp/AxWA0YqTQscAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -1274,7 +1273,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1300,13 +1299,13 @@ "" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1330,7 +1329,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 23, "metadata": { "executionInfo": { "elapsed": 4, @@ -1353,7 +1352,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 24, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1509,7 +1508,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 25, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1538,22 +1537,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "[Stage 448:>(5 + 59) / 64][Stage 450:> (0 + 1) / 1][Stage 452:> (0 + 1) / 1]\r" + " \r" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 4.61 ms, sys: 1.07 ms, total: 5.69 ms\n", - "Wall time: 2.01 s\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " \r" + "CPU times: user 2.45 ms, sys: 1.97 ms, total: 4.43 ms\n", + "Wall time: 1.66 s\n" ] }, { @@ -1562,7 +1554,7 @@ "[Row(h8_30_to_9=18440, h9_to_9_30=39156, h9_30_to_10=38666, h10_to_10_30=58037, h10_30_to_11=58313, h11_to_11_30=34436, h11_30_to_12=33322, h12_to_12_30=39142)]" ] }, - "execution_count": 19, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }