From 562d0e09bf6ff5a4c4faebf695e9fd751e2ba5a2 Mon Sep 17 00:00:00 2001
From: <>
Date: Tue, 16 Jan 2024 23:49:56 +0000
Subject: [PATCH] Deployed a80aaa9 with MkDocs version: 1.5.3
---
.nojekyll | 0
404.html | 353 ++
css/base.css | 325 ++
css/bootstrap.min.css | 12 +
css/font-awesome.min.css | 4 +
details/best-pratice-collect/index.html | 400 ++
details/big-broadcast-join/index.html | 379 ++
details/broadcast-with-disable/index.html | 398 ++
details/class-or-method-not-found/index.html | 399 ++
details/container-oom/index.html | 380 ++
.../correlated-column-not-allowed/index.html | 413 ++
details/driver-max-result-size/index.html | 386 ++
.../error-driver-max-result-size/index.html | 392 ++
details/error-driver-out-of-memory/index.html | 379 ++
.../error-driver-stack-overflow/index.html | 379 ++
details/error-executor-out-of-disk/index.html | 380 ++
.../error-executor-out-of-memory/index.html | 383 ++
details/error-invalid-file/index.html | 379 ++
details/error-job/index.html | 382 ++
details/error-memory/index.html | 390 ++
details/error-other/index.html | 380 ++
details/error-shuffle/index.html | 426 ++
details/error-sql-analysis/index.html | 380 ++
.../even_partitioning_still_slow/index.html | 380 ++
.../index.html | 377 ++
.../failure-executor-large-record/index.html | 381 ++
details/forced-computations/index.html | 389 ++
details/key-skew/index.html | 419 ++
details/notenoughexecs/index.html | 371 ++
details/partial_aggregates/index.html | 378 ++
details/pyudfoom/index.html | 393 ++
details/read-partition-issue/index.html | 413 ++
details/revise-bad_partitioning/index.html | 379 ++
.../index.html | 382 ++
details/slow-executor/index.html | 381 ++
details/slow-job-slow-cluster/index.html | 377 ++
details/slow-job/index.html | 380 ++
details/slow-map/index.html | 389 ++
.../slow-partition_filter_pushdown/index.html | 407 ++
details/slow-reduce/index.html | 411 ++
details/slow-regex-tips/index.html | 414 ++
details/slow-skewed-join/index.html | 379 ++
details/slow-skewed-write/index.html | 400 ++
details/slow-stage/index.html | 465 +++
details/slow-writes-s3/index.html | 386 ++
details/slow-writes-too-many-files/index.html | 384 ++
details/slow-writes/index.html | 390 ++
details/toobigdag/index.html | 385 ++
details/toofew_tasks/index.html | 371 ++
details/toomany_tasks/index.html | 371 ++
details/udfslow/index.html | 377 ++
details/write-fails/index.html | 379 ++
flowchart/error/index.html | 368 ++
flowchart/index.html | 317 ++
flowchart/shared/index.html | 316 ++
flowchart/slow/index.html | 375 ++
fonts/fontawesome-webfont.eot | Bin 0 -> 165742 bytes
fonts/fontawesome-webfont.svg | 2671 +++++++++++++
fonts/fontawesome-webfont.ttf | Bin 0 -> 165548 bytes
fonts/fontawesome-webfont.woff | Bin 0 -> 98024 bytes
fonts/fontawesome-webfont.woff2 | Bin 0 -> 77160 bytes
img/favicon.ico | Bin 0 -> 1150 bytes
img/grid.png | Bin 0 -> 1458 bytes
imgs/identify-slow-stage.png | Bin 0 -> 352284 bytes
imgs/spark-driver-max-result-size-error.png | Bin 0 -> 78802 bytes
imgs/spark-filter-ignored.png | Bin 0 -> 77247 bytes
imgs/spark-filter-pushdown-success.png | Bin 0 -> 80059 bytes
imgs/spark-salted.png | Bin 0 -> 90408 bytes
imgs/spark-skewed.png | Bin 0 -> 87111 bytes
index.html | 390 ++
js/base.js | 283 ++
js/bootstrap.min.js | 7 +
js/jquery-3.6.0.min.js | 2 +
search/lunr.js | 3475 +++++++++++++++++
search/main.js | 109 +
search/search_index.json | 1 +
search/worker.js | 133 +
sitemap.xml | 3 +
sitemap.xml.gz | Bin 0 -> 127 bytes
79 files changed, 27457 insertions(+)
create mode 100644 .nojekyll
create mode 100644 404.html
create mode 100644 css/base.css
create mode 100644 css/bootstrap.min.css
create mode 100644 css/font-awesome.min.css
create mode 100644 details/best-pratice-collect/index.html
create mode 100644 details/big-broadcast-join/index.html
create mode 100644 details/broadcast-with-disable/index.html
create mode 100644 details/class-or-method-not-found/index.html
create mode 100644 details/container-oom/index.html
create mode 100644 details/correlated-column-not-allowed/index.html
create mode 100644 details/driver-max-result-size/index.html
create mode 100644 details/error-driver-max-result-size/index.html
create mode 100644 details/error-driver-out-of-memory/index.html
create mode 100644 details/error-driver-stack-overflow/index.html
create mode 100644 details/error-executor-out-of-disk/index.html
create mode 100644 details/error-executor-out-of-memory/index.html
create mode 100644 details/error-invalid-file/index.html
create mode 100644 details/error-job/index.html
create mode 100644 details/error-memory/index.html
create mode 100644 details/error-other/index.html
create mode 100644 details/error-shuffle/index.html
create mode 100644 details/error-sql-analysis/index.html
create mode 100644 details/even_partitioning_still_slow/index.html
create mode 100644 details/failed-to-read-non-parquet-file/index.html
create mode 100644 details/failure-executor-large-record/index.html
create mode 100644 details/forced-computations/index.html
create mode 100644 details/key-skew/index.html
create mode 100644 details/notenoughexecs/index.html
create mode 100644 details/partial_aggregates/index.html
create mode 100644 details/pyudfoom/index.html
create mode 100644 details/read-partition-issue/index.html
create mode 100644 details/revise-bad_partitioning/index.html
create mode 100644 details/revise-even_partitioning_still_slow/index.html
create mode 100644 details/slow-executor/index.html
create mode 100644 details/slow-job-slow-cluster/index.html
create mode 100644 details/slow-job/index.html
create mode 100644 details/slow-map/index.html
create mode 100644 details/slow-partition_filter_pushdown/index.html
create mode 100644 details/slow-reduce/index.html
create mode 100644 details/slow-regex-tips/index.html
create mode 100644 details/slow-skewed-join/index.html
create mode 100644 details/slow-skewed-write/index.html
create mode 100644 details/slow-stage/index.html
create mode 100644 details/slow-writes-s3/index.html
create mode 100644 details/slow-writes-too-many-files/index.html
create mode 100644 details/slow-writes/index.html
create mode 100644 details/toobigdag/index.html
create mode 100644 details/toofew_tasks/index.html
create mode 100644 details/toomany_tasks/index.html
create mode 100644 details/udfslow/index.html
create mode 100644 details/write-fails/index.html
create mode 100644 flowchart/error/index.html
create mode 100644 flowchart/index.html
create mode 100644 flowchart/shared/index.html
create mode 100644 flowchart/slow/index.html
create mode 100644 fonts/fontawesome-webfont.eot
create mode 100644 fonts/fontawesome-webfont.svg
create mode 100644 fonts/fontawesome-webfont.ttf
create mode 100644 fonts/fontawesome-webfont.woff
create mode 100644 fonts/fontawesome-webfont.woff2
create mode 100644 img/favicon.ico
create mode 100644 img/grid.png
create mode 100644 imgs/identify-slow-stage.png
create mode 100644 imgs/spark-driver-max-result-size-error.png
create mode 100644 imgs/spark-filter-ignored.png
create mode 100644 imgs/spark-filter-pushdown-success.png
create mode 100644 imgs/spark-salted.png
create mode 100644 imgs/spark-skewed.png
create mode 100644 index.html
create mode 100644 js/base.js
create mode 100644 js/bootstrap.min.js
create mode 100644 js/jquery-3.6.0.min.js
create mode 100644 search/lunr.js
create mode 100644 search/main.js
create mode 100644 search/search_index.json
create mode 100644 search/worker.js
create mode 100644 sitemap.xml
create mode 100644 sitemap.xml.gz
diff --git a/.nojekyll b/.nojekyll
new file mode 100644
index 0000000..e69de29
diff --git a/404.html b/404.html
new file mode 100644
index 0000000..c743517
--- /dev/null
+++ b/404.html
@@ -0,0 +1,353 @@
+
+
+
+ Spark Advanced Topics
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Bringing too much data back to the driver (collect and friends) - Spark Advanced Topics
+
+
+
+
+
+
Bringing too much data back to the driver (collect and friends)
+
A common anti-pattern in Apache Spark is using collect() and then processing records on the driver. There are a few different reasons why folks tend to do this and we can work through some alternatives:
+
+Label items in ascending order
+
+Index items in order
+Compute the size of each partition use this to assign indexes.
+
+
+In order processing
+Compute a partition at a time (this is annoying to do, sorry).
+
+
+Writing out to a format not supported by Spark
+Use foreachPartition or implement your own DataSink.
+
+
+Need to aggregate everything into a single record
+Call reduce or treeReduce
+
+
+
+
Sometimes you do really need to bring the data back to the driver for some reason (e.g., updating model weights). In those cases, especially if you process the data sequentially, you can limit the amount of data coming back to the driver at one time. toLocalIterator gives you back an iterator which will only need to fetch a partition at a time (although in Python this may be pipeline for efficency). By default toLocalIterator will launch a Spark job for each partition, so if you know you will eventually need all of the data it makes sense to do a persist + a count (async or otherwise) so you don't block as long between partitions.
+
This doesn't mean every call to collect() is bad, if the amount of data being returned is under ~1gb it's probably OK although it will limit parallelism.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Too big broadcast joins - Spark Advanced Topics
+
+
+
+
+
+
Too big broadcast joins
+
Beware that broadcast joins put unnecessary pressure on the driver. Before the tables are broadcasted to all the executors, the data is brought back to the driver and then broadcasted to executors. So you might run into driver OOMs.
+
Broadcast smaller tables but this is usually recommended for < 10 Mb tables. Although that is mostly the default, we can comfortably broadcast much larger datasets as long as they fit in the executor and driver memories. Remember if there are multiple broadcast joins in the same stage, you need to have enough room for all those datasets in memory.
+You can configure the broadcast threshold usingspark.sql.autoBroadcastJoinThreshold or increase the driver memory by setting spark.driver.memory to a higher value
+
Make sure that you need more memory on your driver than the sum of all your broadcasted data in any stage plus all the other overheads that the driver deals with!
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Tables getting broadcasted even when broadcast is disabled - Spark Advanced Topics
+
+
+
+
+
+
Tables getting broadcasted even when broadcast is disabled
+
You expect the broadcast to stop after you disable the broadcast threshold, by setting spark.sql.autoBroadcastJoinThreshold to -1, but Spark tries to broadcast the bigger table and fails with a broadcast error. And you observe that the query plan has BroadcastNestedLoopJoin in the physical plan.
+
+Check for sub queries in your code using NOT IN
+
+
Example :
+
select * from TableA where id not in (select id from TableB)
+
+
This typically results in a forced BroadcastNestedLoopJoin even when the broadcast setting is disabled.
+If the data being processed is large enough, this results in broadcast errors when Spark attempts to broadcast the table
+
+Rewrite query using not exists or a regular LEFT JOIN instead of not in
+
+
Example:
+
select * from TableA where not exists (select 1 from TableB where TableA.id = TableB.id)
+
+
The query will use SortMergeJoin and will resolve any Driver memory errors because of forced broadcasts
+
Relevant links
+
External Resource
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Class or method not found - Spark Advanced Topics
+
+
+
+
+
+
Class or method not found
+
When your compile-time class path differs from the runtime class path, you may encounter errors that signal that a class or method could not be found (e.g., NoClassDefFoundError, NoSuchMethodError).
+
java.lang.NoSuchMethodError: com.fasterxml.jackson.dataformat.avro.AvroTypeResolverBuilder.subTypeValidator(Lcom/fasterxml/jackson/databind/cfg/MapperConfig;)Lcom/fasterxml/jackson/databind/jsontype/PolymorphicTypeValidator;
+ at com.fasterxml.jackson.dataformat.avro.AvroTypeResolverBuilder.buildTypeDeserializer(AvroTypeResolverBuilder.java:43)
+ at com.fasterxml.jackson.databind.deser.BasicDeserializerFactory.findTypeDeserializer(BasicDeserializerFactory.java:1598)
+ at com.fasterxml.jackson.databind.deser.BasicDeserializerFactory.findPropertyContentTypeDeserializer(BasicDeserializerFactory.java:1766)
+ at com.fasterxml.jackson.databind.deser.BasicDeserializerFactory.resolveMemberAndTypeAnnotations(BasicDeserializerFactory.java:2092)
+ at com.fasterxml.jackson.databind.deser.BasicDeserializerFactory.constructCreatorProperty(BasicDeserializerFactory.java:1069)
+ at com.fasterxml.jackson.databind.deser.BasicDeserializerFactory._addExplicitPropertyCreator(BasicDeserializerFactory.java:703)
+ at com.fasterxml.jackson.databind.deser.BasicDeserializerFactory._addDeserializerConstructors(BasicDeserializerFactory.java:476)
+ ...
+
This may be due to packaging a fat JAR with dependency versions that are in conflict with those provided by the Spark environment. When there are multiple versions of the same library in the runtime class path under the same package, Java's class loader hierarchy kicks in, which can lead to unintended behaviors.
+
There are a few options to get around this.
+
+Identify the version of the problematic library within your Spark environment and pin the dependency to that version in your build file. To identify the version used in your Spark environment, in the Spark UI go to the Environment tab, scroll down to Classpath Entries, and find the corresponding library.
+Exclude the transient dependency of the problematic library from imported libraries in your build file.
+Shade the problematic library under a different package.
+
+
If options (1) and (2) result in more dependency conflicts, it may be that the version of the problematic library in the Spark environment is incompatible with your application code. Therefore, it makes sense to shade the problematic library so that your application can run with a version of the library isolated from the rest of the Spark environment.
+
If you are using the shadow plugin in Gradle, you can shade using:
+
shadowJar {
+ ...
+ relocate 'com.fasterxml.jackson', 'shaded.fasterxml.jackson'
+}
+In this example, Jackson libraries used by your application will be available in the
shaded.fasterxml.jackson package at runtime.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Container OOMs - Spark Advanced Topics
+
+
+
+
+
+
Container OOMs
+
Container OOMs can be difficult to debug as the container running the problematic code is killed, and sometimes not all of the log information is available.
+
Non-JVM language users (such as Python) are most likely to encounter issues with container OOMs. This is because the JVM is generally configured to not use more memory than the container it is running in.
+
Everything which isn't inside the JVM is considered "overhead", so Tensorflow, Python, bash, etc. A first step with a container OOM is often increasing spark.executor.memoryOverhead and spark.driver.memoryOverhead to leave more memory for non-Java processes.
+
Python users can set spark.executor.pyspark.memory to limit the Python VM to a certain amount of memory. This amount of memory is then added to the overhead.
+
Python users performing aggregations in Python should also check out the PyUDFOOM page .
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
spark.sql.AnalysisException: Correlated column is not allowed in predicate - Spark Advanced Topics
+
+
+
+
+
+
+
SPARK-35080 introduces a check for correlated subqueries with aggregates which may have previously return incorect results.
+Instead, starting in Spark 2.4.8, these queries will raise an org.apache.spark.sql.AnalysisException exception.
+
One of the examples of this (from the JIRA ) is:
+
create or replace view t1(c) as values ('a'), ('b');
+create or replace view t2(c) as values ('ab'), ('abc'), ('bc');
+
+select c, (select count(*) from t2 where t1.c = substring(t2.c, 1, 1)) from t1;
+
Instead you should do an explicit join and then perform your aggregation:
+
create or replace view t1(c) as values ('a'), ('b');
+create or replace view t2(c) as values ('ab'), ('abc'), ('bc');
+
+create or replace view t3 as select t1.c from t2 INNER JOIN t1 ON t1.c = substring(t2.c, 1, 1);
+
+select c, count(*) from t3 group by c;
+
Similarly:
+
create or replace view t1(a, b) as values (0, 6), (1, 5), (2, 4), (3, 3);
+create or replace view t2(c) as values (6);
+
+select c, (select count(*) from t1 where a + b = c) from t2;
+
Can be rewritten as:
+
create or replace view t1(a, b) as values (0, 6), (1, 5), (2, 4), (3, 3);
+create or replace view t2(c) as values (6);
+
+create or replace view t3 as select t2.c from t2 INNER JOIN t1 ON t2.c = t1.a + t1.b;
+
+select c, count(*) from t3 group by c;
+
Likewise in Scala and Python use an explicit .join and then perform your aggregation on the joined result.
+Now Spark can compute correct results thus avoiding the exception.
+
Relevant links:
+
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Result size larger than spark.driver.maxResultSize error OR Kryo serialization failed: Buffer overflow. - Spark Advanced Topics
+
+
+
+
+
+
Result size larger than spark.driver.maxResultSize error OR Kryo serialization failed: Buffer overflow.
+
ex:
+
You typically run into this error for one of the following reasons.
+
+You are sending a large result set to the driver using SELECT(in SQL) or COLLECT(in dataframes/dataset/RDD): Apply a limit if your intention is to spot check a few rows as you won't be able to go through full set of rows if you have a really high number of rows. Writing the results to a temporary table in your schema and querying the new table would be an alternative if you need to query the results multiple times with a specific set of filters.
+You are broadcasting a table that is too big. Spark downloads all the rows for a table that needs to be broadcasted to the driver before it starts shipping to the executors. So iff you are broadcasting a table that is larger than spark.driver.maxResultSize, you will run into this error. You can overcome this by either increasing the spark.driver.maxResultSize or not broadcasting the table so Spark would use a shuffle hash or sort-merge join.
+You have a sort in your SQL/Dataframe: Spark internally uses range-partitioning to assign sort keys to a partition range. This involves in collecting sample rows(reservoir sampling) from input partitions and sending them to the driver for computing range boundaries. This error can further fall into one of the below scenarios.
+ a. You have wide/bloated rows in your table: In this case, you are not sending a lot of rows to the driver, but you are sending bytes larger than the spark.driver.maxResultSize. The recommendation here is to lower the default sample size by setting the spark property spark.sql.execution.rangeExchange.sampleSizePerPartition to something lower than 20. You can also increase spark.driver.maxResultSize if lowering the sample size is causing an imbalance in partition ranges(for ex: skew in a sub-sequent stage or non-uniform output files etc..). If using the later option, be sure spark.driver.maxResultSize is less than spark.driver.memory.
+ b. You have too many Spark partitions from the previous stage: In this case, you have a large number of map tasks while reading from a table. Since spark has to collect sample rows from every partition, your total bytes from the number of rows(partitions*sampleSize) could be larger than spark.driver.maxResultSize. A recommended way to resolve this issue is by combining the splits for the table(increase spark.(path).(db).(table).target-size) with high map tasks. Note that having a large number of map tasks(>80k) will cause other OOM issues on driver as it needs to keep track of metadata for all these tasks/partitions.
+
+
External resources:
+- Apache Spark job fails with maxResultSize exception
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Result size larger than spark.driver.maxResultsSize error - Spark Advanced Topics
+
+
+
+
+
+
Result size larger than spark.driver.maxResultsSize error
+
ex:
+
You typically run into this error for one of the following reasons.
+
+You are sending a large result set to the driver using SELECT(in SQL) or COLLECT(in dataframes/dataset/RDD): Apply a limit if your intention is to spot check a few rows as you won't be able to go through full set of rows if you have a really high no.of rows. Writing the results to a temporary table in your schema and querying the new table would be an alternative if you need to query the results multiple times with a specific set of filters. (Collect best practices )
+You are broadcasting a table that is too big. Spark downloads all the rows for a table that needs to be broadcasted to the driver before it starts shipping to the executors. So iff you are broadcasting a table that is larger than spark.driver.maxResultsSize, you will run into this error. You can overcome this by either increasing the spark.driver.maxResultsSize or not broadcasting the table so Spark would use a shuffle hash or sort-merge join. Note that Spark broadcasts a table referenced in a join if the size of the table is less than spark.sql.autoBroadcastJoinThreshold(100 MB by default at Netflix). You can change this config to include a larger tables in broadcast or reduce the threshold if you want to exclude certain tables. You can also set this to -1 if you want to disable broadcast joins.
+You have a sort in your SQL/Dataframe: Spark internally uses range-partitioning to assign sort keys to a partition range. This involves in collecting sample rows(reservoir sampling) from input partitions and sending them to the driver for computing range boundaries. This error can further fall into one of the below scenarios.
+ a. You have wide/bloated rows in your table: In this case, you are not sending a lot of rows to the driver, but you are sending bytes larger than the spark.driver.maxResultsSize. The recommendation here is to lower the default sample size by setting the spark property spark.sql.execution.rangeExchange.sampleSizePerPartition to something lower than 20. You can also increase spark.driver.maxResultsSize if lowering the sample size is causing an imbalance in partition ranges(for ex: skew in a subsequent stage or non-uniform output files etc.)
+ b. You have too many Spark partitions from the previous stage: In this case, you have a large no.of map tasks while reading from a table. Since spark has to collect sample rows from every partition, your total bytes from the no.of rows(partitions*sampleSize) could be larger than spark.driver.maxResultsSize. A recommended way to resolve this issue is by combining the splits for the table(increase spark.netflix.(db).(table).target-size) with high map tasks. Note that having a large no.of map tasks(>80k) will cause other OOM issues on driver as it needs to keep track of metadata for all these tasks/partitions.
+
+
Broadcast join related articles
+
SQL Broadcast Join Hints
+
Tables getting broadcasted even when broadcast is disabled
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Driver ran out of memory - Spark Advanced Topics
+
+
+
+
+
+
Driver ran out of memory
+
IF you see java.lang.OutOfMemoryError: in the driver log/stderr, it is most likely from driver JVM running out of memory. This article has the memory config for increasing the driver memory. One reason you could run into this error is
+if you are reading from a table with too many splits(s3 files) and overwhelming the driver with a lot of metadata.
+
Another cause for driver out of memory errors is when the number of partitions is too high and you trigger a sort or shuffle where Spark samples the data, but then runs out of memory while collecting the sample. To solve this repartition to a lower number of partitions or if you're in RDDs coalesce is a more efficent option (in DataFrames coalesce can have impact upstream in the query plan).
+
A less common, but still semi-frequent, occurnce of driver out of memory is an excessive number of tasks in the UI. This can be controlled by reducing spark.ui.retainedTasks (default 100k).
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Driver ran out of memory - Spark Advanced Topics
+
+
+
+
+
+
Driver ran out of memory
+
Note that it is very rare to run into this error. You may see this error when you are using too many filters(in your sql/dataframe/dataset). Workaround is to increase spark driver JVM stack size by setting below config to something higher than the default
+
+spark.driver.extraJavaOptions: "-Xss512M" #Sets the stack size to 512 MB
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Executor out of disk error - Spark Advanced Topics
+
+
+
+
+
+
Executor out of disk error
+
By far the most common cause of executor out of disk errors is a mis-configuration of Spark's temporary directories.
+
You should set spark.local.dir to a directory with lots of local storage available. If you are on YARN this will be overriden by LOCAL_DIRS environment variable on the workers.
+
Kubernetes users may wish to add a large emptyDir for Spark to use for temporary storage.
+
Another common cause is having no longer needed/used RDDs/DataFrames/Datasets in scope. This tends to happen more often with notebooks as more things are placed in the global scope where they are not automatically cleaned up. A solution to this is breaking your code into more functions so that things go out of scope, or explicitily setting no longer needed RDDs/DataFrames/Datasets to None/null.
+
On the other hand if you have an iterative algorithm you should investigate if you may have to big of a DAG.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Executor ran out of memory - Spark Advanced Topics
+
+
+
+
+
+
Executor ran out of memory
+
Executor out of memory issues can come from many sources. To narrow down what the cause of the error there are a few important places to look: the Spark Web UI, the executor log, the driver log, and (if applicable) the cluster manager (e.g. YARN/K8s) log/UI.
+
Container OOM
+
If the driver log indicates Container killed by YARN for exceeding memory limits for the applicable executor, or if (on K8s) the Spark UI show's the reason for the executor loss as "OOMKill" / exit code 137 then it's likely your program is exceeding the amount of memory assigned to it. This doesn't normally happen with pure JVM code, but instead when calling PySpark or JNI libraries (or using off-heap storage).
+
PySpark users are the most likely to encounter container OOMs. If you have PySpark UDF in the stage you should check out Python UDF OOM to eliminate that potential cause. Another potential issue to investigate is if your have key skew as trying to load too large a partition in Python can result in an OOM. If you are using a library, like Tensorflow, which results in
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Missing Files / File Not Found / Reading past RLE/BitPacking stream - Spark Advanced Topics
+
+
+
+
+
+
Missing Files / File Not Found / Reading past RLE/BitPacking stream
+
Missing files are a relatively rare error in Spark. Most commonly they are caused by non-atomic operations in the data writer and will go away when you re-run your query/job.
+
On the other hand Reading past RLE/BitPacking stream or other file read errors tend to be non-transient.
+If the error is not transient it may mean that the metadata store (e.g. hive or iceberg) are pointing to a file that does not exist or has a bad format. You can cleanup Iceberg tables using Iceberg Table Cleanup from holden's spark-misc-utils , but be careful and talk with whoever produced the table to make sure that it's ok.
+
If you get a failed to read parquet file while you are not trying to read a parquet file, it's likely that you are using the wrong metastore .
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Error - Spark Advanced Topics
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Memory Errors - Spark Advanced Topics
+
+
+
+
+
+
Memory Errors
+
Driver
+
+
+
+
Executor
+
+
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Other errors - Spark Advanced Topics
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Fetch Failed exceptions - Spark Advanced Topics
+
+
+
+
+
+
Fetch Failed exceptions
+
No time to read, help me now.
+
FetchFailed exceptions are mainly due to misconfiguration of spark.sql.shuffle.partitions:
+
+Too few shuffle partitions: Having too few shuffle partitions means you could have a shuffle block that is larger than the limit(Integer.MaxValue=~2GB) or OOM(Exit code 143). The symptom for this can also be long-running tasks where the blocks are large but not reached the limit. A quick fix is to increase the shuffle/reducer parallelism by increasing spark.sqlshuffle.partitions(default is 500).
+Too many shuffle partitions: Too many shuffle partitions could put a stress on the shuffle service and could run into errors like network timeout ```. Note that the shuffle service is a shared service for all the jobs running on the cluster so it is possible that someone else's job with high shuffle activity could cause errors for your job. It is worth checking to see if there is a pattern of these failures for your job to confirm if it is an issue with your job or not. Also note that the higher the shuffle partitions, the more likely that you would see this issue.
+
+
Tell me more.
+
FetchFailed Exceptions can be bucketed into below 4 categories:
+
+Ran out of heap memory(OOM) on an Executor
+Ran out of overhead memory on an Executor
+Shuffle block greater than 2 GB
+Network TimeOut.
+
+
Ran out of heap memory(OOM) on an Executor
+
This error indicates that the executor hosting the shuffle block has crashed due to Java OOM. The most likely cause for this is misconfiguration of spark.sqlshuffle.partitions. A workaround is to increase the shuffle partitions. Note that if you have skew from a single key(in join, group By), increasing this property wouldn't resolve the issue. Please refer to key-skew for related workarounds.
+
Errors that you normally see in the executor/task logs:
+
+ExecutorLostFailure due to Exit code 143
+ExecutorLostFailure due to Executor Heartbeat timed out.
+
+
Ran out of overhead memory on an Executor
+
This error indicates that the executor hosting the shuffle block has crashed due to off-heap(overhead) memory. Increasing spark.yarn.executor.Overhead should prevent this specific exception.
+
Error that you normally see in the executor/task logs:
+
+ExecutorLostFailure, # GB of # GB physical memory used. Consider boosting the spark.yarn.executor.Overhead
+
+
Shuffle block greater than 2 GB
+
The most likely cause for this is misconfiguration of spark.sqlshuffle.partitions. A workaround is to increase the shuffle partitions(increases the no.of blocks and reduces the block size). Note that if you have skew from a single key(in join, group By), increasing this property wouldn't resolve the issue. Please refer to key-skew for related workarounds.
+
Error that you normally see in the executor/task logs:
+
+Too Large Frame
+Frame size exceeding
+size exceeding Integer.MaxValue(~2GB)
+
+
Network Timeout
+
The most likely cause for this exception is a high shuffle activity(high network load) in your job. Reducing the shuffle partitions spark.sqlshuffle.partitions would mitigate this issue. You can also reduce the network load by modifying the shuffle config. (todo: add details)
+
Error that you normally see in the executor/task logs:
+
+org.apache.spark.shuffle.MetadataFetchFailedException: Missing an output location for shuffle 0
+org.apache.spark.shuffle.FetchFailedException: Failed to connect to ip-xxxxxxxx
+Caused by: org.apache.spark.shuffle.FetchFailedException: Too large frame: xxxxxxxxxxx
+
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
spark.sql.AnalysisException - Spark Advanced Topics
+
+
+
+
+
+
spark.sql.AnalysisException
+
Spark SQL AnalysisException covers a wide variety of potential issues, ranging from ambigious columns to more esotoric items like subquery issues. A good first step is making sure that your SQL is valid and your brackets are where you intend by putting your query through a SQL pretty-printer. After that hopefully the details of the AnalysisException error will guide you to one of the sub-nodes in the error graph.
+
Known issues
+
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Even Partitioning Yet Still Slow - Spark Advanced Topics
+
+
+
+
+
+
Even Partitioning Yet Still Slow
+
To see if a stage if evenly partitioned take a look at the Spark WebUI --> Stage tab and look at the distribution of data sizes and durations of the completed tasks. Sometimes a stage with even partitioning is still slow.
+
There are a few common possible causes when the partitioning is even for slow stages. If your tasks are too short (e.g. finishing in under a few minutes), likely you have too many partitions/tasks. If your tasks are taking just the right amount of time but your jobs are slow you may not have enough executors. If your tasks are taking a long time you may have too large records, not enough partitions/tasks, or just slow functions. Another sign of not enough tasks can be excessive spill to disk.
+
If the data is evenly partitioned but the max task duration is longer than desired for the stage, increasing the number of executors will not help and you'll need to re-partition the data. Insufficient partitioning can be fixed by increasing the number of partitions (e.g. repartition(5000) or change spark.sql.shuffle.partitions).
+
Another cause of too large partitioning can be non-splittable compression formats, like gzip, that can be worked around with tools like splittablegzip .
+
Finally consider the possibility the records are too large.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Failed to read non-parquet file - Spark Advanced Topics
+
+
+
+
+
+
Failed to read non-parquet file
+
Iceberg does not perform validation on the files specified, so it will let you create a table pointing to non-supported formats, e.g. CSV data, but will fail at query time. In this case you need to use a different metastore (e.g. Hive)
+
If the data is stored in a supported format, it is also possible you have an invalid iceberg table.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Large record problems can show up in a few different ways. - Spark Advanced Topics
+
+
+
+
+
+
Large record problems can show up in a few different ways.
+
For particularly large records you may find an executor out of memory exception, otherwise you may find slow stages.
+
You can get a Kyro serialization (for SQL) or Java serialization error (for RDD). In addition if a given column in a row is too large you may encounter a IllegalArgumentException: Cannot grow BufferHolder by size, because the size after growing exceeds size limitation 2147483632.
+
Some common causes of too big records are groupByKey in RDD land, UDAFs or list aggregations (like collect_list) in Spark SQL, highly compressed or Sparse records without a sparse seriaization.
+
For sparse records check out AltEncoder in (spark-misc-utils)[https://github.com/holdenk/spark-misc-utils].
+
If you are uncertain of where exactly the too big record is coming from after looking at the executor logs, you can try and seperate the stage which is failing into distinct parts of the code by using persist at the DISK_ONLY level to introduce cuts into the graph.
+
If your exception is happening with a Python UDF, it's possible that the individual records themselves might not be too large, but the batch-size used by Spark is set too high for the size of your records. You can try turning down the record size.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Force computations - Spark Advanced Topics
+
+
+
+
+
+
Force computations
+
There are multiple use cases where you might want to measure performance for different transformations in your spark job, in which case you have to materialize the transformations by calling an explicit action. If you encounter an exception during the write phase that appears unrelated, one technique is to force computation earlier of the DataFrame or RDD to narrow down the true cause of the exception.
+
Forcing computation on RDDs is relatively simple, all you need to do is call count() and Spark will evaluate the RDD.
+
Forcing computation on DataFrames is more complex. Calling an action like count() on a DataFrame might not necessarily work because the optimizer will likely ignore unnecessary transformations. In order to compute the row count, Spark does not have to execute all transformations. The Spark optimizer can simplify the query plan in such a way that the actual transformation that you need to measure will be skipped because it is simply not needed for finding out the final count. In order to make sure all the transformations are called, we need to force Spark to compute them using other ways.
+
Here are some options to force Spark to compute all transformations of a DataFrame:
+
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Key/Partition Skew - Spark Advanced Topics
+
+
+
+
+
+
Key/Partition Skew
+
Key or partition skew is a frequent problem in Spark. Key skew can result in everything from slowly running jobs (with stragglers), to failing jobs.
+
What is data skew?
+
+
+Usually caused during a transformation when the data in one partition ends up being a lot more than the others, bumping up memory could resolve an OOM error but does not solve the underlying problem
+
+
+Processing partitions are unbalanced by a magnitude then the largest partition becomes the bottleneck
+
+
+
How to identify skew
+
+If one task took much longer to complete than the other tasks, it's usually a sign of Skew. On the Spark UI under Summary Metrics for completed tasks if the Max duration is higher by a significant magnitude from the Median it usually represents Skew, e.g.:
+
+
+
Things to consider
+
+Mitigating skew has a cost (e.g. repartition) hence its ignorable unless the duration or input size is significantly higher in magnitude severely impacting job time
+
+
Mitigation strategies
+
+
+Increasing executor memory to prevent OOM exceptions -> This a short-term solution if you want to unblock yourself but does not address the underlying issue. Sometimes this is not an option when you are already running at the max memory settings allowable.
+
+
+Salting is a way to balance partitions by introducing a salt/dummy key for the skewed partitions. Here is a sample workbook and an example of salting in content performance show completion pipeline, where the whole salting operation is parametrized with a JOIN_BUCKETS variable which helps with maintenance of this job.
+
+
+
+Isolate the data for the skewed key, broadcast it for processing (e.g. join) and then union back the results
+
+
+Adaptive Query Execution is a new framework with Spark 3.0, it enables Spark to dynamically identify skew. Under the hood adaptive query execution splits (and replicates if needed) skewed (large) partitions. If you are unable to upgrade to Spark 3.0, you can build the solution into the code by using the Salting/Partitioning technique listed above.
+
+
+Using approximate functions/ probabilistic data structure
+
+
+Using approximate distinct counts (Hyperloglog) can help get around skew if absolute precision isn't important.
+
+
+
Approximate data structures like Tdigest can help with quantile computations.
+If you need exact quantiles, check out the example in High Performance Spark
+
Certain types of aggregations and windows can result in partitioning the data on a particular key.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Notenoughexecs - Spark Advanced Topics
+
+
+
+
+
+
Not enough execs
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Partial v.s. Full Aggregates - Spark Advanced Topics
+
+
+
+
+
+
Partial v.s. Full Aggregates
+
Partial Aggregation is a key concept when handling large amounts of data in Spark. Full aggregation means that all of the data for one key must be together on the same node and then it can be aggregated, whereas partial aggregation allows Spark to start the aggregation "map-side" (e.g. before the shuffle) and then combine these "partial" aggregations together.
+
In RDD world the classic "full" aggregation is groupByKey and partial aggregation is reduceByKey.
+
In DataFrame/Datasets, Scala UDAFs implement partial aggregation but the basic PySpark Panda's/Arrow UDAFs do not support partial aggregation.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
PySpark UDF / UDAF OOM - Spark Advanced Topics
+
+
+
+
+
+
PySpark UDF / UDAF OOM
+
Out of memory exceptions with Python user-defined-functions are especially likely as Spark doesn't do a good job of managing memory between the JVM and Python VM. Together this can result in exceeding container memory limits .
+
Grouped Map / Co-Grouped
+
The Grouped & Co-Grouped UDFs are especially likely to cause out-of-memory exceptions in PySpark when combined with key skew .
+Unlike most built in Spark aggregations, PySpark user-defined-aggregates do not support partial aggregation. This means that all of the data for a single key must fit in memory. If possible try and use an equivalent built-in aggregation, write a Scala aggregation supporting partial aggregates, or switch to an RDD and use reduceByKey.
+
This limitation applies regardless of whether you are using Arrow or "vanilla" UDAFs.
+
Arrow / Pandas / Vectorized UDFS
+
If you are using PySpark's not-so-new Arrow based UDFS (sometimes called pandas UDFS or vectorized UDFs), record batching can cause issues. You can configure spark.sql.execution.arrow.maxRecordsPerBatch, which defaults to 10k records per batch. If your records are large this default may very well be the source of your out of memory exceptions.
+
Note: setting spark.sql.execution.arrow.maxRecordsPerBatch too-small will result in reduced performance and reduced ability to vectorize operations over the data frames.
+
mapInPandas / mapInArrow
+
If you use mapInPandas or mapInArrow (proposed in 3.3+) it's important to note that Spark will serialize entire records, not just the columns needed by your UDF. If you encounter OOMs here because of record sizes, one option is to minimize the amount of data being serialized in each record. Select only the minimal data needed to perform the UDF + a key to rejoin with the target dataset.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Partition at read time - Spark Advanced Topics
+
+
+
+
+
+
Partition at read time
+
We're used to thinking of partitioning after a shuffle, but partitioning problems can occur at read time as well. This often happens when the layout of the data on disk is not well suited to our computation. Note that the number of partitions can be optionally specified when using the read API.
+
How to decide on a partition column or partition key?
+
+
+Does the key have relatively low cardinality?
+1k distinct values are better than 1M distinct values.
+Consider a numeric, date, or timestamp column.
+
+
+Does the key have enough data in each partition?
+
+1Gb is a good goal.
+
+
+
+Does the key have too much data in each partition?
+The data must fit on a single task in memory and avoid spilling to disk.
+
+
+Does the key have evenly distributed data in each partition?
+If some partitions have orders of magnitude more data than others, those larger partitions have the potential to spill to disk, OOM, or simply consume excess resources in comparison to the partitions with median amounts of data. You don't want to size executors for the bloated partition. If none of the columns or keys has a particularly even distribution, then create a new column at the expense of saving a new version of the table/RDD/DF. A frequent approach here is to create a new column using a hash based on existing columns.
+
+
+Does the key allow for fewer wide transformations?
+Wide transformations are more costly than narrow transformations.
+
+
+Does the number of partitions approximate 2-3x the number of allocated cores on the executors?
+
+
+
Reference links
+
Learning Spark
+High Performance Spark
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Bad Partitioning - Spark Advanced Topics
+
+
+
+
+
+
Bad Partitioning
+
There are three main different types and causes of bad partitioning in Spark. Partitioning is often the limitation of parallelism for most Spark jobs.
+
The most common (and most difficult to fix) bad partitioning in Spark is that of skewed partitioning. With key-skew the problem is not the number of partions, but that the data is not evenly distributed amongst the partions. The most frequent cause of skewed partitioning is that of "key-skew." . This happens frequently since humans and machines both tend to cluster resulting in skew (e.g. NYC and null).
+
The other type of skewed partitioning comes from "input partioned" data which is not evenly partioned. With input partioned data, the RDD or Dataframe doesn't have a particular partioner it just matches however the data is stored on disk. Uneven input partioned data can be fixed with an explicit repartion/shuffle. This input partioned data can also be skewed due to key-skew if the data is written out partitioned on a skewed key.
+
Insufficent partitioning is similar to input skewed partitioning, except instead of skew there just are not enough partions. Similarily you the number of partions (e.g. repartion(5000) or change spark.sql.shuffle.partitions).
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Even Partitioning Yet Still Slow - Spark Advanced Topics
+
+
+
+
+
+
Even Partitioning Yet Still Slow
+
To see if a stage if evenly partioned take a look at the Spark WebUI --> Stage tab and look at the distribution of data sizes and durations of the completed tasks. Sometimes a stage with even parititoning is still slow.
+
If the max task duration is still substantailly shorter than the stages overall duration, this is often a sign of an insufficient number of executors. Spark can run (at most) spark.executor.cores * spark.dynamicAllocation.maxExecutors tasks in parallel (and in practice this will be lower since some tasks will be speculatively executed and some executors will fail). Try increasing the maxExecutors and seeing if your job speeds up.
+
+
Note
+
Setting spark.executor.cores * spark.dynamicAllocation.maxExecutors in excess of cluster capacity can result in the job waiting in PENDING state. So, try increasing maxExecutors within the limitations of the cluster resources and check if the job runtime is faster given the same input data.
+
+
If the data is evenly partitioned but the max task duration is longer than desired for the stage, increasing the number of executors will not help and you'll need to re-partition the data. See Bad Partitioning .
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Slow executor - Spark Advanced Topics
+
+
+
+
+
+
Slow executor
+
There can be many reasons executors are slow; here are a few things you can look into:
+
+Performance distribution among tasks in the same stage: In Spark UI - Stages - Summary Metric: check if there's uneven distribution of duration / input size. If true, there may be data skews or uneven partition splits. See uneven partitioning .
+Task size: In Spark UI - Stages - Summary Metrics, check the input/output size of tasks. If individual input or output tasks are larger than a few hundred megabytes, you may need more partitions. Try increasing spark.sql.shuffle.partitions or spark.sql.files.maxPartitionBytes or consider making a repartition call.
+GC: Check if GC time is a small fraction of duration, if it's more than a few percents, try increasing executor memory and see if any difference. If adding memory is not helping, you can now see if any optimization can be done in your code for that stage.
+
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Slow job slow cluster - Spark Advanced Topics
+
+
+
+
+
+
Slow Cluster
+
How do I know if and when my job is waiting for cluster resources??
+
Sometimes the cluster manager may choke or otherwise not be able to allocate resources and we don't have a good way of detecting this situation making it difficult for the user to debug and tell apart from Spark not scaling up correctly.
+
As of Spark3.4, an executor will note when and for how long it waits for cluster resources. Check the JVM metrics for this information.
+
Reference link:
+
https://issues.apache.org/jira/browse/SPARK-36664
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Slow job - Spark Advanced Topics
+
+
+
+
+
+
Slow job
+
Spark job can be slow for various reasons but here is a couple of reasons
+
+Slow stage(s): Go to Slow Stage section to identify the slow stage. In most cases, a job is slow because one or more of the stages are slow.
+Too big DAG: Go to TooBigDAG section for more details on this topic
+
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Slow Map - Spark Advanced Topics
+
+
+
+
+
Slow Map
+
Below is a list of reasons why your map stage might be slow. Note that this is not an exhaustive list but covers most of the scenarios.
+
flowchart LR
+
+SlowMap[Slow Read / Map]
+
+SlowMap --> SLOWEXEC[Slow executor]
+SlowMap --> EVENPART_SLOW[Even partitioning]
+SlowMap --> SkewedMapTasks[Skewed Map Tasks and uneven partitioning]
+
+EVENPART_SLOW --> MissingSourcePredicates[Reading more data than needed]
+EVENPART_SLOW --> TooFewMapTasks[Not enough Read/Map Tasks]
+EVENPART_SLOW --> TooManyMapTasks[Too many Read/Map Tasks]
+EVENPART_SLOW --> SlowTransformations[Slow Transformations]
+EVENPART_SLOW --> UDFSLOWNESS[Slow UDF]
+
+SkewedMapTasks --> RecordSkew[Record Skew]
+SkewedMapTasks --> TaskSkew[Task skew]
+TaskSkew --> READPARTITIONISSUES[Read partition issues]
+MissingSourcePredicates --> FILTERNOTPUSHED[Filter not pushed]
+
+click EVENPART_SLOW "../../details/even_partitioning_still_slow"
+click SLOWEXEC "../../details/slow-executor"
+click SkewedMapTasks "../../details/slow-map/#skewed-map-tasks-or-uneven-partitioning"
+click RecordSkew "../../details/slow-map/#skewed-map-tasks-or-uneven-partitioning"
+click TaskSkew "../../details/slow-map/#skewed-map-tasks-or-uneven-partitioning"
+click MissingSourcePredicates "../../details/slow-map/#reading-more-data-than-needed"
+
+click UDFSLOWNESS "../../details/udfslow"
+click LARGERECORDS "../../details/failure-executor-large-record"
+
+click TooFewMapTasks "../../details/slow-map/#not-enough-readmap-tasks"
+click TooManyMapTasks "../../details/slow-map/#too-many-readmap-tasks"
+click SlowTransformations "../../details/slow-map/#slow-transformations"
+
+click FILTERNOTPUSHED "../../details/slow-partition_filter_pushdown"
+click SLOWEXEC "../../details/slow-executor"
+click READPARTITIONISSUES "../../details/read-partition-issue"
+
+
+
Reading more data than needed
+
Iceberg/Parquet provides 3 layers of data pruning/filtering, so it is recommended to make the most of it by utilizing them as upstream in your ETL as possible.
+
+Partition Pruning : Applying a filter on a partition column would mean the Spark can prune all the partitions that are not needed (ex: utc_date, utc_hour etc.). Refer to this section for some examples.
+Column Pruning : Parquet, a columnar format, allows us to read specific columns from a row group without having to read the entire row. By selecting the fields that you only need for your job/sql(instead of "select *"), you can avoid bringing unnecessary data only to drop it in the subsequent stages.
+Predicate Push Down: It is also recommended to use filters on non-partition columns as this would allow Spark to exclude specific row groups while reading data from S3. For ex: account_id is not null if you know that you would be dropping the NULL account_ids eventually.
+
+
See also filter not pushed down , aggregation not pushed down(todo: add details), Bad storage partitioning(todo: add details).
+
Not enough Read/Map Tasks
+
If your map stage is taking longer, and you are sure that you are not reading more data than needed, then you may be reading the data with small no. of tasks. You can increase the no. of map tasks by decreasing target split size. Note that if you are constrained by the resources(map tasks are just waiting for resources and not in RUNNING status), you would have to request more executors for your job by increasing spark.dynamicAllocation.maxExecutors
+
Too many Read/Map Tasks
+
If you have large no. of map tasks in your stage, you could run into driver memory related errors as the task metadata could overwhelm the driver. This also could put a stress on shuffle(on map side) as more map tasks would create more shuffle blocks. It is recommended to keep the task count for a stage under 80k. You can decrease the no. of map tasks by increasing target split size (todo: add detail) for an Iceberg table. (Note: For a non-iceberg table, the property is spark.sql.maxPartitionBytes and it is at the job level and not at the table level)
+
+
Another reason for slow running map tasks could be from many reason, some common ones include:
+
+Regex : You have RegEx in your transformation. Refer to RegEx tips for tuning.
+udf: Make sure you are sending only the data that you need in UDF and tune UDF for performance. Refer to Slow UDF for more details.
+Json: TBD
+
+
All these transformations may run into skew issues if you have a single row/column that is bloated. You could prevent this by checking the payload size before calling the transformation as a single row/column could potentially slow down the entire stage.
+
Skewed Map Tasks or Uneven partitioning
+
The most common (and most difficult to fix) bad partitioning in Spark is that of skewed partitioning. The data is not evenly distributed amongst the partitions.
+
+
+Uneven partitioning due to Key-skew : The most frequent cause of skewed partitioning is that of "key-skew." This happens frequently since humans and machines both tend to cluster resulting in skew (e.g. NYC and null).
+
+
+Uneven partitioning due to input layout: We are used to thinking of partitioning after a shuffle, but partitioning problems can occur at read time as well. This often happens when the layout of the data on disk is not well suited to our computation. In cases where the RDD or Dataframe doesn't have a particular partitioner, data is partitioned according to the storage on disk. Uneven input partitioned data can be fixed with an explicit repartition/shuffle. Spark is often able to avoid input layout issues by combinding and splitting inputs (when input formats are "splittable"), but not all input formats give Spark this freedom. One common example is gzip, although there is a work-around for "splittable gzip" but this comes at the cost of decompressing the entire file multiple times.
+
+
+Record Skew : A single bloated row/record could be the root cause for slow map task. The easiest way to identify this is by checking your string fields that has Json payload. ( Ex: A bug in a client could write a lot of data). You can identify the culprit by checking the max(size/length) of the field in your upstream table. For CL, snapshot is a candidate for bloated field.
+
+
+Task Skew : **This is only applicable to the tables with non-splittable file format(like TEXT, zip) and parquet files should never run into this issue. Task skew is where one of the tasks got more rows than others and it is possible if the upstream table has a single file that is large and has the non-splittable format.
+
+
+
+
+Copyright various authors 2022-2024, CC-BY-SA 4.0
+Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Keys
+Action
+
+
+
+
+? Open this help
+
+
+n Next page
+
+
+p Previous page
+
+
+s Search
+
+
+
+
+
+
+
+
Partition Filters - Spark Advanced Topics
+
+
+
+
+
+
Partition Filters
+
Processing more data than necessary will typically slow down the job.
+If the input table is partitioned then applying filters on the partition columns can restrict the input volume Spark
+ needs
+ to scan.
+
A simple equality filter gets pushed down to the batch scan and enables Spark to only scan the files
+where dateint = 20211101 of a sample table partitioned on dateint and hour.
+
select *
+from jlantos.sample_table
+where dateint = 20211101
+limit 100
+
+
Examples when the filter does not get pushed down
+
The filter contains an expression
+
If instead of a particular date we'd like to load data from the 1st of any month we might
+ rewrite the above query such as:
+
select *
+from jlantos.sample_table
+where dateint % 100 = 1
+limit 100
+
The query plan shows that Spark in this case scans the whole table and filters only in a later step.
+
+
Filter is dynamic via a join
+
In a more complex job we might restrict the data based on joining to another table. If the filtering criteria is not
+ static it won't be pushed down to the scan. So in the example below the two table scans happen independently, and
+ min(dateint) calculated in the CTE won't have an effect on the second scan.
+
with dates as
+ (select min(dateint) dateint
+ from jlantos.sample_table)
+
+select *
+from jlantos.sample_table st
+join dates d on st.dateint = d.dateint
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Slow reduce - Spark Advanced Topics
+
+
+
+
+
+
Slow Reduce
+
Below is a list of reasons why your map stage might be slow. Note that this is not an exhaustive list but covers most of the scenarios.
+
+Not Enough Shuffle Tasks Too many shuffle tasks Skewed Shuffle Tasks Spill To Disk
+
Not Enough Shuffle Tasks
+
The default shuffle parallelism for our Spark cluster is 500, and it may not be enough for larger datasets. If you don't see skew and most/all of the tasks are taking really long to finish a reduce stage, you can improve the overall runtime by increasing the spark.sql.shuffle.partitions.
+
Note that if you are constrained by the resources(reduce tasks are just waiting for resources and not in RUNNING status), you would have to request more executors for your job by increasing spark.dynamicAllocation.maxExecutors
+
Too many shuffle tasks
+
While having too many shuffle tasks has no direct effect on the stage duration, it could slow the stage down if there are multiple retries during the shuffle stage due to shuffle fetch failures. Note that the higher the shuffle partitions, the more chances of running into FetchFailure exceptions.
+
Skewed Shuffle Tasks
+
Partitioning problems are often the limitation of parallelism for most Spark jobs.
+
There are two primary types of bad partitioning, skewed partitioning (where the partitions are not equal in size/work) or even but non-ideal number partitioning (where the partitions are equal in size/work). If your tasks are taking roughly equivalent times to complete then you likely have even partitioning, and if they are taking unequal times to complete then you may have skewed or uneven partitioning.
+
What is skew and how to identify skew . Skew is typically from one of the below stages:
+
+
+Join: Skew is natural in most of our data sets due to the nature of the data. Both Hash join and Sort-Merge join can run into skew issue if you have a lot of data for one or more keys on either side of the join. Check Skewed Joins for handling skewed joins with example.
+
+
+Aggregation/Group By: All aggregate functions(UDAFs) using SQL/dataframes/Datasets implement partial aggregation(combiner in MR) so you would only run into a skew if you are using a non-algebraic functions like distinct and percentiles which can't be computed partially. Partial vs Full aggregates
+
+
+Sort/Repartition/Coalesce before write: It is recommended to introduce an additional stage for Sort or Repartition or Coalesce before the write stage to write optimal no. of S3 files into your target table. CheckSkewed Write for more details.
+
+
+
Slow Aggregation
+
Below non-algebraic functions can slow down the reduce stage if you have too many values/rows for a given key.
+
+Count Distinct: Use HyperLogLog(HLL) based sketches for cardinality if you just need the approx counts for trends and don't need the exact counts. HLL can estimate with a standard error of 2%.
+Percentiles: Use approx_percentile or t-digest sketches which would speed up the computation for a small accuracy trade-off.
+
+
Spill To Disk
+
Spark executors will start using "disk" once they exceed the spark memory fraction of executor memory. This it self is not an issue but too much of "spill to disk" will slow down the stage/job. You can overcome this by either increasing the executor memory or tweaking the job/stage to consume less memory.(for ex: a Sort-Merge join requires a lot less memory than a Hash join)
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Regular Expression Tips - Spark Advanced Topics
+
+
+
+
+
+
Regular Expression Tips
+
Spark function regexp_extract and regexp_replace can transform data using regular expressions.
+The regular expression pattern follows Java regex pattern .
+
Task Running Very Slowly
+
Stack trace shows:
+
java.lang.Character.codePointAt(Character.java:4884)
+java.util.regex.Pattern$CharProperty.match(Pattern.java:3789)
+java.util.regex.Pattern$Curly.match1(Pattern.java:4307)
+java.util.regex.Pattern$Curly.match(Pattern.java:4250)
+java.util.regex.Pattern$GroupHead.match(Pattern.java:4672)
+java.util.regex.Pattern$BmpCharProperty.match(Pattern.java:3812)
+java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
+java.util.regex.Pattern$Curly.match(Pattern.java:4248)
+java.util.regex.Pattern$BmpCharProperty.match(Pattern.java:3812)
+java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
+java.util.regex.Pattern$Curly.match(Pattern.java:4248)
+java.util.regex.Pattern$BmpCharProperty.match(Pattern.java:3812)
+java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
+java.util.regex.Pattern$Curly.match(Pattern.java:4248)
+java.util.regex.Pattern$BmpCharProperty.match(Pattern.java:3812)
+java.util.regex.Pattern$Curly.match0(Pattern.java:4286)
+java.util.regex.Pattern$Curly.match(Pattern.java:4248)
+java.util.regex.Pattern$Start.match(Pattern.java:3475)
+java.util.regex.Matcher.search(Matcher.java:1248)
+java.util.regex.Matcher.find(Matcher.java:637)
+org.apache.spark.sql.catalyst.expressions.GeneratedClass$SpecificUnsafeProjection.RegExpExtract_2$(Unknown Source)
+
Certain values in the dataset cause regexp_extract with a certain regex pattern to run very slowly.
+See https://stackoverflow.com/questions/5011672/java-regular-expression-running-very-slow.
+
Match Special Character in PySpark
+
You will need 4 backslashes to match any special character,
+2 required by Python string escaping and 2 by Java regex parsing.
+
df = spark.sql("SELECT regexp_replace('{{template}}', '\\\\{\\\\{', '#')")
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Skewed Joins - Spark Advanced Topics
+
+
+
+
+
+
Skewed Joins
+
Skewed joins happen frequently as some locations (NYC), data (null), and titles (Mr. Farts - Farting Around The House ) are more popular than other types of data.
+
To a certain degree Spark 3.3 query engine has improvements to handle skewed joins, so a first step should be attempting to upgrade to the most recent version of Sprk.
+
Broadcast joins are ideal for handling skewed joins, but they only work when one table is smaller than the other. A general, albiet hacky, solution is to isolate the data for the skewed key, broadcast it for processing (e.g. join) and then union back the results.
+
Other technique can include introduce some type of salting and doing multi-stage joins.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Skewed/Slow Write - Spark Advanced Topics
+
+
+
+
+
+
Skewed/Slow Write
+
Writes can be slow depending on the preceding stage of write(), target table partition scheme, and write parallelism(spark.sql.shuffle.partitions).
+The goal of this article is to go through below options and see the most optimal transformation for writing optimal files in target table/partition.
+
When to use Sort
+
A global sort in Spark internally uses range-partitioning to assign sort keys to a partition range. This involves in collecting sample rows(reservoir sampling) from input partitions and sending them to the driver for computing range boundaries.
+
Use global sort
+
+If you are writing multiple partitions(especially heterogeneous partitions) as part of your write() as it can estimate the no. of files/tasks for a given target table partition based on the no. of sample rows it observes.
+If you want to enable predicate-push-down on a set of target table fields for down stream consumption.
+
+
Tips:
+1. You can increase the spark property spark.sql.execution.rangeExchange.sampleSizePerPartition to improve the estimates if you are not seeing optimal no. of files per partition.
+2. You can also introduce salt to sort keys to increase the no. of write tasks if the sort keys cardinality less than the spark.sql.shuffle.partitions. Example
+
When to use Repartition
+
Repartition(hash partitioning) partitions rows in a round-robin manner and to produce uniform distribution across the tasks and a hash partitioning just before the write would produce uniform files and all write tasks should take about the same time.
+
Use repartition
+
+If you are writing into a single partition or a non-partitioned table and want to get uniform file sizes.
+If you want to produce a specific no.o files. for ex: using repartiton(100) would generate up to 100 files.
+
+
When to use Coalesce
+
Coalesce tries to combine files without invoking a shuffle and useful when you are going from a higher parallelism to lower parallelism. Use Coalesce:
+
+If you are writing very small no. of files and the file size is relatively small.
+
+
Note that, Coalesce(N) is not an optimal way to merge files as it tries to combine multiple files(until it reaches target no. of files 'N' ) without taking size into equation, and you could run into (org.apache.spark.memory.SparkOutOfMemoryError: Unable to acquire 65536 bytes of memory, got 0) if the size exceeds.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Identify the slow stage - Spark Advanced Topics
+
+
+
+
+
+
Identify the slow stage
+
When you have an event log from an earlier "good run"
+
You can compare the slow and the fast runs.
+For this you can even use your local pyspark and calculate a ratio between slow and fast run for each stage metrics:
+
# Helper methods (just copy-paste it)
+
+def createEventView(eventLogFile, eventViewName):
+ sql("CREATE OR REPLACE TEMPORARY VIEW {} USING org.apache.spark.sql.json OPTIONS (path '{}')".format(eventViewName, eventLogFile))
+
+
+def createStageMetricsView(eventViewName, stageMetricsViewName):
+ sql("CREATE OR REPLACE TEMPORARY VIEW {} AS select `Submission Time`, `Completion Time`, `Stage ID`, t3.col.* from (select `Stage Info`.* from {} where Event='SparkListenerStageCompleted') lateral view explode(Accumulables) t3".format(stageMetricsViewName, eventViewName))
+
+
+def showDiffInStage(fastStagesTable, slowStagesTable, stageID):
+ sql("select {fastStages}.Name, {fastStages}.Value as Fast, {slowStages}.Value as Slow, {slowStages}.Value / {fastStages}.Value as `Slow / Fast` from {fastStages} INNER JOIN {slowStages} ON {fastStages}.ID = {slowStages}.ID where {fastStages}.`Stage ID` = {stageID} and {slowStages}.`Stage ID` = {stageID}".format(fastStages=fastStagesTable, slowStages=slowStagesTable, stageID=stageID)).show(40, False)
+
+
+# Creating the views from the event logs (just an example, you have to specify your own paths)
+
+createEventView("<path_to_the_fast_run_event_log>", "FAST_EVENTS")
+createStageMetricsView("FAST_EVENTS", "FAST_STAGE_METRICS")
+
+createEventView("<path_to_the_slow_run_event_log>", "SLOW_EVENTS")
+createStageMetricsView("SLOW_EVENTS", "SLOW_STAGE_METRICS")
+
+>>> sql("SELECT DISTINCT `Stage ID` from FAST_STAGE_METRICS").show()
++--------+
+|Stage ID|
++--------+
+| 0|
+| 1|
+| 2|
++--------+
+
+>>> sql("SELECT DISTINCT `Stage ID` from SLOW_STAGE_METRICS").show()
++--------+
+|Stage ID|
++--------+
+| 0|
+| 1|
+| 2|
++--------+
+
+>>> showDiffInStage("FAST_STAGE_METRICS", "SLOW_STAGE_METRICS", 2)
++-------------------------------------------+-------------+-------------+------------------+
+|Name |Fast |Slow |Slow / Fast |
++-------------------------------------------+-------------+-------------+------------------+
+|scan time total (min, med, max) |1095931 |1628308 |1.485776020570638 |
+|internal.metrics.executorRunTime |7486648 |12990126 |1.735105750931525 |
+|duration total (min, med, max) |7017645 |12322243 |1.7558943206731032|
+|internal.metrics.jvmGCTime |220325 |1084412 |4.921874503574266 |
+|internal.metrics.output.bytesWritten |34767744411 |34767744411 |1.0 |
+|internal.metrics.input.recordsRead |149652381 |149652381 |1.0 |
+|internal.metrics.executorDeserializeCpuTime|5666230304 |7760682789 |1.3696377260771504|
+|internal.metrics.resultSize |625598 |626415 |1.0013059504665935|
+|internal.metrics.executorCpuTime |6403420405851|8762799691603|1.3684560963069305|
+|internal.metrics.input.bytesRead |69488204276 |69488204276 |1.0 |
+|number of output rows |149652381 |149652381 |1.0 |
+|internal.metrics.resultSerializationTime |36 |72 |2.0 |
+|internal.metrics.output.recordsWritten |149652381 |149652381 |1.0 |
+|internal.metrics.executorDeserializeTime |6024 |11954 |1.9843957503320053|
++-------------------------------------------+-------------+-------------+------------------+
+
When there is no event log from a good run
+
Steps:
+
+Navigate to Spark UI using spark history URL
+Click on Stages and sort the stages(click on Duration) in descending order to find the longest running stage.
+
+
+
+
Once you identify the slow stage, check the fields "Input", "Output", "Shuffle Read", "Shuffle Write" of the slow stage and use below grid to identify the stage type and the corresponding ETL action.
+
-----------------------------------------------------------------------------------
+| Input | Output | Shuffle Read | Shuffle Write | MR Stage | ETL Action |
+|------------------------------------------------------------|----------------------|
+| X | | | X | Map | Read |
+|------------------------------------------------------------|----------------------|
+| X | X | | | Map | Read/Write |
+|------------------------------------------------------------|----------------------|
+| X | | | | Map | Sort Estimate |
+|------------------------------------------------------------|----------------------|
+| | | X | | Map | Sort Estimate |
+|------------------------------------------------------------|----------------------|
+| | | X | X | Reduce | Join/Agg/Repartition |
+|------------------------------------------------------------|----------------------|
+| | X | X | | Reduce | Write |
+ ------------------------------------------------------------|----------------------
+
+
+
go to Map if the slow stage is from a Map operation.
+go to Reduce if the slow stage is from a Reduce/Shuffle operation.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Slow writes on S3 - Spark Advanced Topics
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Slow writes due to Too many small files - Spark Advanced Topics
+
+
+
+
+
+
Slow writes due to Too many small files
+
Sometimes a partitioning approach works fine for a small dataset, but can cause a surprisingly large number of partitions for a slighly larger dataset. Check out The Small File Problem in context of HDFS.
+
Relevant links
+
HDFS:
+The Small File Problem: Partition strategies to avoid IO limitations
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Slow Writes - Spark Advanced Topics
+
+
+
+
+
+
Slow Writes
+
The Shuffle Write time is visible as follows:
+
Spark UI --> Stages Tab --> Stages Detail --> Event timeline.
+
Symptom: my spark job is spending more time writing files to disk on shuffle writes.
+
Some potential causes:
+
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Too Big DAG (or when iterative algorithms go bump in the night) - Spark Advanced Topics
+
+
+
+
+
+
Too Big DAG (or when iterative algorithms go bump in the night)
+
Spark uses lazy evaluation and creates a DAG (directed acyclic graph) of the operations needed to compute a peice of data. Even if the data is persisted or cached, Spark will keep this DAG in memory on the driver so that if an executor fails it can re-create this data later. This is more likely to cause problems with iterative algorithms that create RDDs or DataFrames on each iteration based on the previous iteration, like ALS. Some signs of a DAG getting too big are:
+
+Iterative algorithm becoming slower on each iteration
+Driver OOM
+Executor out-of-disk-error
+
+
If your job hasn't crashed, an easy way to check is by looking at the Spark Web UI and seeing what the DAG visualization looks like. If the DAG takes a measurable length of time to load (minutes), or fills a few screens it's likely "too-big." Just because a DAG "looks" small though doesn't mean that it isn't necessarily an issue, medium-sized-looking DAGs with lots of shuffle files can cause executor out of disk issues too.
+
Working around this can be complicated, but there are some tools to simplify it. The first is Spark's checkpointing which allows Spark to "forget" the DAG so far by writing the data out to a persistent storage like S3 or HDFS. The second is manually doing what checkpointing does, that is on your own writing the data out and loading it back in.
+
Unfortunately, if you work in a notebook environment this might not be enough to solve your problem. While this will introduce a "cut" in the DAG, if the old RDDs or DataFrames/Datasets are still in scope they will still continue to reside in memory on the driver, and any shuffle files will continue to reside on the disks of the workers. To work around this it's important to explicitly clean up your old RDDs/DataFrames by setting their references to None/null.
+
If you still run into executor out of disk space errors, you may need to look at the approach taken in Spark's ALS algorithm of triggering eager shuffle cleanups, but this is an advanced feature and can lead to non-recoverable errors.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Toofew tasks - Spark Advanced Topics
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Toomany tasks - Spark Advanced Topics
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Avoid UDFs for the most part - Spark Advanced Topics
+
+
+
+
+
+
Avoid UDFs for the most part
+
User defined functions in Spark are black blox to Spark and can limit performance. When possible look for built-in alternatives.
+
One important exception is that if you have multiple functions which must be done in Python, the advice changes a little bit. Since moving data from the JVM to Python is expensive, if you can chain together multiple Python UDFs on the same column, Spark is able to pipeline these together into a single copy to/from Python.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Write Fails - Spark Advanced Topics
+
+
+
+
+
+
Write Fails
+
Write failures can sometimes mask other problems. A good first step is to insert a cache or persist right before the write step.
+
Iceberg table writes can sometimes fail after upgrading to a new version as the partitioning of the table bubbles further up. Range based partitioning (used by default with sorted tables) can result in a small number of partitions when there is not much key distance.
+
One option is to, as with a manual sort in Spark, add some extra higher cardinality columns to your sort order in your iceberg table.
+
You can go back to pre-Spark 3 behaviour by instead insert your own manual sort and set write mode to none.
+
+
+ Copyright various authors 2022-2024, CC-BY-SA 4.0
+ Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Keys
+ Action
+
+
+
+
+ ? Open this help
+
+
+ n Next page
+
+
+ p Previous page
+
+
+ s Search
+
+
+
+
+
+
+
+
Error - Spark Advanced Topics
+
+
+
+
+
Spark Error Flowchart: Note this uses mermaid.js which may take awhile to load.
+
flowchart LR
+Error[Error/Exception]
+
+
+Error --> MemoryError[Memory Error]
+Error --> ShuffleError[Shuffle Error]
+Error --> SqlAnalysisError[sql.AnalysisException]
+Error --> WriteFails[WriteFails]
+Error --> OtherError[Others]
+
+Error --> Serialization
+Serialization --> KyroBuffer[Kyro Buffer Overflow]
+
+KyroBuffer --> DriverMaxResultSize
+
+
+MemoryError --> DriverMemory[Driver]
+MemoryError --> ExecutorMemory[Executor]
+
+DriverMemory --> DriverMemoryError[Spark driver ran out of memory]
+DriverMemory --> DriverMaxResultSize[MaxResultSize exceeded]
+DriverMemory --> TooBigBroadcastJoin[Too Big Broadcast Join]
+DriverMemory --> ContainerOOM[Container Out Of Memory]
+
+DriverMaxResultSize --> TooBigBroadcastJoin
+
+ExecutorMemory --> ExecutorMemoryError[Spark executor ran out of memory]
+ExecutorMemory --> ExecutorDiskError[Executor out of disk error]
+ExecutorMemory --> ContainerOOM
+ExecutorMemory --> LARGERECORDS[Too large record / column+record]
+
+click Error "../../details/error-job"
+click MemoryError "../../details/error-memory"
+
+click DriverMemory "../../details/error-memory/#driver"
+click DriverMemoryError "../../details/error-driver-out-of-memory"
+click DriverMaxResultSize "../../details/error-driver-max-result-size"
+
+click ExecutorMemory "../../details/error-memory/#executor"
+click ExecutorMemoryError "../../details/error-executor-out-of-memory"
+click ExecutorDiskError "../../details/error-executor-out-of-disk"
+
+click ShuffleError "../../details/error-shuffle"
+click SqlAnalysisError "../../details/error-sql-analysis"
+click OtherError "../../details/error-other"
+
+click ContainerOOM "../../details/container-oom"
+click TooBigBroadcastJoin "../../details/big-broadcast-join" "Broadcast Joins"
+click LARGERECORDS "../../details/failure-executor-large-record"
+
+click WriteFails "../../details/write-fails"
+
+
+
+
+
+
+
+
+
+Copyright various authors 2022-2024, CC-BY-SA 4.0
+Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Keys
+Action
+
+
+
+
+? Open this help
+
+
+n Next page
+
+
+p Previous page
+
+
+s Search
+
+
+
+
+
+
+
+
Index - Spark Advanced Topics
+
+
+
+
+
Spark Error Flowchart: Note this uses mermaid.js which may take awhile to load.
+
graph TD
+ A[Start here] --> B[Slow Running Job]
+ C[I have an exception or error]
+ A --> C
+ click B "slow" "Slow"
+ click C "error" "Error"
+
+
+
+Copyright various authors 2022-2024, CC-BY-SA 4.0
+Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Keys
+Action
+
+
+
+
+? Open this help
+
+
+n Next page
+
+
+p Previous page
+
+
+s Search
+
+
+
+
+
+
+
+
Shared - Spark Advanced Topics
+
+
+
+
+
Spark Error Flowchart: Note this uses mermaid.js which may take awhile to load.
+
graph TD
+
+
+OHNOES[Contact support]
+
+
+
+
+Copyright various authors 2022-2024, CC-BY-SA 4.0
+Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Keys
+Action
+
+
+
+
+? Open this help
+
+
+n Next page
+
+
+p Previous page
+
+
+s Search
+
+
+
+
+
+
+
+
Slow - Spark Advanced Topics
+
+
+
+
+
Spark Error Flowchart: Note this uses mermaid.js which may take awhile to load.
+
flowchart LR
+
+SlowJob[Slow Job]
+
+SlowJob --> SlowStage[Slow Stage]
+
+SlowStage --> SlowMap[Slow Read/Map]
+SlowStage --> SlowReduce[Slow Shuffle/Reducer/Exchange]
+SlowStage --> SLOWWRITESTOSTORAGE[Slow writes to storage]
+
+SlowJob --> TOOBIGDAG[Too Big DAG]
+SlowJob --> SlowCluster[Slow Cluster]
+
+SlowReduce --> PAGGS[Partial aggregates]
+
+SlowReduce --> TooFewShuffleTasks[Not Enough Shuffle Tasks]
+SlowReduce --> TooManyShuffleTasks[Too many shuffle tasks]
+SlowReduce --> SkewedShuffleTasks[Skewed Shuffle Tasks]
+SlowReduce --> SpillToDisk[Spill To Disk]
+SkewedShuffleTasks --> SkewedJoin[Skewed Join]
+SkewedShuffleTasks --> SkewedAggregation[Aggregation/Group By]
+
+
+click SlowJob "../../details/slow-job"
+click SlowStage "../../details/slow-stage"
+click SlowMap "../../details/slow-map"
+click SlowReduce "../../details/slow-reduce"
+click SlowCluster "../../details/slow-job-slow-cluster"
+click TOOBIGDAG "../../details/toobigdag"
+
+click TooFewShuffleTasks "../../details/slow-reduce/#not-enough-shuffle-tasks"
+click TooManyShuffleTasks "../../details/slow-reduce/#too-many-shuffle-tasks"
+click SkewedShuffleTasks "../../details/slow-reduce/#skewed-shuffle-tasks"
+click SpillToDisk "../../details/slow-reduce/#spill-to-disk"
+
+click SkewedJoin "../../details/slow-skewed-join"
+click SkewedAggregation "../../details/slow-reduce/#skewed-shuffle-tasks"
+
+SLOWWRITESTOSTORAGE[Slow writes to storage]
+SLOWWRITESTOSTORAGE --> TOOMANYFILES[Slow writes because there are too many files]
+SLOWWRITESTOSTORAGE --> SkewedWrite[Skewed Write: when to use Sort/Repartition/Coalesce before write]
+SLOWWRITESTOSTORAGE --> S3COMMITTER[Slow writes on S3 depend on the committer]
+
+click UDFSLOWNESS "../../details/udfslow"
+
+click PAGGS "../../details/partial_aggregates"
+
+click FILTERNOTPUSHED "../../details/slow-partition_filter_pushdown"
+click SLOWSTAGE "../../details/slow-stage"
+click SLOWWRITESTOSTORAGE "../../details/slow-writes"
+click SkewedWrite "../../details/slow-skewed-write"
+click TOOMANYFILES "../../details/slow-writes-too-many-files"
+click S3COMMITTER "../../details/slow-writes-s3"
+
+click TOOMANY "../../details/toomany_tasks"
+click TOOFEW "../../details/toofew_tasks"
+click NOTENOUGHEXEC "../../details/notenoughexecs"
+click SHUFFLEPARTITIONISSUES "../../details/slow-reduce"
+click READPARTITIONISSUES "../../details/read-partition-issue"
+
+
+
+
+
+
+
+
+Copyright various authors 2022-2024, CC-BY-SA 4.0
+Documentation built with MkDocs .
+
+
+
+
+
+
+
+
+
+
+
+
From here you can search these documents. Enter your search terms below.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Keys
+Action
+
+
+
+
+? Open this help
+
+
+n Next page
+
+
+p Previous page
+
+
+s Search
+
+
+
+
+
+
+
+
^lgVEPBX5Gh_bo8QSSFY{vM^4hsD-mzHX!X?>-tpg$&tfe27?V1mUAbb}
z1dVewCjIN7C5$=lXROG%
zX4%HIa)VTc_%^_YE?u@}#b58a4S8RL@|2s`UUucWZ{P9NJxp5Fi!#@Xx+(mZ+kdt3
zobw#*|6)Z(BxCGw^Gi+ncRvs|a|3xz=tRA9@HDV~1eqD)`^`KTPEg`UdXhq18})-@}JTHp30^)`L{?*
z;c)alkYAc@67|W!7RDPu6Tsy@xJCK8{2T9-fJw6?@=A(w^}KCVjwlOd=JTO=3Zr+<
zIdd?1zo-M^76}Jf!cpLfH`+2q=}d5id5XLcPw#xVocH5RVG7;@@%R>Sxpy8{(H9JH
zY1V)?J1-AIeIxKhoG1%;AWq7C50ok3DSe?!Gatbry_zpS*VoS6`$~lK9E?(!mcrm1
z^cLZ1fmx5Ds`-ethCvMtDTz
zMd=G1)gR$jic|1SaTLaL-{ePJOFkUs%j634IMp}dnR5yGMtsXmA$+JDyxRuSq*)bk
zt3tSN2(J<@ooh3|!(R%VsE#5%U{m-mB7fcy&h(8kC(#>yA(JCmQ6|O1<=_U=0+$AY
zC)@~M`UboR6Xm2?$e8Z$r#u8)TEP0~`viw@@+){#874R?kHRP|IU4&!?+9Cy52v^I
zPV4Xd{9yc;)#l?0VS#6g@
z`#y))03Laq@^6Z#Z*uvzpl{$JzFJgn&xHlNBS|Eb!E@}~Z$^m!a9k34KX
zT|VETZ;B_E$Ai8J#t5#kATCAUlqbr&P~-s)k^FfWyz}iK@`B$FI6L0u1uz5fgfqgU
zRBmB>F8s_qp1HWm1!aXOEbpf`U?X|>{F`8Md500U3i;Mh9Kvbd(CeuC>077ww4g^h
zKgM(A48W`XEDE~N*Th^NqP#S7&^w2Vpq+df2#@A*&4u~I+>t)9&GYcop9OtUo=;2d
zGSq?IMBAYZffMC1v^|Z|AWdQ38UdJS4(H(nFI<|%=>0iAn3lvcSjIR(^7r7QuQI0a
zm+@Z9QXmf!efG1**%Ryq_G-AQs-mi^*WO#v+tE9_cWLjXz1Q{L-uqzh
z-Vb`UBlaT|M;ecG9GQJ&>5)s1TzBO5BM%;V{K#`h4juXPkq?e&N9{)|j&>ZKeRS#3
zOOIZ6^!B3<9)0}ib4L#y{qxZe{ss8}C5PC)Atkb2XK%PS)jPMht9Na0x_5hTckhAT
zOz+FRJ-xk0*b(QE(2)^GQb*<<={mCZNczb3Bi%<19LXGc`AE-^-lOcO^Jw^J>ge2~
zT}Rg*O&{HUwEO6RqnV>GAMK$M`~TX%q<>-my#5LOBmex)pWgq|V@{jX>a;k`PLtE<
zG&ohK;*_0|<6n-C93MK4I*vGc9shKE;CSEhp5tA|KOBE|yyJM=@i)g?jyD~Db^OKg
zhNH*vXUCr$uRH$ec+K$#$E%LtJ6>`8&T-iBTicKH)SNMZS
zB8UG!{1{Y=QL&oLMgLzR(}0Y>sN0TqgG|kLqv_VcVSLD)aJ?AC^D!bLa6K5Ut1)YA
zghRXq;YBrYhrzOK23vXorq6v~v*CBb?*bYw$l-3J@cY5H}8Gr;t8{e8!J}L*5e>!hOQnM3g=8eoXDiYZBlmBW?=(Qvo;ib;hP4-|5>J
zo6*MD%*UW90?aI=ncV;fJZB$fY|a73<^rd=!0(I%TsLE9TH#hRHV<&~b~82~@n<2=
z1-*oTQL{zWh}4H
zGjX>}SbW{R;(k^VBouiebp<&Q9S1P`GIlM(uLaz7TNt~37h`FJ-B1j-jj@}iF}B$Yhy1^cv|oM`3X|20-GXwq
z0QapK#%@FUZ9ik|D}cWpad#li_7EK6?wrrq4l5kOc5H@2*p5ENc6Pxb%`OEl1=q{i
zU1`Sdjxcu562^8fWbEEDi1(A=o?`5)DC_=i#vVX^45ZpSrpE35`g>WA+_QYDo!1%Byk?;4A*Y^%H_McC{^)mJp(mf6Mr$1rr8Klp<
z@9$&m+0Bd{OfmMH!q^XxU*>tneq@E)#@LU6-}5Nz`DYpXi4*QA#$MRP*w045^)U8x
zl=XAu_Y36n%QPIqUi^r$mjH7JWgdEmv0oiv>}BNj>jtO;GSSiGr=LO--M;f3$4%-kcdA5=kp1;?w1)iU%_3WyqWQmjf@AcVZ3xc<7I~#
zFHgbYU4b-}3LN4>NEZft6=17@TlH$jBZ!NjjQC2%Yu;hJu9NWwZ@DynQp=tBj8Wjw$e9<5A{>pD{iW
zZqogXPX_!HxT$LypN98z;4>ox_a@^r4>R7`&G@Wh#%HG(p9^;e{AczsK5r7^^FxfE
z1>DZ=f&=UVl(8@Y2be_)+!n?cUjPUAC8+bcuQI+Aab3F@Uxu=lJpt$oQq38DE=X{7U3=m6P!eKVy6&>UK5q-?WYKFCon}
zcwbuv_Xy+HBi;48;XYwJy_)eGknfFvzbOHS_{~WFRt)zJ
zijpU?=0x
zkwe%IkXL3J<39wBKYX6?A1iQgGX8uw<3E|t_zN{~?=k)}E8{7uHGX6%I@xLJ5o5hU3g}A@9GyXR4dV3$^??m7ZGyeD0jQ;~={sZ6d0>}3fa8JQ~
z#Q6Kj>z^jLM;Px_;9g|>2lp6?Oy32JW8UD|ZH#LugXW9=mzl&9Ov2uUBsVZgS;-{zFeKKwOfnbOFe$i&Nu~HMe}YLB^Wk1(Qs^2cg^_pF
zV@!&4GARo9*fb`^0bBDClWMmysSaUvuQREB7n2(BZbV*M)y$0@8CXG!nX&m5FyO}f|^_bYrq)EtQ3jEW$
z;E;a$iwt`}|2xOlf`@fNIFLzjYz@1@vMcQB;TbKpR_b1>hK{W@uw#sVI6JqW86H;C
ztQ;P%k-Nf8ey^cATop^SG>2V0mP~Z;=5SL5H#}UQ-NIABSS;9=rYBEjx70^!0%|%?
z6H%vBBRb1si5UK{xwWyrI#6mdl~NhlB{DFSQ4f#HYnQ4Tr9_9++!S!BCwdbtt-PhV
z2|9^MD=%7f(aK494ZCcz4t6dY`X;_62ywrIPovV+sT0pH?+{mwxjh%^>
zh_?T`uiv2^KX}>z4HVY!Y%V1QDcBvi>!sD@MEbj99(bg@lcBxTD9~gYzfIm>7jFFl;^hEgOD8Clhu+6jw>0z&OhJ=2DoJ42R3QaA
zWOOLCseE6;o!xG!?ra~f^>o~D+1yBE?qxT0^k{Eo?@YU;MW)Dk7u-Ja^-t=jry`Nm
z^!iU;|I=I9eR|&CLf`eUDtM5Q2iZ}-MO8dOpsgMv)7Ge`r77T1(I!FduCuw%>+xyh
zv~lQApLDjitE7#8{D!C9^9KL8O}^S6)E?BVMw_qP`rdoia-YG@KjOf%Qh4Bnt8Mcoi9h#JRYY3kEvn*UVbReO50BrmV+
z;MZw4c4)uX7XS38vL%mZ(`R5ww4GL|?R_+gqd5vmpyBRdmy(bdo1(0=sB8@yxdn)~lxbJjigu9=)pPhNBHJ@OCr@Hfy7
zMKpelG=3bck_~6$*c^5qw$ra?cd)OqZ$smlOvLJWm7$z_{bM*t_;dW+m52!n&yhSI
z0)LYKbKpO(yrBb!r(;1ei=F17uvjq5XquDp?1L{4s1~Hu@I46id3j>UeJTcx0fQ!$
z&o9RBJJn}4D52n3P@|_Z2y%SzQ!WJ22E$LC;WNiX*{T?@;Pj!}DC|#~nZ>-HpIS<2
za>P22_kUiz%sLYqOLTT7B=H>lmeZ$;kr+*xoe54)>BRz1U!muO7@@$$G=552gn*!9
zJ(lYeq-%(OX#D?e|IqRz)>flsYTDXrc#58b-%`5Jmp#FEV%&+o&w?z>k%vUF^x&@!
zd}aqf<-yN_(1OoX0~BNi5+XV}sW1Mo_rky5sw&#MPqeg*Iv+ow^-qi|g!>=1)d@|(
zIJ=tJ4Yw%YfhiFbenxIIR1N1mmKeveFq!eFI?k+2%4<3`YlV3hM
zS45R<;g^uVtW5iZbSGet@1^}8sBUEktA@_c>)?i}IE-EQTR@N-j%b9$Syc1{S3U?8e~d3B1?Lij0H27USiF&gR}A>wG-vBGIPuh*4ry;{Khxekv}wCTm%_>vhFZSJ)Pw2iv6Q4YVoQ`J2w?yCkiavVTWeVa)j|q=T9@J0pTtcQX!VHnIM6Al-
z^*7Og!1y$xN4)5fYK&2X5x-Om4A;1k20|=O+$wl^1T}IRHkcq<^P$a{C0fAii(ypB
z{ef1n(U1a&g|>5}zY?N{!tOqN_uYr3yPejjJ>KeR7IW!#ztw(g!*Hj~SpH|bkC%t5kd^Q2w*f{D8tJPwQ
z++kT&2yEHVY_jXXBg!P7SUbSC;y1@rj$sqoMWF2=y$%ua1S%Nn_dvGwR*;O^!Fd?1
z8#WkKL1{>+GcdW?sX2^RC#k8D;~{~1M4#fpPxGDbOWPf?oRS^(Y!}arFj}-9Ta5B$
zZhP0#34P$Fx`;w}a*AU%t?#oPQ+U$umO}+(WIxS!wnBcQuM;%yiYhbKnNwXa7LiRjmf+(2(ZG}wiz%sgWJi>jgGIsPnZ=KfX?8mJ2^L!4-hBx#UR
zZa((80+3k2t!n9h@La(dm&Qrs_teRTeB}Y=
zShqm6zJdPGS+juA6^_Mu3_1sz1Hvx#*|M6pnqz`jk<&F@Wt;g%i&gunm7lM5)wE@q
zvbn6Q=6IU;C_@UMWs|fmylAcBqr(MowarQT7@9BsXzyH534G
z1e0`Rlnqb_RAIW{M7dQoxdg$
z;&VZRA?1jrgF9nN0lg?)7VU>c#YI}iVKVtMV&I^SUL2sA9Xn2<8mY@_)qZF;^OV!$
z;QVMjZTMUtC^eDXuo)DkX75sJ*#d6g{w?U1!Fbwid(nlSiF_z
zStRqVrV`8MJBg{|ZM^Kzrps2`fI(Eq&qUZ%VCjWLQn)GthGkFz0LcT(tUy)_i~PWb
ze1obC@Hu0-n}r4LO@8%lp3+uoAMDWnx#|WFhG&pQo@eXSCzjp(&Xl4$kfY60LiIx^
zs+SA=sm(K<-^V>WxOdf!NXC0qN&86q?xh#r;L)>)B|KXvOuO+4*98HO?4jfcxpk`^
zU^8+npM|PWn*7Nj9O_U%@pt)^gcu2m|17^}h}J6KWCJ>t
zv@Qsc2z0711@V0%PDVqW?i)a)=GC>nC+Kx~*FeS}p5iNes=&dpY_lv9^<|K`GOJMG
zE5^7&yqgjFK*qz6I-su3QFo4`PbRSbk|gNIa3+>jPUVH}5I6C)+!U&5lUe4HyYIe4
z>&a$lqL(n;XP)9F?USc6ZA6!;oE+i8ksYGTfe8;xbPFg9e&VVdrRpkO9Zch#cxJH7
z%@Bt~=_%2;shO9|R5K-|zrSznwM%ZBp3!<;&S0$4H~PJ&S3PrGtf}StbLZKDF_le=
z9k)|^Do10}k~3$n&#EP*_H_-3h8^ZuQ2JXaU@zY|dW@$oQAY%Z@s0V8+F~YQ=#aqp
z=je#~nV5}oI1J`wLIQ^&`Mj01oDZ;O`V>BvWCRJd%56g!((T@-{aY6fa;a0Vs+v@O
z0IK2dXum&DKB?-ese^F~xB8#t6TFirdTy3(-MedKc;2cI&D}ztv4^I%ThCj*
ziyQ90UpuyI`FYm%sUlWqP(!Qcg-7n%dk-&uY15{cw0HD+gbuz}CQP*u8*(+KCYFiz80m1pT=kmx0(q(xrCPMsUH1k{mefDSp)
zD5G^q?m1N%Jbl&_iz65-uBs{~7YjNpQ%+H^=H7i%nHnwimHSGDPZ(Z;cWG1wcZw|v
z%*juq&!(bo!`O7T>Wkon^QZ-rLvkd_^z#)5Hg
zxufObryg!`lzZc#{xRRv6592P5fce0Hl-xEm^*nBcP$v
z0`KR64y6=xK{a*oNxW9jv+9)$I9SxN-Oig_c%UK7hZDj_WEb$BDlO#*M?@b>eU7
zxN!%UE+w#Wg$bqFfc#
zeDOpwnoY)%(93rx(=q9nQKg6?XKJZrRP#oo(u>h_l6NOMld)_IF(
zs6M+iRmTC+ALc}C7V>JEuRjk9o)*YO8Y}oKQNl2t?D;qFLv4U`StSyoFzFYuq>i@C
zEa1!N?B0BK0gjTwsL04McVmu=$6B!!-4bi1u_j7ZpCQm-l2u7AlYMmx
zH!4a*@eEhENs{b-gUMy{c*AjMjcwAWGv@lW4YQtoQvvf*jQ2wL8+EGF4rQjAc;uiEzG%4uf
z9wX{X3(U5*s$>6M
z)n+q=_&#l6nEa|4ez8YOb9q{(?8h1|AYN<53x+g()8?U_N+)sEV;tdoV{pJ^DTD)ZvO|;^t&(V6L2z~TSiWu
zI&#bLG#NGMHVY^mJXXH_jBGA?Np1q;)EYzS3U=1VKn3aXyU}xGihu`L8($R|e#HpJ
zzo`QozgXO&25>bM*l>oHk|GV&2I+U-2>)u7C$^yP7gAuth~}8}eO^2>X_8+G@2GX0
zUG8;wZgm*=I4#ww{Ufg2!~-Uu*`{`!$+eE)in1}WPMJ%i|32CjmFLR8);bg^+jrF*
zW0A!Zuas6whwVl!G+Vp(ysAHq9%glv8)6>Sr8w=pzPe1s`fRb9oO^yGOQW^-OZ=5?
zNNaJk+iSAxa}{PtjC&tu_+{8J_cw=JiFhMqFC!}FHB@j}@Q$b&*h-^U)Y&U$fDWad
zC!K&D&RZgww6M(~`@DA92;#vDM1_`->Ss*g8*57^PdIP-=;>u#;wD4g#4|T7ZytTY
zx(Q8lO+5Ris0v-@GZXC@|&A*DPrZ51ZeSyziwc>%X>dNyCAL
zOSDTJAwK7d2@UOGmtsjCPM9{#I9Gbb7#z25{*;Tyl-Zho(Oh~-u(5CLQl;2ot%#Nl
z_cf{VEA=LuSylKv$-{%A=U+QBv0&8bP;vDOcU|zc3n!Nu{9=5j6^6DL&6tm-J4|~)
z9#1w(@m3N|G3n9Xf)O<|NO+P)+F(TgqN3E#F8`eIrDZn0=@MQ%cDBb8e*D_eBUXH+
zOtn|s5j9y2W~uaQm*j{3fV=j|wxar?@^xjmPHKMYy0eTPkG*<=QA$Wf)g`tfRlZ0v
ztEyRwH(8<%&+zbQ+pg>z^Ucf8Jj>x$N*h{buawh;61^S+&ZX>H^j?#nw!}!~35^Z#
zqU|=INy-tBD+E^RCJdtvC_M2+Bx*2%C6nTfGS!1b*MJvhKZZPkBfkjIFf@kLBCdo)
zszai4sxmBgklbZ>Iqddc=N%2_4$qxi==t>5E!Ll+-y(NJc+^l)uMgMZH+KM<|+cUS^t~AUy&z{UpW?AA~QO;;xntfuA^Rj7SU%j)&
zVs~)K>u%=e(ooP|$In{9cdb}2l?KYZinZ8o+i;N-baM#CG$-JMDcX1$y9-L(TsuaT
zfPY9MCb3xN8WGxNDB@4sjvZ10JTUS1Snvy5l9QPbZJ1#AG@_xCVXxndg&0Cz99x`Z
zKvV%^1YbB2L)tU+ww(e6EZYzc6gI5g;!?*}TsL=hotb0Mow8kxW*HVdXfdVep4yL`
zdfTcM*7nwv5)3M-)^@ASp~`(sR`IsMgXV>xPx0&5!lR8(L&vn@?_Oi2EXy)sj?Q8S$Mm
zP{=PsbQ)rJtxy*+R9EqNek1fupF(7d1z|uHBZdEQMm`l!QnDTsJ_DX2E=_R?o*D5)
z4}Rh2eEvVeTQ^UXfsDXgAf@6dtaXG>!t?(&-a~B^KF@z*dl$BLVOt|yVElz!`rm5n
z&%<$O{7{?+>7|f%3ctTlD}Sc0Zs_hY;YO-&eOIT+Kh%FJdM|_@8b7qIL;aj#^MhF1
z(>x4_KPKYTl+AOj0Q$t3La4&;o`HP%m8bgb`*0vs83ZT@J#{j%7e8dKm;){k%rMw*
zG9eKbw_mh1PHLUB$7VNcJ=oL;nV~#W;r|rv;ISD5+Q-FH5g~=&gD`RrnNm>lGJ1GE
zw`K+PW!P*uxsEyAzhLvBOEUkj>)1sV6q-RhP*nGS(JD%Z$|wijTm)a5S+oj03MzBz
zPjp$XjyM!3`cFtv`8wrA`EpL(8Soof9J(X7wr2l^Y-+>){TrmrhW&h}yVPonlai>;
zrF!_zz4@5^8y@95z(7+GLY@+~o<>}!RDp|@N4vi4Y-r@AF@6Q7ET8d9j~&O$3l#Yuo`voKB12v8pK*p3sJO+k{-
zak5sNppfOFju-S9tC#^&UI}&^S-3TB^fmi<0$e%==MK3AqBrn!K@ZCzuah-}pRZc{
z?&7p`mEU5_{>6x=RAFr4-F+FYOMN%GSL@mvX-UT3jRI;_TJH7}l*La_ztFn+GQ3;r
zNk;eb?nh&>e?Z$I<$LDON!e1tJ26yLILq`~hFYrCA|rj2uGJHxzz@8b<}
z&bETBnbLPG9E*iz!<03Ld4q;C140%fzRO5j*Ql#XY*C-ELCtp24zs*#$X0ZhlF~Qj
zq$4Nq9U@=qSTzHghxD(IcI0@hO0e}l7_PKLX|J5jQe+67(8W~90a!?QdAYyLs6f^$
zgAUsZ6%aIOhqZ;;;WG@EpL1!Mxhc_XD!cTY%MEAnbR^8{!>s|QGte5Y=ivx6=T9Ei
zP_M&x-e`XKwm+O(fpg~P{^7QV&DZPW)$j@GX#kClVjXN6u+n=I$K0{Y-O4?f;0vgV
zY+%5cgK;dNK1}{#_x-Zyaw9sN`r9jST(^5&m&8IY?IBml#h0G3e?uSWfByzKHLe8)
z9oCU{cfd~u97`w2ATe{wQPagk*)FX|S+YdySpplm-DSKB*|c>@nSp$=zj{v3WyAgw
zqtk_K3c5J|0pC
zSpww86>3JZSitYm_b*{%7cv?=elhCFy1v6m)^n?211803vG_;TRU3WPV`g7=>ywvsW6B76c-kXXYuS7~J+@Lc
zSf%7^`HIJ4D|VX9{BlBG~IV;M->JId%#U?}jR@kQ&o5A3HyYDx}6Nc^pMjj0Jeun)M=&7-NLZ9@2
z)j60}@#z8oft^qhO`qgPG;Gf4Q@Zbq!Fx_DP1GkX<}_%EF`!5fg*xCsir}$yMH#85
zT3Y4bdV)bucC=X;w24>D>XjaA@K`En^++$6E!jmvauA$rc9F%b=P&f^I7M+{{--HM
z0JXFl21+}*Oz8zr@T8JQp9Td0TZ7rr0+&rWePPKdaG}l-^)$@O*ON;2pkAjf4ZSg#
zy{PLo>hhTUUK_q5L{o!vKb^7AIkbXB
zm3BG{rbFE>fKfZsL4iKVYubQMO_AvYWH<3F_@;7*b}ss*4!r5a-5Mr{qoVbpXW1cja+YCd!nQ3xt*CEBq_FNhDc93rhj=>>F59=AN5
zoRmKmL))oDox0VF;gltwNSdcF9cb*OX3{Gx?X{Q-krC~b9}_3yG8Bn{`W6m}6YD#q
zAkEzk)zB|ZA2Ao`dW^gC77j#kXk7>zOYg~2Y0NyG9@9L)X=yRL!=`tj7;
z^S=K3l)dWTz%eniebMP!Z)q@7d(l_cR;2OvPv7I~Va{X>R@4XXh-
zOMOMef=}m)U?`>^E`qUO(+Ng$xKwZ1|FQ|>X41&zvAf`(9
zj3GGCzGHqa8_lMGV+Q3A(d5seacFHJ92meB0vj+?SfQ~dL#3UE!1{}wjz|HPWCEHI
zW{zYTeA(UwAEq6F%|@%!oD5ebM$D`kG45gkQ6COfjjk-==^@y6=Tp0-#~0px=I@H#
z7Z|LQii;EBSfjse{lo}m?iuTG`$i6*F?L9m*kGMV_JUqsuT##HNJkrNL~cklwZK&3
zgesq4oycISoHuCg>Jo;0K(3&I(n-j7+uaf)NPK7+@p8+z!=r!xa45cmV`Mna1hT=i
zAkgv-=xDHofR+dHn7FZvghtoxVqmi^U=Tk5i*(?UbiEGt9|mBN4tXfwT0b
zIQSzTbod84Y<){2C!IJja=k65vqPM|!xFS?-HOK!3%&6=!T(Z$<>g6+rTpioPBf57
z$!8fVo=}&Z?KB-UB4$>vfxffiJ*^StPHhnl@7Fw@3-N|6BAyp|HhmV#(r=Ll2Y3af
zNJ44J*!nZfs0Z5o%Qy|_7UzOtMt~9CA*sTy5=4c0Q9mP-JJ+p-7G&*PyD$6sj+4b>6a~%2eXf~A?KRzL4v_GQ!SRxsdZi`B(7Jx*fGf@DK
z&P<|o9z*F!kX>I*;y78=
z>JB#p1zld#NFeK3{?&UgU*1uzsxF7qYP34!>yr;jKktE5CNZ3N_W+965o=}3S?jx3
zv`#Wqn;l-4If#|AeD6_oY2Y||U?Fss}Sa>HvkP$9_KPcb_jB*Jc;M0XIE+qhbP$U2d
z&;h?{>;H=Sp?W2>Uc{rF29ML>EiCy?fyim_mQtrgMA~^uv?&@WN@gUOPn(379I}U4Vg~Qo)jwJb7e_Pg^`Gmp+s5vF{tNzJVhBQ
z$VB8M@`XJsXC!-){6wetDsTY94
G*yFsbY~cLNXLP73aA74Mq6M9f^&YV`isWW
zU@CY~qxP|&bnWBDi{LM9r0!uDR`&3$@xh)p^>voF;SAaZi_ozepkmLV+&hGKrp0jy9{6cAs)nGCitl6Cw2c%Z0GVz1C
zH-$3>en`tRh)Z(8))4y=esC5oyjkopd;K_uLM(K16Uoowyo4@9gTv5u=A_uBd0McB
zG~8g=+O1_GWtp;w*7oD;g7xT0>D9KH`rx%cs^JH~P_@+@N5^&vZtAIXZ@TH+Rb$iX
zv8(8dKV^46(Z&yFGFn4hNolFPVozn;+&27G?m@2LsJe7YgGEHj?!M`nn`S-w=q$Y4
zB>(63Fnnw_J_&IJT0ztZtSecc!QccI&<3XK0KsV4VV(j@25^A-xlh_$hgq6}Ke~GZ
zhiQV3X|Mlv6UKb8uXL$*D>r^GD8;;u+Pi;zrDxZzjvWE#@cNGO`q~o7B+DH$I?5#T
zf_t7@)B41BzjIgI68Bcci{s-$P8pU>=kLG8SB$x;c&X=_mE3UN@*eF+YgP|eXQVn)
z)pd&9U^7r1QaaX{+Wb-9S8_jQZC19~W)
z*_+RuH*MPD=B_m7we#2A@YwQv$kH2gA%qk7H)?k!jWbzcHWK497Ke<$ggzW+IYI2A
zFQ_A$Ae4bxFvl4XPu2-7cn1vW-EWQ6?|>Qm*6uI!JNaRLXZFc5@3r48t0~)bwpU*5
z-KNE}N45AiuXh{&18l_quuV$6w|?c-PtzqcPhY)q{d+Hc_@OkartG`dddteZXK&Je
zGpYJ-+PmEUR`sOnx42*X$6KT~@9ze#J>YvvaN24jI}4QG3M;w<>~!2i@r)9lI!6N1
z0GN((xJjHUB^|#9vJgy=07qv}Kw>zE+6qQns-L}JIqLFtY3pDu_$~YrZOO$WEpF>3
zXTu#w7J9w+@)x-6oW(5`w;GI8gk@*+!5ew8iD$g=DR*n@|2*R`zxe7azdr7~Z;$%<
zSH@*lQ9U(Hx^%Fb|1?Smv({(NaZW+DGsnNWwX(DFUG8)(b6Rn>MzUxlZhNbVe>`mS
zl&aJjk3F~9{lT-}y>e~pI}kOf@0^%Vdj&m(iK4LTf6kmF!_0HQ$`f-eBnmdTsf$_3
zR`hz2EjKIKWL6z@jj1}us>ZmY)iQInPifzSiOFN92j9$pX*CuV8SPrD#b%Qa97~TI
zS6)?BPUgFnkqG8{{HUwd)%ZsvurI~=Jr8YSkhUA!RANJ;o|D->9S9QB5DxTybH&PGFtc0Z>dLwr|Ah}aX`XwTtE&UssYSEILtNijh)8)WWjMm$uT;+p1|=L
z><4lEg%APBLn+FRr&2tGd)7icqrVXFE;+3j`3p~mvsiDMU>yK$19$B@8$Dy4GClfzo4)s_o2NuM3t-WhCrXE>LQ
z_CQtR*!a0mhnw#I2S=WxT_H@^Saif`)uhLNJC
zq4{bSCwYBd!4>6KGH5y~WZc@7_X~RqtaSN(`jfT!KhgGR)3iN50ecR$!|?Vq8|xa+
zY#*+B=>j4;wypclu7?wd+y06`GlVf2vBXzuPA;JgpfkIa1gXG88sZ*aS`(w
z_9`LL4@aT0p!4H7sWP`mwUZRKCu@UWdNi-yebkfmNN+*QU+N*lf6BAJ$FNs^SLmDz
z^algGcLq`f>-uKOd_Ws4y^1_2ucQaL>xyaQjy!eVD6OQi>km;_zvHS=ZpZZrw4)}Z
zPz(rC?a`hZiQV9o^s>b?f-~ljm1*4IE<3plqCV}_shIiuQl=uKB4vUx2T$RCFr0{u
z1v660Y3?>kX@{19i6;*CA}pJsFpo{nculW61+66XAOBZD<
z{H|h`mJS5C2;ymL##}U*MC%fL0R97OSQ@lUXQ-j?i{z{=l-!$64H{LlTLo{Ln<|OV
zBWq*5LP`KJl74fC{GzzP_Z;;;6i--QpZUrtHC@+RBlt+=_3TyV4gk=4b{TBJAx!GehYbTby(&-R337
zQ%g2)Uc&K|x|eL0yR*VCXDBqZ89C(obOFYYht(k`^q0OaQ*Y{)@7xE~KQ7XN)hGlZ
zl5$1<#s!tyf%>mbIG(9WR`R*{Qc_h(ZGT^8>7lXOw^g1iIE2EdRaR^3nx_UUDy#W6
zy!q(v^QLL*42nxBK!$WVOv)I9Z4InlKtv#qJOzoZTxx86<5tQ*v528nxJ^sm+_tRp
zT7oVNE7-NgcoqA#NPr*AT|8xEa)x&K#QaWEb{M34!cH-0Ro63!ec@APIJoOuP&|13
z9CFAVMAe@*(L6g{3h&p2m!K
zEG?(A$c(3trJ5LHQ@(h3@`CB*ep}GDYSOwpgT=cZU;F&F6(b=V*TLLD
z*fq(p>yRHTG1ttB*(Q8xLAl4cZdp^?6=QjcG;_V(q>MY0FOru|-SE}@^WElQTpCQZ
zAMJy_$l;GISf1ZmbTzkD(^S!#q?(lDIA?SIrj2H$hs*|^{b|Kp!zXPTcjcCcfA+KN
zdlV!rFo2RY@10$^a_d*-?j7HJC;KhfoB%@;*{;(hx_iP`#qI(?qa{b
zH|YEvx~cE^RQ4J}dS>z%gK-XYm&uvZcgoyLClEhS(`FJ^zV!Vl&2c{U4N9z_|1($J
znob`V2~>KDKA&dTi9YwyS#e-5dYkH?3rN(#;$}@K&5Yu}2s&MGF*w{xhbAzS@z(qi
z&k99O!34}xTQ`?X!RRgjc)80Qud0{3UN4(nS5uZ1#K=^l&$CdhVr%4<67S=#uNP
z$hnqV471K$Gy&){4ElZt?A?0NLoW2o_3R)!o~sw#>7&;Vq954STsM(+32Z#w^MksO
zsrqpE@Js9$)|uQzKbXiMwttapenf8iB|j(wIa2-@GqE@(2P#M09Rvvhdu!sE0Mx&cK&$EtK}}WywYEC~MF5r3cUj%d$|lLwY4>`)
z_D++uNojUl@4Cz8YF3nvwp>JWtwGtSG`nnfeNp(_RYv`S2?qhgb_(1$KD6ymTRgnD
zx^~3GBD2+4vB9{=V_iMG*kQTX;ycG^`f{n+VxR4Ah!t~JQ6Z?Q;ws}Jw|#YE0jR0S
z+36oq6_8xno^4J?Y02d!iad3xPm+8~r^*Vvr4A<|$^#UEbKvJ9YHF=Ch2jF`4!QS#
zl8We8%)x>ejzT^IH%ymE#EBe2~-$}ZXtz&vZ_NgVk4kc
zOv-dk(6ie2e{lAqYwn9Q$weL#^Nh?MpPUK
z#Cb)4d96*6`>t7Zwsz#_qbv6CnswLS9Jt|b`8Mqz?`?H1tT99K#4#d+VwAy}#eC74
z;%UFxaNB!Zw`R9){Pncrny4>k;D}TV2BU0ua-+Fsp>wmcX#SGkn`h0O`pN*`jUj8q
zIlnc7x6NRbR)=wP1g`-}2unC>O6ow=s{=NV6pfEo3=tY8
z=*$TKFk8Wv0K8B_**m*Q>+VW*1&gD#{#GSc(h#YQL?*<(ZUx~>L^RyAG3}j0&Q|mJtT7ec|Y7cr~
z+A`Wz!Sqz9bk0u-kftk^q{FPl4N+T(>4(fl@jEEVfNE$b*XSE)(t-A>4>`O^cXfrj
zd_nrA-@@u?czM(o3OVDok%p3(((12`76;LwysK$;diTl$BdV)!p5Gj=swpb=j2N>b
zqJ1D5E#zO9e(vJ6+rGuy<(PS-B6=gHvFat&)qr%j7T`vT1ju
zIvHwGCk5)id{uDi@-e?0J*(-W-RGZs)uhSeqv7TA&h|CUx(R0ysoiQC8XnxL&RXI3
zO`H`8Pe&^ePw*`{rIJhzUg@MuhUL`IONG^*V?R0h5@BRDFgEF45b0jSrg0r{<4X)nw^c)uQ_Ai_p>ic!=K$pmnyqYb=`6fUo40ru#Gh=
zMRJxOD(1n?Mjz_|IWyJK5^fh3*n>eI0MmEKq%=-oIdGd4F-LT>RL)Bp5FWxb4aNLNXB^o?YBSXQ`SwN
zI*N~(CQW~P$HpzwrMG4IZKI>TVI4nQ$a-#)zV}LE(xgQ5MG@L#e!e@
ziNtg{Ph&qpX9FLaMlqMh>3)Nu%sAO#1NEsbe=#4Vqx0Y;<~+mV!xwj%}Z=xZn=
zSqjxSH4T~v>Xd*=2wmHPN?@+9!}aQz-9(UIITZ==EB9}pgY1H4xu^-WdOFSK!ocZc
zd-qhN$eZcN#Q^0>8J%)XI$4W(IW6R810*ucIM7Q#`twI|?$LYR1kr>3#{B{Z4X(xm&Cb21d^F9MKiD=wk_r+a=nyK!s^$zdXglCdshbfKBqa5aMwN#LmSNj6+DPhH4K-GxRl;#@=IJc
zm{h}JsmQFrHCioWCBGzjr5p9L4$t4`c5#Cz(NJ#+R7q-)Tx2)6>#WZDhLGJD964iJ
zJXu`snOYJYy=`<+b*HDiI9XPo8XK$TF86)Ub5=NC@VN#f$~GDsjk01g$;wDY!KqOh
zC$x={(PT7CH7c?ZPH{RNz}Tel$>M0p;je4|O2|%Yq8@sCb7gRhgR4a*qf+WGD>E8~
z`wb<@^QX)i-7&*Z>U6qXMt_B2M#tzmqZTA1PNgzcvs|(|-E
z4t*ZT-`kgepLl0g1>H!{(h8b`Ko=fR+|!L_Iji>5-Qf34-}z%X8+*Qwe^XrIS4Re$
zWUblH=yEfj!IgeIQ>m}+`V(4u?6c;s&Ym_6+pt|V`IQ1!oAC@R1XC3tL4BQ7`!TnU
zWaoqG=nhI@e7dV7)8VzO8ivuC!q{hcxO7fo#2I=<`rktP0OfAO-CQE!ZT@}e7lw;{c)
z@2l7RV$@&S5H@{=Bj~^Kp5At=Jq=Y92rXP@{-D4j>U=-a^gM2s-nIZA;u=fbm2BP=Zca5W81_cA>Tr
z)x+r@{pu_la2Q(wm`Zqyd@GhNDNT&4oNHb_>w4{jIU}m&iXykMxvi;WL8;y7t}cp&
z9CEpR)WlI1qmOq!zg4QTmzv#eP3>NLd7V-+YKmuyLFP533rd>WnvL$F3b}g39PYk;
z)^hXQ%5jO(B}-TMio7@t<(V?7M5!ycd)u4Z+~!hym9+KwPVO^Wkhi^Dc7$R@)o$oh
z^mRbgQ@5EvalJa}V4Bi3cs^w5pYtbXXz5W|e%+z-K;8M%Lf~BlZRvNI7=)cG6lbjg
z?)l8iOw!mU`uaKN@UL4>d#edM9^-ePb(VICy6Cg-H^Ew$n_s801w`A83W!_Z{D+1G
z(<9A>WB@>)D%cxw7c?Xv7N}6gg?&TkLX|0@k&VL)YMI~SsE^dzj2^3BKL7SM$!0Lt
zj;ytKWw|(58n6_NNH$JVRh!W*wewMr7)H2jOCruuJAIIfPMFpf6j=hL!D3nVT9Dpo
zut}|VoG<%v&w;HrQtz<%%T&X##*z5{D!!egoRN}R_Xxuy+E3dhx6!7mlNyuqsKR-P
zlP#8EKGt{Ij~8kXY?&*%q)PkPG;rziWPd>HefyPwV49!>f&Q_@Fn{8Cyz{HCXuo+(
zJMu<#{Tl}^-dh%nM0IrDa@V
zMHgAog4`tk;DNK-c{HwRhx%Fn%ir3mex!XeZQ4QY)vQ_iZ(j4-GcO?@6Z-Y*f?u7_
zmf!}WRoGkI#BO9;5CFvMobtV@Qm?#eNKbbX!O@xEVhnm
z6LFnWu=E}6kB82ZEf!g}n5&IuivccTHk-_5cazDAe+O!_j+dQ~aUBy~PM34Eq0X-LOl
zjunFnO<4Nq|BL`!xwvyj&g9Q0(A_*xLT~l{^nM&kGzB7+^hP^L&bD7iVdXe3wobJXVX~o*tX$
zI5xthE?gAl!4+v~+ASbN2nYIqNn_#3>!fi2k=g*Hg_%caA#plNQR+RtHTiW>(*OFG*-nzu~6DMCrX>xzP`3sj}D!||8
zf3dk-w(NCUMu^C%k|t?sa>9gU_Ms-R2Hhm~4jNfPPyH!3Zy
zV0QFf=MWK%>|(eV$pB5qOkC)uou{oIJwb_i4epV{W95%N)`+uOrLx7fNtD^czsq4B
znAWb+Zsk|YX}a?b+sS-!*t2w1JUqU6Ol`&Jrqa5=4eeLWzr1DX1fWW`6MYf+8SOW<
z+EMJ|fp${RJ7q9G7J+`pLof$#kBJP^i@%wNnG3fnK?&k>3IUVo3dbs9Nt)x_q|wIB
zlBAi#1Xv-<+nr<13SBfkdzI?dJ|3~?-e>MzG(yRsA}I_oEd{HEGZ&7H|Km9mEbL6r
z{Ubhh;h6_QXN_?>r(eWJ@CM1-yn6Y#am!aXXW!EfCpu}=btdYT?EJ>j+jeuc%;P2g
z5*J%*$9La$^cy>u0DqjO#J%*IdaaPnAX#A6rRQ+sAHhY@o32==Ct3IF&sM14!2`FD
zA))>ZKsccTyp$U0)vjABEY_N5lh(@e+Gj>sYOTgf?=82K)zw-?JX2d$x}n2Y0v%SjDtBXDxV2TyyxQmN?2%8zkKkKF*!AA$P$1#qrF%fUu~URt`tp3C_(>^tkcbHhO0Hh0A
zpTVQR{DjsD=y-Bsl#nuTVKRxYbjpSJg|K+SEP+^Y*z3S9p(_-s9^YP5Zc?Vz*o(Qx
z?f03co`dGfW}0T>UdEZaW>s0XVEzlw@s&bc+B-9;^^AGsx$AE~!1-7?tn9z|p4}_?
zRsM&sjg1>#Rb#6jFBRKMeZ>I_4<%=&rF3yqUD&Lik@7<@2*(0rC)UqPj`Gfe8L&{S
zhGtB67KhF{GnLZCF}gN0IrIPU_9lQ)mFNEOyl0tx-!qeCCX<;7*??>lNC*Q7`xe43
z2$7wD3MhiII4W*v6;Y775v{FSYqhp+|6)6BZR@Rdz4}#KZR4%=+E%T%_gX8-9KPT4
zo|$Aa1ohtUet#uro3p&@^FHhEX`OcGjq==$UeAQ~<6AZzZ|l75nn<#}+mo0rqWv5$
z1N<|1yMgX+Qmz?53v|%P=^&74bwqfH?xIC`L()W{|G`j^>kbs7q<$hb6fL@S
za#nHyi$$TJ7*i!6estChR}QriMs#yy!@Po#AYdeWL~*
zUR%)FT#4Q~O-N!O&it}b8zFOmbe=egH*Ka<9jT?dFCMAcagAo<>tKrW%w?P_A_gd&
zXwHTn>a>WEWRzimu7EJ*$3~Jfv|@bLg}6iH4mgJB!o60eP#_N!xYrQoMf4&rGLau~D9ila
zYGD*3*MNN?v*n6op+dQM!Kkr@qH1|^
zh7skG&aC;+$C$OSR2!ke>7|B6JDpjV%$Jo5hI14PGyx1I=Diw7>h@vzL?PLTzC;`;
z?}nkmP%J6$BG!9mxz?+Np
zIHbVy&<#H&Ekz1(ksSJ_NDQ+XHyg-!YcW8YvE5v*jFQ->F;|Q-IB@Mw6YP~v=jY$~9n@~8MVO{1g
z@g=-I$aXs1BH&>hK(~|d>Y9n*;xRm&07=pLuqVYV-bwyCUIKgMdLSrovEs2f3{b
z<++d|UX&}*7)y8){Ntc{RL*udOS8r%JV4EZ64fUF85n7%NAWejYbLV}NB|lS>SnYN
z?PFpysSR*OodDcNK;OVKsSbKS^g;|bSdogA=};1?3rYq|Nc_tR!b2ln>=bNTL59uS
zZjF^Y1RoS7qF^>LEqt<#Mu0ZjpiUNLtsc5%t*8}5lW4OWwFXfqGn-q~H)5}2mSRZ^
zKpfQxOe+KC(M5V`tz1zQ)@pTTQ2?NgStmwpvPCi&U9wd)m<^I-w&{(`Vb?Q*4ApV5
z(G}DMfgox!S_C+OTa5UkEbB#G$SC<8vLrDPPT_Uq5N~7`%Js5Ut3!o!f@HJm?b;(N
zbbv90V6J7=E&)E`b|}N4n`VOOuvo$IEMx`%EkX8mpug0yY80enF3?M57gI
zQ((b(;dv_v7PDKFgL|6)q^sb%Gp_aU)wp^uX96>jGEsOmBhyuDZ8}+y{bG?UqGqyDfYMtJ{6@xXI>fVC9g+uG
zbQzl4fY>P6VAkv8GEpapl2>quqSIoui)Mr95Nuw@voGBux%Mq
zYqG!&A9RXvoI%gZRwI->g2SYPB1tbg0U9UkC70cRFPTKU0L{E!2e?|as;p-wNwA;>
zm}yKfYURNzE545Jz^T+srPZUGX{3qx0H&3ol`)Eow3xXj!2lx+DkB=}EoF`(n^)2W
z_26hljpwvSdw}akJQN9;WAQnnHTN=3Ko19hR`Qqt#60*^1acxN84Oi8W-4nXd^@w0
zVpMzKqWw_(cHwQ`*uQ>F4F;Ncc?}XU{q867ZF>zihsu1j_i%f38%41S53RkO-5Bq<
z<^ffy6fQNDn;z=lDz2OXjU+MMr0ziZ)HseHI3+}-N8v$8UWEK_n5pL6VPUS@YH^
z-F?^bJ%5Vt}@l0B2B$XfpF!7J0KUW$rc!~hPD3+Ms%)ia=pl{0nuS0_)
zMk9rt16uqE&;%{gtVGqhUs{u$%()O~zzC_11`vYVVXfdfEU}YwTDn~JYTSiTDRNih
z4#ap?$m%48h4*c`rhEH7?VLTW9aCi~b>z~)W0xM$c|y(8H%u~4?Yic=Yr3WyCvBMC
z9P;P}Ra`!CY1TVd3~%qgX48EO<*6O5d**2Osm_lAM&ZKw?7XUKU$o?gjCIcqH|%NJ
zuxtIAj>_t$YW%D0ShIfD2DzU5%qnHsRN0vm^B3-wcim7D^;K7~Uj8EuKZ;X3tlbVD
z(=eh%wxAVAWPvDL3Mmg=TPKpMGzTdG=aT&qTw(TFBIg<;`kFOrB)&>#;&>KE1kb>+
z2B2dhdAN+pj}^ZH_t#P}WOC_RDs4ppbD0<}eknMnviR2G%#`AniYwzKw-y(_5*$-_
zmw5S-TNmxQbkR$TmM>p=*`CF(EG{@lszbazB$k;2MYhTooy&w{`02hJ3>+yIKEOe7
z@JMkSHwDW^-jsRwlSM}sEqQs-p1n(#FUOllp3=O)Tup&?1<^)a@`nk7JGz35N>n$}
zBOy~(>fI9qX^_jCE*5|=cn@Q((|dZ4jk)4MmOAk+0xA#wuDRF-%lTtBwIA!9Gr9Ct
z$c`7mj%LBTedqC%Rm_T=dk5?Lu6Ta&XaF9q!a$AUtk$
z*e$72Su7q{Rad`o)%w|Sbyv5rzAip{{VH|GtUY1tf`Dk1!6*HuN9YH|>@$Gpvq}N6
zCzbi<_XLxmE|LLdr@JCzPlDyUYO2J>kDK?krp5CY@11*7)8aCVVb&~zrEGE2O>>tojkD`+_dDb1*Ao``HQpP(giSRL)4OKuTMcNVOb@(m7M?noGc?geUJ;8t6u0>WYa5RLDJ>(^Zu~>-DTzEbb
z=Pw6=C#Q(ao#It|Sa^jEBWtV8YNL5Ce+KO1
zHqBg6?QNQUAP0QbaOG=Lqb?5ZLlZP3JdqXFBbSG?_!QPegco`UzEDBCfy7n?l|5O(2uWh*{9fh*}OFkZGv)4J9g^Su_Z-y
zktO~$6KAdO?4HIhm;a)+gVRbF%BNDw_qH-YUp3>pUiriPU-DaPao4J;%WF%Dllm58
z#~3FQnvO5O$UIv}o~Up(EN-l>@f8Ipwl+*yG^2h|U81N>`H9+~R;Nq6WZk+k_l_|;
zqH`}-wki9Eekf?yVOxp~wx$i7mS&wyRfA;|YZ$pD0iFQM7=^Of;Mb5{*g%Q+MV}ZZ
z4uCY|_@8q>JQ{}h=B5NG!svf6mRKr5#bVli@?ZR%doi+~75m0rb2XFdcTK&}XtK)Y
z#n$?!<(KX3?3gc;rSMQ3)+>e{<=;f)h)dXgJA+DdJ5q_(=fbyjlD
zyxOq~%LPEFsh*KmXEIW|_M9hDm%Gdrv97&s&LCvUqb)02CoZ4W(b4X%EB2q(#G5YM
z&@wJkH_qwtRocyZt7Y4`(pa=cD4!kEPl#4{yum=*q|U{&O2DV&=)yXRws%3})r>`7
zty6tM=kuW2FpR*(!{^GYty*Jp1woSmG%(Qs4H^#!;!Q>OdkH@{*K(vzM1v#qO$_R{
z7+Jto9d&*4xTs#V1lt-9mM`tTxU{8|32n(X!6M-UNsS#R?m__F|Gn3X9
z&{djT%C$c`e{S8Bi4#KMy0LTS?(Vvq%{y6Caq7xk-@t{Re0DV4heM^6gkrEpL-{{%
z)|>$4EU3Gq;JmPH{E@zsRX+#@>gc;qk2i2FwVHuCI??#%xdiMweM
zWaT78*EG!|+OV634wd0UaR@TenRhksaP%AUUdHC0VcZ2nT>
z|Lq#TX5O&2h!GYviFiX{IRHYEViDCLf^Wf)se&K4oOU>MQK$_!7!L(|E5Bx`dn|^Z
z8D!P9pUu^~tYLFpB<~24WRqgt9Jadj5ce6JRV}}8O%6hRA!!0JH5LHs91WhgWWLJ-
z!KL(|#^$p^amdJ5g8rZ$Ggy6?%`B;J_Kppf<0XMKcmmW9@>-TJn~gIShXI5aI(xEx
zlSd-_6cOeEGR2J$MBqWpK*2%7D7_wEFG0(EP;?Sr1EpZsk|pld3%9nq47KjwNtga;
z^X`AUY0HzBudMExSE>hYgVxdT>O;3bbp6&zv#t6lVjtU=7OitgFDbdK>r_jozEYb*t7qdj?MRk%pu)4==CR^bNgHOU-j*emraW7T2WR%b?1^<K?p<`lIUQwM$W=cui|bx}?bTOb6E1v3`QcM^BdcQe
z=PpkFc*njs2H)6MH*NX+$l&D3bkD1=@_CF6^b#6m7%YZwDoKJobt%*>6l7EZ=V>@G
zzzY{zEr!q?#B%Vk9VD%4E~MxbJ)hcn+q^0Z=@qNy9XNJiUX{8Ns(OzNq-fqrsbhbE
ziWT!T7SLhKQavnveOJ`2^uK@O;eGSx?>nsSlq%#_#sdo9iphZ#Jwo|{FhMbfSrS>R
zQiwFss8KQy?9j`|&<*8j64q^OVgV#e63^ksE_l^9($wb9f`EyHv4&?kqn<@TAOMm<
ze1YGL4dcENbcWZd&n7h~Atmwe(#RoslRpeyDguGF}j}$MRo9?SM8!=4Q2wU($EzceOopeaHDv$UhoQfY3;W=e^g5xM87H
z;I{8*GeL)G;HH8ITBt8$#)NOPnG>ql&Qh*h
zWt>ty34rm;*F33uigBg#?eg{u7R{5>Q`U$R2j3@_Lkx_M{bOC#*zx1XR_*c*B-IGq(GV|B@o{8hJ3p1*lD@AJn%&$i*n1|9(=hKoMs|KsjeFu0HwhG-gj
z6NR02xQ2KllvU2l&Q+ddYuKj6LihSj-&!x-tUR@F>EtCIlkybUel`o1t{IyqKm3Y#
z^I%x~1FN64cI~X$=bbnBPUd;Rxn=jXhSG-2Z`jT3lX2q?hsL#({W072*)OlJJQjT){R0dcw$MIV@Im_3E)riYBiU=q`Y_6ca&e9uVeb_jW)Y(*6X`BKYM85
z!b8t)Ui*XT*XL>UuiVO9x8B8yUlNM}WBcAqm)&yESfoE>5R7X!w(jnYSbl8TpaivJ~v3;LD^f$vOykiS%0kDp1GRq
zVCg_iC;5ATIf&(~gt_DK_8Vo2`%JbUh
z9jfe_*S6Eje-d8cyItyiX=UK|B_;1L?UVG9n?6x~K;xR|0vZ5x!At8OJYq-&B}jT5
z#x}{P70vb-p^szS5EvI&o&q#3;_jrm%4X&6S8u*@Sv#ZVm@V<@Hf3s4l;7vm>@w-r|)yZS%w?(I1*QeIrsG=I+5nepzsGxrc~
z!pSc|SCA)uB~*o*q}1leH+COyX<6)cl^Ly@AOH2^A6)<8mq0BH{PW9E7WVFW74(6f
z)`kEd2^SPxr15s^#3*QkxXWqEyk{wqj1GtNbEQ|(J1tK6
zUnIYs&2$CihuMv=&x^lu`v>+G339PrtlYp%HorK*>MU~Tjmr477+hGhviLYl@>d-K
zU!uTPY~kv}%w^h&xW}uU?TFq&;?(Rl#6glkWN>Gw4B#URl`pWSWHsaPj-^{T?+Rl%;){@`StD{A2dwJ|V96v&
z$16bph~Zles|b2KXKVo$Gy2J6qqP8xDY~bRh4}rn$()b-mt@e#Fwd)MdNQq8Y*-I^
zKqOSY68uyOQhX&e!epDI){mhNNM=IwXQLY2+&brLfPWf!2x1u(hS5ey?BxMlyyvL*
z=no!g*pcWU2>q^rYg;4Lqki3-zG)X;d+6E=r*#^~7*m$_EGg_eQ=4jA+oZ8YMYWd6
zb?&a!UGBQcmfE7Cu~J)W?WPsCJoTfeZdoCs5nPtKdb}+(w{hma1+}#c_RZX|z*J-U
z`YpG79lHe^?%Xkc?nU**&Cy^m+F0WA*VWfFHrCYF`F$mgbgj9#{-U|#cig$|;T=<^
z?0A^d|2~dA8{jc0T&>LodGPkA2Ce<%xn1wIlX?a%!@Eq4Md6Y$Pjh8C)#tL9&B{-Z
zDl*AaMfM==qY6ZMs*j2-_o&#DtOvEgKO^o#a!G8V!FLJa99SgR=R+3-1WD>6kPt4T
zQEnn&KOhDe*4&&kDJBfJWl@4anq%Se(e27Iv}pbO#r>3wvWJpUt}zNZYx9klkhS?P
zCbrI418eh@4+uTT5z<4YR!}Wu!0bb{)|g-CHs~wgPLx_;gZ}Pe*r4aOmyr#+pp0lb
zHFY6iYKHu9A$fn1?OWE+XV41w8uJSK1!e3*OLwh>v1U`ou!Z{BA27G
z@n6d|J;N3qwe4uQiV3KTDcpf57p!m?0p3so1Ax@X#2IiaA}2>9&SUXL^1&>Xh8#Oo
zQ?C?L-8M|oiJLpU6Q{%GGh;&0K{owhQSY%3!h1qcSn>U|R_L;f`cCNUO-efJ#sSbh
zkg5Hb9y)Ys=YeAvt+X|EzTjRz37BGClh(UmXfNBmxvV{Ttan9870vRhk`;uSF?`m!
zyWBXXtg*^vTY1s31F*aP^xb!Xf`+yrz9*G!3+V51{2PK^bPhMbp(nxq$mtS*2*~V%
z(N&JbY2FYBI?V#24?IeNyZFFOpZ~&zB|@M?sbh`bnlV9zkG}tHdLK
zx+5aQXm)byO7#8XHFtDn$5~LO*5aqH%?m
z$2wT6nTmGDI)?$JimeWHNO7Kra|S#r4ugug1UgoGf)+&L03keV@p1OHE$p^lBA
zt*GJGLDNniq=XZ4I+Mb*82pqbfoQ@+p_JGdB0aQaeTB!Lr#Z$97FjWL@MMe@Z^D+s
z&IK)jih;Wbb%1MocDc@#$)|IKVWN*g2&aNVGFMmdoaL`cE`T^;1?Tcf@^i>q-czu=
zA7p!sX62V=__ATa&S(g9I0rd{)J6Sdr^qB}JA4(U(1Y-`7)a4D)MA`g7I!Mwm6+KC
z^C_nUK7sX}(ukntS*u>(uyyY=UeDi#4Mlus`)o8@(xaLmYhKp;LGw3oP&Rni)G|cQ
z7Ur#P!U!VO1g(pNoJAP;`R9fA(}??`-wW?AJpaG_{Fi;Nu)eT^;QuU%IRlFc*+_>_
zx`&U5+e^|ih7FuRhmOU(m+aK71UlNUGH`jW!KA(Xf;sb)=69M;|L@O||H&xL
zl74Wt!{fDxvzf&5M8E`Lo>IUfK@P&dqXA1j9Ysfw#32a=jPn2f=>Dps?=)zh0y=nF
zlN*J67GXr@2Az6He%|WXWJyrTG^F6<|JoS+k`Xm{tCR{6!43_i__z|&s!LT*4`;a3
zwB^UO!_$ZGtWdT77?_S^7Dqv~y|xiDP)-YnK8%pxr7p+Lxp?4~wPvULd
zUmZLLn47GQg>WUt!yAzB$G%F{zYS~B=am%aex&q3x^I|U4B;Xp?}AZk
z^YIrlk>Jo6{xrIjl;V~Ot%d0#DhpmMHo+{Xi^Rz)*c5L{kRh`PE-|>;1QQ0h^lDfo
zd@>|=U5Y91Dt-M)<#*Gl`Fr}3$-Z}Nfx!+IeZ!v7G%
ztcDQl>kp+vdVk8V$G)HSg>V(Daj1A4`JRB+&HA5cq3-~n7Y2oBATKb2YG`uA6X8S{
zY?6>Vt(nsVyAxRF6YnNNtUn~CLrIFaIITfuxMVt=e)j}2Or%oj&|p93A5+|pOZ*pd
z#pmb`Sv&G65piAWD5e2SoNSIcgY-cWl#06J$28$_X(YT)8umd{pHg7Zo=kQW0->a_
z7yr))>upwE8ZMWr(itk!ke5-mNGO~-u?owjq}8&~H}EaBRQUYJk_kzaMJ-j~1H#0S
z1rxw$&lCSsY5*5Eh9p`{{~@y^&(mjM(r6cji;VSvEmZ0dZ}u7v>WxNaH@lu48ujuc
z{04p_HtH?AmEG!dXI$pv!-8`CYpz_XJ(2siAQuczyy!!@pi$wT{)yp>!Xhe@`nl`z
z1^zAe8p<`=WnrFL1*!@PPZ=huBJ={PS>a{s$9bBsNe$AX5$!cHKZH|luaOs}hA*pi
zw$Rj=>@_5!LqS+x4X9Y`l2I@7_L`@81m(I&E!VL96$Z9khIpPCg?Db=MU?BT)g7f3
z1oR}eOn#rEov2`=TqatC@g-cu`;n}|1~nUG-Vnn;qJfhg6hp5T(E`dSLj-kY;GX6Q
zi-z9$l?TDudYiv<9p*t?+4_WO=CNA5llp|}o}F1=q4CAqvoxnl
z-+26xjr)Osgn&kH{tC8-tSujYAX&ByDk<0rhH0A)eE8>_MbIX>Z9mf=3Xu{d5DSGe
z{bXd;!bUBGMEs02AatuZk6h5A3ny8K=vdpjVylr_0=J@48tARLevxvQQ6xQRF2uMT
zDdlo6=qryT!$n?JVgWh91v4nu1G=%?-N5?j)BLSd2l{{#%0EAV&&xf1Dr{4qxZQ5=
zL(D1c=mH9)qTh-=!wPQK;G!Plb9%5!QL&)AKmk+G}epRD9NQD(&9O0C6ZElh(DA_jLN=MkxobFd(kGnzu)+M~#d1*vxjpI7N&Q;y&0Q(nt9Ov@
z0UAx~93%#q(<@Bk9CzjhzLPRMRY32Y!M4>0SFb)OeWL#Q0u->@`-CeGuA;1us}BAQ
zc@mIQK>2shoeQcVJ#!PiaLyd@Kj_ibnQy2+9_9fE%1-skgH%88v00xH6V6~l&y7;<
z3z*+Y;rwAP`&tJ>jA`DJcZ`7&@iupQ%b%(G56`bmS<#9BG;0CU_T(luy
zt=;C3Nlc<}xz{
z@bcSeLnyAw`PUGAL>*F~12pf(YnG!XZdkkO7$`Hc?ByN%$Z$rECfLDLP%2`Mw2Lkn
z%iuczcuO)T(Vwa}C$&16nxS+qnzVRQ5p9I84;?;p=#nva%=pfXYl&x;$;i_
zP|dt~6wqbsm-{)G2ROAL$rK4<&wrWS4F}$7>VLjZ~K@NB#Cl
zO&Qzj{Xrj9Q?1IwthH&{H`*sEN1LX>TEL$T9bDBnzAi-V%H>rqOSs{8i9DPnOQEm?
zKnSNAa;HMY+M##OP3;`0pT=G%gsg(SQ~>24N?A+(Cl^G2rTi+Y_Xmo`>Wi*@@Y*8%
zxO%^0U>2&c=s7QU*VIcq8^q`sm^J3$P#9i9SGJWj|-YQ|Bbro{q^IrwHjL#@aw6r
zO5(p)w}zsz_FT2}`msf*s$lq^*3AS90U;2;%8zQ$AmjS~uU@58ERcbWhv?f>K#BeL
zYN8qi*%SY*!e{wB?9^3;*7vWVA<6l3`r<8_4JXqkECB$U^#wWOuf$1XFNlXZ{n58dU(CAELUC!&Oi-&kb(YyL&bkw
zFG94K{HSTIT!grnt(x7Mt9azgH#FZz%{*?b|DaQ#z(AfKI!4Z}p<~>Ge#1Se1*{80
z*9-3X((C!(%0GrhVCY#e9J%8rDwB&WM#Ib#hh$(WdygIeQucm3{$#|=Kl+eJTk1Z-(L@12&%MZxw-kLv=48+WES(PWIT1Ks
z0C<=YX2Yy?Fc%$1$a>sE6N@S(ydbyNTznjed+MRp#
zqQd(Tx2JkitUck{ZkFv%h>+T$y361us*p`!x@ITML#@u!?BZJ-!@DqEXFzk1cNoI{
zJl=+S{D?*ZKK1{XW)YK5yzt`pzw`QU#6SP_sM{sCSn6GMftpB-*B5YYd}6E1T{V8s
zBM)6)8@_GeJO87$68vfVhG%-%V?Wnl^6Z65%hMOv_5&oUSnJohv?fUse?PIwpgrjj
zbkDBTKUc**{+~4@My+3;_M*cli^%=z;`psm^74d}
zCj*Zab%E6QT+owC_c5m2HMR6aD{F5vvrm4M^bRUw2oc1;q9jPZaA_vxsFaP~U?%O27@cleW3dOF$d>Vq0Zl}ZBVHjH
ztf_?4md<5`q8EHId=*llqXPIzIAX%~1B?b5_S~HV>kar}&i$g+Smv7ZlTat1QzXxJ
z$_Fac3X5RMSd@80O63eVgMA|`7viFSV3ZmRpY_8pOoLm0i@%=q@I7J=7Vq5YX9ffA
z{>R`WG+DU(#C;6O|HMaLg9l
zl)V7Zh_060KjCS9biA=f=azMILnJ&h}h
zly@(WRadr83lyzrB*7h*#Kz%c#TEcwRZLH44Gb)Vv~oEAv$QE>6AfHr(F(C#@+
zLJlGHE;Y1|WL2(ysP_V;dWc_?Nl(dVTAaYOpjag5{{*~1y#T?AsgabJdOGqoA-oeB
zE0oxN_!V3X&c0eE1?A93*;A)ACcg=udm8GzJ~h))e_kxCET|AT%Htl--e2VXnV<@TsN3YA17M0e6&-Kk=YQOE2LMDBtsJQIke#
z@?QDP5g#LZ(1S@bh&gBDacz8F`
zRpD-jIg8-ap`Ym@6rNlM3=JFCvr)2b9N_9ODp{J#8`v;h=Es?IOxlxNiKM<#Q9_2M;_jSYUH}t
zqe$Y&x^->4;JRt+*3Xu{ylQW~6s%=u)@
z9}!qmL7OlT#T4rTQru(OPi>~6!BlKwMiZNC$FYcG5yvTlmyw#v=M)cWYQ~gfFJVt>
zq~`S7oR)6J2?icV&xW6Z&I8CNu=}8Y!-3V5*oU(pJV!{pyvacr8HA5P0nDoEQ%(JY
zi_HlS4K2djpeQwr8f|LDf-$pdJEIqbnAcQ(`R2Mwiz8zq+ZHaqq%>Mu7wuYe%n&tL
zfGjDLMa5%lx}tTse#w%qZMbXkq~r%<8NgEgk(yfXgz;U~-7DFX3+bnQ@#AqBY=^OF
zLbS7X)|dq=R(4l+ji2DHt%>*r30Rp-(iA+JEy;u?keU%+qc(@`QA$BS9Orf!N}fVd
zAL_Iua?ljh5MAJ^c}*yLOiMzDF9{(p(30MIi+m$<`Ua+XOL>c2D0t=$9GupiRQ`FA
z{BOl%>K)}7|3O^Dzk_}@em{Rc@>6mR)GzU+fJP3!_lP56}Ebt+|2<0=uUVxPy
z3)N6@44izF$8~7*yh5H)fjBg#!VE4emB7mt}4}d2r)5g#{ZnU8q)|NhnorPaQnz>S+LontCn2s+La0
zh$jQ|3fkihRKrX7xJMtz8qh?orW`edrfqDgrtxfxOwvIr^UxInxzk2wXb_tKnHl(z^v|lS3R^;C5-qU
z@k^Q^e256y0(|hy8uo+8d0&n6hRC-))pyDz3Z=lgVFfaOs{79aG081CD(x1Z!z{a6rfg{`f{nt;>Z~S~76JTgmet|iqonNy9qSRCrj5SG
zE*k8okuHXMA1b|YZ0qc>KB6<%`;DPFQ>HnqYN&4EGLuv20mv@Zt>Scu^WHjG$A{{M
zn0_!1B4y#@2tE)shK{KGiRKDSUb&Ams?2};;|q5pJXA^P3}#c(A}>+?UHMSdS`A5u
zx!-7KdwaT0vc*icx+RrkWvS1Vqu=l9QLeTd`z1pXyttbcEn$YF%gs^<``o$khc~%U
z9?(+A$FHjL21BG2Kpc=@FYF5APed6YZ)jh=UwQm-OL4H}p<%olMV739mlk7y|VeJq6h({N-N`F)AkKU*9A
zZncuEumPCb0)>TTg$*!DALN=JPBdym6qG@%J)>S~Clne0KH`mlb{f%P!tPP}AjxA#
z93;`Q1V$D?)kIu!LsQfhjw9EQ9F=y_B1`piC?(juo)nIC0-
zDn9&Z<}dFxHQlKEWj$Lbgq~n;oLYO|eW)MPm|++FFVI|Qe8Ff4uCPwVdtGoTV=nn!
z9Mg!5}_H(v@l9y2_n5lmXZ?=E&S(lJU6Imo&ZWZIn@mAKqMS=Au89C=0ru@=+;YS
z)498q9ZI9JWB0j$+}686F?+mvy={HRr$^I7WzrL;!!dIDMD^t8ryc8UdcBwRSe?@Q
zeCZwRQ~JDm!Eo-)4?J-5xd4^sKe}D^^(*(gg=;zY{*Cfo)5#lh`mXYC@C%ts-TPOr
zx4Ya5jAH>O
zc|Naas2cQjC5qX
ztN*_
zp0iX-C5(oALou489mBshd<ac}LWi(CgsaDL(eO*GXYH2uLp{vr@SV&-2TX_wJ$c
zu;DVWH;0OocbL`LWcxFSsKaT)I-4jmq{X-c2t|aJQkL}QXiTVMz=F`J*S(Tc{UO0!
zi%CAn@koN|GR(ehQJ(p;)$Op{@wSOMEh&o|_Qx>8!DwP-
z`FJ}oaQjgCpV#o@Nx!OH&py^S(Mo<6#&dsVsr*A}PIAih}WFPR&w
zCRp$^BQjucQVv0ZvdTb~5Y%*mLkorYIJsDrg^}#t?y#MKoS(VfIorvSE~hJ+Nkv_H
z1NyT0bd&Z4`Byk{k++vY9$qbIp;T4E&6tF`tlp*!>j)C5KxYI&p)K>A@*LYD^nxH$
z?vczftYFCQBHl2#E4np$pk;es%l>Foya6Zs>Eu9EYEz!e5Y{R^h4l>CRPYp*(qm5H
z=D~}jc&KkX?%Ns_4@L11PWDH)q8*0URaN#UIU9C%a`k~+cScW=kFDx3OHQ<-c(1A|
zhLPT?d~EY|Lya>!Q^W8jeqE%Xq@>T#)`R;Q;n0=BC`ofPQDBM+{rFksZ55a(iGAa)
zU*eU+_dJAYMzc*kC0`CJJP^FOO9?7Xpo<{uSO7rZNrA__;wfikngXyqdcC>NU}wp6
zrPBc|2Xff6WKjHOlr*OB8%+b_HySNtDX$lf;WU+r55_k%G}>I?y}14c>;mc66GV=~
zB>p6tL*)LIuB-?uX}lCp$PRoG3NBNh#Q-2Qmv!*o*&zk*WvQ}QR7jc9RyUZv;eI1q
z1myA@D>js9##>)#Y7`z3u*P$CtoC0yo8w|Q6F271w2yF)%8KD0_2xTV;x+lRX_)S7
zLESy7mmECL$tj(~EAaM1nhN5QP)RT+`Em;B3)pSP8(VtVYgUKyj>BSg0P|KE5JF0S
zre930DlR@=+*Q0v=*uq{`_A#ko)-3hEcA%gLXTvULWp5*D*ZywDm-z#xOi1heo6D&
zsfhffDTW$dtI)HAE!7yiAVDOsdl1
z^kJ2l>S9UXuCtekeIpWyAb)r;s3gmj-+uKnaX)3%EDkWLFD+A&-j7eww|&#xTfkW^^2cYa9_rm4Q
zin3x4(yLf3=0BYT{IwK{%rJaGAcrfB}x_x6~
z?NgR#`|L{eSv%T*Hvmwtyp-4g+;<#Yu-bvpE@#a&$atCK%V}j(r9`g}0;71P)B2$A
z^>07GDy&Am=Vx|<@=_YGAKMS!>s6Le->|zU{Oc`LG~#QV)<2JRJPc{DYNOS8_y_LC
zl{@TCrW62$lakMd)^-st?P%lI2t
z)Hp`>W4-6c4x>S@{PH(^%>AB~t9w+1&30NhSzJq;*3A}|Fx76iJC$XzW&Y(3cE8JR
zb!47(SvFgpOI(&s!0&j{;v!y#gh|u^kVZJ9B^rTLKq!cWhf6jz7>B3{VIyUy6St8`
zt}7v#!kob_%sj7rhkZ`%r086h2XZFre!9|+So+}e;-=^KDM@y(a^Sx%DRgARg`+6@
zF2u-VGLQ-ZWzz#K(++!YiRJ=~3|GVj`!3)x5$zUkh)3uGfML}Os*EV|5hF(UJ{A{;
zN;^ys#azEYS4VvUT}QTW$g@cuN;(_~!om}CfZ=y>M0q>J?!6&0ot>C}-$GouFs%Hh
zTmXOk#{D|~3BT@JuRegi$szQ;LUnyKd=u@?UxB<`_Ui-kIc(E;I{yK`ZY?|iTsd&P
z-Ds3oUP!mxQvQ9=j3s~$dYyr~$?Q9b+{-|eMivJd_6zn%Diy*g%^dgph0WMnjlyQm
zYvbd%&X(IOX1{WrZT72MGXRGk%-(<@szG$F^a0wjK{JzM4tXi@39NXYNK<*-69LR<
zHA_JJax@?fIF6fq^$B30HaB2{+{uk~5)kSg_1^k+EuCO#z)8DSy4iVj*ToiH!~Bac
z@4lm}>JH~j*Yjl;)*~sL(K7eK*OTEpx-0KkaM|Wbua?%#Xj@*tK(C(|>l{C&ZhWb0
zMo~pu{jBOKI=QucYE5gb!YQVnoLhYCh8f$YkM&BY2iPFc51wjZM;I&Xyq~eb&xB70
zb!DyRW$vzMsVFjQ1?9U8snP5KICcCp+z|F5YaW9djR7^>S60XQbPOU4qinn+8ToxO
zNmqH=nTD{Wfv@awt2Of=f=NR|5D_7WgKt``%4VxKRM|4nPih20e86-edqM8Km6$g(
zF)F>V8F&FIKjPI0*Fu5JJohBIjc8gc^_8vam+bbN)
z^b&a)S?@-wcXYVkV5Z!+PTi!3PaWYx6x{?3=UUM
zy8MhLFoOTujq!`V*3tMSxoiS#=D?7Pp0%n(Q89qC3)`8F5QUBrh37*5=v^&^@-+(>
z0htu_oq#P)lq8+7G(S15;V0Pkj8^Mm@ObujJiy12bM!;%^Wpm2hU;Hg%d@u!H?ron
zhpV7{3eP3fX1D@MX!O<)`U>hiqBVv!FrlFe?i{Tt*v_Hf&)NWd%*!uj=XwWu1V=%m
zC=E2Y%d?O9C>(f5K@*3!6y2GKU?CtUfo5X3XhJ~Qjcg?3QbPGiIU@?a)bx-J>E7bj!{QCXu3mQVoR({~yqt$+}u$pqisO>>~0Lk}B@ByTU1@@rY
z>u~r$XBHw_V;CUK2l9wfE-|f+u$d`;80<3WWT;92N!SjR2{H~6qAwgjz)%Q~BE5t{
z5sXHIfmk23I8e_Z=spyPNqq^MSm$uq;)aRIt1IR@rrxz|-rh(cR#D{NJiasR3>XYL
zQ?c6>sGBu5Y=Z}>%ZU`B67$U8nWmTEokDOZfCCqnPOb^fozyaELUjAIxk6bm033#B
zK)9kPDhNB1%fimKXjQzX&F%7()mOHa`eSoz%C&yCm5&2z3k}+W{3v)^aQ~O=ST2;{
zqh1e}hLNfmPB0wKxK4n)$lD{=B-9?QB4!5iAyd1#&(;uI5^TqO<*$<7Dnfn947Tvt
zS#<%IyV#^N7y{04=lIS3qKa4`vUlFHyQVtkR$QH&Xo%Y!jyh4ywM6DmD$Evdk4Gmh
zpTE=U_G_b+^J4zew#xc4kIUUw6R(Q4Im646I|U(HBwPXSFjgH1mI-sGZI4bs!_5s5
z3VlxJW8l7`)tX5d8S9bLfPC=@;-9uH}`2fVh;~5}+A$u3Um=pMOMiBA#5(f+jB~MSC
zn)!Lx?D_0_9r0+`pq+|DG;S}OtTT^^ggZJy6=Tf00YNken;J_z?vjl`&(-CAEmN*Y
zCIyenIJNpZr0o0Xx|%6Qw;Ryo*9)=h0Xy!_Sk9T#&@^8c(nn0QS=duDz9H!G1RKVe
zc%JC!;BeL*S`*&RKFe1V{`u~DM2I|G-q7&DbY%s5VEO^&mde^;UG{pRiU8kB^nWzuB+3UUR4BQ7)%rO`tFm8O&c}Ju*E2W7p9T9;I7yo!5lX
z(M02^IocHA0|sI3XLKxj9>WcSSUt~xtJ8+~5J5C2jfxN-A*?|}r&Io+23KzE5u-v>
z$p^6hGe@ZSLfq%|`r@qnoO1>zZdIP&vYv%jtSCiNV75YUt{d0P9x(tvw|d2j+HuYB
z@9tg+vR3!~V7#LD=YyVw>~Aj&yNQK8!ugN
z9UCp~oxz?gj&*j#ii=|%ov~uJU}aN%okhQriOygttN7OrFRS%-*41?$TfI8-OZKsH
zO_fIsv2DtwH7}(~ORJa!MK2%;=)9#Q0e-
z_BW5)m|^T*v&rE5TV+7}mC2O(gmsyWM(^LM{K_LvffdF7!z*rZDzod#Dcu7mwar$`
z*4sUU=djGz-40u=a6w4CiClcL>lMlWR2F#kgGfL)E^!$C{h|!XpPfWluYi?|c7qNc3!frpzTKbdDdEx|9tNx80$qoyY*K46?85f0sW&
z!7aa2ZZbRGWXiX!R!fDr&>YFc1tlDTfX&`!!oS+D8#!ILKE()Z+kfC_7D`;pT=h~J
zBhY)eOM-}%pyjLp^|L}=3dbtO3hGJ%;x`FW2IZS?*ETc@zhv(z#m_v*Cd`@z?SI%G
zDz$1|ag-7Xu5}ewtF<)b4}(GsDA&ELygY7vMMZRq|I9nAAvVB{pUSXJ24sg9wMM(o
zrY%~PNZvB0^154YNvyzv?6VoQqUfS5)sk!s6`k=rvd$y_Iq}U&@DFME5PHT1kJKP}
zEE^;b^Tc&c&>7%g!ecN)VEqyZlqJhD3)xb|seD(iW8I2Rd5A4z
ze^$P$IK@fI%gP_wWaYhW%I|O^7V&L8tQdZqg7Tj9rt(MS6=qfbuKb7c6ILP~P=2EP
zosEO=Vggafln`{`kuTQ?GZ?HQo+QOOT
z9l{$Ong7}-Y~1)3dncttGLMU)9@dYzj8x6t-@Ho*98n&*MR;;==JZ~1Z|3qI;fhoD
zo;ZPVIc$SdeJ>VhHsNXxx8JS}#q7!uNUUwQid_t{L=-8{Fsd9E_Udc(|1mz31cb(?I^6JaRZ
zOzye$B}*=ydBfR%5-yO9@4d2IXr
z(+>fwmj~Z*h2;hVYeof&)GC0`+b19}sRuI!+(055HHC{*^C?{$8X}1Po$Hc}qp<{*!Dk8*^uyoeAHZJU8U%?shoMt&Xib
zYl<(OwlbyH9~UkQMhyC~<8{XJKyk#ND=F6NBZJPshK^b8abrb?-d)}l>3Pm>xa~G=
zd5ie;1B$=2vDk4S7Tj(w853+Y)IY!XJ2L~drKL7goinzKq9^I6`gfQW4iB
zl2x2%Fos>-71gXdzIe8N`N3XMNYqZh`AK(2yynh_YGNH8OI>;CFJ22*)VG*q+r7%>
z`^<8{Humn%zh7QzyVl^S-u|WnM2=W>gQWLXXqjH?v~2l46QA&xl}Y1RW&YR{?x?Qw
zy0NsUFij`?*r{2|!NL28
zsjd^jAOi;(BavJnJkV5@q6Njrx_pnV*!;-$`QZm=?(7`rmYGiaFE&qk+!E>-H~;02
zBJE6QS+!@+L?QH>z_N2MTvjXVl;wk&Q>BefNa&bv=T|ex#<8>^A^`R?a_9izLs%{U
zRyz#ZBUff=dwWf5MPreXAx*?dJ(G)?HgsNDz3k3))2?Or<+tCQr@YKpImX9s`YD@k
ztXaBwY0)>8)e|o6og%Pt(%Ag!lmACj$e`|sn$To(P86!}giq}j+a3JN9kL(9`Y
z{Ef9%UIYG44HLEL>^n)PM^>{TZ54Di;NP@qDndc2gsadLfSJs%0vZVKL>I%adq*nDoUyd%E&iq!a(OQ%d)xUk{)
z(OY-yczEWP&E>UgH_q6-y0LLVWXd7s-ICJD&CSscan9_=7?KCFDf{<77Yc>TaU%cy
zy(5Q9OUuirR3tkZR`1yN3+b{+bLLELcAB(Dw{0CG+Tm`l`qF8*ueg}y4qyR}!j*y$
z0Mxzk?aWg8)20S@k!zRW%qtMWj59&|43(l
zRJX}G;SP2*@$+4~exA6>qSKlWR#hD|Yju{)(cDwjt*ux`iSPOxO`=Czlrud(#EbK_y0L1SShwjawriLP+%D;20XRBpcdlLLkoHhta{
z^Z{xF;tp98FCrCAgdqm6q(YM3jowOiLFwCZj(R6>PGxJRo2b$0UM!pZ&2S<>8&R`n
zUrgV^M@nVkc9Q|AcjZ-*&4_qD$p(`w8qDrlhMGW8GnNH=QI#WB9u9gff}qu!
zbQZCAL9^FW=p|LAIrKz`K!ZhG)m9I;zuz}q$8H2&*a%a$KunOLo)9!W|Th6I$
zoiwXyoGBg(hea#1+5+~Vw1K&p){Ik|XtHRPZl(uZm)?Z-H6oK4I$TihaQbaUL3@d@
zTvsiRyTI+9eBZ^Df>e81UA(Ofz7Xx*r4?S!lybd@%#`(wOq^QeLacmJF0J$!MEwC9
z1W4TksMIEu*=ouJ(PUsHE^jHTs*r3}vyWK=vfgKd1B`>24GzQqOWS*Z$5EYa!+WM|
z@4c_KuXm)KB}*=Hmz!{J;EH=$7dkdzzy@rv=rM+bVv4~K1p*-uz`UjeUW!S8
z03o3UjIAAi_nDP!;gG<4{nzg@J9DO=Iprz$b3a-so`jY9I1>j66mTJ=@l)$fIt8a-
zfa8&};F79ws#SG91uJvZ7d3mNzp6COmD?@8dbisIw|K)Gbrxs4M4>B)vAXKw0(-Mu
zFK2j#tW2*P9+68698FNSO)Il33nn{_;Vc!KV{kIS-w>VoX*u#mvr4!&8GV8y#^Wl3
zoNyfBTrAIg#z^Iij%YMePQ$|jqGkzq@_DtxX0-zLY~)PsF1^gC@L183@s-?J4nk@)
zXxVCm$~IA@FA9egYEEek1ls&&p4I4bq;|DcrEAt26jFy=nx$o>d1Vbz!&7DL0fk*}
z_0V+QbIY5}SCuV&u6up1g?L;!`r&}3Di6xhT1ghHCIw(Tse_keCZxa!8>CMEC@gPmB+B{eEN#oA
z1IAc_fg+2Kz<3QQEg&oBsg)HQoGB8eXNjW;IHZ6pDjz~C$4PQ#GK{|bx=oh`b&q|v
zz1ET?{889VCXFt+_VV?SFlU^%X2a!uS)_n{=YRe%F?-2%{a;~HXGR@9(J^Ypfr8_`djf#7FG;gj{on>7Lh|!^&$cLg14JiQ18@Y;(tRcsrUG
z3+;eso*#O7N`aS=bwnIyon$&@w6X#g2swm6!^;6&2#s}x&kI=yAv+`PiDpH|v|Rwd
z7_Chj>zYZtg~AX`Lo5c=K`Me|#9587gAgM8
zsU=O3_6aq+x~*BG8%oC%=ahI#O20kOcJY!%vgm{TTjzJST_v1)a*2NQzy{&z26?Mw
zYz=Djv%|PD17Ve!3((nH1d+{kg36>_HLwOjNdpL5V*u
z=6|HfKUmY*pv6QRmWYl&qh+8mnc_e+Q7Mrs2td3+mLH7y0U=4O)brQ;?-hu4YAon2
zXoRmw@qPYZJ*BY<5Wu$0BdK|9;HDCKwmrUW+v5bdkX$l;yD&#*1abG51&xgbAU1Ux
zb!6{$;b3k>%ws31MT>-#o$a9~Y|A_=ctwsQ&Yq%!2ZUWXT|}Yx++VnbQD=kChukQm
zE0T><5$KBlSO>8v$U24N;?uB6nt}y+0ebqEicfM>D5AgY)k3dW-V1sV^3vJoNQr&a
zBJpEfLz9H)gYk>jT>&+=S#6;qV-(Ai>2UrO#wOI-Lp9YQd+mhm0yu=YN#_hOpOLq$
z?L9sxnRNOI
zjpoF3Dd1?Nq=(lT)F)18^w>*EGJDnP%wFMT?A2>doKTD3JjFkScnu?3s3c6sH9D+G
z#SsvhI>TaCS~25#c}SF$Da8i`4r2pcKmRPRctm*N(ELB1MmX8lt1(|jrVAGx-$zr-
zu6ULhZ_G0o{S&6_I(gly3$lG$*{67$@<;matPy_w=2j3Nu7BpmZ`Qp`-1}}Mwm)r@
zGTGU_k*}<{?&PjgqfZ+{pU&8%Gd}HH`ZdI%3S+VV-*Eir`nb8|5H<~F?$92LJtrl!
zJ4>--?h<1JiKIVCi$pIhx$7(s2YNCi$vWLD?SXxuk)pxS>T{t0Bc@1f1{fD%mj=B;
z;XosWnIF(9N?{074C0VzbMT{43=jkn=!aQWX%Cn@nvTK|UT%DjHzyls7Ntt(v{h?$
zkDA?f&?g&Ss5(v`==gmmFs|OmcH9TPRnvXPokB}G^#oBq!5}5`!PT!K7QtkCme*%z
zAwPG2$`y@jw66f98#n)Tc`w2!NhEV(<}$+DjO3yxop;e=xQ%bQsx2+kN)znAayW6$Ci4qlA^oC@uqVxC@94?~JFB#t
zbTC$N#^8$9-OHxg9m?S1`8#T)ET_vMMzxja^>TBWPVXttjkz_9)TmJM3<5VCH5#Md
z8h^YiZgy#93B@mf%WUiBbrG+F
z4;Z|sM-ba&`ZK+bYeOii|R4-PiVHNXH+FB6*2!InG{fP0yA<503J#ROk-<}
z*re(pQVIiHP7%pk8i5N!42ldDFHjEc5*Nj#@f}fyYvLvaXu%m3ow*%!j)9RDtFd{^
zN;wiMdSnK#*86b&UzRKyQ&{-w!X-1HBlZfXcfBwCuU64Z$gcNcD~PmT{W~Eod@OwX
z`qnE_2gv01hI~${)k&pSyit&!&+uBMx^ims%5e^pJlBQ?Gf%3w=Wx8!UPH!DER8Bk
z%AIm|sIKnbiS8n`&%OTZ{y>XP>+}bPWx4ihTs+9vd|F;LeQr-EaCpYFsV>jMH9gn0
zXl?)4mHFA(eATx3bxo@uUA%&DsRI|cC$G_}(F&OA+WHk5ElBf>RSTFI)7Mwv?s$g!
z9u4kp&*n9wdeSRgPGgCy>rnHsxKZk>D3m%u!f{r%SPlz`iRO!^Gz3wo@Q~UKASs|p
znM26XjDgaCXie_?gU|l{;N{N*g3kzh(|>vxFm*2e@SoBTkC-2kxccf7e68T>
z7tWjYCb2(3hP{!_5k7fy7TMoVKJvaHpnJl8NM(n0kkb%NNVF^!RizS`MlkbYEY>ox
zo`BJov6a(xp04vSIK>Ni=>41)8V-i1I?O*>+L5Jnm0y=NY5M$G(?`|l4ai}
zb05i_8yY@+(##2C{mY-fWO=68P?#bXkXFdHkh)j>+6ek`gLtm^RV`%%XTz7+D3Oz
z8rxE?({WRsGFyGT%E#D7Ztkk}8qs~&YcG}AstY1av4oRYfPwxyTz3>nZWiOKLHqq)>>1s5FqT!cnZjT$io>v){#=BbB;qt1GGS*1GmWAB
z&%t19AH`Ow2g1hGk^bj?K|B~zMNog{pv-Ih4;cdn{JA;*EpNa;bUhgw+xPG312QtX
zbQ)xGi=-T*fK3#~AfXu(mi224wJiu1$y#_nBhY*
z?N1NAx0fjPJxp@yww1qs5r~VnzUy3`LjI(8{dQJmaFo_hZya`>On5()3JPHE%*d3Y
z{4VAjBJkF+(2p_2V93OblQHR1l^OFE#d9IPn|^6L{ve`*S1S+xZA@Ndyo$Rrm>bn(
zdAC+Ca4mL~b*L&!bTzu>o}2&j&dH(vBX;YbrE=jLQ%~hP2g?8Wq*^x3-eYendnob0
ziHBgAc9G5fXZ*ve+;EJJ~
zrU!<`Y~@l<3P*n1t2Mp}7=}V)`*iTvs6`=Jt#jIt(Fbxm8m|M=kARQ|rmvt0%^yj>
zxl-OAVHRI-ODd@`$*MX#s}Qb~Ox*V~NX`Y*J_Dt(3m;`Vur!6dL3z6sh6)Q<^GFj-iI~arAz&Pyw!emlrWp$-_
zp}bNZYnAnfmWI4V*A)qGL~@D{tON0#93{ueQ3{piG=7I=baJ47K*L2e0PUk^v(nN_Hq_^KsVXqabL;TRA*y^fdwtP8U||3%%{Y4=vh##I+~
z>Jq{W3Hi91!VX>HMvtX-Od@aJf_+YFO;;lC=6GfYfL`VD@$}&MZ5C_I_?o<%7u;d*
z?jGlQl|
zhSFC)I0?YGN!x?8q>fL7>&Q?L2@6Vzz_an0jg2!4pDI-6C@W%YGFFku?(d6L)P@Tm
zj>Nq(RG+Q@?h7HSFnTd&t>j9uqcNq`_YX%#E1Fe(MvxfwdXto>Yv)%Qey0j
zk+MS&10M;|?h;B^q@2af*$l)Kh9@n~*|<94%MXPs-}ob$_SRd%rzHLvdtW&H&9$p<
zC6+(Y6s0Ni9qCCj|PMBy5(bAJooxH476d1n0HDI&v_AL9~=?{dP|bgwBak5^Q=lfjY7T})HDR;6N|8AhHZu`6`CCI7&a
z)qZ;IOB1!)=&Y)X4JU9L+Ftk%#5q(#{Ir)LzB<#hLZw+Y8Jtv@0N+XrnmT|LI?BDrrNiJgMIV>QbpV^ul?g6
zS8sh^IPw10qTy4!!kD(tj1x5OH6R%&dL!^bvZ(b0`Z~3*m53liw3!k(9jMw@VogwD
zn@H3IxCMnJpo$<*fgcZRqPqtR4puvWt?OVfJUdEYbg*)*dVQVn&pJKgw53IB*Az>Q
z!m+aUc)XqbHr`%_wNov#Lt7uNf1VbG%bo9c9%e)~n_b2)z
zS*F+3)#>z7X>qaiHCzmBsXI)sS=LqD66%%`SAMuG-X1S0<}JeWvhHw8aj;6~^6Y%!
zg`HUrUF8#JMwUzm#~4G$Q(8|MTd)rG6coo((N;y9Ev+Y7O<~bMO{+(&Ct6{&qEI=J
zXabW2{5n5fRj6f34-Jpl(5VMf5_?diiGLo~Xm~xJ^KuTa7leYkg8XDY>B{`R2?&O7
z*-hmKNxqNzU5YGE8n~L9mU#1WYqFgDmj~|oQtI%L(xD3xn0z=?h&`(>c`^FbpfQ6l
zKqMbK14|KK5aJ(X0}tWj13;BpA_Lbv8qkkmk~6zk_O5hCTzgh@jalI`n_T3w-Snrs
zX60=w$e43%>C9nQ-KeEYMhPF8T`u#QbzRGsjV72(-KO&Q*KIPp+@|$T_xjNYUb^pG
z13Mj~ZTR31CYuv-sfG-`;y^)vdyJ51#tr
zexk0e628upRT7j{d<|gw%BhSYB(<#F5K+H9`;|;8(G;YFn9Dfnt
zV8AqTc76Dt(w~#z>&cBTz4THSV@dy=3>O}w1vfEf>}eIiD!HEfxIddYjD5?5t8h#!
zbC`Jl1UAb4uG_or$P}Jg9n!z3T`P$1kwmYf6)whn3|Z6D{v^d;Ln4l5#faO%%*MIh
zhqHFXb6xJ7xbUxm6=u`@8_gzLV&aBlrHvc!eqdvJ)8oeywHsO6&>Cc#Q{9LyHjpu?
zDfBm8Ow>=YBdcae)7!IOHZcpZ8R~xwtK`Iw>sKksKCO_wgt=p@dd{M$C~Rst#Wl%mQ`*2euFzN+Y!(PRk?B*lRc{ckhUVvz~+7*JzTDEd29}5?fTlJ
z@I%r0ZRA!qSXo*DLV{5ZZeduDRGF_f9rG!(*|h`+B*M&K3tLv7H@sqDqSl+J*N6Ar
zcjWr>82G~Yu*{?OI>J`Jvp%~6Z9=K{wOcinwHC%1pSI~nGv{1t)$45RLakM!1VV^t
zvJ7FXL1$%Sdgr6P#i0Oew(E_iyf$Z+o<)#{FX?u~VvI`n25*t;q!8d4Fr4Rl{muf{
zScM|rO-KisF~bsy+VTyRrVgDVKH<*ia#@8^VJerY`o}qQedPree7=eesUIj3j>1Ku
zQ^6LR%V=cGN;A+e=?!Dm(qiE1>6J4&t`XzQKY;@+mrO%eB?*8S8EXjIi3lG@8-ag>
zT1PUyOoY^do`PyPu*(Cd0QMT30+cUpM-e#YgN0dcPkh5s;qSsx;p5j+(dw=dU4TaTxMo8oD!HI
zMyJ&oq@0=*TJ!VWW5ph9nGFq{NkVGd>IfSs$X@gE9m3y!yLiPPh`V?4
z-5ZvTNP3j=usLRTPad;3;u-1E*oO^Ywdo*6GqAV}$Pix4lHHOu7!P!Ca7F1Spvpla
z0tMS91Kq8)q@HDMkg0(C^szET?+_Rva0t4-t(@ix!WmI&PEX)iFtD)+AN8mJybq8!
zWo3#2)(BQMHd@cr5t}%0a0R`4ybbq_*Dq}wzh?3!A478$3;qO;D{EIera!rS}GJvcS^Py>|TYrTPiKZcyK#3eS&(>4A)q-m!fF
zy(9j5n+{LZ;lb9 
+
