From dbefaf7dfc6cc99c398328ee7ad84f44c60048ad Mon Sep 17 00:00:00 2001 From: Mathieu Guillame-Bert Date: Fri, 25 Sep 2026 00:13:41 -0700 Subject: [PATCH] Release PiperOrigin-RevId: 988063395 --- .../ten_lines/node_prediction_test.py | 1 + .../tutorial/temporal_alert_regression.ipynb | 2164 +++++++++++++++++ 2 files changed, 2165 insertions(+) create mode 100644 doc/docs/tutorial/temporal_alert_regression.ipynb diff --git a/dgf/src/learning/ten_lines/node_prediction_test.py b/dgf/src/learning/ten_lines/node_prediction_test.py index 091fab0..40352ea 100644 --- a/dgf/src/learning/ten_lines/node_prediction_test.py +++ b/dgf/src/learning/ten_lines/node_prediction_test.py @@ -1399,6 +1399,7 @@ def mock_prepare_warn(*args, **kwargs): num_sampling_hops=1, evaluate_final_model=False, verbose=0, + padding_margin=0.5, ) self.assertEqual( model_warn.data().training_stats.num_skipped_train_samples, 1 diff --git a/doc/docs/tutorial/temporal_alert_regression.ipynb b/doc/docs/tutorial/temporal_alert_regression.ipynb new file mode 100644 index 0000000..f885021 --- /dev/null +++ b/doc/docs/tutorial/temporal_alert_regression.ipynb @@ -0,0 +1,2164 @@ +{ + "cells": [ + { + "id": "7722afde", + "cell_type": "markdown", + "source": [ + "# Temporal Node Precition with Timeseries Data.\n", + "\n", + "This tutorial showcases the native ingestion of timeseries data in GraphFlow (DGF). After completing this tutorial, the reader will have learned about incorporating node level timeseries features. This allows them to model dynamic networks (such as telecommunication and traffic graphs) more effectively." + ], + "metadata": { + "id": "7722afde" + } + }, + { + "metadata": { + "id": "X8LhS-9nc1gF" + }, + "id": "X8LhS-9nc1gF", + "cell_type": "markdown", + "source": [ + "## 1. Native Timeseries vs Graph Representation\n", + "\n", + "\n", + "In [Node Model Tutorial](link_node_prediction.md), we showcased predicting node features on temporal and static graphs. For temporal graphs, we learned that a `creation_time` can be specified for nodes. This enables us to model temporal phenomena.\n", + "\n", + "A single node often observes a stream of data points. For example, a router in a telecommunication network might log various statistics at certain time intervals (e.g., packet drop rates or CPU load).\n", + "\n", + "- **Option A (Explicit Event Subgraph)**: Without native timeseries support, you would need to instantiate an explicit auxiliary node set (e.g. `\"log_entry\"`), creating a separate node for every single sensor reading connected via an edge (`router -> log_enty`). This causes severe memory blowup and massive graph bloat.\n", + "- **Option B (Native Timeseries Features)**: With DGF's native timeseries feature support, the router remains a single node, and its measurements are compactly stored as a sequential feature array (`signal` with shape `(None,)` and timestamps `time` with shape `(None,)`).\n", + "\n", + "Let's visualize these two options with a simple graph consisting of a `\"hardware\"` node, that regularly logs a signal. When the signal gets too large, an alert is triggered. This is represented via a third type of node." + ] + }, + { + "metadata": { + "id": "XvT-b7kjcK-1", + "executionInfo": { + "status": "ok", + "timestamp": 1789380551820, + "user_tz": -120, + "elapsed": 14734, + "user": { + "displayName": "", + "userId": "" + } + }, + "outputId": "1c84d15b-9e57-4f2a-a4b1-24433f2bb7ac" + }, + "id": "XvT-b7kjcK-1", + "cell_type": "code", + "source": [ + "import dgf\n", + "import numpy as np" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/google/_blaze_simonmeierhans/92b7d23ffc411f10a3312fa9d7a085c9_buildrabbit/execroot/google3/blaze-out/k8-opt/bin/third_party/py/dgf/notebook_gpu.runfiles/google3/third_party/py/torch/jit/_script.py:1485: FutureWarning: `torch.jit.script` is not supported in Python 3.14+ and may break. Please switch to `torch.compile` or `torch.export`.\n", + " warnings.warn(\n", + "/usr/local/google/_blaze_simonmeierhans/92b7d23ffc411f10a3312fa9d7a085c9_buildrabbit/execroot/google3/blaze-out/k8-opt/bin/third_party/py/dgf/notebook_gpu.runfiles/google3/third_party/py/torch/jit/_script.py:1485: FutureWarning: `torch.jit.script` is not supported in Python 3.14+ and may break. Please switch to `torch.compile` or `torch.export`.\n", + " warnings.warn(\n", + "I0914 10:09:08.800000 80921 /google/src/cloud/simonmeierhans/temporal_dgf/google3/third_party/py/torch/_inductor/config.py:1497] compile_threads set to 12\n", + "I0914 10:09:08.800000 80921 /google/src/cloud/simonmeierhans/temporal_dgf/google3/third_party/py/torch/_inductor/config.py:1497] compile_threads set to 12\n", + "/usr/local/google/_blaze_simonmeierhans/92b7d23ffc411f10a3312fa9d7a085c9_buildrabbit/execroot/google3/blaze-out/k8-opt/bin/third_party/py/dgf/notebook_gpu.runfiles/google3/third_party/py/torch/jit/_script.py:1485: FutureWarning: `torch.jit.script` is not supported in Python 3.14+ and may break. Please switch to `torch.compile` or `torch.export`.\n", + " warnings.warn(\n" + ] + } + ], + "execution_count": 1 + }, + { + "metadata": { + "cellView": "form", + "colab": { + "height": 445 + }, + "id": "7q8JGGPAcNau", + "executionInfo": { + "status": "ok", + "timestamp": 1789380551927, + "user_tz": -120, + "elapsed": 50, + "user": { + "displayName": "", + "userId": "" + } + }, + "outputId": "a5d14611-fdb9-4b2d-9384-e9c5f558548e" + }, + "id": "7q8JGGPAcNau", + "cell_type": "code", + "source": [ + "#@title Option A: Explicit Event Subgraph (Click to toggle code)\n", + "schema_a = dgf.data.GraphSchema(\n", + " node_sets={\n", + " \"hardware\": dgf.data.NodeSchema(\n", + " features={\n", + " \"#id\": dgf.data.FeatureSchema(format=dgf.data.FeatureFormat.BYTES),\n", + " \"creation_time\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.INTEGER_64,\n", + " semantic=dgf.data.FeatureSemantic.TIMESTAMP,\n", + " is_creation_time=True,\n", + " ),\n", + " }\n", + " ),\n", + " \"log_entry\": dgf.data.NodeSchema(\n", + " features={\n", + " \"#id\": dgf.data.FeatureSchema(format=dgf.data.FeatureFormat.BYTES),\n", + " \"creation_time\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.INTEGER_64,\n", + " semantic=dgf.data.FeatureSemantic.TIMESTAMP,\n", + " is_creation_time=True,\n", + " ),\n", + " \"signal\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.FLOAT_32,\n", + " semantic=dgf.data.FeatureSemantic.NUMERICAL,\n", + " ),\n", + " }\n", + " ),\n", + " \"alert\": dgf.data.NodeSchema(\n", + " features={\n", + " \"#id\": dgf.data.FeatureSchema(format=dgf.data.FeatureFormat.BYTES),\n", + " \"creation_time\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.INTEGER_64,\n", + " semantic=dgf.data.FeatureSemantic.TIMESTAMP,\n", + " is_creation_time=True,\n", + " ),\n", + " \"signal\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.FLOAT_32,\n", + " semantic=dgf.data.FeatureSemantic.NUMERICAL,\n", + " ),\n", + " }\n", + " ),\n", + " },\n", + " edge_sets={\n", + " \"hardware_has_log\": dgf.data.EdgeSchema(\n", + " source=\"hardware\",\n", + " target=\"log_entry\",\n", + " ),\n", + " \"hardware_to_alert\": dgf.data.EdgeSchema(\n", + " source=\"hardware\",\n", + " target=\"alert\",\n", + " features={\n", + " \"creation_time\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.INTEGER_64,\n", + " semantic=dgf.data.FeatureSemantic.TIMESTAMP,\n", + " is_creation_time=True,\n", + " ),\n", + " },\n", + " ),\n", + " },\n", + ")\n", + "\n", + "graph_a = dgf.data.InMemoryGraph(\n", + " node_sets={\n", + " \"hardware\": dgf.data.InMemoryNodeSet(\n", + " num_nodes=1,\n", + " features={\n", + " \"#id\": np.array([b\"hw_0\"]),\n", + " \"creation_time\": np.array([1700000000], dtype=np.int64),\n", + " },\n", + " ),\n", + " \"log_entry\": dgf.data.InMemoryNodeSet(\n", + " num_nodes=3,\n", + " features={\n", + " \"#id\": np.array([b\"log_t1\", b\"log_t2\", b\"log_t3\"]),\n", + " \"creation_time\": np.array([1700000060, 1700000120, 1700000180], dtype=np.int64),\n", + " \"signal\": np.array([0.02, 0.9, 0.12], dtype=np.float32),\n", + " },\n", + " ),\n", + " \"alert\": dgf.data.InMemoryNodeSet(\n", + " num_nodes=1,\n", + " features={\n", + " \"#id\": np.array([b\"alert_0\"]),\n", + " \"creation_time\": np.array([1700000120], dtype=np.int64),\n", + " \"signal\": np.array([0.9], dtype=np.float32),\n", + " },\n", + " ),\n", + " },\n", + " edge_sets={\n", + " \"hardware_has_log\": dgf.data.InMemoryEdgeSet(\n", + " adjacency=np.array([[0, 0, 0], [0, 1, 2]], dtype=np.int64)\n", + " ),\n", + " \"hardware_to_alert\": dgf.data.InMemoryEdgeSet(\n", + " adjacency=np.array([[0], [0]], dtype=np.int64),\n", + " features={\n", + " \"creation_time\": np.array([1700000120], dtype=np.int64),\n", + " },\n", + " ),\n", + " },\n", + ")\n", + "\n", + "dgf.plot.plot_graph(graph_a, schema_a)" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "image/svg+xml": "\n\n\n\n\n\n\n\n\nalert_0\n\nalert_0\n#id: b'alert_0'\ncreation_time: 1700000120\nsignal: 0.9\n\n\n\nhardware_0\n\nhardware_0\n#id: b'hw_0'\ncreation_time: 1700000000\n\n\n\nhardware_0->alert_0\n\n\nhardware_to_alert\ncreation_time: 1700000120\n\n\n\nlog_entry_0\n\nlog_entry_0\n#id: b'log_t1'\ncreation_time: 1700000060\nsignal: 0.02\n\n\n\nhardware_0->log_entry_0\n\n\nhardware_has_log\n\n\n\nlog_entry_1\n\nlog_entry_1\n#id: b'log_t2'\ncreation_time: 1700000120\nsignal: 0.9\n\n\n\nhardware_0->log_entry_1\n\n\nhardware_has_log\n\n\n\nlog_entry_2\n\nlog_entry_2\n#id: b'log_t3'\ncreation_time: 1700000180\nsignal: 0.12\n\n\n\nhardware_0->log_entry_2\n\n\nhardware_has_log\n\n\n\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 2 + } + ], + "execution_count": 2 + }, + { + "metadata": { + "cellView": "form", + "colab": { + "height": 136 + }, + "id": "Lb9Ac7vCX5Kt", + "executionInfo": { + "status": "ok", + "timestamp": 1789380552073, + "user_tz": -120, + "elapsed": 45, + "user": { + "displayName": "", + "userId": "" + } + }, + "outputId": "6ee71b79-fd0b-4a6c-f195-c9dccfdd0cfa" + }, + "id": "Lb9Ac7vCX5Kt", + "cell_type": "code", + "source": [ + "#@title Option B: Native Timeseries Feature (Click to toggle code)\n", + "schema_b = dgf.data.GraphSchema(\n", + " node_sets={\n", + " \"hardware\": dgf.data.NodeSchema(\n", + " features={\n", + " \"#id\": dgf.data.FeatureSchema(format=dgf.data.FeatureFormat.BYTES),\n", + " \"creation_time\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.INTEGER_64,\n", + " semantic=dgf.data.FeatureSemantic.TIMESTAMP,\n", + " is_creation_time=True,\n", + " ),\n", + " \"time\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.INTEGER_64,\n", + " semantic=dgf.data.FeatureSemantic.TIMESTAMP,\n", + " shape=(None,),\n", + " is_timeseries=True,\n", + " group=\"telemetry\",\n", + " ),\n", + " \"signal\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.FLOAT_32,\n", + " semantic=dgf.data.FeatureSemantic.NUMERICAL,\n", + " shape=(None,),\n", + " is_timeseries=True,\n", + " group=\"telemetry\",\n", + " ),\n", + " }\n", + " ),\n", + " \"alert\": dgf.data.NodeSchema(\n", + " features={\n", + " \"#id\": dgf.data.FeatureSchema(format=dgf.data.FeatureFormat.BYTES),\n", + " \"creation_time\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.INTEGER_64,\n", + " semantic=dgf.data.FeatureSemantic.TIMESTAMP,\n", + " is_creation_time=True,\n", + " ),\n", + " \"signal\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.FLOAT_32,\n", + " semantic=dgf.data.FeatureSemantic.NUMERICAL,\n", + " ),\n", + " }\n", + " ),\n", + " },\n", + " edge_sets={\n", + " \"hardware_to_alert\": dgf.data.EdgeSchema(\n", + " source=\"hardware\",\n", + " target=\"alert\",\n", + " features={\n", + " \"creation_time\": dgf.data.FeatureSchema(\n", + " format=dgf.data.FeatureFormat.INTEGER_64,\n", + " semantic=dgf.data.FeatureSemantic.TIMESTAMP,\n", + " is_creation_time=True,\n", + " ),\n", + " },\n", + " ),\n", + " },\n", + ")\n", + "\n", + "graph_b = dgf.data.InMemoryGraph(\n", + " node_sets={\n", + " \"hardware\": dgf.data.InMemoryNodeSet(\n", + " num_nodes=1,\n", + " features={\n", + " \"#id\": np.array([b\"hw_0\"]),\n", + " \"creation_time\": np.array([1700000000], dtype=np.int64),\n", + " \"time\": np.array([[1700000060, 1700000120, 1700000180]], dtype=np.int64),\n", + " \"signal\": np.array([[0.02, 0.9, 0.12]], dtype=np.float32),\n", + " },\n", + " ),\n", + " \"alert\": dgf.data.InMemoryNodeSet(\n", + " num_nodes=1,\n", + " features={\n", + " \"#id\": np.array([b\"alert_0\"]),\n", + " \"creation_time\": np.array([1700000120], dtype=np.int64),\n", + " \"signal\": np.array([0.9], dtype=np.float32),\n", + " },\n", + " ),\n", + " },\n", + " edge_sets={\n", + " \"hardware_to_alert\": dgf.data.InMemoryEdgeSet(\n", + " adjacency=np.array([[0], [0]], dtype=np.int64),\n", + " features={\n", + " \"creation_time\": np.array([1700000120], dtype=np.int64),\n", + " },\n", + " ),\n", + " },\n", + ")\n", + "\n", + "dgf.plot.plot_graph(graph_b, schema_b)" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "image/svg+xml": "\n\n\n\n\n\n\n\n\nalert_0\n\nalert_0\n#id: b'alert_0'\ncreation_time: 1700000120\nsignal: 0.9\n\n\n\nhardware_0\n\nhardware_0\n#id: b'hw_0'\ncreation_time: 1700000000\nsignal: [0.02 0.9  0.12]\ntime: [1700000060 1700000120 1700000180]\n\n\n\nhardware_0->alert_0\n\n\nhardware_to_alert\ncreation_time: 1700000120\n\n\n\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ], + "execution_count": 3 + }, + { + "metadata": { + "id": "d2gc5Hh6c4H4" + }, + "id": "d2gc5Hh6c4H4", + "cell_type": "markdown", + "source": [ + "We observed that the signal peaked at timestamp 1700000120, which lead to an alert. If we want to train a model predicting the occurance of alerts, it is important the future is masked out during training. DGF will automatically perform such timeseries clipping for both options.\n", + "\n", + "In these simple graphs, the alert just logs the signal at the time of its cration. Next, we load a synthetic graph similar to Option B for a regression task. But since just predicting the signal would be a bit simple, alerts now store the average signal over the last hour. If they are connected to multiple pieces of hardware, we average them." + ] + }, + { + "metadata": { + "cellView": "form", + "colab": { + "height": 407 + }, + "id": "4WsnfgljZ3xG", + "executionInfo": { + "status": "ok", + "timestamp": 1789380552413, + "user_tz": -120, + "elapsed": 266, + "user": { + "displayName": "", + "userId": "" + } + }, + "outputId": "8d4e55b9-599b-4e09-aa60-6cdd698ad53c" + }, + "id": "4WsnfgljZ3xG", + "cell_type": "code", + "source": [ + "#@title Plot Telemetry Signal and Alert Trigger (Click to toggle code)\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Retrieve telemetry data from graph_b (or fallback to graph_a)\n", + "if \"graph_b\" in globals():\n", + " times = graph_b.node_sets[\"hardware\"].features[\"time\"][0]\n", + " signals = graph_b.node_sets[\"hardware\"].features[\"signal\"][0]\n", + " alert_time = graph_b.node_sets[\"alert\"].features[\"creation_time\"][0]\n", + " alert_val = graph_b.node_sets[\"alert\"].features[\"signal\"][0]\n", + " hw_t0 = graph_b.node_sets[\"hardware\"].features[\"creation_time\"][0]\n", + "elif \"graph_a\" in globals():\n", + " times = graph_a.node_sets[\"log_entry\"].features[\"creation_time\"]\n", + " signals = graph_a.node_sets[\"log_entry\"].features[\"signal\"]\n", + " alert_time = graph_a.node_sets[\"alert\"].features[\"creation_time\"][0]\n", + " alert_val = graph_a.node_sets[\"alert\"].features[\"signal\"][0]\n", + " hw_t0 = graph_a.node_sets[\"hardware\"].features[\"creation_time\"][0]\n", + "\n", + "# Plot the telemetry signal and the alert trigger\n", + "plt.figure(figsize=(8, 4), dpi=100)\n", + "\n", + "# Telemetry signal\n", + "plt.plot(\n", + " times,\n", + " signals,\n", + " marker=\"o\",\n", + " markersize=8,\n", + " linewidth=2,\n", + " color=\"#1f77b4\",\n", + " label=\"Hardware Telemetry Signal\",\n", + ")\n", + "\n", + "# Highlight alert trigger event\n", + "plt.scatter(\n", + " [alert_time],\n", + " [alert_val],\n", + " color=\"#d62728\",\n", + " s=130,\n", + " zorder=5,\n", + " edgecolors=\"black\",\n", + " linewidth=1.5,\n", + " label=f\"Alert Triggered (t={alert_time})\",\n", + ")\n", + "\n", + "\n", + "# Formatting\n", + "plt.title(\"Telemetry Signal vs. Alert Trigger Point\", fontsize=12, fontweight=\"bold\")\n", + "plt.xlabel(\"Timestamp Unix\", fontsize=10)\n", + "plt.ylabel(\"Signal Value\", fontsize=10)\n", + "plt.xticks(\n", + " times,\n", + " [f\"{t}\" for t in times],\n", + ")\n", + "plt.xlim(times[0] - 20, times[-1] + 20)\n", + "plt.ylim(-0.05, 1.05)\n", + "plt.grid(True, linestyle=\":\", alpha=0.6)\n", + "plt.legend(loc=\"upper left\", framealpha=0.9)\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABisAAAMNCAYAAADp9Uc1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAewgAAHsIBbtB1PgABAABJREFUeJzs3QeUFFXWwPH7JpGDkgQZogRBBAXJpjUnzFnMoqLu6uqa17DmsK5rxog5R8xhTYCCIihBJEiYASTnOOF955ZV8zVNVU/3THdPh//vnD7TobpSV1fXvPvevcZaKwAAAAAAAAAAADUlp8aWDAAAAAAAAAAAQLACAAAAAAAAAADUNEZWAAAAAAAAAACAGkWwAgAAAAAAAAAA1CiCFQAAAAAAAAAAoEYRrAAAAAAAAAAAADWKYAUAAAAAAAAAAKhRBCsAAAAAAAAAAECNIlgBAAAAAAAAAABqFMEKAAAAAAAAAABQowhWAAAAAAAAAACAGkWwAgAAAAAAAAAA1CiCFQAAAAAAAAAAoEYRrAAAAAAAAAAAADWKYAUAAAAAAAAAAKhRBCsAAAAAAAAAAECNIlgBAAAAAAAAAABqFMEKAAAAAAAAAABQowhWAAAAAAAAAACAGkWwAgCALGeMOdMYY31uN9X0ugFVYYzZJ+CYHskejWk/fhWwH9uxH9OHfl4Bn+NXNb1uiB7fRySbMWau37mDTwIAkEgEKwAASOI/eHG4EUBAxjHGtDTG/MMY864x5ndjzCpjTKkxZoMxZqkxZrIx5mNjzH+NMecbY3Y3xuTV9HoDiWKMeb6S34Ld2PtJD9JV90awNAvFcDyVG2PWGGPmG2M+NcbcaozpXtPrDwBAshGsAAAASCJGsmy1L2obY+4RkfkicreIDBGR9iLSSERyRaSOiDQVkV1E5CAR+auIPCYiE0RkCQcuMpExpq6IHFXJZEMlCzFKBBnMiEgDESkUkQNE5DoRmWKM+cgY00ayHN99AMgeBCsAAABQI4EKEflIRK4QkaqMktAGXSATHS0i9SuZ5iRjjAb0AGS2g0XkZ2NMr5peEQAAkoHh8wAAAKgJd4jIPgma90QR2dPn+cUJWh4QT6dFMU1LEdlPRD5l12eNS9xRZ+EW1cC6ILkaa3DfGNPFWrsmics9TkS0YwEAAElDsAIAgJr5B+9BEfHrJfeMiDwd4X2aLgdIa8aY5iJykc9LWrjzHXfExTwR2ew2zrV2vy97iUiXyuZvrV0tIqMTs/ZA4hhjWrgpYKINahCsSF5QwHOtiBzi87yet26P8L5qBUuttZOr836knPDrvXoi0t9Nd7i9z/Q7iMhVbnqopLDW/pisZQEA4CFYAQBADfyDZ4zRxlQ/8621NLIi02lDX77P8xdbax+J9EZjzE5uI200vc+BdHOyW68lGkdrfQtr7YYEr1NWqSwoYIwJqpezhN9vxMDveu8TY8wr7uhArdnkd35IWrACAICaQM0KAADSkOYqN8YcY4x51BgzyRjzhzFmszFmlTFmpjHmJWPM6caYgnRZj8oKTxtjtjPGXGOMmeDOf5V7/x/GmIY+8+trjHnOGDPLGLPJGLPUGPOFMebcWHO9G2N66Hq4759njFnnzrPIGPOlMeZ6Lf4Y4f37eNvj9qb0c2Ok7Q+Zl980c0NeP8gY86IxZrYxZoM3D2PMhz7vKzXGtK5k23sHLPMJqbpuAc+PrOyN1tpZ1lrdJ52j2d9ht0rnb4w50BjzqjFmvnss6zH9jTHmEmNMvaoUSY/iM+tljHnQGDPdPbbWGmOmGWPuM8bsGMU6NzfGHOIeh2+538XF7udfZoxZE3Ks/tsYM1BqiLtu4ftinbdvI7zvkID9eI/PtLWMMacYY15wl7fc/SxL3PPGr27R2ruMMce5I31ShV8QTs8bL/g8Xz+KQtzVZowZYIy50xgz2hhT7B5X691z4cfGmMuNMc2imE+7gM/wK/d1dbwx5m39frjnWBv6fROROQGz3zvSvGtadbY9ZB5fBcwj8LfHfd/2xph/ur+XK93v2wxjzOPGmH4h0831m38U21boHh9T3HPNGvf89R9jzM7RngcT+Rscj99QSRJr7W8i8nDAy+2NMa0ivd+99rndGPOtu390Gza6390x7nlvQDTrEssx4X4+fvv2zJDz8vnGmM+NMQuNMVvc3ym9Njkxwjqk9XcfAFAF1lpu7AOOAY4BjgGOAY6BJB8DIqL/RFmf201RvPd4Efk94P3hN00bdWwl8zuzKuuSzPVw6w8UR5j/bE0P5M5HAxF3V7I+2puxURT7uq2IfBDlNm5x03vV9pnPPlHOo9LPIWCauW4vzFci7MNDAl67oZJ9cFfA+wZV4/h/PGCeu8bp+xW0v0dGeI/uv1cr+Sz0OOsX63cmwmemo0v+KyJlEZa5VkT2j7Detap4XI3XoFEVz1PtqvHZ/C1gnidV8r5nA97XPWy6vdzzTaz74y/xOPaqedx2DVi3b0WkT8BrH0Ux33YB7/2qkvftKiJjotx/6zTgqp3hqrIeIqLBji8CXg/6vkVz+yoBn9PIKpxfqrzt1fk+usWZl0TYP+Ui8oCbcWGu3zSV7IvT3XNUpN/Fa91p/V6fm4zf4LB5Vuk3NJnXe3o+jLCduwe8R1MkfhnDd+PbKH4Doj4m3OuMoO+vBkdmVrI+mgKyVpSfV41897mxDzgGOAY4BmxS9gEjKwAASCPaU1FEXtPedVG+pVBE3jDG3JDG66GNdB+KSKQe5h1E5DNjjPY01jRC/6hknoMijHBwGGP2dVMxHBrlemrD88Uior3w/fJNJ1Ku28gS2DtRRD52GwvCnW2Myamk/kq4mdZabcSsKm3c8vO624M+qalK3eW9JyInVDJpB7dGwO5xWGyB2zij+ckj7X89pnW0RJuA100Vl7+HiIwN7fmcJC+KSElAehNf2iNXRI70eekHa+3UkOm0sf8T93wTq4SOQovS0IDnX3dTC/r1LD4gESNDjDHaWDpORKIdhVPPbawc5X5esagrIu9rwEiyT8K2XUeJici7bjAkcDK3RsfTsZ5LjDFnuYEbPUdF+l28zRhzayzzroHf4Gh+Q5NpY4TXtvl9NMYcLiI/uoH6aA3WoLUxxu/cGk9ag+dzEdEUjpEc6XY0AQBkOYIVAACkCU1zICKXVvHtN2s6pjRdj8MqaQzxFLo9GIfFkO/dtyHOGNPdbUjeTqrWCPxqrKmmqklTOQ2JNIHTFfLPQE64tkEFfY0xfdwG+nDay706pgQ839kNTC0zxnziprI4rrJUVXGgOcD3j3Lahm7jXnW1jKERroGOgJH4axSQXihhrLXL3MbZcAcbYxoHvO3QgILH4QHHf2qvaklDmgNIRE7xeUm/t2+6972/oXIjBXqquC7aSPxcFfelflaPVuGc2VeyU0K23RjTVESejyEIp4GyNjHMv4v7exJtgCOmOgs18Btc6W9okkUKIi8NT9XojgqM5jrJL8j4svtbnyinuEG5aFxsjNFrEgBAFqPANgAAacDt/XxzwMufuf+oauqT7d1G1zN8Chg/bIz5wFq7PE3X40W356P+03uZiPT3mUb/aVeb3B562vu/o/bsDGj00PzwY32e13oM29TBEJF5bgqjqW7v8F3chuvwxnTd9nNFZIT7eKKbykrcdEzXBjS8au/WcLo/o2XdES/vuqk/WrlpcVaFLOMWn0aNc90e6eH8RhqUuw2Z1fG+23PUr4CouA3TB7o3h+YPd7frOWvtzxInxpgWAZ+HWiEi92oPfnedtFH4WImvlSHLaO72TvfrgXqiMeYCa22pz2vr3WPsBzc12yr3tsa93m/i1gk53Sf4tLsxRlMg/U+SR4/Do8Oe00bVYwK+A9rLP9wm93wQyq93+gIRecj9zq51j/3W7v7QnsU9U6QDl54f/HLuf2et1W1Qr4vIFQHnMU0nVm1ufaFnfM7bapqIPCkiv7nHVW+3J3t4L/aztO6LtdbvnBJJqbtsfd9q93M6SEQ2hJw/d3D3Q7hJAUFEnU86iLTtVaGBu6ARNx+6AecV7vGvIxH1PBiLuyMEs15yP6MNbvqfy92Aayzi/Rscr9/QhDPGNHC/V36Wu/vAm9a4+8ovGLDBTYv1tfu7vbebhi98Wv0d1volvd1ODYnysXuM62/eEQHf1xz3d/bOkOcy/bsPAAhHvi1yrnEMcAxwDHAMcAwk/xiINYex+8+/3/R/D5j+qIDpb/GZNur8+zW0Hnr7d9i0jd3G7qDpDw+b/vCA6Sb4rMeBAdNqUKO+z/TaUDfLZ/p5fvnbq1ojJOT9QdusjRHHR/H+RwJyfTfzmdavJsmncfoOXFeNXNTaw3yHeNSsiLAe2jjV2Wf6OyKsVyw1K7xldAmbtqXbiBh1TQ/tXR/lPm8WMN+7klWzwp2vNnT/4TPfz3ymrecGY8KnfcVn2i0+0+1ZybpoD/QLRKRHPI7rBNRxuTSaHPLhx1FVa1a4I9P8pn1LPzef6Tu4Dajh038bw3pYLyCRqPobKVyzIpZtj+r76DZGrw6Y9lGf+eqIisVB6xcwfVCdnat8pu8V4fd6bg38BlfrNzRR13vu+Vk7M/wSYR2fCXvPYQHT6bmwn8+69As4T+rtsATVrAg67oJ+S99K1e8+N/YBxwDHAMeATco+SIVeRAAAoPJ8+voPabgZ1tr7/N5jrdX0CdoTPdyRabgeG9x/gkPnu8r9h96PNpKFp5nR3qp+PdL9ejJrgMXPFdZaLSK7FWvtCrfxKlwbt5EmWbShzK/XYTjtZR4u3x0FU8EYs0dATRK/ba2K293CrlWhPfAnRKjjEAstQOtHA2QzfJ7XIsKLJD40SKC91CtYa3XeQaMcfNNjWGvLtEe85i03xjxqjPnWGLPAGLPWGFNujLF6c3sK+4lHDY6ouaND/NJP7euOdAk1JKDXsF/NGe2xG65bJeuyzFr7mLV2stQQt8aDX20Y65P6yS8VlDe6Ih78zn/aiPtXv1E91loNaL7t855BbiqiaN1prdWCv9ko3ts+IGBUwhq/ek7WWh29F0tNCU0b6NeOoAGDe3zmPykgBWGQmvoNjvY3NF5u9M7NIednHfXSI2D6Le7IyFBBqas0qKE1Z7biPuc3ek3c0Q6JsCJgRJiOlvVDGigAyHIEKwAASH09AxoeOof+oxt+c9MfhdvFGLNdmq3HN9Zav4LMCwOm/yD8CWttSXieZ5dfHnwv5UC4MRG2MbwBwaPpI5JFe2ZXylo7LaAx/JwoUkCtDmiYjJl2zbTW/s3tRTu+CrNoFYd0VKGpw8JpT/JtWGu1wWiUxEd4GiNPUcDzjQIau7U37q/uel3gpjdq5aY8iianfCyNyvHiF2zQHPPHR5ECaoGbdi6cX9H3x4wxU4wxzxpjrjPGHG+M6WGM8UtzVFN05Jff+XCctTb8WAhqTD3VTQlTXXrs+P3PWBTh/Bd+7lAmYF5BNJVNtor3tmug2c+nfo39rjfiMP93rLXlcZh/Tf0GR/UbWkN0G892g4OhBgVMrx1FggT9hgfNq7ret9bq6Lhq/c4BALIHwQoAAFKfpoWJF1ON+dXUemzV8zyE3z+/yq83vNJG5nC5Cd5ObTBOBg3G/BTD9JrHOlxXY0xoI5FfT2/NQ6/pPOLGWqupf/q5vUmv0QY1twdwNPY2xlR59IoxplFA3Qwb4bgTNzBQXeustXMCXtsQbb05Y8zRbpDCrxB6tJLeOGSt1ZzzP/q8dHLY56N5+8M9F9AoemfACKrubr2OW9189Doqa5Ux5lNjzFnuyIaaFDQqwi8wMS6gka99dRsbjTH1q1BbIB7nv3nuiKJslIhtD6o/MT3oDe46rE7U/GM8Z9bEb3Csv6HJpCnzhlhrX4xhX0X6/Qr6nLQmRCJMru7vHAAguxCsAAAg9cW7IXH7NFuPoIZrv0bJeBRVbJQC+zpWK9we/9EaFVqkM8S5bqNl34AUWfFKAbUNa+0Ua62mQznI7WWuI3n+KiKfu8GDIFo0tKrCC417NgUUsvb4jfSJVaSCrZGWXcEYo/UcHg0IuqXD/wR+oysGGGPahqT7qhXtcWitHe++JyjdVai6bjobTYky2RjTSWqAO8Ls0Gh7o7sFcN9IUCqomjrHa2NstkrEttev4nlrbQLnvzbFf4Nj/Q1NtPVuYewL3dpJ4aktPQ0jvD/SvJMZtPZLzxf17xwAIPsQrAAAIPVFatSsirw0W4+gtBLxmj6R25msHoKbYplYaxy4jdzhNEVOo4AUUL9Za7+TJNBe89baX6y1D1prtUFZR3xsTMDolaAGtNrGmJwqNNbFQj+DIJGCM+H1NloENALdoKNltEC1tdboLQWv/V8Wkc1hz+l6nhghBdTYgFoiDmvtKHeUwRnuKIriKNZDAxVvVvKZJ4pua0HAa/MCUt5cFjC9fn+D5pXK5/iYzl8ZJhHbHnRe86v9UpXzWlXmXz/Ff4M31VCwds+Qm6ZN6+V2FGhord3HraeztgqdOTSQLTG+Vt2OHjH91rmBVwAAtsEQOwAA0rfn5Vci8s8qzG9ymq9Hov0RkMNfayvEmgJpsaSuJ91i0aFpkPT+qQEpoJ6VGmKt1VzlWt/hrDjPd40xZqNPKihtMN8pQkqxnSU19Al4/lZr7S0xpG+pEdbalcaYd32CYycbY7Qh7y9RjsYIn+8Gt57JcyHpjTq6QYzd3EBGeBHXHm5j4TeSXPEqjO31Ij+0knz1gTSvvDFmnU/D8mq3rkastHAzki/od6dz0BvcwvaNEzX/GM+Z2fIbPN9aO7qa81gUMHqki4iE17fwaBDbTzaPcAIApBCCFQAApL6f3Z6MDXzysP9orY26R6AxJq+S9DbpsB6Jpo0Hu/g8rz0d/Yr6xrqNQT3qq5vKJybW2uXGGO3ZfnbYSzf7NBSVx6mYdWhBaD2O3ohQkDXaXp9+hdNj8UNAEdbD/IIVbmHmIyQ1NAl4fkLA81rfItU84xOs0N7F1/v8r7LBHS0RE7eo8M/u7R0tti0is30m7ZXMYIUxRoMnAxMQ/KhSsCLk/KcjdkLpaKuN1tqg4yqZ5/iUOH+mOE2H5md/HXkTkO7ouBjnf0HAOfPagPccm0K/wZlkjHsNFu4oEfkoxt8BnVcq47sPAFki1YaCAwCAMO4/2x/67JhmIvK423gayBjT0BhzijHmW7fXfFqvRxJoT28/91eW1978qb8x5okI89GGUz/a8zvZ/Apt+/Vo1SLYC+K4XN3WV0VkmjHm78aYiIU9jTEtQ1IDhZtYzXX5OOD5q4wxO/o8f2MSC6dXJuhY2mZEgjGmm4jcJqlHGx8X+jx/ic9zb+lomKAZGWOuNsYcE0XB7PrRprExxtzkl4rJGHOmxCewoKN44ulwY0y0PeT9BJ23nnZ730dsHDbG7OeOgnpEknvMt6+hNF6p6PuA4G4zv1GQxpjWMY6O/Dyg4XhXY8w5PvPfVUQuSqHf4EzyXsDzZxlj+oU/6T4X3kHBE1QXI1Xw3QeALMHICgAA0oOmdDnep6PBULe3pBaJneYO46/t9rjW3nZ7uKlNvDzmT2XIeiSMtfZjY8w4EQn/R18bdKYaY94Ukf+5ufBL3NQZHd1e2dpI3NydXotj+vErbK2OM8b86vZarSiAGYc0EYGstZOMMdqbclAlkyaqsLamqvi3iNxtjNERDmNF5BcRWeam+9DG0f7u8aWFiP0Kd1Z3/zzlBiDCG7h12T8YY3T9Jrm9y09yj/9UEZRK7W9u8e0P3f24l1usPHxUVI3T+inGGB21c3XYS6YKKaD2EZE7dASGMUZHSOhIgN/c42mDW4w2UsNpPANy0QgK2mpNih+jeP8d7nk1VC33GNXG2qrQfXyNiLQJe1732+/GmBdF5LuQfbWdm/5H02vtG5JKKFFp47SewRqfwsIaWHzGPT+vCHl+srU2Ubn4U5K1dqObRu1Sn5evN8Z0cYPFui97isg/YkkRZ60tMsaMcnvvh9OOC/rbqa9vcs/fV/ik2qvJ3+BM8qH7+6TbHko7j/zPGPOgm6rTur8Df3NfC6ejzj6Q1MZ3HwCyBMEKAADSgLVW/0H/l4jc5POy9jq/LpvWIwnOcxvBwxvE8t0Ga7/Cv9GaEpBOS+et+zZcvHteh3uwkmDFqmqmlYlGrtuopbdY3G6tDS/QHBNr7RJjzO1u+iu/Y/pev7cl4XOJtletX40BDSYOc2+h/I67VDDSJ1jhF+T7Msr51XVTGYWnM4pEGz0/kSQxxmgAVxuNxeczejSa49oNHIQHK7wRG1UKVuhy3d7xH/n8r1jXPTfqrUZoUV5jzPdu/YJwp7u3UPu6jbXZRkdRnRLScB/q+ICgayzntavc75d2Sgg/9/gdI7GeMxP5G5wx3O/DMDcwU8fn+3qVe4tEg0rDUr3gNd99AMgeDJUFACBNWGu1MfV+1iMp+3qym9d5ZQLmvSWe9R/i4M2ANDyeV2KpR5JEb4jIf+I0r9vd1CbR0F76dwe8ZpNdd8QdFRKNcrfxMuVYa39ze+tH8myCG9Nu1MCVJI+OFvLzQQwBOA0i+tV82dMYEz4yImrW2s/dRv9YixknS1VHjWQNa+0y9xjzq0/h56FYCqJba7Wez/AYznlXBs0q2b/BmcZaq6MST3ZHj8VKv+OnWmuD6pykGr77AJAFCFYAAJBGrLWXuf/Az4zxrZoWY0S80iKkynokkrX2f26KDM17HW0RaHFzeX9eSUP6tVGmeUk4txbJY0lOAfWtm4akKulZNrhpak7WFEJx3AdDROT1SiadLiL7RUjllfR0M9ba+9xgSyRr3P2VyjnJI6V4slGmFdK0MLEGNHQkw2XWWk2plBRa2yFCDRYNHkbFWvtHQJDHVLcukLX2ZTd9X6zn6i1uEKWylF1VZq3VQOXjiZp/prDWfuqmaloaYTL9bbvTTRNXJ5ZzmrVWP+OzItQSUJvd1EMPB7y+uoZ+gzOKtfZd9/uqv63R0nNHP2vtW5Im+O4DQHYgDRQAAGnGWvuOMeZdNwXDQSIywM3lvJ37266Nb3+4Dauay1j/4R/nNshm3Hokkubm1sYeY8xOInKCmy5pZxHZ3k29s8Ht+TlLc2mLiObJ/9Lt8R5pvmuMMZq+5QwROcZtkNk+pKZHsmnD3/U+y59urdXc4XFlrdX82Ce5Rdl3d9M/ac77DiLS1s1BXtdtdFrrjvz42U3n8kakIsvVWCftYXqCMUaPZU2DM9AtSKufr/b8f02LDLv54IN6xSezZ34Fa+117ndRi1Lv7eaf1wZEPX41QPG4tTbqXtM1RINX/w1oMP3GWvt7ZTOw1p5rjLnWrV3Rx62z0N7dH/XcQMZ693jS7+sX7vEU8fuaAAcGpOfZ6KZfisWbAWncNBXUHdVN+6f70hjTyz1PDXDrU2znfj/XuQFo7WU/2Q1sfG2t1e9sQllrzzfGaFDkTLeRtoVfgfRsZ639yBizs1un5Si3tkOeW3PkS/fcMMEYo+mWmsZ6TrPWPmuM+dKd/+FurRPrnns0rdpjOgrDGKO1q6QK80/Ib3AmstZqvbC93Joh2plksHv+030l7n6a56bXesdaq/Wq0g7ffQDIfCbFUxMCAAAgwYwxBW5gKbyI9dXW2rv4ALbaV/lu8EIbgcJ1cdOjAEDacOuUPOnz0svW2mqnjzPG3OIGxMPdYa3VACMAAICDNFAAAAA4wydQUZpitTUSyhjzN2NMYSXT1HJHofgFKmYRqACQKowxA40xRxhjciuZTnvi3xPw8gcR3neoMWafKNbjiAg1KwLnDwAAshNpoAAAALKMm4JKNdKc1SLyD5/J3rbWLpLsofvgPmOMFhr90k1rs9RNRdXETVOlPYzbBbz/tiSvLwBE0s0tSLzMGPOxiGghZk2nttZNt6ZB1wPcej1+AY1Zbvq7IJoqT1PQLXDTl01wi3Svd9OudRKRw9xl+Pk6XVMRAQCAxCENFAAAQJYxxlSWB1SLmfay1mqDfVYwxmhx5h2r+PbPtHaLtTaWIrAAkDDGmHPdYEVVlIjIIdbaLyLM/1YNVlRx/lpYe7C1dkoV3w8AADIUaaAAAAAQ7j/ZFKioJi36fQyBCgAZQgu9nxopUFFNWpT9CAIVAADAD8EKAAAAhHpVRK7Jwl2yIcbpl4jIZSKyn7V2XYLWCQCSdU7TEXeaLqqntfb1BMxf6yC9IiLdrbXfxvheAACQJUgDBQAAkN1poDR10XIR+VFEnrLWvilZyBhTICJ/EZF9RaS3iHQUkWZubvcNbtqS+W5edq1pMcpaq6lSACAlGWO0LsWhbn2JnUWkjYg00Jfcc5qOctBUTFqr5w1r7ewY599dRA4SkQEi0kVEWrvzL3Pnv0xEfhaRcVr/IsvqIAEAgCogWAEAAAAAAAAAAGoUaaAAAAAAAAAAAECNIlgBAAAAAAAAAABqFMEKAAAAAAAAAABQowhWAAAAAAAAAACAGkWwAgAAAAAAAAAA1CiCFQAAAAAAAAAAoEbl1ezikQzGmFoi0sN9uFREytjzAAAAAAAAAIAqyhWRZu79ydbazVJNBCuygwYqfqjplQAAAAAAAAAAZJw9ROTH6s6ENFAAAAAAAAAAAKBGMbIiO2jqJ8f48eOlZcuWNbs2AAAAAAAAAIC0tWjRIunbt+827c/VQbAiO1TUqNBARevWrWt2bQAAAAAAAAAAmaIsHjMhWAEgbZSUlMjcuXOd++3atZP8/PyaXiUAAJBBuNYAAABcawA1h2AFgLRhrZX169dX3AcAAOBaAwAApAvaNYDICFYASBu5ubnSqlWrivsAAABcawAAgHRBuwYQGcEKAGn1o968efOaXg0AAJChuNYAAABcawA1J6cGlw0AAAAAAAAAAECwAgAAAAAAAAAA1CzSQAFIGyUlJTJjxgznfufOnSU/P7+mVwkAAGQQrjUAAADXGkDNIVgBIG1Ya51GBO8+AAAA1xoAACBd0K4BREawAkDayMvLk3bt2lXcBwAA4FoDAACkC9o1gMho7QOQNnJycqRx48Y1vRoAACBDca0BAAC41gBqDsEKRD1Mbd26dbJq1SrZsGGDlJeXk4YHAADEjTHGaSguKCiQBg0aOLdatWqxhwEAAAAgSxCsQKXKyspkzpw5TpACAAAgkTZv3ixr16517rdo0UKaN2/uBDIAAAAAAJmNYAUqHVERHqjQBoPc3Fz2HGqEV1ibhisAyMwOEt55Xi1evFi2bNkihYWFNbpeyB56vE2bNs25361bN2ekDwAAANcaQHIQrEBEmvrJC1RogGLHHXeUhg0bOmkagGTTBqzS0tKKolQELAAg887zmzZtctJOLl261Hlu5cqV0qxZM6ldu3ZNrx4AAAAAIIEIViAibSzwaKCC4saoaYzqAYDMpUHoOnXqODc93//xxx/O88uXL3euQ4BE084QnTp1qrgPAADAtQaQPFyBIyJvVIU2HuiICqAm6XHIaAoAyA5NmjSpCFasX7++plcHWUJHD9erV6+mVwMAAGQorjWAyLI2l48xprkx5nBjzL+MMR8ZY5YZY6x7G5mgZZ5kjPnEGLPIGLPJGDPXGPO8Maa/pKjy8nLnr/ZuJPUTAABIFr328Hq2ay0LAAAAAEBmy+aRFYuTtSBjjCZZfl1EDg97qa17O8UYc5O19hZJMaFFLoFUOx4ZZQEA2YHrESTzWCspKXHu5+fnc60BAAC41gCSKGtHVoQpEpFPEzj/p0ICFV+KyFEi0ldEzhGR2e7noCM8zk3gOgAZQQtse0W2AQAA4kkDFdOmTXNuXtACAACAaw0gObJ5ZMW/ROQHvVlrFxtj2onInHgvxBizt46ccB+OEpGjrbVeLoMfjDHvicgEEWkjIncbY96w1v5/VWsAAAAAAAAAADJc1gYrrLU3JmlRV7p/NUAxPCRQ4a2H1sq4SkReFpHt3NEW/07SugFpx8tfDgAAEG+a+qlbt24V9wEAALjWAJKHNFAJZIypLyL7uQ8/s9YWB0z6loisce8fk8h1AtKZ1qgIvQEAAMT7WqOgoMC5ca0BAADijWsNIDK6KCeW1qWo5d7/Omgia+0WY8z3InKgvscYk2+tJUluiC2l5fLZtMXy9YwlMnnBGvl96TrZUlYuBbk50qFZfemxY0PZu3NzOaBbCynIIwYHAAAAAAAAAOmEYEVi7Rxyf3ol0053gxX6mXQSkWnRLsQY07qSSXbw7mzZskXKy8slJ+fPBn1rbUXxQB3q7vUg02m0iLG+Hir0cWhvs0Q9X1JWLk+NniNPfvu7LFu3ZZsN21xaLr8uWuPcXvuxWJo1qCVnD2on5wxuL/m5OVvNP9nrHs/nwz+HdN+mkSNHyllnneU8/v3336Vdu3ZRb5P31xtdkSrbFP5c0PM1vY7x3Kb27dvLvHnz5IwzznA+00zYplRZx3TepvDvtx4n6b5NkZ5/5pln5Oyzz3buz5kzxzmfpfs2pdLn5LcMpdco3vVMaHpAvabR6XNzc51b+PM6rXcN5F0XqdDnK7s2Utrr3uM9r9OFpg0qKytzbuHPB60725Qan5NOt3HjRuc5fb8uk8+J7xPnCM57nMv5za3p3yeuIzLnek9vuk667nXq1HGmSfdt4ro8uz+neKMLemIVhtwPSgHlKQp4XzSKKrlpIXHHzJkznX/AQg++adOmOTfvy6J0Gn1u06ZNWy1ID1Tv5BrK+/LoFyWa5/Wx90UJen7G4rVy9CNj5M6PpvsGKvwsXbtZ7vr4N+d9vy5YFdW6J3ObQnnL9BphvvrqK+cko1/2G264YZvGGb91vOmmm5zp9abvT7Vtqux577VoPyc9RvUWup6ptk2xHGPV/Zy8II93DOgtNE1WNM+HHjexbpOfdDn2kvk5peM26XFxzjnnOHnbGzZsKLVq1ZIdd9xRevXqJcccc4zcf//9MnHiROf76LfuofPL9M8paNvTeZtS6XPyXvMuij3FxcXOdcrixYu3en7u3LnO88uXL9/q+RkzZjjPr1njZd38k3cNFMu1kd5C6Tz1OV1GKF0HfV7XKZSusz6v28A2pd7npMehXi9PnjyZz4nvE+cIznucy/nNTZnfJ64jMuv3Sa8z9HrDuybOhG3iujx7P6d4Y2RFYjUIub+ukmnXh9zXWhdZbcK8lXLOsxNk7eatGzOiNXXhWjnhifEy8qw9pE+77eO+fgDgZ5999pGvv/5a9tprL/niiy/Sbidt2LBBzjzzTHnrLS2ltLVFixY5t19++UXefvtt57n3339fDjxQBwUCAAAAAABUjwnqHZttjDGat2GO+/BZa+2ZcZjnUyLyZ24IkY7W2t8jTKvT6fRqqLX2hTingXJGV8yePdvpjR3t8CON9GovRx3eoz1sk5FiQkdUHPfod1UOVIRqUCtP3ho+UDq1aJBSaTP8nteezPvuu6/zWEdW6KiJytJs3HjjjfKvf/3Luf/ll186DaWptE2JSAOVys8nO8WLRrq1t7Hf9Ndff728++67zv2PP/7Y6RXvN58OHTpIvXr1qrRNpIHadn95wYq9997b+U6m27F32GGHyYcffujc32mnneS8886TPfbYQxo3bizr1693fhPGjh0r7733nixZssSZ9uCDD07pbSINVHoce0HPez2O9BpFr0M8DDcnLUAmDqFnm/icOPb4PnGO4FzO7xO/uVxHcG1UkEbXsDpio7CwIkFQobW2ssxClWJkRWKF5lD6/yPNn1eIW8U0lqayAyH0n3494EMPMn0t9Evg0Wn0+fC80eGP4/18abmVy1//OS6BCqXzuey1SfL28EEVNSyqu46Jft57LfT1VFtHttV/HyR7P3bu3FmCaOOyp0uXLhV59CNJhW1KxvPJOK79Xk/1bfroo48qAhUHHXSQE+zS9E+hBg8e7AQaH3vsMXnnnXekTZs2CVufVDpm4vV8Kq1LvJ5P1u9EuNAL7FChF+rRPO93DVTZtVG0z4df8Fe27mwTnxPHHt8nzhGRz9mcy/l94jeX6wjOEVzDcl2eev9rxBs1KxJrbQypnf7s2hxdyqiMpcW0pyzYOh9aden8dL4AgGAafPD8+9//3iZQEUovio499ljp3r07uxQAAAAAAMQFwYrECh3xUFmqpsKAYttZY0tpecKCCjrfkjL/IqiZbsqUKXLrrbc6PaVbt27tNEDWr19fOnXqJGeccYZ8//33Ed/vpaPyerauXr1abrnlFtltt92c3vteWqdQK1eulKuvvlq6du0qderUkebNm8v+++8vr7/+esRlLV26tGJZI0aM2OZ1HYKmRX+9aS655BLf+WjxX31dI8fhxYB03Z555hk57bTTnJQiui80MrzDDjs4++jxxx/fppBrePEhb/nedmt+/0MPPVRatWrlLNNLxxVKh8Zdc801svvuu8t2220ntWvXdnqln3jiiU66oJqi+0OPjwEDBkjTpk2d40O348gjj/StW1AVVd32oH2tNRL0mNL0VT179pQHH3xwq8JUepy89NJLzueg09WtW9dZto4GiCb1odZt0GNI07K1aNHCOT50PrpcPXb8CgBrnQddT00BpfSvt+7eLXx0i/e8fsfU//73Pzn++OOdIZTai0Gn1+3SY1OnO+SQQ6L6vnvzvf322yUW8+bNq7ivKaCqSj8rbx3Ci32F0toXQ4cOdVKUeceEfi9/+umnrfap36ggv2Pjs88+kyOOOMLZX3oca5qyCy+8cJvCYvE+RwLILDo8ftWqVc4tvPg8AAAA1xpAYpEGKrFCS7h3rWRa73XNfzRLstBn0xbL0rWbEzJvne+nUxfLYbu2lGwSWgcjlDbGz5o1y7k999xzTmDhjjvuqHR+mq9eG2wjNUBqfnENTGghXs+mTZucYsN6O/vss2XPPff0fW+zZs2cAILOQxuxzz///G2m8RqDVVBDt2636tWrlzRs2HCr1zTIEtoo61m8eLF8+umnzk0btTUdjjZ6RqIN36effro8//zzEad76qmnnMDKxo1bZ3grKipybq+99poThNHlBg3NSwTdxlNPPdVpkAmln53WJNCb1jB45ZVXnMbbqojntg8fPlweffTRbRq8//rXvzqfuc5L8zBqg/cbb7yx1XQTJ050Gq61IVwDUkF++OEHOfroo2XBggXbBNK0MVxvuq66bzSQES/XXXedb3BBgxZ6jN1zzz3OsanrFVp/JNzTTz9dMfJBG9pjETqc89dff3W+P4ny7LPPOvUwQoNMejy8+OKLzuf4xBNPxDQ/PYfdddddWz2n5yn9rN58803nvLHzzjsn/BwJIP3p74h3naPXJMkY6g4AALIH1xpAZAQrEkuLWmsXbf0vZ28RudNvImOMvt7fe4+1Nrhbdwq6+s1f5LfFoRmvqmbe8g2SSDe8O0WeHB1Y4zxqXVo0kDuP3VXS5UdQe59rg/Nf/vIXZ6SDNt5rYdypU6fKAw884DTc33nnnU79A6/odZDjjjvOaSzVxuchQ4Y4veQ1gNG2bduKURfaO9kLVGjPeW0w1V7pWgz6vvvucxpTJ0+eHLgMLUyswYrQoIRHl61F4j06nTYia5AjNIDw7bffOvf9Rjhor/h+/frJ4Ycf7gQutMFZGybnzJkjL7zwglOMWhu2TzrppIqgRxDtfa+N5Rp80YZw3Yfa8B8azNHtPffcc537u+yyixOA0eVqb39dpjbma9BA/zZq1MhJv5MM2uiun6HuD+25ruuv+0WPD93Pr776qrM/PvjgA+cz1AbfWMVz27XRedy4cc4IFp2nHnPauK0NyPq8jrjQUQ/6eWig4pRTTnFuLVu2dI5RHb0wffp0pxH8mGOOqSgKHUqPS2241kLSeszqPtHPtkmTJs53RgMUOuJn/PjxzsgTPc68PI633XabXHHFFc536Mcff5Q+ffo46xMqqMHr7bffdta7R48ectlllzn7SoM7kyZNcl7X7dVghfbw1YZzHaXiRxv+9TNTGlSMFNTwo5/NqFGjnPsXX3yxs16h3614GT16tBO01O3RkVe6zfp56IgG3Xf6mQ4bNizqFFP6mWrRbz136DHmfQ91X+lNzxG6vO+++y7h50gA6S+0SGFltYkAAAC41gDiy0STEiMbGGM0z4SXg+hZa+2ZcZqvVis9xB0x0d6vGLYx5iQRedl9eKW19p54LDtk/q291FLauKdpLqKljcHamKM9nrV3mZ+jHxkjE+dv3TM7k+3WprFTsDveQnv4aiOp9iKvzCOPPFLR01xHGYQ3zi9btsz57EKLLYfSRnpttNeGa2381UBAeIEebeS9+eabKwqaaWP+AQcc4Du/yy+/3AlIKO0lHt6oqo2pujztIe7RRuvQNC/aq1qDHF7vbm089GhDrKaN0UZMbcz9/fffndRSGkTxaAOvNroqbVzWtDChtOFa07sE0QZmbdhUn3/+uey3335bva6BCE0v49Fe717am3D6fdP117RC2uD/5JNP+o4e8HrV6/7VbY5UODtamkJHe6/77WNtjO/YsaMzmkQbtbVRWgMIfo3A2mgctC90ntqQq9sWngosHtsevq8vvfRS+c9//rPV+3X+ejzotJrGavny5c40f/vb37aa7o8//nDmvXbtWidIo8WjQ+lvoY4k0KCBppbS7dX5hdPjXxu2taFdt0lHhYTS76AG2rThvLJgV+gxo/tWA0NBdSJ0ft98841z7Grgz49+jhqIURqw0ZoSsZg/f74z+kD3qdJAgqae2muvvZxAln6vItWx8Oix4DXqhx97Svfzzz//7ARv9Lw1cODArV7XQIGmJdPvt9JzU/horvBjQ0dpaCAp/Huoz+vnpHRUjXduiOc5srLtRfVEcx0CAAAAAEg+TbusqaxdhX7t3rGiZkU1GGPONMZY9/Zn0vFt3ev+1Va6h40xW7VyGGO0NczLXaEt/n+2qiCraQBCe1lXdgtPiRNOG1uDGuGUNhZqj22ljc5eT+5IDeBBgYrNmzdX9CTfdddd5aqrrtpmGu2pqL3ovR6LQY2ynvDGXm+0hTYIe4GZoGm08dsv3VSkQIXSRkevQTO04LAf3bcPPfRQYM/L//73v07Dr9aAiJTmSINB2gve6zmfaPo5aaBC6wRoCiu/QIXX0Nu3b9+K98Qi3tuuP3533333Ns/runvpjrThWRvVwwMVSlN6aXon5Y28CaWBAg1UKF0Pv0CF0hEAXnAs1n0SRI9VbVCPFAjwRqhosG3MmDG+03jro+seHqSLhtaM0BE1XsovDQjqiBUNEmnwQEe/aOBCg0ErVqyQqtD6DxqoUBdddNE2gQqlo1rCg1KR6OgZrVvi9z3U0S4ev8893udIAAAAAABQdVkbrDDGDHaDDc5NM9yEvLxT6Gvu61Virf2fiLziPhyi2VeMMUOMMX2MMdoVUyt3tnFfv9pau7J6WwYE04CC9p7WnqpaVFZvoaOrvEbEIFrfIMiECROcYs1KG4+1AdaPjuzR3vxBNC2TN5oiPBDhPY4UrPAea+/4SI2QSrdde9xrT3Vvf+hNG9ij2R/aINygQYPA173e+zqdBgaCaEO+NgYrv1Q18eatlwaGtGE4Em2crsp6xXvbdcRAUJBLg2Meb1SOHz0mlB6n4XU6vPXt0qXLVvOLtE+0voVfse1YDRo0qNLe+Bog8Y5nvyCJBp8++ugj577W7KhqjnUdRaDnBw0kbL/99tucP7TB/+9//7szMqcqgTWtW+OJVFNDR69o+q1o6L4JCvTo5+kFX7yRGok8RwIAAAAAgKrL5poV2k01qKVEc/yE5/nZOsdJbDSnjFb5PVRENM9PeDXPchG5xVo7ohrLQAa58cYbnfRLlQlN0RREU/5o3nUtkqw52CM1rmrP9EgiNeKG1qHYY489Is5He+trT/Yg2oiu9QVC61YsXLjQKXarvacHDx5cUZg3tG5FZfUqPLpsHZWiaXU0LVAi9ofW79D1VZqeRm/R0OBJomldAPXJJ59EnY87lvVKxLZHSo0VGpSKdjr93EMfe/vkt99+i3qfaIogHWFQ3boOlQVHvJRMWoNDU79pqjQduaK1Fjw6QkZT5SgvjVlV6SgWHTGkNVk0dZLWBNE6LlprQkd2KA32aLBBzyex1HHQxn+lwQWtzRFEUy1puqjQ4EaQ0FRxfrS2zrp16wK/6/E8RwJIf3oO0JSCSoOm4anfAAAAuNYAEiebgxVJY63dqB1FjTGnaCYd7eCr7WbaGVYzU4jIQ9baxHenThAtOB0P0xetkY0lGrdJjDr5udK1ZYOU2d5k0LzuWjRW86hHQ9O+VNboF8QbVaEq662voyci0UCDNnBr47UGLbQxUnPbK82pr40H2iO/Q4cOTm9pDWpo72pN4+M1MISmk/JoMENTG2kqqkTvD827XxVevYBE0SBP+KiCeK9XIrY9KFWVCh3FE+104Q3SNfl5RTqOQumxq8EKbXTXgudaL8XjjbbQQKGmiIsH/Y5pYNFLBeaNoNK0UBq48OrU6Hcv0ggjv/OEjtqorAEw2iBQpM889HP3C0LE+xwJIP3puUI7SCgNahOsAAAAXGsAyZO1wQq3gHa1imhba0fGMuLCWvuSiOgto9x5bOW9gqNx5Rs/y2s/VrsOS6AhPVvJXcfFZ13ThRaj1kY47SmuvZ9POukkp7FfGwG9tClaK8D7Rzw03YmfSP+wh763sp7plS0nvG6FBiu8URb6mjd/DWposEKn0QZTbxp93UvVE+rpp5+uCFRor21tdNUaB1ozQRs8ve3TRmDtqV6d/RHaMKrLCS/EHKSq6XuiFbpeJ5xwgvzzn/9M6DJSadujWWdNyaQ1NqLlpQyrjmgbwvSY7d27txMw0OCEF6zQkQ86wigeoyoqo8vXIuO6Ljp6RoMPWozcqweS7edIAOlPzwfeyLVoR9oBAABwrQHER9YGK5B69u7cPKHBir06Vy9VS7rREQle7+drrrlGbrvttkpHRFRHaH57zZ8fKR1PZb3YtWCuvl9rSWgg4oILLqioRaG9oL1izRqs0ACE95r3V9Pq+PVWf+KJJ5y/mm9/7NixTmqdRO2T0Hz72vs+UsqbZNL6ERqY0XXSERaJWK9U3fbK1lmPW00plsrrq4W2NVihgTkN1OnoIm9UhR7PJ598csLXQRvxdDm33HKL89hL+RUN73up6bM0QBQpUKOfRSadIwGkB62P1KlTp5peDQAAkKG41gAiy9oC20g9B3RrIc0a+BdJrS6d74HdI6ceyjSae92jvYWDeLn6qys09YwWHo6kstdDR1doo6ymY9Bc+drDMXTUxb77/ln+RXuVawBEa1BEqlfh7ZMjjzwyMFChPac1T391ac9sHbGhtOd5KvXI3m233Zy/Y8aMSUjaqVTe9sr2iQbI5s2bV+X5JLoXrtat0GCT7tNnn33WSUuktRa8IuSNGjWSZAgdURKaXqsy3bt3ryhkHVrnJpwGMiZNmiSZdI4EAAAAAACREaxAyijIy5FzBrdPyLx1vvm52XW4e8V2VaQG6VhS3lSWHsbrNR0phdKCBQvk008/rXR+XsBB61Z469itW7et8ti3bt3a6Vmuy9KCwJHqVYTuk0j747333qvIVV1dQ4YMcf5qD/g33nhDUoW3XlpY+OGHH07oMlJt2ytbX3X33XdXa+SK1xifCA0bNnTSdykNVui+1YLmKtp0W0FiCSqFNuC3bx/9eXu//faruP/cc88FTvfBBx9UfJ8z5RwJAAAAAAAiy67WW6Q8DSrssmPDuM6zx46N5NwEBUFSWWgKA23U9PPoo4/KO++8E5flaX53zfmutEf0Pffc49s4qEWCt2zZUun8QkdHPPDAAxVBCO1xrTevYdWbzpsmqF5F6D4ZNWqUb2qX2bNny/DhwyVe/vGPf1TkvddUVpX10P7www+dIuGJpuvStGlT577WrPjoo48iTq8jMLxRK+m+7UGOPfZYp1aB972orAj7lClTnOPIL4WZF6RJ1IgSTQWldATIlVdeWREwCBpRFK0LL7xQbr/9didFUySfffZZxTlFU0Ltv//+US9jwIABTpo2pYEyTcfml/7psssuk0w7RwJID3qtoh0r9BYa1AQAAOBaA0g8ghVIKTr64b4TekmDWvEpp9Kgdp7cd0JPycuyURVeWhsv9742uGn6GO2trCmO3n33XTn++OOdhnktKBwvN9xwgzPaQV111VXOMrUYry5TU9UMHDjQaRjfY489okozs9NOOzn3vZ7j2hirxW715vEaaL1pdJtDayaE8goSawOErovm+h8/frzTEH/TTTc5o0O0oXb33XeXeNAGZK9Xts5X97U2NGvjp+4TXfZbb70lV199tbOthx12mMyfP18STXvnv/zyy07tDx0BcPjhhzu99V999VUnqKA3bYjXfdKzZ08ZPHhwzIGEVN32IFo7Qbe/fv36TpBB1/Xggw92ev9rAWtdZz2W77jjDmdbNO2ZV9A9lB5XStOS/f3vf3fqS2hNB71VJ71UKF2+F1jRkUdKA4XVTUG1bNkyue6665yAixbM/u9//+uk8Zo4caKTuk2PGa1VofvFa8C79dZbneMpFhqk0NRRGrTUQMf111/v1I7QZei5Sr+HRUVFThHvRKbWqolzJIDUp9cYGjTVW+j1BgAAANcaQOJRYBspp3OLBjLy7D3kzKd/kLWbS6sVqBh51h7SqUUDyUbawKfpmLQgtY4i0IZGvYXSBtfXX399q/zz1aH58rVBVxsgtRHVb5naqKojH7xRGJHoSAqveK9XryK84dKrW+GJ1Lv8b3/7m9MrXNNQaXHds88+e6vXtY6FNk57DZbxcOaZZzrzHTZsmKxZs8bpsR/Ua18bcLWnejLoZ/TJJ5/Iqaee6nxWehzoLUisDdKpvO1B9Pugo0iOO+44p0aK7h+9xbJPtPaBBjR0ZMX999/v3Dxt27aVuXPnxmVdNeXTFVdcUbHvdF9Xl1dnRIMIGlSKNKJA013dfPPNcumll8a8HA1+Pf30084oK625oYWtQ4tbaxBNgwcaRNRRWl5qrUw4RwJIfXpObdy4ccV9AAAArjWA5OEKHCmpd9vt5a3hA6ucEkrf99aFA535ZDPtmayNfZqGRxtK8/PzZfvtt5e+ffvKvffe6/Ru99LWxIsW0NXCtZqeRtOsaCogTTmkQYWXXnrJaaSMVmjgQetVNG/e3GnI1JsXtNCRHB07dqyYLqhehdLt10CEpozq06ePU6hYG9O1Z7/uIw1QaG/qeDvxxBOdRuo777zT2SbdDl0XXb7W3DjiiCPkvvvuc6YJD74kkjbSauorrfehveX1WCgoKHAahwsLC+XAAw90GpE1sOONSsmUbQ+iKYq0YLumBTrqqKOc/aD7Q/eL7h/dBh0JoCMmdCRROB2ZoamNNDCmox90OxNh6NChFfcPOOAAZz2rS0dS6OiPESNGyGmnneacP7QOjX7f9HuiDfYa5NJjQguReymoquKMM85wRvBosEznq/tXgyU6wkdHWejIFg1wqUQWDa+JcySA1KbnvHbt2jk3vQ8AAMC1BpA8JlE5tZE6jDGal6dI72tqDS9NTzS00U7Tfeg/a9pYnGwlZeXy1Og5zm3p2soL1jZrUMupe5GNBbUBZI8vvviiolaEpq/yim5nEg0iajBNAyc6AgLZqaavQwAAAAAA/oqLi0M7TxZaa4ulmuguhJSmAYcL9u7oBB8+nbpYvpmxVCYvWC2/L1snm0vLpVZejnRoWt8por1X52ZyYPcWBCkAZDxvhJLWZznyyCMl02j9Cg1UqP79+9f06gAAAAAAgCQgWIG0CVoctmtL54bspSPBysrKKgoiJ6rwLpDKNGWWV19Ea79oqrV0o7VodOSEn+XLlzv1LJRum6YSA4Bk0ZE82kNM6WhkUkEBAACuNYDkIVgBIK2Qug7ZaMGCBbJhwwaZM2eOXH311VJSUuLU0qhKgetUoHU22rdvL0cffbRTJ0TrUmiRay1w/sgjj8iiRYuc6bQ+iNa8AYBkKS8vl1WrVjn3taYOAAAA1xpA8hCsAJBWcnKoRYLso4Wov/76662e+9e//uUUpU7XoOOXX37p3IIMHz5crr322qSuFwDodUazZs2cHcE1BwAAiDeuNYDICFYASBua9knTPwHZqm7dutK5c2dnRMUZZ5wh6erZZ5+VUaNGOQEYHUWxbNkyJ9XKDjvsIIMHD5Zhw4bJwIEDa3o1AWQhPRelayAYAACkPq41gMgIVgAAkOK++uorySR77723cwMAAAAAAPCQTwUAAAAAAAAAANQoRlYASKs892VlZc59TQelaaEAAADipaSkRObOnevcb9euneTn57NzAQAA1xpAkhCsAJB2AQsAAIBEXWesX7+eaw4AAMC1BlADCFYASCs5OWSvAwAAiaEjN1u1alVxHwAAgGsNIHkIVgBIG5r2iYYDAACQKHqd0bx5c3YwAADgWgOoAXRRBgAAAAAAAAAANYpgBQAAAAAAAAAAqFGkgQKQVkUvS0tLnft5eXlOWigAAIB4KSkpkRkzZjj3O3fuLPn5+excAADAtQaQJAQrkFYN1fPmzZOJEyfK8uXLZcuWLVJQUCBNmjSR3XbbTdq2bUvjNQAAAKp1vakBC+8+AABAPHGtAURGsAIpbdOmTfLGG2/Iiy++KOPHj5cVK1YETrv99ttL37595dRTT5XjjjtOateundR1RXJQYBsAACSKjtxs165dxX0AAACuNYDk4QocKUlHTtx7773y5JNPyrJly6J6jwYyPv74Y+d22WWXybnnnitXXHGFM/ICmUHTPpH6CQAAxBsjeAEAQDLk5ORI48aN2dlAAIIVSDnvvPOOXHDBBbJ48eIqz0MDHHfeeac888wzMmLECDnyyCPjuo4AAABIb4zgBQAAAFJLTk2vAODZsGGDnHbaaXL00UdHDFQ0ysmRHrVrS+86dZy/+jiIzueoo45y5qvzBwAAQHbTEbzXXHONFBYWytChQ51RuZFSjYaO4NXp9X36fp0PAAAAgPghWIGUsHr1ajnwwAOd2hR++tWtK3e1bCmftu8gY3fqJK+2bSfPt2nr/NXH+ry+rtP50fnq/HU52WDkyJEVKZPmzp0rmVaISm+JLnrp7b+bbropoctBZJo3XD+HM888s9q7So+bLl26OPN79dVX2fVAAmh9Kf2OaR0pGnKRqiN4u3fv7ozAjTbVaNAIXp3Pu+++G/d1BAAAmWvLli0yadIk56b3AWyNYAVqnI54OOyww2TMmDHbvLZPvXoyql17eaawjRzRsJG0LijYpmaBPtbn9XWdTqffu169beal8z/88MPTaoTF6NGjKxrN9fbNN99Itud2LCgocG56P3TfRHvLpOANYvPggw/KjBkzZOedd5bjjz8+pXffqlWr5LPPPpPbbrvNGR3WqlWrimN4n332iWoeVfl+RFJaWuqk1dtrr72kWbNmUqdOHdlpp52ctH3Tpk2Letvmz5/v1BPSz6FevXpOo3bfvn2dOkWxnJ+1h/MxxxwjrVu3llq1ajl/9bE+Hy1d3j333OMsX9ejfv36znrp+ul6Rmvq1KnOftD9oftF94/uJ91fut8i0dcnTpzoTKu1lnbddVenqG+s56zffvtN/vOf/zjHS/v27Z31qFu3rnP/xBNPlA8++CCmIO93333n9CDXgGHt2rWlZcuWcvDBB8srr7wS8X26Lw866CBZuXIlwV6kFEbwAgAAAGlA/3Hlltn7QERa60ett6KiIhuLqVOn2p9//tn5myinnnqqs26htwY5OfbOHVraqZ272GldusZ80/fp+3U+4fM+7bTTbLo477zztlr3c845J6r3PfPMMxXvmTNnjk0F3vrceOON1Z5HdW7R7o94rC+qr23bts7ncMYZZ1RrPmvXrrVNmzZ15vXyyy/7TqOftfe517R27doFHsN77713VPOI9bvRuXPnwHktW7bM9uvXL/C9tWrVsk899VSl6/T+++/bRo0aBc6nS5cudvbs2RHnUV5ebocNGxZxW/R1nS6SWbNmOcsLmoeu5wcffFDpNj355JPO9gfNp3///s7+C3LTTTdV+5x1+umnR/UZH3TQQXblypWVzu/mm2+2OT6/n97tiCOOsBs3bgx8/5gxY5zpCgoK7Ny5c211JOM6BJlv1apVdtCgQYHHdL+6de1dLVvaT9t32ObaUx/r8/q6Thc0D52/LgcAACCSsrIyu27dOuem94F0VlRUFHpN3Doe7diMrECND8UPT/3UJDdXXmjTVoY0alRpT98g+j59v85H5xfqhRdeSIsh+5s3b5bXX3/dua+9fZU+3rhxo2SryZMnB9769OkT1XQ77rhjVMvyTpKkgcoMjz76qJO2Q/OMn3DCCZLqQnvAt2jRwhkVFqtI3wPvpiMIPGeccYbvfMrKypwRC+PGjXMe6/2PPvrIefzAAw9I8+bNnfPVsGHD5JNPPglcn59//tnZ95qOT89pOmpk7Nix8sUXX8h5551XMTpAR9qtW7cucD7XX3+9PP7448793XbbTV5++WUn9ZD+1cdKX//nP/8ZOA+dv+5TXZ7S5et66Proeun66XrqCJxffvklcD66vbrduv36Oen+0P2i+0f3k/r++++d++Xl5ZV+1jqCoX///tKxY0eJxYIFC5y/OjpE1+ell15ytkX3i47Y0PRn3voeccQRgeuinnzySbnxxhudaXQ9nnrqKWc++nu97777OtOMGjXKGQUSZODAgc526LD2u+++O6ZtAeKNEbwAACCVaJYIHWGuN70PIExN9/rnlr0jK7SnaYsWLbYZUfFuu/ZVGk0RdNP5hY+w0OVG6umaCl599dWK9dUey979oF7h2TCyIhLtbZ4qveKRWiMrSktLbZs2bZz5XHnllYHTpdLIinvuuce+8cYbdt68eRXPxTqyIhp9+/Z15mmM2WpZQeeT4cOHb/P6zJkzbcOGDZ3XO3XqZEtKSnzns88++zjT5OXl2bFjx27z+t13312xHO3Z70eXpe/Xafr06WM3bNiw1evr1693nveWo6MnKvusdbnhdP285ey7776+89Dt3GmnnZxpdPv9lqX7y1vOs88+6zufjz/+2D722GN2woQJFftOj/dYzuE6/YgRI+ymTZt8X9f9Mnjw4Ip5Pvfcc77T6aiLxo0bO9Pod2bp0qXbfJd0VIU3n6+//jpwnR544AFnmnr16kU1miMIIytQXYzgBQAAABKDkRXIKJqffPHixVs9d13zFtKpVq24Lkfnd23zFls9p8vV5aeyZ5991vnbrVs3Ofvss52/6rnnnpNs5ROIAyqltR+8+gOnnXZaWuwxHfFw7LHHSps2bRK2DB1VoD3mldbBCFqW1nRQ2223XcX9UFqn4ZprrnHuz5w503fk2g8//CBfffWVc/+cc86RAQMGbDPN5Zdf7tSLUPfff79TED2c1mTwakBoDRKtyxBKazTo80qn0/mE0/n+97//de7r8nS54XT9dD3Vl19+KRMmTNhmmrfffltmzZrl3Nft9xsNoftL95t334/Wdzj//PNl9913d2pVVMXIkSOdERVau8OP7hcdXeR54403fKd74oknnHop6q677pKmTZtu9Xpubq488sgjzt9I26S0ToZuz/r16ylojxrDCF4AAJBqtC1DRyDrjXYNYFuMN0KN2LRpk5NqIryY9hENGyZkeUMaNtym6LYuX1N3pKIlS5bIp59+ulXj6qmnnur81efDgzxVpT+M2miljaKaHkdTkGjDmhZIveWWWyoarfyceeaZTrotLb6qFi1aJFdddZV0795dGjRo4LymjZP6emg6r5tvvnmbor46r2hpA2RlBWurs74eb90ipYHSRrh//etf0qNHD2cIZ5MmTWTw4MHy9NNPO/tW5+fNJ3Te4TTNjBay1RRV+hloo7F+7j/99JPvugfRgra33nqr09CqjYzacKmFmY888kh56623Ir43fHv/97//OSlw9LjIz8/3XXZ1luf58MMP5ZBDDnEKEmuDaufOneXvf/+7LFy4UOLltddec/526tTJ+az8Gnp12/XY9GRDcfbQwGdQCigNPnjFs7XxWT8jP6HfYb/PXhsMPWeddZbvPHQI9Omnn15xbIV/Z/Q75QVCunbt6qQZ8qPPe2mPdLnh/wDofL1zm2530NDrWLYp6Bym+8tLOzZlyhRnf9aUXXbZpSL4MHv2bN9pvG1q2LBhRRqrcFrIfP/9968IBAal7NL0YHo+VK+++mpctgGIxfLly53C96Ea5OTI04Vt4tYxRuej89P5htIApC4fAADAr/OU/o+lN78OWkC2I1iBGqEN5Jo/PtTlzZpXuUZFZXS+VzRrvtVzuvyg3qU1Tet4aIO8rrcXpNC/+ljzx4fX+aiKpUuXyp577uk0SGtDXHFxsRO80UY87QV9ww03OA2CXp76SDQn+6677urkJtcf3Ej55lNBPNa3qKhIevXq5eR210ZIzYm9YsUKGTNmjNMje8iQIVFdeOgIGq23obVUtIFePwOdt37G2ujqjbCJptG/Q4cOTp5+3T5tJNGeGhqUee+995yAlOboj2Zbr7vuOtlvv/2c74ceF37BoXgs79JLL3XqE3z88cfO91HrsWhjrvae19oDfr3Zq0J7xqugxu1spA343nlEA236efn59ttvK+7vvffegfPbYYcdnECTGj16dOB8dFm9e/cOnE/oMsLnM2fOnIraDJHWJfR1PX7Dg0zRbpN+L3V9K9smDYzo9ldlm5JNv6PKL0Cjr3kjbTQAWVBQUOk26flKfy+CeN+57777rmLZQLIwghcAAABIP1XLNwBUU3hje7+6daVjnNM/hdP563LGbdiw1Xp4wYBU4jVQazDBS83Stm1bp5eqNpBpj2jtfV5VOiJAG5t+/fVXp0FKezofeuihTi96fe2bb76R++67zxnBob3eJ06c6CzfjzZGa0OnjpbRRu4DDjjA6U2sxXtbtmzpjATRRiqvR/uFF14ow4cP32oeXpqUaFQ1TUq06xsN3R7dX14KGN1HmoJF9582jmpx3/fff98JCEWiDZea4ksL2Wo6m8suu0wOPvhgZ4TCjz/+KHfccYczXx39EYn2btbgiAaydASE7uN+/fo5vaO1cVd7NWsw5IMPPnB6kr/55puB89LUNjrSQz8vXR/tja1BhEmTJsV1ef/+978rUvHoaAxNo6MjevRz0fdp+p7jjjvOCQJVR2hj9R577OE7zVFHHeU0TGt6Gy9Vjh4P4aItzp4OdHTBvHnznPvag14LSvvRc4RHg5eR6OszZsxwgm16HvEa+kPnoymjIn2HQ5cRuuyqrEvo+9q3bx/zfHQ9NbWTfh/C10XPI3psVWVdaoqex9esWbPNOnk0UOgFJmPdJq/wdjj9Tiv9XmtQY9CgQdXaBiCVR/B+vHaNfL1+fcVzunwdrRiUng0AAGQnzVzgpfnW+wC2RrACNdKj1+u96TmmUaOkLFuXExqs0PXQ9UnUiI6q0EbSn3/+2Te/vj7WYIW+rtP5pbSJxtVXX+00MDVq1Eg+//xzp6E2lAZFNIijvWu1p/z1118vzz//vO+8tEe9NnRqw3vPnj0rng9qGNbUINoAXhXx+JxiXV8/Dz/8sDOaQl188cUVOfKV9hrXNEiXXHKJPPTQQxHno+/VQIUGjPRzGDhw4FaNfNpYr5+BNjIG0UZhTSGlgYMDDzzQCTaEpurREQo6wmGvvfZyAh86iuaLL75wRk740YZZfU0DBqENLPr+eC1Pg2A6ckdpEExHZoT2TNf3ah5/vVUl5VeosWPHbrVufho3buzc9Nj0VHaMamN/UANtLHS0QGXpvRKdAspLveRHAw+h6X8i0WCd0nOqNuR7qZi00dAbSVfZPDRwqUEOPc5Cl13VdQl/X+hjXY5+7pXNR78TGnjUUQTed0K3z0svVZ11Sabbb7+94r6XmioR+zdU6Cga/S4SrECmj+D9ev2cbUbwpmKnGAAAUHP0uiHSKGYg25EGCkmnvXk1XU6o3WpvXSQ1UcKXow3XXu/iVBtVoY1imqIplDYweY1l0aYHCqf/PHu9DbXeQnigwqONyJriR2lP+Ug93K+88sqtGv5TXXXXd8SIERUjAoIKzOrz+noQbaD3glIXXXTRVoEKjzaea0qkSJ555hmn8V9rXWhAKaimwHnnnVfRy1nfE0TTw+jxEdQTNB7L02PXO550hIVfCp2//OUvzjyqy+v9rkKDEdlM97032kUbpXVfB1m7dm3F/aDRF57QkRSh6b9imUfofMJTiMVjXULnE8u6hM8nXuuSLPp5e2kPNYDgl/YrEdvUokUL3+8ikMkjeCOtBwAAAIDIGFmBpAvvJd4oJ0d2TNLQN11Ow5wcWVNevtX61ETPZj/aW/2ll15y7msu//Bev/pY0w9pb3ad7q677pLc3NyYlvHJJ584PZ2DeteG8nrTa+0FrR+gaan8JKvXoPZk9noze0WPq6I666tpjn777beK/aeN9n70eQ02eamOwulog8qKG3vHgRbuDirU6RUc1rRelTXG6+epo4k0f3wQ7fkc6fsQj+XpKBKvF72OQgmiKbK8tExVFZqKK5Z0Y5XRkTh+qaJiVROppbSIstcwraO1ggpMK+9coSrr/RMa4NLUYVWZR+h8QucRr3UJnU8s6xI+n3itSzJMnz69oqi5ppvTUTV+585EbJNOp8vUaSpLiwfECyN4AQBAKtPsCt41tF4rR/p/DMhGBCuQdOGNrm0KCpKWhkmX07agQCaHNMqEj/KoSVrfQdMu+aWA8ujzGqzQ6bTRV1PlxEJrIXiirdGg/vjjD9/ntQeuFlpOZkCnOrUrqru+XvonFalQsAoatRI6H23Mi5RySINRWsg7NLjh93lqECra71HQZ6m08Hgk8Vie18ivaZkifY663dpoWp3CvKHf73gGK7RneVXTmdW0aFNAqdBgnH4OQcE5pWmSPHrRHTSPynjzCZ1HrPMJWpfQ+cSyLuHzide6JNrChQudmjoanNLv61NPPVWRHzdcorZJv3f6z1hQwBXIhhG8qdIpBgAA1DxNdaz14pRem5MSCtga4TskXXgjSEGS60Xkhy0vtNElVRoRdQSF9qj3EzriIrTRMVpLliyp0roFpYGqLOd7qqnu+q5cubLifmUjC5o1a1bpfLbffvtKR8cEzUdHvKxatUpiFSmlV6QG/Xgtz9v2yvafBjJ0/1RHaANsTfRqTzVekNMbHbLzzjtHnL5BgwZRpzDSOhN+aYRimUfofMJTEcVjXULnE8u6hM8nXuuSSNpYq3VlvALzOsrr5JNPDpw+UdsU2msMyJYRvJHWBwAAAEAwRlYg6cKjxlvctD7JUhK2vKDc/Mm2Zs2aihQ72iAczXp56VxCG5miHZmgn4OmdopWUMHVWNNQVYf2DM6vZoNDMtc30bzP0ktJ5dUYSdT+iffyohmZ4aX9qqrQQI823sbyXamssVaLY1eXFqGu7jEdC82f7n2OlY2qCP/ea82Bpk2bBk7rFVrWzzX0fRow0vdpvZzK6hZoIMtrCA8t4uy3LpGEFn32m8+4ceOc5ei5NlIA05uPHkeh5+R4rUui6O/CwQcfLFOnTnUe33LLLXLJJZdEfE8itkmHuK9evbrS4C0QT4zgBQAAqUzbYjSLAAB/BCuQdJp/P9T8LVucBslkpILS5cwLG9lR3Z7b8fLaa6/F3PNbe6xr0VQvH3ks+19HuOj9WFJBYeuRB5WNUomUo92bjzaga+NxpCBB0Hy0EVgLXOtxoI2uiU5LFK/l6bZraigt1F3Z8NjQkSxVEdpAqvPSwvHx8MMPP8i+++5b7flowCOZ6UG0KLrSAEmkXvae0JRBWvsg0kW1vu41XocWYFY6guPbb7+VWbNmOZ9rUPovbx7eeyKtSySVzccrMK7T9e/f33ceup6zZ8/2nYeOJtDt1Eb76qxLIujvyBFHHOEco+of//iHXH/99ZW+r3Pnzs55SM9H8domDVRowEIRrECyMIIXAAAASF+kgULSaZ76UKvLy2VBSUlSlq3LCS2u7bc+NcVL6aTBg5dffrnSW5s2bbZ6X7RCt1drZCA23bt3963/4SfS6958NA1ZpELN2nA4adKkSj/PMWPGREzvFC/xWF6PHj2cv7pd2iAc5Oeff65WvYrQZakZM2ZEnDZZtXNqiu7vX375ZavC7ZUZPHhwxf2vv/46cDoNPnn7V4u0B81HRzNEGtEVuozw+bRv315atWpV6bqob775pqKAeXgwKNpt0u+vN8oj0jb99ttvEevARNqmeNNUbccee2zFMi+44AK5++67o+7h1bdvX+f+d999F/G7581fR5tEqs0T+p0L/S4CicQIXgAAACB9EaxA0mnP5vDRDBM3JSeXfPhytLEuXj2tq9u7evTo0c59bWg66aSTKr0df/zxFY1G8+fPj3pZWmzVSzvzn//8J2JjcTx5tQOqUyNER8ZoL129VTc9UFVpqhTtgaxef/112RRSrD2UPq+vB9lvv/0q7kcKOH3wwQcRC9MOGTLE+auNqg8//LAkWjyWt//++1eMKhk1alTgdE8//bRUlzakernyvZ7m0dS3qOw43WeffZxjsLq3ZI6qCD3OzjjjjKjeo8e613NeR38FBahGjhxZcf/oo4/e5vWjjjqq4v4zzzzjOw/9XofW7QkfuaLBpCOPPLKiZ//333/vOx993uv5r9OHB6H0s2vUqJFz/9lnnw08l8SyTaHThtL9pfvNG9HhnTsSQQObp5xyinz00UfO46FDh8ojjzwS0zy8bdK0hG+99ZbvNJoiyqt7ouexSKnVQr9ze+65Z0zrAsR7BG8ypPIIXgAAkBr0/x7NVKA3bxQygP9HsAJJpw1HXu9Nz1tuTutEC1+Orkcq9KbW1CzeP9LHHXdcVO/xptP3ealdoqE9jb20Udpz/fzzz48YsNBUR08++aRUl5duykurUp0GudDaCTVB95lauHChk2LFjz6vrwcZMGCA7Lrrrs59bfQfO3asb/qnyy67LOK6aM9pr46A1pDwGiqD6IgIr9d5VcRjedpQ7gUQ/v73v/umg9Ig3OOPPy7VFdpbfPz48RGnDU2JVt3jNNXod0ZHZHkNeTqyIlpXXHFFRXDpyiuv3OZ13Vd33HGHc79jx46+Dfv6GXiN1U899ZTTcz/cv//9b/n111+d+3/72998a3lceumlFSmktAZDeOo8fezVZtDpdHq/Y+Kvf/2rc1+Xd++9924zja6frqfae++9nWLk4XQ7dXuVbr/fMaPnAS+VWdC5Ih70d+C8885z0gJ6QW8NCsX6+3buuedWBHKuvvrqbQKlehwNHz684hzsHRtBvO+cBuWC6h4B8cYIXgAAkMq0/WXu3LnOLVmdR4F0Qs0K1IhTTz1VPv7444rH4zZskNmbN0vHBBa71vnrcsLXIxV4wYbmzZtH3fu0X79+TuOP9nLV91933XVRL08bBbVxfMqUKU7vde2JPGzYMOndu7eTi10j/FqYVXvPfvjhh076Dm3Eqo6BAwc6I0jee+89GTFihJMOxevJ3rBhQ2fb08XFF1/sNATq/nvooYfk999/dwIY3uehjew6IkIbaL3GOr9GQw1SaEOoplvR0QbacK9FcTW1iqag0QZQTS+jdQI0hY/fPHTfaSO0jpjR0QCHH36401CpN68hddGiRU7qnbfffttJA/Tggw/KXnvtVaVtj8fyWrRo4RT81YZOvUDT4+6aa65x9peOSNFjTkf9aGBNe6ZHqv0RDW2Y1+CHfhaRCtLrMerRIJF+pzSA4e13bXANqrUQb/p5B6X/0mMivCe/Bi/1uxvkk08+qUhVpLUqYinqrcElPU9o4EmPWZ2PNoxr7RHdp/pZak/8nJwc57MO2kf//e9/ne+9BhQOPPBAufbaa53RE/r4lVdeqQhO6eiDyy+/3Hce+poeN3feeafzHdH5XXXVVc6xp8GCu+66SyZOnFgRHOjUqZPvfPS1V1991UlTpAEYraWhI9Y0iPbll1/K7bff7vzjoI/vv/9+33noPnzggQec+hC6/bouWhtCj2MNUDzxxBMVtTE0ZZSOdPCzbt26iiCDR9fHo6+FFjbX80F47RDdJ96IFa0lo/vWC/wE8as5oz3AdR9qUHLevHnO74x+D/Q3QIOvui90/3jHUaS6LRpA8aaNJTgGxGsErwZYQ0fWti4oyNoRvAAAIHXo/5fe/2Op0HkWSDnxSGPBLbX3gWau0Y9ab0VFRTYWU6dOtT///LPzN542btxomzZt6qyTd9u7Xj07tXMXO61L17jfdL46/9Dl6fI3bdpka9ro0aMr1un888+P6b1//etfK977/fffVzz/zDPPVDw/Z84c3/cuX77cHnzwwVvtk6Dbvvvuu837zzjjDOe1tm3bRrWuEydOtLVq1fKdv86ruvbee++K+fmJdX29ed14442+r8+bN8927NgxcJ8deOCB9qOPPvL9fEKNHDnS5ufn+84jLy/PPvHEE3bo0KHO465duwau7xdffGF32GGHqD7PZ599Nubtjffywo/f8Jt+P3/44Qfn86ruMVJcXGxzc3MjrovnhBNOCFynoO9SIujnEM2+jXbdTjzxxIppx48fH/P6LF261O6xxx6Byy8oKLCPP/54pfN57733bMOGDQPn07lzZztz5syI8ygrK7Nnn312xP1xzjnnONNFosvp1KlT4Dx0PUeNGlXpNul26/YHzadv377O/guin10sn7Xfd9T7nsRyi+SGG26wxpjA9x566KHO73gkX331VcX03333na2qRF2HILOFX9/0q1s3IdeX4TddTuhyDznkkJreFQAAAEDCaDtzyPVv63i0Y5MGCjVCe9SH99T/ev16GbVmTUKW996aNc78Q+nytQd7TQvNI6+902MROn2shba116Gm8Pniiy+ctFDaA1l7ZmuvaH1N055cdNFFTi/3zz77TKpLewJrahXtjavFwVNh31eHboOm0br55pudHsraA1vz7Pfv39/JE6/7NrSehZdaxa/XuvYQ11E+WjxYU9ToiIITTjjBqWOix6n22o40D/WXv/zF6VmuIz10dIaOCNB56XetsLDQ6cl+2223Obn8Tz/99GpvfzyWpz3tdQTKQQcd5Bxz+t6ddtrJSdGjveMjFe6Nhe5Pr9bBiy++GHHaF154wSlIrL3jdX/raIF0p8ePjmhSXbt29U1pVBnt2a+jsfTY1lEC2ltYP68OHTo4oyx++ukn529ldBSCjrbRkSs6SqJu3brO90Y/a29UhB4Dkehnoima9NjRz9X73uhffaznLE1dV9lnp8vR5elydfm6Hro+Xbp0cdZP11NHDlVGt1tHEulf3R+6X3T/6H569NFHnREpoSMj0oGe1/T8ozUw9Pus+1dHvx1wwAHy0ksvOfs+tMaLH53OS8mj50UgmcJHznojeBMplUfwAgAAAOnC1FSRWiSPMUZHVhTp/aKiopjyRk+bNs1JhaEN2FocNJ40F3b37t23ylffICdHXmjTVjrFsSF7xuZNMnT+fFkbUrhI09BomqPwIoxAPN16661OXQf9/mj6ocoa9yI1qmpg4LTTToupPgn+n6Y60zohubm5ToqdZBa2BrKNnu80oKspBTVAqEGPqkrkdQgyl3YW0EDbsmXLKp7bu149eWTH1glJt6D/Tw1fULxVxxgNUmpqyHTvnAEAAAAE0etdve52FWpyC6mm9O8yirSlgYLHHntsq+c0oHB20XyZGafebxqoOKeoaKtAhdKaCQQq0o82BngFtlM90KrrpznxvVElVQ1U/PDDDxWFe+mdXHW677TOhh47XjFoAImhI640ULHzzjs7tUCAZGMELwAASFX6P+mSJUucm94HsDWCFahRRx111DZD5JeXlclp8+fJu6tXV7lBWt+n79cRFTq/UNo73UsJg/RTXl7u3GqaFobW3r5BbrjhBqcAt5fqKUhoIV2/0Udeah3tmXniiSdWa52znab70ZEVWoh4/vz5Nb06QEZav3693Hfffc59TamWCanUkJ608HzTZs23eu62JYvj1iEmtGPM7Uv+f5Swyqu3nQw86sy4LgcAAGQGDVAsXLjQuRGsALaV5/MckFSPP/640/Creb09OhLimj8Wycdr18gVzZpLxxiG0GvO4HuXLtmmRoXSHOI6qgLpKxHpG6pi5MiRTqO3pjcZNGiQky+/pKREfv31V3n22Wflq6++cqbTtCWRcvlrDvj27dvL0UcfLbvuuqtTJ2HlypXO90HrAyxatMiZ7vrrr0+7vPeppkePHs7npgEiDVZomhoA8TVv3jyn3pHWoYmm5geQKHPX5Uj9/S6UZa/cvM0I3qcL28Ql5WjQCN7tDrpI/vbOLFm0OU/O27NDyly7AACAmqfXBfXq1au4D2Br1KzIAqlasyLU6tWr5bDDDtsqYBGqX926ckyjRrJb7TqyY37+Vid0HUWxoKREJm7aKG+uWi3jN25d3DA0UPH+++9HLFIMROumm25yitBGosWMtdB2pPoI+po27kUyfPhwefDBB+mhDCDrULMCVfHl9CVy4YsTZFNJuSwbda+sn/ZnB4LQGmnXNm8hQxo2rFIjgV57vrdmjTOiIjxQUa/7vtL08MsrHh/Zq5XcecyuUqcglw8TAAAAGaU4ATUrGFmBlKABhE8//VTOP/98eeGFF7Z5fdyGDc5NNczJkbYFBZJvjJRYK/O2bJE1laQF0tRPOqKibt26CdsGZJdzzjnHOW4/+eQTp6f+0qVLZePGjU5v4p49ezojJc4++2wpKCiIOB8dhTFq1Cj5+uuvnVEUWgxUg4M77LCDE2AbNmyYDBw4MGnbBQBAOntzQrFc+eYvUlb+ZyrR7Q++WEpXL5HNC6YlfARvrdbdZPuDLtrquXcnLZRZS9bJiKG9pfV2XIcCAAAAkTCyIgukw8iKUO+8845ccMEFsnjx1vl/q6JFixZOkIIaFQAApB9GViAWj38zW27/cPo2z5dvXi9LXr95q4BFvEfwtuzSS/IOuUZyav2Z1iHc9vUK5OFTdpcBHZvwoQIAACAjFDOyAtlSdHvPPfeUe++9V5588kmnp3msNLf/ueee6xRXbNKEfwozhTYYeMW1tWgr+R0BAEB5uZU7P54uj3/zu+/O0ADCKTeOkE1fPSYvv/RiQkbwPvbYY/LihD/kzo+mizuoYysr1m+R054aJzcc3k1OH9CWaxgAALKUdgj2OudqB1vtHAzg/+WE3AdShgYY7rjjDidCp2mhDjnkkEqDDvq6TqfT6/v0/QQqMo8GK7yABQAAyG4lZeVyxRs/BwYq1Ml9C+XxswfKSy++IG+//bbTMBBEAxOTN22SnzZudP5GClTofHRE8PPPP+8Uyhy2V0d55qy+0rC2f6ODpqa68b2pctWbv8imkrIYtxQAAGQCbc/QNNJ6o20D2BZpoLJAuqWBitSrXgsRT5w4UVasWCGbN2+WWrVqOTUCdtttN2nbll5qmU6PgbKyP/+5z83NpVciAGS4VLoOQerZsKVULnrxJ/nyt6WB01zyl53k7wd03uqaYfny5QkdwTt32XoZ9vyPMmPxusB59Cps7NSxaNGwdszLBwAA6UuvbbWDrdL2OUZWIJ0VJyANFMGKLFCdYMWvv/4qJSUlNBIAAIAaC1bk5+fLzjvvzCeACqs2bJGzRv4gE+ev8t0rGpu48fBucuag9oF7TTu+vPHGG/Liiy/K+PHjnSBGEA1K9O3bV0499VQ57rjjnA4zkazbXCqXvzZJPpkaXIOtWYNa8thpvaV32+34ZAEAAJB2CFYg6cGK3377zflHTnuj7bLLLvRkBwAASRtNN2XKFOevNgx36dKFPQ/HotUb5fSnxsvMJf4jF/Jzjdx3Qi85omerGh3Bq7U0Hv5ylvz7sxmB0+i63nLkLnJS3zZ8ugAAAEgrFNhG0hUUFDj/rOk/cJs2bZI6derwKQAAgIRbv369c/2hatcmVQ7+NGvJWidQsXD1Jt9dUq8gV0YM7SODOzWNaZdpIKJdu3bOLV5ycoxcsl8n2bllQ7n01UnOaItwJWVWrn5rskxZuFpuOLy7FORRUhAAAADZi6thRNSgQYOK+6tW+Q+zB5JFG600HYjevAYsAEDm0XO8Fh30NGrUqEbXB6nhp/kr5bjHvgsMVDSpVyAvD+sfc6AilF5jzJ0717np/XjYv1sLeeeiQdKhab3AaV74fr6c9uQ4Wbp2c1yWCQAAUlMirjWATEKwAlEHK7TRYMmSJRUFjoGaasAiUAEAmUnP7+vWrXP+eVu7dm1Fj/fQ6xFkpy9/WyKnPjFOVm0o8X19x8Z15PULBsiurRtXaznl5eVOBx296f142al5fXn7okGyb5dmgdOMn7tChjw0Wn4ppoMQAACZKlHXGkCmoMB2FqhOzQq1ePFi5xYqLy8vvisJAACynnaICA1Ia6BCawU0bNgw6/dNNnt7YrH84/VfpLTcf1Rl1x0ayLNn95UWDaufLkx7OHrXvS1atIj7NW9ZuZX/fDZDHvpyVuA0tfJy5I5jesgxu8d2zQ4AAFJfoq81gGSiwDZqJFihjQZ68K1cuZJPAAAAJAWBCqgnv/1dbv3g18Cd0bfd9vLEGX2kUZ38tNphH05eJJe/9rNsLAkesXzO4PZyzSFdJS+XwfAAAABIPRTYRo01FhQWFkrTpk1lxYoVTsHL8J6PAAAA1b3eyMnJcYppa40KTf2Um5vLTs1Sep1550fTZcQ3vwdOc0C3FvLgybtJ7fz0O04O7dFS2jetJ8Oe/1GKVmz0neap0XNk+h9r5KGTd5ft6hUkfR0BAACAZCMNVBao7sgKAAAAIFlKysrl6jcny5s/FQdOc2KfQrnt6F3SftTByvVb5OKXf5Ixs5YHTtN6uzryxOl9ZOeWpEMDAABAZo+sSO+rewBZpaSkRGbOnOnc9D4AAMgsG7eUyfnPT4gYqLh4353kzmN7JCRQkexrDR0x8exZfeW8PdsHTlO8cqMc88hY+eCXRQlfHwAAkFi0awCREawAkFYpITQNmd5IQwYAQGZZtWGLnPbUOPnf9CWB09x0RDe54qAuTtqwTLnW0KDLdYd1k/+c2NMpru1Ha1tc9NJPcvfH050i3QAAID3RrgFERsl5AGlDc5e3atWq4j4AAMgMi1ZvlDOeHi8zFq/zfT0/18i/T+glQ3r+eR2QidcaR+/WWnZq1kDOf/5HWbh6k+80j3w1W35dtEbuP2m3tCsqDgAAaNcAKkPNiixAzQoAAACkqllL1snpT40LbKCvW5ArI4b2lj07NZNssGzdZhn+wk8yfu6KwGm0OPcTp/eWnZo3SOq6AQAAAB5qVgAAAADIGBPnr5TjHxsbGKjYvl6BvHxe/6wJVKim9WvJC+f2k9MHtA2cZs6y9XLUw2Pls2mLk7puAAAAQCJRswIAAABA0n312xI55YlxsnKDfyHrHRvXkdcvGCA9CxtLtinIy5F/HbmL3HlMDycFlp91m0vlvOd+lP9+PlPKqWMBAACADECwAkDaKCkpkalTpzo3vQ8AANLTOxMXyLnP/ugUjvbTpUUDeWv4QOnYrH5WX2uc1LeNvDJsgDRvUCtwmv98PkMufHGCE7wAAACpLdWuNYBUQ7ACQNqw1jo/5nrT+wAAIP08+e3vcumrk6Q0YDTAHu22k9fOHyAtGtZO+rql4rVG77bbyahLBkuvCCNMPpm6WI5+eIzMXbY+qesGAADS/1oDSCUU2M4CFNhGpigvL5c1a9Y49xs2bCg5OcRbAQBIF/oP+V0f/yaPfT07cJr9d24hD52ym9TOz5WakMrXGptLy+Sf70yR134sDpymYe08efCU3WXvztlT4wMAgHSSytcaQCoU2CZYkQUIVgAAAKAmlZaVyzVvTZbXJwT//3JCn9Zy+9E9JC+Xf9ojBXye/36e/GvUtMCRKTlG5MqDu8r5e3XQ/wPi8vkBAAAAyQhW8J8AAAAAgITZuKVMLnhhQsRAxfB9Ospdx+5KoKISGnw4fUA7eeHcftKkXoHvNBrDuPOj6fLXVyY5+x4AAABIFwQrAAAAACTE6g0lMvSpcfL5r0sCp7nh8G7OSABGAUSvf4cm8t4lg6V7q4aB04z6eaEc++hYKVqxIcZPDQAAAKgZBCsApI0tW7bIpEmTnJveBwAAqeuP1Zvk+BFj5cd5K31fz8sx8t+TesnZg9tLqkina40dG9eRNy4YKEf2ahU4zbRFa2TIQ6Nl7OxlSV03AACQ/tcaQE0gWAEAAAAgrmYtWef06p+xeJ3v63ULcuWpM/eQI3vtyJ6vhjoFuXL/ib3kukN3dmpV+FnpjG4ZL8+MmePUvAAAAABSFQW2swAFtpEpysvLZePGjc79OnXqSE4O8VYAAFLNpKJVctYz451Gcj/b1c2XZ87qK70KG0uqSedrjW9nLpWLX5ooqzf673d17O6t5bajd5Ha+blJXTcAAJD+1xpAOApsA8hq+iNer14958YPOgAAqefrGUvllCe+DwxUOKmLLhyYkoGKdL/W2LNTM3nv4kHSpUWDwGne/KlYThzxnSxa/WcjCQAASK50vtYAkoFvBQAAAIBqe3fSAjln5A+yYUuZ7+vaiP7mhQOlY7P67O0Eaduknrw1fKAcsssOgdP8XLxajnhwjPw4dwWfAwAAAFIKwQoAaUPzLGsBKr2RcxkAgNTx9Og58rdXJklpuX9NhD5tt5PXzh8gOzSqLaksE6416tXKk0dO3V2uOLCzmIA6FsvWbZaTn/heXho3P9mrBwBAVsuEaw0gkQhWAEgbJSUlMm3aNOem9wEAQM3Sf7Lv+ni6/Ov9aYHT7L9zc3n+nH7SqG6+pLpMudYwxsjFf+kkT57eRxrUyvOdpqTMyrVvT3ZuW0rLk76OAABko0y51gAShWAFAAAAgJiVlpXLVW/+Io9+NTtwmuN7t5bHTustdQoo6FwT9tu5hbx90SDp0Kxe4DQ6ukLrjCxZuymp6wYAAACEMww5ynzGmNYiUqT3i4qKpHVrfQikHz1feT0P8vPznV6DAAAg+TaVlMnFL02Uz39dHDjNhft0lCsP6pJWv9eZeq2xZlOJXPbKJPli+pLAaXZoWFtGDO0tPVO0+DkAAJkgU681kJ2Ki4ulsLDQe1horS2u7jwZWfFnY34bY8y9xphfjTHrjTErjDHjjTFXGGPqxmkZ3YwxDxpjJhtj1hhjthhjlhpjvjTGXGaMaRCP5QCZTH/ECwoKnBs/6AAA1IzVG0pk6FPjIgYq/nl4N7nq4K5p93udqdcaDWvnyxOn95FL/rJT4DR/rNkkx4/4Tt6cUO3/MQEAQJZdawDxkvUjK4wxh4nIiyLSKGAf/SYih1prf6/yTjbmchG5U0T8E8b+aZ6IDLHW/lLV5URYPiMrAAAAUG2L12yS058aL78tXuv7el6OkXuP7ylH7bYjeztFfTR5kVz++s+yYUtZ4DRnDWon1x26s+Tl0rcNAAAA/hhZEWfGmJ4i8pobqFgnIteJyEBN7yoiT7iTdRGRD4wx9au4jBNE5F43ULFFRP4jIhog6Scip4jIaHfStiLysTEmKGgCZL3y8nJZv369c9P7AAAgeWYvXSfHPDI2MFBRJz9XnjyjT1oHKrLhWuOQHi3lreEDpc32wQPInxkzV05/erysWK//vgAAgHjJhmsNoDqyvavM/SKiV+mlInKgtfZ2a+131tr/WWuHiciV7nRdReTvVVzGP0PuH2Ot/bu19kNr7Xhr7cvW2j1F5C339ZYick41twnIWKWlpTJz5kznpvcBAEBy/Fy0So5/7DtZsGqj7+vb1c2Xl87rJ/t0aZ7WH0m2XGt03aGhvHfxINmzU9PAacbOXi5HPDhapi5cndR1AwAgk2XLtQZQVVkbrDDG7CEi+7gPn9Ighc9k/xaRX937lxpj8mNcRkMR2cV9+JO19oOASW8Oua8jOwAAAICU8M2MpXLyE98H9rJv1ai2vH7BQNmtzXZJXzdUXeO6BfLMmXvIsL06BE6jwaljHx0ro35eyK4GAABAwkWqoZDpjgq5/4zfBNbacmPMcyJyh3YYc4Mbn8WwjIKQ+5FqXswOuV8rhvkDWUULUPXq1aumVwMAgKzx7qQFcsXrP0tJmfV9vXOL+vLs2X2lZaM6kgmy7VpDa1Jce+jO0r1VQ7nyjV9kc+m26Sg2lZTLJS9PlKkL18g/DuoiuTkUAwUAoKqy7VoDiFXWjqwQEU2/pNaLyIQI030dcn9wLAuw1i4TkRXuw+AuSyIdQ+7PiGUZAAAAQCI8M2aO/O2VSYGBit5tt5PXzh+QMYGKbHZkrx3lzQsHyo6Ngz/Lx76eLWeP/EFWbyhJ6roBAAAge2TzyIqd3b+zrLWRksRN93lPLB4XkatFZHdjzCHW2o8i1LUoE5EnY12AMaZ1JZPs4N3ZsmWLU8AnJ+fPOJW1VkpK/vyHIz8/X+fl3NdpvNx5GvX1eM/rdDq9p6yszLmFP6/TesvLy8ur9HldF12n3Nxc5xb+vE7rrbu3PSr0ebaJz4ljj+8T5wjO5fw+8ZvLdUTVr430mu6eT36Tx76ZE3hxuV/X5vLQKbtLnYJcrvcy5Bq2a4t68u7Fg+SiF3+ScXO8/lZb+3rGUhny0Gh55JSesnOrxim/TfyvkR7HHp8TnxPHHt8nzhHpfx3BuTx7P6d4y8pghTGmtoh41eSKI01rrV1pjNHRF/VEpLAKi7tNRPqIyP4i8rYx5iER+UJElrmjLS4Ukb3dQMVfrbVejYxYFEU7oRbwadGihdSrV6/i4Js2bZpzv1u3bhVfiI0bNzrTqtDhaWvWrJG5c+c6X4Tu3btXPL98+XJZuHChM99OnTpVPL948WJZunSpNG7cWNq1a1fxfHFxsaxatUqaNWsmO+64Y8XzOu/169dLq1atpHnz/y/QOGPGDGdddR46L4+37rpMtinzP6c5c+Y4J8sOHTpIw4YNnRNjum9TJn5ObBOfE8ce3yfOEel7Li8tK5d/vPqTvP3LEglyYKeG8vDQ3pKfm5Nxv0/6T5xOq9uzbt062W677dJ+mzzRfk4vnNtPbn1/mjz73Tzfz3/eig1y7GPfy+1DusgxfTumxTZl4ufENvE5cezxfeIckZ7n8pUrV0r9+vWd87nXrsHvU+p9Tvzmzoj6+xRv2ZoGqkHI/XVRTK/BClU/1gVZa3X+h4jIeW5g5HIR+VBExovIK26g4i0RGWStfSTW+QPZRAMVq1evdn58vIgzAACIj00lZXLhi5EDFUd3rS9X7NmiIlCRafT6Qq8zlixZ4lx3ZCP9bG8+che5fM8WkhfwMW8qtfL3t6bLfz6bIeXl2bmfAACoCr2+0OsM2jUAfyYbL8KNMTpCYr778Hlr7emVTK/T6ntmW2t3qsLy+rsjLPbVhz6TrBGRFzVdlLV2TYLSQP2gd2bPnu1ExTJ5+BHblLmf06ZNm2TWrFnOMjt37uy8L923KRM/J7aJz4ljj+8T54j0O5dvLDNy3rM/yvi5/ul/1LWHdJEzB7TJ6N8nnaf2zNTpO3bs6Mwj3bepOp/TxPkr5eJXfpElazdLkAO6tZD7TugptXJsWmxTJn5ObBOfE8ce3yfOEelzLtf10bY5fc1r1+BcnnqfE7+5JVF9n3QUSmFhRSKiQmttxAxG0cjWYEUzEfG6jL1qrT2pkukXi4iOLZtire0R47KOE5EXRKSWiPwiIjeKyDcistYNgJzo1qzQanZTNV2UtfaPam2gfzDDSRVVVFQkrVtXFtsAAABAtli8ZpOc8fR4mf6HXp5uKy/HyD3H7ypH78Y1ZDZasmaTXPDCBPlp/qrAaXZqXl8eH9pbOjSLeSA6AAAA0lRxAoIVmTl+u3Kh/4lFc0VdL4aUURWMMS1EZKQbqNBAxEBr7TvW2hXW2hJr7e/W2jtE5AgNGIqIJlR7MLZNAQAAAKrm96Xr5NhHxwYGKurk58oTZ/QhUJHFmjesLS8P6y8n7RFcvm/WknVy5MNj5MvfglOIAQAAAJXJymCFtXaTW+BaRewiZozZLiRYEXUha9dJIe+93Vq7PmB9tOC23tQx7jIBAACAhPmleJUc99h3Urxyo+/rjevmy4vn9ZN9u/x/8Upkp1p5uXLHMT3klqN2cUba+Fm7qVTOHvmDPPLVrKyt9wEAAIDqycpghetX9+9Oxpj/T0y2ra4+74nWziH3f6pk2gkhn0nnGJcDZAXNMaiFqPSm9wEAQNV8O3OpnPz497Ji/Z95Z8O1alRb3rhggOzeJrv60HCtEUzzPA/t31ZePLefNKn3//mhQ2mM4u6Pf5OLX54oG7b8mUsaAABwrQFEK5uDFaPdvzryoXeE6fYOuT8mxmWEXqFHCoio/ID3AQhpQFi4cKFzI1gBAEDVvPfzQqcH/Pot/oH/Ts3ryxsXDpSdmjfIul3MtUbl+nVoIqMuGSw9dmwUOM0HvyySYx4ZK0UrNsT18wEAIN1xrQFEls3BindC7p/lN4ExRvfP6e5DrSj3ZYzLmBNyf89Kpt3L/atjpufGuBwga3r01atXz7npfQAAEJuRY+bI316ZKCVl/ml6dm/TWF6/YIC0alwnK3ct1xrR0eNDj5Ojd9sxcBqtgzLkodEydpaXfRcAAHCtAUSWtcEKa+14HQHvPjzHGDPAZ7LLQ1I5/VeLYoe+aIw50xhj3dtNPu//wA0+qOuMMb5X88aYYSLSx334vbV2eZU3DMhg+fn50qlTJ+em9wEAQHS0hsC/P/1Nbho1zUnV4+cvXZvLi+f2l8Z1/VP8ZAOuNaJXOz9X7juhp1x/2M4SUMZCVm4okaFPj5enRs+hjgUAAFxrAJXK2mCF628istFN0fSpMeYaY0x/Y8y+xpgRInK3O90MEfl3rDO31k4XkWfchxqomGiMudYYs6cxppcx5ghjzIsiostSOhb/2vhtHgAAALJdaVm5XPv2ZHnwf7MCpzl299YyYmhvqVOQm9R1Q/r3Dj13zw7y3Nn9nILsfsrKrdzy/jS5/PWfZVMJNccAAAAQrLI6ChnNWqvBgxNF5AURaSgit/tMpoGKw6y1a6u4mOFuXQxdTjMRuS1guvUiMsxa+1UVlwMAAABsRRuH//ryRPl02uLAPXP+Xh3k6kO6kmIRVTa4U1N576LBMuz5H530T37e+mmBzFqyTh47rXfWphkDAABAZNk+skIDFqNEZFcR+Y8bmNjg1qf4UUSuEpHdrLWzqjH/zdbak3RkvYg85y5jvVtEe4WIfCcit4hIV2vtS/HdOiCzlJaWyoIFC5yb3gcAAMFWbyyR058eHzFQce2hXeWaQ3cmUMG1RrW1aVJX3ho+UA7r0TJwml+KVzt1LH6Yq/8GAQCQfWjXACIzmr8Wmc0Y01pEivR+UVGRtG6tD4H0s2XLFpk2bZpzv1u3blJQkL05tQEAiGTJmk1OoCKol3tujpG7j91Vju3NdWEorjWqT/+/fOSr2XLvp78F1kfJyzFy05Duclr/tnFYIgAA6YNrDWSS4uJiKSws9B4WWmuLqzvPrE4DBSC95OTkSOPGjSvuAwCAbc1Ztl6GPjVOildqabZt1c7PkUdP7S37dm3O7uNaIyF1LC7adyfp1rKh/PWVibJ207ajYUvLrVz/zhSZunCN3DSkm9TKo1YKACA70K4BRMbIiizAyAoAAIDsMLl4tZz5zHhZvn6L7+uN6uTL02fuIb3bbpf0dUP2+X3pOjnvuR9l9lLNgutPj8VHT91dmjesndR1AwAAQOqNrKBrMgAAAJABRs9cJic9/l1goKJlo9ryxgUDCFQgaTo0qy/vXDRI9t+5ReA0E+atlCMeGi2TirRsIAAAALIZwQoAAAAgzb3/y0I5a+R4Wb+lzPf1nZrXlzcvHCidWjRI+rohuzWonS+PD+0tf92vU+A0i9dslhMe+05e/9EpswcAAIAsRbACQNooLS2VuXPnOje9DwAARJ77bq5c8vJEKSnzr2a8W5vG8vr5A6RV4zrsLq41akROjpG/H9BZHjutt9Qr8K9PsaWsXP7xxi9y03tTpaSsPOnrCABAMtCuAURGsAJA2igvL5dVq1Y5N70PAEA2s9bKfZ/+Jje8O1Wsf5xC9unSTF48t59sV68g2auXlrjWSKyDd9lB3r5okLRtUjdwmpFj5zoF4pev25zgtQEAIPm41gAiI1gBIG3k5ORIs2bNnJveBwAgW5WVW7n27SnywP9mBU5zzG47yhOn95G6BXlJXbd0xrVG4nVu0UDeu2iw7NW5WeA03/++QoY8NEamLFidhDUCACB5uNYAIjPaIwuZzRjTWkScBLBFRUXSurU+BAAAQDraVFImf3tlonwydXHgNOft2V6uOWRnJ/0OkKoBt7s/mS4jvv49cJra+Tly17G7ypG9dkzqugEAAKByxcXFUlhY6D0stNYWSzXRNRkAAABIE2s2lcgZT4+PGKi45pCuct1h3QhUIKXl5hgnoPbAybs5QQk/m0rK5W+vTJI7PvrVCW4AAAAgsxGsAAAAANLAkjWb5MQR38u4OSsCG3/vPb6nnL93x6SvG1BVQ3q2kjcuGCg7RigAr6MvznxmvKzeUMKOBgAAyGAEKwCkjZKSEpk5c6Zz0/sAAGSLucvWy7GPjZVfF63xfV17pj9xem85rjfpPquDa42ascuOjeS9iwdJ/w7bB07z7cxlMuTh0TJj8dqkrhsAAPHEtQYQGcEKAGlDa+ysX7/euVFvBwCQLbTI8LGPjpWiFRt9X29UJ19ePLef/KVri6SvW6bhWqPmNKlfS54/p5+cObBd4DTzlm+Qox4eIx9P+SOp6wYAQLxwrQFERrACQNrIzc2VVq1aOTe9DwBAphs7a5mc9Pj3snz9Ft/Xd2hYW16/YID0bhvcIx3R41qjZuXn5shNQ7rLPcftKgV5/v+qbthSJhe8MEHu+2yGlFPHAgCQZrjWACIz9E7OfMYYzQdQpPeLioqkdWvSAwAAAKS6D35ZJJe9Okm2lJX7vt6xWT157px+EXP9A+lqUtEqOf/5H2Xxms2B0+y/c3P5z4m9pEHt/KSuGwAAAESKi4ulsLDQ2xWF1tri6u4XRlYAAAAAKeb57+bKxS//FBio6FXYuNKixEA602N81CWDpXfb7QKn+fzXJU5aqN+XrkvqugEAACAxCFYAAAAAKUJHPWt6m3++O1Ws9Z9m787N5KXz+sl29QqSvXpAUjVvUNs51k/uW9Fjbxuzl66XIx8aI/+bvjip6wYAAID4I1gBIG2UlJTI1KlTnZveBwAgk5SVW7nunSnywBczA6c5ercd5ckz+kjdgrykrlu24Foj9dTKy5U7jtlVbjt6F8nLMb7TrN1cKuc8+6M8/OUsJ+AHAECq4loDiIxgBYC0of986g+73vhHFACQSTaVlMlFL/4kL42bHzjNuYPby7+P7+kUIUZicK2Ruk7t11ZeHtZfmtb3H1GkMYp7PvlNLnrpJ1m/uTTp6wcAQDS41gAio8B2FqDANjJFeXm5rFmzxrnfsGFDycmhsQYAkP7WbCqRYc/9KN//viJwmqsP6Srn79VBr+uSum7ZhmuN1Ldw1Ua54IUJ8kvx6sBpuu7QQB4f2kfaNKmb1HUDAKAyXGsgkxQnoMA2wYosQLACAAAgNS1Zu0nOfPoHmbboz2B8uNwcI3ce00OO7xOcsx/IxpFI1749Wd76aUHgNI3r5stDJ+8ugzs1Teq6AQAAZIviBAQr6JYMAAAA1IB5y9fLcY9+FxioqJ2fI48P7U2gAtjmu5HrpES74fBuTkDPz6oNJXL60+PkyW9/J30oAABAmiBYAQAAACTZlAWr5dhHx8r8FRt8X29YO09ePLef7LdzCz4bwIemRDt7cHt57uy+sl3dfN99VG5Fbv3gV/n7az87ozEAAACQ2ghWAEgbW7ZskUmTJjk3vQ8AQDoaO3uZnPT497Jsnf9v2Q4Na8sbFw6U3m23T/q6ZTuuNdLPoJ2aynsXD3bqVAR5e+ICOe6xsbJg1cakrhsAAOG41gAiI1gBAAAAJMmHkxc5NSrWbS71fb1Ds3ry5vCB0rlFcMMrgK0Vbl9X3ho+UA7btWXgrpmyYI0MeXC0jPt9ObsPAAAgRVFgOwtQYBuZory8XDZu/LNHXJ06dSQnh3grACB9vPD9PPnnu1PEWv/XexY2lmfO3EO2r1eQ7FWDi2uN9Gatlce+/l3u/mR64PcsL8fIjUd0k9P6t3VSSQEAkExcayCTFCegwHZetdcKAJJEgxP16tVjfwMA0q4B9f7PZ8p/v5gZOM1enZvJo6fuLvVqcXlek7jWSG8afLhwn47StWUD+evLE2Xtpm1HMJWWW/nnu1Nl6sI1cvOR3aVWXm6NrCsAIDtxrQFERrdkAAAAIEHKnIbRKREDFUf2aiVPnt6HQAUQJ/t2ae7Usdipef3AaV75oUhOfvx7WbJmE/sdAAAgRRCsAJBWPVO1GJXe9D4AAKlsc2mZXPLyT/LC9/MDpzl7UHv5zwm9pCCPy/JUwLVG5mjftJ68PXygHNCtReA0P81fJYc/OFp+mr8yqesGAMheXGsAkfFfEYC0UVJSItOmTXNueh8AgFS1dlOJU0j7w8l/BE5z1cFd5Z+H7yw5OeTNTxVca2SWBrXzZcRpveXS/TsFTrNk7WY5acT38toPRUldNwBAduJaA4iMYAUAAAAQR0u18fPx7+W735f7vp6bY+Tu43Z1cutT4BdILA0GXrp/ZxkxtLfUK/CvT7GlrFyufPMXufHdKVJSVs5HAgAAUEMMqVQynzGmtYg4XYWKioqkdWt9CKQfPV95Iyry8/Np4AEApJz5yzfI0KfHybzlG3xfr5WXIw+fsrvsHyE1DWoO1xqZbebitXLecz/K3IDvp+rXfnt55NTdpUn9WkldNwBAduBaA5mkuLhYCgsLvYeF1tri6s6TkRUA0ob2Pi0oKHBu9EQFAKSaqQtXyzGPjg0MVDSsnScvnNuPQEUK41ojs3Vq0UDevWiw7N25WeA04+askCEPjZEpC1Yndd0AANmBaw0gMoIVAAAAQDV9N3u5nDjie1m2brPv6y0a1pLXLxgoe7Tbnn0N1KBGdfPl6TP3kAv27hg4zYJVG+XYR8fKOxMXJHXdAAAAsh3BCgBpo7y8XNavX+/c9D4AAKngo8mL5Iynx8u6zaW+r3doWk/evHCgdNmhQdLXDbHhWiM7aN2Yqw/pKg+evJvUzvf/l3hzablc+uokue2DaVJKHQsAQJxwrQFERrACQNooLS2VmTNnOje9DwBATXtx3DwZ/tJPToFePz1bN5LXLxggrberm/R1Q+y41sguR/RsJW9dOEh2bFwncJonvp0jZ438QVZt2JLUdQMAZCauNYDICFYAAAAAVSiO+N/PZ8p1b08Ra/2n2bNTU3npvP4U6gVSWLdWDWXUJYNlQIcmgdN8O3OZU8di+h9rkrpuAAAA2cboP1rIbMaY1iJSpPeLioqkdWt9CAAAgKooK7dy03tT5fnv5wVOM6RnK7n3+J5SkEffICAdaKqn2z+cLk+PmRM4Td2CXPn38T3lkB4tk7puAAAAqai4uFgKCwu9h4XW2uLqzpP/ngAAAIAobS4tk7++PDFioOKsQe3k/hN7EagA0khebo7ccEQ3JxgRFGTcsKVMLnzxJ7n3k9+kvJxOfwAAAPFGsAIAAACIwtpNJXLWMz/IB5MXBU5z5cFd5IbDu0lOjmGfAmno2N6t5fXzB8gODWsHTvPQl7PkvOd+lDWbSpK6bgAAAJmOYAWAtFFeXi6rVq1ybnofAIBkWbp2s5z8xPcydvZy39c1NnHXsT1k+D47aQpOPpg0xbUGVM/Cxk4diz5ttwvcIV9MXyJHPTxGZi9dx04DAHCtAcQJwQoAaaO0tFTmzp3r3PQ+AADJMH/5Bjn+sbEyZYF/cd1aeTkyYmgfOXGPNnwgaY5rDXiaNaglL53XX07tF/y9/n3pejnqoTHyxa+L2XEAAK41gDggWAEgbWhP1fz8fOdGr1UAQDJMW7hGjn1srMxdvsH39Qa18+T5c/rJAd1a8IFkAK41EEprV9x2dA+5/egekp/rP2Jq7eZSOfe5H+XBL2aKtdSxAABwrQFUh+GCKvMZY1qLSJHeLyoqktat9SEAAAAi+f735XLesz86jZF+mjeoJc+d01e67tCQHQlkuB/nrpALXvhJlq3bHDjNIbvsIPce31Pq1cpL6roBAADUhOLiYiksLPQeFlpri6s7T0ZWAAAAAGE+nrJITn96fGCgokPTevLmhQMJVABZok+77eX9SwZLz9aNAqf5aMofcswjY2Xe8vVJXTcAAIBMQbACAAAACPHSuPky/MWfZEtpue9+2bV1I3n9ggFSuH1d9huQRXZoVFtePX+AHLt78Ej13xavlSEPjZFvZy5N6roBAABkAoIVANJGWVmZLFmyxLnpfQAA4knToz7wxUy59u3JUh6Qen7PTk2dortN6tdi52cgrjVQmdr5uXLv8bvKjUd0k9wc/zoWqzeWyBlPj5fHv5lNHQsAANcaQAwIVgBIqwaEhQsXOjeCFQCAuP7GlFu58b2pct9nMwKnOaJnK3nqjD2kPvnoMxbXGoi2EPtZg9rL8+f0le3q5vtOowHP2z+cLpe+Okk2bqGTDQCAaw0gGgQrAKTVP4b16tVzbnofAIB42FxaJn99ZaI89928wGnOHNhO/ntiLynI4/I5k3GtgVgM7NhU3rt4sHRr2TBwmncnLZTjHhsrC1ZtZOcCALjWACphdLg7MpsxRpOqFun9oqIiad06OMcqAABANlm3uVTOf/5HGTNreeA0/zioiwzfpyOBcgC+dOTElW/+IqN+Xhi4h5rUK5CHT91d+ndowl4EAAAZobi4WAoLC72Hhdba4urOk65hAAAAyErL1m2Wkx//PjBQoeno7zymh1y0704EKgAEqlOQKw+c1EuuPqSrBA3+Xb5+i5z25Dh5duxc6lgAAAAEIFgBAACArFO0YoMc9+hYmbxgte/rmu7p0dN6y0l92yR93QCkZwqxC/buKM+cuYc0rJ3nO02pWxvnqjd/cdLPAQAAYGsEKwCkjdLSUlmwYIFz0/sAAFTFtIVr5JhHx8rc5Rt8X29QO0+eP7uvHNR9B3ZwluFaA9W1T5fmTh2LTs3rB07z2o/FcuKI72Xxmk3scADIMlxrAJERrACQNsrLy2Xp0qXOTe8DABCrcb8vlxNHfCdL1272fb1Zg1ry2vkDpB955bMS1xqIh3ZN68nbFw2SA7u1CJxmUtEqOfzB0TJh3kp2OgBkEa41gMgIVgBIGzk5OdK4cWPnpvcBAIjFJ1P/kKFPj5e1m/1H57VvWk/eunCg7NyyITs2S3GtgXipXytPHjutt1y2f+fAaTRoetLj38kr4+ez4wEgS3CtAURmrLWVTIJ0Z4xpramZ9X5RUZG0bq0PAQAAsoc2Bl779mQpD7j07bFjI3nmrD2kaf1ayV41ABnus2mL5bJXJ8m6gECpGtq/rfzz8G5OvRwAAIB0UFxcLIWFhd7DQmttcXXnyZUQAAAAMpZ2zHnofzPl6reCAxWDd2oqLw/rT6ACQEIc0K2FvHPRQGf0VpDnv58npz05Tpat809RBwAAkA0IVgAAACAjlZdbuem9qXLvpzMCpzl815by1Jl9nJQtAJAoOzVvIO9cNEj27dIscJrxc1fIEQ+OlsnFq/kgAABAViJYASBtlJaWyty5c52b3gcAIMiW0nL526uT5Nnv5gVOc8aAtvLASbtJrbxcdiS41kDCNaqTL0+esYdctG/HwGkWrd4kxz02Vt6eWO0sCgCAFES7BhAZwQoAaaO8vFxWrVrl3PQ+AAB+NC/82SN/kFE/LwzcQVcc2FluGtJdcnIMOxFcayBpcnOM/OOgrvLwKbtLnXz/QOnm0nK57NWf5db3p0lpGde8AJBJaNcAImO8O4C0kZOTI82aNau4DwBAuOXrNstZI3+QXwLSqGhs4raje8jJfduw88C1BmrMYbu2lA7N6smw53+UohUbfad5cvQcmf7HWnnw5N1ku3oFSV9HAED80a4BRGa06CAymzGmtYgU6f2ioiJp3VofAgAAZJaiFRvk9KfHy5xl631fL8jLcdI+HbzLDklfNwDws3L9Frn45Z9kzKzlgTuocPs68vjQPrJzy4bsRAAAkDKKi4ulsLDQe1hora12Hku6JgMAACDt/bpojRz76NjAQEWDWnny3Nl9CVQASCk6YuLZs/rKuYPbB06jIy+OeWSsfDh5UVLXDQAAINkIVgAAACCtjZ+zQk4Y8Z0sWbvZ9/VmDWrJq+cPkP4dmiR93QCgMnm5OXL94d3kvhN6OiPA/GwsKZPhL/4k93wyXcrKyY4AAAAyE8EKAGmjpKREZs6c6dz0PgAAn079Q057apys3VTquzPaNakrb14wULq1In0KuNZAajtm99byxgUDpGWj2oHTPPzlbDnvuR9l9UauhQEgHdGuAURGsAJA2tAaO+vXr3du1NsBALwyfr5c8MIE2VJa7rszdtmxobxx4UBp06QuOwtcayAt7Nq6sbx38WDZo912gdP8b/oSOfrhMTJrydqkrhsAoPpo1wAiI1gBIG3k5uZKq1atnJveBwBk7z95D385S65+a7IEZUMZtFMTefm8/tK0fq1krx7SGNcaSAWauu7Fc/vL0P5tA6f5fdl6OerhsfLZtMVJXTcAQPVwrQFEZuidnPmMMa21LpveLyoqktat9SEAAED6KS+38q/3p8nIsXMDpzls15ZO7vdaeQS2AaT/CLJ/vjtFSsqC61T8/YDOcvG+O0lOjknqugEAgOxWXFwshYWF3sNCa21xdefJyAoAAACkBU33dOmrkyIGKk4f0FYeOGk3AhUAMsJJfdvIK8P6O6Mtgtz32Qy58MUJsm6zf+0eAACAdEGwAgAAAClv/eZSOefZH+S9nxdG7F1885DukkvvYgAZpHfb7WXUxYOlZ2HjwGk+mbpYjnlkjMxdtj6p6wYAABBPBCsApI2SkhKZOnWqc9P7AIDssHzdZjnlie/l25nLfF/X2MRtR+8if92vk6a/TPr6IXNwrYFUtUOj2vLqsP5yfO/glL4zFq+TIQ+Nlq9nLE3qugEAose1BhAZwQoAaUNr7OgPu96otwMA2aFoxQY5/rHv5Ofi1b6vF+TmyCOn7i6n9gsuRAtEi2sNpLLa+bly93G7RhxBtmZTqZz1zHgZ8fVsrpcBIAVxrQFElic1xPzZ7W17EakrIguttWU1tS4A0kNeXp60a9eu4j4AILNN/2ONnPH0eFm8ZrPv6w1q5cnjp/eRAR2bJH3dkJm41kCq03+jzxjYTjq3aCAXvfSTrFi/ZZtpyq3IHR9Nl6kL18hdx+4qdQpya2RdAQDb4loDSKGRFcaYXGPMWcaYb0Rkg4gsEZE5ItIlbLrDjTF3G2OuS+b6AUhtOTk50rhxY+em9wEAmeuHuSvkhMe+CwxUNK1fS145vz+BCsQV1xpIFxqkfe/iQdK9VcPAabTGz7GPjpXilfqvNwAgFXCtAUSWtNY+Y0xzEflWRJ4UkcEiUkufdm/hNIBxhYj8yxjTK1nrCAAAgJr32bTFctqT45x0Jn7aNqkrb104ULq3apT0dQOAVNF6u7ryxgUDZUjPVoHTTFu0RoY8NEa+m708qesGAACQssEKY4wu5z0R6a/p2UTkNRG5OGh6a+1UEfnOfXh0MtYRAAAANe+1H4rk/Od/lM2l5b6vay9ibZxr00QziQJAdtMUT/89qZdcd+jOElDGwkkVddpT42TkmDnUsQAAACktWSMrTheRvlr0XkQOs9aeZK19pJL3jHJHXegoDACQLVu2yKRJk5yb3gcAZFaxwUe+miVXvvmLk2/dz8COTeSVYf2lWQMdoAvEH9caSNc6Fuft1UFGntVXGtXJ952mrNzKTaOmyT/e+EU2lVAuEgBqCtcaQGoEK052R1SMsNZ+EuV7Jrp/t6pnAQAAgMxSXm7llvd/lbs//i1wmkN77CDPnLWHNKjt3xAHANlur87NnDoWXVo0CJzmjQnFcuLj38sfqzcldd0AAABSKVjh1Z3QVFDR0uLbqkkC1gdAGsrLy5NOnTo5N70PAEh/W0rL5bLXJsnTY7Rkmb+h/dvKgyfvLrXycpO6bsg+XGsg3bVtUk/eGj5QDu6+Q+A0PxetksMfHC0T5q1I6roBALjWAFIlWNE4LAARDa/bnH/CYgBZJycnR+rVq+fc9D4AIL2t31wq5z73o7w7aWHgNJfu30n+dWR3yQ1Kxg7EEdcayAT1auXJI6fuLpcf0FlMwKlz2brNctLj38vL4+cne/UAIKtxrQFElqzWvpVVGCXhpX9amoD1AQAAQA3Sgq+nPDlOvpnhf6mnDWy3HrWLXLq/NrYRqACAWOTkGLlkv07yxNA+Ur+W/4jkkjIr17w1Wa57e7Izyg0AACBbghXT3L+xFMs+xa1zMSFB6wQgDYuvajEqvel9AEB6Kl65QY57bKyTisRPQW6OPHLK7nJa/7ZJXzdkN641kGn279ZC3rlokHRoWi9wmhfHzZdTn/xelq7dnNR1A4BsxLUGkBrBCq1VoV3ihhtjtq9sYmPMWSJykPvw7cSvHoB0UFJSItOmTXNueh8AkH5++2OtHPvoWPl96Xrf17UH8Miz95BDerRM+roBXGsgE+3UvL68c/Eg+UvX5oHT/DB3pRzx4OjAIDIAID641gBSI1gxQkQ0GbFeHX1mjOnuN5ExptAY86CIPOGOqpgpIi8laR0BAACQQD/MXSHHPzZWFq/x773btH4teWVYfxnYsSmfAwDEUcPa+fLk6X3k4n13CpzmjzWb5PgR38mbE4rZ9wAAoEaYZKVSMcbsISL/E5G67lO/iUhXNygxRkSaiUhnb3IRWSsig6y1U5KyghnMGNNaRIr0flFRkbRurQ+B9KPnK29ERX5+PjnMASCNfD5tsVz00k+yOSAvepvt68rz5/SVtk2CU5UAica1BrLBh5MXyRWv/ywbtpQFTnP2oPZy7aFdJS83Wf0bASA7cK2BTFJcXCyFhYXew0JrbbV7PCTtysNa+4OIDBSRKW4wQgMVnkFuQW3j3n4lUAEgnBZYLSgocG4UWwWA9PHaj0Vy/gsTAgMV3Vo2lDcvHEigAjWOaw1kg0N7tJS3hg+Uwu3rBE7z9Jg5cvrT42XF+i1JXTcAyHRcawCRJbWbhLV2srW2p4gcISJPisgkEVkkIkvcItwvisiJItKDERUAAADp33Ps0a9my5Vv/CJl5f6jeQd0aCKvnt9fmjWolfT1A4Bs1XWHhjLq4sEyeKfgtHtjZy+XIQ+NlmkL1yR13QAAQPZKWhoo1BzSQCFTlJeXy8aNG537derUkZwchqUDQKoqL7dy24e/ylOj5wROc8guO8h/TuwltfNzk7puQBCuNZBtSsvK5a6Pp8sT3wafq2vn58g9x/WUI3q2Suq6AUAm4loDmaQ4ndNAAUB1lZaWysyZM52b3gcApKYtpeXy99cmRQxUnNqvjTx0yu4EKpBSuNZAttGaFNcd1k3uP7GX1Mrzbx7YVFIul7w80QlqBI2SAwBEh2sNIDKCFQAAAIibDVtK5dznfpR3Ji0MnOZv+3WSW4/aRXJztFQZAKCmHbXbjvLGBQOlVaPagdNoWr9znv1BVm8sSeq6AQCA7EEaqD/TJLURkb+KyGEiovc3i8gsrQcpIo9YazfEbYcbs7+InCYig0WkpQZVRWSxiPwiIl+IyPPW2nXxWp67zNYiUqT3i4qKpHVrfQgAABBfWoj1rJE/yM9FqwKuSUT+deQuMrR/W3Y9AKSgZes2y/AXf5Lxc1YETtO+aT15fGhv6dSiQVLXDQAAZH4aqKQEK4wxZdV4u7XW5kmCGGMOcwt7NwqY5DcROdRa+3s1l7OdiDwjIkdWMulu1lotPB43BCsAAECiLVi1UYY+NU5+X7re9/WC3By5/6RecmgP7asBAEhVJWXlcsv70+S57+YFTlOvINepOXRg9x2Sum4AACB1pHPNClPNW2JWypie7ugJDVToaIbrRGSgiOwnIk+4k3URkQ+MMfWrsRyd/2chgYoPRGSoiAxwR1icKiL362ccny0DAABInhmL18qxj4wNDFTUr5UnI8/ag0AFAKSB/NwcZxTcXcf2cALNftZvKZNhz0+Q+z+fIeXUsQAAAHGSsBELYW6OYpp6bmBA0yRposxxIvJJgtdLAwR13VRMB1prvwt57X/GmJkicreIdBWRv4vIv6q4nAdFpLe7nNOsta+GvT5GRF4yxugycquxPUBGKy8vlzVr1jj3GzZsKDk5lN0BgJo2Yd4KOXvkj4E5zJvWL5CRZ/WVXXYMGsQKpA6uNYD/d+IebZxUTxc8P0GWrNVMydu6//OZMm3hGrnvxF5OYBoAwLUGkFE1K4wxTUXkaU29JCKXWWsfTNBy9hCR8e7DEdbaC3ym0ZbQKSKys4isFJEW1tqYqokZY3TkxLfuw5ustdEEbuKKNFDIFFu2bJFp06Y597t16yYFBQU1vUoAkNX+N32xk9t8U0m57+tttq8rz53dV9o11T4pQOrjWgPY1uI1m+SCFybIxPn+9YhUp+b15fHT+zj1LAAAXGsgOxSncRqoqFlrl4nIMW7B6X8bY/olaFFHhdx/JmBd9D/v59yHWnNinyos52L3r6aZ+ncV3g/AZYyR/Px856b3AQA1540JxXLecxMCAxU7t2wob1w4gEAF0grXGsC2WjSsLa8M6y8n9qlojNjGzCXrZMhDo+Wr35awCwGAaw0gc0ZWeIwxZ7ojLF631p6YgPl/IyJ7arpNEWlsrS0NmE7rSox1H/7LWntjDMvQbt+r3bRWuh0nuM/r+NgdNR4iIn9Ya7fEa7sC1qO1iBTp/aKiImndWh8CAABUzYivZ8sdH00PfL1f++3liTP6SMPa+exiAMgQ2nbwwvfz5OZR06Q0oE6F9ie68qCucsHeHehcBABAhitOwMiKVE4qOdn9OyhB89fUTmpWUKDCNd3nPdHq6QYq1HfGmB1E5A4ROd6t0aE2GWO+FJFbrbVeUKQqwYhIdLkVQ9s1F6+X618vOEtK/sxsFdpbXacpLf1zt4Sm2vGe93qdecrKypxb+PM6rbe8vLy8Sp/XddF1ys3NdW7hz+u0oXUKdHtU6PNsE58Txx7fJ84RnMv5fUrMb64WUb3389ny5Og5gRcdB3ffQf5zwq6Sa6zzHq4juDbieo9rWP7XyIz/n/T5oQPaOSmfhr/0k6xYv22GZO0LedfH02XqwtVy93G7St2CvJTeJg//56b2scfnlB7nCD4nPieOvez8PsVbKgcrvEZ+rWERV8aY2iHzjRjxsdauNMasd4MLweNe/XULuV/bDcCEb48+f4iIHGSMudxaq0W/Y+WMmojGzJkzpUWLFlKvXr2Kg8+vBsDGjRudaVWvXr0q3q/FjefOnet8Ebp3717x/PLly2XhwoXOfDt16lTx/OLFi2Xp0qXSuHFjadeu3VaRt1WrVkmzZs1kxx11kMmfdN7r16+XVq1aSfPmzSuenzFjhrOuOg+dl8dbd10m28TnxLHH94lzBOdyfp8S95v7y5Sp8uC4lfL1vI2B1xkn920jtx61i2zauEF+4zqCayOu97iG5X+NjPz/qWuTPLnrL9vLnWNWyuwV/kkC3v9lkcxeul4eH9pbcjauTPltysTPiW3ic+LY4/vEOYJzeTJ+n+It5WpWhNC6FWppAubdIOS+1pKojAYrVP0Yl7N9yP0b3UDF+yLSxw1StBCR4Xod4X4W9xljNHABwIdGdTds2CBLlixxIsgAgOTYsKVUbv92ecRAxUX7dJDbj95FcnOoKYT0pdcXep2hjXypmi4XSAXN6uXJPQftIEf1ahU4za+L1jh1LCYUrU3qugFAKtPrC73OoF0DSJOaFcYYDctcommR9KGIPG+tPTPOy9AREvPdhzr/0yuZXqfV98y21u4Uw3KuF5FbQp4apYW93cLdodMNFpGv3YDFFBHZ1cbwwUSZBuoHvTN79mwnKpbJw4/Ypsz9nLTX0G+//ebMw+tNlO7blImfE9vE58Sxl1nfp5Xrt8hZI3+QSUWrxI9uxj8P7SpnDe6QNtvEeY/PKejY0++u9hjT46tLly5Sq1Ytjj2+TxlxLk/UeU/n89ToOXL7h79KQBkLJ4h91YGd5KxB7aLa1prepkz8nNgmPieOvdT5Pm3evHmbdg3OEZz30vVcXpyAmhVJCVYYY/4XxWS65duJSGf9XNxAhY566G2tnRnn9WkmIkvch69aa0+qZPrFIqJjYaZYa3vEsJwrROSekKe6Wmt/C5j2dRE5zn2owQqvZke1UWAbmUJPljpETWnQLfSEDACIvwWrNsrpT41zUnn4yc818p8Te8nhuwb3rAXSCdcaQNWMnrlMLnrpJ1m9cds6Fp5jdt9Rbj+6h9TO///GEADINlxrIJMUp3GB7X00cOkGIKI1T0ROi3egwhU6DjWa1E71YkgZFbScOUGBCtcnIcGKPUIKjANwaXAiNFcsACBxZi5eK6c/PV4Wrd7k+3q9glx5/PQ+MminuJcXA2oM1xpA1Qzu1FRGXTxYhj3/o0z/wz/t01s/LZBZS9bJiKG9pWWjOuxqAFmJaw0gNYIV37jBikg0NZJe1cxxUyJ9YK0N7pZRDdbaTcaYZW4NiYgplIwx24UEK6IuZO0zfXEM0/5/RRMAAIAkmzBvpZw98ofAHrJN6hXIyLP6So/WjfhsAACONk3qypsXDpR/vPGzfDj5D9+98kvxajniwdHy6Gm9ZY92oSUeAQAAkhSssNbqyIpU86uI7CkiOxlj8qy1fyYG21bXsPfEYmrI/crGuoa+HrQuAAAACfW/6Ytl+Is/yaaSrUpsVWi9XR15/px+0r6p15cDAIA/1auVJw+fsrs88tVsuffT38Qv6/SydVvklCe+l5uGdJdT+7Vl1wEAgAr/XyEj+4x2/+p/2r0jTLd3yP0xsSzAWjsvpJB3x0omD319QSzLAbKFFgRasGCBc/MKDwEA4ufNCcVy3nMTAgMVXXdoIG9dOJBABTIW1xpA9Wmxz4v23UmeOqOPNKjl3z+ypMzKdW9PkWvemixbSv1/cwAgE3GtAUSWzcGKd0Lun+U3gTFG98/p7sNVIvJlFZbzpvu3hTFmYITpjgm5/20VlgNkvPLyclm6dKlz0/sAgPh5/JvZcvnrP0tZuX/mzr7tt5fXLhggzRvWZrcjY3GtAcTPX7q2kHcuHiQdmgWPxHt5/Hw5+YnvZcla//pIAJBpuNYAIsvaYIW1dnxIUOAcY8wAn8kuF5Gd3fv/Da+hYYw50xhj3dtNAYu6X0S8K68HjDHbXKkZY05zi5CLW6uj2pXTgUyUk5MjjRs3dm56HwBQfeXlVm7/8Fe5/cPpgdMc1L2FPHd2X2lYO59djozGtQYQXx2b1Zd3Lhok++/cPGKdpCEPjpFJRdo/EAAyG9caQGTG+iWRrCJjzF6SANZaLdAdd8aY3dzUTnVEZJ2I3O6OntDHJ4nIMHfSGSLSx1q7Nuz9Z4rIM+7Dm621vgELY8w/RORu9+E09/4UEWnkjqi4wK1ZscZdzsw4b2drr4B3UVGRtG4dsaY4AADIEiVl5XLVm7/IWz8FZ6A8uW+h3HpUD8nNMUldNwBAZgXG7/98hjzwv1mB0xTk5cjtR/eQ43rz/yoAAOmguLhYCgsLvYeF8eiAH+8C219pbCHO87SJKgRurZ1ojDlRRF4QkYZusCKcBioOCw9UxLice4wx24vIVSLSTURG+ky2RESOinegAgD+j727AJPiSP84/qs1ZJHFbZcQLLgECZbL3SWXiytJiEAgSvRy7u6SnESJEAJxl8td9GK4Eyw4YRcIvsgCa1P/pya9/Cdkelib2ZHv53n62Z7pmuqantmZd/rtqgKAcA6WlOmWJxbqvVU7fA/Q7V/vqm9/o3tw/HEAAKorLc3oO6efoF7tm+g7zy7RwZLyL5Vxc1d877klWrZ5r356dk9lptOTGgCAVBONb38ThSVqrLWvSeon6e9eYuKgNz/FfC+5MNBau7YW9vNjSSMlTZO0UVKxpL2S5kn6uaTu1tpZtfOsAAAA/O0pKtGVD8/xTVS43MSvz+sdPLFEogIAUFvO6NNOL908Uh2bN/QtM2XmRo17ZK52F5Vw4AEASDG1PQzUKYoCa+0H0ag3VTAMFJJFWVlZsIuZ44Yzy8iISqcrAEhqWwoPadzkuVq73Y2A+WWZ6UZ3XTpA5/ZvH/O2AXWNWAOIjcKDJbrtqUX6aM1O3zIdchrowXGD1Lu9Gz0ZAJIDsQaSSUG8DwNFUgFANAUCARUWfj7xXvv2nEQDgKpau32/xj4yV1v3Hg67PTsrXZPGDtaobi05uEhJxBpAbOQ0zNKUCUP1lzc+0aQP14cts7nwkC6+f6b+Mrq/ziOBDiBJEGsAkXFZMoCEkZaWplatWh1ZBwBU3sJNe3TNlHkqPFgadnuL7Cw9OmGI+uXmcFiRsog1gNhJTzP68Vk9g/NY/PCFj3W4NPClMu6+259apOVb9uoH3+wRfAwAJDJiDSCGw0AhPjEMFAAAqe29Vdt10+MLwp4IcnKbNdDUa4aqc6tGMW8bAABuUu0bpy0I9qbw85XurXT3mIFq2jCTAwYAQJIOA8WlyQAAAEnsxYUFuv6x+b6Jih5tG+uFm0aQqAAA1Jk+HZrq1VtHaljn5r5lPly9Q+fdO12rt+2PadsAAEAS96wwxjSWdJqk/pLcgMgN3N0RHmKttdfGsIlJh54VAACkpoc+XK/f/2el7/ahnZrroasHq2kDrlIFANS90vKAfv/6Sk2ZudG3jJtf6c5LB+iMPm1j2jYAABD9nhUxS1YYY1wvjp9L+q6LLyr7MC9ZkR7l5iU1khVIFqWlpdq48fMfLp06dVJmJifXACAcF9/96b/+k5Y6p/dqo39dPlD1MwmzAGINIL48Oz9fP3tpmUrKw/cKdG4/tZvuOLWb0pjHAkAC4bwGkklBFJIVsZxge4qkK70ERLmkXZJau9/T7rlJaiapYqBkd99OSQdj2D4ACXDyraio6Mg6ACD8Vak/emGpXljoHyeOGZKn313QRxnpjAgKEGsA8efSwXnq1rqRJj6+QNv2FYct869312jFln36+2X91bg+FzEBSAyc1wAii8kvVGPMNyVdFZK0aO0NBRVkrT3OWtvEDZss6Z+S3OUTeySdaa09PhZtBBD/0tPT1b59++Di1gEAX3SopDw4QWmkRMWtX+uqP17Ul0QFQKwBxLWBHZvptVtH6cSOOb5l3lm5TRfcO0PrdxyIadsAoLo4rwHEwTBQxpin3cURkpZZa/t59/WWtDTcME/GmHMkvSQp38Uo1tq9UW9kEmMYKAAAkl/hwRJdM2WeFm4qDLvdGOmX5/TS+JFcBwIASBzFZeX61avL9dRcd3ogvMb1M/SvMQP1tR7uukgAAJCow0DFqu//MG9op3srU9ha+29Jj0k6zg1FGf3mAQAAJK6tew/pkgdm+SYqMtON/jlmIIkKAEDCqZeRrj9c2Pfz4Qt95qfYf7hM1zw2T/e+t5bhYgEASGCxSlZUXN6wOuQ+N29FkDGmXpjHPO/Nb3Fh9JsHAACQmNZu36+L75upNdvDD4HRMCtdk8cP0Xn928e8bQAA1AZjjK4adpyevH6YWjbKClvGDRrx1zdX6dYnF+lgSRkHHgCABBTrWRV3h6zvD1kP11dzu/e3U5TbBCBBlJaWavny5cHFrQNAqlu0aY9GPzBLW/YeDru9eXaWnrp+mE7u1irmbQMSEbEGEN+GHt9cr946Sn07NPUt8/rSrbrovpnK330wpm0DgMog1gDiI1mxzfvb/Kj7Srz14DwWR+no/a0f5bYBSBBujh33xe6WWMy3AwDx7P1V23XFQ3NUeDB88rZDTgM9P3G4+uf5T0wK4IuINYD41z6ngZ6bOFwXDezgW+aTz/br3Huma8banTFtGwAcC7EGEB/JCjeRttOr4g5rreuXuci7OSHMY270/n4a/eYBSAQZGRnq1KlTcHHrAJCqXl60Wdc9Nl+HSo+MqvkFPdo21os3j1DnVo1i3jYgkRFrAImhfma67ry0v35+Ti+l+8xj4ZL5Yx+Zo4c/Ws+FTgDiBrEGEB/Jive9+SdOO+r+xyvmpTDGTDXGnG2MucQY85qkb3qTcr8SozYCiHNpaWnKyckJLm4dAFKRO+lyxzOLVRYI38NsSKdmeubG4WrThM6pQFURawCJNY/FtaOO19RrhiqnYWbYMu6r8nevr9R3n12iwz4JfgCIJWINIDITi6FUjDHHS1onqdjNQWGtDQ4LZYxxl0bPlnSil5j4wsO8XhUnWmv3RL2RScwYkysp363n5+crN9fdBAAAicTFbH964xNN+mC9b5nTerbRPVcMDF5xCgBAqnDzU1w/dX5w+Cc/bp6LSWMHBYeRAgAANVdQUKC8vLyKm3nW2oKa1hmTS5OttRskdZbUR9K+o4aC+oakJySVeQmKij6cr0s6mUQFAABIdWXlAX3/+Y8jJiouHZyrB646kUQFACDl5DVvGBz+8Oy+7XzLLN28V+fdM11zN+yOadsAAEAd9qwwxnwsaapLQFhrt1bhcY0ldXPDt0laa60lgqi914SeFUgKJSUlWrFiRXC9V69eysrKqusmAUDUHSop161PLtS7n2z3LXPL17roe6efEBwSA0D1EWsAic2d37j/g3X665ur5HeqIyPN6Jfn9dZVJ3XkexNAzBFrIJkUJEjPCtd74s+SNhlj3jTGXGGMOWY/S2vtfmvtQmvtXBIVAAAA0l5vctBIiYpfnttL3/9mD064AABSnkva3/zVrpo8foga13fXQX6Zm/Pp5y8v009eWqriMuaxAAAg2XtWFEmqSE5UVH5A0guSpllr36vVHaIyrwk9K5AUAoGADh06FFxv0KABk2wDSGqf7T2scZPnaPU2F0aFvzL0zkv76/wBHWLeNiBZEWsAyWP9jgO6YdoCrd0e/nvUObFjjh64apBaN6kf07YBSF3EGkgmBQnSs6K1pPGS3vWSFW48AjfE09WS3jHGfGqM+Z0x5oQo7BtAEktLS1N2dnZwcesAkKzciZWL75/pm6homJUevGqURAVQu4g1gOTRuVUjvXTzCJ3Ws41vmYWbCnXO3dO1aNOemLYNQOoi1gAiq/WzfdbaImvtVGutmzi7o6QfSVoWMnm2S7f8WNIKY8xcY8wtxpgWtd0OAACARLQ4v1CXPDBTmws/70l2tGYNM/Xk9cP0le6tYt42AAASSeP6mXpw7CB961Q3PWZ42/cX67JJs/Xs/PyYtg0AAHxZVC9NttZusdb+xVrbT9JASX+XtDUkcTFI0r8kbTbGvGyMucgYkxnNNgFIXG7YOjcZlVtqewg7AIgHH6zeocsfnK09B0vDbu+Q00DP3zRCA/JyYt42IBUQawDJJy3N6Nvf6K5JYwcpOys9bJmS8oB+8PzH+uUry1RaHoh5GwGkDmINILKYjaNirV1irf2u17PiDElPSDroJS2yJJ0r6TmXzDDG3GuMGRartgFIDKWlpVqxYkVwcesAkExeXrRZ106Zp0Ol4Sf7PKFNY71w0wh1adUo5m0DUgWxBpC8vtm7rV66ZaQ6tWjoW+axWZ/qqofnaNeB4pi2DUDqINYAIov5oO/W2oC19i1r7VhJbSvmsgiZ36K5pImSZhhjVhljfhrrNgIAAMTSI9M36I5nFqssEL7X2ODjmunZG4erbVMmAAUAoLq6t2msV24ZpVMiDKU4Z8NunXfPDC3bvJcDDQBAjJl4GUrFGNNO0lXe0jdkk7XWhu+ricoe21xJwQE48/PzlZvrbgKJx31eVfSoyMzMdO/tum4SANT4c+0vb67S/e+v8y1zWs/WuueKE1U/k3AIiDZiDSA1lAes/vrmKj3wgf/3b/3MNP354n46f0CHmLYNQHIj1kAyKSgoUF6eG0QpKM9aW5BwPSv8WGu3enNa/FLScq+nBQAc4ZITWVlZwYVEBYBEV1Ye0A9f+DhiouLSwbl64KpBJCqAGCHWAFJDeprRj87soX9dPjCYlAjncGlA33p6sf7wn5XB5AYA1AZiDSABkhVufgo3T4U3+fYLknp5Q0I5++q4eQAAALXqcGm5Jj6+UM/O97/w5Kavdgle0ZmRHhfhGgAASee8/u2D80F1yGngW+bBD9dr/KNzVXiwJKZtAwAgFdXZr19jTGdjzC+MMavd/BTePBUtvCRFQNKbkq6U5IaHAgAFAgEVFRUFF7cOAIlo78FSjX1kjt5Zuc23zM/P6aUfntGDXmRAjBFrAKmnd/umeu22URre2Z2OCO+jNTuD81is+mx/TNsGIPkQawBxlKwwxuQYY240xkyXtMYb8qmLl6Bwy1JJP/DGuDrTWvuUtfZwLNsIIH6VlZVpzZo1wcWtA0Ci+WzvYV06aZbmbdwTdntGmtE/Lhuga0cdH/O2ASDWAFJV8+wsTb12qCaM7ORbZtPug7rwvhl6Y5kbEAIAqofzGkAdJyuMMZnGmAuMMW54J/etfp+k4SEJih2S/inpRGttf2vt36y1n0W7XQAAALG0bscBXXz/TK3aFv6qzAaZ6Xr46sG6YCATeQIAEGuZ6Wn65bm99dfR/ZSVEf5UycGSz4dxvPOtVQowjwUAALXOuFnoo8EY4xISY93ckJKaVdzt/S2W9KqkqZLesNaWR6URqHgtciXlu/X8/Hzl5rqbAAAgVpbkF2rClHnaXRR+vOtmDTM1efwQDexYETIBAIC6sji/UBOnLdBn+/wHeji1R2v9fcwANamfGdO2AQAQLwoKCpSXl1dx042U5D8pY131rDDG/NIY44Z4ckM93eh6VIb0opjpzU3R1lp7mbX2dRIVAAAgmX24eocuf2i2b6LCTer53MQRJCoAAIgTA/Jy9OptIzXoOP+LCN79ZLsuuHdGsOckAACI32Gg3DwUnUMSFBsk/VZSN2vtKGvtg9bavVHYLwAAQFx5ZfFmXTNlXnDYiHC6t2mk528arq6tG8W8bQAAwF/rxvX11PXDdPnQjr5l1u8o0gX3zND/PtnGoQQAII7nrHCDMU+WdIq1tou19pfW2nVR2heAFBEIBFRYWBhc3DoAxLPJ0zfoW08vVpnPmNbuas1nbxyudk0bxLxtAMIj1gAQys1d8ceL+ur3F/ZRZnrFqNZftL+4TNc+Nl/3/G+NojXMNoDkQawBxD5ZcYU3zNN11tqPolA/gBRVVlamjRs3Bhe3DgDxyJ2o+Msbn+g3/14RcZzrx689STkNs2LaNgCREWsACOfKk47Tk9cPU8tG9cJudzmKv721Wrc8uVBFxfxOAUCsAcRNssJa+7S11n8WKgCoJmOMMjMzg4tbB4B4U1Ye0I9eWKr73vfvUDp6UK4mjR2kBlnpMW0bgGMj1gDgZ0in5nrttpHqn9vUt8x/ln6mi+6bqU93FXEgARBrANVg6KaY/IwxuZLy3Xp+fr5yc91NAABQmw6Xluu2pxbp7RX+41bfeEpn/eiMHiRcAQBI4O/7n760TC8sLPAt07RBpu65YqBO7tYqpm0DACCWCgoKlJeXV3Ezz1rr/+VYx3NWAAAApIy9h0o17pG5ERMVPzu7p358Zk8SFQAAJLD6men62yX99Itzeik9zfjGBVdPnquHPlzPPBYAAFQByQoAAIAa2LbvsC6bNEtzN+4Ouz0jzejvl/XXdSd35jgDAJAkQ8ZdM+p4TbtmqJo1zAxbJmCl3/9npb79zOJgbwwAAHBsJCsAJIzy8nJt3749uLh1AKhr63ccCI5N/cln+8Nub5CZroeuHqwLBzIEI5AIiDUAVMWIri316q2j1LNdE98yLy/eotEPzNTmwkMcXADEGsAxkKwAkFAnELZs2RJcSFYAqGtL8gs1+oFZvicfchpm6snrT9LXTmgd87YBqB5iDQBVlde8oV64abjO6dfOt8yyzft03t3TNWf9Lg4wkOKINYDISFYASKju1tnZ2cHFrQNAXflozQ5d/tBs7S4qCbu9fdP6en7icA3s2CzmbQNQfcQaAKqjYVaG7r58oH54Rg/5/UzZVVSiKx+eo6mzNjKPBZDCiDWAyIy19hhFkOiMMW7siXy3np+fr9xchqIAAKC6Xl2yRd99drFKy8PHUN1aN9LUa4eqXdMGHGQAAFLM+6u26/anFmnf4TLfMpcOztVvL+ijehnpMW0bAAC1qaCgQHl5eRU386y1BTWtk54VAAAAlfTojA3BExB+iYpBxzXTcxOHk6gAACBFffWE1nrl1lHBixf8PDu/QGMenK1t+w7HtG0AAMQ7khUAAADH4Hqi/u3NVfr1ayt8y3y9R2s9fu1JymmYxfEEACCFHd8yWy/dMlKn92rjW2bRpkKde/d0Ldy0J6ZtAwAgnpGsAJAwysrKtHnz5uDi1gEgJp895QH9+MWluue9tb5lLj4xV5PGDlKDLIZzABIZsQaA2tKoXoYeuGqQ7jitm2+Z7fuLNWbSbD0zbxMHHkgRxBpAZBmqRcaY/6n2WWvtqVGoF0CCCQQC2rFjR3C9VatWdd0cACngcGl5cNint1Zs8y1z41c660dnugk1fWbUBJAwiDUA1Ka0NKM7TuuuXu2a6NvPLFZRSfmXypSUB/TDF5Zq2eZ9+sW5vZSZzjWlQDIj1gBimKxwwzO65ILLW9RCXRX1MAM4gKC0tDTl5OQcWQeAaNp7qFTXT52vuRt2+5b56Vk9df1XOvNCAEmCWANANJzeu61evmWkbpi2QBt2FoUtM232p1q1bb/uu/JEtWxUjxcCSFLEGkBkxo3BXFuMMe9HI7lgrf1abdeZSowxuZLy3Xp+fr5yc91NAADgZ/u+wxo3ea4++Wx/2O0ZaUZ/Gd1PF53IdyoAAKj8hRDfenqR3l/1eW/xcNo3ra9JYwerb25TDisAIK4VFBQoLy+v4maetbYgrpIViE8kKwAAqDx3xePYR+aoYM+hsNvrZ6bp/qsG6WsntOawAgCAKikPWP3trVW6//11vmXqZaTpzxf30wUDO3B0AQAplaxgHBUAAADP0oK9Gn3/TN9ERU7DTD15/TASFQAAoFrS04x+eEYP3XPFQDXITA9bprgsoDueWazf/XuFysoDHGkAQMogWQEgYZSVlWnjxo3Bxa0DQG2avmanxjw4S7uKSsJub9e0vp6fOFwndmzGgQeSFLEGgFg5p197vXDTCOU2a+Bb5uHpGzT+0Xna4xObAEg8xBpAZCQrACSMQCCgwsLC4OLWAaC2vLZkiyZMmauikvKw27u2bhQ8odC1dWMOOpDEiDUAxFKv9k306q2jNKJLC98y09fu1Hn3TtfKrfti2jYA0UGsAcRpssIYk26MaWmMyTPGdIy01FUbAcSXtLQ0tWrVKri4dQCoDY/N3Kjbn16k0vLw83gN7Jij524crvY5/lc+AkgOxBoAYq15dpamXjNU14463rdM/u5Duui+mfrP0q0xbRuA2kesAcTRBNsuOSHpNkkXuIsIKpkssdbajBg0L2kxwTYAAF/mYqC73l6tu/+31vfwfPWEVrrvyhPVMItQBAAARNcLCwr045eWqqTMvxf5LV/rou9844Tg3BcAACTbBNsx++VtjBkh6UVJrdzNWO0XAADgaOUBq5+9vExPzd3ke3AuGthBfx7dT5np9OQCAADRd/GgXHVr00g3TlugrXsPhy1z73vrtHLrfv1jzAA1qZ/JywIASCox+fVtjHEDML4iqbWkIkn/kPQrb7Pr2nGtpO9JelrSIe++6ZImSLomFm0EAACp4XBpuW5+YkHERMUNX+msv13Sn0QFAACIqX65OcF5LIZ0auZb5n+fbNcF98zQ2u0HYto2AACiLVaXCt4qySUsiiUNt9Z+x/VwrNhorX3UWnuXtfYKSV0kfSBppBsqylr7WIzaCCDOlZaWas2aNcHFrQNAVe07XKqrJ8/Vm8u3+Zb5yVk99JOzeiqN4RWAlEOsASAetGpcT09cN0xXDfOfwnP9ziJdcO8MvbPCP6YBEH+INYD4SFac6fWWmGytXR6poLX2M0lnS1rnelsYY74eozYCSIDx5YuKioJLLOfbAZActu87rMsmzdacDbvDbndjP995SX/d8BV33QSAVESsASBeZGWk6XcX9NUfL+qrzPTwI2kfKC7TdVPn61/vrlEgwO8jIBEQawDxkazo6v19J+S+I9+kxpj00MLWWjcU1N+9uS0mxqiNAOJcenq62rdvH1zcOgBU1oadRbr4gZlauXVf2O31M9P00LhBwbGiAaQuYg0A8ebyoR319A3Dgr0t/Nz19mrd/MTCYPICQHwj1gDiI1nRxPv7ach9obNFNQ7zmPne35Oi2C4ACfal3rp16+BCsgJAZS0t2KvR989U/m53LcSXNW2QGRxq4es92nBQgRRHrAEgHg06rrleu3WU+ufl+JZ5Y/lnuui+Gfp0l5smFEC8ItYA4iNZUTHrU0bIfaFjMHQK85j63l83KTcAAECVzVi7U2MenKVdRSVht7drWl/PTxyuQcf5T2IJAABQ19o2ra9nbhim0RF6ga7edkDn3j1dH67eEdO2AQCQaMmKtd7fI7NDWWsLJbn5KZyvhXnMCO8vlwUAAIAqe/3jrZrw6DwVlZSH3d6lVbZeuGmEurUJ18ETAAAgvtTPTNdfR/fTr87tFZxrK5x9h8s0/tG5evDDdczzBwBIOLFKVszx/g456v43vHkpfmCM6V5xpzFmqLvPm9diXozaCCDOlZaWavny5cHFrQOAn2mzNurWpxaqpDwQdvuAvBw9P3GE2uc04CACINYAkDCMMRo/8ng9fu1Jap6dFbaMm2v7D//5RN96erEO+Vy0AaBucF4DiI9kxZteUuKio+6/S1KZN9TTMmPMPGPMcjdqg6SK8Rj+GaM2Aohz1trgF7tb3DoAhPuccJNM/vyV5fL7mPjqCa305PUnqZnPD3wAqYtYA0CiGN6lhV69daR6tauYIvTLXl2yRaMfmKmCPQdj2jYA/og1gPhJVkyVNNsYc3zFndbaZZJuklTuzWcxSFJPN9+MV+RX1lrX+wIAlJGRoU6dOgUXtw4AocoDVj99eZn+9e4a3wNz4cAOemjcYDXM4jMEwJcRawBIJLnNGgaHtDyvf3vfMsu37NN598zQrHW7Yto2AOERawCRmXi4OtkYc4Kk8ZJ6e0kLd5ZhmrV2fl23LRkYY9wMXPluPT8/X7m5/hNyAQCQiA6XluuOpxfrjeUV02F92XWjjtdPzuqpNJ8xngEAABKRO6/z4Ifr9ec3PgkOARWOm+PiF+f00rjhxwWHkgIAoKYKCgqUl5dXcTPPWluQFMkKRBfJCgBAMtt3uFQ3TJ2v2et3+5b58Zk9dOMpXWLaLgAAgFj6YPUO3fbkwuAk234uGZSr317QJzhZNwAA8ZasiNUwUAAAALVu+/7DumzSbN9EhbuK8K+j+5GoAAAASe+U7q306q2j1L1NI98yzy0o0JgHZ+uzvYdj2jYAACqDZAWAhFFSUqLFixcHF7cOILVt3Fmk0ffP0sqt+8Jur5+ZpgfHDtIlg49c6QEAERFrAEh0nVpm68WbR+qbvdv4llmcX6hz75muBZ/690oFEB3EGkBkdTK7pDGmsSQ30bb7e8y+h9baD2PTMgAAkAiWbd6r8Y/O1c4D4ROXTRtkavL4wRp0XPOYtw0AAKAuNaqXofuvHKR731urO99eHbbMjv3FwR4Wvzm/jy4f2jHmbQQAoM7nrDDGXC/pZkn9qvAwa62tk6RKsmDOCiSLQCCgQ4cOBdcbNGigtDQ6hwGpaObanbph2gIdKA4/HnPbJvU19dqh6t7GXRMBAJVHrAEg2byzYpvueGaxb9zkXDWso35xTm9lZfD7Cog2Yg0kk4JEnWDbGON6T7wg6dyKu6qYrGDmp5od/1xJ+W49Pz9fubnuJgAAiec/S7fqjqcXq6Q8EHZ751bZmnbtSeqQ0yDmbQMAAIhHa7cf0A1T52v9ziLfMkM6NdN9Vw5Sq8b1Yto2AEDiKkjgZMUtku72bm6T9KikBZLcAInhzzaEsNZ+EPVGJjGSFQCAZDBt9qf6xSvL5Be69M/L0aPjh6h5dlasmwYAABDX9h4q1R1PL9J7q3b4lmnXtL4mjR2kfrk5MW0bACAxFSRwsmKOS9RLWiHpZGvtnqjvFKHHn54VSAru86q0tDS4npmZ6d7bdd0kADH63//HO2v0z3fX+Jb5SvdWeuCqE9Uwi5EjAdTs84ZYA0CyKg9Y/f3t1brnvbW+ZdxQUH+6qK8uOpERGYBoINZAMimIQrIiVgMS9nT/j5J+S6ICQHW5kwcrVqwILhUnEgAk/4/qn728LGKi4oIB7fXwuMEkKgDUGLEGgGSWnmb0vW+eoPuuPFENMsOPtl1SFtB3nl2i3/57hcp8ht0EUH3EGkBksZ49aVWM9wcAABLU4dJy3frkQj0xZ5NvmWtHHa+7Lh3AhJAAAACVdFbfdnrx5hHKa+4/x9cj0zdo3OS52lNUwnEFAMRMrIaBcvNTDJD0DWvt/6K+Qxx9/BkGCkmB7pJA6th/uFTXT52v2evd9Fbh/fCMHpp4SmeGhANQa4g1AKQSl4i49amFmrF2l2+Z3GYN9ODYwerVvklM2wYkK2INJJOCBB4G6ml3zlzSOTHaH4Ak5OaoyMrKCi7MVwEkr+37D+uySbN9ExVuCIO/jO6nm77ahc8CALWKWANAKmmWnaXHJgzV9Scf71umYM8hXXz/TP374y0xbRuQrIg1gPhIVvxL0seSbjLGnByjfQIAgATz6a4ijb5/llZs3Rd2e72MNE26apAuHXzk6g0AAABUU0Z6mn56di/9/bL+wTgrnEPBoTkX6S9vfBKcTwwAgIROVlhriyWdLskNB/W2MeYvxpgBxpj6sdg/gOQQCARUVFQUXNw6gOSybPNeXXz/LG3afTDs9ib1M/TEdSfptF5tYt42AKmBWANAqrpwYK6enzhC7Zv6n6a57/11uvaxedp7qDSmbQOSCbEGEAfJCmNMuaStkoZLypL0XS9xUeS2HWMpi0UbAcS/srIyrVmzJri4dQDJY+a6nRrz4GztPOCub/iyNk3q6bmJIzS4U/OYtw1A6iDWAJDK+uY21au3jdLQCPHW+6t26IJ7Z2jt9v0xbRuQLIg1gPgYBsqELEffrswCAACS1H+XbtX4yfN0oDh8ErJzq2y9cNMIndC2cczbBgAAkEpaNqqnx687SeOGH+dbZsPOIl1w70y9tfyzmLYNAJD8jJuFPuo7MeaXNXm8tfbXtdea1GOMyZWU79bz8/OVm+tuAgBQ9x6f/al+/soy+YUj/XOb6tEJQ9U823XMBAAAQKw8PXdTME4rLfc/b/Tt07rrtq93VVoa15kCQKopKChQXt6R+STzrLUFNa0zQzFAsgEAABwVG+if767RP95Z43tgTu7WUg9cNUjZ9WISrgAAACDEmKEd1a1NY930+AJt3x9+qM6/v7Nay7fs1V2XDVAjYjYAQIIMAwUAABBUHrD6xSvLIyYqzuvfXo9cPYREBQAAQB0adFwzvXbbKA3Iy/Et89aKbbrw3hnauLMopm0DACQfkhUAEkYgEFBhYWFwcesAEk9xWblue2qhps3+1LfMhJGd9I/LBigrgzAFQGwRawDAl7VpUl/P3DhMlw72H1J6zfYDOu+e6Xp/1XYOIUCsAVQbZwEAJIyysjJt3LgxuLh1AIll/+FSTXh0nv6z1H8yxh+ccYJ+cU4vxj0GUCeINQAgvHoZ6frzxf30m/N7K8Nnfop9h8s0Yco83f/+uuCQnwCINYCqiskg0MaYX1TjYe6b7bCkvS5JL2mBtXZfFJoHIEEYY5SZmXlkHUDi2LG/WOMfnavlW8J/lbvfvH+6qJ8uHXJkci4AiDliDQCI/Bk5bngndW/TWDc/sVC7i0q+VMblKP78xifBeSz+MrqfGmYx9xhArAFUnolFttsY48ZrqemOSiW9Iumn1tq1qkXGmI6Sbpd0tiS37maOcvt4VtJ91tqDtbk/b5/tJK2U1NS76wNr7Vdrez/evlxfzXy3np+fr9xc/66bAADUtk27Dmrs5Dn6dFf4r9N6GWm654oT9Y1ebTj4AAAACWBz4SHdMHW+74UoTs92TfTg2EHKa94wpm0DAMRGQUGB8vKOXHCYZ60tSKRhoNxl0Oaodb8lXJksSaMlLTbGnFprjTLGJSg+lvRdST0kuW/RZpKGSPqrpIXGmM6qfXeHJCoAAEhK7qq6ix+Y6ZuoaFw/Q9OuPYlEBQAAQALpkNNAz08cofMHtPcts3LrvuA8FjPX7oxp2wAAiSsmyQprrdtPJ0mzvcTDS5IudBkXSfXdRZXeurvvZa/MHEldvMTByZLud3PeecmE540xLWraLmNMf6/3hEsaHHC9NiSNkOSSIQ95xU6Q9LoxplHNj8SR/Z4r6WJJzDwFAEhas9bt0phJs4NDQIXTunE9PTdxuIYe3zzmbQMAAEDNNMhK1z8uG6CfntUzOKRnOHsOlmrs5LmaPH0D81gAAOIjWWGMaSzpLUmDJV1irb3YWvuKtXaztbbEWlvqrbv7LnJlvLLuMe4LbYa19hZJ50gql9REkrtdU//wkh9upt7TrbV/sNbOstb+z1p7g5vn0yvnelx8p5aOhUt63Ovd/F5t1AmkivLycm3fvj24uHUA8euNZVt19aNztb/YfcV+WeeW2XrhphHq0dZ9pQNAfCDWAICqz2Nx/Vc667Frhqppg8zwn60Bq9/8e4W+99zHOlzK7zikNmINID6GgbpDUnfXO8Ja+8KxCntl7vd6Vnw35P43JT3h9bw4syYNMsa4YZ4q5oh4xCUpwhS705tXIvgcjDHhv3mr5g9eL5L3rLXTaqE+IKW+1Lds2RJcSFYA8evJOZuCky6WlLkOkV/WL7dpsEcF4xcDiDfEGgBQPSd3a6VXbx2pE9q4a1XDe2FhgS6bNEtb9x7iMCNlEWsA8ZGsuMSbYNsN/1RZL3p/XU+LUG6SbadrDdt0Qcj6o+EKWGvdWZap3k03HFWNJsA2xgz1eoSUSLqpJnUBqXrVTnZ2dnBx6wDii7VW/3p3jX7y0lIF3Ld+GCd3a6mnrh+mFo3cCJAAEF+INQCg+o5rka0Xbx6hM/u09S2zpGCvzr17huZv3M2hRkoi1gDiI1lxvPd3XxUeU1H2uKPu/9T7W9NxI9w8GE6RpAURyn0Qsj6qujszxmRIetA75n+21q6qbl1AqsrMzFS3bt2Ci1sHED9c9/5fvrpcd7292rfMef3b65Grhyi7nvtKBID4Q6wBADXj4rz7rjxR3zu9u/yuL9t5oFiXPzRbT8ypOL0DpA5iDSCyWJ0tKPX+9pW0sJKP6XvUY49OsBTWsE09vb9rrbXhB9T+3CdhHlMdbn4KN6H3Om8oqFpjjMk9RpEjlzWUlJQoEAgoLS3tyFWwpaWlRz4wK65Wd2XKyj4/LFlZWUcqqrjflQs9Wey6sbnl6Ptd2Yr9ZWRkHPN+1xbXpvT09OBy9P2ubEXbK56PE3o/z4nXifce/098RsT2s7w0IP3gxWV6/eOtvl9E40d00o+/2U0KuMfwWc53LnEEsRHxHjEsvzX4/cRvwmT+nXvzV7uoZ7smuuPpxWHnMCstt/rpS8u0NH+PfnZWD2U3qBf3zykZXyeeE68T7z3+n2wNPyMSNVmx1OvJ8D1jzDPW2sORChtjGkj6vjd0lHtsKDePhbOjuo0xxtSX1NK7WRCprLV2jzHG9b7I9uaaqM7+Okv6hXfz5mM9/2rIr2zBNWvWqE2bNsFhdCrefCtWrAiu9+rV68iX5qFDh4JlnQEDBhx5/L59+7Rx48bgl2Xv3r2P3L9r167gPAKuXnfVe4Vt27Zpx44dysnJUadOnY7cX1BQoMLCQrVq1UodOnQ4cr+ru6ioSO3bt1fr1q2P3L969epgW10drq4KFW13++Q58Trx3uP/ic+I2H+Wb92xW3fO2a/5BQd8v3u+/80Tgj9Y3Wc2n+V85xJHEBsR7xHD8luD30/8JkyN37mn9myjl24ZqRumzdf6He60ypc9PX+zlmzcoYcnDFOHFo3j/jkl4+vEc+J14r3H/1P7GnxGJOowUJO9v70k/c8Y8/+fwEcxxvRxZbyyziNHFTnNS2J8XIP2hM745H925f9VfKs2qub+JklyCRiXqHmrmnUAKc9ldQ8cOKDNmzcfuSoFQN3Zc6hMP/3fTt9ERZqR/nRRX93yta7MMwMgIbj4wsUZu3fvDsYdAICa6dq6kV6+ZaQGt3fXjIa3cmeJLpo0R0vyazqABhD/XHzh4gzOawDhmVgF4caY1ySd7SUanMXeXBHbvdsufTPYGyop+BBJr1lrzw+po6k3Z4Wbr+Jqa+20arbF9ZDY5N2cZq0dd4zyrqx7zDprbZUm9jbGuLof8+bg6GGt/cIYGcaYiuPxgbX2q1EcBmqeW1m3bl0wK0YXRbpdJmJXUnc1yqpVq4J1VFylQvfY+Hud6MacGP9PNX2d8ncf1FWPzNGnuw4qnKyMNP3zsv46s2/7hHlOyfg68Zx4nXjvVe3/yf3vuivGXPkTTjhB9erV4/+Jzz0+y/l+4ju3FmKjw4eL9a/31um+DzbIj4sf/3BhX100sD2xEfFe0sblxcXFXzqvkejPKRlfJ55TaaVeJ9erKy/vyEBEedbaiCMYxVuywr0b7pF0nZeI8NtxxbaHJN1mrT0yZ4UxpoUk1/PCmW+tLapmW1qFJElcb4cxxyi/zUumLLPW9q3CftxQUyu9Iafcc7knTJkaJysqmcwIDhWVn5+v3Nxj5TaA+OS+MNwHoePex6FfJgBiZ8WWfbr60bnasb847PbG9TP08LjBOqmz+9oGgMRBrAEA0fXfpVv13eeW6GBJuW+ZCSM76Sdn9VRmeqwGAwFih1gDyaQgCsmKmJ3p85IONxpjHpB0g6RTXY/Ao4q5yafflfSgtfZLE3Fba3e5k/q10Jz9IeuVGdopuwpDRoW6y0tUzJd0XxUfC+AoLjkROi4ngNibvX6Xrn9sftiJEp3WjevpsWuGBidUBIBEQ6wBANF1Zt92Or5Vtm6YukCbdofvofvojI36ZOt+3XvliWqe/f9XTQPJgFgDiCzmlyVbaxdJusmtG2PqSaqYpaPQWlscozYcNsbs9BIJEbsZGGOahSQrKj2RtTHGjXsx1rvp5uC4tKK7ko/WxpiKHh4brLVzKrsvAABi4Y1ln+n2pxeppCwQdvvxLbM19ZqhymvekBcEAAAAYfVo20Sv3jpStz21SB+tcadmvmzW+l069+7penDcIPVu70YEBwCkgjodQ8VLTrghluqCG57pZNe7wxiTYa31m623x1GPqazQ9P8PKlG+p6SnvHU3xwXJCgBA3Hhq7ib99KWlCvgM4ti3Q1M9OmGIWjZy1yEAAAAA/nIaZunR8UP0lzdX6cEP14cts7nwkC6+f6b+Mrq/zuv///OgAQCSVyoPADjd++t6TQyKUO6UkPUZUW4TgGOM7bhx48bgUjGZEoDocnNb3f3uGv34Rf9ExaiuLfXUDcNIVABIeMQaABA7Gelpwbkp/nHZANXLCH966nBpQLc/tUh//O9KlfsFo0ACIdYAIkvlZMXLIesTwhUwxrjjM867WSjpvcpWbq3daK01x1pCHvJByP3jq/2sgCQWCARUWFgYXNw6gGj/z1n96tXluvPt1b5lzunXTpPHD1Gjekx4DyDxEWsAQOxdMLCDXrhphNo3re9bZtIH6zVhyjztPeimQwUSF7EGEFmtnlkwxri5GRxrrT01zP3V8YW6aou1dq4x5iNvKKhrjTGPWWtnHVXsu97wTM4/vUnCjzDGuKTCo97NX1trf1Xb7QTw/9LS0tSqVasj6wCip7isXN99don+/fFW3zLjR3TSL87ppbS0iHMyAUDCINYAgLrRp0NTvXrbKN38xELN3bA7bJkPV+/Q+fe6eSwGq3ubxjFvI1AbiDWAyNxV/KotxphASIIh/aj73Y6qcjajovwX6qpNxpiB3tBODSQdkPQHr/eEu+0mu77BK+ouKR1srd1f28kKY4wN6Vnx1Ro/qfD7yK2YHDw/P1+5uRHnFAcApLgDxWWaOG2Bpq8NP+Gh873Tu+uWr3V13zExbRsAAACSV2l5QL/79wo9NutT3zLZWem667IB+mbvtjFtGwDgiwoKCpSXl1dxM89aW6Aaqu0xGz70kgyVvb9OWWsXGWMuk/S4pCZesuJoLlFx9tGJCgAAktHOA8W6Zso8fVywN+x214ni9xf21eVDO8a8bQAAAEhumelp+vX5fdS7fVP97OVlKin/8vC/RSXlunHaAn3r1G7BhV6+AJA8ajVZ4dczIFo9BmqDtfY1Y0w/Sd9ySQlJrttBiaS1kp6TdI+19mBdtxMAgGjL331Q4ybP1YadRWG3Z2Wk6V9jBuqMPlzFBgAAgOi5dEieurZpFOztu31/cdgy/3x3jZZv2ae/X9Zfjetn8nIAQBKo1WGgEJ8YBgrJorS0VBs3bgyud+rUSZmZBKRAbVm5dZ+unjzX98dg43oZeujqwRrWuQUHHUDSItYAgPiyfd9hTXx8gRZuKvQt07V1Iz04dpA6t2oU07YB1UGsgWRSEIVhoJihFkDCcMnVoqKi4EKiFag9c9bv0qWTZvkmKlo1rqdnbhxOogJA0iPWAID40rpJfT11wzCNGXLkZNiXrN1+QOffO0PvfbI9pm0DqoNYA0iQZIUxpoUxplldtwNA/EpPT1f79u2Di1sHUHNvLv9MYyfP1f7DZWG3d2rRUC/eNEK92rupnQAguRFrAED8qZeRrj9e1Fe/vaCPMtwEamG4WPaax+bpvvfXcmEb4hqxBhDHw0AZY9pI+q2kiyRVJCr2SXpF0i+stZvqrHFJhGGgAADhPD13k37y0lIFfEKBvh2a6tEJQ9SyUT0OIAAAAOKiR/DNTyzUriI31Wh4Z/drp7+O7qeGWbU6TSsAIBGHgTLGtDXGbPGWmyKU6yxpgaRrJTV3d3lLU0ljJS0yxgyo7fYBAJDq3IUK9763Vj960T9RMbJri2CXexIVAAAAiBcndW6h124bFbyoxs/rH2/VRffNVP7ugzFtGwAgPoeBOkVSWy8B8WyEck9Lau8lKJx8lyR3vfe8+1xPi6eMMaTCAQCoJYGA1a9fW6G/vrkq4tVok8cPUaN6fAUDAAAgvrTPaaDnJg7XhQM7+Jb55LP9Ovee6ZqxdmdM2wYAiL9kxVe9v+9Za3eFK2CMOUfSYHdxp6Tdks6w1h5nrR3uJToe9Yp2l3RxFNoIIAGVlpZq+fLlwcWtA6iakrKAvvXMYk2ZudG3zNXDj9PdYwYGxwYGgFRDrAEAiaF+ZrruurS/fnZ2T/lMY6HCg6UaN3muHpm+gXksEDeINYDYJyv6e0mItyOUuTJk/bvW2rcqblhrD0m6TtJS767zo9BGAAk6dI37YndLXc63AySiA8VluvaxeXptyRbfMt/5Rnf96rzeSvP7xQcASY5YAwAShzFG153cWVOvOUk5DTPDlikPWP323yv03eeW6HBpeczbCByNWAOIfbLCTZrtLKlE74u9kp48eqP9/CzkZG84KJf8AABlZGSoU6dOwcWtA6icXQeKdcVDs/XRmvDd4F1u4g8X9tXtp3YL/ugDgFRFrAEAiWdUt5Z69ZZR6tG2sW+ZFxdu1qWTZmlLobs+Fqg7xBpA7JMVrb2/OyNMrO0SGi4h8ZG11m8sl0XeXzevBQAoLS1NOTk5wcWtAzg2N7HgJQ/M0scF7vqAL8vKSNN9V56oK07qyOEEkPKINQAgMXVs0VAv3jxCZ/dt51vGxcPn3TNdcze40ciBukGsAUQWjbN9FZc7Z/lsPylkfUGEegq9v9m11C4AAFLKJ5/t08X3z9T6nUVhtzeul6HHJgzVGX38f9QBAAAAiaBhVobuuWKgvv/NE+TXWXjngZJgj+PHZ3/K0MIAkCLJip0hk2OH4ybRrjA/Qj0V/fcO11K7AABIGe6KMdejYvv+4rDbWzaqp6dvHKbhXVrEvG0AAABANLghTW/5Wlc9cvXg4IU54ZQFrH728jL95KWlKi5jHgsASPZkRcVcFRcfvcF8PhD2ud7NgKQZEeo5zvu7rfabCCARlZSUaPHixcHFrQMI7+0V2zT2kTnaf7gs7PbjXDf5m0aod/umHEIAINYAgKTz9R5t9PKtI9Wllf9gHU/NzdcVD83R9n1cI4vY4bwGEPtkxSvexNjnG2PGHbXt+14Sws1X8a61NvwA2l/sgbEqCm0EACApPTNvk26cNl/FZe6agC/r3b6Jnp84IjiuLwAAAJCsurRqpJdvGanTelZMrfplCz7do3Pvma5Fm/bEtG0AgPCMtS5vUHuMMe7sx3I3v1HIUE9rJfWU1N9LZLidnmmtfcunDldmkze59i+ttb+r1UamGGNMrptj1a3n5+crN9fdBBJPIBDQoUOHgusNGjRgkm0ghPs+v+/9dfrrm/45/hFdWmjS2EFqXD+TYwcAxBoAkBICAat/vLtG/3p3jW+ZrPQ0/e7CPrp0cF5M24bUw3kNJJOCggLl5R353Myz1hbUtM7wA/jVgLX2oDHmMkkuEdFE0mBvcSqmOJrsl6jwnCWpg5fUeKe22wggMaWlpSk7278bL5DKP8B++/oKPTpjo2+Zs/u2012X9Ve9jPSYtg0AEgmxBgAkn7Q0o+98o7t6tWui7z67WEUlX56noqQ8oB88/7FWbNmnn57dU5np0RiIBCDWAI4lKp++1tq5kgZJek7SIS9J4ZZPJX1P0g3HqOLn3t/PrLWzo9FGAACSQUlZQN9+dnHERMXYYcfpX5cPJFEBAACAlHVGn7Z66ZaRwfnb/EyZuTE499uuA8UxbRsAIErDQB3NGOMSIq3c+RRrbaUGATTGVFw6XWat5Rui5q8Bw0AhKbjPq9LS0uB6Zmame2/XdZOAOlVUXKaJjy/QR2t2+pb59mnddfupXfl/AYBKINYAgOS392Cpbnt6kT5cvcO3TIecBsHhU/t0aBrTtiH5EWsgmRREYRioqPdrs9YGrLXbKpuo8B5T5C0kKgAc4RIVK1asCC4VSQsgVbmrva54aLZvosLl8n53QR9967RuJCoAoJKINQAg+TVtmKlHxw/Rjad09i2zufCQRj8wU68s3hzTtiH5EWsAkTEIHwAACaZgz0Fd8sAsLSnY6ztB4H1XnKirhh0X87YBAAAA8S49zejHZ/YMDpVaPzP8qbHDpQF96+nF+uN/Vqo8EN1RSQAAMRoGCnWPYaCQLOguCUirPtuvcZPnaNu+8J0PG9XL0IPjBmlEl5YcLgAg1gAAHMOyzXt147QFwd4Ufk7u1lJ3Xz5QOQ2zOJ6oEc5rIJkUJOIwUABQW9wcFVlZWcGF+SqQiuZt3K1LHpjpm6ho2aienr5hGIkKAKgmYg0ASD1uXopXbx2pYZ2b+5ZxQ6+ef++M4IVDQE0QawCRkawAACABvLNim656eI72HS4Lu/24Fg31wk3DmQQQAAAAqKIWjepp2rUnafyITr5lPt11UBfeN0NvLNvK8QWAKCFZASBhBAIBFRUVBRe3DqSKZ+fn68bHF6i4LPz7vnf7Jnp+4ggd1yI75m0DgGRCrAEAqSszPU2/Oq+3/jq6n7Iywp8uO1hSromPL9Rdb61SgHksUA3EGkBkJCsAJIyysjKtWbMmuLh1IBXGM73//XX6wfMf+07qN7xzi+DQT60a14t5+wAg2RBrAAAuGZynZ28crjZN/OPrf/1vrW6YNl/7D5dywECsAdQikhUAAMQhd6XW715fqT+/8YlvmTP7tNWjE4aocf3MmLYNAAAASGYD8nL02m2jNOi4Zr5l3lm5XRfcO0PrdhyIadsAIJkZd9UmkpsxJldSvlvPz89Xbq67CQCIVyVlAf3g+SV6efEW3zJXntRRvzm/j9LTTEzbBgAAAKSK4rJy/erV5XpqbvCUSliN62Xon5cP0Nd7tIlp2wCgrhUUFCgvL6/iZp61tqCmddKzAgCAOFJUXKbrps6PmKi447Ru+t0FJCoAAACAaKqXka4/XtRPv7+wjzJ8LhLaX1ymax+br3vfWxscxhUAUH0kKwAAiBO7i0p0xcNz9OHqHWG3GyP99oI+uuO07q7XXMzbBwAAAKSiK086Tk/dMEwtG2WF3e5yFH99c5VueXJh8OIjAED1kKwAkDACgYAKCwuDi1sHkknBnoMa/cBMLckvDLs9Kz1N915xosYOOy7mbQOAVEGsAQDwM6RTc7166yj1y23qW+Y/Sz/TxffP1KZdBzmQINYAqoFkBYCEUVZWpo0bNwYXtw4ki9Xb9mv0/bO0fkdR2O2N6mVoyoQhOqtvu5i3DQBSCbEGACCS9jkN9OyNw3XRwA6+ZT75bL/OvWe6pq/ZycEEsQZQRSQrACQMN+xNZmZmcGEIHCSL+Rt3a/T9M/XZvsNht7uu5k/fMEwjuraMedsAINUQawAAjqV+ZrruvLS/fnFOL6X7zGOx91Cpxk2eo4c/Ws88FiDWAKrAMPlP8jPG5ErKd+v5+fnKzXU3AQB17d2V23TzEwtVXBZ+WLOOzRtq6jVD1alldszbBgAAACCyGWt3BuepKDxY6lvmwoEd9MeL+gaTHACQTAoKCpSXl1dxM89aW1DTOulZAQBAHXhufr5umLbAN1HRq10TPX/TcBIVAAAAQJwa2bWlXrt1lHq0bexb5qVFm4Nz020uPBTTtgFAIiJZAQBADLkejQ98sE7ff/5jlQds2DLDOjfX0zcOU+vG9XltAAAAgDiW17yhXrx5hM7u5z+/3LLN+3Te3dM1Z/2umLYNABINyQoACaO8vFzbt28PLm4dSDSBgNXvX1+pP/33E98yZ/RuqykThqpJ/cyYtg0AQKwBAKiehlkZuufygfrhGT1kwk9joV1FJbry4TmaNmsj81ikMM5rAJGRrACQUF/qW7ZsCS4kK5BoSssD+u5zS/Tw9A2+Za44qaPuvfJExrMFgDpCrAEAqC5jjG76ahdNHj9EjetnhC1TFrD6+SvL9aMXlqq4jAvwUhGxBhAZyQoACRX8ZWdnBxe3DiSKgyVluu6x+cHxav3cfmo3/f6CPkpP470NAHWFWAMAUFNfO6G1Xr11lLq2buRb5pn5+Rrz4Gxt23eYA55iiDWAyIwbOxvJzRiTKynfrefn5ys3190EAMTCnqISTZgyT4vzC8Nud3m335zXW2OHd+IFAQAAAJLE/sOl+s6zS/T2im2+ZVo3rqcHxg7SiR2bxbRtAFAbCgoKlJeXV3Ezz1pbUNM66VkBAECUbC48pNEPzPRNVGSlp+mey08kUQEAAAAkmcb1MzXpqkG647RuvmW27y/WmEmz9ey84PWlAJDySFYAABAFq7ft1+j7Z2rdjqKw27Oz0jVlwhCd3a8dxx8AAABIQmlpRnec1l2Txg4Kxv/hlJQH9IMXPtYvXlkWnOcOAFIZyQoACaOsrEybN28OLm4diFcLPt2tSx6Ypa17w49B27JRlp65cbhGdG0Z87YBAPwRawAAouGbvdvq5VtGqlOLhr5lps76VFc+PEc7DxTzIiQxYg0gMpIVABJGIBDQjh07gotbB+LR/z7ZFvyRsfdQadjtec0b6PmJI9SnQ9OYtw0AEBmxBgAgWrq1aaxXbhmlU7q38i0zd8NunXf3dC0t2MsLkaSINYDISFYASBhpaWnKyckJLm4diDcvLCjQ9VMX6HBp+GRaz3ZN9MLEEerUMjvmbQMAHBuxBgAgmpo2zNTk8UM08ZQuvmW27D0cnPfu5UWbeTGSELEGEJmx1h6jCBKdMSZXUnC2pvz8fOXmupsAgNo06YN1+uN/P/HdftLxzfXQ1YPVpH4mBx4AAABIca8t2aLvP7/E90In5/qTj9cPz+ihjHQu1gMQfwoKCpSXl1dxM89aW1DTOvm0AwCgBgIBq9+/viJiouKbvdvosWuGkqgAAAAAEHRu//Z68aaR6pDTwPeIPPTRBk2YMk+FB0s4agBSAskKAACqqbQ8oO89tyT4I8LP5UM76r4rB6l+ZjrHGQAAAMARvdo30Wu3jdLwzi18j8pHa3bqvHtm6JPP9nHkACQ9khUAEkZZWZk2btwYXNw6UJcOlpTphqnz9WKEsWRv/3pX/eHCPkpPMzFtGwCgeog1AACx1jw7S9OuHaoJIzv5ltm0+6Auum+m/rt0a0zbhtpHrAFERrICQMIIBAIqLCwMLm4dqCt7ikp05cNz9N6qHWG3GyP9+rze+s7pJ7h5g2LePgBA9RBrAADqgpuT4pfn9tbfLumvrIzwp+oOlpTrpicW6m9vrgoORYvERKwBRJZxjO0AEDfS0tLUqlWrI+tAXdhSeEjjJs/V2u0Hwm7PTDf6+2UDdE6/9jFvGwCgZog1AAB1afSgXHVr3Ug3Tlugz/YdDlvmnvfWasXWffrHmAHMiZeAiDWAyIy1ZGOTnTEmV1K+W8/Pz1durrsJAKiqNdv2BxMVW/eG/+GQnZWuSWMHa1S3lhxcAAAAANWyff9h3fz4Qs3/dI9vmc6tsvXg2MHq2roRRxlAnSgoKFBeXl7FzTxrbUFN6+TSZAAAKmHBp3t0yaRZvomKFtlZeuqGYSQqAAAAANRI68b19eT1w3TlSR19y6zfUaQL752hd1du42gDSBokKwAAOIb3PtmuKx+ercKDpWG35zZroOdvGqF+uTkcSwAAAAA15uau+P2FffWHC/sGh5oNZ39xma6bOl93v7uGeSwAJAWSFQASRmlpqdasWRNc3DoQCy8uLAj+ADhcGn5S9x5tG+uFm0bo+JbZvCAAkOCINQAA8eaKkzrqqeuHqWWjemG3u9Hd73x7tW5+YqGKisti3j5UDbEGEBnJCgAJw82xU1RUFFyYbwex8NCH6/WdZ5eoPBB+fqehxzfXMzcOV5sm9XlBACAJEGsAAOLR4E7N9e/bRql/blPfMm8s/0wX3TdTn+4qimnbUDXEGkBkJCsAJIz09HS1b98+uLh1IJoB5B//s1K//89K3zKn92qjqdcMVdMGmbwQAJAkiDUAAPGqbdP6wQulLj4x17fMqm37dd49M/TRmh0xbRsqj1gDiMxwdXLyM8a4b7J8t56fn6/cXP8vNgBIdaXlAf3ohaV6YWGBb5kxQ/L0uwv6KCOdnD8AAACA2HHn8abM3Kjfvb7Stwd4mpF+dGYPXX9yZ3dOiJcHQFQUFBQoLy+v4maetdb/REolcZYFAADPoZJy3ThtQcRExW1f76o/XtSXRAUAAACAmHPJhwkjj9e0a4eqWcPwvbxdDuMP//lEdzyzOPgbBwASBckKAAAkFR4s0ZUPz9b/Ptke9ni4C5J+dW4vfff0E7g6CQAAAECdGtGlpV69dZR6tWviW+aVxVs0+oGZKthzMKZtA4DqIlkBIGGUlpZq+fLlwcWtA7Vl695DuuSBWVq4qTDs9sx0o3+OGajxI4/noANAEiPWAAAkkrzmDfXCTSN0bv/2vmWWb9kXnMdi1rpdMW0bwiPWACIjWQEgocbmdF/sbmG+HdSWtdv36+L7ZmrN9gNhtzfMStfk8UN0XoQfAACA5ECsAQBINA2y0vWvMQOCc1T4TU+xu6hEVz0yR4/N3Mhv6TpGrAFElnGM7QAQNzIyMtSpU6cj60BNLdq0RxOmzFPhwfA9dZpnZ2nKhCHql5vDwQaAFECsAQBI1HksJp7SRT3aNtbtTy3SvsNlXyrjJuP+5avLtXzLXv3m/D6qn5leJ21NdcQaQGSGq5OTnzEmV1K+W8/Pz1durrsJAKntvVXbdfPjC3WoNPyEcx1yGgQnrevcqlHM2wYAAAAA1bFxZ5Gunzrft+e4MyAvR5PGDlKbJvU5yACqraCgQHl5eRU386y1BaohhoECAKSclxYV6PrH5vsmKtwVSS/ePIJEBQAAAICE0qlltl66ZaRO79XGt8zi/EKdc/d0Lfh0T0zbBgDHQrICAJBSHv5ovb79zBKVBWzY7UM7NdczNw7nKiMAAAAACalRvQw9cNUgffu07r5lduwv1pgHZ+npuZti2jYAiIRB3wEkjJKSEq1YsSK43qtXL2VlZdV1k5BA3LCHf3rjE036YL1vmW/0aqO7Lx/I+K0AkKKINQAAySItzehbp3VTr/ZN9O1nFutA8ZfnsSgtt/rRi0u1fMs+/fycXsrK4JrmaCPWACLjUwgAkPTKygP6/vMfR0xUXDY4T/dfeSKJCgAAAABJw12Q9fItI3R8y2zfMtNmf6qrHp4T7G0BAHWJCbZTABNsI1kEAgEdOnQouN6gQQOlpZFvxbEdKinXrU8u1LufbPctc8vXuuh7p5/gPi85pACQwog1AADJau+hUn3r6UV6f9UO3zLtmtbXg2MHq29u05i2LZUQayCZFDDBNoBU5pIT2dnZwYVEBSqj8GCJrnpkTsRExS/P7aXvf7MHiQoAALEGACBpNW2QqUeuHqKbv9rFt8zWvYc1+oGZemlRQUzblko4rwFExmXJAICktHXvIV06aZYWfLon7PbMdKN/jhmgCSOPj3nbAAAAACDW0tOMfnBGD91zxUA1yEwPW6a4LKBvP7NEv/v3iuBwugAQSyQrACTUBMluMiq3uHXAz9rtBzT6/llave1A2O0Ns9KDVxWdP6ADBxEAQKwBAEgp5/RrrxdvHqG85g18yzw8fYOufnSu9hSVxLRtyY7zGkBkJCsAJIzS0lKtWLEiuLh1IJxFm/bokgdmanPh5/ObHK15dpaevH6YvtK9FQcQAECsAQBIST3bNdGrt4zSyK4tfMvMWLtL5907XSu37otp25IZ5zWAyEhWAACSxvurtuuKh+Zoz8HwyawOOQ303MThGpCXE/O2AQAAAEA8aZadpccmDNV1o/yHxs3ffUgX3TdTr3+8NaZtA5CaDEOpJD9jTK77fnHr+fn5ys11N4HE4z6vKnpUZGZmMiEyvuDlRZv1veeWqCwQfoiwE9o01mPXDFXbpvU5cgAAYg0AAEK8uLBAP3pxqUrK/OepuOVrXfSdb5wQnPsC1cN5DSSTgoIC5eXlVdzMs9YW1LROelYASBjGGGVlZQUXtw5UeGT6Bt3xzGLfRMWQTs307I3DSVQAAIg1AAAI46ITc/X8xOFqF+HirnvfW6frHpunvYcYlrm6OK8BREayAgCQ0Fel/Om/n+i3/17hW+a0nm007dqT1LRhZkzbBgAAAACJpF9ujl69dVTwYi8/763aoQvunaG12/fHtG0AUgPJCgAJIxAIqKioKLi4daS2svKAfvD8x3rgg3W+ZS4dnKsHrjpR9TPTY9o2AEBiItYAAKS6Vo3r6YnrhmnssON8y2zYWaQL7p2pt1dsi2nbkgGxBhAZyQoACaOsrExr1qwJLm4dqetQSbkmPr5Azy3wHw7xpq920Z8v7qeMdL7qAACVQ6wBAICUlZGm317QR3+6qK8y08MPwXyguEzXT52vf76zRgGf4XhBrAFUFWdwAAAJZe/BUo19ZI7eWbndt8zPz+mlH57Rg7lNAAAAAKCaxgztqKdvGBbsbeHn7++s1k1PLAgmLwCgpowb7xvJzRiTKynfrefn5ys3190EgMTz2d7DunryXK3aFn581Iw0ozsv7a/zB3SIedsAAAAAIFl/h934+AItyS/0LdOtdSM9NG6wOrXMjmnbANSdgoIC5eXlVdzMs9b6D39RSfSsAAAkhHU7Duji+2f6JioaZqXrkfFDSFQAAAAAQC1q27S+nrlhmC4Z5H/x65rtB3TePdP1weodHHsA1UayAgAQ9xbnF2r0/TO1ufBQ2O3NGmbqyeuH6ZTurWLeNgAAAABIdvUz0/WX0f306/N6Kz0t/DwW+w6XacKjc/XAB+vESC4AqoNkBYCEEQgEVFhYGFzcOlLDh6t36IqHZmvPwdKw2zvkNNBzE0doQF5OzNsGAEguxBoAAPgzxujqEZ30+LUnqXl2VvjvUiv96b+f6PanF+tQSTmHk1gDqBKSFQASRllZmTZu3Bhc3DqS3yuLN+uaKfN00CfI7d6mkV64aYS6tm4U87YBAJIPsQYAAMc2vEsLvXrrSPVu38S3zGtLtgSH8c3ffZBDSqwBVBrJCgAJdRVHZmZmcHHrSG6Tp2/Qt55erDJ3aU4Yg49rpuduHBEcPxUAgNpArAEAQOXkNmuo5yeO0Hn92/uWWbF1n86/d4ZmrtvJYSXWACrFMIZc8jPGuBmQ8t16fn6+cnP9J0QCgLrmvpf++uYq3ff+Ot8yp/ZorXuuOFENstJj2jYAAAAAwBd/vz300frg0E8+15kF57j42dk9NX5EJy48BJJIQUGB8vLyKm7mWWsLalonPSsAAHGjrDygH77wccRExehBuZo0dhCJCgAAAACIg16JN3yli6ZMGKqmDTLDlikPWP36tRX6/vMf63Ap81gA8EeyAgAQF1zQOvHxhXp2vn8ifuIpXfTX0f2Ukc7XFwAAAADEi690bxWcx8LNK+jn+QUFuuzB2fps7+GYtg1A4uBsD4CEUV5eru3btwcXt47ksfdgqcY+MkfvrNzmW8Z1G/7RmT3oNgwAiBpiDQAAqu+4Ftl68eaROqN3W98yS/ILdc7d0zV/4+6UPNTEGkBkJCsAJNSX+pYtW4ILyYrksW3fYV06aZbmbdwTdntGmtHfL+uv607uHPO2AQBSC7EGAAA106hehu678kR99xvdZUz4MjsPFOvyh2bryTmbUu5wE2sAkZGs+Hx8vY7GmL8ZY1YaY4qMMbuNMXONMd8zxjRUDRhjmhhjxhhjHjLGLDTGFBpjSowxO4wx73v7yKnJPoBUGgszOzs7uLh1JL71Ow7oovtmatW2/WG3N8hM18NXD9aFA3Nj3jYAQOoh1gAAoObS0oxuO7WbHho7OJi8CKe03OonLy3VT19aqpKyQMocdmINIDJjrVUqM8acLekJSU19iqySdJa1dn016j5T0kuS6h2jqBv35HJr7XtV3Ucl2+HO8uW79fz8fOXmctIPQN1z3X8nTJmn3UUlYbc3a5ipyeOHaGDHZjFvGwAAAACg5tZuP6Abps7X+p1FvmUGH9dM9111olo3rs8hBxJIQUGB8vLyKm7mWWv9JyGtpJTuWWGM6S/pWS9RcUDSTyWNkHSqpIe8YidIet0Y4z9DkL8WXqLCpYjflPRtSV+XdKKk8yQ945VrI+nfxpgBtfj0ACBufbRmR7Dbr1+ion3T+npu4ggSFQAAAACQwLq2bqSXbx2pr/do7Vtm/qd7dN7dM4IXtAFIbSmdrJD0D0lumKcySadba/9grZ1lrf2ftfYGST/wyvWQ9J1q1F8qaZKk4621Z1hr/+F6T1hrF1lrX7PWjpF0u1fWtePOWnxuABCXXlm8WddMmaeDJeEnSe/WupFeuHlEMKgFAAAAACS2JvUz9fC4wbr1a119y3y277AumTRLLyyo8YXZABJYyg4DZYwZImmud3OStXZimDIumbNMUk9JbubXNtba0ii0ZZ7r9eb1wGhtrd1Vy/UzDBSSQllZmbZtc6OmSW3atFFGRvixLxG/Hp2xQb9+bYXv9kHHNdMjVw9WTsOsmLYLAACHWAMAgOj6z9Kt+t5zS3wvXnMmjOykn57VUxnpyXeNNbEGkkkBw0DVqgtC1h8NV8Ba65IHU72bbtD0ryo63vf+uk/h46O0DyDhBQIB7dixI7i4dSQOlxj/65ufRExUuG7Bj197EokKAECdIdYAACC6zurbTi/ePEJ5zRv4lnl0xkaNmzzXd9jgREasAUSWfCnKyjvZ++tm+FkQodwHIeujotSW0Am4OQML+EhLS1NOTk5wcetIDGXlAf34xaW69711vmUuPjFXk8YOUoOs9Ji2DQCAUMQaAABEX4+2TfTaraM0qmtL3zIz1+3SefdM14ot+5LqJSHWACJL5WGgdkhyn4pLrLW+E1sbY1yPit3ezeestZdGoS1LJPXz5s5oYa3dV41hniJpK8kNNaV169apU6dOR070ute/tPTzka0yMzNdXUcyva5rmpOV9f/DsVTc78q58hXKy8uDy9H3u7LuMW5/oUP2+N3v2uLalJ6eHlyOvt+VDT1JXVLyeZY99H6eE68T7734+X86XFqu259apLdWfD58VzjXj+qkH3yze6U+O+LhOVXgc4/Xifce/098RkT+zOaznO8nvnOJI/iMIIYlLue3RqTfT+7Ctj/+Z6UembHR9/di/cw0/XV0f53bvz2/Cfmdy2/3ODsfEY1hoFJywHdjTH0vUeFEPIjW2j3GGNf7Itsd9Ci05WwvUeG8WdVEhSe/sgXXrFkTHOs/Ozv7yJtvxYrPh2Xp1avXkRN0hw4dCpZ1Bgz4/1zOvn37tHHjxuA/Qu/evY/cv2vXLm3ZsiVYb7du3Y7c7+YXcEP2uCvhXZKkgnszFxYWqlWrVurQocOR+13dRUVFat++vVq3bn3k/tWrVwfb6upwdVWoaLvbJ8+J14n3Xnz9P+V27q7rH5uvuRsr8r1fduvI9jott1SbN2/mM4LPPT7L+c4ljiA2It4jLue3Br+f6jyG5Xcuv91578Xu/8nNSXHNiTlqUt5M984rVEn5ly+oPlwa0G1PLdLyLfv0/W+ewGcEn3t8liu+zsPWtlQdR6VxyPqBSpR3yQqnUW02whjTXNK93k03s9DPa7N+AKgruw6W6bJJs3wTFRlpRndd2l+Xn/j/X4YAAAAAgNRzSqeGuvuC49W+qbu2OLwHPlina6bM0/5i/4m5ASS+lBwGyhjjekhs8m5Os9aOO0Z5V9Y9Zp21tmsttcH1rfm3pDO8u35trf1VNetiGCiGeEmJYWuKi4uDmWO3z9zc3GB9if6ckvF1WvPZXl07daEKCg8rnAaZ6brvqhP1tRNaJ8xzSsbXiefE68R7j/8nPiO+/FnuPhvdlWfu2LRr1y54H5/lfD/xnUscQbxHDEtcHpvfGoWHy3XzEws1d4N/7/zjmjfU/Vf01wntmibk7ye3361btwa3VZzXIC6Pv9eJ3+6ldTYMVKomK1pJ2u7dfMZaO+YY5d1g6+7y32XW2r611IZJkm7wbr4u6XxrbVTSw14yIzhUVH5+fvDDEEhE7kMxXPdTxI+PCwo14dF52lX0+RfY0XIaZmry+CE6saObDggAgPhCrAEAQN0qLQ/ot/9eoamzPvUtk52VrrsuG6Bv9nZTtCYWYg0kk4IoJCtSdRio/SHrlRnaKbsKQ0YdkzHmjyGJiumSLolWogJIJi5r68bXc0toZhfxYfqanbr8wdm+iQrXpff5icNJVAAA4haxBgAAdSszPU2/Ob+P/nxxX2Wlh//dX1RSrhunLdDf316tQCCxLsIm1gAiS8kJtq21h40xO71JtiN2MzDGNAtJVlR6IusI9f1Q0o+8mwslnWOtPVTTeoFU4LqZhU4EhPjx2pIt+s6zi1UaZkI0p2vrRpp6zVC1z2kQ87YBAFBZxBoAAMSHy4Z0VNfWjXXT4wu0fX9x2DL/fHeNVmzdF5wPsXH9/x/eJ54RawCRpfKlySu9v12NMZGSNj3CPKZajDE3S/pTSF3ftNburUmdAFDXpszYoNufXuSbqBjYMUfP3TicRAUAAAAAoNIGHddMr902Kvib0s/bK7bpwvtmasPOIo4skARSOVnhhl+S12tiUIRyp4Ssz6juzowxYyXd491cL+k0a63r3QEACcnNeXTnW6v0q9dWyG/6o6+d0EpPXHeSmmUzvwgAAAAAoGraNKmvp28YpksH+w+Msnb7AZ13z3S9t6pieloAiSqVkxUvh6xPCFfAGOOOzzjvZqGk96qzI2PMRZIedatu7hFJp1prt1Sr1UAKKy0t1Zo1a4KLW0fdKSsP6CcvLdXd/1vrW+aiEzvowXGD1TArJUccBAAkIGINAADiT72MdP354n767fm9lZHmTq192f7DZbpmyjzd9/7a4IV18YpYA4gsZZMV1tq5kj7ybl5rjBkepth3Jfi44bcAAEGCSURBVPX01v9prf3C2VFjzHhjjPWWX4XbjzHmdElPSUqXtN3rUbGx1p8QkAJcwFFUVBRc4jn4SHaHS8t18xML9dRc/2l8bvhKZ/1tdP/g5GgAACQKYg0AAOKTMUZjh3cK9txv4dNz350m+Msbq3TrU4t0sKRM8YhYA4gs1S93/ZY3tJOb8fUtY8wfvN4T7vYYd77NK7da0p1VrdwYM0zSS5Lcp6hLdHxbUqYxpk+EhxVYa10vDgBHSU9PV/v27Y+sI/b2HirV9VPna+6G3b5lfnJWD93wlS4xbRcAALWBWAMAgPh2UucWevW2Ubpx2nwt27wvbJnXP96qddsP6KFxg5XXvKHiCbEGEFlKJyustYuMMZdJelxSE0kuWXE0l6g421q7vxq7OENSxadipqQnKvEYNyTVlGrsC0h67ku9devWdd2MlLV932GNmzxXn3wW/uMwPc3oLxf308WD/McSBQAgnhFrAAAQ/zrkNNDzE0foRy98rJcXhx9l3f1udfNY3HvFiRrRtaXiBbEGEFnKj89hrX1NUj9Jf/cSEwe9+SnmS/qhpIHWWv9B2QEgBWzYWaSLH5jpm6ion5mmh8cNJlEBAAAAAIi6+pnp+vtlA/Szs3vKZxoL7TlYqrGT5+qR6RsYShpIEIZx35OfMcZd5hwcXD4/P1+5uVz1DKDylhbs1fhH52pXUUnY7U0bZGry+CEadFwzDisAAAAAIKamr9mpW55cGBy22M9FJ3bQHy7sG0xyAKgdBQUFysvLq7iZZ60tqGmdKd+zAkDiKC0t1fLly4OLW0dsgr4xD87yTVS0a1pfz08cTqICAJAUiDUAAEg8o7q11Gu3jlKPto19y7y4cLMunTRLWwoPqS4RawCRkawAkDBcTzD3xe4WeoVF378/3qIJU+aqqKQ87PYurbL1wk0j1K2Nf0AIAEAiIdYAACAxdWzRMPj79Ky+bX3LfFywNziPxbyNu1VXiDWAyBgGKgUwDBSSRSAQ0L59+4LrTZo0UVoa+dZomTpro3756nJZG377gLwcPTp+iJplZ0WtDQAAxBqxBgAAic0lA+57f53+9tYq39+zGWlGvzqvt64adlysm0esgaRSEIVhoEhWpACSFQCqEtj9/e3V+tf/1vqW+eoJrXTflSeqYVYGBxYAAAAAEHf+98k2feupxdpfXOZb5vKhHfXr83orK4MLIYHqYM4KAEDUlAesfvLSsoiJigsHdtBD4waTqAAAAAAAxK2v92ijl28dqc6tsn3LPDV3ky5/aLa27zsc07YB8EfqEACgw6XluuWJhcFgzc/1Jx+vOy/pr8x0vjoAAAAAAPGtS6tGevmWkTqtZ2vfMgs+3aNz75muxfmFMW0bgPA44wQgYZSUlGjx4sXBxa2jduw7XKqrJ8/VG8s/8y3z4zN76Kdn91JamuGwAwCSFrEGAADJpUn9TD04drBu/3pX3zLb9hXr0kmz9Nz8/Ki3h1gDiIxkBQCkMNfd9bJJszVnw+6w29PTjP52SX/deEqXmLcNAAAAAICachfdfef0E/TAVW7uxfSwZUrKAvr+8x/rV68uV2l5gIMO1BEm2E4BTLCNZBEIBHTo0KHgeoMGDZSWRr61JjbuLNLYyXOUv/vzY3q0+plpuveKE3VqzzY12g8AAImCWAMAgOS26rP9un7qfG3afdC3zPDOLXTPFQPVolG9Wt8/sQaSSUFBgfLy8ipu5llrC2paJ2f6ACQMl5zIzs4OLiQqambZ5r0a/cBM30RF0waZeuK6k0hUAABSCrEGAADJ7YS2jfXqrSN1creWvmVmrd+l8+6ZoeVb9tb6/ok1gMhIVgBAipm5dqfGPDhbOw+En/ejbZP6em7icA06rnnM2wYAAAAAQDTlNMzSo+OH6MavdPYts7nwkC6+f6ZeXbKFFwOIIZIVABKGtTY4GZVb3Dqq7j9Lt2r8o/N0oLgs7PbOrbL1ws0j1L1NYw4vACDlEGsAAJAaMtLT9OOzeuqfYwaoXkb406OHSwO6/alF+uN/V6o8UDvnIIg1gMhIVgBIGKWlpVqxYkVwceuommmzP9UtTy5Uic9kYQPycvT8xBHqkNOAQwsASEnEGgAApJbzB3TQCzdF/h086YP1mjBlnvYerPl5CGINIDKSFQCQ5NyVG39/e7V+/vIy+XVIOaV7Kz15/Ulqnp0V6+YBAAAAAFBn+nRoGpzHYlhn/6GQP1y9Q+fdO12rt+2PaduAVGMYSiX5GWNyJeW79fz8fOXmuptA4nGfVxU9KjIzM917u66bFPdcV9VfvLJMT8zZ5FvmggHt9ddL+isznfw1ACC1EWsAAJC6SssD+v3rKzVl5kbfMg2z0nXXpQN0Rp+21doHsQaSSUFBgfLy8ipu5llrC2paJ2emACQMl5zIysoKLiQqju1wablufXJhxETFtaOODwZaJCoAACDWAAAglbnfxb86r7f+Mrqfsnwu5jtYUq6Jjy/QXW+vVqAa81hwXgOIjGQFACShfYdLNf7Rufrvss98y/zozB762dk9lZZGDxUAAAAAAJxLB+fpmRuHqU2Ter4H5F/vrtEN0+Zr/2Hm0wRqE8kKAAkjEAioqKgouLh1hLd9/2GNmTRbs9fvDrs9Pc0ErxSZeEoXeqgAAECsAQAAjjKwYzO9dusondgxx/fYvLNyuy64d4bW7zhQ6ePHeQ0gMpIVABJGWVmZ1qxZE1zcOr7s011FGn3/LK3Yui/s4amXkaZJVw0KXikCAACINQAAQHitm9TXUzcM0+VD/X8/r9tRpPPvmaH3PtleqcPIeQ0gMpIVAJAklm3eq4vvn6lNuw+G3d6kfoaeuO4kndarTczbBgAAAABAoqmXka4/XNhXv7ugjzJ8hlDeX1ymax6bp3vfWxucQBtA9Rn+iZKfMSZXUr5bz8/PV26uuwkgmcxct1M3TF2gA8Xhe5y4sTanXnOSTmjbOOZtAwAAAAAg0c3dsFs3P7FAOw+U+JY5q29b/XV0f2XXyzhyX0lZQG+v2KYPVm/X0s37gsNGlZQHgpN4d27VSH07NNEp3VvrG73aKCuD68qROAoKCpSXd6TnUZ61tqCmdZKsSAEkK4Dk9p+lW3XH04uDwU44nVtla+o1Q5XbrGHM2wYAAAAAQLLYUnhIN05boKWb9/qW6dG2sR4cO1jtcurrkekb9PBHG7TzQPEx627VuJ6uHXV8cMlMJ2mB+EeyAtVCsgJIXo/P/lQ/f2WZ/Hqa9s/L0aPjh6h5dlasmwYAAAAAQNI5XFqun7y4VC8u2uxbpnH9DLXIztLGXeGHaY6kT4cmuuvSAerehpERkHrJCtJ0ABJGIBBQYWFhcHHrqcwN4fePd1brZy/7Jyq+0r2VnrzuJBIVAABUErEGAAA4lvqZ6brz0v76+Tm9lO43j8XhsmolKpxlm/fp4vtmasGnu3kxkHJIVgBIGGVlZdq4cWNwceupqjxgg70p/vHOGt8y5w9or4fHDf7COJkAACAyYg0AAFAZxpjgcE1uyOWchpm1ftDcpN3jJ8/Tmm37eUGQUkhWAEioYCAzMzO4uPVUVFxWrtueWqjHZ2/yLXPNyOP190sHMDEXAABVRKwBAACqYmTXlnrt1lHBeSqikbD49rOLVeozPyWQjJhgOwUwZwWQHPYfLtUNUxdo1vpdvmV+cMYJuumULimbzAEAAAAAINYOlpTpovtm6pPPar8nxI/O7KGJp3Sp9XqBmmLOCgBIUTv2F2vMg7N9ExVumMy/XNxPN3+1K4kKAAAAAABiKCMtTbuKSqJS9yPTN9C7AimDYaAAIM5t2nVQox+YqeVb9oXdXi8jTZPGDtalQ/Ji3jYAAAAAAFLd2yu2BS8yjAZX71vLt0WlbiDekKwAkDDKy8u1ffv24OLWU8HyLXt10f0z9emug2G3N6mfoWnXnqRv9GoT87YBAJBsUjHWAAAANffB6u1RPYwfrt4R1fqBeJFR1w0AgMpyJw22bNkSXM/JyVF6enpSH7xZ63bphqnzg5NqhdOmST09ds1Q9WjbJOZtAwAgGaVarAEAAGrH0s3hR0KoLUs3741q/UC8IFkBIGG4SaOzs7OPrCezN5Zt1e1PLVZJeSDs9s4ts4OJirzmDWPeNgAAklUqxRoAAKD2rN9xIKqHc/3O6NYPxAuSFQASRmZmprp166Zk98ScT/Xzl5cpYMNv75/bVJPHD1GLRvVi3TQAAJJaqsQaAACgdvldaFhbisuiWz8QL0hWAECcsNbqX++u1d/fWe1b5uRuLfXAVYOUXY+PbwAAAAAA4kFWelpUEwr1Mph2GKmBdzoAxIHygNUvX10eMVFxXv/2euTqISQqAAAAAACII51bNYpu/S2jWz8QL7g0F0DCKCsr07Zt24Lrbdq0UUZGcnyEFZeV6zvPLNHrS7f6lhk/opN+cU4vpaUxfjYAANGSrLEGAACIrr4dmmjl1uhNst23Q9Oo1Q3EE3pWAEgYgUBAO3bsCC5uPRnsP1yqCY/Oi5io+P43T9AvzyVRAQBAtCVjrAEAAKLvlO6to1r/V7q3imr9QLzgUiEACSMtLU05OTlH1hPdjv3FmjBlrpZtDn/1hetE8YcL+2rM0I4xbxsAAKko2WINAAAQG9/o1UatGtcL/s6vba7e03u3qfV6gXhEsgJAwnBDMXTq1EnJIH/3QY19ZI427jroO3nW3ZcP1Om928a8bQAApKpkijUAAEDsZGWk6dpRx+tP//2k1ut29WamcxEFUgPvdACIsRVb9umi+2f6Jioa18/QtGtPIlEBAAAAAECCcEmFPh2a1PpcFdeNOr5W6wTiGckKAIih2et36bJJs3y7hrZuXE/P3jhcQ49vzusCAAAAAECCcL0f7rp0gBrXq52BbNyFjHdd2l8Z9KpACiFZASBhlJWVaePGjcHFrSeaN5Z9pnGT52p/cfi2H98yWy/cNEI929XulRgAACA1Yg0AAFC3urdprCnXDKlxwsIlKqZMGKJubRrXWtuARECyAkDCCAQCKiwsDC5uPZE8NXeTbn5igUrKwre7X25TPT9xuPKaN4x52wAAQOLHGgAAID4MOq65Xrx5RLWHhHKPe/GmEcF6gFTDBNsAEkZaWppatWp1ZD0RWGt1z//W6s63V/uWGdW1pR4YO0iNaqmrKAAASJ1YAwAAxB/XI+Klm0fqkekbgovfUNChWjWuF5z3ggm1kcqMO5GG5GaMyZWU79bz8/OVm+tuAoi2QMDqV68t19RZn/qWObd/e915SX9lZXBCBAAAAACAZFNaHtBby7fpw9U7tHTzXq3feUDFZQHVy0hT55aNgpNof6V7K53eu01w3gsgURQUFCgvL6/iZp61tqCmdXIZLwBEQXFZub7z7BK9/vFW3zLjR3TSL87ppbQ0w2sAAAAAAEAScgmIs/u1Cy4AIiNZAQC17EBxmW6cNl8z1u7yLfO907vrlq91dT2fOP4AAAAAAABIeSQrACSM0tJSbdy4MbjeqVMnZWZmKt7sPFCsCY/OC3btDMd1ovj9hX11+dCOMW8bAABI/FgDAAAkLmINIDKSFQAShptjp6io6Mh6vMnffVDjJs/Vhp2ft/Fobl6Kuy8fqG/2bhvztgEAgMSPNQAAQGIj1gAiI1kBIGGkp6erffv2R9bjycqt+4KJih37i8Nub1w/Qw+PG6yTOreIedsAAEDixxoAACDxEWsAkZGsAJBQX+qtW7dWvJmzfpeumzpf+w+Xhd3eqnE9Tb1mqHq2axLztgEAgMSPNQAAQHIg1gAiI1kBADXw5vLPdNtTi1RSFgi7vVOLhpp27UnKa96Q4wwAAAAAAAD4IFkBANX09NxN+slLSxXwGdK6b4emenTCELVsVI9jDAAAAAAAAERAsgJAwigtLdXq1auD6927d1dmZmadTYh173tr9be3Pm9LOCO7ttCksYPVqB4fswAAJIp4iTUAAEByItYAIuMsGoCE4ZIE7ou9Yr0uBAJWv/n3Ck2ZudG3zDn92unOS/urXgYTcwIAkEjiIdYAAADJi1gDiIxkBYCEkZGRoU6dOh1ZjzU3L8V3n1ui15Zs8S1z9fDj9MtzeystzcS0bQAAIPFjDQAAkNyINYDIiMABJIy0tDTl5OTUyb4PFJfppscX6KM1O33LfPcb3XXr17vKGBIVAAAkorqMNQAAQPIj1gAiI1kBAMew60CxJkyZp48L9obd7jpR/O6CvrripI4cSwAAAAAAAKAaSFYAQAT5uw9q3OS52rCzKOz2rIw0/WvMAJ3Rpx3HEQAAAAAAAKgmkhUAEkZJSYlWrFgRXO/Vq5eysrKiur+VW/fp6slztX1/cdjtjetl6KGrB2tY5xZRbQcAAEjOWAMAAKQWYg0gMpIVABDG3A27de1j87T/cFnY49OqcT09NmGoerVvwvEDAAAAAAAAaohkBYCEkZGRoW7duh1Zj5a3ln+m255apOKyQNjtnVo01NRrTlLHFg2j1gYAAJC8sQYAAEhNxBpAZETgABJGWlqasrOzo7qPZ+Zt0o9fXKqADb+9T4cmenT80GDPCgAAkFxiEWsAAIDURawBREayAgAkWWt13/vr9Nc3V/kejxFdWmjS2EFqXD+TYwYAAAAAAADUIpIVABIqoVBaWhpcz8zMlDGmVuoNBKx+8+8VmjJzo2+Zs/u2012X9Ve9jPRa2ScAAEidWAMAAIBYAzg2khUAEoY7ebBixYrgeq9evZSVlVXjOkvKAvrec0v06pItvmXGDjtOvzqvt9LTOGEBAEAyi0asAQAAQKwBVA7JCgApq6i4TBMfX6CP1uz0LfPt07rr9lO7cmUlAAAAAAAAEEUkKwAkDDccg7vKsWK9JnYdKNY1U+ZpScHesNtdJ4rfXtBHV550XI32AwAAUjPWAAAAINYAqoZkBYCE4caNro3hGAr2HNS4R+Zq/c6isNuz0tP0r8sH6Iw+7Wq8LwAAkHqxBgAAALEGUHUkKwCklE8+26erJ8/Vtn3FYbc3rpehB8cN1vAuLWLeNgAAAAAAACBVkawAkDACgYAOHToUXG/QoIHS0tKq9Ph5G3fr2inztO9wWdjtLRvV02PXDFHv9k1rpb0AACC1Yg0AAABiDaD6iL4BJIyysjKtWbMmuLj1qnh7xTZd9fAc30TFcS0a6oWbhpOoAAAghdUk1gAAACDWAGqGnhUAkt6z8/L145eWqjxgw27v3b6JpkwYqlaN68W8bQAAAAAAAAAkY234k3dIHsaYXEn5bj0/P1+5ue4mkPzc59v9H6zTX95Y5VtmeOcWenDcIDWunxnTtgEAAAAAAACJqqCgQHl5eRU386y1BTWtk54VAJJSIGD1u9dXavKMDb5lzurbVnddOkD1M9Nj2jYAAAAAAAAAX0SyAkBcKykLBOeb+GD1di3dvE/rdxxQSXlAWelp6tyqkfp2aKJTurfWN3q1UVZG2pHHfP/5JXpl8Rbfeq8a1lG/Pq+P0tNMDJ8NAAAAAAAAgHBIVgCIS6XlAT0yfYMe/miDdh4o/tL24rKAVm7dF1yenV8QnG/i2lHHa8yQPN3+9GJ9uHqHb913nNZN3zq1mxsiLcrPAgAAJJJAIKB9+/YF15s0aaK0tM8vhAAAACDWAKKPZAWAuLN6235959nFWrb585MFlbFjf7H+9N9P9M931uhQaXnYMi438dvz++iqYcfVYmsBAECyKCsr08aNG4PrvXr1UlZWVl03CQAAJBFiDSAykhUA4sqCT3dr/OR52l9cVq3H+yUq3LBR/xgzQGf1bVfDFgIAgGTlel1mZmYeWQcAACDWAGKHZAWAuOpRUZNEhZ9G9TL04LhBGtGlZa3WCwAAkotLVPTu3buumwEAAJIUsQYQGckKAHEzR4Ub+qm2ExUtsrP02DVD1adD01qtFwAAAAAAAEDtYcY4AHHBTaZdlTkqKmv0oFwSFQAAAAAAAECcI1kBoM6VlAWCyYpoeHHR5mCvDQAAgGMpLy/X9u3bg4tbBwAAqE3EGkBkJCsA1Lm3V2zTjv3FUanb1fvW8m1RqRsAACTfCYQtW7YEF5IVAACAWAOILZIVAOrcB6u3R7X+D1fviGr9AAAgORhjlJ2dHVzcOgAAALEGEDtMsA2gzi2NwlwVX6x/b1TrBwAAySEzM1PdunWr62YAAIAkRawBREbPCgB1bv2OA9Gtf2d06wcAAAAAAABQMyQrANS5kihPgF1cxgTbAAAAAAAAQDxjGCgAdS4rPS2qCYV6GeRlAQDAsZWVlWnbtm3B9TZt2igjg59LAACg9hBrAJFxBg9AnevcqlF0628Z3foBAEByCAQC2rFjR3Bx6wAAAMQaQOyQrJBkjOlojPmbMWalMabIGLPbGDPXGPM9Y0zD2jrYxpgxxpg3jTFbjTGHjTEbjTHTjDHDamsfQCLq26FJlOtvGtX6AQBAckhLS1NOTk5wcesAAADEGkDspHy/ZmPM2ZKekBR6NtMlKIZ4y3XGmLOsteure5CNMfUlPSfpnKM2HectVxhjfmWt/W31X0ogcZ3SvbWenV8Qtfq/0r1V1OoGAADJww371KlTp7puBgAASFLEGkBkKX25kDGmv6RnvUTFAUk/lTRC0qmSHvKKnSDpdWNMTcaReSQkUfGepAskDZV0raR13uvwG2PMdbXwtICE841ebdSqcb2o1O3qPb13m6jUDQAAAAAAAKB2pHSyQtI/vF4UZZJOt9b+wVo7y1r7P2vtDZJ+4JXrIek71dmBMeYU13PCu/maOy9rrX3FWjvPWjtZkhsCapO3/S/GmJzaeWpA4sjKSNO1o46PSt2u3sz0VP+oAwAAAAAAAOJbyp7BM8a4IZ6+6t18xCUpwhS7U9JKb/0OY0xmNXZVkfAol3Sztdb9PcJau1PSD72bzbzeFkDKcUmFPrU8d4Wbq+K6KCVBAABA8ikrK9PGjRuDi1sHAAAg1gBiJ2WTFd5QTBUeDVfAWhuQNDUkkVCR3KgUb+goN6SU87a11m9Q/hcl7fPWL6rKPoBk4Xo/3HXpADWuVztT6TSun6G7Lu2vDHpVAACASgoEAiosLAwubh0AAKA2EWsAkaVysuJk72+RpAURyn0Qsj6qivtw81LUC1PPF1hrSyTNrnhMNXtwAAmve5vGmnLNkBonLFyiYsqEIerWpnGttQ0AACS/tLQ0tWrVKri4dQAAAGINIHZq5xLmxNTT+7vWWhupj/cnYR5T1X0cXY/ffk73XpNuklZUdifGmNxjFGlbsVJSUhLM4lb8+LLWqrS0NLiemZnp6gquuzIVXd+zsrKOVFRxvyvnylcoLy8PLkff78pW7C8jI+OY97u2uDalp6cHl6Pvd2VDfzi65+OE3s9zSuzXaWBejp65foi+/8IyLd+6X1XlhpL6+6UDdHyLBsH9xsNz4v8pMd57vE68Trz3+H/iMyLx44iafpa7fXTo0OFI293fRH9Oyfg68Zx4nXjv8f/EZwSf5Yn8/dSmTRu+cxPgdSI2spX6f6ptKZmsMMbUl9TSu+k3NFOQtXaPMcb1vsiWlFfFXYWWj7gfSflHPa7SyYqjHhvRmjVrgh+K2dnZRz7MV6z4fFe9evU68k9+6NChYFlnwIABRx6/b9++4Bi+7p+7d+/eR+7ftWuXtmzZEqy3WzeXa/nctm3btGPHDuXk5KhTp05H7i8oKAh2r3dXrbkfhBVc3UVFRWrfvr1at2595P7Vq1cH2+rqcHVVqGi72yfPKXlep5Kdm/Trkxtr/v4OemT6Bu3YX6xjad4gXTd8tduRCbU3b94cV8+J/6fEeO/xOvE68d7j/4nPiMSPI/gs53Xivcf/E58RfJbz/cR3LnEEsRExbKeYxOW1LSWTFW6UmJD1A5UoX5GsaBTF/bh9VKjqfoCkk5FmNPGULsHkw1vLt+mdZQVavGmPtuwvU0nAql5Gmjq3bKSuLbJ0QpOAvn5CC/U8oUtdNxsAAAAAAABANRjXpSbVGGNcz4VN3s1p1tpxxyjvyrrHrLPWdq3Cfh6RdI13s4u1dn2Esq6cK++MtdY+XsvDQM1zK+vWrQtmxehSRTexROz6dvjwYW3atCm4T/c+do+jO1/8vU50u0yM/ydeJ14n3nv8P/EZ8eVhAdz/hbvCzB2bvLy84Gcnn+V8P/GdSxzB0CHEsMTl/Naord9P7vdcfn5+cFvFeQ3icuLyRI3LCwoKgjGzJ89ae6yRhY4pVZMVrSRt924+Y60dc4zy2yS5vjDLrLV9q7CfeyXd7N3saa31nbfCGHOTpPu8m6OttS9Udj+VTGYEh4pyH4i5ucfKbQDxyX0ohhvyAQAAgFgDAADEO85rIJkURCFZkarDQO2v4pBL2VUYMqq6+wkd6Kuq+wFSgsvyunH0KtYBAACINQAAQKLgvAYQWUomK6y1h40xO71JtiN2MzDGNAtJJFR6ImtPaDbJ7Wd+JSfjrup+gJT5Ug+d8AcAAIBYAwAAJArOawCR/f+gU6lnpfe3qzEmUtKmR5jHVNYKn3oi7ccNULa2ivsBAAAAAAAAACBhpXKyYrr31/WaGBSh3Ckh6zOquA83qXVJmHq+wBjjBt4fVvEYa23FYwAAAAAAAAAASHqpnKx4OWR9QrgCxhh3fMZ5NwslvVeVHVhr3ZwV73o3T/Mmug7nIklNvPWXqrIPIJWUlpZq+fLlwcWtAwAAEGsAAIBEwXkNILKUTVZYa+dK+si7ea0xZniYYt+V1NNb/6e19gtnR40x440x1lt+5bOrv3l/3VBT9xpjvjArsDHGzZvx55CEyMM1emJAErPWBr/Y3eLWAQAAiDUAAECi4LwGEFlKTrAd4lve0E4NJL1ljPmD13vC3R4j6Qav3GpJd1ZnB9ba/xljnvbqO0/S28aYf0jaIqmvpJ9K6ugV/5G1dk/tPT0guWRkZKhTp05H1gEAAIg1AABAouC8BhBZSp/ts9YuMsZcJulxbxgml6w4mktUnO0N6VRd13j1nyXpa94SKiDpt9baSTXYB5D00tLSlJOTU9fNAAAASYpYAwAAEGsAdSdlh4GqYK19TVI/SX/3EhMHveGY5kv6oaSB1tq1NdzHIWvt2ZKudD0rJG33Jt7Ol/SkpFHWWr9hpAAAAAAAAAAASGqGcd+Tnzext0uMKD8/X7m5fvN8AwAAAAAAAAAQWUFBgfLy8ipu5llrC1RDKT0MFIDEUlJSohUrVgTXe/XqpaysrLpuEgAASCLEGgAAgFgDqDspPwwUAAAAAAAAAACoW/SsAJAwMjIy1K1btyPrAAAAxBoAACBRcF4DiIyzfQASRlpamrKzs+u6GQAAIEkRawAAAGINoO4wDBQAAAAAAAAAAKhT9KwAkDCstSotLQ2uZ2ZmyhhT100CAABJhFgDAAAQawB1h54VABKGS1SsWLEiuFQkLQAAAIg1AABAIuC8BhAZyQoAAAAAAAAAAFCnGAYKQMJwQz/16tXryDoAAACxBgAASBSc1wAiI1kBIGG4OSqysrLquhkAACBJEWsAAABiDaDuMAwUAAAAAAAAAACoU/SsAJAwAoGADh06FFxv0KCB0tLItwIAAGINAACQGDivAURGsiI1pFesbN26tW5bAtRASUmJ1qxZE1zv1q0bQ0IBAIBaRawBAACiiVgDyWTrF88zHzn/XBPGWlsb9SCOGWMGS5pX1+0AAAAAAAAAACSdIdba+TWthDFUAAAAAAAAAABAnaJnRQowxtST1Ne7uUNSeR03CaiutiG9hIZI+oxDCQAAahGxBgAAiCZiDSSTdEmtvPWl1trimlbInBUpwHuj1LgbDlDXjDGhNz+z1hbUXWsAAECyIdYAAADEGkCVfKpaxDBQAAAAAAAAAACgTpGsAAAAAAAAAAAAdYpkBQAAAAAAAAAAqFMkKwAAAAAAAAAAQJ0iWQEAAAAAAAAAAOoUyQoAAAAAAAAAAFCnSFYAAAAAAAAAAIA6Zay1ddsCAAAAAAAAAACQ0uhZAQAAAAAAAAAA6hTJCgAAAAAAAAAAUKdIVgAAAAAAAAAAgDpFsgIAAAAAAAAAANQpkhUAAAAAAAAAAKBOkawAAAAAAAAAAAB1imQFAAAAAAAAAACoUyQrAAAAAAAAAABAnSJZAQAAAAAAAAAA6hTJCgAAAAAAAAAAUKdIVgAAAAAAAAAAgDpFsgKIMmNMa2PMOcaY3xhj/muM2WmMsd4ypRKP7xRSvrLLxmPU2dAY831jzFxjzG5jzAFjzEpjzN+MMR2r8Nx6G2MeMMasNcYcMsbsMMZ8aIy50RiTUYV6xhhj3jTGbDXGHHbtN8ZMM8YMq0IdLYwxvzbGLDHG7DXG7PPW3X0tqlDPcG/fG722uDa94dpYhToyvGPwoXdMDnnHyB2rXpWtx6urpTHmB8aYGcaYz4wxxcaYLcaYOcaYv7r2VqKOM4wxLxpjCrzHF3i3z6hKWwAA8YlYI3ViDWNMPddmY8xtXh2rjDGBihiwCm040RjzEy82zffiAxcPrnbxqTHm5MrW5dVHrAEASYxYo1LHiFjjy8ckyxhzrRfnbA2JN1z8MrmKcRixRqqw1rJwDHgPRPE94P7NIixTKvH4TseoI9zyZoT6ukj6JMJjCyWdVYl2XSvpcIR6ZklqcYw66kt6LUId5ZJ+Xom2DJG0JUI9myUNrkQ9v/D26VfPq67Nx6jDnayYHaEOd8yuqeR75xJJO4/xWr8c4fFG0qRjPN5tN3wO8jnIe4D3AO+BxH0PEGukTqwh6dFIr3cl3y8fVDKenCop6xh1EWvEwWcAC8eA9wDvAWINzmvEU6zh1ZMn6eNKxBt3RTonQaxhU+4znp4VQGzlS3qrio9xP377VmJ5MuQxj4WryBjTSNK/JZ3g3fWQpFMljZD0U0kHJDWV9Jwxpp9fg4wx35T0oKR6krZJul3SSZLOlPSiV8xlyN3V+5E+Zx6RdI63/p6kCyQN9RIh67zeX65HynUR2tLBOwnRTlKZpL9I+oq3/MW7r7173l5Zv3rcPn7t7XOd14ahXptc25xzJT0coY507/m7YyFv/UzvtjtG271j9qB3DH0ZY8ZJetpLfmz32vYNSYMkne3V97ak0gjV/E7SDd76IkmXe8/pcu+2vO2/jdQWAEBCIdZI4ljD+8FeYb+XePhMVVPRRpd8+aek0V47XG/N73ixpzPWXVhzjLqINQAg9RBrfBGxxlG8kTZe985VyUtajPdijdNd7CWpyNv2bUnfi/B+I9ZINXWdLWHhGCT7e8D7Uep+JLcJ01NiSi3tI937Yelu7JPU0Kfcr0L2/f0w24d7J7/djf/51OG+dNZ4Zfa6nhphytwbsp9xPvWcclRmP/2o7S0lfept3y0px6eeKSH1XOLTO6Fi+2SfOnIk7fHKuH22DHN8Xw2p5ys+9YwPKXNvmO1dvWPmbqx2x9Knnp4hvVY+dAmkCK992CsevX1VvJbzJDU4antD737rlfvS68jCMeA9wHuA90BivAeINVIq1rjMizd6u6SHd9/7VexZ4S5cufTo43HUcVkV0paTiTXq/v+chWPAe4D3ALHGke8pzmvEf6xxcch+ZoaLObwLMUtC4rAvnR/hvIZNyc/+Om8AC8cg1d4DUUpWfLMSP5IzQ764VlR86YQp90BIXYOO8YP8Rz51NPS+bNyNpT5lXJbdelcj5vqUGROyr++G2d7Ge7y78UaE4/NGyL7ahNn+/ZD9jPGpIzdkX6/5lFke8kXrlzD6Uci+LvYp8463fcfRAUYV3hOhCaNhPmWGhZS5u67+J1g4BrwHeA/wHqjd9wCxRvLGGj6Pq9IJhErWeU5Ie/9JrMHnNJ/TvAd4D/AeINYI+31JrBH+uNwVEkecGyHeeDGkXJ8w2zmvYVPvs4dhoIDk4IYMijgElKSvepn2YBlrbcCnXGh3/4vCbL/Ap+wR1tqDkp71bvYxxnQLMxyVG37KedtaW+DTlhe9niJ+bTnPuzqgYlxFPxXtTPce4/ec9oUMY3X0cyrwkgjON7znEPqc3HOsmDz7Ge8YRGpL2OdkjOkRcmzusda6OSuqxBjjhog437v5ibV2ts9zmu1dOelc4D0OAIBwiDXqONaIMZcAqeDmO/sCYg0AQBQQayRPrJEVsr4+Qjk3LGYFN2T2EcQaqYtkBZDgjDGNQ76UPvWGDQrn5JB1N76xn/khYweOilDPKmttpDGSQ/dxdD1DQ76IfNtirXVdAitOtA81xmT6tCViPZHaYozJ8trjzPL2eax66nkTbVa5Ld4xWx2uLR7Xc6XCcyHtbOYSIsYYN4fFsRwfMh51pOMSuj3X6/UDAMAXEGt86Tsz0vdpNGONWAo9yRDuAhdiDQBArSHWSLpYo+Kch9M5QrmKCyKsN9x4KGKNFEWyAkh8o71hl5ypwf7/4bl5ECp84leZtbYsJLvdM0yPiNxj1RFme8/qtOWo7W6ujG4+9eyNlDix1m4N6aFxdFu6eXVXpS219ZzyjDHZR21zQzPJm9tipTHmSmPMEm9oKfeFv9MYs94Y88sIV0FUpy1HPw4AgArEGvERa8SSm+9DEdpMrAEAqE3EGskVazwV0tYfGmMqRsQ4whgzUNLZ3s2nrbUV5cO1LR6eE2KEZAWQXF0lp0Yol+f9LbLWFh6jznzvbytjTGhXPJeoqBgqqKCSdYTuO9zt2qjnWHWE1hPttlSlHhOS/KlQMZTURjePhKTHJfULc4WBm1RsljGmfZj6a+s5AQDgEGvER6wRE8aYNG+OrQoVQ3sm7HMCAMQ9Yo0kijWstTu8SboPSRopaZ4xZpwxZpgx5jR38aXXw8P1CFks6Tthqomr54TYIVkBJDBjTMeQK99mWmvXRijuhotyDlSi6ophoJxGYeqoTD1+dUSjnqo8p2i3pab1NPf+urkrbpHkEksTJbWWVN/rpvlfr0wfN1SUd1IhGm0BAKQ4Yo24ijVi5dshQ0m8ZK11Q4QqwZ8TACBOEWskZ6xhrX1J0mBJj0ga4M2vOsvNW+pdfHnQS1KM8ulREnfPCbFBsgJIbFeF9HSI1KtC3oluJ9LYhRWKQ9YbhKmjMvX41RGNeqrynKLdlprWUzEslOvRUi7pTGvtJHdlgrW22DthcE5IwmJEmIm6a6stAAAQa1Tu+zT0OzVaMULUGWPcRTB/8m5ul3STT9GEeU4AgLhHrJGEsYY35+gVks4NOW8Vqo2kyyV91aeKuHtOiA2SFUBiGxvywfzMMcoeDjNhop/QoZ8OhamjMvX41RGNeqrynKLdltqs5zlrbcUE40dYa91El98PuevyKLUFAABijcp9n4Z+p0YrRogqY0xv15PCG/PaxZaXWmu3+RRPiOcEAEgIxBpJFmt4c3O+I+mnklpI+os3l4Tbd1NJp0ua7o0c8Zox5lthqomr54TYIVkBJChjzFBvqCDn1UrMQ7G/Cl3isn2621XUUZl6/OqIRj1VeU7Rbktt1lPRe+JLrLXLJW32bg6JUlsAACmMWCPuYo2oMca4+bDektTM69l5ubXWjSXtJ+6fEwAg/hFrJG2s8WtJX/HWr7XW/tBa+4m1tsRNpG2tdUNBfU3Se16vi7uMMf3i/DkhRkhWAMk/AdXRExJlG2NyjlG2YkKi4NBDYepQmImh/eo4erKjaNRzrDpC64l2W6pSjw0zUVR+NSaRal0LbTl63wAAEGvEV6wRFcaY9t7Vj+292OQab5zpSOL6OQEAEgaxRpLFGsYYl3yY4N1cba11c1V8ibW2TNLPQ85PVzwm7p4TYotkBZCAvLH/LgsZT/iNSjxsRch6jwh1u67/XbybK0O3WWsPhHzw+9YRZvvK6rTlqO3ui2ytTz1NjTFt/SowxrST1MSnLau9Kwir0pbaek751trQiaAc12OiQvox6kkPOTY1bUu45wQASFHEGnEZa9Q6Y0xLb6LLzt5dt1lrK3MRDLEGAKCm30Gc10jOWMPNRdHcW190jLILfNrlEGukKJIVQGI6W5L7cek86WWkj8WNB1jBTZ7oZ3BIF7oZEeo5IdIX6VH7OLqeeSETJPm2xRjjxiUcVvEY12XQpy0R64nUFq/Oud7N4d4+j1WP620yvzpt8Y5Z93Bt8XwYsl6RNPJTcWKhYjioChskbTlWWzxfCalj4zHKAgBSB7FG/MUatcoY48aMflNSL++uH1lr763kw4k1AAA1RayRnLFG6PkpdzFsJJk+j3OINVIUyQog8btKhu1SF8b7kvZ661d7XfPCGR+yHm4IgJd9yh5hjGnoJmX0bq6w1ros/xHWWjf24LvezdOMMX5d+i4KuXIgXFteleQmm1aYLoMK086A9xi/59TE22e45+TaeJp3813vOYQ+p9UhVyVc6h2DSG2J9JxKvfWwbfHac4o3UZXz0VFtcUM4vOLd7GGMGeZTx7CQqxde8R4HAIBDrBFnsUZt8uKU1yWd6N31e2vtnyv7eGINAEAtINZIzlhjt6R9IYmTjEomYFxy4ghijRTmzk2xcAx4D8TuPSCpkzcesFumVOPxzb0MuLvxcRUf+5uQfX8/zPbh3olyd+N9nzoyveGYrJf86BKmzL0h+xnvU8/XQ8q4E+vpR213PUc+9bbvcRM++tQzNaSe0WG2X3Ks4+0dUzdBufV6F7Q4anu6FwxU1PM1n3quCSlzT5jtXbxjZr1jmOFTz30h9YwJs72x152yosyQMGW6h7yWridLg6O2N/Dut165bnwO8F3Ae4D3AO+B5HgPEGskb6zhU/f7FY+rZPksr0dFxb7+Uc33GbFGHPy/s3AMeA/wHiDW+NL3E+c16j7WeDJkP7/0KdPMGwa7otzpxBp8nrn3gPHeIACixBgzSlLXkLvcD+O/hnTdezi0vLV2yjHqu9lLBjjfs9beWYW2NPa6+VUMQ/SgpKclHXJfVJJ+IqmRd3uEtXaxTz1nSXrN6521TdLvvC6H7svmekkXh3Rn/Kq1ttynnqfcyXjv5nvux7I3fFFfST8NGQZporV2kk8ded44h628boPuePzb23yOpO96XQ93uKsHrbVhJ602xtwo6QHv5jp3haGkpd5kk3d4x8d5ylp7hU8d7sv/A0kjvbtekPSQdwJkqDd5VGvvSohzrLX/9amnlfc6dfSek2vXi97VCe7Y/DCkR8T91tqbfer5oxvSwbvpkht/9p5bF6+Ogd62P1pr3WsPAEhAxBopFWu44STPOOpu911/gs8VmdOttV+Y88sY80LIFZf/8/Yd6UdhydG9ZEPqItYAgBRArEGsUcVYo4cXO1WMOPGaNyrIekn1veG+7/DOeVT08jjN571HrJFqyMKTteI9EN33gLvCLiRTfMylEvXN9sq6H8ttq9EelzhZHaENe70T6ceq5/qQHh7hljkuMXOMOhp4QxD41eFOPPyqEm05SdLWCPW4bSdVop5fe4kEv3pcW+sfo46WXuLGrw53zK6vRFt6SlpzjPfLI66nS4Q60rwykepwybI0Pgf4LuA9wHuA90DivgeINVIn1nAXgVQlrgzXw7WKj3fLRmKNuv8/Z+EY8B7gPUCs8YXvMs5rxHGs4dVzmnchx7Ee/65f71avHs5r2NT6/KNnBRBlxhiXrLi6suWttSZCXd28RIPzhrX2zGq2yU2gfYs3bEFXbziAfEn/kfRPa+2nlaynj6TbJZ3qXRVY5M3b8IQ7CV7Jib9dPVd44y/2l5Tj9db4yBtKaVYl63BJgm9JusAb/qJizMNXvOENdlWynhHesTlZUhtvyIYlkh611j5VyToyvGTOFV7SIdu7ivNd7/gur2Q97nE3uSEn3DBNXq+X7V6PnEnW2vcqWY/rCXODGy7KS6bs9IaAmuTXuwMAkDiINVIn1jDGuBMIlfr+90w4uteuMSb4y78KPrXWdjpGu4g1ACCJEWtU6hgRa3z5mLh5Nq+V5M5d9fZiMHee6DPvnIQbLurVysyfSayROkhWAAAAAMD/tXf3wbbVZR3An2d8S8wm6EWjxrCIsRBJECwFwXcEETSz5EKACpGmDialk8WtmdQhFSwTMQRMQDRCfEtwhgGVLEtQREnCFGUQlDJBBAaRp/ndfptZbPbZ54VzWed0P5+ZPWfvtdZea+211x/3/r77+T0BAACMqZXSAAAAAAAAjEZYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAAAAAjEpYAQAAa1BmHpaZ1R/bjX0+sDlk5sbJfe4KAwBs2YQVAACwilqwMAgZVvzwpbDK9+Vpyw2/MvPqvv3Vvg0AADY3YQUAALCmDQbNTxv7XAAAgM3j/ptpvwAAsKW6NiJ2mrP+/IjYNiK+GRHPXGijqvpiRBic5/+1qtoYEe0BAMAWTlgBAACrqKp+EBEtaJgpM9v65gc9kAAAANjimQYKAAAAAAAYlbACAADWoMw8bF5D5My8qK+7qL/ePjPfkZlfzcxbe5+Hd2Xmz0+979GZeWrf7rbMvCYzT8zMn17ieT09M0/PzK/149yUmZdl5nGZ+TOLvHfbzHxjZl6amTdm5u2ZeX1mXp6Z7+2f+cemP2NETD7DoTOakW/6/IP3bJ2Zh/dzvCIzbx4c5/zMPDIzH7jEBumH9WXPy8yPZ+a3M/P7/fO+PDMfMHhfc1A/57bdLf1zHtVWzDne5FibpkLKzKdl5ocy87r+/bTv6W2Z+XOxhmTm3oNz37sve0FmXpCZN/R748p+X2wzZz8bZzWV79fzvL7uh5m5x5x9vHJwLn+xyh8VAID7iGmgAABgnWsD3BFxTkQ8dLC4DfC/KCKenZl7VdWXM/OFEXFqRDxosF0bBD8qIp6VmU+oqm8ucIyHRMR7IuK5U6t+JCIe0x+/145RVR+Z8f49I6ItvyuM6B7WH4+OiN+OiP/q263U5wbhxvRxntEfLUDYt6quX2xnmfn29rmmFrfP+lcR0QbsX9D/X3V6RDx/arvHRsSJEbFLRBy5hGMdO6N/wyMj4mURcUhm7l9Vn4y1536ZeUZEHDS1fIeIOKbdM+37X8r1nqiqSVh0eUT8ZLv3MnPnqrppuF1m/kpEvLG//Kz+FwAA65fKCgAAWN9as+73R8R3I+LlEfH4iGjBwAltzDciWsXEyZm5W0T8XUR8NSJeEhG7R8STewARfYD/LbMOkJn3i4gP96Ci7fO9EfGbEfG4iPj1iHhlRHwjIn40Iv4hM3eden8LR87qQcX3IuK4Fo5ERNvu1yLit/r5XjN16MN7s/JJgPLB/nr4aNsMtXP9TET8SQtqIqJ97idGxMERcd4gRGjns5ijelDxjxHxvH6+B/b9R1/Wjv+XPag4sx9z1x68fLlvd0Rm7rPIsfbrA+1XRsSL+3m3EOqkiLizX7uPTFfKrBF/3oOKcwfXad+I+Ghfv31EHL/cnfZwo12LplUX/c1wfa+QObMHZrdExIbeMwYAgHUoq+5WbQsAAGzOf4BnXt2Dga9X1XZztjusV0E0j6yqq6fWt+mP9uovr2oD8lV1w9Q2x/Vftjdt3X+0yoKqumVqu/f38OGOFn7M2M8fRMSbWlPwiDigqj4243y3johPRcSOEXFxVe05WPeUiLigv2zVATMrJzKzVShsNePX85Nr9u6q2jQ105zr9ktVddWc9S1cOKW/fFpVXTC1vn0nXxssOqGqjp7aZquI+FIfQG+VID8REUdX1Vuntnt4v+at4uVDVXXAjPMZ/ofs0vadVtXNU9sc0oOm5uyqat/VsmTmaW0arYXup+Xeq33qpwsHi15XVXebgqlPf3Ver2ZZ6N5qAc2xPZyYOV1WZp40qExplTubgqbMbCHRq/vy362qdy7lWgAAsDaprAAAgPXvFdODwF2bwmiiTaVzxHRQ0bWpipr790qJu/S+DC2saN42K6hoqup/BsHIHq2HxmB1G7SfWHAao6q6YzqoWK55QUVff2qfKip6lcQ8rdLjD2fso13Ddw+u62emg4pBZcAH+su7wps5jpwOKvp+WvXL5LofuFhvkBFcEhGvnzWV06Ba5x731jIc3StOmtZf5RGZ+eTBfdmCIEEFAMA6J6wAAID1rU3/dP6sFf3X85PB/y9U1b8vsI/LBs9/YWpdmy5qMjjeKjDmGQYRw4Hp6wbPp6dt2mx6k+aHZ+YOvbH4psdgWqmdF9nFOXOmFfrC4Pn75uxjcm1b4+8fn7Pd5VXVBv0Xcspg0H9TQ+s15MweTMxyyZx7a0l6OLShV/a0a3hGD4taJcb1fVozAADWOQ22AQBgfbtqzkBxc2Pvd9CmI5oXeEwMm3RH70sx8c//N7PPkgyrKS7uvTLaYPUJmbmhVxx8ojVFrqrbYxVl5n6918STZnyeoVYVMc9Sr9lyru3w9dC/LXIu/zp43gKXtWTSm2OW7wyez/su5mpBTmb+aUS8oVXuDFYdvkBVEQAA64zKCgAAWN9mTes0dOdi21XVZJtJg+qh1qB7JbYa7L/9In7/iJhUduzWpw36pzZ4n5kfy8yDeiPve1tJcXJrRN0bVi82OP7ge3Ft71zBdvM+37cXOZdvDZ5vE8u3kmaFucT3rvTeWq7jpoKhk6tq0jQdAIB1TmUFAAAwz3CAuU0/9N9LvFx3G3yvqisyc6ceWuzfm4P/Yg8M9umPV2XmvlW12MD9Ql4UES/uzz/fqjhaP4mIuLYNqFfVD9uKzGzNqlvT6iWXidwHVhImLMets4KkRTyk//1+rA3tHtlh8Lr1RnlwVQ0/GwAA65SwAgAAmGcYTtxeVV9c6eXqYcG5/dFCg9YL41kR8dKI2LU/ToqI567wEEf0v/8ZEU+YM4i9daw9D1vG+uHUSkv1nakpuq6Yt3FmPqj3h1jp8VZVZv7UoG/HTX1qs0dFxJsi4mUjnx4AAKvANFAAAMA8nxs8f8ZqXqqquq6qTunNuC/ti5/dfi0/vekSd7lj//vBhYKKNk9UROwSa89uy1i/ksBo2BB8KZ9/50FVzfC9Y3lXD2zatFIHRsRZfflLM7MFXgAArHPCCgAAYJ6LB7+sPyoz2y/aV1XvadGabU+qvye/6J+4rf9tv/ZfSuX4vGmOnhMR28bas1NmPnaRKa6aVp1y0Qr2/8mIuKM/f2EPbeY5ePD8ghhRZh7Vpw5r3lxVF/YG6tf0Zaf2ygsAANYxYQUAALCgqrqtT7UzmT7orMyc9DK4h8x8aGb+/tSyPTNz+znveWDvYdHcHBE3TG1yXf/belzMc1X/u39m3mOqp8xs7397rF3vnHVtW/PxiNi3vzy3VaQsd8dVdX1EnD2orHjNQttm5lNaMNVffj0iPhwjyczWo+LN/eVlEfG69qSqvhsRh/ZKi1Zx8bdjnSMAAKtDWAEAACzmuMGv69uUO61Z9mszc+/M/NUeRrwkM0/vwcLGqfc/NSKuzMyLMvOYzHxmZu6SmU/MzMMj4lODqYlOrqpJBcDEp/vf3TLzNZm5cws/+uNnB9u1xtlNW/bptu/M3D0zn5SZ7ZwuiYhtBlNOrSWfjYjHtb+ZeVhm7tpCg8xs4cp7+jbfi4hX34tjvGrQ+Pz1mXl+Zh6SmY/vxzsgM0+OiPMj4gE9CDh8xvdxn8jMdg5n9EqZFpptqKrbJ+t7hcVb+st27pOeJQAArEMabAMAAIs2xs7MNg3POyLidyLiEW2we85bJgPi0z+U2mtQQTHLORHx2hnLT+zT/rSg4Q39MdGmj9q7P39rRDy999Z41KAh88St/fz3W4N9Kz7aH8e2aY1mrG9NpZ9TVVev9ACtIqMFNxHxgYj45X6dFupD0ioXDu6BwFg29gCn+aOq+tKMbf64f+etx8bxmXlhVX3lPj5PAABWgcoKAABgUa1hdVUd2gePW3jQBo5v7H0Q2sD253sT5Of3gfDpyow2jdHxEfEvEfGN/kv59miD7+9rAUJV/Uafdmr62NdGxO59/20g+h7bDHpftCDiFb1S4ZYeUHylBy27VNXfr9Wvu6ra4Pw+PbT4VkTc3q9Pq67Ysao+sQrHuDIiHtN7Upzdp3m6pR/r+l5Bc0xEbFdV7TxGkZl7DKaq+nhE/PWs7XqlxYZ+T7QptE7PTD/KAwBYh7Kqxj4HAACALVJmTv5D9mc9rAAAgC2SygoAAAAAAGBUwgoAAAAAAGBUwgoAAAAAAGBUwgoAAAAAAGBUwgoAAAAAAGBUWVXjngEAAAAAALBFU1kBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAACMSlgBAAAAAADEmP4XOzATOs/0D0kAAAAASUVORK5CYII=\n" + }, + "metadata": { + "image/png": { + "width": 789, + "height": 390 + }, + "needs_background": "light" + } + } + ], + "execution_count": 4 + }, + { + "id": "4dc14371", + "cell_type": "markdown", + "source": [ + "## 2. Load Synthetic Temporal Alert Graph from CNS\n", + "\n", + "We load the pre-generated `alert_regression_30k_deg16` dataset (15,000 alerts, 15,000 hardware devices) directly from CNS using `dgf.io.read_graph`.\n", + "\n", + "### Dataset Generation Command\n", + "If you do not have access to the CNS directory or want to generate the dataset locally or with custom parameters, run:\n", + "\n", + "```bash\n", + "blaze run -c opt //third_party/py/dgf/src/bin/experimental:gen_temporal_alert_graph_main -- \\\n", + " --base_output_dir=/cns/iz-d/home/research-graph/public/graphflow_datasets/synthetic_temporal \\\n", + " --dataset_name=alert_regression_30k_deg16 \\\n", + " --num_hardware=15000 \\\n", + " --num_alerts=15000 \\\n", + " --neighbor_decay=0.8 \\\n", + " --max_hardware_per_alert=16 \\\n", + " --signal_period=7200 \\\n", + " --seed=42\n", + "```\n", + "\n", + "### Why the degree cap?\n", + "The number of hardware devices attached to an alert is drawn from a geometric distribution\n", + "(`neighbor_decay=0.8`, mean 5). Its tail is long: across 15,000 alerts the largest in-degree is\n", + "around 43. Those few hub alerts produce sampled subgraphs far larger than the typical one, which\n", + "forces the batch padding to be sized for the worst case.\n", + "\n", + "`--max_hardware_per_alert=16` clips that tail while leaving the bulk of the data untouched: the mean\n", + "in-degree only drops from 5.00 to `(1 - 0.8^16) / 0.2 = 4.86`, i.e. ~3% fewer edges.\n", + "\n", + "### Graph Structure & Domain Model\n", + "This bipartite, heterogeneous temporal graph models hardware monitoring alerts:\n", + "- **`hardware` nodes**: Physical machines emitting telemetry signals over time.\n", + " - `#id`: Unique primary identifier.\n", + " - `creation_time`: Base timestamp when the device became active.\n", + " - `time` & `signal` (dynamic timeseries): Timestamped sensor telemetry readings.\n", + "- **`alerts` nodes**: Incident events triggered at specific points in time.\n", + " - `#id`: Unique primary identifier.\n", + " - `creation_time`: The timestamp when the alert fired.\n", + " - `signal_regression` (target): The continuous regression label to predict, representing the time- and neighbor-averaged telemetry signals over the 1-hour lookback window.\n", + "- **`hardware_to_alert` edges**: Directed edges connecting hardware entities to the alerts they triggered.\n", + "\n", + "We first load and validate the graph." + ], + "metadata": { + "id": "4dc14371" + } + }, + { + "id": "e030239d", + "cell_type": "code", + "source": [ + "DATASET_PATH = \"/cns/iz-d/home/research-graph/public/graphflow_datasets/synthetic_temporal/alert_regression_30k_deg16\"\n", + "\n", + "graph, schema = dgf.io.read_graph(DATASET_PATH)\n", + "dgf.validate.validate_graph(graph, schema)" + ], + "metadata": { + "executionInfo": { + "status": "ok", + "timestamp": 1789380568488, + "user_tz": -120, + "elapsed": 15991, + "user": { + "displayName": "", + "userId": "" + } + }, + "outputId": "1cb1a9dc-9b91-4ceb-bd0e-4f85b6a6622b", + "id": "e030239d" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Graph read in memory in 15.97s\n" + ] + } + ] + }, + { + "id": "5b0b18c3", + "cell_type": "markdown", + "source": [ + "### Inspect Graph Schema\n", + "\n", + "Next, we inspect the node features and timestamps via `dgf.print.schema`:\n" + ], + "metadata": { + "id": "5b0b18c3" + } + }, + { + "id": "c0df61cd", + "cell_type": "code", + "source": [ + "dgf.print.schema(schema)" + ], + "metadata": { + "executionInfo": { + "status": "ok", + "timestamp": 1789380568545, + "user_tz": -120, + "elapsed": 13, + "user": { + "displayName": "", + "userId": "" + } + }, + "outputId": "ccb1baa7-e90d-4766-8af2-2724aaa7290b", + "id": "c0df61cd" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Graph Schema:\n", + "\n", + "Node Sets:\n", + " alerts:\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |-------------------|------------|------------|---------|-----------------|\n", + " | #id | BYTES | PRIMARY_ID | None | None |\n", + " | creation_time | INTEGER_64 | TIMESTAMP | None | None |\n", + " | signal_regression | FLOAT_32 | NUMERICAL | None | None |\n", + "\n", + " hardware:\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |---------------|------------|------------|---------|-----------------|\n", + " | #id | BYTES | PRIMARY_ID | None | None |\n", + " | creation_time | INTEGER_64 | TIMESTAMP | None | None |\n", + " | signal | FLOAT_32 | NUMERICAL | (None,) | None |\n", + " | time | INTEGER_64 | TIMESTAMP | (None,) | None |\n", + "\n", + "\n", + "Edge Sets:\n", + " hardware_to_alert: (Source: hardware, Target: alerts)\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |---------------|------------|------------|---------|-----------------|\n", + " | creation_time | INTEGER_64 | TIMESTAMP | None | None |\n", + "\n" + ] + } + ] + }, + { + "id": "5568c26f", + "cell_type": "markdown", + "source": [ + "## 3. Chronological Temporal Train / Validation Split\n", + "\n", + "In temporal graph learning, a random train / validation split leaks future information into the training set. Therefore, when `time_aware=True`, `dgf.learning.train_node_model` splits the seed nodes **chronologically** instead of randomly, using the creation timestamp of the target nodeset. The size of the split is controlled by `validation_ratio`:\n", + "- **Past alerts (80%)**: Used as training set.\n", + "- **Future alerts (20%)**: Used as validation set.\n", + "\n", + "No manual split is required. The plot below illustrates this split with two alert nodes, one from the training and one from the validation period, together with their respective timeseries. In the signal regression graph, the predicted signal at an alert depends on the previous hour (shaded)." + ], + "metadata": { + "id": "5568c26f" + } + }, + { + "metadata": { + "cellView": "form", + "colab": { + "height": 458 + }, + "id": "Lu2zg1cbe4OT", + "executionInfo": { + "status": "ok", + "timestamp": 1789380569001, + "user_tz": -120, + "elapsed": 416, + "user": { + "displayName": "", + "userId": "" + } + }, + "outputId": "226e85f0-358a-4005-830e-527a35d2e143" + }, + "id": "Lu2zg1cbe4OT", + "cell_type": "code", + "source": [ + "#@title Plot Train vs. Validation Signal Evolution (Click to toggle code)\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Same validation ratio as the one given to `train_node_model` below.\n", + "VALIDATION_RATIO = 0.2\n", + "# The regression target depends on the telemetry observed in this window.\n", + "LOOKBACK_SECONDS = 3600.0\n", + "\n", + "# 1. Reproduce the chronological split for illustration: the alerts are sorted\n", + "# by creation time, the oldest ones are used for training and the most\n", + "# recent ones for validation.\n", + "alert_timestamps = graph.node_sets[\"alerts\"].features[\"creation_time\"]\n", + "chronological_alerts = np.argsort(alert_timestamps, kind=\"stable\")\n", + "num_valid_alerts = int(len(chronological_alerts) * VALIDATION_RATIO)\n", + "train_alert_idxs = chronological_alerts[:-num_valid_alerts]\n", + "valid_alert_idxs = chronological_alerts[-num_valid_alerts:]\n", + "\n", + "# 2. Pick one alert from the training period and one from the validation\n", + "# period. Both are sorted chronologically, so we skip the first alerts to\n", + "# get a validation alert that is clearly after the split cutoff.\n", + "train_alert_idx = int(train_alert_idxs[1200])\n", + "valid_alert_idx = int(valid_alert_idxs[1200])\n", + "\n", + "# 3. Find the connected hardware device for each alert\n", + "adj = graph.edge_sets[\"hardware_to_alert\"].adjacency\n", + "train_hw_matches = adj[0][adj[1] == train_alert_idx]\n", + "valid_hw_matches = adj[0][adj[1] == valid_alert_idx]\n", + "\n", + "train_hw_idx = train_hw_matches[0] if len(train_hw_matches) > 0 else 0\n", + "valid_hw_idx = valid_hw_matches[0] if len(valid_hw_matches) > 0 else 1\n", + "\n", + "# 4. Retrieve their telemetry signals over time\n", + "train_times = graph.node_sets[\"hardware\"].features[\"time\"][train_hw_idx]\n", + "train_signal = graph.node_sets[\"hardware\"].features[\"signal\"][train_hw_idx]\n", + "\n", + "valid_times = graph.node_sets[\"hardware\"].features[\"time\"][valid_hw_idx]\n", + "valid_signal = graph.node_sets[\"hardware\"].features[\"signal\"][valid_hw_idx]\n", + "\n", + "# Reference start timestamp and conversion to hours\n", + "t0 = alert_timestamps.min()\n", + "to_hours = lambda t: (t - t0) / 3600.0\n", + "\n", + "# The split cutoff is the timestamp of the first (earliest) validation alert.\n", + "split_time = alert_timestamps[valid_alert_idxs[0]]\n", + "train_alert_t = alert_timestamps[train_alert_idx]\n", + "valid_alert_t = alert_timestamps[valid_alert_idx]\n", + "\n", + "# 5. Plot both signals evolving over time\n", + "plt.figure(figsize=(10, 4.5), dpi=100)\n", + "\n", + "# Training signal (blue)\n", + "plt.plot(\n", + " to_hours(train_times),\n", + " train_signal,\n", + " color=\"#1f77b4\",\n", + " linewidth=2,\n", + " marker=\"o\",\n", + " markersize=4,\n", + " label=f\"Train Signal (hw_{train_hw_idx} for alert_{train_alert_idx})\",\n", + ")\n", + "\n", + "# Validation signal (orange)\n", + "plt.plot(\n", + " to_hours(valid_times),\n", + " valid_signal,\n", + " color=\"#ff7f0e\",\n", + " linewidth=2,\n", + " marker=\"s\",\n", + " markersize=4,\n", + " label=f\"Validation Signal (hw_{valid_hw_idx} for alert_{valid_alert_idx})\",\n", + ")\n", + "\n", + "# Mark the respective alert occurrences\n", + "plt.axvline(\n", + " to_hours(train_alert_t),\n", + " color=\"#1f77b4\",\n", + " linestyle=\":\",\n", + " linewidth=1.5,\n", + " alpha=0.8,\n", + " label=f\"Train Alert Time ({to_hours(train_alert_t):.1f}h)\",\n", + ")\n", + "plt.axvline(\n", + " to_hours(valid_alert_t),\n", + " color=\"#ff7f0e\",\n", + " linestyle=\":\",\n", + " linewidth=1.5,\n", + " alpha=0.8,\n", + " label=f\"Validation Alert Time ({to_hours(valid_alert_t):.1f}h)\",\n", + ")\n", + "\n", + "# Shade the 1h look-back window preceding each alert: this is the period the\n", + "# alert signal regression depends on.\n", + "plt.axvspan(\n", + " to_hours(train_alert_t - LOOKBACK_SECONDS),\n", + " to_hours(train_alert_t),\n", + " color=\"#1f77b4\",\n", + " alpha=0.12,\n", + ")\n", + "plt.axvspan(\n", + " to_hours(valid_alert_t - LOOKBACK_SECONDS),\n", + " to_hours(valid_alert_t),\n", + " color=\"#ff7f0e\",\n", + " alpha=0.12,\n", + ")\n", + "\n", + "# Chronological split cutoff\n", + "plt.axvline(\n", + " to_hours(split_time),\n", + " color=\"#d62728\",\n", + " linestyle=\"--\",\n", + " linewidth=2,\n", + " label=f\"Train/Valid Split Cutoff ({to_hours(split_time):.1f}h)\",\n", + ")\n", + "\n", + "plt.title(\n", + " \"Signal Evolution: Training Sample vs. Validation Sample\",\n", + " fontsize=12,\n", + " fontweight=\"bold\",\n", + ")\n", + "plt.xlabel(\"Time (hours from simulation start)\", fontsize=10)\n", + "plt.ylabel(\"Telemetry Signal Value\", fontsize=10)\n", + "plt.grid(True, linestyle=\":\", alpha=0.6)\n", + "plt.legend(loc=\"upper left\", framealpha=0.9, fontsize=9)\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "image/png": { + "width": 989, + "height": 441 + }, + "needs_background": "light" + } + } + ], + "execution_count": 7 + }, + { + "id": "d766ad6a", + "cell_type": "markdown", + "source": [ + "## 4. Train Time-Aware Temporal Node Prediction Model\n", + "\n", + "We use DGF's high-level training API:\n", + "- `target_nodeset=\"alerts\"`: Predict target feature on the `alerts` nodes.\n", + "- `target_column=\"signal_regression\"`: Target continuous regression feature.\n", + "- `time_aware=True`: Enforces temporal masking during sampling, and splits the training and validation sets chronologically.\n", + "- `validation_ratio=0.2`: The most recent 20% of the alerts are used for validation, the older 80% for training.\n", + "\n", + "We train for 15'000 steps. If you do not have access to a GPU this takes a couple minutes unless you reduce the amount of steps." + ], + "metadata": { + "id": "d766ad6a" + } + }, + { + "id": "6a8a70d9", + "cell_type": "code", + "source": [ + "# Train the model with time-aware causal sampling. The train / validation\n", + "# split is done chronologically (past alerts for training, future alerts for\n", + "# validation).\n", + "model = dgf.learning.train_node_model(\n", + " graph=graph,\n", + " schema=schema,\n", + " target_nodeset=\"alerts\",\n", + " target_column=\"signal_regression\",\n", + " time_aware=True,\n", + " validation_ratio=0.2,\n", + " num_train_steps=15_000,\n", + " batch_size=32,\n", + " verbose=2,\n", + ")" + ], + "metadata": { + "executionInfo": { + "status": "ok", + "timestamp": 1789380877538, + "user_tz": -120, + "elapsed": 308469, + "user": { + "displayName": "", + "userId": "" + } + }, + "outputId": "041f65ee-da86-4c59-ad81-2d755fb193ef", + "id": "6a8a70d9" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Using gpu JAX backend\n", + "Graph input schema:\n", + "Node Sets:\n", + " alerts:\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |-------------------|------------|------------|---------|-----------------|\n", + " | #id | BYTES | PRIMARY_ID | None | None |\n", + " | creation_time | INTEGER_64 | TIMESTAMP | None | None |\n", + " | signal_regression | FLOAT_32 | NUMERICAL | None | None |\n", + "\n", + " hardware:\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |---------------|------------|------------|---------|-----------------|\n", + " | #id | BYTES | PRIMARY_ID | None | None |\n", + " | creation_time | INTEGER_64 | TIMESTAMP | None | None |\n", + " | signal | FLOAT_32 | NUMERICAL | (None,) | None |\n", + " | time | INTEGER_64 | TIMESTAMP | (None,) | None |\n", + "\n", + "\n", + "Edge Sets:\n", + " hardware_to_alert: (Source: hardware, Target: alerts)\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |---------------|------------|------------|---------|-----------------|\n", + " | creation_time | INTEGER_64 | TIMESTAMP | None | None |\n", + "\n", + "Preparing dataset\n", + "Splitting the train and validation sets temporally on the creation timestamp feature 'creation_time' of nodeset 'alerts': the oldest nodes are used for training and the most recent ones for validation (instead of a random split).\n", + "Num. training seed nodes: 12000, Num. validation seed nodes: 3000\n", + "Create graph sampler\n", + "Compute feature statistics\n", + " GraphFeatureStatistics:\n", + " Node Sets (2):\n", + " 'alerts':\n", + " '#id': count=103354, min=nan, max=nan\n", + " 'creation_time': count=103354, min=1700003600.0000, max=1700070162.0000\n", + " 'signal_regression': count=103354, min=-0.7686, max=0.7531, quantiles=(100)[-0.7566, -0.5674, -0.4967, ..., 0.4714, 0.5536, 0.7531]\n", + " 'hardware':\n", + " '#id': count=48095, min=nan, max=nan\n", + " 'creation_time': count=48095, min=1700000000.0000, max=1700000000.0000\n", + " 'signal': count=48095, min=-1.4500, max=1.3895, quantiles=(100)[-1.3026, -1.1176, -1.0842, ..., 1.0806, 1.1218, 1.2480]\n", + " 'time': count=48095, min=1700000000.0000, max=1700070131.0000\n", + "\n", + "Compute graph statistics for padding\n", + " padding: Node Sets:\n", + " alerts: 613 nodes\n", + " hardware: 239 nodes\n", + "\n", + "Edge Sets:\n", + " hardware_to_alert: 816 edges\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "[Warning] No normalizer created for node set 'hardware', feature '#id'.\n", + "[Warning] No normalizer created for node set 'alerts', feature '#id'.\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Preparing dataset finished in 2.70 seconds\n", + "Normalizer:\n", + "Graph Normalizer:\n", + "\n", + "Node Sets:\n", + " alerts:\n", + " - creation_time: SequentialNormalizer\n", + " - signal_regression: IdentityNormalizer\n", + "\n", + " hardware:\n", + " - creation_time: SequentialNormalizer\n", + " - signal: SoftQuantileNormalizer\n", + " - time: SequentialNormalizer\n", + " - time_mask: IdentityNormalizer\n", + "\n", + "Edge Sets:\n", + " hardware_to_alert: (Source: hardware, Target: alerts)\n", + " (No normalizers)\n", + "\n", + "Normalized graph schema:\n", + "Node Sets:\n", + " alerts:\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |-----------------------------------|----------|------------|---------|-----------------|\n", + " | creation_time_seed_delta_SINUSOID | FLOAT_32 | EMBEDDING | (32,) | None |\n", + " | signal_regression | FLOAT_32 | NUMERICAL | None | None |\n", + "\n", + " hardware:\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |-----------------------------------|----------|------------|----------|-----------------|\n", + " | creation_time_seed_delta_SINUSOID | FLOAT_32 | EMBEDDING | (32,) | None |\n", + " | signal_SOFT_QUANTILE | FLOAT_32 | EMBEDDING | (32,) | None |\n", + " | time_mask | BOOL | MASK | (32,) | None |\n", + " | time_seed_delta_SINUSOID | FLOAT_32 | EMBEDDING | (32, 32) | None |\n", + "\n", + "\n", + "Edge Sets:\n", + " hardware_to_alert: (Source: hardware, Target: alerts)\n", + " (No features)\n", + "\n", + "Core model config:\n", + " EmbedGraph(cat-embedding=64)\n", + " Dense(128)\n", + " Activation(silu)\n", + " Norm(layer_norm)\n", + " Graph Convolution Block x2:\n", + " X = ...\n", + " MPNN:\n", + " Message:\n", + " Dense(128)\n", + " Activation(silu)\n", + " Dense(128)\n", + " Update:\n", + " Dense(128)\n", + " Activation(silu)\n", + " Dropout(0.1)\n", + " Dense(128)\n", + " Residual(X)\n", + " # Post MPNN\n", + " X = ...\n", + " Norm(rms_norm)\n", + " Dense(512)\n", + " Activation(silu)\n", + " Dense(128)\n", + " Dropout(0.1)\n", + " Residual(X)\n", + " Identity\n", + " Dense(1) # Regression head\n", + "Normalized input features:\n", + "Node Sets:\n", + " alerts:\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |-----------------------------------|----------|------------|---------|-----------------|\n", + " | creation_time_seed_delta_SINUSOID | FLOAT_32 | EMBEDDING | (32,) | None |\n", + "\n", + " hardware:\n", + " | Feature | Format | Semantic | Shape | Num cat. vals |\n", + " |-----------------------------------|----------|------------|----------|-----------------|\n", + " | creation_time_seed_delta_SINUSOID | FLOAT_32 | EMBEDDING | (32,) | None |\n", + " | signal_SOFT_QUANTILE | FLOAT_32 | EMBEDDING | (32,) | None |\n", + " | time_mask | BOOL | MASK | (32,) | None |\n", + " | time_seed_delta_SINUSOID | FLOAT_32 | EMBEDDING | (32, 32) | None |\n", + "\n", + "\n", + "Edge Sets:\n", + " hardware_to_alert: (Source: hardware, Target: alerts)\n", + " (No features)\n", + "\n", + "Caching validation dataset\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Caching validation dataset: 17%|█▋ | 16/93 [00:00<00:04, 16.73it/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Caching validation dataset finished in 0.96 seconds\n", + "Number of cache validation batches: 16\n", + "Training model\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Generate first batch to initialize model\n", + "Create model variables\n", + "...Tracing model\n", + "Create model variables finished in 19.91 seconds\n", + "Will validate model every 1000 step(s)\n", + "Will checkpoint model every 1000 step(s)\n", + "Start training. The first two steps are generally slow.\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rTraining: 0%| | 0/15000 [00:00" + ], + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
\n", + "
\n", + "

Node prediction model: Predict the value of a node feature.

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TypeNode prediction model - Predict the value of a node feature.
Target nodesetalerts
Target columnsignal_regression
Number of label classes1
\n", + "
\n", + "
\n", + "\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
WARNINGNo normalizer created for node set 'hardware', feature '#id'.
WARNINGNo normalizer created for node set 'alerts', feature '#id'.
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
RMSE0.025249014309569356
R20.9913621544837952
Num Examples3000
\n", + "
\n", + "\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "
Number of training seed nodes12000
Number of validation seed nodes3000
Training duration5m 2s
Number of training steps (final model)15000
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "

Note: The logs for the first training step are not shown.

\n", + "
\n", + "
\n", + "\n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + "
num_sampling_hops2
sampling_width15
num_layers2
batch_size32
max_training_time_secondsNone
num_train_steps15000
random_seed42
node_embedding_dim128
learning_rate0.001
opt_weight_decay0.0001
dropout0.1
message_pooling'sum'
architecture<Architecture.HETEROGENEOUS_MESSAGE_PASSING: 'HETEROGENEOUS_MESSAGE_PASSING'>
early_stopping{'patience': 5, 'min_improvement': 1e-06}
\n", + "
\n", + "
Raw schema plot\n", + "\n", + "Raw schema textual\n", + "
Node Sets:\n",
+              "  alerts:\n",
+              "    | Feature           | Format     | Semantic   | Shape   | Num cat. vals   |\n",
+              "    |-------------------|------------|------------|---------|-----------------|\n",
+              "    | #id               | BYTES      | PRIMARY_ID | None    | None            |\n",
+              "    | creation_time     | INTEGER_64 | TIMESTAMP  | None    | None            |\n",
+              "    | signal_regression | FLOAT_32   | NUMERICAL  | None    | None            |\n",
+              "\n",
+              "  hardware:\n",
+              "    | Feature       | Format     | Semantic   | Shape   | Num cat. vals   |\n",
+              "    |---------------|------------|------------|---------|-----------------|\n",
+              "    | #id           | BYTES      | PRIMARY_ID | None    | None            |\n",
+              "    | creation_time | INTEGER_64 | TIMESTAMP  | None    | None            |\n",
+              "    | signal        | FLOAT_32   | NUMERICAL  | (None,) | None            |\n",
+              "    | time          | INTEGER_64 | TIMESTAMP  | (None,) | None            |\n",
+              "\n",
+              "\n",
+              "Edge Sets:\n",
+              "  hardware_to_alert: (Source: hardware, Target: alerts)\n",
+              "    | Feature       | Format     | Semantic   | Shape   | Num cat. vals   |\n",
+              "    |---------------|------------|------------|---------|-----------------|\n",
+              "    | creation_time | INTEGER_64 | TIMESTAMP  | None    | None            |\n",
+              "
\n", + "Normalized schema plot\n", + "\n", + "Normalized schema textual\n", + "
Node Sets:\n",
+              "  alerts:\n",
+              "    | Feature                           | Format   | Semantic   | Shape   | Num cat. vals   |\n",
+              "    |-----------------------------------|----------|------------|---------|-----------------|\n",
+              "    | creation_time_seed_delta_SINUSOID | FLOAT_32 | EMBEDDING  | (32,)   | None            |\n",
+              "    | signal_regression                 | FLOAT_32 | NUMERICAL  | None    | None            |\n",
+              "\n",
+              "  hardware:\n",
+              "    | Feature                           | Format   | Semantic   | Shape    | Num cat. vals   |\n",
+              "    |-----------------------------------|----------|------------|----------|-----------------|\n",
+              "    | creation_time_seed_delta_SINUSOID | FLOAT_32 | EMBEDDING  | (32,)    | None            |\n",
+              "    | signal_SOFT_QUANTILE              | FLOAT_32 | EMBEDDING  | (32,)    | None            |\n",
+              "    | time_mask                         | BOOL     | MASK       | (32,)    | None            |\n",
+              "    | time_seed_delta_SINUSOID          | FLOAT_32 | EMBEDDING  | (32, 32) | None            |\n",
+              "\n",
+              "\n",
+              "Edge Sets:\n",
+              "  hardware_to_alert: (Source: hardware, Target: alerts)\n",
+              "    (No features)\n",
+              "
\n", + "
\n", + "
Default feature statistics\n", + "
GraphFeatureStatistics:\n",
+              "  Node Sets (2):\n",
+              "    'alerts':\n",
+              "      '#id': count=103354, min=nan, max=nan\n",
+              "      'creation_time': count=103354, min=1700003600.0000, max=1700070162.0000\n",
+              "      'signal_regression': count=103354, min=-0.7686, max=0.7531, quantiles=(100)[-0.7566, -0.5674, -0.4967, ..., 0.4714, 0.5536, 0.7531]\n",
+              "    'hardware':\n",
+              "      '#id': count=48095, min=nan, max=nan\n",
+              "      'creation_time': count=48095, min=1700000000.0000, max=1700000000.0000\n",
+              "      'signal': count=48095, min=-1.4500, max=1.3895, quantiles=(100)[-1.3026, -1.1176, -1.0842, ..., 1.0806, 1.1218, 1.2480]\n",
+              "      'time': count=48095, min=1700000000.0000, max=1700070131.0000\n",
+              "
\n", + "
\n", + "
Default sampling plan\n", + "
Root: alerts\n",
+              "└── hardware_to_alert (reversed) [width=15] ➔ hardware\n",
+              "    └── hardware_to_alert [width=15] ➔ alerts
\n", + "
\n", + "
Model Structure\n", + "
EmbedGraph(cat-embedding=64)\n",
+              "Dense(128)\n",
+              "Activation(silu)\n",
+              "Norm(layer_norm)\n",
+              "Graph Convolution Block x2:\n",
+              "    X = ...\n",
+              "    MPNN:\n",
+              "      Message:\n",
+              "        Dense(128)\n",
+              "        Activation(silu)\n",
+              "        Dense(128)\n",
+              "      Update:\n",
+              "        Dense(128)\n",
+              "        Activation(silu)\n",
+              "        Dropout(0.1)\n",
+              "        Dense(128)\n",
+              "    Residual(X)\n",
+              "    # Post MPNN\n",
+              "    X = ...\n",
+              "    Norm(rms_norm)\n",
+              "    Dense(512)\n",
+              "    Activation(silu)\n",
+              "    Dense(128)\n",
+              "    Dropout(0.1)\n",
+              "    Residual(X)\n",
+              "Identity\n",
+              "Dense(1) # Regression head
\n", + "Model Weights\n", + "
{'float32': 963073}
\n", + "
Default padding\n", + "
Node Sets:\n",
+              "  alerts: 613 nodes\n",
+              "  hardware: 239 nodes\n",
+              "\n",
+              "Edge Sets:\n",
+              "  hardware_to_alert: 816 edges
\n", + "
\n", + "\n", + "\n", + "\n", + "
" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ], + "execution_count": 9 + }, + { + "metadata": { + "id": "LHliPXhWQP5T" + }, + "id": "LHliPXhWQP5T", + "cell_type": "markdown", + "source": [ + "## 6. Evaluate Model\n", + "\n", + "We finally evaluate the model on the validation alerts, i.e. the most recent 20% of the alerts that were held out during training. We see that most of the variance is explained by our model." + ] + }, + { + "metadata": { + "colab": { + "height": 148 + }, + "executionInfo": { + "status": "ok", + "timestamp": 1789380879837, + "user_tz": -120, + "elapsed": 2040, + "user": { + "displayName": "", + "userId": "" + } + }, + "outputId": "288ff781-f8f6-4ce2-e2f1-afc1f6b5ebfd", + "id": "rF-AIsK6vN8t" + }, + "id": "rF-AIsK6vN8t", + "cell_type": "code", + "source": [ + "model.evaluate(graph, seed_node_idxs=valid_alert_idxs, num_eval_steps=3000)" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Evaluating model on 3000 samples\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Inference: 100%|██████████| 188/188 [00:01<00:00, 94.81it/s]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Evaluation(loss=None, accuracy=None, rmse=np.float64(0.025240105922031367), r2=0.9913682341575623, num_examples=3000, num_examples_weighted=None, mrr=None, auc=None, hit_at={}, user_metrics={}, per_classes=[])" + ], + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
RMSE0.025240105922031367
R20.9913682341575623
Num Examples3000
" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ], + "execution_count": 10 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python" + }, + "colab": { + "provenance": [], + "last_runtime": { + "build_target": "", + "kind": "local" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}