From 609fbf4c1c4747da6b5b6e313e89e3da2c36c2a8 Mon Sep 17 00:00:00 2001 From: PythonFZ Date: Thu, 9 Feb 2023 09:45:23 +0100 Subject: [PATCH 01/13] small code changes --- znflow/base.py | 4 ---- znflow/node.py | 29 ++++++++++++++--------------- 2 files changed, 14 insertions(+), 19 deletions(-) diff --git a/znflow/base.py b/znflow/base.py index ce59ef4..9d93acf 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -20,9 +20,7 @@ class NodeBaseMixin: _uuid: UUID = None _protected_ = [ - "_graph_", "uuid", - "_uuid", "result", ] # TODO consider adding regex patterns @@ -80,8 +78,6 @@ class FunctionFuture(NodeBaseMixin): _result: any = dataclasses.field(default=None, init=False, repr=True) - _protected_ = NodeBaseMixin._protected_ + ["function", "args", "kwargs"] - def run(self): self._result = self.function(*self.args, **self.kwargs) diff --git a/znflow/node.py b/znflow/node.py index a6da86d..7e03530 100644 --- a/znflow/node.py +++ b/znflow/node.py @@ -47,24 +47,23 @@ def wrapper(*args, **kwargs): def __getattribute__(self, item): value = super().__getattribute__(item) - if get_graph() is not None: - if item not in type(self)._protected_ and not item.startswith("_"): - if self._in_construction: - return value - connector = Connection(instance=self, attribute=item) - return connector + if ( + get_graph() is not None + and item not in type(self)._protected_ + and not item.startswith("_") + ): + if self._in_construction: + return value + return Connection(instance=self, attribute=item) return value def __setattr__(self, item, value) -> None: - if get_graph() is not None: - if isinstance(value, Connection): - assert ( - self.uuid in self._graph_ - ), f"'{self.uuid=}' not in '{self._graph_=}'" - assert value.uuid in self._graph_ - self._graph_.add_edge( - value.uuid, self.uuid, u_attr=value.attribute, v_attr=item - ) + if get_graph() is not None and isinstance(value, Connection): + assert self.uuid in self._graph_, f"'{self.uuid=}' not in '{self._graph_=}'" + assert value.uuid in self._graph_ + self._graph_.add_edge( + value.uuid, self.uuid, u_attr=value.attribute, v_attr=item + ) super().__setattr__(item, value) From cb506f8b6fadab1335fc286c7a00e3979174b956 Mon Sep 17 00:00:00 2001 From: PythonFZ Date: Thu, 9 Feb 2023 09:45:33 +0100 Subject: [PATCH 02/13] move examples --- examples/example_01.ipynb | 562 ++++++++++++++++++++++++++++++++++++++ examples/example_02.ipynb | 224 +++++++++++++++ examples/example_03.ipynb | 212 ++++++++++++++ tmp/example_01.ipynb | 562 -------------------------------------- tmp/example_02.ipynb | 224 --------------- tmp/example_03.ipynb | 211 -------------- 6 files changed, 998 insertions(+), 997 deletions(-) create mode 100644 examples/example_01.ipynb create mode 100644 examples/example_02.ipynb create mode 100644 examples/example_03.ipynb delete mode 100644 tmp/example_01.ipynb delete mode 100644 tmp/example_02.ipynb delete mode 100644 tmp/example_03.ipynb diff --git a/examples/example_01.ipynb b/examples/example_01.ipynb new file mode 100644 index 0000000..8fa66c7 --- /dev/null +++ b/examples/example_01.ipynb @@ -0,0 +1,562 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "530b1d08-7428-42e2-834b-821c9d521396", + "metadata": {}, + "source": [ + "# The ZnFlow Package\n", + "\n", + "Define Node connections using a directional multigraph.\n", + "Nodes are connected through Node attributes.\n", + "A Node can have multiple connections to another Node through different Attributes.\n", + "Each Node is definied by a unique `_id_` which could be automatically generated based on the state of the Node." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4cca5c7c-c687-419a-9bf0-85d26f89b0c0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import znflow\n", + "import dataclasses" + ] + }, + { + "cell_type": "markdown", + "id": "69440df5-47a0-4543-9d95-e5d22269d8d2", + "metadata": {}, + "source": [ + "A Node is inherited from `znflow.Node` and can have many different `znflow.EdgeAttribute` that will connect the Nodes to other Nodes or behave as inputs / outputs from the Node.\n", + "In general a `Node` is very similar to a dataclass and even implements a `_post_init_` method.\n", + "We equip our `Node` with a `run` method that computes the `outputs` based on the `inputs`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9f3e7cd6-a337-4773-b3ec-29c550695db7", + "metadata": {}, + "outputs": [], + "source": [ + "@dataclasses.dataclass\n", + "class Node(znflow.Node):\n", + " inputs: float\n", + " outputs: float = None\n", + " \n", + " def run(self):\n", + " self.outputs = self.inputs * 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "213e5833-4cb5-4412-9d7e-458fa8ad7c36", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Node(inputs=25, outputs=50)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node1 = Node(inputs=25)\n", + "node1.run()\n", + "node1" + ] + }, + { + "cell_type": "markdown", + "id": "79af5875-3aa7-46cf-a722-b97c328f8f00", + "metadata": {}, + "source": [ + "We can now create multiple Nodes and connect them. Nodes are connected through `znflow.GraphManager` as follows.\n", + "Every Node inside the contextmanager will automatically be stored inside the `dag` object." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1ed13020-9b05-44a8-b286-d4b8938ed0d0", + "metadata": {}, + "outputs": [], + "source": [ + "with znflow.DiGraph() as graph:\n", + " node1 = Node(inputs=25)\n", + " node2 = Node(inputs=node1.outputs) # TODO Node(inputs=node1)" + ] + }, + { + "cell_type": "markdown", + "id": "b29c9b9e-39fb-4b26-8983-5c0dd7b55f19", + "metadata": {}, + "source": [ + "If we look at the new Node, we see that `Node.inputs` is now a `NodeConnector` to the connected Node." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "584871c5-7a2f-422d-be37-3391d360cee6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Node(inputs=25, outputs=None)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node1" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0034a2a9-aec9-4d9d-ba0a-22a0c45327c5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Node(inputs=Connection(instance=Node(inputs=25, outputs=None), attribute='outputs'), outputs=None)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "node2" + ] + }, + { + "cell_type": "markdown", + "id": "bc08331b-9c23-4ac7-b769-b1bb1a245309", + "metadata": {}, + "source": [ + "Using `networkx` we can visualize the connection." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "20223fc7-a9f4-40dd-a4b9-213d676e5035", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "znflow.draw(graph)" + ] + }, + { + "cell_type": "markdown", + "id": "d832c0bb-dbca-43ad-9c80-5120250251db", + "metadata": {}, + "source": [ + "Another way of connecting Nodes is through `znflow.DiGraph().write_graph`.\n", + "It is important to mention, that we can not use `node1.outputs` here, because we know `node1.outputs is None`. Therefore, we have to replace it by `node1 @ \"outputs\"`" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f2e47705-bf75-4197-956a-7075012feb41", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "node1.outputs = None\n", + "node1 @ \"outputs\" = Connection(instance=Node(inputs=25, outputs=None), attribute='outputs')\n", + "node2 = Node(inputs=Connection(instance=Node(inputs=25, outputs=None), attribute='outputs'), outputs=None)\n" + ] + } + ], + "source": [ + "node1 = Node(inputs=25)\n", + "node2 = Node(inputs=node1 @ \"outputs\")\n", + "print(f\"{node1.outputs = }\")\n", + "print(f'{node1 @ \"outputs\" = }')\n", + "print(f\"{node2 = }\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "001384f9-f408-4cd5-85a0-0578d6380e58", + "metadata": {}, + "outputs": [], + "source": [ + "graph = znflow.DiGraph()\n", + "graph.write_graph(node1, node2)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "55d82c69-4717-4df1-aa9a-101c71e4fece", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "NodeView((UUID('9e958c3b-2cd8-437a-8c91-e8a0eb6d072b'), UUID('1a9a0646-b641-41ba-8234-e5bce8e54911')))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph.nodes" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ee6fc53b-5965-4cad-958b-e8739acf1a4a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'u_attr': 'outputs', 'v_attr': 'inputs'}]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[graph.edges[x] for x in graph.edges]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "2bac56de-c6ed-4169-8b50-2114c9bf4939", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "znflow.draw(graph)" + ] + }, + { + "cell_type": "markdown", + "id": "6f93a87b-066b-4a4c-84d4-4d8c0dd47e6a", + "metadata": {}, + "source": [ + "# Run the Graph" + ] + }, + { + "cell_type": "markdown", + "id": "6f970fbc-2d86-4ead-9892-e06d03e32117", + "metadata": {}, + "source": [ + "First let's build some more interesting graphs:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5419e6a0-7fca-4953-a496-71ab3a37c2fd", + "metadata": {}, + "outputs": [], + "source": [ + "@dataclasses.dataclass\n", + "class SumNodes(znflow.Node):\n", + " inputs: float\n", + " outputs: float = None\n", + "\n", + " def run(self):\n", + " self.outputs = sum(self.inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "00559229-f492-4146-8937-e16f09628b69", + "metadata": {}, + "outputs": [], + "source": [ + "with znflow.DiGraph() as graph:\n", + " node1 = Node(inputs=5)\n", + " node2 = Node(inputs=10)\n", + " node3 = Node(inputs=node1.outputs)\n", + " node4 = Node(inputs=node2.outputs)\n", + " node5 = SumNodes(inputs=[node3.outputs, node4.outputs])\n", + " node6 = SumNodes(inputs=[node2.outputs, node5.outputs])\n", + " node7 = SumNodes(inputs=[node6.outputs])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "14e05618-8f90-4731-97cc-eb8512b8d90e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "znflow.draw(graph)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "1fe31907-18c0-4897-b419-33dcab8b7a0a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NodeView((UUID('5b0d5286-7150-4d80-af09-1e454c85cfee'), UUID('89fca2e1-1127-4029-ba1f-1a183d55a715'), UUID('12ed54f8-0d06-437c-8af0-3b03269f043a'), UUID('b716dd9a-465e-45e8-acff-8abbf572f82c'), UUID('e2c9bfab-33c5-419b-9201-82378a3f7a29'), UUID('181c1c59-0a63-4a7e-a71b-7c7344d53478'), UUID('7f1b944d-7bd2-4f70-a606-5d47afbefb64')))" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph.run() # default is to call node.run()\n", + "graph.nodes" + ] + }, + { + "cell_type": "markdown", + "id": "627e12cd-aba9-4bc5-a5e3-98fd1208d291", + "metadata": {}, + "source": [ + "Or even more nested" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "fc076fec-a755-4131-9bb7-8e65df3b9fd3", + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "k = 3\n", + "j = 3\n", + "i = 3\n", + "\n", + "with znflow.DiGraph() as graph:\n", + " kdx_nodes = []\n", + " for kdx in range(k):\n", + " jdx_nodes = []\n", + " for jdx in range(j):\n", + " idx_nodes = []\n", + " for idx in range(i):\n", + " idx_nodes.append(Node(inputs=random.random()))\n", + " jdx_nodes.append(SumNodes(inputs=[x.outputs for x in idx_nodes]))\n", + " kdx_nodes.append(SumNodes(inputs=[x.outputs for x in jdx_nodes]))\n", + " \n", + " end_node = SumNodes(inputs=[x.outputs for x in kdx_nodes])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e84c30db-8e84-45e5-a24f-6f75f2cde06a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# nx.draw(dag)\n", + "znflow.draw(graph)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "5ed3a78e-6534-42a4-a492-a7a671b525e6", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: total: 188 ms\n", + "Wall time: 543 ms\n" + ] + }, + { + "data": { + "text/plain": [ + "[Node(inputs=0.10663079059035918, outputs=0.21326158118071836),\n", + " Node(inputs=0.30852669713678826, outputs=0.6170533942735765),\n", + " Node(inputs=0.42205628383069327, outputs=0.8441125676613865),\n", + " SumNodes(inputs=[0.21326158118071836, 0.6170533942735765, 0.8441125676613865], outputs=1.6744275431156814),\n", + " Node(inputs=0.6510224933866161, outputs=1.3020449867732322),\n", + " Node(inputs=0.1295009840471666, outputs=0.2590019680943332),\n", + " Node(inputs=0.3126692143734394, outputs=0.6253384287468788),\n", + " SumNodes(inputs=[1.3020449867732322, 0.2590019680943332, 0.6253384287468788], outputs=2.1863853836144442),\n", + " Node(inputs=0.47455176145635425, outputs=0.9491035229127085),\n", + " Node(inputs=0.0828630775610798, outputs=0.1657261551221596),\n", + " Node(inputs=0.8899480785337845, outputs=1.779896157067569),\n", + " SumNodes(inputs=[0.9491035229127085, 0.1657261551221596, 1.779896157067569], outputs=2.894725835102437),\n", + " SumNodes(inputs=[1.6744275431156814, 2.1863853836144442, 2.894725835102437], outputs=6.755538761832563),\n", + " Node(inputs=0.930012031849439, outputs=1.860024063698878),\n", + " Node(inputs=0.23878709674097842, outputs=0.47757419348195684),\n", + " Node(inputs=0.02920544282395754, outputs=0.05841088564791508),\n", + " SumNodes(inputs=[1.860024063698878, 0.47757419348195684, 0.05841088564791508], outputs=2.39600914282875),\n", + " Node(inputs=0.72111060695909, outputs=1.44222121391818),\n", + " Node(inputs=0.9173038860275148, outputs=1.8346077720550296),\n", + " Node(inputs=0.34108516393087207, outputs=0.6821703278617441),\n", + " SumNodes(inputs=[1.44222121391818, 1.8346077720550296, 0.6821703278617441], outputs=3.958999313834954),\n", + " Node(inputs=0.7321596272583626, outputs=1.4643192545167252),\n", + " Node(inputs=0.14906104753801586, outputs=0.2981220950760317),\n", + " Node(inputs=0.7227008525188711, outputs=1.4454017050377421),\n", + " SumNodes(inputs=[1.4643192545167252, 0.2981220950760317, 1.4454017050377421], outputs=3.207843054630499),\n", + " SumNodes(inputs=[2.39600914282875, 3.958999313834954, 3.207843054630499], outputs=9.562851511294202),\n", + " Node(inputs=0.7923095717771177, outputs=1.5846191435542354),\n", + " Node(inputs=0.7648151500433338, outputs=1.5296303000866676),\n", + " Node(inputs=0.7510871700970005, outputs=1.502174340194001),\n", + " SumNodes(inputs=[1.5846191435542354, 1.5296303000866676, 1.502174340194001], outputs=4.616423783834904),\n", + " Node(inputs=0.10828153052898914, outputs=0.2165630610579783),\n", + " Node(inputs=0.13104154391962364, outputs=0.2620830878392473),\n", + " Node(inputs=0.5824887228135961, outputs=1.1649774456271922),\n", + " SumNodes(inputs=[0.2165630610579783, 0.2620830878392473, 1.1649774456271922], outputs=1.6436235945244178),\n", + " Node(inputs=0.9738913614453244, outputs=1.9477827228906488),\n", + " Node(inputs=0.6463907384520062, outputs=1.2927814769040125),\n", + " Node(inputs=0.6065561765646229, outputs=1.2131123531292458),\n", + " SumNodes(inputs=[1.9477827228906488, 1.2927814769040125, 1.2131123531292458], outputs=4.453676552923907),\n", + " SumNodes(inputs=[4.616423783834904, 1.6436235945244178, 4.453676552923907], outputs=10.71372393128323),\n", + " SumNodes(inputs=[6.755538761832563, 9.562851511294202, 10.71372393128323], outputs=27.032114204409996)]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%time graph.run() # default is to call node.run()\n", + "# # [x._id_ for x in dag.nodes]\n", + "[graph.nodes[x][\"value\"] for x in graph.nodes]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b37c8558-bf14-4060-aff1-0ab3b0aea476", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "SumNodes(inputs=[6.755538761832563, 9.562851511294202, 10.71372393128323], outputs=27.032114204409996)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "end_node" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c7751343-80c8-4578-8b62-e358b3773668", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/example_02.ipynb b/examples/example_02.ipynb new file mode 100644 index 0000000..fc05250 --- /dev/null +++ b/examples/example_02.ipynb @@ -0,0 +1,224 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4e964158-14bc-4439-a44f-ef64b39c862f", + "metadata": {}, + "source": [ + "# Functions and Graphs" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "51740efc-d1f9-408d-a611-a87fcf8bfb53", + "metadata": {}, + "outputs": [], + "source": [ + "import znflow" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d12195fe-2c88-4692-999c-6dd48fe5a140", + "metadata": {}, + "outputs": [], + "source": [ + "@znflow.nodify\n", + "def add(*args):\n", + " return sum(args)\n", + "\n", + "@znflow.nodify\n", + "def multiply(a, b):\n", + " return a * b\n", + "\n", + "@znflow.nodify\n", + "def divide(a, b):\n", + " print(\"Computing\")\n", + " return a / b" + ] + }, + { + "cell_type": "markdown", + "id": "c6383d82-8095-43c0-b05e-f7891f41a3fd", + "metadata": {}, + "source": [ + "_eager_ mode" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d5131234-6ef8-47dd-aab5-3e5a50d94c60", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing\n" + ] + } + ], + "source": [ + "n1 = add(1, 2, 3)\n", + "n2 = add(10, 20, 30)\n", + "n3 = add(n1, n2)\n", + "n4 = multiply(n1, n3)\n", + "n5 = divide(n4, n1)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f19d254a-d94b-4d47-88fa-77278859a92b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "66.0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n5" + ] + }, + { + "cell_type": "markdown", + "id": "67345989-03d5-43a6-9ba7-eb0f13775246", + "metadata": {}, + "source": [ + "_graph_ mode" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c22c3a45-2801-4019-857d-d631e2e32aaf", + "metadata": {}, + "outputs": [], + "source": [ + "with znflow.DiGraph() as graph:\n", + " n1 = add(1, 2, 3)\n", + " n2 = add(10, 20, 30)\n", + " n3 = add(n1, n2)\n", + " n4 = multiply(n1, n3)\n", + " n5 = divide(n4, n1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "91f97c85-97c6-4245-9259-6527489e4e37", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "znflow.draw(graph, log=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eea05e60-657c-4e68-9c37-3e9d95edbd4e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing\n" + ] + } + ], + "source": [ + "graph.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "528be861-3bf6-42c8-b349-7af2956d7939", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "66.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n5.result" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b26a9898-4ce5-43db-9d46-68cc5b2f92d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DiGraph with 5 nodes and 6 edges\n" + ] + } + ], + "source": [ + "print(graph)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "952a96d6-3b87-438c-b319-f51a5fcf79bd", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/example_03.ipynb b/examples/example_03.ipynb new file mode 100644 index 0000000..2ea6b90 --- /dev/null +++ b/examples/example_03.ipynb @@ -0,0 +1,212 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "678eaf6f-a85e-4d2e-b1e4-2be680841be0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import znflow\n", + "import random\n", + "import dataclasses" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "69fee3af-d100-41e0-81c0-95c5e8a40e3d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "@dataclasses.dataclass\n", + "class ComputeSum(znflow.Node):\n", + " inputs: list\n", + " outputs: float = None\n", + " \n", + " def run(self):\n", + " self.outputs = sum(self.inputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f2a8cbaa-ebd5-4e16-bd98-f164b76f081b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "@znflow.nodify\n", + "def random_number(seed):\n", + " random.seed(seed)\n", + " print(f\"Get random number with {seed = }\")\n", + " return random.random()" + ] + }, + { + "cell_type": "markdown", + "id": "1163fe03-78cd-4d59-9f7b-0c8222f3ca7f", + "metadata": {}, + "source": [ + "## Without building a graph" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3a03c96e-ef7c-47d7-9ca4-76b074c97805", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Get random number with seed = 5\n", + "Get random number with seed = 10\n", + "Get random number with seed = 1.1943042895796154\n", + "0.2903973544626711\n" + ] + } + ], + "source": [ + "n1 = random_number(5)\n", + "n2 = random_number(10)\n", + "\n", + "compute_sum = ComputeSum(inputs=[n1, n2])\n", + "compute_sum.run()\n", + "n3 = random_number(compute_sum.outputs)\n", + "print(n3)" + ] + }, + { + "cell_type": "markdown", + "id": "5ca5b8da-83c3-49ce-a029-9459d0b72e83", + "metadata": {}, + "source": [ + "## Using a graph" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a486dc3d-3401-4f7a-988b-4e261a260068", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "with znflow.DiGraph() as graph:\n", + " n1 = random_number(5)\n", + " n2 = random_number(10)\n", + "\n", + " compute_sum = ComputeSum(inputs=[n1, n2])\n", + " \n", + " n3 = random_number(compute_sum.outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "eac0659a-8c6d-4f01-a892-caa300fc1617", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "znflow.draw(graph)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ed963555-9d93-4240-b735-69ce5260aab1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Get random number with seed = 5\n", + "Get random number with seed = 10\n", + "Get random number with seed = 1.1943042895796154\n" + ] + } + ], + "source": [ + "graph.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "83df8cd9-5ba1-47be-944d-f0a95ef93fcb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.2903973544626711" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n3.result" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "17f80e19-a5a7-4d31-a38e-4694bb932c2d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tmp/example_01.ipynb b/tmp/example_01.ipynb deleted file mode 100644 index 7aee3a9..0000000 --- a/tmp/example_01.ipynb +++ /dev/null @@ -1,562 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "530b1d08-7428-42e2-834b-821c9d521396", - "metadata": {}, - "source": [ - "# The ZnFlow Package\n", - "\n", - "Define Node connections using a directional multigraph.\n", - "Nodes are connected through Node attributes.\n", - "A Node can have multiple connections to another Node through different Attributes.\n", - "Each Node is definied by a unique `_id_` which could be automatically generated based on the state of the Node." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "4cca5c7c-c687-419a-9bf0-85d26f89b0c0", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "import znflow\n", - "import zninit" - ] - }, - { - "cell_type": "markdown", - "id": "69440df5-47a0-4543-9d95-e5d22269d8d2", - "metadata": {}, - "source": [ - "A Node is inherited from `znflow.Node` and can have many different `znflow.EdgeAttribute` that will connect the Nodes to other Nodes or behave as inputs / outputs from the Node.\n", - "In general a `Node` is very similar to a dataclass and even implements a `_post_init_` method.\n", - "We equip our `Node` with a `run` method that computes the `outputs` based on the `inputs`." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "9f3e7cd6-a337-4773-b3ec-29c550695db7", - "metadata": {}, - "outputs": [], - "source": [ - "class Node(zninit.ZnInit, znflow.Node):\n", - " inputs = zninit.Descriptor()\n", - " outputs = zninit.Descriptor(None)\n", - " \n", - " def run(self):\n", - " self.outputs = self.inputs * 2" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "213e5833-4cb5-4412-9d7e-458fa8ad7c36", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Node(inputs=25, outputs=50)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "node1 = Node(inputs=25)\n", - "node1.run()\n", - "node1" - ] - }, - { - "cell_type": "markdown", - "id": "79af5875-3aa7-46cf-a722-b97c328f8f00", - "metadata": {}, - "source": [ - "We can now create multiple Nodes and connect them. Nodes are connected through `znflow.GraphManager` as follows.\n", - "Every Node inside the contextmanager will automatically be stored inside the `dag` object." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1ed13020-9b05-44a8-b286-d4b8938ed0d0", - "metadata": {}, - "outputs": [], - "source": [ - "with znflow.DiGraph() as graph:\n", - " node1 = Node(inputs=25)\n", - " node2 = Node(inputs=node1.outputs) # TODO Node(inputs=node1)" - ] - }, - { - "cell_type": "markdown", - "id": "b29c9b9e-39fb-4b26-8983-5c0dd7b55f19", - "metadata": {}, - "source": [ - "If we look at the new Node, we see that `Node.inputs` is now a `NodeConnector` to the connected Node." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "584871c5-7a2f-422d-be37-3391d360cee6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Node(inputs=25, outputs=None)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "node1" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "0034a2a9-aec9-4d9d-ba0a-22a0c45327c5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Node(inputs=Connection(instance=Node(inputs=25, outputs=None), attribute='outputs'), outputs=None)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "node2" - ] - }, - { - "cell_type": "markdown", - "id": "bc08331b-9c23-4ac7-b769-b1bb1a245309", - "metadata": {}, - "source": [ - "Using `networkx` we can visualize the connection." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "20223fc7-a9f4-40dd-a4b9-213d676e5035", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "znflow.draw(graph)" - ] - }, - { - "cell_type": "markdown", - "id": "d832c0bb-dbca-43ad-9c80-5120250251db", - "metadata": {}, - "source": [ - "Another way of connecting Nodes is through `znflow.DiGraph().write_graph`.\n", - "It is important to mention, that we can not use `node1.outputs` here, because we know `node1.outputs is None`. Therefore, we have to replace it by `node1 @ \"outputs\"`" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "f2e47705-bf75-4197-956a-7075012feb41", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "node1.outputs = None\n", - "node1 @ \"outputs\" = Connection(instance=Node(inputs=25, outputs=None), attribute='outputs')\n", - "node2 = Node(inputs=Connection(instance=Node(inputs=25, outputs=None), attribute='outputs'), outputs=None)\n" - ] - } - ], - "source": [ - "node1 = Node(inputs=25)\n", - "node2 = Node(inputs=node1 @ \"outputs\")\n", - "print(f\"{node1.outputs = }\")\n", - "print(f'{node1 @ \"outputs\" = }')\n", - "print(f\"{node2 = }\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "001384f9-f408-4cd5-85a0-0578d6380e58", - "metadata": {}, - "outputs": [], - "source": [ - "graph = znflow.DiGraph()\n", - "graph.add_node(node1)\n", - "graph.add_node(node2)\n", - "graph.add_connections(node2.inputs, v_of_edge=node2, v_attr=\"inputs\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "55d82c69-4717-4df1-aa9a-101c71e4fece", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "NodeView((UUID('b3e943cd-9962-454b-a9c8-8cc7ab27d7d3'), UUID('96cdda00-4bd6-4296-b980-57187adddf46')))" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "graph.nodes" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "ee6fc53b-5965-4cad-958b-e8739acf1a4a", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'u_attr': 'outputs', 'v_attr': 'inputs'}]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "[graph.edges[x] for x in graph.edges]" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "2bac56de-c6ed-4169-8b50-2114c9bf4939", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAWUElEQVR4nO3df6zddX3H8fc59/YHVFcUhSLixKGClrUYsFNcnBerJLjh0OhSNt0wmTLZ5sxwEtS0ZXNbcZluOB0byiKSuSxGjGNI2mIc4kRjGgVEmUMHQuWngKW/7jlnf9CW0va2597vr8/38308/vRevufUv155P++9pzcajUYBAABz1G/6DQAA0G4GJQAAhRiUAAAUYlACAFCIQQkAQCEGJQAAhRiUAAAUYlACAFCIQQkAQCEGJQAAhRiUAAAUYlACAFCIQQkAQCEGJQAAhRiUAAAUYlACAFCIQQkAQCEGJQAAhRiUAAAUYlACAFCIQQkAQCEGJQAAhRiUAAAUYlACAFCIQQkAQCEGJQAAhRiUAAAUYlACAFCIQQkAQCEGJQAAhRiUAAAUYlACAFCIQQkAQCEGJQAAhRiUAAAUYlACAFDIZNNvAACgjbY9vj12bt8Z8xfOiwWHLWj67TTKoAQAGMNjD/881n/mq/Ht9d+J733jjnjk/kf3fO2ZxzwjTlxxQpz2+lNiatWr4vCnH9bgO61fbzQajZp+EwAAqfr5z7bEpy6+Oq771MaY3jGI6EWMhvvPp36/F8PRKBYctiB+4/zXxe+sfksctmhhA++4fgYlAMAMvvnlTbHu7ZfFow8+FsPBcOz/rtfvxVHHPSve/5k/jKWvOqnCd5gGgxIA4AC+fOUN8Tfv+MSMF8lD6U/0o9eL+MDn3huv+s0VFbzDdBiUAAD7+NoXbo7Vb7o0ouBK6vV60Z/oxV99+YOx/DVLy3lzCTIoAQD28tDmh+O8k94TWx59vPCgjHjiZyuPOPqI+NRtfxuLFi8q/sAE+TuUAAB7+fsL/jm2btlWypiMiBgOR/Gz+x6Jf3r/Z8t5YIIMSgCAXe6+49648fM3x3B6/F/AGcdwMIzrrtgQD9/3SKnPTYVBCQCwy5c+eX30J6qZR8PhKK67YmMlz26aQQkAsMvXvnDzrP480GyMhqO46ZqbK3l20wxKAICI2PLo47H5zvsqfY0ffufHMRgMKn2NJhiUAAARcdftP6n8NXZu2xk//dH9lb9O3QxKAICI2LZle1avUyeDEgAgIibnTdTzOvMna3mdOhmUAAARseT4oyp/jV6/F88+7sjKX6duBiUAQEQc+Zxnxi8c+bRKX+PYE5bEYYsWVvoaTTAoAQDiic/dXvZrS2Nispp5NDHZj1OmTq7k2U0zKAEAdnnDu14Xg5I/JWe3wfQwznrnykqe3TSDEgBgl1OmlsZzX/yc0j8tpz/Zj5e84kXxS8ueX+pzU2FQAgDs0uv14vf++q2lf1pOL3rxJ5e/q9RnpsSgBADYZcOGDfGW3z8n7j/8roheec/93Ut+K57/0uPKe2BiDEoAoPMGg0GsXr06Vq5cGUuXLo1rv//5ePWbX1HKqHzDO1fGW993dvEHJaw3Go1GTb8JAICmbN68OVatWhVf+cpXYvXq1XHxxRfHxMREDKYH8Yn3XhnXXHZd9Pu9GA7Hn0z9iX6MhqNYdfE58fY1b41er8RzZ4IMSgCgszZs2BDnnntuRERcffXVMTU1td/3fHvDd+Mj53087r/rwehP9A/685W7v37sC4+J9/3LBfGSX3lRZe89JQYlANA5g8EgLrnkkli7dm1MTU3FVVddFUuWLJnx+6d3TsfXv/ituObj18UtN94eg+nBft8zOX8ylr9mabzxgjPj1DOXx8REPR/lmAKDEgDolJkS97h27tgZP7rlrrj7B/fG9I7pmL9wXhx34rHxvJOOjcl5+X1O9zgMSgCgM8ZJ3Mye3/IGALK3729xb9q0yZgsUTfvsgBAZxRN3ByaQQkAZGvvxL1+/XpXyYpI3gBAdiTuerlQAgBZkbjrZ1ACANmQuJsheQMArSdxN8uFEgBoNYm7eQYlANBaEncaJG8AoHUk7rS4UAIArSJxp8egBABaQ+JOk+QNACRP4k6bCyUAkDSJO30GJQCQLIm7HSRvACA5Ene7uFACAEmRuNvHoAQAkiFxt5PkDQA0TuJuNxdKAKBREnf7GZQAQGMk7jxI3gBA7STuvLhQAgC1krjzY1ACALWRuPMkeQMAlZO48+ZCCQBUSuLOn0EJAFRG4u4GyRsAKJ3E3S0ulABAqSTu7jEoAYDSSNzdJHkDAIVJ3N3mQgkAFCJxY1ACAHMmcRMheQMAcyBxszcXSgBgViRu9mVQAgBjk7g5EMkbADgkiZuDcaEEAA5K4uZQDEoAYEYSN+OQvAGA/UjczIYLJQDwFBI3s2VQAgB7SNzMheQNAEjcFOJCCQAdJ3FTlEEJAB0mcVMGyRsAOkjipkwulADQMRI3ZTMoAaBDJG6qIHkDQAdI3FTJhRIAMidxUzWDEgAyJnFTB8kbADIkcVMnF0oAyIzETd0MSgDIiMRNEyRvAMiAxE2TXCgBoOUkbppmUAJAi0ncpEDyBoAWkrhJiQslALSMxE1qDEoAaBGJmxRJ3gDQAhI3KXOhBIDESdykzqAEgIRJ3LSB5A0ACZK4aRMXSgBIjMRN2xiUAJAQiZs2krwBIAESN23mQgkADZO4aTuDEgAaJHGTA8kbABogcZMTF0oAqJnETW4MSgCokcRNjiRvAKiBxE3OXCgBoGISN7kzKAGgQhI3XSB5A0AFJG66xIUSAEomcdM1BiUAlEjiposkbwAogcRNl7lQAkBBEjddZ1ACQAESN0jeADAnEjc8yYUSAGZJ4oanMigBYBYkbtif5A0AY5C4YWYulABwCBI3HJxBCQAHIXHDoUneAHAAEjeMz4USAPYhccPsGJQAsBeJG2ZP8gaAkLihCBdKADpP4oZiDEoAOk3ihuIkbwA6SeKG8rhQAtA5EjeUy6AEoFMkbiif5A1AJ0jcUB0XSgCyJ3FDtQxKALImcUP1JG8AsiRxQ31cKAHIjsQN9TIoAciKxA31k7wByILEDc1xoQSg9SRuaJZBCUCrSdzQPMkbgFaSuCEdLpQAtI7EDWkxKAFoFYkb0iN5A9AKEjeky4USgORJ3JA2gxKApEnckD7JG4AkSdzQHi6UACRH4oZ2MSgBSIrEDe0jeQOQBIkb2suFEoDGSdzQbgYlAI2SuKH9JG8AGiFxQz5cKAGoncQNeTEoAaiVxA35kbwBqMVgMIg1a9ZI3JAhF0oAKrd58+Y499xz44YbbpC4IUMGJQCVkrghf5I3AJWQuKE7XCgBKJ3EDd1iUAJQKokbukfyBqAUEjd0lwslAIVJ3NBtBiUAhUjcgOQNwJxI3MBuLpQAzJrEDezNoARgViRuYF+SNwBjkbiBmbhQAnBIEjdwMAYlAAclcQOHInkDcEASNzAuF0oA9iNxA7NhUALwFBI3MFuSNwARIXEDc+dCCYDEDRRiUAJ0nMQNFCV5A3SUxA2UxYUSoIMkbqBMBiVAx0jcQNkkb4COkLiBqrhQAnSAxA1UyaAEyJzEDVRN8gbIlMQN1MWFEiBDEjdQJ4MSIDMSN1A3yRsgExI30BQXSoAMSNxAkwxKgJaTuIGmSd4ALSVxA6lwoQRoIYkbSIlBCdAyEjeQGskboCUkbiBVLpQALSBxAykzKAESJ3EDqZO8ARIlcQNt4UIJkCCJG2gTgxIgMRI30DaSN0AiJG6grVwoARIgcQNtZlACNEziBtpO8gZoiMQN5MKFEqABEjeQE4MSoGYSN5AbyRugJhI3kCsXSoAaSNxAzgxKgIpJ3EDuJG+AikjcQFe4UAJUQOIGusSgBCiZxA10jeQNUBKJG+gqF0qAEkjcQJcZlAAFSdxA10neAHMkcQM8wYUSYA4kboAnGZQAsyRxAzyV5A0wJokb4MBcKAHGIHEDzMygBDgEiRvg4CRvgBlI3ADjcaEEOACJG2B8BiXAPiRugNmRvAF2kbgB5saFEiAkboAiDEqg8yRugGIkb6CzJG6AcrhQAp0kcQOUx6AEOkfiBiiX5A10hsQNUA0XSqATJG6A6hiUQPYkboBqSd5AtiRugHq4UAJZkrgB6mNQAtmRuAHqJXkD2ZC4AZrhQglkQeIGaI5BCbSexA3QLMkbaC2JGyANLpRAK0ncAOkwKIHWkbgB0iJ5A60hcQOkyYUSaAWJGyBdBiWQPIkbIG2SN5AsiRugHVwogSRJ3ADtYVACyZG4AdpF8gaSIXEDtJMLJZAEiRugvQxKoHESN0C7Sd5AYyRugDy4UAKNkLgB8mFQArWTuAHyInkDtZG4AfLkQgnUQuIGyJdBCVRO4gbIm+QNVEbiBugGF0qgEhI3QHcYlEDpJG6AbpG8gdJI3ADd5EIJlELiBugugxIoTOIG6DbJG5gziRuACBdKYI4kbgB2MyiBWZO4Adib5A2MTeIG4EBcKIGxSNwAzMSgBA5J4gbgYCRvYEYSNwDjcKEEDkjiBmBcBiWwH4kbgNmQvIE9JG4A5sKFEogIiRuAuTMoAYkbgEIkb+gwiRuAMrhQQkdJ3ACUxaCEDpK4ASiT5A0dInEDUAUXSugIiRuAqhiU0AESNwBVkrwhYxI3AHVwoYRMSdwA1MWghAxJ3ADUSfKGjEjcADTBhRIyIXED0BSDEjKwcePGWLVqVURI3ADUT/KGFtuduF/72tdK3AA0xoUSWkriBiAVBiW0kMQNQEokb2gRiRuAFLlQQktI3ACkyqCEFpC4AUiZ5A0Jk7gBaAMXSkiUxA1AWxiUkCCJG4A2kbwhIRI3AG3kQgmJkLgBaCuDEhIgcQPQZpI3NEjiBiAHLpTQEIkbgFwYlNAAiRuAnEjeUCOJG4AcuVBCTSRuAHJlUEINJG4AciZ5Q4UkbgC6wIUSKiJxA9AVBiVUQOIGoEskbyiRxA1AF7lQQkkkbgC6yqCEEkjcAHSZ5A0FSNwA4EIJcyZxA8ATDEqYA4kbAJ4kecMsSNwAsD8XShiTxA0AB2ZQwhgkbgCYmeQNByFxA8ChuVDCDCRuABiPQQkHIHEDwPgkb9iLxA0As+dCCbtI3AAwNwYlhMQNAEVI3nSaxA0AxblQ0lkSNwCUw6CkkyRuACiP5E2nSNwAUD4XSjpD4gaAahiUdILEDQDVkbzJmsQNANVzoSRbEjcA1MOgJEsSNwDUR/ImKxI3ANTPhZJsSNwA0AyDkixI3ADQHMmbVpO4AaB5LpS0lsQNAGkwKGkliRsA0iF50yoSNwCkx4WS1pC4ASBNBiWtIHEDQLokb5ImcQNA+lwoSZbEDQDtYFCSJIkbANpD8iYpEjcAtI8LJcmQuAGgnQxKkiBxA0B7Sd40SuIGgPZzoaQxEjcA5MGgpBESNwDkQ/KmVhI3AOTHhZLaSNwAkCeDklpI3ACQL8mbSkncAJA/F0oqI3EDQDcYlFRC4gaA7pC8KZXEDQDd40JJaSRuAOgmg5JSSNwA0F2SN4VI3ACACyVzJnEDABEGJXMkcQMAu0nezIrEDQDsy4WSsUncAMCBGJSMReIGAGYieXNQEjcAcCgulMxI4gYAxmFQckASNwAwLsmbp5C4AYDZcqFkD4kbAJgLg5KIkLgBgLmTvDtO4gYAinKh7DCJGwAog0HZURI3AFAWybtjJG4AoGwulB0icQMAVTAoO0LiBgCqInlnTuIGAKrmQpkxiRsAqINBmSmJGwCoi+SdGYkbAKibC2VGJG4AoAkGZSYkbgCgKZJ3y0ncAEDTXChbTOIGAFJgULaUxA0ApELybhmJGwBIjQtli0jcAECKDMqWkLgBgFRJ3omTuAGA1LlQJkziBgDawKBMlMQNALSF5J0YiRsAaBsXyoRI3ABAGxmUiZC4AYC2krwbJnEDAG3nQtkgiRsAyIFB2RCJGwDIheRdM4kbAMiNC2WNJG4AIEcGZU0kbgAgV5J3xSRuACB3LpQVkrgBgC4wKCsicQMAXSF5l0ziBgC6xoWygOFwGP3+k5tc4gYAusiFco4+/OEPx4knnhgPPfRQRDyRuJcvXx633nprrF+/Pj70oQ8ZkwBAJ/RGo9Go6TfRhOmd0/Hj2+6Ou27/SezYtjPmLZgXx75wSRx/8vNi3vx5B/1vH3jggTjuuONi27ZtcdZZZ8Wpp54aa9eujampqbjqqqtiyZIlNf0rAACa16lBORgM4pv/uSmu+fh1sWnjd2N652C/75mY7MdLTz8xzn73mfHKs0+LyXn7/1TARRddFOvWrYvhcLjnf1uzZo3EDQB0UmcG5W3//YNY9/bL4id33Bv9iX4MB8MZv3f315/13CPjwk+/O152xsl7vrb3dXLP9/f7cdNNN8WKFSsq/TcAAKQo+5+hHI1GceUH/zXec/oH4t7//WlExEHH5N5ff+ieh+LPVq6Ny/7oihgMnrhmXnrppbF9+/anfv9wGOecc05s3bq1gn8BAEDasr5Qjkaj+Nj5l8d/XL6+2IN6Ea9+8yvibeveHMe/4Pg9v929O3nPnz8/Tj311Lj22mtj8eLFJbxzAID2yPrPBn1u3TXFx2RExCjiq//+9ZietyMWLlwYS5cujTPOOCOWLVsWy5YtixNOOCEmJ7P+vxIAYEbZXijvvOX/4vyXXRiD6YPn7VnpRXz0v/48XvrKF5f3TACAlsv2Zyg/+s5/LP2Z/X4/PvKOf4hMNzgAwJxkOSj/Z9OdcdvXf1DudTKe+GWdu79/T2y64ZZSnwsA0GZZDsprL18fE5PV/NMmJvvxpU9eX8mzAQDaKMtB+e0N3y39OrnbYHoYm264tZJnAwC0UXaDcuvPt8Y9P9xc6Ws8+uBj8cA9D1X6GgAAbZHdoLzvrgdjNKz+l2Y233lf5a8BANAG2Q3KwQE+n7sK0zuma3kdAIDUZTcoFy5akNXrAACkLrtBefQvPjvmLaj4U2t6Ec876bnVvgYAQEtkNygnJifiBb/8/Epf45jjj47Dn35Ypa8BANAW2Q3KiIjT3/jy6PV7lTy7P9GPV559WiXPBgBooywH5ZnvmIp+RYNyOBjGr5//ukqeDQDQRlkOymcctThef95U9CfK/ef1J/rxq29aEceecEypzwUAaLPeaDSq/o82NmDLI1vivJPeEz+775EYlvF3KXsRi37h8Pj07R+LZxx9RPHnAQBkIssLZUTEosWL4qLP/nFEvxe9Xjn5+8JPv9uYBADYR7aDMiJi+WuWxgc/997oT/TmnL97uwbpn17xB3H6G19e8jsEAGi/bJP33m658Xvxl7/9d3H/3bP7WMb+RD8WP+vpceGVF8Rpr19e3RsEAGixTgzKiIitW7bFZ1b/W3zxE9fH9q3bo9/rHfBnK3v9XsQoYnL+RJx53lSc9xer4mlHLGrgHQMAtENnBuVujz+2NTZefWN86/pNcfs37ogH73l4z9eOOGpxnLTihXHKGSfHyre92pAEABhD5wblvnZs2xE7tu2MyfmTsfBwn88NADBbnR+UAAAUk/VveQMAUD2DEgCAQgxKAAAKMSgBACjEoAQAoBCDEgCAQgxKAAAKMSgBACjEoAQAoBCDEgCAQgxKAAAKMSgBACjEoAQAoBCDEgCAQgxKAAAKMSgBACjEoAQAoBCDEgCAQgxKAAAKMSgBACjEoAQAoBCDEgCAQgxKAAAKMSgBACjEoAQAoBCDEgCAQgxKAAAKMSgBACjEoAQAoBCDEgCAQgxKAAAKMSgBACjEoAQAoBCDEgCAQgxKAAAKMSgBACjEoAQAoJD/B4WuSPpqqa9iAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "znflow.draw(graph)" - ] - }, - { - "cell_type": "markdown", - "id": "6f93a87b-066b-4a4c-84d4-4d8c0dd47e6a", - "metadata": {}, - "source": [ - "# Run the Graph" - ] - }, - { - "cell_type": "markdown", - "id": "6f970fbc-2d86-4ead-9892-e06d03e32117", - "metadata": {}, - "source": [ - "First let's build some more interesting graphs:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "5419e6a0-7fca-4953-a496-71ab3a37c2fd", - "metadata": {}, - "outputs": [], - "source": [ - "class SumNodes(zninit.ZnInit, znflow.Node):\n", - " inputs = zninit.Descriptor()\n", - " outputs = zninit.Descriptor(None)\n", - "\n", - " def run(self):\n", - " self.outputs = sum(self.inputs)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "00559229-f492-4146-8937-e16f09628b69", - "metadata": {}, - "outputs": [], - "source": [ - "with znflow.DiGraph() as graph:\n", - " node1 = Node(inputs=5)\n", - " node2 = Node(inputs=10)\n", - " node3 = Node(inputs=node1.outputs)\n", - " node4 = Node(inputs=node2.outputs)\n", - " node5 = SumNodes(inputs=[node3.outputs, node4.outputs])\n", - " node6 = SumNodes(inputs=[node2.outputs, node5.outputs])\n", - " node7 = SumNodes(inputs=[node6.outputs])" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "14e05618-8f90-4731-97cc-eb8512b8d90e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "znflow.draw(graph)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "1fe31907-18c0-4897-b419-33dcab8b7a0a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "NodeView((UUID('9f70416e-380e-4f19-9f42-5caf85d1c109'), UUID('8fe84ca3-150c-4922-8268-68ce819d84c3'), UUID('98af6ef7-fd1f-460d-b917-8d1bacb3c3c0'), UUID('90562226-d151-448b-93a5-72eb0ec08754'), UUID('e92c271c-7641-4baa-a728-02b8ee277277'), UUID('c3aaef07-b4fa-4b12-9aeb-5155cd3943b3'), UUID('babf5cee-d45d-476b-97ab-8aacfe05a410')))" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "graph.run() # default is to call node.run()\n", - "graph.nodes" - ] - }, - { - "cell_type": "markdown", - "id": "627e12cd-aba9-4bc5-a5e3-98fd1208d291", - "metadata": {}, - "source": [ - "Or even more nested" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "fc076fec-a755-4131-9bb7-8e65df3b9fd3", - "metadata": {}, - "outputs": [], - "source": [ - "import random\n", - "k = 3\n", - "j = 3\n", - "i = 3\n", - "\n", - "with znflow.DiGraph() as graph:\n", - " kdx_nodes = []\n", - " for kdx in range(k):\n", - " jdx_nodes = []\n", - " for jdx in range(j):\n", - " idx_nodes = []\n", - " for idx in range(i):\n", - " idx_nodes.append(Node(inputs=random.random()))\n", - " jdx_nodes.append(SumNodes(inputs=[x.outputs for x in idx_nodes]))\n", - " kdx_nodes.append(SumNodes(inputs=[x.outputs for x in jdx_nodes]))\n", - " \n", - " end_node = SumNodes(inputs=[x.outputs for x in kdx_nodes])" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "e84c30db-8e84-45e5-a24f-6f75f2cde06a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddVxU29rA8d+eAQS7u1vsArtbAbu769gK9tFjd3d7bD2i2GJgiwUWKmUnBl0zs98/uPAejgXMHnJ97+fcew+z91oPCjPPXvEsSZZlGUEQBEEQBEGII1VCByAIgiAIgiAkbSKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPQiEkpBEARBEARBLyKhFARBEARBEPRilNABCIIgKCk8LJzQoDBUahVmaU2RJCmhQxIEQUj2REIpCEKSptVouXn8LlcO3+Tx9We89XyPrJMBME1rSrFKhShX25ymfeuTq1COBI5WEAQheZJkWZYTOghBEITY0ul0HN/gyN9/HeTLu6+ojFToNLofXqtSq9DpdFRtWoGhy/qQt3jueI5WEAQheRMJpSAISc7Hl5+Y13MlDy65xeo+lZEKlUpF/7ndaDuqpZgOFwRBUIhIKAVBSFJePnnD2HrT8f/ij/YnI5Ix0WpQY/5Y3R+VSuxNFARB0Jd4JxUEIcnwefuFcfWn4/dZv2QS4Nj6s2y226VQZIIgCCmbSCgFQUgSZFlmcf+1+Pr4o9Pql0xG2r/oKPfOP1CkLUEQhJRMJJSCICQJ53df4fYpF8WSSQCVSmJB79WEhYQp1qYgCEJKJBJKQRASPVmW2TX7IErvodHpZHxef8Zp/3VlGxYEQUhhRB1KQUiiggOC8bj3nE+vP6PVaEmTPjWFyuYnZ6HsyW738sMrT3j15K1B2pZUEodXnKBxz7oGaV8QBCElEAmlICQhgX5BOO68xLH1Z3j+6BX8oEZD6vRm1G5XDeuhTSleuUj8B2kAN47dQW2kRqvRKt62rJNxv+vFt0++ZMyWQfH2BUEQUgKRUApCEiDLMsc3OLJ+3HZCgkKR4IfJJECQXzCOO504vfUCVZqUZ8ymIWTLmyU+w1Xc01seBkkm/839rjdVm1YwaB+CIAjJlVhDKQiJnN8XfyY0nsnyIRsICQwFGX5XPTaypM698w/oW2oklw4m7TWC3g9eGrR9lVrFi0evDNqHIAhCciYSSkFIxPw++zO69lTuOz2O0/1ajY6QoFD+6rSEM9svKhtcPAoNDjVo+5IkRSTrgiAIQpyIhFIQEimtVsu01vN5/eydfqVy5Ih/FvVdg+vFR4rFF5/URmqDti8jY2Rs2D4EQRCSM5FQCkIiZb/iJI+uPlWs7qIkwfxeKwkOCFakvfiUq1AOg7av0+jIVdiwfQiCICRnIqEUhETo87uvbJ6k7LGAOp3M5zdf2D37H0XbjQ8lLYuhNvAIYrHKhQ3aviAIQnImEkpBSIRObjqHJlz5Xc06nYzDujMGX5OotHJ1SqE1wJ9HpEw5MogRSkEQBD2IhFIQEhlZljm69jSy7jdbueMo0DeIK/84G6RtQ6nV1pI0GVIbpG2VSsJqSNNkVwxeEAQhPomEUhASmffeH/n6/pvB2lcbqbnvlLQ255iYmmA9tCmSSvmkT6VW0bx/Q8XbFQRBSElEQikIicyzO14GbV+r0eJ2092gfRhCl4ltyJonMyq1sm9bfWd3JWvuzIq2KQiCkNKIhFIQEpn33h8VT5r+68PzTwZt3xDM0pphu+MPxZYCqNQqSlUrRtvRLRVpTxAEISUTCaUgJDKacI3B1/NpwjUGbd9Qytctzfitw0Ai4p84UqlV5Cmak7+O2qFWi/qTgiAI+hIJpSAkMqapU6HTKVN78mdSmaUyaPuG1LhnXabuG4Np6lRxXlNZplZJll2ZRYas6RWOThAEIWUySugABEGIrkDpfAbb4R2pYNl8Bm3f0Oq0r06GfGnoW+MPMpMdtZEq6vzyH/pf3pnK1ISBC3vSanBjVCrxPC0IgqAUkVAKQiJT3MAFttVGakpWLWrQPuLD4tWLeJ31CZsPrOLcjitcOnCdIP8fnAIkQYFSeWk1uAmNe9QhTYY08R+sIAhCMifJsmzYoRBBEGJtmIUdHne90BlopHLRhT8pX7e0QdqOD3fv3qVy5cqsW7eOQYMGARH1O997f8TT9TnB/iGojVRkzZuFohULkTqdWQJHLAiCkLyJhFIQEqGzO5xY0HuV4u1KEuQplostbsuTbCFvWZZp0KABHz9+xNXVFSMjMdEiCIKQ0MQiIkFIhOp2rE62fFlQKVzIW5ah66R2STaZBHBwcODixYssWrRIJJOCIAiJhBihFIREyvXiI8Y1+FOx9tRGKio2KMuck5OTbEIZHh5OmTJlyJ8/P2fOnEmy34cgCEJyI0YoBSGRKl+vNJ0m2CjSlkqtIm2mtIzZNCRJJ2Hr16/H3d2dRYsWJenvQxAEIbkRI5SCkIjpdDpWDtvEsfVn49yGykhFukxpWXzhTwqYJ91yQb6+vhQpUgQbGxs2b96c0OEIgiAI/yJGKAUhEVOpVIxYM4AhS3tjnMoIlVHsf2XNqxVn1c25STqZBJgzZw7BwcH89ddfCR2KIAiC8B9ihFIQkojX7u9YO2orzqfuoVKp0Gl/XMg7ssh3ppwZ6T6lfbIo4v38+XNKlCjBxIkT+fPPPxM6HEEQBOE/REIpCEnMO+8PnN5ygQdX3Hh6y4PQoDAgoiRQriI5KVWtGLXaWFLdqgpqo+RxTnWXLl1wcnLC3d2dNGlEYXJBEITERiSUgpCEubi4UqViFc6dPUeNOtUxNjFO6JAUd/PmTapVq8bmzZvp27dvQocjCIIg/EDSngcThBQuIMAfLRpy5M2eLJNJWZYZO3Ys5cqVo1evXgkdjiAIgvAToiqwICRhfn5+AKRPnz6BIzGMf/75h6tXr3LmzBnU6uQxfS8IgpAciRFKQUjCknNCGRYWhq2tLc2bN6dx48YJHY4gCILwC2KEUhCSMD8/PyRJSpYbVdasWYO3tzdHjhxJ6FAEQRCE3xAjlIKQhPn5+ZE+ffpkd2rMly9fmDlzJgMGDKB06dIJHY4gCILwGyKhFIQkLDKhTG5mzZpFeHg4M2bMSOhQBEEQhBgQCaUgJGF+fn6kS5cuocNQlIeHB6tWrcLOzo4cOXIkdDiCIAhCDIiEUhCSsOQ4Qjlx4kRy5MjB6NGjEzoUQRAEIYbEphxBSML8/f2TVUJ59epVDh48yI4dO0idOnVChyMIgiDEkBihFIQkLDmNUEYWMa9UqRLdunVL6HAEQRCEWBAjlIKQhPn5+ZE3b96EDkMR+/bt4+bNm1y4cAGVSjzrCoIgJCUioRSEJCy5jFCGhIRgZ2eHtbU19erVS+hwBMHgZFkmyC+IsJBwjFMZkyZD6mRX/ktIWURCKQhJWHJJKFeuXMmbN284ffp0QociCAbj98Wfs9uduH3Ghae3PPH/EhD1WtpMaShRtSiVG5enae96pM+SvKo3CMmfJMuynNBBCIIQNxkyZGDatGmMHTs2oUOJMx8fH4oWLUqPHj1YuXJlQocjCIoL+BbIlsm7Obn5PNpwLRAxQvlfkiSBBGq1iiZ96tN/bjfSZUob3+EKQpyIEUpBSKJ0Ol2y2OU9Y8YMZFlm2rRpCR2KICjuzllX5vdcia+PPzqt7pfXyrIMMmh0Wk5tPs/Vw85M2DYci+YV4ynaiBjee3/E/a4Xvj7+IMukz5KOIhULkbtIDrG+WfgpkVAKipNlmWe3PXG74Y77PS++vPuKrJNJlzktRcoXpHiVIpStUwpjE+OEDjVJCwwMRJblJJ1QPn36lHXr1jF79myyZcuW0OEIgqIc/77Egt6rAJB1sZsM1Gl1+H32Z0qruYzdPISmvesbIsQor5+95di6M5zedpGAb4ERX4wYMCVyMDV1ejMada+D1ZCmFCydz6DxCEmPmPIWFBMWGs6pzec5vPIEr5++RZIkVGoVWk3EFI9KJYEkodPqyJA1Ha0GN6HNiBZkyJp0E6KE9ObNG/LmzcuJEydo3rx5QocTJ61bt8bFxYUnT55gamqa0OEIgmJuHr/DVOv5P5zajjUJ/jw0npqtLfRv6z+C/IPZMH4Hxzc4olKrfjuKqjJSodPoaNC1FsNW9CV9ZrHWU4ggEkpBEc/ueDKvx0peP30D/P8T7a+o1CrSpDdj1PpB1Glf3cARJj9ubm6Ym5tz5coVatasmdDhxJqTkxP16tVjz549dO7cOaHDEQTF+Pr40afkSAK+BiqSUEoSpM6Qmq1uy8mUI6P+Af6P+10vptnM58u7b+h0v04k/0ulVpEuc1r+/Gc8ZWqWVCwmIekSiyEEvZ3edoHhlhN54/4OWY5ZMgkRUzoB3wL5q+MSVv2xOdZvaCmdn58fQJKc8tbpdIwZMwYLCws6deqU0OEIgqLWjNpKoG+QMqOTRLynBvuHsGrEFkXaA3h6y4Mxdafx5X3sk0n4/yn5CY1m4HrxkWJxCUmXSCgFvZzd4cSivmuQdfJvp0p+JPL99sjqU6wesUWxN+CUICknlLt27eLu3bssWbJE1N4TkpWPr3y4sOdqnN4Pf0Wn1XHp4HXeeX/Qu60v779i12wWYSHhesUp62S04Vomt5rL++cf9Y5LSNpEQinEmffDlyzuv1ax9o6uOc25XZcVay+5S6oJZXBwMJMmTaJdu3ZJcqo+Ofv60Zentz15fOMZzx+9IjwsPKFDSnJObHBEUhnmIUmlUnF8/Vm92pBlmWWDNxDkF6xI0qvTyWjCwlnYZ7WYZUrhxC5vIU60Gi3ze64EFBxRlGDl8E1UbFiWLLkyKdduMhWZUKZLl7QWxS9dupQPHz4wb968hA4lxZNlmXvnH3JikyP3Lz7i6wffaK+rjdQUKJ2XOu2q07x/AzLnFL+Xv3Pt6C3FRycj6bQ6rh29Tf953ePchvPJe1w/elvBqECr0XHf6TEX912jQZdairYtJB1ihFKIE6cD1/F0eY5Wo+AbpwwhgaHsnXtYuTaTMT8/P1KnTo2RUdJ5Lvzw4QNz585l2LBhFC1aNKHDSdHuX3pM31IjsW08kyuHbnyXTELEg6OX6wu2/7mPLvkGs3zoRgL9ghIg2qQhLDScl26vDdrHm2dvCQ0OjfP9h5cfR6VW/qNfpZL4Z9lxxdsVkg6RUApxYr/qpEHelHRaHae2nic4METxtpObpHjs4vTp0zE2Nmbq1KkJHUqKpQnXsHrkFsbWm85bz4j1eL97MIxcI31iw1n6mY/iwWW3+Ag1yXnn+V7Zh+wf0OlkXj19G6d7P778xJ2z9w0ygqrTyTy95YH3w5eKty0kDSKhFGLtw4tPuF1/ZrBpnZDAUG443DFI28lJUksoHz9+zMaNG5k6dSqZM2dO6HBSpPCwcP5st4gjq04BxPp3WKeT+fL+GxMazcD55D1DhJikhQSFxUs/oXHs5+HVpwpHEp0kwcMrTwzah5B4iYRSiLUnzh4GbV9trObpLcP2kRwktYRy/PjxFCpUiGHDhiV0KCnWskEbcD5xV69qCrJORqvRMb3NAp7d8VQwuqTPyFidqPtxv+OF2oAxqtRqnt0WPxMplUgohVjzuOeN2shwb0racK34oIqBpJRQOjo6cuLECebNm4eJiUlCh5MiXbV35sz2i7E+AvBHZDliCnxe9xWEhYqd4JFyFoyf40NzFc4Rp/s+vPyEzoBT8lqNVpQPSsFEQinEmp+Pn8H7+PaDDQJCdH5+fklih7dWq2Xs2LHUrFmTdu3aJXQ4KVJwYAhLBqxTtOanTqvj9bN3HFh4VLE2k7o0GdKQw8BJZdY8mUmfJW6/9zqN1uC1frXhWoO2LyReIqEUYi0+ClGLYte/l1RGKHfs2MH9+/dZvHix+HtNIBf2XMXvs7/iyYQsy/yz/LioV/kvlRqVQ21kmI9WtZGKig3Lxvl+0zSmBtlMGUUCs3SmhmtfSNREQinEWvqshh8Vy5gjg8H7SOr8/f0TfUIZGBjI5MmT6dy5M5aWlgkdTop1ZNVJgxXb9vvsz9XDzgZpOylqNaixwXZ6azU6Wg1uEuf7C5bJr2A031Or1RQuW8CgfQiJl0gohVgrWrEQWo3hpjXUxmqKVy5isPaTi6QwQrlo0SI+f/7MnDlzEjqUFMvvsz9e918osnbyR9RGau46PjBI20lR8cpFKGlRVPGRQJVaRdGKhShlWSzObRSvXNhg1TkgYg1lscqFDda+kLiJhFKItZIWhi1IrQ3XGryP5CCxJ5Rv375lwYIFjBw5kkKFCiV0OCmW+10vg7av1Whxu/nMoH0kNaM3DAaFB4RlWWbspiF6LRspXbMEqdObKRhVdMapjKjUqJzB2hcSN5FQCrGWPX82StcsYbC1OGZpTbFsVdkgbScXsiwn+oRy6tSpmJmZMWnSpIQOJUV7/ewdhl66+sbjvWE7SGIKlytA7xmdFW2zx9QOFK2o34NZKrNUtOjfyCDv3WojFY261yFtxjSKty0kDSKhFOKk9fDmBpk6UalVNOvbANPUqRRvOzkJDQ0lPDw80SaU9+/fZ+vWrfz5559kzJgxocNJ0cJDw5FUhn2r14ZpDNp+UtTZrjXlW5RUpK1mfevTbaoyFRLajGhuoHqZEu3GWBmgXSGpEAmlECe121ejeOXCqBTczShJEmZpTels11qxNpMrP7+I0k2JMaGUZZlx48ZRrFgxBg0alNDhpHjGqYyRdYY9DlBtknTOk48vLi4urL+4DHUxDZIkxXpUUKVWgQRdJrZh9IbBqBR6KMiePxt953ZVpK0oEvT8syMFSuVVtl0hSREJpRAnarWaCTv+QKXgXJosy4xYM4DMOTMp1mZylZgTylOnTnH27FkWLFiAsbFxQoeT4uUtngsDlx4kT9Gchu0giXnx4gUtWrSglHkpDt39mxXXZ5P7f39Gv0ssI1/PVTgHy6/Mou/sroolkwAfP35k6f55fJbeK7LzX6VWUbZ2KTpNsFEgOiEpEwmlEGcFSuVl/Lbhiiw+l5Gp2rYc9TvX1L+xFCCxJpQajYZx48ZRt25drK2tEzocAQy+61ZtpKaUZXGD9pGUfPnyhWbNmpE6dWqOHTtGmjRpKGlRjM2PljLn5GQsmlckldmPT4syMTWmStPyzD4+iS1uyzCvXkLR2B48eICFhQUenh6suDCPyo3K6bXJR1JJlKpWjFkOEw16epqQNIh5CkEvDbrUQtbJLOi9CiDW6yollYSsk5Hyh7Li5HysbzamWrVqhgg1WUmsCeWWLVt4/Pgxt2/fFkXME4n0mdNRuFwBvB++NEjpIK1GS+XGYmcvQEhICDY2Nnz69Inr16+TPXv2qNdUKhVVm1agatMKaLVaXj97x+unbwkPDcc4lTF5i+cib4ncqNWGScyOHTtGly5dKFKkCEePHiV//vxYVrNgx58H2DffHkklxfj9W6WW0OlkWg9vTr+5XUllJta8CyDJhj6HSUgRPF2fM6/HCp4/eoUkSTH64FKpJNJmSsuYjYOp0Lg0zZo14+HDh1y4cIEKFSoYPugk7OjRo9jY2PDhw4doH1oJyd/fn6JFi9KkSRN27tyZ0OEI/3Ji0zmWDlxnkLbTZ0nH3jfrMTZJ2csbdDodnTp14tixY1y4cCHRPBjLsszSpUsZN24c1tbW/P3336RNmzbaNU9vebBhwk7uOz1GbaRCq9XBD97C1UYqtBodpaoVY8D8HpStXSqevgshKRAJpaAYTbiGM9su8s+KE7x49AqkiOmwyLNdVWoVyDI6nUymHBmwHtoM62FNSZ854uQdPz8/GjZsyPPnz3FycsLc3Dwhvx29fHn/Ffc7Xnz75IcsQ7pMaShasRDZ82dVZOTu77//pkePHgQHB2NqmjiOOpsyZQqLFy/m2bNn5MuXL6HDEf4lJCiU7gWH4PclQNFRSkmS6DWzE90mx34HcnhYOM8fvuLTq89otTpSpzOlcLkCZMqRUbH44tOYMWNYvnw5//zzDzY2iWM9YVhYGEOHDmXz5s3Y2toyZ86cX67HfOH2mnN/X8LthjvP7ngS5BcMRJRyK1apMCUti9GwW20KlxOn4QjfEwmloDhZlvF0fc6Tmx643/Hk60dfdFodaTOloUj5QhSvUpgyNUv+cM3Nly9fqFevHj4+Ply6dImiRZNOgfNPrz9zfMNZTm05z+e3X394TbrMaWnUvQ5WQ5qQr0SeOPe1Zs0aRo0aRWhoaKKYWn716hXFixdnzJgxzJ49O6HDEX7g2tFbTG+9QLH2VGoVeYvnYt29hTEenQwNDuXivmscW38W9ztePzxxK2P2DNTrWINWQ5okmV3DS5cuZcyYMaxatYphw4YldDgAfP78mXbt2nHt2jU2btxIr169Yt2GTqdDlmWDTcMLyYtIKIVE58OHD9SpU4eQkBAuX75M/vyGPX9WX2EhYWyfto8DSxyQpN+vQ1KpVei0Ohr3rMuQpb1JlyntL6//kXnz5rFo0SJ8fHziGraievXqxalTp/Dw8CBdOsOf9S7EzcK+qzm73Ql93/YlScLIRM3yq7MpVun3m35kWcbx70usHrmFwG9BUWunfybyd6RmGwtGrhmQqEctDxw4QKdOnZgwYQLz5s1L6HAAcHNzw8rKCl9fXw4fPkytWrUSOiQhBRAJpZAovX79mtq1a2NkZMSlS5fIlStXQof0Qy+fvGGq9TzeeX2I9VSiSq0ifZZ0TD80jjI1Y1cAedKkSezduxcvL8MeqxcSFIqny3Pc73rx7YMvsiyTLnNailQoSLFKhUmbMQ13796lcuXKrF27lsGDBxs0HkE/mnANMzss5obDnTgnlSqVhMpIzcwjtlRtWuG31wf6BTGv+wpuHLsTUREiFt2q1CrM0ppit3ME1RLh6VmXL1+mcePGtG/fnh07diha3ieuTp8+TceOHcmXLx8ODg6J/thTWZZ5esuDywdv8OSWB54uzwkJDEFSqcicMyOlLIthXqMEDbvVJkPWxLUJUYhOJJRCouXl5UWdOnXImDEjFy9eJGvWrAkdUjQvHr9idO2pBPoFx/nUIEklYWSsZu7JKZSvVzrG9w0fPpwrV67g4uISp35/RZZlHl9/xtE1p3Dafx2tRoskSaj/V8Rep9Wh08kgQdWmFbjx2okPmje43nfFyEgUjkjstBotGyfs5NDy46hUqlj97KpUKjLnysjkvaNj9BAU6BvIuAYz8Lr/Iu6/I1LEf03aNZJ6nRJPWbHHjx9Ts2ZNKlWqxMmTJzEx+XEpoPgiyzKrVq1i1KhRNGvWjD179iS6KhD/de3oLXZM34en64uI9fY/WAKhUqv+N+2uol7nmvSb05WsebIkQLTC74iEUkjUnjx5Qp06dciXLx/nzp1LNMf4+X8NoH/p0Xz75Kf3EZSSSsIklTEb7i8md5GYFYju2bMnz58/59KlS3r1/V9fP/qyfMgGrh52jtrR+SuRU5e5SmVn7pEp5CmaOEeShe89uOzG0kHrePXk7W//riWVhEol0XJgY/rN7UbqdGa/bV+n02Hb5C/uOz3W/5hWKSKZXeI0k9I1lK3NGBdv376levXqZMiQgcuXL5MhQ4YEjSc8PJyRI0eydu1aRo8ezcKFCxP1uke/L/6sGr6ZC3uv/nb5w7+pjVSYmJowbEVfmvSqlyjWjwv/TySUQqJ3//596tWrR8mSJTlz5sx3JS8SwvyeKzm/54pi55mrjVSUqlacxRdnxGjarHXr1mg0Go4dO6ZI/xCRYEyzmU+Qf+xHXNVGKlRqFeO3DhfF6ZMQWZa57/SY4xvPcvHwVeSQ6K8bGaspVDY/tdpWo3n/hmTKHvPE6eia06wcvkmxWFVqFdnzZ2XjgyWYpk64uof+/v7UqVOHT58+cePGDfLmTdiNQ1+/fqVDhw44OTmxZs0aBgwYkKDx/I7P2y+Mq/8n77w+xO3983/LJjqOt6H/vG4iqUxEREIpJAm3bt2iYcOGVKlShePHj2Nm9vsREkN5cNmNMXWnGaTtCduG07hn3d9e16BBA3LmzMnu3bsV6dfV6RETm81CG66NmM6Oi/+9r9tu/4NG3esoEpcQf4oWLUrzhi0YMWgUWo0Ws7Sm5CmWCyPj2C9j+PbJl24FhxIWHKZojJJKouuktvSe2VnRdmMqPDycVq1acePGDa5cuULZsmUTJI5I7u7utGrVCh8fHw4dOkS9evUSNJ7fCfgWyB/VJvLO68NvZz9iouefHekxrYMCkQlKSPgVxIIQA1WrVuX48ePcuHGD9u3bExam7AdVbBxecSJqPaGSJJXEoWUxG3H08/NTbDe1z5vPTLWep18yCRGbLWRY0HsVT295KBKbED/8/f3x9PSkSo3KEfUGLYpRwDxfnJJJgFNbLhAeGq5wlCDrZI6sPkWYAdr+bd+yzMCBA7lw4QKHDx9O8GTy/PnzWFpaolKpuHnzZqJPJgHWjN7KW09lkkmAHTP28/DqE0XaEvQnEkohyahduzZHjhzB0dGRrl27otFo4j2Gb598uWrvrNgb4r/JOjlqR/Xv+Pn5KbLgXpZlFvdbS1hwmH7J5L9IksT8nisT5ENfiJv79+8DKHJClSzLHF1zyiDHPAIEfA3k6mFng7T9K9OnT2fbtm1s27aNBg0axHv//7Z+/XqaNm1K1apVuX79epKo13vr1D3ObndSbJkQRKyrFe81iYdIKIUkpXHjxhw4cIAjR47Qt29fdDrlE7tfeXz9maJviP8lqSQeXHb77XVKjVA6n7jL7TOuiibIOq2O18/ecWztGcXaFAzLxcUFY2NjSpXS/yi9jy99+PTqswJR/ZjaWI3rxUcGa/9HNm7cyF9//cX8+fPp2rVrvPb9bxqNhlGjRjF48GAGDRrE8ePHE81Gxd/Z+ddBVCpl1zvqtDree3/k0oHrirYrxI1IKIUkJ/I82l27djF06FC9izTHxrPbngaZ7o4kqaQYjVD6+/srsrPUfuXJiCMxFSYjc3jliXhP+IW4cXV1xdzcXJHSN8/uGLY2qjZci9vNZwbt49+OHz/OkCFDGDZsGOPHj4+3fv/L19cXKysrVq1aFfVPUinT5XX/BW7Xnyk2C/JvKpXE4RUnFG9XiL2k8dMoCP/RqVMngoKC6Nu3L6lTp2bx4sXxstvvw4tPGDJ/1Wl0vPV4/8trNBoNQUFBek95+7z5zO2zrrEqNB1jMrz3/siDy26Urxvz+ppCwnBxcVFkuhvgnef7qJNuDOW910eDtf1vt2/fpmPHjrRq1Yrly5cn2I5iT09PrKysePv2LSdPnqRx48YJEkdcXTtyy2A/EzqdzLPbnnz98C1Rn6iUEogRSiHJ6tOnD6tWrWLp0qVMnz49Xvr8UeFdpYWH/XptqL+/P4DeCaXbDXfDJJP/o1KrcLsefyNJQtxoNBoePHhA+fLlFWkvPExj8MRLE2749dNeXl60bNmScuXKsXv37gSr63jp0iUsLS0JDw/nxo0bSS6ZBHh6y8PgM0mGHhkXfk8klEKSNmzYMObPnx+1vsnQUpmlMviH5e+KRvv5+QH6J5QR0/cG/JCUZZ7d8TRc+4Ii3N3dCQkJUWyE0jR1KmQDL3UwMTU2aPs+Pj40a9aMDBky4ODgQOrUqQ3a389s3bqVRo0aUa5cOW7evEnJkrE7ojWx8HR9brBNWhDx8Or94KXB2hdiRkx5C0nehAkTCAwMxM7OjtSpU/PHH38YrK+CpfMZdF2g+n+FpH9FqYTy87uvGHL+XqeT+fjSx2DtC8qIPL5TqRHK/OZ5DbJW7t8KlM5nsLaDgoKwtrbG19eXa9euJciRr1qtFjs7OxYtWsSAAQNYvXo1xsaGTaINKTgg5PcX6UGlkgj2DzZoH8LviYRSSBb+/PNPAgMDGTFiBGnSpKFv374G6ad4lSIGfdLWhmspXrnIL69RKqHUaXWGnPEGMEh5pcRClmUeXHbj3rkHPLvtyUu3N4SHhmNsakzB0vkoXqUIVZpWoKRF0UR9moeLiwv58uUjc+bMirRXvHJhRdr5GbWRmpIWxQzStlarpVu3bri6unLx4kWKFPn176Ih+Pv7061bN44fP87SpUsZOXJkov75iQm1ATb+/ZsMhp1tEWJEJJRCsiBJEgsXLiQwMJD+/ftjZmZGly5dFO+nhEVR0mVKg//XQMXbBlAZqajcpNwvr1EqoUydzgxJJYEBl4WmzZjGcI0nEJ1Ox6nN5zmw+Civn71DbaRCp5WjrRH78OITzifvsePP/RQqm59OE1rToGutRJkYuLq6KjbdDZAha3qKVCiI1/0XBnn40mq0WDSvqHi7siwzcuRIjh49ytGjR6latariffzOixcvsLKy4vnz5zg4ONCiRYt4j8EQsufPiq+Pv8Ha14ZryZYvi8HaF2JGrKEUkg1Jkli9ejU9evSgR48eHDlyRPE+TFIZ03JQE4OU2lEbqajdrhqZc2b65XVKJZSFyhUw6CYjtbGaohULGaz9hPDW8z1j6k5j6aD1vHZ/B0SMwv53w4Gsk6N2tD5/9Ip5PVYwqflsPr02XH3GuFJyh3ek1n+0MMxIvgS5CmenQoMyije9aNEiVq9ezdq1a2nZsqXi7f/OtWvXsLCwICAggOvXryebZBKgpEUx1MaGHUEsXiX+R5OF6ERCKSQrKpWKzZs307ZtWzp27Mjp06cV78NmWFOMTZQf3NdpZTqNt/ntdX5+fkiSRJo0+o3+Fa9SxKC7vLXhWooZePozPj28+oTBFcfz5KZ7xBdi+GcXmVjdO/+AQRXG4en63DABxsH79+/58OGDYusnI9XvXIPMuTIpXsgaGTrbtkGlUvaja8+ePUyYMIEpU6YwcOBARduOiZ07d1K/fn2KFy/OzZs3KV06eZXaKlOrJNpwwz28mqUzpYB5XoO1L8SMSCiFZMfIyIi///6bxo0b06ZNGy5duqRo+1nzZGHwkt6KtimpJDpNsKFYpd8nYJGn5Oj7oVq0YkGDThMZpzIyyNRkQnC/64Vd01mEBIXGeV2oVqMj0DeIcfX/5PWztwpHGDeurq6AMkcu/lsqs1SM2zJU0c05aiMVZeuUolk/ZY89vHDhAr169aJnz57MnDlT0bZ/R6fTMWnSJHr27EnXrl1xdHQkW7Zs8RpDfKjUrBxGpoYZoVSpVbTo1zDO584LyhEJpZAsmZiYcPDgQWrUqEHLli25efOmou23HNiI6tZVItYg6kmlVlGkQkF6TO8Qo+uVOsdbrVZjM6y5It/Dd20bqWjUvU6yWEMZEhTKzA6LCQ8N13saV6fVEeQfzKxOS+KlluLvuLi4kC5dOgoVUn5pQtWmFWj9R3NQ4MdLpVaROp0ZE7YN1+tBSqvV8vS2J8fWn2XFsE3YtprJmGZTqJu3Kb1bDODz2y/6BxtDgYGBdOjQgXnz5rFgwQK2bNlCqlSp4q3/+BAUFMSSJUsoaV4CzxA3DLGEWNbJtBrcRPmGhVgTCaWQbJmamnLkyBHKly9Ps2bNosqjKEGSJKbsHU3lRuX02mihUqsoVCYf809PxcQ0ZsfeKZVQArQY0JD0mdMqnlRKKhUdJ7RWtM2Esm3qXj68+KTYKR86rQ6v+y/Yv/CoIu3pw8XFhXLlyik+hRxp8JJeVGxeGlmPtRUqtQqzdKYscJxOzoLZ49SG/9cA9i04Qo/CwxhuYcfyoRs4sfEsd07cJ0t4LtSvUzOny3K65B/MxGazuHn8jkELcb9+/ZratWtz+vRp7O3tGT9+fKLcsBVXgYGBLFq0iEKFCmFra0urVq04fG83mXJkVHQZhKSS6DDWirzFcyvWphB3IqEUkrU0adJw/PhxihQpQuPGjXFzc1OsbRNTE2YetaXjeGskSYrVRp3IBK5RjzosdppJ+izpYnyvkgllukxpGbNpiOIbKPrN6UreYrkUbTMhfP3oi/3Kk4r/+cgy7Jn7D8GBhq3P9ztK7/D+rw8fPrDr7kbC8vqiUqtQG8XyI0eCIuULsurG3Dhv8Lp29BZ9Soxg86RdfHr1v01RcsQSBOl//4laxiDD3XMPmGI1j8mt5uJjgBFLZ2dnqlatio+PD1evXsXa2lrxPhJKQEAA8+fPp2DBgkycOBEbGxuePXvGpk2bKF2+NOO3DVdsGYTKSEXuIjnpNbOTIu0J+hMJpZDsZciQgdOnT5MzZ04aNmyIp6dyp7cYmxjTf153VlyfTalqEbXxZOnnb5iRtdIKmOdl1rGJjN8yjDTpY3cKh5IJJUAN66q0GaHMjlJJJWHRoiJtRiaPHaqnt5w3WCH7kMBQLuy+YpC2YyI4OJinT58aLKEMDg6mTZs2SCqJfTd3sO7uAsxrlAD4ZWIZOYKVNmMaBszrzsobc+I0AqXT6Vg9cgvTWy/A70tAjB8KIkei75xxpW+pkTy4rNxD6L59+6hbty4FCxbE2dlZ8c1QCcXf35+5c+dSsGBBpk6dSrt27fDw8GDDhg3RllNUaVKe4Sv76d2f2khFhqzpmXd6SoxndgTDk2RDH7ApCInE+/fvqVu3LqGhoVy+fJl8+ZQ/bWPyqGkcXnOcRlWb4eX6gtCgUACMTIwoVDY/5tWK06BrLUpVKx7nKa6mTZuSPn16Dhw4oFjcOp2OmV0XcnX/7Ti3IUlQpVlFph8cSyqz5LEWbGC5sXg/NMyRbpIkUb5eaRaei59z6P/r1q1bWFhYRI2YKUmWZXr06ME///zD5cuXqVy5ctRrLx6/4uTm89y/9BjvBy/R/Ovs+iy5M1HSshi12lhSp0N1TFLF7XQYWZZZMXQjx9af1ev7UKkk1MZqFpydRplapeLcjizLzJgxgxkzZtCtWzc2bdqEqampXrElBn5+fqxcuZIlS5YQEBBAv379sLOzI3/+X5/2dWrLeZYP3Yis08V6k5skSeQtkZs5JybFeQmEYBgioRRSlFevXlG7dm1MTEy4dOkSOXPmVLR9S0tL8ufPz4EDB5BlmbCQMGQ54uxhpdapVa9eHXNzczZv3qxIexAxwmBR1QKzrxnI+Ck3akkd47I4KrUKJOgxtQOd7Vonm92WYSFhWKXrodjayR9Jnc4M+2/bE2T93MaNGxk8eDABAQGYmf36/PjYmj9/PnZ2duzdu5dOnX4+JakJ1+D32R+tRkfqdKakyaDMJq7jG86ybPAGRdqSVBJpMqRm65PlZMyWIdb3BwcH07t3b/bv38+sWbOYNGlSkl8v6evry4oVK1i6dCmBgYEMGDAAOzs78uaNeemeV0/fML/nKp7e8kClVv3290ylViHLMl3s2tBtavs4P2wIhiOmvIUUJV++fJw7d47AwEAaN27M58/KFZp+8+YNzs7OtG7dGoh4kk5llgrT1KkU3fSg9JS3LMv06dOHN2/fULpJMR6kuUrdTtUwMjFCkqQfTk+q1CoklYSkkqhuVYW1txfQfWr7ZJNMArx0e2PQZBIgyD84wYqdu7i4ULJkScWTSQcHByZOnMiUKVN+mUwCGBkbkTlnJrLlzaJYMvnhxSfWjt6mSFsQsYs4yC+YlcM2xfred+/eUbduXRwcHDh48CCTJ09O0snkt2/fmDFjBgULFmT27Nl0794dLy8vVq1aFatkEiBfiTysuD6beaenYNmyUrQ16Cq1KtrmnfRZ0tFpgg07PVfTZ1YXkUwmUsnn3V8QYqhIkSI4OjpSt25dmjZtyrlz58iQIfYjD/915MgRjIyMDH7ChdIJ5aJFizh06BCrVq1i1KhRzJo1C1vbsfh98efSgRs8dXbH7aY7Xz/6Iutk0mVOS0mLohSvXIQ6HaqTLW/yPPIs0Dcofvr5Fgj5ssZLX//m6uqq+Bq+R48e0bVrV1q3bs2MGTMUbTumdvy5X/GSTDqtjksHb/D4+lPMq5eI0T337t3DysoKWZa/m/ZPar5+/cqyZctYvnw5oaGhDB48mPHjx5M7t367q1UqFZUbl6dy4/KEBofidf8lXq7PCfIPQa1WkSV3JopXKULOQtmTdCKeUoiEUkiRSpUqxdmzZ6lXrx4tWrTgzJkzep88Y29vT7169ciU6ddHJ+pLyYTy/Pnz2NnZYWtry9mzZ8mTJw8jR44EIH3mdLQa1JhWgxor0ldSY4jjNROyn3/T6XS4uroqusP48+fPWFtbU7hwYXbs2GGwUkS/4vfZn/N7rsS5+PyvqI1UHF17OkYJ5T///EOPHj0wNzfnyJEjeideCeXLly8sXbqUFStWEB4ezpAhQxg/frziS4Ugohh+KctilLIspnjbQvwQU95CilW+fHlOnTrF/fv3sbGxISQk7iVcvn37xoULF6Kmuw1Fp9Ph7++vSEL56tUrOnfuTP369WnSpAlHjhxh7ty5yWKzgBIy58oYL/1kyhk//fybl5cXAQEBiu3wDg8Pp3379vj5+XHkyBHSpk2rSLux5XTgusGO+NNqdFzce42Q/220+xFZlpkzZw7t2rWjZcuWODk5Jclk8vPnz0yePJmCBQuyZMkSBg4ciLe3N4sXLzZIMikkDyKhFFI0S0tLjh8/zrVr12jfvj1hYWFxaufEiRNoNBpsbH5/Frc+AgMDkWVZ74QyNDSU9u3bY2pqyq5du5gwYQIWFhZ07txZoUiTvlyFc2Ca1rDJdda8WUifOeY1SJUSeeSiUlPeI0aM4OrVq/zzzz8ULFhQkTbj4omzu0FHfLUaLV73X/zwtZCQEHr06MHkyZOZPn06e/fuJXXq2JUES2ifPn3Czs6OggULsnz5coYMGYK3tzcLFy4kR44cCR2ekMiJKW8hxatTpw6HDx/G2tqabt26sWfPHoyMYverYW9vT9WqVWO9MD22/Pz8APROKEeNGoWLiwtXrlzh7Nmz3Llzh8uXL4t1Sv+iUqkwr1YMlwuPDLI5R22komytkoq3GxMuLi7kzJlTkSRhzZo1rFu3jo0bN1K7dm0Foou7Jzfd0WoMM0IJERvt3O94YV6teLSvf/jwgTZt2nD37l327NmT5B7MPn78yKJFi1izZg2SJDF8+HDGjh1L1qzxv7ZXSLpEQikIRNR23L9/P+3ataNv375s27YtxmvAQkJCOHnyJBMnTjRwlMoklNu2bWPdunVs2LCBMmXK0K5dO9q2bUutWrWUCjPZaNG/EXcdHxikba1GR7N+DQ3S9u+4uLgoMt19/vx5RowYwYgRI+jfv7/+genp6wdfg7avNlLx7WP0Pu7fv4+VlRWhoaE4OTlhaWmpeL+vn73F7aY7Hne98fXxi5ilyJyOIhUKUqJqEQqWyR+nh8EPHz6wcOFC1q5di1qtZuTIkYwZM4YsWZLnRjvBsERCKQj/Y2Njw86dO+nWrRtp0qSJelr/nfPnzxMQEGDw9ZOgf0J59+5dBg8eTN++fenfvz9z587l/fv3zJ8/X8kwk40arauSIVt6/Hz8FT3bWaWSyFkoOxUblFGszdhwdXWla9euerXh6elJhw4daNCgAYsXL1YoMj0ZuKyyDNFO3HFwcKBr164UKVIEBwcHRQ9L0IRruLDnKodXnsD9jhcARsbqqKMLJZUUtV40f6k8tP6jBU161Y3RoQLv379nwYIFrFu3DmNjY8aMGcPo0aPJnDmzYvELKY9YQykI/9KlSxc2bdrEunXrGD9+fIySiMOHD1OsWDFKlYr7SRoxpU9C+fnzZ9q1a0eZMmVYvXo1Hz9+ZO7cuQwbNoyiRYsqHWqyYGxizLDlfRVNJgF0OpkRawYkyBKDz58/8+rVK71GKP38/LCysiJLlizs27cv1ktEDCVcCjdo+zqtjnSZ0yLLMosWLcLGxoZGjRpx5coVRZNJ7wcvGFbVjgW9V+Fxzzvq65pwLTqtDp1WF23z0asnb1gxbCMDy43l8fWnP2337du3jBo1ikKFCrFlyxbGjx/P8+fP+euvv0QyKegtcbwLCEIi0rdvX4KCgvjjjz9IkybNL+vpabVajh49Sq9eveIlOYhrQqnVaunWrRt+fn5cvHgRU1NTRo8ejZGREVOnTjVEqMlGvU41cDpwjetHbyuyllJSSTTr24DKjRPmHOfIDTlxTSi1Wi1du3bl7du33Lhxw+BlsmJqx44dPP/sQU5V/hif8hRbsk6mQJm89OvXj61btzJx4kRmzZqlaIkkx78vsajv6qjB1picQR557fvnnxhZawpDFvem7aiWUa+/efOG+fPns2HDBszMzLCzs2PkyJFkzJhRsbgFQSSUgvADw4cPJzAwEDs7O9KkScOECRN+eN2NGzf4+PFjvEx3w/8nlOnSxW5n8IwZMzhz5gynTp2iQIECPH78mA0bNrBw4UIxMvEbkiQxfuswxtadhvfDV3ollSqVitK1SjB8RV8FI4wdV1dXzMzMKFYsbvX+Jk2axMmTJzl+/DglSybMpqL/Onv2LP369aONZWe+3Q5VfEQ5igRjpo/k5p0b7Nixgx49eija/NmdTizotSrO90f+bK4dsw2dTodlhwrMnz+fjRs3kiZNGiZPnsyIESMUOchBEP5LJJSC8BO2trYEBARga2tL6tSpGT58+HfX2NvbkyNHDoMsxP8RPz8/zMzMYjXF6ODgwF9//cXs2bNp0qQJAOPHj6dgwYIMGzbMUKEmK2nSp2bRhRlMtZnPw8tucW6nStPyTD0wFhNTEwWjix0XFxfKli2LWq2O9b07d+5kwYIFLF68mGbNmhkguthzdXWlXbt2NG7cmGWrFtK72AiD9KNSq/A3+YKHhxvnz5+nZs2airbvdf8Fi/utUay99eN2MNR2ENr0oUybNo0//vhD0RO2BOG/REIpCL8wc+ZMAgMDo6a/+/TpE/WaLMtR5Ybi8uEcF7E9JcfDw4MePXpgbW2NnZ0dAI6Ojpw4cYIDBw6QKtXvF/ALEdJmTMOi89OxX3GSTRN3Ra1l+x1JJWFiasLQpb1p3r9hgpdmcnV1jdMD0M2bNxkwYAC9e/dm9OjRBogs9l6+fEmLFi0oVqwY+/fvJ23atFSzqszN43cVL/Wk0+oIzeaP80VnxWttasI1zOuxQtGZehkZi7T12PJwOdlzZVOwZUH4MbEpRxB+QZIkFi9ezKBBg+jfvz/79u2Leu3x48d4enrSpk2beIsnNgllYGAgbdu2JXv27FFH4Wm1WsaNG0eNGjVo166dgaNNftRqNe1Gt2K7+0o627YmfZb/X3qgUksYGatRG///w0XmXBnp9WcndnquosWARgmeTIaFhfH48eNYFzR//fo1rVu3pnLlyqxbty7Bvw+IOF+6efPmmJiYcPz48ajTeXrN6KT8Jip0SJm0nHM5ZZDC7Y5/X8b7wUt0Ch4ZKSER5q/h/PYrirUpCL8iRigF4TckSWLNmjUEBQXRvXt3zMzMsLa2xt7enrRp09KgQYN4iyWmxy7KsszAgQPx9PTk5s2bUWumduzYgaurK9evX08USUFSlT1fVvrM6kLPPzvi7uJFI4umtGnUDvOSpTExNSZfyTwUq1yY/KXyxNvodUw8fvyY8PDwWG3ICQoKonXr1hgbG/PPP/8kilHt0NBQWrduzfv377l27VrUcYA6nQ57x0N4yY8phDJVF2RZRm2kYvP1ZQbbxGK/8gSSSorRBpzYkHUyR1afosP4+JtFEVIukVAKQgyoVCq2bNlCUFAQHTp0wMHBAXt7e1q0aBGvH7AxHaFctWoVu3fvZs+ePZQpE1HrMDAwkMmTJ9OpUyeqVatm6FBTBLWRGnUGeCN702Z883h9uIgLV1dXJEmibNmyMbpelmX69euHm5sbV65cSRTH7+l0Onr16oWzszOOjo6UKFECiDg2sHfv3pw4cYKxo8eifpQel3MPo+o2xoWMjCRJTPp7FPmK51HqW4jmxeNXeLo8N0jbAD5vvvDgkhsV6idMzVMh5RBT3oIQQ0ZGRuzevZtGjRphY2PD7du34213d6SYJJRXrlxhzJgxjBo1KtoRcIsXL+bz58/MnTvX0GGmKB4eHgBJopani4sLRYoUiXGVgDlz5rB37162b99OxYoVDRxdzNja2rJ//3527doVtTHGycmJChUq4OzszIkTJ1i0ZBEz7W2p3LRCnPuR0aFSqbDd8Qf1Oim7Aeff3G56GKxtiNhM9OSmu0H7EAQQCaUgxIqJiQkHDx4kf/78APE+YvO7hPLdu3d06NCB6tWrs2DBgmhfX7BgASNHjqRQoULxEWqK4eHhQapUqQx+jrsSYnPkor29PVOmTGH69Om0b9/esIHF0IoVK1i0aBHLly+nbdu2aLVaZsyYQYMGDShevDiurq40b94cgFRmqfjrqC0DF/SIWNtqFLOPO/l//8lZOAcrb8ylUfc6hvyWcL/jGW3drUH6uOtl0PYFAURCKQixZmZmRq5cuciYMSPt27fn/v378db3rxLK8PBwOnXqhCRJ7N+/H2Nj46jXpk6diqmpKZMmTYqvUFMMDw8PChcurGhxa0OQZRlXV9cYJZT379+ne/futGvXjmnTphk+uBj4559/GDVqFOPGjeOPP/7g7du3NGrUiJkzZzJ9+nQcHR3JnTt3tHvUajUdxlmz8cESmvSqh3GqiFVe/03gVCoJ6X9/fZKpTJ85ndnyaDklqhQx+Pfl6+On+I70f9NpdXx+981g7QtCJLGGUhBi6evXr1y5coUFCxawa9cuGjVqxKVLl+KlyPOvEsoJEyZw/fp1Ll68GLVJASKSgy1btrB8+XJxMoYBeHp6UqSI4RMPfb169YqvX7/+dof3p0+fsLa2plixYmzfvj1RJMpXr16lW7dudOzYkfnz53Py5El69uyJiYkJ58+fp27dur+8P2/x3IzZOIQBC3pw6+Q9nt3xwuOeN4G+QUgqifff3nDX4zYN29Zl7Z6VmJjEX51QAx8/Ho+dCCldwr9TCEISc/z4cbRaLZ06deL06dNkz56dhg0b4uVl+GmlnyWUe/bsYdmyZSxZsuS7gsvjx4+nWLFiDB482ODxpUQeHh5JZv0k/PrIxbCwMNq1a0dwcDBHjhwhTZo08RPcLzx58gRra2ssLS3ZuHEjEyZMoEWLFlhaWuLq6vrbZPLf0mVKS4OutRm8uBeLzv/J3HOT8MzswlHvvdiuGcnmQ+vjNZkESJcxDSq14T6KJZVEhmyioLlgeGKEUhBiyd7eHgsLC/Lkidj1efbsWerUqUPDhg25fPmywdbSybL8w4TywYMH9O/fn27dun13ms+pU6c4c+YM9vb20abABWVotVq8vLySRELp6upKlixZon5u/0uWZYYPH86NGze4cOFC1DrhhPT+/XuaN29Ozpw5Wbp0KY0aNeLevXssXryYUaNG6TV66uHhgZWVFe/fv+fUqVM0atRIwchjrkjFQmg3OhqsfZVKomgFsW5aMDwxQikIsRAcHMypU6eiFTPPlSsX586dQ6fT0bBhQz58+GCQvkNDQwkPD4+WUPr6+tK2bVuKFCnC+vXro9WW1Gg0jBs3jrp162JtbW2QmFK6169fEx4eniSmvF1cXChfvvxP64+uWrWKjRs3sn79esWPFYyLgIAAWrZsSVhYGMOHD6devXp8+vSJq1evMmbMGL2SSScnJywtLdFqtdy4cSPBkkkXFxc27V9n0D60Gh3Fqyb+n08h6RMjlIIQC46OjgQGBn5XLih//vycP3+e2rVr07hxYy5cuECWLFkU7dvPzw8gKqHU6XT07NmTT58+cfv27e+mJ7ds2cKjR4+4deuWKGJuIEmtZNDPylw5OjoyevRoRo8eHe140YQSHh5Ohw4dcHd3p2nTpgwdOpSOHTuyYcOGqCL9cbV582YGDx5MnTp1OHDgAJkzZ1Yo6pi7e/cuM2bM4OjRoxQpXISy2WoS4BOEomcv/k+6TGmo2DBmdUfjwuftF+6cccX9jhfeD18SGhSKkbEReYrnolilwpSvV5pCZRJ+tFswPJFQCkIs2NvbU6JEiR9uwClSpAiOjo7UrVuXZs2a4ejoqPeH37/9N6GcN28eR48excHB4buExt/fn2nTptG9e3eqVKmiWAxCdB4eHqjVagoUKJDQofySn58fXl5eP1w/6e7uTocOHWjUqFG0UlMJRZZlhgwZgqOjI/ny5ePYsWOsX7+eAQMG6PVgpNVqmTBhAkuWLGHQoEGsXLky3peB3L59mxkzZnDs2DGKFi3Ktm3bsLGxwbbrNPxPBSKh7IOfSq2i5aAmmKRS/vt0u+nO/oVHuGrvjKyTURur0YZro15/4uzB2e1OyLJMSYuitBvdiroda4iH22RMTHkLQgxptVqOHj36y2Lm5ubmnD17Fg8PD1q2bElgYKBi/f87oTxz5gxTpkxh6tSptGrV6rtrFyxYgK+vL3PmzFGsf+F7Hh4eFCxYMNGvT40sbfXfHd6+vr5YW1uTI0cO9u7di5FRwo8xzJgxg82bN6NSqTA1NcXZ2ZmBAwfqlYj4+flhY2PDsmXLWL58OWvXro3XvzNnZ2datmxJ1apVefbsGTt27OD+/fsEBgZSokQJdjhuwiSdMSqVcsmWJEHqdGa0G91SsTYBQoJCWTt6GyNqTOL60VtRx0X+O5kE0Gq0UWeqP7vtyewuy5jYbBYfX/koGo+QeIiEUhBi6Nq1a/j4+Pz2dJwKFSpw8uRJXF1dad26NSEhIXr1q9PpojbkQMSHY5cuXWjatCnTp0//7vrXr1+zePFixowZQ758+fTqW/i1pFIyyMXFBRMTk2gj61qtls6dO/P+/XuOHj2aKEpKrVmzhhkzZgDQvXt3bt26FeNjIn/m+fPn1KxZk8uXL3P8+HFGjBgRb6NkN27coHnz5lhaWuLl5cWuXbt49OgRpqamlCtXjuHDh9O8eXOeuLsx98gUvY6J/C9ZhlHrB5Exm3KzJF8/fOMPy4kcXnkC5Ij1mTER+X3dO/+QAWXH8PjGM8ViEhIPkVAKQgzZ29uTM2dOLCwsfntttWrVOHbsGFeuXKFjx46Eh4fHqU+dTkf27NkxMTGhZcuIkYZmzZoRGBhIjRo1UKu/P2Fj8uTJpEuXDltb2zj1KcRcUikZ5Orqirm5ebSSOLa2tpw5c4Z9+/ZRvHjxBIwuwqpVqxg2bBhGRkb8/fffbN68We+yRVevXsXCwoKgoCCuX79Os2bNFIr2165du0bTpk2pXr06L168YPfu3Tx8+JBcuXJRo0YNOnbsGHWyz7Zt2yhQoADl65Wmz6wuisXQ+o/m1O1QXbH2/L74M7bedF49fRM1KhlbOq2OkMBQJjSaKU7vSYZEQikIMSDLMvb29tjY2MR4d2ndunU5fPgwp06donv37mi12t/f9B+SJJE3b140Gg1BQUFAxG7v0NDQqA0hTk5OWFlZce3aNe7evcvOnTuZMWPGb8/8FvQjy3KSSSj/e+Ti9u3bWbx4MUuWLKFJkyYJFxgRf44TJkzgjz/+IH369Ny/f59u3brp3e6OHTto0KABJUuW5ObNm5ibmysQ7a9duXKFxo0bU7NmTd68ecO+fft4+PAh5ubmtGrVigYNGiBJEhcuXOD48ePfjb52mdiG3jM7AxH1I2MrcuC19fDmDFnaW99vJ5plgzbwxuN9jEclf0an1REeGs6fbRcSHKjf7I2QuIiEUhBi4OHDh3h5ef12uvu/mjVrxv79+zl06BD9+vVDp4vdm7EkSYwdO/a7r5uYmPDXX38BcPHiRY4dO0bNmjVp2rQpRYoUoX///rHqR4i9d+/eERwcnOinvDUaDQ8fPoxKKK9du8bAgQPp168fI0aMSNDYvnz5QtOmTVm4cCE5cuTA29ubUqVK6dWmTqdj4sSJ9OrVi27duuHo6EjWrFkVivjHLl26RMOGDalduzYfPnzgwIED3L9/HwsLC3r16kXFihXx9PTk4MGD3Lhxg3r16v2wHUmS6DalHbOPTyJjtvSxWlOpUqtInSE1k/eMYujyPoqecHTp4HUuH7qh2BGROq2OT68/s9lulyLtCYmDSCgFIQbs7e1Jly4d9evXj/W9rVu3ZseOHezYsYPhw4dHLVS/d+8e586d++39HTt2jLZbXKVSYWtrG1V4OiAgIGqDgY+PD15eXowfP56vX7/GOlYh5jw9PYHEXzLo2bNnhISEUKFCBV69ekXbtm2xsLBgzZo1Cbrj9tq1a5QrV45z586RM2dO7t+/r3cJn4CAANq1a8f8+fNZtGgRmzdvNujJNxcvXqRevXrUrVuXz58/c+jQIVxcXKhXrx7jxo2jRIkSnD17ljVr1vDo0SPatWsXoz9zi+YV2eK2nG5T2pMxe8TvvspIFW3UUpIk1EYRH+FpMqSm/ehWbHVbTr1ONRX9e9XpdGy0/Rulf1RknczRNafFJp1kJOG39AlCEnD48GFatmxJqlSp4nR/165dCQoKYsCAAaRJk4bGjRtjbW2NqakpPj4+v9xd6+fnF5WEAmTNmpUJEyZE/XtAQEC063U6HcuWLcPHx4edO3fGKV7h9zw8PJAkicKFCyd0KL8UeeRikSJFsLa2JlWqVBw6dCjejxiMpNPpmD9/PlOmTCFNmjRkzJiRy5cvkz17dr3affXqFdbW1nh4eHDkyBGsrKwUijg6WZa5cOECM2bM4NKlS1SsWJHDhw9jbW1NSEgI8+bNY/78+ciyzNSpUxk1ahRp06aNdT9pM6ah558d6Tq5LffOPeCJswfud7z48v4bsk5HxuwZKFapMMWrFqFKk/KYmBrm7/PeuQe89/5okLYllcSJjY5R0/xJiVaj5eWTN7xxf0d4qIZUZibkLZGbvMVzKTo6nJSIhFIQfuPFixfcu3dP700u/fv3JygoiJEjR7JkyRJkWSY0NJQrV678dApMo9HQuXNnjI2NkSQJWZZZuHBhtA+owMDAaOszJUmifPnyTJkyRa94hV/z8PAgb968mJqaJnQov+Tq6kqBAgUYM2YMz5494+rVq3onb3H14cMHevTowdmzZylRogQvX77k7Nmzeo/y3rx5ExsbG1KlSsXVq1cpV66cQhH/P1mWOXfuHDNmzODKlStUqlQpKnHVarVs3ryZ6dOn4+Pjw9ChQ5k8eTLZsmXTu18jYyOqNqtI1WYVFfguYu/8niuojVR6r538EZ1Wx5ntF5NMQqnVanE+cY+ja07j6vSI8JDvN1umMjOhcpPyWA9tSsWGZVNUcplyvlNBiKMjR45gbGxM8+bN9W4rR44cSJIUVQrIyMiII0eO/PT6KVOmcPHiRQ4cOEDVqlXJli0b3bt3j3bN169f0el0EVNgajUzZ87k1q1blChRQu94hZ9LSiWDzMzMOHDgADt37vyuFmV8OXv2LOXLl48qp+Xu7s7evXuxtLTUq909e/ZQt25dChcujLOzs+LJpCzLnD59mlq1atG4cWNCQkJwcHDg9u3bWFlZYW9vT5kyZRg4cCD169fnyZMnLFu2TJFkMjF4fO2pQZLJSJ9efcbvi7/B2lfKg8tu9Ckxkmk287nreP+HySRAaHAYN4/fwa7pLAaWG8uzO57xHGnCEQmlIPyGvb09DRs21HvX9IkTJ+jSpUu06WuNRsPBgwejfQ0iPsRWb9vDlpPXsR6zgK3O7yli8wfWtqtYeMCJo9cf8ck3Yqr70aNHQMSU5q1bt5gyZUqiKFCd3CWVHd43b97kyZMnzJw5M9oZ9PFFo9EwefJkmjZtSrly5Rg6dCj29vasWrVKrzPmdTod06dPp2vXrnTo0IHz58+TI0cOxeKWZZmTJ09SvXp1mjVrhlar5cSJEzg7O9OqVSuuXLlCjRo1aNu2LQUKFODu3bvs2rUr0S+BiI2wkDDeeLw3eD8e954bvI+40mq1bBi/gzH1pvHhxSeA325OikzAXz19y3DLieyadei79/jkSHzqCMIvfP78mUuXLrF69Wq921Kr1WTLlo2PHz9iZGSERqMBIgqRP3jwgHLlyqHTyRy/+ZjNJ67z0sefvNVteB2kQvv8/9/U73u/Q6PVoZIk6lcoSuU6jSlf/iN79+6N8xpPIXYiSwZ16NAhoUP5JUdHR3x9falRo0aCLIF4+fIlXbt25caNG8yZM4cCBQrQtWtX7OzsGDJkSJzbDQoKonfv3hw4cIA5c+ZgZ2en2EYUWZY5ceIEM2fOxNnZmerVq3Pq1CmaNGmCJEk8evSIiRMn4uDgQKVKlTh79iyNGjVSpO/EJtA3KM41J2PD/0vA7y9KADqdjgW9VnF+zxWQf59Ifnf//67fNm0v3z75MnRZn2R99KQYoRSEXzh+/DharVavkZRITZs25e3btzg6OtK9e3dSp04d9dqiRYt4+fEb/RbvY/qOM7z45BvxgiSh/c8buuZ/b1I6WeaiqwdeqUtSt8doUH1f5FwwjM+fP+Pr65uop7w/fPhAly4RhbI3btwY7x9kR44cidpZfunSJWrUqEHv3r3p1q0bs2fPjnO7b9++pW7duhw/fpxDhw4xceJERb43WZZxcHDAwsKCVq1aYWxszJkzZ7h69SpNmzbl9evX9O3bl3LlyvHo0SP27NnDrVu3km0yCaD41u6fUPLISSVtm7o3KpnUl/3Kkxxaekz/hhIxkVAKwi/Y29tTrVo1cuXKpUh7arWahg0bsnXrVnx8fNizZw/FihVDTpeDzrN28vB/I5GSFLNfTa1ORpZhp+Mdei/Yy9eAYEXiFH4tsZcMCg0NpW3btoSEhJAuXTq9azvGtu8RI0bQunVr6taty71798iQIQM2NjbUrl2bLVu2xHmjwp07d6hatSrv37/nypUrtG3bVu94ZVnmyJEjVKlSBWtra8zMzHB0dOTy5cs0btyYb9++MWHCBIoVK8axY8dYvnw5bm5udO7cOdlvuDBJbYxKbfjvMUO2xHcIg9tNd/bOs1ckmYy0eeIuXj55o1yDiUzy/m0QBD0EBQVx6tSpWBczjykzMzM6d+7MvhMXeKbKR5hG+91oZEzJMni89WHQsoMEBIcqHKnwX5GnFCXGEUpZlhkyZAi3b9+mevXqVKhQId5GJ93d3alevTrr169n5cqV/PPPP4SEhNC8eXPy5cunV7migwcPUrt2bfLkyYOzszMVK+q361mn03H48GEqVapE69atSZcuHefPn8fJyYmGDRsSEhLCwoULKVy4MGvWrMHW1hZPT0+GDx+eYCWXDEmWZdzd3dm1axcjR46kWrVqZM6SCV+NgevZSlCkQkHD9hFLsiyzuN+aOJ1W9Lt2lw1ar2ibiYlIKAXhJ86ePUtwcLDBEkoAv8AQxq13QKvVodNz0bZWJ+P17jML9l1QKDrhZzw8PMiRIwfp0qVL6FC+s2zZMrZu3crGjRt59epVtCMXDWnXrl1UqlSJgIAAbty4wfDhw/H396dFixZR6xL/XaA/pmRZZtasWXTo0AFra2ucnJz0mjHQ6XQcOnSIihUr0rZtWzJlysTFixe5ePEi9evXR6fTsXXrVooXL86kSZPo2rUrHh4ezJgxI1H+fcfVx48fOXbsGNOmTaNZs2ZkyZKF4sWL0717d06cOEHRokVZuHAhDdrWiSqgbgh5iuYiTfrUv78wHt13esyLx68VOxkoklaj48FlN7wfvFC03cRCbMoRhJ+wt7enVKlSBi2/s/DARXyDQvROJiPpdDLHbrrRuHJxapdNPrtNE5vEWjLo9OnTjBs3jnHjxtG+fXv69OnDuHHjDNpnYGAgf/zxB1u3bqV79+6sWbOGdOnSERYWRrt27Xj+/DlXrlwhb968sW47JCSEfv36sXv3bv7880+mTZsW59HWyERy5syZPHz4kIYNG3Lp0iVq164NRCSux48fx87OjkePHtGxY0dmzZpFsWLF4tRfYhIUFMTdu3e5efMmzs7OODs78/z5cwCyZcuGhYUFo0aNwtLSkipVqpAlS5aoex9Xfcqtw64GiUtSSTTv19AgbevDYf0Zg9XeVBupOL7BkeEr+ynedkITCaUg/IBGo8HBwYGBAwcarA/v9184ftNN8XYlCVbYX6FWmULJekdhQvLw8Eh0icbTp0/p1KkTzZo1Y968edy5cwedTmfQEcoHDx7QqVMnXrx4wdatW+nVq1dUAf4BAwbg5OTE6dOnKVOmTKzbfv/+Pa1bt8bV1ZW9e/fSqVOnOMWo1Wo5cOAAf/31F48fP6Zx48asW7eOmjVrRl1z/fp1bG1tuXz5MvXr12fr1q1UrVo1Tv0lNK1Wy+PHj3F2do5KIB8+fIhWq8XMzIzKlStHHb9paWlJgQIFfvk+UapacQqWycfLx6/RKbzjW61W0axv7I+zNbR7jg8MVntTq9Fxx/G+QdpOaCKhFIQfuHr1Kp8/f8bGxsZgfRy85Ipa9f0ubn3JMni+/cx9r3eUL5Jb0baFCB4eHooUulfK169fsbKyInfu3OzevRu1Wo2LiwtqtZrSpUsr3p8sy2zYsIFRo0ZRrFgxbt++HW3jz7Rp09ixYwe7du2ifv3YJwyurq5YWVmh0Wi4dOlSnJI7rVbLvn37mDVrFm5ubjRr1oxNmzZRvXr1qGuePHnCpEmTOHz4MOXKlePkyZM0bdo0yTyIybLMq1evokYdb968yZ07dwgMDESlUlG6dGksLCwYOnQoFhYWlClTJtY1aiVJYuiyPkxoNFPZ4CXoOqkdGbImrg05Pm+/4PfZsIXW37i/IyQoFNPUyavMm0goBeEH7O3tyZ07t8FGKWRZ5vhNN8WTyUhqlYqTt56IhNIA/Pz8+PTpU6KZ8tZoNHTq1AkfHx+cnZ2j1im6uLhQsmRJxY+G9PX1ZcCAARw4cIDBgwezZMkSzMzMol5fv349s2bNYv78+XTt2jXW7R89epSuXbtSvHhxjh49Guupco1Gw969e5k1axZPnz6lRYsWbN26NdqJPG/fvmXGjBls3ryZPHnysGPHDrp165bod21/+/aNW7duRUsgP3z4AEC+fPmwtLRk+vTpWFhYULly5TidIf4jFRuUpdXgJpzYcFaRUUq1kYp8JfPQZVL8F9r/nfdeHwzeh6yT+fjSh/wl8xi8r/gkEkpB+A9ZlrG3t8fGxsZgHzDvvvjjF2S43dhanY4H3u8M1n5KlthKBo0bN47z589z+vTpaDG5uroqPt3t7OxM586d+fz5M/v37/+usPuxY8cYOnQow4cPZ/z48bFqO/Kcejs7O9q0acOOHTtIkyZNjO/XaDTs3r2bWbNm4e7uTqtWrdi5c2e0h0JfX18WLFjA0qVLMTMzY+HChQwZMiRRnsceGhrK/fv3o617fPr0KQAZMmSgatWq9O/fHwsLC6pWrapYabOfGby4J88fvuTx9Wd6bVZRG6lImyktM+1tMTJOfCmIJlwbP/2EaeKln/iU+P42BSGB3b9/n+fPnxt0d/cdNy+DtR3J/Y0POp2caIsGJ1WRJYMSQ0K5efNmli9fzqpVq2jY8P83N+h0OlxdXRU7alGn07F06VLs7OyoVKkS586do1ChQtGucXZ2plOnTlhbW7Ns2bJYTRuHhoYyePBgtm3bxqRJk/jrr79i/DCn0Wj4+++/mT17Nh4eHlhbW7Nnzx4qV64crf21a9cya9YsgoKCGD16NBMmTIjTrnND0Ol0eHh4RFv36OLiQlhYGMbGxlSoUIFGjRoxadIkLC0tKVasWLyPpqYyS8WcE5OY3mYh9849iFMbKrWKzLkyscBxOrkKK3dMppJSxdM0dKrUya/0lEgoBeE/7O3tSZ8+PfXq1TNI+zqdjsXLV0FW5de2/ZtGqyM0XINZKmOD9pPSeHh4kClTJjJnzpygcVy5coUhQ4YwaNAghg4dGu01T09PAgMDKV++vN79+Pj40KtXL06cOMG4ceOYPXv2d3UYPT09adWqFeXLl49awxlTnz59om3btjg7O7Nz5066d+8eo/vCw8PZuXMns2fPxsvLi9atW7N///5o9Sl1Oh27d+9mypQpvHr1in79+vHnn3+SO3fCLgX58OFDtGnrW7du8e3bNwCKFy+OhYUF3bt3x8LCggoVKiSaI1XN0pox99Rk7FecZNPEXei0uhiNVkbumG7WtwEDF/ZIdGWC/i1/ScP/bBinMiJnwewG7ye+iYRSEP7j8OHDtGzZ0mDFi2fOnMnDBw/IX9+wCSWQZDYXJCWJoWTQixcvaNu2LTVq1GDlypXf/T27ukaUedE3oXRycqJr166EhYVx4sSJH25E+vTpE82aNSNjxowcPXo02nrK33n06BFWVlYEBgZy8eLFaBtmfiYsLIwdO3YwZ84cvL29adu2Lf/880+071WWZU6fPo2dnV3USO2pU6coWbJkjGNTSkBAAHfv3o2WQL58+RKA7NmzY2lpydixY7GwsKBKlSoJ/qDyO2q1mnajW1GjdVWOrj7NiU2OBPkFo1JJSCop4uxvSUKSInY0q41U1G5fjTZ/tMC8uuFKsCnh2bNnODg4gKkWQgx3lG3hcgVQGyW/o3JFQikI/+Lt7Y2rqyuTJ082SPvHjx9nxowZDJs8h2ufDdJFlFTGRqQyTn5vWgnNw8MjQae7AwICsLa2Jm3atBw8eBBj4+9HoF1cXMidOzfZs8dtFESr1TJr1ixmzpxJnTp12LVr1w9H9YKCgrC2tsbPz4/r16+TNWvWGPdx8uRJOnXqRMGCBblw4QIFChT45fVhYWFs27aNOXPm8PLlS9q3b8+RI0coW7ZstOtu3bqFra0tFy5coFatWly7di1GiaoSNBoNjx8/jrbu8eHDh+h0OlKnTk3lypXp2LEjFhYWWFhYkD9//iT70JerUA4GLepJ77868eSmB89ue/Li8WtCg0NRG6vJXTgnxSoXxrx68US3kzuSRqPh2rVrHD16FAcHB549e4apqSl1czVDfiWh0yq/aVJSSVS3TpolqX5HJJSC8C9HjhzBxMSEZs2aKd62p6cn3bt3x8rKimljh9Ns0ibF+/i3kvmzJ9kPq8TMw8ODWrVqJUjfOp2Onj174uXl9csEzsXFJc6jk2/fvqVbt25cunSJadOmMWXKlB9OYWu1Wrp27cr9+/e5ePEihQv/uJB+eHg4L1++jBrVlWWZ5cuXM3bsWFq2bMmuXbt+eQJNaGgoW7duZe7cubx69YqOHTty/Pjx78oheXh4MHnyZPbv34+5uTlHjx6lVatWBvsdkGWZly9fRlv3eOfOHYKCglCpVJQpUwYLCwv++OMPLCwsMDc3j3XJnqQglVkqytcrTfl6hp9xUYKvry+nTp3CwcGBEydO8PXrV3LmzEmrVq1YuHAhjRo14vOrr/QtNcog/UuSRPN+DQzSdkJLfj/dgqAHe3t7GjVqpPgRa0FBQbRr144sWbKwY8cOMmZMR7YMafjkG6hoP5HUKonyhQ276zMlCg4O5s2bNwk2Qvnnn39ib2+Pvb39L4uFu7q60qNHj1i3f/LkSXr27ImJiQnnz5+nbt26P7xOlmVGjBjBsWPHOHLkyC/La02cOJFly5Zx9uxZatasyfDhw9m4cSPjx49n7ty5P11vGRISwubNm5k3bx5v3ryhc+fOTJkyBXNz82jXffjwgZkzZ7JhwwZy5szJli1b6NmzZ6zWccbE169fo0r2RCaQHz9+BCB//vxYWloyY8aMqJI9sdmhLhiWp6cnDg4OODg4cOnSJTQaDeXLl2fYsGFYWVlRpUqVaJucUpdITXWrKjifvKtogXOVWkWTXnXJnDOTYm0mJiKhFIT/8fHx4fLly6xbt07RdmVZZtCgQTx79owbN26QMWNGAFrXLMPmk86KHbv4b1qdTCtL899fKMSKl1fE7vyESCj379/PX3/9xZw5c7C2tv7pdT4+Prx+/TpWI5RhYWFMnjyZRYsW0aJFC7Zt20a2bNl+ev2CBQtYs2YNGzZsoGXLlj+9zt/fn/Xr16PVarGxsaFUqVLcu3ePLVu20KdPnx/eExISwsaNG5k/fz7v3r2jS5cuTJky5bv1j/7+/ixevJhFixZhbGzMnDlzGD58eKzWcP5MaGgoLi4u0dY9uru7A5AxY0YsLCwYOHBgVMmenDlz6t2noBytVsuNGzeiksjHjx9jYmJCgwYNWL58Oa1atSJ//vy/bGPE2gH0LTWS4IAQUOAtWlJJpM+SjkGLeunfWCIlEkpB+J9jx44hyzJWVlaKtrtmzRr+/vtvdu3aRbly5aK+3rZWWTafdFa0LwCVSqJsoVwUzRPz9WxCzCRUyaC7d+/Su3dvunbtip2d3S+vjdyQE9MalN7e3nTu3Jl79+6xaNEiRo8eHTVao9HquPrIm7vub3j4/D2vP30jICiIb18CaDZiHuQpi9vLD5TK/+MSMNu3bycwMGIU3t/fn9u3b3P06NEfJqHBwcFs2LCB+fPn8+HDB7p168bkyZMpUSL6Ro6wsDA2bNjAzJkz8fPzY8SIEdjZ2cV5M4tOp8Pd3T3aukcXFxfCw8MxMTGhQoUKNGvWjGnTpmFhYUHRokUTfQH0lMjf35/Tp09HTWX7+PiQLVs2WrVqxaxZs2jcuHGsCr1nzZ2ZsZuGMqvTEv2DkyKmuu12/kHajMl35FqSZQMMjwhCEtS6dWs+ffrE1atXFWvz2rVr1K1bl6FDh7J8+fLvXl9x+DLbz95Gyd9CSYLtE7pQpqAYNVHa4sWLmT59Ov7+/vG2PvX9+/dRhaudnJx+OwK3ZMkSpk6dip+f32+nfQ8ePEj//v3JnDkz+/bti5q6DgvXsOv8XXafv8dnvyCMVCo0uuhTf5IkoZIiRsPN82enX3NL6lf4/0Rbp9NRtGhRvL29o76mUqnInDkzL168IHXqiNIxQUFBrF+/ngULFvDp0ye6d+/O5MmTvzsrXafTsX//fiZPnoy3tze9evVi5syZ5MuX7/d/iP/y/v37aNPWt27dwtfXF4ASJUpgaWkZtWmmXLlyiaZkj/C9Fy9e4ODgwNGjR7l48SLh4eGUKVMGKysrrKyssLCw0Hvpw/ENZ1k2ZAMSEWfUx5ZKJYEkMWnXSOp2rKFXLImdGKEUBCI+1M6cOcOMGTMUa/P9+/d06NABS0tLFi5c+MNrBrWqznkXD974+CpyDKMkQa/GVUQyaSCRJYPiK5kMCQmhTZs2aLVaDh8+HKPpXBcXF8qWLfvLD9Lg4GDGjBnDunXr6NixIxs2bIgq8v34xXumbD3Fi49fox50/ptMQsRSjshNsE9efWLsegcaVSrGxM4NyJQuNadOnYqWTEJEUujj48Mff/zBihUrWLduHQsXLsTHx4eePXsyefLkH5ZkOnfuHLa2tty5c4dWrVpx5MiRX64hjRQQEMCdO3eiJZCvXr0CIEeOHFhaWjJhwoSokj2Ry1GExEmn0+Hs7Bw1lf3gwQOMjY2pV68eixcvplWrVt8V3NdXy4GNyZwrE4v6riHgW2CsTglSqSQy5cyI3c4RVKj/+5/XpE6MUAoCEZtx2rRpw7Nnz74bGYmL8PBwGjVqxLNnz7h79+4vj0V7/v4LvRfuJTAkTK+kUpIkqpXKz7IhNhgnwxpniUGTJk1Ily4dhw4dMnhfsizTu3dv9u3bx6VLl7CwsIjRfeXKlaNGjRo/XQvs5uZGp06dcHd3Z/ny5QwYMCAqQT53zx27TceRIU5nNqtVElnSp2HjmA7Utaz03eik7n+JaYYMGTA2Nubbt2/07t2biRMn/nCX+L1797Czs+PMmTNUq1aN+fPnU6dOnR/2rdFoePjwYdS0tbOzM48ePUKn05EmTRqqVKmChYVF1Ahk3rx5RRWEJCAgIICzZ8/i4ODA8ePH+fjxI1myZKFFixZYWVnRtGlT0qc3fFkiv8/+bLTdydkdlyJ+jmX5hzNLkT9TRiZGtBzYiD6zupA6nf7repMCkVAKAtCrVy/u3LnDw4cPFWlv7NixrFixgvPnz1O7du3fXu/17jODlx/ii19QnDfp1CtXhLn9W5AqEZ6Pm1wULlyYDh06MH/+fIP3tWjRIsaPH8+uXbvo2rVrjO4JDQ0lbdq0rFy5ksGDB0d7TZZltm3bxvDhwylQoAD79u2LVsPx6kNvRq45gizLeu1BUKskMqdLzedLf6PWhtK7d++oMi3//ripV68eW7dupWDBgt+14e3tzdSpU9m1axclSpRg7ty5tG7dOurDWpZlXrx4EW3d4507dwgODkatVlO2bNmoaWtLS0tKlSql+K5vwXBevXrFsWPHcHBw4Pz584SGhlKqVKmoqezq1asn2N/nt0++nNl2kTuO93l2y5OAb/9fqSN9lnSUtChKlaYVaNyzbrJeL/kjIqEUUjyNRkP27NkZOnQos2bN0ru9ffv20blzZ5YtW8bIkSNjfJ9/UAiLDjjhcOMxapUUs9FKWSaViRHjO9anTc0yYsTFgMLCwjAzM2Pt2rUMHDjQoH2dOHGCVq1aYWtry9y5c2N8371796hUqdJ3xbz9/f0ZMmQIu3btom/fvqxYsSJaWZvPfoG0+XM7gSGhiqznVaskqhTPx5oRbVm7di3Dhg377posWbLw6tWraNP4nz59Yvbs2axZs4asWbPy559/0rdvX/z8/Lh161a0BPLTp08AFCpUKCp5tLCwoFKlSlHrM4WkQafTcefOnaipbBcXF4yMjKhdu3ZUEpmQhwn8jCzLBHwLRBOmwcTUmDQZUlYC+V8ioRRSvAsXLtCgQQNu3bpFlSpV9Grr0aNHWFpaYm1tza5du+KU4Ll4vmHPeRfOubij08moVZGjMhHTKTpZhyxDOjMTnt88Q6f6FVkw60+94hZ+z93dneLFi3Pu3DkaNDBcYWI3NzeqVatG3bp1sbe3j9WO4q1bt9KvXz/8/PyidrTeu3ePTp068e7dO9avX//D0c5xGxxwcvVUZB3vv42ytqRXi5pAxJR31O5xjQaAGTNmMG3aNAIDA1m6dCkLFixAkiS6dOlCkSJFcHV15ebNm1G76zNnzhwteaxatWqcTwMSElZQUBDnzp3DwcGBY8eO8e7dOzJlykTz5s2xsrKKOs5TSDpEQimkeCNHjuTQoUO8evVKrxE+X19fLCwsMDEx4caNG3oXNv4aEMwD73e4vfjA289+aLQ6TFMZUTRXVkoVyE7pAjkZP24sO3bs4OXLl7EqiSHE3smTJ2nRogUvXrz4bQ27uPry5QsWFhaYmppy/fr1WBfYHzVqFCdPnuTp06fIssyqVasYN24cZcqUYe/evT9cH+z+xodOs3Yq9S1Ekz1jGnK+v07WLFnIkCED9+7d4+jRo1FrKUeMGEHGjBlZtmwZ/v7+ZM2alS9fvqDRaEiVKhUVK1aMtus6PjdECcp7+/Zt1FS2o6MjISEhFC9ePGoUsmbNmsnyNKGUQvzNCSmaLMvY29tHW58VFzqdjt69e/P+/Xtu376tyCkZmdKaUadsYeqU/fGRdgBjxoxh9erVbNy4kdGjR+vdp/BzHh4emJiYkCdPHoO0Hx4eTseOHfn27RvOzs5xOq0p8sjFL1++0K9fP+zt7RkxYgQLFiz4afmbg5dcY77EIpY+fgtk8pipVCuZjzFjxnD48OFor/+7lFaRIkWoVatWVAJZtmxZTExMFI9JiD+yLOPi4hJ1VvadO3dQqVTUqlWLv/76Cysrq+/qjApJl0gohRTNxcWFly9f0rp1a73aWbBgAfb29hw5ckSRXeIxlT9/frp168aSJUsYNmyY+AA2IA8PDwoXLmywzQBjxozBycmJs2fP/vRc7F+RZRlXV1c6duxIxYoV8ff3x97eHhsbm1/ec/r2U4MkkxCxlvLs3Wd0bVGX169ff/e6SqVizZo1dO7cOapskZC0hYSEcP78+aip7NevX5M+fXqaN2/O6NGjad68eZyL0AuJm0gohRTN3t6ejBkz/vTM4phwdHRk8uTJTJ48+ZdH4hnKhAkT2L59O7t376Z3797x3n9K4enpabCNARs2bGDVqlWsXbuWevXqxamN58+f8+3bNzZt2kT16tXZvXv3b6fm33/1xy8oNE79xYRWJ/PA6x0ZM2bk/fv3UWsnI+l0Oho3biySySTuw4cPUVPZZ8+eJSgoiMKFC9OuXTusrKyoXbu2eNhNAcT5UUKKZm9vT6tWrTA2No7T/S9evKBz5840atRI0aLosWFubo61tTXz58+PWpsmKM/Dw+OHRbf15eTkxLBhwxg6dOh3pX5i6sOHD7Rp0waAYcOGcfHixRit83R/4xOn/mLj5cdvVKxcBa1WS968eenSpQv169ePmoL/b/FzIfGTZZn79+8ze/ZsqlWrRq5cuRg4cCA+Pj5MmzaNR48e4eHhwbJly2jYsKFIJlMIMUIppFheXl7cv3+fadOmxen+kJAQ2rdvT9q0adm9e3eC1rmzs7OjRo0aHD16VO/pe+F7Wq0WLy8vxUcovb29adeuHbVr12bZsmVxasPR0ZHu3bsTEBBAhgwZWL58eYzXA/sbcHQykgyccTzHypUrGTBgQFRyERoaytOnTzE3Nzd4DIL+QkNDuXjxYlRpn8iNgE2bNmXIkCG0aNGCbNmyJXSYQgISCaWQYtnb25MqVSqaNm0ap/v/+OMPHjx4wNWrV8mSJYvC0cVO9erVqV27NvPmzcPGxkbshFXY69evCQ8PVzSh9Pf3x9ramowZM3LgwIFYj5JrNBqmT5/O3LlzadSoEcbGxoSFhcXq7z6yJJWhudy7R85s0X9HUqVKRbly5eKlfyFuPn36xIkTJ3BwcOD06dMEBARQoEABrK2tsbKyom7duuKscyGKSCiFFMve3p7GjRvHqdzOpk2b2LRpE5s3b6Zy5coGiC727OzsaNmyJU5OTnFehyf8WGQdRKUSSp1OR/fu3Xnx4gU3btyI9QPJy5cv6dq1Kzdu3GD27NnY2tpStGhR2rZtG6t2MsfDkXCpjI3InkVswkgKZFnm8ePHUaOQ169fB8DS0pKJEydiZWVFmTLiAAXhx1JsQun/NQD3O168evqWsJBwjFMZkadYLopXLkyGrIY/F1RIWB8/fuTq1ats2LAh1vfevn2b4cOHM3DgQPr27WuA6OKmefPmlC1blvnz54uEUmEeHh6o1WoKFCigSHtTpkyJ+tCO7ZTvkSNH6NOnD2nTpqVu3bocOnSIZ8+e4e3tTZo0aQgICIjRQ5Isy6xfMhfUhi3bUjJ/dlTxNBIqxF5YWBiXLl2K+nn09vYmderUNGnShE2bNtGyZUty5MiR0GEKSUCKSihDgkK5uO8aR1adxONexEJwSZKQVBKyTo46Z7aAeV5shjWjYfc6KeZQ95Tm2LFjyLKMlZVVrO7z8fGhXbt2lCtXjhUrVhgouriRJAlbW1u6d++Oq6sr5cuXT+iQkg0PDw8KFCgQ581b/7Z7927mzp3L/PnzadmyZYzvCw0NZcKECaxYsYLWrVuzefNmWrduzZ07d3BxcQFg5syZ/PXXX7Rp04ZDhw79sr05c+awZeN6GoxaxrcQnV7nd/+MWiVRsUhuA7Qs6OPz58+cPHkSBwcHTp06hZ+fH3nz5o0qMF6/fn1MTU0TOkwhiUkxJ+XcPHGXxf3W8PWDb1QC+TOSFLGQPG3GNIxaO5C6HWvEX6BCvLC2tubr169cvnw5xvdotVqaNWuGi4sLd+/eJV++fAaMMG40Gg3FihWLKhsjKKNt27YEBgZy+vRpvdq5desWderUoUOHDmzfvj3GU4fu7u507tyZhw8fsnjxYoYNG4YkSSxcuBA7O7vvdvcPHz6clStX/rS97du307t3b2bMmEGRmq1YcshJkTO8f+Sf6b0omFNMeSe0p0+fRhUYv3r1KjqdjipVqmBlZYW1tTXly5cXU9mCXpJ92SCtRsuyIRuY0mou3z75AfwymYSIM5ORIfBbILM6L2V2l6WEhYTFQ7RCfAgICODMmTOx3g09depUzp8/z969exNlMglgZGTEuHHj2LdvH15eXgkdTrKhRMmgt2/fYmNjQ/ny5dmwYUOMP7x3795NpUqV8Pf358aNGwwfPjzq3ubNm0dLJo2MjChXrhwLFy6M+lpISAh9+vTh6tWrAJw5c4b+/fvTr18/pk6dilU1c4xicV54TKlVElWK5xPJZAIJDw/n4sWLjB07luLFi1OyZEmmT59OxowZWbduHW/evOHWrVtMmzaNChUqiGRS0FuyTii1Wi1zui7jxAZH4PeJ5H9FPrE7HbjOFKt5hIWGKx2ikADOnDlDaGhorBJKe3t75s6dy5w5c2jYsKHhglNAnz59yJw5M4sXL07oUJIFWZbx8PDQa0NOcHAwrVu3RqVScfjw4RhNJwYGBtKvXz+6deuGjY0Nd+7coWLFitGuKV26NDlz5oz6d1NT0+/ad3JyYtu2bdSvX59FixbRrl07GjduzNq1awkKCmLWjGm8uBL9SESljO9YzyDtCj/29etX9uzZQ9euXcmePTv169dnz5491KtXj6NHj+Lj48PRo0cZMGAAuXOLpQiCspJ1Qrlt6j4uH7qBvrP6sk7G5cJDVo/YolBkQkKyt7enbNmyMR5xevbsGb169aJt27ZMmDDBwNHpL3Xq1IwcOZItW7bw4cOHhA4nyXv37h3BwcFxTihlWaZ///48ePAAe3t7cuXK9dt7Hjx4QNWqVdm7dy9btmxh586dPzzbW5IkWrVqFfXvO3bs+O7YRkdHR4yMjNBoNIwfP55MmTKxf/9+zp07R5kyZVi5ciUjOjalTMEcipYRGtSqOsXyZFWsPeHH3N3dWbJkCfXr1ydbtmx07dqVJ0+eMGLECG7dusXr16/ZsGEDVlZWpE6dOqHDFZKxZJtQut10Z998e8XWBck6mRMbHbl9xlWZBoUEER4ezrFjx2I8OhkQEECbNm3IlSsXW7duTTLTQsOGDcPIyCjRbRxKijw9PQHiPOU9f/58du/ezbZt26hSpcovr5VlmfXr12NhYYGRkRG3b9+mT58+v/y5i2yzQ4cOUafl/NupU6fQaDRRD9avXr2iSpUqNG/enKJFi/LgwQMmTZrI0iE25MyUTu+kUgKaVS1B36YWerUj/JhGo+Hy5ctMmDCBUqVKUbx4cSZNmkTq1KlZtWoVr1694u7du8yYMYMqVaqgMsByBkH4kWS5KUeWZYZUGo/3w1fotModRadSSWTNm4UdnqsS9FQUIe7OnTtHo0aNuHPnDpUqVfrltbIs06VLF44dO4azs3OSO9Fj7NixbNmyhRcvXpA+vSiFFVdbt26lb9++BAUFYWYWu6oPDg4O2NjYMGnSJGbNmvXLa319fRk4cCD79+9n8ODBLFmy5Lv+3n3x4/HzDzx59ZFvgcHIMmRIk4q7lx35c/wfFMgZfUTw06dPZM+e/Yf9DRs2jJUrV0ZLVj99C6DX3B288w2J9cOTJEUsE2pbqywTuzRALRIZxfj6+nL69GkcHBw4ceIEX758IUeOHLRs2RJra2saNWpEmjRpEjpMIYVLlmWD3G664+n6QvF2dTqZjy99uH3KBcuWiaOYtRA79vb25MuX77u1aD+ybNky9u3bx/79+5NcMgkwevRoVq5cyYYNGxg3blxCh5NkeXh4kDdv3lgnkw8fPqRr167Y2Ngwc+bMX15769YtOnfujI+PD/v376dDhw5Rr2m0Os7dc2fvRRdcPd8CoFapiMz3ZBm0uoy0mbGT8kVy07luBRpWKoaRWoWjo+N3faVJkwYbGxs2b95M27ZtadCgAQDOzs7Y2tpy8dIlLFv3IzxHKVSShPY3a88j084MacyY3r0xdcsrf955SuTt7R1VG9LJyYnw8HDKlSvHkCFDsLKyomrVqmL0UUhUkuUI5eJ+azi70wmtRrnRyUgqtQqLFhX564id4m0LhiXLMvnz56dNmza/nQq+dOkSDRo0YNSoUSxatCieIlRev379OHnyJN7e3uKItFgICwvj+fPn5M+fn969e/PhwwcuXLgQ4/t9fHywsLAgXbp0XL169aeFxnU6HUuXLsXOzo5KlSqxd+9eChUqFPW617vPTN12CreXH1FJErrfvF1HXlMyX3Zm9WlGl9YtcHZ2BiISyenTp9OrVy9Kly6Nj48PZcuW5cCBA0yZMoWDBw9SpkwZ5s2bR4sWLXjj48uhKw84dPkBAcERZ34bqSMSmIgkNuL9NX/2jHSpX5GWlqVIayZ+xuJKq9Vy8+bNqCTy0aNHmJiYUK9ePaytrWnVqpVihfUFwRCSZULZo8gw3nt/NFj7aTOm4Z/PSWc9nRDhzp07VKlShXPnzkWNyvzI27dvqVSpEqVKleLs2bMYGSXdgfwnT55gbm7Oxo0b6devX0KHk2TMnDmT6dOnI0kSarWarFmz0qpVK0qXLs3gwYN/uUs7PDycJk2a8PDhQ27dukXBggV/eJ2Pjw+9evXixIkTjBs3jtmzZ2NiYhL1+knnJ0zffhoZ+bejhP+lVknIsszHG0d47XKJkSNHMnfuXFKlSkWbNm04duwYWq0WiNjYkydPHv766y969Ojx3XKecK0Wr7efcXv5kTc+voRrtZiZGFMkdxZK5c9B7izpxXthHPn7+3PmzJmoqexPnz6RNWtWWrZsiZWVFU2aNPnhZixBSIySXUIZ6BdE64y9DN7P395ryFEgm8H7EZQzdepUVq9ezcePH3+aJIaFhVG/fn1evHjBnTt3ksWRY23btuXRo0c8fvxYrP2NoePHj0fbPQ0RiVfkWcelSpX66b1Dhgxh8+bNnDt3jtq1a//wGicnJ7p27UpYWBjbt2+nRYsW0fu/6cbUbaf0+h5kWUaSJAY1KsOgdo2B/18P+m8ZM2bk+fPnZMiQQa/+hJh5+fJl1CjkhQsXCAsLo3Tp0lGn1FhaWorfUyFJSnYLMHxef46Xfj698omXfgT9PHnyhPfv3wMR6yetrKx+OeI4duxYbt26xcGDB5NFMglga2vLs2fPsLe3T+hQkozGjRt/NzIkSRIDBw6Mlkz6+vpy8eLFqH9fs2YN69atY82aNT9MJrVaLTNmzKBBgwYUL14cFxeX75LJp68+Mn2HfifyRMYLsPH8I9xefsDNzY1BgwZ9d923b9/Yvn273v0JP6bT6bh58yZTpkyhfPnyFChQgFGjRqHRaFi4cCGenp48fPiQuXPnUqNGDZFMCklWsksoDbFu8kc04dp46UfQT61atcidOzfly5fn4cOHWFj8vJTJ33//zapVq1i+fDnVqlWLxygNy9LSknr16jF//ny9a7KmFCYmJrRr1y7qw12lUpEvX77visUvXLiQ+vXrM3z4cM6ePcuIESMYMWIE/fv3/67Nt2/f0qhRI2bOnMm0adNwdHQkT5480a4J12iZsvUUSk4gS8DUbado26494eE/PpxBPGwoKzAwkCNHjtC/f39y585NtWrVWLt2LeXKlWPfvn34+Pjg6OjIiBEjvqsbKghJVbKb8n7n/YGeRYYbvJ8uS1pR36YOBQoUEDvtEjFzc3Pc3Nyifa1o0aIsXLgwWi1KV1dXqlevTocOHdi2bVuyWxN2+vRpmjVr9tv1o8L/O3XqFM2bNwciRvsuX75MzZo1o11Tq1Ytrl69GrXWslatWj9cd3vy5El69uyJiYkJu3fvpm7duj/s8+Dl+8zZfc4g30/HqgUw839FwYIFMTU1jfZPoUKFRGkpPb1+/Zpjx47h4ODAuXPnCA0NpWTJklFT2dWrV0/S67EF4XeSXUKp0+mwTteD0GDDnb0tI3NBtkeHltSpU1OqVCnMzc0pXbp01P8WLFhQJJqJQJcuXThw4EDUBoRIkWcbb9myBXNzc6pUqUL69Om5du1arMvDJAWyLFOpUiWyZcvGmTNnEjqcJCE8PJx06dIRGhqKra0t8+bNi/Z6WFgY6dKlIyzs/99rcuTIwYYNG7C2to66ZvLkySxatIgWLVqwbds2smX78dprWZbp8NcOvN9/UexAhkgSUDBnZg5O65nsHpYSik6n4+7du1HrIe/du4daraZ27dpRSWSxYsUSOkxBiDfJ7nFJpVJRtFIhHl19arA+8hXPjfcZLx4/fhy12eHRo0fY29vj7+8PgJmZGSVLloxKMiMTzUKFCok1MvGoVKlS332ADhkyhLCwMJ49e0bdunUpUaIEX7584ezZs8kymYSIETZbW1u6dOnC3bt3f1vUXQBjY2MsLCx48OABM2bM+O71e/fuRUsmAT58+ICNjQ33798nbdq0dO7cmbt377Jo0SJGjx79y4fMp68/4fXui+LfB4AMeL//gtvLj5gXSB5rgxNCcHAw586dw8HBgWPHjvH27VsyZsxI8+bNGT9+PM2aNSNTpkwJHaYgJIhkl1AC1G5bjcfXnhlkvZhKraJ2u2rkz5+f/Pnz06xZs6jXZFnmzZs3UUlmZKLp4OCAr68vAKamppQsWTJakmlubk7hwoXFdIgBmJubo9FogIikqlevXqxatYpy5coBEZskHj9+TL169ciZM2dChmpw7du3Z/LkycyfP599+/YldDiJSkiYBidXT1y93vLw+Xvef/FHJ+vIVK83A3tkZ9+lB9SvUJR82TJG3RM51R35PhP5/yVJokOHDrx7944sWbJw9erVX67djfTA6x0SEcmfIUgSPPB+l2gSSp1O5sXHr7z88JVQjQYTIyPyZ89IgRyZEtUpO+/evYuaynZ0dIw6171Tp05YW1tTs2ZNjI2NEzpMQUhwyW7KG8D/awCdcg8gPFSjeNuSJPG392qy5495ySBZlnn79m20JDPyf799+wZAqlSpKFGiRLQk09zcnKJFi4pEUw+PHj2iTJkyAHTq1Ildu3YRFhZG2rRp0en+fwOXSqWiZMmSXLlyJVmPMKxbt45hw4bx9OlTihYtmtDhJDj/oBC2nL7FoUv3CQgJw0itQvOf41pVKglk0Mky1UrlZ2DLalQokgcLCwtu3boFQKZMmQgKCiI0NDTqPnNzc65duxbjcjx//X2Wo9cfRxUMV5paJdHS0pw/ezYxSPsxodPJ3Hzykv1OLtxwe0lo+Pfv0amM1VQpno9O9SpQ3bxAvCeXsizj6uqKg4MDR48e5fbt26hUKmrWrBk1lV2iRAmxdEAQ/iNZJpQAG8bv4ODSY8ixLAj8Kyq1ikY96jB+yzBF2pNlmffv30dLMiP//5cvEVNfxsbGlChR4rup86JFi4qn4v8IDgvnxYevhISFY6RWkydLetKkMsLU1JSyZcty+/ZtjI2NuXHjBtWrV492ryRJpE+fnjt37lCkSPI9Oi44OJiCBQvSpk0b1q1bl9DhJKirD735c8cZvgYGo4vh+4RKJaHTyXSpX5Fl43oRHODPkiVL8PT0ZPbs2dFmRSRJ4sKFCz/dgPNfI1fbc/mhd5y+l5iqWbogK4e3MWgfP/P4xXumbjuN9/svqFW/PtIx8vX82TMyo2dTyhfJbdDYQkJCuHDhQtRU9qtXr0ifPj3NmjXDysqK5s2bkyVLFoPGIAhJXbJNKEOCQhlQdgwfX/qg0+r/xC+pJDJkTc/WJ8tJmzGNAhH+nCzLfPz48YeJpo9PRP1LIyMjihcv/l2iWaxYsWinbSR3bz/7cujyAy64ePDi49fvNjNkSZ+aErky0KdFTSoVy4skSSxZsoSxY8dGXZM9e3ZsbW0ZOHDgT4/IS07mzp3LjBkzeP78ebKf5v+Zv8/dZclBpxgdZ/gjkiRRIm9W1o5sjzY0iNy5c0cbnYyc/i5TpgwPHjyIUZt/rDrM1UfPYx1LbFQ3L8DqP9oatI//kmWZDcdvsPHETZCIcfIO/3+UZJ+mVRlmXTNitFghHz584Pjx4zg4OHD27FkCAwMpVKgQVlZWWFtbU7t27RT1XioI+kq2CSXA01sejK47DU2YRr+RSgnUahVzT02hYoOyygUYB58+ffouyXz8+DEfP0YcNWlkZESxYsW+W6NZvHjxZHWW81f/IBbsv8iZ20+R/jdq9DORox1F82RlevfG9Grfijt37pArVy5mzJhBz549k9Wfze98+/aN/PnzM2zYMObOnZvQ4cS7/U6uzNt7Xu921CqJYnmywePT7Nm1M+rruXLlokKFCpQrV44WLVpQp06dGLU3eetJTt9+GquEKzZUkkTjysWZ26/F7y9WiCzLzN93gf1Ornq3ZV29NNO6N/5pUnnr1i10Oh2WlpY/jeXhw4dRu7Jv3rwJQPXq1aOmss3NzcVUtiDEUbJOKAFcLjxkcsu5aDQadHEoeq5Sq5AkiWkHxlLDpqoBIlSGj4/Pd0nm48ePo06JUavVFC1a9Ls1miVKlPjlucSJ0aUHXkzbdorAkLBYnXEccb4xVC+Yjjw6H8aNG5ti16dOmDCB9evX8/LlyxR15N6z15/oNndXrM/G/hmVJFGnRA5Ur+7Qtm1bSpcuHec/z+1nbrPi8GWDbcpRSRLDW9ekd5P4ex/bduYWKw5fUay9gS2rMbhV9e++fvjwYTp27Eju3Ll5/vx5VFIYGhqKk5NTVBL54sUL0qZNS5MmTbC2tqZFixY/LeMkxD+/z/48u+OFl+tz/L8GolJJZMqZkWKVClOkQkFMU6ecB/+kKNknlADeD14wt/sKnj98Gav6bpJKIlfhHNjtHEEpy6RZT+zz58+4ubl9txno3bt3QMRmlCJFinyXaJYsWTJRltA5ftONadsjzjjW5ye3hUVJZvRqmqh2k8ant2/fUqhQIWbOnImtrW1ChxMvNFodXefuwvvdZ8USykgbR3egcvG8cb7//fv3DBg7lTfpzRWM6nvrRrbDomR+g/YRyeOND13m/K3on7VKkthh2yXaTvUdO3bQp0+fqE12V69excPDg6NHj3L69GkCAgLInz9/1ChkvXr1UtSMRGKn1Wq54XCHI6tOcu/8QyBiICdyJFqr0SHLMmpjNfU61cB6aDPMqxVPyJCFn0gRCSWAJlzDoaXHObjEgW8ffVEbqdFqvj8+MfLraTOloc0fLehs1xoT0+S3jubr16+4ubl9N33+5s0bIGINWOHChb9bo1myZElSp06dIDHfdHvBsJWH47Tm7Ud6NKrM6HYxm45MjgYOHIiDgwPe3t5JbpQ6Ls67eDBuvYPi7aokiUrF8rBhdIdY36vT6di4cSO2traYpDKleCc7gsIN85acKa0Zp+YNwDie6uD2WrCXxy/eK5pQqlUSRXJnZc+kbkiSxOrVqxk+PPrJaJGjkxYWFlFJZNmyZcVUdiL04vEr5vVcicddb1Rq1W/3O6iNVGg1Oup1qsEfq/qTPku6eIpUiIkUk1BG0oRruO5whzunXXC76c7rZ2/RhGlQmxiRu3AOSlUrTsWGZanV1hKTVClvF7Wvr2+0RDPyf1+9egVEvFkXLFjwh4mmPhta/l3L70f8g0Np++c2vvoHK5ZQAmwc04HKxeI+spSUubu7U6JECdatW8fAgQMTOhyDG7j0IHc9XhtsjeKh6b0olDNzjK9/9OgRgwYN4urVq/Tt25eFCxey/+oTNp64qfi0t0qS6N/C8ofTxYbg9vID3ebuNlj7W8d1Yu3Cmaxfv/671woXLszVq1dT7IazpOLU1gssG7QekNHGcjmaSq0ibcY0/OVgJ0YrE5EUl1AKcePn5xc1df7vRPPFixdR1xQsWPC7zUClSpUiXbrfP0Vu3ryZCRMmsGnTJtq0+b6syfy95zlw6b6iyaRKksiZOR32M/pgpE6ZU98dOnTAxcWFJ0+eJOsTnPwCQ6g3bq3B2lepJAa3qk7/5j/eEPJvISEhzJo1iwULFlC4cGHWr19P3bp1uXnzJkNHjCbcvAXGpmkUSyolCdKZpeLwjD5kShs/y1hm73bE/upDxZcWQMQoZZ3S+VkyrB3w/w+h/34o/fjxI1mzZlW8b0EZx9afZfmQDXq1oVKrMDI2YuG5aZhXL6FQZII+UuaOBCHW0qdPj6Wl5Xc7KAMCAr5bo3no0CEWLVoUdU3+/Pm/SzTNzc1Jnz591DVOTk58+fKFtm3bMnjwYJYsWRK1htM/KIR/rj5UNJmEiELVbz/7cfmBF/UrpMwi37a2tlStWpV//vmHDh1iP2WbVLi9+mjYDmR4/OLDby87f/48gwYN4uXLl0yaNImJEyfi7+/PgAED2LRpExUqVGBIs4psvPhMudBkmNqtcbwlkwA33F4aJJkE0OpkHrz0wcXFhadPn/Lo0SPu37+Pi4sLL168QJZlbt68ScuWLQ3Sv6CfB5fdWD5Uv2QSQKfVoUHD5FZz2eK2nEzZU87mwsRKJJSCXtKmTUvVqlWpWjX6ztHAwECePHkSbY2mvb09S5cujRpJyJs3b1SSeeHChah7N2zYwMWLFzlw4ABlypTh+E03ND9Y76oElSSxz8klxSaUVapUoWHDhsybN4/27dsn23Vm7q8/xbnmZEzoZPmXCaWPjw/jxo1j+/bt1KlTBwcHB4oVK8bGjRuZNGkSsiyzevVqBg0ahFqtJlCVht3n7ykSW5f6FWhYKf42FQaGhPHWx9egffj4BpK/cDHKly8PRMygbNiwgYULF/Lx40dev35t0P6FuAkODGF+z5WoVL9fLxkTOq2OIL9glg/ZwPSD45Lt+1dSIRJKwSDSpElD5cqVqVy5crSvBwUFRY0qRCaaR48ejfYBoNPpePr0KeXLl2fs2LGEFayJoQ451skyd93fEK7VxttmhcTGzs6Oxo0b4+joSOPGjRM6HIPwDw6NOOVGa7gVPkGhYd99TZZldu7cyZgxY9DpdGzatIk+ffrg7OyMhYUFd+/epW/fvsybNy9a+Zox7eqi1cnsu+gSpx/9yHs61i3P2Pb19PiuYu/tZz+DlT76t9c+vgT6fmHZsmWsW7eOoKCgqIfV5Lx8Iyn7Z+lxPr7yUfQEO51Wx9XDzrhceJjgdaJTOpFQCvEqderUVKxYkYoVK0Z9zdvbm8KFC393rU6nY/PmzVTsV0SvEkG/o9Hq8Hr7mRL5shuuk0SsYcOGVK5cmfnz5yfbhFKtUhn0ZwgiRrv/zd3dnSFDhnDu3Dm6dOnC0qVLUalUDBgwgC1btlCxYkWuXbv23TGgELEmc0LHepQtlJO5e84TEhYe4ylktUrC1MQYu84NaGFRMt5HbTRaw8wm/NfSZcvZumL+D1/bvXs3Dx8+JHXq1JiZmUX7579f+9m/i6NtlaXVaDmy+qSiyWQktZGKI6tPiYQygYmEUkhwjx8/Bv7/uLrChQvTvn17bGxsKF+xErXHGG4zRaQXH7/+H3t3HRdV1gZw/HdnCBHEFrFRULETu9vFLljXwsDuVbG7A7s7QHTVtbsT7AIUBQULARUkh5n7/uHKu6yoxAygnu/n467O3PucMwozDyee88smlJIkMXr0aDp27IiHh8cXyxd+BjkzG6PWpHyK7VtyZP50JGtMTAzz589n6tSp5MmThyNHjtCoUSNWr17NuHHjAFixYgV9+vT55kiaJEk0t7GmcrH8bDp2nX2X7xMZrUJPqSD2P9OFnx8zMtCnVfWS9GhamZyZ0+YYUUP91PlYKV3SGhMTEz5+/PjFc8+fP+fNmzdERkbG+xUT8+Uo8tcolcoEE86kJKVJueZnH1W9fvwO797oZimEOlbD5b89+BAUSuYcpt+/QdAJkVAKac7CwoLmzZtTp04dWrVqRbFi/9+xFxoelSp9iNHRGs0fRdu2bbG0tGTOnDns3r07rbujddb/KoStC0qFgjIWebh8+TJ9+vTBy8uLESNGMGnSJO7evRs3vd2zZ09mzZqVpNNZcmY24c+OdRnYqgbn7z3l4bM3PHj2mpCwSJBlsplmpGTB3JQoaEbt0oUxSoNyZ2q1Gi8vL9zd3bnq7g6yJUi6q5wgSdC32+8M6G7PqlWrmDhxImFhYXHFzZcuXUqzZs0S7Oe/E8yIiIgk/fm/j4WEhHzzHnUSRmsNDAxSJXHNmDEjGTJkSPWR64eXvePqSOqCrJHx9niCTbPy379Y0AmRUApprkSJEhw6dCjB5/T1U+endgO9n3t04HuUSiWjRo3C0dGRR48eUbToz1XbrYh5dgz19YhWxeokvkaj4c7lk0zqOhcbGxtu3LhBnjx5GDRoEBs2bKBChQpcuXKFqlWrJrsNI0N9mlQqRpNKaVsiRZZl/P39cXd3j/t148YNPn78iCRJnyo41MhPlKS7XeX5c2bByFCfiIgIGjZsSO7cuVm3bh2nTp1Co9F8NVlSKpWYmJikqGZuUqhUqiQnrgklsZ8ff/369TdjJEWGDBl0nrh+/r2BgQGPbjzR6RpmhVLB4xtPRUKZhkRCKaRrRgb6ZM+UkeCwpL1ZJlUhs8QXpP5ZdenShYkTJzJv3jzWrl2b1t3RKn09JS2rlWTPxbs6KWejiVVx8q/1LF26lD59+rBu3TrGjRuHJEmJmt5Oz0JCQvDw8IhLHj08PHjz5tOO9vz582NjY8OECROwsbGhYsWKZMqUiZUHLrP+iLtOdtUrFRIFTZUYGBigUqniHv+cREqSRJkyZbTebnLo6+ujr68fr0SarsiyTHR0tNZGYCMiIggODv7qPdHR0YnumyRJVJOakFHWXSIvKSSCX4boLL7wfSKhFNK9Uha5uXDPV2clX/SVCgqbZ9dJ7JSQZZkPQaFER8SgZ6BHVrPMKHR49niGDBkYNmwYEyZMYMqUKeTJk0dnbaWFDrXLsOv8Ha3HlTVqMsW85cHd2/j7+1O1alVu3bpFr169mDVr1g9VYDsyMpLbt2/HG3308fEBIEuWLNjY2NC7d29sbGyoXLnyV0+jaVuzNOuPuOukj2qNTOdGldkw2TBeQinLMgqFgtq1a/90X7uJIUkSGTJkIEOGDGTNmlXn7Wk0GqKiohKdqB6ecJHwt5G665CMVkoRCcknEkoh3atqXZDzd5/qJLZSIVGpaP50c1JO2LuPnNh8jmuHb+Dt8YTwD/8fmTU0MqBIuUJUaFiGZr0akCu/9hMVR0dHZsyYgbOzM3PnztV6/LRkmTcHzSoU5sjNJ3wqrJNysiyTwUCfdaMHMXHiRDZu3EjFihW5evXqF4cApDdqtRpPT894yeO9e/eIjY3F0NCQ8uXL07x5c2xsbLCxscHS0jLR6+7MsmaimU1xjnh4afWoS6VCom7ZItiUsebhw4dUr16dly9fxq2d1Gg0+Pr6snDhQjp27Ei+fL/msaqpQaFQkDFjRjJmzEj27N//gfzuBl+83/rorkMSZDRNveL9wpfE0YtCuhcWGU3j0auJVulm48yifi2pU6aITmInVkRYJBvG7eDw2pPExqgB+atlbhRKBbJGpmZbG/o79yBHXu2Orjo5ObFs2TKeP3+eKiMdqeXIkSN07dGTPE37om9sqrVEp15+JRvmTUKSJGbNmkWvXr3S3fS2LMs8f/483rT19evXCQ8Pj1v3+DlxtLGxoVSpUhgYGKSozfcfI2kzeROhEVFaKdkkAcYZDNgzuXvcjno/Pz9q1KjBmzdvUKvVKBQKmjVrxsmTJ4mJiaFWrVrY2dnRvn37JG2EErRvcb81HNlwGrWO3scBRm8ZRMM/aussvvBt6WNYRhC+IZORIe1qlfmizl9KKSSJfDkzU7OUhVbjJtWdcw/oWWIoB1YcRxUdiyx/PZmET9M6sixz+W8PHKyHcnLbea32Z8iQIahUKlau1H25ptQQGxuLk5MTzZs3p0qlCmwY1RljQwOUipR/PckBd1g0figdOnTg0aNHcSfdpLWQkBCOHTvGtGnTaNGiBblz56ZQoUJ07NgRNzc3cubMyaRJkzhz5gwfPnzg/v37bNiwgb59+1KhQoUUJ5MAWUyMmNa9qRZezScyMKlr47hkEqBQoUKcP38+bllBs2bNOHjwIG/evGHjxo0YGRkxaNAgzM3NadasGZs3b+bDB92e4iMkrGilIjpNJgGsKn5Zz1hIPWKEUvghhEfF0G7KZoI+hGt1LeWGkR0pVySv1uIl1cW915jWaSGyRk5ewd9/jkTpOfN37Ma00Vq/+vbty969e/Hz84s7U/1H5O/vj729PVevXmX27NkMHz4chULBk5dBDFi6N1lfTwpJQqPR8NL9MPmUH1ixfDk2NjY6egXfFxkZya1bt+JNXT958gT4/7rHz7++te5RV464ezFh01GAZH3vSv98jU/4oxGta5RK8JrHjx/Trl075s+fT+PGjeM99/btW3bv3o2LiwsXLlzA0NCQ5s2bY29vz2+//UbGjBmT3Cch6d4FfsA+Xx+dlA2SJMhbNA8bHjqL4xfTkEgohR/G9Uf+9HX+69MInhbi9WhSmUGta2ohUvLcOfeAUY2mIqtltPFtOHRVH37ro52Tbnx8fChWrBjLli2jX79+WomZ2g4fPkzXrl3JmDEjrq6uVK9ePd7zHyOjcd5znj0X76NUSN/d/S1JIMugCgshyP1vJo8YkOrT22q1mocPH8bbdX337l3UajWGhoZUqFAhXgJZpEiRdPEBe9XzGRM2HeVdWGSSkkqFQsI0YwamdG1MrdIpH30KCAhg586duLq6cv36dUxMTGjVqhV2dnY0btxYKyOzwtfN7OzM+V1XtJ9USjBoaS9a9m+i3bhCkoiEUvihHL/hzdj1R5C/scYwMVpXL8X4zg1RaGHaMzkiwiJxsB5CyOv3WjuKTN9QjzV3F5LPylwr8ezs7PDw8MDb2xulUsmTJ08oXLiwTneaa4NKpWL8+PHMnTsXW1tbNm3a9M1NA97+gbidu8Oha57ExKqRpE8Dv+rYWJAUSP+8XjnsLc89jtOmTkVmz5yh893b/133+Lne4+d1jyVLlow38li6dOl0fVxgWGQ0y/ZdZN+l+8T+s4kmoe9hCUCSUCokWlQtweA2tchsnEHr/Xn8+DE7d+7ExcWFhw8fki1bNtq1a4ednR116tRJF0sXfja+95/Tt8KfaLSYUCoUEtnMs7LB0xkjkx93NuVnIBJK4Ydz5eEzxm88wofwqCSNdigVErIMfW2r0bOZTZqO3CwbvJ4DK47H7U7VBoWeghJVi7Lo/DStxLt16xYVKlRg6NChnDlzhjt37nDq1Cnq16+vlfi64O/vj52dHe7u7nFT3In9d46KieXo+avMXLyagMAQypYrR+0a1fA4e5wDOzdTrkRRVqxYobOjKYODg7+o9xgYGAhAwYIFqVy5clwCWaFCBTJlyqSTfujah/AoDlx9yJWHfjzwe01oxP/rGWYyMqRkQTOqlihIi2olyZoKCYIsy9y/fx8XFxdcXV3x9fUld+7cdOzYEXt7e6pUqZIuRnl/Ftun/8XmSa5a2aj12ZwTE6nQQJzjndZEQin8kD6ER7Fw9zkOXfMEvr026/N0Zq6MSpYMs6dovrTd7RkaEkanPH2IjdHNqS3Lrs2iWGXLFMWIjo5my5YtDBkyhMjISBQKBRqNhkOHDtG8eXMt9VS7Dh48SLdu3TAxMWHnzp1JOpUmMjKSadOmMW/ePCwtLVmxYgX3799nwoQJKJVKZs2aRc+ePbU2avWtdY9Zs2b9Yt2jmZluj45MK7IsExYRTUysGgM9JZkyGqZp8ibLMu7u7ri4uODm5sarV68oVKgQdnZ22NvbU7p0aZFcplCsKpaxzWZw59xDrdSN/H1sW3pMt9dCz4SUEgml8EMLfP+RPRfvce7OE568DI6bSvssT3ZTKhfLz7X9W/G9f50HDx6k+ZTt7oUHWPPnVq2sm/wvpZ6CBp1r8+fGAcmOERMTQ7FixfDz8/viuZMnT9KgQYMU9FD7VCoV48aNY968ebRo0YJNmzaRLVviTz46deoUjo6O+Pv7M27cOGrWrMmwYcO4d+8evXv3ZubMmYmqs/c1n9c9/rfeo1qtJkOGDHHrHj+PQKaXdY+/OrVazfnz53F1dWX37t2EhIRgbW2Nvb09dnZ2WFlZpXUXv6DRaIgIjUSj1pDB2BCDDOlzTWhkeBQTW87hztkHyXsf/GejVvvhLegzr4v4fkknREIp/DRUsWr8374nKkaFnlKJeXZTMhkZAnDp0iVq1qzJgQMHsLW1TdN+/tlgCrfP3kcrO4sSYJrdhN2BG1L0JtunT58Ej1+8cOECNWum3Uam/3r+/HncWs+5c+cydOjQRL/ut2/fMmLECLZu3UqdOnWYMWMGa9asYcuWLVSuXJnly5cneXpblmWePXsWb9r687pHhUKRYL3H9LzuUfgkJiaGEydO4Orqyr59+/j48SMVK1bE3t6ejh07kj9//jTrW8DjVxzbcJp7Fz3xueVH9OclBBKYFzajRNWi1GxbhWotKqHUSz/rQlUxKrZP/4sdM/cgSVKiRysVegoyZDRk8PLe1P+9pkgm0xGRUAq/BFmWqV69OhkyZODMmTNp2o/WWboREabDI8gAF/9VKSp4Lssyq1atYvDgwajV6rhRhGvXrqVpiZx/O3DgAN26dcPU1JSdO3cm+mQaWZbZvHkzI0eORKPRMHfuXMLDw5k4cSJ6enrMnj2bnj17Jmok+7/rHt3d3Xn79i3wad3jv6etK1asiImJ7s4yFlJHREQEhw8fxsXFhUOHDhEdHR1XQL1Dhw6pVkD92UN/VgzdyM2T91AoFV9NyD4/lzV3FrpMaM9vjo3SfJbm33xu+bJlihtXD9z4VCIqgeRSqadErVZjYKhP4251+WNiB7Kb/zyHLvwsREIp/DJ2795Nhw4d8PDwoFKlSmnSh5DX7+iUp4/O25lzfAIVGpZJcZzLly/TunXruCTp9u3blC1bNsVxU0KlUuHk5MSCBQto1aoVGzduTPSJPo8ePaJv376cOXOGzp0707FjRyZMmMC9e/fo06cPM2bM+Or0dkRExBfrHp8+/XQkaLZs2eJNW//M6x6F/wsNDWXfvn24urpy/PhxABo2bIidnR1t2rQhc+bMWm9To9Gwa/4BNo53QZblJK9DLF3LmtFbBmFWMH2dHBToH8SF3Vd5dOMJXu4+hL8PR1IoyGqWGesqVlhXLUqt9lUxNhV1Q9MrkVAKvwy1Wo2VlRVVqlTBxcUlTfrwyvcNXYsM1Hk7U/aNonpL7exGfvXqFTVr1uTp06fcvXsXRf4s3Hn/DO/Ql7yKfI9a1mCqZ4SVaW6sTfNik8MKYz1DrbT9X8+ePcPOzo4bN24wd+5chgwZkqgpr5iYGObMmcOMGTPImzcvM2fO5NChQ2zduhUbGxuWL18e74eM2NjYeOsePTw8Elz3+PlX4cKFxdTbLy4oKIjdu3fj6urK+fPn0dfXjyugbmtrq5UC6hqNhgW9VnJ809lkx1DqKciULRMLzk6hQPG0O9RB+PmIhFL4pSxbtoyhQ4fi4+NDoUKFUr39oBfB2Ofvq/N2Zh4eS+Wm5bUWLzwygkn7V/MsDzwLf4uEhEIC9T9vHxKgkBSoZQ2GCn1a5KtA50K1yJsx8Ztjvmf//v10796dzJkzs3PnzkRPvV+8eJE+ffrw+PFjhg8fTo4cOZg+fTr6+vrMnj2bHj168Pz583hT1zdu3CAiIgKFQhGv3qONjQ0lS5YU6x6Fb3rx4gVubm64uLjg4eGBsbFxXAH1Jk2aJLuA+oqhG9m79HCK118r9BRkzp6JFTfmkiOP9r5HhV+bSCiFX0p4eDj58+enW7duLFq0KNXbV8eqaWHaBVWUSqftbPReorUC5z5hr5l41w2fsNefN1d+l1JSoJQUDCrWlA4FqqKQkr9mKyYmBicnJxYuXEjr1q3ZsGFDoqa43717x5gxY1izZg1Vq1bF0dGRhQsXcu/ePZo3b07p0qW5d+8e7u7uBAUFAZ/Ohv5vvUex7lFIiSdPnuDq6oqLiwsPHjwga9ascQXU69atm+hSVB7HbjO22Qyt9Uupp6Bi47JMP+AkRtcFrRAJpfDLGT9+PIsXL8bf358sWbKkevuDqjrh5e6js/gZjA35+8MWrSy8P/36PuPuuAKglpNXM652LmtmlLXDUJn0UT0/Pz86derErVu3mD9/PoMGDfruh58sy7i5uTFkyBAiIiKwt7fn+vXr3Lx5E0NDQ6KjP+2C/bzu8d8bZ3LlypWs1ygIifHvAupPnz7FzMwsroB61apVv/q1HRURTTfLgbwP/IBGSydrfea0bTD1f6+l1ZjCr0kklMIv5/Xr1xQsWJBp06YxatSoVG9/43gXXOfs00pR3/9SKBVUblae6fvHpDjWuTcPGX1r+6djLlPSJySq5yzG3PKd0VMkvmzJ33//Tffu3cmSJQtubm7fLeETGxvLiRMnGDVqFPfv38fU1JSwsLC4HeqWlpbY2tpSpUoVKleuLNY9CmlGlmU8PDxwdXVl586dvHz5koIFC2JnZ4ednR1ly5aN97V5ZP0pFvZepfV+SJJEAeu8rL23UHwvCCkmEkohXZBlGXXsp/I0evp6On9z69mzJ0ePHsXX1zfZ65mS682zt/xRuL/O6lDOODQWm2YpWz/5MuIdnS46E63R3tR8X6tGOBSpl+BzHz584M6dO9SuXZuYmBhGjx6Ns7Mzbdu2Zf369V+MJMuyjJ+fX9yax2vXruHu7o5K9am/uXPnJjo6mnfv3tGhQweWLl0qdl0L6ZJarebixYu4uLiwe/dugoODKV68eFwB9aJFi+JYbiS+958ja3l08rNFF6ZRqkZxncQWfh0ioRTSjO+9Z5zcdgHPq494fPMpUeGfpiINMxpiWb4Q1lWK0uCPWliWs9B62w8ePKBUqVJs3ryZrl27aj3+90xqO5drB2+gjtXiWd5KBbkL5WSj95IUTXfLsswAj/XceueX7GnuhCglBduqD6RIptzxHn/48CEtWrTg6dOnXLx4kWHDhnH79m0WLFjAwIEDkSSJt2/f4uHhEW/jzOd1j3ny5CEiIoIPHz7w22+/YWBgwJ49e6hSpQrLly+nYsWKWnsNgqBLKpWKkydP4uLiwr59+wgLC6Ni6cpkvV9QZ20q9ZR0GNmSnjN/11kbwq9BJJRCqntw2Zs1f27h4ZVHKPUUX02qPj9XrLIlvef+Qdk6JbXaj99++w1/f3/u3LmT6tM9gc/f4lBi2P9PtdAGCRaenUrpWtYpCuMe5MPA6xu01Kn/U0oKauUsztwKf8Q99tdff9GlSxdiYmJQq9VkzJiRnDlzMn78eEJDQ+OSR19fXwCyZ88eb7f1iRMnWL9+PaVLl6Z+/fqsW7cOQ0ND5syZQ/fu3dNVAWdBSIrIyEgOHz7M1kWuhF/WYUMSVGhQmjnHJ+qwEeFXIBJKIdXERKvYOM6F3YsOoFB8/WSH/1IoJDQamVYDmtJ77h8YGmmnxuGZM2eoX78+x48fp1GjRlqJmRTHNp1hvsMKrcSSJGg71Ja+C7qlONafN7dy8a23VkcnP1Mg8XfdUeTQN2H8+PHMnj0bSZLi1jkaGBigVqtRq9UYGRl9Ue/RwsICSZLYv38/AwYMICQkhG7dunH+/HkePnxIv379mDZtWpLO8haE9Gzn3L/ZMG6HTtZcf5YlV2Z2vV6ns/jCr0EvrTsg/BqiIqKZ0GI2d849AJkkvTl+3tV4YOUxHt/yZdaRcWTMZJTiPtWtW5fy5cszf/78NEkom3Svx1v/YDZP2pmiOJIEtTtUp/fcP75/8XdExEZzIdALja4WeAJH/W8ytWmvuFNm/v0zbdasWZk2bVrcCKSeXvy3qBcvXjB48GD27NlDvXr1MDU1ZeXKlVStWpXr169ToUIFnfVbENJCVHjUpx+q1bprIyYyRnfBhV+GmA8SdE6j0TCl7TzunnuYokXlGo2M17XHjG8xC3Vsyt9dJUli5MiRHD9+nLt376Y4XnL8MaE9g5b1Qs9AD4Ve0r4dFcpP17cd8htO2wcnup7dt3iHvtRpMglwJ8iXly9fJvhcaGgoDg4OlC1bNl4yqVarWb58OdbW1ly8eJEuXbpw/fp1Ll26xPr167l06ZJIJoWfkp6+HrqeR1Tqpfy9QxBEQino3L6lR7h+/A4aTcqnbDRqDfcueOI2b78WegYdOnQgf/78LFiwQCvxkqNl/yasuTOfjGafdpsrv5NYfk4kcxXIwYKzU+i7sLtWkkmAR6GvkNDdelINMk+jg+nVqxcAFSpUoFWrVnFnHkdGRuLv7x/vnrt371KjRg0GDhxInTp1yJYtG9u3b6dr1648evQIBwcHsVZS+GmZF86llR+gv9lGEVEBQUg58S4s6NQr3zesG7NNu0Fl2DxpJ8+9XqQ4lL6+PkOHDmXHjh28eJHyeMllnNOIU+//xup3c+ra1cAkq3GC1xlmNKRS47JMP+jEpkdLKFO7hFb78UEVgVLHG5RevAtkzZo1LF++nOvXr7Nv3z5CQkK4desWO3fupECBAgBEREQwZswYKlasSHBwMI0aNeLgwYNkzZqV69evs2zZskSdmCMIPzKrioV1Gl+pr6S4jaVO2xB+DWINpaBTexcf1mppnP+T2bPoIENXO6Y4Uq9evZgyZQpLly5l9uzZWuhb0i1ZsgRVrIpJC8ZhZmaGLMu89Q/imecLYiJj0DPQI08RM/Jamf/wo3GyRsOVK1fiTVErFArKlStHuXLlADhx4gR9+/YlICCABg0acOnSJT58+MDGjRvp2rXrD/93IAiJldfKnMw5TfnwNlQn8dUqNWW0XEFD+DWJd2VBZyLDozi64bROdieqYzUc33qOj+/DUxzL1NSUPn36sGrVKsLCwrTQu6QJDQ1l8eLFODo6xhXfliSJXAVyUrlJOWq0tqFK8wrkL5ZX54lUVgNjnezu/rcC2XN/db1jYGAgf/zxB40bN8bU1JQCBQpw4sQJunfvjre3tygFJPxyFAoFFVuWQlcrUfSMlOQobqqb4MkgCs/8uMQ7s6Az9y94EvkxSmfxVVEqbp2+r5VYgwcPJjw8nPXr12slXlIsW7aMiIgI/vzzz1Rv+7+KmebV6ZYcpaSgdLZCXzwuyzIbNmzA2tqaQ4cOUaVKFW7fvk2uXLm4ceMGS5cuFdPbwi/n5s2btGjRginrxuos0fKL9aZUmVKUL1+euXPn8vz5c520k5BYVSwX/rrKwt6r6F1mOM2N7Gms7EhTQzu6FxvMnG5LObrxDFHarNcr6IxIKAWdeXTjadwGEl1Q6il5fOOJVmLlz58fOzs7nJ2diY2N1UrMxPj48SMLFy6kZ8+e5M2bN9Xa/ZqiprlRSrr7N9PIMiUz54v3mLe3N/Xq1aNnz55YWFigUql4+vQpGzdu5MKFC3HT4ILwq7h9+zatW7emYsWKeHt7s37bOnrN6qzVNhRKBbktcnHl1Vn++usvrKysmDRpEgULFqRGjRosW7aMN2/eaLXNz9SxanbN3499/r5M7bCA45vP4nffH1X0p/detUrNi8evOONykQU9V9DRvBdrR28j8mOkTvojaIdIKAWdefbQH13Wu9Co1fje9//+hYk0YsQInj17xl9//aW1mN+zcuVKQkNDGTNmTKq1+S0ZlAY0yF1KZ0mlQpJomLs0ANHR0UyZMoUyZcrw+PFjChYsyK1bt+jRowePHj0S09vCL+f+/fu0b9+e8uXLc+/ePTZt2sTDhw/p3LkzHUa2pLiNZZLLiyXon+nz0VsGkSVbZtq2bYubmxuBgYFs27aNrFmzMmzYMPLkyUOjRo3YsGED7969S3m7gN8DfwZUHs2a0Vt5H/gB4Ku72D+vv48Mi2LXgv30LDnsUy1jIV0S79aCzkR+jIorSq4LsgyRYdr7ibVcuXI0bNiQefPmpco6noiICObPn0+3bt3idjanBx0KVNPJOkqlpKBh7tJkMzSJG3mcNm0alpaWvHz5krx588ZNb2fJkkXr7QtCeuXp6YmdnR1lypThxo0brF+/Hi8vL7p16xZXj1WpVDL9oBN5i+RO2cyPBBISo7cMolSN4vGeypQpE507d+bgwYO8fv2aVatWoVar6dWrF2ZmZrRq1QoXFxfCw5O3dv3eBU8GVnHC74E/SV1bI2tkgl++Y1TDqZx2uZis9gXdEgmloDN6+no6W0ge14aBdgsVjBgxghs3bnD+/Hmtxk3I2rVrCQ4OxsnJSedtJVZMTAx/L9vMh2s+oOUfBpSSArtclenduze1a9cmMjISQ0NDgoKC2LRpk5jeFn453t7edO7cmZIlS3L58mVWrVqFt7c3Dg4O6Ovrf3F95hymOF+cTqmaxROI9n0KPQVGJhmYvOdP6tvX/Oa12bNnp3fv3pw+fZoXL14wb948AgMD+f3338mVKxd2dnb8/fffREcnbn2jzy1fnJpORxUVk+zKHxq1Bo1aw+w/lnDlwPVkxRB0RySUgs6YFcih0xMYlPpKchfKpdWYTZo0oVSpUsyfP1+rcf8rKiqKuXPn0rlzZwoX1m2ducS6ePEi5cqVY+qUqfymLoKJfgatFjmv8TEn9ctVY8eOHeTOnRt/f3969eqFt7c33bp1E9Pbwi/Dx8eHbt26UaJECc6dO8fy5ct5/Pgxffr0wcDA4Jv3mmbPxLxTkxi8vBeGGQ0/jTh+59v082EJlZuWZ6PXEqq3qpyk/pqbmzNkyBCuXLnC06dPGT9+PJ6enrRu3RozMzMcHBw4ceLEV9efx0TFMMN+EaqYWC3NWsnM6baUd/9MmQvpg3gHF3TGqmIR1CrdnfCgVqkpWqmIVmNKksSIESM4ePAgnp6eWo39bxs2bODVq1eMHTtWZ20k1vv373F0dKRWrVqYmppy8+ZNFk6dxbwKXVBKklaSSoOHwcxtPxgDAwMiIiIoUqQIN2/eZPHixWJ6W/hlPH36FAcHB4oXL86JEydwdnbGx8eHfv36YWhomOg4CoWCFv2asPPlGgYt7UWhkgWQFAl/n5pkMaapQwNW3ZrH9P1jyG6esmoJFhYWODk5cefOHR48eMDgwYO5cOECjRs3Jm/evAwcOJCLFy/GOxlt+/S/ePH4tdZKyH1a7hTF0gFrtRJP0A5JFkWfBB158+wtf1j012kb6x86U6C4dndHR0dHY2Fhga2tLWvWrNFqbPg0rWxpaUnNmjXZsWOH1uMnlizL7Nq1iyFDhhAeHs6sWbPo27dvvGMcPYKfMOLmFlQadZLXVUpIyMiEHL9H0MaLREdFYWpqyrx58+jSpQuSjk/kEYT04tmzZ8yYMYONGzeSLVs2nJyccHR0xMjISGttRIZH8eS2H0EBwahjNWQ0NaJI2YLkzJ9D599rsixz8+ZNXFxc2LlzJwEBAXGVM9q0aMOMpsuIjozRSdsbvRaTr2gencQWkkYklIJOjW48ldtnHmi9uLlCIWFdrSjOF6ZrNe5ns2fPZvLkyTx79iyu2Li2rFu3jt69e3P//n1KlkybEyqePXvGgAEDOHToEG3atGHp0qVfLVv0KvId0+79xfWQpyiQ0CRiNb0EaCJVPHU+ROjlx6jVagYNGsSUKVPEiKTwy/D392fmzJmsX7+ezJkzM3r0aPr164exccJHq/4MNBoNly5dwsXFhV27dmEYZIq1lPBBBimlUCpoPbAZ/RZ110l8IWnElLegU22H/KaTk3I0Gpk2g3/TetzPHB0d0dPTY/ny5VqNq1KpmDlzJu3atUuTZDI2NpaFCxdSokQJbt++zd69e9mzZ883a2CaG2VleeWezCnfmWIZ/p9cK+RPo5ASnzbcfJ4a14vWELD1PL5DthFy3pPY2Fj09PTIli1bvNFPQfhZvXz5kkGDBmFpaYmbmxvTpk3D19eXkSNH/tTJJHyajq9VqxYrVqzg1atXNK1gq7PNmRq1hvN/XdVNcCHJREIp6JRN8wpUa1lJqwXOlXoKKjQsTe32VbUW87+yZs1Kz549Wb58OREREVqLu2PHDnx9fRk/frzWYibWzZs3qVKlCiNHjqRnz548fPiQ1q1bJ+peSZJ4ffoue1qMI2zqUXpnqYqdRU0a5i5FPbOSNM9Tngaq/LyddYTrds4E7fZAL0amZ8+ewKdEeurUqRQoUIDFixcnemeoIPxIXr9+zdChQylcuDDbtm1j4sSJ+Pr6Mnr0aExMTNK6e6lOqVQS9PR9kksEJUVQQDChIal/ZK7wJTHlLehcyOt39Cw5jIjQyBSPVioUEoYZDVn3YBG58ufQUg8T5uvri6WlJUuXLqV//5SvBVWr1ZQoUYLixYvz999/a6GHifPx40cmTZqEs7MzpUqVYs2aNVSpUiXR90dGRjJ06FDWrFnDH3/8wcqVK+N9OAYEBDBo0CD27duHsbExUVFRDBw4kClTpvDw4UOqV68eL54kSeTJk4cbN25ofTmBIKSFwMBA5syZw8qVKzEwMGD48OEMGTKEzJkzp3XX0lTI63d0ytNH5+0sODuFMrVL6Lwd4dvECKWgc9lyZ2X20fEYZNBP0UilQqFAz0CPmUfG6TyZhE+7Gdu3b8+iRYtQq1O+W93NzY1Hjx4xYcIELfQucQ4dOkTJkiVZuXIls2bN4vr160lKJr29valatSpbtmxh/fr1bNmyJS6ZVKvVLF26lOLFi3P06FEAypcvz82bN3F2diZz5swUL55wvbysWbOSMWPGlL9AQUhDQUFBjB49GgsLC9auXcvIkSPx9fVl4sSJv3wyCZ8Ot/iZ2hG+TSSUQqooVtmSheemki13FhRfKW/xLQqlgsy5TJl/ZsoXpzvo0ogRI/Dx8WH//v0piqPRaJg+fTpNmzalUqVKWurd17169YqOHTtia2tL8eLFuX//PqNGjUqwWPLXbN++nYoVKxITE4O7uzsODg5xu0Xv3LlD1apVGTx4MNHR0ZiamrJ161bOnz9PmTJl4mJkzZqVbNmyxYvbpUsXrl+/TqZMmbTzYgUhlYWEhDBu3DgsLCxYvnw5Q4cOxdfXl6lTp5I1a8rK8vxMdFmHOC3aEb5NJJRCqrGqUJj1D51p3rshQKJGKz+fW9uoax02ejpjXcVKp338LxsbG2rVqpXiQud79uzh4cOHOh+d1Gg0rF69Gmtra86ePcu2bds4evRokoqnR0ZG0rt3b/744w/atm2Lh4cHpUt/On87IiKC0aNHU6FCBe7evYtSqWTgwIE8evSIP/74I8HyJCVKfJqKypEjBxYWFty4cSNejTpB+FG8e/eOiRMnUqhQIZydnenfvz++vr7MmDGD7Nmzp3X30p1subNodf3815gV1P2MlfB9Yg2lkCZe+Lzi0OoTHN14hrCQjwleY5LFmMbd6mLbtxH5i2m31mRS7N+/n1atWnH58mWqVauW5PtlWaZ8+fLkyJGDkydP6qCHnzx48ABHR0cuXbqEg4MDc+fOTfKHnJeXFx07dsTHx4fly5fTvXv3uCTx2LFj9O7dmxcvXqDRaKhZsyYrVqyISza/Zt26dZw/f56FCxfy+vVrKlWqRJ8+fViyZEmyX6sgpKYPHz6wePFiFi5cSHR0NAMGDGDUqFHkyqXdk7p+Rr1LD/90dreOGGY0ZH/oFnHSVjogEkohTcmyTODzIB7ffEpo8EeQZcZNGUfVRpVYsWFZuih+rdFosLa2pnTp0uzevTvJ939OSM+ePUudOnW03r+oqChmzJjBnDlzsLCwYPXq1dStWzfJcbZt20bfvn0pUKAAu3btiitr9ObNGwYPHoybmxsKhYLs2bOzaNEifv/992T9+yxbtoxBgwZx6NAhmjdvnuT7BSG1hIWFsWTJEhYsWEBERAR9+/Zl9OjRmJubp3XXfhjLB2/gwKpjyT6/+1sUSgXl6pVkzvGJWo8tJJ1IKIV0p2XLlsTGxnL48OG07kqcNWvW0LdvXx4/fkyRIok/7lGWZWxsbDAyMuL8+fNa79eZM2dwdHTEz8+PMWPGMHbsWDJkyJCkGBEREQwePJj169fTrVs3li9fjrGxMRqNhg0bNjBs2LC40kmDBw9mypQpmJqaJrvPsixja2vL9evXuXv3rtjpLaQ7Hz9+ZPny5cybN4+wsDD69OnDmDFjvlmvVUjY07vPcCw3UmfxJ+4eSa22id9oKOiOGCMW0h1LS0t8fHzSuhvxdOnShRw5crBo0aIk3Xf06FGuX7+u9bWTwcHBODg4UL9+fczMzLh9+zZTp05NcjLp6elJlSpV2LFjBxs3bmTTpk0YGxvj6elJtWrV6N27Nx8/fqRKlSrcvn2bRYsWpSiZhE9lgzZs2ABAjx49ED/TCulFREQE8+fPp3DhwkyYMIEOHTrg4+PzzZOkhG8rXKYgJasX0/paSkkhkc08K9VaVNRqXCH5REIppDtWVlb4+voSGxub1l2JY2RkxIABA9iwYQPBwcGJukeWZaZNm0aVKlVo2LChVvohyzLbtm2jePHi7NmzhzVr1nDu3Lm4jS9JsWXLFipVqoRGo8HDw4Pu3bsTHR3NhAkTKFWqFB4eHmTLlo1t27Zx6dKl766VTAozMzM2btzIkSNHWLZsmdbiCkJyREZG4uzsTOHChXFycqJ169Y8fvyYlStXkj9//rTu3g9v8IreWj8tR9bIDF3VBz19Pe0GFpJNJJRCumNlZUVsbCx+fn5p3ZV4+vfvjyzLrFq1KlHXnz59mitXrjBx4kStrAV98uQJTZo0oUvXLtRq05S1V/aTo2lZ9r+4wcVAL4KiQhMVJyIigo4dO9KtWzcqVKiAu7s7JUuW5Ny5c1haWjJ9+nRkWWbQoEH4+vrSuXNnnaxlbd68OYMGDeLPP//k3r17Wo8vCN8TFRXF0qVLKVKkCCNHjqR58+Z4e3uzZs0aChYsmNbd+2kULlOQrpM6ai2epJBo2KU21VrovgSbkHhiDaWQ7jx79oxChQpx+PBhmjVrltbdiadfv37s3bsXPz+/704v161bl48fP+Lh4ZGihEylUrFw4UJmb1lBvrZVMa1uhUpKeIF7TkNTWuevTOt8lcmZ4cup6YcPH9KxY0cePnyILMvo6enx6NEjxowZg5ubGwCVKlVi48aNlCpVKtl9TqyoqCgqV64MgIeHR5Kn7AUhOaKjo9mwYQMzZszg1atX/PHHH0yYMAFLS8u07tpPS6PRsKDXSo5vOpuiOJJConQta2YdGYdBBgPtdE7QCjFCKaQ7+fPnx9DQkMePH6d1V74wbNgwAgMD2b59+zevO3/+POfOnWP8+PEpSiavXbtGpXo1WB91A6sFnTGpYfnVZBLgbXQo631O0+LsHFY/PoFK8/9lA5s3b6Zy5cqEhobGrVuMjY3F0tISNzc3MmfOzNatW3F3d0+VZBIgQ4YM7Nixg8ePHzN69OhUaVP4dalUKtauXUvRokUZMGAAderU4eHDh2zevFkkkzqmUCgYsa4f7Yfb/vPnpL0vfn4frdnGhpmHx4pkMh0SI5RCulSyZEnq16/P0qVL07orX2jdujWPHj3i/v37X6191qhRI968ecPt27eTVR8tNDSUsWPHst3jGJZObVBm0EdD0r5VJaCQcS5mlOjAjJHj2bRpE127dmXv3r2EhYXFu/a3335jx44dKd5wk1xLlixhyJAh6XJUWvjxqVQqtm7dyrRp0/Dz86NTp05MnDgxWWuPhZS7dfoec7svJyggGIVSgUb99R+SJQlkwNg0I4NX9KaeXY10UU5O+JJIKIV0qVWrVsTExHDkyJG07soXLl68SK1atb5aR/Hq1atUq1YNNzc3OnTokOT4e/fuZdCgQaiLZSf/yN/i3lCTQ4FEbGgkPmNcWDJ5DhcvXmTt2rVfXJctWzaCgoLS7I1almWaN2/OrVu3uHv3rigYLWhFbGws27dvZ9q0aTx58oR27doxadIkrW4wE5JHFaPi4h539i09zMOrj+Le5BQKCY0sx/25YIl8tBrYjAada5Exk1HadVj4LpFQCunSyJEj2bdvX7orHwSfkp9q1aqRMWNGTp8+/cXzv/32G76+vt8cwUxIQEAAgwYNYt++fTTu3p4PnYoiIyc7mYzrr1pDLgNTxmdtQPXKVb963Z49e2jTpk0KW0u+N2/eULp0aSpXrszBgwfFKISQbGq1GldXV6ZMmcLjx49p1aoVkydPply5cmndNSEBEWGRPLntx7OHAcRExaBvoEcey9xYVSiMafZMad09IZHEfnshXbKyssLPzw+VSoW+vn5adyceSZIYMWIEHTt25MaNG1Ss+P86aDdu3ODw4cNs27Yt0cmkWq1mxYoVjBs3DmNjY1zcXNmT+yWh4UFo42wJSakgSB3OlpeX4/pvZGSEqakp2bJlw8zMjEKFClG9enUttJZ8n0sJ2drasmLFCgYMGJDimM8e+uN++Bbe15/w9K4fUeHRKPWU5CtqTrFKlpSpU4Jy9UuJY9t+EhqNBjc3N6ZMmYKXlxe2tra4uLjE+x4V0p+MmYwoXcua0rWs07orQgqIEUohXTp9+jQNGjTA29ubokWLpnV3vhAbG0vRokWpWrUqO3bsiHu8devWPHjwAE9PT/T0vv/z2t27d+nduzfu7u44Ojoye/ZsDr67x1LvIykemUzI1moDKZY5jw4ia8/AgQNZv349169fjzv+Mak8jt7CZdZe7l3w/LT4X5LirdOSJAmFUoE6Vk2ugjlpN/Q3WvZvImra/aA0Gg179uxh8uTJPHjwgKZNmzJlyhRsbGzSumuC8MsQP5YL6ZKVlRVAutzpDaCnp8ewYcNwc3Pj+fPnwKfk8O+//2bcuHHfTSYjIiIYM2YMFSpU4OPHj1y8eJFVq1aRKbMprn6XdJJMKiUFewLcdRBZu+bNm0eRIkWwt7cnKioqSfeGvfvI7C5LGNt8Jg8ueQOg0chfLPqXZRl1rBqAwGdvWTV8EwMqj8H33jPtvAghVciyzN69eylfvjwdOnQgT548XL58mSNHjohkUhBSmUgohXQpb968ZMiQIV2uofysR48emJqasnjxYgCcnJzIkycPnTt3/uZ9x48fp1SpUjg7OzNlyhRu3bpFjRo1AHAP8iEwOnEFypNKLWs4/OImUeoYncTXFiMjI3bs2IG3tzdOTk6Jvu/Ns7f0qziKM66XgE+jVokly+D3wJ/+lcdw7dCNJPdZSF2yLHPgwAEqVqxI27ZtyZEjBxcuXOD48eNUq1YtrbsnCL8kkVAK6ZJCoaBIkSLpdoQSwMTEhH79+rFy5Urq1q3L4cOHiYyM/Oqaz8DAQP744w+aNGlCoUKFuHv3LuPGjcPA4P/11G6/80Mp6e7bMloTi3foK53F15YyZcowZ84cnJ2dOXr06Hevf/fmPcPrTCQoIPibJUi+RaPWoFapmdRmHjdPiZN70iNZljl8+DA2Nja0bNmSTJkycebMGU6dOkXNmjXTunuC8EsTCaWQbllZWaXbhFKj0bBv3z6OHj1KZGQk586dA8DY2PiLa2VZZuPGjVhbW3PkyBE2btzIqVOnElwb+vBDABpZG1txEiYh4fkhQGfxtWnw4ME0adKE7t278/bt269eJ8sy8xxWEPQyBHVsyv7uZFlGo9EwvdNCQoPDvn+DkCpkWY4bffztt98wMDDg5MmTnD17lrp166Z19wRBQOzyFtIxKysrdu/endbdSNC6detwdHT8YnfwfxPKR48e4ejoyNmzZ+nSpQsLFiwgZ86cX437IiJEJ+snP1NKEi8j3+uwBe1RKBRs3LiRMmXK4ODgwP79+xMsJXRy23k8jtzSWruyRib8QwRLB65jnMswrcUVkk6WZU6fPs2kSZO4dOkSVapU4dixYzRq1CjVy0pFR0Zz99xDHl1/ytN7z4gIjUCpVJIzf3asKhahZI1iFLTOl6p9EoT0RCSUQrplZWXFs2fPiImJiTctnB60adOGDRs24OHhEe/xzwlldHQ0c+bMYcaMGeTLl4/jx4/TqFGj78aN1eHo5GdqWa3zNrTF3NycjRs30qJFC1auXEn//v3jPa/RaNg43kXr7WrUGs7uvMwfEzuIJCGNnDt3jokTJ3L+/HkqVarEoUOHaNasWaonkoH+QexdfJjD604SERqJQqkAWUaj+fSjn1JPycHVJwAobmNJm8HNqWtXQ5SiEn454iteSLcsLS3RaDT4+vqmdVe+kDNnTs6dO0f79u3jPW5iYsLFixcpX74806ZNY/jw4dy7dy9RySRARj3dJ85GyvSVnH+Pra0t/fv3Z8SIETx8+DDec9eP3eGtf7BO2lXoKTi46rhOYgtfd/HiRRo0aEDdunUJDQ1l//79uLu707x581RNJmVZ5uDqEzgUH8KexYeICI0EPv2w8TmZBOKqBQA8uv6EWX8sYXidibx88jrV+ioI6YFIKIV0K72XDjI0NMTU1BQTE5O4DzpPT09q1aqFqakpN27cYNasWWTMmDHRMYtmyoNShx+asbKGIpnMdBZfV+bNm4eFhQW///470dHRcY+fdbuEUk83b2OaWA2nd1xAlOpNHVeuXKFx48bUqlWLoKAg9uzZw82bN2nRokWqj0rGRKuY1nEBi/utIToyJtEbvT4nml7XHtO7zAiuH7+jy24KQroiEkoh3cqTJw9GRkbpNqF8/vw5mzdvZty4cYwfPx6A4OBgZqxexFCXBezlEV0vL6PjhUX8cWkp42+7st33At6hL78as3jmPJ/OsdWh4qZ5dRpfFzJmzIiLiwuenp7xSgl5XnmU4o043xIa/JGgFyE6iy+Ah4cHzZs3p3r16rx48YJdu3Zx69Yt2rRpkybHb6pj1cywW8TFvcmv2aqO1aCKVjHedpaoGCD8MsQaSiHdUigUWFpaptuEcu7cuWTMmJEzZ85w/Phx6vfpQN5O1dkXE4jkfRiFJKH+15pIn7DXnHx9Dw0yxU3z0LlQLRqbl4n3oVkzZ3GcvQ7rpL8SYG6UlYLGOXQSX9fKli3L7NmzGT58OE2bNqVe3Xq88NH9tOLTO37kzJdd5+38am7evMmkSZM4ePAgxYoVw8XFhQ4dOqBUKtO0Xzvn/s3l/R6kdHecrJHRoGFq+/ls8HQmW+6s2umgIKRTYoRSSNfSa+mg58+fs2rVKiIiInjo95juB+cT1saSRzGfytvIyPGSSQANMpp/PqW8Q18x4e5OBl3fyJt/7bp+ec+HD7d8kZNZS/F7OhWsjkKHdS51bciQITRu3Jhu3boR4PcCWaP76eiP7yN03sav5Pbt27Ru3ZqKFSvi7e3Ntm3bePDgAXZ2dmmeTPref86WyTtTnEx+JmtkIj9G4dx3jVg6Ifz0ftxPFuGXkB5HKG/cuEHlypVRq9X8PqAnZVb2xlP5aVpUk8hPIvmf626EPMX+0mIefgjgxIkTNGzYkFcul5GU2v3WlJAw1c+Ibd4KWo2b2hQKBZs2bUKlUjFk6JDUaVPL/xa/qvv379O+fXvKly/PvXv32LRpEw8fPqRz585pnkh+tnG8C9rO+zRqDVf2X8fz6iPtBhaEdEa8UwrpmpWVFc+fP4+3ESOtfPz4keHDh2NjY8Pbt2/pMqAXgS0LEKIKT3Qi+V9qWUN4bDTdzy2lVZ/OhIeHE3bvOYGHbiIn4ejA75GRGVeqLZn0jbQWM62Ym5uzYcMGDhzZj0JHG3L+LVvuLDpv42fm6emJnZ0dZcqU4caNG6xfvx4vLy+6dev23TPvU1OgfxBXD9xI9klL36LUU7B/5TGtxxWE9EQklEK6ZmVlhSzLPH36NE37cejQIUqWLMmqVauoVasWGY0zomdXjncx4V9MbSeVDMhKiRrL+uM4oB8HDhzg9JjVWGQy08oxjBLQJl9l6pqVSHGs9KJly5b07duXD2rdlAz6N8vyhXTexs/I29ubzp07U7JkSS5fvsyqVavw9vbGwcHhq8eTpqWzrpfQ1R4gdayGczsvExOt0k0DgpAOiIRSSNfSunTQq1ev6NixI7a2thQvXpzz589z/fp12swYxP2PL1KcTH4mKRWEKlWUGNQCW1tbCuctyIrKPclrlA1FCj/lmpiXZVTJVlrpZ3qyYMECyKKOWz6gC/mK5sE485fHaQpf5+PjQ7du3ShRogTnzp1j2bJlPH78mD59+qS7Awr+zcv9MTrLKIFYlRrfe891Fl8Q0ppIKIV0zdzcnIwZM6Z6QqnRaFi9ejXW1tacPXuW7du3c/ToUfbt2wdKiZfW2p86lpFx8btESPRHAHJkMGV91b7UNysFfBppTCylpEApKRhQtAmTy3TQykhneuPn54d5hexISfqbSTxJkvitT0OdxP4ZPX36FAcHB4oXL87x48dxdnbGx8eH/v37Y2homNbd+y5vjyc6me6OI8HjG2k70yIIuvTzfcoIPxVJklJ9Y86DBw+oXbs2ffv2pV27dnh5efH777/z4cMHli5dSttxfQlTR+mkbY0sc+DFjbg/ZzbIyMxy9swp35mCxp/OAP9acigBin+SK5vslmyvMYhuhev80Lu6/0uj0XD06FGaNm1KyZIluXr/EmRRo9HBkZV6Bkoad6+r9bg/m2fPntGnTx+KFSvGoUOHmD9/Pk+fPmXQoEFkyJAhrbuXaKHBH3UaX6lUEhocptM2BCEt/TyfNMJPy8rKCh8fH523ExUVxYQJEyhfvjxv377lzJkzrF+/nmzZsgGwZMkSYmJiMK1ZNC5x0zYZmcMvbn7xeD2zkuysOZQ1VfrQNr8NJTLnQ1/x/52xmfQyUDm7JQ5F6mGy9jZl72oobPLjnYjzNeHh4axatYqSJUvSrFkz3r59y9atW3n27BnLjs9N8bKAhHSfaodptkxaj/uz8Pf3p1+/flhZWbF3715mzZrF06dPGTp0KEZGP/7mL0EQkib9bLEThK+wsrJix44dOm3jzJkzODo64ufnh5OTE05OTvFGV0JDQ3F2dqZ37954RwUme1d3YjwLDyJKrSKDMv7GBUmSKJe1EOWyFgI+nTUcK6uRkND7J7mMiYnBcU8jzu49irGxMZ06ddJZP1ODv78/y5cvZ82aNXz48IE2bdqwdu1aatSoEVcQvlglS1oNacq+xUe1Mv2t0FNgVd6CdsNtUxzrZ/Ty5UtmzZrFmjVrMDExYdq0aQwYMAATE5O07lqKmGY3ISpcNzMPAGq1GtPs4gcU4eclRiiFdM/Kygp/f3+iorT/Zh8cHEyPHj2oX78+ZmZm3L59mylTpnwxVbdixQrCw8NxHD6IdzHhWu/Hv2mQefrxzXevkyQJfYVeXDIJ8Pr1p5NjZFnG3t6e5cuX66yfunT16lXs7OywsLBg5cqVODg48OTJE3bv3k3NmjW/OJKv37weFKlSIMXFo5V6CrKbZ2Xy3lHppjZievH69WuGDh1K4cKF2bZtGxMnTsTX15fRo0f/8MkkQLHKRXRbc1QGq4qFdRdfENKYSCiFdO9z6aAnT55oLaYsy2zbto3ixYuzd+9e1qxZw7lz5yhR4svSOuHh4SxYsIAePXqQKWfqHJ8WqopM1n2vXr2K+70sywwcOJCJEyf+EKd0qFQqXF1dqVq1KtWqVePGjRs4OzsTEBDA/PnzKVSo0FfvVeopWX5+Lpms/tn8kYyBSkmSyGNpzuJLM8iRJ1vyXsRPKDAwkJEjR1K4cGE2bdrE2LFj8fPzY9y4cZiamqZ197TiyZMnvAh7jkaLtV//S09fiUXpAjqLLwhpTSSUQrqn7dJBT548oUmTJnTp0oUGDRrg5eVF7969USgS/nZYtWoV79+/Z8yYMTrbUfxfyW3l3wnlZ9OmTWP48OEp65AOhYSEMHv2bCwsLLC3t8fY2Jj9+/fj7e3NwIEDyZQpcdOEevp6bL25miDz52gk9RejmF+j1FMgSRKdRrVi1c254tzufwQFBTFmzBgsLCxYs2YNI0eOxNfXl4kTJ5I5c+a07l6KvXjxgkWLFmFjY4OlpSW7zu/Q2pGL/6XUU1CnU3UMDNNf/U1B0BaRUArpnpmZGSYmJinemKNSqZg9ezalSpXi0aNHHD58GFdXV3Lnzv3VeyIjI5k3bx5du3alUKFCZDVMnZqE2QyTN4X46tWreInU52nba9euaaVf2uTp6Um/fv3Ily8fkydPpkmTJty5c4dTp07RokWLryb432JiYsL6Ayu5Ih3DvHZWchXIEfecUl+J3j+/Pv8dZTA2pEXfJqx7sIieszpjkCH91klMLSEhIYwbNw4LCwuWLVvG0KFD8fX1ZerUqWTNmjoj9LoSHBzM6tWrqVu3Lvnz52fMmDHkzZuXnTt3EhD0nGotK+lk2lsdq6FlvyZajysI6YnYlCOke9ooHXT16lX69OnDgwcPGDZsGFOmTMHY+PvJ4bp163j79i1OTk4AZEAPk1glH/XUye7L9+hLSiyMcyXr3levXiHLMpIkIcsyRYoUYd26ddSsWVPLvUweWZbjahQePXqU3Llz4+TkhKOjI7lyJe81/1eFChWYMnMyo0aN4sTxE1jlK87jG0/xu/+c6IgYlPpKzAubYVWxMEXKFsTQKP3XSEwN7969Y9GiRTg7O6NWqxk4cCAjR44kZ86cad21FAkLC2Pfvn24uLhw4sQJZFmmQYMGbNiwgdatW5MlS5a4ax1m/I774VtabV+hVFDltwpYVy2q1biCkN5I8o+wuEr45XXs2JGgoCBOnz6dpPtCQ0MZO3YsK1asoEKFCqxZs4YKFSok6t7o6GiKFClCvXr12LJlC3v37sXJyYnYVsXIXrckKLQ//S0hUTJzPjZU65es+93c3Fi+fDldunTBy8uLdevW8erVqzQv4xIREcHWrVtZvHgxnp6elC9fnmHDhtGxY0edFL3WaDQ0atQILy8v7t69S/bsYhr7az58+MDixYtZuHAh0dHR9O/fn1GjRmFm9uOWnYqMjOTw4cO4uLhw6NAhoqKiqFGjBvb29nTo0OGbP7zsmLmHjRNctDL9LSkkMmYyYoOnM9ly/9iju4LwPWLKW/ghWFlZJXmEcu/evZQoUYJNmzaxcOFCrl69muhkEmDjxo28fPmSxo0bU61aNdq1a4eFhQXT2w3QSTIJn+pQtsxXKdn3d+zYkXPnztGrV69PZ11/+MCePXu02MOkCQgIwMnJiXz58tG/f3+sra05f/48N27coEuXLjo7QUWhULBlyxaioqLo3bv3D7EpKbWFhYUxY8YMLCwsmDlzJt26dePp06csWLDgh0wmVSoVR48epVu3bpiZmdG+fXuePn3K1KlTefbsGRcvXmTAgAHfHQnvNKoV1VtWRkrh97ikkFAoFEzcPVIkk8IvQYxQCj+ETZs20aNHD8LDw8mYMeM3rw0ICGDQoEHs27cPW1tbli9fToECSdtdqVKpKFiwIPBpGrlixYrMmTMHCwsLJk2ezJ26xmQwz5r83TNfYaQ04Gi9sRjpaWctX926dVEqlZw6dUor8RLr2rVrODs7s2vXLoyNjenVqxcDBw7EwsIiVfuxd+9e2rZty9q1a+nVq1eqtp1effz4keXLlzNv3jzCwsLo3bs3Tk5O5M2bN627lmQajYaLFy/i4uLC7t27CQoKolixYtjb22NnZ0exYsWSFVcVo2JW58Vc+Ct5a4+VegqU+npM3TeKio3KJiuGIPxoxAil8EP4vNP7W6WD1Go1S5cupUSJEly9epVdu3axf//+JCeTz58/p27durx69Qo9PT127tzJnj17cHNzo1ixYpw8cYLfJEutJ5MAg4o11VoyCeDg4MDp06fx9fXVWsyvUalU7Ny5k2rVqlG1alU8PDxYtGgRAQEBLFiwINWTSYA2bdrQu3dvhgwZgre3d6q3n55EREQwf/58ChcuzIQJE+jQoQM+Pj4sW7bsh0omZVnm+vXrjBgxggIFClCnTh0OHz6Mg4MDN2/exNPTk0mTJiU7mQTQN9BngtsIhqzsg6GRQaI36ij+GdUsXsWKtXcXiGRS+KWIEUrhh/DmzRty587NX3/9Rdu2bb94/s6dO/Tp0wd3d3f69u3LrFmz4i22T4zg4GBmzZrFsmXLiI2NpVSpUhw4cICFCxeycuVKTExMGDNmDP379ydjxoxMvbebwy9uaeXUHKWkoEyWAqy06aXVs7cjIiLInTs3Q4cOZerUqVqL+28hISGsXbuWZcuWERAQQP369Rk6dCjNmzdPF8XBw8PDqVChApkyZeLy5csYGPxaO7kjIyNZvXo1s2fPJjg4mO7duzNu3Lhv1vVMjzw9PXFxccHFxQUfHx9y5cpFhw4dsLe3p1q1asmqCpAYgf5B7FtymENrTxIRGvkpuZRlNJpP3/dKfSVq1adNetZVrGg9uDl1O1XXWX8EIb0SCaXwQ5BlmcyZMzN+/HhGjRoV93hERARTpkxhwYIFFCtWjDVr1lCjRo0kxY6MjGTJkiXMmjULtVpNo0aN2Lt3Lz169GDnzp3o6ekxcuRIhgwZEq+Qc2RsDAM81vPwQ0CKkkqlpCB3hiysq+pIdkPtH83m6OjIkSNH8PX11WqC5+npyZIlS9i8eTMajYbOnTszZMgQypQpo7U2tOXGjRtUrVqVESNGMHv27LTuTqqIiopi7dq1zJo1i8DAQLp27cr48eMpXPjHOa3Fz88PV1dXXFxcuHv3LpkzZ6Zt27bY29tTr1499PRSr1BJdGQ0d8895NGNpzy9+4yI0AiUekpy5suOVcUilKxRjILW+VKtP4KQ3oiEUvhhVKxYkQoVKrB27VoAjh07Rr9+/Xj58iUTJkzgzz//TNLoU2xsLJs3b2bSpEm8efOGvn37MmjQIKpXr86HDx8wMDBg8ODB/Pnnn2TLlvDJKWExkfx5cys33/sl6zVJgIVJLpZVciBHBt2cOnLt2jWqVq3KsWPHaNy4cYpi/bfsj5mZGQMGDNBq2R9dmTNnDk5OTpw6dYp69eqldXd0Jjo6mg0bNjBjxgxevXrFH3/8wYQJE7C0tEzrriXK69evcXNzw8XFhatXr2JkZETLli2xt7enadOmOtvIJQhCyogxeeGH8Xmnd2BgIJ07d6Zp06YUKlSIu3fvMm7cuEQnk7Is8/fff1OmTBl69epFrVq1uH37NoUKFaJSpUoEBwfTrl07nj59yqxZsxJMJmNiYli/fj15c5jh2mw0w4r/hr5CiSKRCyuVkgIJiW6F67Cl+kCdJZMANjY2lChRgvXr1yc7RkREBKtXr6ZkyZI0bdqUN2/esGXLFp49e8aECRPSfTIJ8Oeff1K3bl26dOlCSEhIWndH61QqFWvXrqVo0aIMGDCAOnXq8PDhQzZv3pzuk8l3796xbt06GjZsSN68eePqX27fvp3AwEBcXV1p1aqVSCYFIR0Thc2FH4alpSXHjh2jePHiSJLExo0b6datW6KP2AO4dOkSo0aN4vLly3HFjW/evEmjRo14+/YtmTJlonbt2ri6uiZ4f3h4OGvXrmXOnDm8fv0agDJlymBfqAZ1zUrw1/Nr7PF352NsFBISSklC5tNIpEaW0SBjqNDHNm8F2heoSpFMui/PIkkSPXv2xMnJieDg4CTVZAwICGD58uWsWbOG9+/f07p1a1avXk3NmjWT9PeeHnwuJVSmTBn69OnDrl27frjXkBCVSsXWrVuZNm0afn5+dOrUiSNHjiR4Ln168vHjRw4cOICLiwtHjx4lNjaWevXqsXr1atq2bfvVWQFBENIpWRB+AF5eXnLx4sVlQLa3t5cDAwOTdP+DBw/kli1byoBcvnx5+ciRI/KGDRvkggULypIkyV26dJGXL18uA/KFCxcSjDFv3jw5c+bMsiRJMp/KHsuSJMkTJ06Md120WiXfCXkm7/S7LM95sE+eene3PPP+Xnnb0/Py9aAncrgqKtl/D8n15s0bWU9PT16yZEmirr969apsZ2cnK5VK2dTUVB4+fLj89OlTHfcydezevVsG5HXr1qV1V1JEpVLJmzdvlosUKSIDcrt27eS7d++mdbe+KSoqSt63b5/cqVMnOWPGjDIgV61aVV68eLH88uXLtO6eIAgpIBJKIV2LioqSp0yZIhsYGMh58+aVAfn27duJvt/f31/u2bOnrFAoZAsLC3nr1q3y9u3b5aJFi8qA3L59e/nBgweyRqORy5cvL9erV++r/ciaNWtcIvnvX/v379fWy9WpNm3ayGXLlpU1Gk2Cz8fExMiurq5y1apVZUAuUqSIvGTJEjk0NDSVe6p7PXv2lDNmzCh7e3t/8VxYRJR83dtf3nfpvrz7/B35wNUH8gO/13J0jCoNevql2NhYedu2bbKVlZUMyK1atZJv3bqV1t36KpVKJR8/flx2cHCQs2TJIgNymTJl5FmzZv00P6QIgiASSiEdu3DhgmxtbS3r6enJTk5O8rNnz2RA3r1793fvDQkJkUePHi1nyJBBzpEjh+zs7Czv2rVLLl26tAzIzZs3l2/cuBF3/YEDB2RAPn369FdjPn78OG6U9N+/fpSRlYMHD8pAvNcty7IcHBwsz549W86XL58MyPXr15f3798vx8bGplFPdS8sLEy2srKSK1WqJEdHR8sRUTHyngt3ZbvpW+UKfRfK5RP4Van/Irn/kr/kc3efyLFqdar3Wa1Wy66urnFfg7a2tvL169dTvR+JoVar5UuXLskDBw6Uc+XKJQOypaWlPGHCBPnBgwdp3T1BEHRArKEU0p13794xZswY1qxZQ9WqVbl58yalS5eOKx30rSMYo6KiWLZsGTNnziQ6OpqRI0dSsWJFZs2ahbu7O/Xq1ePSpUtUr1497h5Zlpk2bRo1atSgbt26X41taWlJ48aN8fLyinssV65cmJuba+V161qTJk0wNzdnw4YNVKhQAS8vLxYvXvxDlP3RNhMTE7Zv30716tVxHDuLp3JOwiKikaSvH+Gs1si4ez3nysNnFDLLyrTuTSlZKLfO+6rRaNizZw+TJ0/mwYMHNG3alM2bN2NjY6PztpNClmXu3LmDi4sLrq6uPH/+nLx58/LHH39gb29PxYoVf4o1q4IgJEwklEK6Icsybm5uDBkyhIiICJYvX46jo2Nc7URJkr56prdarWbr1q1MnDiRly9f0qdPH5o0acLChQuZPn06VapU4eTJkzRo0OCLe0+cOIG7uztHjx795geem5sbS5YsYeHChejp6TFs2DCqVaumvb8AHdPT06Nr164sX76cR48eceLECczMzBgzZgx9+/b9IXZqa1PpsuVpPngWd8KVSEQD8L0iaup/iln7v31Pt7mu9LWtRs9mNjpJlOR/qhFMmjSJu3fv0qhRI9auXZvuvuYePXoUl0R6eXmRPXv2uILjNWvWFAW+BeEXIRJKIV149uwZ/fv35/Dhw7Rt25YlS5YkeBzcfxNKWZY5fPgwY8aM4f79+3To0IFOnTqxbt06WrduTdmyZTlw4AC//fZbgh/6siwzdepUbGxsvlmj8cGDBzg4OGBnZ8fQoUORJImGDRvGK3SenkVERLBt2zZ27drFx48fefToEZs3b6ZTp06/ZCmWqJhYBi7bw4tIPUBOcln6z4nligOXCY2IYli72lpLKmVZ5uDBg0yaNIlbt25Rr149zp8/T61atbQSXxv8/f3ZuXMnLi4u3Lx5k0yZMtGmTRsWLVpEgwYN0NfXT+suCoKQykRCKaSp2NhYlixZwoQJE8iaNSv79u2jVatWX73eysqKM2fOAHD16lVGjx7N+fPnqVOnDjt27GDXrl20b9+e4sWL4+bmRrt27b45QnL27FkuXbrEgQMHvpoQfPjwgbZt21KoUCHWrl0bd521tXUKXnnqCAgIYMWKFaxevZp3797RunVrTExMyJUrF127dk3r7qWZadtOcNvnJRotnOuw7dRN8uXMQsc6KTu3WZZljh49ysSJE7l+/Tq1atXizJkz31yGkZrevn3Lrl27cHFx4eLFi2TIkAFbW1vGjRtHs2bNMDIySusuCoKQhsRchJBmbty4QZUqVRg5ciS9evXC09Pzm8kkfEooX79+TatWrahWrVpcQeQ8efLQuXNnbt26xaZNm7h37x4dOnT47nTbtGnTKF++PL/99luCz8uyTPfu3Xn9+jV79+7FxMQk2a83Nbm7u/P7779jYWHBsmXL6NatGz4+PuzZs4dhw4Zx6tQp/Pz80rqbaeL0bR+OeHhpJZn8bOHucwS8fZ+se+V/Th+qXr06zZs3x8DAgJMnT3Lu3Lk0TyY/fPjApk2b4tbffj5+dMuWLbx584Zdu3bRtm1bkUwKgiASSiH1ffz4kWHDhmFjY4Narebq1assXryYTJm+fY71y5cv2b17N/ApYVq0aBGVK1fG0dGRc+fOsWLFCry9venWrVuizvi9ePEiZ86cYfz48V8dnZwzZw779u1jy5YtWFlZJf3FpqLY2Fjc3NyoXr06VapU4dq1ayxYsICAgAAWLlwYd4Zz+/btMTY2ZtOmTWnb4TQQo4plxvaTaHvJo1qjYc7OM0m6R5ZlTp8+Ta1atWjSpAmyLHPs2DEuXrxIgwYN0mwDS0REBG5ubrRt2xYzMzMcHByIjo5m+fLlvHr1ikOHDtGlS5cfZrmHIAipQ5zlLaSqgwcPMmDAAN6+fcvkyZMZNmzYd9dbffjwgblz57Jo0SIyZMjAu3fvaNSoEefOnSNz5sw4OTnRt2/fJI+SNGnShJcvX3Lnzp0ERzJPnjxJkyZNGDNmDDNmzEhS7NQUEhLCunXrWLZsGf7+/tSrV4+hQ4fy22+/xW1o+q/evXtz/PhxfH19f6lNE0c9vBi74YhOYkvAvqk9yJ8zy3evPXfuHJMmTeLcuXNUqlSJKVOm0KxZszRLImNiYjhx4gQuLi78/ffffPz4kcqVK2Nvb0/Hjh0TXM8sCILwbyKhFFLFq1evGDJkCLt27aJx48asXLkybsTsa6Kjo1m5ciXTp08nIiICR0dHZFlm8eLFZMiQgfHjxzNkyJBkTUO7u7tTpUoVXF1d6dSp0xfPP3/+nAoVKlCxYkUOHz781cQsLXl5ebFkyRI2b95MbGxsXNmfsmW/v5bvypUrVK9enRMnTtCwYcNU6G360HOBG3eeaGft5H8pFBLdGlViUOuaX73m0qVLTJw4kdOnT1OuXDmmTp2Kra1tmiSSarWa8+fP4+Liwl9//UVISAglS5bE3t6eTp06pfvzvwVBSF9EQinolEajYc2aNYwZMwYDAwOcnZ2xt7f/5geoRqNhx44djB8/Hn9/f7p06UL27NlZt24darWazJkzx23CSa4WLVrw+PFjHjx48EWyGBUVRa1atXj79i03btxI0tnXuibLMidOnMDZ2ZkjR45gZmZG//79cXR0xMws8eeCy7JMiRIlKFeuHC4uLjrscfqhUqupMWQZsWqNztooY2HOplF2Xzx+9epVJk2axPHjxylTpgyTJ0+mdevWqZ5IyrKMu7s7Li4uuLm58erVKywsLLCzs8Pe3p7SpUunan8EQfh5iF3egs48ePCAPn36cPnyZRwcHJg3bx7ZsmX76vWf15CNGTOGO3fu0LJlS9q3b8/GjRsJDw9nwIABjB49muHDh6doQ8mtW7c4ePAgW7ZsSXDkcdCgQdy7d49Lly6lm2Tyc9mfxYsX8/DhQ8qVK5eisj+SJOHg4MCECRMICQn55r/Lz+Lpy2CdJpMA3gGBqDUalP8sI/Dw8GDSpEkcOXKEokWLsnPnTtq3b5/qywzu3buHq6srrq6uPH36lNy5c9OpUyfs7e2xsdFNHU1BEH4tv87iKSHVREVFMWHCBMqXL09QUBBnzpxh/fr130xaPDw8aNCgAc2aNcPY2Jhhw4Zx7do1Fi9eTMeOHXny5AkLFiwgV65cXy1unljTp0+nSJEi2Nvbf/Hc+vXrWbduHStWrKBixYrJbkNbXrx4wdixY8mfPz99+/alWLFinDt3jps3b9K1a9cU1ZDs2rUrsbGxv8wI5auQMJ23Ea1S8+FjFLdu3aJly5bY2Nhw8+ZNihQpwqNHj9DT00u1ZPLJkyfMmDGDUqVKUaZMGVauXEmDBg04ffo0AQEBODs7U6VKFZFMCoKgFWKEUtCqM2fO4OjoiJ+fH05OTjg5OZEhQ4avXv/48WPGjRvHrl27KFmyJIMGDWLfvn1cvXqVLl26MGnSJCwsLOLdY2VlRWBgIKGhoUneaXrv3j327NnD+vXrv9gJfv36dQYMGECfPn1wcHBIUlxtc3d3x9nZmV27dmFkZESvXr0YOHDgd9edJoWZmRm2trasX7+eAQMGaC1uehWrVqdKO9169ODgHjdMTEzQ09MjMDCQwMBAAJ2vxX358iU7d+7E1dUVd3d3jI2Nad26NbNnz6Zx48YYGBjotH1BEH5dYoRS0Irg4GB69OhB/fr1MTMz4/bt20yZMuWryeTr168ZMGAAJUqU4MqVK/Tp04eoqCiWLl1KtWrVuH//Pps2bfoimQTiNgv4+PgkuZ8zZsygYMGCdOnSJd7jQUFBtGvXjjJlyrBkyZIkx9WGxJb90SYHBwdu3brFrVu3tB47vTEyTJ1k6viRw8Cn8lixsbHIssznpeo+Pj54eHjw8uVLYmNjtdJecHAwq1evpl69euTLl48xY8aQN29edu7cSWBgINu2bcPW1lYkk4Ig6JQYoRRSRJZltm/fzrBhw4iNjWXNmjX07Nnzq9N6YWFhzJ8/nwULFqCvr8/vv//O9evXWbNmDba2tuzevZty5cp9s83P9SAfP35MhQoVEt1XLy8v3NzcWLFiRbxSRWq1Gnt7eyIiIvjrr79S/SjCd+/esXbt2nhlf/7+++9vlv3RlubNm5M7d242btxI+fLlddpWWitirvv1sEZ6EsuXLGLEiBGEhYXx3z2PI0eOjPu9QqEgd+7c5MmThzx58pA3b94E/581a9YvpqXDwsL4+++/cXFx4fjx48iyTIMGDdiwYQNt2rQhc+bMOn+tgiAI/yYSSiHZnjx5Qr9+/Thx4gSdOnXC2dmZ3LlzJ3htTEwMq1evZtq0aYSGhtKyZUseP37Mli1baNCgAevXr6dq1aqJajdr1qxkz549yesoZ86cSZ48eejRo0e8xydMmMDp06c5ceIE+fPnT1LMlEhJ2R9t0dPTo2vXrqxdu5a5c+d+c3nCj84sqwmmGQ0JjYjWSXxJApsSFvTq1Qo7OzsmTpyIs7MzCoUCtVqNQqHA39+fN2/e8OLFC16+fBn3/5cvX3L58mVevnzJ27dv48XNkCEDefLkIXfu3EiSRGBgIL6+vsTGxlK6dGnGjRtH9+7dKVSokE5el6BdH9+H4+3hw+MbT3ntG4g6Vk0G4wwULJkfq4qFsSxXCKVe+itTJgjfI8oGCUmmUqlYsGABU6ZMwczMjJUrV9KsWbMEr9VoNOzcuZPx48fj5+dH06ZNCQoKwt3dnWrVqjFjxgzq1auX5D5UrVqV/PnzM2jQIPz8/GjUqBHm5uZfvd7Hx4dixYrh7OzMoEGD4h7ft28fbdq0Yc6cOYwaNSrJ/Uiq/5b9yZUrF/3796dv375JKvujTV5eXlhbW3+1JufPZMrW4xy8+hC1RjdvexP/aETrGqXi/nz9+nV69OjB/fv3yZUrF2/evPlujOjoaF6/fs3Lly959uwZ586d48KFC3h7exMbGxs3gh4dHT8xzpIlS7yRzYRGO3Pnzp2oU6QE7fP28GHv0sOc23mZWJUahVIRN/IsSRAbqwYZspplpmX/pvzm2IisucRIs/DjEAmlkCRXr16lT58+PHjwgGHDhjFlyhSMjY0TvPbkyZOMHj2amzdvUrt2bWJjY7l8+TLly5dn+vTpST4Z5NWrV4wYMYK7d+/i5eWF+l+bLBYtWsTQoUPjXf/333+TJ08eKleuTM+ePTl06BC+vr5xJ+o8evSIypUr07BhQ3bv3q3T3a4Jlf0ZOnQodnZ2qT7FnpCaNWtibGzMsWPH0rorOuX5/A2dZyW/fum3ZDTU58RcR4wM4p/8pFKpWLp0KQDDhw//bhyNRsPFixdxdXVl165dBAUFUaxYMezt7bGzs6NYsWLAp2nv/45yJjTyqVKp4mJLkoSZmdk3p9jz5MlD9uzZxe5vLQkPjWDNn1s5vPYkSj0F6tjvl65SKCQMjQ0ZtKwXDf+oLf4thB+CSCiFRAkNDWXs2LGsWLGCChUqsGbNmq+uX7x58yZjxozhxIkTlC1blkyZMnHx4kWsra2ZNm0abdq0SVbpFG9vb0qUKIFG8+Ub8v379ylZsmS8x4yNjYmIiKBmzZpcuXKFOXPmMGLECODThokqVaqg0Wi4du2azs4lfvHiBcuXL2f16tW8e/eOVq1aMXToUGrXTl8fEhs2bKBXr174+vpSsGDBtO6OTvVdvJsbjwK0OkopAb1/q0pf22rJul+WZW7evImLiws7d+4kICCAAgUKxBUcL1u2bLK+XjQaDcHBwd9NPAMDA+Ot9zQwMPhqsvnvx772w6TwScCjl4xqNJXgFyFokvr1JgEy1O1UnVGbB6Jv8O0jagUhrYmEUviuvXv3MmjQIN6/f8/06dMZOHBggtNmT58+Zfz48bi4uFC4cGHy5MnDxYsXKVy4MJMnT+b3339P8SaTiRMnMn369HgfflZWVjx69OiLa42MjIiKikKSJGRZpmbNmkyfPp3atWtjb2/PoUOHcHd3x9raOkV9Soi7uzuLFy/Gzc0NIyMjevbsyaBBg3SyU1sbwsLCMDc3Z9SoUUycODGtu6NTL4NDaTdlM9Eq7eyyVigkCubKiuu4P9BP4to3T09PXFxccHV15fHjx+TKlYuOHTtiZ2dHtWrVUq1mpUqliptmT2iU8/PvP3z4EO8+U1PT7452mpubx9sE96t44fOKIdXHEfY+HE0iRiW/RlJIVLWtyKTdI8XaSiFdEwml8FUBAQFxdSFtbW1Zvnw5BQoU+OK6wMBApk+fzqpVq8iWLRuWlpZcvnyZvHnzMmHCBHr06KG1DxSVSoWNjQ337t2L2+gwYcIEJk+e/MW1JiYmhIeHx/35c2LZt29fVq1axa5du2jfvr1W+gWfyv7s3bsXZ2dnLl++TOHChRk8eDA9evTQ2QioNvXs2ZPTp0/z5MmTVD/JJbUddvdk/MajKY6jkCQM9JVs+tOOovlyJuoePz+/uFNr7ty5Q+bMmWnXrh12dnbUq1cvXa9xDA8P/+b0+uff/3t9pyRJ5MyZ87ujndmzZ/9pvu5iolX0LTeSl09eJ2qK+3skCTqPb0+3KT/3GmfhxyYSSuELarWaFStWMG7cOIyNjVm6dCnt2rX7Ysrt48ePLFy4kHnz5qFQKChRogTXr18nW7ZsjB07FkdHR53sGvby8qJs2bLExMQACU93A2TKlImPHz/Ge6xGjRpcvXqVYcOGMW/ePK305927d6xbt46lS5fi7+9P3bp1GTp0KLa2tjov+6NNly5dombNmpw6dYr69eundXd0bte5O8xyPY0kQXLeBZUKCQM9PZYObE0Fq3zfvPb169fs2rULFxcXrly5gpGRES1btsTe3p6mTZumi3W02iLLMiEhId9NOt+8eRNv+Yq+vj7m5ubfHO3MmzcvmTJlSsNXlzgbx7vgMmvvF2WjUkKhVLDcfTaW5b+szSsI6YFIKIV47ty5Q58+fXB3d6dv377MmjWLLFmyxLtGpVKxbt06pkyZwrt37yhdujT379/HyMiIUaNGMWjQIExMTHTaz2XLljFo0CCyZctGcHBwgteYmpoSFhaGJEkoFArGjx/PqlWrKFGiBMePH0/xSJC3tzdLlixh06ZNxMbG8vvvvzNkyJDv1tFMr2RZxtramooVK7J9+/a07k6qOHDxFtO3nyJGIyElYXRMAizz5mBGj2ZY5s2R4DXv3r1jz549uLi4cObMGZRKJU2bNsXe3p4WLVro/HskvYuNjY1XQimhBPTFixe8f/8+3n0mJibfHe00NzdPs0LuQS9D6FywHxotnxuvUCooXcua+acnazWuIGiLSCgF4NMu5ClTprBgwQKKFSvGmjVrqFGjRrxrZFlm9+7djB07lidPnlC6dGl8fHxQKBQMGzaM4cOHf5F86opGo6FixYpUq1mbSVOno1BIZDE2ireGLUOGDERHR5MrVy7c3NxwcnLC39+fGzdukCtXrmS1K8syJ0+exNnZmcOHD6eLsj/aNHfuXCZOnMirV6/ImjVrWndHZ4KCgpg/fz7Lli1DL4MxdbsM5ZUqI7FqDZIkoUngbVGpkFBrZDIbZ6BMTj0Gd2hIkcLxR4vCw8PZv38/Li4uHD16FLVaTb169bCzs6Nt27bfPM9eSFhERASvXr1KMNn89/+joqLi3ZcjR47vjnbmzJlT69PsW6fsYtu03QluHtSG9Q+dKVA8r05iC0JKiIRS4NixY/Tr14+XL18yYcIE/vzzzy9+uj9z5gyjR4/Gw8ODYsWKxZUjGThwIKNGjSJnzsStH0spVaya07d9OHXzMXd9XxH4/v9T2noKBYXNs1HBKh+tqpekQnELzM3NuXLlClOnTmX16tVcuHCBKlWqJLndyMhItm3bhrOzMw8fPqRs2bIMGzYs3ZT90ZZXr16RP39+li5dSr9+/dK6O1oXEhLCwoULWbx4MbIsM2TIEIYPH0727NkJDY/isLsn1x8FcN/vddzXliRBgZxZKG1hTo2SFtQvb0kGQwP09fX5+++/qVu3LkePHsXV1ZX9+/cTERFB1apVsbe3p2PHjl8t9i9ojyzLvH///qvJ5uffv379Ol6ip6enh7m5+XdPKzI1NU30Lnv7/I4EvQjRyetU6inoMKIlPWd11kl8QUgJkVD+wgIDAxk2bBg7duygXr16rFq1iqJFi8a75s6dO4wZM4ajR49SoEABQkNDCQ8Pp3fv3owbN448efKkSl81Ghm3c7dZc/ga7z9GovjKKBL8fySpRIFcjP29ATcvnKRLly6sXLmSvn37fnF9ZGQkL1++pEiRIl889+LFC1asWMHq1asJCQlJt2V/tKlly5a8fPmS69evp3VXtOb9+/csWrQIZ2dnYmNjGThwICNHjvzqD0KyLFO1WnUaNGzIjGlTv/i3/jz6DZ9K7MTExFCmTBns7e3p1KlTgmfQC2lPrVbz5s2b75ZRCgmJnxBmzJgxUdPskR+i6GjeW6evoXRtaxaenarTNgQhOURC+QuSZZmNGzcycuRIJEliwYIFdOvWLd6Hpp+fHxMnTmTbtm3kzJmT2NhY3r17R/fu3Zk4cWKqHvP2MvgD4zYc4c7TV0m6T6n4lHS+vXOW+kWzsXHDhi8Sg5iYGBo2bIiHhwf+/v7kyPFpPZyHhwfOzs7xyv4MHDgwwaTzZ/P333/TunVrbt++narHQOpCaGgoixcvZsGCBURHR9O/f39GjRr13eUJR44coXnz5piYmPDu3Tv09PTQaDRcvXoVFxcXli9fHrfhQpIkChcuzP79+ylRokRqvCxBxyIjI+NNs39tqj0yMjLefRaZrCjyUbffMxmMDdkfuvWn/YFW+HGJhPIX4+3tTd++fTl79ixdunRhwYIF8UZpgoKCmDlzJsuXL8fIyAh9fX2CgoKws7Nj8uTJcad0pBbf1yH0WuBGaERU8gtRyzJ1yhRmrmML9P+161qWZRwdHVm3bh2SJDFlypS44xkvX76MhYUFgwcPxsHB4Yco+6MtKpWKfPnyYW9vj7Ozc1p3J1nCwsJYunQp8+fPJyIigr59+zJ69OhvHs/5mVqtplSpUnh5eQEwe/ZsQkJCcHV15fnz5+TNm5d3794RERERd49CoUBPT4/Tp09/sfZY+DnJssyHDx/iJZnX99/Fa+9znbd9KGI7BhnSZtORIHyNSCh/EdHR0cyZM4cZM2aQP39+Vq5cSaNGjeKeDw8PZ/HixcyZMweVSoWJiQlv376lZcuWTJs2jTJlyqR6n4M+hGM/YxvvwyNTfKqJJMFvVayZ2q1p3GNLlixhyJAhcX9WKBRoNBrq1KnD0KFDadGixQ9V9keb/vzzTzZs2MDLly9/qDWi4eHhLF++nLlz5xIWFkbv3r1xcnIib97Eb2LYsGEDPXv2jPdYtmzZ6NixI/b29tSsWZOCBQsSEBAQ75qCBQty6NChBEtYCb+GoxtOs6DXSp23c+DjNjJk/HG+L4Vfw89RRVb4posXL1K+fHmmTZvGiBEjuHfvXlwyGRsby5o1a7CysmLSpEkYGhoSGRlJuXLluHbtGn///XeaJJOyLDNt+wmtJJOf4sHBq56cvPnpRJ2jR49+cfa3RqNhxowZnD17ltatW/+yySSAg4MDISEh7N+/P627kigREREsWLAACwsLxo8fT4cOHfDx8WHZsmWJTib9/f2ZOXMmjo6OXzy3a9cuVq5cSe3atVEoFHGb1j5POw4dOpTHjx+LZPIXZ5JV90dR6ukrMcjw6508JKR/IqH8ib179w5HR0dq1apF5syZuXnzJjNnzsTIyAhZltm7dy+lSpXC0dERlUpFbGwsRYsW5ezZsxw/fhwbG5s06/uJm4+4cM9Xu+ctSzB9+0nOnL+Era3tF0WHJUli165dWi1G/KOytramWrVqbNiwIa278k2RkZEsXryYwoULM2bMGFq3bs3jx49ZuXIl+fPn/+79b9++ZcWKFdSqVYsCBQowceJEYmPjH8moUChYuHBhvMfMzMwwNTVl1qxZVKpUicuXL6frE26E1FGkXCGdt2FRusBPc6KQ8HMRX5U/IVmW2blzJ9bW1nEbCC5evEjp0qUBuHDhAtWrV6dt27a8ffsW+DRdd+TIES5cuECdOnXSsvvIssz6I+5oe825LENYRDT7Lt5FX18fIyOjeEmALMvcvXuX0NBQ7Tb8g3JwcODYsWP4+/undVe+EB0dzbJly7C0tGTEiBE0b94cb29v1qxZQ8GCBb9574cPH9i0aRNNmjTB3NycIUOGkClTJrZs2YKtre0X12s0Go4cOYJarY577ODBgwQEBDB69Gjmzp2Lu7s7+/bt0/bLFH4wuQvlwjhzRp3FV+opKV6l6PcvFIQ0IBLKn8yzZ8+wtbXFzs6OGjVq4OnpSf/+/VEqldy/f58WLVpQu3ZtPD09ATA3N2fPnj14eHjQtGnTdLFz8MGzNzx+EZSs4/AS42mkIREREURERKBSqYiOjiYoKAhfX1/8/f3JnDmzbhr+wXTq1AkjIyM2b96c1l2JExMTw6pVq7C0tGTIkCE0bNgQLy8vNmzYQOHChb96X0REBG5ubrRt2xYzMzMcHByIjo5m+fLlvHr1isOHD9OlSxf27NnDx48fuX37NgCrVq3Cw8MDLy+veEsgsmXLFncEYL169WjUqBHjxo2Ll3QKvx5Jkqj/ey2Uerr5aFXHqqlvLzZ9CemTSCh/ErGxsSxcuJASJUpw584d9u3bx19//UXevHnx9/fHwcGBsmXLcubMGeDTKRLbt2/nzp07tGnTJl0kkp9duu+LUqGb/sjAi6APvAj6EPeYgYEB2bNnp1ChQqlWV/NHkClTJjp27MjGjRt1dupHYn0+7tPKyor+/ftTu3ZtHj58yObNm7G0tEzwnpiYGA4dOsQff/yBmZkZnTp1IiAggJkzZ+Lv78/Zs2dxdHSMKxUFn6a3jY2NMTIyAqB48eJUqlQJKyurb/Zv5syZeHp6snXrVu29aOGH1KJfY9Sx2v9+kSSJAtZ5KVmjuNZjC4I2iITyJ3Djxg2qVKnCyJEj6dWrF56enrRq1YqQkBBGjRqFpaUlLi4uyLJM1qxZWbduHZ6envz+++/pcuPJg2dvvlq0XFs8nwfqNP7PwsHBgadPn3Lu3Lk0aT82NpaNGzdSrFgxevfuTbVq1bh//z7bt29PsISVWq3mzJkz9OnTB3Nzc2xtbbl16xajR4/m8ePHuLu7M3z48O9u1PlcEsjYOHGbLCpVqkT79u2ZNGlSXMFz4ddkUaoAdTtVR6HU7serLMv0nNk5Xf3wLwj/JhLKH9jHjx8ZPnw4NjY2qNVqrl69yuLFi9HT02Pu3LkULlyYRYsWoVKpyJQpE4sXL8bHx4eePXuir59+dwn66HC6G0CpUPD0VbDuGviJ1KxZEysrq1TfnBMbG8vWrVuxtrbGwcGBChUqcPfuXVxdXb8oHi7LMteuXWPo0KHkz5+f+vXrc+LECRwdHbl79y73799n/PjxXx3JTMjnhDJjxsSvh5s2bRoBAQGsWrUq0fcIP6eBS3tinDkjkpZmWhRKBfXsa1K9VWWtxBMEXRDbEn9QBw8eZMCAAbx9+5ZZs2YxbNgwFAoFGzZsYPz48bx58wYAU1NTnJycGDhwYJI+HNNSlCr2+xelgCTpvo2fhSRJODg4MG3WXJocv8bTN6Hcf/aa92GRyMhkNTGiZKHclCyUmwblrchqYpSi9tRqNTt37mTKlCk8evSIVq1asWvXLsqVK/fFtffu3cPFxQVXV1d8fX3JnTs3nTp1ws7OjipVqqRoJCc5CWXx4sXp0aMHM2bMwMHBIW6NpfDryZzDlAluw3FqOgMNGuQUVKtQKBXkK2rO4OW9tNhDQdA+MUL5g3n16hUdO3akRYsWFC9enPv37/Pnn39y5MgRSpYsSc+ePQkMDMTIyIiJEyfi5+fHqFGjfphkEkBfy1NFCbeR/qb606MXQR8IzlwMq05OLNx7mQNXH+LzIoig0HCCQyPweRnMwasPmbXjFE3GrGHCpqP4v33/zZhhYWFUrlw53ik8Go0GNzc3SpcuTefOnSlatCjXr19n37598ZLJJ0+eMGPGDEqVKkWZMmVYtWoVDRo04NSpUwQEBODs7EzVqlVTPC2YnIQSYNKkSYSGhrJo0aIUtS/8+MrXL820/aPR01eiSOYmHUnxad3k/DNTMMmi+xqXgpASIqH8QWg0GlatWoW1tTVnz55l+/btHD16lNevX1OjRg1atWrFkydPMDQ0ZMSIETx79oxJkyb9kDuW8+fKotP4sWoN+XL+eH8vqUmWZdzO3aH91M2cvf8MhfLTZIY6gc05ao2MzKe/16MeXnSYugXXM7fQJDAq8/m4y+vXrzNu3DiCgoL466+/KFu2LJ06daJgwYJcu3aNAwcOULFiRQBevHjBokWLsLGxwdLSklmzZlG2bFkOHDjA69evWbt2LfXr19fqeuDw8HAg6Qll/vz5GTBgAPPnzycoKEhr/RF+TJWblmflzXkUKVMIINGl0D6vv2w1oClLrswkay7xfiWkfyKh/AE8ePCAWrVq0a9fP9q1a4eXlxfly5enVatW1KhRA3d3d/T09Ojbty9+fn7MmTOH7Nmzp3W3k61Uodzo6bhwr3UBM53G/5GpNRombznObNfTRKvUSSour9bIxMSqmet2lvGbjhCrjp+Abtq0CRcXF+BTUfJChQrRvn17zM3NuXz5MkeOHMHGxobg4GBWr15N3bp1yZ8/P2PGjCFv3rzs3LmTN2/esH37dmxtbeNOrNG2zyOUn3d7J4WTkxPw6QxwQShonY+lV2cyeEVv8lp9OkteoVR8sb5SqacE6dMyE5vm5XG+OJ0Bix0wMs6QFt0WhCQTayjTsaioKGbMmMGcOXOwsLDgzJkzWFlZ8eeff7Jx40YUCgWSJNG9e3cmTpxIgQIF0rrLWlGpaH62nLihs/imGQ2xyJ1NZ/F/ZLIsM2P7KQ5efZjiWMc8vFEqFEzt1gRJknj48CH9+vWL11Z4eDjr16/HwcGBsLAwtm7diqurK8ePH0ej0dCwYUPWr19PmzZtyJIlS4r7lFgREREYGhoma9QzR44cjBgxglmzZjFkyJBEndgj/NyUekpa9G2MrWMjHlz25v4FTx7deMKLx6+JjYnFKFMGipQthFXFItg0K0euAjnTusuCkGSSLM6ZS5fOnDmDo6Mjfn5+ODk50a9fPxYtWsSiRYtQq9VoNBo6derEtGnTvlsj70ej1mj4bdx6At9/1HpshUKie+PKDGwligMn5Ii7F+M2HtFqzCldG1O/TCGKFy9OQEDAF8+XLFkSa2trDh48SFRUFDVq1MDe3p4OHTqQK1curfYlsebMmcPcuXMJDk5eNYCwsDAKFy5M69atWbt2kIqDbQAAG85JREFUrZZ7JwiCkP6IKe90Jjg4mB49elC/fn3MzMy4du0apqamWFlZMW/ePFQqFc2bN+fevXu4urr+dMkkfCrr07lBBa0fvQigQKJdrdLaD/wTCA4NZ5bLKbT51y4Bc3aeoVuvvgkmk/BpSceTJ0+YOnUqfn5+XLx4kQEDBqRZMgmfRihTspEtU6ZMjBs3jg0bNuDt7a3FngmCIKRPYso7nZBlme3btzNs2DBiY2NZtWoVBgYGNGnSJO687bp16zJv3jwqVaqUxr3VPbu65dh/+QF+b0KStIbve/q3rI55NlOtxfuZ7Dx7h4gYFdqcspD5VKKpZIN2fHz3lmPHjiV4nYuLS4KFytNKShNKgL59+7Jo0SImTJiAm5ublnomCIKQPokRynTgyZMnNGnShC5dutCgQQOWLl3KnDlzcHBw4O3bt1SqVInz589z5syZXyKZBNDXUzLDoRkKSdLKSKVSIVGyoBl/NKyY8mA/IVWsml3n7yS4MzulNBqZsw9fcvvuvbjHJElCX18/rrzP54066YU2EsoMGTIwefJkdu3axY0bulsTLAiCkB6IhDKVqFQq/rtcVaVSMXv2bEqVKsWjR49YuHAhjx49okuXLvj6+mJtbc3x48dxd3enVq1aadTztFM0X07mO7ZAISlSlFQqFRL5c2VlycA26KVCjcsf0S2fF3wIj9JZ/LDIaFwPneHevXscOHAAZ2dnBgwYgK2tLcWLFydbtvS1SUobCSVAly5dKF68OGPHjtVCrwRBENIvMeX9HbLmI6geQOwDZPVrQAOSCZJ+MdArBcp83y2irFKpsLGxoVixYri6ugJw9epV+vTpw4MHD+jevTtPnz5l+PDhABQsWBBnZ2datWr1y5/bWqt0YZYPasOY9YcJjYhK1ghaBat8zO1tS2ZRfuOrHj5/g0KSdHaGulIh4fP6HXWbVaFUqVI6aUObwsPDtZJQ6unpMWPGDNq1a8eZM2eoV6+eFnonCIKQ/oiE8ivkmDvIEdsg6hAQy6fB3P+Pbsn8c3SfXlHI2BWMWiBJCdesW7JkCbdv3+b27dsEBARQrlw5VqxYQenSpWnQoAEbN25ElmVy587NggULsLOzQ6HjOow/EpviBdg7uTtzd57hiIcXCoX0zcRSkkCWIaOhPsPb16FNjVK/fGL+PY8Dgj7toNFRzQdZhscBb3UTXAe0NUIJ0KZNGypXroyTkxNXrlwRX4uCIPyURNmg/5A1H5BDp0PU34ASUH/njn8+hRV5kLLMRTKwiffsixcvsLKyIjIyMu6xDBkyUKlSJS5fvoxGoyFr1qzMnj0bBwcH9PREjv8tzwPf89eFuxz18OLth/AvnlcqJIrmy0m7WmVoVrk4Rob6adDLH8/g5fu4eN9Xp21UKV6AlUPa6bQNbalfvz65c+dmx44dWol36tQpGjZsyL59+2jVqpVWYgqCIKQnInv5F1n1EPldT9C8++eR7yWTEDeko3mNHPIHsvFAJJNBcaMQQ4cOJSoq/tq0qKgoLl68iLGxMZMnT2bw4ME6O/HjZ1MgVxaGtavNsHa1efcxkscBb/kYFYNSksiZxRjLPDkw0Bdf1kmlVOh+1Cw12tAWbY5QAjRo0IAGDRowbtw4bG1ttXpMpCAIQnogPnn/Ias8kUM6gxwFfHle8ff9c0/4MmRikDKN5MiRI+zevTvBq1u2bImLi4tWP7R+NVlNjLAp/nOcDpTWcmY2QU+p+OKoRG1RKhTkypIp3mMqlYqHDx9y48YNcuXKha2trU7aTg5tJ5QAM2fOpEqVKmzfvp2uXbtqNbYgCEJaEwklIGvCkN/1+ieZTMyo5HeEr0HWK0bHjr9/9RJ3d3eRTArphnWBXOy+oJtkEkCj0WCe2YBJkyYRGBiIu7s79+7dQ6VSAVC6dOmfPqG0sbGhbdu2TJo0iU6dOmFoaKjV+IIgCGlJJJSAHDoLNMEkb2QyIRJy6CTy5zXC0zvh4wNfv35NWFgYmTJlSvB5QUhNZQqb6zS+DOzbupbDu7d/8ZxSqUx3u591kVACTJ8+nVKlSrFmzRoGDRqk9fiCIAhp5ZdPKGWVJ0QlPC2dgqggR7Jve0PqtTyHpaUlmTJlQl9fH0NDQwwNDbGwsMDIKOFd4YKQ2orkyUHx/Ll4FPBW66WDJAmKmOdgw7xV/Bboz/nz5+M9r1arefr0KQcOHKBu3brp4ocsXSWU1tbWdOvWjenTp9OjRw9MTEy03oYgCEJaEAllxA4St5s7qdRY5r1HgL8XkiLtPyAF4Xt+r1+eiZsTPhoxJWQZ7OuVw8TEhNOnTzNo0CBWrlwZ97wkSdy9e5eWLVuip6dH9erVady4MY0bN6ZChQppsoElIiICY2NjncSePHky27dvZ/HixYwbN04nbQiCIKS2X7rYoSzHQOQ+tJ9MfhYDUUd0FFsQtKuZTXFKFDTT6m5spUKiWL6ctKhW8tOflUqWL1/OjBkz4q6pWbMmfn5+PH78mMWLF5M1a1bmzJmDjY0NuXLlomPHjqxbt47nz59rrV/folKpUKlUOlvjXKBAAfr168fcuXMJDg7WSRuCIAip7ZdOKIn1BqJ12IASWXVbh/EFQXuUCgXTujf9dH66FuJJgITEtO5N4x15KUkSY8eOZePGjSiVyrgToSwtLenfvz/79u0jODiYixcvMnDgQPz9/XF0dKRgwYIUL16cwYMHc/DgQT5+THh9ckpFREQA6HTT3NixY9FoNMyZM0dnbQiCIKSmX7qwuRzhihw6CZ0dDwKgtESR87Du4guClp2984SRqw8gy3KyvzOkf/4zt5ctDSpYffW6gIAAzM3Nvzut/e7dO06fPs3x48c5duwYz549Q19fP970ePny5bUyPf7q1Svy5MnDwYMH+e2331Ic72smTZrE3Llz8fHxIW/evDprRxAEITX82gnlx6XIH1fC52MUdUHKjMLMQ3fxBUEHzt19wph1h4lVq1En8fx0pUJCT6lghkNz6pez1HrfZFnGx8eH48ePc/z4cU6fPs3Hjx/Jnj07DRo0iEsw8+fPn6z4T548wdLSktOnT+t093loaCiFCxemXbt2rF69WmftCIIgpIZfOqHUhC2G8NXoNqHMhMLshu7iC4KOvAwOZfKW41x/5I9SIX03sfx8TXnLvEzt1oS8OTKnSj9VKhXXrl2LSzA9PDzQaDQUL148LrmsU6dOondU37t3jzJlynD16lWqVKmi074vXLiQUaNG4enpiZXV10dyBUEQ0rtfOqGUwzcgh81Fe/UnE6AwR5HrnO7iC4IOybLMVc/n7Dx7mwv3nyLLoJAkFP9s3NHIMhqNjATUKGVBpzplqVaiUNzzaSEkJCRuevz48eNx0+M1atSINz2uUCS8hPzatWtUrVqVu3fvUrp0aZ32NSoqCisrK2rUqIGrq6tO2xIEQdClXzuhjL6M/K67DltQgGFDFFmX6bANQUgdoeFRePoH4vU8kA/hkchAZuMMWOfPRfECZmQ2zpDWXfyCLMs8fvyYEydOfDE93rBhQxo3bkyjRo3iTY+fOXOG+vXr8+TJEwoXLqzzPq5fv55evXpx8+ZNypcvr/P2BEEQdOHXTig1H5ADK+uwBQWSyTAkE0cdtiEIQmKpVCquXr0ab3pclmWsra3jRi8jIyNp3749r169Infu3DrvU2xsLKVKlaJw4cIcPiw28AmC8GP6pRNKAE1Id4i5hq5qUUo5TiDpFdRJbEEQUiYkJIRTp07FJZjPnz9HqVSiVquZNGkSLVq0+Ob0uLbs2rWLjh07cu7cOWrXrq3TtgRBEHThl08o5aiTyO/76yCyEgyqoMi2SQexBUHQNlmWefToEdOmTWP79u0YGxsTHh5Ojhw54k2P58uXTydtV65cGUNDQy5evIgkpd0aVEEQhOT4tQubAxjWAz1rPh2/qE0aJJPBWo4pCIKuSJJEsWLFqF69Ovr6+oSEhHDu3Dn69OnDkydP6NmzJ/nz56dkyZIMGzaMI0eOEB4errW2Z86cyeXLlzl48KBWYgqCIKSmX36EEkBWPUYOboX2ygdJkLE7ClMnLcUTBCG1zJ8/n+nTp/P+/ft4jwcHB8ebHvf398fAwICaNWvSqFEjGjduTLly5ZI9PS7LMg0aNCAoKIjbt2/rfJpdEARBm0RC+Q85wg05dLwWIilBvzRSti1IUvrb9SoIwrdNnTqVVatW8fLly69e83l6/HNyeebMmbjp8c/JZaNGjZJ8As7Vq1epVq0a27Zto3Pnzil9KYmm0WhQRatQ6inR09dLtXYFQfh5iITyX+TwbchhU/m0EiA5tSkl0C+LlHU9kiKTlnsnCEJqGDNmDH/99RePHz9O9D0xMTFcuXIlLsG8ceMGsixTsmTJuN3jtWvXTtT54K1bt+bu3bt4eXlhYGCQkpfyVepYNZf3X+fqwet4XnnEi8ev0PxTuD5zTlOK21hRtm5JGnWtTZacqVOgXhCEH5tIKP9Djr6M/GE0aN6S+KRS+ela415IJoORJEMd9lAQBF0aPHgw586d486dO8mO8e/p8WPHjhEQEBA3Pf45wSxbtmyC09oPHjygdOnSLFu2jP79tbthUK1W8/eyo7jO3su7Nx9Q6ilQx375Pif9U5heoVBQz74Gvef8QbbcWbXaF0EQfi4ioUyArPmIHL4eIraD/B7Q48v1lf8kkQCG9ZBM+iPpl0nVfgqCoH29evXiwYMHXLlyRSvxZFnG29s73vR4REQEOXPmjDc9nidPnrh7unXrxrFjx3jy5AnGxsZa6ccLn1fM7rIEr2s+SbpPoafAyDgDQ1b2oZ5dDa30RRCEn49IKL9BlmMg+ixyzC1Q3QXNK5BjQZEJ9Eoh6ZeEDI2QlOZp3VVBELTE3t6ewMBATp06pZP40dHRcdPjJ06ciJseL1WqVFxyWbBgQcqWLcuUKVNwckr55r7HN5/yZ8MpRH2MSnBE8nskSUKWZXpMt+f3sW1T3B9BEH4+IqEUBEH4l1atWqHRaDhw4ECqtBcUFBRv9/jn6fFcuXIRHBzM0aNHqVmzZrJ3fb/wecWAymOI/BiFRp2cteHxDVjiQOuBzVIcRxCEn4tIKAVBEP6lUaNGZMuWjZ07d6Z627Is4+XlxfHjxzlw4EDcKGmuXLniTY+bmyduVkStVjOkxnge33yKJhkjkwlR6ilZdWsehUrm//7FgiD8MkShM0EQhH+JiIhI1G5sXZAkCWtra4YMGcLJkycZM2YMhoaGdOzYES8vL7p160aePHkoU6YMI0aM4NixY0RERHw13t/LjuLt7qO1ZBI+Jb1zui5FjEUIgvBvIqEUBEH4l7RMKP9rzJgxGP+vvXsNjqq84zj+O2d3EyACBS0aBQ0h3EQuAoqKIhhTY5CmFm3lMiqCMkVRwCImIZWmQArpTLWglrZUC0bGOtNOUUZp6gXEWAuIUapQFS8gZYIXUHY3MXvpi2wYtBASzznZPSffz0v2mf/zhxdnfjzPc56TkaFIJKJt27aptrZW69at08iRI/XEE08oPz9f3bt3V15enioqKlRTU3M06EUaIlpX/lfbe4pFY3p3x/va8fxO22sDcC+2vAHgGP3791dhYaGWL1+e7FYkSRUVFSouLtauXbvUp0+fo38ej8f19ttvHz17uWnTJoVCIZ1++unKy8tT/+7nadOKbY705PObGjV+hH7+13scqQ/AfQiUAHCMXr16afr06Vq0aFGyW5EkhcNh5eTkaOzYsaqsrDzhuPr6elVXVx8NmHWvmTrTzJIcesL70/x6+shj8vl9zkwAwFXY8gaAY6TSlrckdezYUffdd58ef/zxZi9bT09P17hx41ReXq7t27drRN9RjoVJSYp8FdFHb+9zbgIArkKgBIBjBIPBlAqUkjRt2jTl5OSopKSkReNjsZgO7Kl1uCvp/Tc/cnwOAO5AoASAhGg0qvr6+pQLlIFAQIsXL9aGDRu0ZcuWk45vqG9QPOb8aaa6YL3jcwBwBwIlACSEw2FJSrlAKUnXX3+9hg0bpqKiopNe2dNW5xp9Ac5PAmhEoASAhKY7HVMxUJqmqaVLl2rLli165plnmh3rD/jV9bQujvd0RlYPx+cA4A4ESgBISOVAKUn5+fkaM2aMiouLFYs1f1n5gFF9ZZiGo/3knJ/laH0A7kGgBICEpkCZkZGR5E6OzzAMlZeXq6am5qSfhhx6+bkO9iGdM6inMrqm5r8TgLZHoASAhFRfoZSkSy65RBMmTFBpaakaGhpOOO7KGy+XaTrziI9LKpyV70htAO5EoASABDcESklasmSJ9uzZo9WrV59wTLceXTVu0miZPvsf8x0zOih36hjb6wJwLwIlACQEg0FJqR8oBw8erMmTJ6usrOxoCD6eGb+cqg4Z6TIMe89SznrgFnXq3NHWmgDcjUAJAAluWaGUpLKyMh08eFArVqw44ZhTM7vprodvO+k1Qy1l+kxdkD9MV9081pZ6ALyDQAkACW4KlNnZ2brtttu0bNkyHTp06ITjrph0qW7+xQ2W5zN9pvoMzdLCJ+bZvuIJwP0IlACQEAqFZJqm0tLSkt1KiyxcuFB1dXWqqKhodtyUkom6/YFb5PP7ZPq/3WN/RN4QVTx/H1vdAI6LQAkACaFQSJ06dXLNClxmZqbmzJmj+++/XwcOHGh27A9mX62HX1uu7MHnSJJ8JwmWhiHJkDqe0kF3r56lJRuKldEl9VduASQHgRIAEkKhUMreQXki8+fPV1pamhYvXnzSsb3PO1sPbv2llv29VBcWDJe/mU8nnj2wp2avmKF1+1Ypf9o414RsAMnhT3YDAJAqmlYo3aRbt25asGCBSktLNW/ePGVnZzc73jRNDb9yiIZfOUSRhog+fGufPvz3XoWP1MkX8OuMrO8q5/zeOuU77grWAJLLiNv1+h8AuNzcuXNVVVWlnTt3JruVVgmFQsrJyVFubq7Wrl2b7HYAtENseQNAQjAYdN0KpdT4VnppaakqKyv15ptvJrsdAO0QgRIAEty45d1kxowZys7OVklJSbJbAdAOESgBIMHNgTIQCKisrExPPfWUqqurk90OgHaGQAkACW4OlJJ0ww03aMiQISoqKrLt6zgA0BIESgBIcHugNE1TS5cu1ebNm7Vx48ZktwOgHSFQAkCCG++h/KaCggKNHj1axcXFisViyW4HQDtBoASABLevUEqSYRgqLy/Xjh079OSTT37tt3g8ruDhoD6vPazg4SDb4gBsw8XmANq1cLBO773+gWo/PChfbUeFP4po7+6PdVbfTJmmO//Pfdlll6mgoEClpaXKG/s9PV+5RdurarR763v68rMjR8d17n6KBlyYoxF5Q5V30+Xq0r1zErsG4GZcbA6g3QkH6/TCupf11MMb9V7NB4rH/v8xmN4pXRd/f4QKZ+Vr0OgBrvv04Csv/VO3jJmls/05isclxXXcFcmmv5cv4NPV06/QLUsm85UcAK1GoATQbsTjcT1X+ZJWzl6t4OGQDNM4bphs4vObikZiGnhxP93zyO3q2e/MNuz229u68XUtv2mlDh08LLXiCW/6THU9rbMWrJmtEXlDnWsQgOcQKAG0C+EjYZVP/Y1eWb9NMtSqoOXzmzJMU7NXzlDBjFzHerRD1ZpNqpj2oGSo2bB8IobZuGJ5z6N36MqpY+xuD4BHESgBeF74SFjzc8v0zmt7FItae/N55q9u1HXzJtjUmb2q12/VomsrbHnZxjAM/WL9Ao0aP8KGzgB4nTtPnANAC8XjcS2Z/IAtYVKSVv10jV76y6s2dGavz2sPq+LmB9WqpdeTWHbTSh3+5Avb6gHwLgIlAE+rWrNJrz693ZYwKTWu3P361odTLmg9dNcfFfoyLLv2nBqvGArpoTmP2FMQgKcRKAF4VujLsFbeubrxzKRN4vG4gl+Etbqo0r6iFh34oFYv/rnattDcJBaN6YV1L6t27ye21gXgPQRKAJ713GObFT5SZ+cusKTGoFW1drO++OxLewt/Sxt+9w/H7sw0TEMbVlU5UhuAdxAoAXjW3x561s7Fya+JRqL6x9rNDlVvneq//cv21ckmsWhM1eu3OlIbgHcQKAF40pFDQX347322nSn8JkPSG5vfcqZ4K9SH67Vv935H59i762N9Vd/g6BwA3I1ACcCT3nltj6P1Y7G4dr36jqNztMS+//xXsW9x32RrRCMx7X/3gKNzAHA3AiUATzrwfq3jc3y6/3PFYs5sNbdUffirNpmnLljXJvMAcCcCJQBPijREPTXPifgDvraZJ83fJvMAcCcCJQBP6pCR7vgcps9UIMlB64ysHm0yT2bvtpkHgDsRKAF4UtagXo7P0bNfpgzDqffIW6bLqZ11Ws9THZ2jxznfVUbXDEfnAOBuBEoAnpR1Xi/5/M5tB/v8pgaO6udY/dYYnjtYPr8zj3Of39Tw3MGO1AbgHQRKAJ4USAtoxPeGyPQ585iLRmIaNX64I7Vba/zMPEUjzrwcFI3EdM3MPEdqA/AOAiUAzyq8/WrHLvz+To+uuqTwAkdqt9bAUX3Vd3hv28Oz6TfVb2Qf9b8gx9a6ALyHQAnAs0ZeNVRZg3o5sko56d5rHd1Sbw3DMDTv9z+xv3BcuvsPDtQF4DkESgCeZZqmFqydbW9Nn6n+F/RR4ex8W+talXN+b00tvc7Wmjcu+pGyh5xja00A3kSgBOBpOcN6a0b5FFtqmT5DHTLSde/aO+Xzpcbq5LGmLJyo/OlX2FKr4NZcTS7+oS21AHgfgRKA51139wRNKZloqYbpN9Uho4OWV/1MPfudaVNn9jJNU3NXzdSkomslQ63e6jd9pgzD0JSSiZrz25lJvxIJgHsY8Xjc2Y/AAkCKePaRF/TgnavVUN/QureijcYt5aLH7tLZA85yrkEbvfXKbi27aaX2v3tAps9s9uWkpt979svU/Efv0LkXpcZ1SADcg0AJoF2p3fuJVt39J730l1dlGEbjt7iP8xRsClldTu2sH99TqIlzr0mZl3BaKhqNatvGGq1/6FnteH6nGuoa/m9MWoeAhuUOVuGsfI28aqhMk40rAK1HoATQLn3y8afa+OiLemPzW/rP1vd05FCw8QdDyux9ugZe1FcXXTNSl/7wQgXSAslt1gbRaFT7du/X3t371VAfUSDdr14DzlLPfpkpeR4UgLsQKAG0e/F4XHWhekUbokrrmKa0dPcHSABoSwRKAAAAWMJhGQAAAFhCoAQAAIAlBEoAAABYQqAEAACAJQRKAAAAWEKgBAAAgCUESgAAAFhCoAQAAIAlBEoAAABYQqAEAACAJQRKAAAAWEKgBAAAgCUESgAAAFhCoAQAAIAlBEoAAABYQqAEAACAJQRKAAAAWEKgBAAAgCUESgAAAFhCoAQAAIAlBEoAAABYQqAEAACAJQRKAAAAWEKgBAAAgCUESgAAAFhCoAQAAIAlBEoAAABYQqAEAACAJQRKAAAAWEKgBAAAgCUESgAAAFhCoAQAAIAlBEoAAABYQqAEAACAJQRKAAAAWEKgBAAAgCUESgAAAFjyP2jd1m04mIeNAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# nx.draw(dag)\n", - "znflow.draw(graph)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "5ed3a78e-6534-42a4-a492-a7a671b525e6", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 205 ms, sys: 7.81 ms, total: 213 ms\n", - "Wall time: 215 ms\n" - ] - }, - { - "data": { - "text/plain": [ - "[UUID('f4c955a6-e635-4d7e-9b6f-1d87a2e9394d'),\n", - " UUID('5b2dbf54-4ba3-4f54-9d5d-e0cd134c2df3'),\n", - " UUID('2f0c4080-5265-475c-ab10-9bbcb00686a1'),\n", - " UUID('1d69451d-7764-4e7f-9dbe-532cf6f8116f'),\n", - " UUID('4db270e7-16d6-4231-832c-03a0c4cc43ec'),\n", - " UUID('044459b2-350c-4b7e-a676-440ec520114f'),\n", - " UUID('b53a55d6-77d4-4248-8e87-20f960292ec9'),\n", - " UUID('b584b093-c01d-4bea-bda8-354dcd64d7eb'),\n", - " UUID('62a19c65-e9c2-4598-a9ee-a795d59d5fe1'),\n", - " UUID('7cc266b1-1177-4108-a53e-2fd3e553460d'),\n", - " UUID('4ad42750-ca1c-41c8-840c-af44f2b04f32'),\n", - " UUID('4db40e05-733c-4548-b50a-0b195b486ebf'),\n", - " UUID('1fed7aa2-2677-4011-85a0-050bf4d79879'),\n", - " UUID('51c5dd04-6d47-4877-b1d6-bdbc5d9ef789'),\n", - " UUID('ba62491d-23dd-4606-b38c-0ed07a1b7aa3'),\n", - " UUID('e82870bc-3c8a-4e94-b2c7-bc99c64879a1'),\n", - " UUID('f78160f1-9df7-4c4e-ad8c-23377c361a39'),\n", - " UUID('a3b342b9-9842-41a6-9eae-bb5a9dad5417'),\n", - " UUID('1572a4f7-c7fa-465e-b9e4-5f5b0d3eb91e'),\n", - " UUID('7b22fc23-b999-4ed9-ac3b-fbe69c2be9c9'),\n", - " UUID('10581165-7f35-468c-a389-82dad843de38'),\n", - " UUID('38ce7be3-0050-4fe9-afdd-b479ca75cc7b'),\n", - " UUID('f1545d72-6114-4ade-99a4-ec80b1e658aa'),\n", - " UUID('131e8b60-81a5-490f-9620-a58f0ec2e124'),\n", - " UUID('80395b60-2738-41da-bba6-f98088413db4'),\n", - " UUID('20781a17-698c-4049-85ee-318a5a6700a8'),\n", - " UUID('4e891391-4931-4665-9b86-79a28afa8059'),\n", - " UUID('33e9bdfb-3eeb-43f1-95d9-c053c1ac420b'),\n", - " UUID('205a3262-9fd6-4890-b229-67363e589fb7'),\n", - " UUID('88c5f1c9-1436-4006-b77f-7ec1b79384f6'),\n", - " UUID('31d2e2d2-d8b8-4d51-bcbe-f35173b3843f'),\n", - " UUID('a6d811f6-5d5a-4ecf-b835-bbba97a79712'),\n", - " UUID('6417602f-9642-4acd-b50d-5ef980bdc415'),\n", - " UUID('447f6b51-ae37-4f60-888d-e459daea04de'),\n", - " UUID('8e3a641c-774c-4045-99e1-ffc6058fc666'),\n", - " UUID('9c0c1a4d-e8be-4807-ae54-2b45c659680e'),\n", - " UUID('0ac71346-ff35-42f3-9c13-7df90cbc9770'),\n", - " UUID('b05f111a-76aa-4f9f-9794-46305d0b35e1'),\n", - " UUID('48dedbf7-6e29-43df-81e9-a9b6bac0f479'),\n", - " UUID('79e625cd-d163-4cae-bd18-7c1aa5df317e')]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%time graph.run() # default is to call node.run()\n", - "# # [x._id_ for x in dag.nodes]\n", - "[x for x in graph.nodes]" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "b37c8558-bf14-4060-aff1-0ab3b0aea476", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "SumNodes(inputs=[9.245727534191499, 7.098558270790515, 6.575734731170973], outputs=22.92002053615299)" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "end_node" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c7751343-80c8-4578-8b62-e358b3773668", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tmp/example_02.ipynb b/tmp/example_02.ipynb deleted file mode 100644 index 9e42ef6..0000000 --- a/tmp/example_02.ipynb +++ /dev/null @@ -1,224 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "4e964158-14bc-4439-a44f-ef64b39c862f", - "metadata": {}, - "source": [ - "# Functions and Graphs" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "51740efc-d1f9-408d-a611-a87fcf8bfb53", - "metadata": {}, - "outputs": [], - "source": [ - "import znflow" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d12195fe-2c88-4692-999c-6dd48fe5a140", - "metadata": {}, - "outputs": [], - "source": [ - "@znflow.nodify\n", - "def add(*args):\n", - " return sum(args)\n", - "\n", - "@znflow.nodify\n", - "def multiply(a, b):\n", - " return a * b\n", - "\n", - "@znflow.nodify\n", - "def divide(a, b):\n", - " print(\"Computing\")\n", - " return a / b" - ] - }, - { - "cell_type": "markdown", - "id": "c6383d82-8095-43c0-b05e-f7891f41a3fd", - "metadata": {}, - "source": [ - "_eager_ mode" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d5131234-6ef8-47dd-aab5-3e5a50d94c60", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Computing\n" - ] - } - ], - "source": [ - "n1 = add(1, 2, 3)\n", - "n2 = add(10, 20, 30)\n", - "n3 = add(n1, n2)\n", - "n4 = multiply(n1, n3)\n", - "n5 = divide(n4, n1)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "f19d254a-d94b-4d47-88fa-77278859a92b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "66.0" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "n5" - ] - }, - { - "cell_type": "markdown", - "id": "67345989-03d5-43a6-9ba7-eb0f13775246", - "metadata": {}, - "source": [ - "_graph_ mode" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "c22c3a45-2801-4019-857d-d631e2e32aaf", - "metadata": {}, - "outputs": [], - "source": [ - "with znflow.DiGraph() as graph:\n", - " n1 = add(1, 2, 3)\n", - " n2 = add(10, 20, 30)\n", - " n3 = add(n1, n2)\n", - " n4 = multiply(n1, n3)\n", - " n5 = divide(n4, n1)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "91f97c85-97c6-4245-9259-6527489e4e37", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "znflow.draw(graph, log=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "eea05e60-657c-4e68-9c37-3e9d95edbd4e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Computing\n" - ] - } - ], - "source": [ - "graph.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "528be861-3bf6-42c8-b349-7af2956d7939", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "66.0" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "n5.result" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b26a9898-4ce5-43db-9d46-68cc5b2f92d4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DiGraph with 5 nodes and 6 edges\n" - ] - } - ], - "source": [ - "print(graph)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "952a96d6-3b87-438c-b319-f51a5fcf79bd", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tmp/example_03.ipynb b/tmp/example_03.ipynb deleted file mode 100644 index c1afa96..0000000 --- a/tmp/example_03.ipynb +++ /dev/null @@ -1,211 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "678eaf6f-a85e-4d2e-b1e4-2be680841be0", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "import znflow\n", - "import random\n", - "import zninit" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "69fee3af-d100-41e0-81c0-95c5e8a40e3d", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "class ComputeSum(zninit.ZnInit, znflow.Node):\n", - " inputs: list = zninit.Descriptor()\n", - " outputs: float = zninit.Descriptor(None)\n", - " \n", - " def run(self):\n", - " self.outputs = sum(self.inputs)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "f2a8cbaa-ebd5-4e16-bd98-f164b76f081b", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "@znflow.nodify\n", - "def random_number(seed):\n", - " random.seed(seed)\n", - " print(f\"Get random number with {seed = }\")\n", - " return random.random()" - ] - }, - { - "cell_type": "markdown", - "id": "1163fe03-78cd-4d59-9f7b-0c8222f3ca7f", - "metadata": {}, - "source": [ - "## Without building a graph" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "3a03c96e-ef7c-47d7-9ca4-76b074c97805", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Get random number with seed = 5\n", - "Get random number with seed = 10\n", - "Get random number with seed = 1.1943042895796154\n", - "0.2903973544626711\n" - ] - } - ], - "source": [ - "n1 = random_number(5)\n", - "n2 = random_number(10)\n", - "\n", - "compute_sum = ComputeSum(inputs=[n1, n2])\n", - "compute_sum.run()\n", - "n3 = random_number(compute_sum.outputs)\n", - "print(n3)" - ] - }, - { - "cell_type": "markdown", - "id": "5ca5b8da-83c3-49ce-a029-9459d0b72e83", - "metadata": {}, - "source": [ - "## Using a graph" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "a486dc3d-3401-4f7a-988b-4e261a260068", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "with znflow.DiGraph() as graph:\n", - " n1 = random_number(5)\n", - " n2 = random_number(10)\n", - "\n", - " compute_sum = ComputeSum(inputs=[n1, n2])\n", - " \n", - " n3 = random_number(compute_sum.outputs)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "eac0659a-8c6d-4f01-a892-caa300fc1617", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "znflow.draw(graph)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "ed963555-9d93-4240-b735-69ce5260aab1", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Get random number with seed = 5\n", - "Get random number with seed = 10\n", - "Get random number with seed = 1.1943042895796154\n" - ] - } - ], - "source": [ - "graph.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "83df8cd9-5ba1-47be-944d-f0a95ef93fcb", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "0.2903973544626711" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "n3.result" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "17f80e19-a5a7-4d31-a38e-4694bb932c2d", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 1401165b9549ed0e1db3f21c0541a706664fabb0 Mon Sep 17 00:00:00 2001 From: Ruttor Date: Fri, 24 Feb 2023 14:22:25 +0100 Subject: [PATCH 03/13] Added Docstrings to base.py --- pyproject.toml | 5 ++++- znflow/base.py | 17 ++++++++++++++++- 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 228ab9a..65a0d93 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -46,7 +46,10 @@ multi_line_output = 3 [tool.ruff] line-length = 90 -select = ["E", "F"] #, "D"] #, "N", "C", "ANN"] +select = ["E", "F", "D"] #] #, "N", "C", "ANN"] +exclude = [ + "tests", +] extend-ignore = [ "D213", "D203" ] diff --git a/znflow/base.py b/znflow/base.py index d444581..45c0ed9 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -1,3 +1,4 @@ +"""The base module of znflow.""" from __future__ import annotations import contextlib @@ -43,23 +44,31 @@ class NodeBaseMixin: @property def uuid(self): + """A method that generates a UUID to create a hashable object for each node.""" return self._uuid @uuid.setter def uuid(self, value): + """A method that checks for an existing UUID. + + If no UUID exists, it sets the previously defined UUID for the node. + """ if self._uuid is not None: raise ValueError("uuid is already set") self._uuid = value def run(self): + """Run Method of NodeBaseMixin.""" raise NotImplementedError def get_graph(): + """Gets Graph from the NodeBaseMixin class.""" return NodeBaseMixin._graph_ def set_graph(value): + """Sets a value for the NodeBaseMixin graph.""" NodeBaseMixin._graph_ = value @@ -77,11 +86,12 @@ def get_attribute(obj, name, default=_get_attribute_none): @dataclasses.dataclass(frozen=True) class Connection: """A Connector for Nodes. + instance: either a Node or FunctionFuture attribute: Node.attribute or FunctionFuture.result - or None if the class is passed and not an attribute + or None if the class is passed and not an attribute. """ instance: any @@ -89,10 +99,12 @@ class Connection: @property def uuid(self): + """Gets value of the UUID.""" return self.instance.uuid @property def result(self): + """Returns the instance and if available, also the attribute.""" if self.attribute is None: return self.instance return getattr(self.instance, self.attribute) @@ -100,6 +112,9 @@ def result(self): @dataclasses.dataclass class FunctionFuture(NodeBaseMixin): + """ + + """ function: typing.Callable args: typing.Tuple kwargs: typing.Dict From b62b468f97dc71769c930fdc01a13feba70d3425 Mon Sep 17 00:00:00 2001 From: Ruttor Date: Mon, 27 Feb 2023 09:27:17 +0100 Subject: [PATCH 04/13] Removed empty docstring --- znflow/base.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/znflow/base.py b/znflow/base.py index 45c0ed9..2c9df48 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -112,9 +112,6 @@ def result(self): @dataclasses.dataclass class FunctionFuture(NodeBaseMixin): - """ - - """ function: typing.Callable args: typing.Tuple kwargs: typing.Dict From d17be27140fe4b97a46bbdf2e2f956e1d751c1cf Mon Sep 17 00:00:00 2001 From: Ruttor Date: Mon, 20 Mar 2023 10:24:25 +0100 Subject: [PATCH 05/13] Add Docstrings --- pyproject.toml | 2 +- znflow/base.py | 40 ++++++++++++++++++++++++++++++++++++---- znflow/graph.py | 4 ++++ znflow/node.py | 1 + znflow/utils.py | 1 - 5 files changed, 42 insertions(+), 6 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 65a0d93..8529bbd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -46,7 +46,7 @@ multi_line_output = 3 [tool.ruff] line-length = 90 -select = ["E", "F", "D"] #] #, "N", "C", "ANN"] +select = ["E", "F", "D"]#, "N", "C", "ANN"] exclude = [ "tests", ] diff --git a/znflow/base.py b/znflow/base.py index 2c9df48..40b1f78 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -1,4 +1,4 @@ -"""The base module of znflow.""" +"""The base module of ZnFlow.""" from __future__ import annotations import contextlib @@ -52,6 +52,11 @@ def uuid(self, value): """A method that checks for an existing UUID. If no UUID exists, it sets the previously defined UUID for the node. + + Raises + ------ + ValueError + If a UUID is already set for the current node. """ if self._uuid is not None: raise ValueError("uuid is already set") @@ -87,9 +92,13 @@ def get_attribute(obj, name, default=_get_attribute_none): class Connection: """A Connector for Nodes. - instance: either a Node or FunctionFuture - attribute: - Node.attribute + Instance + -------- + Either a Node or FunctionFuture. + + Attributes + ---------- + attribute : Node.attribute or FunctionFuture.result or None if the class is passed and not an attribute. """ @@ -112,6 +121,15 @@ def result(self): @dataclasses.dataclass class FunctionFuture(NodeBaseMixin): + """A class that creates a future object out of a function. + + Attributes + ---------- + function : callable + args : tuple + kwargs : dict + """ + function: typing.Callable args: typing.Tuple kwargs: typing.Dict @@ -121,10 +139,24 @@ class FunctionFuture(NodeBaseMixin): _protected_ = NodeBaseMixin._protected_ + ["function", "args", "kwargs"] def run(self): + """Run Method of the FunctionFuture class. + + Executes the function with the given arguments. + + Returns + ------- + TODO + """ self._result = self.function(*self.args, **self.kwargs) @property def result(self): + """TODO. + + Returns + ------- + TODO + """ if self._result is None: self.run() diff --git a/znflow/graph.py b/znflow/graph.py index af4006e..f8bcbed 100644 --- a/znflow/graph.py +++ b/znflow/graph.py @@ -1,3 +1,4 @@ +"""The graph module of ZnFlow.""" import logging import networkx as nx @@ -47,6 +48,9 @@ def default(self, value, **kwargs): class DiGraph(nx.MultiDiGraph): + """ + + """ def __enter__(self): if get_graph() is not None: raise ValueError("DiGraph already exists. Nested Graphs are not supported.") diff --git a/znflow/node.py b/znflow/node.py index b152737..438830c 100644 --- a/znflow/node.py +++ b/znflow/node.py @@ -1,3 +1,4 @@ +"""The node module of ZnFlow.""" from __future__ import annotations import functools diff --git a/znflow/utils.py b/znflow/utils.py index 88ecf49..710c6de 100644 --- a/znflow/utils.py +++ b/znflow/utils.py @@ -35,7 +35,6 @@ def default(self, value, **kwargs): @functools.singledispatchmethod def handle(self, value, **kwargs): """Fallback handling if no siggledispatch was triggered.""" - result = self.default(value, **kwargs) if result is not value: self.updated = True From 426efb3c22683b655b75206d5cb0fb33ae769a8c Mon Sep 17 00:00:00 2001 From: Ruttor Date: Mon, 20 Mar 2023 15:13:37 +0100 Subject: [PATCH 06/13] Add Docstrings --- znflow/base.py | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/znflow/base.py b/znflow/base.py index 0cfa449..e31f8f4 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -1,3 +1,4 @@ +"""The base module of znflow.""" from __future__ import annotations import contextlib @@ -29,6 +30,10 @@ class Property: """ def __init__(self, fget=None, fset=None, fdel=None, doc=None): + """Init method of the property class. + + Uses the disable_graph function to get/set/delete properties with a description (doc). + """ self.fget = disable_graph()(fget) self.fset = disable_graph()(fset) self.fdel = disable_graph()(fdel) @@ -38,9 +43,11 @@ def __init__(self, fget=None, fset=None, fdel=None, doc=None): self._name = "" def __set_name__(self, owner, name): + """Sets a name as a property.""" self._name = name def __get__(self, obj, objtype=None): + """TODO.""" if obj is None: return self if self.fget is None: @@ -48,26 +55,31 @@ def __get__(self, obj, objtype=None): return self.fget(obj) def __set__(self, obj, value): + """TODO.""" if self.fset is None: raise AttributeError(f"property '{self._name}' has no setter") self.fset(obj, value) def __delete__(self, obj): + """TODO.""" if self.fdel is None: raise AttributeError(f"property '{self._name}' has no deleter") self.fdel(obj) def getter(self, fget): + """TODO.""" prop = type(self)(fget, self.fset, self.fdel, self.__doc__) prop._name = self._name return prop def setter(self, fset): + """TODO.""" prop = type(self)(self.fget, fset, self.fdel, self.__doc__) prop._name = self._name return prop def deleter(self, fdel): + """TODO.""" prop = type(self)(self.fget, self.fset, fdel, self.__doc__) prop._name = self._name return prop @@ -163,9 +175,11 @@ class Connection: item: any = None def __getitem__(self, item): + """TODO.""" return dataclasses.replace(self, instance=self, attribute="result", item=item) def __post_init__(self): + """Raises a Valueerror if a private attribute is called.""" if self.attribute is not None and self.attribute.startswith("_"): raise ValueError("Private attributes are not allowed.") @@ -216,11 +230,12 @@ def run(self): self._result = self.function(*self.args, **self.kwargs) def __getitem__(self, item): + """TODO.""" return Connection(instance=self, attribute="result", item=item) @property def result(self): - """TODO. + """If no result is available yet, it executes the Run Method of the FunctionFuture class. Returns ------- From 4c1c11fb6aca05788edd1afbe2acdcf32ea95032 Mon Sep 17 00:00:00 2001 From: Ruttor Date: Mon, 20 Mar 2023 15:27:07 +0100 Subject: [PATCH 07/13] Add Docstrings --- znflow/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/znflow/base.py b/znflow/base.py index e31f8f4..2157e20 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -230,7 +230,7 @@ def run(self): self._result = self.function(*self.args, **self.kwargs) def __getitem__(self, item): - """TODO.""" + """Gets the object with all the information of the Connection class.""" return Connection(instance=self, attribute="result", item=item) @property From 2d8902d0b6382d52d54a5c1c868f8bc2d5e1dbee Mon Sep 17 00:00:00 2001 From: Ruttor Date: Mon, 20 Mar 2023 18:31:25 +0100 Subject: [PATCH 08/13] Add Docstrings and eliminate merge conflicts --- znflow/base.py | 70 +++++++++++++++++++++++++++++++++----------------- 1 file changed, 46 insertions(+), 24 deletions(-) diff --git a/znflow/base.py b/znflow/base.py index 2157e20..e63bd4c 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -32,7 +32,9 @@ class Property: def __init__(self, fget=None, fset=None, fdel=None, doc=None): """Init method of the property class. - Uses the disable_graph function to get/set/delete properties with a description (doc). + References + ---------- + Adapted from https://docs.python.org/3/howto/descriptor.html#properties """ self.fget = disable_graph()(fget) self.fset = disable_graph()(fset) @@ -43,11 +45,21 @@ def __init__(self, fget=None, fset=None, fdel=None, doc=None): self._name = "" def __set_name__(self, owner, name): - """Sets a name as a property.""" + """Set Name Method of the Property class. + + References + ---------- + Adapted from https://docs.python.org/3/howto/descriptor.html#properties + """ self._name = name def __get__(self, obj, objtype=None): - """TODO.""" + """Get Method of the Property class. + + References + ---------- + Adapted from https://docs.python.org/3/howto/descriptor.html#properties + """ if obj is None: return self if self.fget is None: @@ -55,31 +67,56 @@ def __get__(self, obj, objtype=None): return self.fget(obj) def __set__(self, obj, value): - """TODO.""" + """Set Method of the Property class. + + References + ---------- + Adapted from https://docs.python.org/3/howto/descriptor.html#properties + """ if self.fset is None: raise AttributeError(f"property '{self._name}' has no setter") self.fset(obj, value) def __delete__(self, obj): - """TODO.""" + """Delete Method of the Property class. + + References + ---------- + Adapted from https://docs.python.org/3/howto/descriptor.html#properties + """ if self.fdel is None: raise AttributeError(f"property '{self._name}' has no deleter") self.fdel(obj) def getter(self, fget): - """TODO.""" + """Getter Method of the Property class. + + References + ---------- + Adapted from https://docs.python.org/3/howto/descriptor.html#properties + """ prop = type(self)(fget, self.fset, self.fdel, self.__doc__) prop._name = self._name return prop def setter(self, fset): - """TODO.""" + """Setter Method of the Property class. + + References + ---------- + Adapted from https://docs.python.org/3/howto/descriptor.html#properties + """ prop = type(self)(self.fget, fset, self.fdel, self.__doc__) prop._name = self._name return prop def deleter(self, fdel): - """TODO.""" + """Deleter Method of the Property class. + + References + ---------- + Adapted from https://docs.python.org/3/howto/descriptor.html#properties + """ prop = type(self)(self.fget, self.fset, fdel, self.__doc__) prop._name = self._name return prop @@ -221,11 +258,7 @@ class FunctionFuture(NodeBaseMixin): def run(self): """Run Method of the FunctionFuture class. - Executes the function with the given arguments. - - Returns - ------- - TODO + Executes the function with the given arguments and saves the result. """ self._result = self.function(*self.args, **self.kwargs) @@ -233,14 +266,3 @@ def __getitem__(self, item): """Gets the object with all the information of the Connection class.""" return Connection(instance=self, attribute="result", item=item) - @property - def result(self): - """If no result is available yet, it executes the Run Method of the FunctionFuture class. - - Returns - ------- - TODO - """ - if self._result is None: - self.run() - return self._result From 7f7899f1a15fdad237bbcfa23958b2b2b7a762de Mon Sep 17 00:00:00 2001 From: Ruttor Date: Mon, 20 Mar 2023 18:38:35 +0100 Subject: [PATCH 09/13] Eliminate merge conflicts --- znflow/base.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/znflow/base.py b/znflow/base.py index e63bd4c..7052aef 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -213,7 +213,7 @@ class Connection: def __getitem__(self, item): """TODO.""" - return dataclasses.replace(self, instance=self, attribute="result", item=item) + return dataclasses.replace(self, instance=self, attribute=None, item=item) def __post_init__(self): """Raises a Valueerror if a private attribute is called.""" @@ -228,10 +228,12 @@ def uuid(self): @property def result(self): """Returns the instance and if available, also the attribute.""" - result = ( - getattr(self.instance, self.attribute) if self.attribute else self.instance - ) - + if self.attribute: + result = getattr(self.instance, self.attribute) + elif isinstance(self.instance, (FunctionFuture, self.__class__)): + result = self.instance.result + else: + result = self.instance return result[self.item] if self.item else result @@ -264,5 +266,5 @@ def run(self): def __getitem__(self, item): """Gets the object with all the information of the Connection class.""" - return Connection(instance=self, attribute="result", item=item) + return Connection(instance=self, attribute=None, item=item) From bfc6d7f6ab3526fe05e892bf59c3eb12987587e1 Mon Sep 17 00:00:00 2001 From: Ruttor Date: Mon, 20 Mar 2023 18:48:15 +0100 Subject: [PATCH 10/13] Reduce ruff "D401"-errors --- znflow/base.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/znflow/base.py b/znflow/base.py index 7052aef..27d3536 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -153,7 +153,7 @@ def uuid(self): @uuid.setter def uuid(self, value): - """A method that checks for an existing UUID. + """Check for an existing UUID. If no UUID exists, it sets the previously defined UUID for the node. @@ -172,12 +172,12 @@ def run(self): def get_graph(): - """Gets Graph from the NodeBaseMixin class.""" + """Get Graph from the NodeBaseMixin class.""" return NodeBaseMixin._graph_ def set_graph(value): - """Sets a value for the NodeBaseMixin graph.""" + """Set a value for the NodeBaseMixin graph.""" NodeBaseMixin._graph_ = value @@ -216,7 +216,7 @@ def __getitem__(self, item): return dataclasses.replace(self, instance=self, attribute=None, item=item) def __post_init__(self): - """Raises a Valueerror if a private attribute is called.""" + """Raise a Valueerror if a private attribute is called.""" if self.attribute is not None and self.attribute.startswith("_"): raise ValueError("Private attributes are not allowed.") @@ -265,6 +265,6 @@ def run(self): self._result = self.function(*self.args, **self.kwargs) def __getitem__(self, item): - """Gets the object with all the information of the Connection class.""" + """Get the object with all the information of the Connection class.""" return Connection(instance=self, attribute=None, item=item) From 4c0b16d8d6042c503de851797dadee69db835a11 Mon Sep 17 00:00:00 2001 From: Ruttor Date: Fri, 24 Mar 2023 10:10:58 +0100 Subject: [PATCH 11/13] Finish Docstrings in base --- znflow/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/znflow/base.py b/znflow/base.py index 27d3536..6549d79 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -111,7 +111,7 @@ def setter(self, fset): return prop def deleter(self, fdel): - """Deleter Method of the Property class. + """Set delete method for Property class. References ---------- From 89bd9755e8ad3ea0e95f83646c82524b38dba05e Mon Sep 17 00:00:00 2001 From: Ruttor Date: Fri, 24 Mar 2023 10:38:29 +0100 Subject: [PATCH 12/13] Merge main into branch --- znflow/base.py | 1 + 1 file changed, 1 insertion(+) diff --git a/znflow/base.py b/znflow/base.py index 01b9d65..1e807b5 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -211,6 +211,7 @@ class Connection: item: any = None def __getitem__(self, item): + """Create a new object of the same type as self with values from changes.""" return dataclasses.replace(self, instance=self, attribute=None, item=item) def __post_init__(self): From f95567f4fd8277981719cfd286472bba8e5b21fe Mon Sep 17 00:00:00 2001 From: Ruttor Date: Fri, 24 Mar 2023 11:16:46 +0100 Subject: [PATCH 13/13] ruff is now happy with base.py, but there is still one TODO --- znflow/base.py | 28 ++++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-) diff --git a/znflow/base.py b/znflow/base.py index 493aeff..d49fe44 100644 --- a/znflow/base.py +++ b/znflow/base.py @@ -220,17 +220,26 @@ def __getitem__(self, item): return dataclasses.replace(self, instance=self, attribute=None, item=item) def __iter__(self): + """Raise TypeError when iterating over itself.""" raise TypeError(f"Can not iterate over {self}.") def __add__( self, other: typing.Union[Connection, FunctionFuture, CombinedConnections] ) -> CombinedConnections: + """Add Method of the Connection class. + + Adds instances onto eachother. + + Raises + ------ + TypeError when two types cannot be added. + """ if isinstance(other, (Connection, FunctionFuture, CombinedConnections)): return CombinedConnections(connections=[self, other]) raise TypeError(f"Can not add {type(other)} to {type(self)}.") def __radd__(self, other): - """Enable 'sum([a, b], [])'""" + """Enable 'sum([a, b], [])'.""" return self if other == [] else self.__add__(other) @property @@ -261,7 +270,6 @@ class CombinedConnections: Examples -------- - >>> import znflow >>> @znflow.nodfiy >>> def add(size) -> list: @@ -306,17 +314,20 @@ def __add__( raise TypeError(f"Can not add {type(other)} to {type(self)}.") def __radd__(self, other): - """Enable 'sum([a, b], [])'""" + """Enable 'sum([a, b], [])'.""" return self if other == [] else self.__add__(other) def __getitem__(self, item): + """Create a new object of the same type as self with values from changes.""" return dataclasses.replace(self, item=item) def __iter__(self): + """Raise TypeError when iterating over itself.""" raise TypeError(f"Can not iterate over {self}.") @property def result(self): + """TODO.""" try: results = [] for connection in self.connections: @@ -361,15 +372,24 @@ def __getitem__(self, item): return Connection(instance=self, attribute=None, item=item) def __iter__(self): + """Raise TypeError when iterating over itself.""" raise TypeError(f"Can not iterate over {self}.") def __add__( self, other: typing.Union[Connection, FunctionFuture, CombinedConnections] ) -> CombinedConnections: + """Add Method of the FunctionFuture class. + + Adds instances onto eachother. + + Raises + ------ + TypeError when two types cannot be added. + """ if isinstance(other, (Connection, FunctionFuture, CombinedConnections)): return CombinedConnections(connections=[self, other]) raise TypeError(f"Can not add {type(other)} to {type(self)}.") def __radd__(self, other): - """Enable 'sum([a, b], [])'""" + """Enable 'sum([a, b], [])'.""" return self if other == [] else self.__add__(other)