From 8d2c661877a34b98208d0bc81311b7ad13c6a425 Mon Sep 17 00:00:00 2001 From: Nathan Smith Date: Sat, 11 Jan 2025 07:35:25 -0600 Subject: [PATCH 01/13] broadcast before joining --- .../bipartite/grouping.py | 5 +-- .../monopartite/batching.py | 4 +-- .../monopartite/grouping.py | 35 ++++++++++++------- .../predefined_components/grouping.py | 3 +- 4 files changed, 29 insertions(+), 18 deletions(-) diff --git a/neo4j_parallel_spark_loader/bipartite/grouping.py b/neo4j_parallel_spark_loader/bipartite/grouping.py index 72b3141..9dfd296 100644 --- a/neo4j_parallel_spark_loader/bipartite/grouping.py +++ b/neo4j_parallel_spark_loader/bipartite/grouping.py @@ -1,4 +1,5 @@ from pyspark.sql import DataFrame +from pyspark.sql.functions import broadcast from ..utils.grouping import ( create_group_column_from_source_and_target_groups, @@ -60,12 +61,12 @@ def create_node_groupings( ) final_sdf = spark_dataframe.join( - other=source_groupings_sdf.withColumnRenamed("group", "source_group"), + other=broadcast(source_groupings_sdf.withColumnRenamed("group", "source_group")), on=(spark_dataframe[source_col] == source_groupings_sdf.value), how="left", ).drop(source_groupings_sdf.value) final_sdf = final_sdf.join( - other=target_groupings_sdf.withColumnRenamed("group", "target_group"), + other=broadcast(target_groupings_sdf.withColumnRenamed("group", "target_group")), on=(spark_dataframe[target_col] == target_groupings_sdf.value), how="left", ).drop(target_groupings_sdf.value) diff --git a/neo4j_parallel_spark_loader/monopartite/batching.py b/neo4j_parallel_spark_loader/monopartite/batching.py index ebb683d..955ac8e 100644 --- a/neo4j_parallel_spark_loader/monopartite/batching.py +++ b/neo4j_parallel_spark_loader/monopartite/batching.py @@ -1,7 +1,7 @@ from typing import Dict, Tuple from pyspark.sql import DataFrame, SparkSession -from pyspark.sql.functions import col +from pyspark.sql.functions import broadcast def create_ingest_batches_from_groups(spark_dataframe: DataFrame) -> DataFrame: @@ -39,7 +39,7 @@ def create_ingest_batches_from_groups(spark_dataframe: DataFrame) -> DataFrame: # Join the DataFrames result_df = spark_dataframe.join( - other=coloring_df, + other=broadcast(coloring_df), on=(spark_dataframe.group == coloring_df.group), how="left", # Use left join to keep all records from spark_dataframe ).drop( diff --git a/neo4j_parallel_spark_loader/monopartite/grouping.py b/neo4j_parallel_spark_loader/monopartite/grouping.py index 59f44b2..5a26c5e 100644 --- a/neo4j_parallel_spark_loader/monopartite/grouping.py +++ b/neo4j_parallel_spark_loader/monopartite/grouping.py @@ -1,5 +1,5 @@ from pyspark.sql import DataFrame -from pyspark.sql.functions import col, concat, greatest, least, lit +from pyspark.sql.functions import broadcast, concat, greatest, least, lit from ..utils.grouping import ( create_value_groupings, @@ -50,18 +50,27 @@ def create_node_groupings( grouping_column="combined_col", ) - final_sdf = spark_dataframe.join( - other=keys_sdf.withColumnRenamed("group", "source_group"), - on=(spark_dataframe[source_col] == keys_sdf.value), - how="left", - ).drop(keys_sdf.value) - final_sdf = final_sdf.join( - other=keys_sdf.withColumnRenamed("group", "target_group"), - on=(spark_dataframe[target_col] == keys_sdf.value), - how="left", - ).drop(keys_sdf.value) - - final_sdf = final_sdf.drop("value") + # Broadcast keys_sdf once + broadcasted_keys = broadcast(keys_sdf) + + # Create two views of the same broadcasted DataFrame + source_keys = broadcasted_keys.withColumnRenamed("group", "source_group") + target_keys = broadcasted_keys.withColumnRenamed("group", "target_group") + + final_sdf = (spark_dataframe + .join( + other=source_keys, + on=(spark_dataframe[source_col] == source_keys.value), + how="left" + ) + .drop(source_keys.value) + .join( + other=target_keys, + on=(spark_dataframe[target_col] == target_keys.value), + how="left" + ) + .drop(target_keys.value) + .drop("value")) final_sdf = final_sdf.withColumn( "group", diff --git a/neo4j_parallel_spark_loader/predefined_components/grouping.py b/neo4j_parallel_spark_loader/predefined_components/grouping.py index 020d769..e332130 100644 --- a/neo4j_parallel_spark_loader/predefined_components/grouping.py +++ b/neo4j_parallel_spark_loader/predefined_components/grouping.py @@ -1,4 +1,5 @@ from pyspark.sql import DataFrame +from pyspark.sql.functions import broadcast from ..utils.grouping import create_value_counts_dataframe, create_value_groupings from ..utils.verify_spark import verify_spark_version @@ -44,7 +45,7 @@ def create_node_groupings( ) final_sdf = spark_dataframe.join( - other=value_groupings_sdf, + other=broadcast(value_groupings_sdf), on=(spark_dataframe[partition_col] == value_groupings_sdf.value), how="left", ).drop(value_groupings_sdf.value) From 1b56c499d5144f4e5c8926f28f7a286b36508e28 Mon Sep 17 00:00:00 2001 From: Nathan Smith Date: Sat, 11 Jan 2025 07:53:54 -0600 Subject: [PATCH 02/13] Rely on autobroadcasting for grouping tables. --- .../bipartite/grouping.py | 5 ++--- .../monopartite/grouping.py | 21 +++++++------------ .../predefined_components/grouping.py | 3 +-- 3 files changed, 10 insertions(+), 19 deletions(-) diff --git a/neo4j_parallel_spark_loader/bipartite/grouping.py b/neo4j_parallel_spark_loader/bipartite/grouping.py index 9dfd296..72b3141 100644 --- a/neo4j_parallel_spark_loader/bipartite/grouping.py +++ b/neo4j_parallel_spark_loader/bipartite/grouping.py @@ -1,5 +1,4 @@ from pyspark.sql import DataFrame -from pyspark.sql.functions import broadcast from ..utils.grouping import ( create_group_column_from_source_and_target_groups, @@ -61,12 +60,12 @@ def create_node_groupings( ) final_sdf = spark_dataframe.join( - other=broadcast(source_groupings_sdf.withColumnRenamed("group", "source_group")), + other=source_groupings_sdf.withColumnRenamed("group", "source_group"), on=(spark_dataframe[source_col] == source_groupings_sdf.value), how="left", ).drop(source_groupings_sdf.value) final_sdf = final_sdf.join( - other=broadcast(target_groupings_sdf.withColumnRenamed("group", "target_group")), + other=target_groupings_sdf.withColumnRenamed("group", "target_group"), on=(spark_dataframe[target_col] == target_groupings_sdf.value), how="left", ).drop(target_groupings_sdf.value) diff --git a/neo4j_parallel_spark_loader/monopartite/grouping.py b/neo4j_parallel_spark_loader/monopartite/grouping.py index 5a26c5e..fce2266 100644 --- a/neo4j_parallel_spark_loader/monopartite/grouping.py +++ b/neo4j_parallel_spark_loader/monopartite/grouping.py @@ -1,5 +1,5 @@ from pyspark.sql import DataFrame -from pyspark.sql.functions import broadcast, concat, greatest, least, lit +from pyspark.sql.functions import concat, greatest, least, lit from ..utils.grouping import ( create_value_groupings, @@ -50,26 +50,19 @@ def create_node_groupings( grouping_column="combined_col", ) - # Broadcast keys_sdf once - broadcasted_keys = broadcast(keys_sdf) - - # Create two views of the same broadcasted DataFrame - source_keys = broadcasted_keys.withColumnRenamed("group", "source_group") - target_keys = broadcasted_keys.withColumnRenamed("group", "target_group") - final_sdf = (spark_dataframe .join( - other=source_keys, - on=(spark_dataframe[source_col] == source_keys.value), + other=keys_sdf.withColumnRenamed("group", "source_group"), + on=(spark_dataframe[source_col] == keys_sdf.value), how="left" ) - .drop(source_keys.value) + .drop(keys_sdf.value) .join( - other=target_keys, - on=(spark_dataframe[target_col] == target_keys.value), + other=keys_sdf.withColumnRenamed("group", "source_group"), + on=(spark_dataframe[target_col] == keys_sdf.value), how="left" ) - .drop(target_keys.value) + .drop(keys_sdf.value) .drop("value")) final_sdf = final_sdf.withColumn( diff --git a/neo4j_parallel_spark_loader/predefined_components/grouping.py b/neo4j_parallel_spark_loader/predefined_components/grouping.py index e332130..020d769 100644 --- a/neo4j_parallel_spark_loader/predefined_components/grouping.py +++ b/neo4j_parallel_spark_loader/predefined_components/grouping.py @@ -1,5 +1,4 @@ from pyspark.sql import DataFrame -from pyspark.sql.functions import broadcast from ..utils.grouping import create_value_counts_dataframe, create_value_groupings from ..utils.verify_spark import verify_spark_version @@ -45,7 +44,7 @@ def create_node_groupings( ) final_sdf = spark_dataframe.join( - other=broadcast(value_groupings_sdf), + other=value_groupings_sdf, on=(spark_dataframe[partition_col] == value_groupings_sdf.value), how="left", ).drop(value_groupings_sdf.value) From ea93bca7b6ebd7c8568618c3f2a04ff5679c9988 Mon Sep 17 00:00:00 2001 From: Nathan Smith Date: Sat, 11 Jan 2025 07:55:13 -0600 Subject: [PATCH 03/13] Count groups by batch --- neo4j_parallel_spark_loader/utils/ingest.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/neo4j_parallel_spark_loader/utils/ingest.py b/neo4j_parallel_spark_loader/utils/ingest.py index 179463a..991d27a 100644 --- a/neo4j_parallel_spark_loader/utils/ingest.py +++ b/neo4j_parallel_spark_loader/utils/ingest.py @@ -67,10 +67,9 @@ def ingest_spark_dataframe( for batch_value in batch_list ] - num_groups = spark_dataframe.select("group").distinct().count() - # write batches serially to Neo4j database for batch in batches: + num_groups = batch.select("group").distinct().count() ( batch.repartition(num_groups, "group") # define parallel groups for ingest .write.mode(save_mode) From 30471bcddde99f26ca6c80f4d49da32f6853a2d1 Mon Sep 17 00:00:00 2001 From: Nathan Smith Date: Sat, 11 Jan 2025 09:31:18 -0600 Subject: [PATCH 04/13] Add twitch_gamers example --- examples/twitch_gamers.ipynb | 876 +++++++++++++++++++++++++++++++++++ 1 file changed, 876 insertions(+) create mode 100644 examples/twitch_gamers.ipynb diff --git a/examples/twitch_gamers.ipynb b/examples/twitch_gamers.ipynb new file mode 100644 index 0000000..1531eb5 --- /dev/null +++ b/examples/twitch_gamers.ipynb @@ -0,0 +1,876 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T14:49:41.2174665Z", + "execution_start_time": "2025-01-11T14:49:40.6965287Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "20a7c7a6-49c7-4b5a-9f32-5b15f0e51019", + "queued_time": "2025-01-11T14:48:11.9992599Z", + "session_id": "18", + "session_start_time": "2025-01-11T14:48:12.0369851Z", + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 2, + "statement_ids": [ + 2 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 2, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pyspark.sql import SparkSession\n", + "import requests\n", + "from io import BytesIO\n", + "from zipfile import ZipFile\n", + "from neo4j_parallel_spark_loader.monopartite import group_and_batch_spark_dataframe\n", + "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Create spark session" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T14:49:41.5117197Z", + "execution_start_time": "2025-01-11T14:49:41.3585458Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "769d32ac-fec7-4674-b91c-561e4424b35a", + "queued_time": "2025-01-11T14:48:28.1869292Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 3, + "statement_ids": [ + 3 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 3, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "username = \"NEO4J_USER_NAME\"\n", + "password = \"NEO4J_PASSWORD\"\n", + "url = \"NEO4J_URL\"\n", + "dbname = \"NEO4J_DB\"\n", + "spark_executor_count = 5\n", + "\n", + "\n", + "spark = (\n", + " SparkSession.builder\n", + " .appName(\"TwitchGamers\")\n", + " .config(\"neo4j.url\", url)\n", + " .config(\"url\", url)\n", + " .config(\"neo4j.authentication.basic.username\", username)\n", + " .config(\"neo4j.authentication.basic.password\", password)\n", + " .config(\"neo4j.database\", dbname)\n", + " .getOrCreate()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Download data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T14:50:23.0615084Z", + "execution_start_time": "2025-01-11T14:49:55.5797104Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "2d565aae-42f2-4029-a551-702623320475", + "queued_time": "2025-01-11T14:49:55.4616629Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 4, + "statement_ids": [ + 4 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 4, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------+------------+\n", + "|numeric_id_1|numeric_id_2|\n", + "+------------+------------+\n", + "| 98343| 141493|\n", + "| 98343| 58736|\n", + "| 98343| 140703|\n", + "| 98343| 151401|\n", + "| 98343| 157118|\n", + "| 98343| 125430|\n", + "| 98343| 3635|\n", + "| 98343| 495|\n", + "| 98343| 116648|\n", + "| 98343| 1679|\n", + "| 98343| 123861|\n", + "| 98343| 89631|\n", + "| 98343| 113417|\n", + "| 98343| 145281|\n", + "| 98343| 10408|\n", + "| 98343| 3181|\n", + "| 98343| 40675|\n", + "| 98343| 95914|\n", + "| 98343| 155127|\n", + "| 98343| 124827|\n", + "+------------+------------+\n", + "only showing top 20 rows\n", + "\n", + "root\n", + " |-- numeric_id_1: string (nullable = true)\n", + " |-- numeric_id_2: string (nullable = true)\n", + "\n" + ] + } + ], + "source": [ + "# Download the ZIP file\n", + "response = requests.get(\"https://snap.stanford.edu/data/twitch_gamers.zip\")\n", + "zip_file = ZipFile(BytesIO(response.content))\n", + "\n", + "# Read the CSV file directly from the ZIP\n", + "with zip_file.open(\"large_twitch_edges.csv\") as file:\n", + " # Convert to string buffer for Spark to read\n", + " content = file.read().decode('utf-8')\n", + " \n", + " # Create RDD from content\n", + " rdd = spark.sparkContext.parallelize(content.splitlines())\n", + " \n", + " # Convert RDD to DataFrame\n", + " twitch_df = spark.read.csv(rdd, header=True)\n", + "\n", + "# Now df is your Spark DataFrame containing the data\n", + "# You can verify the data\n", + "twitch_df.show()\n", + "twitch_df.printSchema()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T14:50:40.3463803Z", + "execution_start_time": "2025-01-11T14:50:31.2930721Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "ec3dba3e-335f-4a2b-8f13-7f034153d961", + "queued_time": "2025-01-11T14:50:31.1556519Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 6, + "statement_ids": [ + 6 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 6, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "6797557" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "twitch_df.count()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Load nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T14:51:48.9139321Z", + "execution_start_time": "2025-01-11T14:51:42.0394455Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "5886e1ba-297a-42b5-8d17-7d141e9a261f", + "queued_time": "2025-01-11T14:51:41.8997493Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 9, + "statement_ids": [ + 9 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 9, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "168114" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_df = (twitch_df\n", + " .select('numeric_id_1')\n", + " .withColumnRenamed('numeric_id_1', 'nodeId')\n", + " .union(\n", + " twitch_df\n", + " .select('numeric_id_2')\n", + " .withColumnRenamed('numeric_id_2', 'nodeId'))\n", + " .dropDuplicates())\n", + "node_df.count()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T14:52:25.8382593Z", + "execution_start_time": "2025-01-11T14:52:15.2936378Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "00844db7-d433-41f6-bb3a-6d30eed6a6d0", + "queued_time": "2025-01-11T14:52:15.1638534Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 11, + "statement_ids": [ + 11 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 11, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(\n", + " node_df.write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"labels\", \":Node\")\n", + " .option(\"node.keys\", \"nodeId:id\")\n", + " .save()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Load rels" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T14:55:23.0498345Z", + "execution_start_time": "2025-01-11T14:55:00.1139093Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "93db93ce-ba8c-4141-9062-ba6a9c681008", + "queued_time": "2025-01-11T14:55:00.0018896Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 14, + "statement_ids": [ + 14 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 14, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rel_batch_df = group_and_batch_spark_dataframe(spark_dataframe=twitch_df, source_col='numeric_id_1', target_col='numeric_id_2', num_groups=(spark_executor_count * 2) - 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T14:56:52.1245437Z", + "execution_start_time": "2025-01-11T14:56:48.2089393Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "6afd2da0-a917-4ac5-b24e-c0f609582ca7", + "queued_time": "2025-01-11T14:56:48.0701321Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 15, + "statement_ids": [ + 15 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 15, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------------+------------+------+-----+\n", + "|numeric_id_1|numeric_id_2| group|batch|\n", + "+------------+------------+------+-----+\n", + "| 111207| 159752|1 -- 5| 3|\n", + "| 111207| 145773|1 -- 5| 3|\n", + "| 111207| 42059|1 -- 6| 8|\n", + "| 111207| 29852|1 -- 7| 4|\n", + "| 111207| 75443|1 -- 1| 1|\n", + "| 111207| 12216|1 -- 2| 6|\n", + "| 111207| 123168|0 -- 1| 5|\n", + "| 111207| 40798|1 -- 1| 1|\n", + "| 111207| 52070|0 -- 1| 5|\n", + "| 111207| 118432|1 -- 3| 2|\n", + "| 111207| 140508|1 -- 2| 6|\n", + "| 111207| 78550|1 -- 8| 0|\n", + "| 111207| 76995|1 -- 2| 6|\n", + "| 111207| 73856|1 -- 3| 2|\n", + "| 111207| 154308|1 -- 2| 6|\n", + "| 111207| 129693|0 -- 1| 5|\n", + "| 111207| 63938|1 -- 1| 1|\n", + "| 111207| 21381|1 -- 4| 7|\n", + "| 111207| 28488|1 -- 2| 6|\n", + "| 111207| 13564|1 -- 1| 1|\n", + "+------------+------------+------+-----+\n", + "only showing top 20 rows\n", + "\n" + ] + } + ], + "source": [ + "rel_batch_df.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T15:01:54.9500155Z", + "execution_start_time": "2025-01-11T14:57:24.5030447Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "ecdaef15-dc48-48f2-b23b-b53daa35827f", + "queued_time": "2025-01-11T14:57:24.3876952Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 16, + "statement_ids": [ + 16 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 16, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "query = \"\"\"\n", + " MATCH(source:Node {id: event.numeric_id_1})\n", + " MATCH(target:Node {id: event.numeric_id_2})\n", + " MERGE(source)-[r:RELATES_TO]->(target)\n", + " \"\"\"\n", + "\n", + "ingest_spark_dataframe(\n", + " spark_dataframe=rel_batch_df,\n", + " save_mode= \"Overwrite\",\n", + " options={\"query\":query}\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Delete rels" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T15:03:46.0902216Z", + "execution_start_time": "2025-01-11T15:03:43.2960105Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "f7cb9b0e-b957-4dae-93d6-0c93f3846fe5", + "queued_time": "2025-01-11T15:03:43.1740342Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 20, + "statement_ids": [ + 20 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 20, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6797557 680\n" + ] + } + ], + "source": [ + "rel_count = twitch_df.count()\n", + "batch_count = rel_count // 10000 + 1\n", + "print(rel_count, batch_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T15:09:07.318409Z", + "execution_start_time": "2025-01-11T15:09:06.8032688Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "be93cdfa-06c6-4d6e-bc5a-0146f77d1cd1", + "queued_time": "2025-01-11T15:09:06.6770525Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 25, + "statement_ids": [ + 25 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 25, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "680\n" + ] + } + ], + "source": [ + "from pyspark.sql.functions import lit\n", + "del_df = (spark.range(batch_count)\n", + " .select(lit(1).alias(\"id\")))\n", + "print(del_df.count())" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T15:16:01.4072209Z", + "execution_start_time": "2025-01-11T15:10:19.9712186Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "457a965b-b574-4751-85c2-dc2b43e2c3a2", + "queued_time": "2025-01-11T15:10:19.851916Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 27, + "statement_ids": [ + 27 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 27, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "del_query = \"MATCH ()-[r:RELATES_TO]->() WITH r LIMIT 10000 DELETE r\"\n", + "\n", + "(\n", + " del_df.coalesce(1).write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"query\", del_query)\n", + " .option(\"batch.size\", 1)\n", + " .save()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Load rels serially" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": null, + "execution_start_time": "2025-01-11T15:22:59.3132605Z", + "livy_statement_state": "running", + "normalized_state": "running", + "parent_msg_id": "d14c3ab9-8c1b-4d65-a66e-ba784a7c620e", + "queued_time": "2025-01-11T15:22:59.1886902Z", + "session_id": "18", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "submitted", + "statement_id": 28, + "statement_ids": [ + 28 + ] + }, + "text/plain": [ + "StatementMeta(medium, 18, 28, Submitted, Running, Running)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(\n", + " twitch_df.coalesce(1).write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"query\", query)\n", + " .save()\n", + ")" + ] + } + ], + "metadata": { + "kernel_info": { + "name": "synapse_pyspark" + }, + "kernelspec": { + "display_name": "Synapse PySpark", + "language": "Python", + "name": "synapse_pyspark" + }, + "language_info": { + "name": "python" + }, + "save_output": true, + "synapse_widget": { + "state": {}, + "version": "0.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 821c680b76204c2c7c2638e36cfcef92128aa02b Mon Sep 17 00:00:00 2001 From: Nathan Smith Date: Sat, 11 Jan 2025 17:34:16 -0600 Subject: [PATCH 05/13] Correct column name. --- neo4j_parallel_spark_loader/monopartite/grouping.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/neo4j_parallel_spark_loader/monopartite/grouping.py b/neo4j_parallel_spark_loader/monopartite/grouping.py index fce2266..1051876 100644 --- a/neo4j_parallel_spark_loader/monopartite/grouping.py +++ b/neo4j_parallel_spark_loader/monopartite/grouping.py @@ -58,7 +58,7 @@ def create_node_groupings( ) .drop(keys_sdf.value) .join( - other=keys_sdf.withColumnRenamed("group", "source_group"), + other=keys_sdf.withColumnRenamed("group", "target_group"), on=(spark_dataframe[target_col] == keys_sdf.value), how="left" ) From e7f17d5268edf2906b7a105c811a5e233edf0506 Mon Sep 17 00:00:00 2001 From: Nathan Smith Date: Sat, 11 Jan 2025 17:43:57 -0600 Subject: [PATCH 06/13] Update examples --- examples/bipartite_amazon_ratings.ipynb | 887 ++++++++++++++++++ ....ipynb => monopartite_twitch_gamers.ipynb} | 33 +- ...predefined_components_reddit_threads.ipynb | 883 +++++++++++++++++ 3 files changed, 1787 insertions(+), 16 deletions(-) create mode 100644 examples/bipartite_amazon_ratings.ipynb rename examples/{twitch_gamers.ipynb => monopartite_twitch_gamers.ipynb} (96%) create mode 100644 examples/predefined_components_reddit_threads.ipynb diff --git a/examples/bipartite_amazon_ratings.ipynb b/examples/bipartite_amazon_ratings.ipynb new file mode 100644 index 0000000..746c6df --- /dev/null +++ b/examples/bipartite_amazon_ratings.ipynb @@ -0,0 +1,887 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:03:23.0244336Z", + "execution_start_time": "2025-01-11T19:03:22.8627505Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "2b085336-8c6d-4adf-97f2-4132e4403687", + "queued_time": "2025-01-11T19:03:22.102208Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 7, + "statement_ids": [ + 7 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 7, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pyspark.sql import SparkSession\n", + "from pyspark.sql.types import StructType, StructField, IntegerType, FloatType\n", + "import requests\n", + "from io import BytesIO\n", + "from zipfile import ZipFile\n", + "from neo4j_parallel_spark_loader.bipartite import group_and_batch_spark_dataframe\n", + "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Create spark session" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T18:59:51.2054347Z", + "execution_start_time": "2025-01-11T18:59:51.0447282Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "46cabf82-8138-47c2-9336-203da9e26e57", + "queued_time": "2025-01-11T18:55:55.3501895Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 3, + "statement_ids": [ + 3 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 3, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "username = \"NEO4J_USER\"\n", + "password = \"NEO4J_PASSWORD\"\n", + "url = \"NEO4J_URL\"\n", + "dbname = \"NEO4J_DATABASE\"\n", + "spark_executor_count=5\n", + "\n", + "spark = (\n", + " SparkSession.builder\n", + " .appName(\"AmazonRatings\")\n", + " .config(\"neo4j.url\", url)\n", + " .config(\"url\", url)\n", + " .config(\"neo4j.authentication.basic.username\", username)\n", + " .config(\"neo4j.authentication.basic.password\", password)\n", + " .config(\"neo4j.database\", dbname)\n", + " .getOrCreate()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Download data" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:03:31.160049Z", + "execution_start_time": "2025-01-11T19:03:25.850078Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "de533a22-47ec-4a9c-aaf8-f1c21fb818e5", + "queued_time": "2025-01-11T19:03:25.7041392Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 8, + "statement_ids": [ + 8 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 8, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+---------+---------+------+----------+\n", + "|source_id|target_id|rating| timestamp|\n", + "+---------+---------+------+----------+\n", + "| 1| 1| 5.0|1117404000|\n", + "| 1| 2| 1.0|1105916400|\n", + "| 1| 3| 5.0|1105916400|\n", + "| 1| 4| 1.0|1105570800|\n", + "| 1| 5| 1.0|1104966000|\n", + "| 1| 6| 5.0|1103497200|\n", + "| 1| 7| 4.0|1081461600|\n", + "| 1| 8| 5.0|1074985200|\n", + "| 1| 9| 5.0|1071961200|\n", + "| 1| 10| 1.0|1071788400|\n", + "| 1| 11| 4.0|1071702000|\n", + "| 1| 12| 5.0|1070492400|\n", + "| 1| 13| 5.0|1070319600|\n", + "| 1| 14| 5.0|1066514400|\n", + "| 1| 15| 4.0|1066341600|\n", + "| 1| 16| 5.0|1066341600|\n", + "| 1| 17| 5.0|1066168800|\n", + "| 1| 18| 2.0|1065996000|\n", + "| 1| 19| 5.0|1065909600|\n", + "| 1| 20| 5.0|1065650400|\n", + "+---------+---------+------+----------+\n", + "only showing top 20 rows\n", + "\n", + "root\n", + " |-- source_id: integer (nullable = true)\n", + " |-- target_id: integer (nullable = true)\n", + " |-- rating: float (nullable = true)\n", + " |-- timestamp: integer (nullable = true)\n", + "\n" + ] + } + ], + "source": [ + "# Define the schema\n", + "schema = StructType([\n", + " StructField(\"source_id\", IntegerType(), True),\n", + " StructField(\"target_id\", IntegerType(), True),\n", + " StructField(\"rating\", FloatType(), True),\n", + " StructField(\"timestamp\", IntegerType(), True)\n", + "])\n", + "\n", + "# Download the ZIP file\n", + "response = requests.get(\"https://nrvis.com/download/data/dynamic/rec-amazon-ratings.zip\")\n", + "zip_file = ZipFile(BytesIO(response.content))\n", + "\n", + "# Read the CSV file directly from the ZIP\n", + "with zip_file.open(\"rec-amazon-ratings.edges\") as file:\n", + " # Convert to string buffer for Spark to read\n", + " content = file.read().decode('utf-8')\n", + " \n", + " # Create RDD from content\n", + " rdd = spark.sparkContext.parallelize(content.splitlines())\n", + " \n", + " # Convert RDD to DataFrame with schema\n", + " rating_df = spark.read.csv(rdd, schema=schema, header=False)\n", + "\n", + "# Now df is your Spark DataFrame containing the data with proper column names and types\n", + "# You can verify the data\n", + "rating_df.show()\n", + "rating_df.printSchema()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:03:43.4584278Z", + "execution_start_time": "2025-01-11T19:03:39.0646295Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "e387e6cb-4355-4128-baad-c2eccad4ca78", + "queued_time": "2025-01-11T19:03:38.9431924Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 9, + "statement_ids": [ + 9 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 9, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "5838041" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rating_df.count()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Load nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:13:20.0134295Z", + "execution_start_time": "2025-01-11T19:12:59.1775369Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "f6a2aa90-0280-43ba-9760-a3ebf360b3f1", + "queued_time": "2025-01-11T19:12:59.0570586Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 12, + "statement_ids": [ + 12 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 12, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(\n", + " rating_df\n", + " .select(\"source_id\")\n", + " .distinct()\n", + " .write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"labels\", \":Source\")\n", + " .option(\"node.keys\", \"source_id:id\")\n", + " .option(\"schema.optimization.node.keys\", \"KEY\")\n", + " .save()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:13:32.73651Z", + "execution_start_time": "2025-01-11T19:13:20.1492446Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "b3e17212-f06f-4393-9332-2857c9b9d076", + "queued_time": "2025-01-11T19:13:00.034665Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 13, + "statement_ids": [ + 13 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 13, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(\n", + " rating_df\n", + " .select(\"target_id\")\n", + " .distinct()\n", + " .write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"labels\", \":Target\")\n", + " .option(\"node.keys\", \"target_id:id\")\n", + " .option(\"schema.optimization.node.keys\", \"KEY\")\n", + " .save()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Load rels" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:10:35.8072375Z", + "execution_start_time": "2025-01-11T19:08:40.1552582Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "3f09d80c-27df-4086-80f0-62d78f848826", + "queued_time": "2025-01-11T19:08:40.0073078Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 10, + "statement_ids": [ + 10 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 10, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rel_batch_df = group_and_batch_spark_dataframe(spark_dataframe=rating_df, \n", + " source_col='source_id', \n", + " target_col='target_id', \n", + " num_groups=spark_executor_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:10:40.0880121Z", + "execution_start_time": "2025-01-11T19:10:36.1206943Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "c900169a-def3-41fd-99d3-2fb76a40b836", + "queued_time": "2025-01-11T19:09:19.0361583Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 11, + "statement_ids": [ + 11 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 11, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+---------+---------+------+----------+-------+-----+\n", + "|source_id|target_id|rating| timestamp| group|batch|\n", + "+---------+---------+------+----------+-------+-----+\n", + "| 1| 7| 4.0|1081461600|3 --> 4| 2|\n", + "| 1| 19| 5.0|1065909600|3 --> 3| 1|\n", + "| 13417| 110| 5.0|1102806000|4 --> 2| 1|\n", + "| 398740| 1497| 5.0| 999554400|4 --> 3| 2|\n", + "| 55714| 6452| 5.0|1101769200|4 --> 4| 3|\n", + "| 758089| 8282| 5.0|1024178400|3 --> 4| 2|\n", + "| 758100| 9000| 4.0|1015714800|0 --> 0| 0|\n", + "| 563976| 10287| 3.0|1098655200|4 --> 4| 3|\n", + "| 28574| 14304| 1.0|1093039200|1 --> 4| 0|\n", + "| 968213| 18887| 4.0|1056146400|2 --> 2| 4|\n", + "| 6791| 23365| 4.0|1096322400|0 --> 2| 2|\n", + "| 6791| 23365| 4.0|1096322400|0 --> 2| 2|\n", + "| 94201| 26022| 4.0|1065304800|2 --> 4| 1|\n", + "| 55711| 31486| 1.0|1082844000|2 --> 3| 0|\n", + "| 55711| 31486| 1.0|1082844000|2 --> 3| 0|\n", + "| 758084| 33837| 5.0|1015542000|1 --> 0| 1|\n", + "| 55712| 49215| 4.0|1068246000|2 --> 0| 2|\n", + "| 6791| 53906| 4.0|1096408800|0 --> 1| 1|\n", + "| 28574| 54493| 3.0|1093039200|1 --> 0| 1|\n", + "| 28574| 58905| 1.0|1093039200|1 --> 1| 2|\n", + "+---------+---------+------+----------+-------+-----+\n", + "only showing top 20 rows\n", + "\n" + ] + } + ], + "source": [ + "rel_batch_df.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:35:18.8392667Z", + "execution_start_time": "2025-01-11T19:30:29.4126282Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "c4010936-6bbf-453c-a2d4-ea2148e55c00", + "queued_time": "2025-01-11T19:30:29.2741482Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 19, + "statement_ids": [ + 19 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 19, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "query = \"\"\"\n", + " MATCH(source:Source {id: event.source_id})\n", + " MATCH(target:Target {id: event.target_id})\n", + " MERGE(source)-[r:RELATES_TO {timestamp:event.timestamp}]->(target)\n", + " SET r.rating = event.rating\n", + " \"\"\"\n", + "\n", + "ingest_spark_dataframe(\n", + " spark_dataframe=rel_batch_df,\n", + " save_mode= \"Overwrite\",\n", + " options={\"query\":query}\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Delete rels" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:41:05.7149646Z", + "execution_start_time": "2025-01-11T19:41:01.7596122Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "c17aaaf8-6ede-4ee6-81f9-2a4f75464c33", + "queued_time": "2025-01-11T19:41:01.6354079Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 26, + "statement_ids": [ + 26 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 26, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5838041 584\n" + ] + } + ], + "source": [ + "rel_count = rating_df.count()\n", + "batch_count = rel_count // 10000 + 1\n", + "print(rel_count, batch_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:41:10.2940843Z", + "execution_start_time": "2025-01-11T19:41:09.7728004Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "d620521c-b189-4703-a2b6-dcffda5ce9b5", + "queued_time": "2025-01-11T19:41:09.6172495Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 27, + "statement_ids": [ + 27 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 27, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "584\n" + ] + } + ], + "source": [ + "from pyspark.sql.functions import lit\n", + "del_df = (spark.range(batch_count)\n", + " .select(lit(1).alias(\"id\")))\n", + "print(del_df.count())" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T19:47:33.4788284Z", + "execution_start_time": "2025-01-11T19:42:38.3485714Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "eab7a384-7dfb-40aa-86f4-b422ab134efa", + "queued_time": "2025-01-11T19:42:38.2082178Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 28, + "statement_ids": [ + 28 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 28, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "del_query = \"\"\"\n", + " MATCH ()-[r:RELATES_TO]->()\n", + " WITH r LIMIT 10000\n", + " DELETE r\"\"\"\n", + "\n", + "(\n", + " del_df.coalesce(1).write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"query\", del_query)\n", + " .option(\"batch.size\", 1)\n", + " .save()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Load rels serially" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T20:00:12.8762123Z", + "execution_start_time": "2025-01-11T19:51:49.7653219Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "bfcbca3f-7389-44c8-8b19-035d4be4dc2a", + "queued_time": "2025-01-11T19:51:49.637572Z", + "session_id": "19", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 30, + "statement_ids": [ + 30 + ] + }, + "text/plain": [ + "StatementMeta(medium, 19, 30, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(\n", + " rating_df.repartition(1).write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"query\", query)\n", + " .save()\n", + ")" + ] + } + ], + "metadata": { + "description": null, + "kernelspec": { + "display_name": "python", + "name": "synapse_pyspark" + }, + "language_info": { + "name": "python" + }, + "save_output": true, + "synapse_widget": { + "state": {}, + "version": "0.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/twitch_gamers.ipynb b/examples/monopartite_twitch_gamers.ipynb similarity index 96% rename from examples/twitch_gamers.ipynb rename to examples/monopartite_twitch_gamers.ipynb index 1531eb5..6af63f9 100644 --- a/examples/twitch_gamers.ipynb +++ b/examples/monopartite_twitch_gamers.ipynb @@ -51,7 +51,8 @@ } }, "source": [ - "## Create spark session" + "## Create spark session\n", + "Update the values below for your environment" ] }, { @@ -97,12 +98,11 @@ } ], "source": [ - "username = \"NEO4J_USER_NAME\"\n", + "username = \"NEO4J_USER\"\n", "password = \"NEO4J_PASSWORD\"\n", "url = \"NEO4J_URL\"\n", - "dbname = \"NEO4J_DB\"\n", - "spark_executor_count = 5\n", - "\n", + "dbname = \"NEO4J_DATABASE\"\n", + "spark_executor_count=5\n", "\n", "spark = (\n", " SparkSession.builder\n", @@ -411,6 +411,7 @@ " .mode(\"Overwrite\")\n", " .option(\"labels\", \":Node\")\n", " .option(\"node.keys\", \"nodeId:id\")\n", + " .option(\"schema.optimization.node.keys\", \"KEY\")\n", " .save()\n", ")" ] @@ -471,7 +472,10 @@ } ], "source": [ - "rel_batch_df = group_and_batch_spark_dataframe(spark_dataframe=twitch_df, source_col='numeric_id_1', target_col='numeric_id_2', num_groups=(spark_executor_count * 2) - 1)" + "rel_batch_df = group_and_batch_spark_dataframe(spark_dataframe=twitch_df, \n", + " source_col='numeric_id_1', \n", + " target_col='numeric_id_2', \n", + " num_groups=(2 * spark_executor_count)-1)" ] }, { @@ -818,24 +822,24 @@ { "data": { "application/vnd.livy.statement-meta+json": { - "execution_finish_time": null, + "execution_finish_time": "2025-01-11T15:32:11.4027857Z", "execution_start_time": "2025-01-11T15:22:59.3132605Z", - "livy_statement_state": "running", - "normalized_state": "running", + "livy_statement_state": "available", + "normalized_state": "finished", "parent_msg_id": "d14c3ab9-8c1b-4d65-a66e-ba784a7c620e", "queued_time": "2025-01-11T15:22:59.1886902Z", "session_id": "18", "session_start_time": null, "spark_jobs": null, "spark_pool": "medium", - "state": "submitted", + "state": "finished", "statement_id": 28, "statement_ids": [ 28 ] }, "text/plain": [ - "StatementMeta(medium, 18, 28, Submitted, Running, Running)" + "StatementMeta(medium, 18, 28, Finished, Available, Finished)" ] }, "metadata": {}, @@ -854,12 +858,9 @@ } ], "metadata": { - "kernel_info": { - "name": "synapse_pyspark" - }, + "description": null, "kernelspec": { - "display_name": "Synapse PySpark", - "language": "Python", + "display_name": "python", "name": "synapse_pyspark" }, "language_info": { diff --git a/examples/predefined_components_reddit_threads.ipynb b/examples/predefined_components_reddit_threads.ipynb new file mode 100644 index 0000000..a5b0d63 --- /dev/null +++ b/examples/predefined_components_reddit_threads.ipynb @@ -0,0 +1,883 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T22:00:42.4235235Z", + "execution_start_time": "2025-01-11T22:00:42.2764302Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "04a8f60b-046e-4d2e-956f-a81a40a47cf5", + "queued_time": "2025-01-11T22:00:42.1460445Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 9, + "statement_ids": [ + 9 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 9, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pyspark.sql import SparkSession\n", + "from pyspark.sql.types import StructType, StructField, IntegerType\n", + "import requests\n", + "from io import BytesIO\n", + "from zipfile import ZipFile\n", + "from neo4j_parallel_spark_loader.predefined_components import group_and_batch_spark_dataframe\n", + "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n", + "import json" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Create spark session\n", + "Update the values below for your environment" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T21:44:18.5177192Z", + "execution_start_time": "2025-01-11T21:44:18.3725338Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "da70e421-13d6-4887-bbb3-d39f40e87b24", + "queued_time": "2025-01-11T21:44:18.2491489Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 3, + "statement_ids": [ + 3 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 3, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "username = \"NEO4J_USER\"\n", + "password = \"NEO4J_PASSWORD\"\n", + "url = \"NEO4J_URL\"\n", + "dbname = \"NEO4J_DATABASE\"\n", + "spark_executor_count=5\n", + "\n", + "spark = (\n", + " SparkSession.builder\n", + " .appName(\"ReditThreads\")\n", + " .config(\"neo4j.url\", url)\n", + " .config(\"url\", url)\n", + " .config(\"neo4j.authentication.basic.username\", username)\n", + " .config(\"neo4j.authentication.basic.password\", \"i2_dYwwAMKKqp7tokHoscvNJbBBn1snAZKX0uA_gffA\")\n", + " .config(\"neo4j.database\", dbname)\n", + " .getOrCreate()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Download data" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:01:14.2805724Z", + "execution_start_time": "2025-01-11T23:00:36.4081869Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "35d72265-fbd4-4fa3-91c6-238709bf8ad0", + "queued_time": "2025-01-11T23:00:35.3496326Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 45, + "statement_ids": [ + 45 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 45, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+--------+---------+---------+\n", + "|graph_id|source_id|target_id|\n", + "+--------+---------+---------+\n", + "| 0| 0| 2|\n", + "| 0| 1| 5|\n", + "| 0| 2| 4|\n", + "| 0| 2| 5|\n", + "| 0| 2| 6|\n", + "| 0| 2| 7|\n", + "| 0| 2| 8|\n", + "| 0| 2| 9|\n", + "| 0| 2| 10|\n", + "| 0| 3| 8|\n", + "| 1| 0| 3|\n", + "| 1| 0| 6|\n", + "| 1| 1| 8|\n", + "| 1| 2| 8|\n", + "| 1| 4| 8|\n", + "| 1| 5| 8|\n", + "| 1| 6| 8|\n", + "| 1| 7| 8|\n", + "| 1| 8| 9|\n", + "| 1| 8| 10|\n", + "+--------+---------+---------+\n", + "only showing top 20 rows\n", + "\n" + ] + } + ], + "source": [ + "schema = StructType([\n", + " StructField(\"graph_id\", IntegerType(), True),\n", + " StructField(\"source_id\", IntegerType(), True),\n", + " StructField(\"target_id\", IntegerType(), True)\n", + "])\n", + "\n", + "# Download and read the zip file content\n", + "response = requests.get(\"https://snap.stanford.edu/data/reddit_threads.zip\")\n", + "zip_file = ZipFile(BytesIO(response.content))\n", + "\n", + "# Read the JSON file content from the zip\n", + "with zip_file.open(\"reddit_threads/reddit_edges.json\") as file:\n", + " # Parse JSON content\n", + " data = json.loads(file.read().decode('utf-8'))\n", + " flattened = [[int(t[0]), int(sublist[0]), int(sublist[1])] for t in data.items() for sublist in t[1]]\n", + " \n", + " # Create DataFrame from parsed JSON\n", + " reddit_df = spark.createDataFrame(flattened, schema=schema)\n", + "\n", + "# Show the result\n", + "reddit_df.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:01:16.2592288Z", + "execution_start_time": "2025-01-11T23:01:14.4142013Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "0eb527b1-e56e-4a60-8fe6-9e4419af89bd", + "queued_time": "2025-01-11T23:00:43.7342871Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 46, + "statement_ids": [ + 46 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 46, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "5074915" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reddit_df.count()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Load nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:23:27.639813Z", + "execution_start_time": "2025-01-11T23:23:23.682035Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "7b8ad8aa-c3b2-4ccf-b0f3-e63f1149bd63", + "queued_time": "2025-01-11T23:23:23.5534729Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 64, + "statement_ids": [ + 64 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 64, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "4859280" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node_df = (reddit_df\n", + " .select('graph_id', 'source_id')\n", + " .withColumnRenamed('source_id', 'nodeId')\n", + " .union(\n", + " reddit_df\n", + " .select('graph_id', 'target_id')\n", + " .withColumnRenamed('target_id', 'nodeId'))\n", + " .dropDuplicates())\n", + "node_df.count()" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:26:11.8251813Z", + "execution_start_time": "2025-01-11T23:25:10.4645703Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "8ebd5d91-2211-40f6-955b-c892e42b18ed", + "queued_time": "2025-01-11T23:25:10.3417526Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 65, + "statement_ids": [ + 65 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 65, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(\n", + " node_df.write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"labels\", \":Node\")\n", + " .option(\"node.keys\", \"graph_id:graphId,nodeId:nodeId\")\n", + " .option(\"schema.optimization.node.keys\", \"KEY\")\n", + " .save()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Load rels" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:26:40.0326641Z", + "execution_start_time": "2025-01-11T23:26:29.4493665Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "e541da32-90b4-479c-a59b-4f959cca62bb", + "queued_time": "2025-01-11T23:25:49.4755611Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 68, + "statement_ids": [ + 68 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 68, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rel_batch_df = group_and_batch_spark_dataframe(spark_dataframe=reddit_df, \n", + " partition_col='graph_id', \n", + " num_groups=spark_executor_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:26:41.9804998Z", + "execution_start_time": "2025-01-11T23:26:40.1656981Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "969c7e39-5cf1-4c68-b3f8-733a3da7f95c", + "queued_time": "2025-01-11T23:25:53.0269186Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 69, + "statement_ids": [ + 69 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 69, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+--------+---------+---------+-----+-----+\n", + "|graph_id|source_id|target_id|group|batch|\n", + "+--------+---------+---------+-----+-----+\n", + "| 10223| 0| 2| 3| 0|\n", + "| 10223| 1| 2| 3| 0|\n", + "| 10223| 2| 3| 3| 0|\n", + "| 10222| 7| 23| 2| 0|\n", + "| 10222| 8| 16| 2| 0|\n", + "| 10222| 9| 16| 2| 0|\n", + "| 10222| 10| 16| 2| 0|\n", + "| 10222| 11| 16| 2| 0|\n", + "| 10222| 13| 16| 2| 0|\n", + "| 10222| 14| 16| 2| 0|\n", + "| 10222| 15| 16| 2| 0|\n", + "| 10222| 16| 17| 2| 0|\n", + "| 10222| 16| 18| 2| 0|\n", + "| 10222| 16| 19| 2| 0|\n", + "| 10222| 16| 20| 2| 0|\n", + "| 10222| 16| 21| 2| 0|\n", + "| 10222| 16| 22| 2| 0|\n", + "| 10222| 16| 23| 2| 0|\n", + "| 10222| 16| 24| 2| 0|\n", + "| 10222| 16| 25| 2| 0|\n", + "+--------+---------+---------+-----+-----+\n", + "only showing top 20 rows\n", + "\n" + ] + } + ], + "source": [ + "rel_batch_df.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:29:15.6482319Z", + "execution_start_time": "2025-01-11T23:27:04.6742861Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "26133e00-34f6-4c97-997c-69b0ba1a7d18", + "queued_time": "2025-01-11T23:27:04.555026Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 70, + "statement_ids": [ + 70 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 70, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "query = \"\"\"\n", + " MATCH(source:Node {graphId: event.graph_id, nodeId: event.source_id})\n", + " MATCH(target:Node {graphId: event.graph_id, nodeId: event.target_id})\n", + " MERGE(source)-[r:RELATES_TO]->(target)\n", + " \"\"\"\n", + "\n", + "ingest_spark_dataframe(\n", + " spark_dataframe=rel_batch_df,\n", + " save_mode= \"Overwrite\",\n", + " options={\"query\":query}\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Delete rels" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:29:28.5515873Z", + "execution_start_time": "2025-01-11T23:29:26.7485404Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "3a05e4c2-9b0f-4c01-a7d5-61b002e483bf", + "queued_time": "2025-01-11T23:29:26.6421279Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 71, + "statement_ids": [ + 71 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 71, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5074915 508\n" + ] + } + ], + "source": [ + "rel_count = reddit_df.count()\n", + "batch_count = rel_count // 10000 + 1\n", + "print(rel_count, batch_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:29:33.0382324Z", + "execution_start_time": "2025-01-11T23:29:32.5200288Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "db60fdcf-5a4f-443f-b6fc-03b8e65e5613", + "queued_time": "2025-01-11T23:29:32.4091933Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 72, + "statement_ids": [ + 72 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 72, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "508\n" + ] + } + ], + "source": [ + "from pyspark.sql.functions import lit\n", + "del_df = (spark.range(batch_count)\n", + " .select(lit(1).alias(\"id\")))\n", + "print(del_df.count())" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:32:00.5912265Z", + "execution_start_time": "2025-01-11T23:29:36.7229458Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "048159bf-fd15-4150-bfc2-843fc27d3241", + "queued_time": "2025-01-11T23:29:36.5941022Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 73, + "statement_ids": [ + 73 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 73, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "del_query = \"\"\"\n", + " MATCH ()-[r:RELATES_TO]->()\n", + " WITH r LIMIT 10000\n", + " DELETE r\"\"\"\n", + "\n", + "(\n", + " del_df.coalesce(1).write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"query\", del_query)\n", + " .option(\"batch.size\", 1)\n", + " .save()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nteract": { + "transient": { + "deleting": false + } + } + }, + "source": [ + "## Load rels serially" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": { + "jupyter": { + "outputs_hidden": false, + "source_hidden": false + }, + "nteract": { + "transient": { + "deleting": false + } + } + }, + "outputs": [ + { + "data": { + "application/vnd.livy.statement-meta+json": { + "execution_finish_time": "2025-01-11T23:36:18.2333344Z", + "execution_start_time": "2025-01-11T23:32:00.7201964Z", + "livy_statement_state": "available", + "normalized_state": "finished", + "parent_msg_id": "34fccf78-1a16-4138-af26-e57972d5b79a", + "queued_time": "2025-01-11T23:29:55.6343855Z", + "session_id": "26", + "session_start_time": null, + "spark_jobs": null, + "spark_pool": "medium", + "state": "finished", + "statement_id": 74, + "statement_ids": [ + 74 + ] + }, + "text/plain": [ + "StatementMeta(medium, 26, 74, Finished, Available, Finished)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(\n", + " reddit_df.coalesce(1).write\n", + " .format(\"org.neo4j.spark.DataSource\")\n", + " .mode(\"Overwrite\")\n", + " .option(\"query\", query)\n", + " .save()\n", + ")" + ] + } + ], + "metadata": { + "description": null, + "kernel_info": { + "name": "synapse_pyspark" + }, + "kernelspec": { + "display_name": "Synapse PySpark", + "language": "Python", + "name": "synapse_pyspark" + }, + "language_info": { + "name": "python" + }, + "save_output": true, + "synapse_widget": { + "state": {}, + "version": "0.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 3a65664fdbe6f7096b340a9c97b039509f466521 Mon Sep 17 00:00:00 2001 From: Nathan Smith Date: Sun, 12 Jan 2025 09:27:41 -0600 Subject: [PATCH 07/13] Correct spacing bug --- .../monopartite/batching.py | 2 +- tests/unit/monopartite/conftest.py | 26 +++++++++---------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/neo4j_parallel_spark_loader/monopartite/batching.py b/neo4j_parallel_spark_loader/monopartite/batching.py index 955ac8e..ae2c109 100644 --- a/neo4j_parallel_spark_loader/monopartite/batching.py +++ b/neo4j_parallel_spark_loader/monopartite/batching.py @@ -32,7 +32,7 @@ def create_ingest_batches_from_groups(spark_dataframe: DataFrame) -> DataFrame: coloring = color_complete_graph_with_self_loops(group_count) - coloring_data = [(f"{k[0]}--{k[1]}", v) for k, v in coloring.items()] + coloring_data = [(f"{k[0]} -- {k[1]}", v) for k, v in coloring.items()] # Create a DataFrame from the coloring dictionary coloring_df = spark.createDataFrame(coloring_data, ["group", "batch"]) diff --git a/tests/unit/monopartite/conftest.py b/tests/unit/monopartite/conftest.py index e1e7e93..58bbb07 100644 --- a/tests/unit/monopartite/conftest.py +++ b/tests/unit/monopartite/conftest.py @@ -6,11 +6,11 @@ @pytest.fixture(scope="module") def monopartite_batching_data() -> List[Dict[str, int]]: return [ - {"group": "1--3", "source_group": 1, "target_group": 3}, - {"group": "2--4", "source_group": 2, "target_group": 4}, - {"group": "3--5", "source_group": 5, "target_group": 3}, - {"group": "4--6", "source_group": 6, "target_group": 4}, - {"group": "0--0", "source_group": 0, "target_group": 0}, + {"group": "1 -- 3", "source_group": 1, "target_group": 3}, + {"group": "2 -- 4", "source_group": 2, "target_group": 4}, + {"group": "3 -- 5", "source_group": 5, "target_group": 3}, + {"group": "4 -- 6", "source_group": 6, "target_group": 4}, + {"group": "0 -- 0", "source_group": 0, "target_group": 0}, ] @@ -20,56 +20,56 @@ def monopartite_dupe_batching_data() -> List[Dict[str, int]]: { "source_group": 1, "target_group": 3, - "group": "1--3", + "group": "1 -- 3", "source_node": 1, "target_node": 3, }, { "source_group": 2, "target_group": 4, - "group": "2--4", + "group": "2 -- 4", "source_node": 4, "target_node": 2, }, { "source_group": 3, "target_group": 5, - "group": "3--5", + "group": "3 -- 5", "source_node": 3, "target_node": 5, }, { "source_group": 4, "target_group": 6, - "group": "4--6", + "group": "4 -- 6", "source_node": 4, "target_node": 6, }, { "source_group": 0, "target_group": 0, - "group": "0--0", + "group": "0 -- 0", "source_node": 0, "target_node": 0, }, { "source_group": 3, "target_group": 1, - "group": "1--3", + "group": "1 -- 3", "source_node": 3, "target_node": 1, }, { "source_group": 0, "target_group": 0, - "group": "0--0", + "group": "0 -- 0", "source_node": 0, "target_node": 0, }, { "source_group": 6, "target_group": 4, - "group": "4--6", + "group": "4 -- 6", "source_node": 6, "target_node": 4, }, From 72aafb9cfdef059a47e53121ed21aaad584fe1b6 Mon Sep 17 00:00:00 2001 From: Nathan Smith Date: Sun, 12 Jan 2025 11:15:35 -0600 Subject: [PATCH 08/13] Don't show empty heatmap cells --- examples/bipartite_amazon_ratings.ipynb | 580 ++++++------------ .../visualize/heatmap.py | 79 ++- 2 files changed, 234 insertions(+), 425 deletions(-) diff --git a/examples/bipartite_amazon_ratings.ipynb b/examples/bipartite_amazon_ratings.ipynb index 746c6df..87511c1 100644 --- a/examples/bipartite_amazon_ratings.ipynb +++ b/examples/bipartite_amazon_ratings.ipynb @@ -2,36 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:03:23.0244336Z", - "execution_start_time": "2025-01-11T19:03:22.8627505Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "2b085336-8c6d-4adf-97f2-4132e4403687", - "queued_time": "2025-01-11T19:03:22.102208Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 7, - "statement_ids": [ - 7 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 7, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from pyspark.sql import SparkSession\n", "from pyspark.sql.types import StructType, StructField, IntegerType, FloatType\n", @@ -39,7 +12,8 @@ "from io import BytesIO\n", "from zipfile import ZipFile\n", "from neo4j_parallel_spark_loader.bipartite import group_and_batch_spark_dataframe\n", - "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n" + "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n", + "from neo4j_parallel_spark_loader.visualize import create_ingest_heatmap\n" ] }, { @@ -52,7 +26,8 @@ } }, "source": [ - "## Create spark session" + "## Create spark session\n", + "Update the values below for your environment" ] }, { @@ -71,30 +46,20 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T18:59:51.2054347Z", - "execution_start_time": "2025-01-11T18:59:51.0447282Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "46cabf82-8138-47c2-9336-203da9e26e57", - "queued_time": "2025-01-11T18:55:55.3501895Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 3, - "statement_ids": [ - 3 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 3, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning: Ignoring non-Spark config property: neo4j.url\n", + "Warning: Ignoring non-Spark config property: url\n", + "Warning: Ignoring non-Spark config property: neo4j.database\n", + "Warning: Ignoring non-Spark config property: neo4j.authentication.basic.password\n", + "Warning: Ignoring non-Spark config property: neo4j.authentication.basic.username\n", + "25/01/12 10:50:29 WARN Utils: Your hostname, Nathans-MacBook-Pro-3.local resolves to a loopback address: 127.0.0.1; using 192.168.86.181 instead (on interface en0)\n", + "25/01/12 10:50:29 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n", + "Setting default log level to \"WARN\".\n", + "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n", + "25/01/12 10:50:30 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n" + ] } ], "source": [ @@ -131,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "metadata": { "jupyter": { "outputs_hidden": false, @@ -145,30 +110,12 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:03:31.160049Z", - "execution_start_time": "2025-01-11T19:03:25.850078Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "de533a22-47ec-4a9c-aaf8-f1c21fb818e5", - "queued_time": "2025-01-11T19:03:25.7041392Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 8, - "statement_ids": [ - 8 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 8, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 10:50:44 WARN TaskSetManager: Stage 0 contains a task of very large size (20312 KiB). The maximum recommended task size is 1000 KiB.\n", + "[Stage 0:> (0 + 1) / 1]\r" + ] }, { "name": "stdout", @@ -207,6 +154,14 @@ " |-- timestamp: integer (nullable = true)\n", "\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 10:50:49 WARN PythonRunner: Detected deadlock while completing task 0.0 in stage 0 (TID 0): Attempting to kill Python Worker\n", + " \r" + ] } ], "source": [ @@ -241,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "metadata": { "jupyter": { "outputs_hidden": false, @@ -255,30 +210,12 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:03:43.4584278Z", - "execution_start_time": "2025-01-11T19:03:39.0646295Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "e387e6cb-4355-4128-baad-c2eccad4ca78", - "queued_time": "2025-01-11T19:03:38.9431924Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 9, - "statement_ids": [ - 9 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 9, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 10:50:49 WARN TaskSetManager: Stage 1 contains a task of very large size (20312 KiB). The maximum recommended task size is 1000 KiB.\n", + " \r" + ] }, { "data": { @@ -286,7 +223,7 @@ "5838041" ] }, - "execution_count": 19, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -310,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -322,34 +259,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:13:20.0134295Z", - "execution_start_time": "2025-01-11T19:12:59.1775369Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "f6a2aa90-0280-43ba-9760-a3ebf360b3f1", - "queued_time": "2025-01-11T19:12:59.0570586Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 12, - "statement_ids": [ - 12 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 12, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "(\n", " rating_df\n", @@ -367,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -379,34 +289,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:13:32.73651Z", - "execution_start_time": "2025-01-11T19:13:20.1492446Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "b3e17212-f06f-4393-9332-2857c9b9d076", - "queued_time": "2025-01-11T19:13:00.034665Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 13, - "statement_ids": [ - 13 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 13, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "(\n", " rating_df\n", @@ -437,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "metadata": { "jupyter": { "outputs_hidden": false, @@ -451,30 +334,34 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:10:35.8072375Z", - "execution_start_time": "2025-01-11T19:08:40.1552582Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "3f09d80c-27df-4086-80f0-62d78f848826", - "queued_time": "2025-01-11T19:08:40.0073078Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 10, - "statement_ids": [ - 10 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 10, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 10:53:29 WARN TaskSetManager: Stage 4 contains a task of very large size (20312 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:54:20 WARN TaskSetManager: Stage 12 contains a task of very large size (20312 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:54:50 WARN TaskSetManager: Stage 20 contains a task of very large size (20312 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:54:55 WARN TaskSetManager: Stage 21 contains a task of very large size (2348 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:54:59 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:54:59 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:54:59 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:54:59 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:54:59 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:54:59 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:54:59 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:54:59 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:01 WARN TaskSetManager: Stage 34 contains a task of very large size (20312 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:55:07 WARN TaskSetManager: Stage 35 contains a task of very large size (2348 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:55:08 WARN TaskSetManager: Stage 36 contains a task of very large size (1339 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:55:14 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:14 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:14 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:14 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:14 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:14 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:14 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:14 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + " \r" + ] } ], "source": [ @@ -486,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "metadata": { "jupyter": { "outputs_hidden": false, @@ -500,30 +387,22 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:10:40.0880121Z", - "execution_start_time": "2025-01-11T19:10:36.1206943Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "c900169a-def3-41fd-99d3-2fb76a40b836", - "queued_time": "2025-01-11T19:09:19.0361583Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 11, - "statement_ids": [ - 11 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 11, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 10:55:16 WARN TaskSetManager: Stage 58 contains a task of very large size (20312 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:55:20 WARN PythonRunner: Detected deadlock while completing task 0.0 in stage 58 (TID 134): Attempting to kill Python Worker\n", + "25/01/12 10:55:20 WARN TaskSetManager: Stage 59 contains a task of very large size (2348 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:55:20 WARN PythonRunner: Detected deadlock while completing task 5.0 in stage 58 (TID 139): Attempting to kill Python Worker\n", + "25/01/12 10:55:20 WARN PythonRunner: Detected deadlock while completing task 7.0 in stage 58 (TID 141): Attempting to kill Python Worker\n", + "25/01/12 10:55:20 WARN PythonRunner: Detected deadlock while completing task 2.0 in stage 58 (TID 136): Attempting to kill Python Worker\n", + "25/01/12 10:55:20 WARN PythonRunner: Detected deadlock while completing task 1.0 in stage 58 (TID 135): Attempting to kill Python Worker\n", + "25/01/12 10:55:20 WARN PythonRunner: Detected deadlock while completing task 6.0 in stage 58 (TID 140): Attempting to kill Python Worker\n", + "25/01/12 10:55:20 WARN PythonRunner: Detected deadlock while completing task 4.0 in stage 58 (TID 138): Attempting to kill Python Worker\n", + "25/01/12 10:55:20 WARN PythonRunner: Detected deadlock while completing task 3.0 in stage 58 (TID 137): Attempting to kill Python Worker\n", + "25/01/12 10:55:21 WARN TaskSetManager: Stage 60 contains a task of very large size (1339 KiB). The maximum recommended task size is 1000 KiB.\n", + " \r" + ] }, { "name": "stdout", @@ -532,26 +411,26 @@ "+---------+---------+------+----------+-------+-----+\n", "|source_id|target_id|rating| timestamp| group|batch|\n", "+---------+---------+------+----------+-------+-----+\n", - "| 1| 7| 4.0|1081461600|3 --> 4| 2|\n", - "| 1| 19| 5.0|1065909600|3 --> 3| 1|\n", - "| 13417| 110| 5.0|1102806000|4 --> 2| 1|\n", - "| 398740| 1497| 5.0| 999554400|4 --> 3| 2|\n", - "| 55714| 6452| 5.0|1101769200|4 --> 4| 3|\n", - "| 758089| 8282| 5.0|1024178400|3 --> 4| 2|\n", - "| 758100| 9000| 4.0|1015714800|0 --> 0| 0|\n", - "| 563976| 10287| 3.0|1098655200|4 --> 4| 3|\n", - "| 28574| 14304| 1.0|1093039200|1 --> 4| 0|\n", - "| 968213| 18887| 4.0|1056146400|2 --> 2| 4|\n", - "| 6791| 23365| 4.0|1096322400|0 --> 2| 2|\n", - "| 6791| 23365| 4.0|1096322400|0 --> 2| 2|\n", - "| 94201| 26022| 4.0|1065304800|2 --> 4| 1|\n", - "| 55711| 31486| 1.0|1082844000|2 --> 3| 0|\n", - "| 55711| 31486| 1.0|1082844000|2 --> 3| 0|\n", - "| 758084| 33837| 5.0|1015542000|1 --> 0| 1|\n", - "| 55712| 49215| 4.0|1068246000|2 --> 0| 2|\n", - "| 6791| 53906| 4.0|1096408800|0 --> 1| 1|\n", - "| 28574| 54493| 3.0|1093039200|1 --> 0| 1|\n", - "| 28574| 58905| 1.0|1093039200|1 --> 1| 2|\n", + "| 1| 7| 4.0|1081461600|4 --> 4| 3|\n", + "| 1| 19| 5.0|1065909600|4 --> 2| 1|\n", + "| 41421| 3243| 1.0|1113256800|2 --> 1| 3|\n", + "| 16832| 5177| 1.0|1097532000|1 --> 3| 4|\n", + "| 636810| 8321| 2.0| 955058400|4 --> 1| 0|\n", + "| 16831| 18546| 5.0| 956008800|3 --> 4| 2|\n", + "| 1673392| 36750| 1.0|1139094000|0 --> 3| 3|\n", + "| 16831| 42744| 4.0|1008284400|3 --> 3| 1|\n", + "| 16831| 44234| 5.0| 984956400|3 --> 0| 3|\n", + "| 1197279| 79793| 5.0|1102114800|2 --> 2| 4|\n", + "| 41420| 85397| 5.0|1043708400|0 --> 4| 4|\n", + "| 636807| 131380| 5.0| 943225200|4 --> 1| 0|\n", + "| 236796| 220160| 5.0|1126303200|3 --> 2| 0|\n", + "| 236796| 237793| 5.0|1144188000|3 --> 1| 4|\n", + "| 636818| 420727| 1.0|1138057200|0 --> 1| 1|\n", + "| 236796| 497225| 5.0|1122415200|3 --> 1| 4|\n", + "| 41421| 555044| 5.0|1112911200|2 --> 4| 1|\n", + "| 236792| 838278| 3.0|1074726000|0 --> 3| 3|\n", + "| 236798| 838281| 4.0|1000850400|0 --> 2| 2|\n", + "| 636809| 868684| 2.0| 951260400|0 --> 1| 1|\n", "+---------+---------+------+----------+-------+-----+\n", "only showing top 20 rows\n", "\n" @@ -564,7 +443,55 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 10:55:23 WARN TaskSetManager: Stage 69 contains a task of very large size (20312 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:55:28 WARN TaskSetManager: Stage 70 contains a task of very large size (2348 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:55:29 WARN TaskSetManager: Stage 71 contains a task of very large size (1339 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 10:55:34 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:34 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:34 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:34 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:34 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:34 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:34 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + "25/01/12 10:55:34 WARN RowBasedKeyValueBatch: Calling spill() on RowBasedKeyValueBatch. Will not spill but return 0.\n", + " \r" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "create_ingest_heatmap(rel_batch_df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -576,34 +503,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:35:18.8392667Z", - "execution_start_time": "2025-01-11T19:30:29.4126282Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "c4010936-6bbf-453c-a2d4-ea2148e55c00", - "queued_time": "2025-01-11T19:30:29.2741482Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 19, - "statement_ids": [ - 19 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 19, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "query = \"\"\"\n", " MATCH(source:Source {id: event.source_id})\n", @@ -634,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -646,41 +546,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:41:05.7149646Z", - "execution_start_time": "2025-01-11T19:41:01.7596122Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "c17aaaf8-6ede-4ee6-81f9-2a4f75464c33", - "queued_time": "2025-01-11T19:41:01.6354079Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 26, - "statement_ids": [ - 26 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 26, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "5838041 584\n" - ] - } - ], + "outputs": [], "source": [ "rel_count = rating_df.count()\n", "batch_count = rel_count // 10000 + 1\n", @@ -689,7 +555,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -701,41 +567,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:41:10.2940843Z", - "execution_start_time": "2025-01-11T19:41:09.7728004Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "d620521c-b189-4703-a2b6-dcffda5ce9b5", - "queued_time": "2025-01-11T19:41:09.6172495Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 27, - "statement_ids": [ - 27 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 27, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "584\n" - ] - } - ], + "outputs": [], "source": [ "from pyspark.sql.functions import lit\n", "del_df = (spark.range(batch_count)\n", @@ -745,7 +577,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -757,34 +589,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T19:47:33.4788284Z", - "execution_start_time": "2025-01-11T19:42:38.3485714Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "eab7a384-7dfb-40aa-86f4-b422ab134efa", - "queued_time": "2025-01-11T19:42:38.2082178Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 28, - "statement_ids": [ - 28 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 28, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "del_query = \"\"\"\n", " MATCH ()-[r:RELATES_TO]->()\n", @@ -816,7 +621,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -828,34 +633,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T20:00:12.8762123Z", - "execution_start_time": "2025-01-11T19:51:49.7653219Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "bfcbca3f-7389-44c8-8b19-035d4be4dc2a", - "queued_time": "2025-01-11T19:51:49.637572Z", - "session_id": "19", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 30, - "statement_ids": [ - 30 - ] - }, - "text/plain": [ - "StatementMeta(medium, 19, 30, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "(\n", " rating_df.repartition(1).write\n", @@ -870,11 +648,21 @@ "metadata": { "description": null, "kernelspec": { - "display_name": "python", - "name": "synapse_pyspark" + "display_name": ".venv", + "language": "python", + "name": "python3" }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" }, "save_output": true, "synapse_widget": { diff --git a/neo4j_parallel_spark_loader/visualize/heatmap.py b/neo4j_parallel_spark_loader/visualize/heatmap.py index b8b02e3..321b895 100644 --- a/neo4j_parallel_spark_loader/visualize/heatmap.py +++ b/neo4j_parallel_spark_loader/visualize/heatmap.py @@ -1,14 +1,13 @@ from typing import Any, Dict, List - import numpy as np import seaborn as sns from matplotlib.axes import Axes from pyspark.sql import DataFrame - +import matplotlib.pyplot as plt def _format_spark_dataframe_for_visualization( spark_dataframe: DataFrame, -) -> List[Dict[str, int]]: +) -> List[Dict[str, Any]]: """ Prepare a Pandas DataFrame to be displayed as a heatmap visualizing the group and batch counts. @@ -19,20 +18,18 @@ def _format_spark_dataframe_for_visualization( Returns ------- - List[Dict[str, int]] + List[Dict[str, Any]] The Spark DataFrame contents processed and formatted as a list of dictionaries. """ - counts_sdf = spark_dataframe.groupBy("group", "batch").count() return [row.asDict() for row in counts_sdf.collect()] - def create_ingest_heatmap( - spark_dataframe: DataFrame, title: str = "Parallel Ingest Heat Map" + spark_dataframe: DataFrame, title: str = "Parallel Ingest Heat Map", figsize=(8, 12) ) -> Axes: """ Create the ingest heatmap from a list of dictionaries. - This heatmap will display the groups on the y-axis and batches on the x-axis in sequential order. + This heatmap will display batches on the y-axis and group numbers on the x-axis. Parameters ---------- @@ -40,45 +37,69 @@ def create_ingest_heatmap( A Spark DataFrame with columns including 'group', 'batch' and 'count' title : str, optional A title for the visualization, by default "Parallel Ingest Heat Map" + figsize : tuple, optional + Figure size (width, height) in inches, by default (8, 12) Returns ------- Axes A Matplotlib Axes object for visualization. """ - data = _format_spark_dataframe_for_visualization(spark_dataframe=spark_dataframe) assert ( set(data[0].keys()) == {"group", "batch", "count"} - ), "Invalid keys detected in data. Dictionary keys must contain only 'group', 'batch' and 'count'." - - X_KEY = "batch" - Y_KEY = "group" - VALUE_KEY = "count" + ), "Invalid keys detected in data. Dictionary keys must contain only 'group', 'batch' and 'count'" + + # Create a dictionary to store group-to-number mapping for each batch + batch_group_mappings = {} + for d in data: + batch = d["batch"] + if batch not in batch_group_mappings: + batch_group_mappings[batch] = {} + batch_group_mappings[batch][d["group"]] = len(batch_group_mappings[batch]) + 1 + + # Transform data with group numbers + transformed_data = [] + for d in data: + transformed_data.append({ + "batch": d["batch"], + "group_num": batch_group_mappings[d["batch"]][d["group"]], + "count": d["count"], + "original_group": d["group"] + }) # Extract unique x and y values - x_values = sorted(set(d[X_KEY] for d in data)) - y_values = sorted(set(d[Y_KEY] for d in data)) + y_values = sorted(set(d["batch"] for d in transformed_data), reverse=True) + x_values = sorted(set(d["group_num"] for d in transformed_data)) - # Create a 2D numpy array for the heatmap + # Create 2D numpy arrays for the heatmap heatmap_data = np.zeros((len(y_values), len(x_values))) - - # Fill the array with values - for item in data: - x_idx = x_values.index(item[X_KEY]) - y_idx = y_values.index(item[Y_KEY]) - heatmap_data[y_idx, x_idx] = item[VALUE_KEY] - + annotation_labels = np.empty((len(y_values), len(x_values)), dtype=object) + + # Fill the arrays with values + for item in transformed_data: + y_idx = y_values.index(item["batch"]) + x_idx = x_values.index(item["group_num"]) + heatmap_data[y_idx, x_idx] = item["count"] + # Create annotation with count and original group name + annotation_labels[y_idx, x_idx] = f"{item['count']:,.0f}\n({item['original_group']})" + + # Create figure with specified size + plt.figure(figsize=figsize) + + # Create heatmap ax = sns.heatmap( data=heatmap_data, - annot=True, + annot=annotation_labels, + fmt="", xticklabels=x_values, yticklabels=y_values, linewidths=0.5, ) - ax.set_xlabel("Batch") - ax.set_ylabel("Group") + + ax.set_xlabel("Group Number") + ax.set_ylabel("Batch") ax.set_title(title) - ax.invert_yaxis() - return ax + + return ax \ No newline at end of file From 74f640b12b8694625c61eb36dd33257945bab479 Mon Sep 17 00:00:00 2001 From: Nathan Smith Date: Sun, 12 Jan 2025 16:08:31 -0600 Subject: [PATCH 09/13] update visualization --- examples/monopartite_twitch_gamers.ipynb | 550 +++++------------- ...predefined_components_reddit_threads.ipynb | 313 +++++----- 2 files changed, 281 insertions(+), 582 deletions(-) diff --git a/examples/monopartite_twitch_gamers.ipynb b/examples/monopartite_twitch_gamers.ipynb index 6af63f9..0bf13af 100644 --- a/examples/monopartite_twitch_gamers.ipynb +++ b/examples/monopartite_twitch_gamers.ipynb @@ -4,41 +4,15 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T14:49:41.2174665Z", - "execution_start_time": "2025-01-11T14:49:40.6965287Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "20a7c7a6-49c7-4b5a-9f32-5b15f0e51019", - "queued_time": "2025-01-11T14:48:11.9992599Z", - "session_id": "18", - "session_start_time": "2025-01-11T14:48:12.0369851Z", - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 2, - "statement_ids": [ - 2 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 2, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from pyspark.sql import SparkSession\n", "import requests\n", "from io import BytesIO\n", "from zipfile import ZipFile\n", "from neo4j_parallel_spark_loader.monopartite import group_and_batch_spark_dataframe\n", - "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n" + "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n", + "from neo4j_parallel_spark_loader.visualize import create_ingest_heatmap" ] }, { @@ -71,30 +45,18 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T14:49:41.5117197Z", - "execution_start_time": "2025-01-11T14:49:41.3585458Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "769d32ac-fec7-4674-b91c-561e4424b35a", - "queued_time": "2025-01-11T14:48:28.1869292Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 3, - "statement_ids": [ - 3 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 3, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning: Ignoring non-Spark config property: neo4j.url\n", + "Warning: Ignoring non-Spark config property: url\n", + "Warning: Ignoring non-Spark config property: neo4j.database\n", + "Warning: Ignoring non-Spark config property: neo4j.authentication.basic.password\n", + "Warning: Ignoring non-Spark config property: neo4j.authentication.basic.username\n", + "Setting default log level to \"WARN\".\n", + "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n", + "25/01/12 09:48:18 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n" + ] } ], "source": [ @@ -145,30 +107,14 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T14:50:23.0615084Z", - "execution_start_time": "2025-01-11T14:49:55.5797104Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "2d565aae-42f2-4029-a551-702623320475", - "queued_time": "2025-01-11T14:49:55.4616629Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 4, - "statement_ids": [ - 4 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 4, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 09:48:34 WARN TaskSetManager: Stage 0 contains a task of very large size (12201 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 09:48:39 WARN PythonRunner: Detected deadlock while completing task 0.0 in stage 0 (TID 0): Attempting to kill Python Worker\n", + "25/01/12 09:48:40 WARN TaskSetManager: Stage 1 contains a task of very large size (12201 KiB). The maximum recommended task size is 1000 KiB.\n", + "[Stage 1:> (0 + 1) / 1]\r" + ] }, { "name": "stdout", @@ -205,6 +151,14 @@ " |-- numeric_id_2: string (nullable = true)\n", "\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 09:48:44 WARN PythonRunner: Detected deadlock while completing task 0.0 in stage 1 (TID 1): Attempting to kill Python Worker\n", + " \r" + ] } ], "source": [ @@ -231,7 +185,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "jupyter": { "outputs_hidden": false, @@ -245,30 +199,12 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T14:50:40.3463803Z", - "execution_start_time": "2025-01-11T14:50:31.2930721Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "ec3dba3e-335f-4a2b-8f13-7f034153d961", - "queued_time": "2025-01-11T14:50:31.1556519Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 6, - "statement_ids": [ - 6 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 6, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 09:48:44 WARN TaskSetManager: Stage 2 contains a task of very large size (12201 KiB). The maximum recommended task size is 1000 KiB.\n", + " \r" + ] }, { "data": { @@ -276,7 +212,7 @@ "6797557" ] }, - "execution_count": 13, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -300,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -312,44 +248,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T14:51:48.9139321Z", - "execution_start_time": "2025-01-11T14:51:42.0394455Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "5886e1ba-297a-42b5-8d17-7d141e9a261f", - "queued_time": "2025-01-11T14:51:41.8997493Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 9, - "statement_ids": [ - 9 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 9, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "168114" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "node_df = (twitch_df\n", " .select('numeric_id_1')\n", @@ -364,7 +263,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -376,34 +275,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T14:52:25.8382593Z", - "execution_start_time": "2025-01-11T14:52:15.2936378Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "00844db7-d433-41f6-bb3a-6d30eed6a6d0", - "queued_time": "2025-01-11T14:52:15.1638534Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 11, - "statement_ids": [ - 11 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 11, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "(\n", " node_df.write\n", @@ -431,7 +303,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "metadata": { "jupyter": { "outputs_hidden": false, @@ -445,30 +317,13 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T14:55:23.0498345Z", - "execution_start_time": "2025-01-11T14:55:00.1139093Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "93db93ce-ba8c-4141-9062-ba6a9c681008", - "queued_time": "2025-01-11T14:55:00.0018896Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 14, - "statement_ids": [ - 14 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 14, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 09:48:52 WARN TaskSetManager: Stage 5 contains a task of very large size (12201 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 09:49:23 WARN TaskSetManager: Stage 13 contains a task of very large size (12201 KiB). The maximum recommended task size is 1000 KiB.\n", + " \r" + ] } ], "source": [ @@ -480,7 +335,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "metadata": { "jupyter": { "outputs_hidden": false, @@ -494,30 +349,20 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T14:56:52.1245437Z", - "execution_start_time": "2025-01-11T14:56:48.2089393Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "6afd2da0-a917-4ac5-b24e-c0f609582ca7", - "queued_time": "2025-01-11T14:56:48.0701321Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 15, - "statement_ids": [ - 15 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 15, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 09:49:44 WARN TaskSetManager: Stage 29 contains a task of very large size (12201 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 09:49:48 WARN PythonRunner: Detected deadlock while completing task 5.0 in stage 29 (TID 87): Attempting to kill Python Worker\n", + "25/01/12 09:49:48 WARN PythonRunner: Detected deadlock while completing task 0.0 in stage 29 (TID 82): Attempting to kill Python Worker\n", + "25/01/12 09:49:48 WARN PythonRunner: Detected deadlock while completing task 1.0 in stage 29 (TID 83): Attempting to kill Python Worker\n", + "25/01/12 09:49:48 WARN PythonRunner: Detected deadlock while completing task 6.0 in stage 29 (TID 88): Attempting to kill Python Worker\n", + "25/01/12 09:49:48 WARN PythonRunner: Detected deadlock while completing task 2.0 in stage 29 (TID 84): Attempting to kill Python Worker\n", + "25/01/12 09:49:48 WARN PythonRunner: Detected deadlock while completing task 3.0 in stage 29 (TID 85): Attempting to kill Python Worker\n", + "25/01/12 09:49:48 WARN PythonRunner: Detected deadlock while completing task 7.0 in stage 29 (TID 89): Attempting to kill Python Worker\n", + "25/01/12 09:49:48 WARN PythonRunner: Detected deadlock while completing task 4.0 in stage 29 (TID 86): Attempting to kill Python Worker\n", + " \r" + ] }, { "name": "stdout", @@ -526,26 +371,26 @@ "+------------+------------+------+-----+\n", "|numeric_id_1|numeric_id_2| group|batch|\n", "+------------+------------+------+-----+\n", - "| 111207| 159752|1 -- 5| 3|\n", - "| 111207| 145773|1 -- 5| 3|\n", - "| 111207| 42059|1 -- 6| 8|\n", - "| 111207| 29852|1 -- 7| 4|\n", - "| 111207| 75443|1 -- 1| 1|\n", - "| 111207| 12216|1 -- 2| 6|\n", - "| 111207| 123168|0 -- 1| 5|\n", - "| 111207| 40798|1 -- 1| 1|\n", - "| 111207| 52070|0 -- 1| 5|\n", - "| 111207| 118432|1 -- 3| 2|\n", - "| 111207| 140508|1 -- 2| 6|\n", - "| 111207| 78550|1 -- 8| 0|\n", - "| 111207| 76995|1 -- 2| 6|\n", - "| 111207| 73856|1 -- 3| 2|\n", - "| 111207| 154308|1 -- 2| 6|\n", - "| 111207| 129693|0 -- 1| 5|\n", - "| 111207| 63938|1 -- 1| 1|\n", - "| 111207| 21381|1 -- 4| 7|\n", - "| 111207| 28488|1 -- 2| 6|\n", - "| 111207| 13564|1 -- 1| 1|\n", + "| 132936| 55282|5 -- 7| 6|\n", + "| 132936| 52228|1 -- 7| 4|\n", + "| 132936| 87835|6 -- 7| 2|\n", + "| 132936| 91750|7 -- 8| 3|\n", + "| 132936| 23194|3 -- 7| 5|\n", + "| 132936| 76703|2 -- 7| 0|\n", + "| 132936| 7938|7 -- 8| 3|\n", + "| 132936| 150412|7 -- 7| 7|\n", + "| 132936| 2158|5 -- 7| 6|\n", + "| 132936| 90372|7 -- 8| 3|\n", + "| 132936| 165616|4 -- 7| 1|\n", + "| 132936| 108001|7 -- 8| 3|\n", + "| 132936| 55253|7 -- 7| 7|\n", + "| 132936| 156774|7 -- 7| 7|\n", + "| 132936| 155380|2 -- 7| 0|\n", + "| 132936| 109338|6 -- 7| 2|\n", + "| 132936| 65772|6 -- 7| 2|\n", + "| 132936| 161490|0 -- 7| 8|\n", + "| 132936| 93083|4 -- 7| 1|\n", + "| 132936| 53374|7 -- 8| 3|\n", "+------------+------------+------+-----+\n", "only showing top 20 rows\n", "\n" @@ -558,7 +403,45 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 09:49:51 WARN TaskSetManager: Stage 37 contains a task of very large size (12201 KiB). The maximum recommended task size is 1000 KiB.\n", + " \r" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAroAAAPxCAYAAAAVFQ4CAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QVYFF0XB/C/AeYrJnYrdit2dysWdtdrd7cYKCJ2K3YndsdnomK3mCg2tuIr33Mu7LoLC6KCwPD/Pc8KOzM7O+4wM2fvnHtuFB8fHx8QEREREWlM1LDeACIiIiKi0MBAl4iIiIg0iYEuEREREWkSA10iIiIi0iQGukRERESkSQx0iYiIiEiTGOgSERERkSYx0CUiIiIiTWKgS0RERESaxECXKAJKly4dWrVqpX9+6NAhRIkSRf38VUuWLFGvvXfvXghvJRERUdhioEsUzEBQ94gZMyasrKzQtWtXeHp6IrIYOXKk+v+/ePECEcXKlSsxderUX/oCUaNGDZPzdF8m1q9fj9Dy8eNH9TkH9wuLbpvksXz5cpPLFC9eXM3PmTNnCG8tEVH4x0CXKJhGjx6NZcuWYcaMGShWrBhmz56NokWLquCEtBHohjX5Wxo1atQvt8zLly/5v/onrfTHjx9X84mIIqPoYb0BRBFF1apVUbBgQfV7u3btkChRIkyZMgVbtmxB48aNf3u9379/x9evXxmM0G+rVq0atm7dqlrbEydOrJ8uwW/SpEmROXNmvH79Oky3kYgoLLBFl+g3lStXTv10d3dXPydPnqxaeiUAjhUrFgoUKGDyNrfcRpa0hxUrViBHjhyIESMGdu3a9UvrCK5Tp06hSpUqsLCwQOzYsVG6dGn873//Q0gpU6aMuiV+9epVlC1bVr1HypQpYW9vH2DZ+/fvo1atWogTJw4sLS3Rq1cv7N6922RucXC2+927d+jZs6dKN5DPUNZZsWJFnDt3Tr9t27dvV++ru70vy4a0x48fo02bNiqglO2Qfbpo0SKjZeSLzPDhw9X+lP+TfAYlS5bEwYMHjVpfkyRJon6XVl3dNksqw8/Url1bvfe6deuMpkug27BhQ0SLFi3AaxYvXqz+huVzk9dmz55d3aUILJ1jz549yJs3r/pCJstu3Ljxlz4nIqKwwBZdot90584d9VOCUuHk5KQCuaZNm6rAZvXq1WjQoAFcXFxQvXp1o9ceOHAAa9euVQGvtMDpArBfWcfPyHtIK7QEVyNGjEDUqFH1wc3Ro0dhbW0dIp+DtBRKUGpjY6OCKgnMBwwYgFy5cqn3Fx8+fFDv++TJE/To0QPJkiVTQZhhoPer292pUyf1XvIZSuD18uVLHDt2DNeuXUP+/PkxZMgQeHl54dGjR3B0dFSviRs37k//P97e3ibzkGVd/kmOdpEiRfRfXiRQ3blzJ9q2bYu3b9+qQFzI7wsWLFAt/+3bt1dB+sKFC1G5cmWcPn1aBZDyWgk0O3fujLp166rPU+TOnfun2yxfBiTYXbVqlXq9uHDhAq5cuaLe9+LFiwFeI+8lQbn8vUWPHh3btm3Dv//+q+4wdOnSxWjZW7duoVGjRuozb9mypdof8ncpX9DkywURUbjlQ0RBWrx4sY8cKvv27fN5/vy5z8OHD31Wr17tkyhRIp9YsWL5PHr0SC338eNHo9d9/frVJ2fOnD7lypUzmi7riho1qs+VK1cCvFdw15E2bVqfli1b6p8fPHhQrVd+iu/fv/tkzpzZp3Llyup3w/WnT5/ep2LFigH+f+7u7kF+DiNGjFDLyWegU7p0aTVt6dKl+mlfvnzxSZYsmU+9evX00xwcHNRymzdv1k/79OmTT9asWX97uy0sLHy6dOkS5DZXr15dfVbBJcvK9gT1WLdunX75tm3b+iRPntznxYsXRuuxtbVV26fbn9++fVOfi6HXr1/7JE2a1KdNmzb6afLZynvIZx0cuv0u2+Ti4uITJUoUnwcPHqh5/fr188mQIYN+P+XIkSPIvzUhn7vuNf4/kw0bNuineXl5qf93vnz5grWdRERhhakLRMFUoUIF1eqWOnVq2NraqtbBTZs2qVv1QlINDFs5pQVQbk/rbqUbklvx0grp36+sIyhubm6qFa5JkyaqpVNaKOUhLavly5fHkSNHVMtdSJDPoVmzZvrn5ubmqtX17t27+mnS8iefk7Qe6sgtcGnd/N3tjh8/vkpx8PDwQEgqXLgw9u7dG+AhaSWG5DvLhg0bULNmTfW7blvlIS21su90+01SB+RzEbL9r169wrdv31TO96/u28BUqlQJCRMmVHcBZHvkZ1C544Z/a7Ktst3ydyn7zX/rdYoUKVQrs068ePHQokULnD9/Hk+fPg2R7SciCg1MXSAKppkzZ6qyYnKbV/Ixs2TJom6r60h6wdixY1Ww9uXLF/10ua3tX/r06U2+x6+sIygSLAq5zRwYCWYSJEiAP5UqVaoA2yfrNbxdLnmyGTNmDLBcpkyZfnu7JQ9YlpMvHpLmIB2yJPjKkCHDH/1/JJVEvtT4J/vd0PPnz/HmzRvMmzdPPUx59uyZ/ndnZ2c4ODjg+vXrKj3iZ38Lv8rMzEylE0hKiHzRePjwofrCEBjJeZbUkBMnTgSoHCKfseQSG+4n//tOjgVdbrGkohARhUcMdImCSYIHXdUF/yR3VForS5UqhVmzZiF58uQq8JBcRlNlnwxb0353HUHRtXpOmjRJ5X+aEpx81eAw1dFJ+GZpINS2W/KBpbVbWtWlo5S8ZuLEiaqTlC43ODTptlVaswMLzHX5tVLjVgb4qFOnDvr166c6gMnnNn78eH2ud0iQwHbOnDmqA1uePHlM3jUQ8p7SQp41a1ZVOUS+LEiL844dO1Q+c0i19hMRhTUGukQhQG5hy614qSIgPdh1JEj9m+vQkdZT3S1mU62Tf1vatGlVZQYJfg1bBm/fvv1H2y1fBqQDlTyk9VQ6odnZ2ekD3V9tCf8Vksbyzz//4L///vvptkqnOWlpliDccJukRdXQn25viRIlkCZNGlXFQoL+wEjHM7ljICXJZHkdU50DdfvJ/767efOm+hkalSyIiEIKc3SJQoC0zkkQIEGPjtzS3bx5819dh47cypegUfJK379/H2C+3Hb/myRnVcpwSWCl8/nzZ8yfP/+3tls+I/95pNJKKrmkhikfUsbLVLWEkCD7q169euoLyuXLlwPdVt2y/lu5Jb9Y0gb8V08QkhLxO+TvZ9q0aSqAbt68eZDb7n975HMK7EuV5EFLy7mOVJFYunSpanVn2gIRhWds0SUKAVL6S24BS5ktuX0srYuS0yu5jaZKO4XWOnQkd1jKSknLppSQat26teoMJsGmtNpJi6m06v0tHTt2VCPKSecoKS8mLbFSR1g3SIaupTC42y3luSQ3uH79+uoWvaQz7Nu3D2fOnFF5sIaB85o1a9C7d28UKlRILSedx0LKhAkT1HZJBzbpWCepAtLRTDqYyfbI70Lq0EprrnTokv0stZclxUCWNwzoJaVFpsk2Sw6sdC6TOsW/MnyvlBmTx886rkmqgnwWsm9kG+RLh3xZkBJw/sm2SMk0+XwlP13qBEtptd+520BE9FeFWb0HoghCV37rzJkzQS63cOFCVRorRowYqmyWvE5XksuQPA+sLFZw1/Gz8mI658+f97GxsVGl0GSd8rqGDRv67N+/P8D/73fLi/kvWyVk2/yX9bp7964q9yUl2ZIkSeLTp08fVbJK1nny5Mlf2m4p1SXls/LkyePzzz//+MSJE0f9PmvWLKP1vH//3qdJkyY+8ePHV+/zs1JjMl+28WelvAx5enqq/Zk6dWofMzMzVVqtfPnyPvPmzdMvI6XSxo0bp9Yv/x8pyyXlwEx9TsePH/cpUKCAj7m5+U9LjQW2Tf6Z2k9bt271yZ07t0/MmDF90qVL5zNx4kSfRYsWBfhb0H0mu3fvVsvr/jZ/9p5EROFBFPnn74bWRES+pk6dqkZIk0EddGXaKHyRHFxpUZaKIEREEQ1zdInor/j06ZPRc8nRnTt3LjJnzswgl4iIQgVzdInor5AhbaWHv3Rgko5PUnJLaspKri4REVFoYKBLRH+t8oJ0NJPAVqomSKcrGb2rUaNGYb1pRESkUczRJSIiIiJNYo4uEREREWkSA10iIiIi0iQGukRERESkSeyMRkRERJGe94u7iIjMEmcI600I1zQb6Hp73gjrTSA5AJNmgZk5a6SGF95fH8P72a2w3gySY8MyM89T4eg8xX0RfvYFUUhi6gIRERERaZJmW3SJiIiIgu37f2G9BRQK2KJLRERERJrEQJeIiIiINImBLhERERFpEnN0iYiIiHy+h/UWUChgiy4RERERaRIDXSIiIiLSJAa6RERERKRJzNElIiIi+s4cXS1iiy4RERERaRIDXSIiIiLSJKYuEBERUaTnw/JimsQWXSIiIiLSJAa6RERERKRJDHSJiIiISJOYo0tERETE8mKaxBZdIiIiItIkBrpEREREpElMXSAiIiJieTFNYosuEREREWkSA10iIiIi0iQGukRERESkSczRJSIiIvr+X1hvAYUCtugSERERkSYx0CUiIiIiTWKgS0RERESaxBxdIiIiItbR1SS26BIRERGRJjHQJSIiIiJNYuoCERER0XemLmgRW3SJiIiISJMY6BIRERGRJjHQJSIiIiJNYo4uERERRXo+LC+mSWzRJSIiIiJNYovuL3J1u4zFqzfh6o07eP7yFZzsBqN8ySJGy9y59xCOc5zheuEy/vvvP2RIlxpTxwxC8qRJ1PwXL19j8uzFOOHqho8fPyFd6pTo0LwhKpYpFuR7r9q4Xb33i1evkSVjegzu0QG5slvp53/58hWTZi7CzgNH8dXbG8UL5cPQ3p2QOGECNX/zzv0YOt7J5LoPb1mKRAniIyKLGjUqhg/vgyaNbZAsWRJ4eHhi6bJ1GDduqsnlZ86YgA4dmqNPnxGYNn1BoOvt378r6tapiixZMuHTp884cdIVgwePw82bd/TLxIgRA5Psh6Nhw9qIEcMce/YeQrdug/Hs2Qv9Mo5TRqNYsULIkSMLrl+/jYKFKkFTx8WqDQbHxRCUL1XUxHGxWC3re1ykwdSxclxY/jguZi3CCdfzfsdFKnRoIcdF8UDfd/6ytdh35ATc7z9CzBjmyJszG3p1boX0aVLpl2nVbaB6T0MNalfBiL5d9c/HTZ0Lt0tXccv9PjKkTY0Ni6cjsp6jHj/xROVG7U2u22FUf1QuW8LkPDkvyTqPn3HDu/fvUSBPDgzu0RFpU6cI9jnqjddbDBjjgJt37uPN27dIGD8+ypWwRo8OLRA3TmxENGG1L+T4cZzrjAPHTuGN1zukTJ4UTevXQKPaVY2Wc7t8HdPmL8OlazfV+TNrpvSY6zAKMWPE0C9z+MQZzFmyBjfv3EMMczMUzJsT08YNCZHPh+hvYKD7iz59/qKCzLrVKqDn0PEB5j94/AQtug6ETfUK6NKmMeLEiY077g9gbm6mX2aQnSPevf+AGeOGIn78eNix9zD6jLTHmnkOyGaV0eT77tx/FPYzF2J4n3+RO7sVlq3bio59R2Dbitn6AHXijAU4csIVU0b1R9y4cdTFW7Zx+Sx7Nb9KuRIoYZ3faL1Dxk/Fl6/eET7IFf36dUHHDi3Qpm1PXL16AwUK5MGC+VPw1ustZsxcZLRs7dpVULhwfjx+/OSn6y1Vsghmz3aG61k3RI8eHWNGD8SO7SuRO08ZdUERDpNHomrV8rBt3FG9n5OTHdatXYDSZeoYrWvJktWwts6PXLmyQUs+ff6MLJkyoG71iug5ZJzp46JLf9hUr4gubZoaHBfm+mUG2U1RAdKM8cMQP74Fduw9hD4jJmLNfMdAjwsJJBrXrY6c2TLj23//wWnuUnToPQxbls1G7Fgx9cvVr1kZXds20z+PGfPHhVxHtv3i1Rvqgh6Zz1HJLBPj0CZno9es27Ybi1dtQsnCBUy+p4+PD3oMGYfo0aKpIChunFhYumYL2sm+WDpTvy9+do6KEjUqypYojG7tmiFhfAu1rXaOc+DlMAv2w/siogmLfSHkWnHq3EWMH9obKZNZ4viZ8xjrOAeWiRKqz1cX5HbqNxLtmtbH4J4dES1aVNy4fQ9Ro/y40bv30HGMmDQDPTo0R+H8uVUgfuvuA2gWy4tpEgPdX1SySAH1CMy0+cvV/D6dW+unpUmZ3GgZtyvXMax3Z31rbMeWjbB03VZcuXkn0Av60rVbUL9GJXXCFBLwygVj0/Z9aNesvgqcN27fB/vhfVC4QB61zJiBPVCr+b+4cOU68uTIqr6lG35Tf/XGC6fOXcLoAd2gBUWLFMS2bbuxc+d+9fz+/Udo1Kg2ChXKa7RcihTJMNVxLKrXaIItm5f+dL01av4IkETbdj3xxOMS8ufPjWPHTiFevH/QurUtmrfoikOH/qeWade+Fy5fOoLC1vlx6vQ5Na1X7+HqZ+IkiTQX6JYsUlA9AjNt3lI1v8+/bQI/Li5fw7De/yJX9izqeceWturv/sqN24EeF3MdRhs9txvcC6VqNcXVG7dVy5NhYJs4kW+roSlyodcdExE90P3Tc1S0aNECfFb7j55A5bLFETt2LJPrvP/IAxeu3MBm5xnIlD6NmjasT2eUqdMSO/YfUeeu4JyjLP6JC9s61fTrTZHMEo3qVFOBXUQUFvtCF8TWrlIO1vlyqecNalXBuq27cenaLX2gaz9jAZrWq6GuHzqGd0K+ffsPE6bPR5/OrVCvxo+7TxnT+e5fooiCOboh6Pv37yr4TJc6BTr0GYFStZqjcce+2H/0pNFyeXNkxa4DR+H19p16jVwIvn79CmuDC7Mhb29vXL15G0UK/gjY5DZTkQJ51AVCyIX927dvappOhrSp1O0vuQCZsnXXAcSKGQOVfpIyEVFISkHZsiWQOXMG9Tx37uwoXswau3Yf1C8TJUoULFk8DVOmzMbVqzd/630sLOKpn69fv1E/JeCVlsn9+4/ql7lx444KtIsEcZGLlMdF72EoVbMpGnfojf1HThgtJ2kHRsfFvsO+x4XfxTo43n/4oH5axItrNH37nkMoUaMJ6rT4F45zlqgW6MgouOcoQ/JF4/otd9UaH5ivX73VT8M7V3KOMjMzw/mLV3/7HPXsxUuVmlIwbw5oTWjtC5E3Z1Yc/N9peD5/qVrbT5+7iHsPPVDM70v/y9dvcPHqTSRMEB9NO/dHqdrN0arbIJzz21fi2s076vWyH+u37aG+tEgL8K2790PwUyAKfQx0Q9Cr1174+OkTFq7YgBKF82OewyiVjyW3rM4Y5AhKbpV8Wy5eoynyl6+H0ZNnYerYwUiT6kcum6HXXm/x33/fA6QXJEoYHy9e+QZb8tPMLDri/WN8gZfXSO6jKdK6Uq1CKaNW3ojM3n4G1q7bgsuXDuPjh3s4c3q3yr1dZdAaJOkNcrGdPmPhb72HBMoOk0fhf/87jSt+F2fJB/7y5Qu8vN4aLfvs2XMkTeablx2Z/Tgu1qNE4QKYN2WMyt/tOXQczpy/pF/OYdQAtW+KV2+M/OXqYvTkmZhqNyTQ48JU4DBh2nzky5UdmTOk00+vXrEMJgzrg0VO49CuWQO47DmIgWMcEBkF9xxlaOP2vSpvOV8QdyHS+wWsTvOWwuvde/XlXN7D8/kLPPc7//zKOarfqEkoWLE+ytm0RtzYsTG6vzbuOv2NfSEkNzpj2tQoX6818pWzQcd+IzGkV0f9XY5HHk/Vz1mLV6F+zUqYO2mkumvSttdQ3H/ooeY9fPJjmY7NG2HmxGFq37XuMVh9GSWKKJi6EIK++5UmkVtDLRrWVr9nzZxB3UZau2UnCvmdZGYsXKFu4y1wHIP4FvFw4OhJ9B1pD+fp42GV8ccFOjTJNt29/xDjh/aCVjRoUBONbW3QvEUX1VqbJ08OFZQ+eeKJZcvWIX++XOjWtS2sC1f57feYPm2c6kxWpmzdEN32yHFcFEGLRnUMjotrvseFX4vtjAXL/Y6LsSp3XR0XIybCecbEYB0XY6fMxm33+1g60zffU0du2+rIepIkSoi2PYeo/Ej/6RNaF9xzlM7nL1+wY98RdGzRMMj1mkWPrjoWDp84HcWrN1H5ntJyK3mkPvD55e0c0LUdOrdqjPsPH2PqvKUq51TSvbQktPaFWLHBRbXYzhg/FMmTJcFZtyuwc5wLy8QJUbRgXnz/7rtPGtSqrE+Hk0D35NkL2LhjL3p1bAkfv2U6NG+g7yg9dmAPFTzvPvg/NKz9++fRcIvlxTSJgW4ISmART3XGkG/ShuT23LlLvreE5OK6cuN2o1w26ekqt4xWbdqBEX3/NbleuXDI7SZDL1+9QeKEvq288tPb+xvevntv1GIirzGVm7jBZQ+yZk6PHFkyQSsmjB+GSZNmYO3arer55cvXkSZNKlU1QQLdEiUKw9IyMe7eOa1/jXQus7cfjm7d2iGzlXFvaP+cpo5FtWoVUK68jVEntqdPn6uqC5LSYNiqa2mZBJ5PnyOy0x8X6fwfF6n1t0p9jwsXbF46E5nSp1XTsmbKgHMXrmDVJhejCgmm2DnOVr3DnadPUB14gqLLAX74yCPSBbrBOUcZ2nPouOpQVatKuZ+uW84lGxY5qS8r3t++qc5kcited475lXOUPJeHbJdFvH9Uh61OLRohSeKE0IrQ2hcSEDvNXwYnu0EoXbSQmiYd4q7fdseS1ZtUoJvE7/M2dUw+9fStFPNjmR85uZKakipFMjx5xvMaRRxMXQhBko+WI2tmuD98bDT93iMP1alCfP78RX8L3JDkQQVWrFrWm90qE06dvWB0m1Z61UoHDpE9SyYVtJ06e1G/jPuDR3ji+Rx5cvhe2HWkUoB8I7epFnSeV0QjnTN0LRU60ktYPluxfMUG5C9QQZX10j0kYHWYMhvVazT9aZArlRoqVW6Ie/ceGs07d+6iyiUtV+5HqR8rq4xImzYVTp48i8hOHRfZMsP9gb/j4uFjE8dF1IDHhb99akjyDyXIlXzfRVPt1EX4Z67fuqt+Jk6knaApJM9R/m+Vly1urYLW4Ponbhy1vNwCl5xSXeenXzlHGZJznZByZFoSWvtC0uIkBciweoKIFjWq/vwo5cakdfeev2Py/qPHqgVYt78ksJV9pCNfYB4/9UQKv1KZRBEBW3R/kQSJ0vqkI3UO5cIprQ6So9a6cV30HTkJBfPkUJ1ojp06h8PHT2Ox0zh9Lpu0Ikn+Yd9/28DC4h91i1Zq6s6cMCzQ95VbW1IKTFpHcmazwvJ1W1VN1zrVyusvLlKiRm7xSUccKVMzbuo8FQjrgmEdqWEpAWCNSmWgJdu378XAgd3x4OFjVV4sb96c6NmjA5Y4r1bzX716rR6GpIVJWl0Na+KaSlewta0Dm3pt8O7deyT1O8l7eb3D58+f8fbtOyxevBqT7Efg1as3ePf2HaZOHYsTJ1z1FRdExozpVEmlZEktETNWTJVaISTNQnIatXlcxFV1cls3tkHfEfa+x4VUqzh11ve4mDb+x3GRSo6LGX7HhaQunPA9Lib6VqsILF1BOq1NGzcUcWLH1ud6xo0bW+WeyzZJmbKSRQshfrx/VEWFidPno2CenMiSKb1+PQ8eeeDjp8+qFqzUetUFw9LiJQFJZDpHGX4mZy9cwWz7wD9/Q7sPHkOC+BbqPW7duYcJ0xegXInCKG6dL9jnKOmcJS28ObNmViXJbt97AIdZS1ROqgRnEU1Y7AupNyy5uA6zF6ua3hKUul64gq27D6Jf1zb6hpbWtnUxc/EqdRzIXcUtuw7A/f5jTBk9UL+ehrWqqBzdZJZJkCJZEn31i0qB1O8lCo+i+EiTiAZ5e5ruxfunTp+/hDY9AhbLllIudoN76r95L1i+XvVYTZcmJbq0boxyBkXCpaVDinnL7SkJVlOnTI5WtnVRq3JZ/TKtug9W9Q916xQrN7joB4yQ27qDerRHbr/bsIbF2KWKgwROxQrlU3lt/m8LSi/bVMmTYuLwPghtZkmzwMw8Jf4GCSJHjeyvWl4tLROpASPWrN2CsWMdAw0kb908ienTFxgNGLFv7zpVMaFtO9/8Ze+vxq0eOm3b9sLSZWuNBoyQcmbyu27ACE/P50brLV06YIWLTJkLq/f7G+T/4v3sVoiv9/T5i2jTfXCA6bWrlIfdEN/PceP2PViwfB08n/kdF22a+jsuHvseFxfluPjkd1zYGN2qlcEfUiZLql9nzpI1TG7P2EE9UadaBdVaOGiMgxoIQiotSFpD+ZJFVekywwEITA0qIXavXRhqAZaZZeZQOU+FxDlKSG6sy55D2LN2gf6uiKFKDdupdXZp00Q9X75+mwqEJFCV295yPuvUspHRF4WfnaOkOoDT/OWq/4BUcpD9VaFUUbRtWi9AJ7aQPk9paV/IFz55jdTP9Xr7XgWpUktaGkwM7ybK+0rK3Nt372CVMb0qJZY/d3ajFtypc5di256Dat9JScyB3drr0+5Ca1+ElS/XDyMiipG1dFhvQrjGQDecqtigrTpp1anq22IbUf3NQDek3L51CqNHO+iDWC0JrUD3b6lYv7UKkCWIjehCK9D9GyRXtESNppg9acQvlX8Lr0Ir0P0btLgvwgoDXW1ijm44dNv9gWptMmzhpb8je3YrvH37FsuWrwvrTSF/pKJC3DhxgtUxikKXtOBLCooWAquIjvuCKJy36M6YMQOnT59GtWrVYGtri2XLlmH8+PGqA4KNjQ1Gjx6tOjAERuqXysOQ3DqO+iZij26kFRGxRVfLInqLrpZE5BZdrYnILbpaE6Ytutd+DC4UkcTIxkaxcNuiO3bsWAwePBgfP35Er169MHHiRPWzadOmaNmyJRYsWIAxY8YEuQ4Jii0sLIweMo2IiIiIIrcwbdHNlCkT7O3tVcvthQsXUKBAATg7O6tAV2zatAn9+/fHrVuBt0CxRTd8Y4tu+MIW3fCDLbrhB1t0ww+26P46tuiG4xZdDw8PFCxYUP2eJ08e1Zs0b17fsbhF/vz51TJBkaA2Xrx4Rg+Z9je98XqrximX0jHh0Z17D9RoNlI+KTJImDABHj+6oOrYhkfSC12qPRTInxtap46Nmk3D77Hh/gDlbVpGimMjvJ+npAqDVA+4fF37X8TC+76IbNcM0rYwDXSTJUuGq1d9R4CRVlup7ap7Lq5cuQJLy4CFs8ObecvWqaLoujJEchLr2HcEytZthXzlbVC+XhvYOc7B+w8fQ3U7pHG+U7+RyFmqFvYfPamfLiPbSBmypWs3IzIYNLA7tm3bbVSyq2CBPNi9aw2eP7uKZ55XsN1lBXIblNEJSVIfVAaYcL/rirdet3HhwkF0aN/c6ILu6DgH48YFLDukNfOWrjE6Nq7fvot+I+1Rvl4rFChvg5rNOmHZui2h9v5SNkxKkBk+Rk2eoZ+fMb3fsbHGtz6olvk/T4lxTvPQsF0vdZ6q16ZHqG/DnXsP0XXgWBSpaotClRqgUYfeqgSc7gtgq0Z14DjHGZFxX8jn0Ln/aBSsWF8FwZNnLVaDP4Q0Ca7lGmHqIbWQI+M1Q08GJ4mIDwq/A0ZIikKLFi1Qu3Zt7N+/X6Up9O3bFy9fvlS1/uzs7FC/fn2E99IuUgdx7uSR+mlRokZVJ7Fu7ZqpUWykYLgEul4Os2A/vG+obcuydVsRBcYjrunIwBIj7WeiXdMGiB49GrQqVqyYaN3aFtWrNzUKPF1cVsDFZQ+6dR+s/v/Dh/dVwW76DIXUKEIhafKkEShTpjhatuqG+/cfomKF0pg+fRw8njyFi8tetczKVZvU0MNS5UEGjNAiqVurjg2H0fppV2/cRsIEFpgwtA+SJU0Ct0vXMGrSDDVqU5N6NUNlO6R+aNe2zfTPY8Y0vuNTp1pFjLSfjnbNGmr22DB1ntKpW60CLl67qQbTCE1yHpShfGXQiC5tGqvjUlrUZfQtneqVymDSrEWq8kxo1moNb/tCGnn+7T8aiRLFx/JZ9nj+8jUG2zmqv8eeHVqE6PtLbeJDm4y/TKzbtlvVQC5ZuECku2aQ9oVpoDtq1CjEihULJ06cQPv27TFw4ECVwiABr3RQq1mz5k87o4W1oyddYW5mZjT6mMU/cWFbp5r+uQzn2KhONf2oMqFBRttxXrMZa+ZNQZm6LQPML1YwL7zevYPrhcsoUiAPtKpq1fKqsLnhiGRZs2RCokQJMHLUZDx65JsKM3bsFJw/t1+lN9wJ4Qt8kaIFsWz5ehw5ckI9X7BwBdq3b4ZChfLpA903b7xw/LgrGjasjZEjJ0GLjp4IeGzYVK9ktEzqFMlw4cp17DtyItQCXQls/Q+aYqhYIb9jw+0SihT8kTqlJabOU2Jwjw7q56tFXqEe6E6bvxwlixRAn86t9dNklEhDcu7MlzMbdu4/ohoKIsu+OH7GDXfuP8R8x9FInDABsmYGurZrqlq3ZQCJkBydL1q0aAGOh/1HT6By2eJqGPXIds0g7QvT1AXJyZWqC9u2bcOgQYNUK66UGHvw4AFevHiBxYsXI06cOAjPzl64iuxZMga5zLMXL9WFvGBe3yFfQ6OFoP9oBwzp2THQC7qcKGWYRxlGUstKFLfGuXMXjabduHkHL168Ui298jnEjBkTrVs1xtVrN3Hv3sMQ34aTJ1xRs0ZFpEiRTD2X0dAyZ86AvXuNi5GfcT2vtlerzl68guxZMv10uXfvP6gAJ7Rs33MIJWo0QZ0W/8JxzhLV0hzw2MigtlergnOeCk1SLlKG902XOgU69Bmhbs037tjXKMVKJ1c2K5y9+COFLTLsC/mylzlDWhXk6hQvlE+lu0nrdmi6cuM2rt9yh031ipHymmHE53vEfFD4bdHVgieez5AkUUKT8/qNmoSDx07h85evKFPMGqP7dwuVbbCfvgB5c2YNMGykf7Kdunw4rUqTNhWe+Ovg8f79B1SoWB/r1y3EEL9hN2/ddkf16k3ULcOQ1qPnMMyZbY/7986qfFy5yHfq3B/Hjp0yWu6JhyfSpAmfHeZCwpOnz5EkseljQ+f8pWvYfeAoZtqPCJVtqF6xDFIkTYIkiRPh5h13Fejee/gYTnbG+dGynbK9kfE89Te8eu2Fj58+YeGKDaqltnenljh26hx6Dh2PRU52KJQ3p7998QyRaV/IsO6JEsQ3mpbIL+h98epNqG6PpFFkSJsa+XJli5TXDNI+Brp/SIJYS3Nzk/MGdG2Hzq0a4/7Dx2rccfuZC9W47qZIJzJdK4ZcmLcsnYnaLbrAw+8kUyB3dsyZFDC/TgLpU+cuYv3CqT/d1pgxYqjWXy2LFTMmPvv7P0oL7ry5k3HihCuaN++ibt316t0JW7YsRdGi1fHZXwufmDljApo0sdE/T5DQCtu2LkOJEoXV8/sPHiFvXtMjdHXp0hrWhfOjTt1WePDgEUqWKIxpTnbw8PDEgQNH9ct9+vTZ6Fah1nz+8gWW5okCnX/r7j10HzQGnVs3RnHr/IEu16nvCH1ra4qkltiybBZqN/8XHp6+wVCB3DkwZ/Iok69tUKuK/nerjOnUhbttzyEqX9TwtnnMGOb45K9MYWQ5T/2KUZNnwWXvIf3zM7vXmjx3+ffdr9VJ+i60aFhb/Z41cwa4Xb6OtVt2GgW63BfB87vXDONt+YId+46gY4uGkfaaQdrHQPcPJbCIh7fv35ucJ2kE8siQNhUs4v2jOmJ0atHIZCvXqP7d9PWAdSPBzbYfoe8oFVjJNAlyH3o8RdHqjY2m9xo2AflzZ8eSaeP00yTfSnIitezly1eIn8DCaFpj2zpImzY1SpSspSpTCAl4pQJDrVqVsHbt1gDrGTlqEqY4zjGa1rFTP9XZTUhLrSkSVI8dMxD1G7TDzp371bRLl64hT54c6N2ro1GgmyBhfDx/8RJalSB+PLx9Z/rYkE5IbXsORf1aVdCxpW2Q6xk1QI6Nr8bHxqSRBsdG8IOGXNl9a3Q+fORhFOh6vX2P1CmTRcrz1K/o2rYJWtvW+em5y9T7R48WDRnTpjaaLufGc5eM0xRkX0gn3si0LyRl4dI147JqL1+99ptn3NL7p9cMQ3sOHVeBbGDDakeGawZpHwPdPyStEoYtHIGR29fiayABUtIkAVu+pBPbz7RrWh/1ahh38Knbqhv6d22LMsUKGU2/dfcBKpYuBi0773YZTZvUM5omraby+RuOjaJ7Lnnipjx//lI9DHl4PP3p+5uZRYe5ubl+f+v899/3AO+VM0dWXHDTbv5b1swZ4bInYAH22+730abHENSuUg49gtGjPGmSxL91bATWaVMk9nfr+Jb7fVQsUxyR/Tz1M3J73f8tdlPnLv8k3zNH1sxwf/jYaPq9Rx4B9qXsC9neyLQvpGOalBx7+fqN/vM94eqGuHFiq1JfIXnN8J+2ULa4daBfLCLDNcMIS3VpUph2RtOC4tb5VOuUl0HLlXS62LRjH27dva9qFh4+cQajHWarHCjDuokhQVqMpROD4UMkT5oEqQy+ict2SKe4ohrtVa4jHb6kZFd8gxP3vv1HkCCBBaZPG4esWTOp+QsXOKqWj0OHjofo+7979x6HDx/HhAlDUapUUaRLlxotmjdEs2b1sGXLLqNlixe3xt59xh3UtETSEfwfG5Ku0Kb7YBQrlA8tG9XFi5ev1UNyOEOapCfMWbJKdbaRv39J8xlsNwUF8+RElkzpjY+N59o+Nkydp8SDRx4q+Jc8UGk1l9/lEdgdiz/RunFd7DpwDOu37Vbvu3KDCw4fP21UoUacu3hV/X1Epn0hlT+ktXvQWEdcv+2O/50+h+kLVsC2bjWj8mshSfaBdDSrV8O4E1pku2aQ9rFF9w9J3l82q4zYfeAYGtauos8xW79tD+xnLMTXr96qbmGFUkXRtqlxS+PftGP/EXUy/d2WsIji8uXrOH/+EhrUr4n5C5araTdu3FH5ssOG9sbRI1tVa6ub2xXUqNEMT0Oh00vTZv/CbuwgLHWejoQJ4+P+g8cYPtwec+ct1S9TpHABWFj8gw0btkP7x8ZRNKxdVU3bc+h/ePXGS7X0Grb2yt/lnnWLQvT9zaJHx0nXC6q+tFRakONQWqf8p0rs2HdYBVZaPjZMnafEcPsZcHW7rH9ev61vZ83da+aH+JdyOQcO79MZC5avx3in+UiXJiUcRw9UKVY6krMrnUcrlSkWqfaF9BuYOXEYxjjMRrPO/VRfA0kn6NrmRz3wkLZxxz7VKhzYl4rIcs0g7YviY3g/V0P+5rjl0mLrMGsJNjtPD/RWeFiS1plqTTph4vA+yJ8rdEYDC2rccjPzlH+9lq60qEpnsfD6571ixWxcvHgVEydO/6vv6/31Mbyf/b0hVg8fl2NjETYvnRl+j43GHTBxeD+jgOtvMLPMzPOUP31G2CNLpnTo0Nx056jQPE9xX4Sfa0ZY+XJxNyKiGLkrh/UmhGts0Q0BpYsWwoOHHvB8/lKlDIQ3Uh6mfbMGf/2EFVakE1jmTOmRMmVy/QAR4YnkK0rLs5PTfGhd6WKF1C3ScH1sNG/414PcsBDez1MSXFllSKuvyqBl4X1fRLZrho6PT8iXm6SwxxZd0lyLLoWfFl0KPy26FH5adCl8tuh+vrADEVHMPMZ57mQs/N0zISIiIiIKAUxdICIiIuJwuprEFl0iIiIi0iQGukRERESkSQx0iYiIiEiTmKNLRERExCGANYktukRERESkSQx0iYiIiEiTGOgSERERkSYxR5eIiIiIdXQ1iS26RERERKRJDHSJiIiISJOYukBERET0/b+w3gIKBWzRJSIiIiJNYqBLRERERJrEQJeIiIiINIk5ukREREQsL6ZJbNElIiIiIk1ioEtEREREmsTUBSIiIqLvTF3QIrboEhEREZEmMdAlIiIiIk1ioEtEREREmsQcXSIiIiKWF9MktugSERERRRJHjhxBzZo1kSJFCkSJEgWbN28OsMy1a9dQq1YtWFhYIE6cOChUqBAePHign//582d06dIFiRIlQty4cVGvXj14enoarUOWr169OmLHjg1LS0v069cP3759M1rm0KFDyJ8/P2LEiIFMmTJhyZIlAbZl5syZSJcuHWLGjInChQvj9OnTv/T/ZaBLREREFEl8+PABefLkUQGkKXfu3EGJEiWQNWtWFYhevHgRw4YNU4GmTq9evbBt2zasW7cOhw8fhoeHB2xsbPTz//vvPxXkfv36FcePH4ezs7MKYocPH65fxt3dXS1TtmxZuLm5oWfPnmjXrh12796tX2bNmjXo3bs3RowYgXPnzqntrly5Mp49exbs/28UHx8fH2iQt+eNsN4EAmCWNAvMzFOG9WaQH++vj+H97FZYbwbJsWGZmeepcHSe4r4IP/sirHw+sQoRUcyijX/7tVGiRMGmTZtQp04d/TRbW1uYmZlh2bJlJl/j5eWFJEmSYOXKlahfv76adv36dWTLlg0nTpxAkSJFsHPnTtSoUUMFwEmTJlXLzJkzBwMGDMDz589hbm6uft++fTsuX75s9N5v3rzBrl271HNpwZXW5BkzZqjn379/R+rUqdGtWzcMHDgwWP9HtugSERERSR3dCPj48uUL3r59a/SQab/3EXxXwaeVlZVqOZWUAwk2DdMbzp49C29vb1SoUEE/TVp/06RJowJdIT9z5cqlD3KFrE+27cqVK/plDNehW0a3DmkNlvcyXCZq1KjquW6Z4GCgS0RERBRBjR8/XuXSGj5k2u949uwZ3r9/jwkTJqBKlSrYs2cP6tatq9ISJEVBPH36VLXIxo8f3+i1EtTKPN0yhkGubr5uXlDLSDD86dMnvHjxQqVAmFpGt47gYNUFIiIioghq0KBBKo/VkHTu+t0WXVG7dm2Vhyvy5s2r8mwl9aB06dKIaBjoEhEREUXQIYAlqP3dwNa/xIkTI3r06MiePbvRdMm/PXbsmPo9WbJkKq1AcmkNW3Wl6oLM0y3jvzqCriqD4TL+KzXI83jx4iFWrFiIFi2aephaRreO4GDqAhERERFBUhKk89eNG8adM2/evIm0adOq3wsUKKA6q+3fv18/X5aXcmJFixZVz+XnpUuXjKoj7N27VwWxuiBaljFch24Z3TpkW+S9DJeRFmd5rlsmONiiS0RERBRJvH//Hrdv3zYq8yXlvRImTKg6lEm920aNGqFUqVKq9JdUQJBSYlJqTEgOcNu2bVW6hLxGglepgiDBp1RcEJUqVVIBbfPmzWFvb69yaocOHapq7+panzt16qSqKfTv3x9t2rTBgQMHsHbtWtUZTkfeo2XLlihYsCCsra0xdepUVR6tdevWwf7/MtAlIiIiiiRcXV1VAKujy++VgFJq3UrnM8nHlQ5t3bt3R5YsWbBhwwZVW1fH0dFRVUCQgSKkwoNUS5g1a5Z+vqQcuLi4oHPnzioAlkEnZP2jR4/WL5M+fXoV1EousJOTE1KlSoUFCxaodelIwC3lyKT+rgTLki8sgbf/DmpBYR1dClWsoxu+sI5u+ME6uuEH6+iGH2FZR/fTkYCjckUEsUq1CutNCNc026IblgcLBQyuKHwFWBQ+8DwVfnBfEGmTZgNd7xd3w3oTSC4eiTOwRTe8teg+uRbWm0FybCTPxtb18NS6zuMi3BwXRCFJs4EuERERkdbLi1HQWF6MiIiIiDSJgS4RERERaRIDXSIiIiLSJOboEhEREfkwR1eL2KJLRERERJrEQJeIiIiINImBLhERERFpEnN0iYiIiFhHV5PYoktEREREmsRAl4iIiIg0iakLRERERCwvpkls0SUiIiIiTWKgS0RERESaxECXiIiIiDSJObpERERELC+mSWzRJSIiIiJNYqBLRERERJrE1AUiIiIilhfTJLboEhEREZEmMdAlIiIiIk1ioEtEREREmsQcXSIiIiKWF9MktugSERERkSYx0CUiIiIiTWKgS0RERESaxBxdIiIiIuboahJbdImIiIhIkxjoEhEREZEmMXWBiIiIiEMAaxJbdImIiIhIkxjoEhEREZEmMdAlIiIiIk1iji4RERERy4tpElt0iYiIiEiTGOgSERERkSYxdeEXubpdwuKV63H1+m08f/kKTuOHoXypYkbL3Ln3AI6zFqll//vvP2RIlwZT7YYieTJLNf/Fy1eYPHMhTpw5j48fPyJdmlTo0MIWFcuWCPR9K9VrCY+nzwJMt7WpgaF9uqjfv3z5ikkz5mPnvsP46u2N4tYFMLRvFyROmEDNf+P1FgNG2ePmbXe8efsWCRPER7kSRdGjU0vEjRMHEV3UqFExfHgfNGlsg2TJksDDwxNLl63DuHFTTS4/c8YEdOjQHH36jMC06QuCXHfnTi3Ru3dntd6LF6+iZ89hOOPqpp8fI0YMTLIfjoYNayNGDHPs2XsI3boNxrNnL/TLeH99HGC9TZt1xtq1WxHRuV64gsWrN+HqzTt4/vI1nMYMRPmSRYyWuXP/IRznLlXLquMibWpMHT0AyZMmweMnnqjcuKPJdTuM7IfKZYqbnJezTB2T03t3aok2tnXV710H2+H6bXe8eu2FeP/ERZECudG7Y0tYJk6oX/7GnXuwmzoXl6/fRoL48dDUpjraNLZBROTqdhmLV23A1RuyL17ByW4IypcqarTMnXsP4ThnsVpWf44aOwjJk+rOUa8xedYinHCVc9QnpEst56iGqBjIfhCrN+3Ams074PHUUz3PlD4NOrVqjJJFCuqXWbd1F7bvPYRrN+/gw8dPOL5jtdonhq7euI0pc5bgyvVb6piuWLoY+ndth9ixYyEiCs/Hhs7Xr95o3LmfOg7Wz5+CrJkz6Of5+PhgyZotWO+yBx6ez5DAIh4a1a6Kjs0bQHNYXkyTGOj+ok+fPiNLpgyoW70Seg4eG2D+g0ceaNG5L2xqVEaXds0QJ3Zs3HF/APMY5vplBo2ZjHfvP2DGxBGIbxEPO/YeQp/h47FmoROyWWUy+b6rFzjhu0H+0K2799G+52BUKltSP23itLk4cuIMpowdrALXcVNmqW1cPsdBzY8SJQrKliyCbu1bIGECC7Wtdg6z4DXpHexHDkBE169fF3Ts0AJt2vbE1as3UKBAHiyYPwVvvd5ixsxFRsvWrl0FhQvnx+PHT3663gYNamHSpBHo0mUgTp85j+7d2mH79hXIkbMUnj9/qZZxmDwSVauWh23jjur9nJzssG7tApT2d7Fp27YXdu85qH/+5s1baMGnz5+RJWN61K1WAT2HTQgw/8HjJ2jRbTBsqpVHl9aNESd2LBVsmZubqfnJLBPj0IbFRq9Z57JHBQglrfMH+r7+X3P09DkMt5+BigaBnXW+XGjftD6SJEoAzxevMHn2YvQaMRErZk5U899/+IgOfUeiSIE8GN67M27evY/h9tPxT9w4aFCzMiLkvlDnqIroOWSc6X3RpT9sqldElzZNESeO3znK3OAcZTcF796/x4zxwxA/voXvOWrERKyZ74hsVhlNvm8yy0To1akl0qZKAR8fYMuu/eg2aCzWL3JCpvRp1TKfP39BicIF1GPqXOcA63j24iXa9RqKKuVKYkivTmrfTJw2H0PGOcJx7GBEROH52NBxmOusvvhJoOvf+OkLcOKMG/p2boXMGdLC6+07eL17/0ufAVFYYqD7i0oWLaQegZk2z1nN79OlrX5amlQpjJZxu3wNw/p2Ra7sWdTzjq0aY+maTbhy/Xagga60vhpasGwtUqdMjkL5cqnnEjhvdNkD+5H9UbhAXjVtzJDeqNWkAy5cvoY8ObPBIt4/sK1bQ7+OFMmSopFNDdVCrQVFixTEtm27sXPnfvX8/v1HaNSoNgoV8v08dFKkSIapjmNRvUYTbNm89Kfr7dmjPRYuXAnnpWvV83+7DFRBbatWtpg0aSbixfsHrVvbonmLrjh06H9qmXbte+HypSMobJ0fp06f06/rjZcXPD2fQ2tKFi6gHoGZtmAFShbOjz6dWumnpUmZXP97tGjRkDiR750Hnf1HT6Jy2eJBtuT5f83BY6dgnS8nUqdIpp/WokEt/e8pklmiXZN66D50PLy/fYNZ9Ohw2XdY/T52QFeYmZmplsgbt92xdO3WCBnoSguqYSuqf9PmLVXz+/zbxuS+0J+jev/74xzV0hZL127BlRu3Aw10yxQvbPS8R4cWqoX3wpUb+kC3ecPa6ufp8xdNruPw8TOIHj06hvburFpzxfC+XWDTqqv6Yu7/XBoRhOdjQxw9dRbHz7ipFuSjp36cq3QtzWu37MKmxdOQPk1KNS1V8qQ//T8ThSfM0Q1B0uJ65PgZpEudEh16DUGp6rZo3L4n9h85brRc3pzZsGv/EfXNWF6zY98hfP36Fdb5cwfrfby9veGy56BqVZZWWnH1xi18+/YNRQrm0y8nt7/kVuSFy9dNrufZ85fYd/h/KJjXN1iO6E6cdEXZsiWQ2e+2W+7c2VG8mDV27f7Rgiqf15LF0zBlymxcvXrzp+uUwCd//tzYf+Co0a28AweOoUgR34uXzJfWsP37fyxz48YdFWjrltGZ5mSHJx6XcPx/LmjVshEizXFx0hXpUqdAh34jUapOS3WbVC7WgZGAStINbKpVDPb7vHj1BkdOnoVNtQqBLiPHnAS2eXNkVUGukECsYO7sal/rFLfOB/eHjzXXcqX2xQm/fdF7GErVbIrGHXpj/5ETAc9RB44anKMO+56j/L5Y/4zcfpfXSGumfNbBJbfQzcyi64NcEdPvbti5i1ehNWF9bMj0kZNmYfzgnvrP2f8Xj1QpkuLwiTOobNsBlRq1V63C8ndBFFEw0A1Br16/wcdPn7Bw+VqUKFwQ8xztVP6upA+cMWjBcBgzWAWlxas2RP4ytTDafjqmjhsW7NYKuSjJbcU6Bic6yamTC4T/fLdECePjxatXRtP6jZiAguXqoFydZogbOzZGD+wJLbC3n4G167bg8qXD+PjhHs6c3q1yb1et2mSU3iCf/fQZC4O1zsSJE6oWpmeeP3Jtheez50iWNIn6XfJ2v3z5Ai8v4zSEZ8+eI2ky32XEiJGT0KRJJ1StZouNm3Zg+vRx6NrlR6uaVklu7MdPn7Fw5UaUsM6PeZNGoHyJIug5fCLOuF02+ZqNO/YhQ9pUyJcz+EHS1t0HVAtXhZIBb81OmeuMQlUaoXit5njq+QLT7Qbp57149VodJ4YS+d1BkXna2xefsHDFepU+MG/KGJW/23PoOJw5f0m/nMOoAb7nqOqNkb9cXYyePBNT7Yb89Bx18849FKpUH/nL18UYh1kqPzhj+jTB3r7CBXLj5cvXWLRyg/pCL180HOcsUfMk31hrwvLYkC/sQydMQ8NalZEzq+k7iQ89POHx9Dn2HDqOcYN7YOzA7irXuNcIe2iSpAdGxAcFiakLIej7dx/1s2zJomjhl+yf1Soj3C5dxdrNO1Aon2+L7Yz5S1WqwQKncYhvYYEDR0+g7/DxcJ41CVYZ0//0fTa67EaJIgVhmSTRb23ngO4d0LlNU9x/8BhT5yyG/fR5KpUiomvQoCYa29qgeYsuqrU2T54ccJg8Ck+eeGLZsnXIny8XunVtC+vCVcJk+ww7xbm5XVG5kdLBzX/+sNZ89/E7Lopb69MIpLOL25XrWLt1NwrlzWm0/OcvX7Bj3xF0bNHwl95n0479qFGhlOoM6F/rRnVVa5aH53PMXrIGg8Y7Ydb4ofo7IpHFd7/ONmVLFEGLRnV+7IvL17B2y059KtSMBct9z1GOYxE/fjwcOHoSfUdMhPOMibDKmC7Q9cvt7Q2LpuHdh4/Yc/AYhtg5Ysn0CcEOdiXFwW5IL9jPWACnec6qZbdpvVrqi4hhK69WhOWxsWLjdtUhsF3TeoG+zsfnu+rYLEGu3KkUo/t3RcMOfeD+4LE+nYEoPNPemSMMSW/t6NGiIWM645N6hnSp8cQvL1PyzFZu2IYxg3qpNAM5qf3bpilyZM2MVRtcfvoe0qP5pKsb6tWsEiAfy9v7G976u9X68tUbJE6Y0N+yCVVag3RMG9G/G9Zs2o7nLyJ+a8mE8cMwadIMVcXg8uXrWLFiA5ymzUf//r5BfIkShWFpmRh375zGp4/31SNdutSwtx+OWzdN3yp88eKVatmyTJrYaHpSyyR46rdPnz59rqouWFjEM1rG0jIJPJ8Gno97+vR5pE6dwqgTkBYlsPjH97hIm9pourRKPXkW8PPZc/g4Pn35ilqVywb7Pc5evKJSDaSDlcltiB9PXaiLFcyLScP74OjJs7hw9YaaJ1VJ5Dgx9PK173NdxRKtkB7zvuco//vC4Bz1+AlWbnTBmEE9UKRgXmTNlAH/tm6CHFkyYdWmoM9Rkv4hrb6ybK9OrZAlU3osX/9rVUWqVyyDw1uWY/9GZ/zPZRX+bdMEr9+8RSp/uaVaEJbHxulzF9UxkL9iA+QpZ4NqTTur6Y069sXg8U76a4Vsny7I1W2bMLV9ROERW3RDkJzkc2SzgvuDR0bT7z18rDrB6L6RiyhRjVuSpLVCvj3/zKbte1XFhFJFrY2mZ8+SWd1iP+Xqpi9T5n7/EZ54PkOeIG5x6VoU5Ft7RCe35nSt6oa5grqWoOUrNhjl2ortLiuwYuUGODv7djTzT26fnjt3EeXKlsDWrbt/VK8oWwKzZvv2apb5kr9YrlwJbNq0Q02zssqItGlT4eTJs4Fur7Q4v3r1Wr1W88dF1kzqYmvo3kMPpPBL/zC0cfs+lC1WCAnjWwT7PeQ12a0yImumn98RkVu2unxQkSdHFtUhSNc5TRx3dUP61Clh4S8VSBvnqMyqNS7Qc9Rnv3NUlKgBz1H+jq+fkfOL7nP+VbovGRu370EMczMULWjcqVQLwvLYGNS9Pbq1bap//uzlK3TsNwqTR/RFrmxWapqkR3z77z/15UfXQU62TZjaPqLwiIHuL5KaktIqq/PYwxPXb95RFQ2kTm7rJvXQd/gEFMybE9b58+DYSVcc/t8pLJ7uW8oofdrUqsVD8nL7dm2nXiepC1JTd6b9yJ92XNi8fS9qV62A6NGjGc2TUkg2NSrBfvp8tU65LT7OcbaqtiAPceT4adVSlTObFWLHioXb7vfhMHMB8uXOjpQa6Em7ffteDBzYHQ8ePlblxfLmzYmePTpgifNqNV+CSnkYklZwaXW9efNOoOud6jQfixY64uy5izijyou1R5w4seDsvEbNf/v2HRYvXo1J9iPw6tUbvHv7DlOnjsWJE676igvVq1dEUsvE6rkEEhXKl8LAAd0wxXEONHNcGJRqe/z0Ga7fuut7XCRNgta2ddF31GQUzJMD1nlz4djpc6qjy+KpxiX6Hjx6grMXr2L2hGHBfm8pQSUtXX07tw4w7+LVm7h8/Rby58qm8tcfejzF9EUrVc9zXSep6uVLqXQG6WTTtrENbrk/wIoNLugfQfOnA+yLJ55++yKu6pzaurEN+o6w990X+XPj2KmzOHz8NBZPG6+WT582FdKkSo7Rk2eg779t1J0KdY5ydcPMicMDfV/JpZVqDrK/5Za41MuVvN+5DqON+hJI3rPsZ3Hr7j1VglFeI38rQu54SWc4OUdJHV+HWYvRs1PLAP0PIorwemzIexuKHSum+inHhpQ0E0UL5EF2qwzq2BjQta26BtlNnYeiBfMYtfJqBuvoalIUH13zhsZ4v7gbKuuV2z1tugWsOSvBp93QPvocWin/5fnshRoMQurpljPoBHD/4WM4zl6Mcxev4NOnT0idKgVaNa6HWlXK65dp1bU/UiZLql+n+N+ps+jYeyhcVs1X6/VPN2CE1LyUlshi1gUwTAaMSOSbunD67AWV93b33gPVyiKdqSqULoa2zRqG2kXELHEGmJn/nRNi3LhxMGpkf1Uj19IykRowYs3aLRg71lF9HqZIysL06QuMBozYt3edqpjQtl0v/bR/O7fSDxhx4cIV9Oo1XNXU9T9ghJQzk991A0boSolVqlQGdmMHIWPGdKpF+M6de5g7dykWLFyhb2H8G2TQCu8n10J8vafPX0KbXgEvwLUrl4XdoB76TjQLVmyA5/OXqpe51AwtV8K4JNXU+cvgsvcw9qyeZzInU3p9165STr1WZ9223Zg4YyEOblisvvAZunn3HiZMX6jqg0oNbKmlW9w6vyp2n9Qgx91owAiLeGhiUx1tm4TugBFmybPB+9mtEF+vlO5q0z1gzdnaVcqr/FddK+mC5evg+ewl0qVJqerpljMYxECdo+Y6q0oH6hyVMjla2dqgVpVy+mVadRvoe47yW+ewCU44dfaC6jT2T5w4Kpe3TdP6KFboRyWYmYtWYPbiVQG2beygnqjjVxFg0FgHVRlCOs2lT5MqwPuGBjPLzKFyXITnY8M/3cAU/geMePbiFcZNm6dKkMWKGVOVQuv3b2v9F5PQOC7CyqeNAetORwSxbCJmjem/hYFuOFXRpiW6tG2GOoHkHEYUfzPQDSm3b53C6NEOWLrMdDpDRBZage7f8EkGG6jVHLMnDgt2mavwLLQC3b+lYv3WKkDWBagRWWgGun+Dlo4NBrq/joFu0Ji6EA7dvnsfcePGRq2qP1p46e/Int0Kb9++xbLl68J6U8hEy5h1/lwR/kKuBZL2JKMvhnZLKwUPj40QwlJdmsQWXQpVEbFFV8sicouu1kT0Fl0tiegtuloSpi26643zoiOKWPWHhvUmhGthWl6sW7duOHrUuBf8r5JC/dICZ/iQaUREREQUuYVpoDtz5kyUKVMGVlZWmDhxIp4+ffrL6xg/fjwsLCyMHjKNiIiIiCK3MB8wYs+ePahWrRomT56MNGnSoHbt2nBxcVFlTIJj0KBB8PLyMnrINCIiIqJgC+uhfDkEsDYD3Vy5cmHq1Knw8PDA8uXLVdpBnTp1kDp1agwZMgS3b98O8vVSyilevHhGD5n2N73xeotS1W1VeZbw6I77fZSv00yNqR4ZJEyYAI8fXVADNoRH2aRg/11XNcCF1qljo07L8Hts3HuI8vXbRopjQ+2Lmk3D7b6QEoCVGrRRdY+1LrwfFzISnWzf02cvwnpTiCJ+oGs4QkzDhg2xa9cu3L17F+3bt8eKFSuQJUsWhHfznFejbMmi+kEXpBh4vxETUL5ucxQoWxs1m3TAsrWbQ+39R9lPQ5UGrdV7lazeCN0GjMLd+w/18zOmT4vcObJi6eqNiAwGDeyObdt2q1q4okXzhr6dsEw8khjUUg0JElwH9l716tVQy1y7dksNHNGzZ0do3bzl61G2uLXRgCQy1GzngWNQsHJDdTGdPHsJvn37L1Tev1WPIchZpo7RY5TDbP18GQo3d3YrLF23BVo3b+kalC1ROMDgMJt37EPdll2Rv3xdFQiPnfLj8wnpgRPsHGejvE1LFChvg1rNOmPNZt+RBHXXgFa2dVWN8ch4XIybNh8NO/RGvor1Ua9tz7+2LXI8yHGxbN1WoyGza1Yqg5lLAtY8Jopowk2ga0hSGEaOHAl3d3cV+IZnnz5/VgNEyKhkOldv3ELCBPExYXg/bF4+Bx1a2sJpzhKs/MUx34Mre5ZMGDukN7aunIe5U+zUAAQdeg1Rw9/q1KleCWs2bQ+1gCK8iBUrJlq3tlUjlemsXbcVqVLnNXrs3n0Qhw8fx/PnL0P0/R8+9AjwXiNHTcK7d++xa9cB/XIyqlrHDs0RLZrxCHdaIrU9pRC+jUGdVfmb/HfgGDUi3fIZE2A3qDu27DqAGYtXhtp21K9REYc2LNY/+nRqaTS/TtXyWLNll6aPDXWe2r7X6DwlnFdvwrT5S9GuWX1sXjoL8x3HqgE1QoP9jAU4duocxg/rg63LZ6N5w9oYN3UODh47pV+meqWyOHfpqipfFpmOC526VSugit8Q7n/DvqMncfHqDVgmTmhiW8pj+94j8Hr77q9tD5HmAt20adMGeaGXEaQqVgzfAyYcPXEG5mZm+mF2hU2NyhjUsxMK5cutRhSqWbmcGvhh3+HjobINDWpXQ8G8uVTrgAS93Tq0xFPP50a3xWR0Iq937+DqdhFaVrVqeTVCnG7oXfH582c1QpnuIcFW2bLFsXjJj2A4pEhuueF7yaNO7apYv34bPnz4qF9u374jSJgwPkqV+jFintYcPXnW99jI8eOuzHFXN9y5/wgThvRSoy+VLFwAXds0werNOwMdve5PxYwRA4kTJdA/4saJbTS/WME88Hr7Hq4XLkOrjp5w9dsXvsMeC6937zF9wXKMG9Ib1SuWQZqUyZElU3rV6hsa3C5fUyN3WefLrc5VDWpVQZaM6XHp2k39Mhb/xEW+XNmxc/8RRKbjQgzu3h6N61ZDqr80HLuMwjbeaT4mDu2N6Cauw5nSp1EBsATDkYZUW42IDwq/ga602CZKFLK3jv+2sxeuIHvWzD9d7t37D2qs+dAmuYabt+9BqhTJjMYyl9uCWTNlUNurZSWKW+PcuaCD+WbNGqjbqBs2bA/17cmfLxfy5s1p1MIsJKi7cOEqSpSwhladvXQV2a0yGk27cOUGMqdPg8QJ4+unFbfOh/cfPuL2vR/pNiFp+74jatSoOq26w3HeMtWiZsj32EiPsxevQqvOXryivgQbOnHmPL77fIfni5eo2ayTSinoM3yCSi0JDXlzZsPB/52G5/MX6q6TDKd+76GH0RDBIlc2K02fp0wdF3+bfCEfNG4qWtnWUQFtYHJmzayGgSaKyDgy2h968vQZkpi47WPo/KWr2L3/CGZOGhVq27F6owscZi3Ep0+f1fjw8xzt1AXcUJLEidT2almatKnw5CcdPCS1YfXqzaqlN7S1bt0YV6/dxImTrgHmeTx5irRpwmeHuZA7NhIYTXvx6jUSGQS5IlGC+Pp5Ia16hVJIkdRSbcfNO/fhOHcp7j18DKcxA42Wk2M4tAK88ODJ0+cBzlOPPJ7i+3cfLFi2DgO7t0fcuHEwff4ydOg9DBuXTA9w/vhTg3t2wshJ01HeppVqQYwSNQpG9u+GgnlzRrJ9EfC4+NsWrtqIaNGioplfv4HASIvutVscfIkiNga6f+jzly+wNA+8VfrW3XvoPnAUOrdpiuKFCwS6XKc+w3DW79apXJi3rJiL2k07wsPTNzAtkCcn5jiMCfT1kttWtFA+PH/5CktWbkDf4eOxbLYDYsQw1y8TM4Z5gNYsrYkVMyY+B/F/LFK4ALJns0LrVt2DXM+2rctQwu8W7v0Hj5A3bzm4uR3QB6bHjp1CzVrNg1xHzJgxYWtbB3bjnEzO//zpM2JpuPLC569fYWn+4+/vd3XqP1rf2poiWRJsWTIdtVt1g8dT32CoQO7smGM/3ORrG9SsrP/dKkM6JEmUAG17D8eDx0/UrXqjY0PDA82YOk9JkPvt2zcM7NFBn5drP6I/ytRprlpbTZ2vRk2eAZc9h/TPz+xZj059R6gWY/25a9ksk9uwYsM2XLxyAzMmDEPypJbqfGc3ZQ4sEydC0YJ59cvFNNf2eSqkjgvpROay97D++Zldq00eK/5duXEby9e7YN38KSo9MChy/ZC/nUiDpbo0iYHuH0pgEQ9v370PtKxX2+6DUL9WVXRs1TjI9Ywa2EPlloro0X3zpWY7jNZ3kDEMWE35J24c9UibOqXKwytWpQH2HzmOahXLGOXkpU7x4+KuRS9fvkL8BBaBzm/TpjHc3C7j3PlLQa6nY6d+qmOb0OWO1qrVXN/KJS3nP1OvXnVVQmz58nUm5ydIEB93796PVMdG4oQJcOmacfmol6/f6OeZMqpfl4DHxoRhwT42/N8WFw8fPzUKdCVHN3WKZNAq6UXvf19I0C8ypvtx6zphAgvEt4gXaItq17bN0NrWxmjaqAHdDPaP6UuKBEtO85bCyW4IShcrpKZJPvD1W+5YsmqjUaAr56mE8eMhMl4zfkXXNo3RulGdnx4r/kkqwqs3XqjYsJ1+2n/fv2PS7CVYtn4b9qyZb3RcJLAI/HxKFBEw0P1DWa0ywmX3wQDTb9+9jzbdB6J21Qro0bHVT9eTNEniANNSJPu9TgmS/yb56V+/egdoXa5Y5u/16A0L590uo2mTeibnxYkTG/Xr18TQoT8fOc/DI+AofQ8ePP6lbWndyhbbXPbixYtXJufnyJEVGzeGfp5wWJGccJe9P1r/hHTAkdJKEtzqUhZOuLqpDmIZ06Y2uZ6kJkrApUhm+VvbdP22u/opndIM3XK/j4qltdsxMGvmjHDZY3yekk5f4t6DR0hm6Xv+kR72UuM1eSCfr+wz3X4L6tzln3wpkdbjqFGNWxDl9vl3f51pbt29r7Y3Mh0Xv8P0vvh5nxcpG1akQB6jaR37j0LNimVUBRJDUv2ikL/UEqKIJlyWF4tI5PaetNwalmCRgLJNtwEoZp0fLW3r4sXLV+rxyq/lKiQ9fPwE85euwZXrt1Tul+QD9x46TrVylfRrORFSgeHZ85coWuhHy4kW7d17GNmzWyF+/ICtEA0b1FKtHCtWhn494YwZ06FkySJYtGhloPV2U6ZMhv0HjkKrilvnVQMySAudTrGCeZExbSrVEUaCzv+dPo/pC1fCtk5VmJuHbE6opCfMkWPjxm319y8doQaPn4qCeXIgS8Z0xsfGi1co6u/iryWSmnDH/YHRvkiXJiXKlSiCCdPm4fyla+q8Ndhuisrxt86fO0TfX77ISC6uw6xFOH3+osoPlvq9W3cdQPmSxl8wzl28EqCDmtaPC/Hg0RNVg/3Fqzf48vWr+l0eIV2NRFrsM2dIa/SQnGnpIJo+TUr9cpI+cvXmHRTT+DWDtI8tun/IKmN6ZMuSCbsPHEXDOtXUtD0Hj6lbQy67D6iHYSvUng3OIfr+MczNce7CZTUghdwOk44+BfPkxPI5U4y+7e/Ye0gF3r/bShxRXL58HefPX0KD+jUxf8HyAB3DNm/eCS+vt6G+Ha1a2eLRoycq8DalUaM6at6vthJHJJITm80qA3Yf/B8a1vLNlZVygjPHD8UYxzlo1mWAyqmuVbksurZuEuLvb2YWHSfPXsSy9S4q1URaLSuWKoqOzRsaLbfjwFEVgP9uK3FEYJVR9kVG3/NU7ar66eOG9sbE6fPRpf9IRIkaVQWjcyaPglkgKQh/YvLIAZg61xkDR09Wt8Tl8+7evjka1alqVILs/fsPqFS2OCLTcSGGT5oBV4NqE/Xb91Y/d6+aG2CQj7/h4P9OIbllEhTInQORBnN0NSmKj9zn1iDvF3+vp+jh46fhMHMBNi+bg6hRw18jubQIVGvUDhNH9kf+v3zSMkucAWbmP1oJ/lYt3QkThqoOZOHxz1vyfK9dPYYWLbrg+ImA1RhCkxql7cm1v/Z+h0+4wmHOEmxePC38HhvN/lW1RPPn+lEL+28wS54N3s/+3nC3h4+fUS2qm5fODJf7QvQZMVHV1u3QwvjLSGgzs8zM48KfJp37o2m96qheofRfPy7CyqcVwxARxWoaeEd1YotuiChdzBoPHj5WBbgNa9eGF9KxpH2LRn89yA0rO3fuR+ZM6ZEyZXI8euSB8CZNmpSYOHH6Xw9yw0LpogXx4JGHqtUqrUPhzRPPF2jftP5fD3LDgnQCU/sinJ6n5EuHVYa0aNGoNrQuvB8Xr9+8RYVSRVCtfKmw3hSiP8YWXdJciy6FnxZdCj8tuhR+WnQpnLboLh+CiChWM7uw3oRwLXzeMyEiIiIi+kMMdImIiIhIkxjoEhEREZEmsTMaEREREcuLaRJbdImIiIhIkxjoEhEREZEmMdAlIiIiIk1iji4RERGRNocViPTYoktEREREmsRAl4iIiIg0iakLRERERCwvpkls0SUiIiIiTWKgS0RERESaxECXiIiIiDSJObpEREREzNHVJLboEhEREZEmMdAlIiIiIk1i6gIRERGRD1MXtIgtukRERESkSQx0iYiIiEiTGOgSERERkSYxR5eIiIgiPZ/vPmG9CRQK2KJLRERERJrEQJeIiIiINImBLhERERFpEnN0iYiIiDgEsCaxRZeIiIiINImBLhERERFpElMXiIiIiDgEsCaxRZeIiIiINImBLhEREVEkceTIEdSsWRMpUqRAlChRsHnzZqP5rVq1UtMNH1WqVDFa5tWrV2jatCnixYuH+PHjo23btnj//r3RMhcvXkTJkiURM2ZMpE6dGvb29gG2Zd26dciaNataJleuXNixY4fRfB8fHwwfPhzJkydHrFixUKFCBdy6deuX/r8MdImIiIgiiQ8fPiBPnjyYOXNmoMtIYPvkyRP9Y9WqVUbzJci9cuUK9u7dCxcXFxU8d+jQQT//7du3qFSpEtKmTYuzZ89i0qRJGDlyJObNm6df5vjx42jcuLEKks+fP486deqox+XLl/XLSHA8bdo0zJkzB6dOnUKcOHFQuXJlfP78Odj/3yg+Ei5rkPeLu2G9CQTALHEGmJmnDOvNID/eXx/D+8m1sN4MkmMjeTZ4P/u1lgkKHWaWmXlchKPjIqx8nNkVEVG0dg748uWL0bQYMWKox89Ia+2mTZtUgGnYovvmzZsALb06165dQ/bs2XHmzBkULFhQTdu1axeqVauGR48eqZbi2bNnY8iQIXj69CnMzc3VMgMHDlTrvH79unreqFEjFXRLoKxTpEgR5M2bVwW2Ep7Kuvr06YO+ffuq+V5eXkiaNCmWLFkCW1tbBAdbdImIiIgiqPHjx8PCwsLoIdP+xKFDh2BpaYksWbKgc+fOePnypX7eiRMnVLqCLsgVklIQNWpU1eqqW6ZUqVL6IFdIS+yNGzfw+vVr/TLyOkOyjEwX7u7uKlA2XEb+b4ULF9YvExysukBEREQUQQ0aNAi9e/c2mhac1tyg0hZsbGyQPn163LlzB4MHD0bVqlVVcBktWjQVfEoQbCh69OhImDChmifkp7zekLTE6uYlSJBA/dRNM1zGcB2GrzO1TKQOdOWWOYWf2+UUfoTlrUEKeMucwgceFxRRR0YLbppCcBmmBEgHsdy5cyNjxoyqlbd8+fKIaDQb6H71uBLWm0AAzFPkgLfnjbDeDPJjljQL89fD0Zdx5oWGnyCXfQnCBzaMhD8ZMmRA4sSJcfv2bRXoJkuWDM+ePTNa5tu3b6oSg8wT8tPT09NoGd3zny1jOF83TaouGC4jebzBxRxdIiIiIjJJOphJjq4u2CxatKjqrCbVFHQOHDiA79+/q/xZ3TJSicHb21u/jFRokJxfSVvQLbN//36j95JlZLqQ1AcJdg2XkWoOkgesWyY4GOgSERERRRLv37+Hm5ubeug6fcnvDx48UPP69euHkydP4t69eyrIrF27NjJlyqQ6iols2bKpPN727dvj9OnT+N///oeuXbuqlAepkiCaNGmiOqJJ6TApQ7ZmzRo4OTkZ5RL36NFDVWtwcHBQlRik/Jirq6tal64iRM+ePTF27Fhs3boVly5dQosWLdR7GFaJiLSpC0RERERaz9H9Va6urihbtqz+uS74bNmypSoLJgM9ODs7q1ZbCSqlHu6YMWOM8oBXrFihAlJJZZBqC/Xq1VP1bg2rI+zZswddunRBgQIFVOqDDPxgWGu3WLFiWLlyJYYOHao6vGXOnFmVH8uZM6d+mf79+6sSZPI62Z4SJUqo4FgGmEBkr6PLHN3wgTm64QtzdMMP5uiGH8zRDT/CMkf3o1MnRESxe8wJ600I15i6QERERESaxECXiIiIiDSJObpERERE2szkjPTYoktEREREmsRAl4iIiIg0iakLRERERJGkvFhkwxZdIiIiItIkBrpEREREpEkMdImIiIhIk5ijS0RERPSd5cW0iC26RERERKRJDHSJiIiISJMY6BIRERGRJjFHl4iIiMiHdXS1iC26RERERKRJDHSJiIiISJOYukBERETE8mKaxBZdIiIiItIkBrpEREREpEkMdImIiIhIk5ijS0RERJGez3eWF9MitugSERERkSYx0CUiIiIiTWLqAhERERHLi2kSW3SJiIiISJMY6BIRERGRJjHQJSIiIiJNYo4uERERkQ/Li2kRW3SJiIiISJMY6BIRERGRJjHQJSIiIiJNYo4uEREREevoahID3V/keuEKlqzZgqs37+D5y9eYOmYAypcobLTM3fuP4DhvKVwvXMV///2HDGlTwXFUfyRPmgSPnz5DlcadTK578oi+qFym2E+3YfSUOVi3bQ/6d2mN5vVrBpj/9as3mvw7ADfu3MO6+Q7Imim9mv7l61eMnjJXbbv7/UcoVbQgpo0diIjK1e0yFq/ehKs3ZF+8gpPdYJQvWcRomTv3HsJxjjNcL1z23RfpUmPqmEG+++KJJyo3am9y3Q6j+qNy2RIm5338+AmOc51x4NgpvPF6h5TJk6Jp/RpoVLuqfpl1W3dh+74juHbzDj58/ITj21ci3j9xTa5P9lfjTn1x47Y71i+ciqyZMyCicXW7hMUr1+Pq9du++2L8MJQvZfy3fOfeAzjOWqSW9d0XaTDVbiiSJ7NU81+8fIXJMxfixJnz+PjxI9KlSYUOLWxRMZD9ICrVawmPp88CTLe1qYGhfbr47uP6rUy+1mHMYFQuVxKbt+/F0HFTTC5z2GUVEiWIj4h2jlLHhd85ymnMwIDHxf2HcJwr56grfueo1Jg6esCP46JxR5PrdhjZD5XLFDc5b8h4J2zZfdBoWvFC+TB30gj987nL1uHISVf1t24WPTpObF9ptPz12+5YuHIjzl26qo6tFMks0bBWZZPnuYgoatSoGD68D5o0tkGyZEng4eGJpcvWYdy4qSaXnzljAjp0aI4+fUZg2vQFga63RInC6NOnM/Lny4UUKZKhXv022Lp1t9Ey3l8fm3ztgIFjMGXKHJQqVRT79603uUzRotXgevbCL/1ficILBrq/6NPnL7DKmA51q5ZDz+H2AeY/fPwULboPhk3VCvi3lS3ixo6N2/cewNzcTM1PliQRDm5YaPSaddv2YsmazShZON9P33//0ZO4ePUmLBMnDHSZKXOXIknihCrQNfTff98RM4Y5mtpUx74jJ6CFfZElY3rUrVYBPYeODzD/weMnaNF1IGyqV0CXNo0RJ05s3HE32BeWiXFok7PRa9Zt243FqzahZOECgb6v/cyFOHXuIsYP7Y2UySxx/Mx5jHWcA8tECVHW70vP589fUMI6v3pMnbc0yP+Hw+wl6rVy8Y+oPn36jCyZMqBu9UroOXhsgPkPHnmgRee+sKlRGV3aNUOc2H77Ioa5fplBYybj3fsPmDFxBOJbxMOOvYfQZ/h4rFnohGxWmUy+7+oFTvj+/UdP6Vt376N9z8GoVLbkj328dYXRa9Zt2YnFKzegZJGC6nmVCqVQoojx/h5iN0V9MYxoQa749Pnzj+Ni2ATTx0W3wbCpVh5dWjdGnNix1BdCo+Niw2Kj16xz2aOC55LW+YN8b/l7Hzugm/65md86dby/fVOBct4cWbBx+74Ar5fgPGECC0wY0ktth9vl6xjlMAvRokZFE5vqiOj69euCjh1aoE3bnrh69QYKFMiDBfOn4K3XW8yYucho2dq1q6Bw4fx4/PjJT9cr57aLF69iyZLVWL/O+Pqikyp1XqPnVSqXxbx5Dti0aYd6fuKEa4BlRo3sh7JlSzDIpQiNge4vKlk4v3oEZtrCFSpI6t2phX5a6pTJ9L9HixYNiRMmMHqNtAzKyT92rFhBvrfn85cYN20B5toPR5dBdiaXOXrqHI67uqkW5GOnzhnNix0rJob18m2pOX/5ugoqIrKSRQqoR2CmzV+u5vfp3Fo/LU3K5Mb7IpHxvth/9AQqly2O2LED3xdy8a1dpRys8+VSzxvUqoJ1W3fj0rVb+kC3ecPa6ufp85eC/D8cPXlWBcpTxw7E0VNnEVGVLFpIPQIzbZ6zmt+nS1v9tDSpUhgt43b5Gob17Ypc2bOo5x1bNcbSNZtw5frtQAPdhP4C0QXL1iJ1yuQo5LdvfPex8ZfC/UeOo3L5kvp9HDNGDPXQefX6DU6dvYDRg3oiIpLzT1Bf1KYtkHNUfvTp1OoXjouTPz0uhLlZ9ACvNdS1dWP1c/PO/Sbn21SrYPQ8dYpkuHD1BvYdPamJQLdokYLYtm03dvr9/+/ff4RGjWqjUCHjAFNaZac6jkX1Gk2wZXPQX5TF7t0H1SMonp7PjZ7XrFUZhw4dh7v7A/Xc29vbaJno0aOjZs3KmDnL+EuPphl8aSbtYGe0ECQtS0dOnkXaVMnRsd9olK7bCk06D8D+Y6cCfc2VG3fU7TppXfnZugePd0LrRnWQKX0ak8u8ePUGIyfPwvjBPRAz5o8Ld6TdFydckS51CnToMwKlajVH44591QU7MFdu3Mb1W+6wqV4xyHXnzZkVB/93Wn3x8PHxwelzF3HvoQeK+btY/cyLV68xctIMjB/ayyjQ0uS+OH4G6VKnRIdeQ1Cqui0at++pAk5DeXNmw679R+D19p16zY59h/D161dY588drPeRC7XLnoOqVTlKlCgml7ly/Rau37qrWpYDs3XXfsSKGQOVgkiZiNjnKL/jot9IlKrTEo079/v5caHOUUEfF+KM22W1zhrN/1UpVm+83v7xNr97/xEWgaT9RDQnTrqqFtLMfulJuXNnR/Fi1thlEKTK3+6SxdMwZcpsXL16M1S2w9IyMapVLY/FS1YFukzNmpWQKFECODuvCZVtIPpbGOiGoFdvvPDx02csWrUJxa19c9PKlSyMXsPtccbtisnXbNqxT+XwSvAUFFmntLQ0rWe6VUMCrqETp6t8thxZTLd+RSavXsu++ISFKzagROH8mOcwSuUpSoqDXIxN2bh9r8pVzJcrW5DrHtyjIzKmTY3y9VojXzkbdOw3EkN6dUTBvDmDvX1qf413QsNaVZAza2ZombSQqn2xfC1KFC6IeY52Kn9XUhzOnL9olDP77ds3FK/aEPnL1MJo++mYOm5YgJbfwOw/cgLv3r9HnSACso0uu1Wedr5c2YNcplrFMpr88uF7XHxWebCSZjBv0giUL1EEPYdPDPy48DtH5fvJOaq4dX6MG9wTC6aMQq8OLVRefKcBY1QO8O+SO0+7Dx5D/ZqVoAX29jOwdt0WXL50GB8/3MOZ07tV7u2qVZuM0hvkOJg+w3QKQkho3rwB3r17j02bdga6TOtWttiz51CwUieIwjOmLoSg7349NssUs0aLBr6dJ6Qj2IUr11XuZ6G8OYyW//zlC3bsP4qOLRoEuV5p9V2+YTvWzpscaEvVyo07VCepdk1sQuz/E5F99xvhRlIJWvilEUgnL0k7WLtlJwr5C0rVvth3BB1bNPzpuldscFF50jPGS0eqJDjrdgV2jnNV3nTRgsFr1ZV1SCe1ds3qI7IcF2VLFkUL27rq96xWGeF26SrWbt6BQvl8W2xnzF+q0mkWOI1DfAsLHDh6An2Hj4fzrEmwyujboTIoEqCWKFIQlkkSmZyv9vHeQyolIjCSPnH33kOMH9YPWvTdx29fFJdzVK0fx8WV61i7dfcfHRfVyvvmRQurDOlUX4aqTTqpALpIgTy/vK2Sb919yDh0btlIdWrTggYNaqKxrQ2at+iiWmvz5MkBh8mj8OSJJ5YtW6c6k3Xr2hbWhauE6na0amWrgusvX76YnJ8yZXJUqlQGjZuY7jhNFJEw0A1BCSz+QfRo0ZAxXSqj6enTpML5S9cCLL/38Al8+vIVNSuVCXK90gNZWosrNeqgn/bf9++YPNsZy9e7YPfquTh1/hIuXL2JApUaGb3WtmM/VK9QCnaDuiMySWARz3dfpE1tNF1apuTz9G/PoeOqc1utKuWCXK9c+J3mL4OT3SCU9stJlY4/cmt3yepNwQ50Jd3hwpUbyF+hntH0Rh16o3qF0hg3pBe0IkF8v32RzjjlRlpWz128qu+stnLDNmxeNgeZMqTVB2DnLlzGqg0uGNH/RwcnUzyeeuKkqxumjhsa6DJ7Dh7z28eBpwlt2LZLvW8Ojbay689RJo+LgOeoPYePq3NUrcplf/m9JL9WjsMHj5/+cqArnePa9hmuWnKDE2RHFBPGD8OkSTOwdu1W9fzy5etIkyYV+vfvqgJdqZ4gaQV375w2ypW1tx+Obt3aIbOVcfWM31G8uDWyZsmEpk07B7pMy5aN8PLla2zbtgeRCsuLaRID3RBkZmaGHFkzqXxNQ/cfeSB5Ut8SSoY27tiPssUKImF8iyDXW7NiGRQpYJyn2Kn/GNSoWBp1/AKzQd3aolvbHy1Vz1+8Rsf+ozFpeB/kyq7Ni/bP90VmuD80Lqlz75GHKllkKm1BWrl+ti++fftP3VaMGsU460d6hetaLoNjUI8O6Naumf75sxev0LHvCEwe0R+5sltBc/simxXcHzwymn7v4WP9vpAvECJK1CgByjH5BGP8+U3b96re+qWKWgfZ4ist/P47sOnIHZHd+4+ip0EnLa2eowIcFw89kCJpkgDLS2WEssUK/fS4MOXpsxd48/YdkgTROc2U2+4P0Kb3MNSuXBY9DI4RLZDOfP7PE5LaIX/nYvmKDdh/4KjR/O0uK7Bi5QY4O68NkW1o07oxzp69oKo0BKZli4ZYvny9OtcRRXQMdH+R5BpKC4XO4yfPVGuedJaQGpStG9VG39FTUCB3dljny4ljp8/j8HFXLJo6JkCJn7MXr2LWhCE/fc/4Fv+ohyFplUmcMD7Sp0mpnst7G9JVcJCKD8mSJDZqKZESP2/fvcOHj5/Vtgtdrd2IRAIT+Rx1pP6ndDSyiPeP775oXBd9R05CwTw5VIUEqUJx+PhpLHYaZ7QeaU08e+EKZtsP/+l7xo0TW+XiOsxejBgxzFVwILVIt+4+iH5d2+iXe/Hytepspts+uQ0rZZxku3Tb578ihn5/Wf7YXxFqXzz68QXvsYcnrt+84/t/TWaJ1k3qoe/wCeqzs86fB8dOuuLw/05h8fSJavn0aVOrXFzJy+3btZ16naQuSE3dmfYjf9rBSmrh1q5aAdGjRzO5jNrHbpcxe/LoQNezc/8RFXTUqBx0q36EOy6ePjM+Lmzrou+oyb7HRd5cOHZajoszWDzVuCzcg0e+56jZE4YF6z1nOa9BxVJF1XnpocdTTJnrrKo5GKYdPPF8rjobPnn2Qt2Vku0SspwEgXKctO09XHXsbNmgtjqORNRoUX8r2A5vtm/fi4EDu+PBw8eqvFjevDnRs0cHLHFerea/evVaPQx5e3+D59PnuHnzTpDlxTIZnMPTp0uj0iJkXQ8NGl7++Scu6tWrgf79Az8OpLNchgxpsWixcY1jooiKge4vknzZNr1+BEST/EqvyK09u4HdVIen4b06YsHKjZgwfaHq3TxlVH/k99fBadOO/UiaJBGKBXKru7JtR9SuUlbV4g1J/w4cCw+DEjIN2vdRPy8d3IiI5vKN22jT48cXBXu/zhtS+stucE9UKFUUw/t0xoLl6zHeaT7SpUkJx9EDkT939gCdbdS+CCQPsFLDdmqdXdo0Uc8nj+inauMOHOMAr7fvkSJZEnRv38xowIg1W3Zi9hLfi5do2W2Q+jl2UA/UqRp0hY2I6PL1W2jTbYD+uf30eeqnBJ92Q/ugQuniGN6vqyr/Nd5xjhoMwtFuKPLn8c0JlcEDJAh1nL0YXfqPxKdPn5A6VQr12lLFfrTSturaHymTJVXTdSQYfuL5TFVbCMxGlz1IapkYxYKoAystvhVKFwt0YI8IdVz0+hGc2vvVZ5UWUrtBPVBBzlG9O2HBig0YP22BOkc5jh4Q8LjYqTsuTJ+jKjVq73tctG6sAtGbd++pL3xv33+AZaIE6nVd2zTV1+cVMxatNBpUon773urnIscx6suopEpImpbL3sPqoSNfKPesmY+IrkfPoRg1sj+mTxsHS8tEasCI+QuWY+xYx19az76961RpsrbtfFOcpB6v4WAPkyf7fjlcunStfhnRqGFt1c9j9ZrNga67dWtbHD9+BjduBB5Ya1Yw7h5RxBPFR7p/a9BXD9NVDiICySMsWbslZk8cGqBzSERjniIHvD1vICLvixI1mmL2pBH6urkRmVnSLPB+4duKFhFVtGmJLm2boc5PSsBFBGaJM8D7ScC82AhzXNRqjtkTh2njuEieDWbmvnfHIoLbt05h9GgHLF0WMukM4UlgI7j9DR+GRcx88DhjtPd3EJJYXiwcOnP+kkp7iOhBrhacPn9R1XHVwsU8ort99z7ixo2NWhpsEY9oZCAU6/y5eFyEgezZrfD27VssW74urDeFKEII0xbdc+fOIUGCBEif3je3aNmyZZgzZw4ePHiAtGnTomvXrrC1DfrWvZRH8V8iJUaMGIjy8naobjtFjhZdrYnoLbpaEpFbdLUmorXoahlbdH8dW3TDcYtu69atceeObx7QggUL0LFjRxQsWBBDhgxBoUKF0L59eyxaZDz+t3/jx4+HhYWF0UOmEREREQWbVMSIiA8Kv53Rbt26hcyZfUtfzZo1C05OTiq41ZFg187ODm3a/OjN7t+gQYPQu7dvhwbDFl2wRZeIiIgoUgvTQDd27Nh48eKFSlN4/PgxrK2Na2AWLlwY7u6+5a8CI0GtCmz9+RriW0tEREREEUmYpi5UrVoVs2fPVr+XLl0a69f/KI8i1q5di0yZMiG8e+P1DqXrtlL1KsMjqZ1bvkE7NcZ9ZPDG6y1K1Wqu6uqGR6/f+G6fFNSPFPuium243Rd33O+jfJ1mkeLYUPuiTsvwfVzUaRkpjouECRPg8aMLSJvWeBTN8DSwyK2bJ1Egv/FARUQRUZi26E6cOBHFixdXQa7k5jo4OODQoUPIli0bbty4gZMnT2LTpk0I7+YtX69G1UppMOKWFEYf4zhXjfMugwFInd0e7ZupgR5C2iiH2Th57qIaDU3eK0+OLOjVsTkypPE9iWZMlxp5slth6bqt6KSh4TQDM2/ZOjUCVsrkSfXTxjnNg9ula7jlfh8Z0qbGhkVOofLeMhjH9PnLcfTkWTx68hRx48RBkYJ50KtjC1gmTqQfErdm5bKYuWglxgzU9tDM85xXo2zJokb7ImfxH/WGdexHDUC1CkEPhf2rJKCrXN/0KGcOYwajcrmSyJg+LXLnyIqlqzeiU2vfOslapT9PGewLwyC4Xtte8HzxEse3LQ+VWsIy+MPkOUtwwvWCGngnXeqU6NCsPiqWLvbjuKhUBjOXrMKYnwz5HNENGtgd27btVrVwDbVo3hA9e7ZH5swZ8Pbte2zY4ILuBrXCQ1LWrJkwbtwQlCpZRA0zfO3aTTRs1F4NMOHt7Q1HxzlqfuUqxsPKa5nPd9bR1aIwbdFNkSIFzp8/j6JFi2LXrl2QAhCnT5/Gnj17kCpVKvzvf/9DtWrVEN7rSW7auR91q/0oeSSjK/07yE4FPctmjMfYgd2xZddBzFy0KlS2IbtVRozp3xVbnKdhjr0UivdBx36j1XboyFDBa7fuxjeDaVok+0OG87WpXiHAvLrVKqBKuZKh+v6fP3/B1Vt30LFlI6xd4IipYwfi3oPH6DrILsC2bN93WI0SpVWfPn9WgzDY1Ag4kMPYwb1xaOsK/aN8Sd9gJyTJCHOG7yEPqcErowaWLFJQv1yd6pWwZtN2Nbyzpo+LHftgUy3gcSGG28+AVca0oboNg8ZPVUMNzxg3GBsXOamBK/qMmoxrfqOjibpVy2P73iOaPi5ixYqpBmVYvPjHgDJCRkgbPbo/7CfNRJ685VClqi327D0UKtsgI58dOrgZN27cRoWK9ZG/QAXYjZuqzl86K1dtQvHihVQ5M6KILMzr6MaPHx8TJkzAlStX1GhIUirs3r17WLFihWrlDe+OnjoLc7PoyJM9i37acdcLuHv/EcYP7qmG1i1ZOD+6tmmM1Vt2qW/KIa1BzUpqOE9pUZagt2ubJur2n8fTHyOgFS2YR43i5eoWcQfSCI6jJ11hbmaGPDmyGk0f3KMDGttURyoTrVkh6Z+4cbBgyhhUKVcC6dOkUtsxuGdHXL1xW7Xy62RKnwaWiRJi35ET0KqjJ8747oucxqMCin/+iYPEiRLqHzKcckiLJsNkG7yHPPYfOY7K5Uuq4WZ1ZEQ8r3fv4Op2EVoldxh8j4sf5ymd1Vt2qtHMWjWqE6rb4Hb5BprYVEOubFZInSIZOrZoqI4XGW3S6LhInBD7jp6EVlWtWh5fvnzFqdPn9NPix7fAqFH90bpNT6xevRl3797HpUvX4OKyN1S2YfToAdi16wAGDbKDm9sV9X7yXs+fv9Qv8+aNF44fd0XDhrVDZRuIIk2gG9Gdu3gN2awyGk27cOUGMqdPo8Z815HhMN9/+Ijb9x6G6vZIruHmXQfU7clklr63ynU5V1kzpcO5S1ehZWcvXEX2LMb7I6y9//BBDbspF3VDObNZ4dxF7e6PsxeuIHtW36oq/tk5zEKJao1g266HavX9G+W8r1y/heu37sKmRmWj6b7HRga1vVp19tJV9SXYVP7+HOe16ku5/I2Gprw5s2DXgf+p1trv379jx/6j+Pr1K6z9DYyTM2tmTR8XJYpb49w54y9VFSqUQtSoUZAyZTJcvHgI7nddsXLlHKRKlSLE31/2c7Wq5XHz1l1sd1mhcoX/d2wbatUyPi7EGdfzansjjbAuE8byYqGCge4f8vB8rlrmDL149QaJEvwIcoXuucwLDas374R11SYoXK0Jjp06j/mTRqgLuKEkiROq7dWyJ57PkMTf/ghL0nLjOMcZ1cqXQtw4sY3mWWp8fzx5+kz9zfnXtV1zTB4zCPOn2qFimeIY6zATK9ZvDfXtkYA6Q7rUyJcre4B5SRInUtur7X2RwGja16/e6DfGAX06tUTypElCfRscRvTDt/++oXit5shfsQFGT5mNqWMGIk2q5JHquEiTNhWe+OsQmD59GkSNGhUDBnRDnz4jYGvbAQkTxMfOnasCnMf/lKVlYvzzT1z079cFe/YcQrXqTbB5yy6sW7sAJUsWMVr2iYcn0vj19SCKqMK0M5oWSCBjbv7nJ6JOA8ao1mGRImkSbF7ihDqteuhP+PlzZ8OciZJ/a1r1CqVUesLzl6/hvHaLyn1bNmMcYpj/uCUsvxvmYGnR5y9fYWnwf/5doybPgotBftyZ3WvRqd9InPVraZJ9tGXpzCDXITnafUbYq9bKYX06B5gvt+u1vD8+f/kCS/MfdxV0DDt9ZbPKhE+fPmPxyvVo1sD0LdJOfYbh7IXL6vcUSS2xZcVc1G7aER6evoFpgTw5McdhzE+3ZcfeQ+jYqrHJ+TFjmKs8Vq36/DXgcTF1/jLVYVU6gAVXp/6jfxwDyZJgy5LpqN2qmz5NqkDu7JhjP9zka2csWol37z9ggcMoxLeIhwPHTqHvyElwnj4OVhnSGR8X/ka71JJYMWMGOO4lyDU3N0evXsOwb98RNa1Z83/x6KEbypQphr17DwdYz8wZE9CkiY3+eYKEVti2dRlKlCisnt9/8Ah585YL8Dp5L7F12244TZuvfr9w4QqKFi2IDh2a46hB2ogcm4ZpPkQREQPdPxTf4h+8fffBaJqkLFy+fsto2svXvi25hukMhkb1/RdfvvpW/9VVZpg1YYi+85hhwGqK3BaXR9pUKVSFheK1WmD/0VOoVv5H5yuvd+9VbpyWJbCIh7fv3//xerq2bYLWtsY5i6P6d9MPNy29lIMT5Eowtmjq2ACtuUJu4UpPc03vi3c/3xe5cmTFnCWr1G1sudj7N2pgD/WFUkSP7ntszHYYre88Fpz83j0Hj6lAtlaVH51GDfkeG8Yti1rfF6fOXcQt9wfIU843WNLdAC1ZuwXaN2+Arq0DfikY1a9LwH0xYdhP98WDx0+wctMObF48TeXhCum/ICkKqzbtxAiDL4LSlyCBhQW06uXLV4ifwPj/99SvhffatR/XjRcvXqlHmtSmhyYeOWoSpjjOMZrWsVM/1dlNBNYfRNYp8wzfS1y/fgvFixmnKSRIGB/PX/zI2yWKiBjo/qFsmdPDZa/vN3Ad6fAxf8UGFdzqUhakpI4EOxnTpja5nqRJArZ8pTAoV/YrJN1RWhG/+jvR3XZ/gEqlikLLsmbOYNQS+7tkv/lPPzG1j4IKch888sAiJzvVemWK7I9C/vITtSSrVUa47D740+Wu37qjylmZCnJF0iSJA0xLkSzpL6ctSMk5uR1syq2791CxTAloleQg+z8uHEcP0Aet4vKN2xg2cbpqYQ3sC/Hvnqd0LbRRohrnAUeNFhU+PsYlnW6739f0cXHe7TKaNqlnNO34CVf108oqIx4/fqJ+T5AgPhInTqhaZk2RjmOGnceEh8fTn76/BLmurheQxV/OtpQ08/9eOXNkxQWNd2A2wnxXTWKO7h+SHtvSoUNahPTTCuZBhrSpMHjcNNy47Y7/nT6vbtvZ1q4SImkOhh56PMWCFRtUz2Xp1e92+Tr6jJqkWlak2oOODGbx7MUrFCmg7QLgxa3z4Y77A6P9ISTolI5IkiMtF3f5XR4hXQVDgtzewybgyvXbmDCsD77/913VD5WH4XtJ66JUYpC/H60qXriAGpDBsFTUoWMnsX7rLhVYyj5ZvckFC5auQZP6tUJtO+R9zrpdRr2aVQKtt/vs+UsULZQXWlXcOm+A81SalMmROUNa/UNXB1zSGfx/yftTUoFE3m+0w2xcunZTtfAuWbNZNQCU87vVrj8ubt5RnXe1StIQpGSXVFrQuXXrLrZs3YUpU0ahaJGCyJEjCxYtmorrN27j0KHjIb4NDlNmo0GDmmjbpgkyZkyHfzu3Qo3qFTF3jrPRcsWLW2PvvoBpE0QRCVt0/5BVhrTIljkDdh/8Hxr69VqVskYzxw3GmKnz0KzrIJWTVatyGXRpYzo/8E9ISsPZS9ewbIOLSqFIlMBC5cktmz7e6GK1c/9RFYD/bitxRGGVMZ2qgrH7wDE0rF3FqE6oq5tvnqeo37an+rl7zXyTBfR/lwRMB/932vc92vQwmietu9b5cqnfDx47qToAFciTA1pllTE9smXJhN0HjqJhnWr6lI/VG7fBfto8+MAHaVKmQL9uHVC/lukgNCRsdNmDpJaJUcz6xxc/Q5K7K/N+tZU4IpEc2GxWxuepv8ksenTMnjgMjvOWostgO5X7mTplctgN6o5SBjWND/7vFJJbJkGB3No9Li5fvo7z5y+hQf2amL9guX5669Y94DB5JLZsccb37z44cvQEatRohm/fvoX4NmzZsgtdugxE//7d4Og4Gjdv3lWDRfzv+Bn9MkUKF4CFxT/YsGF7iL8/0d8Uxedv1PUJA189/t7tliMnXOEwdyk2LZqqT/QPT6QlsXrzLpg4pBfy5QpY0zQ0mafIAW/PG3/1PQ+fOAOHWUuw2Xl6uNwfokmnvmharyaqVyz9V9/XLGkWeL/4UaA/tB0+fhoOMxdg87I54fbYqNaoHSaO7I/8fzm4MkucAd5PfDug/g2H5Tw1Z4nKkw2P+0I06dwfTetVR/UKf/m4SJ4NZuamc2FDq5buhAlDVWex8HoJXrFiNi5evIqJE6f/1ff1/voYYeV934hZMzju5C1hvQnhGlt0Q0CpogVx//ETlRogozGFN0+evUC7JvX+epAbVkoXLYQHDz3g+fzlXymb9Ktev3mLCqWKolqFUtC60sWs8eDh43C7LyTdp32LRn89yA0LpYsWVGkcMsyvtJqGz+OiiCrFp3U7d+5H5kzpkTJlcjx65IHwRkqaScuzk5NvVQaiiIwtuqS5Fl0KPy26FH5adCn8tOhS4Nii++vYohu08Hn/ioiIiIjoDzF1gYiIiIjlxTSJLbpEREREpEkMdImIiIhIkxjoEhEREZEmMUeXiIiIIj0f5uhqElt0iYiIiEiTGOgSERERkSYxdYGIiIiIqQuaxBZdIiIiItIkBrpEREREpEkMdImIiIhIk5ijS0RERPT9e1hvAYUCtugSERERkSYx0CUiIiIiTWLqAhERERHLi2kSW3SJiIiISJMY6BIRERGRJjHQJSIiIiJNYo4uEREREXN0NYktukRERESkSQx0iYiIiEiTGOgSERERkSYxR5eIiIgiPR8f5uhqEVt0iYiIiEiTGOgSERERkSYxdYGIiIiI5cU0iS26RERERKRJDHSJiIiISJMY6BIRERGRJjFHl4iIiIg5uprEFl0iIiIi0iQGukRERESkSQx0iYiIiEiTmKNLREREkZ4Pc3Q1SbOBrnmKHGG9CeTHLGmWsN4EMmCWOENYbwL5MUueLaw3gfx4f30c1ptA9FccOXIEkyZNwtmzZ/HkyRNs2rQJderUMblsp06dMHfuXDg6OqJnz5766a9evUK3bt2wbds2RI0aFfXq1YOTkxPixo2rX+bixYvo0qULzpw5gyRJkqjl+/fvb7T+devWYdiwYbh37x4yZ86MiRMnolq1avr5Pj4+GDFiBObPn483b96gePHimD17tloWkT3Q9fa8EdabQH5BrveTa2G9GWQQWEU3TxnWm0EAvn19zGMjHB0XvGaED2wYCX0fPnxAnjx50KZNG9jY2AS6nATAJ0+eRIoUKQLMa9q0qQqS9+7dC29vb7Ru3RodOnTAypUr1fy3b9+iUqVKqFChAubMmYNLly6p94sfP75aThw/fhyNGzfG+PHjUaNGDfVaCbjPnTuHnDlzqmXs7e0xbdo0ODs7I3369Coorly5Mq5evYqYMWMG6/8bxUfCZQ3iSSt8YKAbvjDQDT8Y6IYfDHTDj7AMdL1alkdEZOG8/7dfGyVKFJMtuo8fP0bhwoWxe/duVK9eXbXm6lp0r127huzZs6uW2oIFC6ppu3btUi2xjx49UoGxtLoOGTIET58+hbm5uVpm4MCB2Lx5M65fv66eN2rUSAXdLi4u+vctUqQI8ubNq4JjCU9lXX369EHfvn3VfC8vLyRNmhRLliyBra1tsP6P7IxGREREFEF9+fJFtaAaPmTa7/r+/TuaN2+Ofv36IUeOgGmgJ06cUC2zuiBXSMutpDCcOnVKv0ypUqX0Qa6QltgbN27g9evX+mXkdYZkGZku3N3dVaBsuIyFhYUKwHXLBAcDXSIiIqIISm79SwBo+JBpv2vixImIHj06unfvbnK+BJ+WlpZG02T5hAkTqnm6ZaTl1ZDu+c+WMZxv+DpTy0TqHF0iIiIirRs0aBB69+5tNC1GjBi/ta6zZ8+qTmWSJytpDVrAFl0iIiKi7xHzIUFtvHjxjB6/G+gePXoUz549Q5o0aVQrrTzu37+v8mTTpUunlkmWLJlaxtC3b99UJQaZp1vG09PTaBnd858tYzjf8HWmlgkOBrpEREREBMnNlbJgbm5u+od0CJN8XemYJooWLapKfUnrr86BAwdUbq/kz+qWkTJmUpFBRyo0ZMmSBQkSJNAvs3+/cUc6WUamC6myIAGt4TKSfyx5wLplgoOpC0RERESRxPv373H79m39c+n0JQGt5NhKS26iRImMljczM1MBpwSpIlu2bKhSpQrat2+vqiNIMNu1a1dVBUFXiqxJkyYYNWoU2rZtiwEDBuDy5csqJULq8er06NEDpUuXhoODg6rssHr1ari6umLevHlqvqROSKWHsWPHqrq5uvJi8h6B1f01hYEuERERRXqRZWQ0V1dXlC1bVv9cl9/bsmVLVbYrOFasWKGC2/Lly+sHjJB6tzrSIW7Pnj1qwIgCBQogceLEGD58uL6GrihWrJiqnTt06FAMHjxYBbNSfkxXQ1fIABNSgkxeJ63IJUqUUKXMgltDV7COLoUq1tENX1hHN/xgHd3wg3V0w4+wrKP7pmk5RETxVxwI600I15ijS0RERESaxECXiIiIiDSJObpEREREkSRHN7Jhiy4RERERaRIDXSIiIiLSJAa6RERERKRJzNElIiIikiF1SXPYoktEREREmsRAl4iIiIg0iakLREREFOlFliGAIxu26BIRERGRJjHQJSIiIiJNYqBLRERERJrEHF0iIiIilhfTJLboEhEREZEmMdAlIiIiIk1i6gIRERFFeiwvpk1s0SUiIiIiTWKgS0RERESaxECXiIiIiDSJObpERERELC+mSWzRJSIiIiJNYqBLRERERJrEQJeIiIiINIk5ukRERBTp+TBHV5PYoktEREREmsRAl4iIiIg0iakLv8jV7TIWr96Eqzfu4PnLV3CyG4zyJYsYLXPn3kM4znGG64XL+O+//5AhXWpMHTMIyZMmUfNfvHyNybMX44SrGz5+/IR0qVOiQ/OGqFimWJDvvWrjdvXeL169RpaM6TG4Rwfkym6ln//ly1dMmrkIOw8cxVdvbxQvlA9De3dC4oQJ9MucPHsB0xeswK279xErVgzUrlwO3ds3R/To0RDRuF644rsvbsq+eA2nMQMD7ov7D+E4d6laVu2LtKkxdfQAtS8eP/FE5cYdTa7bYWQ/VC5T/KfbMMphNtZt240BXdqgeYNaRvMOn3DFnKVrcPPOfcQwN0PBPDkwzW6w0TKbd+6H87qtuP/QA3HjxEalMsUwtKfpbYpIokaNihHD+6BJYxskS5YEHh6eWLpsHezGTdUvM3xYbzRsWBupU6XA169fce7cJQwbPhGnz5wPdL1x48bBqJH9Uad2FVhaJoKb2xX06j0crmcvmFx+5owJ6NihOXr3GYFp0xcYzatWtTyGDumJXLmy4fPnLzhy9CTq1W+LiC6sjosh452wZfdBo2lyDpo7aYT++dxl63DkpCtu3HaHWfToOLF9ZaD/jzdeb1GvbS94vniJ49uWI94/cREZrxlqfzRqb3LdDqP6o3LZEibn5SxlfD7S6d25Fdo0tlG/33v4GA6zFuP85Wvw9v4Gq4zp0K1tU1jnz61ffpzTPLhduoZb7vfV38mGRU7QLKYuaBID3V/06fMXFWTWrVYBPYeODzD/weMnaNF1IGyqV0CXNo0RJ05s3HF/AHNzM/0yg+wc8e79B8wYNxTx48fDjr2H0WekPdbMc0A2q4wm33fn/qOwn7kQw/v8i9zZrbBs3VZ07DsC21bMRqIE8dUyE2cswJETrpgyqr8KCMZNnau2cfksezX/+m13dO4/SgXV44f0hOeLVxg9eRb++/4d/bq0QUTz6fPnH/ti2ATT+6LbYNhUK48urRsjTuxY6oKi2xfJLBPj0IbFRq9Z57JHXZRKWuf/6fvvO3oSF6/egGXihAHm7T18HCMmz0KPds1QOH8u/Pffd3WhMOS8dot69OnUErmyWam/LY+nz6AF/ft1QccOLdCmbU9cuXoDBQrkwcL5U+Dl9RYzZi5Sy9y8dRc9egzFXXf50hUTPbq3x84dK5ElW3G8ePHK5HrnzZ2MHDmyoFXr7vB44ommTWywe9dq5MpTFh4eT42WrV27CgoXzo/Hj58EWE/dutUwd7Y9hg6biIOH/qe+6OXIkRVaEJbHRQnr/Bg7oJv+uZnBeU94f/umAuW8ObJg4/Z9Qa5ruP0MWGVMqwLdyHzNUPtjk7PRa+TL9eJVm1CycIFA39f/a46eOovhE6ejYukfDSpdBoxBmlQpsHDqWMQ0j6GuK10GjsHOVfOQONGPBhLZ9ovXbuLmnXt/9FkQhQUGur+oZJEC6hGYafOXq/l9OrfWT0uTMrnRMm5XrmNY78761tiOLRth6bqtuHLzTqCB7tK1W1C/RiV1whES8EpQu2n7PrRrVl8FznLhsB/eB4UL5FHLjBnYA7Wa/4sLV64jT46s2HXgqPrG3rmVre92pUqBPp1boc8Ie/zb2hZxYsdGRCIn+aBO9NMWrEDJwvnRp1Mrk/siWrRoRidzsf/oSVQuWxyxY8cK8r09n7/EeKf5qrXq34FjjOZ9+/YfJkxfqALYetUr6qdnTJda/7vXu/eYvnAFZowbgiJ++0tkyZgOWlC0SEFs3bYbO3buV8/v338E20a1UahQXv0yq1dvNnpN336j0LZNE+TOlR0HDh4LsM6YMWPCpm412NRrg6PHTqlpo8dMQfXqFdGpYwsMH+H7hU6kSJEMTo5jUa1GE2zdvNRoPbLfHR1GY8DAsVi8ZLV++rVrt6AFYXlcmJtFD/BaQ11bN9bfyQjK6i078fb9B3Ru2QhHT51DZL5mmN4fJ366P/y/5uCxU7DOlwupUyRTz1+/eYv7jzwwekA3FYiLXp1aYPXmHepLue71cudQvFrkxUCXIiTm6Iag79+/q+AzXeoU6NBnBErVao7GHfuqi4ShvH5Bp9fbd+o1O/YfUbdurfPmNLleb29vXL15G0UK5jW6NSwBkgSx4uqN2/j27ZtR0JQhbSp16+vClRu+6/nqjRjm5kbrjhHDHF++fsWVG3eguX1x0m9f9BuJUnVaonHnfgH2haErN26rVm+bahV/uu5B46ailW0dZEqfJsD8a7fuqFYo2Uf12/VCGZvW6NR/tEoX0ZG0le/ffVSres0WXVG+flvVqv/k2XNowYmTrihXtgQyZ86gnufOnR3Fi1ljl79b2zpmZmZo364p3rzxwoWLV0wuI62u0aNHV2kGhj5/+ozixQrpn0eJEgXOi6fBYcpsXL16M8B68ufLhVSpkqv9eOb0bjy8fw4uW5eplmKtC83jQpxxu6zWWaP5vxg9ZY5KP/hV0ro8x3ktxg/uqfallgX3mhFgf9xyh43Bl+ifkXQ3eR/D18S3+Afp06TE1t0H8fHTZ/UFfe2W3UiYwALZs2T64/8bUXjBQDcEvXrthY+fPmHhig0oUTg/5jmMUrlYcrtKLgCGeVVyUileoynyl6+n0gemjh2sWlhNee31Vt361qUo6CRKGB8vXr1Rv8tPM7PoAfLY5DWSEyyKWeeH2+Xr2LHvsMoDk1bJOX4tWi9emr5VHLH3xWcsXLlR3U6dN2kEypcogp7DJxrtC0Mbd+xTXw7y5Qz6FvbCVRsRLVpUNKtXw+T8hx6e6uesJavRsXkDzBw/BPH+iYPWPYeqLzfikYcnvvv4YMHy9RjYta1KN/F6+x4d+oxUX2wiuon2M7B23RZcuXQYnz7cg+vp3SpHdtWqTUbLVa9WAW9e3cSHd3dV6kKVqo3x0u/v1b/37z/gxAlXDBncA8mTJ1VfJJo0sUGRIgWQLHlSo7QJ+dI3fcZCk+tJn8H3y8nwYX0wbrwTatdpiddvvLB/73ok8HeMaU1oHhfFrfNj3OCeWDBlFHp1aKHyTTsNGKPONcH19as3+o1xUHdDdH0atCy41wxDG7fvVbmy+XJlC/b7bN11QLX+VihVVD9NvkTMnzIG127dReEqjVCgYj1153DupJGwiKD50CFRXiwiPihoDHRD0He/v7iyJQqjRcPayJo5g0orKF20ENZu2alfbsbCFSrVYIHjGKyeP0Ut23ekfajfFipunU+lKox2mI38FeqhRtNOKFmkoJoXJYq2/hQkiBRli1ujRYNavvuiaT2ULloQa7fuDrD85y9fsGPfEdj4pYYE1ZqyfL0L7Ab2CLS1ycfv76BDs/oqHy5HlkwYO6C7Wn73oeN+2/ddBWMDu7dT+yVPjiwq7eT+4yc4fd70BS4iadCgJhrb2qBZiy4oVLgKWrftid69OqF58wZGy0l+bIFClVCyVG3s3nMIq1bOQZIkiQJdb8vWvp+jtMJ+fO+Obl3aYPWazaplTNda261rW7Rp1yvQdUiALMZPmIZNm3bg3PlLaNuuN3x8fFA/kC8vWhFax4WoVr6kWq9VhnQqWJs5figuX78VaMBmytT5y5AhTSrUrFQGkUFwrxkB9kf1n+8PQ5t27EONiqXVHTwd+Xu3c5yDRPEt4DxjPFbNcUC5koXRddBYPA8kR54oImKObghKYBEP0aNFQ8a0P3IxhbSGnLt0Vd/xYOXG7djsPEN/2ztrpvQ4d/EqVm3agRF9/zW5XmlBfPnat/VW5+WrN0ic0LcFSn5Kr9m3794bterKawxztVo2qqNOqNL7V5Z7/OQZps5bilR+eVtakcDinyD2xbUAy+85fByfvnxFrcplg1yv7KdXb7xQsWE7/TTpzDdp9hIsW78Ne9bMR5JEvp3TDN9bOpakSpFUn5pgapmE8S3U7UQtpC9MHD8M9pNmYO3arer55cvXkTZNKgzo3xXLlq3TLydVR+7cuacep06fw7Urx9CmdWPVImzK3bv3Ua5CfdU6FS/eP3j69BlWrpgN97sP1PwSJQrD0jIx3O+c1r9G0h0m2Q9H927tkMmqCJ4+8e3wd+3aj7QGSR1yd7+PNGlSQstC67gwRXJB5dz14PFTo5SqoJw6dxG33B8gTznfqgC+YTlQsnYLtG/eQJ/jG5muGYb2HDquOrfVqlIu2O9x9sIVuD94jEkj+wf4rKUyzPHtK1XFF5E9S2ecOOOGLbsOqICbSAsY6IYgyTPMkTUz3B8+Npp+75EHUiSzVL/r8gv9twZKK5OuJdDUerNbZcKpsxf0ZWmkBUtOVI3rVlfPJadKLuinzl7Ulylzf/AITzyfq9ZCQ/Lelol9W8127j+ievVmt/LNpdTWvsgUcF889EAKE7dEpSNf2WKFVLAZFGlp8n/R7th/FGpWLIM6Vcur59mtMsLczEy9d/7c2fW9zR8/faZ/b91tYCnvI5+/kLSGN17vNHHLVgJRyUE2JLewda2pgYkaNYpRq1NgJECWR/z4FqhUsTQGDrJT05ev2ID9B44aLbvDZQVWrNyAJc5r1fOz5y7i8+fPsLLKiP8dP6OmybGTNm1q1WlOy0LruDDl6bMXePP2HZIE0TnNP8fRA1SZRJ3LN25j2MTpcJ4+Tt+JKrJdM/ynLUir+a/sD3mNXB+kQcWQ7loU1cS1SNfSHOlE0v+21jHQ/UVycZVWWR2pcXj91l1YxPtHBSitG9dF35GTVM1U6eF67NQ5HD5+Goudxqnl06dNpXrUjp48E33/bQMLi39w4OhJ1Tlp5oRhgb6vtMIOGT9V3QbPmc0Ky9dtxadPn1Gnmm9w9U/cOOp2lpQgs4gXV5WoGTd1nqq2IA+dRat8c/PkZLbvyHEsWLFB5QxLz94Ivy+ePjPeF7Z10XfUZN99kTcXjp2WfXEGi6eONVrPg0dPcPbiVcwO4vPXiW8RTz0MSYuMtKhLxw4hrSMNa1XGrMWrVRCbIqmlKs0kKvnVIJXayeWKW6vqDNKKHzd2LHXbVtYhfzcRncv2vRg0sDsePnysyovlzZsTPXt0wBLn1fpAePCgHti2bQ+ePPVE4kQJ0blzK6RMmQzrN7gEul4JauWL2o2bd5ApYzpMmDAMN27cwRLnNWr+q1ev1cOQ3Ol4+vQ5bt707XD57t17zJ23HCOG98WjRx64/+Ax+vTupOYF9d4RRVgcF/Kes5zXoGKpoupYeOjxFFPmOqtzndTS1ZEv3vKF7smzF+pOiGyXkOXkb8J/hRrpnyAknSGi1tH902uGzoNHHqp1drb98GC/9/sPH7Hn0P/Q10T5SLkuSN+BweOmolMrW8SMYY712/bg0RNPlCpayOh9Ja9b+oHIlxDdPpMqMhKoE4V3UXwkUUeDvD19Kw2EtNPnL6FNjyEBpteuUg52g3vqv0FLJyPp7JUuTUpVq7KcQYFwGRzAca6zujUlwWrqlMnRyrau0e3BVt0HI2UyS/06xcoNLvoBI7JmyoBBPdojd/YsAQaMkCoO0qGpWKF8qoyZYeqCbLt0PpBOH1kySamxxkGWvvlTZkmzwPtJwFuiIbYvegW8CNeuXBZ2g3roO9JIMK/2ReoUvvuiRGGj5SXAdNl7GHtWzzPZ4lipUXu1f+W1psj85vVrGg0YIS24U+ctw7a9h9R+kTq50unMsEqDXIQmzlyI/UdOIkrUqOpCN7BbWyS3DL0WXbPk2RDdPPRvz/sf2EEGjFizdgvGjHVUf5sxYsTA8mUzYF0oHxInTqg6oMmgD+PGORkN/rB/7zrcu/8Ibf1ybuvXrwm7MQNV1YRXr95g46YdapCJt36d/Ey5ffOk6ghnOGCEtOCOGzsITZvWUzV8T58+j959R5is0hBavn19HCrHRlgcF5I72n3oeFUNQMqCWSZKgGKF8qJrm6b69KrABpUQixzHmPyCp/u/hPaAEXJchOdrhpAUM5c9h7Bn7QLT+6NhO9/90aaJftq6rbswcfoCHNzkrBpD/JMcailvJn0PpM+AnJ86tbQ1uibItUgGvfBv95r5SGnQCTQkrxlh5UXl0oiIEu8+HNabEK4x0A2nKjZoq05YutvhEVVoBrp/g+TDlajVHLMnDtNES+vfCnRDyp1bpzBqtAOWLvNNO9CS0Ap0/wYtHhcR+Zqh9keNppg9aUSE3x8MdH8dA92gMXUhHLrt/kDd/v6dDiAU8q0x1vlzRfiLR0SUPbsVvN6+xbLlPzqvUfjA4yJ8OX3+ohq2l/vjz0TW1GStC1ctuh8+fMDatWtx+/ZtJE+eHI0bN0aiRIGXGhJfvnxRD0NyWzTqG47gEh5E9BZdrYloLbpaFpFbdLUmorfoaklYtug+rxgxW3ST7GWLblDCtHhq9uzZ8eqVb72+hw8fImfOnOjVqxf27t2LESNGqPnu7u5BrmP8+PGwsLAwesg0IiIiIorcwjTQvX79ukqAF4MGDUKKFClw//59nD59Wv3MnTs3hgwJmMRvSF7n5eVl9JBpRERERBS5hZvhsE6cOIGRI0eqFlkRN25cjBo1CseOHQvydZKmEC9ePKOHTPubZDx3GaNcysaER6/f+G6f1LWMDNT+qNMy3O6PO/ceonz9tqpkj9YlTJgAHo8uIG3aVAiPsmXLjHt3XVVpK60L78eFOk/VaRkpzlO8ZoRPYT2UL4cA1migqxs4QQq4S16uoZQpU+L58/A/StS8ZevUEI6mSq3ICa18vdbIWaqWGrUstLhdvq5K2BSq1ECNW96y60BV8kckiB8PNSuXxcxFKxEZzFu+XhVV1+0P2Qcd+41C2Xqtka9ifZRv0BZ2U+ep8l4hTS5cOcvUMfnYfeh/+vqTubNbYem6LdC6wQO7Y+u23UYDMUhuqv9Hw4Y/SrOFJClP5v+9Zs6YoJ9/7dotNSJbr54dEdmOi+u33dFvtIM6HgpUaoiaLbqq0f1Cy4uXrzHQzhGl67ZCoSqN0KB9b+w97Dsktv48VakMZi5ZBa0zdc2QGsOd+49GwYr1VZA5edZifPv2X6i8v5Qdk7Jhcq0wdW2KbNcM0rYwD3TLly+P/Pnz4+3bt7hxw7gzgKQv/KwzWngo6yI1EAMbe3z4xOlq7PfQJEFup34jVd3cVXMdsHqeAxrb1EDUKD92b91qFbB932FVrF3L1P7YsQ821X7sD6lRW7aENabbDcH2ZbNgN7A7Tp69gNFTZof4+8sAEYc2LDZ6SE3M2LFioqR1fv1yUjZuzZZdoXYhCw+kPm3r1rZYvNh3kAhDbdr2QsrUefWPLVt2h9p2zF+w3Oi9Bg4yHhjB2XkNOnZoHiEHTfmT4+LqzTtImMACE4b0wuYl09ChWX04zV+mhigPDYPGT1UjsM0YNxgbFzmhQski6DNqsqrrrVO3anls33tE0+cpU9cMGTXw3/6j4f3NG8tn2av6ult27seMRStCZRtkVDQZOKh9swaBLhNZrhmkfWFaXkw6nBmSdAVD27ZtQ8mSJRGeHT3pqoZ7NRx9TGf15h2qeHrnlo1w9NTZUNsG+xkL0LReDaOxydOnMb5VLIXALRMlxL4jJ1CvRiVo1dGTZ/32x4+euxb/xIVt7ar65zK0ZqM6VfWjlYUkCZYMB+gQ+4+eROWyxY1ujxcrmAdeb9/D9cLlAEMKa0XVquXVYBnSYurfGy8veHr+nbs1Hz9+DvK99u47goQJ46N0qaI4cDDoVCktHReGQa+QIXYvXL2BfUdPoomN79DiIcnt8g0M691RDZ4iOrZoiKXrt+HKjTvIljnDj/NU4oRqG+pVrwgtMnXNOH7GDXfuP8R8x9FInDABsmYGurZrCsc5zuqLckiPQNa8YW19mbjARJZrhiGmAWhT1LAOdA0flStXNpo/adIkrFoVvm9jnb1wFdmzZAww/c69B5izZA3GD+mlWhRDy8vXb3Dx6k0kTBAfTTv3R6nazdGq2yCcu3g1wLIydLCp6Vpy9tJVZLcKuD8MPXvxSp28C+bJGerbIyMOyS1im2rGF225cMnY8zLEqlaVKG6Nc+cumpw33ckOTz0u4cT/XNCqZaNQ3Y4mjeuq93I7vx92YweqlmZDMlLbhQtXUaKENSLzcSHevf+ovhiGhrw5s2DXgf+pFsLv379jx/6j+Pr1K6zzGh+HObNm1vR5ytQ148KV68icIa0KcnVk6GRJr5K66mElMlwzSPs4YMQfeuL5DEkSJTSaJsPr9hs1GX3+baXGMpdx30PLI791z1q8Cn3/ba2Cp627D6Jtr6HYvGQG0qZOoV9WWkoMbxNq0ZOnz5AksXGLqo7kIx783yl8/vIVZYoVwuh+XUJ9e+R2cYa0qZAvZ8AW/ySJE6q8PK2SDmgeJjrbjBg5CQcPHsPHT59QsUJpzJg+Tg0ZPGPmohDfhlWrN+PBg0dqO3LlyobxdkNgZZURDRq2N1rO48lTpPF3FySyHBc65y9fx+6DxzBzwtBQ2QaHEf3Qd/RkFK/VHNGjRUPMmDEwdcxApEll3DdD6+cpU9cMGdY9UYIfQyWLRH5B74tXbxBWtL4vKHJgoPuHJGiyNDcPMCZ5hrSpUbNS8Ec2kxxbXeteiqRJsGXpTNRu0QUefoFQgdzZMWfSyACv+/7dd7yPBrUqq5wqkc0qo8pB3bhjL3p1bKlfNkYMc5WbpWWfvwbcHzoDurRRaST3H3lg6vxlsJ+1CMN6dTK5bKf+o3/sj2RJsGXJdNRu1Q0eTw32h/3woLflyxfs2HdE3aI1JWYMc3zyN9iJlsSKGdPk35vduKn6393criBOnNjo07tzoIGuy9ZlKFGisPr9/oNHyJO3HC64HUBav8D02LFTqFGrucnXLlj4I8fx8uXrePrkGfbuWYsMGdLi7t37+nmfPn3WdOWFoI4LcevufXQfMk4dH9KSGJg/OS5mLFqJd+8/YIHDKMS3iIcDx06h78hJcJ4+zqgfgzpPafi4MHXN+B2/e834FZHhmkHax0D3DyWwiIe37417rJ46d1FdOPKU9e1lrxt7rmStZmjfvCG6tmkSYD2j+nfTj/AWPbrvbpltP0JfZziwkmlJ/PJBpSe/IQm0n3oal4aRW4bSm1bz+yOQ6haSOysPaWGV27Mtug9GpxYNA7SuiFH9uqj8UhE9um8npdkThuk7j8kF4Gf2HD6OT1++BjqUs+ToSl6kVr14+QoJEviWCwzK6dPnMXRIL5ibm6tb2f516NRPn24gaQaiZq3m+rxFCVKDS5cvnCljOqNAV1J/7hg8j0zHhZS7a9tnOOrXrBTol7I/PS4ePH6ClZt2YPPiaSr3U8jdJ7ktvmrTTozo09nouEjgV2YyslwzJGXh0rVbRtNevnrtN8+4pfdPrxm/IjJcM4z4+FaBIm1hoPuHsmbOAJe9h4ymOY4ZqL8YiMvXb2HYhGlwnj4BqVOaDmySJglYXUI6Tf2MlKeR20v3Hjw2mn7/0WOUKFzAaJrkehXylw+nNVkzBdwfpnz3+/YhaSYhuT8Mbdy+D2WLFULC+KYv2rfc76Ni6aLQKje3/7N3F2BRdG0YgB8DbEVM7Fbs7u7uAhUVuwsDW2wMsLtbf7vFLgzsTiQEMVBQPxUV/+sc2GUXFkSldva5v2sv2dnZmfk4zOy7Z97znruwtGz12/WKFSsEX9/3OoNcwUtH6o97qL/3yCperJD6Vr6mQoUKYGc0VRuIy+eFuCZYDx2HZvVqYFD3jr/dzt+eF6oe2njxtQOJ+Ani41eoEUBPXd0UfZ3S9ZkhBqaJkmNizIUqhcHZ5SaSJ0uK3DmCvhhExzXqdwzhM4OUL9bLi+m7SmVL4JmrO/w0ekuyZTaTAwtUD1WtRNGTGDoPKyrqEHdt3wKbdh7AsdMX4O7phQUrN8LV7SVaaoxaFiVt7j96KkuQKVmlssVlD5Vme5y95ILdh0/IXnZR5/aMs4ssLVaisLnO2sdRwd3TW95WDG/kuDgOMSiugkIrLgjHnM6gUMF8MNEI9Bs3qgPrrhYoVCg/cufOgV49rTBq5AAsWrwmyvcv0hPGjB6MkiWKyHzhxo3rYM3qeTh71hl37jxQrydey5w5I06cPAdDOi/E+WA9ZBwqli6Ozm2ayTq34uH7wS/K9y+qwIjrot2cJbjz4LHs4V27bQ+cXW6hZnBaivo69fgZKpYpDkP6zBD/v7mzZ4XtFAc5ePXCletYsHIT2rdoCGPjqK24IIh2fvjkuWwH1d+CeK5ZSsxQPjNI+dij+4/y5c4hc2KPnjyPts3qx8oxiFIx3wK+Y+aCVfD/+BH5cufEirl28oNF5dT5S3JgXKngHi2lErl+5vly4eipC2jbNKiKR+JEifC/A8dgv3AVAr7/kLVuRQ3PbpYto+04dh0+LntcwvvAPnTynAwworoHJi4RObE3btxBm9ZNZC1bVepBnz5dMGf2RPkl7emzF7AZPkkrlzaqiN76WjUrY+CA7kiWLAk8PLyxe88hTJ02T2u99u2aw8npzF/3EuvreSFSa0RQe8DpjHyoiHzPY9tWROn+jRImxJKZ4+CwfD36jZ4q002yZjbDVNuBqFq+tHo9MVjULH06lCpayKA+M0RZwkUzx2HynCXo2Ge4zG9vWr8m+lt3iJZj2Lb3MJasDalv3XmArfx3iu0gWePbkD4zNLG8mDLF+/VLlUGqLN99tCefiE5nnK9izuK12LNuAeJHYymxf2HZ2wYdWjVBozrVYnS/Rhny47t3SO9ZTBA9tnOWrpX5gHGxPUSw17BjX8wcOxQli5jH6L6NzMyR0DhzjO2vYYNamDFjrBxAFhcvNSLP9+H98+hk1Q8XnV1idN9ilraYPDfi+nkhWPYZgQ6tGqFR7Ri+TpmZ8zMjDn1mxJZXVatDH2U8+/t0PUPGHt0oUK1CGbh7eMHnzTv5DTguzlteu2oFNKxdFYagWoXSMoXD5+072TsU13j7vEWPDq1jPMiNDYcOn0CePDmRObMZPD29ENdky5YZM2YuiPEgNzbE9fMi6DpVHg1rKf86xc8MopjDHl1SXI8uxZ0eXYo7PboUd3p0KXzs0f1z7NGNGHt0iYiIyOD9CmR5MSWKm8lBRERERET/iIEuERERESkSA10iIiIiUiTm6BIREZHBYx1dZWKPLhEREREpEgNdIiIiIlIkpi4QERGRwfv1i+XFlIg9ukRERESkSAx0iYiIiEiRGOgSERERkSIxR5eIiIgMHsuLKRN7dImIiIhIkRjoEhEREZEiMdAlIiIiIkViji4REREZvF+BrKOrROzRJSIiIiJFYqBLRERERIrE1AUiIiIyeL9+xfYRUHRgjy4RERERKRIDXSIiIiJSJAa6RERERKRIzNElIiIig8fyYsrEHl0iIiIiUiQGukRERESkSExdICIiIoPH1AVlYo8uERERESkSA10iIiIiUiQGukRERESkSMzRJSIiIoPHKYCViT26RERERKRIDHSJiIiISJEY6BIRERGRIjFHl4iIiAwe6+gqE3t0iYiIiEiR4v36xXGGREREZNieF6kLfZTrzrHYPoQ4TbGpCwFe92L7EAiAcaZC+O79ILYPg4IZmZnDyDhzbB8GAfge8JLnRhw6L777PIrtwyDRFhnyx9q+f/1i6oISMXWBiIiIiBSJgS4RERERKRIDXSIiIiJSJMXm6BIRERFF1q/A2D4Cig7s0SUiIiIiRWKgS0RERGQgzp49iyZNmiBTpkyIFy8e9uzZo/X6xIkTUaBAASRLlgypU6dG7dq1cfnyZa11fH190aFDB6RMmRImJibo1q0bPn36pLXO7du3UaVKFSROnBhZs2aFvb19mGPZsWOH3JdYp0iRIjh06JDW66IC7vjx42FmZoYkSZLIY3ny5Mkf/f8y0CUiIiKDF/grnl4+/tTnz59RrFgxLFq0SOfr+fLlw8KFC3Hnzh2cP38eOXLkQN26dfHmzRv1OiLIvXfvHpycnHDgwAEZPPfs2VP9ur+/v3xP9uzZce3aNcyaNUsG0MuXL1evc/HiRVhYWMgg+caNG2jevLl83L17V72OCI7nz5+PpUuXymBbBN/16tXD169fI/3/q9gJI1hHN25gHd24hXV04w7W0Y07WEc37ojNOrqPzetDH+V7cOSv3xsvXjzs3r1bBpjhEUFrqlSpcPz4cdSqVQsPHjxAwYIFcfXqVZQuXVquc+TIETRs2BCenp6yp3jJkiUYM2YMXr16BWNjY7nOqFGjZO/xw4cP5fN27drJoFsEyirly5dH8eLFZWArwlOxrWHDhsHGxka+7ufnhwwZMmDt2rVo3759pP4f2aNLREREpKe+ffsmg1HNh1gWFQICAmQvrAh0RS+w4OzsLNMVVEGuIFIK4sePr05xEOtUrVpVHeQKoif20aNHeP/+vXod8T5NYh2xXHB1dZWBsuY64jjKlSunXicyGOgSERER6anp06fLAFDzIZb9iwMHDiB58uQyd9bBwUGmKKRNm1a+JoLP9OnTa62fMGFCmJqaytdU64ieV02q579bR/N1zffpWicyWF6MiIiIDJ6+TgFsa2uLoUOHai1LlCjRP22zRo0auHnzJt6+fYsVK1agbdu2src2dICrD9ijS0RERKSnRFArqh9oPv410E2WLBny5Mkjc2ZXrVole2zFv0LGjBnx+vVrrfV//PghKzGI11Tr+Pj4aK2jev67dTRf13yfrnUig4EuEREREYUrMDBQnfdboUIFfPjwQVZTUDl58qRcR+TPqtYRlRi+f/+uXkekP+TPn1+WLFOtc+LECa39iHXEciFnzpwyoNVcR+Qfi55l1TqRwUCXiIiIyEB8+vRJpiWIh2rQl/jZ3d1dVkEYPXo0Ll26BDc3NxnMWltb4+XLl2jTpo1c39zcHPXr10ePHj1w5coVXLhwAf3795dVEESVBMHS0lIORBOlw0QZsm3btmHevHlaKRaDBg2S1RrmzJkjKzGI8mMuLi5yW6qKEIMHD8aUKVOwb98+We7MyspK7iOiKhGhMUeXiIiIDN6vQP3M0f1TLi4uMgdXRRV8du7cWZb1EkHnunXrZH5umjRpUKZMGZw7dw6FChVSv2fTpk0yIBXlxkS1hVatWsl6typiQNyxY8fQr18/lCpVSg5kExM/aNbarVixIjZv3oyxY8fK4Dpv3ryy/FjhwoXV64wYMUIG3+J9ohe5cuXKMjgWg+Qii3V0KVqxjm7cwjq6cQfr6MYdrKMbd8RmHd2H+RpCHxV4rD2bGGlj6gIRERERKRJTF4iIiMjgKfP+NrFHl4iIiIgUiYEuERERESkSA10iIiIiUiTm6BIREZHBM5TyYoaGPbpEREREpEgMdImIiIhIkZi6QERERAYv8BdTF5SIPbpEREREpEgMdImIiIhIkRjoEhEREZEiMUeXiIiIDN4v5ugqEnt0iYiIiEiRGOgSERERkSIx0CUiIiIiRWKOLhERERm8X79i+wgoOrBHl4iIiIgU6a8CXR8fH3Tq1AmZMmVCwoQJkSBBAq0HEREREZFepi506dIF7u7uGDduHMzMzBAvHktyEBERkf7iFMDK9FeB7vnz53Hu3DkUL14chsbl1j2s3bYX9x8/w5t37+E4eSRqVS6ntc5zN084LF8Pl1v38fPnT+TKngUOk0bALEM6vHz1GvUteuvc9uwJNqhXveJvj8Fu7lLs2H8MI/p1RafWTcK8HhDwHZZ9R+LRsxfYsWIOCuTJKZd/CwiA3dxl8thd3TxRtUJpzJ8yCvrcFmu27la3xbzJo1CrSnmtdZ65ecBhmWiLe8FtkRWOdiOD2sLbB/Useunc9pyJw1GveiWdr42ZPg97j57SWlapTAksmzVB/fyFx0vMWboON+48wPcfP5AvVw4M6GaJsiWKqNeZNn8Fbt59gCeu7siVLQt2rnKEUsSPHx/jxw+DpUVLZMyYDl5ePli/YQemTdP9/7ho4Qz07NkJw4ZNwPwFK8PdbuXK5TBsWB+ULFEEmTJlRKvW1ti376jWOsmSJcW0qaPRtGl9pEljAtcXHli0cDWWr9igXidDhnSYOWMcatWqghQpkuPx42eYPmM+du8+BH0XW+fF77br5/8Ri9ZswUWXm/D2eYvUJilRs3I5DLC2RIrkydTbuPPwCRyXr8f9R89kJ0ph87wY2quz+jqmb1xu3g1qj0eiPXwxb+rosO3xwgMOS9fB5dbdoN9bjqxwnGwb0h7teujc9pxJI1CvRmWdr/333xc4LFuHk+cv44PfR2Q2y4AOrRujXbMG6nW+fQvArEWrcfjkOQR8/y6vY2OH9kZa09Ra29pz+ATWbdsDN08vJE+aFHWrV5LrESk20M2aNSt+GWjW9pev35Avdw60aFATg8fbh3nd4+UrWA0cjZYNaqNvl/byovD0hTuMjY3k6xnTpcGpnau03rNjvxPWbtuDKuVK/Hb/J85dwu37j5E+rWm468xdth7p0prKQFfTz5+BSJzIGB1aNsLxs87Qd1++fkX+3DnRomFtDB43I8zr7i+9YTVgNFo2rIV+XS2QLGkS+YGibov0aXF65xqt9+w4cEx+KFUpWzLCfVcuWxJTRg5QPzcK3qZKP9upyJbFDKscJsvf+Yb/7Uc/2yk4vGkp0qYJ+RBp0aA2bj94jMeh2krfDR/eD716WsG622Dcv/8IpUoVw8oVc+Hv54+Fi1ZrrdusWX2UK1cSL196/3a7Ioi9ffs+1q7div/t0D6PVGbPmoDq1Suhc5cBcHPzQJ3a1bBgwTR4eb/CgQNOcp01q+fBxCQlWrbsirfvfNG+fQts2bwU5Ss0wM2b96DPYuu8+N12X7/1xet3vrDp00UGwN4+b+SX9jdvfeFgN1IdnPUeYYcaFctg7ODeMugTwXGv4ZNwfMdKGCVMqJefGer2GDtd9++t/yi0bFQb/awt5N/4M1d37fbYvU7rPTv2H8WaLbtRpVypcPdrv2gVLl+/jeljhyJzxvS4ePUGpjgsRfo0pqgR3Dkzc+FKnHV2wdxJI5A8eTJMc1wmj3Hj4pDPNhHgisewPl1RpGA++ffl5f06Cn9DRNHrr64ajo6OGDVqFJYtW4YcOXLAkFQpV1I+wjN/1SZ58Rna20q9LGvmjOqfRQ5z6G/L4hu36CVJmiRJhPv2efMO0+avxDL78TKQ0uXc5euyx0T0IJ+/fF3rtaRJEmPckKCemht3H+Ljp8/QZ+L3HNGFfv5K0RYlMax3F/WybJnNtNtCI+hUfZGoV6MSkiaNuC2MjRKGea/K+w/+sufDbkQ/5M8ddH4M6WmFrXsOy95b1ftGDwzqpfH94Ke4QLdC+dLYv/8oDh8+IZ+7uXmiXbtmKFNG+y6Q6JV1dJiCRo0tsXfP+t9u9+jRU/IRkfIVSmPDxv/hbPCXuZWrNqFHj44oU6aEOtCtUKE0+g+wxVWXm/L59OnzMGhgD5QsUVTvA93YOi9+t928ubLD0W6U1msDu3fAqKkO+PHjJxImTIDn7i9lz68I+MzSp5Pr9enSDi2tB8P71Rv55VHfVClfSj7CM3/FRvm6CCQj3x7Ov22Pm3cfoln9muq7SG2a1seOfUdx58ETGeiK6/+ug8dhP34YypUqJteZPGoQmnbqi1v3HqJYoQLw+/gJC1ZuxMIZ41A+eB1BBO5EihuMljp1apiamspH+/btcfr0aeTOnRspUqRQL1c9DFVgYCDOXrqG7FnM0Gu4Haq16ALLPiNx4vzlcN9z79EzPHzqKntBfrft0dPnoWu75siTM5vOdd76fsDE2YsxffQgJE6cCIYsqC1ckCNrJvQcPhFVm3eGRZ/h8gM7PPcePQ1uizq/3f7Vm3flNht36it7pT74+atfM0mVAjmzZsa+o6fx35ev8kN8+76jME2dCgXz54YhcL7kgho1KiNv3lzyedGiBVGpYlkc0QhSxW3ptWvmY+7cJbh//3GU7fuSswuaNK4jg2ihWrWK8jicnM6EHJ+zC9q0borUqU3kcbRt21SeM2cUcKcjNs6Lv9mu8PHTf/KulwhyhZzZMsMkZQoZgH3//h1fv32TP4v0r0wZ00Np5O/NOfj3NmwCqjbtBIteNr9vjyeuaNko4utU8cIFcOrCFdlBIu7AXrl+Gy88vFAx+Mvm/UdP8ePHD60AVvyeRbrErXuP5HPnqzcR+OuX3EaTjn1Rq1VXDJswU/bGK3UKYH18UBT16IpeXIqY6JkTgc3qLbvR39oSQ3p1wvkrNzBkvD1WzbVDmeKFwrxn96Ggi7i4KEVEbFN8s+/QqpHO18WFbOzMBWjbtB4K5c8jc4ENme/7oLZYtXkXBnTrgKE9rWRbDB4/E6sdJqNM8cJh3rMruC1K/KYtKpUtidpVKyCzWXqZqjJv5Ub0HjkZmxbNkG0kAqcVcyZh4NjpKNfQAvHjxZNB7jL7CUiVIjkMgb39QqRMmRx375yRt5/F72Xc+JnYsmW3VnqD+KBdsFB3CsLfGjR4HJYusYfbi2syWBLBRO8+I3Be4wunhWVvbN60BK997sl1xC3z1m264ZnCetZj6rz4m+2KOx/LNmxH6yZ11ctEusMaxyny3Fm2YYdclj2zmcx/VwXDShL0e/uCVZt2YkD3jhjau7O8EyfSB1bPm6q7PQ46ydSPEkXMI9z26EG9MHHWQhmcJhTXpfjxMHF4f5QO3qboGDEySoiUoa5JaVKb4O279/JnT69XCAz8hZUbd2DUwB5IniwpFqzchJ7DxmPXmvkwMtJO2SLS60C3c+fO0XskCiAuCEL1imVh1SZokJgYQCFuA4mcqtCBruitOHTiHHpZtYlwu6LXd+POg9i+fHa4FS427zokP6y7W7aMsv8ffSZ6IYQalURbNJU/F8ibCzfvPZS9q6E/QGRbHD+LXlZtf7vthrWqqH8Wg8xEznYDy96yl1f0jogvHVPnLUea1Kmwbv40maO786AT+ttOxdZls5AujfLverRp0wQW7Vuik1U/2VtbrFghzJk9Cd7ePtiwYYccTDagfzeULVc/yvfdr19XlC1XEs1biOownqhSuRzmz5sqB8SdPHlOrjNp4nCZo1u3Xju8e+eLpk3ryRzdGjVb4u7dh1Cq6Dov/nS7nz7/h762k5E7e1Y5lkFzf+NnLZRBnLilHvgzUI5f6Dtqijx3EidS1p2qwF+B8l+RSmDVtlnI7+3uQ2zfe/ifrlObdh6Q4zkWTh8Ls4zpcO3mPUx1WCbHd1QoXTzSxye+jI4a2BOVygaNIbGfYIPqzTvjyo078ks/kSJzdA8dOiR7aOrVq6e1/NixY7L3pkGDkFGdhiR1qhTym3PuHFm0lufMlkWOvg/N6YwzvnwLQJO61SPc7vU792Vvcd12PdXLfgYGYvaSddj4vwM4unUZLt+4g1v3H6NU3XZa723fazga1a6KqbYDYZBtkT2r1nLRM3VdR1scO3NRtkXTejX+eF9ZM2VE6lQp4f7ylQx0xQCQM84uuLh/o+wBEQrmyw1nl1vYe+QUundoBaWbMX0cZs1aiO3b98nnInjMli0LRozoLwNdUT0hffq0eP7sivo9oia3vf14DBjQHXnzaY9Kj6zEiRNjyuRRaN2muzo/+M6dBzLQHjqklwx0c+XKjn79rFGseA11yoQY4Fa5Ujn06d0F/frrbyWS2Dov/mS7n//7gl4jJiFZkiSyIoTmALODx8/Ku1GbFs2UlTsE+3FDUbFJR5w8f0XrS6YSiOtG+L+3+2HWP3b6ohzc1rR+zQi3KwLieSs2YN5UW1SrUEadVytSUNZu3S0D3bSmJvj+/Qf8P37S6tV99/6DOidY9aU8d46Q4zM1SSXTs5SavkDK81eBrhiINmNG2NG84haheM1QA11xG6dQgTwyD0qTGJhkliFsftmuQydQo2JpeeGISJM61VG+VFGtZb1HTEbjOtXQPPiCZzugGwZ0s1C//ubte/QaYYdZ44ehSMG8MNS2cPV4qbVctE2mDEGDXDSJPEAx0vt3baHLq9dv8cH/I9IFfziIDxlBpCxoih8/nroHR+nEIBnVHQ4V8SVYFbxs3LQTJ4J7V1UOHtiETZt3Yt267X+9X3Er1tjYWF6LtPcdqN63agBP2HXE8Sk73y26zovIblf05IoKCqKdFkwbg0SJjLXWF+dO/Hjxte5cxYsn2k3kIirv3An6veUN+3vz9NKZkyzSFkSv+e/aQ4wLED2x4nepKUH8+OrzsmD+PPLL5eVrt1EnuKylq7unDGCLFcovn6vSI0S5RFH9QRCDBUW5Ml2fafrOQItJKd5fBbpPnjxBwYIFwywvUKAAnj59CiUT+VSi507lpfdr+S1Z5F6KJP6u7ZrBxm4uShUtiLIlCss8tTMXXbDacXKYkjLXbt/H4hljfrtP8e1ZPDSJXgDxjVwM3hDEvjWpKjiIig8Z0wVdoARR7kfUdfX/+BGf//sqj13QxxqVIlVD/B5VRE/QwyfPkSpliqC2aN8CNpNmo3SxQihbvAjOX7mOMxevyhxATe6eQW2xZMa4SO1z8bptqFO1gvz9e3i9wtxl6+QoaVGDUihWsABSJk+G0TPmobdVO5m68L8DTvD0fo2q5Utr7Vf8PYlcOVHjWBy7qvdE33PfDh50wqhRA+Hu8VKWFytevDAGD+qJteu2ytd9fd/LhybRu+Tz6o2saRseUXopj8bfas4c2WRvrdiWh4cXPn78hDNnLmLGjLH48uWrTF2oWqUCOnZsheHD7eR7Hj58iidPXLF40UyMHDkZ73zfy5q7tWtXRbPm+p+iFRvnhfC77Yogt6fNRHwRvY1jRuHz5//kQxA1dcVdwgqlimPOknWY4rgMli0b4ZfID928EwkTxNeqQa3X7eHto90eFi1gM3FW0O+tRBGZo3vm4hWsmTdNazvunl64duseltiP/+0+xZ0kkYs7Z8ka+WVCfNkQtY33HT2F4f2t5TqidrEoaSbKkKVKmTyo/rTjclltQTyEHFkzy1rHM+avwASbfnK7osax+NwpW1I/24MMT7xff1EQN2PGjNi8eTNq1tS+fXL8+HFYWlri9evYHwgV4BU9JYJEHqb1kLAXGnFrb+qooLqquw+dwMrNu+RIVTGaVuSg1axcVmv9eSs24sDxszi6Zam6p0lTvfa90Kx+Da38tdCvd2zdWOeEEYJqYgrNCSNU7/PSccvpzqldiA7GmQrhu3fYW6JRQeSIWQ8J+yHcTLSF7SD1QJqVm3aq20LU9xQXbk2OKzbggNMZHNu6XGdb1G3XQ5bpEe8VPU5ioIwY9ez/6TPSp0ktRzH3t+4gA1+Vuw+fYv6qjTK/WvSs5MmRDb07t9Uq+9Rl0Bj54RPa0S3LZHH36GBkZg4j46AvR9FJ1OScNHGErJGbPn0amR+7bfteTJniIAd/6fLk8SUsWLBSa8KI4047ZGmybt2HyOdVq1bAieP/C/Pe9eu3q9cRk0FMnWIrA1dTUxO4ub/EqpWb4DhvuXp9ESxPnWorK0GIYxWD0OY6LMWmTTsRU74HvIyWcyM2zguViLYb3nGF/psX5RGXrN2Gp65uiBc/Pszz5sTAbh3VvYzRdV589wmqNBDV5P/3oLAdGuJ3N3X0YHVP7cqN/wv6vWXLHPR7CzWphAgwDxw7jWPbV+puj7bdg9rD2lI+FwPKxHtE/Vw//0/IlDEdWjepJ3OBVT3mqgkjDp04K8/LimVKYNzQPlrlzMQXlJkLVuLEWWfZHiIgFwPTQneuRBWjDNHXzr9zPWtQnrS+KemxN7YPQXmBbq9eveDs7Izdu3fLEmOC6Mlt1aoVypQpg5Urw5/ZSN8D3ZggcrCqNOuMJTPH6hx1q0+iM9CNqbao3LQTlswcp7c9SrER6EaVp08uw85uDtZv+Pt0hrgqugLdmKDE8yK6At0Ya4/GHbBk1gS9b4/YDHRdsjSHPirtuSe2D0EZdXQ12dvbI1myZDJVIWfOnPJhbm6ONGnSYPbs2f90QIY645qmqzfuyLQHfQ9ylUD0xohbdPr+4aGPChbMB39/f2zYGFRmiuIOnhdxy5Ubt1G2ZFG2B1FU9egK4m1OTk64desWkiRJgqJFi6Jq1ar4V2IgidimCJwNtUdXSfS9R1dp9K1HV8n0uUdXafS9R1dJ2KP759ijGw2D0davX4927dqhbt268qESEBCArVu3wsoqZPrb8AwdOlTncjHyWVR0EL3Dwty5cyPczrdv3+RDU6JEiaDssdNEREREFC2pC127doWfn1+Y5R8/fpSvRXamtVOnTuHGjRtaD9FT/ODBA/nzzZtB89BHZPr06UiVKpXWQywjIiIiiqzYnsqXUwDHoR5dEYzqmqHL09NTBpqRMW3aNCxfvhxz5szRqt4gyiqtXbtWZ/kyXWxtbcP0DoseXbxTdpkzIiIiIorCHt0SJUqgZMmSMsitVauW/Fn1KFasGKpUqYLatWtHaltiYolt27ahT58+sLGxCbfk0O+IoDZlypRaDxnoxiBRPLtaiy6ypFdc9N7PXx7fqzdvYQg++PmjavPOsl5lXPT+Q9DxiYkmlM7UNDVeet5C9uzaswXGFebmeeH63EU9iYSSxfXzQtT4rtW6G/778hUG0RZNO8Xta1TTTgZxjSLl+6Me3ebNgxK1RUqBmP43efLkWoPIcuTIIUuMRZYoRXbt2jX069cPpUuXxqZNm3T2FMd1yzf+T85Wkzl4JptHT12xastuOfWlCIJF/cK2TerJurfR5ea9R1iwahPuPHgiayzmz5MTy+zHybnhxTSTYprhxWu2wW5EPyiduj00atFOm78CN+8+wBNXd+TKlgU7VzlG2/4LV9c9oGFo786wbt9CFscX7bFo7RZMHhFUe1mpbEcNxP79R2UtXF1B8DUXJ2TJYoa06czh5+cfrceyf98G1K9fE61aW2PfvqNy2YMHT3D5ynUMHtwL06ZF399EXDwvRLA1cooDHj9/IWf2E7Nt1axUDoN6dFRPXR2VdNWNbtOkHiYM66OeKKVowXxYv2OvnGhFyZZv2IEalctpXaPEjGR2c5bg6o3bcsIfMc3v4J5WSJgwQZTvX9TYnb1kDZxdbsoJLcTEED07tVXPkCavUfVqYNHqzZg8ynCmjw9kGoAi/VGgO2HCBPmvCGjFYDQxr/y/EsHyunXr5CA20RssBqPpW/3C3YdPYKl9SCH0+4+fyw+N6aMHI2P6NDIIFRew+Aniw7JFwyg/BrH9PiMno5tlS9gO6C5nGHr07IXW9I9iquB2vYZjWG8rOSOPUon2EEXrl9kH/a1qatGgNm4/eIzHz15E6zGc3rlG6/m5K9cx3n6hnE0t5FhqoW3PYbDp3UWx7ZEkSWJ07doejRp10Pn68uWzcefOfRnoRrdBA3uEW7pw3bptWLrEHjNnLtC768+/nBei+H+NymUxoFsHmJqklLN3TXVcDr+PH2E/bli0HEfrxnXQv2vQhAZC4sTad9+aN6iFibMXobtl62gJ8OJMWxx0wrLZE9XLxN9d3xF2SJPGBBsX2+PNu/cYPdVB/g5EsBvVbKc64OOnz1g4bSxMTFLikNMZDJtoj23L58A8X1Bt/BYNa6NtjyGw6dtVsdcoMgx/NRitc+fOURLkamrfvj1cXFywa9cuZM+eHfri3OVrMDZKiGIFQ0qitGhYC6MGdEOZ4oWQNVNGNKlTTc5Yc+LcpWg5BjGzjWXLhuhu2RJ5cmaT0zPWr1EJxsYh08iK5enSmuLEuctQsnOXRHsYhZlFafTAHrBo0RBZomnGMU1iViHNx6nzl2VdZPG3oNke6dOa4ng0/U3EBQ0a1JIzL4ke09B69bSCSaqUmOuwLNqPQ0wRLHpse/TUHbwdP35WzqAmZl0zpPNCTFvevlkDFC6QB5kypkf5UsXQrnkDOe1vdBF3mDTPjdA9xxVLF5OzeLncugulOnfJJbgtgqbZFS5evYlnbh6YMXYoCuTNhSrlS6F/9w7YuvvQX6f1ReTmvYewbNUYRQrmk9elXp3bySmB72lMvy2vUWlMcfysc5TvnyjOB7ri26eYGKJs2bJyOmBTU1Otx9/KkiULmjVrJiej0BfXbz9QfwOOiJhGUXywRLV37z/g9oMnsge5Y39bVGvZFV0GjZVpE6EVKZAH13QsV5Jrd+6jYCTaI6a89f2As5euoWXDsLnrhQvkxfVoDCpiW+VKZXH9+m2debFjxgxGV+tBCAwMjPZe5fXrF2LgoNHw0TH1tSACiVu37qNyqGm6De28eP3WVwY1pYtF30Q1B4+flTOqNe8yEA7LN8jeTU1iMLKYsjw6g+3Ydu3WfRTMr90Wt+49RN5c2ZHWNGTq3UplSsjPjaeu7lF+DMULFcCRk+fg5/9RnoNiCmBRHrRsqEmKCpvnU/Q1igzDXwW6kyZNkvVtRfqCKDMmqh60bNlS5oZOnBhyO8YQePm8kd96I3Lz7kMcPXUBrRuH1ByOKp7BgxmWrNuGVo1qY+nMcTDPlwvdh02Am6eX1rrp0pjKPDAl8371GunShnxYxLZ9R0/KgU61q4TtLRQ9uuLvR6myZc8C71CDbUQu/8YNizHKdgo8PLT/PqPDnNmTcMnZBfv3H4twPS/vV8ieLW4OmIvu82K43RyUrtcWNVtbyx5Wu+HRk8ffqHZVzBgzBKsdJ6N7h1Y4cOw0Rk11CLOeuPOk5OuUt89reS3W9Nb3PdKkNtFaliY46BVflqPanEkj8OPHT1Rq3AEla7WC3ezFcJwyGtmyZDKoa1Rov/T0QdFQXkwMGluxYgUaNWokA1sLCwvkzp1bzo526dIlDBxoOMnr4tasZopAaE9c3TBw7Az07twWFcsUD3e93iMny95hIVOGdNizdh6adxmkvsiULGoug9jQfgUG/Zm3aVxX5n0K5nlz4fL1O9h9+CQG9+ioXjdxImN8DdWDojRfAwKQ3tj4n7czac4SHHA6o35+9chW9B5hp+5pEgMM965d8Nvt7D50Ao1rV0WiRGGPSSz7GmqyEyVJkjhxmL+3qVNs8eDhE2zevOuPBpFVrlxO/uzm7onixWvi5s2T6sD0/PnLaNK0U5j3NW5cB9WrV0KZsr//gvn1y1ckUXDlhYjOi5H9rNGnczv5xdhxxQbYL16NcUN661xX1znQrMsAeL0Kuk6VKloQS+3H63yvGHimki9XDqRLkxrdho6XucHZMptpXae+KPi8+Potaq5RvYdPDGmLDOmwd/0iNLPqp/7MkG0xS3fH08JVm2SO7kqHyTKF6OS5S7CZaI91C6YjX+4c2tcohX9mkPL9VaD76tUrFClSRD2YTDV5ROPGjTFuXNhgTMlMUqWA/8fP4ZbL6T5sohyA0atTmwi3M8mmL74FBMifEyYIGoSxeMYY/AgeHJMonAujyHMTcuXIqrU8V7bMYXpF/D5+kqNplUxUmPD/+Omft9Pf2gJd22lXT5g0vJ/8YiNEZqDMtdv34OrxErMm2Oh8XeQipo5k3Wl99O6dL0xSa///1ahRCYULF0Crlo3kc1WVlVfedzB9xnzY2c0Js51evYfLFARBla/YtGkneZtb+BJOOaoa1Ssjd+7sePtGO11n+7YVMjiuXSfknEyd2gTPn7vBEM8LVb5sruxZZHqV1cDR6G3VNkyvY3jnwJIZ42TvoKDrC114ipjnk/96vHylFeiK80Izn12RbfFJuy1EyoKomKPpne/74Ne0e3pVJo0YoJ4VNGHCoI/yJfYT8OPHD/lzeGU2xReLzbsOYs+6hTIPVxDpIiJFYcvuQ5hg01e9rkhtUPpnBilfwr/NpfX29ka2bNlkT+6xY8dkLd2rV6/GeA3b2GaeNycOOJ0Ns1zkVXUbNgHN6tbAwO66R51rypAuaMpjTWKAyO+Ikmbi9tILj5day908vVG5bIkwx1S6eCEoWYE8uXDA6fQ/b0fcRgx9K1FXG0Vk18HjMi9SfIjo8tTVDWVC5cQpyY2bd9HBUrvcYNt2PdRBq1C6VDGsXOmAGjVa4tlz3dUwvLxehVnm7q79966L/ayFWL1ms9aymzdOwsZmIg4cdNJaXqhQAezadRCGfl4EBlemCAj4HqXXKV0ePnXV+rKueResTjXlDgwUg81Ct4UYmCZKjokxF6rrjij9JVJJcucICkajqi1UPbShS3mK1MNfvwLDfGYo+RpFhuGvcnRbtGiBEydOyJ8HDBgge3Hz5s0LKysrWFtbw5BULFNC9tyK3lLNC7W4JVexdHFYtW0i86/Ew/dD2GmT/5W4WHVp1wybdx3CsTMX5bf1Bas3w9X9pdYAKDHo4/7jZ/KYlKxS2eJh2kNw9/TGwyfPZb6b6DkXP4tHdIxoFsQgEtEerRrV0fm6uj0iSGfRd05OZ1CwYD6YmIT06ope03v3Hqkfri885HKRzvDmzbso3b8YfKa5L/EQ3D1e4kXwfgUxmUXmzBlx4uQ5GNJ5cfaSiyyN+OS5m5y44IyzC+zmLkGJwuZa9V2jgrguLV2/DfcePZX7OnXhCkZPd0TpYoWQX+NWuXhNDIqrUKoYlKpS2RJ45uqu1RbiOpA7e1bYTnGQXwAuXLmOBSs3oX2LhhGmxv2NnNmzyB50u9mLcOf+Y9k2a7fuloF1zcrlta9Rj57KzzhDqqOrjw+Khh7dGTNmqH8WA9JEObCLFy/KYLdJkyYwJPlyZZc5sWKwWdumQTloTmec4fvBX+Z4auZ5ijyqo1ujvpxSp9ZN8C3gO+wXrZG3J0WO1fLZE5A1c8jtP/HBkjF9Opm3pWQi908MxtNsD2H8rIVaxepb9wiaNvrolmVR/qEuHD55TtZtbViris7XT124DDPZHsrtYb979yFu3LiDNq2bYMXKjYir2rVrLoPyyPQSK+m8EKW+/nfgGOwXrkLA9x/ImD4talcpL+txRzUjo4S4dO02NvzvgEw1EfsSdaV7dWqrtd6hk+fkl/G/7SXWB+L6LCr1HD15Hm2b1ZfLRO3zRTPHYfKcJejYZ7jMbxcTRvS3/v3dwD9llDChTHFwWLYO/Wwny/bImtkMU0cPRtUKpdXrnTp/CWYZ0qFUMeVeo8gwxPsVXhX1CLx79w5p0gTdNvHw8JAD0758+SKD3KpVqyIuCPDSnoEnOp11dsGcZeuxe7WjvP0TF3XoOxKWLRvJkc8xyThTIXz3jtmSZqJnas7StdizZn6cbQ/LPiPQoZVoj2oxul8jM3MYGWeO0Vq6M2aMlQPI/uJSE+1Enu+D++dhZdUPF51dYnTf3wNexui5EdfPC3F3pWHHvpg5dihKFjGP8fPiu09Qj39MOON8FXMWr8WedQviZFsIlr1t0KFVEzSqE8PXqAzaNdBj0kWzyM/sGpdU9N4Z24egnB7dO3fuyGBWBLei91bMZla/fn18/vxZnqwODg743//+p54q2FCIb8FuL73lLTfRUxHXvPfzR60q5cPtXVSaahVKw93TCz5v38le07g4j3ztqqI94saXwuh0+PAJ5M2TE5kzm8EzVLm7uCBbtsxyRrSYDnJjQ1w/L7x93qJHh9YxHuTGhmoVysDdwws+b97JXtO4eY2qgIYx3DES234xDUCR/qhHt0GDBnJ056hRo7BhwwYcOHAA9erVkz26qnzda9euyRJjhtSjS3GrR5fiTo8uxZ0eXYo7PboUN3t0L2RsDX1U6dX/YvsQlNOjK6oqnDx5UtbLLVasGJYvX46+ffuqb72IQLd8+ZBkdiIiIiKi2PJHyUG+vr5yyl9V/VwxVW/q1CGlYcTPHz9+jPqjJCIiIiKK7qoLoWvvhX5OREREpG+0qwiTwQa6Xbp0UU8K8fXrV/Tu3Vv27AqqWVqIiIiIiPQq0O3cubPW844dO4ZZR0waQURERESkV4HumjVrou9IiIiIiGLJLzAVU4niZqVqIiIiIqJ/xECXiIiIiBSJgS4RERERKdIfV10gIiIiUprASM8TS/qEPbpEREREpEgMdImIiIhIkRjoEhEREZEiMUeXiIiIDF4g6+gqEnt0iYiIiEiRGOgSERERkSIxdYGIiIgMHqcAVib26BIRERGRIjHQJSIiIiJFYqBLRERERIrEHF0iIiIyeIGxfQAULdijS0RERESKxECXiIiIiBSJqQtERERk8FheTJnYo0tEREREisRAl4iIiIgUiYEuERERESkSc3SJiIjI4LG8mDKxR5eIiIiIFImBLhEREREpEgNdIiIiIlIk5ugSERGRwWOOrjKxR5eIiIiIFImBLhEREREpElMXiIiIyOBxCmBlUmyga5ypUGwfAgUzMjOP7UMgDd8DXsb2IVAwnhtxh1GG/LF9CEQUDRQb6H73fhDbh0DBH+RsizjWHq+fxPZhkGiL9HmR0DhzbB8GAfgR8JLnRRw6L4iiEnN0iYiIiEiRFNujS0RERBRZgUzRVST26BIRERGRIjHQJSIiIiJFYuoCERERGbxAlhdTJPboEhEREZEiMdAlIiIiIkVioEtEREREisQcXSIiIjJ4v2L7AChasEeXiIiIiBSJgS4RERGRgTh79iyaNGmCTJkyIV68eNizZ4/6te/fv2PkyJEoUqQIkiVLJtexsrKCl5eX1jZ8fX3RoUMHpEyZEiYmJujWrRs+ffqktc7t27dRpUoVJE6cGFmzZoW9vX2YY9mxYwcKFCgg1xH7PHTokNbrv379wvjx42FmZoYkSZKgdu3aePLkz6brZqBLREREZCA+f/6MYsWKYdGiRWFe+++//3D9+nWMGzdO/rtr1y48evQITZs21VpPBLn37t2Dk5MTDhw4IIPnnj17ql/39/dH3bp1kT17dly7dg2zZs3CxIkTsXz5cvU6Fy9ehIWFhQySb9y4gebNm8vH3bt31euI4Hj+/PlYunQpLl++LIPvevXq4evXr5H+/433S4TLCvTd+0FsHwIBMDIzZ1vEtfZ4/Wffhil6GKXPi4TGmWP7MAjAj4CXPC/i0HkRW3ZltIQ+avlq81+/N168eNi9e7cMMMNz9epVlC1bFm5ubsiWLRsePHiAggULyuWlS5eW6xw5cgQNGzaEp6en7AVesmQJxowZg1evXsHY2FiuM2rUKNl7/PDhQ/m8Xbt2MugWgbJK+fLlUbx4cRnYivBUbGvYsGGwsbGRr/v5+SFDhgxYu3Yt2rdvH6n/R/boEhEREempb9++yR5UzYdYFlX8/PxkQCxSFARnZ2f5syrIFURKQfz48WWvq2qdqlWrqoNcQfTEit7h9+/fq9cR79Mk1hHLBVdXVxkoa66TKlUqlCtXTr1OZDDQJSIiItJT06dPlwGg5kMsiwpfv36VObsixUDk4woi+EyfPr3WegkTJoSpqal8TbWO6HnVpHr+u3U0X9d8n651IoPlxYiIiMjgBcbTzymAbW1tMXToUK1liRIl+uftfv/+HW3btpUpBCIVQV8x0CUiIiLSUyKojYrAVleQK/JyT548qe7NFTJmzIjXr19rrf/jxw9ZiUG8plrHx8dHax3V89+to/m6apmouqC5jsjjjSymLhARERGRVpAryngdP34cadKkgaYKFSrgw4cPspqCigiGAwMDZf6sah1RiUFsS0VUaMifPz9Sp06tXufEiRNa2xbriOVCzpw5ZbCruY7IPxZ5wKp1IoOBLhEREZGB+PTpE27evCkfqkFf4md3d3cZmLZu3RouLi7YtGkTfv78KfNhxSMgIECub25ujvr166NHjx64cuUKLly4gP79+8sqCKJKgmBpaSkHoonSYaIM2bZt2zBv3jytFItBgwbJag1z5syRlRhE+TGxX7EtQQyAGzx4MKZMmYJ9+/bhzp07sqav2EdEVSJCY+oCERERGTxF1lrVQQSTNWrUUD9XBZ+dO3eWwaYIKoXQ6QGnTp1C9erV5c8iCBYBaa1atWS1hVatWsl6typiQNyxY8fQr18/lCpVCmnTppUTP2jW2q1YsSI2b96MsWPHYvTo0cibN68sP1a4cGH1OiNGjJAlyMT7RC9y5cqVZXAsJpiILNbRpWjFOrpxC+voxh2soxt3sI5u3BGbdXR3mHWAPmrjvSm2DyFOY+oCERERESkSA10iIiIiUiTm6BIREZHBC4ztA6BowR5dIiIiIlIkBrpEREREpEhMXSAiIiKDF6ifMwDTb7BHl4iIiIgUiYEuERERESkSA10iIiIiUiTm6BIREZHBCwSTdJWIPbpEREREpEgMdImIiIhIkZi6QERERAbvV2wfAEUL9ugSERERkSIx0CUiIiIiRWLqwh9yuXUPa7buxv3Hz/Dm3XvMmzwKtaqU11rnmZsHHJatl+v+/PkTubJnhaPdSJhlSIeX3j6oZ9FL57bnTByOetUrhbvviLbr5/8Ri9ZswUWXm/D2eYvUJilRs3I5DLC2RIrkyeT7Hz51xarNu3D9zn188PuITBnTo23TeujUugn0UWy1xZjp87D36CmtZZXKlMCyWRO0lp1xdsHS9dvw+JkbEhkboXSxQpg/dbR87YOfP0ZOccDj5y/wwf8jTE1SoWalchjUoyOSJ0sKfeNy8y7WbNmJ+49EW/hi3tQxqFW1gtY6z154wGHpGrmubIsc2eA4xRZmGdLL19++e4/Zi1fD2eUG/vvvC3JkzYKeVm1RJ4JzYsWG7Th+1hmubp5InMgYxQubY0ifLsiZLYt8XZ4Xqzbh4tUb8PZ5g9Ti91ylPAZ076hxXjzHqo3/CzovPvgjk1l6tG3WAJ3aNIMSxI8fHxPGD4OlRUtkzJgOXl4+WL9hB6ZOc1SvM37cULRt2wxZs2RCQEAArl+/g3HjZ+LK1Rv/tN3mzRugV49OKFmyKNKkSY1SZeri1q17WtvJkCEdZs4Yh9q1qiBFiuR49PgZps+Yj927D0EJYuvciMx+C1dprPO9Q/t0hbVlK1y5cRvWA4OuWaFtWT4XRczz/cVvhChmMdD9Q1++fkX+3DnRomFtDB43I8zr7i+9YTVgNFo2rIV+XS2QLGkSeREzNjaSr2dMnxand67Res+OA8dkwFalbMlw9/u77b5+64vX73xh06eLDObEh7rd3KV489YXDnYj5ToiIDRNnQozxgyRx3Hz7kNMmrMYCeLHh2XLRtA3sdUWQuWyJTFl5AD1c6Pgbao4nbmICbMXY1D3jihXsgh+/gzEE1c39evx4sdHjcplMaBbB5iapJTHOtVxOfw+foT9uGHQy7bIkwstGtXB4DHTdLdFvxFo2agO+ll3QLJkSfHM1R3GxsbqdWynzsXHT5+wcPo4mJikwiGn0xg2YSa2rXCAeb7c4X6YW7RohMLmefHj50/MW7YePYeOw94NS5A0SWK8fvsu6LzoZy2DB+9Xr2E3exHevH0HhylBH+D3Hz0NOi/GDkPGDOlw884DTJq1MOi8aKWfXwI1jRjeD716WsG622Dcu/8IpUoVw6oVc+Hn54+Fi1bLdR4/eY5Bg8biuasbkiRJjEEDe+Dwoc3Ib14Jb9/6/vV2RTtfuHgFO/63H8uXzda5nbWr58HEJCVatOyKt+98YdG+BbZuXopyFRrg5k3toFgfxda58bv9Cqf3bNB6fu6SC8bPnK8OoEsUNg+zzoKVG3D52i0ULpAXSsMpgJWJge4fqlKulHyEZ/7KTahSriSG9e6iXpYts5n65wQJEiBtmtRa7zlx7hLq1aiEpEmT/PV28+bKDke7UVqvDezeAaOmOuDHj59ImDABWjasrbXNrJky4tb9Rzh+7pJeBrqx1RaCsVHCMO9VEb/vGQtWYVjvzmjVqI56ee4cWdU/p0qRHO2bNVA/F73r7Zo3kEG2PqpSvrR8hGf+8vXy9WF9rXW2hXDz7gOMG9oXRQrml897dW6P9dv34t6jp+F+mC+bY6f1fOroIajatIMMXksXL4y8uXLAMTigVe1zYE8rjJo8O+S8aFQ37Hlx76HsKVZCoFuhfGns238Uhw6fkM/d3DzRvl0zlClTXL3O1q17tN5jM3wSullbomiRgjh56vxfb3fTpp3y3+zZg3rYdW6nQmn0G2CLqy435fNp0+fJQLtkiaKKCHRj69z43X6F0NewU+cvo2yJIvIcEIyMjLTW+f7jh1zHslVjxIvHqJD0A3N0o1BgYCDOXnJBjqyZ0HP4RFRt3hkWfYbL4Ck84kIlUgpaNqwTpdsVPn76D8mTJpUf5hGtI4IupYmutlC5evOu3GbjTn1lz7lIRVB58OQZfN6+k7d2W3cfguotu6L3CDs8eR7Soxua6JEXgVXpYoWhyLZwDm6LoeNQtUkHWPQcihNnnbXWE2kHR06ek+kG4j2Hjp+Rt9HFB29kffr8Wf6bKmX4f9MfP32OxHnxWTHnhfMlF9SsURl58+aSz4sWLYhKFcviSKj0GxUR3PTo3gEfPvjh1u17UbbdcLfj7IK2rZsidWoTGTy1bdsUiRMnwplQfx9KFJPnxu+89X2Ps85X0bKx9hc/TafPX5apVs0jcY0kiisY6EYh3/d++O/LV5kHK25tL581AbUql8fg8TNlYKTLrkPHkSt7FpQoXCBKt/v+gz+WbdiO1k3Cv2jduPsQR0+dj3AdfRVdbSFUKlsS00YPxsq5kzCkpxVcbt1F75GTZW6d4OHlI/9dvHYrenVqg0XTxyBlimToOnis/KDSNNxuDkrXa4uara1lbq7d8H5QZlt8wapN/0PlcqWwfO5kmSs4eOw0XL1xR73enEkj8ePHD1RqZIGSNVvIFAPHqWOQLUumSO1HBAAz5q9AiSIFZU+uLu8/+GHZuq1o3bR+uNu5cecBjp48F+E6+mSm/UJs37EX9+6cwZfPL+By5SjmL1iJLVu07x40algbH3wf4/PH57JHtX4DC7x79/6ft/s77S17w8goId743MN/n1yxZNFMtG7TDc+evYDSxdS5ERn7Dp+Qd7JqV60Y7jq7Dh5DpbIlZNoXkb5g6kIUCvwVVIWvRqWysGrTVP5cIG8u3Lz3ENv3HUWZ4tq9dV+/fcOh42fRy6ptlG730+f/0Nd2MnJnz4q+Xdrr3KboXRw4Zhr6dG4nB1IpTXS1hdCwVhX1z/ly5UC+3DnQwLK3DKDLlyqGX78C5Ws9O7ZGnWpBHxpTRg5ErTbdcPT0RTkAUGVkP2vZBm6eXnBcsQH2i1dj3JDeUJLA4N9HjcrlYdWueUhb3H2A7XsPo0xwr9TClRtlT+pKhykyZ/PkuUuwmTAT6xbOlL/j35kydwmeurph/SJ7na/L82LEJOTOkQ19rS11rvPk+QsMtJ2MPl0t5BcaJWjTpgks2rdER6t+uH//MYoVK4S5syfBy9sHGzbsUK936vQFOVgsbRpTdOtmiS2bl6Ji5cZ48+bdP233dyZNHC7bu269djJHt1nTenLf1Wu2xN27D6FkMXVuRMbuQ8fRuE51JEoUkhus6dXrt7hw5YYMupUqqDVIadijG4VSp0qBhAkSyABTk+gl9H79Jsz6x85cxJdvAWhar0aUbffzf1/Qa8QkJEuSRFYhMEoY9ruMGJDVbdh42ZMbmcBOH0VXW+gi8tlSpxIDyl7J5+nSmMp/NfctBsBlyZQhzL5F/ps4JhGQTxjaB9v2HpEjpJVE/G5kW2jkKAuqQZOqATmbdx3AZNtBKF+6OArkyYW+XS1RKH8ebNl94Lf7mOqwBGecr2L1vGk6e5s+//cfetmMlwMSxehzneeFqzu6DR4re3JFDqRSzJw+DvazFmL79n0ycBR5s/Pmr8DIEf211hOj+UUv6uUr19Gzl43MYbbuavHP241IrlzZ0b+fNbr3HCZzgW/fvo/JUxxw7dpt9NHIrVeqmDg3IuParbtwdfdEywju7u055ASTlClQvXK5KNknUUxhoBuFRG5boQJ54OrxUmv5Cw8vZMqQLsz6uw4eR42KZWRpqajYruix6mkzUX6IL5g2Ruc386eu7ug6ZCya1ashKwIoVXS1RXg9HSJvLV3woI2C+XLD2MhIa99iEMfLV6917jt0L3RAwHcori3M88LVPXRbvJSD8ISvX7/Jf+PF074kiTznX4Hhz1f069cvGeSKnMbVjlORJXgQjSZ5XgwdF3RezBgXznnhhq6DRqNZ/ZoY1NMKSiJuRweG+h2KNBvxu41I/Pjxwu3d+5ftht6GKu0k7HaUP9gpOs+NP7HrgBMK5s8jg+jwzrM9h46jSf2aOr8kEsVl/Iv9Q6LXQ3zDVhHBy8Mnz5EqZQpZm7Vr+xawmTRb1kwtW7wIzl+5jjMXr2KN4xSt7bh7euPa7ftYMmNcpPb7u+2qgtwv375h3phR+Pz5P/kQRE1dUWFApCt0GzoeFcsUR+c2zWRtRiF+gvh/FeAZYluIfS5etw11qlZAWlMTeHi9wtxl6+QoaVUKiMi1FekJi9dslb2LmTKkV1dTqBtctkcMlHv33g+F8+eRZbCevvDAnKVrZTmfzGYZoPdt4e0T3BbJZS3QrhYtYTPBPqgtShbF+cvXcObiFayZP12unzN7FmTLYga72Qth09caqVKJ27POcHa5iUUzx0eYriAG5syfNhbJkiZV/00nT54UiRMlUge5X75+w7xxNvj8+Yt8aJ8XL9Bt0BhULFsSndu1CDkv4seXZcf03YGDTrAdNRAeHi9lGbDixQtj8KCeWLtuqzrYHG07CPv3H4P3Kx+ZutCnTxdkzpwR/9t54K+3K4gBZtmyZUam4L/pfMEVAl69eg0fnzd4+PApnjwJyssdMXIy3vm+R7Om9VG7dlU0a94ZShBb58bv9qsizpFjp8/Dpl+3cLclyol5evugVQQD1ZSAUwArU7xf4quaAn33fhAt271y4w6sh4QNiEQP6VTbQepBTSs37YTPm3dyNK2o4Somb9Ak8jEPOJ3Bsa3LdfaA1G3XQ/YuifeqRLTd8I5LOLplmQyexIQSS9ZtC/O66GU8tm0FooORmbmi2kLk8g4cOx0Pn7jC/9NnpE+TWn5x6G/dQQa+mj24jss3YL/TaXz7FiALq4/q3w15cmZTH/u8lRvx/IUHAr7/kAFx7Srl0c2yJVJG42h/2R6vn0T5dsMrLN+sfi1MHTNEPZBl5cYd8Hn9DjmyZZY1Q8XkDSpuHi/hsGwdrt++jy9fviBrZjN0ad8STevXVK/TZcAoZM6YQb3N8AreT7EdjOYNa0dY8P7o9lVB58XqTViyZkuY10WP2rEdQfVgo4NR+rxIaJwZ0S158mSYNHEEmjerj/Tp08iJHbZt3ytTBL5//45EiRJh44aFKFumBNKmNZUD0Fyu3cK0afPkvyonnHbghZsnunUfEqntClad2mL1Kocwx2Q3eQ7sJs+VP+fJkxPTptrKig1im0+fvcBch6Xq0mQx4UfAy2g5L2Lz3IjMfoUd+45g5vwVOLVnvXoSldBGTJoFr1evsXHJLEQ3cV7EljWZ9fMuZ9eXG2P7EOI0BrpxkOh9qty0E5bMHBel5WNiQ3QGujFBSW0RnYFuTKnTuqsMAkQQq+9iKtCNKs+eXMYkuzlYv2E7lCY6A92YopRzg4Hun2OgGzHm6MZBorevbMkiigis9B3bIu4QebTJkyXT6sWimFGwYD74+ftjw8bIV1OgmMNzgygO9+g+ePAAly5dQoUKFVCgQAE8fPgQ8+bNw7dv39CxY0fUrBnxiSvWEw9N4lZcfN/n0XzkZAg9ukqj7z26SqJvPbpKpoQeXaWIzR7dVVn0s0e3myd7dONsj+6RI0dQvHhx2NjYoESJEvJ51apV8fTpU7i5uaFu3bo4efJkhNuYPn06UqVKpfUQy4iIiIjIsMVqoGtnZ4fhw4fj3bt3WLNmDSwtLdGjRw84OTnhxIkT8rUZM2ZEuA1bW1v4+flpPcQyIiIiIjJssRro3rt3D126BBUFb9u2LT5+/IjWrVurX+/QoQNu374d4TZEmkLKlCm1HmIZERERUWQF6umD4vhgtHjxgoqCi7JOiRMnlqkHKilSpJA9tHHdBz9/VG3eWdYpjIvefwg6PjGxgSGI6+0hZqar1bob/vvyFQbRFk06xNm2eP/BTx6fIZwbpqap4eV5C9mzZ0FcZG6eFy+eu6gnkVAynhdEBhLo5siRA0+ehAwAcHZ2RrZsQXVGBXd3d5iZmSGuW77xf3IKV1Wh/z2HT6Bw9eY6H+/ef4jy/YsC96OmOqBaiy4oU78d2vQYCqczF9Wvi8L4TepWx6K1YWuFKlHo9nj41BXD7eagVptuKFW3LZpY9ceG/+2P9uMQ4zx7j7CT7X7i3CX1cjHdZ9GC+bB+x14o3fL121CjcjmtSTCmOS5D226DUKJmc7TqOiBa9z9mqoOstav56DUspMh+apNUcrYnUUtX6UaPGoh9+4/Czc1THfge3L8R7i+u4fPH53B9dhXzHKcgRTTVcV68aCYePbiAj35P4f3yNnbtXI38+YMmkBAePHgipx8eMrgXDPG88PZ5jT7DJ6J07VYyyJy9aLWchjm63Lz7ANaDRqNMnVYoV68NOvcfKeuEG9p5QcoXq4Funz595FSPKoULF0ZCjekFDx8+/NuqC3GhzqqYlKClRu3C+jUr4/TONVoPMWuWmPkmTeqQSQWiiu10Rzm17cJpo7Fr9Tw58cCwSbPx4ElI5YkWDWrhoNNZ+Pl/hJLpao/7j5/JGa5mjBmCPWvno2fH1pi3YgM27zoYrccigungGxZhNG9QC9v2HonWD7LY9uXrV+w66ISWOmZTatGoDurXrBIjx1G5XCmc3rNB/bCfOEL7WBrWxkGn04o+N5IkSYyuXdtjzZqQWcvEtLv79h9Di5ZdYV6oipwIolatKli8KOJxEX/r+vXb6N5jKAoXrY6GjSzl3bzDB7doTdKybt029OrZSc5YZ0jnhfgc7DtikpxoRkzKICZ02Hv4OBau2hhtQW5vmwmoWKYEtiyfi60rHGDRsjHia0wzbAjnBRmGWJ0CuHfv3hG+Pm3aNMR15y5dg7GREYoVyq9eJqYeFQ8V3w9+uHzjDuxG9IuWY7h59xHGDe0lZ98Selm1xfr/7ce9R89gnjdo7nIxI1f6tKY4fu4SWjWqA6XS1R6aQa+QNVNG3Lr/SP4uLFs2ipbjEFNtrtu2F9uWzUb1Vl3DvF6xdDH4+X+Cy627KF+qGJTonLNLcFsU0Fo+OrjHTpwXj5+9iPbjEMeQNk3qcF/PkzM70qcxxfGzzoqd4rRBg1pyhj7RY6ry4YMfli1fr37u7v4SS5euw7ChfaLlGFauCukdFL3K4yfY48a148iRIyueP3eTy52On4WpqQmqVa2Ak6fOw1DOi4tXb8iUphUOU5DWNDUK5M2F/t07wmHpWvSztoSRkVGUHoP9gpXo0LoJundso16WM1sWgzsvQmO+qzLFeo6uvrt25z4KBs/fHp59R08hSSJj1K1WMVqOoXjh/Dhy8oL85i16aQ6dOIeAgACULV5Ya73CBfLKKSQNvT2Ej5/+Q6poukUrepVHTJmLMYN7hhtgiQ+uAnly4pqC2+Pa7XsomD9PbB8Grt68I28FN7bsBbvZi2R+ZGiFzfPh+q17UKrKlcrKHtWImJllQIvmDXD2nHO0H4/Iw+1i1U4GuB4eXurlYurgW7fuo3LlsjCk8+LW3YfImyu7DHJVKpUtiU+f/8NTV/co3b9In7t9/xFMTUzQoY8NqjbtiC79R+H67XsGd16QYWCg+4+8X71GurTh9xYJ4lZ6w9pVtXp5o9KcCcPx4+cPVGraCSXrtIHd3CVwnDwK2bJo5zeLHl0vnzcw9Pa4cfchjp46j9ZNoqeXwn7RKhQvVAA1K5eLcL10aU3hreD28H71Rv4/xqZK5Upi2pihWOk4FUN6d4HLzbvoPXyCVspUyLnxGkolBqB5hTPwaeOGRfD/8BQebtfh//ETevYaHm3H0btXZ3zwfSz3V69+DdRvaCGDW01e3q+QLVTvotLPi7e+78OktaUxNVG/FpU8vV7Jfxev2YzWjeth2exJMM+XG90Gj4Gbx0uDOi/IMMRq6oISfA0IQHpj43Bfv3nvIZ67eWL66MERbkcMWlL17mXKmA571y5Asy4D4PUqKBAqVbQgltqHDKLRtHD1Znz89Bkr50yCSaqUOHn+MmwmzsK6BdOQL1cO9XqJEhmrBxsYans8ee6GgWOmoU/ndjJvOqrb49SFK7h8/Q7+t2Lub481cSJjfFFwe4i/tfTGaf55O5NmL8SBY6fVz68e+5/MLxQ9Y0KmDOmxd8Nine9tWLua+ud8uXMgX56caNCuO67euIPypYurXxMlCb9+VW5bJEmcONz/v2E2EzF5ylzkzZsLU6fYYvasCRgwcLTOdQ/s24DKwV/g3Nw9Uax4Tdy6eRLZgwPT8+cvo3HTTuEex+Ytu3D8xFmYZUyPoUN7Y8vmpaharbnW7JZfvnxVdOWFqDovdJ0DzTr1VQempYoWwtLZk8K8LzAwaDLUNk3ry1x5QQS6l67dkrnD4guhoZwXZBgY6P6j1KlSyl6Q8Ow86CRvURf6zS3cScP7yRw6IWHCoIEYS2aMUw9WEkGqLu4vvbF59yHsWTNf5uEKYn8iRWHL7sOYMCwk307khKbWKN9maO0hcuC6DRsve3JFHnN0tMfl67fh4fUKFRp30Fo+ZII9ShYxx9p5U7XaQ+QLK5Wo9hHRuRFZ/bt1RNf2LbWWTRo5QKN9In8ZE79v8TcizhvNQFek/YiR5kr19p0vUqfW/f/n4/NGPh49eob3vh9w5vQeTJ3miFevwvbk9ew9XA5sE1Q9sU2adlLnkIogNSL+/h/l4+lTV1y6fB1vX99H8+b1sW1bSAUS09QmeBacs2so54VIWbjz4LHWsne+QRV6NNMZfncOLJk1ET9+/IjwGpUuOJ0qd46QCkdCrhxZ8eq19h0mpZ8Xof0KZ/Aw6TcGuv+oQJ5cOOAU0tuk6b//vuDoqQsY3CP8Hg6VDOnCfsPPlDH9b9+n6qGNF1/7DI2fID5+/dJOrX/q6oYyofJ2DaU9RJ6b9dBxaFavBgZ17xht7dHdslWYwX4trAdhRD9rVK9YRmv5E1c31KlWAUpVIG9uHDh26p+3I27phr6tmyFd2r/alqgL+sH/I9KlMQ17bpQoAqW6efMuLC1b/XY9VQWE8IIkr+Db3prEILa/IaouiEciY+2UrkKFCmBnNFdEiWvnRbHCBbB8w3aZP6v6W3d2uYnkyZKGCUgjOgcic40SJc1ESsILj6AycyoibUFUKDGk84IMA3N0/1GlssVlT6Gfjp6rw6fO4+fPQDSuE3L7NKqJkbLZMpvBbs4S2SMgeqrWbtsDZ5dbWjmiYoCUKLNVsUxIL5ahtIdIV7AeMg4VSxdH5zbNZN1h8RCj/qOaGHwmBpVoPgSz9GmRRaNmpigU//qtLyootOKCajDNM1f3MOeGu6eXrEohcg9Fj5T4WTxC52r+K/FFU9QivXXvofx9X3K5iYG2k+X5Io5Ns9zT/Ufi3Ag/lUXfHXM6g0IF88FEo3euQf2a6GzVFoUK5Zc5vA0b1MKiRTNw4cIVda3dqJIzZzaMHNEfJUsUQdasmVChfGls27pM9gAfPnJCvZ44jsyZM+LEyXMwpPNC/O2J+tq2k+fg4dPnuHD5Ghas2ID2LRrB2DhqKy6ILxddLVph0//249ip8/J8XLByA1zdPLVKnhnCeUGGgT26/0jkwJrnyyV7bts2rRdmEFrtquWRMppG9wtGCRNiycxxcFi+Hv1GT5UfHFkzm2Gq7UBULV9avd6pC5dhlj6dzNsytPY4duaiDGoPOJ2RD5VMGdLh2LYVsXKch06ek4F3ZHpg9JXIiRW5f0dPnkPbZg3Uy8fPnC8Hham0th4o/z26fZVWAf1/Je5qPH7min1HTsD/02fZiyU+tEXZJs3g4dT5yzDLkA6liin3bsfduw9x48YdtGndBCtWBtVmFdeK7t06YM7sibIH18PTG3v2HMJM+0VRvn+R5ykqPwwc0F2mUPj4vMW585dQpVozvHnzTr1e+3bN4eR05q97ifX1vBB1gxfNnIDJcxaho0gPSZwITRvUkmk70aFT22b4FhCAmQtXylQSkbu+wiHoS6AhnRehsbyYMsX7JaZvUqDv3g9ibF9nnF0wZ+lamSerWfw8LrHsMwIdWjVCI43BOTHByMw8RttCH9pD9Fw27NgXM8cOlXm7Md4er0NmI4xuZy5exZzFq7Fn/aI42RaCZa9hsqZoozrVY3S/RunzIqFx5hjbn+ixnTFjrBxAFhcv+yLP9+H98+hk1Q8XnV1idN8/Al7yvIhD50VsWZw1er5YRLe+HtEzsYhSsEc3ClSrUFre/vF5+072msY17z/4y57lhrWqwhDE9fbw9nmLHh1ax3iQGxuqVSwT1BZv3sneobjm/Qc/1K5aQas6g1IdOnwCefLkRObMZvD0DKldG1dky5YZM2YuiPEgNzbwvCCKOezRJcX16FLc6dGluNOjS3GnR5fCxx7dP8ce3YixR5eIiIgMHnN0lSluJgcREREREf0jBrpEREREpEhMXSAiIiKDp8gBS8QeXSIiIiJSJga6RERERKRIDHSJiIiISJGYo0tEREQGLzBebB8BRQf26BIRERGRIjHQJSIiIiJFYqBLRERERIrEHF0iIiIyeJwCWJnYo0tEREREisRAl4iIiIgUiakLREREZPCYuqBM7NElIiIiIkVioEtEREREisRAl4iIiIgUiTm6REREZPB+xfYBULRgjy4RERERKRIDXSIiIiJSJKYuEBERkcELjBfbR0DRgT26RERERKRIDHSJiIiISJEY6BIRERGRIjFHl4iIiAwepwBWJvboEhEREZEiMdAlIiIiIkVioEtEREREisQcXSIiIjJ4nAJYmdijS0RERESKxECXiIiIiBSJqQtERERk8AKZvKBI7NElIiIiIkVioEtEREREiqTY1AUjM/PYPgQKxraIW4zS543tQ6BgPwJexvYhUDCeF0TKpNhAN8DrXmwfAgEwzlQI330exfZhUDCjDPnx3ftBbB8GBX8BTGicObYPg4K/cPA6FXeuUbGFUwArE1MXiIiIiEiRGOgSERERkSIx0CUiIiIiRVJsji4RERFRZLGKrjKxR5eIiIiIFImBLhEREREpElMXiIiIyOCxvJgysUeXiIiIiBSJgS4RERERKRIDXSIiIiJSJOboEhERkcELjBfbR0DRgT26RERERKRIDHSJiIiISJGYukBEREQGL5BzoykSe3SJiIiISJEY6BIRERGRIjHQJSIiIjIQZ8+eRZMmTZApUybEixcPe/bs0Xp9165dqFu3LtKkSSNfv3nzZphtfP36Ff369ZPrJE+eHK1atYKPj4/WOu7u7mjUqBGSJk2K9OnTY/jw4fjx44fWOqdPn0bJkiWRKFEi5MmTB2vXrg2zr0WLFiFHjhxInDgxypUrhytXrvzR/y8DXSIiIjJ4v/T08ac+f/6MYsWKyQAyvNcrV66MmTNnhruNIUOGYP/+/dixYwfOnDkDLy8vtGzZUv36z58/ZZAbEBCAixcvYt26dTKIHT9+vHodV1dXuU6NGjVkMD148GB0794dR48eVa+zbds2DB06FBMmTMD169flcderVw+vX7+O9P9vvF+/fiky+zrA615sHwIBMM5UCN99HsX2YVAwowz58d37QWwfBom2MDNHQuPMsX0YBOBHwEtep+LQNSq2jMlhCX009cXmv35vvHjxsHv3bjRv3jzMay9evEDOnDlx48YNFC9eXL3cz88P6dKlw+bNm9G6dWu57OHDhzA3N4ezszPKly+Pw4cPo3HjxjIAzpAhg1xn6dKlGDlyJN68eQNjY2P588GDB3H37l31ttu3b48PHz7gyJEj8rnowS1TpgwWLlwonwcGBiJr1qwYMGAARo0aFan/R/boEhEREempb9++wd/fX+shlkWXa9eu4fv376hdu7Z6WYECBZAtWzYZ6Ari3yJFiqiDXEH0xIpju3fvnnodzW2o1lFtQ/QGi31prhM/fnz5XLVOZDDQJSIiItJT06dPR6pUqbQeYll0efXqleyRNTEx0VouglrxmmodzSBX9brqtYjWEcHwly9f8PbtW5kCoWsd1TYig3V0iYiIyOAFQj/Z2trKPFZNYnAXBWGgS0RERKSnRFAbk4FtxowZZVqByKXV7NUVVRfEa6p1QldHUFVl0FwndKUG8TxlypRIkiQJEiRIIB+61lFtIzKYukBEREREkVKqVCkYGRnhxIkT6mWPHj2S5cQqVKggn4t/79y5o1UdwcnJSQaxBQsWVK+juQ3VOqptiPQIsS/NdcRgNPFctU5ksEeXiIiIDJ6hTAH86dMnPH36VKvMlyjvZWpqKgeU+fr6yqBVVExQBbGC6EUVD5ED3K1bN5kuId4jgldRBUEEn6LigiDq8IqAtlOnTrC3t5c5tWPHjpW1d1W9z71795bVFEaMGAFra2ucPHkS27dvl5UYVMQ+OnfujNKlS6Ns2bJwdHSU5c+6du0a6f9fBrpEREREBsLFxUXWrlVR5feKgFLUut23b59WIClKfgmilu3EiRPlzw4ODrICgpgoQlR4ENUSFi9erH6PSDk4cOAA+vTpIwPgZMmSye3b2dmp1xGly0RQK2ryzps3D1myZMHKlSvltlTatWsny5GJ+rsiWBZlzkTpsdAD1CLCOroUrVhHN25hHd24g3V04w7W0Y07YrOO7sgcFtBHM19sie1DiNOYo0tEREREisTUBSIiIjJ4iry9TezRJSIiIiJlYqBLRERERIrE1AUiIiIyePo6MxpFjD26RERERKRIDHSJiIiISJEY6BIRERGRIjFHl4iIiAyeoUwBbGgY6P4hl1v3sHbbXtx//Axv3r2H4+SRqFW5nNY6z9084bB8PVxu3cfPnz+RK3sWOEwaAbMM6fDy1WvUt+itc9uzJ9igXvWKOl87fvYStu8/Kvfr5/8JO1bMQYE8ObXW6Tp4nDw+TW2a1MX4oSH7u/vwCRyXb5TbQbx4KFIgL4b26oT8obalD1xu3sWarbtx/5FoC1/MmzoataoEzbOt8uyFBxyWroPLrbtBbZEjKxwn2wa1hbcP6rXroXPbcyaNQL0alXW+9tb3vdzmxas38fHTJ5QqVgijB/VC9qyZ1Ot8+xaAWYtW4/DJcwj4/h2VypTA2KG9kdY0tXz94VNXrNr0P1y//QAf/PyRKWN6tG1WH53aNIU+En93si2Cz4t5k0eFbQs3DzgsE+fFveDzIisc7UaGtIVFL53bnjNxOOpVr6TztcLVm+tcPrR3Z1i3b4ErN+7Aesg4netsWTpL/v2LtrKbu0Qeuzh3q1UojflTR0MpxDSdE8YPg6VFS2TMmA5eXj5Yv2EHpk5zVK8zftxQtG3bDFmzZEJAQACuX7+DceNn4srVGxFuO1OmjJg+bTTq16uJpEkT4+mzF+jefSiuXb+NhAkTYrLdCNSvXxO5cmaHn58/Tpw8j9FjpsHb20e9jbx5c2HmjLGoWKEMjI2NcOfOA0yYOAunz1yEEsTl65T7S2/MXrwGN27fl9epyuVKwnZQT/V1Sqjbtju8Xr3W2vbgnlbo3rH1P/5miGIGA90/9OXrN+TLnQMtGtTE4PH2YV73ePkKVgNHo2WD2ujbpT2SJ02Kpy/c5QVcyJguDU7tXKX1nh37nbB22x5UKVcigv1+RYnC5jIQnjh7SbjrtWpUB/2tg+alFhInSqT++b8vX9B75GRUr1gGYwb3lBfUxWu3oteIyXDavhxGCRPqXVvkz50TLRrWxuCx08O8Li7iVv1HoWWj2uhnbYFkyZLimatGW6RPi9O712m9Z8f+o1izZTeqlCulc59ixuxBY6YhYYIEmD9tDJInS4L12/ai+9Bx2Lt+EZImSSzXm7lwJc46u2DupBFInjwZpjkuk8e4cXHQ38z9R09hamKCGeOGyuO4efcBJs1ahATx48OyVWPoG/H3qW6LcTN0t8WA0WjZsBb6dbVAsqRJ5Ie7VlvsXKP1nh0HjskAoUrZkuHuN/R7zl25jvH2C1GnagX5vEThAmHWWbB6My5fv43C+fPI5z8DA5EoUSJ0aNUYTmecoTQjhvdDr55WsO42GPfuP0KpUsWwasVcGXguXLRarvP4yXMMGjQWz13dkCRJYl730ToAAHdBSURBVAwa2AOHD21GfvNKePvWV+d2TUxS4ezpPTIgbdykI968fYe8eXLi/Qc/+XrSpElQongRTJ02D7dv30dqk1RwmDsJu3etQfkKDdXb2btnHZ4+cUWdem3x5ctXDBzQXS7LV6AifHzeQN/F1evUf1++ouewCcifOwdWOU6R71u4ahP6j5qCzUtnyS9IKv27WaJ143rq56JtifSFfkU2cUCVciXlIzzzV22SF5+hva3Uy7Jmzqj+OUGCBFrfloWT5y/LHqukScK/eDSpW13+K3qEI5IksXGY7au4ur+UvcH9u1rIi6fQu3M7tOo2BN4+b5Atsxn0SZXypeQjPPNXbJSvD+vTVb1M8/9RtkUa7d/ViXPOqFejUrgXcjdPL9y69wh71i1EnpzZ5LJxw/qgevPOOHTiLFo3rouPnz5j18HjsB8/DOVKFZPrTB41CE079cWtew9RrFABtGxUR2u7WTNlxK27j3D8rLNeBrribz68D11h/kpxXpTEsN5d/qAtLkXYFkLo95w6fxllSxSWv0/ByMhIa53vP37g1IUrsGzZEPHixZPLxIe+6q7HjTsPZPspSYXypbFv/1EcOnxCPndz80T7ds1Qpkxx9Tpbt+7Reo/N8EnoZm2JokUK4uSp8zq3O2J4X3h6eqF7j6HqZS9eeKh/9vf/iPoNLbTeM3DQWFxyPoSsWTPBw8MLadKkRr68udCz5zDZkyuIHt++fbqgcKECigh04+p1Svyti57a/61yRPJkSeU6U0cPRsVGlvKLYIXSIX8fyZIkCXMMRPqCg9GiUGBgIM5euobsWczQa7gdqrXoAss+I3Hi/OVw33Pv0TN5G1v0dEWFg8fPoUqzzmjRdRAcV2yUvQkqObJmhknKFNh16Di+f/+Or9++Yfeh4zK1Qtw6V1xbOLsgR9ZMsteiatNOsOhlI4On8Nx79BQPn7iGCUI1BQR8l/+qelsE0fMhAipx+0/VW/vjxw+UDw5yBfE7FrchxYdPeD5+/oxUKVNAmedFcFsMn4iqzTvDos/w37eFPC/Cb4vQ3vp+kOdfy4a1w13n9IUr+OD/Ec3rR835pg+cL7mgZo3KMkVAKFq0ICpVLIsjR0/pXF/8Lffo3gEfPvjh1m3tVChNjRvXxbVrt7F1yzJ4ed7C1StHZXAckVSpUsq/hw8f/OXzd+/e4+Gjp+jYsbUM2kRQ17NHRxngivQHpYvN65T4DBDf9YyNQtZJZGyM+PHj4XrwOiorN+9EpcYd0LrbIKzesgs/fvyEEv3S0wdFjIFuFPL94CdvB63eshuVypbAslkTULNKOQwZb4+rN3V/YKgCzeKFC/zz/hvWqoLpowdhlYMdulm2xP5jp2GrkYcnbhevdrTDAaezKF3fAuUadsD5KzexZMZYeYtLSXzfi7b4glWbdsq8s+VzJsm8OHHr8OrNuzrfs+ugk8wbLVHEPNzt5gwOWOctXw+/j5/kh4XYh8+btzI3VRVwGRklRMoUybXemya1Cd4GrxOa6F05evI8WjcJuT2orLb4ilWbd6Fy2ZJYPmsCalUuj8HjZ4bfFsHnhUg9iKx9R0/KYKl2laC0hfC2W6lMcfUdDUMw034htu/Yi3t3zuDL5xdwuXIU8xesxJYtu7XWa9SwNj74Psbnj89l6kL9BhYyEA1PrpzZ0KtXJzx96oqGjS2xbNl6ODrYoVOnNjrXF+kh06aNxtZte/Dx4yf18nr126N48cLqfQ8e1BONmgQF2koXm9epooXyI0nixJi7dK3sEBHn6OzFq/HzZ6DWdUqk9MyaMByr501Bm6b1sXLDDvkeIn3B1IUoFBgY9N2qesWysGrTRP4sBoyJ29Uip6pM8UJa64se1UMnzqGXle4Phj8lBp6p5MuVHenSmKL7sAkyb1ikT4j9TbBfLIMH+3FDZG7ium170c92KrYstdfK59V3gb+C5ripUbkcrNo2kz8XyJsLN+8+xPa9h1GmeOGwbXH8LHpZtY1wuyKP2XGKLcbPXIBKjSyRIEF82XMrbtv/+svv1k+eu2Hg6Kno06W9/IKkNIG/gn4vNSqJ86JpSFvce4jt+47+dVuEtvvQCTSuXRWJEhnrfP3V67e4cPUm5kywgSFp06YJLNq3REerfrh//zGKFSuEubMnwcvbBxs27FCvd+r0BZQqUxdp05iiWzdLbNm8FBUrN8abN+90blf0EIoe3bHBOdk3b95DoUL50atHJ63tCmJg2tYtS2W6SL/+tlqvLZg/FW9ev0X1Gi1kjq61tSX27FqH8hUb4tVvUrX0XWxep0xNUmHOpJGYPHcJNu08IHtyG9SqioL5ciNe/KC0HqFzu5ABnyLXWGzbbvZiOSBNs8eYKK5ioBuFUqdKIXtGc+fIorU8Z7YssscuNDHw5cu3AHX+bVQrYp5XPdhBBLqHjp/DS5/X2LhounqgwcyxQ1CpqRVOXbiKBjV1j97VR6lTpQxqi+xZtZaLXsLrd7RvywnHTl+UvRpN69f87bYL5c+DnavnyVxOkfMpPjDE7UaxXEhraoLv33/A/+MnrV7dd+8/hMlze/bCHd2GjEXrpvXQq3M7KPq80NkWYc+LY2cuyvOiab0akd7Htdv34OrxErMiCGL3HDkhU3eqVyoLQzJz+jjYz1qI7dv3yed37z5E9mxZMHJEf62A9L//vuDZsxfycfnKdTy4dx7WXS1kj7Au3t6vcf/BY61lDx8+RcsWIQPNNIPcbNmyoE7dtlq9uSKlQvQkp01fUL18wMDRqF2rKqw6tYH9rEVQsti8Tgnii/WRrcvx/oO/DIbF9apacyvUz1Ql3O0WLZgfP37+xMtXPvKzTUk4BbAyMXUhCon8p0IF8uCFh1eYgQFmGcLmwO46dAI1KpaWF6Do8Oipq/xXFVx9+fYN8ePFUw/CEeLJgDeezBVTXlvklcGPpheeXjrzkcXtQNHj+CdtkSJ5Mrm+m4eXzJsTvTJCwfx55If75WshOYau7p5ywF+xQvnVy566uqProDFoVr8mBvXoBKWfF2HawsMLmTKkC7O+GMhXo2KZP2oL8R7RExW65J7mKPQ9h0/KL5X6Vl3kX4l0DtXdJhVRcUVzVL0uoocvvN5x4aLzVeTPl1trmRhY5u7+MkyQmydPTtSr3w6+vtqpEKrBVKGvP6Kn83fHpwSxeZ3SlNokpQxyL1+7JdMpxD7C8/DJc9k2pqlNIn0MRLHJsK74UUDkU7m/fKV+/tL7tRw0kypFcpkT1bVdM9jYzUWpogXl6O/zV27gzEUXrHacrLUd0ct67fZ9LJ4xJlL79fP/CO/Xb/E6uNTPi+APE9F7KKosiPSEgyfOyltTJqlS4PGzF7BfvEYehygfI1QoXQxzl67HVMflsGzZSH64rNqyGwkTxJfHqm9ED5T4PaqIepPiIiwGdMm2sGgBm4mzULpYIZQtUQTnL1/HmYtXsGbeNK3tuHt64dqte1hiPz5S+z166rwslST28eTZC8xYsBI1K5dTpx2IDxZRKsh+0SqkSplclgua5rhcVlsQD1W6QrfBY1GxbAl0bttcnRMXP0H8aPviE6Nt8eq1dlu0bwGbSbOD2qJ4EZy/ItriKtYElzVScfcMOi+WzNBd+1aXT5//k73ANhqj1kMTo8g9vX1k+T1dRKkzkcco8hk///dFHrvqNrK+O3DQCbajBsLD46UsLybyYUUe7Np1W9XB5mjbQdi//xi8X/nI1IU+fbogc+aM+N/OA+Fud968FTh3di9GjRyAHf/bL6s4dO/eAb37jlAHudu3LZclxpq16CwHmmUI/mLj6/tB/r7FQLn37/2wZrUjpkx1lKkL3a0tkTNHVnWVCH0XV69TmmNExHoixW7G/JUyvUjVUytSKO7cf4QyJYvKMR637j6E/cJVaFynmvzMI9IH8X6Jrg4FCvAKf7TwvxADBKyHhL3QiNusU0cNUOcKrty8Cz5v3snRtKKebs3K2t+Q563YiAPHz+LolqU6ey7qte+FZvVryPcKe46cxLiZYW8h9uncVq4j8g9HTXWUNXu/fPkmB9uIiSx6dmqtLh0jXHS5iaXrtsveRNGba54nJwZ0t0SxgiE9jVHJOFMhfPcJv9LAv5CTAQwK+0VB9JCKMjmqHpCVG/8X1BbZMssarjVDFWt3XL4eB46dxrHtK3W2hSiYLrbZL3hE+cb/7Zc1LEUqQro0qWXbizJtoncm9IQRopSP+ECvWKYExg3to+5dX7R6M5asDQo0NIleHHEc0cUoQ3589w6bLvCvwpuYoZk4L2wHqQeCrZQDYoLOC9kWoXqXHFdswAGnMzi2dbnutmjXI6gtuoaUrRL57zMXrsKpnWvklwxdRkyeAy+fN9i4MGyNX9V2xeuh3T2tXXYrKhmZmSOhcWZEN1HHedLEEWjerD7Sp08jJ4zYtn0vJk9xkH+bYpDYxg0LUbZMCaRNayoHoLlcu4Vp0+bJf1VOOO3ACzdPdOs+RL1MpB1MmTJK1s91feEBR8flWLV6s3wte/YsePZEd8WZWrVb48zZoJrFpUoWxWS7kbK+rxjEKfKIp0x1CLcqRHT4EfDSIK9TYkIJkdIjyk5mDp60RuQKq+76iUkupjgskaUpRSWHzGYZ0KRedfnlPLryc8U1KrYMyhFSg16fzHsR9rOEQjDQjYNEDpYoEbZk5tgwgxH0TXQGujHVFpUbd8CSWRNkb4u+i65AN8baomknLJk5ThltEUOBblQRQeskuzlYv2E7lCY6A92YoKTrVGwGugNz6Oc4ifkvtsX2IcRpyk+C0kNXb9yRqQT6HuQqwZUbt1G2ZFG9//BQAtEzVrZkEbZFLChYMB/8/P2xYaN2NQWKG3idIorDPbpfvnzBtWvXYGpqioIFC2q99vXrV2zfvh1WViGzjIX27ds3+dAkbsXFe/c02o6ZDKdHV2n0uUdXafStR1fJ9L1HV0nYo/vn2KMbh3t0Hz9+DHNzc1StWhVFihRBtWrV4O0dkrTv5+eHrl3DH2AiTJ8+HalSpdJ6iGVEREREkRWopw+Kw4HuyJEjUbhwYbx+/RqPHj1CihQpUKlSJbi7u0d6G7a2tjIg1nyIZURERERk2GI10L148aLsfU2bNi3y5MmD/fv3o169eqhSpQqePw8q7/M7Ik0hZcqUWg+xLCZ98PuIai26yJJKcdF7P395fK/evIUh+ODnL+eMF2V84iJRnF0cn6iUYRBt0bxz3G6L5p0Noi1MTVPDy/OWrIYQF5mb58WL5y7q2rpKFtevUWIim1qtusppgYn0XfzYzs8VtRZVREmTJUuWoEmTJjKNQaQ26IPlG/8nC2yL8iwqRWq0DPM4fPJ8tOz/re972E6bh+otrVG2gQXa9hwmZ13TnH1HFMpfvMYw8niWb9ghi6KLUjgq0+YtR9vuQ1CiVku0sg4qdxVdROmwJh37oEzdNqjY0ALdh4zD7fuPtIqzN6lXQ66ndOpzQ6MthD2HT6CF9SCUrNNGBppTHJdFy/4LV2+u87F66+6QtqhbHYvWboHSjR41EPv2H4Wbm6d8XrRoQWzcsAiuz67io99T3Ll9GgP6d4uWfadObQJHh8m4d/es3Nfzp1fgMNcOKVOmUK/z4METOSPbkMG9YIjXKDGhTJ8Rdihdp7UMgmcvXoMfP35G63GIITq9h09E4apNceLcJfXy3DmyyRnQ1m+PvvJ6RAYxYUSBAgXg4uIi83Q1LVwYVC+2adOm0IeyLrsPn8BS+7A1RCeP7I/KGsW5w6vx+a9GT58vp3lcMNVWThZx6MQ52NjNwdal9jAPLnjfvH5NtOs1HMN6W8lC5Uol2kPUpFw2e2KY11o0rI3bDx7LyTSiU46smTF6cC9kyZRR1tNdv30veg6bgENblqkngxDH0rbHENj07arY9pBtceg4ltlP0Fq+bvte+RjWuzOKmOeT63lF092Q0zvXaD0/d+U6xtsvRJ2qFdTLWjSoJb8c2vTuoti2SJIkMbp2bY+GjTqol5UsUQSvX79F5y4D4OHphQoVSmPpYns5a9riJWujdP+ZMmWQj5EjJ8tpg8UUxIsWzUCmTBnRrn1P9Xrr1m3D0iX2mDFzgTwOQ7lGif/XviPskCaNCTYutsebd+8xeqoDEiZMgME9wx+M/a827NiHeAiZKVNT84a1MNF+Ebp3aCOPwxAEQpHVVg1erPbotmjRAlu26O5JEcGuhYWF/MYZl527fA3GRgl1TrggAlsxa5nqkcg4/Ok0/8XNu49g2aIhipjnRdZMGdGrUxukSJ4U9x8/U6+TJ2c2pEtrihPndBdwV4pzl1xgbGSknoFMZfSgnrBo2QhZQvUsRodGdaqhQunisi3E731E/25y9i7NAFssT5/GFMeDi+Yr0blL14LbIuTcEDOPLVi1CdNsB6FR7WrIltlMztwX0ZSj/0JM0KH5OHX+sizdJ9pGqy3SmuK4Ro+W0jRoUEt+6RI9pipr123D0GETcPbcJbi6umPz5l1yWYvmDaN8//fuPULbdj3lLG3Pn7vh1OkLGDd+Jho3qi1nTFNxOn4WpqYmqKbxRcQQrlEXr97EMzcPzBg7VM7GV6V8KfTv3gFbdx+Sk3pEBzE727ptezB51ECdr1csXRx+Hz/C5dbdaNk/kUEEumLQ2KFDh8J9ffHixWHmQI9rrt9+APNQ872rTJu3Qk78YNFnhJwtLbqC9uKF8+PIqQtymmDx+xIpEmIWm9B1eIsUyINrd5RdWurarfsomF93e8QG8SG1Y99R+aUnf+6cWq8VNs+H67fvQ6mu3bmPgqHODWeXmwgM/AWft75oYtUftVp3w7CJ9vB+HXZWsqj21vcDzl66hpYNa4d5rXCBvIpui8qVyuL69du/XS9VqhTwff8hRo5J9J77+3/S6rkV58utW/dROdRMkkq/Ronpd/Pmyi47RFQqlSkhvyCLWSyjo1d5hN0cjBncSz1bY2hiBrUCeXLKaYeJ9Fmspi4ogZg2VPTMhdava3uUK1EEiRMnktPuTnFcLhP7O7RqFOXHMHuCDYZPmoPKzTojYYIEcp+OdiNlb5mmdGlM8fCpK5TM2+e1/P+MbacvXsXwSbPw9es3Of3m8jl2Mh9Uk+hFfPAkcoMu9ZH3q9dIl1b7Q9TTyweBv37J6U5HDegup6cWPbw9h03ErtWOWtOTRrV9R0/KgU61q4TtLVR6W4gBaF6/GfhUoXxptG3TFE2bRd+tcpU0aVJjzOjBWLlqU5jXvLxfIVu2uDlgLrquUWKcRZrUJlrL0gQHveILWlSzX7ASxQsXCDPNcGjiOEXuMJE+Y6D7j8TtQF1zfve2aqv+WeTJfvnyDWu27Qk30O09crLsHRYyZUiHPWvnoXmXQTKQFkoWNcfSmWHzgIWFqzfLHN0VsycidaoUOHnhCmwmzcba+VORL1d29XqJExnLwEvJvn4LQPooSBGZNHsxDjidVj+/enS7HLRxLbjXT7TR3vWLwn2/mKFo5ypHWfHif/uPwWbCTGxeNlvrwyyRwtvja0DYtgj8FYgfP35g1MDussdKsB8/DNVbdsWVG3dRSSOnXWXSnCU44HRG/fzqka3oPcIupC0ypsPetQt+ezzirkrj2lXl7z002RahJp5RkiSJE0f4t1aoUH7s2rkak6c4yPSB8BzYtwGVK5eTP7u5e6JY8Zq4dfOkzLkVzp+/jMZNO0V4LClSJMf+vevx4MFjOaVwaF++fFV05YWoukbpuh41s+qn/swoVbQgls4KO1ZBpO9cvn4b/1vl+Nt9JE6USPb+Goq4nShJf4uB7j8Sg7/8P37+7XpFzfNi2YYdMqVAV2A8yaYvvgUEyJ9Fr6yweMYY/Ai+rRdefq/Hy1fYsvswdq92lLmGQn5xu+n2A2zdcxjjh/bWyo8M3auoNKLChP+nT/+8nf7dLNG1fXOtZZNGDFDPwqdZLUSXpEkSI1uWTPIhcvEaWvSSA1B6dGyjXkekmii5PWRbfNRuC1VPVu7sWdXLxAA9cR6Fl77Q39oCXduFaovh/eSXTCEyA2Wu3b4HV4+XmDXBRufrfv6fkDpV0EBBJXr7zhepU6cKt6zXsSPbZO/qtOnzItxOz97D5cA2QZU72qRpJ3VPvAhSI5I8eTIcOrAJHz9+Rqs23eWXntBMU5vg2XM3GNI1SqQs3HnwRGvZO9/3wa9p9/RGdD1aYj9B/TsNr8ymCHI9vF6hQiMLreVDxs1AyaIFsXb+NPUykaOrmc9OpI8Y6P4j87w5ccAp/B4QlYfPXiBliuQ6g1whQ7o0YZZl0ihXFp4vwRe6+PG1060TxI8vcyE1iVyv0sULQcnEQA7Nnti/JXpeQ99K1NVGkSVu14svOaHbI3QetZIUyBO2LUoUDhqA88LjJTKmT6sO+EUtarMM6aKtLXYdPC7zhUXOoS5PXd0U3RY3b96FpWWrMMsLFswHp6PbsWHjDjk47He8vF6FWebu/jJSxyB6cg8f3CyDs+Ytu4SZul2lUKEC2LnrIAzpGiW+DIuSY+/ef1D/rYt8dpHaI0p9ReVnRvcOrdGqcV2tZS26DJCDZqtXLKO1/Mlzd9SpVjFS/19EcVWsDkZTgoplSuDZCw/ZW6qZn7nzoBOeuLrB/aU3tu09gpWbdsrKCFEtZ7bMMhd30tylskdA9PCK0k3O126hpsaADnH7SVRhECNplUzc+n7m6q7VHoK7p5ccZSzy3URPoPhZPKJ6RLPIw3Zcvl4OLhEls+49eoqxM+bh9dt3qFejsnZ7PHoq/36UqlLZ4mHODVF6rWalspixYBVu3H2IJ8/dMHr6PPl3LNI9ooMY0HPszEW0alRH5+vqc6OMcs+NY05nUKhgPpgEl7dTpSscP7ZDpio4OC5Hhgzp5CNt2qjPcRdB7pFDW5A0WRL06GUj6+eq9qf5JV3kEmfOnBEnTp6DIV2jxN+euMthO8VBjqO4cOU6FqzchPYtGobbOfK3xOAzMfBN8yGIL5qiJKKKmMxCXLdEBRlDIcqL6eODIsYe3X8kcmBFDu7RUxfQtmk99a3UrXuOwH7RGohCC9kyZ4RNny5o3Vj3B+2/MEqYUKY4OC7fiP5jpslbh+JW09RRA1C1fCn1eqcuXEHG9Olk3paS5cudQ1bBOHryPNo2q69eLmqnutwMKZPTuttg+e/RbSvCTGbwL0RPuqubJ/YdOSnzc01SpkThAnmwbsEMdWqJcOr8JfnBUqqYcnvY8+USbaF9bgjTRg/GzEWr0G/UZMSLHx+lixXCUvvx8m85Ohw+eU5WPGlYq4rO109duAwzeW4oty3u3n2IGzfuoE3rJlixcqNc1qplI6RPnxYdO7SSD5UXLzyQJ1/Eg5T+lKjZW65cSfnz44cXtV7LnbecehKL9u2aw8npTKR7iZVyjRIl1hbNHIfJc5agY5/hMqe6af2a6G8dUvc4ph06cVYG4JHpJSaKy+L9iuuFav9SgFfMlUQ56+yCOcvWyzzZ0CkEcUWHviNh2bIRGtWuGqP7Nc5UCN99QmYFiwlnnK9izuK12LNuQZxtD8veNujQqomsuRuTjDLkx3fvmCsxd0acG0vXYs+a+XG3LfqMkINERV3fmGRkZo6ExpljbH8NG9TCjBlj5QCyuHjZF3m+D++fRyerfrjo7BKj+/4R8DJGr1Nx/Rol7nQ1tOyNmeOHoWSRgjF+jYotvXKEjKHQJ8te7IjtQ4jT2KMbBapWKA23l954/dZXnXcYl4iexVpVyofbo6U01SqUgbuHF3zevAs37zM2vf/gj9pVK6BhDH/piA3VKpSWaSM+b9/JXtO42Rbi3FB+Wxw6fAJ58uRE5sxm8PT0QlyTLVtmOSNaTAe5sSGuX6NESTExcDamg1yi6MAeXVJcjy7FnR5dijs9uhR3enQpbvbo9tDTHt0V7NGNUNy7Z0JEREREFAUY6BIRERGRIjHQJSIiIiJF4mA0IiIiMni/WJNWkdijS0RERESKxECXiIiIiBSJqQtERERk8AJj+wAoWrBHl4iIiIgUiYEuERERESkSA10iIiIiUiTm6BIREZHBY3kxZWKPLhEREREpEgNdIiIiIlIkpi4QERGRwWN5MWVijy4RERERKRIDXSIiIiJSJAa6RERERKRIzNElIiIigxf4i+XFlIg9ukRERESkSAx0iYiIiEiRGOgSERERkSIxR5eIiIgMHjN0lYk9ukRERESkSAx0iYiIiEiRmLpAREREBi+QyQuKxB5dIiIiIlIkBrpEREREpEgMdImIiIhIkZijS0RERAbvF3N0FYk9ukRERESkSAx0iYiIiEiRmLpAREREBi8wtg+AogV7dImIiIhIkRjoEhEREZEiMdAlIiIiIkVSbI6ucaZCsX0IFMwoQ/7YPgTSYGRmHtuHQMF+BLyM7UOgYLxOEacAVibFBrrfvR/E9iFQcFD13edRbB8GaXyYf3/9JLYPg0RbpM+LAM87sX0YJDpGshRBQuPMsX0YxC9/FA2YukBEREREisRAl4iIiIgUSbGpC0RERESRxSmAlYk9ukRERESkSAx0iYiIiEiRmLpAREREBo9TACsTe3SJiIiISJEY6BIRERGRIjHQJSIiIiJFYo4uERERGbxfv1heTInYo0tEREREisRAl4iIiIgUiakLREREZPACOTOaIrFHl4iIiIgUiYEuERERESkSA10iIiIiUiTm6BIREZHB4xTAysQeXSIiIiJSJAa6RERERKRIDHSJiIiISJGYo0tEREQG7xfr6CoSe3SJiIiISJEY6BIREREZiLNnz6JJkybIlCkT4sWLhz179mi9/uvXL4wfPx5mZmZIkiQJateujSdPnmit4+vriw4dOiBlypQwMTFBt27d8OnTJ611bt++jSpVqiBx4sTImjUr7O3twxzLjh07UKBAAblOkSJFcOjQoT8+lt9hoEtEREQGT0wBrI+PP/X582cUK1YMixYt0vm6CEjnz5+PpUuX4vLly0iWLBnq1auHr1+/qtcRQe69e/fg5OSEAwcOyOC5Z8+e6tf9/f1Rt25dZM+eHdeuXcOsWbMwceJELF++XL3OxYsXYWFhIYPkGzduoHnz5vJx9+7dPzqW34n3S4TLCvTd+0FsHwIBMDIzx3efR7F9GBTMKEN+fH/9Z9+GKXoYpc+LAM87sX0YBMA4SxEkNM4c24dBAH4EvIy1fTfM1hD66JC7di/on4gXLx52794tA0xBhISip3fYsGGwsbGRy/z8/JAhQwasXbsW7du3x4MHD1CwYEFcvXoVpUuXluscOXIEDRs2hKenp3z/kiVLMGbMGLx69QrGxsZynVGjRsne44cPH8rn7dq1k0G3CJRVypcvj+LFi8vANjLHEhns0SUiIiLSU9++fZM9qJoPsexvuLq6yuBUpAiopEqVCuXKlYOzs7N8Lv4V6QqqIFcQ68ePH1/2uqrWqVq1qjrIFURP7KNHj/D+/Xv1Opr7Ua2j2k9kjiUyGOgSERER6anp06fLAFDzIZb9jVevXsl/Ra+pJvFc9Zr4N3369FqvJ0yYEKamplrr6NqG5j7CW0fz9d8dS2SwvBgREREZPH3N5LS1tcXQoUO1liVKlCjWjieuYY8uERERkZ4SQa2ofqD5+NtAN2PGjPJfHx8freXiueo18e/r16+1Xv/x44esxKC5jq5taO4jvHU0X//dsUQGA10iIiIiQs6cOWUQeeLECfUykfMrcm8rVKggn4t/P3z4IKspqJw8eRKBgYEyf1a1jqjE8P37d/U6okJD/vz5kTp1avU6mvtRraPaT2SOJTIY6BIREZHBC9TTx5/69OkTbt68KR+qQV/iZ3d3d1mFYfDgwZgyZQr27duHO3fuwMrKSlY/UFVmMDc3R/369dGjRw9cuXIFFy5cQP/+/WUVBLGeYGlpKQeiidJhogzZtm3bMG/ePK0Ui0GDBslqDXPmzJGVGET5MRcXF7ktITLHEhnM0SUiIiIyEC4uLqhRo4b6uSr47Ny5syzbNWLECFn2S9TFFT23lStXlgGpmNRBZdOmTTIgrVWrlqy20KpVK1nvVkUMiDt27Bj69euHUqVKIW3atHLiB81auxUrVsTmzZsxduxYjB49Gnnz5pXlxwoXLqxeJzLH8juso0vRinV04xbW0Y07WEc37mAd3bgjNuvo1svaAProqMfh2D6EOI2pC0RERESkSExdICIiIoP36y+m06W4jz26RERERKRI7NH9Qy637mHN1t24//gZ3rx7j3mTR6FWlfJa6zxz84DDsvVy3Z8/fyJX9qxwtBsJswzp8NLbB/Useunc9pyJw1GveiWdr42ZPg97j57SWlapTAksmzVB/XzZhh04e8kFj566wihhQjgf3KxzW3sOn8C6Hfvg5uGF5MmSom71ihg7WPcxxWUuN+8GtcUj0Ra+mDd1dNi2eOEBh6Xr4HLrblBb5MgKx8m2si2Et+/eY/aSNXB2uYn//vuCHFkzo2entqhTvWKE+96y66Dc91vf98ifOydGD+qJIgXzaa1z8+5DzF+xAXcePJbJ+gXy5MSyOZOQOFEiXLlxB9aDxuje9rI5KGKeF3rXFlt2arTFGNSqWkFHW6yR6wa1RTY4ThFtkT6kLRavhrPLjeC2yIKeVqItdJ8TwooN23H8rDNc3TyROJExihc2x5A+XZAzWxb1Ol0GjJL71NSmWX1MsAka2bvn0HGMne6oc/tn9m1EmtQm0Ccut+9j7ba9uP/kubxGOU4agVqVy2qt89zNEw4rNsp1g65RWeAwwSboGvXqNep36Ktz27PHD0W9arrPDTHcY9Habdh56Dg+fvoPxQvnx7hBPZE9i5nWemcvXcPSDTvw+Lk7jI2NULpoQcyfPFJrnT1HTmH9//bDzdMbyZMlQZ2qFTB2UA/oO3EdmDB+GCwtWiJjxnTw8vLB+g07MHVayN/f+HFD0bZtM2TNkgkBAQG4fv0Oxo2fiStXb/z1dsWsVZPtRqB+/ZrIlTM7/Pz8ceLkeYweMw3e3iE1Sm1HDUTDBrVQrFghue+06QtG82+EKPox0P1DX75+lYFNi4a1MXjcjDCvu7/0htWA0WjZsBb6dbVAsqRJ5Ae8uKALGdOnxemda7Tes+PAMRk0VSlbMsJ9Vy5bElNGDlA/Nwrepsr3Hz9koFy8UH7sOnhc5zbWbd8rH8N6d0YR83z48vUbvF5pF37WF+LY1W0xdrrutug/Ci0b1UY/awskS5YUz1yDPlxVbKc64OOnz1g4bSxMTFLikNMZDJtoj23L58A8X26d+z184hzsF63C+GF9UbRgPmzYsQ+9bCZg/6Yl6qBIBLm9h09E9w6tMXpwLyRIEB+Pnr5A/HhBN1FKFC6A07vXaW13wapNuHztFgoXyAO9PC/y5EKLRnUweMw03W3RbwRaNqqDftYdNNoiZB5026lz8fHTJyycPg4mJqlwyOk0hk2YiW0rHMJtCxHAWrRohMLmefHj50/MW7YePYeOw94NS5A0Scio3NZN6qF/t47q54kThxRTr1+rCiqXK6W13THTHPAtIEDvglzhy5evyJc7B1o0qInBE2aFed3D6xWsBo1Fywa10LdzW/ll96m8RgW1RcZ0aXBqxwqt9+w4cBxrt+9FlbIlwt3v6q17sHn3IUwZ2R+ZM6bHwrVb0WvUZOxd7YhEwdt2OnsJE+cuxaBuFihbvIgMsp+88NDazrod+7F+x34M7dUJRc3z4r8vX+Hl8wZKMGJ4P/TqaQXrboNx7/4jlCpVDKtWzJWB58JFq+U6j588x6BBY/Hc1Q1JkiTGoIE9cPjQZuQ3r4S3b33/artJkyZBieJFMHXaPNy+fR+pTVLBYe4k7N61BuUrNFRvR1wb/7fzAC5duoauXdvH2O+FKDox0P1DVcqVko/wzF+5CVXKlcSw3l3Uy7JlDunRSJAgAdKmCSqWrHLi3CXUq1FJXowiYmyUMMx7NfXvaqHusdXF7+MnGUwtnDYG5UsVUy/PnzsH9FGV8qXkIzzzV2yUrw/r01VnWwg37z3EuKF91L2xvTq3w/od+3Dv8bNwg6v12/eideO6MsAWRMB71tkFuw8eR/eOreUy+4Ur0aFVY/VzQbOX0cjISKstxZeUU+cvw7JVI1k7UN9UKV9aPsIzf/l6+fqwvtbht8XdBxg3tC+KFMwvn/fq3F7+ru89ehpuWyybY6f1fOroIajatAPuP3qK0sULawW24Z07ooddPFR83/vh8vXbsBs5EPpIXH/EIzzzV22Wr4tAUiVrpoza1yhT7d/VyQuXZU9u0iRJwu3N3bjrIHp2bIWalYJ6j6eNHIDqrbvj5PkraFCzsvwiMmPRagzr2Ul2BKjkzpFV6xq1cM0WLJgyCuVLFtX7a1RoFcqXxr79R3Eo+Brt5uaJ9u2aoUyZ4up1tm7do/Uem+GT0M3aEkWLFMTJU+f/arv+/h9Rv2HQ54PKwEFjccn5ELJmzQQPDy+5bJLdHPmvVae2MESBzNFVJOboRiExK4hIHciRNRN6Dp+Iqs07w6LPcBnIhkd8iD986oqWDev8dvtXb96V22zcqS/s5i7FBz//Pzo+cXs+MPAXfN76oolVf9Rq3U32Xnq/VkZvSZi2cA5ui2ETULVpJ1j0sgnTFsULFcCRk+fg5/9RvufQibPyll1ZjSBJk5jl5f7jpyhfurjWbUPxxeHWvYfy+bv3H3D7/mOYpjZBhz4jULVZJ3QZYIvrt++He7ynz1/BB/+PaN4gKHhWbFsMHYeqTTrAoudQnDjrrLWeSDvQaovjZ4LaokSRSO/r0+fP8t9UKZNrLT947DQqN7ZEc6u+cFi6VvZAh2ff0RNIkjgR6tYIP2VCr9vi8nWZTtBr5GRUa2UNy36jcOL8lXDfI770PXz6Ai0b1gx3HU/v13jr+0ErOE2RPJlMwbl1/7F8/uDJc7x+64t48eOhTS8b1GjTHb1HTcETV3f1e5yv3ZbXKLFe066DUKtdTwyzm4NXr99CCZwvuaBmjcrImzeXfF60aEFUqlgWR0KlpWl+Ie7RvQM+fPDDrdv3omy7QqpUKeXfw4cPf/Y5QqRvGOhGIdETJG6zrdq8S6YZLJ81AbUql8fg8TNlkKrLrkPHZX6cuJUdkUplS2La6MFYOXcShvS0kjmnvUdOlrf+IsvTyweBv35h5cb/YVT/bpg7aQT8/D+h57CJWtP0KactvmDVpp2oXK4kls+ZJPN3RYqDZlvMmTQCP378RKXGHVCyVivYzV4MxymjkS1L0Owuob3388fPn4FhbmmnMTWRH/SCp9cr+e/iNVvQukldLJs1UfZIdhsyVuZF67LroJPMuRapLUoT0hb/kykCy+dOlvm7g8dOw9UbIXVk50waKedLr9TIAiVrtoDd7EVwnDom3LYITXxoz5i/AiWKFETeXCE9gI3qVMeMccOwet40dO/YBgeOncKoyUE9V7rsOuCEhrWrafXyKoXvh6BrlEgzqFSmOJbNHIealcthyMRZuHpLdyC1+/BJ5MqWRX4pDM+79+/lv2HOi9Sp8Pa96rwIygVdsm47enZojYVTbZEyRXJYD50gv9zIdbyDrlErNu/CyL5dMXeCjezl7THCThHXqJn2C7F9x17cu3MGXz6/gMuVo5i/YCW2bNmttV6jhrXxwfcxPn98LlMX6jewwLt37/95uyqJEiXCtGmjsXXbHnz8+CnK/z+J4hKmLkQhcYEWalQqC6s2TeXPBfLmkrfHt+87ijKhegm/fvuGQ8fPopfV728TNaxVRf1zvlw5ZA5eA8veMmjTTEOI+PgCZSAxamB3GVQJ9uOHoXrLrrhy4y4qRZB/p2/E/6tQo3I5WLVtFtIWdx9i+97D6rZYuGqTzNFd6TAZJqlS4uS5S7CZaI91C6bL3/Ff7Tsw6O+gTdN66vQGEeheunYLuw45YUivzlrri96qC1dvYM7EEVCikLYoD6t2zTXa4kFQWwT32C5cuTG4LabIfGnZFhNmYt3CmZFqiylzl+CpqxvWL7LXWt6maX31z2I76dKYotvgMTJvWFf6xHM3D0wfNwxKpPrbrF6xDKxaN5E/i0GSt+49wo79x1CmWKGw16gT59BLIwXnX6+PPTq0Qp2qQYNGpwzvh9rte+HoGWe0bVIXvwKDrlG2/a1RMfiuif2YwajRpgeu3Lwng3N91qZNE1i0b4mOVv1w//5jOehr7uxJ8PL2wYYNO9TrnTp9AaXK1EVa8bfazRJbNi9FxcqN8ebNu3/armpg2tYtS2WKVL/+ttH+/6xPFDp/lsFjj24USp0qBRImSIDc2UNyzgTRY6srPeDYmYv48i0ATeuFTMUXWSKnLnWqlHB/GdR7GBniA17QPD5Tk1QwSZVCcekL4ncTblsED2wRgc7mXQcxedRA+WVBfOD37WqBQvnzYMvuQ+FuVwwsE+kJmt75fkBa06DerHTBuaCauYdB+86KVz5hb8HuOXwcJilToHqokfGKawsdvw/ttjiAybaDZFpIgTy50LerZXBbHPjtPqY6LMEZ56uy1/Z3veKqHGAPz7C96zsPHJNBuNivsq9RIfniQs5smeGtIz1ADB4T16gmdatFuN00qYP+5sOcF+/9kDa4lzddcN6v5r7F4KcsZunVqQmqPGrxt6F1jUqpjGvUzOnjYD9rIbZv34e7dx9i06admDd/BUaOCKoAoiKqjjx79gKXr1xHz1428q6TdfAYjH/ZrirIzZYti+wlZm8uGQIGulFI5FMVKpAHrh7aUxi+8PBCpuByVppEZYQaFcvIC/mfEh8MIqdTFVRFhio94oXG8Ylbhh/8PqrLbSmrLfKGbQtPL2TKGFTO6uvXb/Lf0IO/RM7tr+BeSF3bLZgvj6yOoHnLXAxeKhZ8azezWQakT2uKF+7a+3bzfAmzjOnC9CDsOXQCTerVkCXhlEi2hXleuIb6fYi/w7BtET9sWwT3Quoifn8iyBX5vqsdpyKLxqCq8Dx88lz+K3rLQgcXR0+el5UhlEq2Rf7c8pqkSZTx0nUN2HX4BGpUKP3ba5QIVsUXvcvXQ1JRPn3+D3cePEGx4IGeBfPlgrGRkda+xSDMl6/eqPddolA41yj/jzqvofpGDDhW9aqriPQz8Xcekfjx4yFRIuN/2q4qyM2TJyfq1W8HX9/wUyGIlESZn6zRSHwYit4nFVFzUnxwpkqZQl6su7ZvAZtJs1G6WCFZPuf8les4c/Eq1jhO0dqOu6c3rt2+jyUzxkVqn4vXbZO1JMWHiSgPNHfZOnnbVZWCIIjeMfGhIHpmfgYGqj/QxXriQihqxIoR0TMWrMIEm75InjQJHFdskL05fzLgJ862hbePdltYtIDNxFlBbVGiCM5fFm1xBWvmBZW/ypk9i/zdiFxQm77WSJUqhbxdLgbtLYqgXUQqxJjpjrLXr7B5PmzcsU+WdGoePJJcBM7i72DRmi3Inyen7Cnee+QkXN1eYq7dKK1tiQBZ5CW2alwX+iz8tkgu6+R2tWgJmwn2QW1RsijOX74W1Bbzp4e0RRbRFguD20KkLjgHtcXM8RGmK4hBa/OnjUWypEllLV4hefKkMsdWHJMoU1alQhnZK/j42QvMXLACpYsVlm2j6fDJczI4aFz3z++wxCUiH1rzTs/LVz5ywGuqFKIt0qFru2awmeyAUkXN5aDL81dv4oyzC1bPnaS1HfG7u3b7ARZPG/3bfYq/+Y4tG2HZpp2yHWV5sTVbkS5tatQMvlMhypiJ9IRF67YhY/o08ljWbtsnX6tbLajmshiwKL78z1y0BhOG9pJtOm/lJuTMmilM6pc+OnDQSdaq9fB4KcuAFS9eGIMH9cTadVvl6+I6Pdp2EPbvPwbvVz7yy1ifPl2QOXNGWfbrb7crgtzt25bLEmPNWnSWlTUyBH9x8PX9oM5/FhUYTE1TI1u2THIdkQIhPH3qis+f/4uB3xBR1Iv3S6FJKd+9H0TLdmWh/yFhg6Bm9Wpgqu0g9QCzlZt2wufNO3nhFvV0xYAPTSLAPOB0Bse2Ltf5bb5uux5oVr+mfK/Ikxs4djoePnGF/6fPSJ8mNSqWKY7+1h3Ut8vDm1RCWO0wWR3Iil6WmYtW4cTZS4gXP74MPEYN6Aaz9NHTW2JkZo7vPo+iZdvhTbogfm9TRw9WD/ISg+9kW2TLHNQWGpNKiMFhDsvW4fqd+zJYzZrZDF3at9BKJ+kycLT84FZtU9i884B6wghxm912UA8UDb4lriL2K1Ig/D9+RL7cOTGsTxeULKpdgH2E3WxZx3jjYu280uhilCE/vr9+EuXbvXLjNqwHhg2ImtWvhaljhsifdx08hpUbd8DndXBbWHcI1RYvg9ritmiLL8Ft0RJN69fUmvwhc8YM6m0WrtJY5/FMsR2M5g1ryy9/tpPn4Imrm6y0INIaalWpIEuXicBLU4c+NshilgEzxw9HTDBKnxcBniE9oFFF5O1bD5sYZnnTutUxdWTQrezdh09g5Zbd8HnjK69Rop6uqiyYiggwD5w4h6ObFuu8RtWz7INm9aqjb+d2WhNG/O+gmDDiM0oUKYCxA3vI7Wv24Irt7nc6K+sUFymQFyP7dUUejbQWcY2yX7wWx89fRvx48VC6WEGM6mcdrQM1jbMUQULjzIhuyZMnw6SJI9C8WX2kT59GTuywbfteTJ7iIINNMUhs44aFKFumBNKmNZUD0Fyu3cK0afPkvyonnHbghZsnunUfEqntZs+eBc+eXNZ5TLVqt8aZ4Aooq1Y6oLOOMSOa60S3HwHad35iUo0s+nk355SnU2wfQpzGQDeOToRQuWknLJk5Ti97WmMq0I0pddp0Qz9rSzRvEFL7U19FV6AbU+q07ioDZBHE6rvoCnRj6hpVpUVXLJk+WhE9rTEV6EYVEbSKmrfrN2yH0jDQ/XMMdCPGHN04SPRUli1ZRO+DXCV46uoue/7+ZsAgRS1RUSF5smRaPbwUO0SvcdkShRUR5OqbggXzwc/fHxs2aldTICLd2KNL0UoJPbpKou89ukqizz26SqNvPbpKxh7dP8ceXT3u0fXw8IC1dciUobp8+/YN/v7+Wg+xjIiIiCiyfunpf6THga6vry/WrVsX4TrTp09HqlSptB5iGREREREZtlgtL7ZvX1BpmfA8fx5UHisitra2GDp0qNYyMXIVvr9/LxEREREpV6z26DZv3hwtWrSQ/+p6hA5gdRFBbcqUKbUeMtCNQR/8/FG1eWdZOzQuevbCA7Vad5Nz3BsC2R5NO8Xh9nBHrVZdDaI9ZFs06RBn2+L9Bz95fKqZuZRMTAxTrZW1rP0dF73385fH9yqcaW6VRNSq9fK8Jct+xdWJRZ4+voRSJYvCkIhpqvXxQXE40DUzM8OuXbvkzFK6HtevX4c+WL7xf6hRqaycEUvXB70IMgtXbw7/aJhuUQQQYtu6HkdPX5DriKlXixbMh/U79sIQLN+wAzUql9NqD1FPtc8IO5Su01oGwbMXr5HTakY1MWHHNMdlaNyhD0rVbo3ara0xbd5yWVdUJXeObLLm7vrte6B0y9dv02oLcT70GjYeNZpboUTN5qjVqouc2UzUTo0OYgKJUZPnoFqzjihTpxXaWA+CU/B5IaQ2SYUm9Wti0epNULrlm3bKyRhETWiVIrVah3kcPnk+2o7h5r1H6DZsIso26oDyTTqh8+Bxsk64aqroJnWqYfHabVC60aMGYt/+o3Bz81Qvc5hrh8uXDuPzx+dwuXosWvffvHkDHD64GT7ed+XgL9XEECqi9u5ch6WYPi1snXIifROrgW6pUqVw7dq1CGfbietFIUQ9STFBRMtw6nqOt1+IfLmzR9v+RRH10zvXaD3EpAhJkyRGlbIl1euJGrDb9h6JluAuzrXHQSe0bBTSHmK2q74j7PD9x3c5MYOY+GHv4RNYGA3Bzeu3vvJh07crdq9bICcRuXD5OsbPXKC1nphFbdseZbeHmKBBtoXGrG9ikpIalctjwYxxOLh5OabaDsYll1tydrroYDt1Ll54eGLh9HHYtW4RalergGETZuLB42fqdVo0rI2DTqfllxQlnxe7j5xECx21oCcP74dTO1aoH6qZzKIjyO1jOxUVShfD5kUzsGXxDFg0b4D4GtM+N69fEwdPnFN0WyRJkhhdu7bHmjVBs5ZpWrt2K7bv2B/tx5AsWVJcuHgFtqOnhrvO5i27UalSGVnOjEifxWqgO3z4cFSsWDHc1/PkyYNTp8LO9BWXnLt0Tc7fXqyQ9qxYwta9h+VMZl3aNY+2/YtpGtOmSa31OHHuEurVqCSnk1SpWLoY/Pw/weXWXSjZuUsuwe1RQL3s4tWbeObmgRljh6JA3lyoUr4U+nfvgK27D6mnvowqeXNlh+MUW1SvVFZOL1yuVDEM7NERpy9e0QpqK5YuDr+PHxXdHuecw7aFmIa2fYuGKFwgLzJlTI/ypYujXYuGuHb7XrQcw827D2DZsgmKFMyPrJkyyhnRUiRPhnuPnqrXyZMzO9KnMcXxGJr5KTacu3wdxkYJUUxH0CJ+H2lNU6sfiYyNo+UYZi1ZC8sWDdDdooWcCS1n1syoX70ijI2N1OuI5WLa4BPnr0CpGjSohW/fAnD5ivYdyyFDx2PJ0nVwdXWL9mPYtGknpkx1xImT58Jd58MHP1y86IJ2bZtF+/EQKTbQrVKlCurXrx/u68mSJUO1atUQl127cx8F8+XWmRe7dN12TB89WPZMxxTxAS7mtW/ZsE6YnKsCeXLi2u37ULJrt+6jYH7t9rh176EMQMWHuEqlMiXk7XIxIUR0+/j5PyRPmhQJEyYI2x63oifAiwtE8Fowf54I13n99h2On7mI0sWiZ+KB4oXNceRkUA+hSIc6dPwMAgICwkzGUtg8H64ruC2u33kA87y5dL42bf5KOcuZRd9Rcmrg6LiL9u69H24/eAJTk1ToOGA0qrXqhi5DxsvjCq1I/jy4pmO5UlSuVBbXr9+GPrjqckMer6H4pacPisNVF5TA+9Vr2QOhKSDgO4ZPnoNhvTvDLEM6eHi9irHjEWkUubJnQYnCIb1oKunSmspcVSXz9nmNdGlMtZa99X2PNKlNtJalCQ563/p+iNbjef/BH8vWbUPrpvXCvCaOU8nt4f3qjfyb02X4RHucOn9Z5meK3m+7kQOj5RjmTBoJmwkzUamRBRImSIDEiRPBceoYZMuSSWu99GlN8eCJciu1ePm8kb3WofXr0g7lShRB4kTGuOhyC1PmrZSDJDu0bBSl+/cMHoy4ZN12DOtthQK5c2Cf0xl0Hz4Ju1c6IHsWM63zQnxZVyoxAM0rjg7ODM3LywfZssXNAXNEkcVA9x99DQhA+lC3+hxXbECubFnQpG71SG+n9wg7dW9rpozpsHftAjTrMgBer4ICoVJFC2Kp/fiIj+XbNxw6fha9rNrqfF18mH1R+GQaX7+FbY+/0Xv4xJD2yJAOe9cvQjOrfjJgULfHrIkRbkP0GPcdaScHA/btahHm9cSJEsncSaUSf4/pjdPofG3kgB7o09UCbh5ecFy2DvYLV2LcsL461+1tM0Gd2pApQ3rs3bAYzTr1hZdPUPWAUkULYensSTrfu3DlRjkQcKXDFJiYpMTJc5dk4Ltu4Uzky51DvZ6o1PJVwW3xLSBAK0VApXenNuqfRY+v+Htcs31fuIFu71FTcP3OQ/lzpgxpsWe1I5pbD4aXT1DVipJFCmDpjLFh3vfrV6D8t03jOmgRPIWz2N/l63dk7vDg7h20rlOqAWpKlCRx4ij5W1u0cAY6WLZUPzcxzYcD+zagcuVy8rmbuyeKFf+36bK/fPmqlQJHpI8Y6P4jMVI4dDWFy9dv44mrO4rVDLoIqW4tVGlmhR6d2qC/jqBn0vB+Mm9LUN3iXjJjnDqvM1Gi3wdvx85cxJdvAWhar4bO10WOrshTVHx7fNJuD5GycOeB9rS373zfB7+m3dOrMmnEAPUMewkTBp0mS+wn4MePH/Ln35Ww+/zff+hlMxHJkibBvCmjYRS8DU0iR1fJ7ZHaJOy5oaLKJ8+VPStSpUwOq34j0btze509wJNGDtA4N4LbYtZEjbbQfW64v/TG5l0HsGf9IpmHKxTIk0umKGzZfQATbPqr1xWpDaICg1KZpEohxwv8TlHzvFi28X/yrpSuwHjSsD4yaNZsi8XTx4S0RThfMlVpQ6K9NYm7T96vte9q+H38JM9jpXr7zhepU//739rESbNkZQRNPXsPl4PdhKgYf2BqaoI3b5Vf7k0lkIkAisRA9x+JD84DTqe1ljnYjVR/MAt3Hz3FuJkLsG7BtHADmwzpwvZ8icE6f2LXweOyfJDIg9Pliasb6lSrACUTg81Ct4cYDCVKjr17/0GdwuDschPJkyWVpb6iuj1ET24vmwkyD3fB9LHhBmJPnrujTrXwB2PquwJ5c+PAsd8PJg0MDPpwCQjngzlDurR/1RaqXrN4GqP6hfjx4+NX8D5Vnrq6oUyovF0lMc+TEweOhz/wSOXhsxdImSK5ziA33PMiQ7rfbleUNPt/e3cBFlXaxQH8j6uoa6OoiN1ii93dimtgK+paa2C7Biq2KHZ3rH7WWmssxtrd3YUIYmM333NenXEGByxghjv/3/PMA3PncufKK3fOPfe85yZNbIcbfreNlt/080fxAnmNlkndfP48xu2utOTEiTNo1KjOT2/n3r0H6mHIP5zL5LJnz4oTJ7Rbu07WwaJvARwVFCuYR008kyyEjsy2l8lPuoeub6WUM4SsFQ0vvn4B6lJ7nWrGk9AM++1K26sizrmhZcUK5sXV675G41G0QB5kSJMKfYaOU7V/ew8dw6TZi9Xs/9A+0H+UBLltug9QdY6De3fC8+cvVC9XeUibM+PxeIAi+fNAq4oVzPfFWOzafxirN2zB5Ws31O9g577DqrVY3pxOJvtQ/4x0aVIidUoHDB4zGafPXVQZ3vlLV6mTnLIlChu1QTt38SqKhgi4tES6fIQ8Tu3YdwR/b9iqrj7J72bZOh/MXrIKjWpVCff3lwm5bvVrYsnqTdi8c796v0nz/ofrvv6oXfVzyzMpnTh3+RqKavg4tXnLTmR3yoyEIRISGTKkVf1skyVLqrKy8r085IQ5vCVKlFBt2ynbxy4cmTNn+PTexictMhFty9ad4f7+RJGJGd2flDl9WmTLnB4+2/fC1cSEo8iyatNWlW2RoM6Ujf/tVh9235sljmqk7jJb5gzw+W8PXF0q61uwTRnlgSHe09CkfU9VI1ezcll0bPm5LjC8nLt0FafOXVLfV23Y1ug1n2Wz9MHcxm271FhpeTw+j8VuuLpU0dclr1zvo2py5fK49IEuX6ooWjWuG+7vL+Ui07wGYdyMBejw5xC8fPkSqRwdMKxvV5QsUkC/nkyKk0mjzhHU+cESZE6fBtkypYPPjn1wrVFRXyK1dN2/8Jo2H9JoIbVjcvRo1xx1DXpQh6emdarj9Zu36v2kpEX2aaaXh9FVru37Dqv/E1IDr1VnzlzA8eOnUa9uDcya/Zd++czpo1HK4ArP0U83jciQqZDRjSXCQ43qFTF3zjj98/8tnqa+Dh7ijcFDxqrvCxdyRoIE8fD33xvC9b2JIptNsKXfkeEHvQ2IvPY0O/cfgff0+Vgzb6K6LGpppFarapM/MKp/N+TLmS1S3zuGQza8DbwYqe+5c/9heE+djzULJlnueDRqh1EDuiNfzsj9QI+RLAve3jWuV45IkrH1njpX1cla4liIRm27o3HdGqhW4dsnj4aHGEkz4Y3f6Uh7v10HjsJ7xiKsnjPWYseiccc+aPRbVVQrVyJS39c2ZU5Et3WMtPerWqUcRo7sryaLWepH8JLF03Dq1DmMDHGzm4gmd2ozlyKOpue3WLr9ty37fgPmxoxuOChVJD98/fwReP8BHJJ+vV4tsgUE3kfrxnUjPcg1l1JFCsD3lj8C7z1QmTpLIy3FWjepF+lBrjmUKlrg49+GhY7Fo8dBKF+yCKqWt+x+3eGhZGFn3LwdoEqYJGtqaR7J7dKLF0LVssWhdRs3bUPGjOng6OgAPz9/WBopl5DM8/gJs8y9K0Q/jRld0lxGlywno0uWk9Ely8noUuiY0f1+zOiGzTKvXxERERER/SSWLhAREZHV0+gFbqvHjC4RERERaRIDXSIiIiLSJJYuEBERkdXjLYC1iRldIiIiItIkBrpEREREpEkMdImIiIhIk1ijS0RERFYvmDW6msSMLhERERFpEgNdIiIiItIkli4QERGR1eOd0bSJGV0iIiIi0iQGukRERESkSQx0iYiIiEiTWKNLREREVo+3ANYmZnSJiIiISJMY6BIRERGRJjHQJSIiIiJNYo0uERERWT320dUmZnSJiIiISJMY6BIRERGRJrF0gYiIiKwe24tpEzO6RERERKRJDHSJiIiISJMY6BIRERGRJrFGl4iIiKxeMGt0NYkZXSIiIiLSJAa6RERERKRJLF0gIiIiq/eBd0bTJGZ0iYiIiEiTGOgSERERkSYx0CUiIiIiTWKNLhEREVk9thfTJmZ0iYiIiEiTbIKDOc2QiIiIrFv2ZIUQFZ0NPGjuXbBomi1deBt40dy7QABiJMvCsbC08Qg4b+7dIBkLh2yIbuto7t0gAO/e3OZxyoKOUUThSbOBLhEREdG3Yh9dbWKNLhERERFpEgNdIiIiItIkli4QERGR1WN7MW1iRpeIiIiINImBLhERERFpEgNdIiIiItIk1ugSERGR1WN7MW1iRpeIiIiINImBLhERERFpEksXiIiIyOqxvZg2MaNLRERERJrEQJeIiIiINImBLhERERFpEmt0iYiIyOqxvZg2MaNLRERERJrEQJeIiIiINImBLhERERFpEmt0iYiIyOqxj642MaNLRERERJrEQJeIiIiINImlC0RERGT1goM/mHsXKAIwo0tEREREmsRAl4iIiIg0iYEuEREREWkSa3SJiIjI6n1gezFNYkaXiIiIiDSJgS4RERERaRIDXSIiIiIr8fTpU3Tp0gVp0qRB7NixUbRoURw+fFj/enBwMAYMGAAHBwf1evny5XH58mWjbTx8+BCNGzdG/PjxkTBhQrRq1QrPnj0zWufUqVMoUaIEYsWKhVSpUsHLy+uLfVmxYgWyZs2q1smZMyc2btwY7v9eBrpERERk9STAi4qP7/X7779jy5YtWLRoEU6fPo2KFSuqYPb27dvqdQlIJ06ciOnTp+PgwYOIEycOKlWqhFevXum3IUHu2bNn1XbWr1+PXbt2oU2bNvrXnzx5orYrwfTRo0cxevRoDBo0CDNnztSvs2/fPjRs2FAFycePH0etWrXU48yZMwhPNsE/8luKAt4GXjT3LhCAGMmycCwsbTwCzpt7N0jGwiEbots6mns3CMC7N7d5nLKgY5S5pLbLiajI9+Hpb1735cuXiBcvHtauXYtq1arplzs7O6NKlSoYMmQIUqRIge7du6NHjx7qtaCgICRLlgzz589HgwYNcP78eTg5OakscP78+dU6//77L6pWrQo/Pz/189OmTUO/fv1w584d2NraqnX+/PNPrFmzBhcuXFDP69evj+fPn6tAWadw4cLIkyePCrLDCzO6RERERFHU69evVQbV8CHLTHn37h3ev3+vSgUMSYnCnj17cP36dRWcSoZXJ0GCBChUqBD279+vnstXKVfQBblC1o8WLZrKAOvWKVmypD7IFZIVvnjxIh49eqRfx/B9dOvo3ie8MNAlIiIiqyftxaLiY8SIESoYNXzIMlPixYuHIkWKqMytv7+/Cnr/+usvFVwGBASoIFdIBteQPNe9Jl+TJk1q9Hr06NFhZ2dntI6pbeheC2sd3evhhYEuERERURTVp08fVV5g+JBloVm0aJGq7XV0dETMmDFVPa7UykpGVou0+a8iIiIisgISrEr3A8OHLAtNhgwZsHPnTtUl4datWzh06BDevn2L9OnTI3ny5GqdwMBAo5+R57rX5Ovdu3e/KImQTgyG65jahu61sNbRvR5eGOgSERERWZk4ceKoFmJSM+vj4wMXFxekS5dOBZrbtm3Tryc1v1J7KyUPQr4+fvxYdVPQ+e+///DhwwdVy6tbRzoxSACtIx0asmTJgkSJEunXMXwf3Tq69wkvvAXwdzpy4gzmLV2Ncxev4t6Dh5gwrC/KlShstM7VG7cwbvoCHDl5RtW/pE+bCuOH9IFDMnvcDghEpfqtTW7b27MXKpUpbvK1Fy9eYtyMBfhvz0E8DnoKR4dkaFy3Ouq7VPliXbkk0b6XJ/YcPGZy/8TjoCeo09IdgfceYN+GJYgfLy6iGnONxf2Hj9Q29x0+gafPnsE5d3b0dW+LNKlS6Ndx69xX7Z+hejUrY2CPP/TPDxw9iUmzF+PytZuIHTsmXCqVRefWTRE9+i+Iao6cPPtxLC7JWDzChCF/fjkWN29h3IyFal01FmlSYfzg3p/HomFbk9v2HtQTlUoXM/lavxETsNZnu9GyYgXyYsbogep72e70Rctx6Nhp3H/4GPZJEqF6hdJo26QuYsSIof+ZvYeOY8q8/+HKDV/EtLWFc24n9GzfQv2dRXVyOXLggO5o1LA2kie3h79/IBYuWoFhw8fr1xng0Q2uri5IlTIF3rx5g2PHTsNjwCgcOnz8p7Y7Z/Y4NG/mavRzPj7bUa1GE/3z1avmIXeu7EiaNDEePQrCtv/2oE/fYQgIMM70RFWWepz61u2ePn8Z42csUH/bNgByZMuMbu3dkDVjOmiNRptQfUGCWvm3StB55coV9OzZU/WybdGiBWxsbFSP3aFDhyJTpkwq8PXw8FCdFKT1l8iWLRsqV66M1q1bq+4IEsx27NhRdWSQ9USjRo3g6empWof17t1btQybMGECxo0bp98Pd3d3lCpVCt7e3qoDxNKlS3HkyBGjFmThgYHud3r56jWyZEiH36qWR5f+XxZ7+94OQLOOf6J2tfLo0LIh4sT5FVev+8LW9uOHavKkSbBj9QKjn1nxjw/m/W81ShRyDvV9vabMwcFjpzCifzc4Jk+KfYePY+i46Uia2A5lin88g9JZtGIdbNQhKXQDRk1C5vRpVaAbVZljLOTg4N5vOKL/8gsmDu+HuHFiY+Gytfi9mwfWLpyCX2N/nslat0ZFdGzZWP88VqzPl5IuXLmuTkbaNHXFiH5dEHj/IQaPmYr3Hz6gZ4eWiGpevnr1eSw8Rpoei059UbtqOXRo0RBxfo2tPtyNxuLveUY/s2L9ZhUglCiYL8z3Ll4wH4b27qR/HuPTNsV139sI/hCMAd3bI7WjA65c98XAMVPw8uUr9PyjhVrHLyAQnfoNRzPXmhjZvyuePX8Brylz0WXAKKyYNRZRXa+eHdC2TTO0bNUFZ89dhLNzbsyZNRZBQU8wecpctc6ly9fg7t4f167LSVcsuHdujU0blyBLtmK4f//hD29X/Pvvf2jVupv++evXb4y2s2PHPowcOQkBdwLhmMIBXqM8sHzpTJQo5QItsNTj1LdsVxIs7XoOQpliBdG/Wzu8f/8BU+YuQdseA7F15VzEiM4QIioK+lTDK63AZAJZnTp1MGzYMP3Jf69evVTbL+mLK5nb4sWLq/Zhhp0aFi9erILbcuXKqZNe2YbU+urIhLjNmzejQ4cOqnVZkiRJ1E0oDHvtyo0qlixZgv79+6Nv374qsJb2Yzly5AjXfy//l36nEoWd1SM0E2f9pV7v3v7jh6iQD1idX375BUkSf0zb62zbvR+VyhTDr7/GDnW7J85cgEvlsiiYN6c+O7hinY862zYMdC9cvoYFy9Zg2cyxKP1bc5PbWrpmI548e472zetj98HPlx6iGnOMxU0/f5w8exFrFkxGxnSp1TKP7u1RulZzbNy2C3WrV9SvGytmzC+2r/Pvf7uROUNatHdr8HG/UqZA9/Zu6D7QC3+0aIA4v/6KqEQ+GMM6UZs4ezFKFMqH7u3cvmMsDnz170LYxoge6u+5eKF86qGTKkVyXL91G8vX/qsPdCXTJpfcOrdqrJ+M4VbfBZ36jcDbd++i/Id5kcL5se4fH2zc9PES4c2bfmhQ3wUFCuTRr7N06Rqjn+nR0xOtWjZCrpxO+G/7nh/ernj95g0CA++Fun8TJs7Sf+/rexujRk/GqpVz1SxuqfuL6iz1OPUt273m64egJ0/RoWUjlV0Wcsyq3aIzAu7cVcctinpcXV3VIzSS1R08eLB6hEYCZAlSw5IrVy7s3r07zHXq1aunHhGJNbrhSD4sd+0/grSpUqBN94EoWbMpGrbtoT6wQ3P24hVcuHwdtatVCHPbeXJkxfa9h1QGVs7WDx07hRu3/FHU4ENFMge9BnujX5e2oX7wX73hi+nzl2FEv66w0egMy4gcizdvPtYb6bItQoIjORM+fuqc0bobtuxE8RqNUat5R1V2IuOj8/bNW3WJ3FDMmLYqKDh78So0NxYHPo1Fz0EoWas5Grbv+fWxuHIdtauG/XchDp84o7ZZvekfGDx2uirLCcuzZy+MSnWcsmSATTQbrN60TV02fvrsOf7ZvAOFnXNF+SBX7D9wBGXLFEemTOnV81y5nFCsaEH8G6LkQ0f+L7f+vTEePw7CyVNnf3q7pUoWgb/fSZw9swuTJ42AnZ3pY5NIlCihKoXYv/+IJoLcqHCcCmu76VI7ImGCeFi1YYu6PP3q9Wv1vZQdpUge9ct6QvoQHBwlHxQ27UY6ZvDwURBevHyJOYv/Vlmkmd6eqhZLLlfJh7EpuoNG3pzZwty21FZlSJMK5eq0QN6ytdG25yD069oW+fN8TvF7TZqtAuKyJmpydQe/np5j0P0PN/3ZuVZF1FikS5NS/e4mzFyIoKfP1MFf3iPw3n1Vm6pTrXxJjPTohrnjh+H3xnWxfvMO/DnEW/960YL5VJZ+49adKriSE5jp85eq1+4/MH2pOGqPxSvMWbJKlRnMHD0Q5YoXVqUBoY7Fxq1InyYl8ubIGua2ixXMh+F9u2D2WE90bdNM1Ti26z1E/U5N8fULwJLVG+Bas5J+WUqHZJg5ehAmzP4L+SrUQ5HqjXHn3gN4D+wJLRjlNRnLV6zF2dM78fL5DRw55IOJk2bjf/9bbbRetarl8fjhJTx/ek2VLlSu0hAPDP5P/8h2fTZvh1tLd1SsXF/V3ZYsWRgb/ln0RRujEcP7IujRZdwLPIvUqRzxW52oV74TFY9TX9uuXFmaN2E41m/ZAecK9VCwUn3sPXQM00cPjJJzCcg6Rf10hQX5EPxBfZVSgmauH+vLsmZKrwKa5Ws3oYBBUCrk7Hjj1l1oG2KyhimL/16PU+cuYfKI/nBIbo+jJ85i2LgZSJrEDkXy58H2PQdVDe/KOZ8ngoQ0fuZCdSCrUbEMtC6ixkIyfOOH9lE1zsWqNcIvv0RDYefc6rJ9MD6fWUtpiY6UKNgnToRWXT1UPZ5clixWMK8qVRjsPQ19ho2DbYwYaNusPo6eOgcbG22df+oyDlLn16xezc9jcfYClq/z+am/i6rlSui/l5pz+V1XadROBQkyLobkZKJtL09ULFXUqMTk/oNHGDRmKlwqlUHVciXx/MVLTJ67BN0GemGWt6e6jBeV1atXAw0b1EaTZh1w7twl5M6dHWPHeMI/IBCLFq3Qr7d9x144F6iIJInt0KpVI/xvyXQULV4d90Kp4/+W7S5fvk6//pkzF3D69HlcvrgfpUsVNSqJGOM9DXPnLUWa1I7w6N8N8+dOQM1azaB15j5OfW27sly2kTdHNngN6IkPH95j/tI1+KP3YCyd6a3Ks4gsHQPdcJQoQXxV/C+ZV0OSmTp2+svLRZt37FOXs2tWLhvmduVgM2HWIkwY1gelihRQy2Ryg1zanb90tQp0Jci95X8HRao1NPrZrh4jkS+XE+ZPHK7WkRn+ucvsVa/prniUqNkErZu6omPLRtCKiBoLkT1LRvw9d4K6xC01nHYJE6jLjbI8NDmdPt6//danQFc0r19LfbjJTGy5lH474K46GUmZInx7CJpbogTxwhiL81+sv3nnPrx8/QY1K33/CZnU4MrY+96+YxTo3r3/EC27eqgrHoMMOl+I/63ZiLhxfjWqHx7ZryvKu/6uTi5zZ/84dlHVqBEe8Bo9WR90SsCZJnVK9O7V0SjQlYlHV6/eUI+Dh47h/Nk9aNmiocrc/sx2DV2/7qsC5wwZ0hoFupI5lsfly9dw/sIV3Lx+BIULOeNAFJ5DEJWOU6FtV8qvbt8JxOJpXvosvNeA7iharZHqACQnhkSWjoFuOJL6p+xZM6nJLoZu+PkjRXLj2+XpLhVJlksOQGF59+69qleLFiLT90u0aPjw4WO0KpfH6xhkqcRvbp3Qq2MrlC76MTgeN+RPoxnPZy5chsfIiVgwaSRSOWoruIqosTAUL24c9fXmLX9V39ax1ecOCyFduHJNfQ1ZOy3ZwqRJEqvvN23bpWZCO2X+WPOorbHI+OVY3PJHChMlNKs2bEWZogW+ayx07ty9j8dPnqoMumEmV4Jcp8wZVHeGkJfN5UQyWjTjrK1kwIQW6t9kYpHuOKEjpR1fuwuS/E6kbjw8t+vo6IDEiROpDgthva8I6721wlKOU6Ft99XrN+pzx/CqhrriZGOjuplojalsN0V9DHS/k2Q95PKzjvQilE4HCeLHUzVRLRr+hh6DRiN/7uyqQ4L0st2575CqczLk6+ePoyfPYprXgK++p2SbpBbXe9o8dfCX4EB6ka7z2Y6eHVvqAyhTE9Bkn3QZQsOZvOLRp0k7kj2Iin10zTEWwmf7HiRKmEC9x+WrNzBy0myULV5IlSOo7d0OULW3JQrnR8L48XDp6g2MmjxH7Ydk4nXm/u9jzaoEBlt37cPsxX+r/pUyGzrKj8Wdu8Zj0eA39PAc83Es8uTEnkMyFocxb/zQL2popXxj2kiPb3rPqQuWoULJIkhil1Bd0Rg7Y8HH0pACefVBbosu/dXfTI/2bnj0+PNENd3fS8nC+bFwxT+YtmCZKoWQ0oUJs/5SP5MtU9TvFbp+wxb0+bMzbt26rdqA5cmTA13c22D+gqX6gLVvH3f8889mFYBK6UL79m5wdEyOlX+v/+HtSpusAf27YdXqjbgTeBcZ0qfFiBH9cOXqDWzevFOtU7BAXuTPnxt79x3Go0eP1Tqeg3riypXr2H9AG9lcSz1Ofct25WqhfO5IK8tGtauridCzF69UWWhdByAiS2cTrNEOyW8DL0bIdg8dP42W7v2+WC6tv4b17aI/O57910r1IZs2taPqGxpygphcopYJSpuXzzaZAano+rvaprR10dURys9I/9ygJ8+QIrk96taopC59h1ZDmKNkzVBvGGH4b4nIG0bESJZFc2Px18p/VK/JB48eq8yhXGJv17y+vgdhQOA99Bk6Fpev+6r+ssntk6BcycKqBldOWnRk389fvqYmCWbJKK3GGobZhijcxiPgy3KBcBmLrl8Gp1L3OqyPu36CmQTzaixSpfg4FiF6QI+ftQjrt+zE5qUzTY9F/dYfx6JFQ5WJ7dx/hJopLu3ykiZOpLqQSO9iCXzFmk3b0H/UJJP7fGbH55ZaG7ftVj17JcscO1ZMVa4gk9vkJDCixHDIhui2johocePGgeegXqjlUlndlEFu7LBs+VoMGTpOTVKSW4X+tWiyCjqTJLFTJQRHjp7E8OET1FedbVtW4MZNP7T6ves3bVd6bq5aOUcFwAkTxlevb9m6EwMHjcbdu/fVNnLkyIpx3oNVx4Y4cWIjIOAufDbvwPARE+DvfweR5d2b21Z3nPrW7cpnzrT5S1UPavmsyZYpPTq3boLc2cOeKPozxyhzSZ4w7EnhlurO4/A/pmsJA10LJLVSxas3xrTRA6P8WXNEBrqRQUtjEZGBbqSNRc2mmDbKQxtjEUmBbni5evkgPAd7Y+Gi5dCaiAx0I4OWjlMMdL8fA10LLl24f/8+5s6di/379+POnY9n73KPZblbhpubG+zttd0CKzSHjp9CwXy5ovwBSws4FpZDMmMF8+XkWJiBk1NmBD15gkV/mZ5kRubF41T40Gjez+qZLaN7+PBhVKpUCb/++ivKly+PZMk+Np8ODAzEtm3b8OLFC3U/5vz584e5ndevX6uHIbkUF+3xjQjdf7KOjK7WROWMrtZEtYyulkX1jK6WmDOjmyxBxJRjRLTAoAvm3gWLZraMbqdOndRt36ZPn/5FjanE3u3atVPrSLY3LCNGjICnp6fRsoEDB6Jfe+M2W0RERERkXcyW0Y0dOzaOHz+OrFlNn0FduHABefPmxcuXL8PcDjO6lo0ZXcvCjK7lYEbXcjCjaznMmdG1TxA1e2bfC+L/XYvM6Eot7qFDh0INdOU1XTlDWCSolUdIH+/0TURERETWymz3Gu3RowfatGkDd3d3rFu3DgcPHlQP+V6WSelCr169EBU8DnqCkjWbqv6IlujqDV+Uq9MCL16+gjXgeFjYWNRqbrFjIX11Zf/kRhNaZ2eXCP5+J5EmAlum/Yxs2TLhxrUjqq+v1ln6MUraw0m7MrmpEFFUZ7aMbocOHZAkSRKMGzcOU6dOVXfUEdIs39nZGfPnz4er69fvdW8JZi5aoe5V7uiQzOQBrU5Ld9UfMaL61bp17osjJ84YLatXszIGfrrVaYa0qZHLKQsWLl+Dds0bQOtCjofcKnnO4pU4duq8Gg+545CrS2U0rVcz3N9bPrgq1W9t8jW5GUSlMsWtajxm/rVS3XFJNxby++89dBwuXbuh7mAmd2IqW6wQ3Fs3MeoxHJ5OnL2AibMX4/T5S6pPaNaM6TBj9EDEihkTiRLGR42KpTFl/v8wpFcnaFnfPztj3T8+uHnTT78sVaoUmDJpJEqXLopnz56rW/f27T9CfzwOT3LlbbTXANR3dVE3vtm8ZQc6duqr76l7/vxldevhrl3aYtjw8dAyU58ZwyfMxInT53H5+k2kT5NK3b43Im9iMW7GAnUb38dBT9V+NK5bHfVdqqjXpdeuW/1aGDd9AeaEuKkLUVRj1vZi9evXVw85e5RWY0KC35ANrS29f6E0+54xZpDJ1weMmoTM6dOqQDci1a1RUTXK14kVy7ico1bVchjkNQW/N66H6NGj3p23fmY8zl28AruECTHSo5u6xe6JM+fhOXqKuoVyozrVw/X9Zfs7Vi8wWrbiHx/VuL1EIWerGg81Fhu3YobXQP0ym2jRUKZ4QXRq1Rh2CeOrO0YNGz8TQU+fwsuje4QEue16Dcbvjeqgb+fW6kT64tXrRrfT/q1KObi26Y4e7dzU3aq0KHbsWGjRogGqVvt8jJCgf93ahQi8cw8lSrnAIXlSzJs7AW/fvUN/j5Hhvg/eYwahapVyaNCwLYKCnmDihGFYuXw2SpaupV9nwYJlmD7NCyNHTYqQYNvSPzN+q1oep85fUndTjEheU+bg4LFTGNG/GxyTJ1U3hZC7nyVNbKcCcFGtYmmMnjpX3SgiY7rUsAZsL6ZNZitdMCSBrYODg3pEpSBX7D5wBLYxYpi8S8zSNRvVHZvcGnw+kEcUyU7pbgMsj5DZsaL586hg4shJ48yv1pgaj9rVKqCPe2sUyJMDqVIkR42KZVCrSnls3RV2R48fIYGU4TjIY9vu/ahUppjRJVlrGI/dB45+GovPEzwSxIuLBi5VkCNrRpVZL+ycG/VrVVG3/Y0IXpPnonHtavi9cR31YZ0utSMqlykOW9vPxxlZnjSJHbbuPgCtqlKlHF6/fqMypjoVK5SCU7bMaObWCSdPnsW/PtvVXcvat2se7sfh+PHjoWWLBujRyxPbd+zFseOn0ap1VxQtWgCFCubTr7dl6y7Y2SVEqZJFoFWhfWb0dW+DhrWrIaWJK4Ph7cSZC+ouatJ3V7K5cgVQbk9++vxlo7/VvDmyYdO2XRG+P0SaD3SjsqMnz8EpSwaTdZjT5y/DiH5dVRYrom3YshPFazRGreYd1SUpyRoYkg8uuWQr9zS3xvEI6enz55GSvTt78Yq6Ra0E29Y2HkdPn4NT5rDH4u79h+qEI3/uHOH+/nLrU8mO2SVKgMYdeqPkb83h5t4Px0wE1TmyZjK5XCuKFyuIY8dOGS0rXNgZp89c0JcOCCknSJAgPrJnzxyu7++cLxdsbW2xbdtu/bKLF6+qMgrZDx25unfy5DkUL14Q1n6Mikh5cmTF9r2H1JVGyWIeOnZK3f5abqFtKGe2zBF2EkpkFaULWhAQeBf2ie2Mlr158xY9Pceg+x9ucEhmj1sRfM/2auVLquyY7Idc8pJA94bvbUwY1tdoPXk9IPAerG08Qjp++jx8/tuDKaMGRPj+yCVKqbfLm/PLW0tqfTwC7tyFfZJEJl/rOdgb2/cexKvXb1C6aAEM7tkh3N/fz//jRJ+p85ehR3s3dWKxzmc7WnUfgDXzJiJNyhT6dSWje/7yNWiVTEDzDzHxKVkye9wN8f8v8NPz5MmSymlauL1/suT2qg2klCwYunv3HpInN74Dpn/AHaRObZkT5iLrGBXR+rq3xaDRk9Wk2Oi//AKbaDYY1LMj8ucxPuG0T2Kn/o6txQeWLmgSA92fJB/USW1tjZaNn7lQBTdyifxbtes5SH/mnCKZPdYunAKXZh3g/+mDxzmXE6aPNl0HLJeddDJnSAv7xInQqquHqn9M7ehgVN4QMtNrDeNh6PK1m+jcdxjauzVAsYJ5I2Q8Pu/La2zcugttm5meVKn18Xj1JvSx6N2hJdo3r4+bfv4YP2sRvKbOhUfXdibXlRpb/Vgkt8fa+ZPg4tYJ/ncMxsJrQKgfWvVqVFR1uCJbpvQ4cOwUVm3chq5tmurXlclRMl5aFTtWLLwKh/9r69ctQvFPNZw3ff2QO09ZnDzxH9J8Ckz37DmI6jU//15/xMuXrzTdeeFrx6hv5TlmKtZv2aF/fthnucnjlimL/16PU+cuYfKI/nBIbo+jJ85i2LgZ6oSvSP7PWd1YMW3xUsN/F2QdGOj+pEQJ4uPJs2dGy6TIXwKq3GX2que6k8QSNZugdVNXdGzZ6IvtePbqpL/xRfToH4dlmtdAvHv3Tn1vqldwaHI6fayJvBUi0JWaUKlRtbbxMCwnadW1P+rWrIS2zeuHuZ3wGI/NO/apQLZm5bImX9f6eKixeGp6LHT1y+nTpFS1gM0690W7Zq4mM12ePTuo+lKhm7g3baQH3r17rw9STZETPpEhTSqj5fKed+4aZzKDnjxDogQJoFX3HzxEokQJvsjeFiiQ94ssr7gTaDqL16ZdTzWxTVdmIGrUbKqv6ZUg1RSZ8CZ/M1IWYZjVTZrUHnc+nbDo2CVKiKvXbsIaj1Hfo2OrRmgRYv6HqeNWSHJCN2HWIkwY1gelihRQy6Q+V7rTzF+62ijQlb8L6YxCFJUx0P1JWTOlNzqrFuOG/Kn/YBbSi9Bj5EQsmDQSqRxNBzbJ7BN/sUzKEX7EhSsfL8FKIGHo8jVfVChVFNY2HkJmDrfs0k9NwHBv/fWMU3iMh5QtSGut0D4otD4eWTOaHovQMq9S8hOeYyGzySVDdePWbaPlN2/5o3ihzxOgxJXrN9VkRa06ceIMGjWqY7TswIGj6PNnZ9jbJ8a9T11hypcrqQLRc+dM90/1N1GG5etr/Ps15eixU3jz5g3Kli2O1as3qmWZM2dQJRWyH4ayZ8+Kv1dtgLUdo75X4kQJ1eNrfyshyQminLAbdh4R0oXmwwfjS/fS6kz2lygq42S0nySXv69e90WQQeZKsqiZ0qfRP3S9EiWTFPLA9LOkPGH6gqVq0pP0cN2+5yD6DhuP/Lmzq7N0HXnt7v0HRmfr1jIekl1v6d4PRQvkRXPXWrj/4JF6PHwcFGH74evnryaa1aluPAnNmsajWME8uHrjltFY7DpwBKs3bVNjIr+DnfuPYPDYaWp2t6k+1D/DxsYGLerXwuJVG1R23dcvAJPmLMZ139uoXbW8fj3Jup+7dPWLiThasnnLTmR3yoyEBiddsuzc+UtYMG8icuVyUl0YBnv2wrTpC1RQGp6ePHmKufOWYozXQJQuVRT58ubEnFljsX//EaNOEBL4Ojomx7b/Pk9as4ZjlO6YceHyNdx/+FglSuR7eegy5+FFOvJILa73tHk4dPw0/PzvYM2mbap+vVzJwkbrygRNOW5aC5mYFxUfFDZmdH+S1MRmy5xBTW6SmxBEthjRo+PAkZNYtOIfvHz1Csntk6BCqSJo28z40vzGbbvUB/mPZomj8nhs3rFXBbXrN+9QDx35XWxePjtC9kP6x0p2JbQPCWsYD+kfnS1zevhs3wvXmpX0dckr12+G1+Q5ePP2neo7XL5EYbRqVDtC9kFuCvL6zVuMmjJHlVHI/49ZYwYZlfTIpDiHpPZwzpUdWnXmzAUcP34a9erWwKzZf6llHz58gEut5pgyaQT27FqH589fqBtGSIuxiNC9xyD1nsuXzVRlDLobRhhqUL8WtmzZ+U1ZYq19Zgzwmmx045+6rbqorz7LZoX7SeCYgT3VXJI/h3ir8gSpfe/cuon+hhG6FmRyE5GKpbV71Ymsg02wRk8H3gZejLT32rn/MLynzseaBZNUE3ZLIxmBqo3aYdSA7siX0ylS3ztGsiyROhaC4/GV8Qg4H2nvJxlb7+nzVZcDSxwL0ah9LzSuUw3VypeK1PeN4ZAN0W0dI+395GYNI0f2VxPILPGwL3W+F87tQdNmHbBv/5FIfe93b27zMyOE7gO9kCVjWrRp6hrpxyhzSRQ3I6KiR8+umHsXLBozuuFACvp9b/mrnoTSTszSSAur1k3qRXpQZS4cD8tRqkh+dUk28P4DlTW1NI8eP0H5koVRtVxJaN3GTduQMWM6ODo6wM/PH5YmdWpHdUe0yA5yzcHSj1FyMp45fRo0c3Ux964Q/TRmdElzGV2ynIwuWU5Glywno0uWmdFNENe8N/L4UUHPrpp7FyyaZV4zISIiIiL6SQx0iYiIiEiTWKNLREREVk+jlZxWjxldIiIiItIkBrpEREREpEkMdImIiIhIk1ijS0RERFbvA2t0NYkZXSIiIiLSJAa6RERERKRJLF0gIiIiqxcMli5oETO6RERERKRJDHSJiIiISJMY6BIRERGRJrFGl4iIiKwe24tpEzO6RERERKRJDHSJiIiISJMY6BIRERGRJrFGl4iIiKxeMGt0NYkZXSIiIiLSJAa6RERERKRJLF0gIiIiq8dbAGsTM7pEREREpEkMdImIiIhIkxjoEhEREZEmsUaXiIiIrB7bi2kTM7pEREREpEkMdImIiIhIkxjoEhEREZEmsUaXiIiIrB5rdLWJGV0iIiIi0iQGukRERESkSSxdICIiIqvHwgVtYkaXiIiIiDSJgS4RERERaRIDXSIiIiLSJJtg9tOwSK9fv8aIESPQp08fxIwZ09y7Y9U4FpaDY2E5OBaWheNBZBoDXQv15MkTJEiQAEFBQYgfP765d8eqcSwsB8fCcnAsLAvHg8g0li4QERERkSYx0CUiIiIiTWKgS0RERESaxEDXQslkgoEDB3JSgQXgWFgOjoXl4FhYFo4HkWmcjEZEREREmsSMLhERERFpEgNdIiIiItIkBrpEREREpEkMdImIiIhIkxjoWphdu3ahRo0aSJEiBWxsbLBmzRpz75LVkttpFihQAPHixUPSpElRq1YtXLx40dy7ZZWmTZuGXLlyqTs+yaNIkSLYtGmTuXeLAIwcOVIdq7p06WLuXbE6gwYNUr97w0fWrFnNvVtEFoWBroV5/vw5cufOjSlTpph7V6zezp070aFDBxw4cABbtmzB27dvUbFiRTVGFLlSpkypAqqjR4/iyJEjKFu2LFxcXHD27Flz75pVO3z4MGbMmKFOQsg8smfPjoCAAP1jz5495t4lIosS3dw7QMaqVKmiHmR+//77r9Hz+fPnq8yuBFslS5Y0235ZI7nKYWjYsGEqyysnIfJBT5Hv2bNnaNy4MWbNmoWhQ4eae3esVvTo0ZE8eXJz7waRxWJGl+gbBQUFqa92dnbm3hWr9v79eyxdulRl1qWEgcxDrnZUq1YN5cuXN/euWLXLly+rUrf06dOrEw9fX19z7xKRRWFGl+gbfPjwQdUgFitWDDly5DD37lil06dPq8D21atXiBs3LlavXg0nJydz75ZVkhONY8eOqdIFMp9ChQqpK01ZsmRRZQuenp4oUaIEzpw5o+YWEBEDXaJvzl7Jhwfr38xHPsxPnDihMusrV65E8+bNVR01g93IdevWLbi7u6u69VixYpl7d6yaYZmb1ElL4JsmTRosX74crVq1Muu+EVkKBrpEX9GxY0esX79edcSQSVFkHra2tsiYMaP63tnZWWUTJ0yYoCZDUeSRGvW7d+8iX758RuUk8vcxefJkvH79Gr/88otZ99FaJUyYEJkzZ8aVK1fMvStEFoOBLlEogoOD0alTJ3WJfMeOHUiXLp25d4lClJNIUEWRq1y5cqqMxFCLFi1UW6vevXszyDXzBMGrV6+iadOm5t4VIovBQNcCD1SGZ+PXr19Xl2tlAlTq1KnNum/WWK6wZMkSrF27VtW73blzRy1PkCABYseObe7dsyp9+vRRl2nlb+Dp06dqXOTkw8fHx9y7ZnXkbyFknXqcOHGQOHFi1q9Hsh49eqiOJFKu4O/vj4EDB6oTjYYNG5p714gsBgNdCyM9QsuUKaN/3q1bN/VV6hFl0gFFHmlfJUqXLm20fN68eXBzczPTXlknuVTerFkzNeFGTjSkHlGC3AoVKph714jMxs/PTwW1Dx48gL29PYoXL65a7sn3RPSRTbBcnyUiIiIi0hj20SUiIiIiTWKgS0RERESaxECXiIiIiDSJgS4RERERaRIDXSIiIiLSJAa6RERERKRJDHSJiIiISJMY6BIRERGRJjHQJSL6CrkrYcKECc29G0RE9J0Y6BJZkTt37sDd3R0ZM2ZErFixkCxZMhQrVkzd7vjFixewVGnTpoWNjY26vamhLl26fHGLZiIiIp3o+u+ISNOuXbumglrJTA4fPhw5c+ZEzJgxcfr0acycOROOjo6oWbOmyZ99+/YtYsSIAXOSwLx3797YuXMntMISfq9ERFrGjC6Rlfjjjz8QPXp0HDlyBK6ursiWLRvSp08PFxcXbNiwATVq1NCvK9lTyfJK4BsnThwMGzZMLZdlGTJkgK2tLbJkyYJFixbpf+bGjRvq506cOKFf9vjxY7Vsx44d6rl8lefyfrly5VLBa+HChXHmzJmv7n+bNm1URnfjxo2hriPZXcnyGqpVqxbc3NyMssNDhw5Fs2bNEDduXKRJkwbr1q3DvXv31O9Clsm+ye8ppDVr1iBTpkxqvytVqoRbt24Zvb527Vrky5dPvS6/W09PT7x79+6rv1ciIooYDHSJrMCDBw+wefNmdOjQQQVYpkgQZmjQoEH47bffVMa3ZcuWWL16tSp76N69uwpM27ZtixYtWmD79u3fvT89e/aEt7c3Dh8+DHt7exVkS3YzLOnSpUO7du3Qp08ffPjwAT9j3LhxKrt9/PhxVKtWDU2bNlWBb5MmTXDs2DEVzMvz4OBg/c9IaYcEpgsXLsTevXtVEN+gQQP967t371Y/I7+jc+fOYcaMGaq2N2QwG/L3SkREESiYiDTvwIEDErEFr1q1ymh54sSJg+PEiaMevXr10i+Xdbt06WK0btGiRYNbt25ttKxevXrBVatWVd9fv35d/dzx48f1rz969Egt2759u3ouX+X50qVL9es8ePAgOHbs2MHLli0Ldf/TpEkTPG7cuOC7d+8Gx4sXL3jhwoVqubu7e3CpUqX068n3ssyQi4tLcPPmzY221aRJE/3zgIAAtU8eHh76Zfv371fL5DUxb9489Vx+jzrnz59Xyw4ePKielytXLnj48OFG771o0aJgBweHMH+vREQUcZjRJbJihw4dUqUG2bNnx+vXr41ey58/v9Hz8+fPqyyoIXkuy79XkSJF9N/b2dmpMohv2Y5kf3v06IEBAwbgzZs3+FFSmqAjE/KE1CyHXHb37l39Min7KFCggP551qxZVb2zbr9PnjyJwYMHq9IH3aN169YICAgwmugX8vdKREQRh5PRiKyAdFmQ0oSLFy8aLZc6UhE7duwvfia0EofQRIv28bzZ8HL/18oRfkS3bt0wdepU9TC1D4bvH9o+GE4A05VsmFr2PSUSz549UzW5tWvX/uI1qdn90d8rERH9OGZ0iaxA4sSJUaFCBUyePBnPnz//oW3I5DWpTTUkz52cnPTZViEZTB3DiWmGDNuEPXr0CJcuXVLb/xaSKfXw8FC1r0+fPjV6TfbB8P3fv3//TRPdvoVMKjOcoCYnDVKnq9tvmYQmy+SkIuRDdxJARESRixldIishGVApNZBL5zIhSi7fSwAmE8IuXLgAZ2fnr04gk24NefPmRfny5fHPP/9g1apV2Lp1qz4rLB0URo4cqSaOyWX//v37m9yWXOKX4FtKBPr164ckSZKo7gjfSjowyISyJUuWoFChQvrlZcuWVRlf6eogE8rGjh2rgtHwIBnfTp06YeLEiaqMoWPHjurfW7BgQfW6lFNUr14dqVOnRt26ddXvVsoZJNCWLg9ERBT5mGYgshIS+EmXAQlSpXNB7ty5VdA7adIkVfc6ZMiQMH9eAtEJEyZgzJgxqqZXugrMmzfP6IYNc+fOVZlPCZqlzVdoAZ4Ew9KdQNaTm1hI0Cwty74n6JT9ffXqldFy6WLQvHlz1f2gVKlSqjSjTJkyCA+//vqr6uPbqFEjdcIgmeVly5bpX5d2Y+vXr1fdLaSWV4JgCcalfRkREZmHjcxIM9N7E5GVkT66EnhKuQJvqUtERBGNGV0iIiIi0iQGukRERESkSSxdICIiIiJNYkaXiIiIiDSJgS4RERERaRIDXSIiIiLSJAa6RERERKRJDHSJiIiISJMY6BIRERGRJjHQJSIiIiJNYqBLRERERJr0fyn4c94hrVpqAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "create_ingest_heatmap(rel_batch_df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -570,34 +453,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T15:01:54.9500155Z", - "execution_start_time": "2025-01-11T14:57:24.5030447Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "ecdaef15-dc48-48f2-b23b-b53daa35827f", - "queued_time": "2025-01-11T14:57:24.3876952Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 16, - "statement_ids": [ - 16 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 16, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "query = \"\"\"\n", " MATCH(source:Node {id: event.numeric_id_1})\n", @@ -627,7 +483,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -639,41 +495,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T15:03:46.0902216Z", - "execution_start_time": "2025-01-11T15:03:43.2960105Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "f7cb9b0e-b957-4dae-93d6-0c93f3846fe5", - "queued_time": "2025-01-11T15:03:43.1740342Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 20, - "statement_ids": [ - 20 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 20, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6797557 680\n" - ] - } - ], + "outputs": [], "source": [ "rel_count = twitch_df.count()\n", "batch_count = rel_count // 10000 + 1\n", @@ -682,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -694,41 +516,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T15:09:07.318409Z", - "execution_start_time": "2025-01-11T15:09:06.8032688Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "be93cdfa-06c6-4d6e-bc5a-0146f77d1cd1", - "queued_time": "2025-01-11T15:09:06.6770525Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 25, - "statement_ids": [ - 25 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 25, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "680\n" - ] - } - ], + "outputs": [], "source": [ "from pyspark.sql.functions import lit\n", "del_df = (spark.range(batch_count)\n", @@ -738,7 +526,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -750,34 +538,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T15:16:01.4072209Z", - "execution_start_time": "2025-01-11T15:10:19.9712186Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "457a965b-b574-4751-85c2-dc2b43e2c3a2", - "queued_time": "2025-01-11T15:10:19.851916Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 27, - "statement_ids": [ - 27 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 27, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "del_query = \"MATCH ()-[r:RELATES_TO]->() WITH r LIMIT 10000 DELETE r\"\n", "\n", @@ -806,7 +567,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": false, @@ -818,34 +579,7 @@ } } }, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T15:32:11.4027857Z", - "execution_start_time": "2025-01-11T15:22:59.3132605Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "d14c3ab9-8c1b-4d65-a66e-ba784a7c620e", - "queued_time": "2025-01-11T15:22:59.1886902Z", - "session_id": "18", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 28, - "statement_ids": [ - 28 - ] - }, - "text/plain": [ - "StatementMeta(medium, 18, 28, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "(\n", " twitch_df.coalesce(1).write\n", @@ -860,11 +594,21 @@ "metadata": { "description": null, "kernelspec": { - "display_name": "python", - "name": "synapse_pyspark" + "display_name": ".venv", + "language": "python", + "name": "python3" }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" }, "save_output": true, "synapse_widget": { diff --git a/examples/predefined_components_reddit_threads.ipynb b/examples/predefined_components_reddit_threads.ipynb index a5b0d63..bbb4b49 100644 --- a/examples/predefined_components_reddit_threads.ipynb +++ b/examples/predefined_components_reddit_threads.ipynb @@ -2,36 +2,9 @@ "cells": [ { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T22:00:42.4235235Z", - "execution_start_time": "2025-01-11T22:00:42.2764302Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "04a8f60b-046e-4d2e-956f-a81a40a47cf5", - "queued_time": "2025-01-11T22:00:42.1460445Z", - "session_id": "26", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 9, - "statement_ids": [ - 9 - ] - }, - "text/plain": [ - "StatementMeta(medium, 26, 9, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from pyspark.sql import SparkSession\n", "from pyspark.sql.types import StructType, StructField, IntegerType\n", @@ -40,6 +13,7 @@ "from zipfile import ZipFile\n", "from neo4j_parallel_spark_loader.predefined_components import group_and_batch_spark_dataframe\n", "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n", + "from neo4j_parallel_spark_loader.visualize import create_ingest_heatmap\n", "import json" ] }, @@ -59,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": { "jupyter": { "outputs_hidden": false, @@ -73,30 +47,20 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T21:44:18.5177192Z", - "execution_start_time": "2025-01-11T21:44:18.3725338Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "da70e421-13d6-4887-bbb3-d39f40e87b24", - "queued_time": "2025-01-11T21:44:18.2491489Z", - "session_id": "26", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 3, - "statement_ids": [ - 3 - ] - }, - "text/plain": [ - "StatementMeta(medium, 26, 3, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning: Ignoring non-Spark config property: neo4j.url\n", + "Warning: Ignoring non-Spark config property: url\n", + "Warning: Ignoring non-Spark config property: neo4j.database\n", + "Warning: Ignoring non-Spark config property: neo4j.authentication.basic.password\n", + "Warning: Ignoring non-Spark config property: neo4j.authentication.basic.username\n", + "25/01/12 16:04:43 WARN Utils: Your hostname, Nathans-MacBook-Pro-3.local resolves to a loopback address: 127.0.0.1; using 192.168.86.181 instead (on interface en0)\n", + "25/01/12 16:04:43 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n", + "Setting default log level to \"WARN\".\n", + "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n", + "25/01/12 16:04:44 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n" + ] } ], "source": [ @@ -133,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 3, "metadata": { "jupyter": { "outputs_hidden": false, @@ -147,30 +111,13 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T23:01:14.2805724Z", - "execution_start_time": "2025-01-11T23:00:36.4081869Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "35d72265-fbd4-4fa3-91c6-238709bf8ad0", - "queued_time": "2025-01-11T23:00:35.3496326Z", - "session_id": "26", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 45, - "statement_ids": [ - 45 - ] - }, - "text/plain": [ - "StatementMeta(medium, 26, 45, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 16:05:54 WARN TaskSetManager: Stage 0 contains a task of very large size (5590 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 16:06:00 WARN PythonRunner: Detected deadlock while completing task 0.0 in stage 0 (TID 0): Attempting to kill Python Worker\n", + " \r" + ] }, { "name": "stdout", @@ -231,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 4, "metadata": { "jupyter": { "outputs_hidden": false, @@ -245,30 +192,12 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T23:01:16.2592288Z", - "execution_start_time": "2025-01-11T23:01:14.4142013Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "0eb527b1-e56e-4a60-8fe6-9e4419af89bd", - "queued_time": "2025-01-11T23:00:43.7342871Z", - "session_id": "26", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 46, - "statement_ids": [ - 46 - ] - }, - "text/plain": [ - "StatementMeta(medium, 26, 46, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 16:06:02 WARN TaskSetManager: Stage 1 contains a task of very large size (5590 KiB). The maximum recommended task size is 1000 KiB.\n", + " \r" + ] }, { "data": { @@ -276,7 +205,7 @@ "5074915" ] }, - "execution_count": 93, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -431,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 5, "metadata": { "jupyter": { "outputs_hidden": false, @@ -445,30 +374,12 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T23:26:40.0326641Z", - "execution_start_time": "2025-01-11T23:26:29.4493665Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "e541da32-90b4-479c-a59b-4f959cca62bb", - "queued_time": "2025-01-11T23:25:49.4755611Z", - "session_id": "26", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 68, - "statement_ids": [ - 68 - ] - }, - "text/plain": [ - "StatementMeta(medium, 26, 68, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 16:06:08 WARN TaskSetManager: Stage 4 contains a task of very large size (5590 KiB). The maximum recommended task size is 1000 KiB.\n", + " \r" + ] } ], "source": [ @@ -479,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 6, "metadata": { "jupyter": { "outputs_hidden": false, @@ -493,30 +404,20 @@ }, "outputs": [ { - "data": { - "application/vnd.livy.statement-meta+json": { - "execution_finish_time": "2025-01-11T23:26:41.9804998Z", - "execution_start_time": "2025-01-11T23:26:40.1656981Z", - "livy_statement_state": "available", - "normalized_state": "finished", - "parent_msg_id": "969c7e39-5cf1-4c68-b3f8-733a3da7f95c", - "queued_time": "2025-01-11T23:25:53.0269186Z", - "session_id": "26", - "session_start_time": null, - "spark_jobs": null, - "spark_pool": "medium", - "state": "finished", - "statement_id": 69, - "statement_ids": [ - 69 - ] - }, - "text/plain": [ - "StatementMeta(medium, 26, 69, Finished, Available, Finished)" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 16:06:28 WARN TaskSetManager: Stage 12 contains a task of very large size (5590 KiB). The maximum recommended task size is 1000 KiB.\n", + "25/01/12 16:06:32 WARN PythonRunner: Detected deadlock while completing task 2.0 in stage 12 (TID 25): Attempting to kill Python Worker\n", + "25/01/12 16:06:32 WARN PythonRunner: Detected deadlock while completing task 0.0 in stage 12 (TID 23): Attempting to kill Python Worker\n", + "25/01/12 16:06:32 WARN PythonRunner: Detected deadlock while completing task 1.0 in stage 12 (TID 24): Attempting to kill Python Worker\n", + "25/01/12 16:06:32 WARN PythonRunner: Detected deadlock while completing task 4.0 in stage 12 (TID 27): Attempting to kill Python Worker\n", + "25/01/12 16:06:32 WARN PythonRunner: Detected deadlock while completing task 3.0 in stage 12 (TID 26): Attempting to kill Python Worker\n", + "25/01/12 16:06:32 WARN PythonRunner: Detected deadlock while completing task 7.0 in stage 12 (TID 30): Attempting to kill Python Worker\n", + "25/01/12 16:06:32 WARN PythonRunner: Detected deadlock while completing task 6.0 in stage 12 (TID 29): Attempting to kill Python Worker\n", + "25/01/12 16:06:32 WARN PythonRunner: Detected deadlock while completing task 5.0 in stage 12 (TID 28): Attempting to kill Python Worker\n", + "[Stage 13:====================================> (5 + 3) / 8]\r" + ] }, { "name": "stdout", @@ -525,36 +426,81 @@ "+--------+---------+---------+-----+-----+\n", "|graph_id|source_id|target_id|group|batch|\n", "+--------+---------+---------+-----+-----+\n", - "| 10223| 0| 2| 3| 0|\n", - "| 10223| 1| 2| 3| 0|\n", - "| 10223| 2| 3| 3| 0|\n", - "| 10222| 7| 23| 2| 0|\n", - "| 10222| 8| 16| 2| 0|\n", - "| 10222| 9| 16| 2| 0|\n", - "| 10222| 10| 16| 2| 0|\n", - "| 10222| 11| 16| 2| 0|\n", - "| 10222| 13| 16| 2| 0|\n", - "| 10222| 14| 16| 2| 0|\n", - "| 10222| 15| 16| 2| 0|\n", - "| 10222| 16| 17| 2| 0|\n", - "| 10222| 16| 18| 2| 0|\n", - "| 10222| 16| 19| 2| 0|\n", - "| 10222| 16| 20| 2| 0|\n", - "| 10222| 16| 21| 2| 0|\n", - "| 10222| 16| 22| 2| 0|\n", - "| 10222| 16| 23| 2| 0|\n", - "| 10222| 16| 24| 2| 0|\n", - "| 10222| 16| 25| 2| 0|\n", + "| 0| 0| 2| 0| 0|\n", + "| 0| 1| 5| 0| 0|\n", + "| 0| 2| 4| 0| 0|\n", + "| 0| 2| 5| 0| 0|\n", + "| 0| 2| 6| 0| 0|\n", + "| 0| 2| 7| 0| 0|\n", + "| 0| 2| 8| 0| 0|\n", + "| 0| 2| 9| 0| 0|\n", + "| 0| 2| 10| 0| 0|\n", + "| 0| 3| 8| 0| 0|\n", + "| 1| 0| 3| 3| 0|\n", + "| 1| 0| 6| 3| 0|\n", + "| 1| 1| 8| 3| 0|\n", + "| 1| 2| 8| 3| 0|\n", + "| 1| 4| 8| 3| 0|\n", + "| 1| 5| 8| 3| 0|\n", + "| 1| 6| 8| 3| 0|\n", + "| 1| 7| 8| 3| 0|\n", + "| 1| 8| 9| 3| 0|\n", + "| 1| 8| 10| 3| 0|\n", "+--------+---------+---------+-----+-----+\n", "only showing top 20 rows\n", "\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " \r" + ] } ], "source": [ "rel_batch_df.show()" ] }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "25/01/12 16:07:41 WARN TaskSetManager: Stage 35 contains a task of very large size (5590 KiB). The maximum recommended task size is 1000 KiB.\n", + " \r" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "create_ingest_heatmap(rel_batch_df, figsize=(8, 2))" + ] + }, { "cell_type": "code", "execution_count": 71, @@ -865,12 +811,21 @@ "name": "synapse_pyspark" }, "kernelspec": { - "display_name": "Synapse PySpark", - "language": "Python", - "name": "synapse_pyspark" + "display_name": ".venv", + "language": "python", + "name": "python3" }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" }, "save_output": true, "synapse_widget": { From 167fbd82712503b696ca561246ab8b56e87f33c3 Mon Sep 17 00:00:00 2001 From: alex Date: Mon, 13 Jan 2025 12:37:38 -0600 Subject: [PATCH 10/13] Update .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 947febb..d8e283c 100644 --- a/.gitignore +++ b/.gitignore @@ -171,3 +171,4 @@ cython_debug/ # PyPI configuration file .pypirc +Neo4j-0f015ca4-Created-2025-01-09.txt From 6018cbf89207391f548c161285ba9d9a0169ed6e Mon Sep 17 00:00:00 2001 From: alex Date: Mon, 13 Jan 2025 13:19:57 -0600 Subject: [PATCH 11/13] add requestst to dev, make figsize optional in viz --- .../visualize/heatmap.py | 8 +- poetry.lock | 261 ++++++++++++++---- pyproject.toml | 3 +- 3 files changed, 209 insertions(+), 63 deletions(-) diff --git a/neo4j_parallel_spark_loader/visualize/heatmap.py b/neo4j_parallel_spark_loader/visualize/heatmap.py index 321b895..5fd32a8 100644 --- a/neo4j_parallel_spark_loader/visualize/heatmap.py +++ b/neo4j_parallel_spark_loader/visualize/heatmap.py @@ -1,4 +1,4 @@ -from typing import Any, Dict, List +from typing import Any, Dict, List, Optional, Tuple import numpy as np import seaborn as sns from matplotlib.axes import Axes @@ -25,7 +25,7 @@ def _format_spark_dataframe_for_visualization( return [row.asDict() for row in counts_sdf.collect()] def create_ingest_heatmap( - spark_dataframe: DataFrame, title: str = "Parallel Ingest Heat Map", figsize=(8, 12) + spark_dataframe: DataFrame, title: str = "Parallel Ingest Heat Map", figsize: Optional[Tuple[float, float]] = None ) -> Axes: """ Create the ingest heatmap from a list of dictionaries. @@ -38,7 +38,7 @@ def create_ingest_heatmap( title : str, optional A title for the visualization, by default "Parallel Ingest Heat Map" figsize : tuple, optional - Figure size (width, height) in inches, by default (8, 12) + Figure size (width, height) in inches, by default None Returns ------- @@ -97,7 +97,7 @@ def create_ingest_heatmap( yticklabels=y_values, linewidths=0.5, ) - + # plt.clim(0) ax.set_xlabel("Group Number") ax.set_ylabel("Batch") ax.set_title(title) diff --git a/poetry.lock b/poetry.lock index c93acf9..85d84e1 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,5 +1,117 @@ # This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand. +[[package]] +name = "certifi" +version = "2024.12.14" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56"}, + {file = "certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.1" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7" +files = [ + {file = "charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f30bf9fd9be89ecb2360c7d94a711f00c09b976258846efe40db3d05828e8089"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:97f68b8d6831127e4787ad15e6757232e14e12060bec17091b85eb1486b91d8d"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7974a0b5ecd505609e3b19742b60cee7aa2aa2fb3151bc917e6e2646d7667dcf"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc54db6c8593ef7d4b2a331b58653356cf04f67c960f584edb7c3d8c97e8f39e"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:311f30128d7d333eebd7896965bfcfbd0065f1716ec92bd5638d7748eb6f936a"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:7d053096f67cd1241601111b698f5cad775f97ab25d81567d3f59219b5f1adbd"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:807f52c1f798eef6cf26beb819eeb8819b1622ddfeef9d0977a8502d4db6d534"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:dccbe65bd2f7f7ec22c4ff99ed56faa1e9f785482b9bbd7c717e26fd723a1d1e"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:2fb9bd477fdea8684f78791a6de97a953c51831ee2981f8e4f583ff3b9d9687e"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:01732659ba9b5b873fc117534143e4feefecf3b2078b0a6a2e925271bb6f4cfa"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-win32.whl", hash = "sha256:7a4f97a081603d2050bfaffdefa5b02a9ec823f8348a572e39032caa8404a487"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:7b1bef6280950ee6c177b326508f86cad7ad4dff12454483b51d8b7d673a2c5d"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ecddf25bee22fe4fe3737a399d0d177d72bc22be6913acfab364b40bce1ba83c"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c60ca7339acd497a55b0ea5d506b2a2612afb2826560416f6894e8b5770d4a9"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b7b2d86dd06bfc2ade3312a83a5c364c7ec2e3498f8734282c6c3d4b07b346b8"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd78cfcda14a1ef52584dbb008f7ac81c1328c0f58184bf9a84c49c605002da6"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e27f48bcd0957c6d4cb9d6fa6b61d192d0b13d5ef563e5f2ae35feafc0d179c"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01ad647cdd609225c5350561d084b42ddf732f4eeefe6e678765636791e78b9a"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:619a609aa74ae43d90ed2e89bdd784765de0a25ca761b93e196d938b8fd1dbbd"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:89149166622f4db9b4b6a449256291dc87a99ee53151c74cbd82a53c8c2f6ccd"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:7709f51f5f7c853f0fb938bcd3bc59cdfdc5203635ffd18bf354f6967ea0f824"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:345b0426edd4e18138d6528aed636de7a9ed169b4aaf9d61a8c19e39d26838ca"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0907f11d019260cdc3f94fbdb23ff9125f6b5d1039b76003b5b0ac9d6a6c9d5b"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-win32.whl", hash = "sha256:ea0d8d539afa5eb2728aa1932a988a9a7af94f18582ffae4bc10b3fbdad0626e"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:329ce159e82018d646c7ac45b01a430369d526569ec08516081727a20e9e4af4"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b97e690a2118911e39b4042088092771b4ae3fc3aa86518f84b8cf6888dbdb41"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78baa6d91634dfb69ec52a463534bc0df05dbd546209b79a3880a34487f4b84f"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a2bc9f351a75ef49d664206d51f8e5ede9da246602dc2d2726837620ea034b2"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75832c08354f595c760a804588b9357d34ec00ba1c940c15e31e96d902093770"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0af291f4fe114be0280cdd29d533696a77b5b49cfde5467176ecab32353395c4"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0167ddc8ab6508fe81860a57dd472b2ef4060e8d378f0cc555707126830f2537"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2a75d49014d118e4198bcee5ee0a6f25856b29b12dbf7cd012791f8a6cc5c496"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:363e2f92b0f0174b2f8238240a1a30142e3db7b957a5dd5689b0e75fb717cc78"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ab36c8eb7e454e34e60eb55ca5d241a5d18b2c6244f6827a30e451c42410b5f7"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:4c0907b1928a36d5a998d72d64d8eaa7244989f7aaaf947500d3a800c83a3fd6"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:04432ad9479fa40ec0f387795ddad4437a2b50417c69fa275e212933519ff294"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-win32.whl", hash = "sha256:3bed14e9c89dcb10e8f3a29f9ccac4955aebe93c71ae803af79265c9ca5644c5"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:49402233c892a461407c512a19435d1ce275543138294f7ef013f0b63d5d3765"}, + {file = "charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85"}, + {file = "charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3"}, +] + [[package]] name = "colorama" version = "0.4.6" @@ -260,6 +372,20 @@ ufo = ["fs (>=2.2.0,<3)"] unicode = ["unicodedata2 (>=15.1.0)"] woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] +[[package]] +name = "idna" +version = "3.10" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.6" +files = [ + {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"}, + {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"}, +] + +[package.extras] +all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"] + [[package]] name = "iniconfig" version = "2.0.0" @@ -438,66 +564,47 @@ pyarrow = ["pyarrow (>=1.0.0)"] [[package]] name = "numpy" -version = "2.2.1" +version = "1.26.4" description = "Fundamental package for array computing in Python" optional = false -python-versions = ">=3.10" +python-versions = ">=3.9" files = [ - {file = "numpy-2.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5edb4e4caf751c1518e6a26a83501fda79bff41cc59dac48d70e6d65d4ec4440"}, - {file = "numpy-2.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa3017c40d513ccac9621a2364f939d39e550c542eb2a894b4c8da92b38896ab"}, - {file = "numpy-2.2.1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:61048b4a49b1c93fe13426e04e04fdf5a03f456616f6e98c7576144677598675"}, - {file = "numpy-2.2.1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:7671dc19c7019103ca44e8d94917eba8534c76133523ca8406822efdd19c9308"}, - {file = "numpy-2.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4250888bcb96617e00bfa28ac24850a83c9f3a16db471eca2ee1f1714df0f957"}, - {file = "numpy-2.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7746f235c47abc72b102d3bce9977714c2444bdfaea7888d241b4c4bb6a78bf"}, - {file = "numpy-2.2.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:059e6a747ae84fce488c3ee397cee7e5f905fd1bda5fb18c66bc41807ff119b2"}, - {file = "numpy-2.2.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f62aa6ee4eb43b024b0e5a01cf65a0bb078ef8c395e8713c6e8a12a697144528"}, - {file = "numpy-2.2.1-cp310-cp310-win32.whl", hash = "sha256:48fd472630715e1c1c89bf1feab55c29098cb403cc184b4859f9c86d4fcb6a95"}, - {file = "numpy-2.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:b541032178a718c165a49638d28272b771053f628382d5e9d1c93df23ff58dbf"}, - {file = "numpy-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:40f9e544c1c56ba8f1cf7686a8c9b5bb249e665d40d626a23899ba6d5d9e1484"}, - {file = "numpy-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f9b57eaa3b0cd8db52049ed0330747b0364e899e8a606a624813452b8203d5f7"}, - {file = "numpy-2.2.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bc8a37ad5b22c08e2dbd27df2b3ef7e5c0864235805b1e718a235bcb200cf1cb"}, - {file = "numpy-2.2.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:9036d6365d13b6cbe8f27a0eaf73ddcc070cae584e5ff94bb45e3e9d729feab5"}, - {file = "numpy-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51faf345324db860b515d3f364eaa93d0e0551a88d6218a7d61286554d190d73"}, - {file = "numpy-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38efc1e56b73cc9b182fe55e56e63b044dd26a72128fd2fbd502f75555d92591"}, - {file = "numpy-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:31b89fa67a8042e96715c68e071a1200c4e172f93b0fbe01a14c0ff3ff820fc8"}, - {file = "numpy-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4c86e2a209199ead7ee0af65e1d9992d1dce7e1f63c4b9a616500f93820658d0"}, - {file = "numpy-2.2.1-cp311-cp311-win32.whl", hash = "sha256:b34d87e8a3090ea626003f87f9392b3929a7bbf4104a05b6667348b6bd4bf1cd"}, - {file = "numpy-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:360137f8fb1b753c5cde3ac388597ad680eccbbbb3865ab65efea062c4a1fd16"}, - {file = "numpy-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:694f9e921a0c8f252980e85bce61ebbd07ed2b7d4fa72d0e4246f2f8aa6642ab"}, - {file = "numpy-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3683a8d166f2692664262fd4900f207791d005fb088d7fdb973cc8d663626faa"}, - {file = "numpy-2.2.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:780077d95eafc2ccc3ced969db22377b3864e5b9a0ea5eb347cc93b3ea900315"}, - {file = "numpy-2.2.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:55ba24ebe208344aa7a00e4482f65742969a039c2acfcb910bc6fcd776eb4355"}, - {file = "numpy-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b1d07b53b78bf84a96898c1bc139ad7f10fda7423f5fd158fd0f47ec5e01ac7"}, - {file = "numpy-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5062dc1a4e32a10dc2b8b13cedd58988261416e811c1dc4dbdea4f57eea61b0d"}, - {file = "numpy-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:fce4f615f8ca31b2e61aa0eb5865a21e14f5629515c9151850aa936c02a1ee51"}, - {file = "numpy-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:67d4cda6fa6ffa073b08c8372aa5fa767ceb10c9a0587c707505a6d426f4e046"}, - {file = "numpy-2.2.1-cp312-cp312-win32.whl", hash = "sha256:32cb94448be47c500d2c7a95f93e2f21a01f1fd05dd2beea1ccd049bb6001cd2"}, - {file = "numpy-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:ba5511d8f31c033a5fcbda22dd5c813630af98c70b2661f2d2c654ae3cdfcfc8"}, - {file = "numpy-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f1d09e520217618e76396377c81fba6f290d5f926f50c35f3a5f72b01a0da780"}, - {file = "numpy-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3ecc47cd7f6ea0336042be87d9e7da378e5c7e9b3c8ad0f7c966f714fc10d821"}, - {file = "numpy-2.2.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f419290bc8968a46c4933158c91a0012b7a99bb2e465d5ef5293879742f8797e"}, - {file = "numpy-2.2.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5b6c390bfaef8c45a260554888966618328d30e72173697e5cabe6b285fb2348"}, - {file = "numpy-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:526fc406ab991a340744aad7e25251dd47a6720a685fa3331e5c59fef5282a59"}, - {file = "numpy-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f74e6fdeb9a265624ec3a3918430205dff1df7e95a230779746a6af78bc615af"}, - {file = "numpy-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:53c09385ff0b72ba79d8715683c1168c12e0b6e84fb0372e97553d1ea91efe51"}, - {file = "numpy-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f3eac17d9ec51be534685ba877b6ab5edc3ab7ec95c8f163e5d7b39859524716"}, - {file = "numpy-2.2.1-cp313-cp313-win32.whl", hash = "sha256:9ad014faa93dbb52c80d8f4d3dcf855865c876c9660cb9bd7553843dd03a4b1e"}, - {file = "numpy-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:164a829b6aacf79ca47ba4814b130c4020b202522a93d7bff2202bfb33b61c60"}, - {file = "numpy-2.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4dfda918a13cc4f81e9118dea249e192ab167a0bb1966272d5503e39234d694e"}, - {file = "numpy-2.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:733585f9f4b62e9b3528dd1070ec4f52b8acf64215b60a845fa13ebd73cd0712"}, - {file = "numpy-2.2.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:89b16a18e7bba224ce5114db863e7029803c179979e1af6ad6a6b11f70545008"}, - {file = "numpy-2.2.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:676f4eebf6b2d430300f1f4f4c2461685f8269f94c89698d832cdf9277f30b84"}, - {file = "numpy-2.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27f5cdf9f493b35f7e41e8368e7d7b4bbafaf9660cba53fb21d2cd174ec09631"}, - {file = "numpy-2.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1ad395cf254c4fbb5b2132fee391f361a6e8c1adbd28f2cd8e79308a615fe9d"}, - {file = "numpy-2.2.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:08ef779aed40dbc52729d6ffe7dd51df85796a702afbf68a4f4e41fafdc8bda5"}, - {file = "numpy-2.2.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:26c9c4382b19fcfbbed3238a14abf7ff223890ea1936b8890f058e7ba35e8d71"}, - {file = "numpy-2.2.1-cp313-cp313t-win32.whl", hash = "sha256:93cf4e045bae74c90ca833cba583c14b62cb4ba2cba0abd2b141ab52548247e2"}, - {file = "numpy-2.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:bff7d8ec20f5f42607599f9994770fa65d76edca264a87b5e4ea5629bce12268"}, - {file = "numpy-2.2.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7ba9cc93a91d86365a5d270dee221fdc04fb68d7478e6bf6af650de78a8339e3"}, - {file = "numpy-2.2.1-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:3d03883435a19794e41f147612a77a8f56d4e52822337844fff3d4040a142964"}, - {file = "numpy-2.2.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4511d9e6071452b944207c8ce46ad2f897307910b402ea5fa975da32e0102800"}, - {file = "numpy-2.2.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5c5cc0cbabe9452038ed984d05ac87910f89370b9242371bd9079cb4af61811e"}, - {file = "numpy-2.2.1.tar.gz", hash = "sha256:45681fd7128c8ad1c379f0ca0776a8b0c6583d2f69889ddac01559dfe4390918"}, + {file = "numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0"}, + {file = "numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2"}, + {file = "numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07"}, + {file = "numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a"}, + {file = "numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20"}, + {file = "numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0"}, + {file = "numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110"}, + {file = "numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c"}, + {file = "numpy-1.26.4-cp39-cp39-win32.whl", hash = "sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6"}, + {file = "numpy-1.26.4-cp39-cp39-win_amd64.whl", hash = "sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0"}, + {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"}, ] [[package]] @@ -823,6 +930,27 @@ files = [ {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, ] +[[package]] +name = "requests" +version = "2.32.3" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.8" +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + [[package]] name = "ruff" version = "0.3.7" @@ -933,7 +1061,24 @@ files = [ {file = "tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc"}, ] +[[package]] +name = "urllib3" +version = "2.3.0" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.9" +files = [ + {file = "urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df"}, + {file = "urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "9ddd24c13f7089658add40758983e01316712c5ac1997fff8eab1acb440ec18c" +content-hash = "3c58cf2642e706f06b592d49d46af80286f2752343362093a58def6b6cb8f416" diff --git a/pyproject.toml b/pyproject.toml index 7c01ba5..2f680fa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,7 +10,7 @@ exclude = ["tests/*", "benchmarking/*", "docs/*", "examples/*", "Makefile"] [tool.poetry.dependencies] python = "^3.10" pyspark = "^3.4.0" -numpy = "^2.2.1" +numpy = "^1.2.0" [tool.poetry.group.dev.dependencies] @@ -21,6 +21,7 @@ pytest-mock = "^3.12.0" python-dotenv = "^1.0.1" ruff = "^0.3.0" seaborn = "^0.13.2" +requests = "^2.32.3" [tool.ruff] target-version = "py312" From 7b5b9604f2e0736a9b03a1bf6a732ac98009c4c1 Mon Sep 17 00:00:00 2001 From: alex Date: Mon, 13 Jan 2025 13:31:26 -0600 Subject: [PATCH 12/13] update examples with dotenv --- examples/bipartite_amazon_ratings.ipynb | 22 +++++------ examples/heatmap_example.ipynb | 4 +- examples/monopartite_twitch_gamers.ipynb | 21 +++++----- ...predefined_components_reddit_threads.ipynb | 39 ++++++++++++------- .../monopartite/grouping.py | 29 +++++++------- .../visualize/heatmap.py | 39 ++++++++++++------- 6 files changed, 90 insertions(+), 64 deletions(-) diff --git a/examples/bipartite_amazon_ratings.ipynb b/examples/bipartite_amazon_ratings.ipynb index 87511c1..dc844d8 100644 --- a/examples/bipartite_amazon_ratings.ipynb +++ b/examples/bipartite_amazon_ratings.ipynb @@ -6,6 +6,8 @@ "metadata": {}, "outputs": [], "source": [ + "import os\n", + "from dotenv import load_dotenv\n", "from pyspark.sql import SparkSession\n", "from pyspark.sql.types import StructType, StructField, IntegerType, FloatType\n", "import requests\n", @@ -13,7 +15,9 @@ "from zipfile import ZipFile\n", "from neo4j_parallel_spark_loader.bipartite import group_and_batch_spark_dataframe\n", "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n", - "from neo4j_parallel_spark_loader.visualize import create_ingest_heatmap\n" + "from neo4j_parallel_spark_loader.visualize import create_ingest_heatmap\n", + "\n", + "load_dotenv()\n" ] }, { @@ -63,20 +67,16 @@ } ], "source": [ - "username = \"NEO4J_USER\"\n", - "password = \"NEO4J_PASSWORD\"\n", - "url = \"NEO4J_URL\"\n", - "dbname = \"NEO4J_DATABASE\"\n", "spark_executor_count=5\n", "\n", "spark = (\n", " SparkSession.builder\n", " .appName(\"AmazonRatings\")\n", - " .config(\"neo4j.url\", url)\n", - " .config(\"url\", url)\n", - " .config(\"neo4j.authentication.basic.username\", username)\n", - " .config(\"neo4j.authentication.basic.password\", password)\n", - " .config(\"neo4j.database\", dbname)\n", + " .config(\"neo4j.url\", os.environ.get(\"NEO4J_URI\"))\n", + " .config(\"url\", os.environ.get(\"NEO4J_URI\"))\n", + " .config(\"neo4j.authentication.basic.username\", os.environ.get(\"USERNAME\"))\n", + " .config(\"neo4j.authentication.basic.password\", os.environ.get(\"NEO4J_PASSWORD\"))\n", + " .config(\"neo4j.database\", os.environ.get(\"NEO4J_DATABASE\"))\n", " .getOrCreate()\n", ")" ] @@ -662,7 +662,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.12.3" }, "save_output": true, "synapse_widget": { diff --git a/examples/heatmap_example.ipynb b/examples/heatmap_example.ipynb index f3fc7c4..45f585e 100644 --- a/examples/heatmap_example.ipynb +++ b/examples/heatmap_example.ipynb @@ -72,7 +72,7 @@ "text": [ "Setting default log level to \"WARN\".\n", "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n", - "25/01/06 09:16:20 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n" + "25/01/13 13:23:23 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n" ] } ], @@ -125,7 +125,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgkAAAHHCAYAAAA1aMuhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAARQhJREFUeJzt3Qd8FHX+//F3CoQeBEInVOlFQVQEAUFQOncenEpHUCk2bOApRcXgoSL3k6KIlKMpeiiKiIICItKb9CpNIPSSkBCy+398x39iFhZIQjazs3k97zGX7Ozu7IdJzHzm821BbrfbLQAAgCsEX7kDAADAIEkAAABekSQAAACvSBIAAIBXJAkAAMArkgQAAOAVSQIAAPCKJAEAAHhFkgAAALwiSUCWU6ZMGXXv3j358eLFixUUFGR9TavJkydb7/39998zOEoAsB9JAnwq6SKatOXIkUMVK1ZU//79dezYMWUVQ4cOtf79J06ckFPMmDFD77//fpqSr9atW3t9LikR+/zzz+UrsbGx1nlObbKXFJPZpk2b5vU19evXt56vXr16BkcLOANJAjLF66+/rv/+97/64IMPdM8992jcuHGqV6+e9YcdgZEk2M38Lg0bNizNFSGTuJp/65VMdWj58uXW80BWFWp3AMgaWrRooTvuuMP6vlevXipYsKDee+89ffXVV3rkkUfSfVyXy6VLly7xhxzp1rJlS82dO9eq8hQqVCh5v0kcihQpoltvvVWnT5+2NUbALlQSYIsmTZpYX/ft22d9feedd6wKg0kecubMqTp16ngtTZvSr2mqmD59uqpVq6awsDB99913aTpGaq1cuVIPPvigwsPDlStXLjVq1Ei//PKLMkrjxo2tMvbWrVt13333WZ9RokQJ/fvf/77qtfv371fbtm2VO3duFS5cWM8995wWLFjgtS9FauI+f/68nn32WauJwJxDc8xmzZpp3bp1ybHNmzfP+tykkrx5bUY7fPiwevbsaV2MTRzmZ/rJJ594vMYkgYMHD7Z+nubfZM7Bvffeq59++snjrj8iIsL63lQTkmI2zQ830q5dO+uzZ8+e7bHfJAkdO3ZUSEjIVe+ZNGmS9Ttszpt5b9WqVa3q2LWaYL7//nvddtttVjJrXvu///0vTecJsAuVBNhiz5491ldzQTdGjx5tXQQ7depkXRRmzZqlDh066JtvvlGrVq083vvjjz/qs88+s5IFc+eXdPFKyzFuxHyGqX6YC9OQIUMUHBycfGH4+eefdeedd2bIeTB3qOaC/ve//926IJmk5uWXX1aNGjWszzdiYmKszz1y5IieeeYZFS1a1LqApbxIpjXuJ5980voscw7NRevkyZNatmyZtm3bptq1a+tf//qXzp49q0OHDmnUqFHWe/LkyXPDf09CQoLXfhfmWFcyfVLuvvvu5MTPXOTnz5+vxx57TOfOnbOSGMN8//HHH1sVp969e1sJzsSJE/XAAw9o1apV1sXXvNdcpPv06aO//e1v1vk0atasecOYTSJlEoWZM2da7zc2btyoLVu2WJ+7adOmq95jPsskNOb3LTQ0VF9//bX69u1rVbb69evn8dpdu3bpn//8p3XOu3XrZv08zO+lSW5NYgb4NTfgQ5MmTXKbX7OFCxe6jx8/7j548KB71qxZ7oIFC7pz5szpPnTokPW62NhYj/ddunTJXb16dXeTJk089ptjBQcHu7ds2XLVZ6X2GKVLl3Z369Yt+fFPP/1kHdd8NVwul/vWW291P/DAA9b3KY9ftmxZd7Nmza769+3bt++652HIkCHW68w5SNKoUSNr39SpU5P3xcfHu4sWLep+6KGHkve9++671uu+/PLL5H0XL150V65cOd1xh4eHu/v163fdmFu1amWdq9QyrzXxXG+bPXt28usfe+wxd7FixdwnTpzwOM7DDz9sxZf087x8+bJ1XlI6ffq0u0iRIu6ePXsm7zPn1nyGOdepkfRzNzF988037qCgIPeBAwes51588UV3uXLlkn9O1apVu+7vmmHOe9J7rjwnX3zxRfK+s2fPWv/u22+/PVVxAnaiuQGZ4v7777fu9kqVKqWHH37YuiudM2eOVV43TPNAyrtrc+dpSspJ5e+UTPnc3P1eKS3HuJ4NGzZYd3+PPvqodYdt7ozNZu7omzZtqqVLl1p3jBnBnIfOnTsnP86ePbt1t793797kfeaO05wnc9eaxJStzV11euPOnz+/1Szxxx9/KCPddddd+uGHH67aTFNQSibf++KLL9SmTRvr+6RYzWYqBOZnl/RzM+V+c14ME/+pU6d0+fJlq49LWn+219K8eXMVKFDAqj6ZeMzX6/WVSfm7ZmI1cZvfS/Nzu7JqUrx4cau6kSRfvnzq2rWr1q9fr6NHj2ZI/ICv0NyATDFmzBhr6KMpzZr250qVKlml8CSmSeDNN9+0LnTx8fHJ+00p+kply5b1+hlpOcb1mAutYUrD12IuBLfccotuVsmSJa+Kzxw3ZYnb9AsoX778Va+rUKFCuuM2/R7M60zSZpomTOc9c+EqV67cTf17TPOPSQivZH7uKR0/flxnzpzRRx99ZG3eREdHJ38/ZcoUvfvuu9q+fbvVpHGj34W0ypYtm9UEYJpxTJJ28OBBK9m6FtPHwzTn/Prrr1eN0DHn2PSdSPlzuvJnZ/5bSOpLYZqPAH9FkoBMYf7wJo1uuJJpKzd3yQ0bNtTYsWNVrFgx64+2abv1NjQt5V1ceo9xPUl32yNHjrTau71JTft8anjrFGf82bIin8Vt+j+YKoup5phOdeY9b7/9ttWhLqkvhC8lxWqqKNdKapL6E5g5DMzkV+3bt9eLL75odRY05y0qKiq5b0tGMEnB+PHjrc6OtWrV8lqtMsxnmspM5cqVrRE6JtEylY5vv/3W6r+RUVUmwB+QJMB2puxsyuemt77pKZ7EXOAz8xhJzF17UlnY211xZitdurQ1AsIkDinvSHfv3n1TcZtEynS2M5u5azcdFocPH56cJKS1ApMWpukpb968SkxMvGGspoOlqXCYBCZlTOZOPqWbjbdBgwaKjIy0RouYhOlaTCdFU6kywybN65N460ia9HO68me3c+dO66svRowAGYk+CbCduSs0f0DNBSOJKcN++eWXmXqMJKb8bi64ph39woULVz1vSuWZybTRm6GC5qKUJC4uThMmTEhX3OYcXdlubu7OTdt5ymYaM9TQ26iEjGB+Xg899JCV3G3evPmasSa99srqiulPYUr9V45SMEwzRnqY35///Oc/VvLRpUuX68Z+ZTzmPF0rITX9PkzFJokZrTF16lSr2kNTA/wdlQTYzgxPNGVbMxTQlHzNXa3pw2Dacr0NP/PVMZKYvhJm6Ju5ozbD3Hr06GF1HDQXanO3aO7Uzd1kZnniiSesmSpNRzozBNJUAMw8EUkTSCXdoaY2bjOE0PSF+Mc//mGV1U0TxMKFC7V69Wqr3T9l0vHpp59qwIABqlu3rvU609Ewo4wYMcKKy3R2NJ0wTXnfdEo0nRFNPOZ7w8wzYKoIpvOf+TmbuTVMs4B5fcpkyDRDmX0mZtPmbzoimnko0jKlshkKabYbdXI0zQvmXJifjYnBJGwm0TLDVK9kYjHDOs35Nf1xzDwQZvhneqpcQKazdWwFAl7SEMHVq1df93UTJ060hu+FhYVZQ/vM+5KGDaZkHl9r6F5qj3GjIZBJ1q9f7/773/9uDdc0xzTv69ixo3vRokUZNgTyyqF1hontyqGHe/futYYkmmGjERER7ueff94aVmeOuWLFijTFbYYTmiF+tWrVcufNm9edO3du6/uxY8d6HOfChQvuRx991J0/f37rc240HNI8b2K80XDDlI4dO2b9PEuVKuXOli2bNfyzadOm7o8++ij5NWY451tvvWUd3/x7zNBBM2TR23lavny5u06dOu7s2bPfcDjktWK6kref09y5c901a9Z058iRw12mTBn322+/7f7kk0+u+l1IOicLFiywXp/0u3mjzwT8RZD5v8xPTQDcLLOugpl50Ux4lDSUFP7F9DkwlQwz8gZwIvokAA5w8eJFj8emT8KHH35orStAggDAV+iTADiAmWbY9KQ3nd1MJzkzLNDMGWD6JgCAr5AkAA5gRjiYTokmKTCjE0wHPTMroFkTAAB8hT4JAAAEqPPnz+u1116zhuGaUV+33367tRieGbGUGvRJAAAgQPXq1ctaP+W///2vfvvtN2sIr5nAzAyNTg0qCQAABGiH57x58+qrr76y5hhJOQeKmU/FrHVzI/RJAADAIeLj4z1mRjXMVPQpp6NPYlZLNX2YkiZeSznx2LJly1L1eVQSAADwsYQTfy3/fjOGfzBVw4YN89hnphI3C5N5c88991gzhJqF7syMnzNnzrQWVTOz0e7YsSPrJgkZ9QPJirIVKqfhpTvZHYYj/Wv/dM0r8ojdYThSq2MzdbaH/QtqOVX4pIUKzc6cGelx+VLq2uf94Zrkylsi1ZWEpFVLe/bsqaVLl1rrjpiF3MxU4WvXrtW2bdtu+Hk0NwAA4GuuvxafuxnXSwi8MYu+LVmyRDExMdbiYmbtFzN02qysmhqMbgAAwNfcrozZ0sms6moShNOnT2vBggU3XMgsCZUEAAB8zZX+C/zNMAmB6VVQqVIl7d69Wy+++KIqV65srRKbGlQSAAAIUGfPnlW/fv2sxKBr165q0KCBlThky5YtVe+nkgAAgI+5b6Kp4GZ07NjR2tKLJAEAgABtbrhZNDcAAACvqCQAAOBrbmdWEkgSAABwyDwJmY3mBgAA4BWVBAAAfM1NcwMAAPCG0Q0AACCQUEkAACBAJ1O6WSQJAAD4moskAQAAeOPQSgJ9EgAAgFdUEgAA8DWXMydTIkkAAMDX3DQ3AACAAEIlAQAAX3M5s5JAkgAAgK+5nZkk0NwAAAC8opIAAICvuZxZSSBJAADAx9xuZw6BpLkBAAB4RSUBAABfc9PcAAAAvKFPAgAA8IpKAq4nJiZW/zdhqhYt/VWnTp9R5YrlNfDZJ1SjSiW7Q/N7tTs3Ve3O9yt/yQjr8fFdh7Rs9BztWbzR7tAcp/xTbVX51Ue076P52vraVLvDcYSg/AWVo2Nvhda4U0HZw+SK/kMXJ45U4u877Q7NEfo82U3PD+ijokUjtGnTVj3z7GtavWaD3WEhlUgSMsngEaO1e+/vihr8ggoXKqivF/yo3s+8oq+mf6giEYXsDs+vnT9ySj+9PUun9h1VUFCQav7jXnWYMEAft3xFJ3Ydtjs8xwi/rZwiuzbVuS377Q7FOXLlUZ5/jdblbRsU+94guc6fVUiREnLHnLc7Mkfo0KGt3hk5RH37DdSq1ev19FO99O286apavaGOHz+pLMXF6AZcQ1x8vBYuWaYB/R7THbfVUGTJ4ur3WGfr66dz5tkdnt/btWi99vy0Uad/P2YlCotHztal2DiVqF3B7tAcIyRXmG4b21+bnp+ghDMxdofjGGEtH5br1HFd/OQdJe7bIfeJo7q8Za1cx4/YHZojPPdMb308cYamTP1M27btspKF2NiL6tH9YWXJ5gZ3BmxZPUlwu90KNImXE5WY6FJY9mwe+8PCsmvdpi22xeVEQcFBqtrmbmXLGabD63bbHY5jVB/RU9EL1+vk0s12h+Io2W6rp8R9O5Wr72vKO3q28gwdr2wNW9odliNky5ZNtWvX1KIff/b4+77ox2W6++46tsYGBzc3hIWFaePGjapSpYoCRe7cuVSrehWNnzxT5UpHqmCB/Pp24RJt3LxdkSWK2R2eI0RUKqXuc4YqNCybLsXE6fMnRtHUkErF2tdTvppl9MsDr9odiuMEFy6m7E3aKH7B54r7ZqZCylZSzk79pMQEJfzyg93h+bVChQooNDRU0cdOeOyPjj6uypXKK8tx0XExTQYMGOB1f2JiokaMGKGCBQtaj997773rHic+Pt7arkw0/K1EEvXaCxocNUpN2ndWSEiwqlSsoBb3N9LWHdwNp8bJvX/o4xavKCxvTlVueZfavPukpv3zTRKFG8hRvICqvdlNKzu+JVd8gt3hOE9QkNVBMf6LT6yHrgO7FVKijLI3bkOSgLRhdEPavP/++6pVq5by58/vsd+Uo7Zt26bcuXNbndRuJCoqSsOGDfPYN2TIEP2rf1f5E9P/YPKYkYq9GGeNdIgoVEDPvxalksWL2h2aI7gSEnV6/zHr+6Obf1fxWuVUt8cDmv/Kn3+84V14rXIKiwhXgx/eSt4XHBqiAvUqq3TP5ppfqovkCrwmvoziPnNKrj88O3q6jhxQtjvutS0mpzhx4pQuX76swkU8O2YXLhyho8eO2xZXVpKYmKihQ4dq2rRpOnr0qIoXL67u3bvr1VdfTdX11dYk4a233tJHH32kd999V02aNPFox5o8ebKqVq2aquMMGjToqqqEqSTovH/eYebKmcPazp47r+Wr1mpA3552h+TYvgkhV/TxwNVOLN2sJY1e9NhX6/0ndWH3H9rzwVwShBu4vHuLgouW8tgXXKSkXCf/TFhxbQkJCVq3bpOa3NdAc+cusPaZC5N5PHbcJGU5rsyvJLz99tsaN26cpkyZomrVqmnNmjXq0aOHwsPD9fTTT/t3kjBw4EA1bdpUnTt3Vps2bayKgEkQ0sokBFZScIUEPxuh9MvKtVaVpExkSR049IfeHTNRZSNLqn2r5naH5vcav/RPa06Ec3+cUPbcOVWt3T0qfXcVzezytt2h+b3EmDhd2H7Ic19svBJOX7hqP6526fsvlPuV0Qpr9YgSVi9RSLnKyt64pS5OHmV3aI4wavQETZo4SmvXbdJqawhkb+XOnVOTp3yqLMeV+UnC8uXL1a5dO7Vq1cp6XKZMGc2cOVOrVq1yRsfFunXrau3aterXr5/uuOMOTZ8+PdUlEKc5fyFG74+fpGPHTyg8X141a9RATz/RTdlC/a7vqN/JXSif2r73pPIUzq/487GK3n7QShD2LaOnPnzLDHuM/WCIcvyjl8LadbGGPl6cMU4JK360OzRHmD17rtW0OnTwC9ZkShs3blGr1p0VHe3ZmRGpd61+eN5ulu+55x6rYr9z505VrFjRGhSwbNmyG/b1S8n2K1SePHmsUsisWbN0//33W20ogejBpg2tDWk376UJdocQUFb8/Q27Q3CUyxtX6sLGlXaH4Vhjx022tqzOnUFLRY+4Rj880/fAW8X+3Llzqly5skJCQqzr6/Dhw9WpUyfnJAlJHn74YTVo0MCqLJQuXdrucAAA8Lvmhmv2w/Pis88+syr0M2bMsPokbNiwQc8++6zVgbFbt27OShKMkiVLWhsAAAHFnTFJwrWaFrx58cUXrWqCuQk3atSoof3791t9AFObJPjbdAIAACADxMbGKjjY8zJvmh1caahq+FUlAQCAgOTK/NENZuSg6YMQGRlpNTesX7/e6rTYs2fqh96TJAAAEIAzLv7f//2fXnvtNfXt21fR0dFWX4QnnnhCgwcPTvUxSBIAAAhAefPmtWY3Nlt6kSQAAOBrLtZuAAAAAbTAE6MbAACAV1QSAADwNZczKwkkCQAA+JrLmUkCzQ0AAMArKgkAAPia25mVBJIEAAB8zUWSAAAAAqiSQJ8EAADgFZUEAAB8zeXMSgJJAgAAvuZ2ZpJAcwMAAPCKSgIAAL7mcmYlgSQBAABfczkzSaC5AQAAeEUlAQAAX3O75UQkCQAA+JqL5gYAABBAqCQAAOBrLmdWEkgSAADwNTdJAgAACKBKAn0SAACAV1QSAADwNTdDIAEAgDc0NwAAgEAS5HY7tAYCAIBDXJz4QoYcJ+dj7ygzBWxzw94aze0OwbHK/fa9hpfuZHcYjvSv/dM1r8gjdofhSK2OzVTCib12h+FY2QqV08Wlk+0Ow5FyNuzu+w9x09wAAAACSMBWEgAA8BdulzNb9qkkAACQGaMbXBmwpUGZMmUUFBR01davX79UH4NKAgAAAWj16tVKTExMfrx582Y1a9ZMHTp0SPUxSBIAAAjAjosREREej0eMGKHy5curUaNGqT4GSQIAAL7mypg+CfHx8daWUlhYmLVdz6VLlzRt2jQNGDDAanJILfokAADgkD4JUVFRCg8P99jMvhv58ssvdebMGXXvnrbhnlQSAABwiEGDBlnVgJRuVEUwJk6cqBYtWqh48eJp+jySBAAAHLJ2Q1gqmhautH//fi1cuFD/+9//0vx5JAkAAPia2755EiZNmqTChQurVatWaX4vfRIAAAhQLpfLShK6deum0NC01wWoJAAAEKBLRS9cuFAHDhxQz5490/V+kgQAAHzNZU9zQ/PmzXUziz3T3AAAALyikgAAgK+5nblUNEkCAAC+5mIVSAAAEECoJAAA4GNum0Y33CySBAAAfM3lzOYGkgQAAHzN7cxKAn0SAACAV1QSAADwNRfNDQAAwBuHdlykuQEAAHhFJQEAAF9z0dwAAAC8YXQDAAAIJFQSAADwNRfNDQAAwAumZcZ13dKni27p28Vj36V9B3Wo7WO2xeQUtTs3Ve3O9yt/yQjr8fFdh7Rs9BztWbzR7tAcp/xTbVX51Ue076P52vraVLvD8XsxMbH6vwlTtWjprzp1+owqVyyvgc8+oRpVKtkdmt9LdLk0fu7Pmrdii06ei1FE/jxqe08N9W5VX0FBQXaHh1QiSchEl3b9riO9X05+7E5MtDUepzh/5JR+enuWTu07av1xqfmPe9VhwgB93PIVndh12O7wHCP8tnKK7NpU57bstzsUxxg8YrR27/1dUYNfUOFCBfX1gh/V+5lX9NX0D1UkopDd4fm1SfNXaPaS9Xq9R2uVL15IW/cf1ZBJ85QnZ5gebVpXWY7Lmc0NdFzMRCYpSDx5OnlznTlnd0iOsGvReu35aaNO/37MShQWj5ytS7FxKlG7gt2hOUZIrjDdNra/Nj0/QQlnYuwOxxHi4uO1cMkyDej3mO64rYYiSxZXv8c6W18/nTPP7vD83sY9h9S41q1qWLOCShTKr2Z1KqtetbLavO+IsiSXO2O2TEaSkImyRZZQ5KKZKjV/iiJGDFRI0T/L50i9oOAgVW1zt7LlDNPhdbvtDscxqo/oqeiF63Vy6Wa7Q3GMxMuJSkx0KSx7No/9YWHZtW7TFtvicopa5Utq5fb92n/0pPV4x8FjWr/roOpXL6csOwTSnQFbJqO5IZPE/bZdl14bqYTfDymkUAHd0qezik95T4f+9rjcsRftDs/vRVQqpe5zhio0LJsuxcTp8ydG0dSQSsXa11O+mmX0ywOv2h2Ko+TOnUu1qlfR+MkzVa50pAoWyK9vFy7Rxs3bFVmimN3h+b2eLeopJi5e7Qd/pJDgYKuPQv/2jdTq7up2hwYnJQnbtm3TihUrVK9ePVWuXFnbt2/X6NGjFR8fr86dO6tJkybXfb95ndlSCgsLk7+5uGz1Xw927lP8b9sVuWCa8jzQSOfnfGdnaI5wcu8f+rjFKwrLm1OVW96lNu8+qWn/fJNE4QZyFC+gam9208qOb8kVn2B3OI4T9doLGhw1Sk3ad1ZISLCqVKygFvc30tYdVLFu5Ps12/Ttyi2K6tXO6pNgKgkjP134/zsw1lSW43JmnwRbk4TvvvtO7dq1U548eRQbG6s5c+aoa9euqlWrllwul5o3b67vv//+uolCVFSUhg0b5rFvyJAh6ir/5jofo0v7Dyk0srjdoTiCKyFRp/cfs74/uvl3Fa9VTnV7PKD5r3xid2h+LbxWOYVFhKvBD28l7wsODVGBepVVumdzzS/VxbF/vDKD6X8wecxIxV6Ms0Y6RBQqoOdfi1LJ4kXtDs3vjfr8R/VoUU8P3lnVenxrycI6cvKcPpn/a5ZMEtwO/e/M1iTh9ddf14svvqg333xTs2bN0qOPPqo+ffpo+PDh1vODBg3SiBEjrpskmNcMGDDgqkrC4S/ayJ8F5cyhbKWK6cLXi+wOxbF9E0KuaCvG1U4s3awljV702Ffr/Sd1Yfcf2vPBXBKEVMqVM4e1nT13XstXrdWAvj3tDsnvxV1KUPAVQx2Dg4Pk4nfOUWxNErZs2aKpU/8cq92xY0d16dJF//jHP5Kf79SpkyZNmnTdY5iEwB+bF65U4Pneil2yQpf/iFZIREHd0q+rGUisC/N/sjs0v9f4pX9acyKc++OEsufOqWrt7lHpu6toZpe37Q7N7yXGxOnC9kOe+2LjlXD6wlX7cbVfVq6V2+1WmciSOnDoD707ZqLKRpZU+1bN7Q7N7zWseas+nrdcRQvk+7O54cAxTfthldrVr6UsyeXM5Mj2PglJk2oEBwcrR44cCg8PT34ub968Onv2rAJBaJEIFX77FYXkz6vE02cVt26LDnd6Rq7TgfHv86XchfKp7XtPKk/h/Io/H6vo7QetBGHfMnrqw7fOX4jR++Mn6djxEwrPl1fNGjXQ0090U7ZQ2/90+r2BjzbTmC+XKmr6Ap06H2v1RXio4e16ok0DZUkuZlxMszJlymjXrl0qX7689fjXX39VZGRk8vMHDhxQsWKB0Ys4+qW/2oSRNvNemmB3CAFlxd/fsDsEx3iwaUNrQ9rlzhGmlx5uZm1wLluTBNP/IDHFrIPVq3sOjZk/f/4NRzcAAOD3XDQ3pNmTTz553effeou7bwBAAHA5M0lgxkUAAOAVSQIAAD7mdrszZEurw4cPWxMTFixYUDlz5lSNGjW0Zs2aVL+fLroAAARgc8Pp06dVv3593XfffVYfv4iICGuwwC233JLqY5AkAAAQgEnC22+/rVKlSnnMN1S2bNk0HYPmBgAAHCI+Pl7nzp3z2K5cvyjJ3Llzdccdd6hDhw4qXLiwbr/9dk2YkLYh5SQJAABkwtoN7gzYzHpFZtLBlJvZ583evXs1btw43XrrrVqwYIE17cDTTz+tKVOmpDpumhsAAHBIc8Oga6xX5PUjXS6rkpA0nYCpJGzevFnjx49Xt27dUvV5JAkAADhEWBrWKzIzFlet+ucqnEmqVKmiL774ItWfR5IAAICvuTL/I83Ihh07dnjs27lzp0qXLp3qY5AkAADgY24bRjc899xzuueee6zmBrPS8qpVq/TRRx9ZW2rRcREAgABUt25dzZkzRzNnzrTWRnrjjTf0/vvvq1OnTqk+BpUEAAACdO2G1q1bW1t6kSQAABCAfRIyAs0NAADAKyoJAAAEYMfFjECSAACAr7nkSCQJAAD4mNuhlQT6JAAAAK+oJAAA4GsuORJJAgAAPuZ2aJJAcwMAAPCKSgIAAL7mkiORJAAA4GNuhyYJNDcAAACvqCQAAOBrLjkSSQIAAD7mJkkAAACBlCTQJwEAAHhFJQEAAB9zO7SSQJIAAICvuYPkREFut9uZS1MBAOAQxxo3zpDjFFm8WJkpYCsJF5dOtjsEx8rZsLs6lG5ndxiONHv/V5pX5BG7w3CkVsdmKjR7CbvDcKzLlw5z/m7i3Pmam+YGAADgjdvlzOYGRjcAAACvqCQAAOBjbpobAACAN26Hjm6guQEAAHhFJQEAAB9z09wAAAACaXQDSQIAAD7mdui0hfRJAAAAXlFJAADAx9wObW6gkgAAQCYkCe4M2NJi6NChCgoK8tgqV66cpmNQSQAAIEBVq1ZNCxcuTH4cGpq2yz5JAgAAAdpxMTQ0VEWLFk3/+zM0GgAA4LM+CfHx8daWUlhYmLV5s2vXLhUvXlw5cuRQvXr1FBUVpcjIyFR/Hn0SAABwiKioKIWHh3tsZp83d911lyZPnqzvvvtO48aN0759+3Tvvffq/Pnzqf48KgkAADhk7YZBgwZpwIABHvuuVUVo0aJF8vc1a9a0kobSpUvrs88+02OPPebbJCExMVFz5szRtm3brMdVqlRR+/bt09wpAgCAQOfOoGmZr9e0cCP58+dXxYoVtXv37lS/J11X9C1btqht27Y6evSoKlWqZO17++23FRERoa+//lrVq1dPz2EBAICPXLhwQXv27FGXLl182yehV69e1rCKQ4cOad26ddZ28OBBq5zx+OOPp+eQAAAELJc7KEO2tHjhhRe0ZMkS/f7771q+fLn+9re/KSQkRI888ohvKwkbNmzQmjVrdMsttyTvM98PHz5cdevWTc8hAQAIWO4M6pOQFuZG3iQEJ0+etCr9DRo00IoVK6zvfZokmDaNY8eOWdWElKKjo1WhQoX0HBIAgIDltmFa5lmzZt30MdLV3GCGWzz99NP6/PPPrUzFbOb7Z5991uqbcO7cueQNAAA4U7oqCa1bt7a+duzY0ZoL2nD//+mk2rRpk/zYPGdGQQAAkJW53VkoSfjpp58yPhIAAAKU26GrQKYrSWjUqFHGRwIAAJyfJCxduvS6zzds2DC98QAAEHBcNoxusC1JaNy48VX7kvomGPRDAADA3iGQGSFdoxtOnz7tsZmhj2YBCTNHwvfff5/xUQIAAGdUEsyqU1dq1qyZsmfPbi08sXbt2oyIDQCAgOB26OiGDF0qukiRItqxY0dGHjJgJLpcGvPlErUcOFZ39R2p1q+M00ffLEseOopra9/3IUXNfUdTt8zSx2un6MWPBql4uRJ2h+VI5Z9qq1bHZqrqG13tDsVR+jzZTbt3rtCFc3u0fNnXqnvHbXaH5BicO/umZbatkrBp0yaPx+ZCd+TIEY0YMUK33ZY1fwFuZNL8FZq9ZL1e79Fa5YsX0tb9RzVk0jzlyRmmR5sylfX1VLuruhZM/Va7N+5SSGiIHn2pi17971A9d39/xV+Mtzs8xwi/rZwiuzbVuS377Q7FUTp0aKt3Rg5R334DtWr1ej39VC99O2+6qlZvqOPHT9odnl/j3DlfuioJJhG4/fbbra9J37ds2VKXLl3Sxx9/nPFRBoCNew6pca1b1bBmBZUolF/N6lRWvWpltXnfEbtD83vDuw3T4s9/1KFdB7V/2+8a8/xoRZQsrHI1ytsdmmOE5ArTbWP7a9PzE5RwJsbucBzluWd66+OJMzRl6mfatm2XdcGLjb2oHt0ftjs0v8e58+y4mBGbI5KEffv2ae/evdZXs+3fv1+xsbHWKlOVK1fO+CgDQK3yJbVy+37tP/pn9rzj4DGt33VQ9auXszs0x8mVN5f19cKZC3aH4hjVR/RU9ML1Orl0s92hOEq2bNlUu3ZNLfrxZ4/K6aIfl+nuu+vYGpu/49x5Mi3LGbE5ormhdOnSGR9JgOvZop5i4uLVfvBHCgkOtvoo9G/fSK3urm53aI5ihtp2H9JL21dv1cGdB+wOxxGKta+nfDXL6JcHXrU7FMcpVKiAQkNDFX3shMf+6OjjqlyJStb1cO4CY56EdHdcNGtUm3UazKqPZmvbtq1+/vmvjDG1Ll68qGXLlmnr1q1XPRcXF6epU6de9/3x8fEeC0qZzezzN9+v2aZvV25RVK92mvlqD73Ro7Wmfr9Sc5d79u/A9fV64wmVqhipUf3fsTsUR8hRvICqvdlNG/qOkSs+we5wAGSFJGHatGm6//77lStXLms1SLPlzJlTTZs21YwZM1J9nJ07d6pKlSrWDI01atSwpns2HSCTnD17Vj169LjhipRmSGbKzezzN6M+/1E9WtTTg3dW1a0lC6t1vRrqfP+d+mT+r3aH5hiPvf64ajetq2GPvKpT/7/ZBtcXXqucwiLC1eCHt9Ti8DRrK1i/qsr0esD6XsHOvLvJLCdOnNLly5dVuEghj/2FC0fo6LHjtsXlBJy7LNwnYfjw4fr3v/+tTz/9NDlJMN+b0Q1vvPFGqo/z8ssvq3r16tZkTGboZN68eVW/fn0dOJD6MvKgQYOsZCLlZvb5m7hLCQpOMSulERwcJJeLIZCpTRDufOBuK0GIPhhtdziOcWLpZi1p9KJ+bjoweTuzfo8Of/GL9b34/buuhIQErVu3SU3ua+DR5GUer1jBfDDXw7nLwkMgTafFpCWhUzJNDq+88kqqj2M6Oi5cuFCFChWytq+//lp9+/bVvffea600mTt37hseIywszNqudFH+pWHNW/XxvOUqWiCfNQRyx4FjmvbDKrWrX8vu0PxerzefUIO2DfXv3m8pLuai8kfkt/bHnovVpfhLdofn1xJj4nRh+yHPfbHxSjh94ar98G7U6AmaNHGU1q7bpNXWML7eyp07pyZP+dTu0Pwe58750pUklCpVSosWLbL6IqRkLvjmubT0RzAdW1JmmePGjVP//v2tpoe0NF34u4GPNtOYL5cqavoCnTofq4j8efRQw9v1RJu/smx490CXltbXYZ+95bHfDIU0QyMBX5o9e64iChXQ0MEvqGjRCG3cuEWtWndWdLRnhzxcjXP3F3dWShKef/55q4lhw4YNuueee6x9v/zyiyZPnqzRo0en+jhmuOSaNWusfgkpffDBB8mViUCRO0eYXnq4mbUhbTqUbmd3CAFlxd9T3ySIP40dN9nakHacO2ePbkhXktCnTx8VLVpU7777rj777DNrn7nQm34J7dql/g/63/72N82cOVNdunS56jmTKLhcLo0fPz49IQIAgMxOEkxv1bfeeks9e/a0hi7eDNPB8HqdDMeOHWttAAA4mduhlYQ0j24wfQjMyAaTLAAAgBtzZdDmiCGQZj4EM5kSAAAIXOnqk9CiRQsNHDhQv/32m+rUqXPVUMVA6nAIAMDNciso6yQJZi4D47333rvqOTOMMTEx8eYjAwAgQLgcOgYyXUmCGXUAAABSx5UVKglm8iMziVLr1q2tx2ZkQsrFlEynxtdff105cuTI+EgBAID/JglTpkzRvHnzkpMEM5dBtWrVrMWdjO3bt1vzJwwYMMA30QIA4EBuh1YS0jS6Yfr06Xr88cc99pmpk806C2YbOXKkZs+endExAgDgaK6sMARy9+7d1pLOSUyzQnDwX4e48847tXXr1oyNEAAA2CJNScKZM2c8+iAcP35cZcqU8ejQmPJ5AAAgq7khI7abMWLECGsE4rPPPuubJKFkyZLavHnzNZ/ftGmT9RoAAOA/zQ2rV6/Whx9+qJo1a6bpfWlKElq2bKnBgwcrLi7O68iHYcOGqVWrVmkKAAAA+M6FCxfUqVMnTZgwQbfccovvRje88sor1qqPlSpVUv/+/VWxYkVr/44dO6yRDmY9B/MaAADwl4zqdGia9K9s1g8LC7O2a+nXr591A3///ffrzTff9F2SUKRIES1fvtxaKtpMy+x2/zmFlGnjaNasmbVio3kNAADI+CGQUVFRVtU+pSFDhmjo0KFeXz9r1iytW7fOam7IlBkXy5Ytq++++06nTp2yRjsYFSpUUIECBdIVAAAASB0zieGVcxFdq4pw8OBBPfPMM/rhhx/SPclhuqZlNkxSYIY8AgCA63Nl0FxKN2paSGnt2rWKjo5W7dq1k/eZtZWWLl1qdREwzRYhISG+SRIAAID/rt3QtGlTa7XmlHr06KHKlSvr5ZdfvmGCYJAkAADgY24bPjNv3ryqXr26x77cuXOrYMGCV+3PkCGQAAAg66CSAACAj7nkHxYvXpym15MkAADgY66gLLAKJAAAyDqoJAAAEIAdFzMCSQIAAFmkT0Ja0dwAAAC8opIAAIBDZlzMbCQJAAAE4IyLGYHmBgAA4BWVBAAAfMwtZyJJAADAx1zObG1QkNvtdmqCAwCAI0wu0TlDjtP98DRlpoCtJFxcOtnuEBwrZ8PunL+bOHfzijxidxiO1OrYTIVmL2F3GI51+dJhzt9NnDtksSQBAAB/4ZYzkSQAAOBjLof2SWAIJAAA8IpKAgAAPuaSM5EkAADgYy45E80NAADAKyoJAAD4mNuhHRdJEgAA8DGXnInmBgAA4BWVBAAAfMwlZyJJAADAx9xyJpIEAAB8zOXQjov0SQAAAF5RSQAAwMdcciaSBAAAfMwlZ6K5AQAAeEUlAQAAH3PLmUgSAADwMRejGwAAgL8YN26catasqXz58llbvXr1NH/+/DQdgyQBAIBM6LjoyoAtLUqWLKkRI0Zo7dq1WrNmjZo0aaJ27dppy5YtqT4GzQ0AAARgn4Q2bdp4PB4+fLhVXVixYoWqVauWqmOQJAAAEOASExM1e/ZsxcTEWM0OqUWSAACAj7kyqJYQHx9vbSmFhYVZmze//fablRTExcUpT548mjNnjqpWrZrqz6NPAgAADumTEBUVpfDwcI/N7LuWSpUqacOGDVq5cqX69Omjbt26aevWramOm0oCAAAO6ZMwaNAgDRgwwGPftaoIRvbs2VWhQgXr+zp16mj16tUaPXq0Pvzww1R9HkkCAAAOEXadpoXUcLlcVzVXXA9JAgAAAbh2w6BBg9SiRQtFRkbq/PnzmjFjhhYvXqwFCxak+hgkCQAABOCMi9HR0eratauOHDli9V0wEyuZBKFZs2apPgZJAgAAAWjixIk3fQxGN2SSRJdLY75copYDx+quviPV+pVx+uibZXK7nbrsR+bh3GWc8k+1VatjM1X1ja52h+IofZ7spt07V+jCuT1avuxr1b3jNrtDcgzO3V9DIDNiy2wkCZlk0vwVmr1kvQY+2lz/e723nnnoPk3+bqVm/rjG7tD8HucuY4TfVk6RXZvq3Jb9dofiKB06tNU7I4fojTffU927HtTGTVv17bzpiogoaHdofo9z9xd3Bm2ZjSQhk2zcc0iNa92qhjUrqESh/GpWp7LqVSurzfuO2B2a3+Pc3byQXGG6bWx/bXp+ghLOxNgdjqM890xvfTxxhqZM/Uzbtu1S334DFRt7UT26P2x3aH6Pc+d8JAmZpFb5klq5fb/2Hz1pPd5x8JjW7zqo+tXL2R2a3+Pc3bzqI3oqeuF6nVy62e5QHCVbtmyqXbumFv34c/I+08y16MdluvvuOrbG5u84d/Yv8JQR/Lrj4sGDBzVkyBB98skncrqeLeopJi5e7Qd/pJDgYKudvX/7Rmp1d3W7Q/N7nLubU6x9PeWrWUa/PPCq3aE4TqFCBRQaGqroYyc89kdHH1flSuVti8sJOHee7OhPEPBJwqlTpzRlypTrJgnXmsfa33y/Zpu+XblFUb3aqXzxQtbd8MhPFyoifx61vaem3eH5Nc5d+uUoXkDV3uymlR3fkis+we5wADiMrUnC3Llzr/v83r17b3gMM2f1sGHDPPaZ6sPLTcrIn4z6/Ef1aFFPD97558Iat5YsrCMnz+mT+b9yobsBzl36hdcqp7CIcDX44a3kfcGhISpQr7JK92yu+aW6SC5n3uFkhhMnTuny5csqXKSQx/7ChSN09Nhx2+JyAs6dJ6f+V2ZrktC+fXsFBQVddyibeT4981i7Vs6UP4m7lKDgK/4twcFBcvEH+oY4d+l3YulmLWn0ose+Wu8/qQu7/9CeD+aSINxAQkKC1q3bpCb3NdDcuQuS/yaZx2PHTbI7PL/GufNkR38CxycJxYoV09ixY9WuXTuvz5uVq8yCFOmZx/qi/EvDmrfq43nLVbRAvj9L5geOadoPq9Sufi27Q/N7nLv0S4yJ04Xthzz3xcYr4fSFq/bDu1GjJ2jSxFFau26TVq9er6ef6q3cuXNq8pRP7Q7N73Hu/kKfhHQwCcDatWuvmSTcqMrgJAMfbaYxXy5V1PQFOnU+1mpPf6jh7XqiTQO7Q/N7nDvYafbsuYooVEBDB7+gokUjtHHjFrVq3VnR0Z4d8nA1zp3zBbltvAr//PPPiomJ0YMPPuj1efPcmjVr1KhRozQf++LSyRkQYdaUs2F3zt9NnLt5RR6xOwxHMjNBhmYvYXcYjnX50mHO302cO197rkzGzA0x6vdZyjKVhHvvvfe6z+fOnTtdCQIAAP7EJWdiMiUAAOC8eRIAAAgEbjouAgAAb2huAAAAAYVKAgAAPuaiuQEAAHjjzBSB5gYAAHANVBIAAPAxl0NrCSQJAAD4mEvORJIAAICPuR1aSaBPAgAA8IpKAgAAPuaSM5EkAADgY26aGwAAQCChkgAAgI+55EwkCQAA+JjLTXMDAAAIIFQSAADwMbeciUoCAACZMC2zKwO2tIiKilLdunWVN29eFS5cWO3bt9eOHTvSdAySBAAAAtCSJUvUr18/rVixQj/88IMSEhLUvHlzxcTEpPoYNDcAABCA8yR89913Ho8nT55sVRTWrl2rhg0bpuoYJAkAAGSBIZBnz561vhYoUCDV7yFJAADAIUtFx8fHW1tKYWFh1nbdz3e59Oyzz6p+/fqqXr16qj+PPgkAADhEVFSUwsPDPTaz70ZM34TNmzdr1qxZafo8KgkAADikT8KgQYM0YMAAj303qiL0799f33zzjZYuXaqSJUum6fNIEgAAcEifhLBUNC0kcbvdeuqppzRnzhwtXrxYZcuWTfPnkSQAABCA+vXrpxkzZuirr76y5ko4evSotd80UeTMmTNVxyBJAADAx9w2rN0wbtw462vjxo099k+aNEndu3dP1TFIEgAAcMjohsxOTBjdAAAAvKKSAABAFphMKT2C3HY0lAAAkIW0jmyVIcf55sA8ZaaArSTEjulvdwiOlavfB9pbo7ndYThSud++V4fS7ewOw5Fm7/9KodlL2B2GY12+dJjzdxPnDlksSQAAICt3XMwIJAkAAPiY26Et+yQJAAD4mEvOxBBIAADgFZUEAAAcssBTZiNJAADAx1wOTRJobgAAAF5RSQAAwMfcjG4AAADe0NwAAAACCpUEAAB8zO3QSgJJAgAAPuZyaJ8EmhsAAIBXVBIAAPAxt5yJJAEAAB9zOTRNIEkAAMDHXA5NEuiTAAAAvKKSAACAj7kdOrqBJAEAAB9z0dwAAAACCZUEAAB8zO3QSgJJAgAAPuZ2aJ8EmhsAAIBXVBIAAPAxF80NAADAG5obAABAQCFJAAAgE5obXBmwpdXSpUvVpk0bFS9eXEFBQfryyy/T9H6SBAAAMmEIpDsD/pdWMTExqlWrlsaMGZOuuOmTAACAj7ls6pPQokULa0svkoRM0nLSzzpyPu6q/R1rlNSg+6rYEpNT3NKni27p28Vj36V9B3Wo7WO2xeQU7fs+pLserKcS5UvqUly8dqzdrukjpuqPvYftDs1R+jzZTc8P6KOiRSO0adNWPfPsa1q9ZoPdYTkC587ZSBIyybR/3uWRSe4+eUF9vlynZrcWsTUup7i063cd6f1y8mN3YqKt8ThFtbuqa8HUb7V74y6FhIbo0Ze66NX/DtVz9/dX/MV4u8NzhA4d2uqdkUPUt99ArVq9Xk8/1UvfzpuuqtUb6vjxk3aH59c4dxk/42J8fLy1pRQWFmZtvkCfhExSIFd2Fcodlrz9/PsJlQrPqTolbrE7NEcwSUHiydPJm+vMObtDcoTh3YZp8ec/6tCug9q/7XeNeX60IkoWVrka5e0OzTGee6a3Pp44Q1OmfqZt23ZZF7zY2Ivq0f1hu0Pze5y7v5ibxIzYoqKiFB4e7rGZfQFZSThx4oQ++eQT/frrrzp69Ki1r2jRorrnnnvUvXt3RUREKBAlJLr07fYj6nx7aau3KW4sW2QJRS6aKfelS4rbuE2n3p+oxKPH7Q7LcXLlzWV9vXDmgt2hOEK2bNlUu3ZNjfj3Bx7j3Rf9uEx3313H1tj8HefONwYNGqQBAwZ47PNVFcHWSsLq1atVsWJF/ec//7EyoYYNG1qb+d7sq1y5stasWaNA9NOeaJ2Pv6w2VYrZHYojxP22XcdfG6mjfV7RiTf+o2wliqj4lPcUlCun3aE5iklIuw/ppe2rt+rgzgN2h+MIhQoVUGhoqKKPnfDYHx19XEWLBOZNTEbh3PlmdINJCPLly+ex+TJJsK2S8NRTT6lDhw4aP378VXfTJtt88sknrdeYKkN62mf82Zdb/1D90gVVOE8Ou0NxhIvLVv/1YOc+xf+2XZELpinPA410fs53dobmKL3eeEKlKkbqtX8MsjsUIMtx2TS64cKFC9q9e3fy43379mnDhg0qUKCAIiMj/beSsHHjRj333HNey+1mn3nO/ENuJLPbZ27WH+cuauXBk2pfrYTdoTiW63yMLu0/pNDI4naH4hiPvf64ajetq2GPvKpTR7NWh7GbceLEKV2+fFmFixTy2F+4cISOHqO563o4d/7BVORvv/12azNMU4X5fvDgwal6v21Jgul7sGrVqms+b54rUqRIqtpnzp4967GZff5q7tY/VCBndt1b1vM/HKReUM4cylaqmBKPn7I7FMckCHc+cLeVIEQfjLY7HEdJSEjQunWb1OS+Bh43MebxihVrbY3N33Hu/GMypcaNG1vV+Su3yZMn+3dzwwsvvKDHH39ca9euVdOmTZMTgmPHjmnRokWaMGGC3nnnnRse51pDP2Lln+Wmr7b9odZViis0mIElqVXg+d6KXbJCl/+IVkhEQd3Sr6uU6NKF+T/ZHZrf6/XmE2rQtqH+3fstxcVcVP6I/Nb+2HOxuhR/ye7wHGHU6AmaNHGU1q7bpNXWML7eyp07pyZP+dTu0Pwe587+5oabZVuS0K9fPxUqVEijRo3S2LFjlfj/x72HhISoTp06VpbTsWNHBZKVB07p6Pk4ta9KmTwtQotEqPDbrygkf14lnj6ruHVbdLjTM3KdPmt3aH7vgS4tra/DPnvLY78ZCmmGRuLGZs+eq4hCBTR08AvWhEAbN25Rq9adFR3t2SEPV+PcOV+Q2w/WrzRlKTMc0jCJgxk6c7Nix/TPgMiyplz9PtDeGs3tDsORyv32vTqUbmd3GI40e/9XCs1OX530unzpMOfvJs6dr5Ur9GefgJu198R6ZbkZF01SUKwYwwEBAIHJ7XbJifwiSQAAIJC5Mmha5sxG7zkAAOAVlQQAAHzMbX/3v3QhSQAAwMdcNDcAAIBAQiUBAAAfc9PcAAAAAmnGRZobAACAV1QSAADwMbdDOy6SJAAA4GNumhsAAEAgoZIAAICPuWhuAAAAgdTcQJIAAICPuRyaJNAnAQAAeEUlAQAAH3M7tJJAkgAAgI+5HNpxkeYGAADgFZUEAAB8zE1zAwAA8IbRDQAAIKBQSQAAwMfcDu24SJIAAICPuWhuAAAAgYRKAgAAPuZ2aCWBJAEAAB9zO7RPAs0NAABkQiXBnQFbeowZM0ZlypRRjhw5dNddd2nVqlWpfi9JAgAAAerTTz/VgAEDNGTIEK1bt061atXSAw88oOjo6FS9nyQBAIAArSS899576t27t3r06KGqVatq/PjxypUrlz755JNUvZ8kAQAAH3Nn0JYWly5d0tq1a3X//fcn7wsODrYe//rrr6k6Bh0XAQBwiPj4eGtLKSwszNqudOLECSUmJqpIkSIe+83j7du3p+4D3chUcXFx7iFDhlhfkTacu5vD+Us/zl36ce4yljmXVxYYzD5vDh8+bD2/fPlyj/0vvvii+84770zV5wWZ/7u5vAZpce7cOYWHh+vs2bPKly+f3eE4Cufu5nD+0o9zl36cO/sqCaa5wfQ/+Pzzz9W+ffvk/d26ddOZM2f01Vdf3fDz6JMAAIBDhIWFWclWys1bgmBkz55dderU0aJFi5L3uVwu63G9evVS9Xn0SQAAIEANGDDAqhzccccduvPOO/X+++8rJibGGu2QGiQJAAAEqH/+8586fvy4Bg8erKNHj+q2227Td999d1VnxmshSchkpixkJrW4VnkI18a5uzmcv/Tj3KUf585+/fv3t7b0oOMiAADwio6LAADAK5IEAADgFUkCAADwiiQBAAB4RZKQiW5mTe+sbOnSpWrTpo2KFy+uoKAgffnll3aH5BhRUVGqW7eu8ubNq8KFC1uzru3YscPusBxj3LhxqlmzZvKkNWYCmvnz59sdliONGDHC+u/32WeftTsUpAFJgkPW9M7KzMQf5nyZJAtps2TJEvXr108rVqzQDz/8oISEBDVv3tw6p7ixkiVLWhc3s5LemjVr1KRJE7Vr105btmyxOzRHWb16tT788EMr4YKzMAQyk5jKgbmj++CDD5KnxixVqpSeeuopDRw40O7wHMPcicyZM8djHnKknplUxVQUTPLQsGFDu8NxpAIFCmjkyJF67LHH7A7FES5cuKDatWtr7NixevPNN63JfMysf3AGKgmZICPW9AYygllkJ+lCh7QxS+7OmjXLqsKkdt57yKpktWrVyuPvH5yDGRczQYas6Q3cJFO9Mu3B9evXV/Xq1e0OxzF+++03KymIi4tTnjx5rEpW1apV7Q7LEUxSZZpXTXMDnIkkAchCd3SbN2/WsmXL7A7FUSpVqqQNGzZYVRiz5K5ZLMc015AoXN/Bgwf1zDPPWH1hTGdtOBNJQiYoVKiQQkJCdOzYMY/95nHRokVtiwtZh5m3/ZtvvrFGipjOeEg9s9xuhQoVrO/Nsrvmrnj06NFWRzxcm2liNR2zTX+EJKaian4HTd+s+Ph46+8i/Bt9EjJBRqzpDaSH6ZdsEgRTIv/xxx9VtmxZu0NyPPPfrrnA4fqaNm1qNdWYKkzSZpYr7tSpk/U9CYIzUElwyJreWb139O7du5Mf79u3z/ojYzrfRUZG2hqbE5oYZsyYoa+++sqaK8EsFWuEh4crZ86cdofn9wYNGqQWLVpYv2fnz5+3zuXixYu1YMECu0Pze+b37cq+L7lz51bBggXpE+MgJAkOWdM7KzPj0++77z6PhMswSdfkyZNtjMwZkwEZjRs39tg/adIkde/e3aaonMOUy7t27aojR45YiZUZ528ShGbNmtkdGpApmCcBAAB4RZ8EAADgFUkCAADwiiQBAAB4RZIAAAC8IkkAAABekSQAAACvSBIAAIBXJAkAvDITVeXPn9/uMADYiCQB8HNmZsSgoKDkzUxr++CDD2rTpk2pPsbQoUOtWT4BIC1IEgAHMEmBmRrYbGZhsNDQULVu3drusAAEOJIEwAHCwsKsZcXNZioCAwcO1MGDB631QIyXX35ZFStWVK5cuVSuXDm99tprSkhISG42GDZsmDZu3JhcjUha8+LMmTN64oknrDVEcuTIYS28Y5aUTsmsVVClShXlyZMnOVkBkDWwwBPgwFUxp02bpgoVKlhND0kr7pkLf/Hixa3leXv37m3te+mll6zFxTZv3mwtKLZw4ULr9WaxIrPksVnh0KxuaI5Xvnx5bd261WMJ39jYWL3zzjv673//q+DgYHXu3FkvvPCCpk+fbtu/H0DmIUkAHMDc3Zs7ecMsMV6sWDFrn7lwG6+++mrya8uUKWNdyGfNmmUlCWZJaPNe00RhKhFJvv/+e61atUrbtm2zqhCGqUKkZKoR48ePtxIIo3///nr99dcz5d8MwH4kCYADmKWyk5Z9Pn36tMaOHWtVAcxFvnTp0vr000/1n//8R3v27LEqDZcvX1a+fPmue8wNGzaoZMmSyQmCN6b5IilBMExyYpZPBpA10CcBcIDcuXNbzQtmq1u3rj7++GOrojBhwgT9+uuv6tSpk1q2bGlVF9avX69//etfunTp0nWPaSoMN5ItWzaPx6Y/A6vLA1kHlQTAgczF2jQ1XLx4UcuXL7eqCSYxSLJ//36P12fPnl2JiYke+2rWrKlDhw5p586d160mAMi6SBIAB4iPj9fRo0eTmxs++OADq1mhTZs2OnfunA4cOGD1QTBVhnnz5mnOnDke7zf9FPbt25fcxGA6NTZq1EgNGzbUQw89pPfee8+qUmzfvt1KQMwoBgCguQFwADMywfQHMNtdd92l1atXa/bs2WrcuLHatm2r5557zupUaIZHmsqCGQKZkkkEzIXf9G2IiIjQzJkzrf1ffPGFlVg88sgjqlq1qtXR8cqKA4CsK8hNAyMAAPCCSgIAAPCKJAEAAHhFkgAAALwiSQAAAF6RJAAAAK9IEgAAgFckCQAAwCuSBAAA4BVJAgAA8IokAQAAeEWSAAAAvCJJAAAA8ub/AfYHLDT7ZOdbAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] diff --git a/examples/monopartite_twitch_gamers.ipynb b/examples/monopartite_twitch_gamers.ipynb index 0bf13af..2956c5c 100644 --- a/examples/monopartite_twitch_gamers.ipynb +++ b/examples/monopartite_twitch_gamers.ipynb @@ -6,13 +6,18 @@ "metadata": {}, "outputs": [], "source": [ + "import os\n", + "\n", + "from dotenv import load_dotenv\n", "from pyspark.sql import SparkSession\n", "import requests\n", "from io import BytesIO\n", "from zipfile import ZipFile\n", "from neo4j_parallel_spark_loader.monopartite import group_and_batch_spark_dataframe\n", "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n", - "from neo4j_parallel_spark_loader.visualize import create_ingest_heatmap" + "from neo4j_parallel_spark_loader.visualize import create_ingest_heatmap\n", + "\n", + "load_dotenv()" ] }, { @@ -60,20 +65,16 @@ } ], "source": [ - "username = \"NEO4J_USER\"\n", - "password = \"NEO4J_PASSWORD\"\n", - "url = \"NEO4J_URL\"\n", - "dbname = \"NEO4J_DATABASE\"\n", "spark_executor_count=5\n", "\n", "spark = (\n", " SparkSession.builder\n", " .appName(\"TwitchGamers\")\n", - " .config(\"neo4j.url\", url)\n", - " .config(\"url\", url)\n", - " .config(\"neo4j.authentication.basic.username\", username)\n", - " .config(\"neo4j.authentication.basic.password\", password)\n", - " .config(\"neo4j.database\", dbname)\n", + " .config(\"neo4j.url\", os.environ.get(\"NEO4J_URI\"))\n", + " .config(\"url\", os.environ.get(\"NEO4J_URI\"))\n", + " .config(\"neo4j.authentication.basic.username\", os.environ.get(\"USERNAME\"))\n", + " .config(\"neo4j.authentication.basic.password\", os.environ.get(\"NEO4J_PASSWORD\"))\n", + " .config(\"neo4j.database\", os.environ.get(\"NEO4J_DATABASE\"))\n", " .getOrCreate()\n", ")" ] diff --git a/examples/predefined_components_reddit_threads.ipynb b/examples/predefined_components_reddit_threads.ipynb index bbb4b49..c272dfc 100644 --- a/examples/predefined_components_reddit_threads.ipynb +++ b/examples/predefined_components_reddit_threads.ipynb @@ -2,19 +2,36 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ + "import os\n", + "\n", + "from dotenv import load_dotenv\n", "from pyspark.sql import SparkSession\n", "from pyspark.sql.types import StructType, StructField, IntegerType\n", + "\n", "import requests\n", "from io import BytesIO\n", "from zipfile import ZipFile\n", "from neo4j_parallel_spark_loader.predefined_components import group_and_batch_spark_dataframe\n", "from neo4j_parallel_spark_loader import ingest_spark_dataframe\n", "from neo4j_parallel_spark_loader.visualize import create_ingest_heatmap\n", - "import json" + "import json\n", + "\n", + "load_dotenv()" ] }, { @@ -64,20 +81,16 @@ } ], "source": [ - "username = \"NEO4J_USER\"\n", - "password = \"NEO4J_PASSWORD\"\n", - "url = \"NEO4J_URL\"\n", - "dbname = \"NEO4J_DATABASE\"\n", "spark_executor_count=5\n", "\n", "spark = (\n", " SparkSession.builder\n", " .appName(\"ReditThreads\")\n", - " .config(\"neo4j.url\", url)\n", - " .config(\"url\", url)\n", - " .config(\"neo4j.authentication.basic.username\", username)\n", - " .config(\"neo4j.authentication.basic.password\", \"i2_dYwwAMKKqp7tokHoscvNJbBBn1snAZKX0uA_gffA\")\n", - " .config(\"neo4j.database\", dbname)\n", + " .config(\"neo4j.url\", os.environ.get(\"NEO4J_URI\"))\n", + " .config(\"url\", os.environ.get(\"NEO4J_URI\"))\n", + " .config(\"neo4j.authentication.basic.username\", os.environ.get(\"USERNAME\"))\n", + " .config(\"neo4j.authentication.basic.password\", os.environ.get(\"NEO4J_PASSWORD\"))\n", + " .config(\"neo4j.database\", os.environ.get(\"NEO4J_DATABASE\"))\n", " .getOrCreate()\n", ")" ] @@ -825,7 +838,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.12.3" }, "save_output": true, "synapse_widget": { diff --git a/neo4j_parallel_spark_loader/monopartite/grouping.py b/neo4j_parallel_spark_loader/monopartite/grouping.py index 1051876..47c6b94 100644 --- a/neo4j_parallel_spark_loader/monopartite/grouping.py +++ b/neo4j_parallel_spark_loader/monopartite/grouping.py @@ -50,20 +50,21 @@ def create_node_groupings( grouping_column="combined_col", ) - final_sdf = (spark_dataframe - .join( - other=keys_sdf.withColumnRenamed("group", "source_group"), - on=(spark_dataframe[source_col] == keys_sdf.value), - how="left" - ) - .drop(keys_sdf.value) - .join( - other=keys_sdf.withColumnRenamed("group", "target_group"), - on=(spark_dataframe[target_col] == keys_sdf.value), - how="left" - ) - .drop(keys_sdf.value) - .drop("value")) + final_sdf = ( + spark_dataframe.join( + other=keys_sdf.withColumnRenamed("group", "source_group"), + on=(spark_dataframe[source_col] == keys_sdf.value), + how="left", + ) + .drop(keys_sdf.value) + .join( + other=keys_sdf.withColumnRenamed("group", "target_group"), + on=(spark_dataframe[target_col] == keys_sdf.value), + how="left", + ) + .drop(keys_sdf.value) + .drop("value") + ) final_sdf = final_sdf.withColumn( "group", diff --git a/neo4j_parallel_spark_loader/visualize/heatmap.py b/neo4j_parallel_spark_loader/visualize/heatmap.py index 5fd32a8..b3ec205 100644 --- a/neo4j_parallel_spark_loader/visualize/heatmap.py +++ b/neo4j_parallel_spark_loader/visualize/heatmap.py @@ -1,9 +1,11 @@ from typing import Any, Dict, List, Optional, Tuple + +import matplotlib.pyplot as plt import numpy as np import seaborn as sns from matplotlib.axes import Axes from pyspark.sql import DataFrame -import matplotlib.pyplot as plt + def _format_spark_dataframe_for_visualization( spark_dataframe: DataFrame, @@ -24,12 +26,16 @@ def _format_spark_dataframe_for_visualization( counts_sdf = spark_dataframe.groupBy("group", "batch").count() return [row.asDict() for row in counts_sdf.collect()] + def create_ingest_heatmap( - spark_dataframe: DataFrame, title: str = "Parallel Ingest Heat Map", figsize: Optional[Tuple[float, float]] = None + spark_dataframe: DataFrame, + title: str = "Parallel Ingest Heat Map", + figsize: Optional[Tuple[float, float]] = None, ) -> Axes: """ Create the ingest heatmap from a list of dictionaries. This heatmap will display batches on the y-axis and group numbers on the x-axis. + Group IDs will be displayed in parenthesis below the value count in each cell. Parameters ---------- @@ -62,12 +68,14 @@ def create_ingest_heatmap( # Transform data with group numbers transformed_data = [] for d in data: - transformed_data.append({ - "batch": d["batch"], - "group_num": batch_group_mappings[d["batch"]][d["group"]], - "count": d["count"], - "original_group": d["group"] - }) + transformed_data.append( + { + "batch": d["batch"], + "group_num": batch_group_mappings[d["batch"]][d["group"]], + "count": d["count"], + "original_group": d["group"], + } + ) # Extract unique x and y values y_values = sorted(set(d["batch"] for d in transformed_data), reverse=True) @@ -83,11 +91,13 @@ def create_ingest_heatmap( x_idx = x_values.index(item["group_num"]) heatmap_data[y_idx, x_idx] = item["count"] # Create annotation with count and original group name - annotation_labels[y_idx, x_idx] = f"{item['count']:,.0f}\n({item['original_group']})" + annotation_labels[y_idx, x_idx] = ( + f"{item['count']:,.0f}\n({item['original_group']})" + ) # Create figure with specified size plt.figure(figsize=figsize) - + # Create heatmap ax = sns.heatmap( data=heatmap_data, @@ -96,10 +106,11 @@ def create_ingest_heatmap( xticklabels=x_values, yticklabels=y_values, linewidths=0.5, + vmin=0, ) - # plt.clim(0) - ax.set_xlabel("Group Number") + + ax.set_xlabel("Spark Processor Node Number") ax.set_ylabel("Batch") ax.set_title(title) - - return ax \ No newline at end of file + + return ax From 5b8ea254779496f784d1d1be56d76e3f7633c904 Mon Sep 17 00:00:00 2001 From: alex Date: Mon, 13 Jan 2025 13:42:51 -0600 Subject: [PATCH 13/13] Update CHANGELOG.md --- CHANGELOG.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 52cc112..ce1ad61 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,8 +4,16 @@ ### Changed +* Swap heatmap visualization axes +* Add group ID to each cell in heatmap +* Heatmap scale start at 0 +* Update monopartite batching algorithm +* Update ingest algorithm + ### Added +* Examples demonstrating each parallel ingest method with real data + ## 0.2.4 ### Fixed