From 2fd6c6542560cc0c8f862325a7f244572956c6f6 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 14 Aug 2026 10:11:33 -0400 Subject: [PATCH 01/85] Add new interface via ABCD class --- src/abcd_graph/__init__.py | 3 +- src/abcd_graph/graph/__init__.py | 3 +- src/abcd_graph/graph/abcd.py | 121 +++++++++++++++++++++++++++++++ tests/abcd_graph/test_abcd.py | 9 +++ 4 files changed, 134 insertions(+), 2 deletions(-) create mode 100644 src/abcd_graph/graph/abcd.py create mode 100644 tests/abcd_graph/test_abcd.py diff --git a/src/abcd_graph/__init__.py b/src/abcd_graph/__init__.py index de13c8e..70b5dde 100644 --- a/src/abcd_graph/__init__.py +++ b/src/abcd_graph/__init__.py @@ -21,7 +21,8 @@ __all__ = [ "ABCDGraph", "ABCDParams", + "ABCD", ] -from abcd_graph.graph import ABCDGraph +from abcd_graph.graph import ABCDGraph, ABCD from abcd_graph.params import ABCDParams diff --git a/src/abcd_graph/graph/__init__.py b/src/abcd_graph/graph/__init__.py index aa93706..05fee6c 100644 --- a/src/abcd_graph/graph/__init__.py +++ b/src/abcd_graph/graph/__init__.py @@ -1,4 +1,5 @@ -__all__ = ["ABCDGraph"] +__all__ = ["ABCDGraph", "ABCD"] from abcd_graph.graph.graph import ABCDGraph +from abcd_graph.graph.abcd import ABCD diff --git a/src/abcd_graph/graph/abcd.py b/src/abcd_graph/graph/abcd.py new file mode 100644 index 0000000..b48e487 --- /dev/null +++ b/src/abcd_graph/graph/abcd.py @@ -0,0 +1,121 @@ +import numpy as np +from numpy.typing import NDArray +from typing import Sequence + +from abcd_graph.callbacks.abstract import ABCDCallback +from abcd_graph.graph import ABCDGraph +from abcd_graph.params import ABCDParams +from abcd_graph.models import Model + + +__all__ = ["ABCD"] + + +class ABCD: + """Artificial Benchmark for Community Detection + + This class combines the ABCDGraph and ABCDParams class, essentially adding a sample + method to ABCDParams. + + Parameters + ---------- + + vcount : int + The number of vertices in the graph. + + gamma : float, default=2.5 + Powerlaw exponent for the degree distribution. Not used if degree_sequence is passed. + + beta: float, default=1.5 + Powerlaw exponent for the community size distribution. Not used if a custom + community_size_sequence is passed. + + xi: float, default=0.25 + Proportion of edges in the global background graph. Setting xi=0 gives disjoint communities + while xi=1 gives a random graph with no community structure. + + min_degree : int, default=5 + Minimum degree in the graph. Not used if degree_sequence is passed. + + max_degree : int, default=30 + Maximum degree in the graph. Not used if degree_sequence is passed. + + min_community_size : int, default=20 + Minimum community size. Not used if a custom community_size_sequence is passed. + + max_community_size: int, default=250 + Maximum community size. Not used if a custom community_size_sequence is passed. + + degree_sequence : Sequence[int] | NDArray[np.int64] | None, default=None + Used to pass a custom degree sequence that overrides the default powerlaw distribution. + + community_size_sequence : Sequence[int] | NDArray[np.int64] | None, default=None + Used to pass a custom community size sequence that overrides the default powerlaw distribution. + The sum of the community sizes must equal the number of vertices minus the number of outliers. + + num_outliers : int, default=0 + The number of outliers. These vertices have their entire degree in the global background graph + so do not appear in any community. + + model : Model | None, default=None + Random graph model used to sample the community and background graphs. + + verbose : bool, default=False + Flag to log runtime infomation. + """ + def __init__( + self, + vcount: int, + gamma: float = 2.5, + beta: float = 1.5, + xi: float = 0.25, + min_degree: int = 5, + max_degree: int = 30, + min_community_size: int = 20, + max_community_size: int = 250, + degree_sequence: Sequence[int] | NDArray[np.int64] | None = None, + community_size_sequence: Sequence[int] | NDArray[np.int64] | None = None, + num_outliers: int = 0, + model: Model | None = None, + verbose: bool = False, + ): + self.vcount = vcount + self.xi = xi + self.min_degree = min_degree + self.max_degree = max_degree + self.gamma = gamma + self.min_community_size = min_community_size + self.max_community_size = max_community_size + self.beta = beta + self.degree_sequence = degree_sequence + self.community_size_sequence = community_size_sequence + self.num_outliers = num_outliers + self.model = model + self.verbose = verbose + + def sample(self, callbacks: list[ABCDCallback] | None = None) -> ABCDGraph: + """Sample an ABCD graph. Calling sample multiple times will overwrite the + self.graph_ object.""" + self.params_ = ABCDParams( + self.vcount, + self.gamma if self.degree_sequence is None else None, + self.beta if self.community_size_sequence is None else None, + self.xi, + self.min_degree if self.degree_sequence is None else None, + self.max_degree if self.degree_sequence is None else None, + self.min_community_size if self.community_size_sequence is None else None, + self.max_community_size if self.community_size_sequence is None else None, + self.degree_sequence, + self.community_size_sequence, + self.num_outliers, + ) + + self.graph_ = ABCDGraph( + self.params_, + logger = self.verbose, + callbacks = callbacks, + ) + + self.graph_.build(self.model) + + return self.graph_ diff --git a/tests/abcd_graph/test_abcd.py b/tests/abcd_graph/test_abcd.py new file mode 100644 index 0000000..b13d41e --- /dev/null +++ b/tests/abcd_graph/test_abcd.py @@ -0,0 +1,9 @@ +import pytest +from abcd_graph import ABCD +from tests.utils import assert_graph_built + +def test_abcd_sample(params): + sampler = ABCD(1000) + sample = sampler.sample() + assert_graph_built(sample) + assert sample is sampler.graph_ From 7211d2b489361e47ff8642d891bac2761d5814ae Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 14 Aug 2026 10:13:35 -0400 Subject: [PATCH 02/85] Run black --- src/abcd_graph/graph/abcd.py | 22 +++++++++++----------- tests/abcd_graph/test_abcd.py | 1 + 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/src/abcd_graph/graph/abcd.py b/src/abcd_graph/graph/abcd.py index b48e487..b13853e 100644 --- a/src/abcd_graph/graph/abcd.py +++ b/src/abcd_graph/graph/abcd.py @@ -7,7 +7,6 @@ from abcd_graph.params import ABCDParams from abcd_graph.models import Model - __all__ = ["ABCD"] @@ -29,7 +28,7 @@ class ABCD: beta: float, default=1.5 Powerlaw exponent for the community size distribution. Not used if a custom community_size_sequence is passed. - + xi: float, default=0.25 Proportion of edges in the global background graph. Setting xi=0 gives disjoint communities while xi=1 gives a random graph with no community structure. @@ -45,24 +44,25 @@ class ABCD: max_community_size: int, default=250 Maximum community size. Not used if a custom community_size_sequence is passed. - + degree_sequence : Sequence[int] | NDArray[np.int64] | None, default=None Used to pass a custom degree sequence that overrides the default powerlaw distribution. - + community_size_sequence : Sequence[int] | NDArray[np.int64] | None, default=None Used to pass a custom community size sequence that overrides the default powerlaw distribution. The sum of the community sizes must equal the number of vertices minus the number of outliers. - + num_outliers : int, default=0 The number of outliers. These vertices have their entire degree in the global background graph so do not appear in any community. - + model : Model | None, default=None Random graph model used to sample the community and background graphs. - + verbose : bool, default=False Flag to log runtime infomation. """ + def __init__( self, vcount: int, @@ -92,13 +92,13 @@ def __init__( self.num_outliers = num_outliers self.model = model self.verbose = verbose - + def sample(self, callbacks: list[ABCDCallback] | None = None) -> ABCDGraph: """Sample an ABCD graph. Calling sample multiple times will overwrite the self.graph_ object.""" self.params_ = ABCDParams( self.vcount, - self.gamma if self.degree_sequence is None else None, + self.gamma if self.degree_sequence is None else None, self.beta if self.community_size_sequence is None else None, self.xi, self.min_degree if self.degree_sequence is None else None, @@ -112,8 +112,8 @@ def sample(self, callbacks: list[ABCDCallback] | None = None) -> ABCDGraph: self.graph_ = ABCDGraph( self.params_, - logger = self.verbose, - callbacks = callbacks, + logger=self.verbose, + callbacks=callbacks, ) self.graph_.build(self.model) diff --git a/tests/abcd_graph/test_abcd.py b/tests/abcd_graph/test_abcd.py index b13d41e..10f9880 100644 --- a/tests/abcd_graph/test_abcd.py +++ b/tests/abcd_graph/test_abcd.py @@ -2,6 +2,7 @@ from abcd_graph import ABCD from tests.utils import assert_graph_built + def test_abcd_sample(params): sampler = ABCD(1000) sample = sampler.sample() From 240fa0527fc42584eb61f5e47c96112b01de1428 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 14 Aug 2026 10:22:18 -0400 Subject: [PATCH 03/85] Update README and demo --- README.md | 8 +++ examples/demo.ipynb | 135 ++++++++++++++++++++++++++++++++++++++------ 2 files changed, 127 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index cf3b624..2ac6448 100644 --- a/README.md +++ b/README.md @@ -64,6 +64,14 @@ params = ABCDParams(vcount=1000) graph = ABCDGraph(params, logger=True).build() ``` +Or for an alternative interface +```python +from abcd_graph import ABCD + +abcd_sampler = ABCD(1000) # vcount is required, other ABCDParams are keyword args +graph = abcd_sampler.sample() # return a built ABCDGraph object +``` + ### Parameters - `params`: An instance of `ABCDParams` class. diff --git a/examples/demo.ipynb b/examples/demo.ipynb index 9143a20..793c8eb 100644 --- a/examples/demo.ipynb +++ b/examples/demo.ipynb @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "e9e64ff7-a4cb-4ac8-b9c5-d662aff7e80a", "metadata": {}, "outputs": [ @@ -54,13 +54,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "gamma=2.5 delta=5 zeta=0.5 beta=1.5 s=20 tau=0.8 xi=0.25\n" + "ABCDParams(vcount=100, gamma=2.5, beta=1.5, xi=0.25, min_degree=5, max_degree=30, min_community_size=20, max_community_size=25, degree_sequence=None, community_size_sequence=None, num_outliers=0)\n" ] } ], "source": [ - "params = ABCDParams()\n", - "G = ABCDGraph(params, n=100, callbacks=[stats, vis, props])\n", + "params = ABCDParams(vcount=100, max_community_size=35)\n", + "G = ABCDGraph(params, callbacks=[stats, vis, props])\n", "G.build()\n", "print(params)" ] @@ -75,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "53fccabe-1837-4125-96a9-16651f2d1511", "metadata": {}, "outputs": [ @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "69c0cabf-904f-435c-bb63-26c412d43473", "metadata": {}, "outputs": [ @@ -140,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "9d16b234-c7a9-4e13-ab41-6788cc186ebe", "metadata": {}, "outputs": [ @@ -175,7 +175,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "a659166e-a817-4b8e-8fa2-48fa9ba4a6bf", "metadata": {}, "outputs": [ @@ -205,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "64b006a5-dfe7-49c2-bb18-4b0a5626c797", "metadata": {}, "outputs": [ @@ -250,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "6620a1e7-7eb5-4aa9-84b1-a1afd62025c9", "metadata": {}, "outputs": [ @@ -283,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "49b978d5-eba0-492d-82a7-b126bed97ef0", "metadata": {}, "outputs": [ @@ -323,7 +323,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "02b27e7c-d799-4a8b-b642-84db0cff29b8", "metadata": {}, "outputs": [ @@ -352,7 +352,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "64ea46be-5da1-4e49-8ae4-34eababf67f9", "metadata": {}, "outputs": [ @@ -394,7 +394,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "8a61565c-3acb-46ac-b0c6-9a198a00fd1a", "metadata": {}, "outputs": [ @@ -420,7 +420,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "e87207bb-3c98-4db7-a54e-2de991643359", "metadata": {}, "outputs": [ @@ -508,6 +508,109 @@ " print('number of collisions = ',stats.statistics['number_of_loops']+stats.statistics['number_of_multi_edges'])\n", " print('time_to_build = ',stats.statistics['time_to_build'],'\\n')" ] + }, + { + "cell_type": "markdown", + "id": "5c03a4fe", + "metadata": {}, + "source": [ + "# Alternative Interface\n", + "\n", + "There is another ABCD interface that effectively adds a .sample() method to the ABCDParams class." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "290408f3", + "metadata": {}, + "outputs": [], + "source": [ + "from abcd_graph import ABCD" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ce9619e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "abcd_sampler = ABCD(1000) # vcount is now required\n", + "graph = abcd_sampler.sample()\n", + "graph" + ] + }, + { + "cell_type": "markdown", + "id": "d87a411d", + "metadata": {}, + "source": [ + "Calling .sample() multiple times samples different ABCDGraphs with the same parameters." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7997dd77", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph2 = abcd_sampler.sample()\n", + "graph2 is graph" + ] + }, + { + "cell_type": "markdown", + "id": "46d9c7b4", + "metadata": {}, + "source": [ + "Other ABCD parameters can be set with keyword arguments in the ABCD construction." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b30b5d00", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "abcdo_sampler = ABCD(1000, num_outliers=100)\n", + "abcdo_sampler.sample()" + ] } ], "metadata": { @@ -526,7 +629,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.14" + "version": "3.13.0" } }, "nbformat": 4, From ff6f00f770d419950e379f5d02bf6070f9922441 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 14 Aug 2026 10:30:26 -0400 Subject: [PATCH 04/85] Update changelog --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0a40f3f..b763409 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,8 @@ +## Unreleased + +### Features +- Added top level ABCD object, an alternative interface that effectively adds a .sample() method to the ABCDParams. ([#67](https://github.com/AleksanderWWW/abcd-graph/pull/67)) + ## abcd-graph 0.4.1 ### Changes From 1ef6f1b4c8fbfbb6c2fca53914f410092b1419af Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 14 Aug 2026 10:43:30 -0400 Subject: [PATCH 05/85] Formatting fixes for flake8 --- src/abcd_graph/graph/__init__.py | 2 +- src/abcd_graph/graph/abcd.py | 44 +++++++++++++++++++------------- tests/abcd_graph/test_abcd.py | 1 - 3 files changed, 27 insertions(+), 20 deletions(-) diff --git a/src/abcd_graph/graph/__init__.py b/src/abcd_graph/graph/__init__.py index 05fee6c..2efb2a8 100644 --- a/src/abcd_graph/graph/__init__.py +++ b/src/abcd_graph/graph/__init__.py @@ -1,5 +1,5 @@ __all__ = ["ABCDGraph", "ABCD"] -from abcd_graph.graph.graph import ABCDGraph from abcd_graph.graph.abcd import ABCD +from abcd_graph.graph.graph import ABCDGraph diff --git a/src/abcd_graph/graph/abcd.py b/src/abcd_graph/graph/abcd.py index b13853e..9b3e605 100644 --- a/src/abcd_graph/graph/abcd.py +++ b/src/abcd_graph/graph/abcd.py @@ -1,11 +1,13 @@ +from typing import Sequence + import numpy as np from numpy.typing import NDArray -from typing import Sequence + from abcd_graph.callbacks.abstract import ABCDCallback from abcd_graph.graph import ABCDGraph -from abcd_graph.params import ABCDParams from abcd_graph.models import Model +from abcd_graph.params import ABCDParams __all__ = ["ABCD"] @@ -13,8 +15,8 @@ class ABCD: """Artificial Benchmark for Community Detection - This class combines the ABCDGraph and ABCDParams class, essentially adding a sample - method to ABCDParams. + This class combines the ABCDGraph and ABCDParams class, essentially adding a + sample method to ABCDParams. Parameters ---------- @@ -23,15 +25,17 @@ class ABCD: The number of vertices in the graph. gamma : float, default=2.5 - Powerlaw exponent for the degree distribution. Not used if degree_sequence is passed. + Powerlaw exponent for the degree distribution. Not used if + degree_sequence is passed. beta: float, default=1.5 - Powerlaw exponent for the community size distribution. Not used if a custom - community_size_sequence is passed. + Powerlaw exponent for the community size distribution. Not used if a + custom community_size_sequence is passed. xi: float, default=0.25 - Proportion of edges in the global background graph. Setting xi=0 gives disjoint communities - while xi=1 gives a random graph with no community structure. + Proportion of edges in the global background graph. Setting xi=0 gives + disjoint communities while xi=1 gives a random graph with no community + structure. min_degree : int, default=5 Minimum degree in the graph. Not used if degree_sequence is passed. @@ -40,21 +44,25 @@ class ABCD: Maximum degree in the graph. Not used if degree_sequence is passed. min_community_size : int, default=20 - Minimum community size. Not used if a custom community_size_sequence is passed. + Minimum community size. Not used if a custom community_size_sequence + is passed. max_community_size: int, default=250 - Maximum community size. Not used if a custom community_size_sequence is passed. + Maximum community size. Not used if a custom community_size_sequence + is passed. degree_sequence : Sequence[int] | NDArray[np.int64] | None, default=None - Used to pass a custom degree sequence that overrides the default powerlaw distribution. + Used to pass a custom degree sequence that overrides the default + powerlaw distribution. community_size_sequence : Sequence[int] | NDArray[np.int64] | None, default=None - Used to pass a custom community size sequence that overrides the default powerlaw distribution. - The sum of the community sizes must equal the number of vertices minus the number of outliers. + Used to pass a custom community size sequence that overrides the default + powerlaw distribution. The sum of the community sizes must equal the number + of vertices minus the number of outliers. num_outliers : int, default=0 - The number of outliers. These vertices have their entire degree in the global background graph - so do not appear in any community. + The number of outliers. These vertices have their entire degree in the + global background graph so do not appear in any community. model : Model | None, default=None Random graph model used to sample the community and background graphs. @@ -94,8 +102,8 @@ def __init__( self.verbose = verbose def sample(self, callbacks: list[ABCDCallback] | None = None) -> ABCDGraph: - """Sample an ABCD graph. Calling sample multiple times will overwrite the - self.graph_ object.""" + """Sample an ABCD graph. Calling sample multiple times will overwrite + the self.graph_ object.""" self.params_ = ABCDParams( self.vcount, self.gamma if self.degree_sequence is None else None, diff --git a/tests/abcd_graph/test_abcd.py b/tests/abcd_graph/test_abcd.py index 10f9880..95d023d 100644 --- a/tests/abcd_graph/test_abcd.py +++ b/tests/abcd_graph/test_abcd.py @@ -1,4 +1,3 @@ -import pytest from abcd_graph import ABCD from tests.utils import assert_graph_built From 205cf2a8603943c58c2d53d9c4a47607ecc1aeca Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 14 Aug 2026 10:45:55 -0400 Subject: [PATCH 06/85] More formatting for flake --- src/abcd_graph/__init__.py | 5 ++++- src/abcd_graph/graph/abcd.py | 1 - 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/abcd_graph/__init__.py b/src/abcd_graph/__init__.py index 70b5dde..319e3a3 100644 --- a/src/abcd_graph/__init__.py +++ b/src/abcd_graph/__init__.py @@ -24,5 +24,8 @@ "ABCD", ] -from abcd_graph.graph import ABCDGraph, ABCD +from abcd_graph.graph import ( + ABCDGraph, + ABCD +) from abcd_graph.params import ABCDParams diff --git a/src/abcd_graph/graph/abcd.py b/src/abcd_graph/graph/abcd.py index 9b3e605..8801dd0 100644 --- a/src/abcd_graph/graph/abcd.py +++ b/src/abcd_graph/graph/abcd.py @@ -3,7 +3,6 @@ import numpy as np from numpy.typing import NDArray - from abcd_graph.callbacks.abstract import ABCDCallback from abcd_graph.graph import ABCDGraph from abcd_graph.models import Model From 6fe9732e334ede95d61da0e85ef8b7051a8d82d6 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 14 Aug 2026 10:47:16 -0400 Subject: [PATCH 07/85] More formatting for flake --- src/abcd_graph/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/abcd_graph/__init__.py b/src/abcd_graph/__init__.py index 319e3a3..e9691c8 100644 --- a/src/abcd_graph/__init__.py +++ b/src/abcd_graph/__init__.py @@ -25,7 +25,7 @@ ] from abcd_graph.graph import ( - ABCDGraph, ABCD + ABCDGraph, ) from abcd_graph.params import ABCDParams From c2f88519f2de3a6eb4dd9496b1108878619ec5d9 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 14 Aug 2026 10:49:26 -0400 Subject: [PATCH 08/85] More formatting for flake --- src/abcd_graph/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/abcd_graph/__init__.py b/src/abcd_graph/__init__.py index e9691c8..cdeac78 100644 --- a/src/abcd_graph/__init__.py +++ b/src/abcd_graph/__init__.py @@ -25,7 +25,7 @@ ] from abcd_graph.graph import ( - ABCD + ABCD, ABCDGraph, ) from abcd_graph.params import ABCDParams From 3dbb7b7fbd824112c17a63a1a4324e0c0d6d9818 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 15 Aug 2026 15:21:18 -0400 Subject: [PATCH 09/85] Remove src, tests, profiling --- profiling/profiling_report.py | 22 -- profiling/scaling_report.py | 40 -- src/abcd_graph/__init__.py | 31 -- src/abcd_graph/callbacks/__init__.py | 24 -- src/abcd_graph/callbacks/abstract.py | 45 --- .../callbacks/property_collector.py | 97 ----- src/abcd_graph/callbacks/stats_collector.py | 73 ---- src/abcd_graph/callbacks/visualizer.py | 117 ------ src/abcd_graph/exporter.py | 85 ---- src/abcd_graph/graph/__init__.py | 5 - src/abcd_graph/graph/abcd.py | 128 ------ src/abcd_graph/graph/community.py | 21 - src/abcd_graph/graph/core/__init__.py | 19 - .../graph/core/abcd_objects/__init__.py | 8 - .../graph/core/abcd_objects/abstract.py | 47 --- .../graph/core/abcd_objects/community.py | 94 ----- .../graph/core/abcd_objects/edge.py | 31 -- .../graph/core/abcd_objects/graph_impl.py | 364 ------------------ .../graph/core/abcd_objects/utils.py | 43 --- src/abcd_graph/graph/core/build.py | 212 ---------- src/abcd_graph/graph/core/constants.py | 2 - src/abcd_graph/graph/core/exceptions.py | 25 -- src/abcd_graph/graph/core/utils.py | 55 --- src/abcd_graph/graph/graph.py | 228 ----------- src/abcd_graph/logger.py | 107 ----- src/abcd_graph/models.py | 66 ---- src/abcd_graph/params.py | 112 ------ src/abcd_graph/utils.py | 55 --- src/abcd_graph/version.py | 24 -- tests/__init__.py | 0 tests/abcd_graph/__init__.py | 0 tests/abcd_graph/test_abcd.py | 9 - tests/abcd_graph/test_graph.py | 92 ----- tests/abcd_graph/test_xi_matrix.py | 11 - tests/callbacks/__init__.py | 0 tests/callbacks/test_property_collector.py | 114 ------ tests/callbacks/test_stats_collector.py | 43 --- tests/callbacks/test_visualizer.py | 66 ---- tests/conftest.py | 30 -- tests/test_abcd_params.py | 121 ------ tests/test_exporter.py | 58 --- tests/test_logging.py | 90 ----- tests/test_utils.py | 28 -- tests/utils.py | 25 -- 44 files changed, 2867 deletions(-) delete mode 100644 profiling/profiling_report.py delete mode 100644 profiling/scaling_report.py delete mode 100644 src/abcd_graph/__init__.py delete mode 100644 src/abcd_graph/callbacks/__init__.py delete mode 100644 src/abcd_graph/callbacks/abstract.py delete mode 100644 src/abcd_graph/callbacks/property_collector.py delete mode 100644 src/abcd_graph/callbacks/stats_collector.py delete mode 100644 src/abcd_graph/callbacks/visualizer.py delete mode 100644 src/abcd_graph/exporter.py delete mode 100644 src/abcd_graph/graph/__init__.py delete mode 100644 src/abcd_graph/graph/abcd.py delete mode 100644 src/abcd_graph/graph/community.py delete mode 100644 src/abcd_graph/graph/core/__init__.py delete mode 100644 src/abcd_graph/graph/core/abcd_objects/__init__.py delete mode 100644 src/abcd_graph/graph/core/abcd_objects/abstract.py delete mode 100644 src/abcd_graph/graph/core/abcd_objects/community.py delete mode 100644 src/abcd_graph/graph/core/abcd_objects/edge.py delete mode 100644 src/abcd_graph/graph/core/abcd_objects/graph_impl.py delete mode 100644 src/abcd_graph/graph/core/abcd_objects/utils.py delete mode 100644 src/abcd_graph/graph/core/build.py delete mode 100644 src/abcd_graph/graph/core/constants.py delete mode 100644 src/abcd_graph/graph/core/exceptions.py delete mode 100644 src/abcd_graph/graph/core/utils.py delete mode 100644 src/abcd_graph/graph/graph.py delete mode 100644 src/abcd_graph/logger.py delete mode 100644 src/abcd_graph/models.py delete mode 100644 src/abcd_graph/params.py delete mode 100644 src/abcd_graph/utils.py delete mode 100644 src/abcd_graph/version.py delete mode 100644 tests/__init__.py delete mode 100644 tests/abcd_graph/__init__.py delete mode 100644 tests/abcd_graph/test_abcd.py delete mode 100644 tests/abcd_graph/test_graph.py delete mode 100644 tests/abcd_graph/test_xi_matrix.py delete mode 100644 tests/callbacks/__init__.py delete mode 100644 tests/callbacks/test_property_collector.py delete mode 100644 tests/callbacks/test_stats_collector.py delete mode 100644 tests/callbacks/test_visualizer.py delete mode 100644 tests/conftest.py delete mode 100644 tests/test_abcd_params.py delete mode 100644 tests/test_exporter.py delete mode 100644 tests/test_logging.py delete mode 100644 tests/test_utils.py delete mode 100644 tests/utils.py diff --git a/profiling/profiling_report.py b/profiling/profiling_report.py deleted file mode 100644 index 4e1b46d..0000000 --- a/profiling/profiling_report.py +++ /dev/null @@ -1,22 +0,0 @@ -import cProfile -import pstats - -from abcd_graph import ( - ABCDGraph, - ABCDParams, -) - -params = ABCDParams(vcount=1_000_000, num_outliers=1000) -g = ABCDGraph(params, logger=True) - - -if __name__ == "__main__": - profiler = cProfile.Profile() - profiler.enable() - g.build() - profiler.disable() - stats = pstats.Stats(profiler).sort_stats("cumtime") - - print() - print("######## Profiling report (top 10% of cumulative time) ########") - stats.print_stats(0.1) diff --git a/profiling/scaling_report.py b/profiling/scaling_report.py deleted file mode 100644 index 190b545..0000000 --- a/profiling/scaling_report.py +++ /dev/null @@ -1,40 +0,0 @@ -import time - -import tabulate - -from abcd_graph import ( - ABCDGraph, - ABCDParams, -) - -START = 100_000 -STOP = 1_000_000 -STEP = 100_000 - - -def main() -> None: - stats = [] - for i, vcount in enumerate(range(START, STOP + STEP, STEP)): - y = time_build(vcount) - - if vcount == START: - delta_y = 0 - else: - delta_y = y - stats[int(i) - 1][1] - - stats.append((vcount, y, delta_y)) - - table = tabulate.tabulate(stats, headers=["Vertices", "Time (s)", "Delta time (s)"]) - print(table) - - -def time_build(vcount) -> float: - params = ABCDParams(vcount=vcount) - g = ABCDGraph(params, logger=False) - start = time.perf_counter() - g.build() - return time.perf_counter() - start - - -if __name__ == "__main__": - main() diff --git a/src/abcd_graph/__init__.py b/src/abcd_graph/__init__.py deleted file mode 100644 index cdeac78..0000000 --- a/src/abcd_graph/__init__.py +++ /dev/null @@ -1,31 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -__all__ = [ - "ABCDGraph", - "ABCDParams", - "ABCD", -] - -from abcd_graph.graph import ( - ABCD, - ABCDGraph, -) -from abcd_graph.params import ABCDParams diff --git a/src/abcd_graph/callbacks/__init__.py b/src/abcd_graph/callbacks/__init__.py deleted file mode 100644 index d8a66b1..0000000 --- a/src/abcd_graph/callbacks/__init__.py +++ /dev/null @@ -1,24 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. -__all__ = ["StatsCollector", "PropertyCollector", "Visualizer"] - -from abcd_graph.callbacks.property_collector import PropertyCollector -from abcd_graph.callbacks.stats_collector import StatsCollector -from abcd_graph.callbacks.visualizer import Visualizer diff --git a/src/abcd_graph/callbacks/abstract.py b/src/abcd_graph/callbacks/abstract.py deleted file mode 100644 index f5969b0..0000000 --- a/src/abcd_graph/callbacks/abstract.py +++ /dev/null @@ -1,45 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -import datetime -from abc import ABC -from dataclasses import dataclass -from typing import Optional - -from abcd_graph.exporter import GraphExporter -from abcd_graph.graph.core.abcd_objects import GraphImpl -from abcd_graph.models import Model -from abcd_graph.params import ABCDParams - - -@dataclass -class BuildContext: - model_used: Model - start_time: datetime.datetime - params: ABCDParams - number_of_nodes: int - end_time: Optional[datetime.datetime] = None - raw_build_time: Optional[float] = None - - -class ABCDCallback(ABC): - def before_build(self, context: BuildContext) -> None: ... - - def after_build(self, graph: GraphImpl, context: BuildContext, exporter: GraphExporter) -> None: ... diff --git a/src/abcd_graph/callbacks/property_collector.py b/src/abcd_graph/callbacks/property_collector.py deleted file mode 100644 index c7902fa..0000000 --- a/src/abcd_graph/callbacks/property_collector.py +++ /dev/null @@ -1,97 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -from typing import Optional - -import numpy as np -from numpy.typing import NDArray - -from abcd_graph.callbacks.abstract import ( - ABCDCallback, - BuildContext, -) -from abcd_graph.exporter import GraphExporter -from abcd_graph.graph.core.abcd_objects import ( - Community, - GraphImpl, -) - - -class PropertyCollector(ABCDCallback): - def __init__(self) -> None: - self._graph: Optional[GraphImpl] = None - - self._communities: list[Community] = [] - - self._degree_sequence: dict[int, int] = {} - - self._xi_matrix: Optional[NDArray[np.float64]] = None - - self._expected_degree_cdf: dict[int, float] = {} - - self._actual_degree_cdf: dict[int, float] = {} - - self._expected_community_cdf: dict[int, float] = {} - - self._actual_community_cdf: dict[int, float] = {} - - def after_build(self, graph: GraphImpl, context: BuildContext, exporter: GraphExporter) -> None: - self._graph = graph - - @property - def degree_sequence(self) -> dict[int, int]: - if not self._degree_sequence: - self._degree_sequence = self._graph.degree_sequence # type: ignore[union-attr] - - return self._degree_sequence - - @property - def xi_matrix(self) -> NDArray[np.float64]: - if self._xi_matrix is None: - self._xi_matrix = self._graph.xi_matrix # type: ignore[union-attr] - return self._xi_matrix - - @property - def expected_degree_cdf(self) -> dict[int, float]: - if not self._expected_degree_cdf: - self._expected_degree_cdf = self._graph.expected_degree_cdf # type: ignore[union-attr] - - return self._expected_degree_cdf - - @property - def actual_degree_cdf(self) -> dict[int, float]: - if not self._actual_degree_cdf: - self._actual_degree_cdf = self._graph.actual_degree_cdf # type: ignore[union-attr] - - return self._actual_degree_cdf - - @property - def expected_community_cdf(self) -> dict[int, float]: - if not self._expected_community_cdf: - self._expected_community_cdf = self._graph.expected_community_cdf # type: ignore[union-attr] - - return self._expected_community_cdf - - @property - def actual_community_cdf(self) -> dict[int, float]: - if not self._actual_community_cdf: - self._actual_community_cdf = self._graph.actual_community_cdf # type: ignore[union-attr] - - return self._actual_community_cdf diff --git a/src/abcd_graph/callbacks/stats_collector.py b/src/abcd_graph/callbacks/stats_collector.py deleted file mode 100644 index 58612c4..0000000 --- a/src/abcd_graph/callbacks/stats_collector.py +++ /dev/null @@ -1,73 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -__all__ = ["StatsCollector"] - -from typing import Any - -from abcd_graph.callbacks.abstract import ( - ABCDCallback, - BuildContext, -) -from abcd_graph.exporter import GraphExporter -from abcd_graph.graph.core.abcd_objects.graph_impl import GraphImpl - - -class StatsCollector(ABCDCallback): - def __init__(self) -> None: - self._statistics: dict[str, Any] = {} - - @property - def statistics(self) -> dict[str, Any]: - return self._statistics - - def log_statistic(self, key: str, value: Any) -> None: - self._statistics[key] = value - - def fetch_statistic(self, key: str) -> Any: - return self._statistics[key] - - def before_build(self, context: BuildContext) -> None: - self.log_statistic("model_used", context.model_used.__name__) - self.log_statistic("params", context.params) - self.log_statistic("number_of_nodes", context.number_of_nodes) - - def after_build(self, graph: "GraphImpl", context: BuildContext, exporter: GraphExporter) -> None: - _ = exporter - - self.log_statistic("start_time", context.start_time) - self.log_statistic("end_time", context.end_time) - self.log_statistic("time_to_build", context.raw_build_time) - - self.log_statistic("number_of_edges", len(graph.edges)) - self.log_statistic("number_of_communities", graph.num_communities) - self.log_statistic("expected_average_degree", graph.expected_average_degree) - self.log_statistic("actual_average_degree", graph.average_degree) - self.log_statistic("expected_average_community_size", graph.expected_average_community_size) - self.log_statistic("actual_average_community_size", graph.actual_average_community_size) - self.log_statistic("number_of_loops", graph.num_loops) - self.log_statistic("number_of_multi_edges", graph.num_multi_edges) - - self.log_statistic("empirical_xi", get_empirical_xi(graph)) - - -def get_empirical_xi(graph: GraphImpl) -> float: - num_community_edges = sum(len(community.edges) for community in graph.communities) - return 1 - (num_community_edges / len(graph.edges)) diff --git a/src/abcd_graph/callbacks/visualizer.py b/src/abcd_graph/callbacks/visualizer.py deleted file mode 100644 index b503617..0000000 --- a/src/abcd_graph/callbacks/visualizer.py +++ /dev/null @@ -1,117 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -from typing import Optional - -from abcd_graph.callbacks.abstract import ( - ABCDCallback, - BuildContext, -) -from abcd_graph.exporter import GraphExporter -from abcd_graph.graph.core.abcd_objects import ( - Community, - GraphImpl, -) -from abcd_graph.graph.core.utils import get_community_color_map -from abcd_graph.models import Model -from abcd_graph.utils import require - - -class Visualizer(ABCDCallback): - def __init__(self) -> None: - self._communities: list[Community] = [] - self._model_used: Optional[Model] = None - self._exporter: Optional[GraphExporter] = None - self._graph: Optional[GraphImpl] = None - - def after_build(self, graph: GraphImpl, context: BuildContext, exporter: GraphExporter) -> None: - self._communities = graph.communities - self._model_used = context.model_used - self._exporter = exporter - - self._graph = graph - - @require("matplotlib") - def draw_community_cdf(self) -> None: - import matplotlib.pyplot as plt # type: ignore[import] - - assert self._graph is not None - - actual_cdf = self._graph.actual_community_cdf - expected_cdf = self._graph.expected_community_cdf - - x_actual = list(actual_cdf.keys()) - x_expected = list(expected_cdf.keys()) - y_actual = list(actual_cdf.values()) - y_expected = list(expected_cdf.values()) - - plt.plot(x_actual, y_actual, label="Actual") - plt.plot(x_expected, y_expected, label="Expected") - - plt.xlabel("Community Size") - plt.ylabel("CDF") - plt.legend() - plt.title("Community size CDF") - plt.show() - - @require("matplotlib") - def draw_degree_cdf(self) -> None: - import matplotlib.pyplot as plt - - assert self._graph is not None - - actual_cdf = self._graph.actual_degree_cdf - expected_cdf = self._graph.expected_degree_cdf - - x_actual = list(actual_cdf.keys()) - x_expected = list(expected_cdf.keys()) - y_actual = list(actual_cdf.values()) - y_expected = list(expected_cdf.values()) - - plt.plot(x_actual, y_actual, label="Actual") - plt.plot(x_expected, y_expected, label="Expected") - - plt.xlabel("Degree") - plt.ylabel("CDF") - plt.legend() - plt.title("Degree CDF") - plt.show() - - @require("networkx") - @require("matplotlib") - def draw_communities(self) -> None: - assert self._graph is not None - if len(self._graph.deg_b) > 100: - raise ValueError("Drawing communities is only supported for graphs with at most 100 vertices") - - if self._model_used is not None and self._model_used.__name__ != "configuration_model": - raise NotImplementedError("Drawing communities is only supported for the configuration model") - - import networkx as nx # type: ignore[import] - from matplotlib import pyplot as plt - - assert self._exporter is not None - - nx_g = self._exporter.to_networkx() - - color_map = get_community_color_map(communities=self._communities) - - nx.draw(nx_g, node_color=color_map, with_labels=True, font_weight="bold") - plt.show() diff --git a/src/abcd_graph/exporter.py b/src/abcd_graph/exporter.py deleted file mode 100644 index 52b4bbc..0000000 --- a/src/abcd_graph/exporter.py +++ /dev/null @@ -1,85 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -from typing import TYPE_CHECKING - -import numpy as np -from numpy.typing import NDArray - -from abcd_graph.graph.core.abcd_objects import GraphImpl -from abcd_graph.graph.core.exceptions import MalformedGraphException -from abcd_graph.utils import require - -if TYPE_CHECKING: # pragma: no cover - from igraph import Graph as IGraph # type: ignore[import] - from networkx import Graph as NetworkXGraph # type: ignore[import] - from scipy.sparse import csr_matrix # type: ignore[import] - - -class GraphExporter: - def __init__(self, graph: GraphImpl) -> None: - self._graph: GraphImpl = graph - - @property - def is_proper_abcd(self) -> bool: - return self._graph.is_proper_abcd - - def to_adjacency_matrix(self) -> NDArray[np.bool_]: - if not self.is_proper_abcd: - raise MalformedGraphException("Graph is not proper ABCD so the adjacency matrix cannot be built") - - assert self._graph is not None - return self._graph.to_adj_matrix() - - @require("scipy") - def to_sparse_adjacency_matrix(self) -> "csr_matrix": # type: ignore[no-any-unimported] - from scipy.sparse import csr_matrix - - if not self.is_proper_abcd: - raise MalformedGraphException("Graph is not proper ABCD so the adjacency matrix cannot be built") - - assert self._graph is not None - return csr_matrix(self.to_adjacency_matrix()) - - @require("igraph") - def to_igraph(self) -> "IGraph": # type: ignore[no-any-unimported] - import igraph - - graph = igraph.Graph(self._graph.edges) - - graph.vs["ground_truth_community"] = self._graph.membership_list - - return graph - - @require("networkx") - def to_networkx(self) -> "NetworkXGraph": # type: ignore[no-any-unimported] - import networkx as nx - - graph = nx.Graph() - - graph.add_nodes_from(range(self._graph._params.vcount)) - graph.add_edges_from(self._graph.edges) - - m_list = self._graph.membership_list - - for node in graph.nodes: - graph.nodes[node]["ground_truth_community"] = m_list[node] - - return graph diff --git a/src/abcd_graph/graph/__init__.py b/src/abcd_graph/graph/__init__.py deleted file mode 100644 index 2efb2a8..0000000 --- a/src/abcd_graph/graph/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -__all__ = ["ABCDGraph", "ABCD"] - - -from abcd_graph.graph.abcd import ABCD -from abcd_graph.graph.graph import ABCDGraph diff --git a/src/abcd_graph/graph/abcd.py b/src/abcd_graph/graph/abcd.py deleted file mode 100644 index 8801dd0..0000000 --- a/src/abcd_graph/graph/abcd.py +++ /dev/null @@ -1,128 +0,0 @@ -from typing import Sequence - -import numpy as np -from numpy.typing import NDArray - -from abcd_graph.callbacks.abstract import ABCDCallback -from abcd_graph.graph import ABCDGraph -from abcd_graph.models import Model -from abcd_graph.params import ABCDParams - -__all__ = ["ABCD"] - - -class ABCD: - """Artificial Benchmark for Community Detection - - This class combines the ABCDGraph and ABCDParams class, essentially adding a - sample method to ABCDParams. - - Parameters - ---------- - - vcount : int - The number of vertices in the graph. - - gamma : float, default=2.5 - Powerlaw exponent for the degree distribution. Not used if - degree_sequence is passed. - - beta: float, default=1.5 - Powerlaw exponent for the community size distribution. Not used if a - custom community_size_sequence is passed. - - xi: float, default=0.25 - Proportion of edges in the global background graph. Setting xi=0 gives - disjoint communities while xi=1 gives a random graph with no community - structure. - - min_degree : int, default=5 - Minimum degree in the graph. Not used if degree_sequence is passed. - - max_degree : int, default=30 - Maximum degree in the graph. Not used if degree_sequence is passed. - - min_community_size : int, default=20 - Minimum community size. Not used if a custom community_size_sequence - is passed. - - max_community_size: int, default=250 - Maximum community size. Not used if a custom community_size_sequence - is passed. - - degree_sequence : Sequence[int] | NDArray[np.int64] | None, default=None - Used to pass a custom degree sequence that overrides the default - powerlaw distribution. - - community_size_sequence : Sequence[int] | NDArray[np.int64] | None, default=None - Used to pass a custom community size sequence that overrides the default - powerlaw distribution. The sum of the community sizes must equal the number - of vertices minus the number of outliers. - - num_outliers : int, default=0 - The number of outliers. These vertices have their entire degree in the - global background graph so do not appear in any community. - - model : Model | None, default=None - Random graph model used to sample the community and background graphs. - - verbose : bool, default=False - Flag to log runtime infomation. - """ - - def __init__( - self, - vcount: int, - gamma: float = 2.5, - beta: float = 1.5, - xi: float = 0.25, - min_degree: int = 5, - max_degree: int = 30, - min_community_size: int = 20, - max_community_size: int = 250, - degree_sequence: Sequence[int] | NDArray[np.int64] | None = None, - community_size_sequence: Sequence[int] | NDArray[np.int64] | None = None, - num_outliers: int = 0, - model: Model | None = None, - verbose: bool = False, - ): - self.vcount = vcount - self.xi = xi - self.min_degree = min_degree - self.max_degree = max_degree - self.gamma = gamma - self.min_community_size = min_community_size - self.max_community_size = max_community_size - self.beta = beta - self.degree_sequence = degree_sequence - self.community_size_sequence = community_size_sequence - self.num_outliers = num_outliers - self.model = model - self.verbose = verbose - - def sample(self, callbacks: list[ABCDCallback] | None = None) -> ABCDGraph: - """Sample an ABCD graph. Calling sample multiple times will overwrite - the self.graph_ object.""" - self.params_ = ABCDParams( - self.vcount, - self.gamma if self.degree_sequence is None else None, - self.beta if self.community_size_sequence is None else None, - self.xi, - self.min_degree if self.degree_sequence is None else None, - self.max_degree if self.degree_sequence is None else None, - self.min_community_size if self.community_size_sequence is None else None, - self.max_community_size if self.community_size_sequence is None else None, - self.degree_sequence, - self.community_size_sequence, - self.num_outliers, - ) - - self.graph_ = ABCDGraph( - self.params_, - logger=self.verbose, - callbacks=callbacks, - ) - - self.graph_.build(self.model) - - return self.graph_ diff --git a/src/abcd_graph/graph/community.py b/src/abcd_graph/graph/community.py deleted file mode 100644 index 2e79856..0000000 --- a/src/abcd_graph/graph/community.py +++ /dev/null @@ -1,21 +0,0 @@ -class ABCDCommunity: - def __init__( - self, - community_id: int, - vertices: list[int], - average_degree: float, - degree_sequence: dict[int, int], - empirical_xi: float, - ) -> None: - self._community_id = community_id - self.vertices = vertices - self.average_degree = average_degree - self.degree_sequence = degree_sequence - self.empirical_xi = empirical_xi - - @property - def community_id(self) -> int: - return self._community_id - - def __repr__(self) -> str: # pragma: no cover - return f"ABCDCommunityObj(id={self._community_id}, vertices={self.vertices[0]}-{self.vertices[-1]})" diff --git a/src/abcd_graph/graph/core/__init__.py b/src/abcd_graph/graph/core/__init__.py deleted file mode 100644 index 017a8f0..0000000 --- a/src/abcd_graph/graph/core/__init__.py +++ /dev/null @@ -1,19 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. diff --git a/src/abcd_graph/graph/core/abcd_objects/__init__.py b/src/abcd_graph/graph/core/abcd_objects/__init__.py deleted file mode 100644 index 07169f5..0000000 --- a/src/abcd_graph/graph/core/abcd_objects/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -__all__ = ["Edge", "GraphImpl", "Community", "BackgroundGraph"] - -from abcd_graph.graph.core.abcd_objects.community import ( - BackgroundGraph, - Community, -) -from abcd_graph.graph.core.abcd_objects.edge import Edge -from abcd_graph.graph.core.abcd_objects.graph_impl import GraphImpl diff --git a/src/abcd_graph/graph/core/abcd_objects/abstract.py b/src/abcd_graph/graph/core/abcd_objects/abstract.py deleted file mode 100644 index 1b3c617..0000000 --- a/src/abcd_graph/graph/core/abcd_objects/abstract.py +++ /dev/null @@ -1,47 +0,0 @@ -import abc - -from abcd_graph.graph.core.abcd_objects.edge import Edge - - -class AbstractGraph(abc.ABC): - @property - @abc.abstractmethod - def adj_dict(self) -> dict[Edge, int]: ... - - -class AbstractCommunity(AbstractGraph): - def __init__(self, edges: list[Edge], community_id: int) -> None: - self.community_id = community_id - self._adj_dict: dict[Edge, int] = {} - self._bad_edges: list[Edge] = [] - - self._diagnostics = { - "num_loops": 0, - "num_multi_edges": 0, - } - - for edge in edges: - if edge.is_loop: - self._bad_edges.append(edge) - self._diagnostics["num_loops"] += 1 - - if edge in self.adj_dict: - self._bad_edges.append(edge) - self._adj_dict[edge] += 1 - self._diagnostics["num_multi_edges"] += 1 - else: - self._adj_dict[edge] = 1 - - self._edges = edges - - @property - def edges(self) -> list[Edge]: - return self._edges - - @property - def adj_dict(self) -> dict[Edge, int]: - return self._adj_dict - - @property - def diagnostics(self) -> dict[str, int]: - return self._diagnostics diff --git a/src/abcd_graph/graph/core/abcd_objects/community.py b/src/abcd_graph/graph/core/abcd_objects/community.py deleted file mode 100644 index 6ec1cc0..0000000 --- a/src/abcd_graph/graph/core/abcd_objects/community.py +++ /dev/null @@ -1,94 +0,0 @@ -__all__ = ["Community", "BackgroundGraph"] - -from abcd_graph.graph.core.abcd_objects.abstract import AbstractCommunity -from abcd_graph.graph.core.abcd_objects.edge import Edge -from abcd_graph.graph.core.abcd_objects.utils import ( - build_recycle_list, - choose_other_edge, - rewire_edge, -) -from abcd_graph.graph.core.constants import BACKGROUND_GRAPH_ID - - -class Community(AbstractCommunity): - def __init__( - self, - edges: list[Edge], - vertices: list[int], - deg_b: dict[int, int], - deg_c: dict[int, int], - community_id: int, - ) -> None: - super().__init__(edges, community_id) - - self._vertices = vertices - self._deg_b = deg_b - self._deg_c = deg_c - - def __eq__(self, other: object) -> bool: - if not isinstance(other, AbstractCommunity): - return False - return self.community_id == other.community_id - - def __hash__(self) -> int: - return hash(self.community_id) - - @property - def vertices(self) -> list[int]: - return self._vertices - - @property - def average_degree(self) -> float: - return sum(self.degree_sequence.values()) / len(self.vertices) - - @property - def degree_sequence(self) -> dict[int, int]: - res = {} - for vert in self.vertices: - res[vert] = self._deg_c[vert] + self._deg_b[vert] - return res - - @property - def empirical_xi(self) -> float: - return sum(self._deg_b[i] for i in self.vertices) / ( - sum(self._deg_b[i] + self._deg_c[i] for i in self.vertices) - ) - - def push_to_background(self, edges: list[Edge], deg_b: dict[int, int]) -> None: - for edge in edges: - if edge.is_loop: - for i in range(self.adj_dict[edge]): - self.adj_dict[edge] -= 1 - if self.adj_dict[edge] == 0: - del self.adj_dict[edge] - - self._update_degree_sequences(edge, deg_b) - else: - for i in range(self.adj_dict[edge] - 1): - self.adj_dict[edge] -= 1 - - self._update_degree_sequences(edge, deg_b) - - def _update_degree_sequences(self, edge: Edge, deg_b: dict[int, int]) -> None: - deg_b[edge.v1] += 1 - deg_b[edge.v2] += 1 - self._deg_c[edge.v1] -= 1 - self._deg_c[edge.v2] -= 1 - - def rewire_community(self) -> None: - while len(self._bad_edges) > 0: - for edge in self._bad_edges: - other_edge = choose_other_edge(self.adj_dict, edge) - rewire_edge(self.adj_dict, edge, other_edge) - - new_bad_edges = build_recycle_list(self.adj_dict) - if len(new_bad_edges) >= len(self._bad_edges): - self.push_to_background(new_bad_edges, self._deg_b) - return - else: - self._bad_edges = new_bad_edges - - -class BackgroundGraph(AbstractCommunity): - def __init__(self, edges: list[Edge]) -> None: - super().__init__(edges, community_id=-BACKGROUND_GRAPH_ID) diff --git a/src/abcd_graph/graph/core/abcd_objects/edge.py b/src/abcd_graph/graph/core/abcd_objects/edge.py deleted file mode 100644 index ad9d50b..0000000 --- a/src/abcd_graph/graph/core/abcd_objects/edge.py +++ /dev/null @@ -1,31 +0,0 @@ -__all__ = ["Edge"] - -from dataclasses import dataclass -from typing import Any - - -@dataclass -class Edge: - __slots__ = ["v1", "v2"] - - v1: int - v2: int - - def __post_init__(self) -> None: - self.to_ordered() - - def __eq__(self, other: Any) -> bool: - if not isinstance(other, Edge): - return NotImplemented - return self.v1 == other.v1 and self.v2 == other.v2 - - def __hash__(self) -> int: - return hash((self.v1, self.v2)) - - def to_ordered(self) -> None: - if self.v1 < self.v2: - self.v1, self.v2 = self.v2, self.v1 - - @property - def is_loop(self) -> bool: - return self.v1 == self.v2 diff --git a/src/abcd_graph/graph/core/abcd_objects/graph_impl.py b/src/abcd_graph/graph/core/abcd_objects/graph_impl.py deleted file mode 100644 index e41a825..0000000 --- a/src/abcd_graph/graph/core/abcd_objects/graph_impl.py +++ /dev/null @@ -1,364 +0,0 @@ -__all__ = ["GraphImpl"] - -from typing import ( - Optional, - cast, -) - -import numpy as np -from numpy.typing import NDArray - -from abcd_graph.graph.core.abcd_objects import ( - BackgroundGraph, - Community, - Edge, -) -from abcd_graph.graph.core.abcd_objects.abstract import AbstractGraph -from abcd_graph.graph.core.abcd_objects.utils import ( - build_recycle_list, - choose_other_edge, - rewire_edge, -) -from abcd_graph.graph.core.constants import OUTLIER_COMMUNITY_ID -from abcd_graph.models import Model -from abcd_graph.params import ABCDParams - -UNSUPPORTED_OPERATION_CUSTOM_SEQUENCE_MSG = """Cannot compute {operation_name} because relevant parameters are `None`. - If you passed custom degree sequence to `ABCDParams()` you cannot use this property. - Otherwise this might be a bug on our side - please contact the maintainers or submit a GitHub issue. - """ - - -class GraphImpl(AbstractGraph): - def __init__(self, deg_b: dict[int, int], deg_c: dict[int, int], params: ABCDParams) -> None: - self.deg_b = deg_b - self.deg_c = deg_c - - self._params = params - - self.communities: list[Community] = [] - self.background_graph: Optional[BackgroundGraph] = None - - self._adj_dict: dict[Edge, int] = {} - - @property - def average_degree(self) -> float: - return (sum(self.deg_b.values()) + sum(self.deg_c.values())) / len(self.deg_b) - - @property - def expected_average_degree(self) -> float: - if not all([self._params.gamma, self._params.min_degree, self._params.max_degree]): - raise RuntimeError( - UNSUPPORTED_OPERATION_CUSTOM_SEQUENCE_MSG.format(operation_name="expected average degree") - ) - - self._params.gamma = cast(float, self._params.gamma) - self._params.min_degree = cast(int, self._params.min_degree) - self._params.max_degree = cast(int, self._params.max_degree) - - bottom: float = sum( - k ** (-self._params.gamma) for k in range(self._params.min_degree, self._params.max_degree + 1) - ) - top: float = sum( - k ** (1 - self._params.gamma) for k in range(self._params.min_degree, self._params.max_degree + 1) - ) - - return top / bottom - - @property - def actual_degree_cdf(self) -> dict[int, float]: - return self._calc_actual_degree_cdf() - - def _calc_actual_degree_cdf(self) -> dict[int, float]: - deg = {v: self.deg_b[v] + self.deg_c[v] for v in self.deg_b} - sorted_deg = sorted(list(deg.values())) - val = sorted_deg[0] - cdf = {val: 1 / self._params.vcount} - for d in sorted_deg[1:]: - new_val = d - if new_val == val: - cdf[new_val] += 1 / self._params.vcount - else: - cdf[new_val] = cdf[val] + 1 / self._params.vcount - val = new_val - return cdf - - @property - def expected_degree_cdf(self) -> dict[int, float]: - if not all([self._params.gamma, self._params.min_degree, self._params.max_degree]): - raise RuntimeError(UNSUPPORTED_OPERATION_CUSTOM_SEQUENCE_MSG.format(operation_name="expected degree cdf")) - - return self._calc_expected_degree_cdf() - - def _calc_expected_degree_cdf(self) -> dict[int, float]: - self._params.gamma = cast(float, self._params.gamma) - self._params.min_degree = cast(int, self._params.min_degree) - self._params.max_degree = cast(int, self._params.max_degree) - - cdf = {} - bottom = sum(k ** (-self._params.gamma) for k in range(self._params.min_degree, self._params.max_degree + 1)) - - for d in range(self._params.min_degree, self._params.max_degree + 1): - cdf[d] = sum(k ** (-self._params.gamma) for k in range(self._params.min_degree, d + 1)) / bottom - return cdf - - @property - def actual_average_community_size(self) -> float: - return self._calc_actual_average_community_size() - - def _calc_actual_average_community_size(self) -> float: - volume = sum( - len(c.vertices) for c in self.communities if c.community_id != OUTLIER_COMMUNITY_ID - ) # Excluding outliers - num_communities = len([c for c in self.communities if c.community_id != OUTLIER_COMMUNITY_ID]) - return volume / num_communities - - @property - def expected_average_community_size(self) -> float: - if not all([self._params.beta, self._params.min_community_size, self._params.max_community_size]): - raise RuntimeError( - UNSUPPORTED_OPERATION_CUSTOM_SEQUENCE_MSG.format(operation_name="expected average community size") - ) - - return self._calc_expected_average_community_size() - - def _calc_expected_average_community_size(self) -> float: - self._params.beta = cast(float, self._params.beta) - self._params.min_community_size = cast(int, self._params.min_community_size) - self._params.max_community_size = cast(int, self._params.max_community_size) - - bottom: float = sum( - k ** (-self._params.beta) - for k in range(self._params.min_community_size, self._params.max_community_size + 1) - ) - top: float = sum( - k ** (1 - self._params.beta) - for k in range(self._params.min_community_size, self._params.max_community_size + 1) - ) - return top / bottom - - @property - def actual_community_cdf(self) -> dict[int, float]: - return self._calc_actual_community_cdf() - - def _calc_actual_community_cdf(self) -> dict[int, float]: - L = len([c for c in self.communities if c.community_id != OUTLIER_COMMUNITY_ID]) # Excluding outliers - sizes = {c: len(c.vertices) for c in self.communities if c.community_id != OUTLIER_COMMUNITY_ID} - sorted_sizes = sorted(list(sizes.values())) - val = sorted_sizes[0] - cdf = {val: 1 / L} - for s in sorted_sizes[1:]: - new_val = s - if new_val == val: - cdf[new_val] += 1 / L - else: - cdf[new_val] = cdf[val] + 1 / L - val = new_val - return cdf - - @property - def expected_community_cdf(self) -> dict[int, float]: - if not all([self._params.beta, self._params.min_community_size, self._params.max_community_size]): - raise RuntimeError( - UNSUPPORTED_OPERATION_CUSTOM_SEQUENCE_MSG.format(operation_name="expected community cdf") - ) - - return self._calc_expected_community_cdf() - - def _calc_expected_community_cdf(self) -> dict[int, float]: - self._params.beta = cast(float, self._params.beta) - self._params.min_community_size = cast(int, self._params.min_community_size) - self._params.max_community_size = cast(int, self._params.max_community_size) - - cdf = {} - bottom = sum( - k ** (-self._params.beta) - for k in range(self._params.min_community_size, self._params.max_community_size + 1) - ) - for s in range(self._params.min_community_size, self._params.max_community_size + 1): - cdf[s] = sum(k ** (-self._params.beta) for k in range(self._params.min_community_size, s + 1)) / bottom - return cdf - - @property - def num_loops(self) -> int: - assert self.background_graph is not None - - return ( - sum(community.diagnostics["num_loops"] for community in self.communities) - + self.background_graph.diagnostics["num_loops"] - ) - - @property - def num_multi_edges(self) -> int: - assert self.background_graph is not None - - return ( - sum(community.diagnostics["num_multi_edges"] for community in self.communities) - + self.background_graph.diagnostics["num_multi_edges"] - ) - - @property - def xi_matrix(self) -> NDArray[np.float64]: - if self._params.xi == 0: - raise ValueError("xi_matrix only available if xi > 0") - - return XiMatrixBuilder(self._params.xi, self.communities, self._adj_dict, self.deg_b).build() - - @property - def degree_sequence(self) -> dict[int, int]: - deg = {v: 0 for v in range(len(self.deg_b))} - for e in self.edges: - deg[e[0]] += 1 - deg[e[1]] += 1 - return deg - - @property - def adj_dict(self) -> dict[Edge, int]: - return self._adj_dict - - def to_adj_matrix(self) -> NDArray[np.bool_]: - adj_matrix = np.zeros((len(self.deg_b), len(self.deg_b)), dtype=bool) - for edge in self._adj_dict: - adj_matrix[edge.v1, edge.v2] = True - adj_matrix[edge.v2, edge.v1] = True - - return adj_matrix - - @property - def edges(self) -> list[tuple[int, int]]: - return [(edge.v1, edge.v2) for edge in self._adj_dict] - - @property - def is_proper_abcd(self) -> bool: - return len(build_recycle_list(self._adj_dict)) == 0 - - @property - def num_communities(self) -> int: - return len(self.communities) if self._params.num_outliers == 0 else len(self.communities) - 1 - - @property - def membership_list(self) -> list[int]: - result = [] - - for community in self.communities: - result += [community.community_id] * len(community.vertices) - - return result - - def build_communities(self, communities: dict[int, list[int]], model: Model) -> "GraphImpl": - for community_id, community_vertices in communities.items(): - community_edges = model({v: self.deg_c[v] for v in community_vertices}) - community_obj = Community( - edges=[Edge(e[0], e[1]) for e in community_edges], - vertices=community_vertices, - deg_b=self.deg_b, - deg_c=self.deg_c, - community_id=community_id, - ) - community_obj.rewire_community() - - assert len(build_recycle_list(community_obj.adj_dict)) == 0 - - self.communities.append(community_obj) - - return self - - def build_background_edges(self, model: Model) -> "GraphImpl": - edges = [Edge(edge[0], edge[1]) for edge in model(self.deg_b)] - self.background_graph = BackgroundGraph(edges) - self._adj_dict = self.background_graph.adj_dict - - return self - - def combine_edges(self) -> "GraphImpl": - for community in self.communities: - for edge, count in community.adj_dict.items(): - if edge in self._adj_dict: - self._adj_dict[edge] += count - else: - self._adj_dict[edge] = count - - return self - - def rewire_graph(self) -> "GraphImpl": - bad_edges = build_recycle_list(self._adj_dict) - - while len(bad_edges) > 0: - for edge in bad_edges: - other_edge = choose_other_edge(self._adj_dict, edge) - rewire_edge(self._adj_dict, edge, other_edge) - - bad_edges = build_recycle_list(self._adj_dict) - - return self - - -class XiMatrixBuilder: - def __init__( - self, - xi: float, - communities: list[Community], - adj_matrix: dict[Edge, int], - deg_b: dict[int, int], - ) -> None: - self.xi = xi - self.communities = communities - self._community_len = len(communities) - self.adj_matrix = adj_matrix - self.deg_b = deg_b - - self.location: dict[int, int] = {} - self.actual_betweenness_matrix = np.zeros((self._community_len, self._community_len)) - self.expected_betweenness_matrix = np.zeros((self._community_len, self._community_len)) - self.normalized_betweeness_matrix = np.zeros((self._community_len, self._community_len)) - - def _build_location(self) -> None: - for c in self.communities: - for v in c.vertices: - self.location[v] = c.community_id - - def _build_actual_matrix(self) -> None: - for edge in self.adj_matrix: - self.actual_betweenness_matrix[self.location[edge.v1]][self.location[edge.v2]] += 1 - self.actual_betweenness_matrix[self.location[edge.v2]][self.location[edge.v1]] += 1 - - def _build_expectation_matrix(self) -> None: - # Pre-compute community volumes and empirical xi's before looping - vol = {c.community_id: sum(c.degree_sequence.values()) for c in self.communities} - empirical_xi = {c.community_id: c.empirical_xi for c in self.communities} - bottom = sum(self.deg_b.values()) - 1 - for c_i in self.communities: - for c_j in self.communities: - if c_i.community_id == OUTLIER_COMMUNITY_ID: - vol_i = float(vol[OUTLIER_COMMUNITY_ID]) - else: - vol_i = vol[c_i.community_id] * empirical_xi[c_i.community_id] - if c_j.community_id == OUTLIER_COMMUNITY_ID: - vol_j = float(vol[OUTLIER_COMMUNITY_ID]) - else: - vol_j = vol[c_j.community_id] * empirical_xi[c_j.community_id] - top = vol_i * vol_j - - self.expected_betweenness_matrix[c_i.community_id][c_j.community_id] = top / bottom - self.expected_betweenness_matrix[c_j.community_id][c_i.community_id] = top / bottom - - def _build_normalized_matrix(self) -> None: - for c_i in self.communities: - for c_j in self.communities: - if c_i == c_j and c_i.community_id != OUTLIER_COMMUNITY_ID: - self.normalized_betweeness_matrix[c_i.community_id][c_j.community_id] = (1 - c_i.empirical_xi) / ( - 1 - self.xi - ) - else: - self.normalized_betweeness_matrix[c_i.community_id][c_j.community_id] = ( - self.actual_betweenness_matrix[c_i.community_id][c_j.community_id] - / self.expected_betweenness_matrix[c_i.community_id][c_j.community_id] - ) - - def build(self) -> NDArray[np.float64]: - self._build_location() - self._build_actual_matrix() - self._build_expectation_matrix() - self._build_normalized_matrix() - - return self.normalized_betweeness_matrix diff --git a/src/abcd_graph/graph/core/abcd_objects/utils.py b/src/abcd_graph/graph/core/abcd_objects/utils.py deleted file mode 100644 index 9af6d46..0000000 --- a/src/abcd_graph/graph/core/abcd_objects/utils.py +++ /dev/null @@ -1,43 +0,0 @@ -import random - -from abcd_graph.graph.core.abcd_objects.edge import Edge - - -def build_recycle_list(adj_matrix: dict["Edge", int]) -> list["Edge"]: - return [edge for edge in adj_matrix.keys() if adj_matrix[edge] > 1 or edge.is_loop] - - -def choose_other_edge(adj_matrix: dict["Edge", int], edge: "Edge") -> "Edge": - edges = list(adj_matrix.keys()) - other_edge = random.choice(edges) - while other_edge == edge: - other_edge = random.choice(edges) - - return other_edge - - -def rewire_edge(adj_matrix: dict["Edge", int], edge: "Edge", other_edge: "Edge") -> None: - if edge not in adj_matrix: - return - adj_matrix[edge] -= 1 - - if adj_matrix[edge] == 0: - del adj_matrix[edge] - - adj_matrix[other_edge] -= 1 - if adj_matrix[other_edge] == 0: - del adj_matrix[other_edge] - - new_edge = Edge(edge.v1, other_edge.v1) - - if new_edge in adj_matrix: - adj_matrix[new_edge] += 1 - else: - adj_matrix[new_edge] = 1 - - new_edge = Edge(edge.v2, other_edge.v2) - - if new_edge in adj_matrix: - adj_matrix[new_edge] += 1 - else: - adj_matrix[new_edge] = 1 diff --git a/src/abcd_graph/graph/core/build.py b/src/abcd_graph/graph/core/build.py deleted file mode 100644 index d5adec1..0000000 --- a/src/abcd_graph/graph/core/build.py +++ /dev/null @@ -1,212 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -__all__ = [ - "build_communities", - "build_degrees", - "assign_degrees", - "split_degrees", - "build_community_sizes", - "add_outliers", -] - -from typing import Any - -import numpy as np -from numpy.typing import NDArray - -from abcd_graph.graph.core.constants import OUTLIER_COMMUNITY_ID -from abcd_graph.graph.core.utils import ( - powerlaw_distribution, - rand_round, -) - - -def build_degrees(n: int, gamma: float, min_degree: int, max_degree: int) -> NDArray[np.int64]: - avail = np.arange(min_degree, max_degree + 1, dtype=float) - - probabilities = powerlaw_distribution(avail, gamma) - - degrees = np.sort(np.random.choice(avail, size=n, p=probabilities))[::-1] - - if degrees.sum() % 2 == 1: - degrees[0] += 1 - - return degrees - - -def build_community_sizes(n: int, beta: float, min_community_size: int, max_community_size: int) -> NDArray[np.int64]: - max_community_number = int(np.ceil(n / min_community_size)) - avail = np.arange(min_community_size, max_community_size + 1, dtype=float) - - probabilities = powerlaw_distribution(avail, beta) - - big_list: NDArray[np.int64] = np.random.choice(avail, size=max_community_number, p=probabilities) - community_sizes: NDArray[np.int64] = np.zeros(max_community_number, dtype=np.int64) - - index = 0 - while community_sizes.sum() < n: - community_sizes[index] = big_list[index] - index += 1 - - community_sizes = community_sizes[:index] - excess = community_sizes.sum() - n - if excess > 0: - if (community_sizes[-1] - excess) >= min_community_size: - community_sizes[-1] -= excess - else: - removed = community_sizes[-1] - community_sizes = community_sizes[:-1] - for i in range(removed - excess): - community_sizes[i % len(community_sizes)] += 1 - return np.sort(community_sizes)[::-1] - - -def build_communities(community_sizes: NDArray[np.int64]) -> dict[int, list[int]]: - communities = {} - v_last = 0 - for i, c in enumerate(community_sizes): - communities[i] = [v for v in range(v_last, v_last + c)] - v_last += c - return communities - - -def assign_degrees( - degrees: NDArray[np.int64], - communities: dict[int, list[int]], - community_sizes: NDArray[np.int64], - xi: float, -) -> dict[int, Any]: - phi = 1 - np.sum(community_sizes**2) / (len(degrees) ** 2) - deg = {} - avail = communities[0][-1] - already_chosen: set[int] = set() - - lock = 0 - d_previous = degrees[0] + 1 - - for i, d in enumerate(degrees): - if lock_needs_update(d, d_previous, lock, len(community_sizes)): - threshold = calculate_threshold(d, xi, float(phi)) - lock, avail = update_lock(threshold, lock, avail, community_sizes, communities) - - d_previous = d - - v = choose_new_vertex(avail, already_chosen) - - already_chosen.add(v) - deg[v] = d - - if avail == len(degrees) - 1: - return assign_remaining_degrees(i, degrees, already_chosen, deg) - - return deg - - -def choose_new_vertex(avail: int, already_chosen: set[int]) -> int: - avail_set = set(range(avail)) - already_chosen - - if not avail_set: - return max(already_chosen) + 1 - - return int(np.random.choice(list(avail_set))) if avail_set else avail - - -def lock_needs_update(degree: int, previous_degree: int, lock: int, num_communities: int) -> bool: - return (degree < previous_degree) and (lock < num_communities) - - -def calculate_threshold(d: int, xi: float, phi: float) -> float: - return d * (1 - xi * phi) + 1 - - -def update_lock( - threshold: float, - lock: int, - avail: int, - community_sizes: NDArray[np.int64], - communities: dict[int, list[int]], -) -> tuple[int, int]: - while community_sizes[lock] >= threshold: - avail = communities[lock][-1] - lock += 1 - if lock == len(community_sizes): - break - return lock, avail - - -def assign_remaining_degrees( - degree_index: int, - degrees: NDArray[np.int64], - already_chosen: set[int], - deg: dict[int, Any], -) -> dict[int, Any]: - still_not_chosen_set = set(range(len(degrees))) - already_chosen - still_not_chosen: NDArray[np.int64] = np.array([v for v in still_not_chosen_set]) - degrees_remaining: NDArray[np.int64] = degrees[degree_index + 1 :] # noqa: E203 - - np.random.shuffle(still_not_chosen) - - deg.update({label: degree for label, degree in zip(still_not_chosen, degrees_remaining)}) - return deg - - -def split_degrees( - degrees: dict[int, int], - communities: dict[int, list[int]], - xi: float, -) -> tuple[dict[int, int], dict[int, int]]: - deg_c = {v: rand_round((1 - xi) * degrees[v]) for v in degrees} - for community in communities.values(): - if sum(deg_c[v] for v in community) % 2 == 0: - continue - - v_max = _get_v_max(deg_c, community) - deg_c[v_max] += 1 - if deg_c[v_max] > degrees[v_max]: - deg_c[v_max] -= 2 - - deg_b = {v: (degrees[v] - deg_c[v]) for v in degrees} - return deg_c, deg_b - - -def add_outliers( - *, - vcount: int, - num_outliers: int, - gamma: float, - min_degree: int, - max_degree: int, - communities: dict[int, list[int]], - deg_b: dict[int, int], - deg_c: dict[int, int], -) -> tuple[dict[int, list[int]], dict[int, int], dict[int, int]]: - regular_vertices = vcount - num_outliers - outlier_degrees = build_degrees(num_outliers, gamma, min_degree, max_degree) - communities = communities | {OUTLIER_COMMUNITY_ID: list(range(regular_vertices, vcount))} - deg_b = deg_b | {regular_vertices + i: outlier_degrees[i] for i in range(num_outliers)} - deg_c = deg_c | {regular_vertices + i: 0 for i in range(num_outliers)} - - return communities, deg_b, deg_c - - -def _get_v_max(deg_c: dict[int, int], community: list[int]) -> int: - deg_c_subset = {v: deg_c[v] for v in community} - return max(deg_c_subset, key=deg_c_subset.__getitem__) diff --git a/src/abcd_graph/graph/core/constants.py b/src/abcd_graph/graph/core/constants.py deleted file mode 100644 index 5e5c1e7..0000000 --- a/src/abcd_graph/graph/core/constants.py +++ /dev/null @@ -1,2 +0,0 @@ -OUTLIER_COMMUNITY_ID: int = -1 -BACKGROUND_GRAPH_ID: int = -2 diff --git a/src/abcd_graph/graph/core/exceptions.py b/src/abcd_graph/graph/core/exceptions.py deleted file mode 100644 index 4ea5eb3..0000000 --- a/src/abcd_graph/graph/core/exceptions.py +++ /dev/null @@ -1,25 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -__all__ = ["MalformedGraphException"] - - -class MalformedGraphException(Exception): - pass diff --git a/src/abcd_graph/graph/core/utils.py b/src/abcd_graph/graph/core/utils.py deleted file mode 100644 index 5e9c8e4..0000000 --- a/src/abcd_graph/graph/core/utils.py +++ /dev/null @@ -1,55 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -__all__ = ["rand_round", "powerlaw_distribution", "get_community_color_map"] - -import math -import random -from typing import TYPE_CHECKING - -import numpy as np -from numpy.typing import NDArray - -if TYPE_CHECKING: # pragma: no cover - from abcd_graph.graph.core.abcd_objects import Community - - -def rand_round(x: float) -> int: - p = x - math.floor(x) - return int(math.floor(x) + 1) if random.uniform(0, 1) <= p else int(math.floor(x)) - - -def powerlaw_distribution(choices: NDArray[np.float64], intensity: float) -> NDArray[np.float64]: - dist: NDArray[np.float64] = (choices ** (-intensity)) / np.sum(choices ** (-intensity)) - return dist - - -def get_community_color_map(communities: list["Community"]) -> list[str]: - import matplotlib.colors as colors # type: ignore[import] - - colors_list = list(colors.BASE_COLORS.values())[: len(communities)] - - color_map = [] - - for i, community in enumerate(communities): - color = colors_list[i] - color_map.extend([color] * len(community.vertices)) - - return color_map diff --git a/src/abcd_graph/graph/graph.py b/src/abcd_graph/graph/graph.py deleted file mode 100644 index 19fb811..0000000 --- a/src/abcd_graph/graph/graph.py +++ /dev/null @@ -1,228 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -__all__ = ["ABCDGraph"] - -import time -import warnings -from datetime import datetime -from typing import ( - Optional, - cast, -) - -import numpy as np - -from abcd_graph.callbacks.abstract import ( - ABCDCallback, - BuildContext, -) -from abcd_graph.exporter import GraphExporter -from abcd_graph.graph.community import ABCDCommunity -from abcd_graph.graph.core.abcd_objects import GraphImpl -from abcd_graph.graph.core.build import ( - add_outliers, - assign_degrees, - build_communities, - build_community_sizes, - build_degrees, - split_degrees, -) -from abcd_graph.logger import construct_logger -from abcd_graph.models import ( - Model, - configuration_model, -) -from abcd_graph.params import ABCDParams - - -class ABCDGraph: - def __init__( - self, - params: Optional[ABCDParams] = None, - logger: bool = False, - callbacks: Optional[list[ABCDCallback]] = None, - ) -> None: - - self.params: ABCDParams = params or ABCDParams() - - self._vcount = self.params.vcount - - self.num_outliers = self.params.num_outliers - - self._has_outliers: bool = self.num_outliers > 0 - - self._num_regular_vertices = self._vcount - self.num_outliers - - self.logger = construct_logger(logger) - - self._graph: Optional[GraphImpl] = None - - self._exporter: Optional[GraphExporter] = None - self._callbacks = callbacks or [] - - def reset(self) -> None: - self._graph = None - - @property - def is_built(self) -> bool: - return self._graph is not None - - @property - def exporter(self) -> GraphExporter: - if not self.is_built: - raise RuntimeError("Exporter is not available if the graph has not been built.") - - if self._exporter is None: - raise RuntimeError("Exporter is not available.") - - assert self._exporter is not None - - return self._exporter - - @property - def vcount(self) -> int: - return self._vcount if self.is_built else 0 - - @property - def edges(self) -> list[tuple[int, int]]: - return self._graph.edges if self._graph else [] - - @property - def membership_list(self) -> list[int]: - return self._graph.membership_list if self._graph else [] - - @property - def communities(self) -> list[ABCDCommunity]: - return ( - [ - ABCDCommunity( - community_id=community.community_id, - vertices=community.vertices, - average_degree=community.average_degree, - degree_sequence=community.degree_sequence, - empirical_xi=community.empirical_xi, - ) - for community in self._graph.communities - ] - if self._graph - else [] - ) - - def build(self, model: Optional[Model] = None) -> "ABCDGraph": - if self.is_built: - warnings.warn("Graph has already been built. Run `reset` and try again.") - return self - - model = model if model else configuration_model - - context = BuildContext( - model_used=model, - start_time=datetime.now(), - params=self.params, - number_of_nodes=self._vcount, - ) - - for callback in self._callbacks: - callback.before_build(context) - - try: - build_start = time.perf_counter() - build_end = self._build_impl(model) - context.end_time = datetime.now() - except Exception as e: - self.logger.error(f"An error occurred while building the graph: {e}") - self.reset() - raise e - - context.raw_build_time = build_end - build_start - - assert self._graph is not None - self._exporter = GraphExporter(self._graph) - - for callback in self._callbacks: - callback.after_build(self._graph, context, self._exporter) - - return self - - def _build_impl(self, model: Model) -> float: - degrees = ( - build_degrees( - self._num_regular_vertices, - cast(float, self.params.gamma), - cast(int, self.params.min_degree), - cast(int, self.params.max_degree), - ) - if self.params.degree_sequence is None - else np.array(self.params.degree_sequence) - ) - - self.logger.info("Building community sizes") - - community_sizes = ( - build_community_sizes( - self._num_regular_vertices, - cast(float, self.params.beta), - cast(int, self.params.min_community_size), - cast(int, self.params.max_community_size), - ) - if self.params.community_size_sequence is None - else np.array(self.params.community_size_sequence) - ) - - self.logger.info("Building communities") - - communities = build_communities(community_sizes) - - self.logger.info("Assigning degrees") - - deg = assign_degrees(degrees, communities, community_sizes, self.params.xi) - - self.logger.info("Splitting degrees") - - deg_c, deg_b = split_degrees(deg, communities, self.params.xi) - - if self._has_outliers: - self.logger.info("Adding outliers") - communities, deg_b, deg_c = add_outliers( - vcount=self._vcount, - num_outliers=self.num_outliers, - gamma=cast(float, self.params.gamma), - min_degree=cast(int, self.params.min_degree), - max_degree=cast(int, self.params.max_degree), - communities=communities, - deg_b=deg_b, - deg_c=deg_c, - ) - - self._graph = GraphImpl(deg_b, deg_c, params=self.params) - - self.logger.info("Building community edges") - self._graph.build_communities(communities, model) - - self.logger.info("Building background edges") - self._graph.build_background_edges(model) - - self.logger.info("Resolving collisions") - self._graph.combine_edges() - - self._graph.rewire_graph() - - return time.perf_counter() diff --git a/src/abcd_graph/logger.py b/src/abcd_graph/logger.py deleted file mode 100644 index ad30fd7..0000000 --- a/src/abcd_graph/logger.py +++ /dev/null @@ -1,107 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -__all__ = [ - "construct_logger", -] - -import logging -import os -from abc import ( - ABC, - abstractmethod, -) -from typing import Union - -from typing_extensions import TypeAlias - - -class ABCDLogger(ABC): # pragma: no cover - @abstractmethod - def info(self, message: str) -> None: - pass - - @abstractmethod - def debug(self, message: str) -> None: - pass - - @abstractmethod - def warning(self, message: str) -> None: - pass - - @abstractmethod - def error(self, message: str) -> None: - pass - - @abstractmethod - def critical(self, message: str) -> None: - pass - - -class NoOpLogger(ABCDLogger): - def info(self, message: str) -> None: - pass - - def debug(self, message: str) -> None: - pass - - def warning(self, message: str) -> None: - pass - - def error(self, message: str) -> None: - pass - - def critical(self, message: str) -> None: - pass - - -class StdOutLogger(ABCDLogger): - NAME = "abcd-graph" - - def __init__(self) -> None: - logging_level = int(os.getenv("ABCD_LOG", logging.INFO)) - logging.basicConfig( - level=logging_level, - format="[%(name)s] - %(asctime)s - %(levelname)s - %(message)s", - ) - self.logging_level = logging_level - self.logger = logging.getLogger(self.NAME) - - def info(self, message: str) -> None: - self.logger.info(message) - - def debug(self, message: str) -> None: - self.logger.debug(message) - - def warning(self, message: str) -> None: - self.logger.warning(message) - - def error(self, message: str) -> None: - self.logger.error(message) - - def critical(self, message: str) -> None: - self.logger.critical(message) - - -LoggerType: TypeAlias = Union[ABCDLogger, bool] - - -def construct_logger(logger: bool) -> ABCDLogger: - return StdOutLogger() if logger else NoOpLogger() diff --git a/src/abcd_graph/models.py b/src/abcd_graph/models.py deleted file mode 100644 index c1de0d1..0000000 --- a/src/abcd_graph/models.py +++ /dev/null @@ -1,66 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -__all__ = [ - "Model", - "configuration_model", - "chung_lu", -] - -from typing import Protocol - -import numpy as np -from numpy.typing import NDArray - - -class Model(Protocol): - def __call__(self, degree_sequence: dict[int, int]) -> NDArray[np.int64]: ... - - @property - def __name__(self) -> str: ... - - -def configuration_model(degree_sequence: dict[int, int]) -> NDArray[np.int64]: - labels = list(degree_sequence.keys()) - counts = list(degree_sequence.values()) - - vertices = np.repeat(labels, counts) - - np.random.shuffle(vertices) - - edges = np.array(vertices).reshape(-1, 2) - - return edges - - -def normalize(degrees: list[int]) -> NDArray[np.float64]: - """Normalize the degree sequence.""" - degrees_array: NDArray[np.int64] = np.array(degrees) - norm = degrees_array.sum() - result: NDArray[np.float64] = np.divide(degrees_array, norm) - return result - - -def chung_lu(degree_sequence: dict[int, int]) -> NDArray[np.int64]: - """Generate a Chung-Lu random graph based on a given degree sequence.""" - nodes = list(degree_sequence.keys()) - degrees = list(degree_sequence.values()) - - return np.random.choice(a=nodes, size=int(sum(degrees)), p=normalize(degrees)).reshape(-1, 2) diff --git a/src/abcd_graph/params.py b/src/abcd_graph/params.py deleted file mode 100644 index dfefab2..0000000 --- a/src/abcd_graph/params.py +++ /dev/null @@ -1,112 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -__all__ = ["ABCDParams"] - -from dataclasses import dataclass -from typing import Sequence - -import numpy as np -from numpy.typing import NDArray - -DEFAULT_GAMMA_VALUE: float = 2.5 -DEFAULT_MIN_DEGREE: int = 5 -DEFAULT_MAX_DEGREE: int = 30 - -DEFAULT_BETA_VALUE: float = 1.5 -DEFAULT_MIN_COMMUNITY_SIZE: int = 20 -DEFAULT_MAX_COMMUNITY_SIZE: int = 250 - - -@dataclass -class ABCDParams: - vcount: int = 1000 - gamma: float | None = None # 2.5 - beta: float | None = None # 1.5 - xi: float = 0.25 - min_degree: int | None = None # 5 - max_degree: int | None = None # 30 - min_community_size: int | None = None # 20 - max_community_size: int | None = None # 250 - degree_sequence: Sequence[int] | NDArray[np.int64] | None = None - community_size_sequence: Sequence[int] | NDArray[np.int64] | None = None - num_outliers: int = 0 - - def __post_init__(self) -> None: - if self.degree_sequence is not None: - if any([self.gamma is not None, self.min_degree is not None, self.max_degree is not None]): - raise ValueError("cannot pass both `degree_sequence` and any of (`gamma`, `min_degree`, `max_degree`") - self.degree_sequence = np.sort(np.array(self.degree_sequence))[::-1] - - if sum(self.degree_sequence) % 2 != 0: - raise ValueError("The sum of a custom degree sequence must be even") - - if max(self.degree_sequence) >= self.vcount: - raise ValueError("None of the custom degrees can be larger than the total vcount") - else: - self.gamma = self.gamma if self.gamma is not None else DEFAULT_GAMMA_VALUE - self.min_degree = self.min_degree if self.min_degree is not None else DEFAULT_MIN_DEGREE - self.max_degree = self.max_degree if self.max_degree is not None else DEFAULT_MAX_DEGREE - - if self.gamma < 2 or self.gamma > 3: - raise ValueError("gamma must be between 2 and 3") - - if self.min_degree < 1 or self.min_degree > self.max_degree: - raise ValueError("min_degree must be between 1 and max_degree") - - if self.community_size_sequence is not None: - if any([self.beta is not None, self.min_community_size is not None, self.max_community_size is not None]): - raise ValueError( - "cannot pass both `community_size_sequence` and any of \ - (`beta`, `min_community_size`, `max_community_size`)" - ) - self.community_size_sequence = np.sort(np.array(self.community_size_sequence))[::-1] - - if sum(self.community_size_sequence) != self.vcount: - raise ValueError("The sum of custom community sizes must be equal to the total vcount") - else: - self.beta = self.beta if self.beta is not None else DEFAULT_BETA_VALUE - self.min_community_size = ( - self.min_community_size if self.min_community_size is not None else DEFAULT_MIN_COMMUNITY_SIZE - ) - self.max_community_size = ( - self.max_community_size if self.max_community_size is not None else DEFAULT_MAX_COMMUNITY_SIZE - ) - - if self.beta < 1 or self.beta > 2: - raise ValueError("beta must be between 1 and 2") - - if self.min_community_size > self.max_community_size: - raise ValueError("min_community_size must be between min_degree and max_community_size") - - if self.max_community_size > self.vcount - self.num_outliers: - raise ValueError("max_community_size must be less than n") - - if self.vcount < 1 or not isinstance(self.vcount, int): - raise ValueError("vcount must be a positive integer") - - if self.xi < 0 or self.xi > 1: - raise ValueError("xi must be between 0 and 1") - - if self.num_outliers < 0: - raise ValueError("num_outliers must be non-negative") - - if self.num_outliers > self.vcount: - raise ValueError("num_outliers must be less than vcount") diff --git a/src/abcd_graph/utils.py b/src/abcd_graph/utils.py deleted file mode 100644 index b1f29b2..0000000 --- a/src/abcd_graph/utils.py +++ /dev/null @@ -1,55 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - - -import random -from functools import wraps -from typing import Callable - -import numpy -from typing_extensions import ( - ParamSpec, - TypeVar, -) - -P = ParamSpec("P") -R = TypeVar("R") - - -def seed(num: int) -> None: - random.seed(num) - numpy.random.seed(num) - - -def require(package_name: str) -> Callable[[Callable[P, R]], Callable[P, R]]: - def deco(func: Callable[P, R]) -> Callable[P, R]: - @wraps(func) - def wrapper(*args: P.args, **kwargs: P.kwargs) -> R: - try: - return func(*args, **kwargs) - except ImportError as e: - raise ImportError( - f"Package '{package_name}' is required to use '{func.__name__}'. Run " - f"`pip install abcd_graph[{package_name}]` to install it." - ) from e - - return wrapper - - return deco diff --git a/src/abcd_graph/version.py b/src/abcd_graph/version.py deleted file mode 100644 index 626140b..0000000 --- a/src/abcd_graph/version.py +++ /dev/null @@ -1,24 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. -__all__ = ["__version__"] - -from importlib.metadata import version as version_parser - -__version__ = version_parser("abcd_graph") diff --git a/tests/__init__.py b/tests/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/tests/abcd_graph/__init__.py b/tests/abcd_graph/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/tests/abcd_graph/test_abcd.py b/tests/abcd_graph/test_abcd.py deleted file mode 100644 index 95d023d..0000000 --- a/tests/abcd_graph/test_abcd.py +++ /dev/null @@ -1,9 +0,0 @@ -from abcd_graph import ABCD -from tests.utils import assert_graph_built - - -def test_abcd_sample(params): - sampler = ABCD(1000) - sample = sampler.sample() - assert_graph_built(sample) - assert sample is sampler.graph_ diff --git a/tests/abcd_graph/test_graph.py b/tests/abcd_graph/test_graph.py deleted file mode 100644 index 0e0a9b0..0000000 --- a/tests/abcd_graph/test_graph.py +++ /dev/null @@ -1,92 +0,0 @@ -from unittest.mock import patch - -import pytest - -from abcd_graph import ABCDGraph -from abcd_graph.graph.core.constants import OUTLIER_COMMUNITY_ID -from abcd_graph.models import configuration_model -from tests.utils import ( - assert_graph_built, - assert_graph_not_built, -) - - -def test_abcd_graph_not_built(params): - # when - g = ABCDGraph(params, logger=False) - - # then - assert_graph_not_built(g) - - -def test_abcd_graph_built(params): - # given - g = ABCDGraph(params, logger=False) - - # when - g.build() - - # then - assert_graph_built(g) - - -def test_abcd_reset_after_build(params): - # given - g = ABCDGraph(params, logger=False) - - # when - g.build() - - # then - assert_graph_built(g) - - # when - g.reset() - - # then - assert_graph_not_built(g) - - -def test_graph_exporter_raises_exception_if_exporter_is_none(params): - graph = ABCDGraph(params=params, logger=False).build() - graph._exporter = None - - with pytest.raises(RuntimeError): - _ = graph.exporter - - -@patch("abcd_graph.graph.ABCDGraph._build_impl", side_effect=Exception) -@patch("abcd_graph.graph.ABCDGraph.reset") -def test_graph_build_error_triggers_reset(mock_reset, mock_build_impl): - graph = ABCDGraph(logger=False) - - with pytest.raises(Exception): - graph.build() - - mock_build_impl.assert_called_once_with(configuration_model) - - mock_reset.assert_called_once() - - -# TODO: Tests for different param values - - -def test_outliers(params_with_outliers): - g = ABCDGraph(params_with_outliers, logger=False).build() - - assert g.num_outliers == 100 - - assert OUTLIER_COMMUNITY_ID in [c.community_id for c in g.communities] - - outlier_community = next(c for c in g.communities if c.community_id == OUTLIER_COMMUNITY_ID) - assert len(outlier_community.vertices) == 100 - - -def test_outliers_deg_c_is_zero_for_every_outlier(params_with_outliers): - g = ABCDGraph(params_with_outliers, logger=False).build() - - outlier_community = next(c for c in g.communities if c.community_id == OUTLIER_COMMUNITY_ID) - - deg_c = g._graph.deg_c - - assert all(deg_c[v] == 0 for v in outlier_community.vertices) diff --git a/tests/abcd_graph/test_xi_matrix.py b/tests/abcd_graph/test_xi_matrix.py deleted file mode 100644 index 54520b5..0000000 --- a/tests/abcd_graph/test_xi_matrix.py +++ /dev/null @@ -1,11 +0,0 @@ -from abcd_graph import ABCDGraph - - -def test_xi_matrix(params): - g = ABCDGraph(params, logger=False).build() - - xi_matrix = g._graph.xi_matrix - - assert xi_matrix.min() >= 0 - - assert xi_matrix.shape == (len(g.communities), len(g.communities)) diff --git a/tests/callbacks/__init__.py b/tests/callbacks/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/tests/callbacks/test_property_collector.py b/tests/callbacks/test_property_collector.py deleted file mode 100644 index c31bf39..0000000 --- a/tests/callbacks/test_property_collector.py +++ /dev/null @@ -1,114 +0,0 @@ -from unittest.mock import patch - -import pytest - -from abcd_graph import ABCDGraph -from abcd_graph.callbacks import PropertyCollector -from abcd_graph.params import ABCDParams - - -def test_property_collector(params): - props = PropertyCollector() - graph = ABCDGraph(params, callbacks=[props]) - - graph.build() - - assert len(props.degree_sequence) == params.vcount - - assert props.xi_matrix.shape == (len(graph.communities), len(graph.communities)) - - assert min(props.actual_community_cdf.values()) >= 0 and round(max(props.actual_community_cdf.values()), 10) <= 1 - - assert ( - min(props.expected_community_cdf.values()) >= 0 and round(max(props.expected_community_cdf.values()), 10) <= 1 - ) - - assert min(props.actual_degree_cdf.values()) >= 0 and round(max(props.actual_degree_cdf.values()), 10) <= 1 - - assert min(props.expected_degree_cdf.values()) >= 0 and round(max(props.expected_degree_cdf.values()), 10) <= 1 - - -@patch("abcd_graph.graph.core.abcd_objects.graph_impl.XiMatrixBuilder.build") -def test_property_collector_lazy_eval_xi_matrix(mock_xi_build): - props = PropertyCollector() - graph = ABCDGraph(callbacks=[props]) - - graph.build() - - mock_xi_build.assert_not_called() # xi matrix not built until called for - - _ = props.xi_matrix - - mock_xi_build.assert_called_once() - - _ = props.xi_matrix - - mock_xi_build.assert_called_once() # xi matrix not rebuilt upon every call - - -@patch("abcd_graph.graph.core.abcd_objects.graph_impl.GraphImpl._calc_actual_degree_cdf") -def test_property_collector_lazy_eval_actual_degree_cdf(mock_actual_cdf): - props = PropertyCollector() - graph = ABCDGraph(callbacks=[props]) - - graph.build() - - mock_actual_cdf.assert_not_called() - - _ = props.actual_degree_cdf - - mock_actual_cdf.assert_called_once() - - -@patch("abcd_graph.graph.core.abcd_objects.graph_impl.GraphImpl._calc_expected_degree_cdf") -def test_property_collector_lazy_eval_expected_degree_cdf(mock_expected_cdf): - props = PropertyCollector() - graph = ABCDGraph(callbacks=[props]) - - graph.build() - - mock_expected_cdf.assert_not_called() - - _ = props.expected_degree_cdf - - mock_expected_cdf.assert_called_once() - - -@patch("abcd_graph.graph.core.abcd_objects.graph_impl.GraphImpl._calc_actual_community_cdf") -def test_property_collector_lazy_eval_actual_community_cdf(mock_actual_cdf): - props = PropertyCollector() - graph = ABCDGraph(callbacks=[props]) - - graph.build() - - mock_actual_cdf.assert_not_called() - - _ = props.actual_community_cdf - - mock_actual_cdf.assert_called_once() - - -@patch("abcd_graph.graph.core.abcd_objects.graph_impl.GraphImpl._calc_expected_community_cdf") -def test_property_collector_lazy_eval_expected_community_cdf(mock_expected_cdf): - props = PropertyCollector() - graph = ABCDGraph(callbacks=[props]) - - graph.build() - - mock_expected_cdf.assert_not_called() - - _ = props.expected_community_cdf - - mock_expected_cdf.assert_called_once() - - -def test_property_collector_failing_methods_with_custom_sequences(params_with_custom_sequences: ABCDParams): - props = PropertyCollector() - graph = ABCDGraph(params=params_with_custom_sequences, callbacks=[props]) - graph.build() - - with pytest.raises(RuntimeError): - props.expected_degree_cdf() - - with pytest.raises(RuntimeError): - props.expected_community_cdf() diff --git a/tests/callbacks/test_stats_collector.py b/tests/callbacks/test_stats_collector.py deleted file mode 100644 index e888a60..0000000 --- a/tests/callbacks/test_stats_collector.py +++ /dev/null @@ -1,43 +0,0 @@ -import pytest - -from abcd_graph import ABCDGraph -from abcd_graph.callbacks import StatsCollector -from abcd_graph.models import ( - chung_lu, - configuration_model, -) -from abcd_graph.params import ABCDParams - - -def test_stats_collector(params): - stats = StatsCollector() - graph = ABCDGraph(params, callbacks=[stats]) - - graph.build() - - assert isinstance(stats.statistics, dict) - - assert stats.fetch_statistic("model_used") == configuration_model.__name__ - assert stats.fetch_statistic("params") == params - assert stats.fetch_statistic("number_of_nodes") == params.vcount - assert stats.fetch_statistic("number_of_communities") == len(graph.communities) - - assert "start_time" in stats.statistics - assert "end_time" in stats.statistics - assert "time_to_build" in stats.statistics - - -def test_stats_collector_chung_lu_model(params): - stats = StatsCollector() - graph = ABCDGraph(params, callbacks=[stats]) - graph.build(model=chung_lu) - - assert stats.fetch_statistic("model_used") == chung_lu.__name__ - - -def test_stats_collector_failing_methods_with_custom_sequences(params_with_custom_sequences: ABCDParams): - stats = StatsCollector() - graph = ABCDGraph(params=params_with_custom_sequences, callbacks=[stats]) - - with pytest.raises(RuntimeError): - graph.build() diff --git a/tests/callbacks/test_visualizer.py b/tests/callbacks/test_visualizer.py deleted file mode 100644 index 2b5c6d2..0000000 --- a/tests/callbacks/test_visualizer.py +++ /dev/null @@ -1,66 +0,0 @@ -from unittest.mock import patch - -import pytest - -from abcd_graph import ( - ABCDGraph, - ABCDParams, -) -from abcd_graph.callbacks import Visualizer -from abcd_graph.models import chung_lu - - -def test_visualizer_raises_exception_if_more_than_100_nodes(): - visualizer = Visualizer() - graph = ABCDGraph(callbacks=[visualizer]) - - graph.build() - - with pytest.raises(ValueError): - visualizer.draw_communities() - - -def test_visualizer_not_supporting_models_other_than_configuration_model(): - visualizer = Visualizer() - graph = ABCDGraph(params=ABCDParams(vcount=60, max_community_size=50), callbacks=[visualizer]) - - graph.build(model=chung_lu) - - with pytest.raises(NotImplementedError): - visualizer.draw_communities() - - -@patch("matplotlib.pyplot.show") -def test_visualizer(mock_show): - visualizer = Visualizer() - graph = ABCDGraph(params=ABCDParams(vcount=60, max_community_size=50), callbacks=[visualizer]) - - graph.build() - - visualizer.draw_communities() - - mock_show.assert_called_once() - - -@patch("matplotlib.pyplot.show") -def test_visualizer_draw_community_cdf(mock_show): - visualizer = Visualizer() - graph = ABCDGraph(params=ABCDParams(vcount=60, max_community_size=50), callbacks=[visualizer]) - - graph.build() - - visualizer.draw_community_cdf() - - mock_show.assert_called_once() - - -@patch("matplotlib.pyplot.show") -def test_visualizer_draw_degree_cdf(mock_show): - visualizer = Visualizer() - graph = ABCDGraph(params=ABCDParams(vcount=60, max_community_size=50), callbacks=[visualizer]) - - graph.build() - - visualizer.draw_degree_cdf() - - mock_show.assert_called_once() diff --git a/tests/conftest.py b/tests/conftest.py deleted file mode 100644 index 73a4669..0000000 --- a/tests/conftest.py +++ /dev/null @@ -1,30 +0,0 @@ -import pytest - -from abcd_graph import ( - ABCDGraph, - ABCDParams, -) - - -@pytest.fixture(scope="session") -def params() -> ABCDParams: - return ABCDParams() - - -@pytest.fixture(scope="session") -def params_with_outliers() -> ABCDParams: - return ABCDParams(num_outliers=100) - - -@pytest.fixture(scope="session") -def params_with_custom_sequences() -> ABCDParams: - return ABCDParams( - degree_sequence=[9] + [1] * 9, - community_size_sequence=(5, 5), - vcount=10, - ) - - -@pytest.fixture(scope="session") -def graph() -> ABCDGraph: - return ABCDGraph() diff --git a/tests/test_abcd_params.py b/tests/test_abcd_params.py deleted file mode 100644 index aff6c3f..0000000 --- a/tests/test_abcd_params.py +++ /dev/null @@ -1,121 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. - -import pytest - -from abcd_graph import ABCDParams -from abcd_graph.params import ( - DEFAULT_BETA_VALUE, - DEFAULT_GAMMA_VALUE, -) - - -def test_abcd_params_negative_vcount(): - with pytest.raises(ValueError): - ABCDParams(vcount=-1) - - -def test_abcd_params_invalid_gamma(): - with pytest.raises(ValueError): - ABCDParams( - gamma=1.5, min_degree=1, max_degree=30, beta=1.5, max_community_size=100, xi=0.5, min_community_size=2 - ) - - -def test_abcd_params_invalid_beta(): - with pytest.raises(ValueError): - ABCDParams( - gamma=2.5, min_degree=1, max_degree=30, beta=0.5, max_community_size=100, xi=0.5, min_community_size=2 - ) - - -def test_abcd_params_invalid_tau(): - with pytest.raises(ValueError): - ABCDParams( - gamma=2.5, min_degree=1, max_degree=30, beta=1.5, max_community_size=5000, xi=0.5, min_community_size=2 - ) - - -def test_abcd_params_invalid_xi(): - with pytest.raises(ValueError): - ABCDParams( - gamma=2.5, min_degree=1, max_degree=30, beta=1.5, max_community_size=100, xi=1.5, min_community_size=2 - ) - - -def test_abcd_params_invalid_min_degree(): - with pytest.raises(ValueError): - ABCDParams(min_degree=0, max_degree=30) - - with pytest.raises(ValueError): - ABCDParams(min_degree=30, max_degree=20) - - -def test_abcd_params_invalid_min_community_size(): - with pytest.raises(ValueError): - ABCDParams(min_community_size=110, max_community_size=100) - - -def test_abcd_params_proper_init(): - ABCDParams(gamma=2.5, min_degree=1, max_degree=30, beta=1.5, max_community_size=100, xi=0.5, min_community_size=2) - assert True - - -def test_abcd_params_default_init(): - ABCDParams() - assert True - - -def test_num_outliers_cannot_be_negative(): - with pytest.raises(ValueError): - ABCDParams(num_outliers=-1) - - -def test_num_outliers_cannot_be_greater_than_vcount(): - with pytest.raises(ValueError): - ABCDParams(vcount=1000, num_outliers=1001) - - -def test_custom_sequences_defaults(): - ABCDParams( - degree_sequence=[9] + [1] * 9, - community_size_sequence=(5, 5), - vcount=10, - ) - - -def test_custom_sequences_fail_with_params_provided(): - with pytest.raises(ValueError): - ABCDParams( - degree_sequence=[9] + [1] * 9, - community_size_sequence=(5, 5), - vcount=10, - gamma=DEFAULT_GAMMA_VALUE, - beta=DEFAULT_BETA_VALUE, - ) - - -def test_custom_sequences_fail_wrong_vcount(): - with pytest.raises(ValueError): - ABCDParams( - degree_sequence=[9] + [1] * 9, - community_size_sequence=(5, 5), - vcount=100, - ) diff --git a/tests/test_exporter.py b/tests/test_exporter.py deleted file mode 100644 index c776a5e..0000000 --- a/tests/test_exporter.py +++ /dev/null @@ -1,58 +0,0 @@ -from unittest.mock import patch - -import numpy -import pytest -import scipy.sparse - -from abcd_graph.graph.core.exceptions import MalformedGraphException - - -def test_export_to_adjacency_matrix(graph): - graph.build() - - assert graph.exporter.is_proper_abcd - - assert isinstance(graph.exporter.to_adjacency_matrix(), numpy.ndarray) - - -@patch("abcd_graph.exporter.GraphExporter.is_proper_abcd", False) -def test_export_to_adjacency_matrix_not_proper_abcd(graph): - graph.build() - - with pytest.raises(MalformedGraphException): - graph.exporter.to_adjacency_matrix() - - -@pytest.mark.integration -def test_export_to_sparse_adjacency_matrix(graph): - graph.build() - - assert graph.exporter.is_proper_abcd - - assert scipy.sparse.isspmatrix_csr(graph.exporter.to_sparse_adjacency_matrix()) - - -@pytest.mark.integration -@patch("abcd_graph.exporter.GraphExporter.is_proper_abcd", False) -def test_export_to_sparse_adjacency_matrix_not_proper_abcd(graph): - graph.build() - with pytest.raises(MalformedGraphException): - graph.exporter.to_sparse_adjacency_matrix() - - -@pytest.mark.integration -def test_export_to_igraph(graph): - i_graph = graph.build().exporter.to_igraph() - - assert i_graph.vcount() == graph.vcount - assert i_graph.vs["ground_truth_community"] == graph.membership_list - assert i_graph.ecount() == len(graph.edges) - - -@pytest.mark.integration -def test_export_to_networkx(graph): - nx_graph = graph.build().exporter.to_networkx() - - assert nx_graph.number_of_nodes() == graph.vcount - assert nx_graph.number_of_edges() == len(graph.edges) - # TODO: Check if the ground truth communities are exported correctly diff --git a/tests/test_logging.py b/tests/test_logging.py deleted file mode 100644 index 863d17a..0000000 --- a/tests/test_logging.py +++ /dev/null @@ -1,90 +0,0 @@ -# Copyright (c) 2024 Jordan Barrett & Aleksander Wojnarowicz -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. -import logging -import os -from unittest.mock import patch - -from abcd_graph.logger import ( - NoOpLogger, - StdOutLogger, - construct_logger, -) - - -def test_construct_logger(): - assert isinstance(construct_logger(False), NoOpLogger) - assert isinstance(construct_logger(True), StdOutLogger) - - -def test_default_logging_level(caplog): - logger = StdOutLogger() - caplog.set_level(logger.logging_level) - - logger.debug("debug") - logger.info("info") - logger.warning("warning") - logger.error("error") - logger.critical("critical") - - captured_stdout = caplog.text - - assert "debug" not in captured_stdout - assert "info" in captured_stdout - assert "warning" in captured_stdout - assert "error" in captured_stdout - assert "critical" in captured_stdout - - -@patch.dict(os.environ, {"ABCD_LOG": f"{logging.CRITICAL}"}) -def test_env_var_for_logging_level(caplog): - logger = StdOutLogger() - caplog.set_level(logger.logging_level) - - logger.debug("debug") - logger.info("info") - logger.warning("warning") - logger.error("error") - logger.critical("critical") - - captured_stdout = caplog.text - - assert "debug" not in captured_stdout - assert "info" not in captured_stdout - assert "warning" not in captured_stdout - assert "error" not in captured_stdout - assert "critical" in captured_stdout - - -def test_noop_logger(caplog): - logger = NoOpLogger() - - logger.debug("debug") - logger.info("info") - logger.warning("warning") - logger.error("error") - logger.critical("critical") - - captured_stdout = caplog.text - - assert "debug" not in captured_stdout - assert "info" not in captured_stdout - assert "warning" not in captured_stdout - assert "error" not in captured_stdout - assert "critical" not in captured_stdout diff --git a/tests/test_utils.py b/tests/test_utils.py deleted file mode 100644 index efa2fca..0000000 --- a/tests/test_utils.py +++ /dev/null @@ -1,28 +0,0 @@ -from unittest.mock import patch - -import pytest - -from abcd_graph.utils import ( - require, - seed, -) - - -@patch("numpy.random.seed") -@patch("random.seed") -def test_seed(mock_random_seed, mock_numpy_seed): - seed(42) - - mock_random_seed.assert_called_with(42) - mock_numpy_seed.assert_called_with(42) - - -def test_require(): - @require("non-existent-package") - def func(): - import non_existent_package # noqa: F401 - - return - - with pytest.raises(ImportError): - func() diff --git a/tests/utils.py b/tests/utils.py deleted file mode 100644 index c7c02bc..0000000 --- a/tests/utils.py +++ /dev/null @@ -1,25 +0,0 @@ -import pytest - -from abcd_graph import ABCDGraph - - -def assert_graph_built(graph: ABCDGraph): - assert graph.is_built - - assert graph.exporter is not None - assert graph.communities != [] - assert graph.edges != [] - assert graph.membership_list != [] - assert graph.vcount == graph.params.vcount - - -def assert_graph_not_built(graph: ABCDGraph): - assert not graph.is_built - - with pytest.raises(RuntimeError): - _ = graph.exporter - - assert graph.communities == [] - assert graph.edges == [] - assert graph.membership_list == [] - assert graph.vcount == 0 From ff1a6fe271cb2ee4ec8d0848574387929b2f1014 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 15 Aug 2026 15:23:18 -0400 Subject: [PATCH 10/85] Update pyproject version, tools, and dependencies --- pyproject.toml | 81 +++++++++++++++++++++++++------------------------- 1 file changed, 40 insertions(+), 41 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index ee44945..2ffc0ee 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "abcd-graph" -version = "0.4.1" +version = "0.5.0" readme = "README.md" description = "A python library for generating ABCD graphs." authors = [ @@ -8,33 +8,17 @@ authors = [ { name = "Jordan Barrett" } ] license = "MIT" -requires-python = ">=3.9" +requires-python = ">=3.12" packages = [{include = "abcd_graph", from = "src"}] repository = "https://github.com/AleksanderWWW/abcd-graph" dependencies = [ - "numpy>=1.26.4", + "numba>=0.66.0", + "numpy>=2.0.0", + "scipy>=1.18.0", "typing-extensions>=4.10.0" ] [project.optional-dependencies] -networkx = [ - "networkx>=3.2.1", -] -igraph = [ - "igraph>=0.11.8", -] -matplotlib = [ - "matplotlib>=3.9.4", -] -scipy = [ - "scipy>=1.13.1", -] -all = [ - "igraph>=0.11.8", - "matplotlib>=3.9.4", - "networkx>=3.2.1", - "scipy>=1.13.1", -] dev = [ "pre-commit>=4.0.1", "pytest>=8.3.4", @@ -53,34 +37,49 @@ markers = [ [tool.black] -line-length = 120 -target-version = ['py310', 'py311', 'py312'] +line-length = 88 +target-version = ["py312"] include = '\.pyi?$' exclude = ''' /( \.git - | \.mypy_cache - | \.tox | \.venv | build | dist + | \.eggs )/ ''' -[tool.isort] -profile = "black" -line_length = 120 -force_grid_wrap = 2 +[tool.ruff] +line-length = 88 +target-version = "py312" -[tool.mypy] -files = "src/abcd_graph" -mypy_path = "stubs" -install_types = "True" -non_interactive = "True" -disallow_untyped_defs = "True" -disallow_any_unimported = "True" -no_implicit_optional = "True" -check_untyped_defs = "True" -warn_return_any = "True" -show_error_codes = "True" -warn_unused_ignores = "True" +[tool.ruff.lint] +select = [ + "E", # pycodestyle errors + "W", # pycodestyle warnings + "F", # pyflakes + "I", # isort + "B", # flake8-bugbear + "C4", # flake8-comprehensions + "UP", # pyupgrade +] +ignore = [ + "E501", # line too long (handled by black) +] + +[tool.ruff.lint.per-file-ignores] +"__init__.py" = ["F401"] + +[tool.coverage.run] +source = ["abcd_graph"] + +[tool.coverage.report] +exclude_lines = [ + "pragma: no cover", + "def __repr__", + "raise AssertionError", + "raise NotImplementedError", + "if __name__ == .__main__.:", + "if TYPE_CHECKING:", +] From b737ef8eaed5d99add84e524d31ed95bebb4b05b Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 15 Aug 2026 15:24:03 -0400 Subject: [PATCH 11/85] Add configuration model and rewiring --- abcd_graph/__init__.py | 1 + abcd_graph/models.py | 187 +++++++++++++++++++++++++++++++++++++++++ tests/test_models.py | 116 +++++++++++++++++++++++++ 3 files changed, 304 insertions(+) create mode 100644 abcd_graph/__init__.py create mode 100644 abcd_graph/models.py create mode 100644 tests/test_models.py diff --git a/abcd_graph/__init__.py b/abcd_graph/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/abcd_graph/__init__.py @@ -0,0 +1 @@ + diff --git a/abcd_graph/models.py b/abcd_graph/models.py new file mode 100644 index 0000000..bccbfcb --- /dev/null +++ b/abcd_graph/models.py @@ -0,0 +1,187 @@ +from typing import Any + +import numpy as np +from numba import njit +from numba.typed import List, Set +from numba.types import uint64 +from numpy.random import Generator +from numpy.typing import NDArray + + +def configuration_model( + node_ids: NDArray[np.uint32], degrees: NDArray[np.integer[Any]], rng: Generator +) -> NDArray[np.uint32]: + """Sample a random graph with the given degree sequence. + + Parameters + ---------- + + node_ids: NDArray[np.uint32] + List of node_ids for the graph. The returned edge list will contain each + node_id equal to it's degree + + degrees: NDArray[np.integer[Any]] + List of degrees. The value degrees[i] corresponds to the degree of node node_ids[i] + + rng: Generator + numpy.random.Generator object used for randomness. + """ + node_ids = np.arange(len(degrees), dtype="uint32") + stubs = np.repeat(node_ids, degrees) + rng.shuffle(stubs) + edges = np.array(stubs).reshape(-1, 2) + return edges + + +@njit(inline="always") +def make_edge_id( + edge: NDArray[np.uint32], +) -> uint64: + high, low = edge[0], edge[1] + if high < low: + high, low = low, high + return (uint64(high) << 32) | uint64(low) + + +@njit(inline="always") +def edge_from_id( + edge_id: uint64, +) -> NDArray[np.uint32]: + edge = np.empty(2, dtype=np.uint32) + edge[0] = np.uint32(edge_id >> 32) + edge[1] = np.uint32(edge_id & 0xFFFFFFFF) + return edge + + +@njit(inline="always") +def swap( + edge1: NDArray[np.uint32], + edge2: NDArray[np.uint32], + rng: Generator, +): + edge1 = edge1.copy() + edge2 = edge2.copy() + if rng.uniform() > 0.5: + edge1[0], edge2[0] = edge2[0], edge1[0] + else: + edge1[0], edge2[1] = edge2[1], edge1[0] + return edge1, edge2 + + +@njit(inline="always") +def is_bad_swap( + edge1: NDArray[np.uint32], + edge2: NDArray[np.uint32], + good_edges: Set[uint64], +) -> bool: + if edge1[0] == edge1[1] or edge2[0] == edge2[1]: + return True + edge1_id = make_edge_id(edge1) + edge2_id = make_edge_id(edge2) + if edge1_id == edge2_id: + return True + if edge1_id in good_edges or edge2_id in good_edges: + return True + return False + + +@njit +def rewire( + edges: NDArray[np.uint32], + rng: Generator, + max_swap_attempts_per_bad_edge: int = 5, + drop_collisions: bool = False, +) -> NDArray[np.uint32]: + """Perform inplace edge swaps to resolve loops and multi-edges. + + Parameters + ---------- + + edges: NDArray[np.uint32] + Edge list with shape (n_edges, 2) to be rewired. Will be altered in place. + + rng: Generator + numpy.random.Generator object to use for randomness. + + max_swap_attempts_per_bad_edge: int, default=5 + Cap the attempted edge swaps to this values times the number of initial bad edges. + + drop_collisions: bool, default=False + If true, drop any bad edges that failed to swap from the returned array. The returned + edge list is guaranteed to be a simple graph. + + """ + # Move good edges to the front, add their hashes to a set, and + # make a List-backed-queue of bad edges + good_edges = Set.empty(uint64) + bad_queue = List.empty_list(uint64) + n_good_edges = 0 + for i in range(edges.shape[0]): + edge = edges[i] + edge_id = make_edge_id(edge) + if edge[0] != edge[1] and edge_id not in good_edges: + good_edges.add(edge_id) + edges[n_good_edges] = edge + n_good_edges += 1 + else: + bad_queue.append(edge_id) + + # Try to resolve the bad edge at the head of bad_queue by trying a swap + # with a random edge (good or bad, but not the one we are trying to resolve) + # If the swap would cause a collision, move bad edge to the back of the + # queue. Repeat until the Queue is empty or we give up. + + queue_head = 0 + queue_tail = len(bad_queue) + n_bad_edges = queue_tail + for _ in range(queue_tail * max_swap_attempts_per_bad_edge): + if n_bad_edges == 0: + break + bad_edge = edge_from_id(bad_queue[queue_head]) + choose_from_good_edges = rng.uniform() < n_good_edges / ( + n_good_edges + n_bad_edges - 1 + ) + if choose_from_good_edges: + swap_index = rng.integers(0, n_good_edges) + swap_candidate_edge = edges[swap_index] + new_edge1, new_edge2 = swap(bad_edge, swap_candidate_edge, rng) + if not is_bad_swap(new_edge1, new_edge2, good_edges): + edges[swap_index] = new_edge1 + edges[n_good_edges] = new_edge2 + n_good_edges += 1 + good_edges.add(make_edge_id(new_edge1)) + good_edges.add(make_edge_id(new_edge2)) + good_edges.discard(make_edge_id(swap_candidate_edge)) + queue_head = (queue_head + 1) % len(bad_queue) + n_bad_edges -= 1 + else: + queue_head, queue_tail = (queue_head + 1) % len(bad_queue), queue_tail + else: + swap_offset = rng.integers(1, n_bad_edges) # don't choose current head + swap_index = (queue_head + swap_offset) % len(bad_queue) + swap_candidate_edge_id = bad_queue[swap_index] + swap_candidate_edge = edge_from_id(swap_candidate_edge_id) + new_edge1, new_edge2 = swap(bad_edge, swap_candidate_edge, rng) + if not is_bad_swap(new_edge1, new_edge2, good_edges): + edges[n_good_edges] = new_edge1 + n_good_edges += 1 + edges[n_good_edges] = new_edge2 + good_edges.add(make_edge_id(new_edge1)) + good_edges.add(make_edge_id(new_edge2)) + n_good_edges += 1 + bad_queue.pop(swap_index) + queue_head = (queue_head + 1) % len(bad_queue) + n_bad_edges -= 2 + else: + queue_head, queue_tail = (queue_head + 1) % len(bad_queue), queue_tail + + # Write bad edges that failed to swap back into the edge list + for i in range(n_bad_edges): + bad_edge_id = bad_queue[(queue_head + 1) % len(bad_queue)] + bad_edge = edge_from_id(bad_edge_id) + edges[n_good_edges + i] = bad_edge + + if drop_collisions: + edges = edges[:n_good_edges] + + return edges diff --git a/tests/test_models.py b/tests/test_models.py new file mode 100644 index 0000000..ec7ce38 --- /dev/null +++ b/tests/test_models.py @@ -0,0 +1,116 @@ +import numpy as np +import pytest +import scipy.sparse as sp +from numpy.typing import NDArray + +from abcd_graph.models import configuration_model, rewire + + +def assert_no_bad_edges(edges: NDArray[np.uint32]): + n = np.max(edges) + 1 + adjacency_matrix = sp.coo_array( + (np.ones(edges.shape[0], dtype=np.int32), edges.T), + shape=(n, n), + ) + assert np.all(adjacency_matrix.diagonal() == 0) + assert np.all(adjacency_matrix.data == 1) + + +def test_configuration_model(): + rng = np.random.default_rng(seed=1) + node_ids = np.arange(32, dtype=np.uint32) + degrees = np.full(32, 4, dtype=np.int64) + + edges = configuration_model(node_ids, degrees, rng) + + ids, counts = np.unique(edges, return_counts=True) + assert set(ids) == set(node_ids) + assert np.all(counts == 4) + assert edges.dtype == np.uint32 + + +def test_rewire_loops(): + rng = np.random.default_rng(seed=1) + edges = np.array( + [ + [0, 0], + [1, 1], + [2, 2], + [3, 4], + [5, 6], + ], + dtype=np.uint32, + ) + + edges = rewire(edges, rng) + + assert edges.shape == (5, 2) + assert edges.dtype == np.uint32 + assert_no_bad_edges(edges) + + +def test_rewire_multiedges(): + rng = np.random.default_rng(seed=1) + edges = np.array( + [ + [0, 1], + [0, 1], + [2, 3], + [2, 3], + ], + dtype=np.uint32, + ) + + edges = rewire(edges, rng) + + assert edges.shape == (4, 2) + assert edges.dtype == np.uint32 + assert_no_bad_edges(edges) + + +def test_rewire_swap_two_bad_edges(): + rng = np.random.default_rng(seed=1) + edges = np.array([[0, 0], [1, 2], [1, 2]], dtype=np.uint32) + + edges = rewire(edges, rng) + + assert edges.shape == (3, 2) + assert edges.dtype == np.uint32 + assert_no_bad_edges(edges) + + +def test_rewire_many(): + rng = np.random.default_rng(seed=1) + edges = np.array( + [[0, 0], [0, 1], [0, 1], [2, 3], [2, 3], [3, 3], [4, 5], [5, 6]], + dtype=np.uint32, + ) + + edges = rewire(edges, rng) + + assert edges.shape == (8, 2) + assert edges.dtype == np.uint32 + assert_no_bad_edges(edges) + + +def test_rewire_failure(): + rng = np.random.default_rng(seed=1) + edges = np.array([[0, 0], [0, 1]], dtype=np.uint32) + + edges = rewire(edges, rng) + + assert edges.shape == (2, 2) + assert edges.dtype == np.uint32 + with pytest.raises(AssertionError): + assert_no_bad_edges(edges) + + +def test_rewire_drop_collisions(): + rng = np.random.default_rng(seed=1) + edges = np.array([[0, 0], [0, 1]], dtype=np.uint32) + + edges = rewire(edges, rng, drop_collisions=True) + + assert edges.shape == (1, 2) + assert edges.dtype == np.uint32 + assert_no_bad_edges(edges) From 841b6a4b84a231188e51cf4585dfd0a40bcaa2f2 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 15 Aug 2026 15:24:51 -0400 Subject: [PATCH 12/85] Ignore .DS_store --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 672b1f0..b1eaff8 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ __pycache__/ .coverage dist/ .python-version +.DS_store From 276ecd894d3af090cffa1d29850b5e62cb739546 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 15 Aug 2026 20:15:17 -0400 Subject: [PATCH 13/85] Add chunglu model --- abcd_graph/models.py | 23 ++++++++++++++++++++++- tests/test_models.py | 16 +++++++++++++++- 2 files changed, 37 insertions(+), 2 deletions(-) diff --git a/abcd_graph/models.py b/abcd_graph/models.py index bccbfcb..1d54347 100644 --- a/abcd_graph/models.py +++ b/abcd_graph/models.py @@ -8,6 +8,28 @@ from numpy.typing import NDArray +def chunglu_model( + node_ids: NDArray[np.uint32], degrees: NDArray[np.integer[Any]], rng: Generator +) -> NDArray[np.uint32]: + """Sample a random graph with, on expectation, the given degree sequence. + + Parameters + ---------- + node_ids: NDArray[np.uint32] + List of node_ids for the graph. The returned edge list will contain each + node_id equal to it's degree + + degrees: NDArray[np.integer[Any]] + List of degrees. The value degrees[i] corresponds to the degree of node node_ids[i] + + rng: Generator + numpy.random.Generator object used for randomness. + """ + node_probs = degrees / degrees.sum() + edges = rng.choice(node_ids, size=np.sum(degrees), p=node_probs).reshape(-1, 2) + return edges + + def configuration_model( node_ids: NDArray[np.uint32], degrees: NDArray[np.integer[Any]], rng: Generator ) -> NDArray[np.uint32]: @@ -15,7 +37,6 @@ def configuration_model( Parameters ---------- - node_ids: NDArray[np.uint32] List of node_ids for the graph. The returned edge list will contain each node_id equal to it's degree diff --git a/tests/test_models.py b/tests/test_models.py index ec7ce38..f9bb2b5 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -3,7 +3,7 @@ import scipy.sparse as sp from numpy.typing import NDArray -from abcd_graph.models import configuration_model, rewire +from abcd_graph.models import chunglu_model, configuration_model, rewire def assert_no_bad_edges(edges: NDArray[np.uint32]): @@ -16,6 +16,19 @@ def assert_no_bad_edges(edges: NDArray[np.uint32]): assert np.all(adjacency_matrix.data == 1) +def test_chunglu_model(): + rng = np.random.default_rng(seed=1) + node_ids = np.arange(32, dtype=np.uint32) + degrees = np.full(32, 4, dtype=np.int64) + + edges = chunglu_model(node_ids, degrees, rng) + + ids, counts = np.unique(edges, return_counts=True) + assert set(ids).issubset(set(node_ids)) + assert edges.dtype == np.uint32 + assert edges.shape == (64, 2) + + def test_configuration_model(): rng = np.random.default_rng(seed=1) node_ids = np.arange(32, dtype=np.uint32) @@ -27,6 +40,7 @@ def test_configuration_model(): assert set(ids) == set(node_ids) assert np.all(counts == 4) assert edges.dtype == np.uint32 + assert edges.shape == (64, 2) def test_rewire_loops(): From 4336194f110bf6b3793eb3bc81b0ef9c660813de Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 16 Aug 2026 08:05:55 -0400 Subject: [PATCH 14/85] Add community assignment for partitions and overlaps --- abcd_graph/membership.py | 149 +++++++++++++++++++++++++++++++++++++++ tests/test_membership.py | 72 +++++++++++++++++++ 2 files changed, 221 insertions(+) create mode 100644 abcd_graph/membership.py create mode 100644 tests/test_membership.py diff --git a/abcd_graph/membership.py b/abcd_graph/membership.py new file mode 100644 index 0000000..cd9ff01 --- /dev/null +++ b/abcd_graph/membership.py @@ -0,0 +1,149 @@ +from typing import Any + +import numpy as np +import scipy.sparse as sp +from numpy.random import Generator +from numpy.typing import NDArray + + +def make_primary_community_sizes( + n: int, + community_sizes: NDArray[np.integer[Any]], + rng: Generator, +) -> NDArray[np.integer[Any]]: + n_coms = len(community_sizes) + # Make primary community sizes with expected size + # equal to full_size / eta. + eta = np.sum(community_sizes) / n + primary_community_sizes = community_sizes / eta + primary_community_sizes += rng.uniform(size=n_coms) + primary_community_sizes = primary_community_sizes.astype(np.uint32) + # Ensure no community has size 0 + primary_community_sizes[primary_community_sizes == 0] += 1 + # Sum of primary community sizes must be n (will be on expectation). + # Increase or decrease random communities by one (but not to size 0) + # to make it so. + primary_size_sum = np.sum(primary_community_sizes) + required_change = n - primary_size_sum + if required_change > 0: + increase_indices = rng.choice(n_coms, size=required_change, replace=False) + primary_community_sizes[increase_indices] += 1 + elif required_change < 0: + big_coms = np.where(primary_community_sizes > 1)[0] + decrease_indices = rng.choice( + big_coms, size=required_change * -1, replace=False + ) + primary_community_sizes[decrease_indices] -= 1 + return primary_community_sizes + + +def make_overlapping_communities( + n: int, + community_sizes: NDArray[np.uint32], + dimension: int, + rng: Generator, +) -> sp.csr_array: + primary_community_sizes = make_primary_community_sizes(n, community_sizes, rng) + + # Make random points on hyperball + direction = rng.standard_normal(size=(n, dimension), dtype=np.float32) + direction /= np.linalg.norm(direction, axis=1, keepdims=True) + radii = rng.random(size=(n, 1), dtype=np.float32) ** (1.0 / dimension) + points = radii * direction + + # TODO pynndescent with masked query + # for now brute force + primary_communities = [] + has_primary = np.zeros(n, dtype=np.bool) + norms = np.linalg.norm(points, axis=1) + for size in primary_community_sizes: + available_ids = np.where(~has_primary)[0].astype(np.uint32) + seed = np.argmax(norms[available_ids]) + dist_from_seed = np.linalg.norm(points[available_ids] - seed, axis=1) + community_ids = available_ids[np.argsort(dist_from_seed)[:size]] + primary_communities.append(community_ids) + has_primary[community_ids] = True + + # Expand primary communities to full size + communities = [] + for primary_members, final_size in zip( + primary_communities, community_sizes, strict=True + ): + n_new = final_size - len(primary_members) + non_members = np.setdiff1d(np.arange(n), primary_members).astype(np.uint32) + community_mean = np.mean(points[primary_members], axis=0) + dist_to_mean = np.linalg.norm(points[non_members] - community_mean, axis=1) + new_members = non_members[np.argsort(dist_to_mean)[:n_new]] + communities.append(np.concatenate((primary_members, new_members))) + + indptr = np.arange(len(community_sizes) + 1, dtype=np.uint64) + indices = np.empty(np.sum(community_sizes), dtype=np.uint32) + next_indptr = 0 + for i, members in enumerate(communities): + indptr[i] = next_indptr + indices[next_indptr : next_indptr + len(members)] = members + next_indptr += len(members) + indptr[-1] = next_indptr + data = np.ones_like(indices, dtype=np.bool) + membership_array = sp.csr_array( + (data, indices, indptr), shape=(len(community_sizes), n) + ) + return membership_array + + +def build_membership_matrix( + n: int, + community_sizes: NDArray[np.integer[Any]], + n_outliers: int, + dimension: int, + rng: Generator, +) -> sp.csr_array: + """ + Build a communities x nodes sparse array of community memberships. + + Parameters + ---------- + n: int + The number of nodes + + community_sizes: NDArray[np.integer[Any]] + Array of final community sizes. + + n_outliers: int + Number of outlier nodes, i.e. no community. These will be assigned + the higher of node ids. + + dimension: int + Dimension of geometry for overlapping communities. Not used if eta=1.0. + + rng: Generator + numpy.random.Generator object used for randomness in the construction + of overlapping communities. Not used if eta=1.0. + """ + n_inliers = n - n_outliers + # eta is average number of communities per non-outlier node, following + # naming from the ABCDoo paper + eta = np.sum(community_sizes) / n_inliers + if eta == 1: + indptr = np.cumsum(community_sizes) + indptr = np.insert(indptr, 0, 0) + indices = np.arange(np.sum(community_sizes), dtype=np.int32) + data = np.ones_like(indices, dtype=np.bool) + membership_array = sp.csr_array( + (data, indices, indptr), shape=(len(community_sizes), n) + ) + return membership_array + + if eta < 1: + raise ValueError("eta must be at least 1.") + if dimension < 1: + raise ValueError("dimension must be at least 1.") + membership_matrix = make_overlapping_communities( + n_inliers, + community_sizes, + dimension, + rng, + ) + # Add outliers as empty columns on the right + membership_matrix._shape = (len(community_sizes), n) + return membership_matrix diff --git a/tests/test_membership.py b/tests/test_membership.py new file mode 100644 index 0000000..3fcd066 --- /dev/null +++ b/tests/test_membership.py @@ -0,0 +1,72 @@ +import numpy as np +import pytest + +from abcd_graph.membership import ( + build_membership_matrix, + make_primary_community_sizes, +) + + +@pytest.mark.parametrize("n", [20, 25]) +def test_primary_community_sizes(n): + community_sizes = np.array([10, 10, 10]) + rng = np.random.default_rng(seed=1) + + primary_community_sizes = make_primary_community_sizes(n, community_sizes, rng) + + expected_values = community_sizes / (np.sum(community_sizes) / n) + assert np.max(np.abs(primary_community_sizes - expected_values)) < 1 + assert np.sum(primary_community_sizes) == n + assert primary_community_sizes.dtype == np.uint32 + + +def test_no_zero_primary_community_sizes(): + n = 20 + community_sizes = np.array([10, 10, 10, 1]) + rng = np.random.default_rng(seed=1) + + primary_community_sizes = make_primary_community_sizes(n, community_sizes, rng) + + expected_values = community_sizes / (np.sum(community_sizes) / n) + assert np.max(np.abs(primary_community_sizes - expected_values)) < 1 + assert np.sum(primary_community_sizes) == n + assert primary_community_sizes.dtype == np.uint32 + assert np.all(primary_community_sizes > 0) + + +@pytest.mark.parametrize("n", [20, 25]) +@pytest.mark.parametrize("n_out", [3, 5]) +def test_build_membership_matrix(n, n_out): + community_sizes = np.array([5, n - n_out - 5]) + dimension = 2 + rng = np.random.default_rng(seed=1) + + membership_array = build_membership_matrix( + n, community_sizes, n_out, dimension, rng + ) + + assert membership_array.shape == (len(community_sizes), n) + assert np.all(membership_array.sum(axis=1) == community_sizes) + n_coms = membership_array.sum(axis=0) + assert np.all(n_coms[: n - n_out] == 1) + assert np.all(n_coms[n - n_out :] == 0) + assert np.all(membership_array.data == 1) + + +@pytest.mark.parametrize("n", [20, 25]) +@pytest.mark.parametrize("n_out", [3, 5]) +@pytest.mark.parametrize("dimension", [2, 4]) +def test_build_overlapping_membership_matrix(n, n_out, dimension): + community_sizes = np.array([10, 10, 10]) + rng = np.random.default_rng(seed=1) + + membership_array = build_membership_matrix( + n, community_sizes, n_out, dimension, rng + ) + + assert membership_array.shape == (len(community_sizes), n) + assert np.all(membership_array.sum(axis=1) == community_sizes) + n_coms = membership_array.sum(axis=0) + assert np.all(n_coms[: n - n_out] >= 1) + assert np.all(n_coms[n - n_out :] == 0) + assert np.all(membership_array.data == 1) From 5b29725b3776ef31394386f774120b301ae5aa00 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 16 Aug 2026 09:15:01 -0400 Subject: [PATCH 15/85] Add function to split degrees among background and communities --- abcd_graph/degrees.py | 81 +++++++++++++++++++++++++++++++++++++++++++ tests/test_degrees.py | 31 +++++++++++++++++ 2 files changed, 112 insertions(+) create mode 100644 abcd_graph/degrees.py create mode 100644 tests/test_degrees.py diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py new file mode 100644 index 0000000..c0b2caf --- /dev/null +++ b/abcd_graph/degrees.py @@ -0,0 +1,81 @@ +import numpy as np +import scipy.sparse as sp +from numba import njit +from numpy.random import Generator +from numpy.typing import NDArray + + +@njit +def _split_community_degree( + community_degrees: NDArray[np.uint32], + background_degrees: NDArray[np.uint32], + indptr: NDArray[np.uint64], + data: NDArray[np.uint32], + rng: Generator, +) -> None: + for i in range(len(community_degrees)): + n_coms = indptr[i + 1] - indptr[i] + if n_coms == 0: + background_degrees[i] += community_degrees[i] + continue + min_degree = int(community_degrees[i] / n_coms) + data[indptr[i] : indptr[i + 1]] = min_degree + n_to_add = community_degrees[i] - min_degree * n_coms + if n_to_add > 0: + random_numbers = rng.uniform(size=n_coms) + add_indices = np.argsort(random_numbers)[:n_to_add] + add_indices += indptr[i] + for j in add_indices: + data[j] += 1 + + +def split_degrees( + degrees: NDArray[np.uint32], + membership_matrix: sp.csr_array, + xi: float, + rng: Generator, +) -> (sp.csr_array, NDArray[np.uint32]): + """Split degrees into community degrees and background degrees. The fraction of + degree in the background is, on expectation, xi. Community degrees will be split + evenly among communities if the nodes belongs to more than one. + + Parameters + ---------- + degrees: NDArray + Array of degrees. + + membership_matrix: sp.csr_array + n_communities x n_nodes sparse matrix of memberships. A one at index i,j means + node j is in community i. Outlier nodes have no membership. + + xi: float + Proportion of degrees assigned to the background graph. + + rng: Generator + numpy.random.Generator for a source of randomness. + + Returns + ------- + community_degrees: sp.csr_array + n_communities x n_nodes sparse matrix of community degrees. The value at index i,j + is the degree of node j in community i. Has the same non-zero entries as the + membership_matrix. + + background_degrees: NDArray[np.uint32] + Array for the degree of each node in the background graph. + """ + background_degrees = degrees * xi + background_degrees += rng.uniform(size=len(degrees)) + background_degrees = background_degrees.astype(np.uint32) + + community_degrees = membership_matrix.copy().astype(np.uint32) + community_degrees = community_degrees.tocsc() + _split_community_degree( + degrees - background_degrees, + background_degrees, + community_degrees.indptr, + community_degrees.data, + rng, + ) + + return community_degrees.tocsr(), background_degrees diff --git a/tests/test_degrees.py b/tests/test_degrees.py new file mode 100644 index 0000000..f88badd --- /dev/null +++ b/tests/test_degrees.py @@ -0,0 +1,31 @@ +import numpy as np +import pytest +import scipy.sparse as sp + +from abcd_graph.degrees import split_degrees + + +@pytest.mark.parametrize("xi", [0.2, 0.4]) +def test_split_degrees(xi): + degrees = np.array([10, 5, 3]) + membership_matrix = sp.csr_array([[1, 0, 0], [1, 1, 0]]) + rng = np.random.default_rng(seed=1) + + community_degrees, background_degrees = split_degrees( + degrees, + membership_matrix, + xi, + rng, + ) + + assert community_degrees.dtype == np.uint32 + assert community_degrees.shape == membership_matrix.shape + assert len(background_degrees) == len(degrees) + assert background_degrees.dtype == np.uint32 + assert np.all(community_degrees.sum(axis=0) + background_degrees == degrees) + is_outlier = membership_matrix.sum(axis=0) == 0 + assert np.all(np.abs(background_degrees - degrees * xi)[~is_outlier] < 1) + assert np.all( + np.abs(community_degrees.sum(axis=0) - degrees * (1 - xi))[~is_outlier] < 1 + ) + assert np.all(background_degrees[is_outlier] == degrees[is_outlier]) From 88e076ebf26badfcb3d80c8aed6ed001a214cf5d Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 16 Aug 2026 15:25:55 -0400 Subject: [PATCH 16/85] Add degree assignment and splitting --- abcd_graph/degrees.py | 239 +++++++++++++++++++++++++++++++++++++++++- tests/test_degrees.py | 82 ++++++++++++++- 2 files changed, 319 insertions(+), 2 deletions(-) diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index c0b2caf..5f217a4 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -5,7 +5,7 @@ from numpy.typing import NDArray -@njit +@njit(cache=True) def _split_community_degree( community_degrees: NDArray[np.uint32], background_degrees: NDArray[np.uint32], @@ -79,3 +79,240 @@ def split_degrees( ) return community_degrees.tocsr(), background_degrees + + +def _assign_outlier_degrees( + degrees: NDArray[np.uint32], + outlier_threshold: float, + n_outliers: int, + rng: Generator, +) -> (NDArray[np.uint32], NDArray[np.uint32]): + available_indices = np.where(degrees < outlier_threshold)[0] + if len(available_indices) > n_outliers: + chosen_indices = rng.choice(available_indices, size=n_outliers, replace=False) + else: + chosen_indices = np.argsort(degrees)[:n_outliers] + outlier_degrees = degrees[chosen_indices] + + remaining_mask = np.ones_like(degrees, dtype=np.bool) + remaining_mask[chosen_indices] = False + remaining_degrees = degrees[remaining_mask] + + return outlier_degrees, remaining_degrees + + +@njit(cache=True) +def _assign_degrees( + degrees: NDArray[np.uint32], + n_coms: NDArray, + thresholds: NDArray[np.floating], + rng: Generator, + alpha: float = 0.0, +) -> NDArray[np.uint32]: + assigned_degrees = np.empty_like(degrees) + open_nodes = np.arange(len(n_coms), dtype=np.uint32)[n_coms > 0] + n_coms_exp_alpha = n_coms.astype(np.float64) ** alpha + for d in degrees: + allowed_indices = np.where(d <= thresholds[open_nodes])[0] + if len(allowed_indices) == 0: + allowed_indices = np.where( + thresholds[open_nodes] == np.min(thresholds[open_nodes]) + )[0] + allowed_nodes = open_nodes[allowed_indices] + + # Choose an available node proportional to n_coms ** alpha + if len(allowed_nodes) > 1: + probs = n_coms_exp_alpha[allowed_nodes] + probs /= np.sum(probs) + cum_prob = np.cumsum(probs) + random_value = rng.uniform() + chosen_index = np.searchsorted(cum_prob, random_value) + else: + chosen_index = 0 + assigned_degrees[allowed_nodes[chosen_index]] = d + + # Remove assigned node and shorten list + open_nodes[allowed_indices[chosen_index]] = open_nodes[-1] + open_nodes = open_nodes[:-1] + + return assigned_degrees + + +@njit(cache=True) +def _assign_degrees_with_alpha_search( + degrees: NDArray[np.uint32], + n_coms: NDArray[np.uint32], + thresholds: NDArray[np.floating], + rng: Generator, + rho: float, + rho_tol: float, + alpha_min: float, + alpha_max: float, + alpha_iters: int, +): + # We known the sign of alpha will match the sign of rho + if rho > 0: + max_rho_degrees = _assign_degrees( + degrees, + n_coms, + thresholds, + rng, + alpha_max, + ) + empirical_rho = np.corrcoef(max_rho_degrees, n_coms)[0, 1] + if empirical_rho < rho: # Return best try + return max_rho_degrees + else: # Prep search for positive alpha + alpha_min = 0 + + elif rho < 0: + min_rho_degrees = _assign_degrees( + degrees, + n_coms, + thresholds, + rng, + alpha_min, + ) + empirical_rho = np.corrcoef(min_rho_degrees, n_coms)[0, 1] + if empirical_rho > rho: # Return best try + return min_rho_degrees + else: # Prep search for negative alpha + alpha_max = 0 + + # Default to alpha=0 + assigned_degrees = _assign_degrees( + degrees, + n_coms, + thresholds, + rng, + ) + + # Binary search for best alpha + for _ in range(alpha_iters): + alpha = (alpha_max + alpha_min) / 2 + assigned_degrees = _assign_degrees( + degrees, + n_coms, + thresholds, + rng, + alpha, + ) + empirical_rho = np.corrcoef(assigned_degrees, n_coms)[0, 1] + if np.abs(empirical_rho - rho) < rho_tol: + return assigned_degrees + elif empirical_rho > rho: + alpha_max = alpha + else: + alpha_min = alpha + + return assigned_degrees + + +def assign_degrees( + degrees: NDArray[np.uint32], + membership_matrix: sp.csr_array, + xi: float, + rng: Generator, + rho: float = 0.0, + rho_tol: float = 0.01, + alpha_min: float = -60, + alpha_max: float = 60, + alpha_iters: int = 10, +) -> NDArray[np.uint32]: + """Assign degrees to nodes. + + Parameters + ---------- + degrees: NDArray[np.uint32] + Array of available degrees in any ordering. + + membership_matrix: sp.csr_array + n_communities x n_nodes sparse matrix for community membership. + + xi: float + Proportion of each degree that will be assigned to the global + background graph. + + rho: float + Target pearson correlation between node degree and number of + communities the node is in. Only used if there is overlap. + + rho_tol: float + Tolerance on empirical rho to stop alpha search early. + + alpha_min: float + Internal parameter used for correlation between degree and number of + communities. + + alpha_max: float + Internal parameter used for correlation between degree and number of + communities. + + alpha_iters: int + Number of times to try alphas in a binary search. + + rng: Generator + Source of randomness. + + Returns + ------- + assigned_degrees: NDArray[np.uint32] + Array of degrees that is aligned with the membership matrix. + + """ + degrees = np.sort(degrees)[::-1] # sort degrees descending + community_sizes = membership_matrix.sum(axis=1).astype( + np.uint32 + ) # size of each community + membership_matrix = membership_matrix.tocsc() + n_coms = membership_matrix.sum(axis=0) # number of communities per node + community_size_matrix = ( + sp.diags_array(community_sizes, dtype=np.uint32) @ membership_matrix + ) + min_com_sizes = community_size_matrix.min(axis=0, explicit=True).todense() + + n = membership_matrix.shape[1] + n_outliers = np.sum(n_coms == 0) + n_inliers = n - n_outliers + outlier_threshold = ( + (n_inliers / n) * np.sum(np.minimum(xi * degrees, 1)) + n_outliers - 1 + ) + + assigned_degrees = np.empty_like(degrees) + outlier_mask = n_coms == 0 + outlier_degrees, remaining_degrees = _assign_outlier_degrees( + degrees, + outlier_threshold, + n_outliers, + rng, + ) + assigned_degrees[outlier_mask] = outlier_degrees + + eta = np.sum(community_sizes) / n_inliers + expected_primary_community_sizes = community_sizes / eta + phi = 1 - n_inliers * xi / (n_inliers * xi + n_outliers) * np.sum( + np.power(expected_primary_community_sizes / n_inliers, 2) + ) + thresholds = min_com_sizes[~outlier_mask] * n_coms[~outlier_mask] / (1 - xi * phi) + + if rho == 0: + inlier_degrees = _assign_degrees( + remaining_degrees, + n_coms[~outlier_mask], + thresholds, + rng, + ) + else: + inlier_degrees = _assign_degrees_with_alpha_search( + remaining_degrees, + n_coms[~outlier_mask], + thresholds, + rng, + rho, + rho_tol, + alpha_min, + alpha_max, + alpha_iters, + ) + assigned_degrees[~outlier_mask] = inlier_degrees + return assigned_degrees diff --git a/tests/test_degrees.py b/tests/test_degrees.py index f88badd..9015148 100644 --- a/tests/test_degrees.py +++ b/tests/test_degrees.py @@ -2,7 +2,7 @@ import pytest import scipy.sparse as sp -from abcd_graph.degrees import split_degrees +from abcd_graph.degrees import assign_degrees, split_degrees @pytest.mark.parametrize("xi", [0.2, 0.4]) @@ -29,3 +29,83 @@ def test_split_degrees(xi): np.abs(community_degrees.sum(axis=0) - degrees * (1 - xi))[~is_outlier] < 1 ) assert np.all(background_degrees[is_outlier] == degrees[is_outlier]) + + +def test_assign_degrees_no_overlap(): + degrees = np.concatenate( + (np.full(16, 4, dtype=np.uint32), np.full(16, 3, dtype=np.uint32)) + ) + # Membership matrix with 4 communities size 7 and 4 outliers + indptr = np.arange(5, dtype=np.uint32) * 7 + indices = np.arange(28, dtype=np.uint32) + data = np.ones(28, dtype=np.bool) + membership_matrix = sp.csr_array((data, indices, indptr), shape=(4, 32)) + xi = 0.2 + rng = np.random.default_rng(seed=1) + + assigned_degrees = assign_degrees( + degrees, + membership_matrix, + xi, + rng, + ) + + assert assigned_degrees.shape == degrees.shape + assert assigned_degrees.dtype == np.uint32 + assert np.sum(assigned_degrees == 4) == 16 + assert np.sum(assigned_degrees == 3) == 16 + + +def test_assign_degrees_overlap(): + degrees = np.concatenate( + (np.full(16, 4, dtype=np.uint32), np.full(16, 3, dtype=np.uint32)) + ) + # Membership matrix with 4 communities size 7 and 4 outliers + indptr = np.arange(6, dtype=np.uint32) * 7 + indices = np.concatenate((np.arange(28, dtype=np.uint32), np.arange(7) * 4)) + data = np.ones(35, dtype=np.bool) + membership_matrix = sp.csr_array((data, indices, indptr), shape=(5, 32)) + xi = 0.2 + rng = np.random.default_rng(seed=1) + + assigned_degrees = assign_degrees( + degrees, + membership_matrix, + xi, + rng, + ) + + assert assigned_degrees.shape == degrees.shape + assert assigned_degrees.dtype == np.uint32 + assert np.sum(assigned_degrees == 4) == 16 + assert np.sum(assigned_degrees == 3) == 16 + + +@pytest.mark.parametrize("xi", [0.2, 0.4]) +@pytest.mark.parametrize("rho", [-0.7, -0.2, 0.2, 0.7]) +def test_assign_degrees_overlap_with_rho(xi, rho): + degrees = np.concatenate( + (np.full(16, 4, dtype=np.uint32), np.full(16, 3, dtype=np.uint32)) + ) + # Membership matrix with 4 communities size 7 and 4 outliers + indptr = np.arange(6, dtype=np.uint32) * 7 + indices = np.concatenate((np.arange(28, dtype=np.uint32), np.arange(7) * 4)) + data = np.ones(35, dtype=np.bool) + membership_matrix = sp.csr_array((data, indices, indptr), shape=(5, 32)) + rng = np.random.default_rng(seed=1) + + assigned_degrees = assign_degrees( + degrees, + membership_matrix, + xi, + rng, + rho, + ) + + assert assigned_degrees.shape == degrees.shape + assert assigned_degrees.dtype == np.uint32 + assert np.sum(assigned_degrees == 4) == 16 + assert np.sum(assigned_degrees == 3) == 16 + n_coms = membership_matrix.sum(axis=0) + empirical_rho = np.corrcoef(assigned_degrees, n_coms)[0, 1] + assert np.sign(empirical_rho) == np.sign(rho) From af39a10e96fd5bd880642f66167b697f5e70ca90 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 16 Aug 2026 19:22:03 -0400 Subject: [PATCH 17/85] Add degree and community samplers --- abcd_graph/samplers.py | 96 ++++++++++++++++++++++++++++++++++++++++++ tests/test_samplers.py | 74 ++++++++++++++++++++++++++++++++ 2 files changed, 170 insertions(+) create mode 100644 abcd_graph/samplers.py create mode 100644 tests/test_samplers.py diff --git a/abcd_graph/samplers.py b/abcd_graph/samplers.py new file mode 100644 index 0000000..2860b88 --- /dev/null +++ b/abcd_graph/samplers.py @@ -0,0 +1,96 @@ +import numpy as np +from numba import njit +from numpy.random import Generator +from numpy.typing import NDArray + + +def sample_degrees( + n: int, + degree_exponent: float, + min_degree: int, + max_degree: int, + rng: Generator, +): + options = np.arange(min_degree, max_degree + 1, dtype=np.uint32) + probs = options.astype(np.float32) ** -degree_exponent + probs /= np.sum(probs) + degrees = rng.choice(options, p=probs, size=n) + return degrees + + +@njit +def _sample_community_sizes( + available_sizes: NDArray[np.uint32], + prob_cumsum: NDArray[np.float32], + target_sum: float, + rng: Generator, +): + max_n_communities = int(np.ceil(target_sum / available_sizes[0])) + community_sizes = np.empty(max_n_communities, dtype=np.uint32) + + next_id = 0 + sizes_sum = 0 + for i in range(len(community_sizes)): + random = rng.uniform() + index = np.searchsorted(prob_cumsum, random) + size = available_sizes[index] + community_sizes[i] = size + next_id += 1 + sizes_sum += size + if sizes_sum > target_sum - 1: + break + + return community_sizes[:next_id] + + +def fix_community_sizes( + community_sizes: NDArray[np.uint32], + target_sum: float, + min_community_size: int, + max_community_size: int, + rng: Generator, +): + sizes_sum = np.sum(community_sizes) + if sizes_sum - target_sum >= 1: + # rand round target_sum up or down + target_sum = int(target_sum + rng.uniform()) + decrease_amount = int(sizes_sum - target_sum) + if community_sizes[-1] >= decrease_amount + min_community_size: + community_sizes[-1] -= decrease_amount + else: + increase_amount = community_sizes[-1] - decrease_amount + community_sizes = community_sizes[:-1] + increasable_indices = np.where(community_sizes < max_community_size)[0] + indices_to_increase = rng.choice( + increasable_indices, size=increase_amount, replace=False + ) + community_sizes[indices_to_increase] += 1 + return community_sizes + + +def sample_community_sizes( + n: int, + community_size_exponent: float, + min_community_size: int, + max_community_size: int, + eta: float, + rng: Generator, +): + target_sum = n * eta + options = np.arange(min_community_size, max_community_size + 1, dtype=np.uint32) + probs = options.astype(np.float32) ** -community_size_exponent + probs /= np.sum(probs) + prob_cumsum = np.cumsum(probs) + + community_sizes = _sample_community_sizes( + options, + prob_cumsum, + target_sum, + rng, + ) + + community_sizes = fix_community_sizes( + community_sizes, target_sum, min_community_size, max_community_size, rng + ) + + return community_sizes diff --git a/tests/test_samplers.py b/tests/test_samplers.py new file mode 100644 index 0000000..ca4cde2 --- /dev/null +++ b/tests/test_samplers.py @@ -0,0 +1,74 @@ +import numpy as np +import pytest + +from abcd_graph.samplers import ( + fix_community_sizes, + sample_community_sizes, + sample_degrees, +) + + +@pytest.mark.parametrize("n", [20, 25]) +def test_sample_degrees(n): + exponent = 2.5 + min_degree = 3 + max_degree = 5 + rng = np.random.default_rng(seed=1) + + degrees = sample_degrees(n, exponent, min_degree, max_degree, rng) + + assert degrees.shape == (n,) + assert set(degrees).issubset(set(range(min_degree, max_degree + 1))) + + +def test_fix_community_sizes_decrease_last(): + community_sizes = np.array([10, 10, 10]) + target_sum = 25 + min_community_size = 3 + max_community_size = 15 + rng = np.random.default_rng(seed=1) # Not used but must be passed + + fixed_sizes = fix_community_sizes( + community_sizes, target_sum, min_community_size, max_community_size, rng + ) + + assert np.all(np.array([10, 10, 5]) == fixed_sizes) + + +def test_fix_community_sizes_increase_random(): + community_sizes = np.array([12, 12, 4]) + target_sum = 25 + min_community_size = 3 + max_community_size = 15 + rng = np.random.default_rng(seed=1) + + fixed_sizes = fix_community_sizes( + community_sizes, target_sum, min_community_size, max_community_size, rng + ) + + assert 12 in fixed_sizes + assert 13 in fixed_sizes + assert len(fixed_sizes) == 2 + assert np.sum(fixed_sizes) == target_sum + + +@pytest.mark.parametrize("n", [20, 25]) +@pytest.mark.parametrize("eta", [1.0, 1.5]) +def test_sample_community_sizes_no_overlap(n, eta): + exponent = 1.5 + min_community_size = 3 + max_community_size = 10 + rng = np.random.default_rng() + + community_sizes = sample_community_sizes( + n, exponent, min_community_size, max_community_size, eta, rng + ) + + min_n_communities = n * eta / max_community_size + max_n_communities = n * eta / min_community_size + assert len(community_sizes) > min_n_communities + assert len(community_sizes) < max_n_communities + assert set(community_sizes).issubset( + set(range(min_community_size, max_community_size + 1)) + ) + assert np.abs(np.sum(community_sizes) - n * eta) < 1 From f6157631ca6cc9518df073591f22cc0913e2c948 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 16 Aug 2026 20:25:16 -0400 Subject: [PATCH 18/85] Try harder to fix community sizes --- abcd_graph/samplers.py | 18 +++++++++++++----- 1 file changed, 13 insertions(+), 5 deletions(-) diff --git a/abcd_graph/samplers.py b/abcd_graph/samplers.py index 2860b88..948b97b 100644 --- a/abcd_graph/samplers.py +++ b/abcd_graph/samplers.py @@ -60,11 +60,19 @@ def fix_community_sizes( else: increase_amount = community_sizes[-1] - decrease_amount community_sizes = community_sizes[:-1] - increasable_indices = np.where(community_sizes < max_community_size)[0] - indices_to_increase = rng.choice( - increasable_indices, size=increase_amount, replace=False - ) - community_sizes[indices_to_increase] += 1 + while increase_amount > 0: + increasable_indices = np.where(community_sizes < max_community_size)[0] + if len(increasable_indices) == 0: + raise ValueError( + "Stuck fixing community sizes. This is likely caused by a too large min_community_size." + ) + n_to_increase = min(increase_amount, len(increasable_indices)) + indices_to_increase = rng.choice( + increasable_indices, size=n_to_increase, replace=False + ) + community_sizes[indices_to_increase] += 1 + increase_amount -= n_to_increase + return community_sizes From f1d2f78ca1458a05bb88f0f89867073008254488 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 16 Aug 2026 20:26:14 -0400 Subject: [PATCH 19/85] Make community size sums even --- abcd_graph/degrees.py | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index 5f217a4..ba85ed3 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -29,6 +29,28 @@ def _split_community_degree( data[j] += 1 +def make_community_degree_sums_even( + community_degrees: sp.csr_array, + background_degrees: NDArray[np.uint32], + rng: Generator, +): + community_degree_sums = community_degrees.sum(axis=1) + odd_coms = np.where(community_degree_sums % 2 != 0)[0] + for com in odd_coms: + com_members = community_degrees.indices[ + community_degrees.indptr[com] : community_degrees.indptr[com + 1] + ] + com_degrees = community_degrees.data[ + community_degrees.indptr[com] : community_degrees.indptr[com + 1] + ] + indices_of_max_degree = com_members[ + np.where(com_degrees == np.max(com_degrees))[0] + ] + decrease_index = rng.choice(indices_of_max_degree) + community_degrees[com, decrease_index] -= 1 + background_degrees[decrease_index] += 1 + + def split_degrees( degrees: NDArray[np.uint32], membership_matrix: sp.csr_array, @@ -77,7 +99,8 @@ def split_degrees( community_degrees.data, rng, ) - + community_degrees = community_degrees.tocsr() + make_community_degree_sums_even(community_degrees, background_degrees, rng) return community_degrees.tocsr(), background_degrees From 7e1a4bfbfa67230142757dfa8fde8542c9148663 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Mon, 17 Aug 2026 08:53:37 -0400 Subject: [PATCH 20/85] Check sum of community degrees is even --- abcd_graph/degrees.py | 46 ++++++++++++++++++++++++++++++------------- tests/test_degrees.py | 10 +++++----- 2 files changed, 37 insertions(+), 19 deletions(-) diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index ba85ed3..d4ec038 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -29,26 +29,34 @@ def _split_community_degree( data[j] += 1 +@njit(cache=True) def make_community_degree_sums_even( - community_degrees: sp.csr_array, + community_degrees_indptr: NDArray, + community_degrees_indices: NDArray, + community_degrees_data: NDArray, background_degrees: NDArray[np.uint32], rng: Generator, ): - community_degree_sums = community_degrees.sum(axis=1) - odd_coms = np.where(community_degree_sums % 2 != 0)[0] - for com in odd_coms: - com_members = community_degrees.indices[ - community_degrees.indptr[com] : community_degrees.indptr[com + 1] + for com in range(len(community_degrees_indptr) - 1): + com_members = community_degrees_indices[ + community_degrees_indptr[com] : community_degrees_indptr[com + 1] ] - com_degrees = community_degrees.data[ - community_degrees.indptr[com] : community_degrees.indptr[com + 1] + com_degrees = community_degrees_data[ + community_degrees_indptr[com] : community_degrees_indptr[com + 1] ] - indices_of_max_degree = com_members[ - np.where(com_degrees == np.max(com_degrees))[0] + print("Com", com, "degrees", com_degrees) + if np.sum(com_degrees.astype(np.uint64)) % 2 == 0: + continue + + print("Fixing com", com) + indices_of_max_degree = np.where(com_degrees == np.max(com_degrees))[0] + print("Max degree indices", indices_of_max_degree) + decrease_index = indices_of_max_degree[ + rng.integers(0, len(indices_of_max_degree)) ] - decrease_index = rng.choice(indices_of_max_degree) - community_degrees[com, decrease_index] -= 1 - background_degrees[decrease_index] += 1 + print("Decreasing index", decrease_index) + community_degrees_data[community_degrees_indptr[com] + decrease_index] -= 1 + background_degrees[com_members[decrease_index]] += 1 def split_degrees( @@ -100,7 +108,17 @@ def split_degrees( rng, ) community_degrees = community_degrees.tocsr() - make_community_degree_sums_even(community_degrees, background_degrees, rng) + print(community_degrees.todense()) + print(community_degrees.sum(axis=1)) + make_community_degree_sums_even( + community_degrees.indptr, + community_degrees.indices, + community_degrees.data, + background_degrees, + rng, + ) + print(community_degrees.todense()) + print(community_degrees.sum(axis=1)) return community_degrees.tocsr(), background_degrees diff --git a/tests/test_degrees.py b/tests/test_degrees.py index 9015148..f3a6bc7 100644 --- a/tests/test_degrees.py +++ b/tests/test_degrees.py @@ -2,7 +2,10 @@ import pytest import scipy.sparse as sp -from abcd_graph.degrees import assign_degrees, split_degrees +from abcd_graph.degrees import ( + assign_degrees, + split_degrees, +) @pytest.mark.parametrize("xi", [0.2, 0.4]) @@ -24,11 +27,8 @@ def test_split_degrees(xi): assert background_degrees.dtype == np.uint32 assert np.all(community_degrees.sum(axis=0) + background_degrees == degrees) is_outlier = membership_matrix.sum(axis=0) == 0 - assert np.all(np.abs(background_degrees - degrees * xi)[~is_outlier] < 1) - assert np.all( - np.abs(community_degrees.sum(axis=0) - degrees * (1 - xi))[~is_outlier] < 1 - ) assert np.all(background_degrees[is_outlier] == degrees[is_outlier]) + assert np.all(community_degrees.sum(axis=1) % 2 == 0) def test_assign_degrees_no_overlap(): From 3b2bcc9b506881bf2bb0bd065b9bb383b67366b3 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Mon, 17 Aug 2026 08:54:08 -0400 Subject: [PATCH 21/85] Check total degree is even --- abcd_graph/samplers.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/abcd_graph/samplers.py b/abcd_graph/samplers.py index 948b97b..a19c95c 100644 --- a/abcd_graph/samplers.py +++ b/abcd_graph/samplers.py @@ -15,6 +15,10 @@ def sample_degrees( probs = options.astype(np.float32) ** -degree_exponent probs /= np.sum(probs) degrees = rng.choice(options, p=probs, size=n) + if np.sum(degrees) % 2 == 1: + max_indices = np.where(degrees == np.max(degrees))[0] + index_to_decrease = rng.choice(max_indices) + degrees[index_to_decrease] -= 1 return degrees From 4affb6b042d762dd074ed5533300e7e38e01d2df Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Mon, 17 Aug 2026 08:54:38 -0400 Subject: [PATCH 22/85] Update ruff settings --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 2ffc0ee..7f03d2e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -66,6 +66,7 @@ select = [ ] ignore = [ "E501", # line too long (handled by black) + "B008", # Do not perform function call in defaults ] [tool.ruff.lint.per-file-ignores] From 5f8f96727ca31087a6f1844b048753b74fe049f5 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Mon, 17 Aug 2026 08:55:50 -0400 Subject: [PATCH 23/85] Initial implemention of top level ABCD class --- abcd_graph/__init__.py | 2 +- abcd_graph/abcd.py | 367 +++++++++++++++++++++++++++++++++++++++++ tests/test_abcd.py | 15 ++ tests/test_models.py | 13 +- tests/utils.py | 13 ++ 5 files changed, 397 insertions(+), 13 deletions(-) create mode 100644 abcd_graph/abcd.py create mode 100644 tests/test_abcd.py create mode 100644 tests/utils.py diff --git a/abcd_graph/__init__.py b/abcd_graph/__init__.py index 8b13789..e8da3ce 100644 --- a/abcd_graph/__init__.py +++ b/abcd_graph/__init__.py @@ -1 +1 @@ - +from abcd_graph.abcd import ABCD diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py new file mode 100644 index 0000000..da1daf8 --- /dev/null +++ b/abcd_graph/abcd.py @@ -0,0 +1,367 @@ +from collections.abc import Callable +from warnings import warn + +import numpy as np +import scipy.sparse as sp +from numpy.random import Generator +from numpy.typing import ArrayLike, NDArray + +from abcd_graph.degrees import assign_degrees, split_degrees +from abcd_graph.membership import build_membership_matrix +from abcd_graph.models import chunglu_model, configuration_model, rewire +from abcd_graph.samplers import sample_community_sizes, sample_degrees + + +class ABCD: + """Artificial Benchmark for Community Detection + + This class combines the ABCDGraph and ABCDParams class, essentially adding a + sample method to ABCDParams. + + Parameters + ---------- + + vcount : int + The number of vertices in the graph. + + gamma : float, default=2.5 + Powerlaw exponent for the degree distribution. Not used if + degree_sequence is passed. + + beta: float, default=1.5 + Powerlaw exponent for the community size distribution. Not used if a + custom community_size_sequence is passed. + + xi: float, default=0.25 + Proportion of edges in the global background graph. Setting xi=0 gives + disjoint communities while xi=1 gives a random graph with no community + structure. + + min_degree : int, default=5 + Minimum degree in the graph. Not used if degree_sequence is passed. + + max_degree : int, default=30 + Maximum degree in the graph. Not used if degree_sequence is passed. + + min_community_size : int, default=20 + Minimum community size. Not used if a custom community_size_sequence + is passed. + + max_community_size: int, default=250 + Maximum community size. Not used if a custom community_size_sequence + is passed. + + degree_sequence : Sequence[int] | NDArray[np.int64] | None, default=None + Used to pass a custom degree sequence that overrides the default + powerlaw distribution. + + community_size_sequence : Sequence[int] | NDArray[np.int64] | None, default=None + Used to pass a custom community size sequence that overrides the default + powerlaw distribution. The sum of the community sizes must equal the number + of vertices minus the number of outliers. + + num_outliers : int, default=0 + The number of outliers. These vertices have their entire degree in the + global background graph so do not appear in any community. + + model : Model | None, default=None + Random graph model used to sample the community and background graphs. + + verbose : bool, default=False + Flag to log runtime infomation. + """ + + def __init__( + self, + n: int, + xi: float = 0.25, + outliers: int | float = 0, + eta: float = 1.0, + dimension: int = 8, + rho: float = 0.0, + degree_exponent: float = 2.5, + min_degree: int = 5, + max_degree: int | Callable[[int], int] = lambda n: int(n**0.5), + community_size_exponent: float = 1.5, + min_community_size: int = 20, + max_community_size: int | Callable[[int], int] = lambda n: int(n**0.75), + degree_sequence: ArrayLike | None = None, + community_size_sequence: ArrayLike | None = None, + rho_tol: float = 0.05, + alpha_min: float = -60.0, + alpha_max: float = 60.0, + alpha_iters: int = 10, + model: str = "configuration", + max_swap_attempts_per_bad_edge: int = 5, + drop_collisions: bool = False, + rng: Generator = np.random.default_rng(), + verbose: bool = False, + ): + self.n = n + self.xi = xi + self.outliers = outliers + self.eta = eta + self.dimension = dimension + self.rho = rho + self.degree_exponent = degree_exponent + self.min_degree = min_degree + self.max_degree = max_degree + self.community_size_exponent = community_size_exponent + self.min_community_size = min_community_size + self.max_community_size = max_community_size + self.degree_sequence = degree_sequence + self.community_size_sequence = community_size_sequence + self.alpha_max = alpha_max + self.alpha_min = alpha_min + self.alpha_iters = alpha_iters + self.rho_tol = rho_tol + self.model = model + self.max_swap_attempts_per_bad_edge = max_swap_attempts_per_bad_edge + self.drop_collisions = drop_collisions + self.rng = rng + self.verbose = verbose + + def _validate_params(self): + if not isinstance(self.n, (int, np.integer)) or self.n < 1: + raise ValueError("n must be a positive integer") + + if not isinstance(self.xi, (float, np.floating)) or self.xi < 0 or self.xi > 1: + raise ValueError("xi must be a float between 0 and 1") + + if isinstance(self.outliers, (int, np.integer)): + if self.outliers < 0: + raise ValueError("integer outliers must be positive") + elif isinstance(self.outliers, (float, np.floating)): + if self.outliers < 0 or self.outliers > 1: + raise ValueError("float outliers must be between 0 and 1") + else: + raise ValueError( + "outliers must be a positive integer or a float between 0 and 1" + ) + + if not isinstance(self.eta, (float, np.floating)) or self.eta < 1: + raise ValueError("eta must be at least 1") + + if not isinstance(self.dimension, (int, np.integer)) or self.dimension < 1: + raise ValueError("dimensions must be a positive integer") + + if ( + not isinstance(self.rho, (float, np.floating)) + or self.rho < -1 + or self.rho > 1 + ): + raise ValueError("rho must be between -1 and 1") + + if ( + not isinstance(self.degree_exponent, (float, np.floating)) + or self.degree_exponent < 0 + ): + raise ValueError("rho must be positive") + elif self.degree_exponent < 2 or self.degree_exponent > 3: + warn("Typical degree exponents are between 2 and 3", stacklevel=2) + + if ( + not isinstance(self.min_degree, (int, np.integer)) + or self.min_degree < 1 + or self.min_degree >= self.n + ): + raise ValueError("min degree must be a positive int at most n") + + if not isinstance(self.max_degree, Callable) and ( + not isinstance(self.max_degree, (int, np.integer)) + or self.max_degree >= self.n + ): + raise ValueError( + "max degree must be greater than min degree and less than n" + ) + + if ( + not isinstance(self.community_size_exponent, (float, np.floating)) + or self.community_size_exponent < 0 + ): + raise ValueError("rho must be positive") + elif self.community_size_exponent < 1 or self.community_size_exponent > 2: + warn("Typical degree exponents are between 1 and 2", stacklevel=2) + + if ( + not isinstance(self.min_community_size, (int, np.integer)) + or self.min_community_size < 2 + or self.min_community_size >= self.n + ): + raise ValueError("min community size must be an integer between 2 and n") + + if not isinstance(self.max_community_size, Callable) and ( + not isinstance(self.max_community_size, (int, np.integer)) + or self.max_community_size >= self.n + ): + raise ValueError( + "max community size must be greater than min community size and less than n" + ) + + if self.degree_sequence is not None: + try: + self.degree_sequence_ = np.asarray( + self.degree_sequence, dtype=np.uint32 + ) + except TypeError as e: + raise ValueError( + "degree sequence must be able to cast to a numpy array of uint32" + ) from e + if self.degree_sequence_.shape != (self.n,): + raise ValueError("degree sequence must be 1d array of length n") + if np.sum(self.degree_sequence_) % 2 != 0: + raise ValueError("sum of degree sequence must be even") + + if self.community_size_sequence is not None: + try: + self.community_size_sequence_ = np.asarray( + self.community_size_sequence, dtype=np.uint32 + ) + except TypeError as e: + raise ValueError( + "community size sequence must be able to cast to a numpy array of uint32" + ) from e + if np.any(self.community_size_sequence >= self.n): + raise ValueError("community sizes must be less than n") + if np.any(self.community_size_sequence < 1): + raise ValueError("community sizes must be at least 2") + + if not isinstance(self.alpha_max, (float, np.floating)) or self.alpha_max <= 0: + raise ValueError("alpha max must be positive") + + if not isinstance(self.alpha_min, (float, np.floating)) or self.alpha_min >= 0: + raise ValueError("alpha min must be negative") + + if not isinstance(self.alpha_iters, (int, np.integer)) or self.alpha_iters < 1: + raise ValueError("alpha iters must be positive integer") + + if not isinstance(self.rho_tol, (float, np.floating)) or self.rho_tol < 0: + raise ValueError("rho tol must be at least 0") + + # TODO models + if self.model not in ["configuration", "chung-lu"]: + raise ValueError("model must be one of 'configuration' or 'chung-lu'") + + if ( + not isinstance(self.max_swap_attempts_per_bad_edge, (int, np.integer)) + or self.max_swap_attempts_per_bad_edge < 1 + ): + raise ValueError( + "max swap attempts per bad edge must a be positive integer" + ) + + if not isinstance(self.drop_collisions, (bool, np.bool)): + raise ValueError("drop collisions must be True or False") + + if not isinstance(self.rng, np.random.Generator): + raise ValueError("rng must be a numpy.random.Generator object") + + def sample(self) -> (NDArray[np.uint32], sp.csr_array): + self._validate_params() + + if self.outliers < 1: + n_outliers = int(self.n * self.outliers) + else: + n_outliers = self.outliers + + if self.degree_sequence is None: + self.max_degree_ = ( + self.max_degree(self.n) + if callable(self.max_degree) + else self.max_degree + ) + self.degree_sequence_ = sample_degrees( + self.n, + self.degree_exponent, + self.min_degree, + self.max_degree_, + self.rng, + ) + + if self.community_size_sequence is None: + self.max_community_size_ = ( + self.max_community_size(self.n) + if callable(self.max_community_size) + else self.max_community_size + ) + self.community_size_sequence_ = sample_community_sizes( + self.n - n_outliers, + self.community_size_exponent, + self.min_community_size, + self.max_community_size_, + self.eta, + self.rng, + ) + + self.membership_matrix_ = build_membership_matrix( + self.n, + self.community_size_sequence_, + n_outliers, + self.dimension, + self.rng, + ) + + assigned_degrees = assign_degrees( + self.degree_sequence_, + self.membership_matrix_, + self.xi, + self.rng, + self.rho, + self.rho_tol, + self.alpha_min, + self.alpha_max, + self.alpha_iters, + ) + + community_degrees, background_degrees = split_degrees( + assigned_degrees, + self.membership_matrix_, + self.xi, + self.rng, + ) + + print("CDS", community_degrees.sum(axis=1)) + + # TODO Parallel + if self.model == "configuration": + model_func = configuration_model + elif self.model == "chung-lu": + model_func = chunglu_model + else: + raise ValueError("model should be one of 'configuration' or 'chung-lu") + + graphs = [ + model_func( + community_degrees.indices[ + community_degrees.indptr[i] : community_degrees.indptr[i + 1] + ], + community_degrees.data[ + community_degrees.indptr[i] : community_degrees.indptr[i + 1] + ], + self.rng, + ) + for i in range(community_degrees.shape[0]) + ] + graphs.append( + model_func( + np.arange(self.n, dtype=np.uint32), + background_degrees, + self.rng, + ) + ) + graphs = [ + rewire( + g, self.rng, self.max_swap_attempts_per_bad_edge, self.drop_collisions + ) + for g in graphs + ] + + self.graph_ = np.vstack(graphs) + self.graph_ = rewire( + self.graph_, + self.rng, + self.max_swap_attempts_per_bad_edge, + self.drop_collisions, + ) + + return self.graph_, self.membership_matrix_ diff --git a/tests/test_abcd.py b/tests/test_abcd.py new file mode 100644 index 0000000..a285643 --- /dev/null +++ b/tests/test_abcd.py @@ -0,0 +1,15 @@ +import numpy as np +import pytest +from utils import assert_no_bad_edges + +from abcd_graph import ABCD + + +@pytest.mark.parametrize("n", [100, 200]) +def test_abcd(n): + abcd = ABCD(n) + edges, memberships = abcd.sample() + + assert_no_bad_edges(edges) + assert np.max(edges) == n - 1 + assert memberships.shape[1] == n diff --git a/tests/test_models.py b/tests/test_models.py index f9bb2b5..554ea87 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -1,21 +1,10 @@ import numpy as np import pytest -import scipy.sparse as sp -from numpy.typing import NDArray +from utils import assert_no_bad_edges from abcd_graph.models import chunglu_model, configuration_model, rewire -def assert_no_bad_edges(edges: NDArray[np.uint32]): - n = np.max(edges) + 1 - adjacency_matrix = sp.coo_array( - (np.ones(edges.shape[0], dtype=np.int32), edges.T), - shape=(n, n), - ) - assert np.all(adjacency_matrix.diagonal() == 0) - assert np.all(adjacency_matrix.data == 1) - - def test_chunglu_model(): rng = np.random.default_rng(seed=1) node_ids = np.arange(32, dtype=np.uint32) diff --git a/tests/utils.py b/tests/utils.py new file mode 100644 index 0000000..b651395 --- /dev/null +++ b/tests/utils.py @@ -0,0 +1,13 @@ +import numpy as np +import scipy.sparse as sp +from numpy.typing import NDArray + + +def assert_no_bad_edges(edges: NDArray[np.uint32]): + n = np.max(edges) + 1 + adjacency_matrix = sp.coo_array( + (np.ones(edges.shape[0], dtype=np.int32), edges.T), + shape=(n, n), + ) + assert np.all(adjacency_matrix.diagonal() == 0) + assert np.all(adjacency_matrix.data == 1) From eb0e023571a32d9bd20238d40e36ceb933ddee10 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Mon, 17 Aug 2026 09:07:22 -0400 Subject: [PATCH 24/85] Update pre-commit hooks, remove mypy and switch to ruff --- .pre-commit-config.yaml | 28 ++++++++-------------------- 1 file changed, 8 insertions(+), 20 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 3b403c4..57ed37e 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,6 @@ repos: - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v4.3.0 + rev: v6.0.0 hooks: - id: end-of-file-fixer - id: trailing-whitespace @@ -11,30 +11,18 @@ repos: - id: check-yaml - id: debug-statements - id: end-of-file-fixer - - repo: https://github.com/pycqa/isort - rev: 5.13.2 - hooks: - - id: isort - args: [--settings-path, pyproject.toml] - repo: https://github.com/psf/black rev: 24.2.0 hooks: - id: black args: [--config, pyproject.toml] - - repo: https://github.com/PyCQA/flake8 - rev: 7.0.0 - hooks: - - id: flake8 - args: [ --max-line-length, "120" ] - - repo: https://github.com/pre-commit/mirrors-mypy - rev: v1.4.1 + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.16.3 hooks: - - id: mypy - args: [ --config-file, pyproject.toml ] - pass_filenames: false - additional_dependencies: - - "numpy" - - "pydantic" + - id: ruff-check + args: [ --fix ] + # Run the formatter. + - id: ruff-format default_language_version: - python: python3 + python: python3.12 From 30c86a7f9dcf9e930f41afb07780a538fb7128c5 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Mon, 17 Aug 2026 09:22:09 -0400 Subject: [PATCH 25/85] Update pyproject --- pyproject.toml | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 7f03d2e..8194417 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,16 +1,36 @@ +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + [project] name = "abcd-graph" version = "0.5.0" -readme = "README.md" description = "A python library for generating ABCD graphs." authors = [ { name = "Aleksander Wojnarowicz", email = "alwojnarowicz@gmail.com" }, { name = "Jordan Barrett" } ] +keywords = ["community detection", "graph clustering", "benchmark", "evaluation", "random graphs"] +readme = "README.md" license = "MIT" -requires-python = ">=3.12" +license-files = "LICENSE" +classifiers = [ + "Development Status :: 4 - Beta", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Operating System :: OS Independent", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: MIT License", +] + +[project.urls] +Homepage = "https://github.com/AleksanderWWW/abcd-graph" +Repository = "https://github.com/AleksanderWWW/abcd-graph" + packages = [{include = "abcd_graph", from = "src"}] -repository = "https://github.com/AleksanderWWW/abcd-graph" + +requires-python = ">=3.12" dependencies = [ "numba>=0.66.0", "numpy>=2.0.0", @@ -25,17 +45,12 @@ dev = [ "pytest-cov>=6.0.0", ] -[build-system] -requires = ["hatchling"] -build-backend = "hatchling.build" - [tool.pytest.ini_options] addopts = ["--strict-markers"] markers = [ "integration: marks tests using external dependencies" ] - [tool.black] line-length = 88 target-version = ["py312"] From 12345a7edcfc16af8ad789504b1fc793d19e63b7 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Mon, 17 Aug 2026 09:24:42 -0400 Subject: [PATCH 26/85] Remove print statements --- abcd_graph/abcd.py | 4 +--- abcd_graph/degrees.py | 9 --------- 2 files changed, 1 insertion(+), 12 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index da1daf8..af5d652 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -319,9 +319,7 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): self.xi, self.rng, ) - - print("CDS", community_degrees.sum(axis=1)) - + # TODO Parallel if self.model == "configuration": model_func = configuration_model diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index d4ec038..5e73555 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -44,17 +44,12 @@ def make_community_degree_sums_even( com_degrees = community_degrees_data[ community_degrees_indptr[com] : community_degrees_indptr[com + 1] ] - print("Com", com, "degrees", com_degrees) if np.sum(com_degrees.astype(np.uint64)) % 2 == 0: continue - - print("Fixing com", com) indices_of_max_degree = np.where(com_degrees == np.max(com_degrees))[0] - print("Max degree indices", indices_of_max_degree) decrease_index = indices_of_max_degree[ rng.integers(0, len(indices_of_max_degree)) ] - print("Decreasing index", decrease_index) community_degrees_data[community_degrees_indptr[com] + decrease_index] -= 1 background_degrees[com_members[decrease_index]] += 1 @@ -108,8 +103,6 @@ def split_degrees( rng, ) community_degrees = community_degrees.tocsr() - print(community_degrees.todense()) - print(community_degrees.sum(axis=1)) make_community_degree_sums_even( community_degrees.indptr, community_degrees.indices, @@ -117,8 +110,6 @@ def split_degrees( background_degrees, rng, ) - print(community_degrees.todense()) - print(community_degrees.sum(axis=1)) return community_degrees.tocsr(), background_degrees From 796c3468c9611df83b02a68f9576b8866455e4aa Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Mon, 17 Aug 2026 09:37:29 -0400 Subject: [PATCH 27/85] Optimise split community degree --- abcd_graph/degrees.py | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index 5e73555..52087a5 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -7,20 +7,21 @@ @njit(cache=True) def _split_community_degree( - community_degrees: NDArray[np.uint32], + degrees: NDArray[np.uint32], background_degrees: NDArray[np.uint32], indptr: NDArray[np.uint64], data: NDArray[np.uint32], rng: Generator, ) -> None: - for i in range(len(community_degrees)): + for i in range(len(degrees)): n_coms = indptr[i + 1] - indptr[i] if n_coms == 0: - background_degrees[i] += community_degrees[i] + background_degrees[i] = degrees[i] continue - min_degree = int(community_degrees[i] / n_coms) + community_degree = degrees[i] - background_degrees[i] + min_degree = int(community_degree / n_coms) data[indptr[i] : indptr[i + 1]] = min_degree - n_to_add = community_degrees[i] - min_degree * n_coms + n_to_add = community_degree - min_degree * n_coms if n_to_add > 0: random_numbers = rng.uniform(size=n_coms) add_indices = np.argsort(random_numbers)[:n_to_add] @@ -96,7 +97,7 @@ def split_degrees( community_degrees = membership_matrix.copy().astype(np.uint32) community_degrees = community_degrees.tocsc() _split_community_degree( - degrees - background_degrees, + degrees, background_degrees, community_degrees.indptr, community_degrees.data, @@ -110,7 +111,7 @@ def split_degrees( background_degrees, rng, ) - return community_degrees.tocsr(), background_degrees + return community_degrees, background_degrees def _assign_outlier_degrees( From de9cdc5c93c3a512f35ad87d11b4d6e35e6b9b85 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 14:18:26 -0400 Subject: [PATCH 28/85] Simplify degree spliting --- abcd_graph/degrees.py | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index 52087a5..a39b507 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -23,11 +23,10 @@ def _split_community_degree( data[indptr[i] : indptr[i + 1]] = min_degree n_to_add = community_degree - min_degree * n_coms if n_to_add > 0: - random_numbers = rng.uniform(size=n_coms) - add_indices = np.argsort(random_numbers)[:n_to_add] - add_indices += indptr[i] - for j in add_indices: - data[j] += 1 + indices = np.arange(indptr[i],indptr[i+1]) + rng.shuffle(indices) + for i in range(n_to_add): + data[indices[i]] += 1 @njit(cache=True) From 9a7842c3e3691cacb666db0e9ab06cc1c4585682 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 14:18:58 -0400 Subject: [PATCH 29/85] Add seeds to tests --- tests/test_abcd.py | 3 ++- tests/test_samplers.py | 6 +++--- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/tests/test_abcd.py b/tests/test_abcd.py index a285643..2023af0 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -7,7 +7,8 @@ @pytest.mark.parametrize("n", [100, 200]) def test_abcd(n): - abcd = ABCD(n) + rng = np.random.default_rng(seed=1) + abcd = ABCD(n, rng=rng) edges, memberships = abcd.sample() assert_no_bad_edges(edges) diff --git a/tests/test_samplers.py b/tests/test_samplers.py index ca4cde2..17ec0e4 100644 --- a/tests/test_samplers.py +++ b/tests/test_samplers.py @@ -58,7 +58,7 @@ def test_sample_community_sizes_no_overlap(n, eta): exponent = 1.5 min_community_size = 3 max_community_size = 10 - rng = np.random.default_rng() + rng = np.random.default_rng(seed = 1) community_sizes = sample_community_sizes( n, exponent, min_community_size, max_community_size, eta, rng @@ -66,8 +66,8 @@ def test_sample_community_sizes_no_overlap(n, eta): min_n_communities = n * eta / max_community_size max_n_communities = n * eta / min_community_size - assert len(community_sizes) > min_n_communities - assert len(community_sizes) < max_n_communities + assert len(community_sizes) >= min_n_communities + assert len(community_sizes) <= max_n_communities assert set(community_sizes).issubset( set(range(min_community_size, max_community_size + 1)) ) From 4f7c59865e13330dbab801457c9f162d61983ced Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 14:19:27 -0400 Subject: [PATCH 30/85] numbaify configuration model --- abcd_graph/models.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/abcd_graph/models.py b/abcd_graph/models.py index 1d54347..fc9d1ec 100644 --- a/abcd_graph/models.py +++ b/abcd_graph/models.py @@ -30,8 +30,9 @@ def chunglu_model( return edges +@njit def configuration_model( - node_ids: NDArray[np.uint32], degrees: NDArray[np.integer[Any]], rng: Generator + node_ids: NDArray[np.uint32], degrees: NDArray[np.uint32], rng: Generator ) -> NDArray[np.uint32]: """Sample a random graph with the given degree sequence. @@ -47,10 +48,10 @@ def configuration_model( rng: Generator numpy.random.Generator object used for randomness. """ - node_ids = np.arange(len(degrees), dtype="uint32") + node_ids = np.arange(len(degrees), dtype=np.uint32) stubs = np.repeat(node_ids, degrees) rng.shuffle(stubs) - edges = np.array(stubs).reshape(-1, 2) + edges = stubs.reshape(-1, 2) return edges From 2b28398d3f83c7423655f921b3161db86df34fd5 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 14:53:27 -0400 Subject: [PATCH 31/85] Update workflows --- .github/actions/build/action.yml | 12 ++++-------- .github/workflows/ci.yml | 6 +++--- .github/workflows/coverage.yml | 6 +++--- .github/workflows/pr-title.yml | 26 -------------------------- .github/workflows/pre-commit.yml | 6 +++--- .github/workflows/profiling.yml | 24 ------------------------ .github/workflows/release.yml | 4 ++-- .pre-commit-config.yaml | 4 ++-- 8 files changed, 17 insertions(+), 71 deletions(-) delete mode 100644 .github/workflows/pr-title.yml delete mode 100644 .github/workflows/profiling.yml diff --git a/.github/actions/build/action.yml b/.github/actions/build/action.yml index a492d4b..0ab22c3 100644 --- a/.github/actions/build/action.yml +++ b/.github/actions/build/action.yml @@ -10,17 +10,13 @@ runs: using: "composite" steps: - name: Checkout - uses: actions/checkout@v2 - with: - repository: AleksanderWWW/abcd-graph - path: ${{ inputs.working_directory }} + uses: actions/checkout@v7 - - name: Install uv - run : curl -LsSf https://astral.sh/uv/install.sh | sh - shell: bash + - name: Install the latest version of uv + uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1 - name: Install dependencies working-directory: ${{ inputs.working_directory }} run: | - uv pip install --system -r pyproject.toml --extra all --extra dev . + uv pip install --system -r pyproject.toml --extra dev . shell: bash diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c80f5f7..1f33132 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -6,11 +6,11 @@ jobs: strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest] - python-version: ["3.10", "3.12"] + python-version: ["3.12", "3.13", "3.14"] steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v7 - - uses: actions/setup-python@v5 + - uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 003f242..aa21f04 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -4,11 +4,11 @@ jobs: test: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v7 - - uses: actions/setup-python@v5 + - uses: actions/setup-python@v7 with: - python-version: "3.10" + python-version: "3.12" - name: Build uses: ./.github/actions/build diff --git a/.github/workflows/pr-title.yml b/.github/workflows/pr-title.yml deleted file mode 100644 index f912a01..0000000 --- a/.github/workflows/pr-title.yml +++ /dev/null @@ -1,26 +0,0 @@ -name: Enforce Conventional PR Title - -on: - pull_request: - types: [opened, edited, synchronize] - -jobs: - check-pr-title: - runs-on: ubuntu-latest - steps: - - name: Check PR title - run: | - PR_TITLE="${{ github.event.pull_request.title }}" - echo "Checking PR title: $PR_TITLE" - - # Define the regex for Conventional Commits - CONVENTIONAL_REGEX="^(feat|fix|chore|docs|style|refactor|perf|test|ci|build|revert)(\([^)]+\))?!?: .+$" - - if [[ ! "$PR_TITLE" =~ $CONVENTIONAL_REGEX ]]; then - echo "❌ PR title does not follow Conventional Commits format!" - echo "📝 Expected format: 'type(scope): description'" - echo "👉 Example: 'feat(auth): add login API'" - exit 1 - fi - - echo "✅ PR title is valid!" diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index 68404a5..7f502a4 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -11,12 +11,12 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@v7 - name: Install Python - uses: actions/setup-python@v5 + uses: actions/setup-python@v7 with: python-version: "3.12" - name: Run pre-commit - uses: pre-commit/action@v3.0.1 + uses: pre-commit/action@v4.6.2 diff --git a/.github/workflows/profiling.yml b/.github/workflows/profiling.yml deleted file mode 100644 index 85faf47..0000000 --- a/.github/workflows/profiling.yml +++ /dev/null @@ -1,24 +0,0 @@ -name: profiling reports -on: [workflow_dispatch] -jobs: - test: - runs-on: ${{ matrix.os }} - strategy: - matrix: - os: [ubuntu-latest, macos-latest, windows-latest] - python-version: ["3.10"] - steps: - - uses: actions/checkout@v4 - - - uses: actions/setup-python@v5 - with: - python-version: ${{ matrix.python-version }} - - - name: Install dependencies - run: pip install . tabulate - - - name: Computing efficiency profiling report - run: python profiling/profiling_report.py - - - name: Algorithmic complexity profiling report - run: python profiling/scaling_report.py diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 965075d..1a02aea 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -9,8 +9,8 @@ jobs: publish: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 + - uses: actions/checkout@v7 + - uses: actions/setup-python@v7 with: python-version: "3.12" - name: Install uv diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 57ed37e..cc0136e 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -11,8 +11,8 @@ repos: - id: check-yaml - id: debug-statements - id: end-of-file-fixer - - repo: https://github.com/psf/black - rev: 24.2.0 + - repo: https://github.com/psf/black-pre-commit-mirror + rev: 26.5.1 hooks: - id: black args: [--config, pyproject.toml] From edce9291483930455e7e6e8d888905a113964ec7 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 15:08:39 -0400 Subject: [PATCH 32/85] Run workflows on release branches --- .github/workflows/ci.yml | 14 +++++++++++--- .github/workflows/pre-commit.yml | 8 ++++++-- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1f33132..22345d9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,5 +1,13 @@ name: unit tests -on: [push] +on: + push: + branches: + - 'main' + - 'release/**' + pull-request: + branches: + - 'main' + - 'release/**' jobs: test: runs-on: ${{ matrix.os }} @@ -8,9 +16,9 @@ jobs: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.12", "3.13", "3.14"] steps: - - uses: actions/checkout@v7 + - uses: actions/checkout@v4 - - uses: actions/setup-python@v7 + - uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index 7f502a4..255a6d8 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -1,10 +1,14 @@ name: pre-commit on: - pull_request: push: branches: - - main + - 'main' + - 'release/**' + pull-request: + branches: + - 'main' + - 'release/**' jobs: pre-commit: From b84589e746797da09849230928c38906b44c3746 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 15:12:04 -0400 Subject: [PATCH 33/85] Update licence file in pyproject --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 8194417..944be72 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,7 +13,7 @@ authors = [ keywords = ["community detection", "graph clustering", "benchmark", "evaluation", "random graphs"] readme = "README.md" license = "MIT" -license-files = "LICENSE" +license-files = ["LICENSE"] classifiers = [ "Development Status :: 4 - Beta", "Programming Language :: Python :: 3.12", From 8f677fb54b85a723bb2d4a34b4dc430bff6c3a96 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 15:16:28 -0400 Subject: [PATCH 34/85] Fix type in workflows --- .github/workflows/ci.yml | 2 +- .github/workflows/pre-commit.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 22345d9..9b2bea5 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -4,7 +4,7 @@ on: branches: - 'main' - 'release/**' - pull-request: + pull_request: branches: - 'main' - 'release/**' diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index 255a6d8..8283b6a 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -5,7 +5,7 @@ on: branches: - 'main' - 'release/**' - pull-request: + pull_request: branches: - 'main' - 'release/**' From 118efbb465aecdfba1a3bfa83e58915b172180a3 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 15:20:16 -0400 Subject: [PATCH 35/85] Update version and packages in pyproject --- pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 944be72..f1ef0f7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "hatchling.build" [project] name = "abcd-graph" -version = "0.5.0" +version = "0.5.0-alpha" description = "A python library for generating ABCD graphs." authors = [ { name = "Aleksander Wojnarowicz", email = "alwojnarowicz@gmail.com" }, @@ -28,7 +28,7 @@ classifiers = [ Homepage = "https://github.com/AleksanderWWW/abcd-graph" Repository = "https://github.com/AleksanderWWW/abcd-graph" -packages = [{include = "abcd_graph", from = "src"}] +packages = ["abcd_graph"] requires-python = ">=3.12" dependencies = [ From 71957ed1cf2613bd36734ad860f68cdd3f6c0ddf Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 15:32:39 -0400 Subject: [PATCH 36/85] Replace pre-commit with prek --- .github/workflows/pre-commit.yml | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index 8283b6a..5e2e443 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -12,15 +12,9 @@ on: jobs: pre-commit: - runs-on: ubuntu-latest - steps: - - name: Checkout repository - uses: actions/checkout@v7 - - - name: Install Python - uses: actions/setup-python@v7 - with: - python-version: "3.12" - - - name: Run pre-commit - uses: pre-commit/action@v4.6.2 + jobs: + prek: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: j178/prek-action@0.4.14 From 35ece00f7e9bd9109f7422e093db8953e4bed955 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 15:37:03 -0400 Subject: [PATCH 37/85] Fix pyproject bug --- pyproject.toml | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index f1ef0f7..6ec34b6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,12 +24,6 @@ classifiers = [ "License :: OSI Approved :: MIT License", ] -[project.urls] -Homepage = "https://github.com/AleksanderWWW/abcd-graph" -Repository = "https://github.com/AleksanderWWW/abcd-graph" - -packages = ["abcd_graph"] - requires-python = ">=3.12" dependencies = [ "numba>=0.66.0", @@ -45,6 +39,13 @@ dev = [ "pytest-cov>=6.0.0", ] +[project.urls] +Homepage = "https://github.com/AleksanderWWW/abcd-graph" +Repository = "https://github.com/AleksanderWWW/abcd-graph" + +[tool.hatch.build.targets.wheel] +packages = ["src"] + [tool.pytest.ini_options] addopts = ["--strict-markers"] markers = [ From 57379d0094e63f2a153006a2d47221b7efa7e15b Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 15:52:22 -0400 Subject: [PATCH 38/85] Add pytest ini to pyproject --- pyproject.toml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pyproject.toml b/pyproject.toml index 6ec34b6..361e0cc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -47,6 +47,9 @@ Repository = "https://github.com/AleksanderWWW/abcd-graph" packages = ["src"] [tool.pytest.ini_options] +pythonpath = [ + "." +] addopts = ["--strict-markers"] markers = [ "integration: marks tests using external dependencies" From 4493ed34c39dd10c38472d9d64e36ddc45cda643 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 15:53:42 -0400 Subject: [PATCH 39/85] Fix typo in precommit workflow --- .github/workflows/pre-commit.yml | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index 5e2e443..2c5afbb 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -11,10 +11,8 @@ on: - 'release/**' jobs: - pre-commit: - jobs: - prek: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v7 - - uses: j178/prek-action@0.4.14 + prek: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: j178/prek-action@0.4.14 From 76351ea85d6b886d8d684ae5d8a55d92000db275 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 15:58:43 -0400 Subject: [PATCH 40/85] Only run coverage on main repo --- .github/workflows/coverage.yml | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index aa21f04..32e7545 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -1,23 +1,24 @@ name: coverage on: [push] jobs: - test: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v7 + if: github.repository == 'AleksanderWWW/abcd-graph' + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 - - uses: actions/setup-python@v7 - with: - python-version: "3.12" + - uses: actions/setup-python@v7 + with: + python-version: "3.12" - - name: Build - uses: ./.github/actions/build + - name: Build + uses: ./.github/actions/build - - name: Test - uses: ./.github/actions/test + - name: Test + uses: ./.github/actions/test - - name: Pytest coverage comment - uses: MishaKav/pytest-coverage-comment@main - with: - pytest-coverage-path: ./pytest-coverage.txt - junitxml-path: ./pytest.xml + - name: Pytest coverage comment + uses: MishaKav/pytest-coverage-comment@main + with: + pytest-coverage-path: ./pytest-coverage.txt + junitxml-path: ./pytest.xml From e6779b22ce5e96be6d0d4d60a2dc29197993e7ac Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 16:03:43 -0400 Subject: [PATCH 41/85] Fix prek version in pre-commit workflow --- .github/workflows/pre-commit.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index 2c5afbb..05aedaf 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -15,4 +15,4 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v7 - - uses: j178/prek-action@0.4.14 + - uses: j178/prek-action@3.0.0 From 73a55b49ca9936c169f9a2990470c7f36144e9df Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Thu, 20 Aug 2026 16:04:30 -0400 Subject: [PATCH 42/85] Fix prek version in pre-commit workflow --- .github/workflows/pre-commit.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index 05aedaf..0b5ddb6 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -15,4 +15,4 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v7 - - uses: j178/prek-action@3.0.0 + - uses: j178/prek-action@v3.0.0 From e56f10e2e5f1d276812b96f40d57c3a306466eb6 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 21 Aug 2026 08:49:18 -0400 Subject: [PATCH 43/85] Formatting and ignore example in pre-commit --- .pre-commit-config.yaml | 2 ++ abcd_graph/abcd.py | 2 +- abcd_graph/degrees.py | 2 +- tests/test_samplers.py | 2 +- 4 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index cc0136e..86f9fcd 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,3 +1,5 @@ +exclude: '^examples' + repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v6.0.0 diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index af5d652..e4968b6 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -319,7 +319,7 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): self.xi, self.rng, ) - + # TODO Parallel if self.model == "configuration": model_func = configuration_model diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index a39b507..2dfdcfb 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -23,7 +23,7 @@ def _split_community_degree( data[indptr[i] : indptr[i + 1]] = min_degree n_to_add = community_degree - min_degree * n_coms if n_to_add > 0: - indices = np.arange(indptr[i],indptr[i+1]) + indices = np.arange(indptr[i], indptr[i + 1]) rng.shuffle(indices) for i in range(n_to_add): data[indices[i]] += 1 diff --git a/tests/test_samplers.py b/tests/test_samplers.py index 17ec0e4..cd601ed 100644 --- a/tests/test_samplers.py +++ b/tests/test_samplers.py @@ -58,7 +58,7 @@ def test_sample_community_sizes_no_overlap(n, eta): exponent = 1.5 min_community_size = 3 max_community_size = 10 - rng = np.random.default_rng(seed = 1) + rng = np.random.default_rng(seed=1) community_sizes = sample_community_sizes( n, exponent, min_community_size, max_community_size, eta, rng From 4b37048b6b94f8d3fb0e873680d09ba323c33a0b Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe <61296655+ryandewolfe33@users.noreply.github.com> Date: Fri, 21 Aug 2026 10:56:48 -0400 Subject: [PATCH 44/85] Refactor graph generation in preparation for parallelisation (#1) --- abcd_graph/abcd.py | 110 ++++++++++++++++++++++++++++--------------- abcd_graph/models.py | 25 +++++----- tests/test_models.py | 26 ++++------ 3 files changed, 94 insertions(+), 67 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index e4968b6..f5966ab 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -8,10 +8,76 @@ from abcd_graph.degrees import assign_degrees, split_degrees from abcd_graph.membership import build_membership_matrix -from abcd_graph.models import chunglu_model, configuration_model, rewire +from abcd_graph.models import Model, chunglu_model, configuration_model, rewire from abcd_graph.samplers import sample_community_sizes, sample_degrees +def generate_community_graph_task( + i, + graph, + community_edges_indptr, + community_degrees_indptr, + community_degrees_indices, + community_degrees_data, + model, + max_swap_attempts_per_bad_edge, + rng: Generator, +) -> None: + com_indices = community_degrees_indices[ + community_degrees_indptr[i] : community_degrees_indptr[i + 1] + ] + com_data = community_degrees_data[ + community_degrees_indptr[i] : community_degrees_indptr[i + 1] + ] + community_graph = model( + com_indices, + com_data, + rng, + ) + rewire(community_graph, rng, max_swap_attempts_per_bad_edge) + graph[community_edges_indptr[i] : community_edges_indptr[i + 1]] = community_graph + + +def generate_graph( + community_degrees: sp.csr_array, + background_degrees: NDArray[np.uint32], + model: Model, + max_swap_attempts_per_bad_edge: int, + rng: Generator, +): + # Add background degrees as the last community + community_degrees = sp.vstack( + (community_degrees, sp.csr_array(background_degrees)), format="csr" + ) + # Sort communities by volume decreasing + community_m = community_degrees.sum(axis=1) // 2 + argsort_community_m = np.argsort(community_m)[::-1] + community_degrees = community_degrees[argsort_community_m] + + community_edges_indptr = np.cumsum(community_m[argsort_community_m]) + community_edges_indptr = np.insert(community_edges_indptr, 0, 0) + + graph = np.empty((community_edges_indptr[-1], 2), dtype=np.uint32) + n_coms = community_degrees.shape[0] + rngs = rng.spawn(n_coms) + # TODO Parallel this loop + for i in range(n_coms): + generate_community_graph_task( + i, + graph, + community_edges_indptr, + community_degrees.indptr, + community_degrees.indices, + community_degrees.data, + model, + max_swap_attempts_per_bad_edge, + rngs[i], + ) + n_good_edges = rewire(graph, rng, max_swap_attempts_per_bad_edge) + graph.resize((n_good_edges, 2), refcheck=False) + return graph + + class ABCD: """Artificial Benchmark for Community Detection @@ -93,7 +159,6 @@ def __init__( alpha_iters: int = 10, model: str = "configuration", max_swap_attempts_per_bad_edge: int = 5, - drop_collisions: bool = False, rng: Generator = np.random.default_rng(), verbose: bool = False, ): @@ -117,7 +182,6 @@ def __init__( self.rho_tol = rho_tol self.model = model self.max_swap_attempts_per_bad_edge = max_swap_attempts_per_bad_edge - self.drop_collisions = drop_collisions self.rng = rng self.verbose = verbose @@ -250,9 +314,6 @@ def _validate_params(self): "max swap attempts per bad edge must a be positive integer" ) - if not isinstance(self.drop_collisions, (bool, np.bool)): - raise ValueError("drop collisions must be True or False") - if not isinstance(self.rng, np.random.Generator): raise ValueError("rng must be a numpy.random.Generator object") @@ -320,7 +381,6 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): self.rng, ) - # TODO Parallel if self.model == "configuration": model_func = configuration_model elif self.model == "chung-lu": @@ -328,38 +388,12 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): else: raise ValueError("model should be one of 'configuration' or 'chung-lu") - graphs = [ - model_func( - community_degrees.indices[ - community_degrees.indptr[i] : community_degrees.indptr[i + 1] - ], - community_degrees.data[ - community_degrees.indptr[i] : community_degrees.indptr[i + 1] - ], - self.rng, - ) - for i in range(community_degrees.shape[0]) - ] - graphs.append( - model_func( - np.arange(self.n, dtype=np.uint32), - background_degrees, - self.rng, - ) - ) - graphs = [ - rewire( - g, self.rng, self.max_swap_attempts_per_bad_edge, self.drop_collisions - ) - for g in graphs - ] - - self.graph_ = np.vstack(graphs) - self.graph_ = rewire( - self.graph_, - self.rng, + self.graph_ = generate_graph( + community_degrees, + background_degrees, + model_func, self.max_swap_attempts_per_bad_edge, - self.drop_collisions, + self.rng, ) return self.graph_, self.membership_matrix_ diff --git a/abcd_graph/models.py b/abcd_graph/models.py index fc9d1ec..cc1c993 100644 --- a/abcd_graph/models.py +++ b/abcd_graph/models.py @@ -1,4 +1,4 @@ -from typing import Any +from typing import Any, Protocol import numpy as np from numba import njit @@ -8,6 +8,13 @@ from numpy.typing import NDArray +# Define the function interface contract structurally +class Model(Protocol): + def __call__( + self, node_ids: NDArray[np.uint32], degrees: NDArray[np.uint32], rng: Generator + ) -> NDArray[np.uint32]: ... + + def chunglu_model( node_ids: NDArray[np.uint32], degrees: NDArray[np.integer[Any]], rng: Generator ) -> NDArray[np.uint32]: @@ -30,7 +37,7 @@ def chunglu_model( return edges -@njit +@njit(nogil=True) def configuration_model( node_ids: NDArray[np.uint32], degrees: NDArray[np.uint32], rng: Generator ) -> NDArray[np.uint32]: @@ -107,13 +114,12 @@ def is_bad_swap( return False -@njit +@njit(nogil=True) def rewire( edges: NDArray[np.uint32], rng: Generator, max_swap_attempts_per_bad_edge: int = 5, - drop_collisions: bool = False, -) -> NDArray[np.uint32]: +) -> int: """Perform inplace edge swaps to resolve loops and multi-edges. Parameters @@ -128,10 +134,6 @@ def rewire( max_swap_attempts_per_bad_edge: int, default=5 Cap the attempted edge swaps to this values times the number of initial bad edges. - drop_collisions: bool, default=False - If true, drop any bad edges that failed to swap from the returned array. The returned - edge list is guaranteed to be a simple graph. - """ # Move good edges to the front, add their hashes to a set, and # make a List-backed-queue of bad edges @@ -203,7 +205,4 @@ def rewire( bad_edge = edge_from_id(bad_edge_id) edges[n_good_edges + i] = bad_edge - if drop_collisions: - edges = edges[:n_good_edges] - - return edges + return n_good_edges diff --git a/tests/test_models.py b/tests/test_models.py index 554ea87..871989b 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -45,11 +45,12 @@ def test_rewire_loops(): dtype=np.uint32, ) - edges = rewire(edges, rng) + n_good_edges = rewire(edges, rng) assert edges.shape == (5, 2) assert edges.dtype == np.uint32 assert_no_bad_edges(edges) + assert n_good_edges == edges.shape[0] def test_rewire_multiedges(): @@ -64,22 +65,24 @@ def test_rewire_multiedges(): dtype=np.uint32, ) - edges = rewire(edges, rng) + n_good_edges = rewire(edges, rng) assert edges.shape == (4, 2) assert edges.dtype == np.uint32 assert_no_bad_edges(edges) + assert n_good_edges == edges.shape[0] def test_rewire_swap_two_bad_edges(): rng = np.random.default_rng(seed=1) edges = np.array([[0, 0], [1, 2], [1, 2]], dtype=np.uint32) - edges = rewire(edges, rng) + n_good_edges = rewire(edges, rng) assert edges.shape == (3, 2) assert edges.dtype == np.uint32 assert_no_bad_edges(edges) + assert n_good_edges == edges.shape[0] def test_rewire_many(): @@ -89,31 +92,22 @@ def test_rewire_many(): dtype=np.uint32, ) - edges = rewire(edges, rng) + n_good_edges = rewire(edges, rng) assert edges.shape == (8, 2) assert edges.dtype == np.uint32 assert_no_bad_edges(edges) + assert n_good_edges == edges.shape[0] def test_rewire_failure(): rng = np.random.default_rng(seed=1) edges = np.array([[0, 0], [0, 1]], dtype=np.uint32) - edges = rewire(edges, rng) + n_good_edges = rewire(edges, rng) assert edges.shape == (2, 2) assert edges.dtype == np.uint32 with pytest.raises(AssertionError): assert_no_bad_edges(edges) - - -def test_rewire_drop_collisions(): - rng = np.random.default_rng(seed=1) - edges = np.array([[0, 0], [0, 1]], dtype=np.uint32) - - edges = rewire(edges, rng, drop_collisions=True) - - assert edges.shape == (1, 2) - assert edges.dtype == np.uint32 - assert_no_bad_edges(edges) + assert n_good_edges == 1 From 09159f7cd0d5c172501dafb175bfb8663c576e74 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe <61296655+ryandewolfe33@users.noreply.github.com> Date: Fri, 21 Aug 2026 15:18:30 -0400 Subject: [PATCH 45/85] Feature/logging (#2) * Add basic logging with verbose and prints * Use logging module --- abcd_graph/abcd.py | 82 ++++++++++++++++++++++++++++++++++++++++++++-- pyproject.toml | 3 +- 2 files changed, 81 insertions(+), 4 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index f5966ab..4d8ef70 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -1,10 +1,14 @@ +import logging +import sys from collections.abc import Callable +from time import perf_counter from warnings import warn import numpy as np import scipy.sparse as sp from numpy.random import Generator from numpy.typing import ArrayLike, NDArray +from tqdm import trange from abcd_graph.degrees import assign_degrees, split_degrees from abcd_graph.membership import build_membership_matrix @@ -12,6 +16,17 @@ from abcd_graph.samplers import sample_community_sizes, sample_degrees +def format_duration(seconds: float): + if seconds >= 1.0: + return f"{seconds:.3f}s" + elif seconds >= 1e-3: + return f"{seconds * 1e3:.3f}ms" + elif seconds >= 1e-6: + return f"{seconds * 1e6:.3f}µs" + else: + return f"{seconds * 1e9:.3f}ns" + + def generate_community_graph_task( i, graph, @@ -44,6 +59,7 @@ def generate_graph( model: Model, max_swap_attempts_per_bad_edge: int, rng: Generator, + logger: logging.Logger, ): # Add background degrees as the last community community_degrees = sp.vstack( @@ -61,7 +77,9 @@ def generate_graph( n_coms = community_degrees.shape[0] rngs = rng.spawn(n_coms) # TODO Parallel this loop - for i in range(n_coms): + logger.info("Building Community Graphs") + start = perf_counter() + for i in trange(n_coms, disable=logger.getEffectiveLevel() > 20): generate_community_graph_task( i, graph, @@ -73,7 +91,13 @@ def generate_graph( max_swap_attempts_per_bad_edge, rngs[i], ) + end = perf_counter() + logger.info(f"Finished in {format_duration(end - start)}.") + logger.info("Global Rewiring") + start = perf_counter() n_good_edges = rewire(graph, rng, max_swap_attempts_per_bad_edge) + end = perf_counter() + logger.info(f"Finished in {format_duration(end - start)}.") graph.resize((n_good_edges, 2), refcheck=False) return graph @@ -133,8 +157,13 @@ class ABCD: model : Model | None, default=None Random graph model used to sample the community and background graphs. + logger : Logger | None, default=None + Option to pass a custom logging object. + verbose : bool, default=False - Flag to log runtime infomation. + Only used if logger is not passed. If True, sets the logger level to info and the + output to stdout. If False, sets the logger level to warning and the output to + stderr. """ def __init__( @@ -160,6 +189,7 @@ def __init__( model: str = "configuration", max_swap_attempts_per_bad_edge: int = 5, rng: Generator = np.random.default_rng(), + logger: logging.Logger | None = None, verbose: bool = False, ): self.n = n @@ -183,6 +213,7 @@ def __init__( self.model = model self.max_swap_attempts_per_bad_edge = max_swap_attempts_per_bad_edge self.rng = rng + self.logger = logger self.verbose = verbose def _validate_params(self): @@ -317,8 +348,29 @@ def _validate_params(self): if not isinstance(self.rng, np.random.Generator): raise ValueError("rng must be a numpy.random.Generator object") + if self.logger is not None and not isinstance(self.logger, logging.Logger): + raise ValueError("logger must be None or a logging.Logger object") + + def _get_logger(self): + if self.logger is not None: + return self.logger + logger = logging.getLogger(__name__) + logger.handlers.clear() + if self.verbose: + logger.setLevel(logging.INFO) + handler = logging.StreamHandler(sys.stdout) + logger.addHandler(handler) + else: + logger.setLevel(logging.WARNING) + handler = logging.StreamHandler(sys.stderr) + logger.addHandler(handler) + return logger + def sample(self) -> (NDArray[np.uint32], sp.csr_array): + sample_start = perf_counter() + self._validate_params() + self.logger_ = self._get_logger() if self.outliers < 1: n_outliers = int(self.n * self.outliers) @@ -326,6 +378,8 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): n_outliers = self.outliers if self.degree_sequence is None: + self.logger_.info("Generating Degree Sequence") + start = perf_counter() self.max_degree_ = ( self.max_degree(self.n) if callable(self.max_degree) @@ -338,8 +392,12 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): self.max_degree_, self.rng, ) + end = perf_counter() + self.logger_.info(f"Finished in {format_duration(end - start)}.") if self.community_size_sequence is None: + self.logger_.info("Generating Degree Sequence") + start = perf_counter() self.max_community_size_ = ( self.max_community_size(self.n) if callable(self.max_community_size) @@ -353,7 +411,11 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): self.eta, self.rng, ) + end = perf_counter() + self.logger_.info(f"Finished in {format_duration(end - start)}.") + self.logger_.info("Building Membership Matrix") + start = perf_counter() self.membership_matrix_ = build_membership_matrix( self.n, self.community_size_sequence_, @@ -361,7 +423,11 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): self.dimension, self.rng, ) + end = perf_counter() + self.logger_.info(f"Finished in {format_duration(end - start)}.") + self.logger_.info("Assigning Degrees") + start = perf_counter() assigned_degrees = assign_degrees( self.degree_sequence_, self.membership_matrix_, @@ -373,13 +439,19 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): self.alpha_max, self.alpha_iters, ) + end = perf_counter() + self.logger_.info(f"Finished in {format_duration(end - start)}.") + self.logger_.info("Splitting Degrees") + start = perf_counter() community_degrees, background_degrees = split_degrees( assigned_degrees, self.membership_matrix_, self.xi, self.rng, ) + end = perf_counter() + self.logger_.info(f"Finished in {format_duration(end - start)}.") if self.model == "configuration": model_func = configuration_model @@ -394,6 +466,10 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): model_func, self.max_swap_attempts_per_bad_edge, self.rng, + self.logger_, + ) + sample_end = perf_counter() + self.logger_.info( + f"Sampled ABCD graph in {format_duration(sample_end - sample_start)}." ) - return self.graph_, self.membership_matrix_ diff --git a/pyproject.toml b/pyproject.toml index 361e0cc..d9db4cf 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,7 +29,8 @@ dependencies = [ "numba>=0.66.0", "numpy>=2.0.0", "scipy>=1.18.0", - "typing-extensions>=4.10.0" + "typing-extensions>=4.10.0", + "tqdm>=4.0.0", ] [project.optional-dependencies] From e651d9884c49c5e2a904634854c014428d2a83c4 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 21 Aug 2026 15:23:02 -0400 Subject: [PATCH 46/85] Add reproducibility test --- tests/test_abcd.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/tests/test_abcd.py b/tests/test_abcd.py index 2023af0..a1abcd8 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -1,4 +1,5 @@ import numpy as np +import numpy.testing as npt import pytest from utils import assert_no_bad_edges @@ -14,3 +15,21 @@ def test_abcd(n): assert_no_bad_edges(edges) assert np.max(edges) == n - 1 assert memberships.shape[1] == n + + +@pytest.mark.parametrize("n", [100, 200]) +def test_seed(n): + rng1 = np.random.default_rng(seed=1) + rng2 = np.random.default_rng(seed=1) + + abcd = ABCD(n, rng=rng1) + edges1, memberships1 = abcd.sample() + + # reset seed + abcd.rng = rng2 + edges2, memberships2 = abcd.sample() + + assert_no_bad_edges(edges1) + assert_no_bad_edges(edges2) + npt.assert_array_equal(edges1, edges2) + npt.assert_array_equal(memberships1.toarray(), memberships2.toarray()) From 1438c4dd3962f9ad491bf95882218d5205760039 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe <61296655+ryandewolfe33@users.noreply.github.com> Date: Sat, 22 Aug 2026 09:10:38 -0400 Subject: [PATCH 47/85] Add ABCDSample return class (#3) * Add ABCDSample return class * Measure exponents with powerlaw --- abcd_graph/__init__.py | 1 + abcd_graph/abcd.py | 4 +- abcd_graph/abcd_sample.py | 170 ++++++++++++++++++++++++++++++++++++++ pyproject.toml | 1 + tests/test_abcd.py | 20 ++--- tests/test_abcd_sample.py | 99 ++++++++++++++++++++++ 6 files changed, 284 insertions(+), 11 deletions(-) create mode 100644 abcd_graph/abcd_sample.py create mode 100644 tests/test_abcd_sample.py diff --git a/abcd_graph/__init__.py b/abcd_graph/__init__.py index e8da3ce..a5880ea 100644 --- a/abcd_graph/__init__.py +++ b/abcd_graph/__init__.py @@ -1 +1,2 @@ from abcd_graph.abcd import ABCD +from abcd_graph.abcd_sample import ABCDSample diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index 4d8ef70..dbfe790 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -10,6 +10,7 @@ from numpy.typing import ArrayLike, NDArray from tqdm import trange +from abcd_graph.abcd_sample import ABCDSample from abcd_graph.degrees import assign_degrees, split_degrees from abcd_graph.membership import build_membership_matrix from abcd_graph.models import Model, chunglu_model, configuration_model, rewire @@ -472,4 +473,5 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): self.logger_.info( f"Sampled ABCD graph in {format_duration(sample_end - sample_start)}." ) - return self.graph_, self.membership_matrix_ + self.sample_ = ABCDSample(self.graph_, self.membership_matrix_) + return self.sample_ diff --git a/abcd_graph/abcd_sample.py b/abcd_graph/abcd_sample.py new file mode 100644 index 0000000..026d36a --- /dev/null +++ b/abcd_graph/abcd_sample.py @@ -0,0 +1,170 @@ +import numpy as np +import powerlaw +import scipy.sparse as sp +from numba import njit +from numpy.typing import ArrayLike, NDArray + + +@njit +def count_intra_community_edges( + edges: NDArray[np.uint32], + indptr: NDArray[np.uint64], + indices: NDArray[np.uint32], +): + m_intra_community = 0 + for i in range(edges.shape[0]): + u, v = edges[i] + u_coms = indices[indptr[u] : indptr[u + 1]] + v_coms = indices[indptr[v] : indptr[v + 1]] + m_intra_community += int(np.any(np.isin(u_coms, v_coms))) + return m_intra_community + + +def icdf(points: ArrayLike, sequence: ArrayLike): + points = np.asarray(points) + points = np.insert(points, 0, 0) + hist, bin_edges = np.histogram(sequence, bins=points) + cdf = np.cumsum(hist) + cdf /= cdf[-1] + icdf = 1 - cdf + return icdf + + +class ABCDSample: + """A sample from the ABCD model. + + Consists of an edge list and a community-node membership matrix. + Has functions for measuring empirical properties of the graph, and + functions for converting the edge list to other common graph types. + """ + + def __init__( + self, + edges: NDArray[np.uint32], + membership_matrix: sp.csr_array, + ): + self.edges = edges + self.membership_matrix = membership_matrix + + @property + def n(self) -> int: + return self.membership_matrix.shape[1] + + @property + def xi(self) -> float: + membership_csc = self.membership_matrix.tocsc() + m_intra_community = count_intra_community_edges( + self.edges, + membership_csc.indptr, + membership_csc.indices, + ) + return 1 - (m_intra_community / self.m) + + @property + def m(self) -> int: + return self.edges.shape[0] + + @property + def n_outliers(self) -> int: + return np.sum(self.membership_matrix.count_nonzero(axis=0) == 0) + + @property + def eta(self) -> float: + return self.membership_matrix.sum() / (self.n - self.n_outliers) + + @property + def rho(self) -> float: + # Degrees sorted by node_id + degrees = np.unique_counts(self.edges, sorted=True)[1] + coms_per_node = self.membership_matrix.sum(axis=1) + inlier_mask = coms_per_node > 0 + rho = np.corrcoef(degrees[inlier_mask], coms_per_node[inlier_mask])[0, 1] + return rho + + @property + def degree_sequence(self) -> NDArray: + degrees = np.zeros(self.n, dtype=np.uint32) + node, degree = np.unique_counts(self.edges) + degrees[node] = degree + return degrees + + @property + def degree_exponent(self) -> float: + degree_sequence = self.degree_sequence + min_degree = np.min(degree_sequence) + exponent = powerlaw.Fit( + degree_sequence, + discrete=True, + verbose=False, + xmin=min_degree, + ).power_law.alpha + return exponent + + @property + def community_size_sequence(self) -> NDArray: + return self.membership_matrix.sum(axis=1) + + @property + def community_size_exponent(self) -> float: + size_sequence = self.community_size_sequence + min_size = np.min(size_sequence) + exponent = powerlaw.Fit( + size_sequence, + discrete=True, + verbose=False, + xmin=min_size, + ).power_law.alpha + return exponent + + def to_sparse(self, matrix: bool = False) -> sp.csr_array | sp.csr_matrix: + adjacency = sp.coo_array( + (np.ones(self.edges.shape[0], dtype=np.bool), self.edges.T), + shape=(self.n, self.n), + ) + adjacency = adjacency + adjacency.transpose() + if matrix: + adjacency = sp.coo_matrix(adjacency) + return adjacency.tocsr() + + def to_dense(self) -> NDArray[np.bool]: + return self.to_sparse().todense() + + def to_networkx(self): + try: + import networkx as nx + + g = nx.from_edgelist(self.edges) + return g + except ImportError as e: + raise ImportError( + "Package 'networkx' is not installed. " + "Run `pip install networkx` to install it." + ) from e + + def to_igraph(self): + try: + import igraph as ig + + g = ig.Graph(n=self.n, edges=self.edges, directed=False) + return g + except ImportError as e: + raise ImportError( + "Package 'igraph' is not installed. " + "Run `pip install igraph` to install it." + ) from e + + def community_array(self): + if self.eta > 1: + raise ValueError( + "Overlapping communities cannot be represent with an array" + ) + result = np.full(self.n, -1) + coms, nodes = self.membership_matrix.nonzero() + result[nodes] = coms + return result + + def degree_icdf(self, points: ArrayLike): + return icdf(self.degree_sequence) + + def community_size_icdf(self, points: ArrayLike): + return icdf(self.community_size_sequence) diff --git a/pyproject.toml b/pyproject.toml index d9db4cf..2007701 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -29,6 +29,7 @@ dependencies = [ "numba>=0.66.0", "numpy>=2.0.0", "scipy>=1.18.0", + "powerlaw>=2.0.0", "typing-extensions>=4.10.0", "tqdm>=4.0.0", ] diff --git a/tests/test_abcd.py b/tests/test_abcd.py index a1abcd8..ea67c75 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -10,11 +10,11 @@ def test_abcd(n): rng = np.random.default_rng(seed=1) abcd = ABCD(n, rng=rng) - edges, memberships = abcd.sample() + sample = abcd.sample() - assert_no_bad_edges(edges) - assert np.max(edges) == n - 1 - assert memberships.shape[1] == n + assert_no_bad_edges(sample.edges) + assert np.max(sample.edges) == n - 1 + assert sample.membership_matrix.shape[1] == n @pytest.mark.parametrize("n", [100, 200]) @@ -23,13 +23,13 @@ def test_seed(n): rng2 = np.random.default_rng(seed=1) abcd = ABCD(n, rng=rng1) - edges1, memberships1 = abcd.sample() + sample1 = abcd.sample() # reset seed abcd.rng = rng2 - edges2, memberships2 = abcd.sample() + sample2 = abcd.sample() - assert_no_bad_edges(edges1) - assert_no_bad_edges(edges2) - npt.assert_array_equal(edges1, edges2) - npt.assert_array_equal(memberships1.toarray(), memberships2.toarray()) + assert_no_bad_edges(sample1.edges) + assert_no_bad_edges(sample2.edges) + npt.assert_array_equal(sample1.edges, sample2.edges) + npt.assert_array_equal(sample2.to_dense(), sample2.to_dense()) diff --git a/tests/test_abcd_sample.py b/tests/test_abcd_sample.py new file mode 100644 index 0000000..99c57a5 --- /dev/null +++ b/tests/test_abcd_sample.py @@ -0,0 +1,99 @@ +import numpy as np +import numpy.testing as npt +import pytest +import scipy.sparse as sp + +from abcd_graph.abcd_sample import ABCDSample + + +@pytest.fixture +def sample(): + edges = np.array([[0, 1], [1, 2], [2, 3], [3, 4]], dtype=np.uint32) + membership_matrix = sp.csr_array([[1, 1, 0, 0, 0], [0, 1, 1, 1, 0]], dtype=np.bool) + sample = ABCDSample(edges, membership_matrix) + return sample + + +def test_xi(sample): + xi = sample.xi + assert xi == 0.25 + + +@pytest.mark.filterwarnings("ignore::UserWarning:powerlaw*") +def test_degree_exponent(sample): + exponent = sample.degree_exponent + assert exponent > 0 + + +@pytest.mark.filterwarnings("ignore::UserWarning:powerlaw*") +def test_community_size_exponent(sample): + exponent = sample.community_size_exponent + assert exponent > 0 + + +def test_to_sparse(sample): + result = sample.to_sparse() + correct = sp.csr_array( + [ + [0, 1, 0, 0, 0], + [1, 0, 1, 0, 0], + [0, 1, 0, 1, 0], + [0, 0, 1, 0, 1], + [0, 0, 0, 1, 0], + ], + dtype=np.bool, + ) + + npt.assert_array_equal(correct.todense(), result.todense()) + assert isinstance(result, sp.csr_array) + + +def test_to_sparse_matrix(sample): + assert isinstance(sample.to_sparse(matrix=True), sp.csr_matrix) + + +def test_to_dense(sample): + result = sample.to_dense() + correct = np.array( + [ + [0, 1, 0, 0, 0], + [1, 0, 1, 0, 0], + [0, 1, 0, 1, 0], + [0, 0, 1, 0, 1], + [0, 0, 0, 1, 0], + ], + dtype=np.bool, + ) + + npt.assert_array_equal(correct, result) + + +def test_to_networkx(sample): + pytest.importorskip("networkx") + result = sample.to_networkx() + + assert result.number_of_nodes() == 5 + assert result.number_of_edges() == 4 + + +def test_to_igraph(sample): + pytest.importorskip("igraph") + result = sample.to_igraph() + + assert result.vcount() == 5 + assert result.ecount() == 4 + + +def test_community_array(sample): + sample.membership_matrix = sp.csr_array( + [[1, 1, 0, 0, 0], [0, 0, 1, 1, 0]], dtype=np.bool + ) + result = sample.community_array() + + correct = np.array([0, 0, 1, 1, -1]) + npt.assert_array_equal(correct, result) + + +def test_community_array_raises_with_overlap(sample): + with pytest.raises(ValueError): + sample.community_array() From bf89d06dbe79b52e16d32c9d8b1c50e319fa360a Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe <61296655+ryandewolfe33@users.noreply.github.com> Date: Sun, 23 Aug 2026 09:14:24 -0400 Subject: [PATCH 48/85] Feature/speed up assign degrees (#4) * Fix bug in rewiring and models, faster degree assignments * Faster (and fixed?) degree assignment * Can sample 100 000 node graph in 0.5s. --- abcd_graph/abcd.py | 9 +++-- abcd_graph/degrees.py | 81 +++++++++++++++++++++++++++++-------------- abcd_graph/models.py | 42 ++++++++++------------ tests/test_degrees.py | 5 ++- 4 files changed, 85 insertions(+), 52 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index dbfe790..e6ea530 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -77,9 +77,10 @@ def generate_graph( graph = np.empty((community_edges_indptr[-1], 2), dtype=np.uint32) n_coms = community_degrees.shape[0] rngs = rng.spawn(n_coms) - # TODO Parallel this loop logger.info("Building Community Graphs") start = perf_counter() + # TODO Parallel this loop + # TODO logging for this progess bar for i in trange(n_coms, disable=logger.getEffectiveLevel() > 20): generate_community_graph_task( i, @@ -99,7 +100,11 @@ def generate_graph( n_good_edges = rewire(graph, rng, max_swap_attempts_per_bad_edge) end = perf_counter() logger.info(f"Finished in {format_duration(end - start)}.") - graph.resize((n_good_edges, 2), refcheck=False) + if graph.shape[0] - n_good_edges: + logger.info( + f"Failed to rewire {graph.shape[0] - n_good_edges}, they will be removed." + ) + graph.resize((n_good_edges, 2), refcheck=False) return graph diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index 2dfdcfb..4fdaa3c 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -133,7 +133,6 @@ def _assign_outlier_degrees( return outlier_degrees, remaining_degrees -@njit(cache=True) def _assign_degrees( degrees: NDArray[np.uint32], n_coms: NDArray, @@ -142,35 +141,65 @@ def _assign_degrees( alpha: float = 0.0, ) -> NDArray[np.uint32]: assigned_degrees = np.empty_like(degrees) - open_nodes = np.arange(len(n_coms), dtype=np.uint32)[n_coms > 0] + is_open_mask = np.ones_like(assigned_degrees, dtype=np.bool) n_coms_exp_alpha = n_coms.astype(np.float64) ** alpha - for d in degrees: - allowed_indices = np.where(d <= thresholds[open_nodes])[0] - if len(allowed_indices) == 0: - allowed_indices = np.where( - thresholds[open_nodes] == np.min(thresholds[open_nodes]) - )[0] - allowed_nodes = open_nodes[allowed_indices] - - # Choose an available node proportional to n_coms ** alpha - if len(allowed_nodes) > 1: - probs = n_coms_exp_alpha[allowed_nodes] - probs /= np.sum(probs) - cum_prob = np.cumsum(probs) - random_value = rng.uniform() - chosen_index = np.searchsorted(cum_prob, random_value) + degree, counts = np.unique_counts(degrees) + # Sort by degree descending + degree_argsort = np.argsort(degree)[::-1] + degree = degree[degree_argsort] + counts = counts[degree_argsort] + # Group decisions since there are relatively few unique degrees + for d, count in zip(degree, counts, strict=True): + allowed_indices = np.where(is_open_mask & (d <= thresholds))[0] + if len(allowed_indices) <= count: + # assign allowed and pick the next smallest thresholds to meet the count + assigned_degrees[allowed_indices] = d + is_open_mask[assigned_degrees] = False + n_left = count - len(allowed_indices) + if n_left > 0: + # This part is slow, but does not run that often + # Sort still open ids by threshold descending + open_ids = np.where(is_open_mask)[0] + sorted_by_threshold = open_ids[np.argsort(thresholds[open_ids])[::-1]] + # Pick the next best + next_best_indices = sorted_by_threshold[:n_left] + # Break ties randomly + min_needed_threshold = thresholds[next_best_indices[-1]] + next_best_indices_without_max = next_best_indices[ + thresholds[next_best_indices] < min_needed_threshold + ] + n_of_max_threshold = len(next_best_indices) - len( + next_best_indices_without_max + ) + all_indices_with_max_needed_threshold = np.where( + is_open_mask & (thresholds == min_needed_threshold) + )[0] + probs = n_coms_exp_alpha[all_indices_with_max_needed_threshold] + probs /= np.sum(probs) + chosen_max_indices = rng.choice( + all_indices_with_max_needed_threshold, + size=n_of_max_threshold, + replace=False, + p=probs, + ) + # Assign degrees and update masks + assigned_degrees[next_best_indices_without_max] = d + is_open_mask[next_best_indices_without_max] = False + assigned_degrees[chosen_max_indices] = d + is_open_mask[chosen_max_indices] = False else: - chosen_index = 0 - assigned_degrees[allowed_nodes[chosen_index]] = d - - # Remove assigned node and shorten list - open_nodes[allowed_indices[chosen_index]] = open_nodes[-1] - open_nodes = open_nodes[:-1] + # Choose `count` indices from allowed_indices proportional to n_coms ** alpha + probs = n_coms_exp_alpha[allowed_indices] + probs /= np.sum(probs) + chosen_indices = chosen_max_indices = rng.choice( + allowed_indices, size=count, replace=False, p=probs + ) + assigned_degrees[chosen_indices] = d + is_open_mask[chosen_indices] = False return assigned_degrees -@njit(cache=True) def _assign_degrees_with_alpha_search( degrees: NDArray[np.uint32], n_coms: NDArray[np.uint32], @@ -296,10 +325,10 @@ def assign_degrees( community_sizes = membership_matrix.sum(axis=1).astype( np.uint32 ) # size of each community - membership_matrix = membership_matrix.tocsc() n_coms = membership_matrix.sum(axis=0) # number of communities per node community_size_matrix = ( - sp.diags_array(community_sizes, dtype=np.uint32) @ membership_matrix + sp.diags_array(community_sizes, format="csr", dtype=np.uint32) + @ membership_matrix ) min_com_sizes = community_size_matrix.min(axis=0, explicit=True).todense() diff --git a/abcd_graph/models.py b/abcd_graph/models.py index cc1c993..1008651 100644 --- a/abcd_graph/models.py +++ b/abcd_graph/models.py @@ -55,7 +55,6 @@ def configuration_model( rng: Generator numpy.random.Generator object used for randomness. """ - node_ids = np.arange(len(degrees), dtype=np.uint32) stubs = np.repeat(node_ids, degrees) rng.shuffle(stubs) edges = stubs.reshape(-1, 2) @@ -154,16 +153,16 @@ def rewire( # with a random edge (good or bad, but not the one we are trying to resolve) # If the swap would cause a collision, move bad edge to the back of the # queue. Repeat until the Queue is empty or we give up. - - queue_head = 0 - queue_tail = len(bad_queue) - n_bad_edges = queue_tail - for _ in range(queue_tail * max_swap_attempts_per_bad_edge): - if n_bad_edges == 0: + next_index = len(bad_queue) + for _ in range(len(bad_queue) * max_swap_attempts_per_bad_edge): + if len(bad_queue) == 0: break - bad_edge = edge_from_id(bad_queue[queue_head]) + else: + next_index = (next_index + 1) % len(bad_queue) + bad_edge_id = bad_queue[next_index] + bad_edge = edge_from_id(bad_edge_id) choose_from_good_edges = rng.uniform() < n_good_edges / ( - n_good_edges + n_bad_edges - 1 + n_good_edges + len(bad_queue) - 1 ) if choose_from_good_edges: swap_index = rng.integers(0, n_good_edges) @@ -176,13 +175,10 @@ def rewire( good_edges.add(make_edge_id(new_edge1)) good_edges.add(make_edge_id(new_edge2)) good_edges.discard(make_edge_id(swap_candidate_edge)) - queue_head = (queue_head + 1) % len(bad_queue) - n_bad_edges -= 1 - else: - queue_head, queue_tail = (queue_head + 1) % len(bad_queue), queue_tail + bad_queue.pop(next_index) else: - swap_offset = rng.integers(1, n_bad_edges) # don't choose current head - swap_index = (queue_head + swap_offset) % len(bad_queue) + swap_offset = rng.integers(1, len(bad_queue)) # don't choose current head + swap_index = (next_index + swap_offset) % len(bad_queue) swap_candidate_edge_id = bad_queue[swap_index] swap_candidate_edge = edge_from_id(swap_candidate_edge_id) new_edge1, new_edge2 = swap(bad_edge, swap_candidate_edge, rng) @@ -193,16 +189,16 @@ def rewire( good_edges.add(make_edge_id(new_edge1)) good_edges.add(make_edge_id(new_edge2)) n_good_edges += 1 - bad_queue.pop(swap_index) - queue_head = (queue_head + 1) % len(bad_queue) - n_bad_edges -= 2 - else: - queue_head, queue_tail = (queue_head + 1) % len(bad_queue), queue_tail + if swap_index < next_index: # Pop larger index first + bad_queue.pop(next_index) + bad_queue.pop(swap_index) + else: + bad_queue.pop(swap_index) + bad_queue.pop(next_index) # Write bad edges that failed to swap back into the edge list - for i in range(n_bad_edges): - bad_edge_id = bad_queue[(queue_head + 1) % len(bad_queue)] - bad_edge = edge_from_id(bad_edge_id) + for i in range(len(bad_queue)): + bad_edge = edge_from_id(bad_queue[i]) edges[n_good_edges + i] = bad_edge return n_good_edges diff --git a/tests/test_degrees.py b/tests/test_degrees.py index f3a6bc7..017afa5 100644 --- a/tests/test_degrees.py +++ b/tests/test_degrees.py @@ -107,5 +107,8 @@ def test_assign_degrees_overlap_with_rho(xi, rho): assert np.sum(assigned_degrees == 4) == 16 assert np.sum(assigned_degrees == 3) == 16 n_coms = membership_matrix.sum(axis=0) - empirical_rho = np.corrcoef(assigned_degrees, n_coms)[0, 1] + inlier_mask = n_coms > 0 + empirical_rho = np.corrcoef(assigned_degrees[inlier_mask], n_coms[inlier_mask])[ + 0, 1 + ] assert np.sign(empirical_rho) == np.sign(rho) From 5748827e2711887f8fe2e817a24a2048bf709858 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 23 Aug 2026 09:15:30 -0400 Subject: [PATCH 49/85] Update versions in ci workflow --- .github/workflows/ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 9b2bea5..f9cb6af 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -16,9 +16,9 @@ jobs: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.12", "3.13", "3.14"] steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v7 - - uses: actions/setup-python@v5 + - uses: actions/setup-python@v7 with: python-version: ${{ matrix.python-version }} From 8dbc96c3fd5750a1e27253fcc855e20eb34a3a1c Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe <61296655+ryandewolfe33@users.noreply.github.com> Date: Sun, 23 Aug 2026 10:29:14 -0400 Subject: [PATCH 50/85] Add fit function to ABCD (#5) --- abcd_graph/abcd.py | 59 +++++++++++++++++++++++++++++++++++++-- abcd_graph/abcd_sample.py | 25 +++++++++++++---- tests/test_abcd.py | 25 +++++++++++++++++ 3 files changed, 102 insertions(+), 7 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index e6ea530..4e92de1 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -1,7 +1,8 @@ import logging import sys -from collections.abc import Callable +from collections.abc import Callable, Container from time import perf_counter +from typing import Self from warnings import warn import numpy as np @@ -372,7 +373,7 @@ def _get_logger(self): logger.addHandler(handler) return logger - def sample(self) -> (NDArray[np.uint32], sp.csr_array): + def sample(self) -> ABCDSample: sample_start = perf_counter() self._validate_params() @@ -480,3 +481,57 @@ def sample(self) -> (NDArray[np.uint32], sp.csr_array): ) self.sample_ = ABCDSample(self.graph_, self.membership_matrix_) return self.sample_ + + def fit( + self, + graph: ABCDSample, + do_not_set: Container | None = {"degree_sequence", "community_size_sequence"}, + ) -> Self: + """Set parameters of this ABCD class to the empirical values from another graph. + Measureable parameters are: + - "n" + - "xi" + - "outliers" + - "eta" + - "rho" + - "degree_exponent" + - "min_degree" + - "max_degree" + - "community_size_exponent" + - "min_community_size" + - "max_community_size" + - "degree_sequence" + - "community_size_sequence" + + Parameters + ---------- + graph:ABCDSample + The graph used to measure empirical values + + do_not_set:Container | None (default={'degree_sequence', 'community_size_sequence'}) + List of parameter names that should not be set to the empirical values. Setting degree + sequence or community size sequence take priority and force samples to have exactly + the same sequence. + + + """ + parameters = [ + "n", + "xi", + "outliers", + "eta", + "rho", + "degree_exponent", + "min_degree", + "max_degree", + "community_size_exponent", + "min_community_size", + "max_community_size", + "degree_sequence", + "community_size_sequence", + ] + for parameter in parameters: + if parameter not in do_not_set: + value = getattr(graph, parameter) + setattr(self, parameter, value) + return self diff --git a/abcd_graph/abcd_sample.py b/abcd_graph/abcd_sample.py index 026d36a..924f3d0 100644 --- a/abcd_graph/abcd_sample.py +++ b/abcd_graph/abcd_sample.py @@ -65,18 +65,17 @@ def m(self) -> int: return self.edges.shape[0] @property - def n_outliers(self) -> int: + def outliers(self) -> int: return np.sum(self.membership_matrix.count_nonzero(axis=0) == 0) @property def eta(self) -> float: - return self.membership_matrix.sum() / (self.n - self.n_outliers) + return self.membership_matrix.sum() / (self.n - self.outliers) @property def rho(self) -> float: - # Degrees sorted by node_id - degrees = np.unique_counts(self.edges, sorted=True)[1] - coms_per_node = self.membership_matrix.sum(axis=1) + degrees = self.to_sparse().sum(axis=1) // 2 + coms_per_node = self.membership_matrix.sum(axis=0) inlier_mask = coms_per_node > 0 rho = np.corrcoef(degrees[inlier_mask], coms_per_node[inlier_mask])[0, 1] return rho @@ -88,6 +87,14 @@ def degree_sequence(self) -> NDArray: degrees[node] = degree return degrees + @property + def min_degree(self) -> int: + return np.min(self.degree_sequence) + + @property + def max_degree(self) -> int: + return np.max(self.degree_sequence) + @property def degree_exponent(self) -> float: degree_sequence = self.degree_sequence @@ -104,6 +111,14 @@ def degree_exponent(self) -> float: def community_size_sequence(self) -> NDArray: return self.membership_matrix.sum(axis=1) + @property + def min_community_size(self) -> int: + return np.min(self.community_size_sequence) + + @property + def max_community_size(self) -> int: + return np.max(self.community_size_sequence) + @property def community_size_exponent(self) -> float: size_sequence = self.community_size_sequence diff --git a/tests/test_abcd.py b/tests/test_abcd.py index ea67c75..cc6dc87 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -1,9 +1,11 @@ import numpy as np import numpy.testing as npt import pytest +import scipy.sparse as sp from utils import assert_no_bad_edges from abcd_graph import ABCD +from abcd_graph.abcd_sample import ABCDSample @pytest.mark.parametrize("n", [100, 200]) @@ -33,3 +35,26 @@ def test_seed(n): assert_no_bad_edges(sample2.edges) npt.assert_array_equal(sample1.edges, sample2.edges) npt.assert_array_equal(sample2.to_dense(), sample2.to_dense()) + + +@pytest.mark.filterwarnings("ignore::UserWarning:powerlaw*") +@pytest.mark.filterwarnings("ignore::RuntimeWarning:powerlaw*") +def test_fit(): + edges = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 0]], dtype=np.uint32) + coms = sp.csr_array([[1, 1, 1, 0, 0], [0, 0, 1, 1, 0]]) + sample = ABCDSample(edges, coms) + abcd = ABCD(100) + + abcd.fit(sample) + + assert abcd.n == 5 + assert abcd.xi == 0.4 + assert abcd.eta == 1.25 + assert abcd.min_degree == 2 + assert abcd.max_degree == 2 + assert abcd.degree_exponent != 2.5 + assert abcd.min_community_size == 2 + assert abcd.max_community_size == 3 + assert abcd.community_size_exponent != 1.5 + assert abcd.degree_sequence is None + assert abcd.community_size_sequence is None From 25c5a3a5e9694118aefacd694bfcb6860aca4a35 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 23 Aug 2026 11:03:58 -0400 Subject: [PATCH 51/85] Add upper limit on n --- abcd_graph/abcd.py | 22 ++++++++++++++++------ tests/test_abcd.py | 6 ++++++ 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index 4e92de1..4522ee5 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -17,6 +17,8 @@ from abcd_graph.models import Model, chunglu_model, configuration_model, rewire from abcd_graph.samplers import sample_community_sizes, sample_degrees +MAX_N = np.iinfo(np.uint32).max + def format_duration(seconds: float): if seconds >= 1.0: @@ -226,13 +228,15 @@ def __init__( def _validate_params(self): if not isinstance(self.n, (int, np.integer)) or self.n < 1: raise ValueError("n must be a positive integer") + if self.n > MAX_N: + raise ValueError(f"n must at most {MAX_N} so it can be stored as a uint32") if not isinstance(self.xi, (float, np.floating)) or self.xi < 0 or self.xi > 1: raise ValueError("xi must be a float between 0 and 1") if isinstance(self.outliers, (int, np.integer)): - if self.outliers < 0: - raise ValueError("integer outliers must be positive") + if self.outliers < 0 or self.outliers > self.n: + raise ValueError("integer outliers must be positive and at most n") elif isinstance(self.outliers, (float, np.floating)): if self.outliers < 0 or self.outliers > 1: raise ValueError("float outliers must be between 0 and 1") @@ -260,7 +264,10 @@ def _validate_params(self): ): raise ValueError("rho must be positive") elif self.degree_exponent < 2 or self.degree_exponent > 3: - warn("Typical degree exponents are between 2 and 3", stacklevel=2) + warn( + f"Typical degree exponents are between 2 and 3, got {self.degree_exponent}", + stacklevel=2, + ) if ( not isinstance(self.min_degree, (int, np.integer)) @@ -283,7 +290,10 @@ def _validate_params(self): ): raise ValueError("rho must be positive") elif self.community_size_exponent < 1 or self.community_size_exponent > 2: - warn("Typical degree exponents are between 1 and 2", stacklevel=2) + warn( + f"Typical degree exponents are between 1 and 2, got {self.community_size_exponent}", + stacklevel=2, + ) if ( not isinstance(self.min_community_size, (int, np.integer)) @@ -323,9 +333,9 @@ def _validate_params(self): raise ValueError( "community size sequence must be able to cast to a numpy array of uint32" ) from e - if np.any(self.community_size_sequence >= self.n): + if np.any(self.community_size_sequence_ >= self.n): raise ValueError("community sizes must be less than n") - if np.any(self.community_size_sequence < 1): + if np.any(self.community_size_sequence_ < 1): raise ValueError("community sizes must be at least 2") if not isinstance(self.alpha_max, (float, np.floating)) or self.alpha_max <= 0: diff --git a/tests/test_abcd.py b/tests/test_abcd.py index cc6dc87..069a76d 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -19,6 +19,12 @@ def test_abcd(n): assert sample.membership_matrix.shape[1] == n +def test_abcd_raises_large_n(): + abcd = ABCD(np.iinfo(np.uint32).max + 1) + with pytest.raises(ValueError): + abcd.sample() + + @pytest.mark.parametrize("n", [100, 200]) def test_seed(n): rng1 = np.random.default_rng(seed=1) From 297f272279fef201a1a0f9aacf74665578501851 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 23 Aug 2026 12:03:57 -0400 Subject: [PATCH 52/85] Update docstrings and don't use rho in degrees without overlap --- abcd_graph/abcd.py | 68 ++++++++++++++++++++++++++++----------- abcd_graph/abcd_sample.py | 1 + abcd_graph/degrees.py | 2 ++ tests/test_abcd_sample.py | 5 +-- 4 files changed, 56 insertions(+), 20 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index 4522ee5..cee77b8 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -119,36 +119,52 @@ class ABCD: Parameters ---------- - - vcount : int + n : int The number of vertices in the graph. - gamma : float, default=2.5 - Powerlaw exponent for the degree distribution. Not used if - degree_sequence is passed. - - beta: float, default=1.5 - Powerlaw exponent for the community size distribution. Not used if a - custom community_size_sequence is passed. - xi: float, default=0.25 Proportion of edges in the global background graph. Setting xi=0 gives disjoint communities while xi=1 gives a random graph with no community structure. + outliers : int | float, default=0 + Number or proportion of outliers. Outliers have their entire degree in + the background graph and do not belong to any community. + + eta: float, default=1.0 + Average number of communities for non-outlier nodes. When eta=1 there + is no overlap. + + dimension: int, default=8 + Dimension of the hidden reference layer used to construct overlapping + communities. Not used if eta is 1. + + rho: float, default=0, + Pearson correlation between node degree and the number of communities + it is in. Not used if eta is 1. + + degree_exponent : float, default=2.5 + Powerlaw exponent for the degree distribution. Not used if + degree_sequence is passed. + min_degree : int, default=5 Minimum degree in the graph. Not used if degree_sequence is passed. - max_degree : int, default=30 - Maximum degree in the graph. Not used if degree_sequence is passed. + max_degree : int | Callable[[int], int], default=lambda n: int(n**0.5) + Maximum degree in the graph. May be be passed as a function that + will be called on n. Not used if degree_sequence is passed. + + community_size_exponent: float, default=1.5 + Powerlaw exponent for the community size distribution. Not used if a + custom community_size_sequence is passed. min_community_size : int, default=20 Minimum community size. Not used if a custom community_size_sequence is passed. - max_community_size: int, default=250 - Maximum community size. Not used if a custom community_size_sequence - is passed. + max_community_size: int | Callable[[int], int], default=lambda n: int(n**0.75) + Maximum community size. May be be passed as a function that will be called + on n. Not used if a custom community_size_sequence is passed. degree_sequence : Sequence[int] | NDArray[np.int64] | None, default=None Used to pass a custom degree sequence that overrides the default @@ -159,13 +175,29 @@ class ABCD: powerlaw distribution. The sum of the community sizes must equal the number of vertices minus the number of outliers. - num_outliers : int, default=0 - The number of outliers. These vertices have their entire degree in the - global background graph so do not appear in any community. + rho_tol: float, default=0.05 + Tolerance for rho optmiziation. Only used if rho != 0. + + alpha_min: float, default=-60.0 + Minimum bound in rho optimization. Only used if rho != 0. + + alpha_max: float, default=60.0 + Maximum bound in rho optmization. Only used if rho != 0. + + alpha_iters: int, default=10 + Number of alphas to try in rho optimization. Only used if rho != 0. model : Model | None, default=None Random graph model used to sample the community and background graphs. + max_swap_attempts_per_bad_edge: int, default=5 + Maximum number of time to try and swap each bad edge during rewiring step. + Small numbers will improve speed, but degrades the quality since any edges + that fail to get rewired are dropped. + + rng : numpy.random.Generator, default=numpy.random.default_rng() + Source of all randomness. + logger : Logger | None, default=None Option to pass a custom logging object. diff --git a/abcd_graph/abcd_sample.py b/abcd_graph/abcd_sample.py index 924f3d0..cc30782 100644 --- a/abcd_graph/abcd_sample.py +++ b/abcd_graph/abcd_sample.py @@ -168,6 +168,7 @@ def to_igraph(self): "Run `pip install igraph` to install it." ) from e + @property def community_array(self): if self.eta > 1: raise ValueError( diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index 4fdaa3c..89fd351 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -326,6 +326,8 @@ def assign_degrees( np.uint32 ) # size of each community n_coms = membership_matrix.sum(axis=0) # number of communities per node + if np.max(n_coms) == 1: + rho = 0.0 community_size_matrix = ( sp.diags_array(community_sizes, format="csr", dtype=np.uint32) @ membership_matrix diff --git a/tests/test_abcd_sample.py b/tests/test_abcd_sample.py index 99c57a5..35b0be0 100644 --- a/tests/test_abcd_sample.py +++ b/tests/test_abcd_sample.py @@ -88,7 +88,7 @@ def test_community_array(sample): sample.membership_matrix = sp.csr_array( [[1, 1, 0, 0, 0], [0, 0, 1, 1, 0]], dtype=np.bool ) - result = sample.community_array() + result = sample.community_array correct = np.array([0, 0, 1, 1, -1]) npt.assert_array_equal(correct, result) @@ -96,4 +96,5 @@ def test_community_array(sample): def test_community_array_raises_with_overlap(sample): with pytest.raises(ValueError): - sample.community_array() + result = sample.community_array + assert len(result) == 5 From 4d1508410864ca11c26d63cec6b3bb4a52cf8949 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 23 Aug 2026 12:04:53 -0400 Subject: [PATCH 53/85] Update README and pyproject --- README.md | 305 +++++++++++++++++++++++++------------------------ pyproject.toml | 3 +- 2 files changed, 158 insertions(+), 150 deletions(-) diff --git a/README.md b/README.md index 2ac6448..770b221 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,12 @@ -# abcd-graph -A python library for generating ABCD graphs. - ![tests](https://github.com/AleksanderWWW/abcd-graph/actions/workflows/ci.yml/badge.svg) ![pre-commit](https://github.com/AleksanderWWW/abcd-graph/actions/workflows/pre-commit.yml/badge.svg) [![Release](https://img.shields.io/github/v/release/AleksanderWWW/abcd-graph)](https://github.com/AleksanderWWW/abcd-graph/releases) ![GitHub License](https://img.shields.io/github/license/AleksanderWWW/abcd-graph) ![GitHub repo size](https://img.shields.io/github/repo-size/AleksanderWWW/abcd-graph) +# abcd-graph +Artificial Benchmark for Community Detection. ABCD is a method for sampling random graphs with known community structure, and is useful for benchmarking community detection algorithms. The generated graphs can be have similar properties to those generated by LFR, but ABCD is much faster and has a noise parameter `xi` in [0,1] that transitions from disjoint communities to no communities. + ## Installation @@ -30,204 +30,211 @@ If you're using `uv` then run the following for lightning-fast installation: uv pip install -r pyproject.toml . ```` -### Optional dependencies -The project comes with a set of optional dependencies that can be installed using the following commands: - -```bash -pip install abcd-graph[dependency-name] -``` - -or - -```bash -uv add abcd-graph --extra dependency-name -``` - -where `dependency-name` is one of the following: - -| Value | Packages installed | -|--------------|-----------------------------------------------------------------------------------| -| `dev` | `pytest`, `pre-commit`, `pytest-cov` | -| `matplotlib` | `matplotlib` | -| `networkx` | `networkx` | -| `igraph` | `igraph` | -| `scipy` | `scipy` | -| `all` | `networkx`, `igraph`, `scipy`, `matplotlib` | - - ## Usage -```python -from abcd_graph import ABCDGraph, ABCDParams - -params = ABCDParams(vcount=1000) -graph = ABCDGraph(params, logger=True).build() -``` - -Or for an alternative interface ```python from abcd_graph import ABCD -abcd_sampler = ABCD(1000) # vcount is required, other ABCDParams are keyword args -graph = abcd_sampler.sample() # return a built ABCDGraph object +sampler = ABCD(1000) +sampler.sample() ``` + ### Parameters -- `params`: An instance of `ABCDParams` class. -- `logger` A boolean to enable or disable logging to the console. Default is `False` - no logs are shown. -- `callbacks`: A list of instances of `Callback` class. Default is an empty list. + n : int + The number of vertices in the graph. -### Returns + xi: float, default=0.25 + Proportion of edges in the global background graph. Setting xi=0 gives + disjoint communities while xi=1 gives a random graph with no community + structure. -The `ABCDGraph` object with the generated graph. + outliers : int | float, default=0 + Number or proportion of outliers. Outliers have their entire degree in + the background graph and do not belong to any community. -### Graph generation parameters - `ABCDParams` + eta: float, default=1.0 + Average number of communities for non-outlier nodes. When eta=1 there + is no overlap. -The `ABCDParams` class is used to set the parameters for the graph generation. + dimension: int, default=8 + Dimension of the hidden reference layer used to construct overlapping + communities. Not used if eta is 1. -Arguments: + rho: float, default=0, + Pearson correlation between node degree and the number of communities + it is in. Not used if eta is 1. -| Name | Type | Description | Default | -|---------------------------|-----------------|--------------------------------------------------------------|---------| -| `vcount` | `int` | Number of vertices in the graph | 1000 | -| `gamma` | `float` | Power-law parameter for degrees, between 2 and 3 | 2.5 | -| `min_degree` | `int` | Min degree | 5 | -| `max_degree` | `float` | Parameter for max degree, between 0 and 1 | 0.5 | -| `beta` | `float` | Power-law parameter for community sizes, between 1 and 2 | 1.5 | -| `min_community_size` | `int` | Min community size | 20 | -| `max_community_size` | `float` | Parameter for max community size, between `max_degree` and 1 | 0.8 | -| `xi` | `float` | Noise parameter, between 0 and 1 | 0.25 | -| `num_outliers` | `int` | Number of outlier vertices in the resulting graph | 0 | -| `degree_sequence` | `Sequence[int]` | Custom degree sequence to use during graph building | None | -| `community_size_sequence` | `Sequence[int]` | Custom community size sequence to use during graph building | None | + degree_exponent : float, default=2.5 + Powerlaw exponent for the degree distribution. Not used if + degree_sequence is passed. -Parameters are validated when the object is created. If any of the parameters are invalid, a `ValueError` will be raised. + min_degree : int, default=5 + Minimum degree in the graph. Not used if degree_sequence is passed. -**Notes** -- You cannot pass both `degree_sequence` and any of `gamma`, `min_degree` or `max_degree`. -- You cannot pass both `community_size_sequence` and any of `beta`, `min_community_size` or `max_community_size`. + max_degree : int | Callable[[int], int], default=lambda n: int(n**0.5) + Maximum degree in the graph. May be be passed as a function that + will be called on n. Not used if degree_sequence is passed. + community_size_exponent: float, default=1.5 + Powerlaw exponent for the community size distribution. Not used if a + custom community_size_sequence is passed. -### Communities and edges + min_community_size : int, default=20 + Minimum community size. Not used if a custom community_size_sequence + is passed. -The `ABCDGraph` object has two properties that can be used to access the communities and edges of the graph. + max_community_size: int | Callable[[int], int], default=lambda n: int(n**0.75) + Maximum community size. May be be passed as a function that will be called + on n. Not used if a custom community_size_sequence is passed. -- `communities` - A list of `ABCDCommunity` objects. -- `edges` - A list of tuples representing the edges of the graph. + degree_sequence : Sequence[int] | NDArray[np.int64] | None, default=None + Used to pass a custom degree sequence that overrides the default + powerlaw distribution. -Example: + community_size_sequence : Sequence[int] | NDArray[np.int64] | None, default=None + Used to pass a custom community size sequence that overrides the default + powerlaw distribution. The sum of the community sizes must equal the number + of vertices minus the number of outliers. -```python - -from abcd_graph import ABCDGraph, ABCDParams + rho_tol: float, default=0.05 + Tolerance for rho optmiziation. Only used if rho != 0. -params = ABCDParams(vcount=1000) + alpha_min: float, default=-60.0 + Minimum bound in rho optimization. Only used if rho != 0. -graph = ABCDGraph(params, logger=True).build() + alpha_max: float, default=60.0 + Maximum bound in rho optmization. Only used if rho != 0. -print(graph.communities) -print(graph.edges) -``` + alpha_iters: int, default=10 + Number of alphas to try in rho optimization. Only used if rho != 0. -Communities have the following properties: -- vertices - A list of vertices in the community. -- average_degree - The average degree of the community. -- degree_sequence - The degree sequence of the community. -- empirical_xi - The empirical xi of the community. + model : Model | None, default=None + Random graph model used to sample the community and background graphs. -### Exporting + max_swap_attempts_per_bad_edge: int, default=5 + Maximum number of time to try and swap each bad edge during rewiring step. + Small numbers will improve speed, but degrades the quality since any edges + that fail to get rewired are dropped. -Exporting the graph to different formats is done via the `exporter` property of the `Graph` object. + rng : numpy.random.Generator, default=numpy.random.default_rng() + Source of all randomness. -Possible formats are: + logger : Logger | None, default=None + Option to pass a custom logging object. -| Method | Description | Additional packages | Installation command | -|--------------------------------|-------------------------------------------------------------------------------------------|---------------------|------------------------------------| -| `to_networkx()` | Export the graph to a `networkx.Graph` object. | `networkx` | `pip install abcd-graph[networkx]` | -| `to_igraph()` | Export the graph to an `igraph.Graph` object. | `igraph` | `pip install abcd-graph[igraph]` | -| `to_adjacency_matrix()` | Export the graph to a `numpy.ndarray` object representing the adjacency matrix. | | | -| `to_sparse_adjacency_matrix()` | Export the graph to a `scipy.sparse.csr_matrix` object representing the adjacency matrix. | `scipy` | `pip install abcd-graph[scipy]` | + verbose : bool, default=False + Only used if logger is not passed. If True, sets the logger level to info and the + output to stdout. If False, sets the logger level to warning and the output to + stderr. +Parameters are validated after calling `ABCD.sample()` If any of the parameters are invalid, a `ValueError` will be raised. -Example: +### Returns -```python -from abcd_graph import ABCDGraph, ABCDParams +The `ABCDSample` object with the generated graph. -params = ABCDParams(vcount=1000) -graph = ABCDGraph(params, logger=True).build() -graph_networkx = graph.exporter.to_networkx() -``` +### `ABCDSample` +The `ABCDSample` object has two properties that can be used to access the communities and edges of the graph. -### Callbacks +- `edges` - A m x 2 numpy array of node ids, each row is an edge. +- `membership_matrix` - A scipy sparse booleean array of with shape (\# communities x n) where `membership_matrix[i,j] = True` means node j is +in community i. -Callbacks are used to handle diagnostics and visualization of the graph generation process. They are instances of the `ABCDCallback` class. +It also has a number of methods to measure properties of the returned graph (for example, `ABCDSample.xi, ABCDSample.eta`) and covert to other popular graph formats. -Out of the box, the library provides three callbacks: -- `StatsCollector` - Collects statistics about the graph generation process. -- `PropertyCollector` - Collects properties of the graph. -- `Visualizer` - Visualizes the graph generation process. +If there is no overlap, the membership matrix may be represented as an array of length `n` where each entry correspond to the community id of the node. This array is accessible via `ABCDSample.community_array`. -Example: +The other graph formats available are described in the following table: -```python +| Method | Description | Additional packages | +|--------------------------------|-------------------------------------------------------------------------------------------|---------------------| +| `to_dense()` | Export the graph to a `numpy.ndarray` object representing the adjacency matrix. | | +| `to_sparse(matrix=False)` | Export the graph to a `scipy.sparse.csr_array` or `scipy.sparse.csr_matrix` object representing the adjacency matrix. | | +| `to_networkx()` | Export the graph to a `networkx.Graph` object. | `networkx` | +| `to_igraph()` | Export the graph to an `igraph.Graph` object. | `igraph` | -from abcd_graph import ABCDGraph, ABCDParams +## License -from abcd_graph.callbacks import StatsCollector, Visualizer, PropertyCollector +The abcd-graph package is MIT licensed. -stats = StatsCollector() -vis = Visualizer() -props = PropertyCollector() -params = ABCDParams(vcount=1000) -g = ABCDGraph(params, logger=True, callbacks=[stats, vis, props]).build() +## Contributions -print(stats.statistics) +Contributions are more than welcome! Everything from code to notebooks to examples and documentation are all valuable, so please don't feel you can't contribute. To contribute please fork the project, make your changes, and submit a pull request. -print(props.xi_matrix) +## References +If you use the ABCD model in an academic work, please consider citing the following works: -vis.draw_community_cdf() +### ABCD (communities form a partition) +```bibtex +@article{abcd, + title={Artificial Benchmark for Community Detection ({ABCD})—Fast random graph model with community structure}, + author={Bogumił Kamiński and Paweł Prałat and François Théberge}, + journal={Network Science}, + volume = {9}, + number = {2}, + pages={153--178}, + year={2021}, + doi = {10.1017/nws.2020.45}, +} ``` -## Docker - -To build a docker image containing the library, run: - -```bash -docker build -t abcd-graph . +### ABCD+o (allows outliers) +```bibtex +@article{abcdo, + title={Artificial benchmark for community detection with outliers (ABCD+o)}, + volume={8}, + doi={10.1007/s41109-023-00552-9}, + journal={Applied Network Science}, + author={Bogumił Kamiński and Paweł Prałat and François Théberge}, + year={2023}, + articleno={25}, +} ``` -To run the image, use: - -```bash -docker run -it abcd-graph +### ABCD+o2 (allows overlaps and outliers) +```bibtex +@article{abcdoo, + title={The artificial benchmark for community detection with outliers and overlapping communities (abcd+ o2)}, + author={Jordan Barrett and Ryan DeWolfe and Bogumił Kamiński and Paweł Prałat and Aaron Smith and François Théberge}, + journal={Journal of Complex Networks}, + volume={14}, + number={4}, + pages={cnag023}, + year={2026}, + publisher={Oxford University Press} +} ``` -This will give you a python REPL inside a container with the library installed. - -Available are also installation commands for the additional packages: -```bash -docker build -t abcd-test --build-arg INSTALL_TYPE=igraph . +### Other extensions +There are other extensions of ABCD that are not yet covered by this package but may be of interest. + +Hypergraphs ([available implementation in julia](https://github.com/bkamins/ABCDHypergraphGenerator.jl)) +```bibtex +@article{habcd, + title={Hypergraph Artificial Benchmark for Community Detection (h--{ABCD})}, + author={Bogumił Kamiński and Paweł Prałat and François Théberge}, + journal={Journal of Complex Networks}, + volume={11}, + number={4}, + pages={cnad028}, + year={2023}, + publisher={Oxford University Press}, + doi={10.1093/comnet/cnad028} +} ``` -Possible values for `INSTALL_TYPE` are `dev`, `matplotlib`, `networkx`, `igraph`, `scipy` and `all`. - -| Value | Packages installed | -|--------------|-----------------------------------------------------------------------------------| -| `dev` | `pytest`, `pre-commit`, `pytest-cov` | -| `matplotlib` | `matplotlib` | -| `networkx` | `networkx` | -| `igraph` | `igraph` | -| `scipy` | `scipy` | -| `all` | `networkx`, `igraph`, `scipy`, `matplotlib` | - -> [!WARNING] -> If you choose an option not included in the table above, the build process will fail. - - -## Examples - -The library comes with a set of examples that show how to use the library in different scenarios. -You can find them in the `examples` directory in the format of Jupyter Notebooks. +Multi-layered networks ([available implementation in julia](https://github.com/KrainskiL/MLNABCDGraphGenerator.jl)) +```bibtex +@article{mabcd, + title = {Multilayer artificial benchmark for community detection (mABCD)}, + journal = {Expert Systems with Applications}, + volume = {307}, + pages = {130920}, + year = {2026}, + doi = {10.1016/j.eswa.2025.130920}, + author = {Łukasz Kraiński and Michał Czuba and Piotr Bródka and Paweł Prałat and Bogumił Kamiński and François Théberge}, +} +``` diff --git a/pyproject.toml b/pyproject.toml index 2007701..76f3c44 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -8,7 +8,8 @@ version = "0.5.0-alpha" description = "A python library for generating ABCD graphs." authors = [ { name = "Aleksander Wojnarowicz", email = "alwojnarowicz@gmail.com" }, - { name = "Jordan Barrett" } + { name = "Jordan Barrett" }, + { name = "Ryan DeWolfe", email = "ryan.dewolfe@uwaterloo.ca" }, ] keywords = ["community detection", "graph clustering", "benchmark", "evaluation", "random graphs"] readme = "README.md" From a5dddee74e9d73ccd1ec7c54c40a09942f1df463 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 23 Aug 2026 12:09:05 -0400 Subject: [PATCH 54/85] Bump version to beta --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 76f3c44..1768262 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "hatchling.build" [project] name = "abcd-graph" -version = "0.5.0-alpha" +version = "0.5.0-beta" description = "A python library for generating ABCD graphs." authors = [ { name = "Aleksander Wojnarowicz", email = "alwojnarowicz@gmail.com" }, From f6ba638b10925c8d6443cd4449fcd6ea85baa32e Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 23 Aug 2026 13:53:29 -0400 Subject: [PATCH 55/85] Fix overflow error in membership: --- abcd_graph/membership.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/abcd_graph/membership.py b/abcd_graph/membership.py index cd9ff01..9f5e18c 100644 --- a/abcd_graph/membership.py +++ b/abcd_graph/membership.py @@ -24,7 +24,7 @@ def make_primary_community_sizes( # Increase or decrease random communities by one (but not to size 0) # to make it so. primary_size_sum = np.sum(primary_community_sizes) - required_change = n - primary_size_sum + required_change = n - int(primary_size_sum) if required_change > 0: increase_indices = rng.choice(n_coms, size=required_change, replace=False) primary_community_sizes[increase_indices] += 1 From 77137e2896a7003a1ea0112d71f657312136d3dd Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe <61296655+ryandewolfe33@users.noreply.github.com> Date: Sun, 30 Aug 2026 19:48:05 -0400 Subject: [PATCH 56/85] Add sphinx docs (#7) * Start docs with index and API * Getting started notebook * Add outliers notebook * Add overlap notebook * Run overlap notebook through prek * Add igraph notebook * Add networkx benchmark * Add networkx benchmark to index * Add sknetwork benchmark * Fix igraph benchmark import * Update getting started headers * Add how it works doc --- .gitignore | 1 + .pre-commit-config.yaml | 9 + abcd_graph/abcd.py | 238 ++++++++----- abcd_graph/abcd_sample.py | 226 +++++++++++- docs/_static/big_picture.pdf | Bin 0 -> 16955 bytes docs/_static/overlap_geom.png | Bin 0 -> 77730 bytes docs/api.rst | 16 + docs/benchmark_igraph.ipynb | 334 ++++++++++++++++++ docs/benchmark_networkx.ipynb | 289 ++++++++++++++++ docs/benchmark_sknetwork.ipynb | 286 ++++++++++++++++ docs/conf.py | 72 ++++ docs/getting_started.ipynb | 610 +++++++++++++++++++++++++++++++++ docs/how_it_works.rst | 131 +++++++ docs/index.rst | 37 ++ docs/outliers.ipynb | 286 ++++++++++++++++ docs/overlap.ipynb | 225 ++++++++++++ pyproject.toml | 20 +- 17 files changed, 2671 insertions(+), 109 deletions(-) create mode 100644 docs/_static/big_picture.pdf create mode 100644 docs/_static/overlap_geom.png create mode 100644 docs/api.rst create mode 100644 docs/benchmark_igraph.ipynb create mode 100644 docs/benchmark_networkx.ipynb create mode 100644 docs/benchmark_sknetwork.ipynb create mode 100644 docs/conf.py create mode 100644 docs/getting_started.ipynb create mode 100644 docs/how_it_works.rst create mode 100644 docs/index.rst create mode 100644 docs/outliers.ipynb create mode 100644 docs/overlap.ipynb diff --git a/.gitignore b/.gitignore index b1eaff8..b3f32e8 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,4 @@ __pycache__/ dist/ .python-version .DS_store +docs/_build diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 86f9fcd..bac7c36 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,12 +1,21 @@ exclude: '^examples' repos: + - repo: local + hooks: + - id: ipynbcompress + name: Compress IPYNB images + entry: ipynb-compress + language: python + additional_dependencies: [ipynbcompress, nbformat] + files: \.ipynb$ - repo: https://github.com/pre-commit/pre-commit-hooks rev: v6.0.0 hooks: - id: end-of-file-fixer - id: trailing-whitespace - id: check-added-large-files + args: ['--maxkb=4096'] # For notebooks with output - id: check-case-conflict - id: check-merge-conflict - id: check-toml diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index cee77b8..1855b0a 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -2,7 +2,6 @@ import sys from collections.abc import Callable, Container from time import perf_counter -from typing import Self from warnings import warn import numpy as np @@ -11,7 +10,7 @@ from numpy.typing import ArrayLike, NDArray from tqdm import trange -from abcd_graph.abcd_sample import ABCDSample +from abcd_graph.abcd_sample import ABCDSample, icdf from abcd_graph.degrees import assign_degrees, split_degrees from abcd_graph.membership import build_membership_matrix from abcd_graph.models import Model, chunglu_model, configuration_model, rewire @@ -150,7 +149,7 @@ class ABCD: min_degree : int, default=5 Minimum degree in the graph. Not used if degree_sequence is passed. - max_degree : int | Callable[[int], int], default=lambda n: int(n**0.5) + max_degree : int | Callable[[int], int], default=int(n**0.5) Maximum degree in the graph. May be be passed as a function that will be called on n. Not used if degree_sequence is passed. @@ -162,7 +161,7 @@ class ABCD: Minimum community size. Not used if a custom community_size_sequence is passed. - max_community_size: int | Callable[[int], int], default=lambda n: int(n**0.75) + max_community_size: int | Callable[[int], int], default=int(n**0.75) Maximum community size. May be be passed as a function that will be called on n. Not used if a custom community_size_sequence is passed. @@ -176,16 +175,16 @@ class ABCD: of vertices minus the number of outliers. rho_tol: float, default=0.05 - Tolerance for rho optmiziation. Only used if rho != 0. + Tolerance for rho optmiziation. Only used if rho is not 0. alpha_min: float, default=-60.0 - Minimum bound in rho optimization. Only used if rho != 0. + Minimum bound in rho optimization. Only used if rho is not 0. alpha_max: float, default=60.0 - Maximum bound in rho optmization. Only used if rho != 0. + Maximum bound in rho optmization. Only used if rho is not 0. alpha_iters: int, default=10 - Number of alphas to try in rho optimization. Only used if rho != 0. + Number of alphas to try in rho optimization. Only used if rho is not 0. model : Model | None, default=None Random graph model used to sample the community and background graphs. @@ -290,59 +289,33 @@ def _validate_params(self): ): raise ValueError("rho must be between -1 and 1") - if ( - not isinstance(self.degree_exponent, (float, np.floating)) - or self.degree_exponent < 0 - ): - raise ValueError("rho must be positive") - elif self.degree_exponent < 2 or self.degree_exponent > 3: - warn( - f"Typical degree exponents are between 2 and 3, got {self.degree_exponent}", - stacklevel=2, - ) - - if ( - not isinstance(self.min_degree, (int, np.integer)) - or self.min_degree < 1 - or self.min_degree >= self.n - ): - raise ValueError("min degree must be a positive int at most n") - - if not isinstance(self.max_degree, Callable) and ( - not isinstance(self.max_degree, (int, np.integer)) - or self.max_degree >= self.n - ): - raise ValueError( - "max degree must be greater than min degree and less than n" - ) - - if ( - not isinstance(self.community_size_exponent, (float, np.floating)) - or self.community_size_exponent < 0 - ): - raise ValueError("rho must be positive") - elif self.community_size_exponent < 1 or self.community_size_exponent > 2: - warn( - f"Typical degree exponents are between 1 and 2, got {self.community_size_exponent}", - stacklevel=2, - ) - - if ( - not isinstance(self.min_community_size, (int, np.integer)) - or self.min_community_size < 2 - or self.min_community_size >= self.n - ): - raise ValueError("min community size must be an integer between 2 and n") - - if not isinstance(self.max_community_size, Callable) and ( - not isinstance(self.max_community_size, (int, np.integer)) - or self.max_community_size >= self.n - ): - raise ValueError( - "max community size must be greater than min community size and less than n" - ) + if self.degree_sequence is None: + if ( + not isinstance(self.degree_exponent, (float, np.floating)) + or self.degree_exponent < 0 + ): + raise ValueError("rho must be positive") + elif self.degree_exponent < 2 or self.degree_exponent > 3: + warn( + f"Typical degree exponents are between 2 and 3, got {self.degree_exponent}", + stacklevel=2, + ) - if self.degree_sequence is not None: + if ( + not isinstance(self.min_degree, (int, np.integer)) + or self.min_degree < 1 + or self.min_degree >= self.n + ): + raise ValueError("min degree must be a positive int at most n") + + if not isinstance(self.max_degree, Callable) and ( + not isinstance(self.max_degree, (int, np.integer)) + or self.max_degree >= self.n + ): + raise ValueError( + "max degree must be greater than min degree and less than n" + ) + else: try: self.degree_sequence_ = np.asarray( self.degree_sequence, dtype=np.uint32 @@ -356,7 +329,35 @@ def _validate_params(self): if np.sum(self.degree_sequence_) % 2 != 0: raise ValueError("sum of degree sequence must be even") - if self.community_size_sequence is not None: + if self.community_size_sequence is None: + if ( + not isinstance(self.community_size_exponent, (float, np.floating)) + or self.community_size_exponent < 0 + ): + raise ValueError("rho must be positive") + elif self.community_size_exponent < 1 or self.community_size_exponent > 2: + warn( + f"Typical degree exponents are between 1 and 2, got {self.community_size_exponent}", + stacklevel=2, + ) + + if ( + not isinstance(self.min_community_size, (int, np.integer)) + or self.min_community_size < 2 + or self.min_community_size >= self.n + ): + raise ValueError( + "min community size must be an integer between 2 and n" + ) + + if not isinstance(self.max_community_size, Callable) and ( + not isinstance(self.max_community_size, (int, np.integer)) + or self.max_community_size >= self.n + ): + raise ValueError( + "max community size must be greater than min community size and less than n" + ) + else: try: self.community_size_sequence_ = np.asarray( self.community_size_sequence, dtype=np.uint32 @@ -426,37 +427,43 @@ def sample(self) -> ABCDSample: else: n_outliers = self.outliers - if self.degree_sequence is None: + if self.degree_sequence is not None: + degree_sequence = np.asarray(self.degree_sequence, dtype=np.uint32) + else: self.logger_.info("Generating Degree Sequence") start = perf_counter() - self.max_degree_ = ( + max_degree = ( self.max_degree(self.n) if callable(self.max_degree) else self.max_degree ) - self.degree_sequence_ = sample_degrees( + degree_sequence = sample_degrees( self.n, self.degree_exponent, self.min_degree, - self.max_degree_, + max_degree, self.rng, ) end = perf_counter() self.logger_.info(f"Finished in {format_duration(end - start)}.") - if self.community_size_sequence is None: + if self.community_size_sequence is not None: + community_size_sequence = np.asarray( + self.community_size_sequence, dtype=np.uint32 + ) + else: self.logger_.info("Generating Degree Sequence") start = perf_counter() - self.max_community_size_ = ( + max_community_size = ( self.max_community_size(self.n) if callable(self.max_community_size) else self.max_community_size ) - self.community_size_sequence_ = sample_community_sizes( + community_size_sequence = sample_community_sizes( self.n - n_outliers, self.community_size_exponent, self.min_community_size, - self.max_community_size_, + max_community_size, self.eta, self.rng, ) @@ -465,9 +472,9 @@ def sample(self) -> ABCDSample: self.logger_.info("Building Membership Matrix") start = perf_counter() - self.membership_matrix_ = build_membership_matrix( + membership_matrix = build_membership_matrix( self.n, - self.community_size_sequence_, + community_size_sequence, n_outliers, self.dimension, self.rng, @@ -478,8 +485,8 @@ def sample(self) -> ABCDSample: self.logger_.info("Assigning Degrees") start = perf_counter() assigned_degrees = assign_degrees( - self.degree_sequence_, - self.membership_matrix_, + degree_sequence, + membership_matrix, self.xi, self.rng, self.rho, @@ -495,7 +502,7 @@ def sample(self) -> ABCDSample: start = perf_counter() community_degrees, background_degrees = split_degrees( assigned_degrees, - self.membership_matrix_, + membership_matrix, self.xi, self.rng, ) @@ -509,7 +516,7 @@ def sample(self) -> ABCDSample: else: raise ValueError("model should be one of 'configuration' or 'chung-lu") - self.graph_ = generate_graph( + graph = generate_graph( community_degrees, background_degrees, model_func, @@ -521,29 +528,30 @@ def sample(self) -> ABCDSample: self.logger_.info( f"Sampled ABCD graph in {format_duration(sample_end - sample_start)}." ) - self.sample_ = ABCDSample(self.graph_, self.membership_matrix_) - return self.sample_ + sample = ABCDSample(graph, membership_matrix) + return sample def fit( self, graph: ABCDSample, do_not_set: Container | None = {"degree_sequence", "community_size_sequence"}, - ) -> Self: + ): """Set parameters of this ABCD class to the empirical values from another graph. Measureable parameters are: - - "n" - - "xi" - - "outliers" - - "eta" - - "rho" - - "degree_exponent" - - "min_degree" - - "max_degree" - - "community_size_exponent" - - "min_community_size" - - "max_community_size" - - "degree_sequence" - - "community_size_sequence" + + * n + * xi + * outliers + * eta + * rho + * degree_exponent + * min_degree + * max_degree + * community_size_exponent + * min_community_size + * max_community_size + * degree_sequence + * community_size_sequence Parameters ---------- @@ -554,8 +562,6 @@ def fit( List of parameter names that should not be set to the empirical values. Setting degree sequence or community size sequence take priority and force samples to have exactly the same sequence. - - """ parameters = [ "n", @@ -573,7 +579,51 @@ def fit( "community_size_sequence", ] for parameter in parameters: - if parameter not in do_not_set: + if do_not_set is None or parameter not in do_not_set: value = getattr(graph, parameter) setattr(self, parameter, value) return self + + def expected_degree_icdf(self, points: ArrayLike): + """Measure the expected inverse cumulative distribution function + (icdf) of the degree distribution at a sequence of values. + + Parameters + ---------- + points: ArrayLike + An array of points at which to measure the icdf. Points must + be non-negative and increasing. + + Returns + ------- + NDArray[np.floating] + The expected icdf values. + """ + self._validate_params() + if self.degree_sequence is not None: + return icdf(points, self.degree_sequence) + values = np.arange(self.min_degree, self.max_degree + 1) + weights = values**-self.degree_exponent + return icdf(points, values, weights=weights) + + def expected_community_size_icdf(self, points: ArrayLike): + """Measure the expected inverse cumulative distribution function + (icdf) of the community size distribution at a sequence of values. + + Parameters + ---------- + points: ArrayLike + An array of points at which to measure the icdf. Points must + be non-negative and increasing. + + Returns + ------- + NDArray[np.floating] + The expected icdf values. + """ + self._validate_params() + if self.community_size_sequence is not None: + return icdf(points, self.community_size_sequence) + values = np.arange(self.min_community_size, self.max_community_size + 1) + weights = values**-self.community_size_exponent + return icdf(points, values, weights=weights) diff --git a/abcd_graph/abcd_sample.py b/abcd_graph/abcd_sample.py index cc30782..871901a 100644 --- a/abcd_graph/abcd_sample.py +++ b/abcd_graph/abcd_sample.py @@ -20,11 +20,11 @@ def count_intra_community_edges( return m_intra_community -def icdf(points: ArrayLike, sequence: ArrayLike): +def icdf(points: ArrayLike, sequence: ArrayLike, weights=None) -> NDArray[np.floating]: points = np.asarray(points) points = np.insert(points, 0, 0) - hist, bin_edges = np.histogram(sequence, bins=points) - cdf = np.cumsum(hist) + hist, bin_edges = np.histogram(sequence, bins=points, weights=weights) + cdf = np.cumsum(hist).astype(np.float64) cdf /= cdf[-1] icdf = 1 - cdf return icdf @@ -36,22 +36,77 @@ class ABCDSample: Consists of an edge list and a community-node membership matrix. Has functions for measuring empirical properties of the graph, and functions for converting the edge list to other common graph types. + + Parameters + ---------- + edges: NDArray + List of edges. If dtype is integers, assumed to be contiguous and + treated as node ids. If dtype is anything else, they will be + assigned contiguous integer ids. + membership_matrix: sp.sparray | sp.spmatrix | ArrayLike + Community x node sparse membership array, 2-d community x node dense + membership array, or 1-d array of community ids. """ def __init__( self, - edges: NDArray[np.uint32], - membership_matrix: sp.csr_array, + edges: ArrayLike, + communities: sp.sparray | sp.spmatrix | ArrayLike, ): + edges = np.asarray(edges) + if not np.issubdtype(edges.dtype, np.integer): + _, edges = np.unique(edges, return_inverse=True) self.edges = edges - self.membership_matrix = membership_matrix + if sp.issparse(communities): + self.membership_matrix = sp.csr_array(communities) + else: + communities = np.asarray(communities) + if communities.ndim == 2: + self.membership_matrix = sp.csr_array(communities, dtype=np.bool) + elif communities.ndim == 1 and np.issubdtype(communities.dtype, np.integer): + communities = communities.astype(np.int64) + n = len(communities) + node_ids = np.arange(n, dtype=np.int64) + membership = np.vstack([communities, node_ids]) + membership = membership[:, membership[0] >= 0] # Drop outliers + membership_matrix = sp.coo_array( + (np.ones(membership.shape[1], dtype=np.bool), membership), + shape=(np.max(communities) + 1, n), + ) + self.membership_matrix = membership_matrix.tocsr() + else: + raise ValueError( + "Got an unknown format for communities. Must be a sparse or dense membership matrix or a 1-d array of community ids." + ) @property def n(self) -> int: + """The number of vertices in the graph. + + Returns + ------- + int + """ return self.membership_matrix.shape[1] + @property + def m(self) -> int: + """The number of edges in the graph. + + Returns + ------- + int + """ + return self.edges.shape[0] + @property def xi(self) -> float: + """The proportion of inter-community edges. + + Returns + ------- + float + """ membership_csc = self.membership_matrix.tocsc() m_intra_community = count_intra_community_edges( self.edges, @@ -60,20 +115,37 @@ def xi(self) -> float: ) return 1 - (m_intra_community / self.m) - @property - def m(self) -> int: - return self.edges.shape[0] - @property def outliers(self) -> int: + """The number of outlier vertices (belong to no community). + + Returns + ------- + int + """ return np.sum(self.membership_matrix.count_nonzero(axis=0) == 0) @property def eta(self) -> float: + """The average number of communities per non-outlier vertex. + + Returns + ------- + float + """ return self.membership_matrix.sum() / (self.n - self.outliers) @property def rho(self) -> float: + """The pearson correlation between the degree and number of communities + to which they belong for non-outlier nodes. + + Returns + ------- + float + """ + if self.eta == 1: + return 1.0 degrees = self.to_sparse().sum(axis=1) // 2 coms_per_node = self.membership_matrix.sum(axis=0) inlier_mask = coms_per_node > 0 @@ -82,6 +154,12 @@ def rho(self) -> float: @property def degree_sequence(self) -> NDArray: + """The degree sequence. + + Returns + ------- + Array[int] + """ degrees = np.zeros(self.n, dtype=np.uint32) node, degree = np.unique_counts(self.edges) degrees[node] = degree @@ -89,14 +167,32 @@ def degree_sequence(self) -> NDArray: @property def min_degree(self) -> int: + """The minimum degree. + + Returns + ------- + int + """ return np.min(self.degree_sequence) @property def max_degree(self) -> int: + """The maximum degree. + + Returns + ------- + int + """ return np.max(self.degree_sequence) @property def degree_exponent(self) -> float: + """The measured degree exponent + + Returns + ------- + float + """ degree_sequence = self.degree_sequence min_degree = np.min(degree_sequence) exponent = powerlaw.Fit( @@ -109,18 +205,42 @@ def degree_exponent(self) -> float: @property def community_size_sequence(self) -> NDArray: + """The community size sequence. + + Returns + ------- + Array[int] + """ return self.membership_matrix.sum(axis=1) @property def min_community_size(self) -> int: + """The minimum community size. + + Returns + ------- + int + """ return np.min(self.community_size_sequence) @property def max_community_size(self) -> int: + """The maximum community size. + + Returns + ------- + int + """ return np.max(self.community_size_sequence) @property def community_size_exponent(self) -> float: + """The measured community size exponent. + + Returns + ------- + float + """ size_sequence = self.community_size_sequence min_size = np.min(size_sequence) exponent = powerlaw.Fit( @@ -132,6 +252,19 @@ def community_size_exponent(self) -> float: return exponent def to_sparse(self, matrix: bool = False) -> sp.csr_array | sp.csr_matrix: + """Format the graph as a sparse adjacency matrix. + + Parameters + ---------- + matrix: bool, default=False + Flag to make the return type the deprecated scipy.sparse.csr_matrix. + This is useful for passing to scikit-network algorithms as they currently + do not accept the modern scipy.sparse.csr_array type. + + Returns + ------- + sp.csr_array | sp.csr_matrix + """ adjacency = sp.coo_array( (np.ones(self.edges.shape[0], dtype=np.bool), self.edges.T), shape=(self.n, self.n), @@ -142,9 +275,21 @@ def to_sparse(self, matrix: bool = False) -> sp.csr_array | sp.csr_matrix: return adjacency.tocsr() def to_dense(self) -> NDArray[np.bool]: + """Format the graph as an adjacency matrix. + + Returns + ------- + Array + """ return self.to_sparse().todense() def to_networkx(self): + """Format the graph as a networkx object. + + Returns + ------- + networkx.Graph + """ try: import networkx as nx @@ -157,6 +302,12 @@ def to_networkx(self): ) from e def to_igraph(self): + """Format the graph as an igraph object. + + Returns + ------- + igraph.Graph + """ try: import igraph as ig @@ -170,17 +321,66 @@ def to_igraph(self): @property def community_array(self): + """Format the community membership matrix as an array of community ids. + The value at index i is the community id of vertex i. Following hdbscan + convention, communities are indexed 0-n and -1 is used for outliers. + + Returns + ------- + Array[int] + """ if self.eta > 1: raise ValueError( - "Overlapping communities cannot be represent with an array" + "Overlapping communities cannot be represented with an array" ) result = np.full(self.n, -1) coms, nodes = self.membership_matrix.nonzero() result[nodes] = coms return result + @property + def community_dict(self): + """Format the community membership matrix as a dictionary with community ids + as keys and sets of nodes as values. + + Returns + ------- + dict[int, set] + """ + indptr = self.membership_matrix.indptr + indices = self.membership_matrix.indices + return { + i: set(indices[indptr[i] : indptr[i + 1]]) for i in range(len(indptr) - 1) + } + def degree_icdf(self, points: ArrayLike): - return icdf(self.degree_sequence) + """Measure the inverse cumulative distribution function (icdf) + of the degree distribution at a sequence of values + + Parameters + ---------- + points: ArrayLike + An array of points at which to mearuse the icdf. + + Returns + ------- + NDArray[np.floating] + The measured icdf values. + """ + return icdf(points, self.degree_sequence) def community_size_icdf(self, points: ArrayLike): - return icdf(self.community_size_sequence) + """Measure the inverse cumulative distribution function (icdf) + at of the community size distribution a sequence of values + + Parameters + ---------- + points: ArrayLike + An array of points at which to mearuse the icdf. + + Returns + ------- + NDArray[np.floating] + The measured icdf values. + """ + return icdf(points, self.community_size_sequence) diff --git a/docs/_static/big_picture.pdf b/docs/_static/big_picture.pdf new file mode 100644 index 0000000000000000000000000000000000000000..2d7ad33d5a6d83917caa420a0a4ac6089b7b27d4 GIT binary patch literal 16955 zcma&O1#BfTvn3p+2{Y%0nK=_?W}46qb8^Fs6PPeFGsA>AnJ_c+gqfND`F7vaztXO> z+v=9=vfD1Xt8BMU9aAccOER)DaUxL8EDWw7Z~<5VAY*F;etraIc{6(p7fS#)J2xxf ze_RO6l2*1ZW=;TRNn0ZqGjTH$kf|Ahpdf;?i<6m=9fHSNmwrbAMVtM@5&c+Fl;X_? zOOuyvaA*9G+K5g_O_ZI4bc`Pmj2)cNTvMZx{`=d|Ryr}qX`CTCg)~5^Z5?QT`S^zN z)VrPY>B8-ABS-hSlzKdO5&J~)emSl;ik~d^Y=1t~ zem>TIT`UWIJpTelG^vpl<<88kEps0;d_0!^7!c5vt*B9sH92LP+Yb5E0)5@3e&xo* z8o{^SyL_W$qTJsHT{W~a^tzLj*V^Ck4vN+{5B#-heNj%;Bm7}oFLb;|%Gi}8XcbzV zj0s8hQy!lrmy1;Z4WAHSTVlfQB;VUsNBsTASrOe&Mg;d^+t+)4r#*8t#1RnN_3OSi z^OFL-k2Tc}J9ZW~*sE2v?;v@}iJIE!g=AsfJ$~P7m`K*h{>I&8hq!Q{WHFAYWqMBh zw@A5aj<{Lrhwh>*KI_N!0YZ;`EEMrMHh<0H=#7@<1$&s~Q*^p$*hYFXzs@z0c{O&- zi=4srd1xC$h8QLH<3)|gMxb9i!4v_Q@5TH@G&cOQNB45^k*NJc%-k+E{)#5(KFh~8 zkb&8VmY2edKi*Gj51Gu5KgL1t8^F#k-|@gmiwDE1e-}N1KqB9 zlYfb2GyK}@+Cwh{6=MHR8*)=C?O-a&8O$9F5AeJpT<4f$u0@z$L$0`jyB`pJB%aSx8~;T)Y@bhNpyGMy_!lx_12Q8vpak72S*W~E znp7qH!(2N#G>RCmkrw?k?@?iK0&I{^r(IAbAefYgUqv(0S3|ZI^qXLU;IB_{tf~)j zRv{}&peRBF?HWE&Ws+#j98K8u!kz&Eb9Li{hLlOO>F{s5yq!_Grw#q&!Q!?xFe&Ic zLSI=kt9%(@u^N_ruX_S7)wML)mC`09x{#c2D?}JAu;ponuQ$B)OC@(+n4JZk;1kQ2 zrI^omxBaXNKpH{De%!=4aZq)9gXyblWjsScx?<)eqngJ$ISDKmxX_R|4DBCqbMj9G2>0QMhaV6$EB+p7m1`yUuTyQk zo#0bALQ}G5=;?Swyf%!Ew)j+09P8PY-1u~BstA#m-j(_L1Q$^ph#Y^Zbfj8R6a_)5 zYoujudSJ-na}55PMS)YC)w6haB@X%X6$@E+OEuxg4QnFG8&xcgg>`4_&}xR5$kQ$w z>q!PrGf0O>4&AS5_?|!RI@4y9>QWz)tmi~o#VK&|{BI*h#E9|jG|~_8i2#r!B*Kk3 zvzJ-}l_B{$ zN1hy0Z8?|IGwO7#|MbR1b_=EF3~=V3bj%n&Lq?dBBtVm>?>tKYMXKg7*G6aZCb zQwg;dh7S#Crl^ZnCz=<)pZbW2$JyD%DrIua{M;CALYkcqYWhO!Dkpo zlM!ERkr@Ov-SEJ4ipeDzpm=bnareKBUDK$+)*odOMxhDQ87UNaeCI?qrnr@HVH-(b zf{2P$%?p{Ag3FjoQ^OKtL>2i1p&D+BsIW(3g9S->mMz;06Wty&RHK9`oGT$KcHvXj z*vlW8Jmpz+&dnpFK-F!go7$dt;dortj8~!FA|C`9@A(aGuo`o+Qz)51=`J5x#c@IX8g8SrwTY%t*Sb;wg&2tZj9K zy!5Dtjj%hZ+KCiHi)CPJY<#hZyOlljW(`2hD~ga2Sr znSod2yOQqdjN)&#gxRS-RLzO?A_a)IzJR3#fUqnK8vZYNa+i6`Mf|}Ii|5Cv-V%#) zNnYh#1x|!1*K$b@IJKd^ft32+7KLqa1fjGx;L}6uW+UJ#5@{k}<)-+EQ@3bKw@IzP z6@ON&(uBEBZ0#ca@lEN9qjuu*CHF?fmf29AhRgM9>WwbI?jmiEAK*LoT< zpDxwg#&9P+tcP$m#-xjEJR-nXGq}@V?O6)icVW6bh50!xS8lcxC08>FEzYsJKMKGe zRugtsvhh+Bv1V4lio*Q!-3^q3*s3Iu{=lK@*_X(jb;cG?*zv|j4ZUqqXNtmG0RmqmvJKshd<%yiC2uMDw|NEM7GQY*N_$)tDIDE!KY$Rn7xpFPb z)cSkoHtRIlf~^%+tZpL>yuhGJWZeTAwu?i9T@o!;6QqP=n5*B1)TI*abcwC#P$Tza zj!qJmTTstrY^o^3dY`iBb;9T}C1xLb8kPi~ict)iqmP_9-eglw+N%Z&o!*$oG9YqUF28uit0cE z%tc94M|?yu2UV`50CZT|HDdbG

FM036#0Z3eEQ3<7*9t(~u|xwVjr+64H(_Y{y4 zUX@qMETLC*j-u5+1LB>OjwFM2wv#;wR921K0N3I7bX^pujMbL$@eaXLAl6N_W=y0C z;iUBz7f(0CQK9pc7GCfvZi-Gvd)6X^qR3lq6Rit3Vsa;AN4}|Kf$UN&3-2K_pNoVk9D~Ca^hi^YC zk&fC4OYKB?eyGsZn0I7&QJni9cmCGMsIV{pH+FY`q=-tq0?#5&LEc(749-b>3I4UN zZSP#KTHAE$O)dAW%KDsBleAmN{6pI6fcd#}zTu;RQVsc^71){(MWcWxcvS^I`~owf zYR3tGQK5hP0+oTF)qh`f!Gd-s|8V+9m^-U7AsLo{T#jBWp3JmA}%lBvH;L{lkFGg{6Wex25_{o;?wi(hMC(}=Ke^Fb6RSHO_9-r zs60WcvFmG+1xA&%k)&o z0NS)P*_^0Spr+1|{#c{S?Jy)Q#dPVe%~~l|Vu4c67QsFCh8Iq+qXe-x5;S@F(0g0) zgfev{;sazQvE2=dUqhysPqY5C#Qee?2jXN)!EvDzkGsj=ME10_b0kM6Ne@<%O@=zczqu5_4;N@pu`X&{{+?-Zf|g9~%s=lANf66dp~S4Id|8T)4v8;}_wNbEZ<6(H&N|Rt z2F?fX+L9Xf8gn0PHeyaVjdiY$3s77)`>YP#45Vpete8S>%V*VtP|*=z!S2tgQlvzd zM}mWkRfV;d-U6g8oTjhHmfM39UNt7~zC&k^YnL2iguFJICC6s;2o=G|jvKDueuEjk zih#}_$4OV8Lw8zng12$ukZfdZ;_-79D=dr*O_HNoYmG?>yYf}|*|d|4edB8`zgU5% zQSF7K@x~XM{P<8<*WSbZy~hJ*SYN1=+ZshRVK}mgX&Qs zU+)AyHqY64FOm2Wjlk}7l#8I3@H4BP8|~7LdgH$|Yza&uj{;6qlzMtV@TX@BA^Nghv zMNZb$*}HzMonAebN!g7v7amivgX*#*WvP zam#|IpAixFg>)Z0KRF{$F{!u@8Y3*W9Ah%8uCUzoW0znTosC(#Oy73EB}VVDBUCQ+ z+(ta2TjTaKYjY(Tmwy}T&(Lw(wA|)jj%^&P9ivsr7>#?JEE+pB_W&fM#6Ly@WlN+} zVRd%+v*q}l1BCnO#CEwC)a5X*b7s8{Tda79*?OvVj>7-7O18y~u#X?Y;acEZxT@$4 zn_arN{tTyL)w|fn2x01jk^UOHTPB_<*4&bkI^zSwTu3yxyp%7H3|P)AFXu&YWpNn3 z4-FL}^CI9o;h4_s)swg@sU=im06n5N#Fd^9jLU{nC4~Q-TnKKM%#)|EQ{1e|ohF>>16#q680FzLXw z;Po`21$IUUAYAQAdi~R+U15<+wi(I%EtLZ*%TBL6leS0$ZkRda!4@eT>}5?|roEEI zJJU_w&hV7HpgG?uqeMZ4iPTChg?`^s?U12ZOf7}Mh(`@vxv|{V1gM7l($Z)KWhZ+` ziQD%?c`?!xpQ&KF1Qg-T;JmBPZ$hzLdc+7urd zhlyb83~iQaQ~{W)B~VMClhN2ILye45v9U`##86#6ugu&_x!6`tS#fa%wS`7S#{%Qs zp3_-E6?MBDchI2#=?!$!8)WE3kt(F(BtN0ateguX^BXjryQ$!WAQ%NO%`h!BBrx=& zXd~bw+!|e`ae~CI<56+J!8jSJzEopAZrPt_aMuQ!t?Es_C9 zndRxa)yi~n*nz>(o$N`S#O9h=3pl`5bn#5J(SbiDb5QQgk*Vu%;~ZK*kUCW5bYS*lac84N*AG4^(l5<2R7;%m?BtjimKQP3NK!kbM{CLmN4(33N9a?W8(#`E-U&__C)hxaR4(g7es z+_*?mB63{cQGCrmPmJBXu1s4T(Hvej#Awg~T9%(JhAp-lOcXzqBl59f0je{sXmv9H z>EifV(u;EmK4Ze=l8^JKkg=I?RHB?{I@8>Fg}&dpI9c9EGuLK#l}bujQXR@~m@pw; zrUr@+dFzhZ1zdON?y|lf8S#qKW#eQNLdIgvl>rG{@zRstQw+Cfv!RkwgM@5Xt^a%{ zKpN?O0z%@S?~toz4*eC3&v04GC0E@$vf}CBhS@KSd-ATs3`!;Au1CufvOBwgK|z=K zXfZNFLjP3fnW>ul*eI#_#WWXkU3zQ?kJ zF4Qi>d?|et!9Be#!||AOI^Qhyy6_@v*NM7l)ePK3yGqjy#Tj75LsuK>itU$)mN%P& ze8Ek%{dk!}JlSwL0xF>AmzW?B;Syk$tH)26h^f(>9maUB1v9gAT$k*ddaZv?}uy&dI!*TQtG zV9FKN(Tpkl{M@YS?OrXSxSQunl5&p5#=*xp{LCtD;xT@l13d(aV!iazIG4jt?h}Wf z1@ir%8qztfeCyo9Vw?FK*>Tyb_=%J2Ic;tpB^l$`Hb1*2MhX=T6T+{@z*_SCW5VWi zrCn{G<+Uk&NWN4)V^CL>I(CZ=|K*LFmwME|z{}IsPEigq{c7H0HE(aqtsG5t|NGCr z^igf5Tu~n}iRxJ9t_*Mt=(81n zXmNhTfq8z{O;)nw$dkd^Qo`vGKoeuG>4rF54p`jcx>qdewILCg>R`@*MohhL~| zPRS2#qTi|3BOVH6I}~i_n%>^LT}JX;48;t*y{+1^XCX|o@uZ7+hAcyyuqDHT>ei+# zBSn-}qQMm;l%HT!X*XGUs;_3v>o%s^ExgQw3y7*W9RWhs%^0VDt-p{+4$ScSC4>^Esz?XgMX?LkPtud4|wa!4NeGLWf`4NK=+` z#vD6!ZyYV3km`VmuukbCV%&5l7OH+gtJqB(6dd#L(SXj0|1^HUlYT%p_!0c@)|!Nc zD|;Q4y0Q@5h5K6_s>y+>iNIH);fi=(vkq$7%Ob)$sFx^u6N6Bwx);M>H<8mr7UZLX zlvDq%s92#|)`ziV_#jveE=i4rZ#<7)VH~77yI)MD(Sy$7ENJJ3FppTTeP5F*QoQFGw(2bJN$ZRq8jndcv#Dlb|2PLY$Ie8Z_=RZREvTtqZ>+2FWHSqoG7XVP>VXg;TxTt+2dem zlghWC0v1%rtO!6VqUy)1Ldg8p@q#(2x80^1C#Oh0a>^xMMDAg2i1xE7gzigtE!~z{ zjX{;68mSL_f$CQu4l!N!m3p^Da9r~$3 z;bnSwuI4R#{`IJ;-~nZKMGDF@cwG|GplXmsRFG;JEa6Y(8CZ(Y3QN6TFtBW8HIQ{F zJKzP_XCmv`OBUHs3QdEkS82X~C46+&O9#TJBj2L%ZYoX%i;o6xxiDl!a^gR%XLHb> zjqP%0VS{phBhurC<*gtWsU}-E=ya4$8b{~4Dixat1rRB0vZ4u9Ut_@RBvSgxiu-6p z=c3>4W*5U3Lya8!HYtwKc-Q5O&;*I7q=g_&i7W3ys+L2ED(+S5z^%qsSHO8DNT^gR zHwM*tKkk$!OAvsrN5{yFNV-e@OnZ2gYL6D-Z_?D&4hoMge212k#kP$QrM0!B>s6Ks z!QY}u2^C(Wl9XNJR#SsSJTpAWad`Hu;#g4pB}+eM*5oJr6GaW9XjfJEzUPIAZ8tNB zY_f+2-?gV89ZnDWpL|5O^PikBGYA5!{sXHW6d!h#r9c0%24+A`*ag z8%bldYv7EWGN%pZZOo3h=+4n#peU42GoLbiNKZb0+_ZDKGbtDmed4#SQHAcardklG zI*vg#=Ppa}YntS20?4teZ6{dvpcuse{)Zbrbs5TmYr0e#ReOe;jk4Nd;Zq;lmvA+8 zX_#J9d3N|s;*hQ!#BgFl_2cje#aRY;{LX0H$eUArvZseAQJ=3Q;k!4kMbHEOrLW-| z2y_E29`#of3~I9a1NBMXG@J_`Yi4mdIGr`SVm(rG<`ng*)%=(G4OHR@VOpO4$Hh92{K#onr^E z{C5(-&B4O<|B9eSyFjZa*)1~_qR-9IqEPZ8iXo6m%gF{6^+O>dvh#3Arv{+YNrxp# zyK{%lF;bGDqyG#pN_sy&d+Yjo%WhcWwOR5yT=fQaT)wpv8z>5h{U(F3h*a-4((hG9 zQ~4qMLuwR}4kj!jBJ$r8e|w9cug^Nt^HJ1ECEfWA|5x${5YCJr{m|=DEwC*I($zs* zcpeE-co4iSi9uaQQymi(11tH3Agq5Jf{w+V17ZdZoWoJO=o@V<+tli}*yaXzfvdYG z`adW*V0mn8bA3JY;1bjn#7Mu4z=_f-1?EmV$q7Tj5gi>k<`&O@l+Op}`uf>sq^Kw; zC}?Skk#NW$YGweUN1px#IAqZ`^s5+gupUhq7bC?Hp~~>MTL{TV%hVo-P@bepSj1SU zDI#1B!f;n!CC7fUIFG-b-wn(1kv1G9jlUplzMxTIJ_(V*umV3zH*(K`Au}u6qbxjx zNBfBVUio!yUg>!H{am;TmMeo8C|k)z?gd@KMU|7DyuEP8XggR zu1-V8NPX{U4{Ob1?Qsi!r*rn3sL&2(n;L}=cXcKG;LJt9j}6Yv?ZDZeKHxKUB-YOD zVZ_9b6#meG+&M&K9V)o$Amvp5G@Q~e`g%T(s|hG7D=TYELJa6c0SN3o#sQI{Itfvf|<+cUztGRMf4-yu z5Py1XPIjl#BcYzZNZX6cifG>7!9TuA-ma3q2*&+2Ui{HNdZ<;M`wjhuU%nvTNgUHK z@b?~I9jElTmz}YW|4uape1OVmZ<$Z%c38r`Vys&Grke7?n)=_5aA%pUEtM!lQ7#Z# zz9O0YU!witk%ETE9vqmCfw|aVh*(%3wJUAye`AhvQBs{1KaokN2k)*@Dztf!Z{*C3 z6I8(vV}E(ZN93r<$g84X2j+~U1>V0;8iSGj9Bj)e1v?slfuJGGxnGW!m4QGV1lII0 z(1I1*$5J8*CwdH?{pet{z$K57kZ^5FvCV{8( zv)r%$CI};wCunC7W^R-;G^SU}CIahfg}EUx+MZE>r|atv#mtQ{QJF*{_eb}-t8AD2 z8VNCIQGkBy!2kRk0dN6G7e7b#eUt=Th|A9uFO7XH(?31L4&Vfhm;{+VG z43+4TtkaEM9^qE$y_8FGZ1#y8zaq*yGkdkhD9ci6Vj;waT+ThxIQ@)ZmA5f3kg1KE z!s88DGmURQ=4Q@i^N_-d?*0Qy@50kwa~2*#-6YhjhqSt<1+X@N2g;EEhWcNILBYTlfXh^tu47+YLCBH#PY2Yd@9TH<8H zyP=(U_*O+U8<4!qwa$1FbSGFE7Is(HI@Bq3@k6>riIh>9iuBqkaA3TXQR7F4RSE1{ zGM)2=nZ7IYW^v!fozoYH!{6-p{+9flkvz7uiT%Z=J_sEoZI6|#U}+uLdNN}QM9q_Xv$!N)9U&Kax4$w*8cbqBnWlO@N?o`eyZIBq63e-}y;FW-kWIB000aVv@d@ zTb4<#G0bWTjIc&FXEY}`4wnHfb%tNVmAfJ1esAAe8U%2Ix^N!Mn4?@VxE+*ZrXM2t z2}*u>FCDR)wy_ILTkI$y7sRutMkZy*r!2hkWaxo=G4K02Np#VQVN%ST#`fqwbEvu% z1lJJcz#A(UjEu)EvEY58fz$REBDl$63 zERjP!{H5U4+}^6#ojb)~J?axNN2SyY%pmN++{X1dx=1G(T`2v0I8G|iq?;Ke$V2@k z?k=Z{`Ez7fR&N-AA2{`UA}Fu(*XpQYS&lBdf(S z*9qCNPU&hyou3WNUN#f-cG#5`(}b>bCmG6?j;c%Xpl43%Q~|;L&CkFxJJ~~F_--dX zJc75CBEOo)YQaU8zPGI+*oVBKnXi9(`S;pFzI3BsPMazjMDQgIqc`%x4U|e303VY%*~(ZAj}@?>yzpV6?t`%KU&= zDovkhbLVyE`k8`3X+mDxqO&Vk@JI*hkUO^JANnCxOe-N=u9HJ*f1pUJ<0RJZ{DD3 zaVV;%pPozpNs5fM2T^W{ja<}8kI8vRo-FsbNJ0v`dE|yXZ%CQ?L&c$=i-@h#A?6j`_u0H7u z7;*G_jUEPyYq;Ngm?dWvb{UVpSt8{^fJO-ha{FCKj^Q(*p{Uw&94(D$HE9fot-q~c zx9!XvE$Y|V#^McZTR_L?xZ~S|w?IfJAr7twvXw0TSRLU4Oim`3;nj)5{7Mo)x*?j0 z;S{+=ZVmrl{K~-1hqkCv{A2pBF1yID3o*yW3XrsNGPFkXJoim9}Bu6M;X?~T39C!3SD za)xRswG8fNju3`yX;_{Wj`Y~#G_Nflwt30e@6cloXeSAfPwJ9u3>nP87V2vsk~lF1b^& za*7A-wV97yP}!pa@8(P=sXCKaqfGXM4BWQ<@NX`gXUM1r4P8WUry}id0)dqvarM5H zl>v4^hC!Q~0rq*bYCT13sNlhm@k9(s!M4WI3Kp)3Zf>4PkBpC@umZk36az^;z#}75 z8u#^p+@NadZAAXW#VF&)aI{Ie$3l%)%tLr_k*Np&Qy;9mSL94bP%^~*IHC>^v7vgE z?&G(sj07Kp`EcKIt(i#s0z(k}*F};+>Kg>epS3taa%YBYz?&=Uf&Bl=%)qaBYte1TGWWL4H+vxd`7T<{cN za~fb7S-zW0**5T35+r9Qgz}?uSaCYnlw3Qd68}{$e(oDz_NsH14ZG|H?>~0kFP%6d zn(}+bH{gK61_Rmo;oL7s99tV4UpOJG7AaxFPVtxkO2A zg1)+4=fV^A2N!DzD)tmVdjQ1_r9pLd73(qK0ToLWT9JI2=d-&V8Rbhsb@K=Pr0&CO zEuVW}0X0cA;a_4fR%1Si=(PbXm>r;>Iq$avJ1_SDWd0^z9i{W14vs)x?vQYy7%5H>BZo3YNA znAnlhX3?DHD&Wh{j>X}f6~qQU>bFuhc(#<{rh=tgur|*J15=SaAjwkA>)>rOWEX8) ze#_;t(@Myfj(&X)RAQwrp{ zrXNEDm2QEv6#KTP`L8~y-U_JkeF9>utDHX+iW)?ufUew&C|{oGNf1A!PP%gUFNw7c zJ94yeF5IT{!VJjsy@l5Kxru#zlaI14e$r6o zV=Bhg8H;ZiPD48xK|5wFK`WgEU#V_XF= zRko33KC<8s!@Ov~qJLl3^H#<`{OTiO5 zv|7-RG*?y{+QGMem;h9tIQQESyoLQ(ev#*vxw-7E-%IBUGJ0NON#`|Z;Ii#)7|^;U z*Ib_H0+D*tWhE&OL_C>8_P=v&0{SGwk2t97?{3VRE5=W#G)ZSp(Gsi0baxDE92m1Q zX!^LYhg83!U#ghxU?}tLH?@wRgSRc(x`1vONfhO$M^RX~=-ZWYwDE8pI5{%6*3zJqD?lflp+l^N{5$G z5-OvUIxMr@`JIC$&!bl5PYl>cLySu%j*rNEEBPjbhP5e`00Np3e8?|$ap(kGpcjpg zA#<0fKDC;$L-IxaQ$*CcC~z>VUx~W&%^+gSo`XB&J<$by9c=m{6go2~bh&Hoq6suV z(uvS_n+ubAi7cy%M6mJmIdADcx#tZV;H4wePWAXfg>#JsF!TPx7``$`Q$6fV*W zl2tlTy+~*dgE9)9Y;M8idN1`UF}-IgM__M@3*{xb*F5K55v?2a%c*m%mWl`7xF&Z*DNwPeM~yU0c8sRnf@?ZG$1)ZGJL82%8>rL~tp$bWFG*x;D%8gB8yT0pHU<`kri|MZ0a4#CK z9q{qYm4`C6iV8@az|}BhB~V_Zzdb_<*l%a=pu!uG0eiOAN44zy+Ul#fVTNpe|Ho49s-YdCxVUJ~Li~o;iE! zfh!sG*(A1R#pLcwrcT#JIpPOZ`TXaWfyjR0+OVMj-F@z}O>bM|WVQUZ;#xevsUAaEB1anxRR6}nX+lQr02#lF;dOXL{# zG`2OanWPzW!;Vq^L)Mn-ujW^Q7o=p#jUx1^bTFmHs+&RIx~S zag`19b4UMK?YJws+XT4XM0V$VXQwmAcWXX?rn$i2Jvp}c zNwq<}A4Hz(yc7(AqEeT#0#~So9?5>J#QEh#1C2~Mb7GELHSHi!;6yadZa{PPLSi|+ z{1rW^OB)4AUo>NmW2LIdh~?F@QMFXuQqNxcF9v5@gf{lgY!Sv?q>#|$*)7||F~$#X zL>6C!80#mQwi2CtX|DMjDq*af&IuNt(oKv+M+6tJn6< z6&27UTahHbW!KI+?i8FO5EgIC41WpiQ>)u3@(~cOh4k*`MSg6QOb^Td3in4muX`rE+!T31hCn^Ah1nLEw30?O5JCKZcanp_kurrTWR3w5X`;5qAJxH{kQJ)ad+@24%O}KfcZIE)- zoO&x!V}R0|o2>w-Rk5aSDp}au7luXlzsx;gRi0Q(j7Z`M8hhvzT7aY{SblRH7`SKH zW`)#%=`$N#mI_NfNPzR_>mM_i$m zYknnkq9}S^s3oVWg9ir6#_JG##_aH-j1T8dmn{Ty{o}hPhWwD6u31nxDaOLABF;yU zNc1Z2gs>k-XhOe1`sOnmg~k4iLO|A4;O@MnK#QW=B-Bu7?l?Uk($B%SWC82I1Bu zvIt-J(dS$Zg7yxkK~PTvmx{|6Fp%*U8>ExG5ZJ5Pp0Dq+m$_JnS;98ucA=@bcCxJa zjeZ$^Zd$VO)zzQ?9#rMs)0#*8D?`Zi6Z7Dv^U^Pi$hCCfa7OS&d+F{vI$sgm;gIYg z;`xZT+N(bviKVtwZ)c>4eO@2~U*v1_hEICsj-$gc1nSYPr_2Ue4(a8@R%_D3F?MBN zC~jdRB}T-POsP6N}wF18MHY}&7Q-tYPM?)vGWSg~U_ zvWrUW?O&9{IYzbb0+f{RclEQfn4W|2tiU2&lkuNE2@2A}F|LaCSrzkg7qw2Sr1Q+l z)DS|#R~|yG8ACX9PFaku zJ=o(j6O8>MiOt|C8r}%3nLlNkyeR$crKlz1AOQlC?K$ z%B+SJ5(QB8J}jK$1d8@J^~cxVnpm$KDqX<{~&~G z)4`_LN*IHV3k+Hbo`lw4`^Oq=chbKWF&*|}H==6izZ;I46n0nV)GVC1OSO>~W~OJv zX2qXM>0x1Ck8AMRt6E#c!%D65V*fpi^fVJYZ_;a8?@Zp_U(;-;H3>_OaJHwC3s>BG zvSyHeht~lrVM|_SIr4lC1W?gN$>zObya4Upw_kl4-p1@beB~S+jYkS}lKL)3Q?XQ3 zXj);4Kh0!GbA28kZe9M0@LqFD{?3`~zx4+*-Pca|KLD)%Ak+Vid&==&)KkF!oqKAh zp#a)t!R$QJ@<2&mgB)~|hQJc7zaw>AvD2tnG$3W&l#a_oExPCd#sYt)+M(p#+&y~^ z5l?Kkq)v)!TujOLNlh6{wspA_rx$Ivl>WVBvKb$r<@i7`p;L=)IHG=>YdRRZKNr-u zI4ij%Ves5c`Xy&3xwK4Sw{i2gT-n4U^WL9 z8zeZ@#aolYvpF`%$to2!-k8ZNw1mSbz%AO zwL*-P>34E7=K02hN42RPS5sd-@zThs&|v)31msW$fq~ zL8B2Ng{@J0h{hq(4m>fxq;CVeuWvUD0ULH)TRV$J>o<=!Rhqmi$1a2brdQdZD^8`2 zdfbGR#KDyvx8>0e#5fPW+^C76j4RDwQX?dO@+?THMo8Eg_zuDTDSJj2SyFu^Hnibq z!>rdEh`otewWvG)XY$h4>Okr&ShQURDE^g1`2b4Cd?g+fz3G5#*mS;_I{>>SmJ1TX zF9!4q`oFx@u7pR?7BOP(as81FTjEe(KYg%blyX#uN5jbjM}MtrA+*~arzX^}LMp=b zyGsjT@sK_s_QIb;aomfGK{-&NIg&XPWW9@usmC$jNAcd|la7`l`-#3I`l8RBT&gCx!*XFVfM*s{3lpDk}3UHbmuwOHl4`ilcRch zmxPd8s{YDf+;EoN2JC(--m~kI^YVQhlUrWJnH6Zc%V|C8~#F$ z%8C5T>}6kJ{C{v7&i}<}l$}7Pt|tHZ*)$HO=IUnJ|9IUTEKF=%v%{|MSHpnoO* z#Q&YO0@;iIqj3Xh#QE4**tl4D*jZS)*m*g58Cf`}Sy-t5)l&eO{@<#oI~h4Rn3?|L zgd5p9n;|eOt4nAzNxItF8XMW$|3?>fODkuz&zc36*D<@|c0N4K?kio&l^FQM;{vW0lGgWxt=snoQSwazf0vWuMp6%qWX4*kRm!2tJzIHSyRM8YLNMeUS z%+kVO7KGYh{0Lx5{Nbd5EYX0VG!qbP zsLL2xe^RT)cgDLNM1=r&G_!GO2UIdWg!pDCBg854@T>0jTd07tU%d;3=a{E`KP{XU z)5#;U`=%}2^}nBBZuL^bF{;2-X$s557dYgKb9h;V)@UN*2d^Xvx165mWrrL1gSni4 zMV0sm9EL>LF90{oPx(Ls>WQIcLu0y-S-`-uXP(tmzRA>v}-QK$qQR@og*hO?hD>_1DK_{AFGW1L#~ z*!B9{R3^f1R>yvbhzMI=EbKA+OhnDReTf+zvp&vwa0||GPFjg@lUP6(5AhB$ZT;O9 zg>(0EP&-bHn$gqYeEGQ40bO1#TdoDF5}fgK51{39-||Yse^k5MgFdztve$QxRNVWK z7sH;c-^YIRI8*OS5^dj4iDJAAJ=$52&c@|a-;JEPeL&hYjR*W6yy$;D_TYb7khZFs zIRdkcy{VZ8K$iu;%B_#UtY+n9_AiCNtOd|z1+W2F|H)KAAeVn(K>sXI^*`0kK>*hO zxa5B_;s9NK305&N4lx!99u_ekQBE#45m5;iaY;6DE=hI~9&R>vLBRjL%D-Oz>nH{; zmj5!_{|CD@F*JOh9{AG>H83GO0WlCIJn?7b&oo%kD&9p*fF&}(+$?Dks%{mxx?Pxq sy70meMp8->1}sqm>i^pp%?`SARDy0Ph#5LjV8( literal 0 HcmV?d00001 diff --git a/docs/_static/overlap_geom.png b/docs/_static/overlap_geom.png new file mode 100644 index 0000000000000000000000000000000000000000..cb7f19122b46dc0f9f71e0e4d62b14a879b0c8ec GIT binary patch literal 77730 zcmb4qWmp_d(=NKWyIX+Z8r&gBu!P{2C3tXm_u#=Dg1fuBEJ1_AqKmsbhdi%6-+R9E zNC^R`)DHSLv80FXUDI(x?Pt@nT^Ll_Y6;~98 zf~t;2c{G53J*PC3RZ)b3a;JlW@(qN7x__qEc&Ck@PNBL~#$9*Xnz zZxUh-1@}+-R|$V@M*lqj>!@hpXlrTXXleeH(%IPF!Q950ifaQsHuk1$P*AYh(ErgV8|Gj9VU)9B|5b)M{Uhln0H*)-fMhGHtNvxvHk4rlNv?p^X)*fsxHuV^&uy+dn8MAy6l(B=My}7O9YtK;r;cM{K z#>r8bn);8Re{cWL)7aJgKa#8+{%O{$foy+T*f?0(+5R_}qq)id1NNuo{|S5Tqko(A zKZLm&*!~0bS7-b~N1;C&2z)emHMZ1}GPg3e{&S^8IJwz{{?hILYWa_Ke?w~i2g$+D z`*-BuTK*d;X=7<)|Jl~S&{%}ypOC**{f+vMu>vZ_4mOrfe>z*u+T2luQ;6+cVZZ}hKMMnKZu*uc@o zUe(6NQsn>p9us2wZx;XLF2wd{2>xwI{$srVRr@;NMUY>S|GIfZkja5oI#5tzP;ye@ zs;+f;k(3SO>B4+ zWX89Ody3yL!5)<|l`nTkt^6Git|u!VE+>quJ*|~TW5;7-hhwiBK7XmWKPHf}OU%~~ z3Kkjwg9=B8$c~8v_&$Kk6pH)b4QuR}h|17Zf6@G>ZKF$!QmEgrjPl$6U;?DX%!DC+ z<@O&+7}P#LKQY(uuv+53|0eDa0i_T;_y3@TBMgOw^*hBysPQlQw_^WbCFY83_TMTa z0ASV`(2d|f!T!U9e+hl%F!4W)15%=+;zrY0W4=q`u-zUdN-~`M=@*d(D#EA%g%Ga2 zVGvX-k&UJ9VMBxlu&ScMJ;pS$e32rdg{?k_q>|(qSg2bM75S+p(f0tNJ zml)q7#!baXRh}$$YEUXY@d(9ZM%s(VDQS;bnN){CFMvV6t?75U4zHM=NWU1L$SMB2 zH6%8ko>dZbn)Q)e$V84Lr|}3b!>6Bty6$`VDlLxYg<;?0Sv{@0mzMi{>&tn^v)kL| zLtntR>z8}eHD;64ywY{nEB9@~?;m3VaL<60pq|fNP-ofvxN`#7wx+0SAzx2+#*Bh zl+yXAM4!*1Aq`8`C;(KppXbBER%SIGs5&} z^1rmZ*OR=tK3Qcun5&G&WpT|4Ar^6Q%cX(G^`V_c zrrY>U4{;Z?=spp~st)m~guqk?%C+~e)ORWsy8OJ|`i<6lO-0?UqlGA}!8{1_Z!g8($eG6bBqZqGI=%D>|=ZFfvs&y;E; zsh4ZZg`kt=DWq^#NM24Uk*iY~XpvaKPMl(+^PO3WRgGmG%$Dmwd|n>1m~|RP&3{yM z-0!0b89w%6uVjk{Yy}bM+k%|uzWB8F*7CmC-T_YRF<`;hrsp9hfzMHX8MJdB5*X#e z@mWYkFZXBUQ@PE5cm#p^(<3^DvAv_Ea@Rl<2ttv>?>;ymFEgA<mWK9I8EWDpc%wrRFHms4JG zy`>f+=FpjG8wW!hZVknr-|b`x2LHrqetCXaDeER#1=_xs4Z^DS_>MbBBHA=ghDt~= zn)*(@#c}V4d4bESSEJC)vcr$~cwDuvA>5B5;Xv*%p7n6H4%@|Srph)I0hi-+KYfYjDDi;pS+T-|vMy-qA#h>*UTAh#f0fFSg?oB(DozIJUVLJ2vGhyh@ zUtaE$bS$1vdofmO@?8qV+uclnKz!&iS82?z3(y8AYD};U0b+S#-s~SK`QG<@1h+R{ z7kD8i={cvgKEK|sNy;L3QrY1l6yEdghSImQIyS?n>%A*n=8=iZ;S#3^9WN^<-aFi= zKKIjE={#ZXQ|q5KjyAz;==Fy38!yoRK zoOEPHN_@B09bj#n{W>y^>=%>x9k!cPydTd7{RJ|_gKpP}g-lE1E+(-2cQ3UP#re*$ z%V$!c{TDRu&LR0Ws~r_Ien?$t0dL7rZr13hB6>iUL0HlJt1A3iuvRjB_FJK?uaAvY zmgzIwqxv}k#SsJw&$SK~-KGhoMLN{hq@XQ~09Y^B%Q0*;p|9O$1d=uYr9g_rJgpy; z8sbi{PCY=v4=_9kLc!p<|xs`fMghvh-vD+9zqv*{Go@pS&r6|KhtZjc0x zbT|J-)y7rt)(7hoWF0|jIPs--7PF3H@??He9)Wr^t&<-i!D}H7f;yhgh3GbNj*YWO%i*5u8T)4N+y^q(8 zop=q3Q$=*|bQb+R-vJ6QI(ITX(jx)H2$k7pcFAEhMm>Zy(h)Idn}dQT_s=(-Y|$e3 zMZMuzf^%l0pJMEsbK+Namn(j^S}xQm#eL<=&M5zNq-W4v!!1rx1?+~oo2m4sMI+&H zRO9lNRa8ubB| z9HK+^xH)#3=@CI|RT_Y?X*EC@+L~lSBmf9$k`caGcifq1HQVP?qUMm*guS!FEK6o* zUl6kh3`X{*MAvRzeR;l7x-gQr8^Bmw2$um89XDf09Dk)OFcu`9A%2zGWlwgEM);!D zg@NLCJ3x9}UZtBt%kCi&Lro~IV=6YB?I2D;;E@Rg1J?kw^;iePN2T}4WBJmPRoe3d# zf4jmnucOgXixm2tr6_J@tyNP%ks|ETz_ll4`_&l1yBi@Zh1bdq&i0PMW&&mK0h@5?Pu*OjBPpKj zhBmWhDVrn#;zF&ww_ulLgx3cn@F=nrX|X}C)wu#{od;KI*i6voVd0_2_G%Us=yM{N z`-SeanHkaN6j`6wOA&R=)^Yna1TZl7^0*^Txwe%V-dLn~w_SL$^JpS7sLzoR{*u77y(r zkLnKe&4!Am6v9medcjM+3pU)7^Q6y$L zFmbNMIENa^Bu5K4j-_-Y#BhR+a55;?ODj9LELO7DV=eu%>$ly>aA^q>;~UjRuyIuE?CL{d zfv-~*YmyQ~X}=(2VF6_|aZtw00$>tDysvAshH0XOet_wNbhcr~6N4|shxk#GtBmR* zojJ7MS{@l(b(=kp`#jg`ge^4LIDH0C`oToUI!en9)l~}+8 z33u2krzJ%(TTiYcVg$InV*o{Zsq6H4LfZiNc<|+A(foKm9tJ#WGP>4{a!O8IsFWeV zpZ>G{YtH}>-g6Cm4Z$B`#l8#@x{aH=+mT8r7v5{F@(LP5B9tOw(eyaY^zayWFhHy; zog{M%%?`Lm68{e5JD;5~o9ck>^T(Uo=3yRn0|U7q z;C~>o(q{Me-4-K)$b8ZBB>ujU(ZUE`jpm(k%3?m5C|1qjRU#Ab35tMdU!5g_#AF1f zWwuxhG65za#``X%an1G&c|$P$>y#arBv2jG!gnIF8`Vd5&vrg)vDL+fcNb=SqZ>C* zQZ0NUu&e)A+PSXE0f~gz*^%&~S^=(hBPJ3eMx*dRZlQ&PHGU3I*Wbzt6)=JiX3+yS z_FBe{MfhgRXGbE!lhLbt^SrNmygmo9waWFEH-h)?5poSQ77%?Ds?NNnce%UcYFkts zkzfpPT^m&Wf?*d;=NSF*6T=nfieoLyq^JCKta8%g<{Y+OMM zw{Fk`y8fTdpwl|#;^>-1!qITdXwLkP`Wshzah9hm;DskDCf;5dM0Bwr)R`DcF+T$9 z3^Z(Elyb~nVK(j5U3WE@*;;E39*!DUoq0Y*DEizzIGkVZj&IG)t-cXxaHV4 zj!cKb!7&Rkt47|exMUruDr(wdA$L>koA@i2&2VgsTLcLs1pA|wjk34hR=Wb`GLLpK z2ocN48TEma=wmf7hQkSdqd+fs?$4|vNQM|##(W1%EKS)gZ4N_ zLBWA5&e5XJO*rgkBycvU5-eUFMGE*R21g2d-LQ@_E7_(G_(*j(g2!kR>e+HVx%S+d zrv--m7%rHIipi*yeP`(4`(HNRnqD&@Sl0FuB#TS7NnCH z?Qx9nB{@(xE(e%jjvjLWTw(lSQ`L3rvtxgjhlc!mE67|OX&m5d#aUJT=H^4je0oGd z5zQh6U26l0U}m~z^{c@XxFAAWq3-VmH3!E^kp6 ztF)9!i!#y2(~l%E)2_DeYs(d{irrtgF-ye>MD3Uek_tGhjwCX&yjQzr4y7tN?Ndli zfhHsE!6w5EfEu4?ChVTaTMy%77SC~(G3+TDPcEgTeyfsFJ{H@t83uy^N}^4yOQ+f@>;s zq-@sOF55D`jBv&?Ksut-i84nxTtd9P|H>}oA?(QxaTQwv~}J6<8|M zu61kEUJ9FZs-xJ;Q%nMtH5z;-hFvKd0AGWexBDH z1NxeLln^si8Km3{*<>^PnaPqx!)PROeiw4y3f7QsXWU0rMOgS+Qv8;=dl6UC`_|8w z5(R^uF4+yn3*R572l`P`M|06X3dQ2U^}yh2FavE6he{}?x;6p617{6hRP^>jpltDI z_4$aw&2E-^Pp37Ll%HtIJ&EDd6w<+i8t~Jd+=tyaI|t*UKl~bB#DY66zqOd~a@{^Z zZg|c1%dyB{@t4R4D@Qy@c{}eVsFd2P_-%!RE~8K-f50QSfP>U$+i;akNC+)GyP>-oXoCf}q+0=2m^nSaWYe3_) z`h}c?<{#$;3iEUzq3dD2GVm08`#k2-5jO@KL1JdGM}V1*hzOW<(MsEPPQl5@nt>JS zn{G&q5`iTb+m))SGxi=q@@CO*vX>m+(o&*FW=Z40krU2_QL$rC&ntRR)MWoWpzQet zeQ)0O@sfeR!c${!%3GyV`j_pR{o%?27gdVE^MKR&WeXmsh1ZZY`q5`;bLzqGG3;F_ ztbAOUwLzJ*)B*w~E~txe77DGL2hu^&TM=ssb36c~-X91tGcy;A`{n&IC=Q#Eye(sC z85%{^RL*GzGVnhs!Vm&%`<0Nd_$=1vy`Vx&1(;1(Ntwg4@GJ^Pf%F@#PWVN~XP^8F zekkGQ__q)g0Ih=6k^F{t(;K!;o5VJ|(K)9(v>x#2bTuat zjCS|)?X{*8Ra$Gv-&S;?Z2P}=Et{ZQOFp_XTkyF9eQC)TtgAt6JPlh2U#y9rlyD7& zzhH44`p{K?mjvJR78pjfQxm9p*L}W{E9h-J07H~3?@;rew>ZAy?aRYctxArro7-LP zjq&)pq{^qIpM9|rgW<;cqi1Te>*tP3m*I|EpMnX<$e|! zi6&?~X}dnb+vuNQ@K_Uc?(;=CJ_;|+Xxp#-9HgE!bfjlrN!qOT1%zOgHJ3OIMwlBS zWM4FX4-<*gdW3i_Vn1@xX*o4~(DC$;ZgO&It_~-q-DtK)?cD4YGkX6)BT(BBJB3rn z`tIzB^Y(;od!#0VMNL_+S<0Kku+8zKcXESIw2+;h29c{=67$T}6jpx&bbZZleQ?G58tN^J@4EGU zUh0*I^#{CGjs;|E9jlW33aV!e&{#F|#A}C483pSueGXCCQD2|#B;*#x zh#w}T>q!HMQZu+Aah4`TSb8|b)?wc3O<+oNY{namMtO0tPROm=j+6Bqkdy~|vScJh zS8;8ON_&c~x4dZ-Fk4(0>GhIbk9%;?>c!AVWab3Si0u9#Cw}WJ1yAMkl@gXLNHqit z<(r*VjaeJeu`5>b6z;KWlIdE6x=Z4^dml72j$t+|(W3`om3(JGd4K1WGPyk3*h zdh8wv!QyW{p6ATeX*x^FXBY8Eg6UZo1q)2`T!$ylE++6<`c`odq#ZVRZiLY<4+M!m zu49b3y|p_Myx}J*6Vk1>Ws?t!dgeNpw1b3reWQOEsH>d1qhuQ)tXQ4|;~}mOhsG>eIGa`h z!eMpKg2%eZ!(!UeLRTaI_~uvT`gj5Th#1>lrbw*BgbMaFn!>i|vcjh{5Ec#Vgzm+@ zXvx!F!Hb8>tvKb8CHFum$kpJl$Qt|sp$LL5Q+2!jd^?kYTgTp5s_uthr>2gBto)DH zRb*ruuwdVq(Q8NDqzQ1}uSg)I-xT+%%j$zZT=2r@MYblMGrX?AyoCb|5L?oCQc&7l zE1|mcm&-K{X;eZze}~O*!njO=UyJ^7P(s~+WZ6gKJ5KbqY&9p}^ZFO>9`!rcSxH!%S|Z!xshEvp`> zixQk>Th#1Vd$el4J>Y9#Z^n@_t2c-fOcQP3ECl}ufD&U3l&6n?k_>S8-rgQfZ!y)Q ziOKFQ%a=iBfYAA7n=81DS(DsMQQr-MCw}$aw=dCj0~RAE%xV^u&=p;VR{pey!!@i$ zyZN*=XtVRxxz$;th2h<2iVn%qdD_aJHH>_uWb45MbCA|(m#feJHW=Y)Q>nD4WBSnlr zfx7*1d#kb`EWa?P=aTV|;t`epQ@#`-%E0F={L7Gnldgc{E&Cq0KJ9mrRxdwj^f)_} zh!ssk=lVDiW9L^qIvTMtySFg{IdPHdir>xos9cW$kxVpcqWtI77Kk7qBE3i1#F%Yp zwfrar(?JT`KjQA^IwQUtj^sstascr*gae)`%npXaWE+=2#GhjA z^Oy%bKGoo&_Fdd3RH2AeKK<=dEjjsjL*VT3jQ!t97WbDRyg9f5j02aW7&iRzxbOp7 zF5A4hr6XB2T?$q5+nusu6$LW0MAgn8dI=P5hDc2#(NwE!O_D(NLDMX+ZA7BNfOPfo znPfWkKI|;tNbJlkyZHgAKpQmDAMgETB&p-YB6K5nkG|)A5PTAzt$9OD?oT0-p`xOq zn_(NZ(C%?lrH~o=h#Ks~&eyjE^|1~WHIomz9(`bgTGPK4k4e1=9j%)IQESk5@+}$1 zqEMj5vIOPOMt379bqa~GJ?rkz`=bhRE0 zX`BJJSRmboFzj2WX4O5r1MRDO5sQ{OYaH)2c`0uqpxKxA$u;gN%Z)}Ax|5I8a>e@c z(U}vQCcg)U8?b+Ax2oV59w(_on1%!OmW@Y-!~cC2~b7;r!6Rr5rff)L=>Y!j?v##A`!SA6L?ptJ!9poby<9ekyMM zrMkwm!znF>q*;1l%O&O^mm>e(<2-VbYBEADo5MjsQN8uV^)J)XDcMG1!Pze$*zB&+nMarVbC-fXrVV!L7Sp!#kRI4I=K}6LGJX(XE-Xf}QJ~f3EhB2G9iZVfo{bFk=pqxJuUsDhu8l zMNRY!)4Gv7;jDU`gscZ8C3vt=Xl9J>Hr)+WVHo!(E9V*gYEgk~nQOVeQL{dBXnvDW znf-`){vMyT^AMT!6!vN*&l*Yp6AQEU?8v?30~`i%rb}sO;TJ_>+JoOg;&v?Kd@Nty zTY>aPFsNwG9a2kdA)_FdJMYE}ESOr0s2(7l?SgSqbMP?h2Ifc&Cr%Zo+XcqW*n@EE zO##e1zAXeh?12cP%{qHWd}fa4SC?(l)|OErUKL*=Iv?DN#{)TN#>9ac1bl-*Ln&rA z#1xPels*s!amdl19PmEvMo{u?d5!<+A!OpE>kubqY9*Tdz*M|#xLsQ@>s|%)Rmbf5 z!88F@fe#=K(=!P-lV`^TwXHH;wcO0djq?ND!XuW}1h!TU8!eGkLA~c(nQCrU9sOAf zVdhFbr#Oe;=8H9Nmp7oy-vKq2OC~dbKyIfkuMckL8~4Km5vzrV8-gnC=(O8wj&Njk zYltUW<~H)ZMr1jtufDXCr#l(k8y}y@ky|o%` z8b{~rlnOFL7%EpBOPA*kJ|OVS);xePj}}la^z<^leSUEk>$H>|szL8TENl`>AWS0_ z0sC)0W59tMd@7k2+qxA=edQYcKF-zKIWTB^SW;d!##PIOq_?h~x1YiZv_;0gy(Cm< zH31~K;?D^jj!qfvv>KwrV@5HcvT|9P2oMf+oc5rMd84eK%ZT2`;(RS@!xybJ4NqE_ zK?#wJs>To_8Tvsg_~E0A!*_uUbUUO(I$ql(tvi%^mtI;8lR+~TE&JLVt>P@v@|OjS zxD&X=X^)f09Rjnq)s1#~3{Xhj00FA?YXr+-Eg3b(?L7*+$rZMnRkx-2t6!(=_rjsP zS7j2u)4oi)6|7)sojGwiTC2;42W4>VH-Tbv&7bj}%{GN?v(GB#$*O85`(0OkGppaV zt;%!IaqpapLbWeFFRzQLXb7g$1&U+%LHQ{>R*OwITPeoXs=*Xw+)9WXo*0dJ=ImOn zrp2^^ru3iK0(Qzbw}#^~&~UX;EKQF)9;{7Ia9JyO^=v6906ptm%dNNB!Hd7w2(3&3 z0k?4BCqCP0-CH6|RJ!iqoUrG|i}4j{B+D`pHN|C_Z(^%$?@_eCRV~bK^%PXTC&VBz z3O&_We;0E5MOk>p;p(i{;Z(~!-3=MI*3&)P!260i*5Kt~9Mr>5KBxrT2`nFmhSc9A z{z{?^K_3!)viV_Be=vfiH^ww}UVuRKeg>ZwGhGNVY;*SXL=pQq*?u%hViTs#u)uE%72QNnHpU!8p->Crdn6M&?KH`;cZ9_2R952M=MRG*E*GgoFs+ zkRF5RX&l7RlYhn~>pWuO1n%%^E#+b~Gx_}*BykqppKrfj3&0qWTEPz&>mNg}Q{>y- zl3^!QN1ukO@{ac7J%-gBJb8`FE|Udx*9pKbC5mWizh4Rj29v3qNGAfAng*hvEp)h< z3DP2Tn=L-$-MaPqX4}dY52c0a~57BS^O+9XJuaDfbo}K`zUS2p9=+ATGoR} zNUfeAY(92%(NIA-d?BCaCL-U+Z;!wQyzNH_idTcWQ2fwRPL#S+Nf#Y!Rm!KC)vHJYxfyw56 zO+)|?A);wNFdIf|y0kzfY`py?QiL-)g(FxrL-@0FBDNvg?_VSeQ0r@}4H(NbR%*Fn zYm#*;j8az}7fXASIkqaf@QivY^&+JjL%BySt;6r)Ou1E?FuDeRARVcXt;=r@BMW!6 zSZtcKq^obVoxKr`L*(tsIYcW_cM-Lzb32$D0_crZ5)M^Wn5mj>y&hYx)y(yQ36gP?kn%xhhql+d=h-iZSQm?@> zW$7tatrZFwhfy`0F68*_j?PB8#+#6!^b^+6*ve%_BI~4;CnE9_6F4(!b%)b zrn_b-f?JAQwB>nrhCV9ly{(M;4s?yLX9C3IbPBX=GYBAIzd8{9rneMNN z7wMEe#Dd<5^YBB*^xQ^pH2$*25J6EHBljzS$w%gHs(H$-2`tYY!PQtlScH~*b`uS= z6rjqfk-Tl!1_3MkfdMbxHIyTJUYIF9E_y+GKn@aOL$uI&D3|8o4qms8i~yE}#tp|U z4gnydpvrDD#P|DJR3ckrKs}9w5G&4v$n$H)nF9>k;z!Rd%HJHos%l>#BwAIyLsGtr zvxD88j)D&HXt6#H35SkPgZ9?pgF4lB$hwW!fsPVaWLgkIT%j!Oin>z=By=AIR947?Qo)B)F#j2qRjvd+aQZ76}%X=4z9bCob2*@fM*vzj}f;c6Limwo2 z&dW(@Zw$s|@m8Wdfp?M6gc=erMfoiAUq+9_w9I7gXB%gTPN(waR|x$YC>jwEo#*Ll zx_d`VA<^|^1?y~TC3&(zBPv>hA#Y~PX4S3s+PplB7S}M0?~8Jd1w1YU3e^P4A;=I1 zb-uh*G10^ErCWoosXG;I^V*J{C)uPqrF4Omj!Ei7d-pqN{fqNn38!HW^B3~s!dERP zT+IWKN~upJnNuKk>7K2Yrm&pyPN;oNjKES4^^7c9v5Z9ZNz*nsg)l zh{;d{W*{~tx5QF|6(mu|+HT2+h!SaSy`;3l{^qee3kL>skvwf!^ZruSy;tzO*A`RA z`+S(b;*i-(lZ-ioBVO2JT{Goq|H@7S)j#E(wlH^1lD>Pf z13VT*USB_t0m3>d%UfvjApOZi2}AwV(D>R(M0sShD%&96hVN12Eq=}miv4dO>md}* zbr?@H3LMRplv1?x^sVA0E+^n)GI?xocb-NVP^0w^DiRHO$&BvW$Lg&iDx!RO{6?4K zy{UooK{#3)UC_zT7Br*F#$$!7_0KYvX_kqK+Da*d1kpMzA1QOlyHHq~q649OxfaQ8 zp&J>@Aci@Ovh1}FnR4(tt=hHC;6vJ4M5S5n0#1aXw z&ER3q(|rr0z3&iegqvY4y#}W8I#I7D#ye1>6U^C2+Sqe(dX#wX4F9&I@{?4aolJ4m zujwANy*hX>s>|=WTZ6sCNb9?nSY%$rk6FbgyY6___YIaLT-ra+BrPBzb~|U1X4v8_ zn4;+)(W>v&R6WECXzx-e&g;9Iu(09e3d1m{LZ`rk%Rf`3;44I*YKatKf(wIaceV-?%IRv5S+sz%c z7(j2DvdM{l)_H!!QjOBLJ)oT~fp7%>T{&SWK0Txl3bI(Ue^MJTZGwk+LSY=?k21U?UY$+0|6B09o3OR zYe~m@8Fb3ngCjxCgn&N>T$}-)%;fKt%w6FvaDRD|A2+nMa2_}4Lq9J1EOWOq?Gsxl z;ws-#HxU-llUacN_KWxKoc)2XpLH>&foEq6j4#HdEq3-y>WqafQN}3Y(HZ!B^Lb|2 zFo9xLUNJ)Qc(n9iFm3zhq!2 zts5^R&^(eUGHjE z!s^T64u?jHCr0U}x+@gtdz|lGYTERR`M=GU&3v}}`KK6~t81z1Tnd^uG=Cn5kTKH$ zJZ1LPiW4&jkj2UKIC4Pk8X|my7!Ub#GB%*{dJ;Zfz?fWt^a$pvFC@TXwy&3zl}~nC z=G57@?LvgUgs?2dP^S+H$`d3=>dBPWUwwNmGJBr0_}=WR8!Sr4PeRXlypm?rFM0K@|aXd-wq#ZSeYu)KAX_9?O&?RgOWZ;&3DrbS_&00_%WQ zL->+6f@K z({47OF(nll9LwEt9<_GH6{7aNPuohQU4ClTG@JpK6rd|?UWF#!kvOeQWA0xqTb3z9b1cyQLI_A*#)Ixew>g4M~ zIf<19h1V*EpRvdeLzI$_-+MyfL>-|LV?2fWv&KOUmH4z+Wx+~np1kLUQ<$y)Is7_l zeydCf!iGR*RcTK>yYrqzaXB6Hri)cV5XoHgTs%`}uqVBcA9H9gRysOr;ATiPXx%Gh zrIpM4q$d2M1uh&ise;IBlJiamIt42RQyR@$9pXATNdCYJAuiXeCp)Gl`-ln(<>qDVP>(ArWIQ$&+kYW}NSw9}<#01_V}+qlR>*+cakS$5JY-JTkh06Z9Mz!_XAjq_VX zOGGC}6+{QPDH7D1o}0lb8mO-r14N(roQ!VpsI;{yics#cgoq-kn6akZU`SHo&H|~3 zy7#~yCr-o@NngDAr=fcnQ!brtAoZpJWJe=ieUw2@xT)&98NOCH1M3r*Bs`kP2Aha= zL)eIyD3RD-hoid#l^*|uI>xA17+URP4=4S;17YEB;xt%iAShS#^`BPI4wnw#DAPV# zPHA1Qy_1JL%zPW3xMB+GRUS^eob*p~vuGnjxCT`@fo5>r;EUCM#z$y&unV6&3hGLg zY8`t8Q0&g#64_9;89oejrSEzN4TCSnMNd$>7R(hxrA@CROJBg5T)p`B$qg+_<-x=O z^u?GoYTslT@DdR{F8L@@xOF;I1CGtPWJX5SQ&n?pu4zO5q|#9nuMjTpP37@( zNK%*^39OPp0oLTx5z*}EGS3+TfiQ3!e|(hN^y+X9+9a4F6tz?fxa!_dz8)(X!LUd| z(SCa#l|bQKa3=W~67sEIenb|6uozpjGZ%BBi|2c~LgF--dQC|S3Jf(qI=ree7^5qm zE2yx*G)z9EPH3C>2~_U3#0T^>)0{YPLQ$Ya9J%&lf)CYS^9|_u`4_x)Qp5wr{l{Rs z8D}M9!!Z1~-d2}qjKPZoG!RKu%wb5*sy=l`1^c0pR;7)fT1wwD({kDxguqw$S~b-) z#m|u(3hylCxb-yRz77uggGdUHFgw!o<+Z+OI`2UkytQ|vq_9IOeOX2qbkDmUM0Cx` z>$Sjl^oO!-w*^szGZLQfDoy#M0Uc*r>{EO91x>yaN77esrb=>;5&dS2&lHLvj za4GGkA*7$EP%(ynIn5q-SP;!S4a%LU)zhpNay@@f)kteWBePt?$b6?JGT;23*sMiO zV2L$1F5H^Iow&^##2oXyvhaCJYXwV9T#g9(sB>TU;`_*qgidb)MeYn0*KN>U>m{ywmb7&Hq^%s}%_8JbS$TE?lxEb?{ zydB6>p34pSkDteYAOCQPR?v~3go-XG-z@(<9dWw&&Ce-Ivigw4pO^YNcR!m2Jk_N5 zbUkl>Dck`c=*;toOO0i&Fd@^Xd6K=-92dPW@pGBe#)I|(rxbHStKe#_`_eAWEJ&y4 z2*%yW_Fe>aTaor+^fM@F>T!flrP}1Z*6qSq{yIoix`6wKAE|1I0J43#TqOpjrjap3 z^T2URKMeE;G!EzfwTTYn>>6E9N+17(-ekT^YE5m`1ov=h7`E<>cCz!=jY!K$*>MHt2CSEzMa5@#f?MpZ*OEei7<(zd$J3|VPMBGVb{#f zj6NX|)ZMo*^^tYUi%??D>~xRGY*p)~^->PXJsC}5o>MDf6jUNlq8W+H()TFkF8Ks9 zkIbCx^;+25LR9=rItyu)dC;d(bL59~x@XQEWw1HPldq46>&=#q7si=`c0Mwa4{OmC z>+x3)ysV$I6`e!?PA~eQXD`(hV5&VlUOy}|q@Q0GOE^7gQ16@FRZI9r3)N+G4Kh@F z$xDgo69RbE9u_Azor1&!IZ(TzOU|6*ws7~Ra&mcFS_`8o1U5crym8RgK;n124Lu&U zc>Bb90O=qZy};f_*$h$JKREYd}r-x2-7(RDUG!9NYrNpf`Zp6yBS zJ1<{p);lU^PsM|S4Vwm5s99x@Di$DRS(Wt3e@Z=G%C%DTeo z(e5zKCN$6M_?+w8+H4QWG{QqZ-ZpkV{aR38SBSDY{#4O+$Y)+P$ zvu@h7E6kU=??Q-cT{B75Nay`#L*gk~N(<_XzgZ}or%~RXqIvrgWP4a56BHe(v|@ zYx5_T(6_UJ>5bjv6GvX(j&St#XK#NtkT0O=12(~M0f#-2wCzchZ8xz~+N7=6r`-uXN7v#T0Z(TH1ajB}WOfaOM~=N!wjlI%?i+E@zfN(Qu(c%7%%-t9v`{bs<@6 z#;3IjlsTaL`a-K~g}P|+`D$(92qxK~$v!JRdShQJ>&fcG!lWdM>BxxAv6I44AY%b1 zJj)i9vM-};Bu_}z%}BN5%@OPkb*rTba8uUVHl_X7rrzkcX4 zWhk<#7!;NrfAcpXgd^ncfj^i07~)`3v~Jm3@-8n*@JD{~Qt{N7806CFoF|DVwM?2O_Q#e9FTIdJ4x^?EAjrbqWM>QZ;`Q$aY3UiFb^p5DP zNgeAtSg&HP|M~+>Y@**P62^WGa7GYAXr{YuIB=6nGaX@#+-AF2;^vG+p|-^sL9Yct^?Nib5?# z!lxjn?0myp(sPV`$3wUfov-=RpLrpJ-$`Bjv9|bkTXRdgfcJ;*32*5%o{sFBk5isi zTE3ba5cMJ{c`KM!<4Sw7`bb*)15K-CIp}i_&3qA;KO^`6@6gg10%eGyl(-5|3=u^ckY%;pL@GsT;6E7(=b zY`6`zrP!a2GB6Y`f_{9Uk-yCT{k_F=@JG6|?YrFCtCzN_s3Nj;$ALwk>qB?iI7@p@{=x%@C zXI{KgmKe|aMf*cMBbC~L27jU5hc!YpiQ$*NNgQ-<>N@S}98r&ITedE3QR#L<*N3C{ zA{?jQwOBnzxCSo=%U~pBX<*+Kpce_mdz-N#*uakXp=e;QZC(jI-J+s-z&u;_BxExv zWyPZuW67*_Mn18>MT%F=RH3xNDpvGhEPvcXkH$+oaBMo@z2*i}6;-qwOxq+90b!=> z=6ZXGO8(5y4Fnml0xNj;Z9BKzpq^wBol?mF%qpL;lU7B|w{-V>?zrzQhQm(f9}e8k%MYc!D!$eQdzB@&Zww%GPCSs|)l*Puk-{ z>s=Es9FVk(!I`vXM z%#-Ms$4_c0-*1{qDE&VG7(wU0Tvlo{(nAULz5Nmg)!pf-E?J%z!7dL{j)JkMzhsN#St(vOTP=3nx3@rR?)@=m=4)Cz88@6JR z^w1eKFlMY#-)TydS0y)-H}@z`ORwQiL=6R$(fy7Er@9&$&sHu6EcZgO!Ab-SbP5E30I2X*lVD=SAZq4heU zWuLTSsf!ZAj5l`H?(^Q}DXrWPBf$ujE5Y8ohXnqyd|-%mbJokDJ%?q>)NN9%R53|v zsJr^w)|2v8FrLewGe$H%{Ll;`*f0Ylc=2Tn&K6sYD5;BSoSbS`%@k zA0s8A9C-o5aB4JY__p_nE|cX`(0GE5lR*Kk(@^z!GpI^UnX3o#;_MGiq-h}yZ>x81 zlW)~-;51OA-LEt5jr-L9Sc4QdnV6&k*d+}bg=XIR-O|w`(Mx^4=o@);>w4*3AxRD@ z9o{*6k}TG=H+SqFwn@ONchCwODaM!9MwG+uV@z7$qfuW1?O}Ddwz2*!(Ur7(xUwso zACtv9?zkh}CeX@|=)AKEk3JH|tQ%G9G;G5vxlO%}PtaxLfx4{RA*G2E0>PKj2$>N!hx9XTv3^q7^#x*>FTA@TaQ6<8Z{4J z$B|uzsCmBIj>;39^FKF0hRT;K1ew3^RkC-$9?Ge^!y>mRn1cGtIYny_>V z2^A|}{567ExNxDd$Z(+|0vT)*>`Vcy)eA@-Z(jZ zZ)Hc-{FF8wju>*|9g?Ju1}#n`h&CwfJh)$KzW=&R>vO$yYQ))C|U2Om22LsLr`_1UygY4qxf zN%Hyt-58;oS8qJ(0Fgqnj#ibXd501BF6D#!pi|R@3 zZX0CH;B``_K^bX%MGGf5nU9?q!R1&qa6vGE(ylCed*e*AdHENGSRo#GGP4kA(>{xpet#t9<+Rq#rV77S*5Y0?;ZWXWuqtb)^}&04vv zUcUBb`PG==(&w`wGC@0tWIb%vTkb@aC#T_f@f+|&cx-!V8P1@?X6c}m+T;DZO=tH^ z=Xp>&agLO5!jlR?(YkE~;lemw=IEg3+>KHV)-d(7{NrwY94%S9AQ<7ZCQ@L)alrsa zikOA>)Rkh+)}4Zrbzpe($^j0F^kKWptunWYYAe|h=!4w&Jff@+(_ z_qjnzD7`QVI<33(%jybEqG%`2geR*2o|BKNJA&2Y*Q#%);%;|c*-B-kO5I#=7MIo= zk$<_WW#zUJgJi?}jk0^wUa8+&y_qM#9YWSg<6KH32E&7}PcAbOGxQI&}@*-F|_mD$>tezYx^X8jxI{SuY%a_UBcipA4q2kg)1*5Tj z2T0E}!3lwi?Xgc@euE5OI7ce$mRmw@lr@nkuzCkP5gDt7Ba6WR0A*qbdZ*4P!v(&Z z8lUe*%NCcJDxEx9r_pNk+ESMe1?Y7(8B+tIZ3@i%~=|ji|f$ip- zZ+1>O@qK0|LZk~GS%960Buo&|nwlU4Ov=ROhdZM3!?_gH5BjnPpBR4muj-{!qyFPt1eS=fH!5LK22-Yalf1@ zQl9R%gD?;6JuEX`nk5HUrplr9hh)#jebS&yeJNWp|3KSj%eha5X>&fU5z#grjldj4)gdG;7u@ zUGT8@TT{yf4&$<`~YJ4+F-s4uCDwQQ%#HA61lDU5plp_wmRP@`r!EAoCV2 zluyQvk+G8}O2;;B-HHN2kfTffq!BH3@zbh%$9w(p(fHwA_+is(X{MSd_@SjP_svm( zosAG|y0CIM(aXma4wk1P#yg%@*}5e=@|dgq@T&4d3(BMYLMPq%svle(DPOqYFI%`c zvAoNZ-FE3G!E4=Wq*Ryo-)kd>#vYcV^R)7Jx0kB*s)YPG(U`dqKqiQ$T#*o-3&jYV z1wNMW5dQYtZ#yB!%4(6bLkMj5ec*uyoN&VNEeIwo1LC>YeEj4kJ}^*cW`*!LP>;^3 zTD5AZooK5x#xM#oyuiqO%MM-)x4C%@cp^HstxehS2`}7z_uWoQI)DCrmk>H3(C*Mg z=x5a7K85{b-79`@7$9D6(@8GUBPWilHnWs!qcAr8Z1Fepg&rV$K$koSoLGM@k5FD= zfhXuCWn^g*4eM}qHds|Xnb*((?E~C&Y~Si~vE4-p$}-Qv(B8)56b9`$!V`S~M`-1C zu>J))Gg{2;GK9--)3&Yh(aZmmPv?9suYUEp{Bw*R(~`DRj`$&d2nj~9^oeQRYRE5? z68XPcca+w;A?KvlyModkLeNO%he_&7?XWJ36G-Fof%npW?nBxi@CE%QDi}ZD)qJ=* z;WU1DUnf2|{3IvZ$;#rtCaN5HqIse+Cy$+!WfNCOjmFhw^P;WN<|nNr`R0bQZ__@h z)l83sPz(?+w}KbJxs_+6e2h6EfR8@<$Q{_r*>lOs$?kAU-bYdwTZfYw?uf?^BXb68jySJ=dxl-PF=N)$j9*6lxGD443_C&n5vNOxW&cGM}Z5eh?1dHR%&$XcvPPlL0 zc=_?3G6y^nxn+zeIA`p|7hjb2?c2L8ZIyw|5U?G;w_y&ubg;x{I2!Gw&Sivv!xB1FXKP4 zb%0sbVGl={gm8`FK3o8QT*E8jLuj1fje|=ZQ(~w{h=dz2QF`ygp$r(74~PA>YuC;R zOv8o^la!Pcw~Mc7)27m+M~`sHbNrnNh`3T%uwa3t>M7&cWj*xJLvFdzzUO#Bav_6& zCo)H}(LCBmHa0M+s8p$v6Rt@ei5|Rs;Jx?fXz+=1Z^ujJ-n3qq0cNmzB=4)U?BOdG zN=M!5?On3)!^w$f`T+tSpSKLU+w}`W=FX5W)W6xi>Z6Act!^$t0r_L~Kxo1}3cTO1 zUq9E*2u>C(o;_cv*Q2^rB~!nVjVkodR`&u3Oz=Xa;KiHw-XA{$KXm9J_o;9~K(qh8 zdh70??mb56=886&FG5i`SO$Z1FTee!+vGF>vk&^JMebtx~FHDH;2-@zUz<=8{w= z$sNyvqfCDQ5d?2z_~R7TXM`t&CYIF7l`H3n)H+jdo&CfDuKe%3@$H^?W*iP&*7LC| zfB{X*V{voyYHhuC?OG>1;#-9+!fY8fW6j(wPmbgj@I=gLHG0PGkT$EwkIf^Qg(H&H`V3mB0vS3}v>y2EJB{=G6^4?6A9v}H`QTHq0k zmJMdSSL8S#v1^bYr`XTbV_{+xk$B6Qi1^k%XuuJW>(#60 z48?KBLVH_Zm0g@BqOAD=MisUBYj^WNX_wqc8t9QK*ejU>QGfZ2AGYk>qjsTsVuuRe zhHrmdp7~Zv`K^umY_b6DtB=l>`gO04Cyze&GwIc( zs}r6$)IB@F_@N5gH4R($?U6aVcSslIhq>D~%XK>8E~_glIn58bw``|1KBG282uJnX z*ON6f*UProcSxiA8cNT5y1Siiks1<4;TP$9b{ZnTruB9X2u&&_K~yq3yZ+^2?<|hYoI*3y!?y@#BoN_RB1;KW(&U@}%x8St3MH z9<&a04t$GNrf6{U&9{Ij;%W-o8#-etxj};l!Z95d!qEaVQo=u{j*|_0b~<%F&*9>F z->E%Nr)lV$AgZPHYC1&-dkQ(CL`sR{g`|Evxa zEz#k8HBX{*@W8Xm?%lFas>6Fz(uDaq^QX31CkIE5QSD4M zb!9M6XU#P$C1pxKXm7{|gV^@9>dH{v-AOw!$vC7F3*J{Q8*+!?&)1$wkH>Q~0XXl= zF3no{O?!69JGwQyxegHf)!wOYiBd954=3)XXNFZ!tuX_f*DZsUr=VSvlarkzO3u?{ z(u5Wq9E8)lQ@2R(3sSwQpAw!EKqxmflvzNaG@&wDTm!vk$2R#wwU)RZxcZ{@As=Y^ zFX@1-tHYc$^B3LL8hy}v_85K z$L!IU&W0t9ntjP$%@hNUz`<~AhrDBo5^1Xo--4I!llXVopq{g-+k`6=bYAvd$#vK_~3(acPa+YF|uYJ zjkql?vkdH!&l05Nmd^6D=fZNmka>bO%&EZ-uj8XOu90JE==#0pZROTZ zA*X@S=$i7R&D*#Q8=`%;Z!b(3CABM5lv_IXh*oIH9=R&HJ^pFjUExkj~Qgjm`mvp6`% zWik_*FofEgCdbcJPCDqM{JFPmM{a4McnNjmu0ju5Bm}5p#dQsodZ%%{A#D4q9kOKH zGTAs|v+Q4YQ1+)?*o}t&8-$ku0|q#Cx8c&tklEGXape~+*mpdYj~+eR2~gNfVQ6mO!lkE71aBPg zy*CZ-ExtdEH(o)%ztDKXRO+;^wQ(dGh_`Lgz5t7D{14BZAk}n>HDRI})b`gi>(B&c zwp`$)e9D^MIi=lszXRKX4Mf;sJT_~R98~uPz0@yGX3Kn}ce$kToWqZGhz4A*oJe0@ zwXb-I#?Hxp=9?!{xjY~W#I5msG}^Gq=+dQ2<&{@nao)e#M1XyiH=WUy_g#KMLcD#n zx9rr(|MPz5-e`T9+9y4zG+9TrmAsp)KFqFE+Jv66QwD#2E>9F2I^NBhKTn={=GSuj zZFj2|@QqSl?Vb8{yVTJ!@vLpa!SH_1$bsi#BOsO4W0>HtGVaQKsT`Y(oy%DySC{R) z8PiiZEs2404ZCIcnmy9IZxcOur$|U}Oknw}o*ZG4oSf_k z2m2+0eT%1hv7|Bl;;;}yZv3!tNHO+S_AOGL2H$2U#EX{3;zxp4Xx?8yJh5lvUfH~4 zi&Sf0MM@SeDb;IKPgpa;bA)+%WJ7l~^sc5``=Oz2y1cMp^9HG>hPCkogBMF0>&7^= z8vip(4j+{1>Jj{!wjr%~G#I4C2`0OUq8Wh0EB;W}c*I*D@4dI)_8uQ~EZ?$`WbWL# z(!G0k_sn+;%z4K~6L#yFuQ*HVg_jri*6)o`JD@Knj+a{1s;i%-}#cdAT#ZH63Nn<_;#-kB3;q{X17 z((byp=fIm_cJ58C+*uw|2+*=RLpv zg?ur7ut>v8L=GPi*|tVj&sZyslT+lR(lNVCV-1mpy%XvO>7?4jBBVQZ&@29tIFTVI z0(o&*@ajD~x?odPZ#=2wlnd@&0X=Ak{{>h2qWygX2(q!lxGWXisoB(BQ zniFNs3e3FIJY`baqG|_4IC@Y|gMR)BDOsk3Y@D}QPO0HI8mEfYDoE$=b&$^=7$*lu zrb?TCwUUdk4GB*8ih?PMX*`uJ=tpxmq){&#uz7EvtTP*7qtdoPy_NgIvHCeS~m5l#tyc3?72xMnqvxx+lbVjVv zQJT=NM)P0k0jh^pXi{al^U6H?(0-Yr4*jlfb4h4v&X;RicOet?96dU$(RwH`+r!-s zCVe)zzGN5tqqQ}zTpoGk5n-c@^*@FjHqIb;urrfmsE9*9WofOiwD@^(ov4Qm?^4g{ zefoVzRGZ+6O-{R2-`(%qTm%9PHPDpJa;Xa_X6_{9gqbZ*GgA4>JC>YtHUJaqeE(&^`%~$s`iOC3l~3EDikJ@ zd@DS;4nwinth+9CrG=J#n!CHh`wq*&ovBi~LMf@!ua;bNPYc<*ZeO~Pv|`FCDOJ9d zH0jbP{hh(c(pAghY!G6U!VsFyoIWEJt5=jxceR(HDW6KE7D;ln_!eo_vY9k&+)xf| zJ1A$0oROqjl|w}`iix3sMnHS^>~Y@5={(T-*!#Tb7%)(eHPC^<-0YkqVCWfy%rQ_H zc!F~yJKWh$mN!}{mG4iI-A8u1ouTbIUM#6Q4#}xAC)K7gDTItTc!C7b|EyWFoNEiV zwzE6aZL?Osb%O|T^p|MkSn?*AkTXz?aIbIE!IP&BBwBbu9l>VN%GZO6D27*Ns@ZybFVY!oU+d56TTQuab>@bDySxSEL$tRt56D%%J=az?bKynT)l~$wCX&9`>^(r$r23}xRj!)HV z^I$y!V?c$CQDl3rz)ysiRt_D}MEmg3#9gda*OS?r?Ft&={m?G7G@g$WqKvj>cEJLYqPqSHWfJmW^^m zZL2!!!O~Wa%wT5aI}S0~`4($1+f-xaEsS1p*%DrRqz#(H+v#wnX+%qQceXo;e-XX!qD z-XvY`>m;?B){KdWjnJ7*ty{NFYSyeN3l}bwE3drL&7?5c{@{ZTTn936pn9IwV^=Iq z%w^9)L?imll3H1M_wFqmOpNDrg1yfyeehi|P)K-U)5lw+Z>N4zc6S9C`lC;rwszN| z-Hu1%;R&M&Y+ulTvTq)!~sIZ43deH-dFiQj*i?%$YOiyxn>6;LQ3hZ`<0t%-|T6tX#KN4lSD`<$K+# zn%KjR2A~ZDn<^?qja5JhJn;lq9$luZRJx4rM$?IT)#MC9-AFxPdZ`NQZ|FI2?9`+z zX+u^#*~Apr+9g9|Z7+X*=A&%i;X|@j?f)LDo8p9}HkGT%UKOCWtB3zOdT4j7_|1@C z4m`xyA~{fiSU|enb7~ue%D?-)on^$mVo6DWE&Z26d?qwEln)B|JLdN{&D>=UR zq*~{lm86R*OZ{GTW$Du^Uv#0Un$2&DO z>gbUpN4n!H@{?mpZzmTBPUlfe%r6QuPtZ}r6UX+3e7q&Kt|Ya))|6$>u9UNfl_!SA z#}mejc%Mg`IeGGAx%b|CrB3aTBfe!@b<>GD20WzN*ss^DluMhnQeM$nxoWX!dm zgE#^i+AK8w?DVr^v@&ZqqrNiQ{!+Pt6JUy~AOl@sXw8dLS{F6+jkQSW@xXzMoh;M3 zU927}^)U6>%jA&y2O})kCE=;c54%;vId|P^>D;)P8#~P1MLLiK-DHLb%f_6$R#HvX zqgUKuuN_}7f3Wh!3hx|%oVhCy!V^_@gsQUY;eAJ>ZvWa+?Z>TU-}?QIzz|^(atNtA z56N}!_jgNnyVvcN25su;tRv&Ps*4!qk1@sm?FVG~t6$5B)RS&E-^UMsCe5#JA{SlJ zDpTo~2F4h?X5$*t;YaP|%PS|!*@I{0s^>13?aOya(;qjI6NgU9$z!2|kmC{kDIc8! zzMNRc=bixbvlSQj0j!fFVA(epA)owlxY0Tw>~Wu8m?58_C+1=lRGz5SB#kHfPn0tU z;E8^+eTDMGgIVJVqbH6Q`s-i+D*M&=wr<_J>Dq=b)d0Jg(pfVdL_S-wNVQMRoH4d( zequ&=4n+)jATfxwegpvqK?c(XH1Z}ySuVYL^>W%KCY9L55&VJ^yhSjW?jgb-b`7%( z2t1C+y5*KzVoDdvA!N)ghqlR46=n|TQd(IR@D`|JSJ|!`2pXu1i@7V@F1ZNVXLxPp zt)Pb4e|r8oDXne^(7Nrq{2FQ1q^XPh)yk#L)~UH3XEH($yY7&J_NiEo**|3{U3&Ikv0LoP^C&f#J1Sb=EGNwIe-@tbS znsZ*sBM;sNYs=EDGUkWl<><6y(qZt$()IREUhvWH;SLq-zJ71ERIFW51-dhG>i8+C zdr@umS5-~WZ0*~&-`z(CbpBT>A78j9z&PwKnK*Hx6QFwQ(iq2^c;mW=!Jh(;fq*B@ zZ$dAfr?H;Q+n{G6e*T_ZR=%?Cemg7E)bG;gJ+E>*-?C%pa(?dFdt*H8g<=Dt_g!!w z9Rpq(u$bO=-h2D*zk1_DqY;ZYV#Emf?6c3D4HcVr?!W(jKgh7pY-T{4GW?5?a?^d+ z%XQa$Us81mcc(5}J@Tzvq`qoS52+A%LN!mlx^;Jl>RO&*0j9k)+7B0J(Wdp%cI11~ zyPTT2XoN}14`21VR{FMT>n5}LMQEX({*d4JA^!_c9!fy)VYz~U+8yI@7d&xzHpE9l z_TJ5Vo$+~{=8<=Z8If+7zfl%{vP>Oxs?$l$r{@p4$0dva=cEcuB}dKUdMa2GJDg7d*}Tg+!sI$c<3eIiHz+By&KKL|KF@%Bdd08mvXvQn)kp3rt-N`b>* z`$oJ-!QvcH|5RU1nIxZ%|4OQ>xkc)cBhsr=XSq%f`mLDe>=+otCsf~H36 z>JJv5_oO7wthFm;@wUxUQI`tQydG1*tX`!mPIz+h^qm)nybD5j4CH^|Ny~jS^_Vl- zuGT<}#Z+j5XdGjBgsJe=%lP(a>QQ%w-n>s2=#t+7>HXtNo%W|}rO3Mhc5mF{4lU+T zVuYU>jjD%^lSu<@43IIWj87PwpFVj?X1+Z~%GW9<7hToT5j@7^xHK?Ln5FU(eY}M1 zP0PK1CJ{?{tsLR520z|%g@fgPm))}Y;T7iR3yCMZbm6_vtbJpR8*9AG@=Nr0H&h0L zS=?yNYI|BboNbOBJJy{O%5GqMMA})JPMY{yIy*UK zA*~4(TbFH<)f3lB|6lcU612(KriIE3v=IZop{6`LU6;;II}O&bAB~Vs544xY>JQ4r zQK`)B!by|jd56Gep?0%ccAL&jG$io|{zkQY_ioxN)1Lj>#oIY+mu#KBO)h<;n;<-e ztAiJg!AQ?IlN(D*I!*3f+C=cRS~X7tJT3_;;rAHw_ec-&`*7~6xljIpK2JXSi)wEo4)n0d+zF9x_` z$1y?=Uc}jml8(O^(cz7cn}aXE{L-BQfpBxj9e0E#>zWVk;Eij~&>uhVH?rp0Lbx`x zcSnyNl_K@<_^mzyHBY&$lawzPa*}B@Pu#s~Q#Eh#B6sL5`5jgJ)@F?wOR~Cuap^3x zv}-uNphQOJ-g`@GWwPgZuYMfFn?79pbeLN3^!soTbMali6rOA;V&}SDvgp$#a&Y4z zIeGA;eERFprRkN8rB&b14!c~F4yK=5Z z@T9YQ%gYGM!Bnl$!Ck3tm!Ez2UR`?Cj@4JA^-d3-kg;7RNYNTaUB0*`uz}E}v85EJD?$_tzPt!$CX za-qJz5P1T6ht3%kIedEk`t{B~n7Q9DS|AQ|L~(~R;@Zw&(8{%-nLc` zS06MuBWzixzH`cHyMn@{iT2J0GUJK;YWuQ7odt5%U4Aick5>NN{$}*S5iGC2{<`bq zafWFI+lI$@%Y~K)*tToWo1XX3nB~nkp2N|fKY#x-X|2tjQG59sQcBNowZh9JWip?jN7kPkkfS}4tN=x(?& zTbcY zKM-0qTk z2dr?g>>YH^)@ppxJimC3j9I?OeL`@GuV*rdp)&GhWt+5Wsr-4$I46)XP{dlca}W#n z9c@lvqRG-4UdA_X-t0~H_ql)nGZ-g^L8Ssm@;1KTUGyDUrJrFW!@ zfFfcqF~%B=F(xswBpPG#CI9q%zwb-Fn3$p_F=}jyJvLNCL{yO8*`=2)z!tW!y)Xag zIq#jj?_O@dcLC)dxcjzq=FBM_jvT{$Z$f_;ICza-NkiVrCTrgYaOg=|0A2C*BY(Io? zvCK|(?A|TgcH~JOJdcxQXZ_Q*7gtrvx$nIyhbqfW8Gpx| zdh$O~RUx-*TPrK}?X>E2ydx(9ex4|9%&x57^4+=e+fSFBHuP{>N}f2#juw=|(7ILX zD;gwmWP;Rfsz*2WFuUyZE8KJ}1|ReLN}6Zzq=80q#p`3(>Bd1rc(gmJDmf;fKD0)z z`s1a>d*h&zM2yD9Lt?g1w&lQPfwCBj8P6Y=Gj_s*R=jh_-a$5ebYkGrFpN^a zag-dXj}v$0^q$ti?cYn6E;X(Ycus#hIXQ4*#>E2oYX53EPe*%R;>L3H%k%o{uN#RL z@%+wrz7v$_-BX>Phx_cOGmR$ny-@-{X(xX?=eS{_C+Q_imIxgka-riEbbk{kWG)*Y zA#PR$=#25R__b}AA0Ok{Fh_>Kv0Dk{$So~rNR`qfGNRuAgI}=HC-X%OnyQ6Qp2Y`t zOD=XpZOn%+9=KN^?N}3wzpecI=F@p(HyH+e6jEA5|4NLsppqkHa7@3UD@a3H&Rx&w zbE^H6X<|NmnY_F_VV#V{$w&$IX9`p2Tsks-?6JqpyiF~_SHJpIgKJbJGaX@vGMY5{$5!ydV=&rFkszP z$a?%u>;pEE2Y#d+gY(eE`FkX z4xKwg{7FjO2?+_tCknr$SeAZtmqO{{_~#;qtf$8$rO_^SLVXaA5P|+kQud| z@#Mad-cQ~vIw1SN{4kw3dvpbI+?0p?3F6T$+P_PN!wWRsAbh~UzDT;@bS>rninuUw z3;FwbTdV~U*K4pVs;IGEM#5p>Vk~HMmPok%N&*Z}AAfXQ`N($KJ=Qsg3k;aJi+N{{}uoq6=fPADiSkiY-^??wXu^wUp!lqM-`j!XWA4hxre_NootpAm zDcn*dTmHEnVN>d5+mc*445M-e1a7Q>;ho)u0qX^h0Bi1->?=k7JSV5j1&O=urrkJ2 zj<+3`qfeGgT<=(!cFkEv8s*xd%9y1OPLqUw@sfFAUrESFKrmBVfL}LlB^u;RfS$?#o~Pvdo(|&zZ-c6UCR|V}Aep-^*`)^Bbc+WLb*I>EMtP0~bjR)@kn( zf9mj*hyBg|bJy>l$^?BsLK9)537s4{9w?3czyJF`LmT=YIbQhV*d$Gug~iK@)2WI~ z$f|w21`5mZ!=NNm+BV90MMA?%FJQ zu%BY`RNg#v{9!wY3)8y@AM?=W)zXS_T8*#lN4Kt%2Ap%g_$30Pu7wne$>qDu+za+k zxacd``a>&dFY{sWbfX+W^8bb&@h|*uJf8J4!qBg zLozx%=T8&IS2BY0Qa#8zDeZBWbbQcBF+)(%S?9uq3neo%(`2{9zor5`6Cb(=p01xZ&Vl zd35!Maul>s2YaivVBBBdzJXOc85ncn^2a`gUqd{)SC5s0acVTut6yzLknW13R{LDa zxw}+Y?1MLUY>_9otvCI`kCZ>-obe2gwJdyTzO=)cWO+Wkg-?P(ChU?vdH7SruRA6&y<+6`+uxSf zV{J0{s)16qvr5{oZazYPKe$T`&W|^ z4W%---+sFhQ8QAwzdK48Kla-U!R~DapnZ!Ecj?qJOjAN_1KXk<}b{YZi zM7WF(OAkv4%F_=|Z%CWcpY=%sYFwYjLRsPOrjqxGY^EGASDduK7}sJ?w;h_8W=|?e>1TYMI1htX zs1G+B+$Ra3g;9`Z4TRTpSSQO!1kc`EUMlB|gv%ciit+!@KsS+FRxtvy0q7HNWy3^0*TQ1B6eI<3XT=6 zGW4p!a?WkDoOVlOp6F}o)5q6H@$yoMMm`1>KJTY z6~9!bU3ZowrzN``G&<-`Xfnr%KcnP?g5kZP_)*IA-~avJhUqCREHnhqa4yaP9pJ!Y zIeS@u2d?77Rx;k+Yp=a#Y_GU$ia|R$scEw3)qBAn6;?AO1KcIZFH>EB{lz`dx+65< z(qmzy34Nce!G2Cj0qtE}@0%O8KU(JXO>5*ATi3`u1RVYOg3G0EYHt(%g5Tq&s?wFmGO0tFxU47xH4+~##JvQF) zKI1nuyCK)y-$0OrJ1k4M=qCmXZ$vm2*2wGQR|I2~J z`V8^-0i8?<7Zpl+h%+Y+CVvKoJMe@-&YVBf2ktVtxyQV$lW74AdvCn)M&TFZm%j8R z!#J5fbhIlFxNfR)-qJQQTn!E7|L})DnB9EZ7mAOwK!_(1n!w=iW}2{%4f~i1gmIz@ z;9rR6H3Q*VHdI&2row|}(vE{vD;CU4APWU2UeY367MP!dK6O#^HpUz?hHSxC_IGz} zfzf)4GZKbAcu{@Ho?Q=jHx zpAc6{Xx@0^4dZ>AbZCEPnm3fA!ZYu{(f2Ajm@;LG&_3>(YpyZUZQ5#5Wk(}!s?XFk zz_or#FR7k8a^#3ig58nAqYDHYrc;_k#*DU1Os@TFhiAu+_jw&^A`CJ|Wb%odO4RvL zc=3V@JRiKCGcWsrKNxkG#NPD&x9W*pRdZ62c!05rDb|gKJ zE|eaCGy6%$p0_@rI{hbmw?p;U40-?~mA_j)b=XeDK*CFW_#;ynXn(rHLEp%BsM~K} zx7=^LN46pAmq^|kV}C{_fe4o!I4bYn^}f^}X^{G|2HEk}E=eDkW{k0kV4#h%*I_>= zEJ~UP&%nhwQ(R)K44<7Nz54Y+2RF;etA?0>n*=L_^Y@NtZDI8Db1G&$7nDpogw&KLEK&lXF7|%t|yw?!> zkudZ}T(mA8X;e&U7e)2!*RPkcW5b zP)?PE33z#Nkz6!ngrtC0)CkpGS$Fpc&)v_CkDj}hXE~;Fs1O%I0(Q~h;nEK{e0}&> z=>r4wflwndhZ)yA;-_VB>N9D*EMv-|1n=?dz5yPrA6>m%qH*2=3Dn%2Q2{NI-YPeB zU~!`)+my)sbV8yLgAx z9IBO=6mYfiQF3fwHH^}mVJ`(oWsY_mV5jg8+r&khwqR@viG)XOmpjz-87B_@>`4cb z{a!HVb~sv}{hlY7{0hv6+l8S+hZ=hYf691*rDe5#=F@vTr_ntbMoxVE+T=BpJ-@jT z=${Bp1lnU^&Chon2u<*Px8sXA6>6~`4IUwb()-Ge@)DyOXu#yjS)FmSTtD7mpOmq`^66UJ0cSv|et`pq&x@8!=EW)nvYm`3-_${6kzcQQ}U+ zZP(OyDPL*T~;K zSt6Vf3y&X`9@uzsE_VFU1}YP(Y~AUmWrI0t{Z;j~mIF{QWqQvYyorOeg}+)bF@N}I zvHWcMIfk)U^%|L;K$F(j2pg;@2w*5-X42)I^swewh0FmxEGao8S0nbHam4B4{rV?) z0>+8}EVg9lqTN#dVWp&uPm#WtrAu;Vl4K6=YY_4@AkD*Y{c+F*jk-;JxQ+tX%--O& zo*VYkRwoBK+hL>y=)?pVi8nPg$)11jllq;F(*J^fa{m42NYRYIyn-%&d8yXz2@cDsQW2%&++FD#Hm%z1R6sd*F?#rf(7?v>RrtWU0Pkfs9#vI1^5etq-TWJ>mM=XlXFK_B@Z zQ20-<>+1kBKP(gOhS0a37_)YVwCgR{AKkMJc8M?!XBqqZ2ox7>KW!b4U_;1=e*K;8 zs|5`_1Y`O2U>M6=8f7i6+u`W*qLJf$dRWA`xqtuwKmbWZK~(oo@?^s{00u$%zI{-d zWQu9UroZ4YHU}^`k4)cYDmv%zJGeb~d zx)k5OIT?}!DO#^d&>=&zV;H9s3U>buC;qNgp&4|)5ET<8yFbL1TS(Pt8QmFkG)!uU>8Jnb=0UW1w9X8D(xKrj(0clDZSiwQM-9BQz0?UOW+o z$MFy#O%M*p1C4#}{r>$jW7bSrk64pYm&}y|%?)xk{NnV6k*v2#{Y30eyrZ;7FUv2( zy};ySePqFyiN^R_L%G;XF+Uv~R%4gny9aj37vW#$UAQDTZ`62Wv}@1n?>XB*n~+8@ zMeo2j4t+%}95>0RVF=@BZMEzNn1_B1b6|ZLC5`x+rriKWT8$qDAJz z<))i%a(*CrlGN}WF)55t@Ng|_=6pBnfu}kZM}1DI)#1a3rKqULFiw2VXWfCTEAIAd zcXe_Mao*dKyIn55;6jmE;~`0aWCb3|SFBkrbMf(L#)PB&lnPeBi+Bxe(54K5ga^z@ zG*osS&2ch3rJpAEo z>#5#=nI{^?_8O2X*FJf*&~UpIi+N%%h^EzO+E$YeKC0J98&S~^TR9jQTei?n9Xyf_ zWK$>ZkvZZ$GEzow%Y2T!tWfi}x4~mEjK~-M_d*k=uDPMb*i;z?%w8ZgEZvtzU+Bv< zxS|hn3lqJCs7lBx4pqvkht?T2B_)5atz9JN+&|N}Zm<&+&q>&nH0|28%X}r#z>#%u z=LkjT%0QX=kYD@3J%aAbyRR(1h3S3G87Q zX+p;cX=3~K?Z#!tdGINg0$aO&F$vO=(o43(C(SDOjJa&mG!8ya41wY6$W6LcTB03E zUoaxO>Z)Zu{O4RSZZc+)6X9xp8pN)L@%l7;Wv{QTf^)$g@`bZzN)4DQs{J%yAc$>% zSMqIu6_2)mf-UTqPMm6rQxdfV4Ap~B%TPUHPxdz0@B4dBJhjj1*px=wl-B4Rq)dq` zJT1ff_H);K;kwp3v|shw6MRb0XamJfF0>(K(z2e)g!4Y}W3up5n;UHr8Qh>XqNUOV*ba%M3_#Qm|v~IOb3osYq60itK>2lNS@PJ{4c;BAbLX}3*>;Dcg_-7^elI19~cK;q(fDZtw z{`w@Pm^Jc5YO+J?JlFR`Lv%Xsi~~Ka-nU!MA3M=x%7dGbJoHs|dZuK<&4NAoq6aL+ z{v|~sE-_9fTsY1!LVX7GmcbJST8xT|ic4P>%M~MDT;9?h=H=@E@UPaub5Xs;IySz( zMH(QEGz9CWr->guloxF~jJGDT`HihoQ(6P}2$r2d;57$W!n_$&4QW?fYnvQcf6%B2 zm2o08wuKB7?a5}|HC2wiP%TwY9h2#IPI1dPvEB4zLNB<_KmWW@RgsyYfh5~YW61en zESShpF@G?LeM)#V_@)S(k|Z)QG)mWJuCVn!)oOR#afjS}_ua;~6MaWf%umB^s`OZn zuze+kPpKN2BdYA|J7gF}fjeSoq)JAT-hsoN6o&{+gsEq{fhLGqF4P%xiNP^JHO5f{ z7|qArRS3Jrp7;`fGH;_W#vR8f=^~h<^i%+^%rC-gc{0BKQ{YGH#hqJ>(@WQJ&97VD ztHgrv9P%XNi?|wJy9qs_~aIN@YICVufV1veX*qRv0sP97;yCga4!Yfp*KxC@qZ zm$!VL$_H|veWZ182cW(;*EvV?(ap)zPd{yZ1i=&Mj)W4p(JPsx# z(?0Cxd^C32Yd$DA zl1M+klJ*^q&|ia>{{Col2AIs3KyOr+)3)p1d$vgicJaNu1;Pmj9q7^Xh_z}CSn@=a z3A7wir>(E$%7x!Q-!K4*D8cG^<>4wRFQ|}18xKqM!5WEAjgwUDkn2Cvzqo9KXz`k(QHlKg~`DOfF?KYTnC?Aa@WuDC$rhrkvI^brH5rMR(9_P}tuZz{rBa3TpXaU61?VfqMCqf#(I z8Blwq;rA{KQEz}0Xd$Fe_N2JQN5{(loPU`m9Y+Q-GKsJa+KesZze1>siG2sim!_SK zC;sC_Nz?BO_Q=IBfGuflmX)=~{zJC6!1KAb zjUO*$h-fs<{#Sa{l6pKm$7u|h=`={{qoJip&+IFgUwVl|#l}ctMw*mhjO+zHaBKuJ?o4H@ z&qfbR!L&4hF+zL?$pZ88N_nwd2lpIwaA{9EX2{h2>4K{aJ#k7PQ$=<1GK}8`kL1h6 z4oNQS@RwGXK@$AWvcqy^?{uld8u4LesoV_vE;{xs1tUj#SYCQazJNB5hK-`X$!{l_ z`m(AJOn1*G`=q)E9=rEc%K&WsPtQ)1G3SjkoFgmNymU;t=IM2EXo=-ZBz0V>oORO# z;m$ZFBgzg35=)DKk|tjUREqI zePZN`k6dBp1J~T0#^S1uqb<|Qf2@}Bt(C^nXIpKXjJ#&JOuuHz3H4W(BK{i~Po`=} z$a?idj6Pe^Hj#ngq`+XQ6f@Hcvwb4ce72%Np9TwyLrA@R`puLmYRVk5rgX!-xttUbg{`Q#XeBDVClxRNq;Dcrnf9fA>GK z4vqq|ASHV6k}pbMs2J6T#5J$$HEm3)p_+@v7d6Y!1A1xAG5PV@kK`yAyCGoeJ_N(~ zwX{rmPLsz^kSzGLB0fyaR|P45 z+7~Vo$y+ZnaTd7!wQ}drek>3D;@5@-+A%&ja{1vJDm_p-Q~?{icCM#pows(1)8>gb zhOWsIJv87W=lk!xECmg9G6GIB|M!w>BpK>#?H^Y-uGa;i2YNe?g204jxZCa!>=M7T z>I139954*@upH{j9}XHO|L?MEjWb$*-l5-;Cu=GY>6MuZiA|F1dTNh!v~);S<}sOY zvE?RRE96U3$CQ(*Bu8Z~Exl(+pLTe;kq(TyvIIg z8BPutU38JmhkA}*Q~Hd9hRK&S$7J&JkJib0nf!&#a{LlyqP-Mtpg2L$c^$t}14*tp z@R~m+!sU<2wLi_x5dTDI;d6y4`EEE?uDk9!6MvH?29(}=noIP))}z<1u>HMec_uP_oG)q9 z$#cEWXNu<_^fQ01Npa9JadENo;jFpoHW`&OOya>{n*>H8T#4hA-uwMc zUFiX=6q?Ts74L4}C~IpfWmamMtb!z$L9>k{*UvFK)Ww#G_@pD$%irf+>eI}Xgr zYi}Pm{xD?T>a#ynX#iDm&ph*tu|uRgx#D{1gVh8>Zo#E#Tt$DQ}|#n3kC$et3Zuc((z z4{w#T?wTkmeUl|?WR_{SC;SzzyQ9Lct*C>FI@;J;F?cZp6w`ycK6h8vpL?N}_ot3< z5CE5e1RO5hG|^Qoxf^tsP|oAsXC1xQH;e&^&Q3SWGGK8tg-8`ao(iDNNTUM@IX(a#jD@RR$K35ol978GVsUCZK zG>^M>>9bRD)NxL~WF`2Jpu|)^OQ_Wv&?n6}lhu5I;z(GXuT|eK)Ro?t3ztd)l3N>f z6KWhhq0^{p+=4MqkghMl;DJAUSv1;?>lH7FIoNs&<|b$QP{TOsm%9^)?Sw|%Osk(> zYXbdJBI7F=cL>O&aJ?~3gyo8}JNOLYLL=?Xf7y;0deO4scUxrgJ>$FdgS&Fx?y+9> z3ngz%#Fr{jrf?99KkYJ=o#H>*5B$2~xwkLmKvA{#qy0QkINtI{XyUU$6Q?^p7zq&u z8oi5;9bj#TcO7@3jA6n*S$&{1O{o!oOx|!;nx~qM#^N7+^pWuc=gXn3!qmXuRQr1} z{5D89{wRJd&!qJ`9-naV)o+};$Ry?G=gZQiON}YQyYIehTs5!_isuP{{kWmHGOL~| zKEcA(@_tl*%CcDWaNO87jevcVyA&+rL|B&eOQEv1z>|L-#%*x5fO!cc-xcus@@I3Zq&f4>o#a(K@Xsa#emnHOZpxp&Snb&v~IDOUiXO;!V+ z1dRV=6tz!zpDq*VL7mCoKjy~g><`<=_Z9AT5?($0n$UqKy&HE|QoQy3u^zqWu1+0O z5t=x$ci3;F*)x$QtOdhTE3yylKR)v|rcUh16Yp@_Ibm$Zw)6uqq8*an*BF!s^0j>; zRQGpS519&`f4$+(XUs>t9=aCcCYO2h=6O}wDO|cZc9p5&zDL zhZQ_YShW#9?IZ0|cEPG=)*9n#JWlQt7QnE&Aqe~{n(?svx55AStnU+Via zL?59Ec6U(eOr{CWC$z_K{e?b{;RDT~3Vaa;xG&~yl2)h#S&yr|OHeP(O(A{|=|`-a z$6apeJjaimoSYnE98FsF)NZA5x}l&80jl~|ty(3;#l;40chY$m#Bsqk5+C}oyXBT! zjM4kG*IsKJ6Z5{OHn_s^b*+8GBR>dfS4Nem-uG4hv-q5CbEO4d^M0sFnI!r=dl|m1 zNC$-N@7M{Nc`}G|O-CDa@pm@H!&*(|{Dotk zsy+vg<*c$hPKbvg45-u!HW!(?8!MV5J}n-$Ui;yMv(dC2*+NR%-qz+;NZayd`}=uP z`2Jzp4#%PgHXM|eM$2D^gO3ZTuFrd6eP^6h-hcmn69t`Lr`!rn@qV{YG!dGJ(8Os- zWXf!8#aH%vcx~QVQze_=f6Am#ComuFW!f8G{IeZ~zY+@VJ%iXoq< zx?|Gkp6UwceVub?^F)74+{L$K$r9sGlj{echa+j9G$Ls3bI(0zc96dQ`s>E+i}qbO z>Nyi&P{PEty(nMSz~|Yzs&b(Oib(|~=EBRL;F%}KB0*c7ilWL+!f@PoS0`Vv{@gux z-gAt#nxi$6F*;qYfAbm{en}3(!C0}`P8MNMg1|(TT2gwF?EcR_soPU0d!IjG+7Xvz zNx|IlfX=oAa6;RvhGUJg`H}6?1Lj>@AI_E9QW})|w)G02nlmCRZ4kHxnMSJ=<1@Zp z=N9#D>VgPONQ5T3X>5f6R==nT;=SG5B^`dJQn59C5zaL*akv(ES2UHeAU)a{2~YLu z`rvDhS6JM>f9tKc%6<3U=a&yASNy_ptxO>!E%1Ylc3vx1tS~MY2;Wm%1Fc)@;m$<* z@#CDfeED)CfeL3mf#UU9%g^^g2@}&|xCQAK8!s{7P2Rz|8LyDg`t#0$W}fs#Ho-N( zCx2WeE%lakg!jo%QI$so{6WIC^Hq|SlAdDx9??7aX-|P&NRiC?-3;VTA3N~co zAjyCftY<8O2M>yu(dUjdUclMbP^Dm;D2yEpj^i&FD;d+%q+xTT^q!O|lP{lWN!!RN zhl@)Kdq&JU@ zr3Lm71K|eYrII3HT)pl}ocl>@RHbpNy*>Pr(qJ&_gW{{SPG*I+PGqFCPR(;Nj%4JR z=ueCxswjDyJbAKlfx!FPR-T8F6b>UX(58yM@mLRiVlnCSQ0h1n%Bq@rEn-^!*S=h7 zg>R?q#AJEu@Bvv1A5#9NfDOiVa8kvz>bbSDd&ypDC~lNPJB~HBAr7pY zZ6Om!hUQ!Zpk^?3?T4U&+X`wu46#L3CHsqU))B(%#*&r=$L3p>6a{f7w?zK|5Qobh*;@2 zF;g1BU@%@>dvv?;)=8!(9_p?3Hb=;UKqnNm)<~MzYG17hrB^+a)t5~-3H?WBLE40P zc|+5kE(Y|uhvLrLhKSez4{cC53?oAZG&Vj~28``5@hS0UV$st+(DX@g=zvje*4T^Yi78fBd6~ z)kcSpT>O=Wg291h^ye>b;m)V{(=>qQ0%Q<%9tvk&S`Qg0O1k`U%@At+Y=`TQFo}z| zr0>Lj^p^i*JX4I>o}n3;GI7vQSy!-6@?Zm)1oMuY&zfa|CZoYV+ZVLjjtx!jog^_S zF*5uo*%F@-Z^EFgdt`&O*0jp5C-)ey;yXXsEft3lyA4c->1T*v%p>jr~{N~gTzd1vT28N=ioZ(2v=98jl6}B(TGm^cQ0nmp*V8lB$92g53#4tH;QD*t**CU6^0%y~ zd`b^n@gea-;eHvP(p&a5)XU<$EuM;;a6e$llLdjCz6fK(rH@RLDPNc*iG34fFzkXT zaoYE@1Clf?QO168wB)ZWM80|$KwI2Td@?z5OJH#VHr;gt^_dhR1I7WPKfh5$oh)-? zS1}0VxbYzFPgyfKL&Vp2J?t1Th3zfUTE0`-YL7@%LK-A}-k2!I%R`%*OE*jXrc0$~ z+zbR(9v<9F)xp34#h+gLM&4r%_8kdM#pnzSyl~+{$;rtvWlZ0CEFJ8F2u=9ibLLe? zXu@NEDGh{)CP)ih__$#Fb=8Nm0&&86VE0=B)J%_-9Fps@21zDjkcC_Nq%=5s^k`#y zIBwiHvuT4;VD3tzdjWpbeDcXBCM*l>cqma}x$dD+k3Al?2gF-{{sPtZYB?VDo+lXg zyq@xe>ppi%He$ze8yH;rYHV>Zx@vT7uSfA_nSa0bsw{eciEPcwm1Qee$R2o&A3qv? zxTvZP;2qoBs^|7P13f2>qz7)6`2C9a=uHt z*JVF<*4@n~jJ3x=!XG^Nkqn&PUnX2Q&N#q~O|XLYc60UK!Bf(Modq4OjZ(YrhY0ix z)z+M6U=*L^fr+tRx{)|l?2^_hFkIyyNOYgM5|c3n$KhbUV7!RIX&52zwIiQZe|!B= zX+FGCqEZG+T>t5gQf>yA!Xtd6V#F%!R7~i@&f`gc-)>Nj&_w6^(6b0lXivB~b^}eA zxfOK6#o`E}$#YR);zGngsC|-B%wpkY__{$buv_kEkX!9{?b>D3b??0Mj&Uk^`0!!* z@|VACK62cZ39Qz@aprkPU$#C)*8@GJ=3uSt zTYNy~eeWEzbI|OtgH6~eOJJOukF1lnW7uI3l?p~TP8#>Uj#EV09(0ZaExum|j*ipz zhH|Ofa<)Vz-!47khDclWCTTu&r=(2VVlht~@mj`X<2Yf_fgG6Y`Vwh6_ydW_{I0}h zO+`^mSl&RG0qwirIPmS`(;FdpL^F^F+D#FfaNBDUn(#GdyN4!pZsiyM5ZHOROZsly zJqzWY(xAfUHKj{arc5zlX-H06sQCDJ$;hyFQ@g8=i!GC{1=n3!Z};qYX+B-p75DC( zH?$7=YhqAjGM03$LI&zoC+(YN#9Q3;+S?NSr7NWl3`hQw_oU$)cN+9KO}k4R=>z*_ zO6C<8%Df>tvi0gX8Qy<@S7yWxN9*P?LJ8JAKl{4OJO4)6UU3w0?t03$C!dq7%zhr3 zFqUU>_wG!e<5?^W#YbihH2GZrIO}(PV7m^PttKMQpTp}oD<+fD0;c8ak1v;LKbS1# z`4y&GyPE+r56s6O1Nw5%Dv{W54Ej_%ZvWZ?vip<01`ZjehMGp%`cAGP#O`36Sdpn4 z?~lQcM_)Ti%APEj+D&zG&ONg%#tD67?~9-t8FWEwa5W$KP?`(A0%oNZNJmL?;eScX z;l+UJAPdLARO6WYd&c*cgi&uwR4+)0+G@Z=jW^dllXPPCu}GMKO?6?b)NOx4nhM?m z!*&f&I3_h4e+P9S^v-0E90cHOBCo-49fzchc2>vRn$5KnS7*k~6X)0@ypxpdb@Cna z7omv=O?VxCCy6FF4(&fmq4-bdO0PHu`H-;5^w{g5T8HVXtFDskuDed|yz@@8d(2%G z#Fyn&^58B{F!u;oaiWt=O23#`k5N^Dk}K6K zU7}*5q~GvNqpD&N^9)DRKrSr!SGfI?Wz|7dyI86DbwM9Q`w zmGy2Fy_5#uLfABx9oLgbu#`t{HwKhA#c5T5{_JuIZr1gC7EsgTBXk2 zdd(woCPTqvcf_cq^y`^to-rTpcieG@j2bn{#LFuxDw4}CyUa+*+~H-%G1zm$CA0R$ zFMd%LFJ5d6>FF!#v`CIQmrRVT%ahHS1Ei!CTAY;|rMU$k+en^S7=&1Z1Py8(W8(yI z8YDf@X1({-Htp*QFinGQyjq51m*~_%*;0oH5i#hiMC@oJ-(Zr<0M@d6Mn=?^W8_fi zA^gmfwh4?;6gtkR$#72Z*_yP06-5>BpVT0Gm+h0LW6ctu8Yc-U36eRiuf<&XxdCNgRd1rJrpY+{cNSoxNoXt4eusq27STykH2KB zqz&w27)S;;W^#RLuDG9+Ye;co`s9FF8UUN4x52zrO8fw*U1Jc%+QzJO!NvAYV$#P+ z^7KuRJoUG-ILmY?(e=V%)6rbA8LGN}8>UG*@TCO?N_xgi^3;tIoi@TM<*_lWaXglXXt_A!t@!CEw z>N-K!1~0$-vQcMo$KIepgF;>(6gKPKym_-(WLfu4*!MI*LP8JWR3p;O0+}f?d8*E1 znQ$d-@8H3M<(uF9rnCKa{K8dNpl}qoRm-ODf4LHZtb^>Us z9)ErR59DXxxz8|%3`!jhul7{WGLd2QC&i)eIFw^J6*6N-ni{3La1ZSE96Pf)bR0-% zpOM*Hx^$^*-MUp4ELdPREBI4apm{nunm|kXk)Mq*YB4lW8)h#S1<~L3|Kv&KmSfT* zx`%A6*(&qyoo&w&)Hz=|nU?tEco{r(pcEla9F5ioPah;h&l)TRi;Cpfv(+-`>G77d z%c5Q9O9-k`4~5u%GESTy$Uyea>SeL(o<<$v=)j=uPj@DT-!od0C;h-;n4%a82FRih zyCla1*U{Plbs4?_V-h7QsjvB&e0;8D6n~Ctz1Ia8YG|#Kj(Th;NXGj{ESlrTAtLX9 zzQ1>l^aSkVFidpr`g6c;t=cE`o2Np>cdztJnl3FRi=c9RP*P^TDAB!!pav3Da7KhK z=yls=geLeg8leey1MEzs3C`8JNW1ol-seI{@8tFM^=4-t4a@bJYZ-s9Szgy9x-+2x zJ5_bG#p1$G2^Upq^h2f6u2AdrhMVHTJoa;MWxD&Bws#D6E5GpPN1cipE|==s!j%cq zGCcNiFj%g5o?x1Tyb8~rmoTP4O&AZ`B<}2M22*s&@KG}JsxL`GJU;M|v_5;eef##w zYp=Z~WJt+$a~CHW;czp*VP&2)#E5c&&W3Rf)tin6ler-yG5Pw5vgFNWa=fuaX5Bw6 zJciVGyK2kSjIc46{^>%qhhV%uuJE-6MEqYCL8L?*lR^QBHd$cd$DdqozXGNFDq?Nu2bk#Pyqu=8$1=VUoPz z?|2rQH4O~Uzoqfuo6=hPj3kcv9d_(Z02A$q7ue;?#A4)nLR}cs|6xeTz`!+^K;kt{ zdZf)o8HNJI>q*y5_}KMMk8F^uc>y zyIua@pB|F?zvVDi2RwIuMJXXe^^}&D8Y!hpyWHiq*B9t{@U9A6YO)V5`?*Ut=cQRx zz)&36kS~We9hNrOBn_H2Kt`S8P}w+h27lrXkCsM+JaM=QXlrRR#=Lak>13;eug*^(f?ufJ$ zuaLIN6%vzmHJF`=M&d(B5h&j(fJvbBSiW>LRv0M~{YIH*xbIBN>$q+_@E+`~7D@8N zADQ-gei0TPgi*iyRcYFDog|&LQsM{CK@l);C*bX@?UbF^$DjS&6G9Q1aP1lEokwV* zbL@BRq0alC1)3lY@W5j_k<~pRU>Xj_siwSEQv0Py4C3I?A5PlfK60$2+CSBnC*ZdGIuN-inS}LQ z87E4WM8_*LVfGDrU79c@yd`y1qo zlGK^MgDU{UN3yH1+*B2oTZWl&(+Li|+Nd(yIuk0h?@EvOA#kesk+d9oL{etGVAO2N z3=x;+!yija;cb#UZJTkrc>;c{i*TW4i_cyt@k1A&ugJiX337vj0nm9rHggK3P49p? z8|DDr`Rs(cPT`FRO}KP^geJ~dn$X2g=VX_W;r3F?Fh1UXI9TK&O?xMm4!JE9#7*Ml zD#_7ng7d}bDV{-8?OfEgU;KqtR#s-14u*p9w@fhj`BO%5r;YO!Q)f%*h;cHocbaTS zNPtDV_ zZ+AIro-Q|W!Mt&3iRdv>x+i_<2 ziXKv3S|cm}yjn_DAC=m|Iw@RtNcv6gE2(|KF!-b1Isvfz8^le2R_Ai-Y^ToK9pglX zOC$~IcssQ?yg)Z1FMU+UIR0ECGW+jkO!@j9ras*vkA{4W)N zNq|9gayJ>Yvtj-uwBtB}6iW}_&%xPNjsAqHulHQ+cEip%wg;)LrbwFdmqjii`IH$Zxsy#^_aAg@Jp3q z)qR>tojArKG=W#qXk;zwnh0mkCEc=E`nzvYWnt$WQjq>-u|6M4J%g)X=JM_rx z1yZ*ik5JFKy`MHqb&w4G?X{Pss2&1?);8$}WAEo*d02)HgopVlSSOGe5c)e${7p6& z9WWltH@x(k%sOwLoO^cYw$9o=><2sZ+g<$z~*xd6~Op z_BUoqZ!l4s&;Ekw_lAoLT?EYh<}`VG!4hdN>5vOo&6h#r26kau?B&97ZtqC@xhrhr zp9c&1;hje$5nj5rlgKu&narKxDKwAZYWo{3|@d?es}J$xWFNDPdq&2BQ5VSXkvcZ7EWu>iaL#Xux; z#9etE&DCayoFyfqpO)j&u;)cc*777ebs~1Y^_G?+{{mAp986!bv{rsB$4hdtvvC( z2SsS&jHd}MVq^-qgY94c`j>F$9Jh~u=R4n#oSdA_Inxb2=`9-ja@#p2Pu?79YW|aT zRC;H9x|Z1Q`NBiX&_w}v^-)rC+ikZQFXOIo^qT#-cI{fTYpoeu_qi*O{m4GnJihAf zuIHSlW1wDZ$6U;F<1;BK!|ak%w*hpJIw`%cR3;?K2spXix^S)}!$!$dVw<`o!0lm8 z@?CCg+gT6Ky)mI(3WjjuYT)8GD86`Y*u;y+OWLSDQubK6)bFpCDc4W37$-ZjbV8soNKyyZx*T!35wd@ z&|gda_Ai5(coq|ACZsX@rGCo-X|32{<<~)>O-1>bw6g#o{46Co9SD>elPT?0?;z&f zq0TZKmHZh*Tn3hvtK0sz*BpS|)2FB!3=8mVufq-%?2t5G!W;4-Dcc71BpAP*Fu-p+ zCb6)KN}BvEF2Oi48N992&cE88&O2SsP^KNytLDPy_7sWS1 z6WSAwV}vHoc$&}=!G*rOyj*(q>ScDZ)xw^|-!y;zd=t9m=9_Pp3of|86w|fGUl`%e zr;9b!XRo~SiY#BgTv}RMFeP=ai>`IDj7miG$gnKSmMt^8`f_t~W$)g-uEor?!X=YL zCX01tWo5~Z9Xp)PJ+)7?9=&!8FpM|36OMKDP0x_O{?|_>3p?RbU@#sJCVA|{*^;|^ zmpuB&Bk~G%zU2YmYJ^(Jt*@2Mhl`9|RCR5QM{L;cEO79+j{Bd~%brlp8 zobWE#=lq4MUqV*f5oxOD_OHs90oP_h!hjtSQwKREpeHXz)yl9^zcqS*Gk6FR4fg@)4Sd&_skLEaD(7a89MffpOdD z$$ReHxiWk9Y-emTPxHN&r9tt~p+hA*JNu;UeDgro&fB_1a3Ox~x#xsxG^)_J6OcAp zOs;LxGWPpCryGQ0$Br4bB)8UIc;SU+rB%Oo_F4PrhiSvj=Bk(Kdo1v zb=Q%8n8?^M{pjm=NI`S496VYo6?@l-#HGo=lwM%+j>yI>o23zUP{Wc_<=k--C416% znKf~;Od2;nB-Gee#!2L^OfsZ&Ye8didmm_@*zbi>DOR=66L+wUzif>0oLyI0Cv*?M zq@C%lhJ;iriZ=5kq*xBLT=R1PFtO20;TjNXNUoADsuETFIdb-JX@CRIm6xxPxT$e+ z`3rL;V+g!pQ<|odF~js=zyPhL!X?sD^mR!&8)`Z*I`o4SKWL7$l&6{SC(&uoNW!p- z4gM!A>|_AIEJY`0O3Ks+q<+W0q_ylFIUWme>)iw4;g&iX1~L;cmjek;@5l#{m^<8%psT=gmvj?DC{f`N0-N&Ar*>(A1HO6 ziL$;&O@7L__uVp?y5(1{^_VCbKA34#ctZbv#!X;dk90X`2KtZ9&bQNPbxl3BUy1H5@aU+wZ?c#bv@8VqOsgg`j$J`3IT8AB;u1&q+Kk3`w{|uk8knBo*s&C29L8iK9Io-%0=e{hfWxJ|Uw^XQ-7hUZ)55 z6d0pxxnS!K-Bp2ojk2Bliu1EbQ45+wUy1 z3r)B9_l$>B&Dc75LD0dBwN~uG_Wc#GnOX!!;X+B7d?%Q&U9dNL8HFJtg-WbPbT9l; zBysdtEJu~f$ejRQ2d2e%p71!38;&+pQpUJ)w8LtvIV`p7ZiSR=9K3+S#tr_LVh3J> zop8fpCpE$tgNMY(IO;s!-YnIt?+33|id~3*v)T;Yn~FX~U%dzZ75&oD0F7cYY{mvj z(wLjkKMskQVNL^SXoz`jbYSP0b-t0akqr^mKq7Og(uu+lHIV71ZGIv_W9lUVe^HfJIjKsIV+c(_}(Caq?L0^0A zwPEx8t@Y9-j#5A}vD2qdH;fsXCNiBHHf)e5pM26V?sSTJ%PqHbVXlJdgU}^Ujx|{u zz$248&eOEM`LHgp5 z)_6w^unagDn!{GAscC94*NiZDL=X0#V}1+kq5h8<1i(q6p?4C^JR26k8tJAh*~s>bdU z7f>hdGC~s(nuyTE3FOAPQ`d>kdGv&A0pC!VRDaRG4^?NB?&$r10Xhn3dAdoUk@lD| zV}wpKnY1me=NsSnhNA?hJoi!~dNAj1!IALRP5Y=hbLL25Vxp0V5SI3b9-RPfCxlIA zfJ_K&$o}z-YohLROZo^o<>jB!49xA|h82$RW>=FKzrDPd!rLaG~?JoT4(=;t4;m;Ewx=1gZPJ8X^(N~LIXM>{p1s|3_pAi$H5 zZJx9~?JOSkT%Uz<1T@*UBv*15@07~CDyckNW&BC?9@Janlj1BU3UvmWh~t(;+hp~h z)|kFLm3oDd#B?+jz)1R9 z*!n=N2Ir8JO10Nx3o2}rI=AAxV9LP;T-uwCL9(#_+lA1Zk%BpC>7B%dbC>B^{>{${7ht?-hKC7BXy#*Y2w6*hGArznJC@4 zra!I6015DqmL)9O9kIX2%w=ZcLmG*F#(tpvn>}xU)ws>hItf#M z%*1RmN3@;$Sib@h5c2QxKJUEMkqn&h^$>A0>O*P$^n-Sn9UbW2aS% zjQaTq>6MAC>PSxeBac8&e4w2+_3E>v`f#o6xOcZ?+>$1qAxUL*_L$2FcIts7r161wL_)2Nm`HG z4GB>$^24`^qfcGy_k3*?U{Kz+YV4@1+6*aE9AeT|E`PKQWaKCTV_r&dZo26vdGpOT<(Eyz`R5UzS zMoP=`$fP)#3;fx#WsBLVMq40CW;DM(_vff(Xm9lP+ix579NklpdAjSayM*>`YO}?> z$^`lY+uuBFmuuU2&H7Ry{i3SQE^%_r>u)`pFKm)01sKwi3xqBb3JBMf`W)E_FWtQn z7bmW#O#I?_1pN(O>O|1&xc0VoIj}Nc#@;*15J1fb)+x$bmm&f0Jp_e&><+p$}rx$4lIxi!eUaErRuh7I-D6SqXNi=~NqD zxQ@_7geJ_0IKyay3!yI5Y`@OSRDqFk;BG7K1Kg$ z66|U_1*JIXwYwu>5l2d`lyRT|^P`VGY8WE!w4-!{%$h4aUi1F*&p&VcI#Hs-{FEw@ z;h_;e+sZnam|ue#YhUS+&+PfOZ{Kdze^gDfjfAQAxod}~dn#z4bnV$^pEXPv8BQ{> z+1c4fU8%Uaw$BsHQ0{AcwNAaJYEREYfzPt1h2)9$OXh`gk+9ysSupe^Ha9fOfJyyj z{+;urWN)c7R5!qjIV4Z6i;ADUp)ZfNOf$YR)i}T$bKXdJMaMRKCJeAZQxv>_M~USL zys6-2Y^8q{>O9&bbx70x8z4b?5Vk;5EU=D2Ze76lL?i5%u=T%349bHMYO7izv4g$| zA4zu`h6J5swH1tmQAKg`!>;cv4=P5;KB0>{B$Mcy+6KF5zZe;*;9@oW?%nc2NDRJT2q4$0EqlXL%pDIB9 zLP?4As_qF*M!0bZuaCOthpANi&zp=~%Gw(?O+q0zP7VMa4uJyCxcq zGv-}fBAh#dk>mQWgTX(zC_qNWaDE_;1W1gM=RzuT0Dz(-KId21eTTSk2~a07kpXZp z0c3_^GNvK_C5}Pr>NQgS^b{tHJAq)#gG7jzaM`0tiAL=>SNwwD? z79O_2M#UKkRczL!VB!uz>a5c2Yu`A{cqxS~^`GCZ~y zLZ?z3T~lCO-4>3mW@4vN8{4++CXL;svDw(RZBK05jV89;Sa<&Wavo=rv-j-1*0(-@ zCkHs0X#Azx)~wL|0fo5seFDZ_)q<5<&rn6y2=ZB+o6#_+&+U;O$Y?ita{phFP57B~ z2>|cb!cu4jIV*97G~G*9$Hw_`22E1oSwW=>EYiX(5LJuu^562{-a)E?-Fd2>kc5-eyJ#rjlx`Xl23AtH!{xs>2tp*Qpt<0 z)L(oCQvvl{6LxgHGmw2Xq7G8<(|Z+lnD4HCl;c+BZc3mT(baM(k|o&g^4c1KFRE$% ziMfDDg~PXr*DaCA%CWE1KaUtfLk5KdaAEJ!i*QRGFOvK7*3XQI0Raub&Sa6~%>#>M z{~_U}!{Ei`A`8OnD-4ftjw&2zpSMxOK6+6{{kfv#{&U7L=xItRM~U>Iyp(iByJ5xO zioo|)=OT13$_%iYZ#~nRPhbVCJ^Pvc3Mfbj_3tAx~9MW_%svhd+Izk zX;p#i|yXd9-gVLN%{Zn^!iP}$x;*_LRRu;NUAl6%b`Qat*4DKZIUqMzOVQWF>w;& zBDd9xfhe4BKwXv%+zdmjHZiz9Rb_@>6u&}VV(tmpb_g)dco-z6n8}No1*%!AIqNVVxJ1Lzie>Nj^^ASJNfOvCMX%Hfts98RP%lCQ18a< zPaB1|pA#RGWOMSW*qGuJIhF;xMaGwil2c3=R6DE1;bw?dB>D$&D|(cJkwd*ifH#mo)Vz^H zgkmv}qgCv1MWJk4vXhFI*?`_FeKB$=7#5W5(3JWbmGl1roM7lBzBoYdDJkC&4^Yuk zhFOr$@qS;1G&xy&%zZ?#(+GH<$crL8E6mM97kui)`}KIX%ycZF<3I(M^ta5Yg(+$U z*VJ2klTa+r$8bjK5!N}i_aQEQ$4-da)_}Q!SIZllhLsUzUw-i`zMzlN@ty*))`bE9lGRSZrx9WXeap3 zVnWv3rs7pr-}*UMU*{pM=xq{W{ocRxM{*Is@Zd4aLjR&C|MPv&_2oDz;E7xhLER0H zQ-3G#!hCKd9&U4TX2V(Y8=w=1AdIlY|3I3a8A+J;NAl!P}!(wBeIKl zGT$+Kiu-V>z$Paq?wMA+omN4x)(i6Lsei|bOt2~(j|xvfmDNP4{)3N5RnKUf%g6m- z!B3;ef7)*8S95^hd@z76#6B6wn)9#GdBbHHf00NZkGZ~zHP@)gh z_-p4*2;rZGd?cXVloEB^Rfx4Tb+g>7{9Vu)UVG?`GE2Q6JJsVmF=iqLL%0v-fwW!t zWcwTl={Hc`NH@_XZ&3u4^cUV(e1&W7vb^Fct<(2?Z64U5bJ)qIMs2`3$KS}NBf^n5 zPf@}skBrayHZtA1XS;%k3(aq@s0Fe9eF?BUIUBIy^aQ<0HofuyOu7p4qk_S|L?p$x zt+R~?ImSbgnCE`-lnp|U?2ip_A}rDhD}_JG!s9Ui!g?S2taKNDzcQ$0m-ZciR7`lL z`d7nNtK&KKIMv);vjSeWI4W=6Y1zL8Qdue1ybn5>G_U%pDwMN#I`d{9Z8_D<3pbG+D?h*JK;n5!9(WXl2#5-G;Gnhmsjv~;(%(X=B&n|p@57_=A};n6$=E)65|#L5 zNy2BBpOvedNn?Cz7&SZ@+Wvh>G*p$wLTq4&J3vL%+;XU}((J>>DO!o9K)Jm|-u%P6 zq6qbp;`t0I8ac4c@?6^TXc-p1t}v4b6EEe4&c!H0yT6_m%G_y;+G@q4mQu-MiCN|T zM{Vk0{b!I5mO%YH{=wS3?k%tD`a61m7E0h+Ae^+T06hnE+!lKCXTtOp;`p{?vhro)>8O7Frls_KvuOt6yTMF`H{5(ks z*xYAnz}LiJZYew*^Bb$GGndFc@$1-T3$+@8pJK#Rq7VZ38}1x7X!bBKQzwXBer&EX zb_lK0VXx5@7XW3!PV91^IKlbf?j`>S1M)iYzt8*8>!BICkuEd67+4Deu>^w*LxYAg zPQQ}jn7aLlQj?PF0xpsS6i(7~&NYoad||;KF$sYQd}( zm${!i6OuUu{th05pQfEK=tb-HiXL&0^(}i~6HH0cp@<>hIjs&4nrbGi&&hiofZEyG znijmWtQx%R)0aFIH&7EO{8HBXM8TXm<*rot4(&#;A2ADKAPQDzkVfP(Wn4?3>!DZO z=c`R&PjiT#(K!8^WShae+DO`s(^+tLSx+C%2D>K|S<`ll4KWdMf2R*|cwX-LFvBC| z{V4jRY@+yTa-IA6CY3_3WBdoPGEsrm%QPwCi(G8Sk#i}bgGOsaAxR);?hKP7EnLR7~L@n$Ulj3fYYstTW(vN}hS7pp z48}xVBcSV)VaCG{bPEv2XWDQfr0y5vBDT&!KAF#i2+MW_PYIQM{$xAF7RDyz#q>{i z4Bpg1dm;H2L=-Qtb47JP3@1j)@)I5k1;)d33WG)r^D-j8{HQVS8AQ*xx~7hSs}~!{ zZig;GCn`@UB4}(frUQk=@j9%2gA5@|D2)lRHO#5%O%v?Rx*hqFaqJBXew;@dP79*5 z8<#q)-Tm*qr;Kc4i`X&|i6 zDWh8QiPAcU!FLTKxQ_L80Km4bQbu*U{p%J3udLCYlwQ~ba+-!hacxL>ZgJ;@`Br^k z;0a|)%QR4^Y+!z9wlI{RvFuo8Hd zHY*p8Z)BN>O{a;+bYNPL7M3|*vm{!0et)*Z3mb)6tYYwfs--}(>}vHP9P>|dn%GC3 z^l*P4Pcm$tW>@S4bJ3wH6_YwdaE`1+mkXappk;X?&261WI-J1mxoyH^=2M4f*>zU? zV<(i9v%6$PkhL2H%V(PBD6Pb@+a6fCmPT_~uxDsvWu2__3Dlf^@8cQ%4Op~bpBKaq zw?hn>nMqM`l9c^8gevFJrSJ(g&+?a@dFq~L8)^_JP*9jDx_Lqs>&7VJMk|S|zgDH* z`i}a#l^k**l(dg;qbw2m_qQ)Z)Q0i7VWX?)Upo(&iVg$W@v!PJIj%WllrTt2dF5Za z+=L~Fm&h2r#m}>tLB>`gk$`Bu2Dt{F}C7 zY=bA|9>{fx86y1)B<+e)GbSE#9V0KX@d)2K7)^=MIQaZYEN!!JWE!xPD`D2KVzzbCmucVny4gX#<#K3y+&5`|6GMs zl7rK5i*WZXPK#X!X7bT!lak8ObzHcXS^kUcl=T>_*M_*@6zRlEnHxi9A6iQAnLbM zYSWkV1u!j8yZi3&)8HA5Y=(de%!XYwXG42Y-5XBGuU3 z3$_%=#>T=CXxV0|Djpo>GCnv|SU8vawohZ{@Bk-glv5+c+HlqL*}a-9GjJ0QAa@r& zjo}P7xE*wW2bI_^{9{sxH@lYY`W%6$dS7BsfBsb9JBR}Cslc+heq|Au6bi9341`IA ztk=Oc?yCu9lXd4qvw#BNK*w&qSw+Ye6(NT|k*k1ADHS`9`+<-mRCe&uBW4OCF`dOL z`HvYujc$e;3g2IN$a1Gax0AK1_zX5R&-C0Jlyj`aR@Y5CrUD2929=~$xPK5Ccu5Em z4Y_j@pb1Ow9EkSgDuVMXF5&tfvGNhGx`@D!cat377|Z_RCid~A4I{=_#nWP0U*~$4 z7D-EzieVf^z2iZp3GUxP?#4^BT+BetpNo1*X~VVC6fq7D(mBLbU!bDy$mk z>c<}?I&XvF!7I}%Pj!OFpb1pNpe|t=ZU$m%qi=TAe`k$8PnBWQ)6*(!$ zkBr|K8%{ZVhEX0mjl{{b@`%1kTK0>T{`VMJ`MoysY>`R*w>vx`pw|081(EdR;;{$>yPYS`a}0l!xYy-Y)luIbAPfXBoC!p!5+rWD`- zGWt~z)yLs_D`AmEBU9J|6ZMN}g2GobXRkWC&WJ7$^#}E@1~j>WnjXsJ31;nTA#I?90^ zt?v7Lohp|R1<-E80DZL+h3xBhz&|lPk3{!el5P&$k|sgGHbZ!x_VkK*-3{~@vp}^e z^3DvRH-q*6hF38mQe|E(zg8XQC7Y#vue#dToNreouQZFJ)o32@gYN*L#puw)v-_uQ zFy5=)V=&$oR);oJ)h;6m*G=34?8PcIqyk)b9z|!-l<7c^do^pQ`DS{}RknLp-Z?`-TW_}CPIQ)^Mz15sYc!@W zzQ%EGOXBA5qRZ+YuU2!{O5A+5b>^PV+rCC$sk%H1wsIHB#AYtyb;7+`^2Ctn3wyoD zq7rJj=47{uD{Kso+%X@LD|DTCUOJ^6mp=p8MS97PR#N0BEPu9vSR8S2PJ_W+o_SMu zxqIeVd|zBo4un#hukdRq6$dn^iRJpCGqfho=p*^zA)yB14$y&UzE#R#mx)$;IA3iv zi$-pIn5wdu^Dz?ywH?Pl%8+gg!#1n~~LtDgcv0w>EC> z%M*KxCrDRBfrTTR`61zbe$cLDv%*2O@7f|#)R4F-$vueMc7VUXSWQn+pmbr&O)BIfuh zwXZ6FBtF0l19Y0IahgJ0uBeZ0Tkw%e3=)55wLWCQ3v*Dhjc7_fc8{-UljSsEyE7-U0L zd$nC_o4Lwi2*EMA>@~P7h2y&jE|uBr>@2SOinpWV>jKUYtJC>Gq2}xuW}m*2Y`x`` zG@N*tK-?QpGy7}7w-utu_v-*pff)fk^2}>{Mlt{v$e{S448k-Mw^EMN#a)I* z^$CY2P@k`U<8RG~B~Qtrj#WH%&4lz^oWnKKLBs8kNlQgfzQX=ZyIAI^nB^2*cr?69 z&CQ5TYg4Wze-1+wN&R2PgMJVVg=ot)X zf}G3B?UFR9HhUM%6Di2}WY+fwwj_GE3I^wgiXZ*eSzY6c>VI1=T+a?%*Bf)`NI81n zE&6HfPN9vXy)sp`I_j5PPS@t5J6^~*0^$_?pGK1DGw()Ix(Z^X+A#A>r#gCY7-kFY zGV7TtMaJ$INHCSzR9*X{RROSsxSeD>wQXp8`eeNpZjj%MOZ@eJAxSjG$$hN_MOW(I zkEdH7_Hx~hkr!*rTGT&gd_RiZDDSH|6XY5-8rR?LrCIyVKLuY-sC46IaX^3isPgSl zG;`D-0lW#BI=(8F`?OwLXu){_#lbr%&t|K;i|_O8?mmhu!vFq!>+|E0S7VUJPV1*f zF^NNhowu~cuU&%PYZ0l6)~TUbr)vl)BF2zp1np#?C^=wt81f0LpUUc{i)wUL6ueO#`YvOhkgluU{D4~W({=Os=4nnnAa<{uW z%Ly9nc0Y|k@pu;X->)=w5V~Gtq?gbw4tR5oV*Ne(+@fE$dsTJY_ai-Q-tZ+Dt&~W@p#l!!kvfO=z=zyxxY^L=b7PUC;W}r21 zwAQ+gl{{>w#d4&RZs(=(bX-7Ceu}+d=HQV`#HZF>OazFwLTSpXIrJ=o8LC0 zEh@<5Tr15K0Cr3JZFZ+H^1D+kzV!UmP9j*>taF5Q!?XI);a-B){a$K!q z2K*}*?(zmL<|hOSiR$Wuxy^5MCm>1!v4h>m^>#P6FJvqX@tjV9pagBTS7nyH`#R`1u21stL8+b1qM7{0CNsz1nPW;*6`8X)T4U7@Nt$NMi?9CJ2#Fk5^I zFxryzcjvz`N0lQ_$z)11eJmREeD8TpwyV-~J@RoWwk$89z6}R=6sISnU%%^4nOFjz zJ5Oh+Z{v0AOY?gy>|tOOvba@BcUwo$m0@~~E|4F&mlzzv7&Rv#)#!Z>F*fvw*ym>L zwOJw)#wL1&8J#1@Yak=b)k;rytzA0>9@m{NH@&VjJT_g|Y-7GF;zX#~Ez#94Ay;Ee z&mXDc%;R1ETSzB@bcEpC1cYMm(aV!!`o(#$OmvNvTvVyhXEd*LIkl|(TWytDni$Qp zI#T7jjndbc07hFTjq|3qfqB_(V(3H#P&MTh4rf}nvsUe=(Tg>XV#R0kVkIH0yu6w` zeLqT)DpGtYbxYG(lkZ8>UkEQ`oAC>f%j9@nW1*ovZie=Dy)AY_2h?per@qYIrevUC zBqc#mZSU&pI0-Dc5WT3e&|L>tX1O(=buNe2RK#|o?QffH%49xd@7G@Isyiw$oLndh@DzW|Ty8bMp6uAxLH;u`mjg2apYu0A~r9dCMDj z1WnC)u)1Qzd5<971~v-j=y2E@J^`*S8~9zU5W9g{yY1lE!DFL#1E2fkKhq=vo>-lo z!^q9KBp&-;79F!)mUJpS8kiG9yO49zr3g|CIGRw|JDC^y_ANOPaXZY(9G)3lmhwbyX+#A4t3t`B$_$DKi(?7 zTC6|63sElp*P9tQ0;hA&Eiz=kFOsr9x_8q71sN9wY z$7qB@3YOkRbU2M&`*oAaY)XxE*{rrQSO6!AW|Ew;Cab>1e0*lnRCIZ6dAP|Cr*xBR ztARpW>I+D`;*kg>PFoIy>*;yF_-!rd4?9MGF1Q!Pc8XH5WG9dFFo~UtdRz}lv?kK? zx^bn~MArbY>qF+(S=aWmF1g3^)d&Kh`tua@Y1$PuODZ=owv6mhlaaYlugf9oY=L1 z93Y-S@ebz{|B^)0_$NcH#!I@n3St^HH?c);h%wOPrh=cW=m|Ckw}?7!(8#j5%jy}g zhe4KG>NZokhBXDmrQF;LLjp{JRZ_VCgssdnvA$L6MRL$XYr}rhV-S0~xp1x&!d6-n+HHj4{fyc}BJT0$r zyW0FQ*u<{jVyilpi0yf@UaSAuy*92}>Uvq3E~l5<*B~Ikv#nbd^3%%nCdX~y9I?iD z_@?IWvbF>5J)LfgXlYiDAV+W-Iip~FC~=T+K^s<_XAYYIEl;fv*{oy*G$#CmK&Q_v zb32A#b&k`ot;XX@a`pZ(4Wgq^{XBDt{}2QY1acw1-^+?vnWqTl-09hwrS`T0HhU2& zLn22ZzfIQ8HZZqaN_M~9%4Mq>=W%_C9;GsMc|Vb(3TeoWE)K7FTOLfb6yI$XKjV|? z>8wv7?3WS$6xm+1T{Nb>+mE~u9nrC{W&6X-`rQ0Ae zX7LQ+A=b)0{HQS`-}F3ALT<<`Ez%S~^d=i|?$PGD%QPQ^2V_P>O`5MlPh#iZqerA% zdNVw4Fg^_Iudy743cB@W!LFCF*AK5u9@@1jdDFh+3uh?X+P6aJWIWQ5W@N86VJNu zoCw6!tgTrPWT-l%2Z44Se)77+!PO)e|;UGr#4!G}0 zV*@?qDO@i=9N#Upf!y>U3lP=weeGP%?E|U-doryriO-s?4!GZyn&UT-GPT zgAA)k@&2YuQ~$Jf|8?h?PK)JHVvhZSnxO0{HBgr@^}J4W)2>78z#X?L^au82h|xi_ z#v7vTpNOw6k=EcttFr9w9=m~M4QB68G~in0SKgSZ3BNG{mKu`wwYd*Q$04_Ki+1+S z6t+ngfLdPp>2oQooAp4 zadYlUaE1w$RvItZG_4vK;vdiRv zajumxfBbFsS0BNj{v~<=YU(8Xk(JeYdz|v`A!+jNxP6`XuRFUhJOBqz=(|7`7vX zF-u2D3-jjae0h0|gRLB>ef4V6h3#kBi7N@;=%PBC576U-ivgLPjPz-rW3)i*J{l^(C zvtlr<_TK)Nt6H+I+#&tuFW&8Uu+uC>rTfLlwyX$kQj~Y1{JYo>%7i>*SfJ!(p z#RBeEFXq}Vm_X0bG&p6)H|^F~_hM=kD0uU4ud^HGd%uiD4_2Q`XB5*U$~oB6)9!J@ zO-a#4XVCk(?w{*a3Qgn;M>c<6uw?jmsj5hH68;rp*A*k{i!A41HfroT=%Ljh`HLID zs>wk*94#!H90D;sb9ieo;&Yk(y5*K!IS2zK)tc1o(vihK8I8w9F9rsFk`Ocu{7x&n zJ=c=&h4gUJuad|WBJu_^qVE?z7`IR8mpx*+^h1f!rN7MGsrqASkx#7BR;2GBq@c20 zB|DwQBn)_SOz#813YCS;Si4I8=L`f@Be@NUr|RS5(eU1isp zbfrA^fQzb2FkRD8Lqnr|A;xAVN8tXKXzwo{*6`cSl^F)jyTQCk!?|J$+~s_W^i0>~ zBfEzks7JM?0Vw!65Ap8~w4ac{M zcBPMR!`!LJvv>?}Jh<)S618m!jDeVjA|>@J#7BJoVQ+PbFr+n-zsMPKFDr0`zR6}d zvRv~hdz;y{4lW@*hqG<`h6{qos;DhNFgOcBBQtNR601-=kC77@0Q`Nyk8O=+n@OTD zP;{bd|Dkf+&!$*oyXKNY>|7d-THQKaZhr8KCF5BPcdb?Q$>K4ayEk!=;e=ImcWinj zhaw35W&pqXN$u%}@c%cj`TsZXumxyngw*exIVOC~uHz!%X#YmuojUaX5-b@}#uYj; zUg{Nw?l@e@n0a?bjIZ=`OWp(k`w(6Jm`ippv{TrVN%Ai#M1W=dpYL z+taRnungrbiP)=M;hHMjf?u&9pDv6gl?>r)y)>B`=tzob*c-zGDQ1k-&}`g3dvySM z1WD9D6ipGgZrTLKSxF#PZq!Xydpueg&#Fz*I^)qBS_H3gA91qOlZ`AJ!u3LP$b2kp zSaK#!wV~#2kbCQskLT9Q7M@O!$~nNbHgv;Nse18K-EQNhjR*fm`ZSRBfExoE$d|ln zBKn^K-~~Z_d8=pJvb+yr6Jhg+!fQa!e5~Xqg#sBs9Zuy>YO~C9Uex#Sv(^P}9~#<7 zPu_B83FMDeIWlldteLOi-f!8}f--99#m$Cp5;a2P6m@yqAhMN;;`{b%R*LNooP#^o z^?KQ19Zgi2v8p@B`Es5%0D9~VfOg47KbisGWxbNTy~3Woh|O`}Rs^l(*DC9Q$|Q$QLdhsb zFH9>h7zVl@O#`dL4%ve%#9QWbaZqz0kUG;&qdDvbzYMHzL&LSr#}wD7wZycejsMIU z%lKXr!80?Fkv+uPJ8@Y*6f6D0+9%L(R()zSN7O|ZdYXf=OaSQ_LrD84f9++c{>N@55$rVVgBmg1DhK%R>gyJfa)^dk2D7=qZbOOZw}~RdG5AYih4lqqm>pOEIf8HY1}3Evv?vRTt`rurHD zj@M$DO*xf&DLjl7e6PA5HP1B-MJQ zUDRdt!cb#AM7f;*hP7<8ty7~(YkuDVfAH+MY?VrfZFszEuAs~HZm#R_`Lz2RlE6_< zc8Ya1SaV*#EZHPMu{vW@-{hk&A7Z2#C3?~hNm03bRuZz>hw+_5S7p6NRlfZT= zC_h+T@GJG`yr)y|wP^ms`tk^v^(S+}O8GrH`)Gv5kB#{z&^o##&NxMvVw1h{=spBl z9fKF?!TwT?Q!FP$e_2tp`*%o3%@=Ij)>i1!GoXGSWXmKN0!fJFh-c?@z z6|hzon_oE7qGU%Kuc z>E3mWc#RT?Lqxa&2h8X{4Y14XmDzNLjTfk#AtaqOdZ%E6|ob}15Z2$nbfD6#@0D$6{V%ozuUK5X0q~CPHqHL zILUN+Qx&0Rp4EO?o&||G|EOm&J*H{TFiZ$!l=Dw6h8u0U1upo+B(?c~QSQv2*i=>ks|L{Sg-C zAakTdICF}Xbf10eJn+5D$L9O<|QlhtSYBeXweRoR*bK@LJh%C^G#|W_URqxy8 zkZhIusVbjL`8wfONS4g@_57V&$dTB*;8QYqWxSjju!8TASVksWdy{9&ofO}*nVEBvKUnpY;1PJJrKfB#P;B`AZ zQ2KB*lGJy9gb{eMP|62XS`p#}i|y_!rr0o;4|y zpEnG!Xta2A%XHnoh>^_B{W1lge?E&<`jiWStQuNB@+sFwp&XXPnoee=TnkVmEKCBm zMHV>`1(QmNak#V8XfQIWHls<+%AvmDpIB&Ao8C(lo+9H z!G+76-y!1$>v77B4+U6*AJllrC0w`4BSWc32)w_a@Jh>L6Mc0a3`z7ap0|y`T$3|a zM!8Uvd6k4xOd?l}5l<)7%M;EslLfbeDbGK}%5M|=(X|gJ(+eXz6rd%v^RwpqwW&iW zo*iN-CXWi0JqU;ke{0<-x!vzMZ0YLF@=I(wgMo1U`-pO545ykJ3EC50`Clv-^dZFP zSQ5(p+Gb*p%*~$#R(|CUV zlJVK$jpY_{ke@uP;Fh~6tcALS}2FART^`w{QDGfVzx!d|U`{@vO08_;(hI>=t&Nopa zLSX$;z?5W#RMmzb$)kD%a_nOD<1<7l8W$yOEkP-spYG-D!;`oRN9z+Xm5)o{-O$LV zvOyY&H z{BUaCmddeaw!*OFSwHn^dDY6pw$h>{=Kq+8)Stqkh5f~1B6>*#@Bp~r_DAbdT zY8Ws{ehgxX!XfOUyfmjGbXhl(&U7d5q{I0=nv`bCYtIiXVg3IgL2gT1`ExGTx5%c3 z9*oh_*F~Vs_KR{G-j37Ns^?kU=$>+%H{WelK_JDTTD4p#)_9KDKrzDb-wOx>MfI_N z4HlM=(EG6JY^>!W*Y!b8PBL9CAoz_1YLPGnDvE_t4sb0H zduG(j1Cgzeo93xoQ=HGqwR`lT0&$N`zEVI(yaPMj=TlrLp>&g0q?%u+|(PhkldcuTX{2HSkkz!?|!3!n~%y*{i$uebP= z#d|10R6>CIK`r#64RXm5MP`wRxVK5z;2G6uy2;S=EO#Fp;{oX zqN;aczSjU!GnArdM8!j7$zx6(T5lgsac%wGBlwSTQN`B|hs~<-ZiUhJRXVFeK3@T= zFA|ZSJsIYWWwJ+UB$jlfM+vv5_-PqZY3Y0Ij}}EG+rzm2ZB{vm^lJSMO%BX-laN`m zfDpM}(6_TMPxXX{?~hwTh-8N_=nacMs8(l%BEgTeukW zP41(s zD=ebvcgSJwN}DxX8p3Q-L=~2{-CgQnQlqd>P%BQjP!4>1 zAPQDf?0kTagL$VWUboBh6h{41MeZG#md8!7g^XC|_8%Ce?~s*&zbq^OqFdcQk;c?{ zab_sM2r;O?9Omf|#|D1yO&Rjv(583wusGZsLfXLqPYc+rwH4fxwu3WC`KzwJl@MUL z%TPehah~|CPL*Y-o?C_=%JivcP~vx5As>E#4Y7|e(EXmo;N5qnVU~noaVhJXDE*6l zPIIiX&net&4ssbu3EAd@kIuHVo$n4xS>~~S;8!cMtOaFv8SmAW^#S@#1mVId}Lh6ogDDunP@TSWRy>#5oAw&@PNQ!przCrnEUA;AY`--CO)*MAF2 z8`*A~>81{|c_J~SjKIhu?S2IcS%1%ALrs*JW}`F1#_G=#xZScI0YZJR&5VPGJD^tw z0qLB@-OR&j>El(S!WQ056#5cR<{KeJuD2D=QWg7y${8>4eWT=9VfA z%*?p=%{*~=Hd@SRqN2~>#Cl~7JucwY;-oO~bYH{k~AH&9{?-9{KrF`{_vZH@wkV#{%ms z9O5rn#A9ItfA6YGXz%|d`;Xg!=@cw)J05KW{<)?5p5YO!IBCuN z-M#vs%flku2A=Ka9)&YHegZ8fXaw_iu^zi;EH`CZstwSyBvz$K}qFP;l-$Zd5 zF-&2bgBVprxT+0Ktt*!&SkQd*)*iCsc`_R-RszsD&5Fg9&=Ewow7?;#3apt^A&Pd}WcuktksOXlpu zrJ3dxy?p+9zSYyicaWr(a1rRdBpC+KixXy%&XYW~E(aS~3hvLMoYvWyz+^0e=QsV} z-R*H1Cx$l14W0%x_?lh|cNo&|;JR2Qad$)mfr+H=$5Olu(<&5nS~cnnD8mI{HlLf@ zdHo1&TETn$9U%k8Hu9_Wx%bc#fuYU*Xgm@vgr242Y{>oP##%HUizv7%=5{`u$~=0x zKP%;g;t@oY@)#w2we2pfMknU|tB}pRc+vCu0YbOWSqD=|svifbrmJ)siEM&G(Mfao zO{QJN`qkiJo^KCik-N9ir9L4I{)^`#@Y!@()?du^h3Q_c3tj_f`rNCdCc^U1 zq_GTKv~2lS6jP8q*Cj!KMwecgsb)n#lJuCSnIaJ*#;usxo%#R}GBBMxcT)O8QMv7| zT`}RLWym{l{-rcI?)~)=H${nxvK6RSFht>)G{jtmvq?;$vdLXlNf+0p=`v)cobhE> zRM}n~4c%MzixWal9CReE#GyaWcu@r;JX=+*FrD{T(Fyl|2SS)5f}vVYF6+PF?h6-6 z5}P@coKL;O!GiD2z483n`#R}Nw+b7@%Pd7X#L2w_%k#RpnR2XE^8Fp(9HVuD*lnfg%FZ$W#dGh4A z?lAJbEC7v^0lZ!&u^VB8)1xbtS1a7;nja$4|t9{|gJ9UjQVZm^H85BdOFE&QWE zx^7xffb~}Oe=a}XgaM^yw2rJMz za+Kqx=m94#@VuW0iiN02BM@gBX_eC%3x)Qd`%@p}-`-oV#J%75N`~suOZb*K$)Sqo zN6!F+DCftOr4-MCfS|3F5f@R9v`IVsp087((>S|Wl|g00o6^xtEY(p_eANMprqg@f z^rA$|nd)vuSnV$3@!c(mWR#_bo0>O7JgN+MwvCarn)T3^IR(G_JbO&b1QR*Q(~D8-QmkJ7ogf)P@TrWX7eVB7J%Hpm zIKe(L1=G$D&a<}=j(9d{v?DnL&|Cym>`eZ2M7lU{Jkq$))6ra;WoiKs7{k?_rEuoM1bDu6kV3+!*?&Iz zeU_4n`zM1{pzrNUR-AQQNG(z3YTyc z@A^vOXo5yT%k}@tRalWUu|CN4Sx@p7u(ql7%KM0q*C*@~e08Yzh3)xBb$U_rr#p!3fjo?4R33 zUa(i<#i&X;Ti%mZp;fovwKS9=8y_JQIt@bBj-hRBscn#a`{) zTn17cQekL}n-K)dl@VxYzKnEmC8HF8wcz0E<&S0sNeG^Q)aS;2fk1b#t;&Djj-?PF z8z#!YX6NM=w4Xi4%>B;eI#|#aASjIbQwIGQk{f@NZ#RqrxPgYxD!zw?$1Hpz0#D)) z75cx9&cd&$wvFQ(JyJnBh9aOeGLQ~QB?S}^cmRow5SfHDla%i61_32TNjFM^q;!q$ z82ujK{RwC1bD#Sc*Y^VP7j*06_CH`hOs4S{0Z|0B12eVg(mdS$rQx^x%(=;VQ>{x!6td-TQP0AOOoezEZ%Aj@VR}IXy# zo;80Ri!s7&(=iHoJ7Zq7ExK$yBJH*Ho{<(f!Ze-OjS1>%K%7S8DI(h&#rGQZ*R2IR zmAcxpx$=Cq>G|pwaTFJ^hT?mEB$Nnuh)RCpJg2w}u(9`Npd$@4C`+YB9j+9l%&DZz z416}a-#OYS-@eJqoHvJ-)6+~3<*DfrJ8RRl7 z0w$%y-sH1zP>sIVPk;`hh_ily0=lXt>o3h_<$FdMdoO{4{E~*mE^J&I>^a4*`p(;1 zI?tSV2LR?wI_n_Z9ni=zkz=)K5HA9~IOMv{;*LlGy#(fsxJGInx`mKSlN*2I@lZ+@ z*4t(J@LjxE03c31k3_~`+27D1 zQ)wnI7Mt)@W&f&}^P z^KE>G#%B9?kHx0iS^fy|muT%n@ibnOKh~|F)+InE|6wkW!M0JL_o~L?1aZQNp!X2( zlM^Z(S$}oR;IsO6jf?Ib66QrkRCF<|+)rU9_M&w`L0S=`W!xjAA6 z-|!}bXA-6;s-uaiCP_kIW!kTiu7Zua$3kX>jW1qs;n-%{aO*XU+UGcP#VXE0?&7Ss z4$+=VT{Jxvtq}ngS;qg-98dRG_)hS8OIeVxq*av?56ZDlB~g~Uk2B2+HI7CvZImL| zx@DN9&k>FTKLpok5VdL${W&l!>vguKNQ*9eO?el$UR|;(ZNphnyTXS$TQMf8b1bK7JH#5h!mlfd0V|Ys80xa>*qM^})|TZ|(8I>W8JI zhYz7MKg8NWPeBZ52T9xqOYy}o3TUGV$FK)MR>bB0E|A+zwqB}xzuP}8gIz#ry%dXz zbmU^$jf?5>v5MQhF_m$NiMA%V*kvix|GqXRy|-{5{%z_B_o#MS#T|;PN|Mz#YmI%? zks|*BcJv6WONQiV)P)tr?GTwt(;WDRi0EAF!ibk9nFz*T#8p*~mW#g$+fUZOzb*As zJ&g#v17&Exp{*+rwwB&gzgOacXAeb=Fi(|-Ull4Bc(_1f}&ag3=T>o*uBa`(D4Ifzi z!It!3%g3cI@-EvzN|m#fr>;ZJzxiH0dMP2ObT0xb;}TYpx&xr~l(dEXTDpQGxQnlO zo5@x?D?HkBU_4>2XjRprsyRc3YmjD=Dt1%T=Nkj_sDezO_L}^=v^7l6OUyoIs426% zC9aW3t9^fL{57NRZ9Fl|(v;|~17@S5& zH{4h$-@QNe?$fmVbV?x}8v60^#8~)!H7O(?7vDG`!KQY-?rpQlPY=X}*%^{*pksO1 zDtY4l7vaGfXPER*0tdtT72FY;AFs+F^ZoGtsj8k;=t9i*3;J~HM-Z+0ex#<~BIe4_ zwT=LSR)AQ0LPJ68wbViU2tRS z`Bmc!wRu}AZe-V!+Jg0B0~9BNKbZZlxj2CKh=OuzhBAx!Al^peOK)a6tZrCDmvl*! zI}T-?h=67@quYsx@f7*o4=locJBYI;LFB z8bpSgy1sN)2)yPpZqYMt%M`#P3+AH`-Ci6pQwl(*jjnw#5gM$JJEr%VxtAZDtf zdkVEH!xMrTUC&y&3o&r%hR5~j-WFfyY_>ZB8G_9K6&a}KyLdmPg9V91SkVKT1fLQ4 z-+-x-D7#zmPOlztrgu_WDn#pGiwZX_C!?x!z&l@xQNG_@Z$wv=YkYt|NKHHQHRR#- z(`S$em3KAb5lgFpn$WARMBh&fu;gm4=9bZDz7}?A=<7_3ACENm_MUF{T6(N?lETS_ zYby@Yuo_8tWky}?kV6y)m?Avjw%cvJ@1JA$+zcVl^XA`qVOCE7aE8hkD%;F{C`reJ z!KdmgoWv(lz-PD|c&yLMZp|Mu{_NKf2oJ9+cOt!N4L&}=E@hcp2g^$wrw1%)ijvEW z9v=T?H}jSZRrT~vVDVWnXii8Rfv2zxFqoThDc^1~!Eze)XA$1mR1T!S=0f53yK#|XowUONXCaYMv6|8bksP=P z{RTGvH1Oj+UQ+qQy!_q!KvBAD*&su@^>9BsxXSggP!#J+AYljWN7JZ|^9E$`wkzTp z7NFo3D7QI?WL&5x3CK-;F$QR=42g|lw4vsDmlTfJB~KX=lF0$eCv>iriLE5hmI}Yo zrB)5@MQlR2*iHVD5|{3qdQ0eZ^hSL8O8t14h*D)SM`KRBzJ~q7-0b18a4i3SY5U!` zt}>^pEIaY$XHzaYv2Zid2#tinVR5l$CFL->Y{Ji<=r->wGez5lidj+T5JDcP;e-)h z7ZvtdyxOh)6+8R1Co}6bQLXfLJtjN+d0zd+dMY&xDJl>MOk-XjueLQ8cRyOeSEsTi z)C6ur)i212mWK^N)R>>6HKG$=U6XLyM%L*jvB-G_cwIE--oIh0O42x?1O2)Puo}|} zbyh$5u85YB2M7OH%Kb^#+;pmLH&+5ztw+EYrUAIh8(th(w!ZuE??$xePo*&|`h@-; z+(jyv;y*1(hc$hnJ#`7VISex*7x^jm&^jV-*_Cl{%s6NNVsN6CvB667?XvCU z=P7b$$6trPxM)K=4T$;@ztjUG1!MNH;e$UEeziJKJs!pb&Xe-N;t$q_&sS0DbMVMP zhjH$2#y_H)j24y-T^`B@Gg-wook3FmAjPYfI)WO0#d2;Z3a4{1OEW{$c|v=TOcO7A zSbz(sj%w?r6=NP|FcZ`4)wgeaI?_{A!(no}(*c&PK#V*(50bfl_%cKowN9Eu55@kK zvKH$+FUpOm+_3LY68z->dmbhSBAj7a4D4m^-q(=pVKvRbE&(50SfiO z;;XUD+dSwEy2p<~dMcdpxdz1|ut%M64oDKvH~;Pd#E2|)cb5dAb)+l5<<-TI&v(!s zU`;qTxu1R-k~|LkCy?Sfxk(oH_I>Ue&dAnq%Co=}Ob%*HOm5mVgO~CWfi4jhH248s zY(rFg3F571($r11;_iphZc8U=F%tpjvqW#aL}iFH=(GFK^l6y0gLMaBSP zpSed!vf#QB&ftA_bKVe4#raL-`~s6XDeoyJ@o{4~JEGj=dYP6uLZvT`VGjW1PS8^( zB+H%yPt6G+T>m-T^#L^OKYy3Y3SMV`C}8F14afH4>6A1${(=TnbRK?o?0>3ef(A)(rN_Y!W}U8;AFW#hZNfH4=e z5h6V)LV>Rrj}h5&d-{WVgV`IqL<|Gl3{L~r+?*UC^Mk>mKhL$!HT_ztNX&~JjNP4( zxf;xy8F!lswOg4bb5RSsJ7=OUdd8x*)J^s^r!uc!BbX-c?btjOJGlRV!rcdWdFMVi zAE%3xbu0(i0*Aya6a{H&c9jN?i8liGEWpOZf4EXa2`&YATS3fECSI5GMPbPXo||~f z|D50jZ!tSpCGL1%jq&@eoiWxIUJdU0AW0@mT?qHQzBcS9GtNfINt8sDl4BkTf*=h; zMJu8{VJH@zPiR7#nB12kzML~X*uxd(6eid+(S}b$K@vJ9AhLp4{RRICf+&lIIW-+c z&%F;)j~Wk=epaEyE)%TCG|DBk=8Eu)Nb*bYK@uAj_ibmj6OFxIJN9)qkS589%^_?b zCwp7GJ4|f3&gV#$@oA3uA!&r{q82|L(p~uBead|feC6H>+YQUfwf$i;rQl_3Oqv)v zvM-yQUH_x4@{*A75bpkcJB!bLh;Ws}ushVnGWbXE1M6pQ(;zuT(@ETo#0!0{Wx$|w z(nvfxs~$kft#w9o07=vP7!Z_hqJr9&e})hjH$CYlD-t^Pc}jl8Ha=jbZkU7k;i)W} z2}JA8?swq}R8ZNAa9FL*DlxbIgWW( z2Z+*~^jKI!>U!~6q62unl}ox|tR!@9ANi5`B_HWB{GXQjGpCR#(v|vA5&4){DlJ- zL>>GCx0wl~S;X!(BKjx!pl-qY%G&aGFML7_LnFv(u%;y5$wvv%`Vq1z)j^S7c5^S* z&E^1 zh`*-}B$l)@^Eu%*+$TrK)nAL`ra<;DF-W%xl+R60{np7PcCvId{r_HajDn>RoN6!4 za6rRd*!D*s3%*TFHv!Jx271n8zo`)QHPY$&siT`)y++q-=}`eiE1eIh`vu4Pb%WTh zKhSr~76fER@XNV`yn}v^KKaC9^VhLP}_ooAb7X*QOCtD6MZXgBQnyD#Zy4l zk4a_dg%b>c$@FRNCZuaRXeS{SO?%C3y#_ugqIiPcyz$6Q{5{lOS3s<}MjOr; zz9QrJ@q5Lp%?aa`&DyeY)~>m-nP7Y|t3V9SYc1|ljkQB^Mi8aC3K4nFB+2<1X-@Y% z{tNtg0@}yJGmm9Gs?JO;3+MFz3br_qQ6jh?Q&Yp$s(Sbu-q7aUlcj*75~bL)R^^&% zK`*&Vt!Otll9ybsfiwINaqDfAN!Z74v_gp(_C=a}J*zx0Pgl-P%l7#%$LFKS z2OemN=ou5>Me!Qoyj{3)nT+XU{5|2xF3X(XtaRmYSN|}-3JGSYNur^=mT+d=i z5^}EBaO-klfEV04k$@UE6z5TMD{ly_s&cI-@HD-#8~xi9fE0#P z`(f;^t?l|xFE_*9axi$OIY5C(n%&g-?@rptQWY6JeD}TW@q;5k+Hpbj(`%h2CVq58 z2IMafw3pst>a|uvM^4;O(tHdB8ApUvBy<~{EU{e!4;DrhH!p@pM3p8Z{h&iM2~Rau z;YhdjAbMIRD~hlT_s6&To-AGrvsZ^YUB{ab{(8+X{+i?(?^clb!(rbzM5|H_igUry zx~`ihYQ_5hHP^BZg>7Dy$7^PIrf!zYNaFXYDGItk4dqBYRI+dO#NMLzs zhkaWfIH`s~5QXjkn)5uxnN)s1-6LhNqnFvti~Y0yuK?uv;wK=eqd+&M`y1wrqeGX@ zHvlO3?OzoX1?WN0{Cl(6NOQMT=ykbORBkh!VL4kTxqT_>iZ#s1n*rBAT59j6Qs48q zs^sGDIARvK8q5S%jO#*qRXfHvrpDWM=o#NKVf?8N0nDO}fECAqywX(jt2b{SwO1Vu z2*Hr+@XhjC6{vr{3rW@WO+`F<{o~<|&26VOAK%9Vi>u9UAJHzaX3ye=%i$HH;G&l$ z&wsUru;<(V3(x{5Go1DIe7-XN^perz_8pp_W59uHxo#B~o_Mm7>#nYuUW_xaQYRhz z6%kG4F0)VdDPT(>ZFF?uzkI$V31=Zqsc8(~HXoa?I=v($Lr?|U4)Xuyx2^l=3DGh~ zaK7~^-Gjm48k+DXDv`mB6G8H?yo{s-O54`*$Hbd{cnn{Tfj~H{tz8MtfrE52+WtU#YW#Vu3Avep5Ip}E36zlJ~JI=h*mEjr^(;D(-AD_$59UQZ8ncFV3_5_f`qNit5LT<66@}J zT@{8V#J70S4Id)?JAql(1U2QJuT>GTS6Z6UFC5f)fk(ZmTBwm(a2n%Xt4*-FiwB#U zcBwylc@sGJ_hU=hN+ki#P7mn$|wh0-NRj~NY%z9cb6E28w>`W6CK z{d7_(1Q}w>1ngg*K5Ra3+J7qQz8b9@C-Zw?M*Z?R8r8Xy{x8+%QVrKF^-<`3$w{rf zkMGop7qHcI!Oq5R?|C-~R|~I~xqIevWy{}b#c#kQaS<(H9wg~xtA^HOFdXCy;TXd5 z`2KMyo~-~d4gzPfnb(ic4mv1$R{Lac@^O0jnodTO5Q!%jz%?*f>Yx?Z-3I{kcCF%X zH8n0yjq90|ogY=cKMKe>e{Y|eLhVOBc(n2#m(vbVcwH6Yh=2H$usBVS8&JNn;iX?` zjgI3`P1{BbRpZ6y>w{stcdfh?!rF-r>zSdj#Wrl+?d7)lr#OF(M1J$8SA~hBg&8Tw zV=sG>?f8}Y{;vsYD9eAc`Po(8!CC;nJhhI$<&tY%i9D=+zA|KG_@?@<>2`e~|CRQS z%uMJ_1L<%|_eToXVHyQoYAT1UrG&xnB(!{C>A=)_S0nNDjsRLBk(VDD|FBXtMJ4z|w+si`p< z$hi%t+g`P6nd%ItGVe4~d!SV$3DF-xhq-<744)?v2sQRR?BbFbS?pRBO-?H933+H( zG0Z{*O6-qpCgN;;>M~Bc9#|+b(wn4CMv$>X*xA z^2&Hc$;2t5-d9En-4!&im$~7*AwCX)P%!)~Nqx*vu%PBPe&cb=Q|pMa-%CLD)HTm} zte)cA*(l!=$KZTH$(7?0kPeS!R&YhUOAzvxZFuCQIF)6kB|PS#n#lL&4G;3-9f|;R zwupTetyHMp zy_I9O;$3tUD){;94YmE~&gNdxoDzG>*{Az7r&R8q^xDcd&iCI^SV#WRf$4OvY)A4d zwL?gNTgOvCc9U{K>#myZcZa2BQF~HzI*i=2H8~G|^^C9-jqy|#4AqiRVP7wNPy(w{ ztl*i0stElE$VQtpT!&ka>PXjr!u;!2EEq`2h|P&N>w1twVFapj!>mYz067^&1R4=E zEU<(ZRjjlF)Qct@&*+345Yc!$8&V9kgNYr2>48cip2(?>sX%e;s85%{vJv zVe0uib%8pO^IwS)OA#46Lh1{x2&}N1^ILL|uRMF!86R3>ZTFauG`1-R<_fO$klY2wP?(bRbc;8&K*XK{bZj#LRp&cdHs^MJm zUrm103tM#y zEC;|I%DGu!-td&o5G~={8oLHrTmqSTlm7Y9Yu1QjA^6x$J>rhgE!a$AFb@fhr0S+{ zJTQ~RlbI3_8Q}@cZ`Tf%UGd}a+F3IS^<&U`NoS_6;s}AyG_W>M!|3+kmT%t{%8&9+~Sw^oLg68vd!hNuD1%4bRIJ|D29Qm2R zt(%r6NXWKL6eRm17Dr3gu>B_sh++5WAEt&?);sK>$n8ViZXTwYCn(Y^U*{J)-a^A2 z;_R&uAub-@+LQhQI@e`lf%lT)t5NbNHk-nJozM+|x64z;gH}{b+h5ePQ5@lO4ROiO zwBItV6-cfRKgy13oldenfA*npABC>mQJl1RsCxP2H)&FiQ8&qqEH?>^e%p;RY^;=5 zXdYJe=tk#LlW691;#LwxQ4|G}_v;>#t~(L~Qjf0VJ4|bCi_Ee@?NDpmUKHQox~h4% zfzx|!yYsazJdZvWQnOO0KQYb-7twjJ^HmnVw~v|AMp{cS-k-P+M~I;{2cM{1`XsWPh?l+gUH9>$yaZLAFCuPelCdde-5H0g9C%Q#4~hZzx(tPqL>#`qsfO`pzyCtqOQ=r(D89|a*tPUTP@+W|FvdenC*RpaD zR>$!!X1cw8^=js4$GNl?4J>n;Pjs2?bD-Mp&T||7NqED2ag5~}q4AcqpMVff7?mea z)feAprl^2*zfEz2{aj?3R}76QYQm~JjGj10{|T?HUA##vnT{EnOu}dr{OS3pXk8T~*BfuFDTyKY(64eVR$)_Gg^PBZXT;gVeRIK8YmL*Px<(i``s}@wzJyzw4l_K*+9I;ad$a$yq6(1Hs{FcrB}Gs|F|tR(`TLB zeF=F!SOKr|A|QJWX1lga&*b;RFPa)XuH4CxYXe2?Yp!ra6l?ODp!FO5)gp*{hW?}! zX}kUMOb1O2#-@W3^!O@&$H9rXH6Z#@{ijkw>Bc$@FF~X0ash$e_J8cuT@={gH!f=4 ze^(N)_>2HC8nyZCQXh@Co*41gYiVWM&7!RTZ%wGUVsi*9V9+-63r9@#e*+mz+Ha&rA00R31`s#5a&Tjn#$l znlK>B@C}>Hno6RSIvF^xUCTs7v*NcFbhNC80aps@5L$E)S?#oIBdJgj~y8Lowrk-m9S?_^edt#hHcd1!Z7HzT!%uDm=i9wlr^U<1#~>@&ih zAC`=Er7AzOF?ycr$(?fykvUaWos+93r3eI1eJUVLWQt09_};_pw} zsE)g9TG7p~5{m`cgWC##+h2o>raZY~~X?fy_t8;!ano-a}zLW}|P%LTqqf>DB zuNv-;R|Ky)=6Z)AmTS2OE8U~@eOob#AhX1SUFdx2I^x?ZbvsIakA#J8*m*@lY4%o9 zL}=P7lG2&+x@Nxke|{qhf%S;UVHmcom$qcH&;~d=f#l|$R&M?c?W(BT(5LTRZYsDd zl8oLR;Kd4j7y}i&>Lb{EXN0)7pjUfw?hoG%vx>{eKkpcb1SmN?{ojk1ugttfZ$Sm` z|4Kt5+k`XlQh-$o_RFPZ{_Zobr`f_f1sN3{$?0a(VI*Y+Z?ktUUZTXi?cM*r&VV!Z literal 0 HcmV?d00001 diff --git a/docs/api.rst b/docs/api.rst new file mode 100644 index 0000000..36cc7f5 --- /dev/null +++ b/docs/api.rst @@ -0,0 +1,16 @@ +API Reference +============= + +.. currentmodule:: abcd_graph + +ABCD +---- + +.. autoclass:: ABCD + :members: + +ABCDSample +---------- + +.. autoclass:: ABCDSample + :members: diff --git a/docs/benchmark_igraph.ipynb b/docs/benchmark_igraph.ipynb new file mode 100644 index 0000000..8b67984 --- /dev/null +++ b/docs/benchmark_igraph.ipynb @@ -0,0 +1,334 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Benchmarking with igraph\n", + "\n", + "This notebook is an example of benchmarking community detection algorithms using ABCD with igraph." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from time import perf_counter\n", + "\n", + "import igraph as ig\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import partition_igraph # noqa: F401\n", + "from sklearn.metrics import adjusted_rand_score as ari\n", + "from tqdm import tqdm\n", + "\n", + "from abcd_graph import ABCD" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "algs = [\n", + " \"community_multilevel\",\n", + " \"community_leiden\",\n", + " \"community_ecg\",\n", + " \"community_label_propagation\",\n", + " \"community_infomap\",\n", + " \"community_walktrap\",\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Performance\n", + "\n", + "First lets test how well each algorithms can detect the ground truth communities subject to increasing amount of noise in the graph. To evaluate the similarity between the ground truth partition, we'll use the adjusted rand index (ARI) and a graph aware adjustment (GARI)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 780/780 [06:07<00:00, 2.12it/s]\n" + ] + } + ], + "source": [ + "n = 5000\n", + "xis = np.linspace(0.1, 0.7, 13)\n", + "reps = 10\n", + "\n", + "aris = np.empty((len(algs), len(xis), reps))\n", + "garis = np.empty_like(aris)\n", + "\n", + "abcd = ABCD(n)\n", + "\n", + "with tqdm(total=len(xis) * reps * len(algs)) as pbar:\n", + " for j, xi in enumerate(xis):\n", + " abcd.xi = xi\n", + " for k in range(reps):\n", + " sample = abcd.sample()\n", + " sample_graph = sample.to_igraph()\n", + " sample_coms = sample.community_array\n", + "\n", + " for i, alg in enumerate(algs):\n", + " predict = getattr(sample_graph, alg)()\n", + " if isinstance(predict, ig.VertexDendrogram):\n", + " predict = predict.as_clustering()\n", + " aris[i, j, k] = ari(sample_coms, predict.membership)\n", + " garis[i, j, k] = sample_graph.gam(\n", + " ig.VertexClustering(sample_graph, sample_coms), predict\n", + " )\n", + " pbar.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ari_means = np.mean(aris, axis=2)\n", + "ari_stds = np.std(aris, axis=2)\n", + "gari_means = np.mean(garis, axis=2)\n", + "gari_stds = np.std(garis, axis=2)\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", + "for i, alg in enumerate(algs):\n", + " name = alg.split(\"_\")[1]\n", + " if name == \"multilevel\":\n", + " name = \"louvain\"\n", + "\n", + " axs[0].plot(xis, ari_means[i], lw=3, label=name.capitalize())\n", + " axs[0].fill_between(\n", + " xis, ari_means[i] - ari_stds[i], ari_means[i] + ari_stds[i], alpha=0.25\n", + " )\n", + "\n", + " axs[1].plot(xis, gari_means[i], lw=3, label=name.capitalize())\n", + " axs[1].fill_between(\n", + " xis, gari_means[i] - gari_stds[i], gari_means[i] + gari_stds[i], alpha=0.25\n", + " )\n", + "axs[1].legend()\n", + "\n", + "axs[0].set_xlabel(\"xi\")\n", + "axs[0].set_ylabel(\"ARI\")\n", + "\n", + "axs[1].set_ylabel(\"Graph Aware ARI\")\n", + "axs[1].set_xlabel(\"xi\")\n", + "\n", + "fig.suptitle(\"ABCD Benchmark of igraph community detection methods\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looks like ECG is doing the best, while Leiden is doing terrible. That's a bit strange since Leiden is usualy at least as good as Louvain (it is an extension after all), but we note that the igraph implementation of Leiden defaults to the `constant potts model` objective instead of the more traditional `modularity`.\n", + "\n", + "Let's also note that the shaded region of the label propagation algorithms extends above 1 for xi around 0.4. This is just the result of a very large standard deviation, as both ARI and GARI are capped at 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Time\n", + "\n", + "We can also use ABCD to test how each algorithm scales." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 600/600 [04:33<00:00, 2.19it/s]\n" + ] + } + ], + "source": [ + "ns = np.linspace(1000, 10000, 10, dtype=\"int64\")\n", + "reps = 10\n", + "\n", + "times = np.empty((len(algs), len(ns), reps))\n", + "\n", + "abcd = ABCD(1000)\n", + "\n", + "with tqdm(total=len(ns) * reps * len(algs)) as pbar:\n", + " for j, n in enumerate(ns):\n", + " abcd.n = n\n", + " for k in range(reps):\n", + " sample = abcd.sample()\n", + " sample_graph = sample.to_igraph()\n", + " sample_coms = sample.community_array\n", + "\n", + " for i, alg in enumerate(algs):\n", + " start = perf_counter()\n", + " predict = getattr(sample_graph, alg)()\n", + " end = perf_counter()\n", + " times[i, j, k] = end - start\n", + " pbar.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "time_means = np.mean(times, axis=2)\n", + "time_stds = np.std(times, axis=2)\n", + "\n", + "for i, alg in enumerate(algs):\n", + " name = alg.split(\"_\")[1]\n", + " if name == \"multilevel\":\n", + " name = \"louvain\"\n", + " plt.plot(ns, time_means[i], lw=3, label=name.capitalize())\n", + " plt.fill_between(\n", + " ns, time_means[i] - time_stds[i], time_means[i] + time_stds[i], alpha=0.25\n", + " )\n", + "\n", + "plt.legend()\n", + "plt.title(\"Scaling of igraph community detection algorithms\")\n", + "plt.xlabel(\"n\")\n", + "plt.ylabel(\"Time (s)\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looks like everything except Walktrap scales linearly. Let's zoom in on Louvain, Leiden and Label to make sure." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAtsJJREFUeJztnQeYY3X5/c+UTDK995ntvfcCC7v0Jl06gv7EhiKKICIi4l/BQhNUEEEUEKT3srRllwV22d7LbJ3e+0ym5/+cbzbDlGTSbpKb5P08TzY7yb3JzU1y78lbzhthsVgsEARBEARBEIKeyEBvgCAIgiAIgqANIuwEQRAEQRBCBBF2giAIgiAIIYIIO0EQBEEQhBBBhJ0gCIIgCEKIIMJOEARBEAQhRBBhJwiCIAiCECKIsBMEQRAEQQgRRNgJgiAIgiCECCLsBN1SW1uLiIgIPPjggyPepldaW1vxne98B7m5uWqbv/nNb9pdLpheEzlw4IDa3scffzzQmxLy6OWzYTKZ8JOf/ATBiF72od630d1tkOOAfhFhJ7hEVVUVbr75ZkydOhXx8fHIy8vDaaedhqeeegodHR2yF+3whz/8AS+88AI+/vhjcHLfv//9b9lPgteUlpaqE/Bf//pX3e9Nf21rMO2TYEL2a3ASHegNEPRPXV0dFixYgJiYGPz973/H0qVLYTab8eSTT+J73/se2tvb8f3vf98v25KRkaFEUjCwevVqtd8ohkPlNQn+RT4bsg/lsya4iwg7wSn/+c9/1C+3d999F2eccYa6LSkpCb/4xS9U1O7IkSOyFx2kNsaPHy/7RhAEQfAbkooVnFJfX6+u8/Pzh903f/58XHzxxYNu6+7uxh//+EfMnDkTsbGxKCgowLe//W2UlZX1LxMdHa1SJ7wwEjhu3DjccsstaGtrc7sOZGCtx8svv6wiZEajEbNmzcLKlSuHPUZlZSWuvPJKpKSkqMs111yD5uZml+uIGhsbceONN2LUqFFq2wsLC3HDDTeo28lbb72ltmfv3r14++23+1/nunXrXH5N7mznwNf/3HPPYfr06TAYDGo7XN3XAx/j6aefxsSJE9XzzJ07V70GR7iyv+3hymfE2X4eut3PPPMMJk2apEoF+AOEP0YIX8/kyZPV62G0edeuXYO2RYvH+OSTT9RjvPfee8NeK/c/yxjsPZ+z/Tf0s7F27Vq1Hwj3he19/dGPfqTeT35Orr766mHbwHIJRv8uvfRSpyUXXH/oZ87Re3jPPfdg2rRpar+kpaXhsssu6/+hN9K2uvoYrnxenD2Po++Xu58vTz/rnh7r3D1Wuft6hh4r3PmsDcXZvtHiO0b+8pe/qM9AQkKCKge64IILsGXLFpfeh7DCIghOePfdd5kntFx++eWWpqamEZft6emxnHHGGZaUlBTLv//9b0t1dbWlvLzc8uSTT1ruvPNOu+s0Nzdb3nnnHUtubq7l2muv7b+9pqZGPe8DDzww4m1FRUXqtksuucTy4x//2FJSUqKe87zzzrPExsZaKisr+5dtb2+3TJ061TJ+/HjL2rVr1et58803LVdffbXFaDRabrzxxhFfX0dHh2Xu3LlqW1euXKnW//DDDy35+fmWWbNmqce3MXnyZMs555zjZO/af03ubKft9V9wwQWWH/zgB5ajR49atmzZYvn8889d3te2xzj//PMt119/vaW0tFTtx+985zuWyMhI9RnwZH97+hlxdT/btuXCCy+03Hzzzeq5Dxw4oJZZvHix5X//+5/lJz/5iXr8Q4cOWebMmWOZNm2apa+vb9jr8eYxVq1apR5j4H6yERUVZfnZz37m0f6z99ng8rzt4YcfHvZc/Fzw88F9OhDuZ67z3nvvOXxfzGazZfr06ZaxY8da1qxZo/b5a6+9ZrniiiuGfeZ6e3vVZzsjI0Ptn4aGBvW6zjrrLPWeVVVVOd1WVx/Dlc/LSM9jbx+6+/ny9LPuzbHOnWOAu6/H3rHC3c+aO/tGi+/Yo48+ajEYDGpZ7sfa2lq1P6688kq33oNwQISd4BJ33HGHJSYmRh1QTjrpJPUlfOONN9TJYCDPPPOM+gI/++yzbu/Zv/71r0pE2A5C7gq7RYsWDXo8HrR4+3333dd/2yOPPKJuW7169aBlH3/8cXW7M2H32GOPqeX42u2J34EHQG+EnTvbaXv9M2fOtHi6r22PwQPqQHhg5QGWB2BP9rc9XPmMuLqfbduyZMmSQcu98MIL6vYVK1YMuv3ll19Wt3/22WfDXo83j+GJsHNl/7l7st23b58lIiLC8oc//GHQ7Tx5FhYWKjHliH/84x/qcflaBsIT6tDP3PPPP69ue/HFFwct29jYqATYrbfe6nRbXX0MVz4v7go7dz9fnn7WvTnWuXMMcPf12DtWeCrsXNk3WnzHGFig0BWcI6lYwSV++9vfory8XHV2Lly4EJs2bVJhcKZQNm7c2L/cO++8o1IPl1xyyYiP9/777+P0009Heno6IiMj+0P8fX19OHTokEfvyjnnnDPob6YkEhMTBz3eqlWrVH3giSeeOGjZ8847z6Xn+Oijj1SaY+hznXnmmSo9wPu1wJPtdHSfO/v63HPPHfQ3l+Xjbt++XaVq3N3f9nDlM+Lufj7rrLMG/T1lyhR1fcIJJwy63dbIYm8btXgMd/B0/40EU1ynnHIK/vGPf6j3lzBVtX79enzrW99S778juE/5/CtWrBh0O7/nQ3nzzTfV+zP0M5ecnKwahtg45AxXH8PVY4o7uPv58ua98vRY584xwN3X4+rxzhXc2TfefMdmz56NPXv2qBQ0zz+9vb2avYZQQ4Sd4DI8MF1++eWq1mXNmjXqZFFTU6NqYmxUV1cjOztbHYgdwXX5BR8zZoyqO2OH7UA7ENbTeAL94obCA+PAGhN2+GZlZQ1bjvVHI530hq5vb1m+7qHix1M82U57NZDu7mu+hqHYbuM2ubu/7eHKZ8Td/Tx0W3hiGel2e9uoxWPYw1HHs6f7zxnXX389Dh8+3F/vx052igkKu5HgPrf3/tt7H1j71dXVhbi4OPU+RkVF9YuWDz/8cNhnxR6uPoYrnxd38fbz5ep75c2xzp1jgLuvx96xwlPc2TfefMd+9rOf4Te/+Q1ef/11Jfx5Pvr617+OzZs3a/ZaQgURdoLH8Mv1ta99Tf2qYjSPZGZmqgLsnp4eh+uxeJYF0I8++qgq0mfBLeHJyBt4QnAGDwY8UQyFBz5bhGMkWNzN9e2drPm6edDVAk+2k0XQ3u5rvgZHt3Gb3N3f9nDlM+Lufna0Le5sozePwSgTaWlpGSZeHL1fnu4/ZzAaw6J3CrqmpiY8++yzKopHceHJZ463DX0N3P88eVOY8X1k9ITLHCvvwf79+51up6uP4crnxV20+nw5w5tjnTvHAHdfj71jhaf46zvGbb7zzjvVvuPlgQcewM6dO1VE09aAIVgRYSc45bHHHsOOHTvs3seuNP7SZrifUOjxAPziiy+O+JhMGwz8MvOgzhOQrznppJNUVxk7vgZi6yB1Bk+QPBExPTQ03cJJE7xfD9vp6b4e+vg8UTBlxk43rUSrK58Rf+1nrRg7dqyKlvBE4+375Qx2E5LOzk679/P7+N3vflfZEzHCQZ9JdpA64+STT1afuaFpVEZIhsKUPZe11wXs6ra6+hiufF6c7ZNAfr48Pda5cwzw1etxd7/6C/5IYQT63nvvVd3FErUbjAg7wSnFxcWqru72229HUVGR+pIzSnfTTTfh008/VSbF/OVNmJZlCzvTQfS/Y6qWUQumHniSsUUUGhoacMcdd6iIAlvhr7jiClVD4WuuvfZaVb/xf//3f/jiiy9UhIUHQ9az2H5NjwTtBridfM1MF3F9rnvddddhxowZ6nH1sJ023N3XNosECnZefvCDH6i6FlpSaIUrnxF/7WetoBUF00KMkvE7we195ZVXsGHDBiW0tCQ1NVVZPXCiCd9Te3CUHVOXtK5gNOfCCy90+rjc5/zMUQR+9tln6jVQ1FPoDf3MsSSDgotj8jh9hu8fl+cJlv6WPOE621ZXH8OVz4sr+2Toa/XH58ubY507xwBfvR5396sv4f54+OGHsW/fPnUOOnr0qPoMMKjA7JHwFSLsBKfwIMtUAouw+cuPXyT61/GkxSLtgWN8eBJ74403lE8Ta/HoN0VRyF+djCIQHsy5Hn+B5+TkqIMff70P9cPzBUyLsJCY28/CYm4f/Zzoj8SogDPRRI8lHjBZUM4TEk+a9P3ia+IJkPVCethOG+7ua943b948ld6g3xbrgl599VWcffbZ0ApXPiP+2s9a8re//U1FWbivWEBOLy9fzf7817/+pX5wsa7KnrcY66ps7/FVV13l0ueFnzmewPle8DXwffnf//6nxOpQGJ187bXX1I89fiZpxM0fBRQWjOxSWDrbVlcfw5XPiyv7ZCD++nx5c6xz5xjgy9fjzn71JRTxTMHyNfKH1HHHHac+Q/whRfEpfEUEW2MH/C0IYQmjUzxw3n///fjpT3+KcNtORhJYA/TPf/5T/coXgh+O+aOo2Lp1q1+i4YJ/CJZjlRA4JGInCMec08ny5ct1vT+CZTuFwMKIDj8rjGyJqAst5BggOENmxQph6clHvy+mzZjmYd0Ka2DOP/98lYbUC8GynYL+RN19992nuic5wkkIXuQYIHiCROyEsOMb3/iG6ixbtGiR8nO666678MMf/lDVE+mJYNlOQT/ws0FbCDYeUBTwR4AQvMgxQPAEqbETBEEQBEEIESRiJwiCIAiCECKIsBMEQRAEQQgRpHnCCzjWhaO0ONfOV+OBBEEQBEEIbywWizKepmefs7nmIuy8gKKOhpqCIAiCIAi+pqSkRPkYjoQIOy9gpM62o20jtQRBEARBELSEc4MZSLLpjpEQYecFtvQrRZ0IO0EQBEEQfIkrZV/SPCEIgiAIghAiiLATBEEQBEEIEUTYCYIgCIIghAhSY+cHS5Suri5fP43gATExMU7bxgVBEAQhmBBh50Mo6A4fPqzEnaA/KOrGjh2rBJ4gCIIghAIi7HxoJlhRUYGoqCjVoiyRIX2aS/M9GjVqlBhMC4IgCCFBwIUdnZRfe+01VFVVYebMmTjjjDM0XWfXrl149dVXsXjxYpx22mleP7er9PT0oL29XblEx8XFafa4gnZkZmYqccf3ymAwyK4VBEEQgp6AFhiVlpYqQfXwww/j4MGD+Na3voVLLrlERbu0WKetrU3d96c//Qlvv/2218/tDr29vepa0nz6xfbe2N4rQRAEQQh2Airsbr31VhU1+eyzz/DII49g1apVKrr28ssva7LO9ddfj3POOQfjxo3T5Lk9QWbI6hd5bwRBEIRQI2DCjlESpkGvueaa/jTY5MmTccIJJ+Cll17yep3//ve/2L59O37/+99r8tyC/tizZ48asyIIgiAIQoCFXXFxsapBmzRp0qDb+ffevXu9WufAgQO46aablLizlwr15LlJZ2enEhIDL6FGWVmZ6uQNBpYuXYr3338/0JshCIIgCLohYMKutbVVXScnJw+6PSUlpf8+T9ahxchll12GX//615g2bZpmz03uuecetY7twm7XUOP2229X9YbBAN/foe+hIAiCIIQzARN28fHx6npo1Kupqan/Pk/WeeaZZ1QzRENDA373u9+pC7tev/zyS/V/Nkd48tzktttuU8vYLiUlJQhXGPU8cuTIsGYT2ojs3LkTHR0dg27ft2+f2meE7w/fk6EwUsguVVJUVKQeZ/fu3WhsbLS7DU888YTqdh7YAW0T5nxv2PUsCIIgCOFEwIQdvcNiY2NV2nQgPKGz3s3TdaZPn44f/ehHSljYLhQfrKuz/d+T5yZGoxFJSUmDLq7Q12dBXWtnQC/cBi3YvHkzpk6dilmzZmH+/PmYMGEC1q5d238/xTK7jSnKBrJ8+XK8+eab6v/33nsvrrrqqkH3M9LKx3vvvffU3z/72c9w+eWX4+tf/7qKjLL+kWJypFTs7NmzVVMMlz/xxBORnp6OW265RZPXLQiCIAjBQMB87KKjo3Huuefi6aefxne/+131NyM5a9asUbfZoE0J675syzhbhxGcgVEc8tZbbykRwIgdoVmwK8+tFQ3tXZj/uw8RSDb96lSkJxi9egyKr0svvVSJpn/+859qP954443qNorikaKdA7n66qvVYzA6R58/8s4778BsNishR954443+5Xn7N7/5TfVc7FweCb6HGzZsQE5ODj7//HMsW7ZMpeYXLFjg1WsXBEEQBEcweBIZGQGEu93JH//4RxWFOemkk1SzA6/PPPNMJRRs8ET+0EMPubWOVs8tDOaDDz5Q6VdG3DhRg3Yhd999t4rSvf766y7vruOOOw6jR4/G//73v/7b2OhCsT0wCkrjYKZUDx06pN6bDz90Lo5/+tOfKlE38Hm2bdsmb6UgCIKguZirbunAzrImVLUMLj8K28kTY8aMUSm7F198UdVcUcCdd955g8Zvfe1rX1MpNnfWGcp3vvMdNRPU3ecWBsPUNSNsaWlp/bclJCSofTs0rT0SFIRXXnmlqoekqGbtHaOqzz//fP8yf/7zn5VVjclkUs/HaCHr5ygiR0qB2yKANhhFlFo7QRAEQSvau3pQ3dyJmtZO9PRay5zSE/QzczzgI8VSU1NVOtQRF1xwgdvrDOWHP/yhR88tYJhIYlp0KLSOsaVhHZn+Mvo2ENbYUbjRi+6LL75Q65911lnqPqZSf/nLX2L16tUq6kY+/vhjnHLKKao5QxAEQRD8SR9r5du6UNXcgZaOweczvRFwYRcOpMbFqBq3QG+Dt8ydOxe1tbXK+JnNE4S1iUzP8j7CaBqjbLbuVsKUd11d3aDHYgPGvHnzVAqWwo4pcJtZNDtos7Oz+0Ud+eijj7zefkEQBEFwB3NXrxJzA6NzekeEnR9gQaW3jQv+hDN2h3a1JiYmqq7Viy66SHWrss6OTSfsQl2xYgVOPvnk/ogdI2+/+c1vlMccI3x33nmnqskbCqN2TLlWV1fj//2//9d/+6JFi9RtrN879dRTVeTuwQcf9MMrFwRBEMKdviCKztlDhJ0wiIKCAmzcuFGJt4Gwu/TRRx9VdXFsPKEQo3UMmxqYNh3I448/jl/96ldK9PHx/vCHP+Cuu+5SBtADueKKK/Dkk08qo+GB0TlOAOHIt7/85S9qdi/vZ7cyTacHCsShBsUzZsxQAnQgEydOREZGhrzLgiAIgkvRudrWTnQHSXTOHhGWoQ6zgsuwkJ/CgsX/Qwv66ZlHw102FjA1KegPeY8EQRDCmz6NonNjMuKQmxyLQOiNoUjEThAEQRCEsMIcItE5e4iwEwRBEAQh5OkL8to5VxFhJwiCIAhCyGIO4eicPUTYCYIgCIIQktG56pYONJtDNzpnDxF2giAIgiCETHSuuqUDNS3hEZ2zhwg7QRAEQRCClnCOztlDhJ0gCIIgCEGHROfsI8JOEARBEISgic7Vt1s7WyU6Zx8RdoIgCIIg6BqJzrlOpA/fByFMmT59Ot55550Rl1m4cCFeffVVv22TIAiCEHzROVqU7CpvwtaSRpQ3doRtQ4Q7SMROGMRNN92EkpISvPjiix7vmbKyMrS3t4+4TEVFBdra2mTvC4IgCIPo6Lb6zoVzZ6s3iLATBlFfX4+amhqv9sru3buRmpoqe1YQBEFwCamd0w5JxfqDvj6grTawF26DBnR3d+Puu+/G/PnzMXXqVFx22WXYt2/foGVOO+00rFq1qv/vuro6fPOb38TEiRNx8skn4/nnn/focceMGYNnnnkG11xzjUr3Llu2zGnKVxAEQdB3dO5oXRs2FzegqKpVGiI0QCJ2/sBcD/x5PALKLQeB+AyvH+aqq65CZWUlHnjgAWRlZeG5557D0qVLsWfPHmRnZ9tNxV5yySUwm81KlFHAXX/99SgvL3f7cUtLS3HjjTfi4Ycfxu23364E4kUXXYSioiIUFhZ6/doEQRAE/0Xnqps70WTull2uMRKxE1xm06ZNquGBlxNPPBFTpkzBXXfdpa7/85//2F1n3bp1+OSTT5SoW7x4sYqyPfnkk7BYLB497s9//nNceeWVmDx5Mu644w4kJSVhzZo18i4KgiDonO7evkHRORF1vkEidoLLfP7550qQMV1qE2a8rq2txYwZM+yus23bNuTm5mL8+K8illw/Li7Oo8cd+HdERISK7nE5QRAEQd8crGlFQ5tE6HyNCDvBZTo6OlRTxNq1a4fdFx8fb3edzs5OxMTEDLvdYDB49LhRUVHDlhkY/RMEQRD0R2VTh4g6PyHCzh/Epllr3AK9DV7ChgVGx1g/N2nSJJfWYcMEa+7YbZuWZt2G4uJiNDU1efW4giAIQnDQ3tWjUrCCf5AaO7/s5Uhr40IgL9wGLznjjDMwe/ZsXHvttTh69Ki6jQLtoYcewkcffWR3HXbIjh49Gj/72c/Q1dWlxBsbILx9XEEQBCE4GiVYT9cniRW/IcJOGMYXX3yBgoKCQZdvfOMbKg26cuVK9TebFxiBGzt2LA4fPqzq4+wRHR2tulf5mGx04LoUerZOV+LJ4wqCIAj652h9O9q7egO9GWFFhEUKlDymubkZycnJKrpE0TIQ1o1RmFCgmEwmBAsNDQ12J0LwNWRkfGWXwugbX//A22zQyoQ1c7GxsYNuZ7o1PT1dNT3Q2oT7bGAThbPHZUqXtxuNxv7bqqqqVB1eQkKC2681WN8jQRCEYKChrQt7K1sQDozJiENu8uBznr/0xlCkxk4YBAWZK1Mj2BBhT3yRvLw8u7cPXD4nJ8ftx83Pzx9228DInyAIgqAPunr6VBes4H8kFSsIgiAIgqYcqG6VOa8BQoSdIAiCIAiaUd5oFvPhACLCThAEQRAETWjt7EFJ/VcjJQX/I8JOEARBEASv6e2zqBSsWJsEFhF2giAIgiB4zZG6NpjF2iTgiLATBEEQBMEr6lo7Ud3cKXtRB4iwEwRBEATBYzp7enGoVkaG6YWAC7u3335bjZSaM2eOmm5w6NAhr9ehwe6f/vQnnHLKKVi8eDH+7//+Dzt37hy0zG9+8xtMmTJl0OW8887T/PUJgiAIQqjCGQesq+vplZlheiGgwu6dd97BBRdcoOaJ/u1vf4PZbMYJJ5ygph94s873vvc9NZOU4u3BBx9Eb28vjjvuuEECkJMPONrqtdde67/85S9/8flrDgfuv/9+vPLKK14/Dt/fZ599VpNtEgRBELSnrNGMZnOP7FodEdDJExReV155JW6++Wb198KFC9VEgkcffRS33Xabx+s8+eSTMBgM/etwGQqETz75BOPGjeu/PTExUUXqhK/gvuPor1tuucXj3ULxvWDBAlx00UVe7doPPvhAzY/l+y0IgiDoi5aObpQ2mAO9GYJeInatra3YuHEjzjzzzEHjpE499VSsWrXKq3UGijqb0LAJvIF89tlnmDdvHk466ST8+te/Vo8f7qxevVqlugVBEATBmbWJRTKwuiNgEbvS0lKVm8/NzR10O6NvQ+vhPFln7dq1uO6669TgXKZr33zzTcycObP//pSUFNx0001Yvny5Gi5PYcdl1q9fr8SiPTo7O9XFBh873HjmmWdU5JOkp6djyZIluPDCCx1G3Ci4mQpnLeSMGTOGvZ98PF4zksplMjMz/fI6BEEQBM85XNuKju4+2YU6JGDCjid7MlREGY1G9PT0eL3O3LlzVd0c04r//Oc/ce2116oI3YQJE9T9v//97xEVFdW/PFOHFBfPP/+8Ehj2uOeee3DXXXe5/Vr7LH1o7GxEIEkxpiAywvsA7dixY9HR0aH+X1VVhZ/+9KdYuXKlSoUP5Omnn8b777+v0qjbtm1T+5eCkEKQfPHFFzj33HNVupaCb8OGDWr/UlgPTJcLgiAI+qKmpRM1LV2B3gxBb8KO0R5C4TUQ/m27z5t14uPj++vnjj/+eEybNg0PP/xwf4PEQFFHCgsLMWbMGOzatcvhNrOGj1G+gRE7rucMirrlzy9HIFl92WqkmdK8fhzuS15sXHbZZZg0aRJ+9atfqXo4G11dXVizZg0SEhLU3xEREbj11ltVqpewU/n2229XwtAGBfWdd96pRKEgCIKgPzq6e5URsaBfAibsmD6lEFi3bt0gmxFGctjxqtU6NlGRnJw8YuqUQoSdslzOEYwM8hLO9PX14a233lLvAQU1/46MjMS+ffsGCbuzzjqrX9TZBOD555+vIqtHjx7F3r171fvG9Zhe5+XgwYNoaWkJ0CsTBEEQRkKsTYKDgNqd0Jbk8ccfR1FRkfr7X//6Fw4cOIDvfOc7/cvccccdg0Scs3VYT8d1bCKOH8SnnnpKpfooLGwijtG3pqYm9TdTiz/60Y+U6Lj00kv9uAeCj6uvvho33nijingy3c3UKoXdUEE2NIKakZGhUun19fX9EVc2rjBFy6aWRYsWqSgeI3+CIAiC/mAHbEuHWJvonYDanfziF79AcXGxqrFipIzC6t///jdmzZrVv0xFRcUg/zln6zCixtuZHmQtHsVbWlqaqrOj/52ta5ZCY/Lkyer/FBpM1bLYf/z48QHYE8EBvQKfe+451Zk8f/58dVtdXd0gIW6jpKRk0N+M0plMJtUcQWFN+B5+7Wtf89PWC4IgCJ7S3NGtPOsE/RNQYRcdHY3HHnsM9957rxIITOUNtSr53e9+p6Jwrq7D6BE97nhhtytr7dgBOzQ1+7Of/UxduExqairi4uJ82rjAGrdAwm3QioHROTY82IOWKYykslmlu7tbmQ0zYsp9z/eM3ci//e1vceKJJyIpKUmtw/eTjRYnn3yyZtsqCIIgeEdPb59YmwQRARV2Nnhit53c7dXVubuOjfz8fKfP7coy3sJuVC0aF/wF695oFTMQRtd+8pOf4Pvf/76yN6GXICOpTGPbqzucPn268gdkqnb37t1KDP7nP//pv582JxR6jJraJofw8e677z6/vEZBEATBNQ7XtqFTrE2CBl0IO0E/sM5t2bJlw263df8+8sgjuOaaa1Q0jn6CK1aswH//+19Vb2eDkVCmuhmZY20j0+Wnn376oGYK3seULpsw+Fh5eXlqru/AZVj3yIirIAiCEBiqWzpQ2yrWJsFEhIXdBYJHsEGD9Xys4xsaPWQk6/Dhw8r3jbVlgv6Q90gQBGGEY2R3L7aXNqkpE8LIjMmIQ25yLAKhN3TVFSsIgiAIgv5gzKeoqlVEnYsUVbXg/V2V0AOSihUEQRAEYRAl9Wa0doq1iTP2V7XgtS1l2FLSiPT4GJwwMROxMYMHIPgbEXaCIAiCIPTT1C7WJs6imTvLm5Wg213x1eCDurYu/G9DMb51/FgEEhF2giAIgiAoumltUtMqe8MOfRYLNh9twGtby3Cwxv5YtcfWHMJVi0cjJjpwlW4i7ARBEARBUByqaUNXT5/sjQGweWTdoTq8vrUMJQ2OTZpT4wy4avGogNclirDzMdJ0rF/kvREEQfiKquYO1LeJtcnA6OWaohq8ua0cVc2dGEnQXbN0DL63fBziYgIvqwK/BSEKp2FwykJNTY0ao8X/C/oSdXxv+L4MnXYiCIIQbpi7enGk1n56MRxtXj7eW423d1SMKHSzEo04b04eTpyYiYnZCboQdUQfWxGCREVFKRPe0tJSHDlyJNCbI9jBNt6M75UgCEK40tdnQVF1C8Ldrq6tswfv767Cuzsr0NLhuCO4IDUWF8zJx5Jx6YiK1F/QRoSdD+EUhYkTJ6pZqYL+YKRORJ0gCOFOcX072jp7Ea40mbuVmHt/VxXM3Y73w/jMeCXo5o1ORaSOs3Ai7HwMhYOIB0EQBEGPNLZ3oaKpA+FIXWsn3tpeodKuXb2OG0am5Sbhgrn5mJGXFBRlVSLsBEEQBCEMYffrwTC0NqloMquGiDVFtSN2sM4tTFGCblJ2IoIJEXaCIAiCEIZQ1HX1hE9h3dG6Nry+rVxZl1gcvGzG4xaPS8P5c/IxJj0ewYgIO0EQBEEIw6hVY3t32MxxfW1rOTYXNzhcJioiAssmZuD82XnITYlFMCPCThAEQRDCrPuzuK4doW5ptYtjv7aWqWtHGKIicNLkLJw7Ow8ZCUaEAiLsBEEQBCGMrE0OVLeGrLWJhWO/ihuVoOPrdESsIQqnTcvGWTNykBIXg1BChJ0gCIIghAlH6trQ3tUbkoJ13eE6lXItqXccjUwwRisxd/r0HPX/UCQ0X5UgCIIgCIPgFIWRRmMFIz29ffi0qBZvbCtHZbNj25aUOAO+NjMPp0zNgskQ2qb0IuwEQRAEIcTp7OnFoRCyNuHrWbW3Gm9udz7269zZ1rFfMdGRCAdE2AmCIAhCiHOwug3dvcFfWNfedWzs144KNI8w9is/JRbnz8nDceMzdDn2y5eIsBMEQRCEEKas0azGZgUzzWrsVyXe3105Yo3g2Ix4XDgnH/PH6Hvsly8RYScIgiAIIUprZ8+IzQTBMPbr7R3WsV+dPY7Hfk3JScSFc/MxMz85KMZ++RIRdoIgCIIQgnBcFi0/HE1Z0DOVTR14c3s5Vu+vGXHs15zCFJVynZKT5Nft0zMi7ARBEAQhRK1NzEFmbcLo4utby/C5k7Ffi8Zax34x9SoMRoSdIAiCIIQYTGFWB5G1CSOLFHQbjzoe+8UeiGUTMnDenHzVHCHYR4SdIAiCIIQQHd29OFTbhmCYErGnohmvbi3HzrKmEcd+reDYr1m5yEw0+XUbgxERdoIgCIIQIlAsMfrVo2NrE27jlpJGvLalDEUjjP0yGSJx6tRsnDMzN+TGfvkSEXaCIAiCEELWJi0j+LsFeuzX+sP1KuV6dIRO3XhjFM6cnoszOfbLJDLFXWSPCYIgCEII0NLRjdIGM/TIluIGPL3uKCqaRhj7FWvAObNyccqUbMTGhPbYL18iwk4QBEEQQmBmapEOrU2YdqUP3bPri+Fo0zITOPYrF8snZYXN2C9fIsJOEARBEELA2qSz27GBbyCg/9y/Pz+CD/dU2b0/L8WE82fn47gJ6YiOFEEXUsKuurpaXcaNG4e4uDjN1qmoqEBraytGjRoFo9Go2XMLgiAIgl6oaelETUsX9DbT9aGPirCtdHi3K73naCq8cExa2I798iUBlchdXV246qqrlPA699xzkZWVhX/+859er/Puu+9i9uzZWLJkCc4880xkZmbi7rvv9vq5BUEQBEFv1iaM1unNQ++uN3fbFXWXLSzE7y+YgcVj00XUhWLE7ne/+x1WrVqFoqIiFBYW4vnnn8cVV1yBefPmYf78+R6vc/DgQbz88suYMGFCv9A7++yzsXTpUpx00kkeP7cgCIIg6AU9Wpscrm3Dn1fuRUN79zAvuh8sH4+l4zMCtm3hQkAjdo8//jiuu+46JazIZZddhqlTp+KJJ57wap0f/ehH/aKOnHbaaYiOjsbRo0e9em5BEARB0AvsgNWTtcmmow24681dw0Rdoikavzpnmoi6UI/Ysf6Nl4ULFw66ffHixdi8ebPX6zQ3N2P//v3qmiKOou3CCy/0+LkFQRAEQS80mbuVZ51eeG9nJZ5ad2RYV25esgk/P3MKspNkYkTIC7u6ujp1nZ6ePuj2jIyM/vu8WWfXrl244YYbUFtbi6amJjz88MNITk72+LlJZ2enutigaBQEQRAEf1ubHNCJtQlNh+lP996uymH3Tc1NxE2nThaT4XARdgaDQV0PFErEbDb33+fNOqyn27hxo/r/ypUrVYNEbGwsLr74Yo+em9xzzz2466673HiVgiAIgqAtnAPb1dOni8aNhz8+gM3FDcPuO2FCBr574jhER4mNib8J2B4vKChAREQEysvLB93Ov9mpqtU65IwzzlBp1jfffNOrx7nttttU9M92KSkpcem1CoIgCIIWVDd3oK418NYm9W1d+O1bu+2Kuq/PL8APVowXURduwi4+Pl7Zkbz99tuDImYfffQRTjnllP7b2PDAtKqr6/T19Skrk4H09PSgtLQUaWlpbj33UOiFl5SUNOgiCIIgCP7A3EVrE8czVv3F0bo23PH6TtUBO5DoyAhcv2I8Lp5nDZ4IYWh38v/+3/9TPnOTJ09WqdO//OUvSElJwfe+971By6xbtw47d+50aR2mVynafvCDH2DatGlobGzEP/7xDxVhu/766916bkEQBEHQk7UJpzkEkq0ljfjLR/vRMWTKRYIxGjedNglTcyXgEWgCmvxmdIz1b9u2bVO1a7QeWbt27aBI2JgxYzBjxgyX12Ed3RtvvKE6Yu+880489thjyptuz549gyxQXHluQRAEQdADxfXtaO0MrLXJB7urlEfdUFGXk2TCb8+bLqJOJ0RY+DNA8Ah2xbLTltFAEYSCIAiCL2hq78buisC5MPRZLHh2fTHe3lEx7L7J2Ym46fRJSDI5bjwMB8ZkxCE3OVYXekMXs2IFQRAEQRhON61NaloDtms6e3rx91UH8eWR+mH3HTc+Hd87cTxioqXzVU+IsBMEQRAEnXKoJnDWJo3tXbj3/X04WDN8Fu2Fc/NV92ukNEnoDhF2giAIgqBDKps6lK1IICipb8efVu5F7RBrlaiICHznxLFYPikrINslOEeEnSAIgiDojPauHmUrEgh2lDXhwQ/3o72rd9DtcTFR+OmpkzAj3zrFSdAnIuwEQRAEQUdwTBetTQLhbLJqbzWeWHsYvUP6KjMTjLj1zCnIT/Vdg4CgDSLsBEEQBCHA0KCiu9eCrt4+VDV3oK1zcLTMH52vL2wswetbB09kIhOyEnDz6ZORHBvena/Bggg7QRAEQfBxZysbIGzXXf1/W/r/5n2BMh/jNjyy+gDWHRre+bp4bBquXzFBOl+DCBF2giAIguABPb3HRFmPBZ29vf1CbaCA6+7pC0hK1VWazd2q87Woerilynmz83DZwkLpfA0yRNgJgiAIwgA4tmtwZO2r684Bf+tZsLlCeaMZf3xvL6pbOgfdHhkB/N+ysThlSnbAtk3wHBF2giAIQtg0JXQNEWf20qOBnsfqD3aXN+H+D/cPq+WLNUThJ6dOxKyClIBtm+AdIuwEQRCEkBBsttSnLT3a1duLLnVtFXA9vaEv2Fxhzf4aPPbpoWECNiMhBj8/YwoK0+ICtm2C94iwEwRBEIKug7Sk3oyG9i4l2BhlE1zbby9tLsUrm8uG3Tc2Ix63nDEZqXExsiuDHBF2giAIQnB5vNW0om7IRARhZCiA/7HmED47UDvsvgWjU/HDkybAZIiS3RgCiLATBEEQgkac7KtsQUtHT6A3Jaho6ejG/R/sx97KlmH3nT0jB1ctHo1IdkwIIYEIO0EQBEH3dHT3KmFiHjLmSnA+b5adr5XNHYNuj4gAvrl0DE6fniO70EsMURGIi9GPnNLPlgiCIAiCHdo6e7C3slk1Qgiuw3123/v70do5OMJpMkTixydPxNxRqbI7vYBBztzkWOSlmBAdFQm9IMJOEARB0C1N7d3YV9USFhYkWsJaukdXH0TPkP2WFh+jmiTGpMcHbNtCgczEGBSkxumyLlGEnSAIgqBLalo6cbCmNWCjtoK18/W1reVq7utQRqfH4ZbTJyM9wRiQbQsFEk3RGJMRjwSjfuWTfrdMEARBCFvKGs0ormsP9GYE3Yizx9cexur9NcPum1uYghtOnojYGP1FmIIBkyESo9PjVcRT74iwEwRBEHQVcTpS166K/gXXYR3dAx/sx+6K5mH3nT4tG9csHYMo6Xz1qDGCKdfsJCMi2HESBIiwEwRBEHTjUcdh9PVt4lHnDtXNHfjjyr0obxzS+QrgG0tH48zpOUEjSvRCZASQk2xCfkqsrhojXEGEnSAIghBwxKPOM4qqWnDv+/vQPMTbzxgdiR+dNAELxqRp8v6EExkJMWqsmh4bI1xBhJ0gCIIQUMSjzjPWH6rD3z45MGykWkqsATefMRnjMxM0eX/CqTFidHocEk0GBDMi7ARBEISAIR51ntUhvrm9As99WTzsvsLUWPz8zCnIkM5XtxojRqXFhUy3sAg7QRAEISA0tndhf1WreNS5QU9fH/792RF8tLd62H2z8pNx46kTdTUFQe+NEfmpschONIXUSDV59wVBEAS/U93SgUM1beJR5wbtXT34y4dF2F7WNOy+U6Zk4ZvHj0F0ZHAV+geCyCBujHAFEXaCIAiCXyltaEdJvVn2uhvUtnbiT+/tRUnD8P121eJROGdmrnS+ukB6QoxKuwZrY4QriLATBEEQ/FYbdri2DVXNnbLH3YDTN+5duQ+N5u5hqcQfnjQBi8emy/4Mk8YIVxBhJwiCIPgc8ajzjI1H6vHwxwfQ1ds36PakWANuOX0SJmQlavL+hHJjRGFaXFg1k4iwEwRBEHyKeNR5Ft18d2clnll3FENH5bI27OdnTEZWkkmjdyj0iGZjREoscpJCqzHCFUTYCYIgCD5DPOrcp7fPgqe+OIL3d1cNu296XhJ+euokxOt4CH0giWBjRJJJdbsaQrAxwhXkkyEIgiD4bH7pvspmdPUMjTkJjjB39eKhj4uwtaRx2H3LJ2XiumVjQ7KTUwvCoTHCFUTYCYIgCJojHnWu02exoKS+HTvKmvDJvhqUNQ7vfL1sQSHOn5Mnna8OGiNGpcchKQwaI4JC2FVVVeHZZ59V1zNnzsRll12G6Ohor9f56KOP8Pnnn6vbly1bhhNOOGHQ/S+++CI+++yzQbfl5ubi1ltv1fDVCYIghB/iUeec+rYu7ChrxI7SJuwob0bzkI7XgZ2v318+HseNz9D8fQp2jMcmRoRTY4TuhV1RURGOP/54zJ07F4sWLcKdd96JJ598EitXrkRUVJRH6/T19WHBggVIT0/H0qVL0dTUhHPPPRdXXnkl/v73vw8SfuvWrcM3v/nN/tsyMuSLIwiC4A3iUec4xbqnollF5XixF5UbSoIxGjefPhmTc6TzdSDh3BjhChEWtt4EiIsuugi1tbX45JNPEBkZieLiYkyYMAFPPPEEvvGNb3i0Dl/Otm3bMGfOnP513n//fZxxxhnYvn27ivCR73//++pxXnrpJY+3v7m5GcnJyUo8JiUlefw4giAIwY541A1vgKD/3M5jQq6Io9PcON1SuFDUcUKC8FVjRHaSCQVh2BjR7IbeCFjErru7G++88w4efPBBJdDIqFGjsGLFCrz22mt2hZ0r60RERAwSdcQm5srKyvr/Tw4ePIhf/vKXamcxVXvcccf5+FULgiCEHuJRZxW2lc0d1ohcaRN2VzSjvavXrf2YlWjEzPxkzCxIxvzRqTIebABp8dbGiNiY8G6McIWACTtG2jo7OzF+/PhBt/PvobVv3qxD/v3vfyM2NhYLFy7sv40CMC0tDSaTCYcOHcJvfvMbXHfddXj44YcdPg6fm5eBCloQBCGcCWePupaObuwss6VXG1Hb2uXW+vExUZiel4wZ+cmYVZCsolHC8HQ0GyOSY6UxQvfCrr29XV0nJg6uHWCI0XafFuusWrVK1eE98MADqu7Oxi9+8QuMHj26/+/LL78cJ598Ms4//3yceuqpdh/rnnvuwV133eXyaxQEQQhlws2jziZibXVyR2rbhpkHj0RUZAQmZiWoqByF3LiMBKkRG6ExojA1DpmJ0hgRNMLOJs4aGwd79TQ0NAwTbp6uw67Y8847T4m4H/7wh4PuGyjqyEknnYTCwkKsXbvWobC77bbbcNNNNw2K2HEdQRCEcCMcPOqYXi0+ZkPCy96KlmGjvVyplWNqlWJuWm5S2HusudIYkZcSi1xpjAg+YcfauISEBOzduxdnnnlm/+38e9q0aV6v88UXX6hlfvzjH+O3v/2tS9vU1dWl6vgcYTQa1UUQBCGcCWWPOqsNiVXIsfGhyYENiSOYMlR1cvnWFCtrwwTnhHNjRMgIOzY/XHzxxar+jR2qrHVj1ypr5V555ZX+5Z5//nkcOXJE+cu5us769ev7Rd3vfve7Yc/d09Oj1lm+fHn/bTZfvNNPP90Pr14QBCE4CTWPOqaT2ehga3pwxYZkIDFRkZiam4iZ+SkqMleYGismwm6SGm/A6LR4aYwIBbuTyspKJa5iYmKULx07Xs855xz85z//6V+GDQ30m9u5c6dL67S2tqKgoEBF1q644opBz8c6uiVLlqC3txdnn302WlpaMH36dNWUsWbNGtx+++341a9+5fL2i92JIAjhRCh41LGD91BtK7aXHrMhqXYv8kjXtLEZ8f3p1UnZiRJh8hBpjIBP9EZAhR0xm8149913+6dIcErEQD788EMl5q6++mqX1uno6MCjjz5q97lOO+00JeRsbN68GVu2bEFqaqoyO6YgdAcRdoIghAPB7lFX1dyhhBxTq7vKm9DmZrNHZoKxX8hNz0tCooyu8oqYaOvECGmMCFFhF8yIsBMEIdRhNKuougUNbe7VmgWS1o4e7Cz/qk6uusU9QRqnbEiSjtXKpSA7ySjpVY0aI3KTTchLjpVu4FA0KBYEQRD0TbB41HE791cdsyEpbVLRRbdsSCIiMDHbakPCy7jMBGVNIngPZ92mxscgPT5GNZbQQ1bwLSLsBEEQBLtNBZxt2tHtnr2HP2CiqbTBfKxOrlF56XX2iA2JXoiJjkBqHMWcEUmx0SLm/IwIO0EQBCFoPOoOVLfiqS+OqKYHd2C0iPYjtqic2JBoL+bS4o1qvyaZRMwFEhF2giAIgu496rhd/9tQgtX7a1y2IZmibEisQo7F+pIG1L4JginWtIQYJBpFzOkFEXaCIAiCorq5A4dYn6YjTdfT24f3dlXilc1lMHc77mZl5dYY2pDkf2VDQuEhaD/qS4m5+BjpDtYpIuwEQRAElNS3q7o1PbG1pBFPf3EE5U0ddu+nuJhdkHJsyoPYkPgKkxJzRhWZo/ecoG/kHRIEQQhj2IjAKF21jjzqKps68PS6o9hc3OBQaFw0twBnzchBtIyf8gmxMVH9kbl4EXNBhQg7QRCEMEVvHnXsxH11Sxne2VGBHgc1fidOzMDli0aprktBW+jfRyGXnhCDuBiRB8GKvHOCIAhhiJ486hg1XHugFs99WYyGdvsic3xmPL553BhMyEr0+/aFMvHGY2Iu3iizWkMEEXaCIAhhhp486g7VtOI/XxxRnbj2SIo14IqFhThxUiYixdxWE1gnx3o5plpNhihtHlQIbmHX2tqKdevWobS0VP1dWFiIJUuWID4+XuvtEwRBEELQo67J3I3nN5Tgk33VdqdEcBrEmTNycNG8fEkLakCiKVpF5ngRMRfauCXs1q5di/vvvx9vvfUWuru7ERsbq243m80wGAw477zz8JOf/ATLli3z1fYKgiAIHtLQ1qWMfQPpUdfT14cPdlfhpU2laO+yb18yqyAZ1ywdg/wU6zlGcB8GNxmZY70cxZwxWiJz4YLLwu6SSy7BmjVrcNVVV+G9997DwoULkZhorXVoaWnBl19+qQTfxRdfjOXLl+OFF17w5XYLgiAIQeZRx1mu//n8CMoa7duqZCUalaCbNypFzIQ9FHOMzClrkvgY8fELU1wWdosWLcJTTz3VH6UbCAXeKaecoi533303/vrXv2q9nYIgCEKQetRRVD6z/ig2HLFvX2KMjsQFc/Nx9oxcESMeiLkkk6E/MmcQ+5ewJ8LCdiTBI5qbm5GcnIympiYkJSXJXhQEQXedr8X17QHzqGOTxhvbyvHW9nJ099o/1Rw/IQNXLhols1vdIJJiLtagmh9SRcwFnOauZvT29SLVlKoLveFR80R7ezvef/99XHDBBepv/v+hhx7C+PHjcc899yAuLs6zLRcEQRC8bo5gLV1je7f6fyBgvOCLQ3X47/pi1Ld12V1mbEY8rl06BpNzxL7EVTGXEkchZ0BaXIwYM+uA3r5elLaWorq9GoWJhdALHgm7X/3qVxgzZoz6f2Njo6q/Y+PE6tWr8fOf/1xSsYIgCH6cpcoOU/q/NZm7At7teqSuTdXR7a1ssXs/a8AuW1iIkyZlIZJqRXAIdw8jckyx0pA5SvaXrqJ0R5qOoLNXPxNbvBJ2L774IjZu3Kj+v3LlSsyePRtPP/00Dhw4oBonpMZOEATBd7R39Sgh19jepQyG9VBQ09zRjRc3luCjvdV2t4ea5PTpObh4XoHMG3VBzDHNygidiDn9Run0ikfCrqGhASaTSf3/448/xplnnqn+n5ubq/K/giAIgnbQnqRZReW60GjuRqcOjIUHbttHe6rwwqYStHXaty+ZkZekul0L06RMxxGGqAhkJ5nUJSY60ofvmBCKUTqvhd28efNw1113KUH3/PPP45NPPlG3b9u2DXPmzNF6GwVBEMIONh6wTo5ijqIugNZzDtld3oR/f3FUdd3aIzPBiKuXjMbCMaliXzLCSK+cJBMyEoySmtZxlK6stQxV7VUIBjwSdg888AAuv/xy/O1vf8MNN9zQL+b+9Kc/4ZZbbtF6GwVBEEKevj6LSqvaonJmB+a9eqCmpRP/XX8U6w/X270/JioS58/Jw9dm5Un0yYFFSUqcAblJsUiOM/j67RK8oKWrBYebDus+SqeZ3QlXjRgwu6+urg7p6ekIF8TuRBAEb+js6UVTu63xoTugEyFcoaunT9mXvLGtzKF9ydJx6bhy8SgVgRIGw3q5zEQjcpNNMtZL57gbpWNXbE58TnDZnXz22Wc4/vjjB902UNQRm6jj6DEZKyYIgjD8x3BLZ88xMdflsCZNj9v95eF6ZTJc22rfvmRUWhyuPW4MpuWKp+dQjIZIlW7lZI1oMRDWPS1BGKXzSNh985vfxIQJE/D9738fZ5xxRn/zxEBvu3feeQf//Oc/cfDgQdUhKwiCEO7QJLjxWAcro3KOIl16hQbHtC/ZXdFs937OI710QQFOnpItHZx2rF0YnaNdydBAiKA/+ix9KG0pDZpaOq+F3c6dO5UJ8Q9/+ENUV1dj+vTpyM7OVr/kKisrsXv3buTk5ODHP/4x3njjDd9utSAIgo6hMTCFnM0kWA92JO7S2tGDFzeV4MM9VXYbN6hTTpuajUvmFyLB5FG5dsjalXC8V05yrNi6BFmU7kjTEXT0diDYcbvGrqenB2vWrFGp2ZKSEvUrpKCgQKVeTzjhBERHh88XXGrsBEEgrI1TQs5sjcwF2iTY2yYOetG9sLHE4eSKqbmJamrE6PR4v2+fXhG7kuCN0pW1lKGyvdKrxwnKGrv+FaKjcfLJJ6uLIAhCuMKuVdbJNejIJNhb9lY0499fHMHROvv2JTTNvWrxaCwZlyapxWOIXUnw0trVqmrpQiFKN5DwCa8JgiB4GclijRyjchRzejIJ9pa61k48+2UxPj9Y5zAade7sPJw3Ow/G6CiEO0xDc8RXTrIJybFiVxKuUTq9IsJOEATBiUlwo7lLdbLq3I3EI/uSt3dU4PWtZejssS9UF41Nw9WLRyEzcXDDXLjalbCzlYLOZBCBG4y0hmiUbiAi7ARBEI7BkuPmjq8aH9p1bBLs7evceLQBz6w7iuoW+5YOBamxqo5uRn4ywh3albC7lZM0xK4kOOkL8SjdQETYCYIQ9lDIUeAw1doTZHYk7lLWYMZ/vjiCHWX253rHx0Th6/MLcdo0sS9JiqVdSSxS4wxSUxjEtIZBlE5TYdfd3Q2DQWoMBEEIXlG3t7IlJJofRqKtswcvby7F+7uq0GvnxdJl7eQpWbh0QSGSwrhuzGpXYp0OEW+U2EfQR+lay1DZFvpRuoFEeyrmfv/73+OJJ55AaWmpCuuT66+/HjfddJMyMhYEQQgGsbO/qjWkRV2fxYLV+2rwvw3FKs1sj8nZiWpqxNiM8LUviYlm/ZwJ2UkmmW8bArSGWZRuIJGerHTPPffgxRdfxH333Tfo9hNPPBG//e1v3Xqsp556CvPnz1deeGeddRa2b9/u9To7duzAt771LUyePFkZKX/ve99DeXm5Js8tCELozGllpE7v81m9YX9VC3712k489ukhu6KOExF+dNIE3HnutLAVdbQrGZ8Vj7mFqShMixNRFwJRupKWEuyp3xOWos5jYffvf/8bzz33HC699NJBt69YsQJvvfWWy4/zwgsv4LrrrsMNN9yAjz76SAmsk046CVVVVR6v09vbi2984xtqW958803897//RVFREU455RSYzWavnlsQhNCgp7cPeytaVFdoKEYhOS3i16/vxJ1v7MLh2rZhy0RHRuCCOXm475LZOH5CRtjVj/HlUtROy0vCrIIUFamLZA5WCGrautuwu2532KVevZ48QYxGIxobGxEbG4vIyEj09VkPjrW1tSgsLBwkoEZi9uzZWLJkCf7xj3/0i7K8vDw1j/auu+7yeB2+pIEHKs6uZXr4448/VuLN0+ceikyeEITg9KPbU9mMZrP9tGSwviY2Q6wuqsHGI/UjzqNdMDoVVy8ZrVKO4YbYlYQmeqilKwzmyRNk0qRJaqTYqaeeOkhAPfPMM5g1a5ZLj8GNY+rzV7/6Vf9tUVFRaqLFp59+6tU6Q3992oSmyWTy+LkFQQgNDtW2hoyoK280Y01RDT4tqkV9W9eIy+almJR9CSNU4YbJEKm858SuJDSjdKylM/e4FlAKBzwSdrfddhuuvvrqfmH08ssv47333sOTTz6pau9cwVbzlp2dPeh2/r1161bN1mH07tZbb8WUKVOwYMECjx+HdHZ2qstABS0IQvBQUt+OmpaRBZDeae/qwRcH67B6fw2KqludLs/JCOfOysMZM7IRHelR9U3QInYloR2lK28tR0VbRaA3JTSE3ZVXXqmiYr/73e9UGvbrX/+6iuI9/fTTuPDCC116DFsGmJGyQRsUHd2f2tViHXbpMrq4Zs2aflsWTx7H1jTiappWEAR9Ud3cgdIGc9CmWneWN2HN/hp86STVaks5zh+diuUTMzG7MEX9HS6IXUnoo7coXZ+lD+8cegeT0iZhWf6y4PWxu+KKK9SFaU6Kofh49zqqMjMz1XVNTc2g2/m37T5v1/nFL36Bf/3rX/jggw8GpYg9eW5bpJJCcWDEjjWFgiDo36vukJ0mAr1T0WRWYm6NC6lWws7W5ZMycdz4dCSawsuLTuxKQh89RumONh/F07ufxqGmQ8hPyMer57+K2OjYgG6T1+6LbKDwBAqosWPHYu3atbjgggv6b2dk7aKLLvJ6nV/+8pd45JFH8P7772PRokVeP7etaYQXQRCCh2DzqmOqdd2heiXo9lW1OF2eZsLLJmTgxIkZGJ0eH5Z2Jayfy4g3SmdrCKO3KJ25x4xXi17FR8UfwQLrwYUNHP/c/k/8eN6Pg0/YMZX5xhtvKGHU0NAw7P7HH3/cpcf58Y9/jN/85je45JJLlJ/c/fffr+rf6Dtn46c//Sk2btzY39Tgyjp33HEH/va3vylRt3jxYo+fWxCE4Kajm151zbr3qqOJ8O7yZlU39+XhenT1jmzDEhURgXmjU7B8UhZmFyaHXe2cISpC1Q5mJZnUtRC6UG9QMOklSmexWPBl5Zf4377/oalz+Fi+J3c9icunXI6suCwElbC75ZZb8Pe//10ZEqekeN5hdeONN6K6ulp117IpIT8/H6+88oqq17PR0tIySDw6W6eurk7V/jGyds455wx6vgcffFA1fbj63IIgBLdX3b5KetXpV9RVNXcoMfdpUQ1qW52nWsekxx1LtWaE1dgvGh0kGKOViEuJM6j/h5v3XjjS3t2uonTtPe3QAxVtFXhm9zPK/Ngeo5NG45eLfxlQUeexj116ejreeecdh9Ewd2GNXltbGxITE4fd19raip6enmEC0tE6fDkUd/bgskNTqSM9tzPEx04Q9ImeverMXb1Yd7hOpVo5+cIZiaZolWqloAunVCtr5pJjY5SQo6AzRIVXVDKc0VuUrqu3C28degvvHX4PPZbhx5ToyGhcNeUq3DDvBhijjMHpY0cxNHXqVGgFTY4dCauEhAS31uGvuIyMDE2eWxCE4ERvXnVMte6paFYzW9nV2tnjPNU6dxRTrZmYU5iC6DAQNQzAUcSmxMUgJdaAeKPXJeBCEKK3KN22mm34757/otZca/f+mRkzcdXUqzA/e77PRJ27ePTNYYMB6+gGdogKgiDogeI6/XjVMdVKA2FG51xJtY5Ks6ZaOeYrHGrHjIZIJeIo5vh6w8mWRRgepStvK1ddr3qgzlyHZ/c+iy3VW+zen2pKxZVTrsS8rHm6KwvwSNj9/ve/x7Rp0/Dss89i/Pjxw17U//73P622TxAEwS0hVdZoDnjDxvrDdfhkn2upVtaLqVTr5EyMCfFUK3UbawOZXk2JjUFszGAvUSE80VOUrqevBx8c/QCvH3xdpWCHEhURhdNGn4bzxp8HU7Q+x/J5JOx+8pOfqNmqY8aMkTSmIAi6oKGty+7Ae3+lWvcy1bq/BusPO0+1UuDMKUzFikmZKuUayqlWijdrVM6AJJNBLEmEfvQWpdtXv0950nGb7DExZSK+Me0bKEgsgJ7xSNi9+eabyupk7ty52m+RIAiCm7R29qjxWv72quM0C5oHs6u1uuWrcYOOKEyNVRYlx09IV+nHUCQ6KkIJOFvTg8kgUTlB31G65s5mvLD/BXxe/rnd+xMMCbhs8mU4Lu843aVdNRN27FAdN26c9lsjCILgQepznx+96qypVquB8O6KZpdSrZwEwdo5ToYIhhODJybBTK0mq6icWJEIwRGl67P0YXXJarxc9LJdgRmBCCwvWI6LJl6EhBj7jZwhI+zOOOMM/PWvf8Xtt9+u/RYJgiC44VW31w9edTwZ8XmsqdY6dHQ7T7XOLkhRdXPzRqWGnFWHzSCYQo6CLiY6tF6f4Btau1pxtOWoitYFmiNNR1Ta9XDzYbv3j0ocpdKu41PGI9jwSNgVFxfjySefVM0TEyZMGPYL9LXXXtNq+wRBEBx61XHkFn3hfEVNS6dKs1LQuZJqzU+JxYrJ1q7W1BBKtYpBsOANnNBQ2VaJ5tYKgJYgUYGzsmnvbscrRa9gVcmq/lFgA+Gc14smXISTRp2EyIjg/MHi0d6dMmWKugiCIASKgzW+8apjqnXDkXol5naVO0+1xsdE4bhjBsLjQijVyiicrU6OzQ+h3OAh+IbGjkaVduWcV0ULhV0MkDLK77vcYrFgXcU6PL/veTR32f9eL8ldgksnX4oUo+cTtYJW2DENKwiCEEivOld84dw56DP6x7q5dYfqYe4eOQoYYUu1TrKmWkMhFcn0ceKxpgde4mLEIFjw7LtU31GvInSD6tY6W4Au/t0OmFIA08jTE7SkvLVcjQLb27DX7v058Tn4xtRvYGq6doMXAol8cwVBCCoqm7TzqqNNyYd7qvDujkpUNnc4XT4vxaS6Wuk7lxYf/KlWEw2Cj016oL+cGAQLnqLGeXbUoaK1Ah29dr5LLVVf/b+5HIiJByJ92zHd2duJNw++iZVHVqLXMvzHmiHSgHPHn4szxpyh/h8quCzsTj31VHX94Ycf9v/fEVxGEATBF151R+q08arr7OnFI58cVB2uIxHHVOuxrtbxmQlBnWqlcEuKjVYND4zKiRWJoEVnaU17DSrbK+0a+io6moGBDRNcrqUSSM732RuwpXoLnt3zrBKb9pidOVtNjsiMy0So4bKwW7Bggd3/C4IgBJtXXX1bF+57fx8OOTA0pnablZ+sxNz80WlBnWqlMLVNeuAs1kgZ2yVoQG9fL2rMNSrl2t3XPfLCrdXDbzPXA7Ep1sidhtSaa5Wg21qz1e796aZ0XDn1SszJnBPUP9JGIsLC+KmL7Ny5EzNmzPDtFgURzc3NSE5ORlNTE5KS/FcvIAjhBhsadpU3aWJrwukUf165Fw3tw09GeckmnDgpEydMzAzqVCvPV+zKZeqYdXOCoOXIrar2KlS3V6v/O4XRuoYj9u+LNgIZk6wfWA22iynXNw++ia4++6PAmHI9d9y5MPJ5NaYwsVDV6ulBb7hVYzdz5kyVRxcEQfAX3Rp61dGD7u+rDqKrt29YVOv6FRMwb1RKUP+KZzAuI9GIvORYmcMqaEp3b7dKt1LQMf3qMq0DauuG0tMJtFUDCdlebdueuj14Zs8zqGirsHv/lNQpuGraVchP8F3qV09I84QgCPr2qqv03quOP0hf21qOFzaWDLsvO8mIW06fgvzUWATzGK/sRBNykk1BnTYW9Afr5iiYWEdnz/dtRFRtndl5mtaYDBhMHvnj0b6ENib2SIpJUqPAaGMSzD/Y3EWEnSAIuvaqa+nwzquuq6cPj316CJ8dqB1239TcRPz01ElBm66kiMtNNiE7ySQdrYKmdPR0KEHHmjWPGSlaZ4NZwOZSIH2Cyw/LiOGq4lV45cArMPeY7Y4CW1G4AhdPvBhxhjiEG24Lu5tvvtnpMvfee6+n2yMIgqA4WtfmtVddY3sX7v9gv2q6GMpJkzPxf8ePDUrjXaaOc1NMyEwwhlUkQvDPZAYKOnrReYW5yXm0zgb97drqgPh0p4seajyEp/c8jaPNR+3ePyZpjBoFNjZ5LMIVt4XdW2+95XQZEXaCIHjrVVfe6NxXzpkwvPf9fcPEIWXQVYtH4+yZOUEnimhVwvq51CBu7BD0CadD0Mi3sbNRmwd0JVo3ENqfmBKtkykcbN/LRS9jdclqh6PAvj7x61heuDxoR4EFTNjt3WvfuVkQBEEL6jXwqtt0tAF/XVWEju6+YYa8N5w0EfNGpyJYoPZkhy5TrsGaMhb0C8dr0VTY0Zgtj6N1PW7+MKOBcFMZkDZ2WH3s5+Wf44X9L6Clq8XuqkvzluLSSZcimbV6gtTYCYKgH1o6unHAC686ngTe3lGBZ9cXD/tNn5EQg1vOmIJRaXFB0+GayQ7XlFgxEhY0h40HjNC1dg8vU/Ca1krP1uPYMXOj1d8OQFlrGZ7e/TT2N+y3u3hufK5Ku05Jk9n1A5HmCUEQdONVxw7Y3j7PVF1Pbx+eWHsYn+yvGXbfxKwE/Oz0yWqgfTB0uOYkWRsipMNV0BrWzrGGjrV0PkFF6zo9X7+5HB2R0XjjyDv44OgHdkeBxUTF4Lxx5+H0MacjOlJkzFDc2iP33HOPO4sLgiC45VXX3euZqGvu6MYDH+xXjzEUznX9zgnjdC+SjAZrh2tWonS4Cn6e46rdE3kerTu2nZsb9uK53f9EfVeT3WXmZs3FFVOuQEZshhcbGtq4Jex+8Ytf+G5LBEEIS7z1qitrMONPK/eiumV4lOCyBYU4f06erpsk4o1RyE2OValiPW+nEHzQFoR2JYzQOZzjqiUdnkfrqjub8Gz5J9jectju/RRynO06J2uOlxsZ+kgMUxCEgMFf6Ae88KrbVtKIv3xUBHP3YFFojI5UkyQWjU2Dnjtc81NikRInHa4eRYbaaoGE0Bvg7vc5rppG66rcj9b39eC9mk14q/pLdNtJu3IU2Fljz8I5486BMUr7UWBakB2XjfRY51Yt/kKEnSAIAeNoXTvqPPSqW7mrEv/54siwRgt2kN58+mSMzdB2uLiWHa5siEgwyuHXIxgRqt1vLbInIu6+2jV9PWrkF2e5ujTHNcDRul0txXimbBWquhrs3j81aRyunvlt5CbkQo+kGlNRkFgAU7T7UzN8iRxZBEEICBVNZlQ0uV/v09PXh6e+OIoPdg+PDozLiFdNEhRPekI6XDWCJrZ1RUDvsShUw2EgLg2IjEI4w6hcVVuVEnX2mg30Fq1r6G7F8+Vr8GWT/W7X5Og4XJZ7IhanTkFEjP4sTBIMCShMLERCTAL0iAg7QRAC4lXHaJ27tHb2qNTrzrLhhdVLxqXh+8vHwxitn5O8gTNck6wzXA1BOOFCN/T1AfWHgJYhQ94ZIWo8CqSNQzjCujmmW5l2ZT1dwOhodCla12vpw8d12/Bq5Rfo6OuyOwrs5PTZuDBnKeJsademUiBjojXcHWCMUUYVoUsz6bfEg4iwEwTB7151RVUtbnvVMcJ378p9KLcT5bt4Xj4umleASB0c/Il0uGpIVxtQs9c6dsoezeVAQg4QExz+hFrNcaWgY2OEvSkM/o/WVTsVdNubD+P1qnUo7hhuR0TGxmbjmvxTMDoua/AdNDpuqwYSshEooiOjkRefh6y4rKBocBJhJwiC373q3LWq21XehAc+3I+2zt5hETFG6Y4brw/rA+lw1RiKtvrDwEjRKAqL+oNAzkyEOhx4T8sSWpfoBnODw2gdO13XNuzC2vpdaOyxP00mPsqIi3OW4cS0GY5/mFE4cqqEwb+1bBGIQHZ8tjJCDia/vODZUkEQgt6rbk9Fs9tedR/trcKTa4+gd0iIj2bDN58+CROyEhFouC15KSbpcNUK1tCxQaLdxUH0bKRorQnZRgrOSaWga+i032QQ2O7kmmFdrluaD2JN/S7sbi0ecfXjU6fhktxlSIqOc/48zWVA+nj4i3RTOvIT83XbiTsSIuwEQfCbV93Q2a3O1nlm/VG8u3O44enotDjccsZkpCcE7qDL4EI6Z7hKh6v2EaCa/YC7vmsh2EjB2agc+6XpHFcfRevKO+qxpn4nPm/Yg9Ze84ir5ZvS8Y38kzEpPt+9lDybZ+J9ayuSGJOoGiPiDfrrqncVEXaCIOjOq669qwcPf3wAW0uOWVoMYMHoVPzwpAkBm5/KDtesJJOaEhGobQhJGJWhOOMgeE8IkUYKfl8o5Ggq7GjovS6wWNDZUo6N9buxun4nDrSXO12FdXTL02fiuNSpiI7w4LvTUgmYEoEo7bveTVEmJehSTNY5tcGMLoTdnj17UFVVhalTpyI7O1uzdQ4dOoT9+/dj0aJFSEsb3MWye/duFBcPDhMnJibi+OOP9+KVCILgrVdddXMH/vz+PpQ2DP/Vf97sPFy2sDAgTRLS4epDus3WBolOLwfSB2EjBYUcU60UcRR0rd2tge1wdYGjzUex5sj7WFe1CWY73a0DYXfr0pSpODFtOgpjvUyV08qlqRxIGwOtMEQakJeQh8zYzKBojNC9sGtra8NFF12EL7/8EhMmTMDOnTtx5513jji6zJV1Pv/8c/z2t7/Fjh07UF5ejlWrVmHFihWDHuehhx7Ca6+9hjlzvhpPMmbMGBF2ghBAr7q9lc24/4P9w6J7UZERat7r8kmZAelwzUuORWaiUW2HoDEtVdbmhz4N/NeCoJEiGIUcae9ux/rK9VhTukYJO2dMjs/HiWkzMT95AmK0bDzobAbMTUCsd/52kRGRyInPQU5cDqJCKH0fcGH361//WkXUioqKkJGRgZUrV+LMM8/EsmXL1MXTdY4ePYobb7wR06dPx+jRox0+P5d/6aWXfPb6BCGcqWvtdMurbs3+Gvzz00PoGdIym2iKxk2nTcKUnCT4u8OVEyJYRxcqv+R1RW8PUHdgWPG91+iskSJYhZxt2w82HsTq0tXYULXB6bxZNkEcnzoVJ6TNQI4x1XcbxkYKmgNHeSbIMmIzkJ+QjxgfpHQR7sLuqaeeUgKMAo2cccYZmDt3Lv7zn/84FHaurHPFFVeo69LS0hGfn9G/NWvWIDk5GZMnT4bJpK+xIIIQzF51B6pbXfKq67NY8PyGEryxbXiNTkFqLG45fbKqafNnhytnuCbHGfz2nGEHx0+xQYIeZb4ggI0UFEPtPe1fCbmu1sBMg/ACbvsX5V+o6Fx528i1c/zJMz1xNJanzcTsxLGI9sc+57i0lnIgpdCt1ZJiklQdXZwheFL1QSXsKLpqa2uVKBsI/962bZtm64wERV1TU5NK17a3t+ORRx7BxRdf7HD5zs5OdbHR3KzTTiVBCBKvOi77t1UHsPHocBuHOYUpuOHkCYiLifZbhysjdPEyw9V3UOk3FgNNJdb/+wo/NlKEgpAjjCLurd+rxNzmqs3osYzc7JRqSMAJqdOxLG06MmL8G03v78iNTQGMzu2O4qLj1MSIZHrhhQEBE3aNjdZut6FNDenp6WhoaNBsHUecd955+OMf/6iidfxisibvqquuwowZM1T0zh733HMP7rrrLreeRxDCCXe86piqZZOEvXTtWTNycPXi0Yj0Q01bRkIMCtPipMPV13R3ALX7gA4//SD2USNFqAg5G42djVhbthafln6qRpONRFREFGYnjcOJqdMwI3G0qlMLKHyP0ycCkZEOGyMKEguUJ104lVMETNjFxFhz22bz4M43Rs5s92mxjiPOPvvs/v/zDb/jjjvwl7/8BW+99ZZDYXfbbbfhpptuGhSxKyx0LxQsCKGKO151TNPe9/4+NJqPDXM/RlREBL51/BicMtX344NS4gwYlRYnETp/0FYL1BZZU2j+QqNGilATcqS3rxc7aneo6Nz22u1Oa/44SuvE/BNV/Vxyh44sWBiZba0EkvIG3RwZEammRbA5IuDiM5yEHQVRVFQUSkpKhqVb2Z2q1TquEhkZiZSUFFRUDBkyPQCj0agugiAMP/kVVbvmVff5wVo8uvrgsKgemxV+csokzMj3bbqEzRiM0LGWTvAx7HStP2T1HwsEHjRShKKQs8HZshRzn5V95nSKBUdoLchegBPyT8DktMmI5NeVEVe90V4H0HvuWGQ2Ky5LzXU1RIXv9ztgwi42NhYnnniishy59tpr1W2sd/vwww9VytPGrl27VAqW/nKuruOMvr4+tLa2IikpadDzsJt2oP2JIAiucaSuHfVtXU5PmC9tLsUrm4cb0NLsl5MkcpNjfbbLY2OiUJgaG9BpFWFFZ4u1QaLb9c7oQDRS8HPJGawUcRRzvISKkCM9HPFVvUUJut11u2HByGUS7BY9seBELM1digR2ntpg9zJHvekNRmabSpGSvxAFSYWIjfbdMSRYCGhX7N1336385W644QYsXbpUNS8wKvftb3+7f5kHHngA69atU351rq5TVlamPOzYaEHoedfR0aF873jp7e1VpsVXXnmlskShUfG9996rumovu+yyAOwJQQheyhvNqHTiVdfV04dHVh/AukPDZ3/OyEvCjadOQoKPmhZioiOVoKMPXTjV2QSUplKg4SigB1sPO40U9GQLVSFng7Nl15RZo3O0WBkJ2n4sylmE5QXLMS553PDvSV+f9rY0GhHPiRGmTCRGxgIi6hQRFv5cCSBbtmxR4oxTJGbOnKlq2AY2Rzz44IPYu3cvHn30UZfX+eCDD3DfffcNe66rr75aXUh9fb16TD5WamoqTjjhBNU8wZSsq7DGjs0XjBoOjP4JQrjABoj9VSOfNBrau1Q93cGatmH3nTo1G9ceNxrRbnzvXCU6KkJ1ueYmmfzShCFQRHUBtfutHYs6or2vE83p49Fi6VEih1GsUKSztxMbKzfi07JPsb9hv9PlxyaNxQkFJ2Bx7uKRI11MZ7c4LlMKBDFsjDBlID3mWFcsa+ny5wGG0IzYuaM3Ai7sghkRdkI409zRjT3lzSPamhyubcO97+8blqZlQODapWNw+rRszaNo1HBM6ealmBAdFX6F0wGjvd4q6nSQrmvv7UBzjxktPWa09pjRw4icMSHo58g6ori5WKVav6j4QqWVR4ICjmlWpltHJY1yrU6yZp9/G19GICoiEnnGNGQZU4Y3RpiSgdxZCHe9oYtZsYIgBBfmrl7sd+JV9+Xhevz9kwPo7Bmcjos1ROHGUyZidqG2w7apD7MSjchPjYUxOrRGBOkapulYx0briQDR3tuJZjY8DBRyQ+EcWjZT0PssBKCAW19hHfF1pPmI0+UnpU5SYo4NEW5NXKBg14Goi0AEsozJyDWmw+DIBJnG1y2VQGIOwhkRdoIguAXr5TjT1ZFXHZMAr28rV9MkhkLhxSaJglRtvcXS6UWXGqcaJAQ/0tVmjebw2s/UdbWgobtFiTm7Qs4eTCfS0DZIZ4OqEV9NB5WY+7LyS6cjvhJjEnF83vEq3Ur7D7dhtE4HtXVphkTkm9JhckWQ1h8GYtOA6NAcF+YKIuwEQXCZXidedTQo/ueaQ/j0gLVxaSBTchLx09MmIcmknQ0BLUtGpcf5rPFCGIHmCquViZ8bJMy9XSg2V6sIndswTdxaNcz3TO/QcoVpVgq6stbhXeVDI1vT0qepRog5WXOUbYlXViIBjNYlRMei0JShrl2m79gM4uxpCFfkaCgIgsvRAhoLt3baP9A3mbtx/wf77DZTLJ+UieuWjdWs5o1CrjAtFilx4furPGBQHNFsmCd9P0IT3fKOelR2Nji17BgRbjcjOgZ9zwbn691Xv0+JuU3Vm5w2fKQaU7Esf5mKznHIvfcbwGjd8B9o/sAYaUBhbKYaW+bxe9xWC8RrsB+CEBF2giA4neda09KJ6pZOlYa1R3F9O/68ci9qW4c0SQC4cvEonDMzV5MmCZMhUpkLZ4gXXWBgjRobJGgh4keauttw1FyNzj4NGjPYL8gB8jptpOCIL1qUcMRXtbl6xGXZPDA7c7aqnZuRPgNRWqaYAxCti46IQp4pHVkxyd4fL+oOWo2Lo8JP5oTfKxYEwaXoHDtZKeYYiRupd37z0QY8vKpoWHqWIuxHJ03E/NGpXu/xmOgIVZfHGj3xogsA/AA0HAGay6z/9xPdfT0oNtegvlvjMVY6a6Sgr96mqk1YX7kee+r2OI1IZsZmKjF3XN5xSDV5//0KdLSO6eNsYypyTalK3GlCb5e1qSdjIsINEXaCIAyKzlU3d6KmtQNdPRan4u+dHZX47/qjw05DGQkxuPn0yRidHu/dASoqQk2loH1JlHjRBYZus7VBgpMk/AQ/W9VdTSjrqEWvr2r4AtxIQc+5bTXbVGfrjpod6LGMHB2LjojGvOx5StBNSZvi2xmo7bV+i9alxyShwJSufOk0p6USiM/UjYD3FyLsBCHM6euzoL69Swk6Rudcoae3D//67AhW7RueKpqYlYCbTpvkVf0bNVxOskkZDBvEiy5wtFZbC9EZwfETbT0dOGKuVl50PiUAjRSsk9tVt0uJOY75orhzBrtZ2QixNG+p6nL1Ob29QKvvo3VJ0XEojM1AXJSPax3rDgB58zgQHuGCCDtBCOPoXFVzh6qfc2RdYo+Wjm488OF+7KkYHsE5fkIGvnvCODXGyxNYVsP6uYLUWJgMwWlJERL09gD1B63Czk/QsqSsow7VnY1+e05/NFKwCaKooUiJuQ1VG9DW7dwaxhhlVH5zFHTjU8b7t/zAXAv4cMRabFSMmhiR4mljhCcR50aOlBuLcEGEnSCEYXSOgq7Z7H6qpazRrJokqpqHRxouXVCIC+bkeXwSSouPUZ2ucTFyWAooHc3WBgmeEP3oSVdirka3v2e2+qiRgqlkmgYrMVe5AQ2dzkesMdU6M3MmFucsxuys2Urc+R0fResMEVFINiQgxRCPlOh4/9fJNpdZU7KcPhIGyBFUEMJkUgTFXG2re9G5gWwvbcRfPipCe9fgk29MVCSuP2k8Fo9N9+hxE03RyotOS387wUOR01QCNBb7rUGio7dLdbt65Emnw0aKitYK1QBBQVfVXuVS0wDr5ZbkLlH1c/EG72pSvaa9RrNonSkyRkXlUg3xiI8yBbbpyWKx/ljJm2tNC4Q4IuwEIYSjc3Vt1uhcS0ePVynbN7eX47UtZcNGiKXGGVSTxLhM938Jx8VEYVRaHFLjxYsu4NC+hA0SHMnkB5ierOhsQEVHvXeedDpopKgz16kpEBRzxS3FLq0zPnk8FuUuwqKcRUg2JkMXMFrX5p03YWJ0rIrIUdC5NCXCn3S1AU2lQEohQh0RdoIQYrR39RzrbO1Ej4fROVuDxEd7q/HKljI022mqGJsRr0QdU6juYKQXXSq96GLEukQP8GReV2RtJvADTd3tanJER9/I47D8ipuNFM1dzdhYuVGJuaLGIpfWyU/IV5E5irnMuEzoDg+idezMTY6OU0IuOTre8QxXvdBYbDUtNrgxySIIEWEnCCESnatt61SCzpvonHosiwVfHKzDCxtLlI+dPRaPTcMPVoyHMdr1A7khKgL5qbHITjQhUqxLAg87XTlXk9EqP3nSlXTUqHo6XaIaKVIdnvTNPWZsrtqsxNzu+t0q6ugMToBYnLtY1c0VJBZA180yLkbrDJHRKirHqRCM0PnUdkVrLH3WqSm5sxDKiLAThCCmrbNHia9aL6NzA+vonvuyGEfq7Nc8sTrlwnn5uHheASJdrFWh/1zuMesS8aLTCawrY+q12/e1bWwkqOlqQqkvPem0qsNqLgfSx/ff1NXbhe0121XdHD3nnI31IkkxSSoqR0E3LnlccESl6Vs3QrQuLsqoonIUdPHR+h7F5hSWG9DfLjEHoYoIO0EIMnpZO9dqHfHlbXTOxsGaVvzvy2LsLG92uMzcwhRcvmiUqotzBQblspJMyE+J9dj+RPABTWXWKRJ+EFn0ojvSXo02X3vSaUVXG3rb67C7rVyJOUboOlzY9rjoOMzPnq/EnM/Ng30Srau16zOnxJwhXs1uDSnqD1ttbqJ1VgeoESLsBCGIonNshGBDhBbROVLRZFYp13WH6h0uQ8PhKxeNwpTcJJcfNzMxRo0AEy86HdHTZe0MNDu33vAWRuY4NaLKn550XpYfHGgvx/rGfdi4+wBaXOjSjYmMwZysOUrMzciYAUOwip821tb1ISoiUom45OgEJBvitBvtpUf6jvk0Zk1FKCLCThB0Hp1jmpW1c62d2o34aWzvwsuby7BqbzV6HVhb5KWYcPnCUVgwOtXldFJKnEFF9OKNcmjRFe311toizs/0MfVdLSjuqFE1dXqGKWJuJ8Xcl437XZpHGxURpUQca+Yo6kxBnpaMQSRSe/uQHF+ApOjY4Egba0VbrbWuMN4zmyY9I0dfQdAhrbboXGuXEndadsy+tb0C7+yoQGeP/VQcu1y/Pq8AJ07KdLkmjl50hWlxSI4N0qhFqELRzkHoTL/6mM6+buVJ1+TCZIVAUtXZoMQcL7RcccVrbnLqZGVPwmkQCTHBbXJLr7wUY4q6xLHWzBRAD8FAU38QMCUDUaElhULr1QhCEEN7EZvvXFuntg783b19+GB3FV7dUuYw8hcfE4Xz5uTjzOk5LtfExR7zonPX8kTwE5yTyZO3D2F3aGVnA8r14knnIIr4ZdN+JeYoPl1hbFwuFhcux8KchUg1pSJYoTBNMiYpIZdqTIUhyvBVat7Hn42g8G9sOAJkTEAoIcJOEAIMZ69yRFd9m7bROZsNymcHa1UdXW1rl0MbEoo5iroEF1OoFH6FqbHITDSGV/ommKg/5PMTNydGHG3XmSfdMVp7zNjYVKTE3P62MpckZ64xDYtTJqtLtjEFSBkFmLyfSOFvoiOjlfExhRy7dKPs+cs1l1otb8Kdlgqrt50Gk0f0ggg7QQhQdI5Ci9G5oSO6tKof2lrSiOc2lKCk3oF1SQSwYlKmsi5JT3BtLiVFIG1LcpLEi07XNJb4NP3a3dd7zJPOcRd1IOCIsi3Nh7C+cS92tRSjF847f9MNiVh0TMwVmjIG/1DxYiKFvzFFmZBisqZYEwwJI//gYrSu2T/+hUET2c6bB0QGUTfzCIiwEwQ/0tzRrRohaFeicXCun6KqFjz7ZTH2VjouBmdDBBsjaBjsKtlJRpV2jY4KjYNfyMITNtNLPqKm0+pJ16PRTFFvYZPGjpYjKjK3rfkwuizOmzYSo2KxMGWSEnPj43IdezK6OZHC31DAMU3M6FxstBvTFDgTWM+egv6m2ww0HgXSxiIUEGEnCD6G9W22zlZfROdslDWa8fyGYmw44rggfEpOIq5YNAqTshPdGgE2PiMByXHSGKF7WmusBeE+oL23U9WnMcUZaFjXt6e1VEXmNjUdgNmFVHBsZAzmJU9QYm5qQqGy99BiIoU/USO8YpJVZI5iziOLFamts09zGRCfCRiDuzmGiLATBB/RZO5GTYu1s9VX0TnC2ryXN5di1b5q1QRpD9bD0VyYJsPu1MRlJRkxWqJ0QWRpss/aCauxJ115R51qkNBDR+vaht34vGEPGrpbnS5viIjC7KRxSszNShyjxmFpMZHCn1C82bpY2QThtfmxROscv8+cmZw7x1qnEsSIsBMEjZsVqlo6VDOE2YfROcLu1je3lePdnRXodmBYnJEQg0vmF2LZhAy35rPGREdgXEYCUqXbNXjGJFXv0VzUUTwxShdITzrWzbEJgoKOTRDOiEQEpieOVmJubtI4xEa5Vj86Il1tgLnRbwX2TKuqLlZTqrIn0bQLNNw7YZ2N2mPkLlnHc31dQISdIGgYoTtc2+ZzQdfV04eVuyrx+rYyh7Yo7G69YE4+TpuW7fY4L06NGJ0eD4PU0gXPyahqt6Y1U/SkKzbXoNGFqJgvYPPPgfYKfFq/Cxua9qvtccak+HwsTpmE+ckT1TgszfFDIwW7WLPjs5EY43qphFs0lUptnTMai4G4dF2k3j1FhJ0gaFBDd7SuHTUtnT6PBq4pqsGLm0pV+tUeMVGROHtmLs6dnYu4GPe+3ux4HZsR73KHrKCTou+qXdYRSRoJKuVJ11mv6tj8DSOETLOurd+Nqi7nqd9RpkwVmVuUMgnpMa6PvPMIHzVSMLWaEZuB7Lhs306ykGida9AChl2yOTMRrIiwEwQvqG7pQHFdu8NUqFYn201HG/C/DSWqQcIezLKePCULF80rQGqc+2bB6QkxStRJlC6I4Im6cqdmY8Jaesw4aq6C2Q9jxwbS09eLrS2HlJhjd6szk+OEKBOWpE7BstTpGBWbCb+iYSMFa+co5jLjMpXvnF8scKQT1jWYdm+pAhKzEYyIsBMED2C69VBtK5rNvq092lvZjOe+LMb+KscpscVj03DZgkLkprh/somOisCY9HhlNCwEEYweUdT1dGjiSUf7ktquJviTEnONqpv7omEvWnvNTqcnzEwcjWVp0zE7caxnTRBaoEEjRZwhTgm6dFO6/8y9uzus0UbBPYNvivjo4JuqI8JOENxMhzJqVt5o9mmnK02FGaHbXOw4HTUtNwlXLh6F8ZmeteenxhtUg4S7NXiCDlJFVTuBbu9nfFLMlZj950nX1tOh/OY+bdjl0miv7JgUJeaOS52KVINObCg8bKRgMwTr5zgJwu9IJ6z7sLyB1kFZUxFsiLATBBdpbO9SzREd3b6rPaLf3UubSrFmf43DhNTo9DhcsXAUZhUke/SLn1E6PkZWog/reQTf0Ndnraljw4SXnnTF5mqVfvWP51yJaoTY3HzQqYg0RhqwMHkSlqVNw8S4PH2OrHOxkcJv9XMjIdE6z2mrBdrqgPh0BBMi7ATBhS7Uo3VtDmetajUv9vWt5Xh/d6XDer2sRCMuXVCIpePTHTvlOyE51oBxmfEwGfQ/Ikmwkwas2WO1NvHKk64elZ31Pt+91Z1N+Kxht7rUdzuegjKwq/X41GlYmDwRpiidp7+cNFLY6ucy4jI8MxHWPFrnw/SCq3S1A8VfADEJQP48ICpIDM/rDwKmZCAqeORSwLf04MGD+Ne//oWqqirMnDkT3/3udxEbG+v1OhUVFXjiiSewd+9e3H777Zg6daomzy2ED2xaoB9dSUM7enzUHNHZ04t3d1bija3lMHfbj2QkmaJx4dwCnDo1y+NxXlGR1ihddpJE6YKW2v1WE2IPoXXJUXMNulywDvEU2pJwEsTa+l3Y21bqdPmU6Hgl5o5Pm4YcYyqCCjuNFHHRcSrd6tf6OWdd03qoraveDXzyB8B87PNLO5HpFwETzwAMJv03KTUcATImIFiIsPDsFSC2b9+OZcuW4ZxzzsGSJUuUyDIajVi7di1iYmI8XufBBx/E/fffr5Z59NFHsWrVKqxYscLr5x5Kc3MzkpOT0dTUhKSkANRNCD6jrbNHpV1bOnzTHNHbZ8En+6rx0uZSNLbbP9EaoyPxtVm5OGdmHmJjPI+wJcVGqzo8idIFMXUHrUX7HkAhd9SHnnQ8hRxqr8Tahl1Y37gfHU7Ge3GU19yk8ViWOg0zEkd7P0khkMTEq0YKjvdihI7XuqJmf2CFHeXF7teBTU8C9lLwxiRg6nnA1K9ZI3l6JneWNXIXINzRGwEVdmeffTZ6e3uxcuVK9Xd1dTVGjx6Nhx56CN/5znc8XufAgQPqNkbiCgsL7Qo7T557KCLsQg8KrtKGdlQ0dfgke8Gv25dH6vH8hhL1HI6ia6dMycKFc/OR4oF1yUALlFHpcchJMukjeqBTmjqbUN9Rj142JQzAke2Gw9vd+MC49RgtFbA0Vzh4HOe3dvR1+8STrqm7DV807lW1cxUupHYLTRmqEWJJyhQkujOwXqewUzcjJgnZ+YsRm1II3cFoXdmmwKVhmXr9/C/A0c+cL8uo5+RzgGnnW6OgesQQB+TNBSID80PEHb0RsFRsV1cXPvzwQzzyyCP9t2VlZeHkk0/GW2+9ZVdcubrOhAkTNH9uIfSh6S+jdKyp8wW7y5vw7JfFOFjT5nCZ48anqzo6b1OmiSZrlM6bSF8o093XjTpzHarbq9HZ61tjaa9orbEW6usENj7saD6iulq3Nx9GnxPPufgooxJyFHSjY7MQCnD+bJYxBZkxKTCweYLvD2vtfDiRwnPfugCJOqYuP7nHOp7LVRG68yVgzxvAxNOtadoEnX1eutuBpmIgdQz0TsCEXXFxMbq7u1WUbCD8+9NPP9VsHS0fp7OzU10GKmgh+GGd25HadofTHLyFjRf0ottW6rjofVZ+Mi5fNEqZBHsDo3QFaXHIS5YonaPoXK25Fg0dDU6NcAMO6+l0IurKOupU3RwjdM09I9usMDY8PcHqOcdZrQHznNOY2KgYVQeYZkgcnD5mDVbjUSBtHHQDo2Vtzu1kfMKhVcAXf7Xul6HMvAzInwvsfBko3TD8fppj730L2PcuMO4kYObFQLKOoqFNpUBcBmDUd9o4YN84s9naZp+QMHgHJSYm9t+nxTpaPs4999yDu+66y+XnEfQN015Mh5Y2mFUKVmuqmzvwwqZSfH6g1qGEGJcRjysWjcKMfO9rN+KNUZiQleD2KLFQJ2iicwMxN7ke7fARtET5kp5z9btw2Oy8TiszJllNgzg+dSrSfDXrNABw7myOMQ3JTMU5gvWPCdnWmjs9EIhOWHYKb3gc2Pf28PtYP3fCz4CChda/s2dYDYB3vAgcWTu8qID1eAc/BA5+BIw+Dph5CZCug+YFiwWoKwJy5wA6Lm8J2BmAuWLS0DDYgLW+vr7/Pi3W0fJxbrvtNtx0002DInas4ROCD9qLMO3a1qm9MWuzuRuvbinDB3uqHApG1r1dtrBQTY3wtv6Nq+enxKIgNVZq6YI1OjeQzhZryicAabQ+iwX72kqVmNvUVIRuJ55zMRHRWJgyUQm6ifH5Htvw6LF+jrNns40piIsyunjCP2gtsNdFtK7Gv8/ZWg2s/oO1c3soaeOBFbcBiTlDbh8HLL8VmHM1sOtl4ODHdmYeW6w1erzkz7cKPIrCQNLZav3RlVwAvRIwYUdBlJKSgp07d+Kss87qv33Hjh3KekSrdbR8HHbN8iIELz29fSiub0d1S6fm5832rh5lXfL29gqH1iX0kbt4XgFOmsL5kN4X4cbFRGF8VgISjBKlC9ro3NCTcsNRv4u62q5mq+dc/W7UdjsvMZkQl6vEHEVdrCvCJ0iIPlY/lxWT7H4Kmf6CrIlM8PP82qE0+vlHARs0Pr0P6LTzuZl0JrDou8BIvoTJ+cBxPwZmXwHsegXY/z5g77vL5+Elaxow6zIgb17gomaNxdaUrE6tWgLaFfuDH/xAdaxu2LBBpUE///xzZUHy3nvv4fTTT1fL0IuOXa5Mg7q6jo3S0lKHXbHuPI4jpCs2uOBUB9a7dfVo+5Hv6O7F+7sq8eb2CrR22rdHiTVE4dzZeThrRo4mtiM8nuUlW6N0kSysC3OCNjo3tIC8/rCdqIVv6OrrwWZ6zjXsxp7WYqd7LTk6To32oqDLNaUhlGD9XHZMKtJjhtTPuUu00RpZClQjBcedlW/xj7Bjp/W2/wHbnhueSqWQW3I9MOFU9x+X49rYRMFau5HG5jESyAjeqKWB2d+xKUCO6wGlsLE7YSqUIopWI9OnT1eNCzQJvu+++/qXue6667Bu3ToVXXN1Hd72j3/8A+3t7Xj11Vdx6qmnIjs7GxdddJG6uPo4zhBhFxxQeDHt6sgvzlPYPfvhniq8vq1cpV/tER0ZgdOnZeP8uflIMmnjtM5O1/GZ8UjU6PGClaCPzg2kp8vqcM86JR/Cw/0Rc7XynFvXsBdmZ55ziMScpHHKQHhm4hjlQRdKWOvnUpFs0LA2jhGoQDVSVO/1Txq2oxlYe581gjaUxFxr6tXbfUCRyno9+uCNNG0lqQCY+XVg3ArA3406GZOAxGy/PFXQCDtCL7nPPvusf/rDlClTBt1PUVdbW4uvfe1rLq9z6NAhFYEbyqxZs9TF1cdxhgg7fdPXZ0F5kxllDWZo2RvR3duHj/dW47WtZQ7FImNoyyZm4JL5BcjUcCZrbrIJo9LiwjpKFxLRuYFQzLGQ3F4XoUawk5VCjjYl7HB1Rr4pHSekTseS1ClK/IQSrJ9jcwcFnUv1cx6F0+f6v5GCQqhss++fh3V0tDKxJyALlwDLfqKt2XBPB1D0gTVNO5Jojc88Ns3idGvk1B9wLBpTwtG+H4EXVMIumBFhp1+azNbmCHOXds0RPX19WL2vRjVG1I1gjbJgdCq+Pr8Ao9O1O7AbDZHKl441euFISEXnBtLba43U8eTlIjQbZlNDd1+P3WumWLstPejp61UROfrNbW0+hF6M7M8YGxmjhBxTrWNis/TbiGPpQ0L9ESTUHUZHYhYac6YDLkQSWT/Hzl02RPjcgoUTCvzdSFG9xzq03ldQKtCGZMNjw8sFuP/nXWsVVr763PAHEK1U6Hc30hQWU4rV6JiGxzF++FFCQZnlXlDIE0TY+QkRdvqD0bSjde2oadHu5M/O1rUHavDK5jLVdOGIOYUpKkI3LlNbj6PsJKMSiZxIEW7oMTrH38K9Skh1o7u323rd142u3i513UNhdew22/1dfV2DlrXe14Xu9jp093Y6FGnDri096NVwigQ/UVMTRqnxXvOSJyBGr55zFgviG0uQVrYFaWVbETMgNdeWnI/SaeeiOWuS3VVNkTFKzHFKhF/Hl2VO8V8jBTs1WVvnK7o7gHV/swore0KK3a3+qjfjhJjiz4HtLwANhx0vZ4i3jirjyDJfjwLLng7E+bbuVISdnxBhpy+qWzpQXNeO7l6LZqncLw7V4eXNpQ7HfxF60FHQTcrW1rsrJppRunivxooFI/6MzrV3t2ND5QYcaDyAjt6OYWJtmBg7dpteRKanZBiSsCxtGo5LnaYEjy6xWBDbUoG00q1K0JnaR04hN2ZNQen0c2FOylV/c2wZ060phgCZyfqzkaJqN+Bk/3hMUxnwye+tnaBDyZpuFXU+FjUOI4hlG60Cr2bPyO/DxDOB6RcC8RlB+16LsPMTIuz0AdOth2pb0Wzu0czLa8Phery4qRRljY4Nq6fkJKrxX1NztT8xZiYaMSY9DtFRoVWsrofoHFOZ++r3YW3ZWmyq2qSiaeEAR2EtSJ6oJkJMji/QreecsbVGCbn0si2IbXFvgL0FEWgZuwzRc69BHIv4A40/Gil8Ga2jf9xnD1o7tofCtOu8a/zfsGBP4FXtAna8AJSPUGPI7Rx/MjDj69YRcFpDA+VjPyp8gQg7PyHCLrAwokbhVd6oTXMEU2ybjjbgpU2lOFrvuM1+YlYCLllQiBl5SZrXIcVER2BcRgJS48MjSufP6Byf57Pyz5Sgo4AMNVhDRvHGdKohIlrNMeU1mx+YZl2UMsk3zQIaENPegLTyrUgr3YJ4jm1ygR5DLKLtCQ5bBIXCgxcOmA8U/mik8EW0jjV0m/4N7H5t+H3cn8f/1DoRQm/UHbBG8JiqdQTT8aOXWa1S0sZq99wU8BTyPkKEnZ8QYRc4Gtu7VHNER3efJoJuW2kjXtxYikO1bQ6X4xzXSxcUYHZBik8KyzMSYjAmIx6GMIjS+Ss6x7Tpluot+LTsU+yu2+3T52K3ZUxUDAyRhq8uUQZER0YjJjJG/d/Q1wtDX58SYCzg/+r6KyE2/L7hy8bYlj12HRURpdsInCOiO5qRVr5N1cwl0r/PBTriM1CfPxf1+XNgTshCbskm5O59F1GO7DBiU4E5VwETTguct5wvGyk4paR8q7aPSZG4+o9A9e7h96WOAZbf5lMBowmNxdYmi0OfWP32HFGwCJh1qbUe0ltE2IUGIuz8D73jaDJc29qliaDbVd6MFzeVYH9Vq8PlaC/CGrr5o1N9IugMURFKNKYn6DOaEmzROb6vxS3F+LT0U6yvWI+2HsdinVAUzc6cjcLEwn4xNlCYDRJqkYZB4i06Krr//3ycET8fHLvUUolwJqqrDakVO1RkLqn2ACJcENpdphTUF8xFS8FCWNLHqUkXxkiDuk6IMiGCHcW7XrWOpXJkGZM8CljwLSB/QWCmFfiqkYIpyPZ67R6vcjuw+k9AR+Pw+8adBCz9IRCtz2kLdmmtAna+AhS9D/SN4BGZMwuYeSmQO9vzz4cIu9BAhJ3/4MmaHakcB9ajQXPE3opmvLCpBHsqWhwuw/mrtC1ZNDbNZ9GQtPgYJerYKBGq+Cs619rVii8qvlCp1pKWEqfL5yfk44T8E7AkdwmSjD5uIGirs86XDEMiuzuQWrlTReaSqvci0oWu3l5jEjpHLUbfmGWIzpoOY5TR+Y8qCpytzwAHPnQcpeEJfMG3gfTx8Cu+KK7XMlrHOrWdLwNbnhq+71ibtuh71vFgQRYV7sfcYE0r730H6HFcN430idYIXuFilyx0BiHCLjQQYecf2jp7VNq1pcP75ogD1S14YWMpdpQ5djLPSTLh4vkFOG5cus+MgKOjIjAmPV41SYQi/orOsRFiV+0ulWrdWr0VPZaRPyOx0bFYnLtYCboxSWP849XGEUlNJX6f/xpIInq7kFK1R0XmUqp2I9KFMWmWmAREsG5r7IlA9kzPRVDDEWDTk/anIli3zjqlYO43gIQsBG0jReVOq2Dxlq5WYO2DQMm64ffFZ1mnSGRMREjQ2QrsfdM6sozC2BGM8LIGj59FVz+HIuxCAxF2voX+caUN7cpqxNtzIoXhixtLsKXETorhGJkJRlw0Lx8nTMz0qWdcSpwB4zLjYYwOUM1PCETnqtqqsLZ8LT4v+xwNnc5PblPTpmJZ/jLMy56noj9+g6OXGo+GhaiL6OtBUvU+1c2aUrkLUa5M0oiOBUYtsZ5Ac+dYnfy1omIrsPFf1qke9og0WI1seQL3x5QILRsp+Lmq2Ob943DfcIpES8Xw+xhhXPYzwKRTOxxv6DYD+1dap1mYR0hlJ2QDMy62zrzl/NuREGEXGoiw8x31bV04UteGTi+bI1iPxy7XjUcbRkyHXjg3HysmZfrUXoRikRYmWUlBVKOio+hcZ08nNlZtVNG5/Q37nS6fbkrH8fnH4/i845EZ5yej2KGRkPojIxdvBzGcG2tEFFLrDiG5dBNiyzYhkmOtnK4YAxQsAMacCBQs9O34J+57mupufhpod9AJzTT87CuAyWf53rpDq0YKLaJ1TFmv+zvQO7ReOQKYcyUw6zL305HBRm83cPAjYMdLQOsI9a+xacD0C4BJZznushZhFxqIsNOezp5eHKltV8LOGzgf9qXNJVh3yPGvsZRYA86fk4+Tp2T5vMaNo8AYpTMZQidK54/oHGsrDzYeVHVz6yvXOxWO7ECdnzUfywqWqSidXycNDKTLbI2GWLQbaRcI2OlrijKo6Q3GyBiYIvn/aMTWHUT0kc+sPmf2Cu2HPVAUkD/PKuZYv+SPUU8DYfRwz+vAjhfte7IRepvN+yYwaqlva8m8baRgB3DFds/Xp5Bb/6i1ocCeyD3xFmtkMZzo6wWOfGr9fDDC7gjOwOUki6nnAsYhhvQi7EIDEXbansCZci1tMKsUrKdUNnWoSRGfHax1mP1KMkXjvNn5OHVals/ToYzSsas2Jzk0onT+is41djbii/IvVHSuss15Jynr5ZhqZf1cPEcJBRKKiLqDw+dp6hgl3JSA+0rExUYZEMN0JeGXiTNtD622ngAdRb8GQlHNMVMUc6ydG3oiDASsd9z2HLD/XceR1Kxp1gaLzMn6bKSo3GF9HZ7ArmymXvleDiVjsnWKhD/rDvWGpQ8o2QDseB6oHSErwM7gyWcD0y74auqGCLvQQISdNrR0dKsauLZOz6MbNS0dapbrmqIah2bF8cYonDsrD2dMz/FL5CzRFI0JWQlBH6VjgwKFFgUdo3S+is5xxur2mu0qOre9drt63pFIMCRgad5SJehoVaILGA2pO2QnvRV4KNKUcIuicDMgVgk4g7o4bCJpOAocWQMcXmO/DsuRMBpzAjBmmdVHTo/QBJkGvPYaBmzwNXCwfWKOfhopvInWlXwJrL0PsJcun/I1q5jVssYxmLFYrNYvnGYxUi0jU/f0SGQdHn+8iEFx8CPCzjt6evtQ0mBGVbPnzRF1rZ14bWsZVu2rcRjpizVE4ZxZuThrRg7iYnw//oZ9F4VpcchNNvmn69JHEdTmrmYl5tic4ExkeUNZa5nynKNVSUtXi9PU4MyMmUrMzcmao1KvuqG3xxoJcaVpwMvaNnrmRatr6/95HT3g/1H46j6aGFPQuZyWbi63RuUo5kZKSw0dp8TIHMVcMEV8qnZaGywcRWf4+ZpyDjDrcm0jjp42UngSrWOacet/rSLFXvRw6Y+Bccvde8xwomafNUU70o8AfrcmnwOcfDuQNdUnmyGTJ/yECDvPRUNNaydK6tvR1eOZomto78LrW8vx0Z4q9DgQdCZDJM6cnqtEXYLR9wKAFiYZCUYl6II1SkdhZRNzjKD5ivbudnxZ+aVKtR5ucj51IDsuW4m54/KOQ6pJh1EgnjxZU+eofmuAMB0kwAaIs5GEGv9PYcaxYT6hreaYmPsUqCtybR1aQrCbdewJQJLOJxGMBH9V8rVv/o/V0NYeFGBsJphyrnZRLXcbKSjoKOzcgeus+ZM1+jSUpAKrlUnqaPceM1xpOGKdZsEfPCP90GX084K/W99fDRFh5ydE2Hkg6Fo61XxXT0eBNZu78ca2cnywuwpdvfYfIyYqEqdPz8a5s/OQZDL4JeWalWRERrzRZ753voQii2KurqNO1dD5Ckb99tXvU6lWdrc6ey7akizMWagE3cSUibqIflpHd0WqSKESXZFRiGZ0rO6QmqrgTLQFrJnDHuyqZPMDT1T2xkfZIzHXGpmjmON4qVDrkNz7FrD9f/bTlTb7Cw6+5z7Q4vPoTiMFU7CORqfZo3oPsPoP9ufIMs183A2Awc9NLKFAc4V1ygm7iu39+KUH4/c/1bwBR4SdnxBh5xp9fdYIHQWdp/YlrR09eGtHOd7bWYnOnj6Ho7lOmZqN82fnISXOieeQRtG5rEQj4v0QDdSajp4OJeTqzfXo6O3w6XOxc5Z+c/Sd4/+dMSFlgjIQXpCzQBkK+xqOA0sxpqjxYUqEDRRtnMMaSaFmvQwTl4z28ASq9RB2Xxq0ckA6xRyjOK6k2OMyrEKA0TmmXHUgsH0KjWu3P28VeY6i1hmTgAX/B2TP8E8jhTvROn4macDLFPPQrmxGfLnd7OwM9ffR17TVWqdZsBFnYPnF158EZlyk+dOJsPMTIuycCzqOAaOg44xXT2jv6sE7Oyrwzo5KmLt7HXaenjQ5CxfMyfP5vFUVnUs0qufxpYmxL+jq7UJ9R70SdIzS+ZLu3m5srt6sonO763Y7bbhINiarNCujc7nxufA1TIkypZsRm4GkmCTPo4E1+x2n7/QC3+uS9VYxV77FtW5dUwow+nirmGPNkJ4ijf6CHaRMzzJN64jCJcD8bwLJBb5tpGABP02JXXmvP3/Y/jbTi42pVx/VgIUtjKLyR8Det4H4TOBHG7QdHXcMEXZ+QoSdfdjEUN3SgXIl6Dyroevo7lXROUbpHHXLUlctn5SlzIV9OZqLAi4jIQbZSaagi84x3UmfOQo6Z40JWqTajzYfVWJuXcU6tPeMLB4ZAZuTOUd5zs1In6EiY74mMSZRiTlG6LxuvKClCRsN9AgjcZwjSq+y0i9d69JlHRnFHNOMtCnxw/sRNMXzG59wnK6m6KVxLU19PamrctZIwZQ5DYmd0VgMrLobaC61PyP3xJ8DsSnub5/gGhy/xvKSHC+juA4QYecnRNgNF3SVzR2obPJc0NGgmPVzrKNzNBuWx8FlEzJw8bwCJbZ8BRsuspOCLzrX29ermh8o5mhP4msoGCnk2Nla2mrnpDKE/IR8lWpdkrsESTRE9TGmKJMSc2mxadqNE6MNCE+keoMi4MAH1nFJrkQS6cdFw2BG5vLmid3FSOlNdkVyBq0jMc+JBBxPNvV896dpjNRI4Uq0jv6CXzwM9Ngpq5h5KTDnKhHqvkZHPnbBFX4QdCvoKprMyhy4u9czQcdU7Ud7q1Sna5PZflE9pdWS8elK0OWn+Kb2igIu/Vh0zh+dtFo2JlDEUczRc86X9iS259tZu1NF57ZUb0GvkwkLrJWjeTAFHc2Efd0IwWgcR4qlx6Zrb1jME7ueRJ2Kzm2xijmmXJ1Nu6DpMEd5UcxxtBfFnTAy/LxyIgX32753rSbHnUPEFjuiNz8F7H0HmPcNYNxJrqewmc5rrRneSNFeP7KoY8MHo4lMBQ6FEcBlN1mFuxBWBM+ZS9ClDx2nRTBK1+OhoONjrNpXjde2lo84RmzRmDR8fX6B8ofzBTQvppjLCKLonM1rjmKO6VZn4koLqtqqlJj7vPxzFRV0Bsd6UczNy56HGGdDtDWqm6OgY82eT8Rja7U1BauX6FzRB0CRC9E5Fs0z3Ucxx7owf4/0ChWYvuc4qfEnW73N2KQwNM3NqRxrHwB2vw7M/z8gb45rj91w2DrFYGAKfKQfELSo+eQPQO2+4feljbfW0/nCXFnQPREWnh0EjwjXVGx3b5+Kznkl6Pr68On+WryypRS1rY4F3bxRKfj6/EKMzdB+TFSwRudau1qVmOPFl/YkNjg+bFvNNmys3IiiRuceZxRWx+cfj+PzjkdmnBczMd2om+NzUtT51LC4rQ6o2WNNywVLdI6WJJPOtNbNmcLnGOU3KK62PA0cXMU3x/4y7Hqd/y3X7GEGNlIwWle1y/5yZZuBT+8dHjUkE08HFn8f8PEPKWEIkooVglXQVTRaBZ2n81wZoVt7oFZNi6hqduzQPys/GZcsKMCErESfROeyEhmdi0F0VGTweM3RnqSjXnW3+jrNeqjpELZWb1WCjpMhnEFBNT9rvmqEYJTO135trJtjmpUXzermnNlN1OwNnKjjSZ6+Wa5E51jfRSFHQUdbDrG18B3sgmS6k3V1TInaMwIu22QV4xNOBeZc/dVsUUdpfnrlMY1qb+oHhT2tWLY+O1xIUsgt/gEw8TQNXpgQzARPmEIIGKx/Yw0dhZingo5drh/vrcbbOypGTLlOy01Sgm5KTpLm0bm0eEbnjEj0g2mxFnT2dirjYIo5c8/IEw208LXbVbdLCTleXO2gHROXixOyF2BR9kLEcy5olMln1hgUj2mmNBWdS4hJgF99zdgR6eO6RW2ic2cB41a4P6pK8I708cDpvwfKNgIbnwSaioe/l+xQPrwamH6R9cJmi6HwhwNT/bRPoefgQFhrx1mvFIr2jKOZevVk/qwQckgq1gtCPRXLDlVG6DjL1UM9h+aObqzcVakujmxLyKTsBFwyvxAz8rUdwxIXY6udC47oHP3fbJG5tm4H7vcaweegiGNkbk/9HpdHiCVEmbA0dSqWpU5DYaydVCtHLjFqxEgaC/Ojj11HRXtUN0drEkbmeO336RNd7dYoDIvU/YVE54IbjpdjZzLns7IO0h78EcROVQ6Qt2crw+/QwM9cbRHwyT1AW/XwZdkcseyngD9/7Ai6TsWKsPPTjg42QVfe2IFqLwQdR4cxOrdqb7XD0V9kfGa8EnSzCrQrdmfvAy1KOObLHyPFvIWCyuY1x2YIX8Fy2uKWYiXkttZsVZ5zrpIYFYvZSWMxJ2kcZiWORbQnHmesf4uOAThNgmkjCj6DyW4tUIIhQYk5Ruh8Wjc3Et0dVlE30FXe59G5945F55xEB1PHHovOLZfonF5hl+yuV63jpxx9hjhvd8G3gPwF9lPmjODxM/HlP4YbSzMyPvca65SDcDSQ1htpIuxCglATdkyX0lSYosxTQVdS3443t5Xjs4O1Iz7G5OxEnDcnD3MLtYvCxKronBGZCUbdR+dYx2YTc7QpcTaZwZsIIKNxFHKMzvE5XSXflI7ZiVYxNy4ux3d1c3zcaCOMxiSkx+cgPSEPJkY0GOULVH1YT5dV1PHk7PPoHDtb35fauVCF7/HWZ6w1ko4EOw2EF3zbmtK1QU+6dX8HDn5sfzLI8p9b1xP0QZoIu5AgVIQdBV1pgxm1rZ0e14bvq2xRpsKbi0cWDvNGpeK82XmYnJOoYXQuBllJJt1H5xgxs3nN0SrEV15zzZ3N2Fa7Dduqt6m6OdbquQInQUxKmYDZCaMwJy4fWUbfu9RHR0Qh1ZCAjJgkJAydC0vBx4gefehYj8SB5bTp4HKRPhTuvT1WUedoELy3SHQuPGk4YjU4tlcjp4iw1kfOu8ZqocLUK9cZStY0YPmtQFy6r7dYcAcRdqFBsAs7c1cvyhrbld2IJ4KOQmVLSSPe2FqOfVUtI4qv48dn4NzZeZr50DE6x5mtHCVm0Hl0TnnNma1iztU6Nnffh/K28v4U66HGQy5HAOOi4zAzYybmZM3BzMTRiGurd22WqBewbi7ZEK/EXHJ0nPuRQEbxGM2j0Bso+Hjt7Risvj6gaodrczndRaJzAqnYCmz8F1B/yP7+YGkCP8f2osXTLgTmX2staxD0QUSEtXklZbRHdcSuIpMnhBFp7+pBWYMZdW2eCTp2xn5xqE5F6Jh6dURMVCROmpKFc2bmajLLlQKRna2MziXH6js6x8YHijk2QvjCa44CsaihSAk5Croac43L62bFZikhNztzNiamTlRRM7RUAC12CrM1JJ6jvWKSkGpIhMEbAcYPLU969k58qm7PjuBjMborj8vuVy1FnUTnhKHkzgG+9iBwaBWw+WmrofFAGK0b2mfGz/NxNwJjlsn+1BPGRCB9AmDUV+OKyP4woq2zB2WNZtSNYAjsrKli9b4avLW9AjWtnSP6xJ0xPQdnTMtBkgYCzGSIVJ2teo/O0TJEdbSa69HRa2dmowZicUftDiXkeO2qBQojZONTxmNO5hwl6HLjc7+qa2RRd+Nhn9WSGSMNSI9JQrohESZ/GKby9fAytBuRwk4JvmOizyb4bDM9Keo47N1RF6O7tNdZa6poVWKvk3Eg3Iaxy4GJZ4jvXLjAKPX4U4DRy4A9r1unWDj6DjIStOKXPu24FNyExxPaC+l0socIuzCglYKuwTyif5yz9d8/ZlnS3OE4TcdoGqNzJ0/JgsngXUqMuiOd0blEE5LjDLq3J+GFJsK+mPpgS7Hub9jvcl0eTXtnpM+wplgzZyIpJsm+6W5TmXN/NDeJiohEmiFRCbrEoXVzgYLWEb1N1pmcA2FKi0KPJ9qh97mLROcEd6Gon3kpMOF06/zZ/e8ObrDgvNklP7TWmgqBJyICSMgBUpl21e95KeDC7oEHHsCDDz6IqqoqzJw5U/29bNkyr9dxtsz3v/99/OMf/xi0zvTp07Fz506ECi0d3SpC19DmWSqQQvCdHRX4aG8VOrodC4q8FJNqiGAdnbfdqIzOMdXKztaY6MiwsyehcDvYeLA/xVrRVuHyuhyppaJymXMwJW0KDI4OPPTZosO9VtGpY6TQosSQiBRDvM8nT2gG6wlpQOwNEp0TvCU2BVjyA+sc2t2vWTukGdFjJFcmh+gDY8KxtKv205BCStg98cQTuP322/HCCy9g6dKl+NOf/oQzzzwTu3fvxqhRozxex9XHvfjii/HSSy8h1KApMCN0je2eCTpanry1vRxrimpHnDRBD7rz5+Rj/uhURHpx8OGqaiqEjqNzFFyNnY1qEoTW9iS2qQ+2EV6t3UMc50dgTNKY/hRrYWKhc+uYLrPVFV8jbzbWzTEyl+Zt3VywQXHMIvh97wKlX4rvnKANnDix9EeyN/VElMGaDmfaNUhEdkANiqdMmYLTTz8dDz30kPqbm1JYWIhvfOMbuOeeezxex5VlGLGrra31StjprSu2yWwVdLz2hIM1rarDdcOR+hFlC82Ez5+dh6m5SV550BlttXM6jc7xc8OIHNOsjR2N6NUwZammPlRvw5aaLdhbtxc9Ftc6UWnWOy19mhJzbH5glM5l2mqtTRJefuVjWDd3LNUaG26DxiU6JwjhQyLTrmN0kXYNiq7Y+vp67Nu3D3fffXf/bRQJK1aswOeff+7xOu487nvvvYe4uDi1s0444QQV2RszZgyCjab2bpQ2tqPZ3OOReNlR1qQ6XHeVO04rUr8tGZeOc2flYWyGd3Mo2dGam2xCarw+RUFrV6sSXrxo1dHK/cxJD7YUKydAuArr42ZlzsLcrLmYljYNRlvBvzu+bE2lQKfnaeO4KKOql2O6NSlaG8uaoIrO2aZCSHROEEKfmHhr2tUU+ICNJwRM2FVWVqrrzMzBsyazsrKwYcMGj9dx9XEnTJiA5557DsuXL0dZWRl+8pOfKHHHGjsKPXt0dnaqy0AFHUga27uUsXDLCA0Njujrs2D94Xq8sa0MR+ocF/0boiKwfFImvjYrT0XXvB3zRUEXbwx4aecw2GHKNCvFnKuGvs7o6u1SUx8YmaOgYyrXVfIT8lV6lZG5scljPa9Z4yDxphK3Z52aImOUkKOIS4yOC68068DoXNGxqRDS2SoIoU9ktLUxgr50QZJ2tYfuzrCMbLib3nNlnaHL3Hzzzf3/Z1jz+eefR25urrr+7ne/a/cxmMa96667EGga2qyCjt2q7tLV04dPi6yWJZXNji05Yg1ROH16Ns6cnoOUOM8jaxSGFIS86C3dSuFFIUdB196jTUcr6++212xXQo51c3wOV6c+TE6brNKrFHOZcYN/mLgN060swG6rcSn1yvSqTcglRceqv8MSj6NzK6wWKoLgDfwBl5QHxKUBLbbvr28m1AhDSMi2pl05zzrICZiwy8mx+r/U1Aw2VuXf2dnZHq/jyeOSlJQUFBQUoKioyOEyt912G2666aZBETvW7vkLdqmWeSjoaEr84e4qvLuzEo0j1OClxBpw1sxcnDo1C3Ex0V5NhmB0jvVzkQzX6ayjlXVzLV0tmjQ+7GvYh911u9WlrLXM5XXjo+OVFQkjc7QmiaOvmhZQTDaWjDgSyxARhSRDHBKjGJGL9Y/HXKhF5yadCaRPDOpf9oKOSMiyFunbrE1MyVahoczDK63fa8FHadfx1v0dIgRM2KWlpWHy5MlYtWoVLrroov6o2ieffKKaHDxdx5PHJY2NjSgtLUVeXp7DZYxGDir3foKCO3DblaBrNKOts9ejdC3F3Ae7q2Dudrx+TpIJX5uVixMmZnoVWdNj/Rw7Wm32JN52tFIYHmk6YhVy9buVNYk7TRXZcdn9KdYJKRMQpXWK09wENJcNGwvG6RIUcEyrMioXdk0PNhi9NNcDDUeBRl6Krdd1ByQ6JwQG1nEx8muvnovRI6YGkwut0Tt+t301wzgc064po6wR0hD7cRbQVCzToTfeeKOyIqEtyR//+EclsNixauO6667DunXr+v3lXFnH2TKsk7v88stVBI7edcXFxarGLjExEVdddRX0xN7KFo9sS6qaO5Rlyer9NejudSxk2AhBD7pFY9I8jqzpsX6uv6PVXKdmtLpq7OtoDiuF3J66Pdhbv9etqRKc+kABp8TcsakPPoEzTvnLnpEn9Z5EWlOrUbEqMhcXFYYGpzQctgm3gUKuy3U7GYnOCT6DxtiMyMVnOF82MhJIzLZeaCyufCjrve5wD+voaOrYkEi72iOgZ2GKNqYzf/CDH/QbCbNTdfTo0V6t42wZRt24DAXgli1bkJqaqhon1q9fr5os9ARr4tzhSF2b6nBdd6huxO/89LwkJehm5id7bFmix/o5drQyzcoInacdrVzXFpHjNaN87mCKMmFGxgxVL8du1sQYHxtadncgoqkEiZYIJJrSVUSO/nLeWNEEFV3tx0Tb0cFCrsP1ZpVhSO2c4NNIUSGQmGcVbJ6YGfPCEWQUeKylZW2o4JyYOCBtvHX/hTAB9bELdvzhY7etpBHtXSN/afkW7qloxuvbyrG91LEI4Wl+4dg0JejGZyaETP2ctx2tXJ+ROFudnDvTHmyND5zFSn85XsYmjdU+xWqHBFqPdHchsbUGCZGG4Jn24Ck0VWaH79AIHFNUWiC1c4Iv4Q8tdlsy/aelLxrtjCjuGLH30cznoIfHY5V2zQ/atGtQ+NgJ3tNnsWDT0QYVoTtQ7Ti9FBUZgRMnZijLkryU2JCon2O3qU3MudvRyjq5Q02H+oUc/+9uqrYgoaBfyE1KnQRTtO9TnWyuoKcdLwlRsYhqOAyYm4Eo/9Z9+hxas7CWaGgalQXkWk384PvFAz2L1dVlFJA1BdCqgUUQBhKXbk27+qJzOioaSM631oq111u/O97OPQ4l4jOBNKZdQ+w4OQIi7IKQnt4+rD1Qize3l6O8sWPEuaunTMnG2TNz1ciuYK+fY2rV1gThTkcrI5rsVrUJOXaxuhvZSzOl9Qu5qWlTkWz0fQdVHD3kYhL7L5w6oeBs08rtwf/rnOmj1srhjQxNZYBWUz5o28K010ARx2J0HuxDPcIp6KPjMm2cf1J/jETFp1sv9K9kmjac7VIMcUA6970b03lCBBF2QURHdy8+3luNt3dUqE5ZRySZonHmjFycNi0bCR6KMb3Uz/X29VpntHZYZ7S6Sr25Hrvqd6mGB4o5NlK4Q2x0rBJw09OnKzGXFZfl85o11uZRwCUZk9S1wZ6XHCdINBwJrqJpbitPMLY6OCXkio8ZJ3dp6P+V/5Vwswk5pr7C0VxZCCyMDvHzxyL9QKT+OLA+c1J42qVERlm7iDl3N0jTrt4iwi4IaO7oxspdleoykuUJa95oWbJ8ciaM0VFe1c9lJBhVCjcQMMJGEcfInKsdre3d7WrKgy0qV9Ve5dZzRkdEY0LqBGtULm0axiSP8XnNWkxUjFXIHUuv8m+H9HQBtfsBcwN0LeDYsNAfgRsQidMyupjA+Y22FOoxEceDuA7mOQphDkUFf2Dw86iHHxThZpfCDuO0cWGVdrWHCDsdU9rQjsfWHFIedF29jsVNYVoczp+dp2a5eirGkmKjkZccG9D6OaZXbTNaWQfnLC1LDzmbkDvcdNhtf7pRiaP606sTUyfC6ONaNUbgKOBsqVWX6/Io5mr26+sXN9PBKvpWPFjAeTGPdhhxGV9F3mxCjicom4GrIOgFlQalhcZofYqKULdLoXUMBR0ndggi7PTIwZpW/O3jA6rLtbfP8RdvSk6i6nCdU5jiUZqQq2QkxCA3OTZg9XOMtDHNSjE30vgtRu1KW0r7hdz+hv3o6nNP6GTEZvQLuSlpU5TI8iWsiUs0JPanV5nedQsedJl25a/sQB6Au9uByp1A1U6g/rBVxPGkoBVGGrSO+Sr6ZkulxnjeuS0IfoMTCygqmP4MBvrtUjqAlnLr6DInP6R1C7MqrKFNYoRUamZtSMROhxysbsUrWxyPppo/OlUJuknZiV7Vz2UlGT1O2XoD7UVsTRD8vyNqzbX9Qo6X1u5W96LyhnhVJ2cTc6yT8xU0IqZw48XWverViDAedGv2WiNjgehKrdkDVGyzXpgC1qIA2xA/QLgNSKOGuKeUEKLw+60MhtMRlDDyTUHK7yHtUhjFC6aGLHYac/slgj8MEXY65NSp2ZiQlTDIwiQqIgLHTUjHubPyVOo12OrnaBzMernGjkaHkxu4zEA/uWqzk5mddiJktB5hjRyF3KikUT6pk2NK1Sbg1DVHdEXHatdc0VYL1Bb571c0u1PrD30l5Kp3Ax74AfbDlLZKoQ5Jo/JArNdiZm5XqKSlBN/CWk5+ttmYo9fPs9t1gXnW18OyD2YImK7VK5J2dYoIOx1C09/vLx+Pm1/cBmN0JE6akoVzZuYqQRYs9XO2kV7saHU0BaK7txtFjUX9Qu5o81G36uQYJRudNLo/IsfRXSM2ILgJRSHr4GzCzSbk7HarajUWrP7gMb82H0IBw4O3TcjROsWdMVs2aL/CIvGB0TfViZodPFYi/LzwNSTmWFPOPLHxpMZaQRF6wrDO61wgmQbDIXjqpEhljRovbLBQUy2q9WOXwv3P7yrrbCXtOiIh+OkMDZhqrWnpxIy8JERHRQZF/RytSZq6mlRUjoKud4gXGevkKN7U3NX6PShqKHJ77BfTqbbOVdbJJWhUh8XGiYHijReTP8dy8UDK1CvHY/kCRgErjwk5Xo7NlHVLxGVOAbKnW8dtUcDxJGfz1gs2lKDLHzzWyZhovVCgMopJk1eb0KPoE8IXdlsy7cpoUbj472VM/MoupbkisM1bFJsq7Rom+99LZKRYCIwUG1o/l5VoQnayf+rnKMxoTcKoHK8HRtwYtStvK1dechRyTLOOVFPnaGyWLSLHCxsgvIHjv+ylUf0xAswhPGgyFarlL2NlYrzjKyHXXOrmA0RYD6S5s62XrOmhUcvCNJqK0Lnpb8eaR4o82rlQ6AVrsbngHhT6nFrABolwxuZFyUg/zY/9BZ0DeBwK1jpGDZGRYmEIp0wwOpeZ6Pv6OXavUsixZm7oBAiO+dpdv7tfzLljKkxiImOsdXLHhFxBYoHHdXKMuA0ScIZYn1uauD3jsa7IGk3zlp4OoGr3V1G5uoPuj9+i/5ZNyGXPBEy+7Rr2u6Dj62MtkScinqLWkGuNUvIkR+GsonkN1jS2pG1DCwqK1GMGw4I1BcR9wQsj2UzTMurvq8+9SrvSD3CUpF09IEjzKMLA+jkKOk9HhrnbyUoxR4sSGxR2KhpXt1cJuup29xoeWCc3Nnlsv5AbnzLe7Ro2WzPD0FSqrw2GvYIHR3rTUZB5AiNGbLCo2GoVckzjuhtFik07JuTmALmzrGO2Qg1vBZ2jkxxFLy88+VOg2yJ5FHqevqeCTqYWFIh9xkgwesmLr+xSOAIsfbykXb1AhF0Q4q/6OXudrB09HcpDzlYnV9JS4vbj5sbnKhuSqelT1bWrtiD9liKGr1KovDYE08QB/sLlKC2a+brza5dpWk50UM0OvOwE3Exrq7qZnFlfReXo/RQKXX0OBV2eVdT5Os3OQnrWYPFCaBlhi+ZRwLNeTwiCiFSOtb6S0xoED+xSKryrRaWxs0q7elduI4iwCyqi6T/nw/o5e52svBxqPNQ/rosTHoY2RTgjzZTW7yc3JXUyUiOij3Ud9h3rQGyznhwjbRcDDIbhdXCaWooEAjUWbJ/rVgLsjrVF5Ni5SpHgboNA1rRjEbnZ1oOmHsYc+RLVqZvvH0HnCBZ480JhqcasNR2L6DFt2yZpW73BCBHr6PjDR/DcLoWX9nr37VJ4TFdznkeF/vHJT0jELszr54Z2slLIFTcX9ws5dq66O+GBDQ/sWGVEjt2rWbGZiOhuO1abUTkobM90aWxkDGKjjIhjZ2pUDOKi+hDd3QdEdQFRFH1Gq0hhFEZdD/l/MLS+84BHo1+a/zqCJ/6K7V/VyfFXsDsw9cxOtpxjQi5rinX/hAM2QccuVz1ZUfCkZXP6Z4ch339bypZir8cLv0DBO2JoMDxWxlBpibt2KfxepI23vheCZujoCCjYY1xmPBKM0ZpGqgZ2slLQVbRVKCHHhgd2rrb1uDckmt5xNmNgirnCxEJEsquSX25VS2at/4qKiES8amhIQvwxIWdyJDx4MOBJT534Wp2f1G1ij+F8RwIwEClbetM1HLYe5IZCa5OqAZ2rHNXlLkyDDGx4CLcDJN97W8pVT4LOEfwMJmRaL4TfEZvQYxRb0rZ+eA9ijhkM54RuKYLe7FKYfRj4I4bHaYpq2/dA0JQgOBKGN4kmg+adrPSSo4hjswObHnibu5YhbHKw1cmNSx6npj5Yn4i/1CoQ0dmC+Igoq4AzZShBx2icT2AEkJduFyJaSugZ/BMFZK2VGgt2TJgyWlN9bFRX5VZr84O7FicJ2VYRl0MxN8uaRgpHgk3QjXQC5IXRRv4I6BzgncfvkqCxwXCepPwCMaWDpsLs/mealk1H/EEqaVefEcRHRMEZ7F5lerW4pRhbqrb0p1er2t1L8bFpgVE41shRzDE6Z+QvLhvdZsR1NCO+uwvxlgjER8cjNiFNf/Vw/owCMgVRs8+afh00qstNk092n/U3PMyxRhnCmf56noLgFnT24I8JCnWbWGdNpq02j0IvkAaxwQ47vpXBcAh4MQZtc8qASLXgU0LsyCiwk5Wp1fUV67GtZpsScuxcdWdUF8mOy+4XckMnPNAfTgm4nk7Ed7Ujrs+CyIi40EoDOosCsiieUzMoEnnNZWl7wagcU69HPzs2qsvNqEt0LJAz41hEbrbVTkPPti1+F3SM0AVRF7Q3sDvT5h1GGPm11eZ1HGs+EkZGWdKMDS1PRkFwggi7IIedrDQFXl+5Xom5XXW7cLDxoNudqynGlP5mB16zk9VWP8cIXLwhHvGIRFxnG6J5chnY1q534UERxqH29F2ixxhTpMOuzcfut3dtW27I7VqcWG2jumwROdalBOuYLl8JOk6JoLdYuAg6RxgTrBcUDh55RqHnq1F0wQq7khmhE+sMIQyRM0gQ0t3bjU3Vm/BZ2WfYXLUZ+xr2oZPCxQ0o1mydq7zkxOUoEUeLEYo4drby/wZGoThKpqnCPzU/FGEqXTpAQA0VYUOF1rDbh1zzopvoRoTVfNNWJ5c9zepyLwxGBJ3z/WPrQCT8zthSthR6I3VfhzL8UZRSOHgGsCCEGSLsgiQqd6jpEFaXrMa6inXYUbsDrd2tbo/qmpg6sT+9ymkPiTGJg4QchZ2Cgqm9Fqg7pN1cQD6mzZiX3Z+2mYM9dqJk7o7C0jusB7N1rubMtM6fFEYQdDnWYutwj9C5A+tAud944Y8jjjkb2ITBHza6+XHjoxouRnZZqC+fGyHMEWGnUziai6nVNaVrsKFyA+o66tzuXKV4sxkDz8qYhRRTSr+Qo9nvIPiLv6nMGp3jHEwtBFwTRdyxi7uebMEI9ymLs1Wr/6SvonKSDnJd0FEEi/O/9yKHPx54odAZCDtvLQMvvUP+tgz5u8+a9nW2zKDHsne/D3+sMWrJOrpQqvEVBC8QYadDNlVtwjff+6bb67FzlUJubtZczMuah8y4zH4RZ7dDlV13jMyxDV1NgrC4L+AGiregEXARVgFmE2K8ZjrUNjFA/X/I/f23D72OA+LTgbh064mUoo5WKoySdLVYo5IUylrOUgw5C4pcEXT+QqUnA5CitIm9YSLRkWC0t9xQwWixfnbC1fJHEBwgwk6HMMLGwfY0Eh6JrLgszEyfiXk587A4ZzHyE/JVRI7THBzC2pv2OmtkjsXXzsScQwFX7Z+UKV8LBdRQUTVUYNlEmPrbJsiG3n/sdgovT6xYWL9j8x1jl7Dt//Yei89DwWeD9X5K5DVb02QUfuFsRsv31ZZylQhd6MPvSESUeJcJgh8QYadDGGGbnTkbG6s2Dro92ZiM2RmzsTB3IY7LOw7jk8cjyhWTRzZA9Iu5RvtijgKuudRa/+YzAcc6GA7aHm0tcI7LGB4xGyrcWPcXCD881iwNEnEJ3nlg2V6TzceJ7wE7ixnNo+BjdC8c5oiKoBMEQfApIux0yuLcxdhXvw+zMmdhYc5CLMtfpoyBXTb9ZTSI80kp5lhEbSucZrNCk03AlXwl5Hwp4Fjnw//Tg2ygsbEe4P6ksLSJOOMxEefrAmw+r+05EwfUP6loXutXgm+grUxICLoC/X0GBEEQQogIC1suBY9obm5GcnIympqakJSUpPnUCGOU0bWIHAYIA/MxMcfZpAMjbzYhp2rgtBZwo766JI/S78mb4oIF1rYInE1Y6Xm0DaOttlo9JfiOdRIHCyLoBEEQ/Ko3JGKnU1gr5xI80ZdtAso3A1W7gIYjvhdwybZrnQq4gfVwtggc/899qrcxZ87g2KyBY6ZsTS/9UT2mcFv151tGQce5tozY6vUzIgiCEIKIsAsW6CzPuaMcKs9B8pU7rP9nZM4XAo5F7SqVqnMB118PZ4vA2URcCJv+stkgeoA5ra1GUom8AdG9QDRnqJmQx1KuofweCIIg6BQRdnqEcyD3vXNMxO0FavYADUf9IOBYA6fjkzFFAxsQBqZR/VEPFwyojmC+d0ObM2wpXHbjtvvOpFYJumzr50kEnSAIQsAQYadHeEJ+9XvaCbjkAQ0MTI2pCJyOBVx/PdwQWxH+X8YEud+cgeyvajC72wZ34tKGxZsyWxF0giAIuiLgwq6vrw/r169HVVUVZsyYgQkTJmiyjlbLBARGPkzJVp85lzgWLRnYxNCfQtW5gCOMuA31hwvGeji9Q1Fsm0hgg+laW52eTfC50pzB9yY+y/pDgVFUQRAEQRcEVNixu+PMM89EcXExpk2bhs8//xw33HAD/vCHP3i1jlbLBAyeNDOnAiXrht5hFWyZU4CMiceuJwMZ461CqD/yMiACM/Q2t5aBi8tYPFiGnz6TtblBz/V7oQ47gmNTrBcbbMQY2JhBsdfbZb1PBJ0gCIKuCaiwu/3221FfX4/du3erNt61a9fihBNOwGmnnYZTTjnF43W0WiagjD3RerKleMuaekzETZJ5iIJ/IqhxdpozKPJUNFUidIIgCHolYD52fNq0tDTcdttt+PnPf95/++LFi1UE7cknn/RoHa2WCbSPnSAIgiAIQtD42JWWlqKxsVHVtg1k5syZ2Lp1q8fraLWMPTo7O9Vl4I4WBEEQBEHQCyNMi/ctVJ2EkbOBpKenK9Hl6TpaLWOPe+65Rylm26WwsNDFVysIgiAIghDCws5otBbMt7a2Drqdf5tMJo/X0WoZezB1S1Fou5SUlLj4agVBEARBEHxPwFKxo0aNQnR0tOpKHcjRo0cxbtw4j9fRahl7UBDaRKEgCIIgCILeCGjEjt2nL774Yv9ttbW1+Pjjj3HOOef037Zhwwa89957Lq+j1TKCIAiCIAjBRsC6YgkbFZYtW4YLL7wQS5cuxeOPP46IiAjlKWeLjF133XVYt24ddu7c6fI6Wi3jDOmKFQRBEATB17ijNwIWsSNz5szB5s2bkZubqyZAXHnllVizZs0gYbVo0SKcddZZbq2j1TKCIAiCIAjBREAjdsGOROwEQRAEQfA1QROxEwRBEARBELRDhJ0gCIIgCEKIIMJOEARBEAQhRBBhJwiCIAiCECKIsBMEQRAEQQgRRNgJgiAIgiCECCLsBEEQBEEQQoSAzYoNBWwWgPSXEQRBEARB8AU2neGK9bAIOy9oaWlR14WFhd48jCAIgiAIgku6g0bFIyGTJ7ygr68P5eXlSExMVHNmBfd+fVAQl5SUOHXRFvSBvGfBh7xnwYe8Z8FHsx/OZ4zUUdTl5eUhMnLkKjqJ2HkBd25BQYE3DxH28Esgwi64kPcs+JD3LPiQ9yz4SPLx+cxZpM6GNE8IgiAIgiCECCLsBEEQBEEQQgQRdkJAMBqNuPPOO9W1EBzIexZ8yHsWfMh7FnwYdXY+k+YJQRAEQRCEEEEidoIgCIIgCCGCCDtBEARBEIQQQYSdIAiCIAhCiCDCTvAIGjHefvvtOOOMM3DxxRfjscceQ09Pz7DlXn/9dVxwwQU46aSTcNttt6Gpqclnywiu88orr2DJkiW45557ht23bt06XHnllVixYgV+8IMfoLi42GfLCK4Zof/73/9Wn/+zzjpLfdeGjhU6cOAArrvuOixfvhzXXHMNtm7dOuxxtFpGcM7GjRvx7W9/GyeffLJ63/7617+iq6tr0DK1tbX42c9+pr4fX//61/H+++8PexytlhHsv0f8rPM4+Nlnn9lZwr/HQi2PlyLsBI9EHQ9YCQkJ6oBy/vnn4//9v/+Hq6++etByTz/9NC655BKceOKJ+OlPf4oPP/wQp59+Onp7ezVfRnCdI0eO4MYbb0RVVRUOHjw46L7169erk3p+fj5+/vOfq8kqxx13HOrq6jRfRnCNK664Ar/+9a9x4YUX4tZbb8WOHTvw6KOP9t9fWlqqTk5msxm/+MUvEB8fj2XLlmHXrl2aLyO4JhiOP/54dXz81a9+pX743n333fj+97/fv0xnZ6f6fmzatAk333wz5s6di7PPPhtvvPGG5ssIw/nDH/6A733ve5g2bZo6VjU0NAxbxp/HQs2PlxZBcJPOzk5LV1fXoNtef/11hhAsZWVl6u++vj5LQUGB5dZbb+1fpri42BIREWF56aWXNF1GcJ3u7m7LkiVLLP/6178sxx9/vOXb3/72oPtPP/10yznnnDPovc7KyrL85je/0XwZwTnPPfecJSoqyrJz585Bt5vN5v7///jHP7ZMmjTJ0tvb238b3+PLL79c82UE59x1113qmDWQP//5z5bU1NT+vx977DGL0Wi0NDQ09N/G7+KMGTM0X0YYTmNjo7rmfuN568033xy2jD+PhVofLyViJ7hNTEwMDAbDoNv465TY0g379u1TEYBzzz23fxnO0uMvSkbctFxGcB1GEPir8Fvf+taw+5hKX7169aB9zff6zDPP7N/XWi0juAaj1fwlP3369EG3m0ym/v9/9NFHKkozcH7keeedhw8++EDzZQTnLFiwQKVHi4qK1N/MLDDNtmjRokH7+oQTTkBKSkr/bcx87Ny5U0XStVxGcH80lz+Phb44XoqwEzSpAWKt1uzZszFmzBh129GjR9U1BxYPhH/b7tNqGcE1eIJ+9tlnVY2WPXgiYGpnpH2t1TKCa+zevRvz5s3DAw88oMofmNb717/+pb5zNrhP7e1rpnHa29s1XUZwDsUxv2OLFy9Wx0TOE+cP3hdeeMHpe2a7T8tlBPfx57HQF8dLEXaC17C248svv8QzzzzTf1t3d7e6HurEHRsb23+fVssIzuHB49prr8WTTz6JtLQ0u8vIe6Y/Ojo68M9//lPV1f3yl79UzROswbnpppsGvW/2vh+2+7RcRnAOo2U8JrLm+P7771f1XJs3b8a9994r71mQ0O3H85cvznHRHq0lCMdgZ+zjjz+OlStXYsaMGf37xSYe6uvrB/0S4a//zMxMTZcRnPPee++hsbFRvV+82KJB+/fvVwXzDPkP3NcD4b5OT08f9n54s4zgGtyXTNU88cQTiIiIULfx1z2F3Z///GdVEsFl7O1r3peYmNj/OFosIzjn97//PSZOnIiHHnqo/zY2olx22WW4/vrrkZOT43Bfk4HfIy2WEdzHn8dCXxwvJWIneMwdd9yBhx9+WImGpUuXDrqPIo8nhA0bNvTfxl8fW7ZsUfVxWi4juJYe+vjjj/Hggw/2X8aOHaveN/6fvw6TkpIwfvz4Qfva1rFl29daLSO4Xq9FIWATdSQ3N1el9tra2tTfTNXa29dMA9rq5bRaRnAOT9CsYx0If5Qyfc4fV7Z9ze7ZofuaAprfHS2XEdzHn8dCnxwvPWq5EMKeO++805KYmGj57LPPHO6LK6+80jJz5kxLU1OT+vvee++1mEwm1dWq9TKC+9jrir377rstmZmZlkOHDqm/3333XdWBvGrVKs2XEZyzdu1a1fW4YcMG9XdHR4fl7LPPtixYsKB/mVdeecUSExPT/13csWOHJSEhwfLII49ovozgnN/97neW5ORky549e9TfdBC46qqrLLm5uaornezevVt1Oz/55JPq7+rqasvYsWMtP/zhD/sfR6tlBMeM1BXrz2Oh1sdLEXaC22zbtk19GXJyciyLFy8edPnyyy/7l6uvr7esWLFCnRx4sElJSVEnj4FotYygjbDjieeaa65RYoLWFxTQtGrwxTKCa/ztb3+zJCUlKQuL9PR0y8KFCy379+8ftMwdd9zRv68pzq6//nplFeSLZYSRoVWF7bPP94wn7IkTJyqRPpCnnnpKHdPGjx9viY2NVYK9tbXVJ8sIg/n444/V+Yo/kHgumzx5svr7oYceCsixUOvjZQT/8SzWJ4QrTAGxmNseNHxkaHkghw8fVpMipkyZMsimwRfLCK7DGjvux3Hjxg27r7KyEhUVFeo+R9YAWi0juPado30G60qHpvls0GSV5tPswnRUf6rVMoJzmpub1X6kFQn3pb10NruNaenEWqpRo0bZfRytlhEGp8tZXzwUpsyH7j9/Hgu1Ol6KsBMEQRAEQQgRpCJWEARBEAQhRBBhJwiCIAiCECKIsBMEQRAEQQgRRNgJgiAIgiCECCLsBEEQBEEQQgQRdoIgCIIgCCGCCDtBEARBEIQQQYSdIAiCIAhCiCDCThAEQRAEIUQQYScIguBjOA7snXfeQU9PDzZv3oy3334bZWVlst8FQdCcaO0fUhAEQRjIypUr8fvf/x5jxoyB0WhUt61fvx7PP/88zjvvPNlZgiBohkTsBEEQ/AAHfN9888345JNP1OVHP/oR7rjjDtn3giBoigg7QRAEP5CZmYmLL764/+8VK1Zg3759su8FQdAUEXaCIAh+IC0tbdDfTMl2dnbKvhcEQVNE2AmCIAiCIIQIIuwEQRAEQRBCBBF2giAIgiAIIYIIO0EQBB8zadIknHPOOYNuy8nJwWWXXSb7XhAETYmwWCwWbR9SEARBEARBCAQSsRMEQRAEQQgRRNgJgiAIgiCECCLsBEEQBEEQQgQRdoIgCIIgCCGCCDtBEARBEIQQQYSdIAiCIAhCiCDCThAEQRAEIUQQYScIgiAIghAiiLATBEEQBEEIEUTYCYIgCIIghAgi7ARBEARBEEIEEXaCIAiCIAgIDf4/t5JHWho6Jn8AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "time_means = np.mean(times, axis=2)\n", + "time_stds = np.std(times, axis=2)\n", + "\n", + "for i, alg in enumerate(algs):\n", + " name = alg.split(\"_\")[1]\n", + " if name == \"multilevel\":\n", + " name = \"louvain\"\n", + " if name in [\"louvain\", \"leiden\", \"label\"]:\n", + " plt.plot(ns, time_means[i], lw=3, label=name.capitalize())\n", + " plt.fill_between(\n", + " ns, time_means[i] - time_stds[i], time_means[i] + time_stds[i], alpha=0.25\n", + " )\n", + "\n", + "plt.legend()\n", + "plt.title(\"Scaling of igraph community detection algorithms\")\n", + "plt.xlabel(\"n\")\n", + "plt.ylabel(\"Time (s)\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "Louvain\n", + "- [Vincent D Blondel, Jean-Loup Guillaume, Renaud Lambiotte and Etienne Lefebvre. Fast unfolding of communities in large networks. Journal of Statistical Mechanics: Theory and Experiment, P10008 (2008) doi: 10.1088/1742-5468/2008/10/P10008](https://doi.org/10.1088/1742-5468/2008/10/P10008)\n", + "\n", + "Leiden\n", + "- [V. A. Traag, L. Waltman & N. J. van Eck. From Louvain to Leiden: guaranteeing well-connected communities. Scientific Reports, 9:5233 (2019) doi: 10.1038/s41598-019-41695-z](https://doi.org/10.1038/s41598-019-41695-z)\n", + "\n", + "ECG\n", + "- [Valérie Poulin & François Théberge. Ensemble clustering for graphs: comparisons and applications. Applied Network Science, 4:51 (2019) doi: 10.1007/s41109-019-0162-z](https://doi.org/10.1007/s41109-019-0162-z)\n", + "\n", + "Label Propagation\n", + "- [Usha Nandini Raghavan, Réka Albert, and Soundar Kumara. Near linear time algorithm to detect community structures in large-scale networks. Physical Review E, 76:036106 (2007) doi: 10.1103/PhysRevE.76.036106](https://doi.org/10.1103/PhysRevE.76.036106)\n", + "\n", + "Infomap\n", + "- [Martin Rosvall and Carl T. Bergstrom. Maps of information flow reveal community structure in complex networks, Proceedings of the National Academy of Sciences, 105(4):1118-1123 (2008) doi: 10.1073/pnas.0706851105](https://doi.org/10.1073/pnas.0706851105)\n", + "\n", + "Walktrap\n", + "- [Pascal Pons and Matthieu Latapy. Computing Communities in Large Networks Using Random Walks. International Symposium on Computer and Information Sciences, Lecture Notes in Computer Science, 3733:284–293 (2005) doi: 10.1007/11569596_31](https://doi.org/10.1007/11569596_31)\n", + "\n", + "ARI\n", + "- [Lawrence Hubert and Phipps Arabie. Comparing partitions. Journal of Classification , 2:193–218 (1985) doi: 10.1007/BF01908075](https://doi.org/10.1007/BF01908075)\n", + "\n", + "Graph Aware ARI\n", + "- [Valérie Poulin and François Théberge. Comparing Graph Clusterings: Set Partition Measures vs. Graph-Aware Measures. IEEE Transactions on Pattern Analysis and Machine Intelligence, 43(6):2127 - 2132 (2021) doi: 10.1109/TPAMI.2020.3009862](https://doi.org/10.1109/TPAMI.2020.3009862)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "abcd", + "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.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/benchmark_networkx.ipynb b/docs/benchmark_networkx.ipynb new file mode 100644 index 0000000..3f57661 --- /dev/null +++ b/docs/benchmark_networkx.ipynb @@ -0,0 +1,289 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Benchmarking with networkx\n", + "\n", + "This notebook is an example of benchmarking community detection algorithms using ABCD with networkx. Since networkx is quite slow without configuring a backend (which is beyond this notebook), we'll keep the size of the ABCD graph quite small. If you want to see how the algorithms perform on larger graphs, check out [benchmarking with igraph.](benchmark_igraph.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from time import perf_counter\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "import numpy as np\n", + "import partition_networkx\n", + "from sklearn.metrics import adjusted_rand_score as ari\n", + "from tqdm import tqdm\n", + "\n", + "from abcd_graph import ABCD" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Assign ecg as networkx community method\n", + "nx.algorithms.community.ecg_community = partition_networkx.community_ecg" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "algs = [\n", + " \"louvain_communities\",\n", + " \"label_propagation_communities\",\n", + " \"ecg_community\",\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Performance\n", + "\n", + "First lets test how well each algorithms can detect the ground truth communities subject to increasing amount of noise in the graph. To evaluate the similarity between the ground truth partition, we'll use the adjusted rand index (ARI) and a graph aware adjustment (GARI)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 390/390 [04:39<00:00, 1.39it/s]\n" + ] + } + ], + "source": [ + "n = 1000\n", + "xis = np.linspace(0.1, 0.7, 13)\n", + "reps = 10\n", + "\n", + "aris = np.empty((len(algs), len(xis), reps))\n", + "garis = np.empty_like(aris)\n", + "\n", + "abcd = ABCD(n)\n", + "\n", + "with tqdm(total=len(xis) * reps * len(algs)) as pbar:\n", + " for j, xi in enumerate(xis):\n", + " abcd.xi = xi\n", + " for k in range(reps):\n", + " sample = abcd.sample()\n", + " sample_graph = sample.to_networkx()\n", + " sample_coms = {\n", + " node: com\n", + " for com, nodes in sample.community_dict.items()\n", + " for node in nodes\n", + " }\n", + "\n", + " for i, alg in enumerate(algs):\n", + " predict = getattr(nx.algorithms.community, alg)(sample_graph)\n", + " if isinstance(predict, tuple):\n", + " predict = predict.partition\n", + " else:\n", + " predict = {\n", + " node: com for com, nodes in enumerate(predict) for node in nodes\n", + " }\n", + " aris[i, j, k] = ari(\n", + " [sample_coms[i] for i in range(n)],\n", + " [predict[i] for i in range(n)],\n", + " )\n", + " garis[i, j, k] = sample_graph.gam(sample_coms, predict)\n", + " pbar.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ari_means = np.mean(aris, axis=2)\n", + "ari_stds = np.std(aris, axis=2)\n", + "gari_means = np.mean(garis, axis=2)\n", + "gari_stds = np.std(garis, axis=2)\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", + "for i, alg in enumerate(algs):\n", + " name = alg.split(\"_\")[0]\n", + " axs[0].plot(xis, ari_means[i], lw=3, label=name.capitalize())\n", + " axs[0].fill_between(\n", + " xis, ari_means[i] - ari_stds[i], ari_means[i] + ari_stds[i], alpha=0.25\n", + " )\n", + "\n", + " axs[1].plot(xis, gari_means[i], lw=3, label=name.capitalize())\n", + " axs[1].fill_between(\n", + " xis, gari_means[i] - gari_stds[i], gari_means[i] + gari_stds[i], alpha=0.25\n", + " )\n", + "axs[1].legend()\n", + "\n", + "axs[0].set_xlabel(\"xi\")\n", + "axs[0].set_ylabel(\"ARI\")\n", + "\n", + "axs[1].set_ylabel(\"Graph Aware ARI\")\n", + "axs[1].set_xlabel(\"xi\")\n", + "\n", + "fig.suptitle(\"ABCD Benchmark of networkx community detection methods\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Time\n", + "\n", + "We can also use ABCD to test how each algorithm scales." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 270/270 [01:12<00:00, 3.74it/s]\n" + ] + } + ], + "source": [ + "ns = np.linspace(200, 1000, 9, dtype=\"int64\")\n", + "reps = 10\n", + "\n", + "times = np.empty((len(algs), len(ns), reps))\n", + "\n", + "abcd = ABCD(1000)\n", + "\n", + "with tqdm(total=len(ns) * reps * len(algs)) as pbar:\n", + " for j, n in enumerate(ns):\n", + " abcd.n = n\n", + " for k in range(reps):\n", + " sample = abcd.sample()\n", + " sample_graph = sample.to_networkx()\n", + "\n", + " for i, alg in enumerate(algs):\n", + " start = perf_counter()\n", + " predict = getattr(nx.algorithms.community, alg)(sample_graph)\n", + " end = perf_counter()\n", + " times[i, j, k] = end - start\n", + " pbar.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "time_means = np.mean(times, axis=2)\n", + "time_stds = np.std(times, axis=2)\n", + "\n", + "for i, alg in enumerate(algs):\n", + " name = alg.split(\"_\")[0]\n", + " if name == \"multilevel\":\n", + " name = \"louvain\"\n", + " plt.plot(ns, time_means[i], lw=3, label=name.capitalize())\n", + " plt.fill_between(\n", + " ns, time_means[i] - time_stds[i], time_means[i] + time_stds[i], alpha=0.25\n", + " )\n", + "\n", + "plt.legend()\n", + "plt.title(\"Scaling of igraph community detection algorithms\")\n", + "plt.xlabel(\"n\")\n", + "plt.ylabel(\"Time (s)\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "Louvain\n", + "- [Vincent D Blondel, Jean-Loup Guillaume, Renaud Lambiotte and Etienne Lefebvre. Fast unfolding of communities in large networks. Journal of Statistical Mechanics: Theory and Experiment, P10008 (2008) doi: 10.1088/1742-5468/2008/10/P10008](https://doi.org/10.1088/1742-5468/2008/10/P10008)\n", + "\n", + "ECG\n", + "- [Valérie Poulin & François Théberge. Ensemble clustering for graphs: comparisons and applications. Applied Network Science, 4:51 (2019) doi: 10.1007/s41109-019-0162-z](https://doi.org/10.1007/s41109-019-0162-z)\n", + "\n", + "Label Propagation\n", + "- [Usha Nandini Raghavan, Réka Albert, and Soundar Kumara. Near linear time algorithm to detect community structures in large-scale networks. Physical Review E, 76:036106 (2007) doi: 10.1103/PhysRevE.76.036106](https://doi.org/10.1103/PhysRevE.76.036106)\n", + "\n", + "ARI\n", + "- [Lawrence Hubert and Phipps Arabie. Comparing partitions. Journal of Classification , 2:193–218 (1985) doi: 10.1007/BF01908075](https://doi.org/10.1007/BF01908075)\n", + "\n", + "Graph Aware ARI\n", + "- [Valérie Poulin and François Théberge. Comparing Graph Clusterings: Set Partition Measures vs. Graph-Aware Measures. IEEE Transactions on Pattern Analysis and Machine Intelligence, 43(6):2127 - 2132 (2021) doi: 10.1109/TPAMI.2020.3009862](https://doi.org/10.1109/TPAMI.2020.3009862)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "abcd", + "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.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/benchmark_sknetwork.ipynb b/docs/benchmark_sknetwork.ipynb new file mode 100644 index 0000000..485c11a --- /dev/null +++ b/docs/benchmark_sknetwork.ipynb @@ -0,0 +1,286 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Benchmarking with scikit-network\n", + "\n", + "This notebook is an example of benchmarking community detection algorithms using ABCD with scikit-network." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from time import perf_counter\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import partition_sknetwork\n", + "import sknetwork as sn\n", + "from sklearn.metrics import adjusted_rand_score as ari\n", + "from tqdm import tqdm\n", + "\n", + "from abcd_graph import ABCD" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "## Add ECG object to sknetwork.clustering\n", + "sn.clustering.ECG = partition_sknetwork.ECG" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "algs = [\n", + " \"Louvain\",\n", + " # \"Leiden\", # There is currently a bug in sknetwork's leiden, patches coming in version 0.33.6\n", + " # \"ECG\", # ECG depends on Leiden\n", + " \"PropagationClustering\",\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Performance\n", + "\n", + "First lets test how well each algorithms can detect the ground truth communities subject to increasing amount of noise in the graph. To evaluate the similarity between the ground truth partition, we'll use the adjusted rand index (ARI) and a graph aware adjustment (GARI)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 260/260 [00:08<00:00, 31.16it/s]\n" + ] + } + ], + "source": [ + "n = 5000\n", + "xis = np.linspace(0.1, 0.7, 13)\n", + "reps = 10\n", + "\n", + "aris = np.empty((len(algs), len(xis), reps))\n", + "garis = np.empty_like(aris)\n", + "\n", + "abcd = ABCD(n)\n", + "\n", + "with tqdm(total=len(xis) * reps * len(algs)) as pbar:\n", + " for j, xi in enumerate(xis):\n", + " abcd.xi = xi\n", + " for k in range(reps):\n", + " sample = abcd.sample()\n", + " sample_graph = sample.to_sparse(matrix=True)\n", + " sample_coms = sample.community_array\n", + "\n", + " for i, alg in enumerate(algs):\n", + " predict = getattr(sn.clustering, alg)().fit_predict(sample_graph)\n", + " aris[i, j, k] = ari(sample_coms, predict)\n", + " garis[i, j, k] = partition_sknetwork.gam(\n", + " sample_graph, sample_coms, predict\n", + " )\n", + " pbar.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ari_means = np.mean(aris, axis=2)\n", + "ari_stds = np.std(aris, axis=2)\n", + "gari_means = np.mean(garis, axis=2)\n", + "gari_stds = np.std(garis, axis=2)\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n", + "for i, alg in enumerate(algs):\n", + " name = alg\n", + " if name == \"PropagationClustering\":\n", + " name = \"Label Propagation\"\n", + "\n", + " axs[0].plot(xis, ari_means[i], lw=3, label=name.capitalize())\n", + " axs[0].fill_between(\n", + " xis, ari_means[i] - ari_stds[i], ari_means[i] + ari_stds[i], alpha=0.25\n", + " )\n", + "\n", + " axs[1].plot(xis, gari_means[i], lw=3, label=name.capitalize())\n", + " axs[1].fill_between(\n", + " xis, gari_means[i] - gari_stds[i], gari_means[i] + gari_stds[i], alpha=0.25\n", + " )\n", + "axs[1].legend()\n", + "\n", + "axs[0].set_xlabel(\"xi\")\n", + "axs[0].set_ylabel(\"ARI\")\n", + "\n", + "axs[1].set_ylabel(\"Graph Aware ARI\")\n", + "axs[1].set_xlabel(\"xi\")\n", + "\n", + "fig.suptitle(\"ABCD Benchmark of sknetwork community detection methods\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Time\n", + "\n", + "We can also use ABCD to test how each algorithm scales." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 200/200 [00:05<00:00, 35.64it/s]\n" + ] + } + ], + "source": [ + "ns = np.linspace(1000, 10000, 10, dtype=\"int64\")\n", + "reps = 10\n", + "\n", + "times = np.empty((len(algs), len(ns), reps))\n", + "\n", + "abcd = ABCD(1000)\n", + "\n", + "with tqdm(total=len(ns) * reps * len(algs)) as pbar:\n", + " for j, n in enumerate(ns):\n", + " abcd.n = n\n", + " for k in range(reps):\n", + " sample = abcd.sample()\n", + " sample_graph = sample.to_sparse(matrix=True)\n", + " sample_coms = sample.community_array\n", + "\n", + " for i, alg in enumerate(algs):\n", + " start = perf_counter()\n", + " predict = getattr(sn.clustering, alg)().fit_predict(sample_graph)\n", + " end = perf_counter()\n", + " times[i, j, k] = end - start\n", + " pbar.update()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "time_means = np.mean(times, axis=2)\n", + "time_stds = np.std(times, axis=2)\n", + "\n", + "for i, alg in enumerate(algs):\n", + " name = alg\n", + " if name == \"PropagationClustering\":\n", + " name = \"Label Propagation\"\n", + " plt.plot(ns, time_means[i], lw=3, label=name.capitalize())\n", + " plt.fill_between(\n", + " ns, time_means[i] - time_stds[i], time_means[i] + time_stds[i], alpha=0.25\n", + " )\n", + "\n", + "plt.legend()\n", + "plt.title(\"Scaling of sknetwork community detection algorithms\")\n", + "plt.xlabel(\"n\")\n", + "plt.ylabel(\"Time (s)\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "Louvain\n", + "- [Vincent D Blondel, Jean-Loup Guillaume, Renaud Lambiotte and Etienne Lefebvre. Fast unfolding of communities in large networks. Journal of Statistical Mechanics: Theory and Experiment, P10008 (2008) doi: 10.1088/1742-5468/2008/10/P10008](https://doi.org/10.1088/1742-5468/2008/10/P10008)\n", + "\n", + "Leiden\n", + "- [V. A. Traag, L. Waltman & N. J. van Eck. From Louvain to Leiden: guaranteeing well-connected communities. Scientific Reports, 9:5233 (2019) doi: 10.1038/s41598-019-41695-z](https://doi.org/10.1038/s41598-019-41695-z)\n", + "\n", + "ECG\n", + "- [Valérie Poulin & François Théberge. Ensemble clustering for graphs: comparisons and applications. Applied Network Science, 4:51 (2019) doi: 10.1007/s41109-019-0162-z](https://doi.org/10.1007/s41109-019-0162-z)\n", + "\n", + "Label Propagation\n", + "- [Usha Nandini Raghavan, Réka Albert, and Soundar Kumara. Near linear time algorithm to detect community structures in large-scale networks. Physical Review E, 76:036106 (2007) doi: 10.1103/PhysRevE.76.036106](https://doi.org/10.1103/PhysRevE.76.036106)\n", + "\n", + "ARI\n", + "- [Lawrence Hubert and Phipps Arabie. Comparing partitions. Journal of Classification , 2:193–218 (1985) doi: 10.1007/BF01908075](https://doi.org/10.1007/BF01908075)\n", + "\n", + "Graph Aware ARI\n", + "- [Valérie Poulin and François Théberge. Comparing Graph Clusterings: Set Partition Measures vs. Graph-Aware Measures. IEEE Transactions on Pattern Analysis and Machine Intelligence, 43(6):2127 - 2132 (2021) doi: 10.1109/TPAMI.2020.3009862](https://doi.org/10.1109/TPAMI.2020.3009862)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "abcd", + "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.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..b3a6006 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,72 @@ +# Configuration file for the Sphinx documentation builder. + +import os +import sys + +# Stops an import error + +sys.path.insert(0, os.path.abspath("..")) + +# -- Project information ----------------------------------------------------- + +project = "abcd-graph" +copyright = "2024 Jordan Barrett & Aleksander Wojnarowicz" +author = "Aleksander Wojnarowicz, Jordan Barrett, and Ryan DeWolfe" +version = "0.5" +release = "0.5.0-beta" +language = "en" + +# -- General configuration --------------------------------------------------- + +extensions = [ + "sphinx.ext.autodoc", + "sphinx.ext.autosummary", + "sphinx.ext.napoleon", + "sphinx.ext.viewcode", + "sphinx.ext.intersphinx", + "sphinx.ext.mathjax", + "sphinx_math_dollar", + "numpydoc", + "nbsphinx", +] + +templates_path = ["_templates"] +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + +pygments_style = "sphinx" + +# -- Options for HTML output ------------------------------------------------- + +html_theme = "sphinx_rtd_theme" +html_static_path = ["_static"] + +# Autodoc settings +autodoc_default_options = { + "members": True, + "show-inheritance": True, + # "special-members": "__init__", +} +autodoc_preserve_defaults = True +# Keep short signatures in docstrings +autodoc_type_aliases = { + "ArrayLike": "numpy.typing.ArrayLike", + "Generator": "numpy.random.Generator", +} +# Keeps the string representation intact for alias replacement +autodoc_typehints = "description" + +# Suppress return types +napoleon_use_rtype = False + +# Intersphinx mapping +intersphinx_mapping = { + "python": ("https://docs.python.org/3", None), + "numpy": ("https://numpy.org/doc/stable", None), + "scipy": ("https://docs.scipy.org/doc/scipy", None), + "igraph": ("https://python.igraph.org/en/stable", None), + "networkx": ("https://networkx.org/documentation/stable", None), +} + +# Numpydoc settings +# See https://stackoverflow.com/questions/12206334/sphinx-autosummary-toctree-contains-reference-to-nonexisting-document-warnings/77588774#77588774 +numpydoc_show_class_members = False diff --git a/docs/getting_started.ipynb b/docs/getting_started.ipynb new file mode 100644 index 0000000..83c15b6 --- /dev/null +++ b/docs/getting_started.ipynb @@ -0,0 +1,610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Getting Started\n", + "\n", + "The Artificial Benchmark for Community Detection (ABCD) is a method for sampling a random graph with known ground truth community structure. Real data with reliable ground truth is scarce, and sharing these datasets can be difficult due to privacy concerns, for example, financial networks. In contrast, we can easily sample and share any number of synthetic graphs (with trusted ground truth communities), and use these networks as a proxy to build and test our algorithms." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "import numpy as np\n", + "\n", + "from abcd_graph import ABCD, ABCDSample" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "abcd = ABCD(40, min_community_size=10, rng=np.random.default_rng(seed=42))\n", + "graph = abcd.sample()\n", + "\n", + "G = graph.to_networkx()\n", + "pos = nx.forceatlas2_layout(G, seed=42)\n", + "nx.draw(G, pos=pos, node_color=graph.community_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Key Parameters\n", + "\n", + "There are only two essential parameters for ABCD graphs: the number of vertices (n) and the level of noise (xi). The level of noise is a number between 0 and 1 that controls the proportion of edges that are wired without looking at the community structure. When xi is 0, all edges will be intra-community, so the communities will be disjoint. On the other end, when xi is 1, the graph will be completely random and have no signature of the ground truth communities." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# The default minimum community size is 20, but we decrease to 10\n", + "# for these small examples so that we get more than 2 communities.\n", + "abcd = ABCD(40, xi=0.1, min_community_size=10, rng=np.random.default_rng(seed=42))\n", + "graph1 = abcd.sample()\n", + "\n", + "abcd.n = 100\n", + "graph2 = abcd.sample()\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(8, 4), dpi=100)\n", + "\n", + "G1 = graph1.to_networkx()\n", + "pos = nx.forceatlas2_layout(G1, seed=42) # for a reproducible layout\n", + "nx.draw(G1, ax=axs[0], pos=pos, node_size=150, node_color=graph1.community_array)\n", + "\n", + "G2 = graph2.to_networkx()\n", + "pos = nx.forceatlas2_layout(G2, seed=42) # for a reproducible layout\n", + "nx.draw(G2, ax=axs[1], pos=pos, node_size=150, node_color=graph2.community_array)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Sample three ABCD graph with increasing level of noise.\n", + "abcd = ABCD(50, xi=0.1, min_community_size=10, rng=np.random.default_rng(seed=42))\n", + "low_noise = abcd.sample()\n", + "\n", + "abcd.xi = 0.3\n", + "med_noise = abcd.sample()\n", + "\n", + "abcd.xi = 0.6\n", + "high_noise = abcd.sample()\n", + "\n", + "fig, axs = plt.subplots(1, 3, figsize=(12, 4), dpi=100)\n", + "for i, graph in enumerate([low_noise, med_noise, high_noise]):\n", + " G = graph.to_networkx()\n", + " pos = nx.forceatlas2_layout(G, seed=42) # for a reproducible layout\n", + " nx.draw(G, ax=axs[i], pos=pos, node_size=150, node_color=graph.community_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Graph Properties\n", + "\n", + "A key property observed in real complex networks is that both the degree and community size distributions tend to follow a powerlaw. That is, the probability of getting a degree/community size of $d$ occurs with probability $d^{-\\alpha}$ for some exponent $\\alpha > 0$. This means there are a few very large degrees/communities, but most are quite small. Analysis of real graph data has found the degree exponent is typically between 2 and 3, whereas the community size exponent is typically between 1 and 2. The ABCD model samples both degrees and community sizes from discrete powerlaw distributions controlled by the following parameters.\n", + "\n", + "### Degrees\n", + "- minimum_degree\n", + "- maximum_degree\n", + "- degree_exponent\n", + "\n", + "### Community Sizes\n", + "- minimum_community_size\n", + "- maximum_community_size\n", + "- community_size_exponent\n", + "\n", + "We can plot the expected vs empirical degree and community size distributions to check that they are being sampled correctly. Plots usually plot the inverse cumulative distribution function (icdf) on the y-axis and\n", + "use log-log scaling. In an ideal sample and large range, the plot will show a straight line with slope equal\n", + "to the exponent of the powerlaw, but due to the bounded range it tends to have a slightly concave shape." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "abcd = ABCD(\n", + " 10000, # it's helpful to increase the nodes so we sample more degrees and communities\n", + " min_degree=5,\n", + " max_degree=100,\n", + " degree_exponent=2.5,\n", + " min_community_size=20,\n", + " max_community_size=1000,\n", + " community_size_exponent=1.5,\n", + " rng=np.random.default_rng(seed=42),\n", + ")\n", + "\n", + "graph = abcd.sample()\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(8, 4), dpi=100)\n", + "\n", + "# Plot at integers evenly spaced on a log scale\n", + "points = np.round(np.geomspace(5, 100, 20)).astype(int)\n", + "expected = abcd.expected_degree_icdf(points)\n", + "axs[0].plot(points, expected, label=\"Expected\", alpha=0.7, lw=3)\n", + "empirical = graph.degree_icdf(points)\n", + "axs[0].plot(points, empirical, label=\"Empirical\", alpha=0.7, lw=3)\n", + "axs[0].legend()\n", + "axs[0].set_xscale(\"log\")\n", + "axs[0].set_yscale(\"log\")\n", + "axs[0].set_ylabel(\"ICDF\")\n", + "axs[0].set_xlabel(\"Degree\")\n", + "axs[0].set_title(\"Degree Distribution\")\n", + "\n", + "# Plot at integers evenly spaced on a log scale\n", + "points = np.round(np.geomspace(20, 1000, 20)).astype(int)\n", + "expected = abcd.expected_community_size_icdf(points)\n", + "axs[1].plot(points, expected, label=\"Expected\", alpha=0.7, lw=3)\n", + "empirical = graph.community_size_icdf(points)\n", + "axs[1].plot(points, empirical, label=\"Empirical\", alpha=0.7, lw=3)\n", + "axs[1].legend()\n", + "axs[1].set_xscale(\"log\")\n", + "axs[1].set_yscale(\"log\")\n", + "axs[1].set_ylabel(\"ICDF\")\n", + "axs[1].set_xlabel(\"Community Size\")\n", + "axs[1].set_title(\"Community Size Distribution\")\n", + "\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fitting ABCD Parameters to your data\n", + "\n", + "If you do happen to have a graph and want to test how your algorithm performs in general under similar conditions, or you want to see how changing one aspect of the graph changes the algorithms performance, you can fit an ABCD object to match the empirical parameters of an ABCDSample. This means all you have to do is pass an edge list and community array / membership matrix to ABCDSample and call ABCD.fit(). The parameters available to be set are\n", + "- n\n", + "- xi\n", + "- outliers\n", + "- eta\n", + "- rho\n", + "- degree_exponent\n", + "- min_degree\n", + "- max_degree\n", + "- community_size_exponent\n", + "- min_community_size\n", + "- max_community_size\n", + "- degree_sequence\n", + "- community_size_sequence\n", + "\n", + "By default, all parameters except degree_sequence and community_size_sequence are set to match the empirical values seen in the ABCDSample, but you can pass a list of parameters to fit() that will not be set.\n", + "\n", + "As an example, lets load the football graph studied by [Girvan and Newman (2002)](https://doi.org/10.1073/pnas.122653799). This graph has 115 vertices representing american football teams, where each conference is treated as a community." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAH0CAYAAACD0737AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQd0VMUbxe/uphF670WqCAIKKFZQBLuo2HvvvYvYey+I+kfF3huIioIgdqUJShGk994hCcnu/s9v4oSXZTfZEhBl7jl7CCm7782b+eZ+9yvjC4fDYTk4ODg4ODg4ODgkCX+yf+jg4ODg4ODg4ODgCKWDg4ODg4ODg0PKcAqlg4ODg4ODg4NDSnCE0sHBwcHBwcHBISU4Qung4ODg4ODg4JASHKF0cHBwcHBwcHBICY5QOjg4ODg4ODg4pARHKB0cHBwcHBwcHFKCI5QODg4ODg4ODg4pwRFKBwcHBwcHBweHlOAIpYODg4ODg4ODQ0pwhNLBwcHBwcHBwSElOELp4ODg4ODg4OCQEhyhdHBwcHBwcHBwSAmOUDo4ODg4ODg4OKQERygdHBwcHBwcHBxSgiOUDg4ODg4ODg4OKcERSgcHBwcHBwcHh5TgCKWDg4ODg4ODg0NKcITSwcHBwcHBwcEhJThC6eDg4ODg4ODgkBIcoXRwcHBwcHBwcEgJjlA6ODg4ODg4ODikBEcoHRwcHBwcHBwcUoIjlA4ODg4ODg4ODinBEUoHBwcHBwcHB4eU4Ailg4ODg4ODg4NDSnCE0sHBwcHBwcHBISU4Qung4ODg4ODg4JASHKF0cHBwcHBwcHBICY5QOjg4ODg4ODg4pARHKB0cHBwcHBwcHFKCI5QODg4ODg4ODg4pwRFKBwcHBwcHBweHlOAIpYODg4ODg4ODQ0pwhNLBwcHBwcHBwSElOELp4ODg4ODg4OCQEhyhdHBwcHBwcHBwSAmOUDo4ODg4ODg4OKQERygdHBwcHBwcHBxSgiOUDg4ODg4ODg4OKSEttT93cHBwcHDYebBi4Ur9OGiMVi9do2B+UBWqVlDb/XfVbvu0lM/n227XEQwGlbM+VxnlMpSRmb7dPtfBIRYcoXRwcHBwcCgB4XBYE0dN1uBnh+rHwWOksORP8wv6GAqFFQqG1LhNQx135eHqfsaBysrO3CbjmbMhRyPe+kGDnh2quZPnF32/QpXyOvScbjrq0kPVoEVd9ywd/hH4wqwUBwcHBwcHh60QLAiq/9UDNeT5YQqk+RUsCEXfTH0+Qzwbtqqnh77qq1qNapbZaIZCIb1170d6/7HByt2UJ58KP8sLf8BviG3HHu10w8DLVKN+dfc0HbYrHKF0cHBwcHCIAkjbQ2c+o2/e+UHxSi+Qzso1K6v/6AfLhNRBaB88/Wl9+8HPcf0+ymmVGpX06Mi71GjX+il/voNDvHBFOQ4ODg4ODlHw3sODNPLt+MkkQMFcu3yt+hzxgMlzTJXQPnP5S/ruw1/i/ptQQUhrlq/TzT3v1aolq1P6fAeHROAIpYODg4ODQwQ2527Wuw8PSmpcIJWz/5insV9OSGlcf/9uir548eutwtulgdA3ZPKVvu+m9PkODonAEUoHBwcHB4cIEGLeuHZT0uNCTuOgZ79MaVw/7f+lCaEnA5TKEW99p/WrN6R0DQ4O8cIRSgcHBwcHhyhkzu9Pvg0QKuHYYRO0ZM6ypP5+5eLV+uGT0TGLgOJBweaghr/2bdJ/7+CQCByhdHBwcHBwiMCs3+ealkApISzNmbSlvU8i+GXIWENKU/r4cFij3v8ppfdwcIgXrg+lg4ODg4ODBxTTbM7NL5MxOfv0c7S+/EqlpaUVvQKBQKlfa06W5EuXwqk1S6cBu4PD9oAjlA4ODg4ODh74/X4F0gPmJJxUcfhRh6lqywqGpBYUFBS9vP+P9vUmf1Cby+CppBIyd3BIBI5QOjg4ODg4SFq1apW+/fZbjRw5UnnhHKUpI+VxufTaS9SqU7OE/25Qv6F67ppXFCZungIqVSuf0t87OMQLRygdHBwcHHZKrF+/Xj/88IMhkLx+++03k3fYrFkz7dFuH639LTehHpReQATTKweUk7Y+qb9v3223hNsFRas079ijfUrv4eAQL1xRjoODg4PDToGcnBxDHPv27at9991X1apV0xFHHKF33nlHbdq00cCBAzVnzhzNmDFDLwx5Rj5/8lskxyPOD8/QHnvsoQMPPFDvvfee8vPjz8ts0raRajSrqrBCKR3ZeOTFPZL+eweHROAUSgcHBweH/yQgcGPGjClSIH/66Sfl5eWpRo0aOvjgg3X22Webf5s3b27O4vaiet2qOvCELuaUmkSrrX1+n7KyM/XjzJEa/s1wPfvsszrllFNUt25dXXTRReZVr169mH8/YsQInX/++cqdG9Luvr2Tu3mfzLne9ZrVSe7vHRwShDvL28HBwcHhPwEKWiZOnFhEIL/77jtt3LhRlSpVUrdu3Qx55IUaSeFNaVi3ar0uaHetVi1aLV/cAb2wUTYf+OI2deq5Jdw8adIk9e/fX2+88YYhtb1799YVV1yh/fbbr4jM/v777zr33HM1fvx48/9jju6lvB/Tlb8qJL8vMbU0pKDSu+TprSGvq3r11M8Ud3AoDY5QOjg4ODj8K0GO4dSpU4sI5KhRo7R69WqVK1dOBxxwQBGBJOxsWvEkCHIqex54qNqH9lNgc0bpSqVPCoVDanV8Az334dNRf2Xt2rV67bXXjGr5119/qV27dka9/OabbzR8+HDzOx07dtRzzz2nW265RaN/GKOe1Xtr44qcuJRScjdpP9Sr7yG6o9+tKl++vD788EN17tw54ft3cEgEjlA6ODg4OPxrCOSsWbMM+bIkcunSpUpPT9c+++xTRCD32msvZWZmpvRZkL39999fjRo10pCPP9NDFz+liUOnKs2XbhTFYgUzPikcCiun/Hp1PWdvPdj/Xn300Uc6/vjjS8xvhOjdcMMNmj+/sPk55K9fv37q2rWrjjzySC1btkyffPKJOrTdQ3cd/6j++G6qIazR1ErC7FxD0JevrM4hff7zYPO+J510kiHGTz/9tC6++OKtQvsODmUFRygdHBwcHHZYLFy4sIg88po3b54JV6O4QR4POuggEzbOzs4us89csGCBIZMond9//70p3mnfvr3q12mgq0+5QaPe+1ETR/+hgvygWrfbVdWbVdLDb92rXG3Szz//rMcff1xffvmlfv31V+22225Rq8sfeughPfbYY9q8ebO5doqECHXTugiCTJ4nuZStW7c2f0MuaI+9DlcDNVX99F3MWd1eNGvfWMdedaRyKq3V8SccpxdeeMEQSN7/+uuvN4roGWecYb4PcXVwKHOEHRwcHBwcdhAsW7Ys/P7774cvueSScMuWLZEBzat9+/bha6+9NjxkyJDwmjVrttnnL1++PNy6detwo0aNwvPmzTPfGzx4sLmG7777ruj3evfuHT700EPN16FQKNy4cWPzOx07dgyvX78+3KZNm3CLFi2KXWtubm746aefDlesWNH8biAQCF9zzTXhdevWmZ+/+eab4bS0tHD58uXNz5s2bRp+9NFHwytXrgwfeeSR5nutWrUKr162Jjzx28nhu698IFxNtcIzJs4udg8XXXRRODs7Ozxt2rSi7w383yvhepmNwp0a7hN+r9/H4Uk//hkuKCjYZuPosPPBKZQODg4ODv8YyCmkeMYqkBSmgFatWhWFsCmoQbHb1kA57N69u2kdRH/Kli1bmtB2ly5dlJGRYdRKi+OOO85UkX/22Wfm//fff7/uuOMOE8omr3P9io06+bDTtGvz1rrq6qs0ceoEPf36Y1q8dLH5/aOPPtqEtxs3bmw+49FHH9XNN9+sU089VS+//LIpLqKI5/333ze/j9II3nrrLZ122mnm60GDBpnrIDRes2bNomvbsGGDyRutWqWqXnz8FX0x4Gt9+/7PChYUP/mnRv1q6nX5YTr0vINVtVblbT6+Dv9tOELp4ODg4LDdsGnTJv34449FBHLs2LGGhJGrCJmzYez69etv16eSm5tr8ha5HnI099xzT/N9rpHr+uKLL3T44YcX/T6EkOIXSB0gX5F7qKZa2qNmF/lXZZqcRi82h/O0udYG3fHCzTr8uEPN9yCll19+uV588UXTH/Oee+4plucIWWRMJk+ebP5PruiVV15pqsQJr0O2p02bZsivF9+N/F7XHNJH1VVHgTR/zCMYyb0MBPy6dsAl6nl2tzIbT4edD64PpYODg4PDNgMtcsglhJhB1CBBkKjatWsbonThhReaf3fZZZd/rGCEs7NR/ehT+dVXXxWRSfDAAw8Yte+www7b6m+8hT9VK1bTIVWPldakKbQiFPXIxAxfprJWldNTJ76s3CeCOvjs/XTiiSeacXnllVd0zjnnbPU3EEpLJiG2qJlcK+PXq1cv833yLr3YtD5Hb9/wqar76piEgZLO84b0FoSCevTc/tqweqOOv+bIhMbOwcHCKZQODg4ODmUGiBbFJVaBJHTMCTVVq1Y1yqNVICk22REqjiFoNBF//fXXTUU1yqMFRJhw9wcffKATTjih2N/16NHD9Hd89913tWHNRl29322aP23RVqpkSVhfc7mmbZ5oKsIZl2ggBP7xxx+bkLcNbU+ZMsWEw1999VWj+FKURMidE3lAn8Pv1/gRfyTckB3c9fGN2u/YvRL+OwcHRygdHBwcHJIG4WqadlsC+e2332rdunWqUKGCITg2D5J+i4SIdyRAJm+47ga9+dR7Ou2oM9W4XhOlZ6arer2q6nbKfrr46gtNOBmFMPLabVieRuU3HHyXJv0wVaFg4mdvn/lwb5114ylRf/bnn3+aKnGuE5XUNjy3WLx4sTlxhxN4+Lpt27Y6qcdp+u6p4r+XCOo1r6NXpz2zQ5B9h38XHKF0cHBwcIgbkBt6NFoCSbh2xYoVJvyLUmYJZKdOnUz7mx0Vq5eu0U2n367pI+Yow5elQHohYYRGhUJhQ5SXhxbr5Ot76ZZHb9iKYNE4vWnTpjr32At1f+/oTczjQa1GNfTGrP5RT+4588wzjWrKaT9DhgzRUUcdtdWzYNxpUwTxpDXQrMFLVFP1EjjZZ2vcOfh67X90l6T/3mHnhCOUDg4ODg4lYu7cucWaidMbkpNnaCBuCSTFIllZWf+KkZw2dqauO+h25W3Ik6+EIw3Jg/TJZyqhL33qnGIq5d57723C+/q9vKoEa8qfAoG7//M+2uvwPYp9b8aMGabSnXGmHyYnAEVTDcml5AjH22+/XSsXr9ZpDS82hDhZhBXSpuy1ev7Hx03vTQeHeOGKchwcHBwcimHJkiVFBJJ/Z86cacgMYVdy+iCQNP6uWLHiv27kZkyYrav3v035m/NLPR8bMgk+fe5L5W7K0/UvXWoKiqjIJvwcCKZrfx1R9HvJgArswf2HbkUoKQbiDPI1a9aYKvBYIWiarkM2wdRfpqdEJgHKZrm8SiZ39Pnnn49aKOTgEA1OoXRwcHDYyUGVMLmPVoGk6AO0adOmSIEkHxLy8m8G1c+nNr5IG9ZsSkpR3Pusdnrn+1c1e/ZsQ/Cqh2qrvW+/lK+rXMUsPfTzraYinuIb+mCefvrpJg+VfNT//e9/Jn2An9vfsV/Ts7JKlSomBL90whptGF2812SyJLfBWRXNe1OF/8wzz/xr1GeHfw6OUDo4ODjsZKCBN9XXlkBy1jP5eM2aNSvWTLxOnTr6L+GpG5/XZ4+PSEpRJPydF87V1Gq/aOWqlUad7dH2SK37pSDl62LsR+ijuH6XsLs39I5ias8Vr6NGautLvUI7Iytdn296WwMHDjTqKPmZnDtOaycHh1hwhNLBwcHhPw6adtP/0RLI0aNHm/w/qpQtgaRqmVNb/qvg5JnLO96qrFB2SiHqhTWm66AT99c777yj2mqoBmuKNxRPCv6wCg5YaU4NosCJJunRwGk9tA3iVatWLfPvuHHjTNHOMccco9lj52vz6IyUL6dGg2p6Z97/zNc4G7RMIqxORTvN3x0cosERSgcHB4f/GFCtOPHFEkhOpiE8yvGFthckrxYtWuwU7WHIAe2x12FqtrpDSu8TCoe0Sss0QT+Y/1dVTXX0dU35+vL9ecrsnmcIIi2YqKLHCShfvry+/PLLIvJITiXPixQFjoEcNWqU3nzzTUNCQeOGjdVyWWeFC09pTArhcEgryi/U/ud00imnnKJ9993XEN2zzz7bVJrfdtttuvvuu3e4FlAO/zwcoXRwcHD4lyMYDBoFzhJIyAbnOUNACF1bEkmfwmjtaf7LWLRokSkgqrKptqova5Dy++UpR2MyRxjCh9J5gI40bYeShk+aE/5Tzw59TLvvvrtpRXTIIYfo888/15133qm77rrLEEjOO4dA8uK8c8LcTZo0UeXKlU0VPkoi/3/pljf1/mOfJtRgPRKtzq2nwcM+1oIFC9SgQQOddNJJ5sXc4nhI5hMKrff8cAcHRygdHBwc/mWATEydOrWIQEIyCEnSXobiDKtAUpVN25mdBfSOhEDOmjXLvGhITkU2J/U0y2ijehs43jE1Qu3P8KnVRXVMoQxpA021m5qEW/3dwTIJ+KT0rjn6ZcJPOvbYY03fSZ7j0qVLddFFF5lUBS+BxEHg1bVrV/P/p556Sn369DEn5uBY3Nf3QX3/8ISkwvr+gF97HtJODw69zYwlR1G+9957ev/9980pPZBdqr9RTbOzs833aRfl4GCmcthm8zo4ODg47JDATFNZbAkkLwgHlb9s6JZA0hfSe770fxFUPTMWljR6X1RHUwFtwfgwdkcccYTqhhpr5ueLU/78UHpQIzd/YkK+KHXPPv6crurYN6ljDkMKKTd7g64eeL6uvPJKQ9o4otK2AaIIxksgo+W4cmQk4WhI58UXX6xffvlFZxx4vhZ/tyZhMlm+crb6j35IdZvWLvYziCpdADhmkmMiUUwhvaRR3HLLLbrvvvt2itQJh5LhCKWDg4PDDgiah3ubiRPWJFzNCTSWQHIyDUrRfwmofoRaoxFGXitXriz6XXIMUc14Qb7s14Rpb7jhBkOuGEPGbOywibr1sPtSujbyC0MV83Xla+fqkksu0dVXX23Uwc/+N1xPXzogsfdSSAW+Ak3I+F5rcwsJJMAhgKgNGjRIvXr1KvV9+L3jjjvO/F2jRo30yiuvmPD3U1e+oF18reNuE5RdsZweGna7WnZsVmp+7tdff623337bKJQQeNoWMRZnnXWWGX+HnROOUDo4ODjsAFi+fLkJXVsCOX36dPN9TiuxVdj0giRn7t8OFLhYhHHevHmFJ9CwQfl8atiwYVTSyIscvkhlDDWN5uuDBw/W0KFDzdiZ7xcEdVrjS7RqcWLKXSQmh8eo0d519Mcff+jaa6816hx475HBJn/RRJrDpRf35GuzJvh+UKBy4ak7X331lSHIVGyT+0ohTGlgjvTu3dsU8kDmaESOgsjXXFuz7NZ67/7ByvSVi3pd9iSgDge11bUDLla9Zom1iSKPlBN6CLsz7qjBnTt3NsU85FxC7B12HjhC6eDg4PAPAMJAoYUlkIQsAcftWQWSMOe/sfAB1QpiGIs0eskS5In+l9FII4pbIiF8CA1hXxpyQ6zISfSi3/Uv6tMnv0o637EgnK/vNMSc+41SByD6ENjjjz9ek7+ZrpdufUuLZy5ld5XCvq1UST67YYc6uqr/hSpXNVM9evQwBVSQM5Q+TikCFOUQqo8GyNvTTz9tKq6pAGes6SuKU0KLH063GTBggHFAZs+areBSv07a90zNGDdH+bn5goNnlM/QX+sn6+3vXlHHA4qf0pMo/vzzT6OSkorQrl07M5dRWSmGglxyTRwR6fDfhiOUDg4ODtsBFE3QvscSSNr6UPgAaerevXuRCklvyB0dEDda1cQijISsuTdAriG5f15l0UsayRksq/y7W2+9VQ899JAJ+3qPDITcPProo3rw7oe1d7CH/GF/wp/p8/t00Nn76Os5n5nnB0hBqFevnklP4GsUOZTQjQvz1FDNVNVXUwGlFxLJ9LBqtauiQWPf1wuvPKc9m+6lBdMXa+a0mXr48YcUzgpqY/pard+w3owd4/bBBx8YohapSp533nmmYOaqq64yuZfNmzfXvffea16EyanA/vTTTw3JZaxRuSn2ARw5GUgLGJUYMkpx0QUXXJDy2EOKIfOEwvkX1ZVm6MOGDTP3w9w++eSTzTVVr15d2wL5oVzlBDeYr8sFKijd70732Z5whNLBwcFhG6l0v/76axGBpFoXVQulxiqQvNjwd8SCBhQzilxikUZCsxYQBC9h9JJGQtbbo9IcwnjTTTfpiSeeMOFeC4pJOD5wxowZZpxbVW+r+itbGlIcbyU0BStt9mulh4fdrvSMdKMsox5HgiIgnrH9t2PHjpo2bZpRHiHZw4d+rfOPuFRN0lopo+BvsuNT0bXkhDcqo1lYfZ69UUcde4Qhwtdff73uv/9+M4YcgUjOJk4HpJmKfp4TBTI0PWc+EernPjk2E7JOE3tC/4cddthW18vf8+zIwywLcB+E3a+55hpz7xBirg0yS0EP+awQb1RZlEvIb6opHMFwvqav+1ljVw3RgpzJxX7WMLutOlU7Ri0qdlHAt/N0O/in4Ailg4ODQxmAvL/x48cb8sjGSS9I2tWwqVOlawlk69atdwgCyeZPeDUWYaT9jgVkhRY10Ugjr22R18n1/TZykka89Z2Wz1+pvE15qlitgikaOeLC7qpRf4vKRYgblY0QsM1pREGlMOe1114zZIx7oIciyuXpPc6Rb3IF83v+UtoI8ax226+F9rqgrX4a/aPJc6UdEeDZ8mK8UBQJRe+6667myEp+z/49hVOVw9XVNrS3Qnkh0Vsl2hwwTVd8UmZ2hs554kSdfsXJha2JmjY153rTaxRV8oEHHjD5loDvdejQwfwOeZ18Vv/+/Y1yCWGjQIfG7tEakT/88MO65557TKFTWZ7VjSN14oknmvmPWkpfTUBnAlRLWhGxPkhnOPzwww25POqoo4ruKV5MXfudvlrynHKC6+ST/++Ugi2w38sOVNahdS/XrpX2L7N7dNgajlA6ODg4JAHCeBRDWAUSJYyWNmz85K5ZAklO2T91qggqYqwWO3wfdcsC5TSSMFrSSFh3e90DIeMhzw/Tx898bnIRqUAOFmwhCn6/z9SW7HtMZ51663GaNG+iKQChZ+Nzzz1nfgcSCfHi/iFphIhPP/10Q2RQ9lCPO+/aRV3qdNOf38806qAN0duiGYhmWgW/VmYv0tilP5oCFk4WQpnkdeaZZ+qll17S+eefb062gchyag3klfeHMPL7ixcvVsbGbLUP7WdyFyE5pQESxHgfcv0+uunh68x7cR9nnHGG+UybV0r4G5WR8PV1111nwv3MQULgkDjUStIAINLRADGm2X0sBTMVQOgZ8+HDh5tQPNfhbaqPYouCiXKJigoRPvroo01YHJJZGsEds3KQvl6aWGV9jzqXqlO1o5O+J4eS4Qilg4ODQxxgQ4c4WAKJCsmmyeZO+x5LIGlRQ8hzewBFjPy9WKSRvoYWbNDRCCMv1MdE1aFtgZyNubrv5Cc0ZugEQ+BKqpYmDM0vTNZYHXDC3obM8XwgeuSnAp4LhTmfffaZIfwcPQnhgrAQhoWorVi4Uh88/anGjBiv5QtXaO36tVq1aYWWaJ6qNa+kbgdt6QNp81tRDXnGr776qukBacGYP/jgg4b0QZ6YM1kqr711iNIIuSbQ9Zn7D/vC+iU0TDm+jYZMQr4o2oIwcy8UveDA8Dk9e/Y0hTqQx8cff9xUX99xxx2mYAeHIOpnhMPm+XM+97PPPqttMT9RQHnxGZwFjqIbCcaNFkTcH4prxYoVzXNDuYQYoy57MWXttxq88OGkrunYBreqdaUDkr4nh9hwhNLBwcEhBtiMvc3EIW8oUDQQtwSSxuJlGS6MBBXRJTXyttXGAMITizSiQO4IofaSlMnbjnxAv42YVEwtLAmFbW+km964Ql+OH2La1/C3devWNUUghJ0J3aPioVJC9iCCFKxAOu1Rhpw6BFq2bGnII2FinjOFL9Fg8xYhsahwxa4pHDaV+RQikQLRytdB9cNNSw2tRwNKaa0OVbSs2hwTzoaQ0UicKmryMiFeFHpBvHAKUChRRekJieqIumyLcWIBJZfxYI5tq/nBtUCIqegn5E1+ZUkV4yjJkEu+rlatmink4R55NiFfgfpNP115oU1JXUuWv4KubPmW0vzbx+nbmeAIpYODwz+O9fm5+nrRVC3JXae8YL4qpmepdeW66lJzl6Q24mRBjpe3mTi5Z2yyHGFoCSSqEBt5WQFCOH/+/JikkVNJLFCjYhFGCMy2JLbbGm/e+6Fev+v9wjzCROArJF4/hocqnBHUbrvtZlIRII6QmMsvv9xUM6N4QRQpEmJcvQTSKpBWyaOwB6UPMh9NbaaimTkA6SFE6wXPkeeBKnr9NTeo/qzW8oeTTxcIhoM65O7OGjDwf0aV/Pjjj00FNfmvqJVcA2d+owZyn0OGDDGEjM4BX3zxhVFjSwJV2IceeqghrIS/txVwfsir5HP69etncl5LIrDMA36X++N+eGbc39l9D1PV7stTupaj69+otpUPSuk9HLaGI5QODg7/GKatXaJ3Zo/R4PkTtTlUoIDP/3f/5bCC4bDqlaui05vupeMa7aHKGeXK/PMha4RCbQjbFltASry9IFFJkgUbI59j8xajNfKGDADCpLQRimzgbV9U5O7IKmOyoJXNKfUv1rqV65M+wWZJubmanDPOjBNhb4ijVSFRugCEkTw9SyBRMmMVlXBmNf+iRkdizZo1JnRLDiA9Fr2gCOW0004zPSG7teipums5OSb5Z8ZamBaeoGOvONycS47Kx3x5rv/zevyWpxWel6FK/qryhfzmKMdKNcorvXFY4xb/rL/mTi8195VKcuYVBBr1c1uCz6IC/IUXXjDFURQPxXPSE2uIZwmxDB0wTtWbZskfSG5MyZetk9VS5zR9Mqm/d4gNRygdHBy2O9ggXpv5sx6bPMwokMFw9BCn3TKqZZbXgH3O1K6VEzvJI5qyRHWpVSBRrLgWGmtbAgnZoEo30Y2SoxFjqYzk7VlARKKd+mIbeW+v/MsdCaPe+1H3n/pUSu8RChQoo3ue5sydXUQgqbimQIUm4VdccYVpuxMPKKqhcp12PRS7RIKqaNRCwsmRzdMJN6MMks/ZLr2LaocaJpQ7udV9KaQl4XmaorFFJ+mcddCF2jipQGtXrI95Ag7FS91PP1CXPXWuKlYtrGiPBULK5NvSHH17gPPHOboShZgQOM8oHmzIX6V+f51RJtdwdct3lJ327z91akeCI5QODg7bHc9P+1bP/vlN3L+PbpkZSNNbB5yvVgmQSnLd6P9oCSTVpBRUoFR5m4kTLi4JkE423FgqIxWrNlRL7p1tsRNJGvl/tKKEnR039bhHE0dNVigYX+5kLKyoP1ddjupYpEDyrPfcc0/T2PvLL7+Mqdbx7Eg9YL7wwkHgSEPUQPIu7ffti9QI2vJQWQ4Z8v6MvErC4Sibk96ZrVq++nH3u4yF+u1r6aMZrxuHqLU6qr5vl7j+jsKles1q65Gv71TNBrGbiQ8cOND06uS+IMrbA4SzLZGlyCiSmEfD8tw5emnWZWXy+Rc1+5+qZzYsk/dyKIQjlA4ODtsVwxdN0TVj3k/47wI+n6pkZOvz7leaHMtogBQQGrMEkoIFyAGbJMTRqpAULkSGjumZZ8liNNLISTcWFF3EOl+awpjt0cj7v4QzdrlMS+emlhcH6natrPK7phtih5L39ddfm+dKEQjFOpHE0PtKOHfz70bmqIbkrvKi4p9G5jgUzIM1P25WHV+jlAglJ/RkNfRr6IKPdPSuJ2ndpLyE0h5ou1S/RV0989P9Kl85eiU/+ZiE/yn6Ie90e4Ec1XPPPdcovTSltw3cowEyPe6v7/RTZtlUo1/Y7AXVyGxUJu/lUAhHKB0cHLYb2LSPH/W8/lq3LKkoINvoLW0P0xnNupj/QxJoM2IJJCeYsPGgLKFQWQJpiw3oCRiLMPIzC4iBlyhGfl2WRTkO0gm1z9fa5VvSApINDS/MmKEVFRaa58c8WL9+vWkkT4U7BU3MC16Es8ndsyTQEkLva8KECbr55ptNcQ0OiPdnKHmEa+mxaJt2A9Twfffd1zg1zJEjW52gXQK7KhwKp3RfC8IzdcLlvTT6uSlJvQdKJTmYlz655TjKSKCoMr8pgtneNoEiKMaagrdHHnnE5BxDzL0vOixUrpOlm0eUTTHNlS3fVIW05HOjHbaGc6MdHBy2G/5YvVDT123pjZgMBk77XquHjtE3I78xBRc0daaFC61hOBmFECSbPsUuVGmz6VsSiVppgSJjSSLhb6/KyM+8TZgdti3KVchKmVD65VfDXRqqYoUMk89K3ipK3pQpU8wrEhBLWu/Y024iX7Z5OI4KRSt8j3nFXLNzI1JN++WXX8zv0Mye/Nylmq8moVYp3xc9MT/t/6Vq+xompXaSSjD05RE6575TVK58dHWfk2ogdvboyG0JipoiCSP5wxTIUcEOGEeIPJXsFPDwb8tWLTUu8ILWBpem8Ok+Vc9ooPIBl3pS1nAKpYODw3ZDn/Gf6LMFf8QswokX8+98U3VzAkZ5oukx5IG2JFTWWqBAxTpfmpBkPNWlDtsHdx73iH79fFyxE3GSwSNf3yFftaDpDUql9YABA4xSidMBieHfkl6Rv0MOZjRAKgml2xQHS0LpW4nTgmNDXi1q2wmNz9XquWvlS6L9FepdoIpPS+vOVPWpqbfQuur5C3X0xT2j/oyemaQGQKBJD0kVjB1OnJc0UizFv96G+w0aNDBkkRfFcDQ4xwHgWEjOMfeG9yl0ev6r21Wj21qTCpAsDq1zufasdmTK9+hQHI5QOjg4bDccM7K/Zq5PLVcuHApp6SvDtfqzX81mFIs00rPuv9hi57+IMV/+pj5HPJD8G/ikOk1q6anR96hz586G3FGxDPFLFpA5eiXSFYBKZC/hpBE6ZJHCHZQ0S0DHjBljlE3IlFXD66ih2voKVbdkcMo9xygzPVOv9fkgpWpx7meNf4U6nNvc9Obk/G/v+uDnrCcaiHPSTrzgtKhItZEX0QHbdJ88U1IELHGk+p5/USBJRfCCsevTp48effRRM74UDBFt4Pxy2gbVaVhTl3zSQWmZyZHrdF+maWyeGXAOZVnDEUoHB4fthoO+elzLcpPrNWjBNnJijba6udPRRWFJh38vOI/6tttu0+IPNyrLl51USBdidNGjZ+qVES+YsPO4ceOMCp0qKFI566yzTJsgby9STqqhcpyuARBYwIk8qJUfffSRqV6meTcthEjNuOKgm1RbDRNycCB4y7VQv+sX7aLW5pWqQpnj36gfg0PN1xA6yOOpp55qvgZUrRN2hhBGtlGaMWNGVOJoG+9zb3RLsKTR+2JcEnXuKNShnyigwIq+olTsU61/xBXt1fm82FXrJaFHnUvUqdoxSf2tQ8lwOZQODg5lBqplOfUFRYE8Nvvi/4SkAzcepYx6qSXC09T5lQEvaegNj5sNDOLAy37Nvy6cveODIqi7777bnHtNG6cTTz5dv78/I6mm5r4Mv8Yt+tkc8UcPyLIgk/YscEAomxxDCxsK9+ZQ0gQd0BAd0BWAHM0Oe3Qw541Xq1pdGWviPy99j0Pa6sxH79TGnA367JmvNfbDPxQKpiBRSmrSqIk697rGHFEJEUSJ5BmgVnLiD+SP5un33nuvUWNtiJrQtT0Ok4ImSxQ5n9t+Te5yKoqwF6jL//vf/wyRJKWFcebFKUCEwe+66y79vO4tjV5V8rGSkehS/QRHJrchHKF0cHCIWzGhzYeXJEaSRtqPeMGGSkiQ0BchwQbLViu9dhX5AskrLb5AQAft2UVh/1xDUtnIIbH2tBlAuDsa2bRfR4bZHLYfICqEiyE1EBBy5SiK6n18b1XKrKMaeYXHH8YDmnfLn6YxBd9o+OMfmtzFww47rMyulfQJ8vpoP1UaoUQZRUWzxzfa03Q4JzuskLpcsLuG/u8bVVtfV+nK+Psc8i2qHTmBpho8Pawz+5yk0/v2LuqbueDH5Rr74aStO5gniPTsNNOaBwLJqTg2D5T1e+uttxb9Hkc5sk7atGmjXr16FQtVb6tUEuwLbZ7uu+8+062Bzgz09EQZveeeewypPe644wzZJTJxcLkLVCG9ukYtfVXBcAFvsHVeZbjwfRX26/NHp6jNCTUkJ05uMzhC6eDgYIACgWrkJYqRpJE2LBYoB2ygbDw2b5Gf8x4kz/M1myrhLqpGIaNrRk5QhQ7NUhrxcoF0PXv5jcpOyyi2wRNyhGDy4lrt1xQbcB82nwtQtRuNbNr/UwHsUPbq9bPPPmty4fj62muvNb0HcQhoRE7+3keT3tBXz36nj5/+3PRPLKlIh1Y4VIdf/uLZ6n3eUGXlZxkCQt6dVQlTBcSJVjYQSi+iEUpaBnk/FwcKNY/G6LzPbxN+0585E1QQHquaqq8GvqaqV7mBNq7bpLTMNK3dvFIVd8vQJz99oIqVijs8u+3bKuWm77Qf+nHytyaf0QJnz56RfdVVV5nqdU6x4dpZM5wgRdslxnRbNeSH8KE8QiTJQe3UqZMGDRpkbMr5559v1i+qJOuSU4vo5sCRl/x/7+rHq2naPjrlpoPU/YJdpfKbi713xfSa+rzfb2ri20s116Wbnpe0GWOuOZQ9XA6lg8NOFo6OpS7yMy/pYjPEaPOipYf9mlwywmUoB/TbI4+MHnEANYcNgUbiKAqQBT7XokqN6mr8/OXKT09O4eCs71N36axbdz88ob9DvYToRpJN+zX/kidmweYZTdm0X6O8OsQHyBckBdWLZ8CJLHfccYdpzfTcc88ZItOzZ0/T/9AS+bHDJmpQvy/06xfjzf9D4ZDS09KFMFaQH1TFquV11CU91fO8rjr6hKOM88Lxiuedd56Zk5wVDXkoC6CkoubhENmcXRQ0+pyS/0lhCeuG9QIpskc1kp84adIkcz68VemZQ6wdHDFOiuHF+1N4Qi7miBEjoqrnkK4L212veVO2nMiUDCof5tPyjUsNqeJ+WNeQYAgzeaIPPfSQIcnkfj755JMaPHiwOeMepfTQQw81+ZbHHHNMXAp/XnCT1uYvVV5ok9J9WaqUXqPYUYesSYqdUEwZB4gi54lTYU5BDqF4CO0rr7xS1EqIZ8vZ6Tzvt956y6jRjB3FU7NmzVSFugGt2rBMPQ7pIV9Bhmb/vlgPPPCgeS60cerRo4dxfKlkL+2Mc4fE4RRKB4f/AEwF55o1UYmi/ZpmzF6woVuSSFNjL2nkazZIKlXZfCCNqAcYb3tOMo2bIY+crLHHHnsY4kj+GmoDoTQLNqgjjjjCbBb8/okD7taUWiH5kujzGAyFdGKjjgn/HZsHqgQvFKdo6izh+mhkk7w8vvYSY0u2Y6mcENKdvcKcOQkhoWKXquiTTjrJbOwQMEgmRxeiWEJeHnvssWJqX6ee7c1ryZxluvS4q7Vm6Vr1PLKHKlTJVvM9m2r/4/dWekaaIY3k+KEOEpKFKPC+EEsak/O+qfZUJI+SdYBSRjsir0JpSQmEiDkfqVDipEGW6ZeKMogayLyg2T5fQ1BNSDwc1sUXXxyVqEG8WMcVW6crNDmUVNESam77bm30yBd3FF2/rV7/+OOPzdzn+q655hoT1uYzcQ4JQfMzFMF33nlHp59+uklTOProow1hPvzwww1Z9mJRznSNX/WZpqwbVRiK/htcd4uKXdS+0uH6/pM/9NCDDxlCzvgwDw488EAzjowx5A/1GifE+/7YD54DNgebgmNim8s3aVJ4HGX1jIaaN2GNmU+0auLMcFRxrv/tt982ajjzkPd2KFs4hdLB4V8Ujo6lLkYLR0MKvSTRqzRCrCIrpPkMNmfIoyWQbMq20TF5V6gokE9eqCzDhg0zhprTRLyEC5ADRaiKZH82IX6O+vDr2DFq/uB5ymxRX6EEc8IWv/C5DsioZxQvSN32gj3LO1pI3X7tPZoRYhArf5N/UXD/y4QTBQ9VD6LHZo/yRY9DgDLGnICs9O/f3xCpksDJMxR88My9oGgDshB5XCDPCoUS5RPVi76GqZxPzfxHkUYxI0cTQGIgQjx71hRKK2SMe7OFKRBnVHzIC84U/yctA3IKGWI+4eRBfGyTddS6yCpqSBfquV8B7a1DVM5X3jQ7TwSBtIAeH3W32uy7dZN11j1FR1SnQ7hsj0iOF2XMyW+1pJx5Tuse1GRsA9dNXiPkcp+unTRk6SOav2mSfAoorC05zVs+jJzXsJbNXK9Fn1TTDZf2NTaFMSaXllxJxunVV18tqp6PBq4Zkgih5HnTbxTl2wLbxphZNZe5wL1hK1E/+RycD1Rmh7KDI5QODjtYODoaaaRJcjzhaPt/Gn6XdNILhpb3hDRaAkk4yZJSVApLHDHstEjBSNNAnNAiigVqpPfkGYAyR94TGz3hKgsUB8gkGy6qxlsff6Crxryn8SvmSqU0KPbLZ4jnjW16qsafq4xKgrpKnhXXuSOA8aQfXyyyyYsG2xZUoZcUUv+39tCknQ7FHcwNCCRE0ns0IaocxS04R6hjkJXSgFJ26aWXFlOUSKWALNLmBnUrGmh/Q3gUco9Syuk1yQJFkTVHKxuAag0pJNWDIhxaC6Hcs47sfIBYQsp4joSTUf1YHzhakDEcEH7G/1FwWVsW5B2juPKZhKNROyE/P3z9kw6vcaI2rc2Jqwl84RTy6ZY3r9LBp26tzEeC62bcIIg2osE1QBoZS56ldUS5ZsglDuXi1XN12Tv7qVLtTMXT2cgX9ps+kKc3eVhLpq8vym3k+EVIYrztwHBMsEW2XRP2CjDORGwgxzwD0m9wSpgrzBnmHWSfzySf2qFs4AilwzYBhmn8qnl6d/YYTVqzSBvy85QVSFO97Co6vtEeOqx+G2UGtu3xXjtaODqSKMYKR7PJQJgiQ9CR4ehEYJsuewmkrcjGGFvyyAsi4H1/cr4Iy0EAUCQhtpBVVAKula/Jr7riiiuMahOZm0RFL2oVv/v000+b3wOvvfWGbvzsZTU+5RBtUkERcfTmS3Kizu5V6+uyVl11YO2W5vsoNmxwEHAUlGOPPVb/hjnAM7DkMpJs8vISCsJ8JVWpQ7J2pKMh2bAhAuS14UigtEFAvNdIiJXnxmaPom17H5YESDipFTxn25MQksAcRSEnlIwaHwuMMfODOfPaa6+Za0oGt99+u1FEWafMY9I6yCXk/5B/mnaTz/fMM8+Y30cNw/EhEgB5RoWMdL7AbrvtZoguz5RjD1FrKeJh3PhM8hhZk/S0hMBCxh++51H1Ofx+zZ2ywISyYxXrUPGcnpmu2965RvseE1vtiwZ7Jjlki3lJ3jT3iiJJuJsiHe4X0pwXzNGAqZdpvZbGRSaLrk9+hXIDevzoEapbtYlRJQlpxwvsEHMABxVySyicfFScD/IkWVNfffWVsUmWfNKfFNWXZ4KTTDoDzsa/0XnbEeEIpUOZ44sFf+i5ad9q9oYVRaTAwpKGimmZOnmXzoYo/NuJJcqDzb+LFZKOFo6OpS5GC0cnAnK5UEBs2Jp/qboGEEVv2JqvbZsTL9g8UADx+knKJ+eKsBdGHMLIPUMcLrvsMrPRowJEgt+1+WNsSIRBaUMCIFeoi+QzvfHOWxq5+E8NmjdBi3LWKjeYr0rpWYZIntSkk1pXrrvVezOenO9L/hcbL33pdiSClQxwOkoKqTNm3jnk7bsZWaWOQ7I9ig446pKQ7vPPP2/IByoiCnVk3iJkAWWIDRzHJF5ViJw6CBcqHQSHecicotAFAoEzVBpQAsmpRE0j9EzoOtG5QjNtiAtkBPKIUknzckLFKF0olOQAMudRKr3PijUHMeYzeSYQUGwCpJo+jhaE7VmvL7/8srlefocWORT5QNYhlxBj7EOwIKhfPx+vT/p9oQkjaSdUHNXqV9GJ1x6jnud0U6VqFZUobA4la4xrJ4UAe8EzoHCI50LOJST3kIt208p6Y5JqaYTKGppZWzcfMSBhm2dJPdEPiDnpCBBviDzjxFjSZ9MWSfF/7sE2nrd/jxNA3q1D6nCE0qFMVZhn/hypAdO/N2njpZkXyCWk4fkup6tyRtk0xN1W4WiMeyx1MTIcTS5UrNxFXmwoZUV+MPx45968R8KObLwYaIplLHHkX8I+sT6b+4CgYXBpLGyVMjZkFBbeE0UCgw1poPIylmfPhs8Gi7oJaUQp8CpJhMQJlXHt0QhtvPMNNQeSwMZGy5j/cvW1twdoNOJJWNUCQmfnXDSVkzH3FsEkCgg9ihpFL8wnQpUU13hb0gBUbIpyyI+jEpecyZIUxUjg1KBqoihBcFC6+UzyL5lXicwVroFrQeVjrsTTGoq/w7lC2UKZo0qYseX/kT1XIb68bOsdQO4mBJprZT3iePF3hOFZG971A8HkM/gea4vqZpwu1iV5hRAjlN9IPPXgM3qgz8M64+QzddAhB+nMC09Xv9ee1JlnFSq6yeLss882jilhYcabNc81M/7cD7aCezvo/gqq2iC7sCdoEqAC/KpWbyvDX7y4pzSgPGOHcSwssCnMM+Y2yiqKL2TYgutGKcYRYJyZs/ycHqLYSofU4AilQ5nhxenf66mpIxL6m4DPp3ZVG2jgvmcrI5D2j4ajY6mL0cLRsdTFbdnDkGvlmrxhazY2TpPguvDSvcrj7rvvXurmTU4bBJIXeWkoKFw/Cgtf8yK5HWUJQ33iiSduRRoiAWkgCd4SPshGtHAaaoINf6cC8tlOO+00s1lDQBiHnREoSbHIJl/bYgvAhovSFatK3fYOjQRzgdAvyhkbNs+PnMloiiPzEtWNkCIkhL6TiYYWUZhQ57g3VEFCrbwXxV7JgNxO5gqEmuuCqFlVHxU/2tGC3lQEwu84Ssxt3gvlEmeJwiA7vqwVbAZrC2eHsacwCCLDmBJqJccZAmmBA4cqyTVAJlFkrcJMfiG/ixIaLdWFYiBSSSB3jE9k+D1ZkJtIZb4tPGIcUAE5SQdizQlHoeqr9M7cPkoVh9e9Sh2qxt+QHlLO/OW+OZfcYnnuXI2Y9aZ+mT5M6eV9SvOla/fmndS2ysFqXelAffXFcEPaGW9bvU9VOXMVW+oOPEgNjlA6lAmmrFmkE78dkNTfolRe0upAXb7rQWX+NGz/wWjq4pxVS7WmeVVldWqmQKXyZrMLbcxVYOZy1Zm7Uc2q1N6KNGLEElFYUgFFHpF5j4QYAdflzXvkjFs2u3iAKmhJJAoEmxyEgA0RRQlCyeaBkkrIi40unnw3FExCSBA83oMqSlvZa4GSS54UY4gqUFZhWTZblCzIE7lyhLQcioNN0x6BGY14ehU3VDZLOO3chyQRJmSekOZApSzzMBpQ1di4eS7kE/J1MoAskCoBuWGek6sLOUsm5w0SSBENahtODo4kBTEou4yLrQhmLUQ7j5r8PApWCGnbM76JXnBvKPnkGRMOpnDF9mplvCB5XC/khWtHncfhIj0A9Z9zzCFGtByCbDJe2CwKt1AHUc4gh7GcL8gd92TTAiDxEFN7FGQqijgKK9dGaosFBBrnEqfz5Lv31i6HpCuQnnzEJRQKa9mEoHbb2NuMVTwV+VRqk+pC1TxjPXfjRH237E0tyJlscjM5mciCjCtyOzP92Wpf5TBde8STatqohXE+AeFx7Cf5taRmOCQPRygdygR9fxukT+f/XixfMhFUzcjWyEOvU4Y/LalwdKyCFwo3bM+4onB0+9bKPLazNjapYnqjhX1bq6bBcFj71Gyq63Y7RLtVSS4kmwjYWAjdePMeUTgABtMbtuZfFI54wUZJGNySyClTppjQNe/BxsVGZ5PvIZTkdRHeImcs3h5+EAc8fsgGCgt5l9HO9UVxor8c9xdJNlMFKhbkF/LBJk2unGteHD9Q6YqcLU+xEE4HBMW7jiBIqJjRQurMI3LSmDsQqlSqq1HaUFNZC8xj5k1pjhPzAJIQrf0OpBpwbTg1/J8wKCSM8DLEMRahoeCI38OpQzFEOUSx5fcJxaPU8l58Dr/DeKHKQgZthTdrm7QT1E3UMOYr5Js8VJRGxpufE5IntQQCTcETKSSx1iIFKPwOL8Yf5R8lkeeQSi42oBqa9+B6LcifZG0R8j72rjba89gGCqSlVtSyZkZYjx8/3MwrCDJV5oS0o0V7mAdEIWhjRoh7wuov9eXifqbMx0skowGyGdhYUfcc8YnG/jCxyFEmRYEQf2QLKofE4AilQ8pYuzlHXb98TPnhKH3HEsDjnU7QYfXbblUZW9JRgN4wnjccHSskPS+4Xhf9/IY2FOQZ0lgS/D5CJgE92flEdatTukIXL9ho2CCs6siL/7PpQMLwlr0Ekg0jUUWGsWPzsiRy5syZZiO2VaeoM5BICCRjTJiMzQ3VhTFMBDQ7p+CC9yLEh3IVDTw7jnFD3UD12BbgvlEv2NzZjCEB2+rIuP86UJAhSqhytOjhuTJ/YoXUIUbeU1xQuCncilalziuawxEJQtKopShRzGfbJso2+44WoranNgGcpmhqI8f6saYIp9PPkDA4IdySron75O8IlWN36HvISTionPbkFVr7QIBRyFEjCVGj9AFIEKoap82wXggdE25l/XgjALwHZPfGG280c9gWkUQD4406CrHFuYb8YU9w6lAobRudZEEhEGsJFRdHlBxO7h8bQTSi8oHLVLHNppQUStAou516ZF9n7hWSSEcA7gXnFnJJ3qt9NjZlhl6gdTsH9OnCRxP6LEjlspkblDOspZ7vtyWqhuqOaoljb1MhHBKDI5QOKePDueN014QhSdT4eSeiVHeDX81/LB6e9vbuw8BENuv2fl1aOHrOhhU6+dsXtalgc9wNtaFxVKoP3O9sdazeOOH7wuCjrnjD1hgs1CA2SjYjb94jVdDJnuzBJmsbFKMeoM6ibrIJEs5ko2WDQ6XlZ2xE5EhBJDk9JlHSCoEkp5LPIq+SfLJop9BYoDgwDoTct/VZ2bQ3YiPi/tkkGGeH+MDzQeElZ5E8XPJgKXoqaX4wzyGcVNvTs5EWLcw3L/FkzjFnvGQvVpU6L+Yn65m/QfFkzljSiGJqG+nzexCASNKIkxRPkRbED7URsso9xwrjc4+0qYF84uRxTeSTQixx0CB9rG+uk3HAcQL8LqSSoiJIJZ8B6YTIEvqOVNEpxmFN8rs4Q5CrWGMP0UYpxlm0uZ5EHLgGck2TrV5mbHFCSTcg3I3zCam0xXkWR97QRvuc2VD+FBTKUDCsKV8v06RXC8w844UzggoMubS5jb169TJknFxRIiATp43WCzPPVyhaA/VSQCBt7IcL9MJlX5vPsoVmOPPYSOzo9kpt+i/BEUqHlPHcn6P0v+nfqSDJcLdF/vwVyn7ph5jqYqrV0SeO+p+mrVtSqjIZLcezSkY5jYgjJE+eWWTeI7lUdmPxtuwhN6q0ApfSQE4iChIkko2Kz2fjYjMl7AY5wLNno2bzYWNDvSCkzaafLLGD9KMSQBrI+2LTKykUiaoBoSQcnWwvwEQBkSevko2RTRry6xAbKIwQIcYK4kThDeSptLQByAfzidw/SCUqdTQCxFxlvkQqmzwnnhHz00s4I2G7J6Bys3aYd5BAvpdq1wTC+sxPHD0IC4psNELZ++CTterPDWpct4lJI2nSvLEWbZqrR157QN0OLjx1hb/HiSFsjc1izbHeyYeE9BEiJ9+RNRoNONEQOFRHiI097jEaWPuE2SHUhNotWOO8PyHckp4bYw8550Xaiv2X9e0Fc4DcZz4Lsk5YHgd22JiPVPHImUoV3z6xRMNfmVj0/Jk/3BMFUNguoiqowNgzAPG7+vljtajCr6WGuWMhPzeo4BeddHffLZXzkFfGGyJOeo5DYnCE0iFlPDnla70646eUCWV2TkhnLK1uwilUYfIvL5LTU8UfqxfqlO9eTOk9Hu3YW0c02L2Y4ccAeVv2sEECKo4j8x5TOf7NCxQIkvAhkRA1CCukG3UTFYHrsFXfbJBsEHw2IR02ftsLMllw7BqhcQgCrUxKM7yME9eC2oXqsD2bCJMjxz3Tg5DwLblqLq+yOJg/nGhD7h1KEISQwpF48u9wYCDt9AKkGArFOxaYm6iLFLV4Q9SQSdt2i7VuFTfb/gp1mRxjFE5vey7U51hV6vw/0eb/OGA4HZA9TlSxR0JuzsvXFy9+rU+e+UKLZixRSCH5ff6i8L45WzstrPnBGWq4Xy1dcvXFRU4TyicE3Ya+iT6gTNojHKOBNWuP5kQ1K2m9EKZHIaUQiBCwBYSI4hnG0JJGSxjt14ynvQccWwicPd0KuwbhJ08Rwo59g/DzQjWELEOQeQZXfbK/MqrnF4ZzkkCmv4KuavmWNufmm1O4SAFAgcTOeY9QZG5gV7GxNWvV0EUftVf5asmriOFQWF8/OVuf9RtfbI+h+IrcV64FtdQhfjhC6VAm7YL6/TkyYeUvEjl/LdTsG1/a6vtsLmwylmB6yab3/yUpZLeNH6QhC5IvGkKlbJZRVYfNzSgikHjLeNQYI7x3L4FkQytL4sSGSkgZEgkpQ+lAgcDg8zVKBRsRmy+kgI0EBYIcLAgVlaiphnC4V4gkeYm2qpUE+tLA5slZx+SJEn7f3mAzgvRS2cvGy4bIRrizgzlFwQhkEuJGKx5e8arWFGeQ28aGj2PDvOdrCGK03EbbJ5N1wfqIltvIOoc0ckwnOXuEkm1uoD3PPlaVOv96T6NB0SzpeEt+HrlGrZMEoYRU33/3A7rvxCc16QeUMV+xHNFIoJRlVczSTznDpApBc+3YJlRZPg/CioODml9SaggpBuRaogASco6mllowp8lHpoAO8moJI5/B+HkBaURZhDjaf+3XEDWUVXIkyQtFGSTtgfUNscJ+8HxxVrEj5E9SvELR1JSNIzV08TNJh7tbpx+i43ct3gaKZw5Bxt6h9kLGUW2Zs4xLk70q6Zz/JXb6TzRCuejPdVo7uGkxJZdnzP2SgwppTrZP7s4IRygdUsZPy2bqwp/fSHEiShWmLNPKV4YbLxjD4QWqEpuKJUWQp8ijzDCY0QhnnXp19VjFWQqmlOVZiFmX9FPruo2L5T0SgiupSbSpsl68VJ/8PkWL161XTn6+KmdlatfaNXVC+7aqXbFC1L+z52ZjVGnFw5hQMcvnovphcNmkIZYQNUJeVHryNTlYtPwhr7QswEZOFTfvT5gRFSceUoZBppobZRCF8J8Eqi5hftQiNqlUqo//zYA8ogJRqQvJQYlDlYy3cwDzGYWKv2OTh8ywZiGNzA82fAAxjUYaITElFb+QV0izaXJgcZSs6l8aIJwopiX14sRuWHB9scgmhOyWG2/Vflk9lZabFfN4w62uAfUy4NMYjdT60FpzTdwHIWiKbPg/6zpWqgvPA5WQimPWPiFmnhUEi7GFLE6fMU1zlkzXgiVzNHb0eK1YsE55GwuKkUaeJXnEKG2E8hlzUmGiEWieJSSW98YBhUjSwgiFk5/hLPD52BXmCa19vOpvMJyvt+f00cKcqQmFnznPe+2SXL101jg9+XC/mNXVOCkolpwgRMoM6HHh7up2dYO/zypPHjlrC3TvvsONvcSJsPOS54CzznzFzrqoRnxwhNIhZYTCIR06/BktylmT0vt80u1Staxcu2jTI+xCXzfUQMJkePreIh0AwcS4ESIiXwnVgcVP5TIkiI1uowrU6vUbVRZ4Za8ztFfd5nFvvJ/8MUWvjv5Nfy5broDfr6DNEfpbqQGHtGymi/bprHb16hSdmw2JZEPAmEJaUSkw6qiUhLAgzRBL7pMmvYTSMPQYRjahsjyGkA2FUCbXAongmL141Fc2T0goGygh0R0hyZ1NmeIJyDcbFJv9zgLmI/MKwsD9kx9JniS5vdEQq9k3yqQtiGGe8ffRiCOkJlGV3rbmQdHmyE42dnLnyur+eb+Sjre0bYVAm0Bn1Qk1KgxpJ/I5Cis3vEnjMr5RMBw0FeEQISq7cWJwsqIBB5n1i7OD8kjLJQr4cAoJT1eum6W9TmqovU9upHKV0oupfJvnVlSvdpeqQ4Ou5plwr5B9WhFRyR4Jnh9EldODyJeEdFLNzZqFRJIiQh9c0lR4HtgYCvuwxRbr8ldobf5SbQ7lmGPRRi57WSvz5sdFKqm0zlIltVt3hh69u5+xa6ii2BlILqH+yBd5ruwBiATNe5bTIdc2S/p0HotAOEM3tx1sbBOpQKi0dj1AYmmbxBphzTiUDkcoHcoE5FA+Nnm4MaaJIhwMKWfaAtX5dKoJv9E2IxYgmoRzUZsISRB2ppjAe1Y2gGARxsGrbtG5vUZ32/qs6WRw4PSw2lesa7x9q4CycUbmm20OBtXns2H6dPKfwuaFShgW+l6G2ACmTtSYd98yCg9EjPAs90sPODYWFBV79BubLQae5HRC2lQ/lnV7HDYlCCTtTTC4bIqEuuIFFbCEDUsL221voPSSd0YRCeF41JlUjiH8NwBShkJMyJIwJfeMAmObfUcLUUOybIgXNRolHIcHMkreJBstyldZOQqsa5Qx8hhpMI0jxTWSJ7g9wL2i+EMs//xjul6/cJAJiyaLGeUmquPh7QxJgaSRw0zKCM8hMp+Rf71KLGk05C7iSB91zOE66NqGyqs5Xz5yN6MRNprp+sKqntFAxzfsqxqZjYp6eHpP5MEhZ11SAQ7RRbHHsRg7dqy5RtIVSDvgexBJCDAED+fr0ksv1chvRmhD+XmaG/hZ67PmR4yflL/Op/RKIVNFjVIb7ezuQJpfM39ZofdunqgNKzZv9Tuk0yASkMJkX6TxMIche9xXuVbrVH7/Le2hkkX5tKr65OJFhjxjF5jfhL9J5QCkHrBWUMqxySAUDmpRzjRtLFitYLhAWYEKqpPVXNlpieXs/hfhCKVDmWBVznp1H/KI8tJ88gUSVMfCYc27522VX7TehKy8G168gHiRM4SiSf888vXw6lHH/OUytOs7t6ossKTvG1ozZc5W1ahsuEUEs04dLWrWWgsSOJ+czQw155D0sFqm+024CwPKhkAYis0FlY+qT4ijPU87kTFKBGysGFCIBaScz4VExwueI6Fx1EA2ox0NjDfJ94Qhydej0Cja8YH/djBnIDCo3SgwEEEU/FjNvgm3RlMbUb0oNEGpGjBggEmnKEuQbwiBJGTLXINQsaZ4Pihn2xvvPTJYL/d5K2lCSdRmjVZoRqUJxhFkjIkmeME9Ep62+Yw4ydgs7t/2nu15eHftcXmaqjZNi8tZR/lL82XomBq36bn73zANu1H/cD5RHYl+QJxQHiFqEFnWKnYGx5gID88a4mmVQZtaVKtZBZ31XEdVa5BdRAwjYb+fsyao9MyA0jwmcHNOgZaMlr58fqJWzskx6im5ipY0co04ethuCC8nA1mF2yrXRBT4+fLNc3TVx7HzUOMBY9WsQidl/9HZEEgcd1ItGCPOfKdjAXaCiA/P5cexozRPozVu9RBtKCjs3GHhV0CtKx+ojlWPVr1yrbZr4eGOBEcoHcpkM8DT/WHGH2r6yAUK+sLyxXGkniVRt7Q5VIs++s6EZmweFwsY1Q0VxFYeJgO8a7z8C6d/ovWBIHHmpN8rlJev2Rc8rbz1hRswrVW4NogWmwaGGE93Vka21rdJguiFwwqHQpr71EPap22borY8tAPCwKNYQiIJT+HFx4OlOes0ec0irc/PNWel18isoD2rNzK9NWOBDQjiQVgM4sqmlGgIHePP+0BadhSiFgxtVEGIJtN+pfmrKODPMqSduYsCwjhvK4K+PYCTY5t9kwMIgUD9iuwdWFKz72hKLaSTDRf1hp6jhCbL+rqZ01wzShlrCvIFoYTo83y2N87Y5TItnVt4zGkq+MU/TP7yhXmANk3AAgJv26Kh8pInDWEiCoE9Sc9I07j0N5TZYFNUtS8WCIHnbShQ/5N/0qr5xXPRI8G8x35hyyCTXlXQ+0qvmauZdQYpkOGL61oga+UClVT+9866+Ya+mjF1lvbbq5u6HtDN5O5ypCbKLWp0//79TTQJQF5xgHD2KHSkNRSRKAqFAHMDgsdrU6cftSo0L6momMWMN7N09mHXmEgMa4D5zcEIEEo+gwI+ntsZt/XQoTc1UyDgi/l5PgUUVlDNK+ylXg1uVoY/fkHhvwJHKB1SAiESNhu8SyoEb37iftW97RSlV61gyGKspW6ONwyGtPa1kfrpmbeMAkduFiEhjAcqJZsLBI3cI0IPiShkkbh35Ht6d92UpAklYfnQLzO06IXPjNdO8jbXDClmE8foQLp2oyVP79OVl55cGDAcCmrNj99pxZdDijYdigQIbRNy9IbaTcFRnTpbhdu5pl+Wz9Lbs0dr1JLpWzVxr5lVUaft0lnHN9pTNbIqFPs7kvipGoVY0AaG0FeiQGlhU6RdSlkrWYkiGMrVik1faOG617Rx82TPT3yqmnWA6lU6U+uWNVbv3iea9AnCq8nc8/YEFa/RQtTeZt+AZ0jIsmfPnqZtUyLNvi1Q/FEmmWvk9KXi3MUCdoNiD0KznIwCyJ+GUBCi59/tCQjuYeknmxBuqmh+Yh35a4TMmoCYo8KSm8ozxI5EKy60aH1QLZ35bJLHk4Z8WjYhrKfOHGrmge1Dizppz/uGzMXTymxd/nINnHWlcvLX4YvFDUilL6ec7uw2SDnrNpv0FxRuFEbbUJ6m6dhNUp0Ic5PKw8sSSNR0Igg4fvRIZR+wGDXzff2cl9zZ2zzbgvV+vXn2dP01/S9D6kk5IL+VNUP+JOSesXvi0+s1q9zXRQJIPPddK6upzmjy8E5HKh2hdEgaKAooWYRgSfBmAaJWNm7ZTLe894LemzdOczauLCxAMSe5hEw4vEJapk5s0lGHVmmuo/c72JAi8uzw0vHk2WB4EZbBmEBM+D5khxBYIv3lSCLHI/7y25Fq9doN8qWVrpzGwswrn1Pe/C2qBYaQzce2QTHHddVvqDktUjuVJZSbq0pDP9FurVoa4kpIigIjXnztVZsA428JZo2G9bTgoMZaXTkgf9jsKzHbIHG05N0djtGxjTqY54byBKknhwrDzyaUKCA0GGSKhjDK/2ToZ/H6dzV71cMKhsmvZSeMzD1jLgSVGairxhXv1o1XvWryp2gbQ7HCP5lXyTOmgCgacWQOWPCsrLqIqk+uF+sIheXqq6+O63jDWCC0jZLEyTf2GMGyBqF4nEeiExAGCz4PZZLUi7Jo8URecrRCD5RQitzsST6ssRVLV6rlotRa0lgsrTVL/jpBQ1ZYY6SvUGTjVf9wBMhTxk5BnolG8LsrWn4j1VirEoIJJd9zQUgPHzxKG1bmGUcCEomzlKhT8NXi/vpt9dDkGoiHpa+enK5RL80oClvb43Kx+YSZUSrtKT/YHAphUAe5Zuw9+wy2lmeDkonNZbxuue0mXfxuJ1OsZNqEJIiP+v6hSV8sN846KQnk8BL5Ia8a8guufvh0dbwk8T7IPvnVtPyeOrHR3TtV+NsRSoekgHpFvgveLoaCCmM8TwgFIQoWKR7d+FXz9OfaJfpzzkw991Q/PXBzX53dpaeyAulFhI+ebCR8e893Rp1ErUQBZXNkwdN4mbwj/s9GV1LY1xJJDBa5fBDf15f+pkpH75X4udihkFoFK+reXQ831wXZouKQDd+egmNR59SzVaF127hC/iXhiV6H66g2hecWe4ExZZO1BBNl2H49f+Uy/dW9gYKVy8WXx4qb7vOpzazN+vTWJ4xSQgsYQr/xNLWOBkgBjZvx9Gmn9E9hzuonNH/tc3H+dqHL06rGY3p34BxDKCkMI9xqQ3HbCrbZt33Zpt+Rzb6jhajZcCG9VN3jgLFGIJFUCKdSoAX5YlMl7Mg6499tQa4hcbSUoqUO6qQ3rYI59MgjjxjVOBoRTPTlbRdUEogIlMsqp84beiRc3R0ND33VVx17tDchZYoHsUuolBY4yuS2QvJIEbFYlbdQ/5t5YUqfTeh7xLMzNPqtxSalAKfD2x6JayptnecFN+mZ6aepILx18UxcCEtrl+bqurbv6JNPBhmiRmTHnsTDfbPWsOXsI1wPeYzYa+tY4SizTnB4meeolDir7D99H7xBH624XXnBjQkR3s7VjlWznB6m6wEv8u6tQMA1sAZOOKG3OvfxKde/NulMqTOaPKqG2akdJPFvgiOUDgmBBUd4iqIZWlzQ3oOQNJsviz8yLGGBAcGQkSeEIuEFOTQkYKNKeI/Hg5zyXjSl5jgsVCMUJIo8MDIQRkind7OLJJKQT8jfE088Icqtuw24VctrpMeddYOSl7k6R+MveUJ39elrrgdCisGhFyN5ahgkVCMMUd2Lr1Z67eRD84WfKZ23ZzvddFj3uP+Ghu1nfj9Qk9YsTLjBPMR//v3vaMPYvwo/3+83eXbRwuuR//eSekJ6qMqoCvSd/KdAeHvWqnuT+Eu/2tZ+Vb+PzjfzEHUPco1zlAribfbNRhur2XdkDivzj6pclD3ybFmLd955p/ndVIBSRO4yPQhx8CCU8c4hHJJ4CR7KIPlqrHHGl38jf6ckMF6RVcDWDkDEeT8INkof4WVbrQ5hRCGEXEFmsBEcBkBKAKq6Heczm16uJXMKlbRU8PqMZ5VeKVDkmER2PMBJxgnARnn7oo5ZOVgjlg5IKT/QkLk5IT3W62vTYgwbTNi76IQfn8/cc6xenMzHKZtG6Ksl/ZUqXr14jKb/sMI8I+Y0eZIQSUitBc4xhJM2ZSipNN1HvcX2k9eITeFZMpZ0aCCn3JLvd+f1NS2MCp3DWDmOhRXys4YG9cI1XxTrLYk6DaGlPRB7HPOg9YF1dXr/5HvV+hVQq0r76dgG/2z/3e0JRygd4gYGGgLHJot6wKkaEDXUDMgFBgiSFU3NYLOBfNAOhKa9XmDgMCCoFCiAGBwvUAT5GwwOn0tIhI2UNjaoYHitGEaq8iyR5OcoH/Q1Ix+LjYQN+LgTeuvuiUP0ybwJpjAl5sk5VHf6fdqrWmP163Kqnnr4MUMmCcFTgcm1QiL5XCqZUWhRHg7u/7JWFxQ2dk4W4YICrf7xW60fNdwoTfTXhCiwCVLgwuZpN1H79cz0Teq39rfkPi8UVt208nqwdrdiiqf3a/v/yHA7+XiWXFJlz0bOZsFG4SWfhEu3R+hnc3ClRs/fT2EVv8744FNmWj11rv+N5s9fYJ4rqjuhX1q+lATmMPMhGmksi2bf3s9h7uEokWfGvGOjZc4nCp6ll8DhEKDOch8QSchFIipg5NyIBEqrJYAQSl5EOCJDwLwIaTK3cF7t93DYIIjMQ8gRJN223UHttJ0XsDPe6mnvyTBe0lgS3rz/A712x/uxuElcVd7NOjXWgDFPGOUR5R9A1MlpBZAjrotKZ1KGvPh+2Zv6acV7Cik1W7J+SYEe7D7ckFjsiC3Qwh6zVsmpJMSOI8Hz4Jq8OPvZvdSyazX5Uuj3GMwPqcqqNjq2xbWGsDFvscmx5jfEjub2PG9INmk42Fz2FoguzxoSjsBgFVZ6YU5aM1JjVg3Wqs0LDHmkGT3PwRQRhfxqV627Cv6qqeMOOssQ1GjHX1J5TvQNYWRO7S9UfTdf1Gr2eOGTX1e2fMO0J9oZ4AilQ1xABaEHISE5vMNevXoZtZGCHCpjIRN42ZFk0AvIEWSDkFwk2JAgZBA/QuaR53dj9Pg7FFEIJQaYXBw2PttsFxKDkYFEUkAACcBgorZxrVQMAhuKf2f2GA1bNMWQSlJwTD5kAE1S2qNCPQ3p86SuOeJkderYyaiQEFhINUYMRYj3J+cJ1QEjyO9UPutCZdVNTSUKB4NaOeJLrf52hPGiuS6rKvB/XhAUS1JAoztOV/n2u6QUaj9xZXW1yKwWlbDyL8+E5xSNcBIy4rlBfNmUIhvQs8l7Fc5Y6iebXiqnUsxf+z/NWf1YTJUiHrSt/YqqljvAhElJxWCDYQNjE2LMozX75mU3YwgL5B+SVxbNvi3IJUP9ZZxRnLg2nLhYBM/b+iXaK7LqOBLkYsaq+k30xfyxz9WePx2taAs1F8JAGgxkgjG0pJE8RDvnmU8ojJGEMRHSGA3YC0Kujz34uFqv7CJ/IlUoEbiw32k66fLjjKNL2gCEjabl2E6AU/Dkk08aJxhVlZA4dpb79beer+ZHZimQlpoTtnLeRj1++HdJ//0Fr+ylpnul1qUBQjl95Fr9+OwyYz9xWHi2PEPsvX1Bdu3XkF4KslBUAXOI/FMIJek0FOlgK+hCwfO2f5uWnqZw1TUqqLRGfy0bL1+VjapQI9O0MMoIZCkzVFEzv9moV+/5Qi8+96rZE7yfiy1jH6JtUfiIn7Q5VHKVfDw4oeEdalGxi3YGOELpUCpoqo0XjZGmR9cee+xhiCUKIAohGxzhiSuvvLLE92FzOOKIIwrDz1GAGsRGSbiRzcZuvJCpFXkbtGbzJv3888/qe91NWjV3kdlQSKSGSGIMSK6nupgkfkLR/D0bE6G1WNWMK3I36IdlMzR4+FB9NXyY+j38uNpVqKPfR/1svGmIAoAMoAbx70033WQ2R0IuVG9i9PCgyfGZXqeRlpevBKtIaWa1XDhbBzUtrDyErOPVe4sxvKjXtoWq3HtqSi2RILHrfpyihU98XOLvQaYjiSbfg1BCCnm+fB8yAhFmY4C4QM7YTKwSQu4pDoEN+Vowx9go4iGfkYpeOBzU6AVdtTm4JOlxoFCnWrmuqpx/R1FOI0UDFLtwnyg73mbf0dRG5iW/y+9x36nm/1k1z+tARL3yQCAposfGzZpkk0cZRJm0z7CswWexJsmRI9oRrbm3vU/WNHmi0c6ejpYGkAogkjT8xiGlswREt9HGVvrxgzEKJdqL0iflhDbqhd8fUX5BvkkJ4jkyn7ARjCuqNQrrVn9KZ4xwWPuc3lhH3tI65ZNg6In4zAnfmVQUUoWYv/ZlFUrWJf96X8xb8+8eo6Waa1ImlKG5tbTpp3pmzWPbsRMQQYh0tBdKNLada2RMmNusedYVP7dNyJkrVqXk+9icjsc3UPfLm6tKnXJb9cvkWZoC0YKwfvt0ob549E/TYika7vvjsJTHHxxZ7zq1q1IYnv+vwxFKhxJBeJvKPHKMIJMsajY3yCQGHUMJqaRaszQDT+UeGwFqXiyQI8lGY9q3nH2mvlg4SW/O+lXT1xUnU7lzl2nV57+qyRq/hnz0iXlf8pFQcFA5ANeNksnGVBpQnyCQEGfUTAwq94zhp5UJ+Z0oJ6izGES7GeDNojpBqjnWrW6HPVXhxOhn0saLgo0bNPvhu0mUM2SZ6nlCkRAoCA6FCoSB2Jz5f17rOmpw3fFKFTUzK2po18uK1C2rcJX2NW0+CEFSYMFG5f0d71F2scB98WKjRS2wjgSbhe3fxwYS2UwexRRHgZwq5mWbPSrpyPN+TXkcgsGwurecJT6OjYyNj4bbOCz8H6WE5xKrctirEJZGAi0xj/YCqDE4WpBXHBpSLiJPEbEvFJ9E1E/Gk9QQUkYgUChzyRZjRYLNnfXiJYzcByqrNzTO50WGp7kPUlywKTiI2xKsc0skWb98LnYABzEvJ0/Xd7tTf42fHf9Z3uGQwr6Qfg2P0Cat34oo2lxPb14n8x4nBNJHPif2tGHrGhrpeySleyOVpdyc1pr22SYTRcExTRSDFzysqeu+T67C21MctH/tU9S11tnmnlmrRHgovIoEcwNbTMiZtYYNJqcSUo6SyzxF1SUdgvVF7j0RBPYMzuL+ZcPbGrt6cHzXVRBW7iqf9vddKl9eIVG1fYtppn//74fLl1ptpcEx9W9Sm8rdtDPAEUqHqGDhk69IiJo+dCxaNnAWPN4luY5425AJyI03uToWaAOC909vu5JAYvZHc8ap0WW9lBsuiJ5m/fc3wpvzte7d79Wr7u4mP5MNnGtkg8XgEFoj9xEjFgk8XIwVoWrynPhbCCIbNy82OYweeVz2DF7GgK/5XfKA2JQhlGxEVFKisB750huavXJ1UkFX7rX5prUa99ILWymSKHOot5BLb0ufF/8YqadmJR/WssgOZGjMUX0S+hsUY/LgIPMY90gwPpDBRElqtK8jT+6IxJ77ltNTb9VTWeDIDrO1fu3Wm6glBpBYiGYqYWBIajQnjDXCvKNYjY0T0sc8LkvFkGfCnGXu0wMQRyzRULyXNEYeJcj3LZmGNELQuC+eI+sRhxTyGE1ptDmHOHPJtK6Kl0iSG8u9QyQhJKxznikRBxt+nv3XHP06YJI2Lcoz67mkym9IV4EvX4tq/6UZS6aZ9UpaiCWOAOKI/SD0jZ0j2kHaQrR58M7cPpq78fekyRzq3EMHfaO8dYWRAiJNRJfihcnXHf+qJpX7QKnipNoPqln1wpQjUpIYY3LjvUCRhGhyuhP/IirgwFMkxrVg38lxZO3wM1vciQhB+scR17XVHqdUS3iMygWr6Yp2LykzkF1M/DjgvgxlV0u9u8GpjR5Qkwr/3gMTEoEjlA5bAVWIkwNYwBhZqqatwYPMEN623+cUldIKFixItCb3xTatjYXnpnyj/n99G3cjWbDsnVFa/eEPRsmBJJLXCcmhGp37wRBhvFG7MOaEMWk9AeHhiEE2NsLkbIJsNqixKKmWaEIkIc1smCYktc8+Rs1ELWQMCPcTNkR9GPTHFN005KuEZxbRlcy0NH11ybmq6PeZJHQ2fIowbC6RBZ/DNXFvWQfuprqXHpVy0Uul9Cz9fMQtCREKVEkb8k4l9zERsDmifEaSzlyNU4VdXiiTz8id+agqlq+7VXiYuUDeLso3BJpnHo8CHg+4D3LtUGiYY5A8eq/yuWUJ5hL50Mxd5jiOUGmkMdrZ05Gk0eY0RoanKbqBFLMWUR3JgS4J5EmTs8paLcs5xRxBZYZIQlRIv7A5l0RdIJGQXi9Qg+vXq6/62kWBRdkqWEex3t8OLXnXFH34/MoPb9ZCzdI8zVBWpQzj9EAYIe6kEeB0c045+ZTYFEL72MGS5s7gXwdqSsUPky4GaVVxf017S0bRs70fye2lmBICFiuixDxkfFCsJ/4xQbd9d4jKVU6OWBFiXvznOr15wWRDElk7RIDYR1BpiUxgw5gbKOWkOBABIjJGOyzmqje1hWpsnCuKmzg1jA4gPKNfp43QyODjyV1jMKw25Q7RAVXPMUfeIp6Q4tLzuhba94zGKRXlZAUq6qqWbyrgKxsbsaPjn+vc67BDAoOKOgdBwPMjbGzBJopxQj1hIVMF6/15acBjj5UHaPHJvN8MmQSJEKRap3ZTaO0madwcozhghCCQVqFkk0ZxhYxgSAkdQjjZTFEvMWIQSu4HQspGAMlEiUJl4P8YLsJjEEl7RCSAXEIu2Ghpn9SrbWtNWrxUr4+dEPf10xMyFA5r02efqOW9t23VNoVr5p7Y4DHA3IdtBpy2ZmPqFdThsNJyg2bs4u29SFsZwpiE3rcXmbRkmmfhbbTNvPpxzASVFfU65OCj5fNtbR4hAKgjKNk4SKjWFGt550Oi4JlCOiAbEBtOD6FgY1v0wPTmQ6MQoVjx+RCcSMLIv94KdUsaIYmsGy95hDTGIiisJ8gCamBpZBKQToIyGe+cgnwTbYAQ2hfqovdriEjkmsL5xClDKSb3lXvghT1gPZHHx7jYNJOpi39SOBxQ7WADZfqzzN+u3bhGq8MrVLd9dc2bOt2MF+FzojD2rHgUSELZ/D4q3PDhw01edywyCRmFgD/2+KO66u3uqt02I6H2QRCkcunl1K322TrulrrGDrJWuC+uD1sFoUPhwy5C4gDXBomkGwYOGwWXPLfspsv188r3k1JKyUGcMWyTEShYN4wJObTMOaIbKPDnnnuusSOEmREqeO4ULtH5IzJPGqceQko+KPcAseTr/DaT5VtbePRhwtcY8GnimmE6qd3Nys8p/HscyCmfr9IB5+yiZOGTX3tWPWKnIZPAKZQORcBwYkTwHFHxUO4sUMsgYeSwQLDs+aqJbHos/AsuuMAQomjGNKdgs/b/4hHlhvITLzAJh5XpT1fdV8boi0GfGlJMaIm8G64VEoJBZXOB2LJ5E+Zig0WlQY1lw8HwolryNRsOmy9qDoYQso3R9bZFQkWBzLBpYhD5e3Ie8zZv1oRAlpbXro+bXmKRDo3T/eGwWi6ao2aZaWaDtEnneOhssBA9wLix+VExz3MwG75favnqDQpkp5D/Fgpr2bujtPKD7004krQGckchHNHIKjmT5HpB2Bmb7Q3GBRXBvpi7aenS4DHNVDGlA138qpzZSe3qvl3qb7ImSAdhA4QgkO6QCJhn5OayiaKcofSj+m+LMC8bOMoc6hTkl4IyxtCGp21eo83ni1Y9jYOVqOMAMaUTAkQStT0ex4eCHaIENjrA+opGEr1feyvWIbaojlwvax5iyDpnTdOyB4JlbRutkiCLRaRx6lRTPGPfD7JJMSFz3f7Li3EhKoHtwJ4xbqwZnFJSCXie5IvSa5EiM5wOiCVkkbHkZ9HGgk4Z2CWu4d5779WV116m9+ffrsW50+MilXRB25xToO8fXq2vPxhd9Bk8b+6FyAzrlSgTYwfIQ0YFZx4wXthoXlyvbW7++uzrtHLzgsRIZdinBRPW64VzftBxvY43YgRkGkcUOwpZZJxp7E6Ux4bjUQnZh0gpKqkHLDYIlfKH0aN0+w89Usp3xOYOufdPtcw80CipkF6u6fvg82q2V3X5k6i298mnS1u8osrptbSzwBFKBwOqldkcMcKEWAmNeBcuigwGlTYNeJve9hfxgveFoLEBYPC9QOW64Z1ntfzAJimpbZ0W+PTNwy8bRQKwcRDewUBB9tjgCH9DNCFnbLQoL2yobF5s5lwjBgW1gipkNjQ2JEIwGDgMM9/jFdm3DXD95IzxymzaXKvrNNSyjEwTIoM8simb5ujhkEKojVMnqXW4QNPHjTEbkX0PNnaUDZusz4vNyEvGuWZT+f7TB1rWvHJ8J+REQyisp+oeogVTZ5ixITSJAsoGQz4b5JJNiT6KgGdPHi0bsP3etoQ9VtC+eI6AOcmmbV8bAm9oycaX5OPcySSRteEGdW5bePRaaYCU4bzY+cFmFM/mxcZKfjL5YsxNVH+ecypgDscKTzOvbFGTlzRGC0+XldqMykWYF8LF+o6cJ3zf5it6ySGREFukxc+9hU18zyqJ2Cr7tff/EGb+BkWMUCqtYCikIucbBdgSR++Y4Bh7CaN9xVJeWfd8Hs8OEgkgjdhQ1gbvi43E5tBwHqWStYQTyHplXCKfHWohv8vnEh2yjc7zQ3kauvgZTV77TVFz7mhNtOlZWS2jgX55Zq1e7fe+IfHYdUChEQ49Y4FtgbCiPr7zzjtFzoQtOKNlTuQpV+vzV+jNOTeb5uHxkEoKghZN2aCpAwNas3y9mZc8O54JBBZxAqeBscWeIlSgnKKWsp5wolkbpe0FrKV+g/tqQ4vxKe0bEPE541fp4jb9TRoPY8KYvfTus7ri/f1UriKHYSRmUw6pfZE6V4+dTvJfhCOUDibMwWKmopKQrTeUyKZAU1zUMrxbDAGFIZGNeOMBmwoqjjc5nO+hyuCVtu5/lfz1quLYJgXIWv7i1er4/Qp1PfBAo/5QNAShtCfxoCiwydriCm+7FZQM7j2SJPK7GEHIJ+OBgkLohY3Lnihjv+Y9STrnvgijU4iEMf12/G96+tMvtCI3VxUqV9Ga5cuUs3CB1v8+XuHNm824QGIteaS6MbIXZ0mYtW65jh75bFKtg+jBmTd+puY/8oEh2yitfDYhUcglz4YNGCLLXKCtDPdmN9BtATNmHgJpiTZqhiWPEATGHrCBswk/9mQfPftxVlLtPpgO69dIvTrP1AknnGwUInM+eylAdSL8jQLIXEMBilVAw7yASJJLTDET4VGee7xgoyspPB2pNOLU8H0qfEnnQJlHedrWKQqogYQsITT25KxIddHm9VmgkrGuIDs4boRkI0kjjf2jEQfWHWSNFATmJvOWXECIqffYReZuJGnkxfsmAiqKyW/96aefipRpohREM5iXfA59c1nP5GrzO4R3GXuelRf8H1WSSAp/A6mMVm2/ZvMSTVg9VL8uHaxQ2uZiSljLivuqY7Wj1Ci7nRkfyCRzjIIW8iG5NtIUyE/FjvMz7hkHiJAz44VyaB1xngO2ABXWOrA5wfV6/fe+Wpk+3RBGf2RuoTnJtfAY012zu+qeE97U1MnTzVnwEElII44qQFBgT2Fe8jPWDhEgfhebTUoVnx8Pfl7xvr5d9npKlehgw9ICfXDxHCN8oNDybHGipy8bp0vfOFCbgxu3vucY2K/GaTqwVmrdPv6NcIRyJwZePCEwDIm3qMRrpCFEGBvIBYnybGaEK5JRpTBWGFRyYDBmlkgSwr3+jj56qnwhaUgV+/+4RmvnLTGbFsnwNtcwEmxgGHl+bn8HA2uJiiWJqBeMCxshBAPyQD5YtJNSSAMgbAVJx8u2KijgPRg3CKcljqgGGHxUUcKmyYDPhZys7VBXtc9KrN8ZbdyrZ5bXwE6n67V+LxiVBMWAZ0OrDjsfICXMA4qVUNe4X8gKyiWhPqoiSzpbvSTwXrw/G4klkMwzgEoDeTRVlwccEDXFgtAzmw+KKWN768MttC78blJtOVtUe1yfvb/c3D9qDiE18tniOdKQTRHHBfLApm3Jrg2tonjwfZwFlDOeeTRy5CWNkWpjJGnkGUQLT0O+2LBxfhgXHEAIXqrgWdkCllghaF6RThnrvTRlkbXBXGbcWAv2POdIm8UYWJXRhqshJt51jmNI6gbPwpJG1C/mdlmMAY4N6xeFz7a7Yr2Ql82cZb5SGAgxYSz4PqkN5J0zB+z7kJONDUa9pBjEm2YUC88+1093PHCLqtSsoJ4HH6anH3m+WIWyfW8+H1vNHOa+CXMD1hEFQ1xL5JplHEkJgPhht7BfCA3YO2wW9jA/fb2ufPxEZe+2TqGAp+NCToa6NjpV7av2NCfDMA9wavhsVFwKcnh2zHnSAJgz5OrznAh98zuMEX9HhIz9BhLqFTii4fvlb+mn5e+mfKpQOVXRLXsW2mAEBMQVnjNzc7fOu6jzhVXUcI9KUVVi+70KadXUtdY5O03fyUg4QrmTIp4zeznSDXUB444hwPDhbWMsk8GqjetUr3Vztdx9N02fPFVNqtTSHTfdakjr3E2rdPTI1M+MBRsfGqS1f84t1uvNKpIYU9QFNhjrefN9VAEUKcD1cO9s0JGgPxrhSUggGzaEFRLJy1aIYqQhDahmkEsIEV44BIIcLsbbAlWC8JcNQ8WjiHkBOWfjRSU759xztfv1p+rlGT/G3cy8YO0mBQeM1GUnnGEIhz2rnc0Nok/4C8JoiQ/HldHOhjEkxwmHgJQIFE1UEX6Xl82/ivq54bAhR14CySbCZ7AJegkkeayxAOlC0WEjIkxlE/5vvfUWBWq+op7HVUgoDLZL1VvUoPIF5mtULdQciB+qNEQRZbE0JYtwJiE7PpecQcYBcorjYI8HJVeSMeD6o4WnY5HGyPA0KlIspZEiB+Yb107olcKx0sCzRzUsqbiFf72KH/cJGfISQ1tkBGFh/LjveI6VtOOHc8S6QKXzkkb+hZjbtlE4hMxRyBw/x6bh4JRF+kBJwAaipPEvIGoD0eJ6eIY8c4gQec/kSqIG8rwgRsxPSChjCdHD/kLucOTirebHeSI6QDoAf0uqRTTijfPHmoas2VNpmJsouKWBZwgJxlaxvgHOHPfEM7fNxes1qqN77r9D77/9sVo1b21y0b2AXDMXmVsQRz6b60AtHz36Vx15ysF6+vnHzDPM8lfQQZ2PVJ3ahSdmQby5btRb1l9kGB6HHSduZvg77XFWlZSbkAdXZ+n2/T8xX+OAodwC5hTONDmVh5/UVV/PeNMc81i+Sobp80bKf9MqHdSx2tFqXmEv+cuieeW/FI5Q7oQgnMhmg6EgDEzeTCRo28CGwAaIESIERfVprFNuSsKk1Qv17Jih+n7DPMmT48dZ2j3r7aZTd+msKunZOuabsiGUM695QXlzlhoDTpgH44XnDxFCJcJrxjhQLGABuWFjgEhioFFKMCiE963yCHnkZcNC5P+getj8Rqs68v52o8fwYxAhSpBLPH08bwuIBYaSZ4I6ComJB/wdVY6QKAw0oXyuFXw8d7yemTpSy/M2yO/zmerxYn8bDMnn98s/fYmmP/quNq/YoiZBDtgMISAk0bNpQhQJQQGIG2MEubLXgaoBsbRKNpsZY2ELeyDMGH9LIFcv+16tmm1U1coB1ahZVzVr7aoqdXpr7y6HGcW4NBDKJFQM2eX3IS2MMc8DpwBFsV69ujrxgoCOOzvz7xy4aOGwwg3I78tU8+r3qnaFrRUxSAr3zrznfciFY0MvafNH2WTe2ep3NkVUHogVZNEqjVa5tqQx2tnTJZHGWKCYBaeIsCtHkPIv+YpcV0nKIgTF23SceRVLTbRfoyZ6c3r5DGwF106lc2ktlWxOoyWMqN+Erb2ArEUWxbDGUNF49qxHCuFwfiNJx7YA68yeXkVRGo4DhIm5AuHl/nEiWJMQKhQ60jFQS5k3PBtsKfMCR8Oe8x0vWFOsO5xJ5pUNIwOeIe8JoWdcWK+MLY4FefB8Jk3OEwH3ynpnLgEIJY4xtoz0GOYxcwGHGMXRgvXO3mLnFAQaRZbQ+YRVX+nzKQNUoVbx+bFuaa52zTpYJ3S+QmuXFR6Dyd/g6HD9rBNbSGULpxq2q6JL3yndYSqtMn7MhwvUpdzpZt1i95iHOELMO3Lpba9dquBxCleuXKHzLjhX+XlBY/8cHKHc6YACwGaHkSNXBCUtEoRJUAkgBCweyAWqBIpUvEqDPdbwgm9e1l+bVytcEJQvbeuNEVJJcUqLirX01/riOVXJYq9vlunKsy6IWqGMt0wVJuSO1iy2TQXEGm8epdY23bWV1QCDybmvEEY2QQx2vGotZ42zCaBgouxFqsGoExhmNl9IfmmV8+Snod5h8Lgucn0iFUHG9Nsl0/XO7NGauHqBNuTniTqVmuUqaeYHI3RC4z31xB33mY2J/CoIE5uBJTkAsoaqwIbEdREGorq8pP555KFCaFBhGB+ulWdASuEpx1bUTVfU1a7NOZvcJ8oyfSbRnVBVmpR1pHzZZ8iXUdgAORI2T5KxQh1GLWWjs+SOcSRch7rBnOUZTvhjlELlRmnqgv7KrrDl3kC5tKaqV+ls1arQS2n+ktUhNjSUL5wNxgXHhOI05g5jYxVGNjqIFJue92QfxitWeDoZ0ugFSpFtjYMCBJGxrWrIK+RnOEXeBtus/1gk0X7N807keEPmDs4H40CetA3587msKW+Y2r5sGzHmCGFOxoHrJTxrSaRXpYYYo4JRUML9Qs4gktHs2LYA98HYotxBkCC75HpiP3jGODo4eswT0oiYJ1wrThjzkfQDngnXjfNYkgIfCzixKKQQLeYiY4ijBvliLaPs2uJJCCU/Z77hiPEz/vWmNsUDrh2bA5iv1qnGaYdIsw65Z9Yl70/kgP8TuUCY4HrN6TjvXqFAu7kKhoN/9xku/jl8j76eOHsVF7TV5EFrNWLEyKL+v5Hg8yGs573RQbWbVzQtgJLFnmsv0KH7HG/uAVvPmOFgY89Ig0JMYF1zbzgROIU4FNhhbLyDI5Q7FQjTsqjx9AhjRyMukCh+DnHAiNC7EYMI2fAqeqXhq1++140zh6qgXEC+ODZLCkMoqjE8I8kzevn7jLV5urf6/sbIR5Ieu7FRPYi3iRqCx26P+AMYaNRENmMIAL9rQy8QGTxUFCXGgu9B5uIJq2KAKGDBwPK1PeUBsMGwkWPkIbmE32OB54AqgdHGMeDa4iEjbdq2VY9DDjGKJhsh6oEtTvKODyQQYsa/3hNp+AzGiXtnHFDqbD4axAlja8PXKCCQZ+7HtFjZpYIeunWFmjUO/32cYazx4j6CUvb58lXk5BZ/zDxJNm5vex2IOhs4IWmUEww9m7xVbdu2ba0jj+2kPn2vlk8BpQeqKiutcVzPjvu24WlCseRWodpwf4yZrUIuqt7/W6FFNWM9cW2oVqy5yO4GJYH3Jm0jVp6i/T8OjhfMS5tHGYs0shGn3Ls0AjwfogA2dcQbrrY9IJk/EKLIohi+h7OKs8emjeMbSVYtkYTAMwcgkuS4bU+Q8oIyjh3BfrCmmfOkafDMcWZwKFBOWSdEPZg32BtSjLgPnCLmRjKAPDFOrD8+A0B6UIaxWYTAichE5h0ypowVfx/ZXzgeMGe4Z1vkw3OFRKKSck82pQinC2KLosc65L6JhjFm93x4ntJ3W5LQ5/789lwNuX9K0fuz5rDR3gb0rLtz7zpcTY9PLoeSAqPaGS10fsvCHFNvxAoQzcJhweYTcYIoM76sZxwGHDgiTA6OUO4UYCFiCG3vRfJOolURQqogK2wAyP4QHZRKDHdJJMcLNvw7H7hX07o3UEbd6om1sTGE0pf0Rsd9Ln7+c60ZNs4seNQSvEw8aJvniIIGIHYoImzKbHYYPXLN8DQh1F5grBk7VElUF8aSMCJhH8gFakNpICeRUDJEkhAVCof3qEKqQyErkDM2zGhKMJspzwLViI0bBSJe4HHjZWPgqbzlOfN5sXonMpb8nHAv4Rxv3hyArKNe4nhA9vDqIQt8z+ZAohKWy1yv8MreUmjl30pknCh3snyV7jFjES1P0gvyUyGQbDTkrHGfhNpQSQGkjOskL4pnEA2QQKs0RlZPU2FulVurNKJM2T6OOGY8E5SgaPm3jCNpI3wGzgRriucM2SytuAX10YJ1wedGkkTujTWNUhIrH7oswTUR3vQqjTg6XLsFBTbRqqlxAkpSx3i2/A6REcC4s6EzpmzalkhCnrY3uBbWPW2BIBXkLvOMsJU8B0gxDiaOGGubZ4JNRZ0jj9JWqRMdSRbMST6H9czzZk6gGELymFcl2U5LkiBg2PhoOeLRYNcU742t9BY2cX+MCXbVhqCxA9w/NpPnBAntfcO+GrYkvnSeSPz6yjI1ytvXdOIgFYv5BrCR3AvO9SGHHqxDH6qp/LT1MqGYOGFUz7DUbNmxOvngLfYUJw0lmlQB5jZ2kufIZ7HmcZ5IrcEeIQJ41+nODHdSzn8cEAFyAdmQ8R7xKmO13UDhQRlAnSLcBWEibMyCiYdIkjdEGH3XC49RVv2aibf/QZkMhxM6cnHLDUiBkFR7ca7W+f2GRNiqaUgAoTOUOQwjRo5NCxKA8Ycso8oByEMkoUQBYAMhlGXPVaYYAIJDiJUNprQKZ96X92F8UBcYazZl8hTZYHlG5ChxTZDP8y88RevzflNBaK0KCsLqe+tDenPgaFWrVt0ox9xPIrAKo7eIAMIVi1Ay/uQ+4pGjpnDdbECQct6HzdWexcsmSfiZeQK5KXokhLVWnpw4mQQ57+mzr6bpxLM+Ne9JKNfmSXoB8eB5sNlwbZBsnCVUQQs2fOYUCgNhqmjV017SyPOw4Wny22x4mn/ZZCwhQpli47RHiTKv+Hw2WEKCXmKIw4KaDGEizImT400v4D0hiJYkopJHKovMn0jVnWunFyIheRQzq6qUBVCZIotieKHW2vAj1wShgUwzvqhmqDn2tJlEwXNg47ZKHkSSZ4bSzPr4J4ikBeFknEvyH3GgyBlGKQfcO2NgVX1yhllzkCsICfaDdBtIXTKAsJm2WI89Zv5vm5Jju7Dr2IPSxhsnDyea8cSuc40oqiZykzNN41d/rvmbJimP9ji+NFOx3LbKwTrv4uvN35O2E1klz/0xp62tZZ4yDqTQ4NywXn8Z86PKz58of5IHxux1Vm09eegbWrG4UAyATKOCM++ZJzhpOMr3H/mpLnt3H2VXyYgr9I0y6fP7NOuTgPrecanmPLjG2HPGkQJUrh3VmfQBIlXYbdLAgG17x/ixx0I8y5dBB4F/O1xRzn8YKIyQHcKRGCNUklggnwdlg4RuwuIUjuBhkwtVUqK7l0hCsm6/43YNrL5US3Kjt+rZltj83s/abWNhhTWGBs8axRE1kv/zglCSUE2oylsAArkihxIyQpgfohArf4wxgTxRoQloDYJ6WRL4TAy5JWGRvT/xtiEPe3apqm5HhXTAoTTSLZ7zl7PBr6a1z1ODKmcoK71BQmMDSSbsSt4VoPURBAfiExkyZ5y4RzY/jDWEDHCNqCCQK+YWBAZD6gVzhXAac6lS5jiF18TXIDwalq8sUK/zq+nmm28zxC6StHP9KFZcF5s1KhBOA88CUmcJI2E5/uU+o5HGyGIYL2mMBJsHCi8bGuPCM4NMQL7YdCLHw46bJYcQEhwJxpE+hjg2/IyNKZF8RcDzYU3j/LH+Eu0QACATzIFI0sjL5hBzXYxVZGGMJTE4JZY4pbKpovLw9zxDnFrIJesUJ25bVm3HC4guIWNSOmzPUXvyFtEDnFLsB+Qem8P9YIsgoswrlHaIl23KHw+wr9gK7BNqIIQaBwb7w/ex7cwrHFNvxCMWaG0EEea6mTcjJ3+o0evf17K82UXN0YshLBXkhzThs0V66qJBaliradGPINUodewtgDnMvCa0jt1gnhtH7oQGOu6utslHnkJhffn4dNXL6WxUT3tUpBcotNidDvu21kF9aqhGk/KmWbknaybiTX0KBUP6oM/v6t7qlKL8V/YAogzsm9gRoi2QR+wMe6N1Fnmxbm20h7m6i+cwkJ0VjlD+R0FhDR4cBpD2ESXlP7IRo0aimmGYyAGioStyvrciORaRZIFj9FGyfloxS5f88lbZ3AQqSGlGCKHEJ124y766pl3PrX6MwSXBHyULZY3wJJs6GyCqEUSPMLTtmUZeIqFvvHlUsZKOwWPTI5yDR47hITyMahkNVJmzqaA+WkDIUF4wTEM++1i/TD9fDVouNopkWsyjvrCQYTWpcr0aVL44biON2shmRHjY256FZ8+1QY5sDiQhbOtxsyGgZrJpQEq9Dbv5GSSKZw9p8xahmPH5pKn22ytNgRROrbm8T75eeGWOIWWkMKCSEM5m7CHykEQ2EsLVVv2x12FJI+oOGz0buiWPkaSRe0E1jJWnyItNJDJfEafEkkVehMQgHBBu1hAKG4TL+5zIBSTXDRWSjTeeHpeRYHPjPZh3qMheZTgaINIoUpFFMbYCGDBGOIWRYWrGK5oCz5hRcMEcwh4kQ2gtsFNs6BTJAYgy88qeFvNPg5xZiBLEDjuHYwpppGAD4FxiR2woGkA0mTfWYUNN5LlZdTEWeB58DoSRQkjmKkTQFLU88ICxzzx3CDzrD5vF3OR3SwOfj6LP2A7761Ud1af137nK4VKroKtm1dGpjR9Q1Yy6Zs4x/yDN3DP2w647iCqpL7zM8ZEf76dqTZI7bMB8diisgnUBXdv2LVWqtHVPShxLngm2nPtbunyJBg59REuyf1O9tuWLqZEgO1DFNIHfvVIPvdjvNTPnsPPYERwD9gmunXXMumUfYOztwRg4CMwH1gbPmnVs+2nu7HCE8j8ISB5EBwMPmWTDiwU2GTY8iBCeK8YMNYCNF+8rUjWJRSQxmnjeN377lqZXCyV/BODf/RFz/lqorMa15c/6m8BsVQ5YSCSzAxm6qe2hOrFJdCJnQRI3Hie5h5AEyCOGg7wsQraQb8geY8DGigFBdYJgo5jEIm68L14rRAvigicLiYjcXAkBYoAjc1HZ1I877ihd+2BQrTuky0d1UpyoX+kCNa1W2L6nNEAaeV4YR8JyGEA2IjZFSBLKG2FjwleQaTYsnjGbPEaztHYs/D2qCUq3yTVrENDM0al57OGwX2s2NtVTr3U0RBcVElXEC+YnygBjz31ZEsL85bkwLyHEhK0ImZdU3AIZ9IK/g+zhhJAvyeczRqQnQGbZhKIpcswrCDjPmvclb5OvvZX4rCNy8BgrNmdbQVsaeG/SVgh9El4n1OcNg7N+I5VGXoTGbfsWSHC0/EY7XvGCucG12BNikgHXxCYN8cAWAXKMUX12JOBsQyggbjikPHtyOyExAFWS+eI9gStyXChSQcXErkQDzi8RBOYOuYo4T9gMiKp9Lij12Bo+B8USe2VPwWGdlkbA+Qx+572f+2lmpS8SG4SwT/nr/BpwxmgtnFXYkQNbSeQDG8I6ssUq2Frsx7rclbrth+4qC7x7/kz1f/TlYjnU7G84H9hdnod3/rK2OhzQUuk1NiurYpryc4OqXamhXn1skGrVrF30e6wP1qh1iihgYk/gvckDtwd8IACwTxL5ongMlZq5QKEd6RhHHXWUdnY4QvkfAhMfAkQ+G5I9qlxJISgUGRYMC4/CAVQOFhaJzxieyA0wGpHEkJKfScgBL7XxDSeq/L6tae6X0r10qtRAz+9/lr5cNElvzvpV09YVthexyFidoz7dTtKRDXZXdlr0Y+6igXvF4JHfg0oH2caIQBa4FwgEGzXjh7Jp+8Sh7MWq0EWZJL+GYh0MKUYGwlHYD7Ge2eRpbePdgLyYOP8yrckfZlJIE0WzanerXqXTSyV7OA2QL/L3IJMk0LMZoCoQRkJNw9O2qh3hKjYe7guCHC8IkzIOS+a+oQ9e2nJSTLJYtz6omrvNM6SR58SGgfFmQ6Xwg1xZ1DPuh2eGigq5tCQRh8G2OLHgPXguJZ3aws8hqDxbyBvjgsJJqkC8YV3+HpUJ1YO1Ru4dlb+2uwLzDYWaQg6iAfy8JMUZwktIjiIpnhkbq5c82vZOFtxLJGkkTG2JTypAJSOqwf0kMj+8RBKbAZGE7EKucfLIfUX1KusK9FTAuDMfePbcK3mi/EtkgnUNEYZgoOyjSqJOM8cgfF6HHJvDeHkLOJi3KGzME/v32A5eEPxI4ChBHlHPWJ/YJdsHEoWttD7BOCQNmtfSVUO6JFS8UvT3BSFNHr5MmX+0M2ktqJO8J2sD58YLHJ1K9dJ1/RddVRb4/r4N+vLdH4xNYv4TpWDNE2kibcgbcWBMKN7C6cGZZ9x5foUtzDLMOsJJsLmQzEfWH/ab9cnzZk3xXHAgIczcK2sWW0oq1cw5f2lVxnRd3edi9ep9tDp36KJqmfXVouLeCviSTBj9l8MRyv8IWEAscBYEi5vQSEk5WRgBjDjKD2SSjcY2Myckh4EEhFEgkmzilkgScsQrZkNgUWM48KZZpKMbSUMXT1aolBBKiQhLe2TX0cBu55nFD1GusUsDXXDlZSZc88KTz+j1/gOMQU9l44EAY+RRHvgciB/GAnLJ12zYkCwMPuSAzQ7lN/Iz+Rm5UoQLCWGigjL+bBakDOC58l7kT0YerbZx83SNX1SY6J0M0vxVtHfDH01zbgs2LEiKDWHzfNncuEfIsVUgAepCpHfNeEMwIWPka8XTe5QxIEeUXCL+rpzvS5193J9J39eWa5G++/MFLV68xDgAjK1tBg+ZhLx7+9Pt2i5Tx5xaRbu0yFbV6uW0OTdNY39ZqL3b3KQWTQ4qylcsSYnjXlCKIA0QQTaeeE7JiQXUJhw9iCnXSsI/BV4QYtYtDiDOCxsXCq8NL9uKfzY2nic/455RlW0bHu4DIhZJGnklczxqPICgM2/YjEl1SETVZOMmnAuRJKIBOcKm8F6MM+Fz1t+OBOYCZIN5zfwhdQS7gMOOveVZMqdQLXG8eTY455FqOooWiiO2FxLN+xIx4PdI5+BnEKRYPV6ZK6xF25qJKArECnANXA+OVGnN5M9/tIeaHZ4eO7+wFHDM4AkVH9XA598oygn1prtQuILdg5gdcuz+umFo2RDKY6vcrcGvjzDzhedA1ACnBvvsTcVhfmKncZxtXjTEG7LO37FPspb4Pewx8449DfXRpo6QQw6BpCKfe2HtogbzfE4+t5dy6szS3ic1ki8jZEh2wB8w+y05qOUClbRH1SPMq1J6De1McITyPwC8J5LXkeIxUvbIqJJAeJIQDGoHJAPPC0NJXh3EkgXlJZKQVDYy1EgWFsaNJHVIJCSUa4Bkvr5yonI7NIjaxDxe0AR97Xd/aHG/T42awuZIfhwbL4ad/BUIEKGJVPK2LCAlKEQU4wCMCxsG+UmE/dkwMUYYIEg4YxzZw9P2mRz85RfKaVlD780ao9mrlyo3VKBwzmblzF6iB4+9QCe1219p/i1jM2PlnVq8/t3Eq6A9aFzxQU0dW6mIQEKUeT7kMpHrBYFks2HD4/lZQG7s5kjYMbIND2FaSBT3jerCHCHEjwKIagPphnxBEiKbDp90TAW987+6ShU5uSFV2KUwFGqB4UedQUWAnECgPxp6o1TpSwX9sxQKSp4hLspJzU5rrybVLlP17OghODZ6nCQ2LIgcaj1qK1XMZQHGjjWHY0LonDVIYQcbERsWn8W8wqmhkhqV2KtmsWlC9MmHteSRzTJaC7BtBZ43c4r5gLPJHIsHjK0lkqxbQsHcr1WIAE4pa41Q444CeyY2ubjYRQgG10xYmrkCoSa/kefHs8WRBKhlOCNeZ4y2VaTPUImPI060AFvN30crNIkE44bTSuiVMDjzCBJqc+YhQOR/Q3pi3cv0v6bp3dXXKaNi8mNCPuXwftP17YuzilJOSJOCwDEvUASxFTzzrEppuuPnsklfeLj7N6oQqF50uAKOPWQQFdI6YexNpLYw7qiWOGqkGDBm5SpmqGb9Kib6lh7O1leff21UVfYWog7MbfZQ6g3YC7B/rEfuhWfG3nPn/y7TiQ+3VyDgL5GQ+yhx8qWrd8O+alqh5HSs/xIcofyXA+8QcsVmhbdolaeSYCuayeeBpGFoIEqoIBALFhlEErKGggDhwlBBItjs+FtCdfb7KHwYOxZ4uTaN1eS+QnUzFdT/dp7++uQbs7FHFnuwgbL4yTuDxNljD0s7YaYkoCZihCBSEDI2DjZslFo+n3vke9wjxgtjY1tMgJyCzdrv7kuU166elJFmDvULRx53GPArO+jXlbv30JnNuygY3qhf5u2tsLY0EE8UkKepv+fq0uMXGpXE9oDkX4g4agnkBCMLyE3juWEkMbSoLjgDOAuomN6j9yLBvbJRMv78PgoY+XiQTj6bjYTQGxtl/VpL1bVdYUV5soCj5m6urpG/9zHPGZKM00KIC2D0+/S5Rd9MuFCqMOLvoxRjK+PBYNg0VV84paPaN71Lu7YqrFK2x9gRFmNjZs4Tpi7r01d4FoSlUarJ1+WzbDsnS8jZoHnh1OCw8ZxQN9nkIDSM8z8JCAwRDO4hnoMOuDc2dpQ0bATPjrUTrXiN+QpRwrnbUWBPiLF5ndhLlEZUQAg+KTG2lQzPzHsMIuQGZx0bxt+gLOKMUbxBRTZzurR2Y17g/GPrIfKMXyR55HukKTFPAOub0CwRCl58XbWlT+e/HL1VWLxgrq5ekKsXThhblHfMnMUWoLZyfxBl9iQKXi56vYsadaiS9Ck2ENjw2mw1mXucvh7+tXGOsUO2RRNr2J7pDtEk7YX1hf0+/8JztTZ7po65ppMW5hSPmNTNaqVO1Y/RuE/n6JyzzjN/z32QLwlR5dngVGL3Ta7oMQ105B3NixX4lAyfsUgnNLxLzSsWb0X3X4UjlP9i4FmhDrLJ2D6BpQGyhMJAEjMbA4uRfzEAbBCEbFBkWKAkeZMTh6GHRJL8TF4axJUXPzMyfyhkFiMJ2Rixlv+7Wmm1KpdeoR0D1TLKa+Sh1yndX5iHxAaDQoqqgWrozYmznw8glPZ4RAgmL0hBPDlvbHzcAxsEY4GnSjgco819kdPEhgKh4XcgoKhMhE9OOfcsPbD4e01es6jUQL/tsblHqIrOqp6hco0SPxt9q/cMSRcfGVBOTp4x8ORMYmxt38lo4BrYFHmhNKLAshlBNnlBHDDIqA+8UDf5XdIMSju5hc/m0c/4tYka1cdIJzcPIICPPJerux5ZYoiu9+QbwqKEXQd80E1N2xVXMOPBS4+v1PefVy0665iNiHWBykRecbLg+UICox0z6G38zRpjvPldnEK+hmhBGMhNRmkmnEcVMblxhFYTIR/bArbaFQUbpa0kMPdQwyGSKK3cF4pkrC4IrGEcOpQ+NvMdBdg9bCJzBNvGc2LtMw/pLWnTIKxyaYFjZf8PscQGMb8ghYRqcb4SBXYQp8eSee8hDKw5Tm3B+UAcwHYTVgdco626bn5QJc2tvoX0JotgnuQfur/ZJ9gfSLuAOPN/7g1lnfQM0PGYRur9YJuU1tTHd0zSxE+XGLuFjWfvY2+wxW98lj1JxzrF+5/cSgdf08iopIVHsIW3UhHDCilvfVB/vL1JL/T92BBRiD+ONpEAIgik8Qz8+Bld9CZ56L44yaSFT2m+dJ3X9FlVz0ys1du/EY5Q/kuRaNsQAFHAELGZsSDZoCCiGCAWIe+BYoJnSa4JeSgoCpAEPoPNDbJiVR1+HwOLAobnTZ4gBS2LGpfXaysnJEUo/fLpklYH6vJdtzRoRkllYyKExGdjPNhkMahs/uTWsTED7ol7wKBZ8ka4yhJMSzZRXyN7DUJO2SS8J9BgWDAwbKJ8PmOFuoCihfEO+sJqdM9Zym5Zv7Axe5zg2jInjNMz56SeZwiO3nOe8vPSzaaMcohKSLoARJHQMMQYAkxhEM/WS05Qnfk9VEw2SrxyWqREkkbmj5ekotCUdB50q4Y/qaL/hb/P604chKob7TlbS5cXfibPDrKBsgO5363jRl3UJ7aiWhoeuCaoLwcXHpmGAsF7ojYReo08Gz3WcYzR2vDY1kLML5y8yMIYNl17/jhAcYIM0HqG9YmqQ+EBRBNSAoFAEf4nQQoM6TAUlZXUc5VxgfizXhkLxhIiWZqaiZPImGOP+JsdAThP2EpCqjimdAqAVHJvPCMbnWAtQ/4hVBTo8H+eF84dTg+kBCcBlZCUBX4Hm5QocF4pxqEoCLtMOJc5wvtCaO3xsfY0H0si+Sx7rRNWf6mhi7ccMZgs/ErTzbsVpibgkLIfEdmyJNbaIOxnzdo1dO2X+0oZrNXEbUG6r5zmDaijZ59+vkjJx36TMkLKBXaLe+c6GBfW0h8bv9TyOr/GpSba3zm41vnau0bhiVbMQ+6H4jNTKPXCfsrcZYMCaYknnvoVUIeqh+vQupfpvw5HKP9lKK1tSCzgVRMKtUeF4SUTsiUJ3gIDgHJJgji5MOQIQdq8JAKiASHDeELkMBwsaK4Fo0ue0NXXX6dG95+tQIPqCRXnBDhGLLua3ul6gSqlb8k9IneFCkjb3w3gmfK5GHiuG+LDfXG99mULF/g5hAGDAym0ZIjN3RJNXhhhqnqjKSRsDnwmRpyNko2ezfWdJRO0oUvjpM8fv7bZcLWqULyCPRn0aD1LeblbjzX3DZHk3iHMtnIURQgjDPGGAHnP7QZsiBBDq6RFI40Y85KKosKh1QovO5CW8wlvJLQM+vCzjTrlogVms0ZBZM4C69B8MW4/VaiGI1E8JSJesjrxZ6m6CvP4cBBQkiBvOFeQV8glJBOFh43b2/wb1c0eNYf6FNnw2+Y3xrM2LWyeMASTZwVxJvWE9yKMWRrJ3VYgjImyyDgwPtGUUmwETidki/Fh7CCSkadOxQKKLPaJv030FKhtBfIhyflEpcSu4ZhhN1CsvPOeucP9WucWQBzJv2be2MgRNgynG3U9kXQKxh97BqFkHfOyoWaIlSWOvFDYIXU2PcecgrNokYns8L05+WPU7OTiByYkgyx/RTWbfrqpKieagz3BkWducH32mFD2ERylJl0q6KMFiXcDAHvqNJ3Z7Tpji0hzIR2F+WIjU9giUg0Ya3OK2cHVdMQdiRN2sGZkbbUst7/J0Wavo9DwuYFPq94585MO2YM0X6auavmWMgP/rGO4reEI5T+IhTlL9dWS7zRu9SRtKNhoMi4qplVQl+od1KP2/qqVVbyqFCOCl4z3xEK2bRBKA0aFXEAMPmofRSX2uDiAIWfzQoFCXfCe5IABJSEZksnPyYfiX8IBkEgIqO1lSHI5FXemZc4j9+vS8e9p3sZVCkYUbES9xmBQlZShjw+7UvWyt5xgA8irwlChsllg1AmzxOr/hbEhZ8uSS7x4CCl5ePaYO1QiiBQG1xY/QMAwJKQRQMQgBGyW3B/k1f7LswgqrJYvX6u0KlvUpkTgC4fVvsp8XdLkO6WEcIYW/NJXs2fPMYqAVRNJSWAzinYONy+bLlBa7iRzgLA/zgP/JvKqVfl3VfbdbhIi4xWs8V/mLQxqr8PmqM9tj5iqaMBGzGZCDnDTXTP06tBUi2V82qvBd8pMq2tUb8gMShwbIBsw88LrTDEfmBtsNl7FEYKd6Ck30cD8ZC4zF1H/UbJYe5BY5i1rsyyPVowH3D/XxBpibCJb2TB/LJGkWI6cQYhkrCM9YwHCht3g3v/p0D5gPWAjcBoYe8glbWgg/LaXLHaA60atZA1BEhkDbDJRHkK/3hA+4wcxJ4QeK/TP+0D8bN4jL6v6McdIPcGx4HeYHzjL3mdFJIXIFfae+cvv2ROPmFP79thD+92ZmXKKzYyfVuqVi0eb/0O02T+wOzg+9hhfIh3cJ7n5kO3fVg/Vl4v7lZrr7EU7/7G64KA7jT1G/LBFgnwecxJnzjbmxwm85rqrtKjdJwpkxpvn6LmvsJSfE9IDB36tzTlB8xwh7D2vaK26B21Ouire4rC6V5jK7/8y3Fne/wBmbpin1+Z8pMnr/pJftBrYorCsL9ioQQuH6ZOFw7Rn1TY6u0lv1S9X2ywi5HyMCFWQiYSF2IRR19gQrXFDBcBQUV0IufSeMcuiJbRLcQIGldwpVFEWL6FmiCR5LBZ4qBBdFEE2FxY7ePvAC9Rn/CB9s2SaUR+jEcuAz69gOKQqqws0sc9zWj7sGNVrX5xQ4iXaxHcL8voIReD1RyOU1vhCHjFGGBveB1ICGSVEjsH1nqcMIJgY/pKKUuwxiRW77KpwkmQShH0+TVzbUKvyslQts1DtSkZp++qjFXr4ltPN9dnCGMaHYgKrJhKmZMPBk49sA0TolrAYGwMhNchVPC9Cgii+9v9WEY7E6b0rauBThY2EY58AtOV+Zs3N16GnLNQxvc4yz53nBJnlGilkQVF87u0DlBf8Qv5A8u2pOIHjwaeP1oDHFxkCbgFpgjiSM4yzhMoCweTFBg+JsgptWZFJ1jRKGOFwvmZu24pzxhm1B9ULBZ02JturTyNEEYJNuouXTDIGOI/8nDWF0we5Sva0ENYkY7ojkElIHfYMG0Hkgg4OPHvbBxSbQ39CbB1rCvLJ/1lvzBsIFWuK/6NeWptr15118Pg97ttLHvkc2+KLec78h5zzNTYMO4yCTYoRf8u1QRr5O9aGJVfkuNvKZP6WSnWIKPfw7LiLFaq2Sv4kwrcAYvXL23NNRIcUGUgkkRvmB6SbOeG1BbYLwR5VD1eFtKr6eOYjCmXkRj0a0eY10nqng7+3zjjoWkOEqdJmXyIHlcgUexHPgTQM1EpyS6ky7z/oLp24N3tT4uuDJZWR7dcPsz+R5tUx48lLVacqHA78XWKTHPwKaGnubP3X4RTK7Yyxq/7Qo9NeVCgMjSw5VAfZzAxkqLcO1mXHXmgWJopcPOfaQgQJ4bG4bagYY42nyGZE2wpvqxeUFvJ8IJIsYDYHvF2ILF4mXi8/9+Z+YUh5fwgroRyq76K1WJm7YaXenzNWH8wdr40FW0KrWYF0Hdeog05p0lkNMiqZa8Pg4cGjbnmT9cljwoBBqCGGXBckGUKDF4mB5WsMqlUVIlvZeAExZDx42ZMnIC6QA6tKQRh4b0gDih7qJCoWKiBocPNJqrh3q6TD3QbhkHrXG68etZLPpbzg6PlaOr+cKSYiLBatOIvKRRQVwnCRYFwxymwCjAHkJRkwbryHl3SikLIJNq63Qv0fbqldGixXMOhTwEMEiVxxQlBOTlivvLtOdzyyUmvWbr02bAgP4nvr4xXUbq9gSqoBouzUsdW1eHLPYvmNsfIVIXYQKzY1SBbzDeKHKoeDR3g80d6P3A8qFkVnrD1yXL1FZJALnAFCryhNrAcK8Zj72zqvkkgITiz9OMlLA3w+JIaWYhBJKptRJIlYpALytZl7zMNUMG/5Gr3/00SNmjRLazcVOmmVs7N00O7NdPK+7dSgRnFnNRK0lCGVBSIBwcXWYCt4xqx9nHIccKIjrDdSjshjpwCJPEJUVuYpUSDmB+olawAbZgt3IEQomChs/AtYs97QNQ67JWK2JRufxxyDOFnChr1CHOB9LXEkkoMzwnja98A+cq0U9tTbM1OnPd0hqfE1+YZ5Weqy/ir1e6afIZM4r8wP20mCz4Rccg0QPsYUMmzRvkM75VdbqiufPEFr0ouTrIbZbdSx2jEqt7qBunU9yNhm5gS2mM8gwsZao3gmsi+s6fc6/iwFquUmHZ6GNNbMbGKKaKzT9uasmzU/94+k3s9LlFtXOlC9Gtyk/zIcodyOmLJuhu6a/JQhk3HrKmGpICdfq/rP0IcvvFviZs+GDlFkIRMes96qPRkkMoQHUYSAsEBZsKhXGEJIK0QLbxw1Mlp4BkOLF49RZEPBQyytwXF+KKg1mzdpbd4mbVi5RivmLtT8OXMNOSQHErKIUspGafP+8OZtsnkseFvZ8HeRrWwguRg4NgH+hRRHU3jYQOwpFd5QOQTX5iAS1sJoM54/tsvS6gqpKUX03Dyk1lSdUH9CwuQoWBBWILSL6vpfMM8NJ4DNi00eZcL29QM8S1Q45ocXbD4QGVRo8o8oNKLoqKwAEWJ+EK5i4w0XzFR407vS5l+k0DqJEyX8NZUTPkQd97tL06YvMJXEjDupFzx7lGbUHhwW2yN0z0NHqE6T4o2jk2m5NHlseY38oIVxYJg3vOzX0b4HYWQe4LAQyoNc8iLUyTzkOhl3lCU2+pKURO4NR42xp8CAsYqldjL/6DqA80ZYGDvAet1WZ12zFimkoTLZtqFB9YJIQqjIa+W5plIR7wUqHKSDOZwMpi9arscGf6dfps9TwO9TMFTcwvI9FOl9WjXW9b0OVIu6xftnYhdJI4IAYiOYe5B71jskjLnHsyFqwzMjBYjiGMYDooltYd7yLJmvtHxiruLIoRQSDrapRPaIU+4Z8si/2CucC+ygVcOt8mgdWABp5L2ILHG9jFmkY2HPHUdBJp2JNQ2ZZL6xxm+48QZ9nf+oFm+ckRTxmvFBQAPv+szcM+PFPuDNFcbmouozX3B+vP2CmVf2WFT2kGA4X7nBDQorrHKBikrzZ5h9inmH80LExB59SI48Y04T92jrZFPBWj09/VSVBX65O6xZUxYURgbvbabWB9VKOIQeqVDuXqW7jqh3jf7LcIRyO6EgFNTF4/poXf6GxE+RCYXVILuuntrj9q02KBYbxAcSiZeMioI3HJk3B8i3QUlAZUE1YnNi4WPEUUEwXHjGkEiMRCy1hc+icpH3o28loUjC5xgIinUwiryvzeHDU7ftbNiII/tKemHz+lBpaAPEJs17s0GjHnnJId49YUAS4VNVSAAbAffNuERuNmwa3oIfFIzGj12grF1SPF6wIKTy0ybo8dOmJPiHflOEc8VJi3XHLQMMYWR8cSQ4BYJrZKzOu/Qi7dbrYA18/y2tXLNat113k/ao1lCNK1Q3zwRVDlJi1SjUEEJJZQEKOCCRbDpsvLHA/GDeMf9sWxrmMRst84ANmM0EQscGg0I/ZdnlWrmJ9ifJh7xRSqeMrq5PX6tiFBxeqKr8awtuIsH6s06Ll2gyT5nrzH3uA/UehwbCBaGAYEAC+V1UF+YuIXXUJu432pGc0cBnkFOKQgMgCBCeeE4zihcQVpQlSCzEHieE54fShEIGkeTnZQkc2muuucbMlUTx87S5uvrlT7U5GDSksSRALDPS0vTMBcdo7xaFRU6Eju3RiYwt6wICib0hvMwzY15A8CyBJxwOMWK+QtiwfZA3CIj9fRsh4bmTa868Jc+cPHTSgiBaXuLIv1axxLZa1ZEXP6PbBNdGxASnt6Q1RXW5TUvhOrDX5H+iqIMNBav0xNizFCgfTIhUjnpxpmZ9FjKhbWxOZKcMgJrLHgPxg/SyHmy6BM4q98ELpzcSXC/jyNxjreO88GywA+xvJTkwK/Pma8DMLR06UsHvT6cpuDrLjHet7uvVvEf5pCq8vQrlfjVP1QE1Sz4m998Ol0O5nTB61UStyY+eY1Yq/D4tyF2iP9fPVOtKheFMCA7EjhcGkY3Nqo9eMglJYrPCwyM0gdqIwoOSQv4LChXeJT/H2GEk8SIhGJYc2gIPjB3GgQ0H5YvFFnmUoBf8DpunbWVDDg+Gko3WHoOFoYGQ8iLUzoaNIcKjpviCalqSu8lXivTE7VFkbARlQSgZh8icSnsfKAG82EAAY3D6qBc1Pb+wRUyy8KcF1HOfUzX5h4+1237jTWJ4aX0bw2GfAv4sta/3vPbeY4AhwYwTGz3Gl9fgX77R0798rvfq5cj/1zCFO9SQL1xDt/1WWNi0T82myh01WStXrTInbjDuhB3JkSX/K9o5wokA4sOGw/xg84kF5hBzknlFSgXkimthfhDmQ8lB8WAeoSyzuTJPr+jTIKHk/mhAvO115GW67NTCUF1kLq0ll/bfkr62Jwjxd8xJwm+QDu6Blxfci12rkBacMlTOaIpoNMUUBxDiw8ZNw2w2WlJCmJuJVJVHA+QDBQ6yg2MFGcZ5wnGjpVZJ6z1ZMI6kY+AkJopJ85boipcGq8A0hy/991Euc/PzdcWAQXr1ypP087DPdO211xpCi7oIwScf0hJB8llRxbBNlkzidNGHE8WPsD/2zBJBG+nASSLaAjFFnWddEekAqNGEr62dZq0xryFblkBiG73iAXnq2GacbZx1IiTRgL0mLAwRw5aRv8n68x76gLM07ItRGtpviTpdkaV6rSuZ5uGxiGWoICx/mk+jnpurYf2nm/2D+4mlpjNOOCG24t2G3ZnzOELMf3u0rxdWIGA+0K4Hx5h7IUeeXsmlHX2KyllWwJH4a9wiQ2S7VeuoVoenlicdVkhtKx+s/zocodxO+GLxN6bHYrJnXJNP+dHMocoYnmNIJHmRTHZIlu3NaMkPBg5Pj5ANGxbeM8nhLGaIhz3T2Z72gJEiJ4tFG/Pz/X6z2fCCFGLQvOQQI+olh6W1lCkJbI4Ydrx6SAbvHy1fjOtHxbLKwrYilNHA9XRr0lYzZvygUDw7WQwwH57rc5/2qtxQ6f7D1aTDr8rIXl10XKAX9nu/j9mkL9+uoGuuyDHPjGdMfhEkgDyuV+b9queWfqtA04ry/31t5ll43u7X5bMUalNOnV+6SVXr1y7KpbRHlpHTlyyYIygokEXIUjQVw5JyQn4o0DSt53e9c4aNlX6MKDEo1ITQIL+Ehr/6WnrlK+ZY0pcpn9JVu/yxUX/GJsjcTvZkGptPCvmgyIvcVRRbwpEQEdYp4VRUZKtYMg5eohqr8p6/teSSTRYyBglkrCDgtOphbcYK3fOKlZ7CJo4twPnDsSO0i1KEA7qtgEMMEu3NGAyFdP2rnykYDMVFJotV8wZDOuORgZrQv6+6detqHAEcV9RnYO+ZCnuIET8jRxDFlnUGWCvMbdKGIJworABHivUIEYVwoloyz+2YYxv5G+Y3yry3UjsWCJcTNrZ5tJGEEicQu8n6xzbx7FBOmV+QSW86FDmwEF4ctdGnLNFuB9fWPqc31i6dqm0pjDEVM1LepgKN+2iBerY6W188fYNOXXaqce4hfpC+aDaeVA/GE9UV2HO2ESmwCdj0yMMmWCeo3zhhCAkQdqIS5BdzL/HsJVn+5AskI3HGyeeo+9NHmLWEXRo35SXVbVUpqRQBn/xqUr6DqmakfhTtjg4X8k4BM9bP0YhlP2lJ7grlBHNVPq2cGpSrqx619zMhaotVm9fowrF9Un5YoYKQPjt0oNIU2Cokx6Il75Hvl5ZzaMkTi5oXGwxGDcODV453zIZiT0iBmNIqgzAKBikZJSFRYIQxuDbBm3y1aMBwo2rhtada+YpxZxOBtMSDRZvWqOfwp5L3iznZYVO+Wg6aoYULFhgDzPM75Mj6OuPSemrQfJ3SMwqMerBubUjfDs3R8tltdeYpN5vqX0g3Gz6951D4UKJb3XCK8jvFry7i5DQqX81U5FfOKGeUapwOQmzJAoWHEBu5d+ScRQP3SfiKz2EjweGJJDlseoQJ+T5OERshOVmQL4rB6rf/UHt1ZVNPxsgHVKtCb7WsUXj28vYAZA3FyPa4o3KVDZT1R74duZdUS0NiIeX2tJFIRTTyeyiIkB7mvz21ijGL7C3qBcTJSzSJINg2MwA1DAcDhy0aKS3Lamxy/YiWQJbiPRscfDd5llEnU8HSL9/Qsj9/MykJKN/MK2wOOXykjUBqIPbYS5Q5iCFjzVhB0CCcjBlzk5QAL7CdEC+cPirzcYSwsfyLKpoIsIH2yFsUfa6LHFeiSRBXxAKeDeQLssrzhLhxD6SykAqDjeR9cP65bqIICAXMGwjnhJk/afqKcfpi+Kf6c8o0Vc2urRMOuFBXXXatuV6um3mJzeHecfhRxyPB+HhTInCsiC4wl7juyF6jrHPGCccC5xHbFk+I2743zhoKP0WoJz3fTDWbVUj6dC5QLaO+Lmo2oGhuQm6bdauokx7a0tkkUZzU8G412wmOX3QKZYJgQf2wYqwGLxyu2ZsWbNX25/c10/TZ4pFqU6mFjqvfU3tUbaPVmwubaacK2jykVUhX7orCnokAY2DJJEaPxQkphIyx4eDZomBgOCCKeNg2j6Y0ED6BpBC6IeeSxZ5qSC1e4FnjGbLBlnRGNyE4esTZZO/tpVCiUkCcciqtUGa7Juac7mQQ+mG6Pv7ok6JqdsLqa5Zm6c7LlxnVAY6MMjF9+iyjPGzaNEJDPh5nNhY2CtQkvGhysq586yl9Hlic2OcrrDnrl+uUz57RoCOvMWFvinQw+uRXJgpCbWw+5EfFIpMQHTZsNmIIPBtBNMWMzZFND8LE/GMuomKxsRMevOn2r9XloGTOQWez8al+pXO0PQAhsWkcEAtUF0gfzxz10hb2EAZkPfM8bWEPTlys8KYXkBmeGwQVZxBljLFl3CjgiBWuRxnimRFSZXPGTkDqIO3kv8XqlADpKi1EX1KBE4TWOoAQCQhQaSHNSLzzw4SoBTjxIhwKqumBR+iUngcY+4HKy5gA7Cjkke9jSyFtqMsULBIOtc3sAeOF7eAeUOAYT+Yqa5ncdJwh/pb1bZ3+RMDv42BjB2xzf5wNFFMcfD4fp5Lr57ogi8wxVFbSlQi7YyfZByB73CNzjd9njuGM8vNrzu9jbD0Ozx13PGHmE/PhtzG/m6I/nHeuH2WSeQlJxTZHOuAtWrZQ/TaVVL1eZeXl5WpFaJY2LK9hQv7MRS+ZZLyIlrFPYc9Y1/wLCY+l3GJ77ZrhHrHZ9njgTrUbaLY/taMlO1U7xqwn1irjwfjWzG2jtpW7a9JaDgJJbL7tVe24nYJMAqdQJgD6Jb486z19tfR7016gpJwNG94+rdEx2q1ic/WdnPqZzeCrk95SpVB5E95i07b5KeQ7shGx+UAECA+yYZH4jwEhLMzGjNccD8itxDPDCEJatndDZQuMNBsdeUjRroENEcODAYqWl5MI8IYZu1iVphgucqrIJcOo8rntjuimpce1MU3MEqkCpC8nZ5YPOvgypeeHDbGA7NuiH8ikvX82X9QFm3fHM2ZD4bmiOLABjBk3TpUePE1plUs/tzwW1j42WKfv29PcH+E71JpEwDUxByGH3Eu0QhHUc9Qg5iO/C5Gxc9gLNgtyp9iQbcNrCBIqFoYeFQOl5bWPzlFBxYFFx2yWjsK8y11rPq2a5bf9EX8QN1RfVBQ2XjbxWPC2JaKCm7/FOfS2JbLttKKBtcCmSksjQrQQH9Y8GzT5kN52Y4wX5Ii8W5Rx3hfyABmyBBb7YdtAlZRDGuvnvGI5aHyWDb/zGTgZKF/xkFNeSs/UwXe+mHLWHKHdRe88ps57tDfki3VGLiX2FAUZO8r8tGovX0OqcJpsPjrzEMWZtQoBZY7ynElxYDzpHWrbB0GoyJ9MZG3hHEBOIU/MI6sU8rmkprA+IIukqkAw7fPEGecZM9YQN9abbf9W6JxuMr9nUysgzqwr0k+8+ZFELCBsXhtrSRzOANEr5tHGgjWauOYrjVs1xBT9eBHa7NePb81Q745X6PxTCrtI8PnMa4gm+xJEmLA9Y+tdy4w9925JJKkhPAeKd/h7Xjia/N4Pv3yrX6s8I1964qdngYAyNG9AXT3fb4Ah8KQN4BwQWeh7Rx99vvBJTV63pWdzaXZmz6pHqWedS+RLtSv6vwSOUMYJFvCLs941ZDJRHFO3uz5dPEJlgSNmd9LZJ59VLC8NJRFvGnWChU5ImvANmwoeKUoRuTW2oKQksMjJR0R94+8IJyeqHJQV8MwhJZA8jDGGkryfSGBsCbFQoJAKUM0gaBBoL1AHIDaMBZuOPR8X75UNqPt152rxAYX9N+PZ4MLBkMqnZ+rtrheoRaXaMcmF9yhJDKpN4oewMR/Z8NncIJpZnVuo4U0nJn3vOEDVl+bqtxufM+oMSgfhHtrDxNu4m+4AjB0bRLSj5di4eD/CZaQXMDejkU42R54pGxwbiN1cIEeEzdg4mMu00WGO3HBXJ517HYrf1nmnxVHYnLhVzce3C5lks4XMoSrZvLN4YdsSod4yBpAK1jw5knYTjdaWiLkAKUC1R8WGjEImuRbIpm1zAwGAcDLnWVM8a5w2/l9WYI7yfEojn8wZ7gPCG/m79ojBSGRWq62WZyWf5+tFr1oFmjL2l6L2SFw3a4y8SD4fAkd4GSUPMgipg/xacJ38LgQOsmNzmbHB/AxyCuEkrYPTzUgloNgkXtjWXrw/DgfXRpU0xA/CCInEPkCymBeMI+o/OYuA9cuas2Fo7o97gFza/FVC5hCnWE4Z8wibxJyxv4M9wg5iAx//5Hrlt5xmik9iCS2kbBFlg2QdUOVsHdvrOONQou4yfoS4bXElexrjxdyH2FP1TYTNzn2cUmwfjjjOPS8IPPPt4PNa65Dr4xNOIjHiqTka895CQ5JRS7lnFH8K6xhvxm786s/168qPtDZ/6VbFTD4FFFZQ1TMaqEuNk7R75e7b7RCCHQGOUMYJwtxPTk+uRxrI9GcoL1R6bmNMhKUamVX1Qsf7iho8QzQgfuQ4Qi7YsPBYWWwYEQgmGzOLlAVR2sSm0IeQJ4YTzwyD+E8uBjxWq7ayuAlpYzgiizwgMhgTNt1UwCZBCAdPn/FEJWJ8Mdp49GzQGG1CPZAuKh0Zbzb2kYv/1PVjPlBeMP/vApitx82q2qHVG1X+vbH6cdCXUdW5aMCgkqrAC2PLc2XTsApQ4/vOVnbrRkmH3oHf59OQ/S7WU/c+ZMgawDlh42EjLcmxgDCRUwWpp5VNrCP82BAZL8iyt0m+FxAffs+rllnVDYeHjYzKdkg+mwub3BXXHqPNmUN1eO8qCivfFDDxBPyBgPz+kPy+cqpdobfqVTxT2RnbPgeYjZJ8T9Q0NnYKp1IBaxJyyYs1wMaJqmM3WNQaLzknpw81iQ2f+QqhIGSJiglwigjjEtrmuRHeLimvb8biFfpi/DQtX7dBmwuCqlguU7s3qqOeHVqqXEZqaTBcIykbnNMczQmxTfK9RHT64hV666/oZDNRzP/wWVUOBE1/R4gepJrnhb3BHmIL7dGKKIw8Ay8g4tgO7oHIAnYZW4p6CdHDCeBZ4aDjhCaSp02eNGsPW8hahPxznZBG1gjrCuUassPYoCISPuZaWbdEXVAmsWk8Z9YR6ijOHMTURj2IvOD8xAKfBanEznor/XH0z36wq/Y9N7FjUFdMkvqdOVz5mwvM50LAIeNWhcS2sYdx/XaOY/MYB0sgGUvmAs4vz4xnwAvb/NDgS3XA+Yl1qvj2pZmqv3Z/44zZfs+MCw4AToH30I5QKKh9j22jQy9qp0ata2pzKEeZ/mzVyGxsTgRqkN1mpyKSFi6HMk58uvDrUsPcseALS2sXrFZG7XLyJ7nhMzmPqNvNhIfILSSnBaNFyALyQ5gWwxPZ/sMoqy++WOLk5nfI7yKMzmYfS2Ha3iD3CBBawntl06QFBhuhFxg4iAzGLZ6KyVjAU0aRYGNjfPHeCSej8EDiCIUx1hAmVFw8V4uD6+6qg8Zs0rszf1XzMw/Xys2FTeXDoVDRSTq7Vq6t05vurdpLN+ugkc+YvnCMezzAaEK0cAwgVBg9jCi5Pmxg/WstVjgFMgmoVp9fsN7kX1FpiWMCeYeIELIjVEaaBRuUdz5BdhgTCDfht63e9+/UCzYlyAObWSwyCTHls5njkEmIE6Sdo90oXOEZsJmgprCxspnzN5BNrqFLozu0fOMQrVz7p0aP+U7jx01R7vqqOqZHX+171Enbxcij9nAtzEuUv7JQ+CEkjD0vnj8E0aqXqFWQSZ6Xzb1kvFnLkBjUNcKjkEneBxKJ2ss484Jo2ArlSLswfOJfevO73zRh9iKTr1j4/ULn4/0ff9dDH49S733a6rQD9lC9aomdEgRwiNisYxX6Mf8YPzuGtifsrMWF51OXBX4fP0Zd9+5knBRLqiFeqFM4jYA0EOwRamEkcI5IS2G8TDheMvYTBQ1bCoGEjKG4YZ+i9QiOBEQUZRQlERtPoRbqPM4BY4BjyTqF9GIbydFlnUFqiaTwmXauo0xi0yDGpKIgMBDCxfagnBKi5/slEUoiC5Bp1qGXUM7zjU6YTILqu4V16PUtVWX+nkXjxbxkfFBi2YtY79hj1juhcNY6aih2GqJpuxBgj2wlOc8Cx5U9o9uN5+v71a+rILh5qy4XFszl4Oagpn6cp3tPfdO8lxdExbgm1FEvfv/9D/06ZJruv7q/ujfbolbv7HAKZZxnb9/0+0MpDbSV+5MFxT+V39msd1952xgkFj8eG2QHwxPZEBjVEoWCDY3NJRZQMSGibE7kppHcvSOcpwvYKDHw3C/eNOrBTTfdZBRD7/ndtiAHJSiRM84t2AjI6YMwEdLGYLHJMsaolIwlGzYqKWMUrUgIY8hmjaG+74H7NXr5bN384N2aOnOGaleuqqr5AX3/7qdFv88GBTlgQ+dz41UrMKRsJja/0DbNbz/kXpUFfB+MVsaUJYas4f1jYBkfNldCtzwLNjgIAPeLIWfT4/tsZii5PCuIAC9UBp4XJIAcM8aHv7eVyPb3eLF5QF7ZXNhQuAY2QZ4JRJV5zOfxu8x3NhiUGZ4H4wjJQlnwvi+KBiFgfgYBZxOO3DTKCmzoXD9riPxjqrrtRretwLNhbC25REFC1YMoQChxOGybG9IEmDMoOByniCrJRsv4MN7e1lz5BUHd+d5wfTZ2qiGPJbXGgmhmpafr2Qt7qWOz4htvabBrl3WG0hYJ5h1kh7lvc4yZJ/60NLW56B4pIzVbVa1COd3QpaGOPuoo8xn2LHIKXvgsxpZ1wDXaFKBIMC9xZplvkA9b+QyRY40QksYR5O8hhbwXDlO0Zwl5wp5DKFljvJi7EG/WBSokNoCxwoYgKtCNgygNdtzb5or3wyay5lBOcSzYL3DMuS7WFQSVlAPTm3JYycUsqKo4HjiQEKyCUL76TT9duaENSR/j+Nhh36pRjZbFciE5apFxYH0zP5ijFAFBHnGaUHwj2w4BxoI8e+Y994LTmhvcqOOu3Ff7n91U/orFC/hWLcjRH4NX6pR9r9JZp54XNbWHVANbSe4F6weSjt3f1mv83wRHKOPAi7Pe07Cl35sjE5MFeXPrZq5S5RY1Ej63HsMw/a0JWjtkgdlY2azIM8NgQSwIZ3iVF3L+IJtI9ZChWMALh3SyERIqQdnYkYCChyG2R5YxDhhlwonkztgCI75PKIgNE+UuXrCxYkwJaxNexUhhKFEnMdYoX5AVSC1tcEo6p5mjJ/H4Mba29QmGDWUTY0g4HiXAPieuGfWD+8Orjqeimr9hU8Hw4albb53vt/v0nqR7nHqx++/rVW1xjiFzEEGUCe4HksKL+0G55V7YQG0Tb+YbX9vfQ0XhX0ioIQB+v9lsuVb7M/t78VbWlyW4dsbOSz4jCW68P+PFfaFmcL/kfjIevH8i71PaZ8Tzu6QEUNVLyNuGtyGKqL2EFCEikCIcIzZJ7Ae/yzNG/ce+BAJpuvH1z/X173/F3d8R0gmxHHjFSWrfJP5+e+THMccgDlwjY+glkPbYQYgSRAxnhBxa5ue6Gs1Uo1P3oghAouCaLzm0iz7rd58hV6iJrE/SS3BMqJDHceFf1jZ2KFrFPaFQogcQINY69gOQL4kqD6FnDTD/uQfsAmk8FswdHAKIpO3CwbpgjfHekEgKu3Bosfl27fDsiEKh5HnJEO+HXSG0zXjyN9wbeYE0VUflx1by3qiuOEA467aNUCywzlG6IagQ00lrv9GQhfHngm6FsE8tfN2UNat1EYFEOQeMkSWQEODSIk9U0XMqFznwvJe3eA1l9Zhjjlaf+6/X0K8/1VNPP6X5MxfrnBMv0W239S3qPRoN7DFEXiJzXlF5GT/2CIctcIQyDtw3pb9+W5Nafp6CYXWtvreWBFdo+vrZcYfO8eJCf+Xo3BrH68jDjzCbBqoini6LDEXCqyxADjHQVOahTtgQjBcYZAwLCgW/S4gu3lZC2xPkoGGIvZ4zmyRGG6LnrRBGJYBkk1dTGsjPgTCiEuCZQ7wxzITSMWi8D4YE1Qavv7Rj7bzqpA3H2zZAjD/Gh1wcyIa3qIh74zmyiaGGRPO6I4FXzMZPThchNMJD4MAvH9XKvMIweyp464Dz1aFaQ3P9KB+E6uzJIV6wETGHcGYA+buQbhRDS7DIwbVFXWxs3hykSDAHCVvzXFB4eI48E8LdvJ8ln2xqKLooolwXOW44BqhAkAAvmY0kt8x73pewJc8dNYMXZCzyd0t6n8ivuSaIAEQEZZB1Gc/flfazfwLMxdp7HaIaXQ5LPD0gHJIvWKA6s35Qhl8lkl9ejBdEBzKA/cGuMe/4GWPI+uH/PF9egPVue+TWbtxUE7JbRM1XjpdQPnJMRx12cFeTMwzJ4rMhCSiUkFyuF0JCZCRaZTZEFJJJJAjiic0iPOuNEmGzsAOsERxXHA7WLvcG8WM943DaI3NZL0RIIKkQK2wdRBSHAKDkoX57U24A70dhEcQUtQ4iBonkX1JEmKN8DtXLKJasNdaYJfWR/SGjAYUShwXR4r3FfbQk9y9TiJMsctbl68GuI1WnVr2iHEhIJMQ1XkD0iT4wTqi5kSkmjDf3jJ3m5xBx9j57vngsQLB5L/YJnoVXNceOQ8xT7SzyX4MjlHHgtj8eN8cepgJC1l1r7qW91rfWQ388J1+LciWGwe3P2qm5butytdL8hX36IBIYJggjxjhyk8aTxjPGSESrKiUEyCaMYcHwoVTEW8W7vYEhgHBZj9+CIgy8bgiLzUGkNQeGmfBUtF6Z9pxrjCiGFYNFnhtqL8QbIghBhZzzeSgC8fbcjKZOYnAx+ISsuAdCsqgVqAlesJkSgiW0YqtdSwIbGM8cQ4eijFEDT0werldm/pTSqT31ylXWVz2ulv/vFheQOZLlbRqAF6gnVGpTvADphtyRG2nHlbw48npRCnheJTXDR21C0eP92HAhDRDMyBAoJNUew4mCRWUo78u1EapEcY/nmZmk/YceMpsKGz3hK+4h1ukxJQF1GYcE4oGiyz2UFSAIpRFR1F3Co8w/SATFGqiM5JDZ37H/sqFCcrzhO1R3xh4ijFIzbPhwBfc5QWnZsVWbEhEOq+bqWaqwZn6xz/ZWe0PAcaZsQQiwSruXSLMWrG2yXQ0iUe/gE1Rt9y4Jt2Xh/VZO/FGLR21RCiPh7abA2HhJsbd5POsD0gkBtUfK8jNsNTYaBxhnBxLHeocsE9rFBns7N/A9IhWQZZRmnFucXz6DdcUcR9lkfTHPLFE3vSJ/+82QU+wOed84XfyOvVbmBjmHkGbWJc8dJY+wMMSecDjrAbsXSxXnc7hH7vWlgS9q6V4fqSzQPe0GdW5xUFL5zdhcyCTOOKHyyJOtIIXMb6I5EEjOvcdJjgeQT8gtz8lbU4DNZd+AWJbUI3lnhCOUceDBqc9r7OripyAkQygLxq7ToKvfMN7mpQ9erdGbJ2lzQ5nKXJRISrkJ31DE07lSO714+dPq3GAPvfP22+Y9MG7kyhCeRmnxnkZgySIkDIND8rQX/C3kAAIJIYHg8Ls7KmyCOypYtGMAbQ4iChlG0OYXQhYhcJENyBkzlAI8cZQ0jAoGGCKJ0eZvrHHlveJFNHUSYNxQBtjY2SRQDlALUD0jgbpGQQDXyfMtDXjYbCBcK0YNArZg42od9vXTSQe9KTi7oU0PndN8y5xiXGzrHm86BM+G/FLGmk3Pqq5W+WXDghiwCaFQovbE2ix4L4gjZJRNFGJNnl+0QhZ7Ag/Em3QBxopwLYoJ18O8R7mJF2zwzC/GHyJGfiXzI15YJYtqXp7v9lT5besX2v/QXgiywdc4LLHGGuLOfESFYgNGJSMfjXVh2xJ1PvJEbdgl+RxTPrlB9cq6/6g9zfyw4WtsE9eMCseztSFdSyBxDOw51own/0a2COPvIWk4cOTWms/zB7T3xX21KbNy3HOf3pONK6TrvI6NdO45Z5tQKQoe1wQBIbSMIkX4lDVN9APbEo3cQzogaxAMcgwZT5wsfsa14sSy/rH5KLDkansBUYVsYnu4Pz6fCAlrAQJHfh5kHEeV98MZIsed38WZiEaytyUsyc6ulq4+35bN2dSnNLpfu1RIfC9iPkMmGSecKm86As8IO0LKAo4MzwDHNpF8Rwg2f48D5HU2mQ84EbFOb9uZ4aq84wDHKI5fPbnYiTiJIhgKatEf84zyQliEjfDD819SRrUs1exYX4cc3VOjfx2ttUtW66lrH9Hx+x2r2udlGeXkkosvNkaPIhUWCRt2JJnEgLG5oYqhvniBkULN4zPZdDHG8YRX/0mwyWE88dajgVANiiJqDBsQKgCGFoPNZuRtQM4Gxu8xBowPhAQCQajEnklL6JP3xOgkApRREHmWOHmGbOy2qhMvOfJoNgs2L1IXUJZRCtj0SwJzApIHSAeATNVKL6/qqwq0vLJPvkSVtrCUHvDr2EYdin0bhQPygfPhJZSEB217D++mz3NAIbBH1aGqoCiihEMEmZ+RjbkhB4w/pBjyiYISjRBBTBgfNnvIJEoJ64ANn7A/z5q5zTjjaMQDCAPhLJwsnh9kjPeCWKLYxRyucNjkkKGIo/ZzHdurkM0WbkAemes4QuTfcd0lKTyQEXLB2FAhwhAUQqO8D3nJOGasp4ETFhXrTJDw9aHOr1yr/Y48XrlL5hblHdsTdyBBfLYljpaExTpMwAtCsqRU2EIN5hL29NDDj1Dft7/SVxOmm7C7YqiVha2mpYIF0zXtj1FaWv8aY2N43qhuAKUX8oCShcrH93E4YinfOCCEacnd5m+Ze94iOxRDxh7F3toWrh0nmRxxbBPEyPa5JS2GFBnWC88LYYD3hoxSYMP9Y7dwWFHWIerMW9YRtqOklArWDvaCtcacYQ+wP2M+42CxN0RLxeAeSHPBaSQ9Z31eYX5uWcDvSzwyYPr/du9edEa5l0wyj7EVXCv2B6eb+Zdo8QxOO2qvl0yiFjOGjLfD1tgxY507GDibOxUyCQIK6LmrnzTeLBsZE53FwDGKwT826uXL+ikwMU9LvpmjGb8XVmWyAWNcrCEgf4UCEW97IAs2VgwWIS1vTiWGB2JAwjN5PrTX2dHJpLdlEGGgaMAocy+El6guxvCx+Pke48v3IHKQRww26iAhSd4PcgnxwDCSGkBYg/dL5OhFq06yiaBORp5BDKGEUKFAoCRybTbhPBow5PwOm4gtpogFCCQbka0oZYPBwRhz6/PKDqeZU3jiBhu9T+q5tqqqZGyZN4AxgTCRc4hiAiiGIp+MeRhZxMWmxCbHhgVBZgww9ow14TbGA1URQ8/z4j0gm4SNINuoPNFIEUoWz5MN0xJ48tn4O0seeaYQQzYSCFcigJShcLA+GEueA84FG1EkUItQsyCTNAmHkG4PMmmJJIoMii4bPIQe9Q+1vbRwIePPs8OphPSj6rAmUOmxDcw71kGlOg2TJpNeZFatZewQz57xgjDy+awFNmr+z7qBGJSWt4edhFTxXpBJwNwj+gDBykxP0yNnHaG+h++pNdMnmuZuhWMWKhoXCobomZnxx9cK/TFKq1asMDmPOJSWTAKeJ+NJqNq2q4lFJnkmpDwwf+yaJarC9fK39mAJnCFsM9ePg4wSzFrhM1DkiXAwr1nXjA1/g+1HzWU+EqrlPiCn/AuRwqlC1eX5k0qD4IBdh8BjF3jGkCyiUXwmv2ttKs4zzxpVmxZA/C1OBT/n+4wp1wVRhYTZHqasbdYJc7BK+eqGu5cFsgOxT3+KZXdZAyiHjDP2HjA+2Cuuj+tmbAhPYyuZd4kCO4XT4wX3T7qGt8uIwxY4QhkH6mTVVPvKu5qwdVIIS5vGrFSn3fc0HjWEEJUSA0AemM27ImQGAbHEA6OPB084igWPIYnW/BdjxQZL+M62vYAYselhPDAmENmS2gftaLAnOMRSKAFhIkJKGF3bLJvcUnLauF8UHDYexgyjQ7iZMWQ8yUWKbB+TKKGMpU7a64e8sqlaQkn+VKz3h4ShHNlzdksKZWEs2VDwlvkb1B5y077/fJje7XGpOdIxEEdOmTnR2udTi0nr9MiZV5oQTyQw0BhQyAv/or6g7kb2AkXlITzEZglJt8VGhP15RqgfEFFUFq6XeY8KhMqEyhIrQR7iyWfa8CH3jlJFmJtNzus8cQ08X8iR7QwQL7hW1gfPiPeBqHNN3KfNc4NgsuFCyvg57Xa2dV9LSAuEj00f8gOhZQwhKczteD4fp4roBmqXNx0EQB5wrAA/W7ex0HFIBVxR37vuLpyT339vPhebx3P3qkQQA0hBSfm1PEcUe541YwF5x4biHHrz1xiHbz55V8GJI3Rxm6qa/+VbSps1Xjcd21UPnnGYvr7rQj169pF68dH7THELzxF10oZw7WcxrkQMsBX0cmR8YoH3Yb16CSXXhpPLs2KO2pA+jj1OE2sHGwCJRFWGIOOUokyS0hFJYLgmxoeUHew510pIHVvHPLD2vjR4u2Uw5pHgHrgunEfsAOsIJxlHDoKLvYFY8sywOX1vu12TRyyRLyUK4VOV9LqqkVm8uKgkMN6owqxFyCSpBKxPyC57ANfIWHHNdmzYZxMllLwndiYyLYwxh6R7jzF12IKdmlCyODcW5Ghl3mptLNhUYlug4xocmpRKSfgomB/Ugk+nG+8XtQxvm8Vgwwl4rpZQQmq8oVE2NdsqA8MceUoMGwzeLBMcg2PJDF4amyFhLT6rpArbHRF4y9bbjgZUK4giRJuxwTuFvPBM2QzYbPjX5kFBjDDeGPxYTdsTIZQlqZOAz4JQYsxQ9+xGYnsCRgObDAozmyWkpiRAmjCSEC2IMeoPG2/zSrX0fteL1LNea/Is6Fa+1d9asrlr5boasM+Z+qTP48YZgRhDCu0Ga+cf70vYG6Wc3CHCo94TfmxTfDZniCcbcSRQS5ifzEdIAfPWgudo1ZNI8DdsxhA421yYMC1fRzZRZ23wezx7iACEJlFAeFBOIQuE3yGNbFSkkTDOXCfXQxXutgZ50sxpNnfmEPMC8keVb7xEFscKVRi1jJSPaICgQKQgWRvWJT5mkaAw7MN339Hll19u0iNQ0CieiHSSrNMYjVDyu9g71ir3ACAIOIzRcnJ51hBn7nHejGnKnTNZTQKbdPqBe+jIjq1VvWJhVAaCwDyGOKEmUshlT63BPuPQQ1ooDmMNljTOloiTy2rVelJtuBbEAPKibYcKfhdSZlNVsPU4vNxbrJZk2At+joMGIefayAXkM1Dr4wXrGcGBNYsiSe4fDp43hAsJsxEJbAHrAGLJM8LJom0Oc9GqtTyD3wetSKnCG3SqdkzccxkijHrMtTPmrEtyl5kj3B/zDfuKQ+4tNE2GUPL82Zu9hJJxtD2Qd8ZTcOLBTplDCYEctvQHDVvyvdYVbGnKmh0oZ8LbPescqDpZxUnC7pVb6ewmvfXanPgr20yhjc+nla/P0O+jxuu7Vt8ZZZIFbDc7FrQllLbtCZ4RxoRFgbfMxMaYEH6JzDWCAEBebMIx+T6E6yA5hB3t2aj/NmDIUCe9C9c2ICdfjvAkP2NjRwlgXOwZ3BANfg/iAuEjFGqP0ioJiRBK1Ek+P5o6aa+fjZ/NCWNmPVrU55Ly8zBWhOKs2owyFQnUCWs02SQIb3l7qdUqV0m98xvoqfPO1TVvPq3p2blalbdR+aGgKqZnae8au+jUXTqrbdUtrTkIwaEaQgxRWyCJ1iizyZAzxNhAeL1qIikGhJn5XVTfWEUtvCcbJ4QPssdGzobLZ6LMQCrZlPkdlBvIKZs+RI6fsZnZMBRKJflm0Y6thCRg9Bk7lE0UhWSqtwmToaCySTHW3D8hSO4/UuUra0BYCUfzL7nBEIhkNjHGHHsDYaRYKdrfo/QQZmVcmf+hDWsULlchpbA3n/PX7+M1beVCQwLsmmI9El6GCHBNFJ+AyMpcyCfkyxaw8PywfRD9WB0pbHNu8mhZ/9jCyKIeb/gfsoqTg9NAKhHXBaFkbuL0UOgX6znTixWnyrYHoiuEdSpx8CB/rGG+x3zh+llXEGfmOHMSpycyD96C98DxZU2yT0Aeme+otMl05CBfkudrU2uwKaxZnhPEzJ6TzTXxbGx+ZUkgOtS9/XFaOXeiqjbgBLjECVbAl6bdq8R3ygwOFWsAcotiz5gS9kYsgWRiT7ypC14kQyhZE4y13ZsBkRQcShfujo2dilDmBHP1wsy39eOKcSYsE9kIelMwR0MWjdTgRV+rU9XddUXzs1QxfcvCyp4S1vwPp6jBma3lC/tK1HdN2x+/X1nDc/XTa98YkocXiBJAYQhGlBCiVa+s18rEt0oWRIlKTAwQXhmbLR64JYlsOHiReI8okHiNGFZIKBtIZAHEvwksXJs/GdmAnDAHKi+qi60GRp2CZELQCXegYpFfl8gYxEsorTqJUY6mTrKJoqCygeAc8Ezt8V0QSghaSWBD4x4gRBg2Wz2MagORhWziOfOc2XQgUHyGdxPg+TeuXluPHHFu3JsQRQIQMhQtey4wY2LDYWyA5MNZsOnxu2xMODKxwoMobcxNe2woRA01FscAkka4ig2asCzGmp8RauN5Q4i4LgsUQ54/7xcLbCyQTjYawuw2NSFR2JNGWLMoO6xVlGHba5DrKEuQnwWRZLx4voQpyatLRg1hrvCsIJWQBsg3jifzyb4gGSjOAIWMcGuHDs01NcUcykoZAe13yP76dtQoUxAImPvYPeYoURpC4fazya3l55BMnGd+ZlsKMcbM75LyLHlOzHfy/iCJRHhwzGMRSlQtCAnkBIcFosB8wx5TIMTajTwggfsg1YF5jt2FsJJugd2F9BEhAbwn78P78ruQXGwUtmDYiJF6esBAjRw/WT9OnKpFy1epXs0tERhsFzl/RFR4P8Lm2H3IL2lRhMUTdWYYG3J9ef5cK4SbcC5OCveKIAHJZQ+CsDPf48mxZy59880orfl2ni56fZ/CaqcEp+lhda9UViD6Eaxe2F7BiCbYeEg6toL9IZ7T0WzaUSJgbTDnvCk1fBb2ijQyh5085L0+f6P6/vGEfloxzjQVj3WqiA1rU9V9yx+PaNXmNWZzxevFIwqP26iNA+Zr7lf/Z+8uwCSrjr6B18ysO4u7u3sIEiR4CO7uFoKFIMEtJEAgCSFYgASCu4YAwd2COyywiy8L6zIz93t+dzjD3d7ume6Z4X3zvZniaWa2p/vec8+pU/Wvf9U5580cNOYbj09piubGpjy1bQLXNUVMP7xvPLj7DXH89kfmLJoIkxPiVE1mToKR4eyTscSipVQgZ5vYGY6RIUjpGsYWyAKopBdtaeFvDCXgxWn//wwmE8PHsAEsnASWEVDA7kp7YQYZaukbTpehNfn1JxCEIai1D6oFlImdxHS0t6AopbwJo11ppXdRgOO0YTjQyDlavIC5A5DcF/usT3yWg2DsknCIAJUApFZGg55jEdVJcdCcpfthl4obvEuB0z9iOyqMTjmmxWpWqVS6DkxjnzgGYDRdTx9ZkON9hfTAmz7mBIyJ98wrwA64ECy0t9+kuYqNEXBVs4K4VOgB3fPsAC2wZxGF+SV9Kc3GASfA1BkBoPQR5oitwczqCwC9I2BSv7MTmCb2AcMqUADOAOKU3sTOcdDS+4AnoHTF2SfHwL7TMr/ViubutcEP45xz/xD3PfpkPPnyG3Hh5VfGhhtvnAdi0rfmrAAL0w1IAgdKV8wNYLq4PyU2UADmBRiZF5x9mlNEuwVuAkjPAbCaE+UAJaANfOoHpQTmEP0AENOm5lhpc9c9zAVgRlCHFKB3AiKBvXuZl3SXvfE3IB6rrO+xkgDhVrvvE1/OsFCsefxFce2wSTHf1j+LubY+KDY8/a9x4MW3xAMvvpX3gfHxDAI3fZFKFFJGAACvBJJLhV6ao0CpjAawio3GuKXSKIGcdqvvpg9YfUDROLUl5oDgA3Cea8AS8Y+Th0XjFL6w/Xalcpq1Z9ozlhoy7T7J5XQZ2GfvzMe0wAvg10fVHLXbUYayXP2k/mzvoIv/ZvmvYCinNE+J0984Pz4c/3HVx9MBlp9PHBlHPHl6/HP3a2PUZyPzKJFTme7d6fLPvPzHx2PVPdeJZddcIR5+4pGYMm5S9JvYO6a8PCb+dt+Dce/RN+VOh4PgoBgYrJbaHJObAWNE0irRxEQxttgZjiCBFp9V68PZcuCcmolvsnFEjBiw1VaB+/8PwhFwGgwbR4e90G+ATjo9gVGS4hDJcybqigAUTkd/M87AeK1bO1QDKNtjJ4u1YZwSY56MGcONtahG6IJ+ADRSQTyj77lTWhmgBjrUZaX9OAmDC0iW2w2gGqFTGCuAMm0KDFRhwoFV4Eq6mtDJcvfh4H0Go2wsBAB+BwaBzHKLCTyfwCDtVwgQC5I4WA6MUzTW1Z59DlS5JyAgGMHIVOuMAY58G51LL53q+YyFxTvAKv2jd1hTQKDWbUk4SYykFB7b4lmBl1pApMBSnR2QlZhHjjaBsrQ3LcfbwkAu02b5R68ePWKnNZaNC+55suY9TZ0806tHQ7wx/PNY7Vfnx+TG74Bh/yFLxt6/3SF+NP9MeTqcPsvACKABOJKe27ySRmYXtd9LEKmfbJ+TBOOJ1RTApeMKfaZ4HGup+LvFKcZVlkiQp86zaH+kmAEX42Hu0lU2m5013kBYErZA+8wNtkMQ63uY9vGTG+OIv90VT0waGr3nHTxVf+RtpAOvvR+PvPZ+TPr6y1h57fXjlKMObz2GFfEgEDDPBZV8RrmjH9PzGve0nZcMB/AMTNFL+k830ilWSAeBRbGkJrGffEu5Y3gFl8bKd/WPue+5AdPZZpg71jl8zhg5+aOoj4Zojqmf1eIdNM6EUU3x9aPTx8pHtb9A1DMLqPk1Yy04lJlgT6oF1kQfAKZpb9z2hB4JftnBok1QglHLPrf/lZL9F8jdnzyUbfHY/h16bf7wvtnyB66R7zrer1+/rK6uLhswYEC2zz77ZM8991zrPfr375//ffnll88/+/HHH2c333xz/vstt9ySTZo0Kdtkk02y+vr6bLbZZmvZxTwim2666bL3338/v8Yrr7ySv9ezZ8/8/QkTJkzzLLvuums2cODA/HMLLbRQ3p5jjjkmmzx5cvb/s7z55pvZoYcemj936ptjjz02mzJlSutnGhsbs+uvvz5bbrnl8r+vuOKK2U033ZQ1NTW1fuatt97K/6afn3jiiZra8Lvf/S4fx7bkqKOOysf/iy++qPiZs846K79Oc3Nzdskll+Tt0fa///3v+e9fffVVVe2hM6uvvnr+HXr12WefTfOZO++8s1Vnvvnmm/w+c889d7bbbrtlnZWzzz47v/Ycc8yRvf7661mPHj2yfffdN+9b75955pnTfMczn3/++Vnfvn2zhRdeuHWOeJallloqW3LJJbOJEydWvOcf/vCH/NrXXHNN/m9je/fdd2errrpq6xw86KCDstdee62qZ3DfNdZYI5txxhmzYcOGVaWHCy64YDZ06NDsoYceavOzn3zySW4H9McCCyyQ66Lnb08effTRbJ111smfR5+U6nBb97vrrruy0047Ldt6663ze6a50qtXr1xHttlmm7yPVllllVwfOiJTGpuy/S64MVv60HOyJQ/5XVWvJQ4+q/X3ZQ4r/730/sF/uTUbM2FiNssss2TzzDNP6zMUX8sss0xuD2677bbs66+/bm2buWNeX3755flcXH/99Vvne+k1Nthgg+zkk0/Orr322uzFF1/Mxo8fn2222Wa5DqZxYmPodel3F1lkkeyUU07J3nnnnezDDz/MDjzwwKx3797Z4MGDc3u78847t352+umnz/veeCQZOWZc9pPTLqvYF6Uvfb3yL/+YvTTsk9Zr7L777rmNI8OHD8/vdccdd7T+fezYsXn/mJNzzjln/nd2Z9NNN80uuuii7LrrrmttI19UFP3is2PGjGl9T594lhNOOGEanXj88cezeeedN/c9V155Zf4ev6bvBg0alPer73847pXslo/OyH7z2ibZ6a9umL9Oe3nD7KphR2dvjX4iO/KoX+ZzsT19Z8dck3/T/hVWWKFme56ELXGNoh61JWydz993332t71111VX5e8ahWyrL//mUt2jsrk8eqLW84zupr4uZ15sn6hrq8tSDVLRaFhE0VjCJKBArJKUt0rayEdsgXS2tIjpKx+RJXYhkRZ/alzbiTilabKSoqtz+dpgi93AvKQcRtzq6ao8J/E8SEb2Um9QTpkFtDCZSBEwwXCJK0SVGQZoRc6TfpM6kQLFoxbQuxldxuQhWqUEq/O8KhrK9ld2lWwbRg1SPhPlItbJYs/Yk7S0p3eu5MbbFNF8SbCWmRbulg9XcSrNVu7l3JcFKYgIw4q4tJakd9B7zgWks1jYS7BHG1L2lw608T3PEKkz1Zca43GIaIhWKkbdIIrGtxtZ+eH5azGQuYWO1BXsrRdnWmJmXat+Mg7aZM5XEXFKfbP5haeyU0JZgxfQHhlBmQG0lxkcWo9LzScVjSvWVdmGNSnVY/xp/ZQvqZdkQ96LTaRss38eCYczc33NhVLH6PoulKrdyuBrp0VAfv9t9k1h9sXnzfUrt59jeThY4qKy5hZVqKrOzQPH9B195LzY56cL44uvR+YbfxPhoM7aRncTmsw3GTMYGayhTgXkz9rI3GGLlPr6rP9Sd0xULvYi5r/6QLmGAlcTIFmGgZDKkfjGfic01Bum4TzqMHTMHjO21N90amx3wy1hnz0Pj6qfeiLteHhbTzbVAzrJKsZvbaXHR5MbGOPCiW2L4yK8r9kW5lfETpzTG/hfdFCO+almwmfagJKnelL/ADNKJlKFQI0uHZC88s2dUIiXLxaewraX1zfqPPdHHpRkCdrV1zJqacgZS6QRmGxPOLrMzbDG7YBz4L3Znzn6Lx6ZzHBlHLHJrHL7ITfHU8fXx5DENsf3cp8eCA38QP9l4kzzLIXNTSbQLK+w5LDZk+7WpowtMkw2uNu1tTpJiyjttd1bLGeP/jfJ/HlC+PubdGDHhs44fSVdXF31m6B9XPHpdrmjqOIorapMkJ8kgmpSMo+8yaIyBSQcEcRZWyHEA6qX83QpW4DOd8wxgMVLSWUUxIZJhcB21LGn16/9PouBcmtCWPoySVGYyzJylfxPAUDqKQVenJBUEYFnZp5alXGrQe0CQFAnDJDVT7fFk7QHK9moni4AylR4UjRnD7h5tbXBOgK60tyQHCigA0amvigJwp3OopdOlZDjf0j02O7KgwzWt3Jaa1ZbUbrVdxq8oasY41VTnqB2poN179F96t3SfvSKA9XycRuleq1Je+sD7aqfoj2c1VoIGeuTa9KecAP/aZFwq6YPV6uafvtPntZSOKAsQQHpJjel7qfEEllwP8KeXnpMT55gBUM9Q3Ogb2AQCpCgBIbpgjAEEANQzqN1TayjtLgUIfPmMdCTQ7nMJVHVU+vbqGXutOG98/K8bYkjPbzcHr6trrYHL9zClK02NkTVOyU+ocQxiteDpy/GTY+5N94qsri4H4WolgWULsgQjgDKAIpAyNua+mkCpewAT4AAwBXj6CbgCvuipn8ChfgdeBILSlQC4+Se4RwwASgKS9Ez0BBg395S0CE7vfPSZ+OHeR8Ws2xwSrzYPibca+8fAJVaNWX+0WcyxxQFx+2cR/3z5vfjqm2/yOUrufO6NePWjz6oGk8V+GTdxclx4z1OtgFJgqjxAW4l6cWBYkG0uSLf7HDtJx5If8rwCJD5EP5XWUrOPArJEciTRr4IpfUJ/LUAxtwQ2Sl20h/0FYIFa8xA4FbwU08HsZK/6PjHjdLPGp59+d0CA+W38ijXfSdwzHWGqhtj1tYF968jq9s4ASv2TtqyjLwB09+ru9uX/PKB8euSLVW3y3JbY0HzU9OPbrG0qnq8qauYE/c4oqRnjDC3MsacfoJPqJdWKcdppSwROPDGVRSYLC8FQAqxYPGyNFXr/02e5dlS0M7G2nAZnKLr1XACLqDcxsvoBaLdYSe0do6YvRKzVbOTLcXPYnJJ7lm7CXUk4G2NYXBRQKztZZChJAlWMGbaMY6wEKBl/QISBVr+T9pZk2Dg+3ysHZhlcbU6gJtWkdVTURXEaQD7WhbMvMr3GKc0Fuux+HD0wpo6raHgxs57HcxRrz8ptXk5HsHJFtt140HNzioMhnKZ6WSBTn9Aj9VX0Sn0jxqa4l2YCfZyfldNFMJzYKoEioAwYJ2BQqwCk9A5rKXg0X+kBpllQSR/pEOArQAKu6TkW15zWbitxMWfsB9bNZ4FhK/8B0NKttJI4ug84cO9KoL0W0X+HHXZoDJ34Zdx36oHx14O2iS1/uGT8aLF5ov/EUTHqzedj0R5jo27Em1HXo0fVYDKJz/ebZe7Y45jTc3BcbgGd59R/+krwLJDAQgKDAD97Ora5Ie589aNYfvsDYpNfnBYf9Zoxes48d86mpe2ijDFGDIPHJutTesLuJqBGp4BRQCdnqOrqYpbVN4kZNtg1RvYYlB/nqD3aDQSnMXhj+Bf5sY8fzrRU9B86Y0t94sMvSGx1SIDQO557Pc497/y8ZlIQC/ilGmrzw1w0P9kCQWo5faAv9JifYVPKCbsBJKbThwj7KijCgmJ1+Rv3lmEwL30eqGWT01wF2OgvHSwFbe6f2FUi8DGPSwGlmmuAmI7LwFmAZS52xeLSBCjLZXiqOSFHZkEQ57m75b8cUI5pHJufLtcZsUCnuF9lOQEME7jDmJgUgBLhSE0sESNFZeCkU0RdJiKWEqOJbfAeBsNPzpmBEn1iPRgYztrE5ZhE4Jz+f7JgCNIWK2lTWpGssgE/sStJsDfAt1WUGFzsk+gbS9PW3o3lACUgAwwBIwAEo9ieJCBTjqWslp00tsUtj0qNGRavHKDECqTSB2OqYL7IhANr9ECfYWqKwqkAbPQPgC234rpawSbqMzqLKcd0AEr6BOjDfHE2HAvDq13YNe9xEqULPuydZ2U3MFWpIN7iKXOFgyotttcfUsgcfznHqT/1CdBrHklhSlsKRuhR8RhLDkEKU4mIPgTgBTjmkvZbzFVN0X5b4vvahGFM5x97j1MFrDliOi5AkskwphwWe8GpapeV/J6heBJMW0J3BDrStG1tp1SLpCMZBX7A1rLzzR7HbrVOnLfPFvH4+SfFz9ZcMm74/akRsy5YM5j8TrL4qv8s04D/SpKf6rTggrHnnnvF7keeFPNtdUAstOtRMfMqG8aUmeePYZN7x3RLrxGj518lBm+4Z6y5y4Gx4io/zBeymLd0mC1iRwUXWDaBGmGHsP/sxnLLLx9zrrtdTL9sy4KVtp4Pq0gaew+ItwcvFFfd83C89fGX5c4TqFqmOFv7suvy34FB+o8x9RxY/PZKGegD8MyGKh+pVGLi+V3L3EySDn1wP1kgtiqVfvA3AkfBHTBevK6g0nxK5UpJ+D39XSQ++DC2A7CXpRPQ6f901rk5UZoB6YzUwlDSxdIV3smusbHd8l8OKFtWdXcSUeaGo20mkCMHJihv2gNNhJX+ZvJS1rzOZM458yiT4/G7SS91jWGQ/uG00/YW0kD+7nomJ3BFOCbAgfPpyIkg36d4TuwR1tG2IFImanA4znJlAxg9K3rT3oQmr0iVg2/r6MVKgvFh7IAh99ZXGK1ipFwLoASKq2UnARvfLwWUxZXewEQysH5ir4FgaTv9k1ZQl4p+8zfpT+CjKGklMt3p6LYW9AhoBBIxBBxTOjc6bSCvH7QZa+Jz+pkj4FBKAZ8V+EAdAJdWrpaK4MkKWq/SE3bcB1vnXl5tCccIUAnC0obg5oaaJ0EbtpdI/0l7p6MA6algrqOsrjZizWwvA8ylDatTMEnPjav5ri30G3jEmEnl0vtUB9gRSeece17gryvEymuZAdtUlVvta5z17UkXXBF1PWtb2T71derjnU9HxovD2p6XRZk0pTGO+Oudcfjld8Tkfi1p/dy6YxAbGvIX6TFwSIwcOl+MXmSt6Dlourx/2RcMXAoaBCvpFB42yFh59jFD5owhi61Y02p7oLOxoVeccuMDrbWknemXlTbcPP8dAAZkBNvVrmwWfMlq8DtsRiVJwSdASY/NEfM9nRcuwEulE0AtfUhBb6mN0bfKsQR1xQBBm9nDYmAnQMUeCyQFXggS9/MZzwvMdqXUAijZb9moUkAJSHcm7f7fIv/ne2hAQ7/OH5PUnMUXH33eunlt2fsMGJADSRMES4KNS8dsEU7HJOfsgEbnSWNRMFdSiCJB9TAApsnp5T2pDcyGWhKsVbE2ihNO6YH/BBGhAoFAk6gWIFHnY5IyWhxncSwAKxG4PgMsgAfPCZjXwkiWCpCD0QUoGS5RM2MALKWzdctJ2valFFBWy06WbhlUmvIm+gZzgLVLe0tirDhwIKSt2j1tUGiPAZeyKy4wSem90vR0tcIJcD7SXdgbwAyI42AZU2DSPbBqfhoj38EulDvKUtuANkBZQFRO6LvPcGoW25QK9kg7pO+qFX1E9zB9dAlDKn3MKavfkjoFyrVfcKeMItUutycYLOBZqtWWRJ4NkMUQ0610Wouxoc/YSSDdOAOQxhaAxNBUsx9pe+IZBEruqa9q3baokgCm+s7PtmznqHq2tXP3aqivj4dea5kz7UljU3Mccultcf/L77TLHAJlXn2nmyEW3fmImJg15EyZwB1w9MJO521oaMiZMkHPDDPNHL0X7thJSNrTa0DX7P87ZuKUPBBJ9l5Gp9KWQUURkCqRwLTaLqu9lLH5Z6zppfkBfJnv5m8ae6BbOto859MqBT+AIL9WzAal0i5zIImSJoCUTTH3BHkYVQv9BCpdLbUAytIFOcoBBO/d9ZPVyf95QLnUkEWiqZodV9uS+rq45Q/X5YW6UrcYIk63yHgBlKI8zgWgNCkpIqfCwaupspEwsMJ4mXicE4cDSDAWojTAx/cADobOdYEx0V9agZgE+weEiQpd739LTEL1Z8UNyD1vcQPyolhYw5hjaKVOOS7OnfMHBhmfjjCTReHsAUqgB+OJQfLvtKlvtQwlBkg6tBp2MgFKhlhAUCnlTdJKVkEDwCMVWw0goA/ACifAYSQ2QNrZc/q3RRm1iu/rI2yBIIXj5ZTopPvpG6AFoDRGdE8wYAEF1q1UOAkOXBBU7uhD98BCC6AAtFLgAvhjlzFklY6oa084MzplTNLZzYIzIB6TSC85MM9ZKuZoYlh9Rz2ZvsfKAt7SwUCJ9hOpWCDW9/QXUEkH0nP5nlpBiw60R+mLOVN0tLWK0gTOu3jOeWcFcMEo0/e2TqchI8eM73Q5UWPjlLjwL5fn/ce2CsT0m+cxfuaccdP386yzRTz6+rDWNHM1IvU8Jepj7s2cEDOxVbeKwRhg7iUAnjLd7FHXa9rdNaqVfEV8J2v2U/BSPImpWkCZ2EnPUy5IKxXBqaAXW+7z0tr8DJsuM8GvSH0bFwtTyi1ITcJmqFXmj8oBSsEum5EWnrF3Av8EJLsyzd1RQCkVD8SneQ1Aa6c+6Jb25f88oFxuuiViup6dixp7R8944rIHckfBGUndYjlMcEZXdMeRkMRQUkCpFZOQEwE20xYQ3mPQOBbXxJ4oyDexAQ1MH/DJKEiTieZSYX7pIhwMkcnOAVRbi9QVwgkDuqLadDIEowAYAjSev5gi0DYgE+uFqdRHntU2J9qemDxAusjwdQZQAvzpetKp2FLArdwKw0qAshZ2khhTzjDVF5UaMyAGI83wG3eAsjRQaE8wKRwA5tUiDOyXF9aM+FstIoDBLkgNcwgYPu0F5KS3ODfAUdpbW4FE9U/GzfekmvVt0j9sAyYVg16OcfU5Cy0w/mqxgIVSwV7QEYsBOivmofrJtPId04LVs+hFmk9JBMBpfgGCdI9T4SCl5TCp9Fy6XzAEaHouz0kEl/oQS9nWueH0yAIiTtoiInOfTQDgql0wkIRNocteXXkUXDqz/Pty7uV04ZvRo3M7gA0SgLMhAIigI9UFzzTb7DHdUqt2KNuEOew7w6wxYO6Fc5vkGgno0F+ABgNHD6dferVvt0HqmGBFOyuecPLYltXqSdiy9gCljI/5xG8o62jv8+ygQEmfsFcCFD+VBQCT5r6A0nXoenuL1fSr/vS9dFpY6md2CtkieBZA+ukeQKzv0ONOZxIrSFrsWS1DiZ1MbdFHidXulvbl/zygtMJ7o1l/FHUd3InS8YovX/VMHPKzg3MHi63iEBg8++FRNmwF9otceuXl0ThzfVzwz8tijZ1/HHc988/8c4w+52VSJfDEWfo+o8qhiUKTIiu+Ju5l8mFrvKTSsWZJGAARIaYiFZi73qcTv4g3x7wXr41+Jz8hqLGTdT3F1D1wBegCGYwM5wa4cUKl+3RxCIwcZ85oA8scqefy/VJWLqWMO8tQJlYrjQuxbyJgodYtAc22AGWt7CThFItguJjy1neALoDGkIt+0951tYpFXYAcgwwIYRqkzgFWzDd2sBoBrAAh31dHCHgLdlKQwMBi0wQJgCQ2DCjSH37HLiu5wAQKKNRBAYuAJwa1nGD96KrrlWPBOBrXxGB2RSE8sCatDrhhzDlOupfKKtJ+pkAxkOm+0tccNFDj7xwiHXYNfWSxGEDvM9LObQHJUqHzxg2Iku3wrOyCe1azawM9wpoCv6V7gXZGPKcabc9YzUr3vj06DwDY5aaJLWU/gnF2kj5ib807fWs+Nc4wT0SHF//Y1agppl9mtbxEQTDAfgNSbC4ACzSxDf1nmTPqOlkr11lgJCz76s1/twJK9ohetldDadywk2mroLbIAH3reQVKbKR7JP/BNrGFAkz2BBFQmmWqJIgWuqP0iR9ClOgP9sOY0l32IS1MFByzB98XmCTGudrzvIsLcsx9WYXudHf1Umd38xo+//+ljGscH0e8eEZ8Memr1rO6q90uqHnclLhr+ytj4sjxOdMhmgWoSouS9z32wHh60isx708WjbqeUxukMR99HbN9OiQeu/j+WHKhxfMVlGmLFBEgpwJ0mXDSAQAPoMGIMLDpODH1lIBEOuu5uIiBk3/hlX/HefdfEvd/9UR8NGHqQveBPQbE+rOsHuvNvFpM37u2PeoYG22W2tQWxgWDKvVXqebPdzhcRdYYnsT2pKLvSgLAcfpAQC1OupwwVu5bTMkCPMCSlKcFGcWVitLv6lsxY5yblc4Mo2i7WkApugdUiudHc5YCBMCb43J/hst9OiOAKYegxkkqHzBJW1RhwLDX7QnHIs1N/4AsNZQYPOOMkcOkeiaMYREoA7NYc86YwRbUAEnSdPQW0Eppo6LoYyy1OVS632QS7GZaYNPRWlpAWRsEWrZBUnaSNsknylc4DmBZxoHTBPSYQ4tc3B/4p6sCQX2LeaEXAqf22MhaBLCka5wuAI0VLx6JVxRg35inFG1XMSfskSBMvwlIyj1bumc63u+DKb1j9h9v02kwsN+Kc8eET97Px8tLsFksQ3D9xfb4VdQPmK7lsPCOSpbF7B88Hs888mCuD2nut+7tWlcfSx58VqeepXivjra1T88e8dy5v4gr/3p5DqhlA8wlfV5ukRRhY9k7ZS/G0XwuJykAEhDRM3qufxEVgChwaU7Tc/3DRtVyzCFhgywopacp8ya7kfa8RJ6YY+7hnjIV3yegJPwpJlQwWUlkGWUmBHZS8/pQ0FZKEnTLfzFDSfr36BfHL/7zGNSzfw4Sq5G6rC76NvSO3/3w+HjgjvtzQKH2hkJSLuwM5zOpaXKc/eYl8eVGWcyzybRgkgyYfVCMXj6Lxf6wRjwz+uUcYEivYHDU1HF6nAkWRK0V4dhNsiJTAHwCIpw2oMkhJ0Zj19P3jWUuWDcuH35TDJ/wadntk24a/o/Y97lj4/L3b6yqrrS9DcjLgUlAEBDRRgXfomwO2zNiKNszHBhK9+sKZ53qKIvCYIjEgbBSdqfIUHaEnUztL/YLg0lP9FvaW1I5ABBRa5qzVBh8Dsb109m9yi8SKGtPBAmeEbsoqAG2jZuz4kXlGA+seNrQuCjJ0aX+ZawT68ZRlGNepe0whan8oJwAEhhXgVO1YFK76Vfa6NucMr8wiok1VfzvnoIyqzjTghwBor07jQ3A6TmsaNVGz4GtAfKktDkaYAcL01VgkuhzrL0ABzgXBGFMOf2iGGeskbZzdl2ZhhP8YSht2VJ8NnZIbSgHm8CKAM3YHLTNxhFNlQ8CaE9Ygnlmmi72337zXG+BGhkO84+dUGOMLd58iy06DybzG9bFo8+/3LpojT2b6qCArLlT6e7Se3VEGurr4ofzzhjNUya3MpRYVNJWCptus20yE+UWttAdIM+c8LsSmeLODIJJdjoFfGxLOnGsFrEmgM4IfNQjmmPmT8r6KPcCLo0rZlJdZXsHPXSFKD1qj6HUXpIYSuluwXU3mKxe/isAJZmlzwzx26WOirn7t6RkKwFLKW4y/uMx8Zuljsw/L9IyURk9E1C6BEOx6o9WjSOeOi2eGNmyMqy+R/lrSqHU1ddFQ68esdLJ68asG8yfTzgTj3PjnDlACp9qTohJLe2I8UnCqHCKjIZI0GKdG9+5K678+vbo0bdnbqWzCtsk2ULJf7d/cn/87s2/lAWVtWxAXhrdMWq+Y1Uvh8xQYHXUTFYrxT0cuwJQishTfWsSoN1zAVMCg1JAicWqtXYygUfjmdqf9pZMRxdK8RpnjlI/W+3YGXEN7QdAMGyYOP2/2OKLxAxzDo/nPtg9nh+xSTwzfJ144ePN4+0vj4uxk1ruCQximYF8DCUdU/uJdeZQAGrjLaAotzejvvX5tCemz/vdoh3jLp1WNOD6QFACMGHXK+33KKgy1wDZUuEIBTmYUeUiQJfSCGk+bQaMpdSw/IAXPcUGA2DmEebb50rTd9pkbKSdBRscL+AEHHsW81Awh83s7D6VbYl2q9EE7gQenBmQngAQsGe8sd+VtmHqiLBFbInxUT/rmR0GoD1ABXAPSAuABRDGQNB3yoknxDevP9OpbXKWmb5Xnr4HVgUbgg61t4AGmyPQvuLvV3UeTH4rg6efMR9Dc50tLT2ydsq4qU8n66gsOdcsUV9jm22GPsPA/rFE/5adKEqPXawEKDFodMZCF+NXekQhm8SeA5DSzcBkWhyYxN+VA5hT5qpAK53KVK0topeCMDXFAo50NCRQ6hlkPQBJgYP2ptpE8/k/AVAia9gMdsDzYIS70921yX8NoCRSvWcudVScvPghsfL0S0d9SV2lf3325Ifx9SXvx93bXhHXXnjVVE6HowFQpMtIttHgGN7kWMcqN+b99viEpQ5dNWZZZe5ccU1eTiKdQZtSXRwzYCaC5syKW8EwiMAbJ/lW8wfx98++nZA12K8nv3oh/vr+jR3agLwonL9UNgfDyUsRYFYwcqVGqxphxDpbP1kEPUAIJ10qggNBAeCRUs/JuQBXHWEnUyE6UFfcW9LzFFlLxhZY7WxkDkRyJphEY3DcccfEQ88fFX+8oXecccmsMbbp0Rg35fWY2PhBjJ38cnw29rp44ZOfxvMjNo9TztqiNaXF2AMOQAoADViI1ts6OzdtwwSAAeD6E4OP9RSQpNWiySGp6QKwMXGlm58XgQ0ggy0ByrGCnJPvpo2+zT1OCrhS44RZ5JyAc4DefekiYArUYv2qWR3L4bg3fXYvQSOQSR8Fb5gW+mx+mq8pdd7Vol8BOClM80ma0Jy04AqjDhSn+uquEuAB6GBX9C9Wlk7pb0y34IOzVf4gfYnlsoiCDPlmeAzo1aNmUOnzk7/6NE49cLdcL/Qxu4ElBaKLzFjvnl0H4r/5amSup+wu2wbQAM6OFqRHc/WY2LlFOREx5/SD48L9tojF55q5JfVdZX80NDfGRftvGR8Pey/v+7Tlj3Yam0q2iN76rLrwUnZSypntxj6mjES5fWrNJfcQfLMrCUi1deZ2EnNOWQywKvvCpigV8tP9kSTmkfkI8KYTdpSY8HuVFkn+bwBKc1w/yFLwA92Asjb5/sLt/1DhyBcfvFD++mbKmPhi4sgY3zQx+jT0jhl7D42dT98xB1cD+g/InTRHWayzwxoAW4effVQMW6Xj0eyPT908Llrl9HxVLQCiBo0jTqsrGQCGlmBKsHzSEUUGc/0N1o/Vhz4Yoxo71o47P30gZhzRP6654O+5o9c3WAJOnIFoKz3NeGHERKUmoH5Ss1driqQowB9QVumosFpFhM8w60ur84vi2ayG5hyBEo4sAUqpzVrZSZKOMKM3VgJjfYACY1c0ZowbgNnZvQgBfayZ6y+/whIx/w9ui7oh10fPb8etvn5qZ5ZFi9MfO+nl2OmQyBnti84akTtV9XGAd9ryphrBrGOT6CwmCdCin15S0PocAKMbAKBSiHJstTS3vuAYARs1fNqU6ugAxHS+suf1O3a0VD8FX5yahSVqSgGlajYjBuzVSEojS7kCkxh26XP3MIZKXYBK6V5AGigWjKh7TgFmVwqnT488DyDJQWNPBJrmSWdrzugqBial2gknai4oo+D4i3YPADM++klKHBhQmoDt32LnPWLOzfaN+h49qjq/OgeT33wVaw+ZHFc9/VQ+pqXPQx8FNRZFeDXOukL06N/2CTHVSMOUFp1it7BlgBjGla4IqOv7DYyFd69cZ1eN7LDGsjGgb+/YcZGhsc9dt8X0i6+UP1+57Y6kuPXZhM8+iuEP3RjznntEDqyLK7wBSnOqnC7zRXbb8Hm6m2osBTx0lo1GSJgTlQIrmTKZCoKZY9sFVcqt2MX0t1LRLrW/7KVMgIyGIJpoCyDLr5kfromRVEde1CuATWmUQK5SoPk/mfJO9gnIRfDUkl3rlv8yhrJUBvccGAsMnCffq3KhgfPGdL0G5+kXQI4xV6CeTiAplTk3WXgahrNawVSO7zMp3p/SclycVICUkoiO4QEypR6KG5YzMiapSYk9AJKe/fLl+LppTIedS9aUxTHXnppHoZxF2oAcM1XpmtrJ0WJNAAiRvT0RMXKdAZMECytS7iqG0jNIXZbWUSYBWjhUzlU6KAFK4KhWdpJgjN0Tu1TcW7LcCsO0B2VHhSNh9BTVRzTF26MOjYWWmtzCgrejDmlnk+327Rnb7Dk4ZxFF5kBdtWCSAHaYROUDAhG1UUkADUCFo9C3KeXGedF3JQUCB7puHAQwaa9IbcGG+ZzPc0YcEeCKnbRAoVQ/BYHYETqJaQIC2wOT+h+AwshxJkCGgMZP80CNVxLj6PkAZVkKLKG5S1eVMxjvalZo1yqcGnZHTSpd1s/p0IBaBMBI5z9bWW/+Yn7ZHKDK8ysXMJbARNHpm/Pq4JQhpFOSsMfes9/usgvNGzf8cpdYYJaW+VKJ4Uss5tiP3on3rv19fPLB+3nfG0sAUprfYjJMFmafDgkM2OHZ68Z1mjkc/+mHscKiC+Rzj13HxrFlAnpjrh177LBtLD/XDFHXkdPVsixnUzdZcdGcLd9vn71j4abP4x/H7RF7r7tSTDdgamawV4+G2HzlJeK6X+wYm8xaH19/2uIPSgFlW1sGAcHAkvEwnp7BONIVY8ku081K31fziCUEqgF32ROsuLkjeCmnZwI395VhUxMpMPe5BCaLWwixUWmBIlubdr1IIhtGXOf7FH3UVs06HZPlKNZPAuffZ4nL/0X5rwaU5YQxY8QBG0ZXvReGsCiYzcdHPvftsY4dEzWcd3/yYG6QOVssjlo2BpWBk5YB1hgCqW9OklPjBE1mk/cXVx6Xg8KOSl1DXSy+/Qrx4qsv5Y6mra0hRKocJwDAqQIEQA2DXzy9pzOSUsZdWQStn7S90gk5nkdaT3oTaCG1spMMrFSkxSxqJEv3lixnzBKg7OgmC1K67iU9OmL05TFqwsN5lWytsu8vB8f5Fx+ZO53SLZ+qEWwV9gpTWRTPBXzoS86Jw3B9OoYxAQ4BeeAI65dqHoFabIr+t/CsGt0CeABSjpRu6pO2xD0AQmAGiDFu6dQeQQWQIXWIGSzn6DhdbGsqB6G3nLL6MfMCCO4qSaUCwDZAaJyAAM+rntkcrCSAiGfDxOn3BLixr3Rd4CStp//1RakAeYIif9PHalXZQ30C9HC40sVq4Bacc9YcGJ2783oxYPwX06TA65qb4quXn4y3rjgzht18YTROHJ+nYAXIggTtA1DVwWKm9b2MjDpKgcfr993SqX40y+btMSEPLrUby8zOYNeMuewKG2BMrzrhoJg85uuq09X59bOW+vT61x6Oxgnj8/YL1PT/rEMHx4Eb/jD+ddI+8dAp+8WUh6+JlSe/H0/8+sA4fpsfxyKzz5STB+YKIgPIL2UoywXrCADXl+0QZHkm4A0oSuUf9KdSYMXHAXT8mzS3QE65CV3TdoCS7Uw2yk9Ai800Tthzc86CvnKL1NJ+jqnmvhygEyjR5e877d0eQylIpO/anEo8utPdtUs3oCwRyp+OUUsruRnkotjfsbOn79i+6KVv3sh/F/lzQtgOkxP1n07QMMkZc06SgaX0UkQPPPhAzLTiHDko7IxMqWuMYROGl/1b2kcMAMBaioIZMEBAnVNHzx+uJF21B2UpoGRI0pm95QSAAGjSKTqCimrZycQGABgidn1VusK5nDEzrtK71e4XWQpgbQ7M+Pfr1ydGjLYdR8eAaV1dj1hns/oOnVOLyQAs6An2QdDDkeoDAIHj8XyAr2CIk8Ic0qPk8AAybLy5pk6wmnrHoigT0f/uAXi1laIyj7CMwLz0rj7kvC1OKl2coUY5AY/Sc9OTuKdFTNg9QMUcEQQCzsBpNfVnbYlFTkoFME3pudIpJoJPDC6dA0L0ZypboMfAmb486OgTYnhjr9jq4GPjvBvujtsetqfmRbmz9D3zwzOW02vO1Wdc1/MAHhhSfW6OYCqBQn9XMy04Xm+lpePpS8+M1y88Pub7/N8x8h+XxxJj3owLdvxRfPzAjTFlVIu+JwYUi82ZCyDU43pWugPcAcBAOj0f8d7b8c3bL3aQpcyiccLYWHrWwTkTJSCnb8oK3FcwCFwDrsDEH88+M245fr+YY4YheUq63asLnLIs9v7hwvHuUw/mANz4pEVyxWMmsZQrLLZQvPTsU9Gzx3cgzIIYYyHwxZxWc0oO9tEzCEzpoc3MgTzjKVBKO4aUE+DOGOp7m5YnZk4faIPAAdDD/Ata0ulvvpOOBcbgVwr42AWfZ0fTCu/iyXJFoYva8H3VJVcDKM1hNpBdVgoCIFd7JGu3fCfdgLKMSHunM5E5FYxGcV+vsY2d2+4lyZhJ43LDzwGL5DAdnJ3UKQBkQqej+TgUKQSRKOe1xTZbRtZFo1f6PJglDIb7p4UVCqmlBDjfrjozuFQ8v5RnVzGeRP9yXpXS3kmkmhh1wlG2J0CUtKjaIZE+R86xlttKqVLKm3Qk7c35MfTS3V9NeCgmN9UOSlulrik+H3tLNDZVV4fLEWEtlF1Y9cth0F0MT9q7TQo1OTMBCP2RUtNXnLm5VWQ0OF79Wcs5vj4PxHNaGDfjq9ayEpAEhDgLoJOzTxsslwLJJOkMePONE22LdUylFUCV5xQgYkoxPGp0sUa1bhHF5ghy9GlLWcPUbfM3TltphqyGIEa/sxN/+vMFMdPSP4x1j/lDLLDj4TFx/pXjuXG94sJHX4/dz7s+Njrt0jjwN+fHG++8lwPWYvmAuW881IprA/AA9AHf5iU2UqaCXWALgD0BMDBjHhgTwfDWm28aLzz6YKyw0DxxzaUXxfo/Xqf1+snBJ0bYvMfQYY1latgaZTSAOaAj7aiNx229Tswz89Ca0tEerbmpKSY9fWecfWbLvqfmuf4zzz0/YOR56Ib6XeBs4blmi6sO3T62+MGS0btHw7dVJCU1yd8+y7gR70bj07fHz7dpAUaen42sBOjoBABTCqAwtYkNLNZXlwOU7iHVbJyASlkW9waUU6akkgDVsmKCKmwzPU2iVhNrCdCn9wV6gkOBFb/AH7lvJVGiwqex5drkfqnNlQClBXkIk/8tQClIS4eOYEsx713ph/5bpBtQlhETiXIBDFgCRo/zScbQ6TtdIYwUpeVwpX4YOo4rpbw5QBE6RkoKRKoNyLPYYeyY786i7SoRSUo3Mh5YWYYKG8HIMvZduffe973COwkwybC3BygZtGRwGNO2UtHYoHSOtX7BBmAlGNJy6fpyKW+fY7w6Aigt0GCw6ehnY63U79y4ZDElvhh/1zTvC6gw1NLZ0quciHpHTFzaIBiLxCGYI5gMY8gBSc9it4COtJ8qRwT8CdJSeQEnA4Qo67CAqlo9VY8pwPI9LFm5PRkFQNga8yiddgNIAhOVgGRRzEfbXmGMMJvFIzkrCWBnoQIWH/jyb/cDjrBh7t+eSGmbf1gqbS4CPnoJbEhF60eMHmCSgpb5llg2Ft/r+BgxeL74fEL5ldcffzU6Hv+iMRbf96SY1P87Jj6dMZ6APaZTKQDnmgIZbDJwYwGG+lMgA4D2XSuItcVCJU4ZKBQcA4TAbvG8cXYOw536lG019z2veYQ5EyBw9JgjQHPv3XeNnRabISZ8CZi0Dypt29M8eXIMu/mieO+Fp/L3PB9dBJDpq0ASYPNvQK/Y10P6981B7AOn7BtHb7lWLDXXrNE87puonzwhZh3YO0b++5H43darxeQnb4u3nnk0DyaUD7A56VAFz18q7JF+8oxFMZ6pPwBdfZr2xC0FlEor0mpkQJ7PQEIU65jLCV+iTpo9NEbFusckgH4KvPQ9UGjRkrEWTLRVs4/hBdQBajZAQEBnivtplorgmm58n2nv9k7KSSfksNNsXne6u2PSDSjLiAkDLCRWkmPkVKzaJYN6VI7+apFBvQbmYM1qWekr0aVJx7AxsBx5WhjAoDJ6ok+U/N233xVNk8rXBdYq2226TQ4WsE3YWfU6HIaVymj/7/sUg+9jD8pyG5y3BRIZ6ASYsY1ATjlJe0sCCxgsThEbwJAKAioBylJjxlAD7rWu9MZsWJCVWKuJjcoVOnesZl00xOcj38hrp4ADTImVmfQBc8OZcPJqGjn8dKwbZyngAiQ4PkX9+gGI41SsAi7tB+CPUwJGBGxSyxywtGM1Yh5yvJwdhqY4bkk4PnNK/0qrY29SrVet7LrxlM43F6o5eSiJNnFK5qpUMZAlWBMEWDWrr8vV9Zr35iAQwf4kR0jf2AAgiwPWt4JRJQOADIB2630Px4C1touvJ7Rs1l1uVXESczqrb4gDLro5/vXyO3n6VPBKH+k3MK48QX8JmLC0xgwLbx5pi34RaAPrQFICo4ASG6IP0hY99MIrSdq0HhupLGLG2eeKsTPMFxc8+kbs8cdrY4NfnhmfDpon9j786Bx86Xsgfb/dd4n5R70Re62zUgzu11KbV8xK53M8fzXHyFefibeuOjuyrz5uPbVJ6pYe0wtzyTxK2/NUkv+PVI8AAQAASURBVAF9esd2qy0TVx66fZy5+crx4vm/iu3m7RtfPnFXvPH8U/n8p8NKZ9hoOmmOCvrMJbpaFP2kb4DBorDBghiBvLmXp/pHjMj/VqyhpBuCSjZE3+pzjHglhj6Jz5qbgF6qXy0ngiBgVdAI6NEHNZPl9h8uiuDQM9MR90ggWHkU0SeVdNFcoePf18F9bTGU2iuwz0vJHnggZ1S7AWXH5L/i6MWOCOPHqTIGWBaTDJOY14QNGRh7PntUTGhqofI7IjZQ//Tud+P9y17OjbeCd4KZQP1jh7ADIk+TgePglIpyxEOnxjt1wytuqF6VjG+Oe7a4MsaNGZcbjJSeUMckRSll7OV3DML3CS6liz2/lFtXCpZJigcoKmd0GWjPxrm4N4fPsEj1YYRJAvgMq74ApIrg0eeBKMClWFCfmB7gCWNTFACHUxEdVyvScUCKZ8kZihHrxYQpLbWnHZUpU7K48fJv4vzTR+YsIQeSXowspiyBNmlWbCwWg1NLgnmkp9g1TlCgVIlxZMD1NUDouuks8PYEMANszEFsGWBQlLR3o/ovjtA1tbMrSjS0Vd+bh+k0olrF3FIniMUCaLTRnMZgJsBgtwV1mOyOxSlAO93CLJkfUvxeFjMVHfzX4ybElr+9Ir4aO76qrXuSmM1Swu9cc05ko0fmAazn1Nd03BZiaZ9Wc0cwQI+TjTJ+ABngiOUvrnTX78AghsozCE6AhgQQ6f27n38dm/782Hjo9WHR1NTy3fws7SyLhob6/Fl6TBgdR++4SZx8wK55H6pNxTJOaWyK+156J255/IW475HHY/CQ6eKrzz6OccPfjVGvPh31TZPzdnFx+srqdu2o5pzytgSwFnAbD+l+gNo8MVaAtaAzrVzHotMZ4IxuJvtpDsmElYJNtsP8kYqm39h+wS3wmxZOsWVsGkAJsCa2vy3RD7IMPutFh0pFjSPyhK0CaI0ltt0COlmZtlh99eAAqsCGbhRrQPU/28AeVFpEljYRFwwap64WZSGeg46WCv12TwuT2BU/2bn/KSLl/5J0M5QVhLGXzjO5KJafDISUQu+GXrHuzKtWfYxj2Y7vUR+vXPVsPgEBFWkLIoWVIikRn8gXc1AuNbrGoBU7BSazpuZ467p/x47b75hPIA4MQ8roq81ihC1OktZlPNNKURExNpXT6ap4RN9yVF2d8ibq20iltHc6FScdxQjUAtGem9NkaDG1GGpMGmdSykRKT7lGOcBaacsKTJNgoppUamLn1Olx+Gk7ix51XbA3X0N9bLbpDrkjA9akuKRU1R1i1BKYNEbYM8yDWsiiYAQZYkASc9VW+tr1sIYcpGvS/fb0CEMI3HNyHHgRTHIIKSUvCODA6bN+6qp6X8DPnPCSTeiImE9qDTE1WD+1avpZ4AqkqEkFgs0zwQZdS/s/ekbPJBUq4Clli2544uUYOaY2MEnyT9dFLPGTHfPgBmDTz2yOMU51fqmkQYqY8081pcbP78YPIwwcc8oCC4Ea3afnwJT3XSedTLTT4cfHwLW3jwdefS80u+VEsW/tGUD27bM09R0Up9z0UIyde7m44cabWgGhRS0bLrdwrD6kMd677o/xwkUnxwe3XhKT334usskT8r6TncAMey5Me2fBJAG6ARMgDSuPaGAnPBcbmnSZnmPv9aNtsDCOqT8Bz1KGMolrYFSVSAg+iDlnnmAYgcm0Z2Pp7grlJC2qSnvFloJJbRJIG3NpZ3MToE3jqu9K0/OldolO2jEAM1kEk4Rd5D/Y99LjRJMIxjGz31faO9ngcnYmBfTskfsDtt1gsmPSvclSG8J5qpUDFqTZgAzOhENYb9nV47aP7+8wO/nlvz+OsR9+nTOQoieF+9J/7imlKKX11LNPR/1i/WLRk1aNEdNNiW2eOCh61feM6eoGxpcPDo8bT74y1r18u+gza/+aTslJwnhfe+zlsdhc30WEmBITqkj5AxmAghdHiAFKLCJ2AmNXZDMZlFpXDbeVMu6siLYXXXSheP/tf0Q2yfWbI+qHRPRYML788uvc6GMSsNDazehIxWHo1KtypJyDGsDidkBFkY7jBMoBmErpFrV9jDkj21aRexKO0ec57SQDei+en4KTNi3viNgAfbklNonp+7W9whrwVg6AgShX9A/scXjFIv9Kor84Kc6Nw2XsOepyemNuAFtYUGA1FcsDWeYJJo3DxZjKJhT3UOxKMU8xKAINLFS5BVjVCt0CstKKYOnttGE5lkpfYKKqOa+7qbk5rn7k322muNuSuvqGmDRollhuldUimzgu7196bEzSVl4p6ElsX6rnNn7AQOn+gknYT8+HPU4LsvLrTTd7nHPv898CyLaNV3qqQQsuE1f9+6NYcoklor6+Lg8Q6UUp2KEL2g48CkSwg54p7XnYFWQDVl1gnRhZQY5/Kx0AlukhMZ7eZxvYdgE7HVbWZD4Dj+nkGn0LhLM1AB0QqqwGsZC2tQLKgHLfEYS0p4PaJ7DCNHulesYkWFV1yHycrIHnSvOLbmLStcfzpZXg5bYeYiOxv5WOBPVdz8DWCopKxfNIlwN0KbDvSmGD9a/+LtVVgNKYGht+qDvd3XHpZijbEJOPQTfxSTpNhtOcpc+Msf2cm3SIFVT7+MrvW+pJGAjpLEZaPRJDs9rqq8XCOy8bjy35Zpz79mURs/aM+n4N0ZQ15Wn2EZM/j0mr9opN/7FX/GjxH7bUQ9XITJCd5t5sKjBZSUTDALXUrXSJNgOZjB5jyQDpG1sbYbQYciekiLAZRE5YlPw/vWUQyZq/imzsRfHwzT3j6H2fjGzULpGN2i2ykZtF9sUa8cKje8WsMze07jvJWHOewKW0IhbB8yl4rwQmU/srgWEGTJRf2gfpaMpqFuYwhmmLHdcCQKRwTj/m8U6BSdcd9WVz/P6MB1udfTnhtI0/1iwt0kii/ZwAR16sk2tLgCl9LAWsLpOj4XCLbK3+ElyZF5ypBWLGQlkBpg8IxxBJCWLLS0+16mrBCgs0MIhS79KAtUhiV9WpYqgEbxhPbfa76wJoUrqAkmdva7urJI+89n58MbrtU0Cq0YPpFl85D+qAmsSkAZaCRO3EXLNV2EeBJfaM860EJokx4aix14ANmXGu+WKuDXeOLN96rfpImIW7+4U34+RLr8vtDD0sgklzF3DTv2xUqj9ng2SWunJ3CgEo/UtMlpQ3tpkNVLJQqhsYfAGpsWVXsNL6uji+WE59K/3KtvIJCQSzp+orvccOlTtmcZr+yrJ83ARkQK6MQxJzKJVP6DMpdexzcWWzOYeN9pz0tlSAduMvy+LZKh3PSwA2oE7NeaV5Y07J/lR7fngtkra4KxfYe3aAF5gVKBufbumYdAPKNoShZIikuzkDbCKnpwieE9tyjg1i41mnruNqj5lsnNgYjx1+Z0z6ZHwexSZGRhTKOH3y2Sdx7BNnxmL7rhw9BvQqO0pOQ8mP8qrP4ulRL8W4Ed/kW1jUAio3mXWd2Gz2ygCpPQEGsHeMp1QKA8cRMSze83cLDzAUDBImE8MkGgbQbeVSBFiYkEop445KNu7yyD5fLbKxZ8d0g8rscdY8MtZa6bV4/ZGZY2jvq3IDzOlwgNLkDAzjjUHU3rYEoKzEFiRjlo4STAJAWP1bCVACV2mjb6wYRo6jAVyt1FTX98mHPWLUp9NHlnXw1KZoiOFvLBznnPOHXL85HUa9mBrSDnrv+UoX2kh3KRHg4KUUpZzbA5UckNQ95ggzIZ2MZZSO81z6SUrRdbGCykCk4eiYhQ9YEJkCDhCQxKx8n0CyKByulCMdARLaC5T0DxCq/2zJYoW8dmMhlZMIzDBBwIS5o9wE2wNM+h1QAZyAImCunLz0wafRowP7iBYFUzhwzvlzoJsWa6jfE7wIqrRZWrNWUObZbGUEfKZtdAYuskKOI+s6sFsGvbzmiVfirbfebg1AARFCL+go+wMoKYvAYgKXXXWcaxG80sk0T9yT/cLCYu1sq1Uq+lV7ACY6n1ZpJ0npYDaHfmPxixvrA/Z0wPzC5vl3JdEuwZ8gVMAmACPAHCCqPIFNY7utavbvUgGOXQeQLT0xJ209JGuljW21hdB93wFC+dNyYszMJ4HL/xSg9HxphTd7r7Tp+9oW779BugFlO8IRcGTpvFtGBNBUT5cfzTjPVrHnvNtE/4aWtEXzt4XlpUCSfP3WF/HgPjfFjJNbwBWHIk0nXcxQMDBz7rF4zLH2AlXXcDidoc8sA6J+VBYz9hk61f1KPpjLlHGTY4EPZ47d5t2yy+tE0qpghdyYJyBLHQ6DhU0DnkS8+pQBS5v5iqIxn+ruuuqoq+YxZ0U25nTl6PnDV3rUhgYnubA050X2zbF54ADEpL0lU3E88FBpY972GMq2ouN05CEApZSCPqif43yx46J+/YWd01/6VpoKoBGEaN9qS/026uo6ku6sj4aG/rHX9lfk7KTnFq3TTTqJ2QDulGJgUgDbYu2evgLwgCGOCRhljAHDtgSDhKHBPCbxXUCNruhvgF4KDajCgqg/w9yo0ZIyS8dltrfy9PsQ7fCMxsR4lDoojlrqE6tkTng2TsvzKhcQeAHQQI5nlhIGuPQ5MU/0EbuD+feMPotJsmjC+0UZPaHjiwOLssIqq+V6jvUFRoDIrrARWErjCiTVNfSIPvMtnafZOyLa02vQ0Pjxtru0gq60Wp5dNm8Bcv1PBC6C1FRH3ZVSZNrSSnFMHJ0QBJWrF1QqwK7QC7pCv5OkzxsD804wAXyykWk+sq8C0LbYSdcFcLUB88+emKuAnMDPe7INMkeCtkpjzB4D6wiUdBgBwV6nhUlAWDV9C1DycRYRIWPKHVOa9h0t9klXSbLBpbXs7GhalImF7U53d066V3m3IyanmkDOIZ1JKurjzCwEYLDIlOYpsdEhW0Tjkr1i6OLfHXLfM3rEZw99EJOe+jqevO2RfJKakBy4KFVdi9QM8HDC306PFU/rGGtYF3WxzNgF4t4r74opS/SMWX44d8u5zt9K79H1seeyO8R1J/8trv37NXnKo/REl/8pwdpwsNJmqTYz7c/HeWI1Uj2mF4azmn0Dk2Tj/x7Z6O/OQa9Fjv/tyLjrwbmnqhPEIjF0WCWAphT0SlNJ8wMJ5U4d8R2LmTg/oFPxOuCmD6SisGxpOxbPyemkFdZ+cj6AJwdfusl1kuHfXBzvj5p6oUzb4iT6hlhqlr/HoD4tQIYw9JgyRh9YBWI5aaC/eLY1ATQtIuFUUqE/hpFDr7TgwDNzjra/SnVmRcG6SvfqBw4QaDPH6CowxTn+b4DIcgLYYtwFmYCEYAnY9/zADRZJv0hbAtClQu+BBQEDFqktUX+Wjgjl2F2XLmANT7r67rjt+bfzhS2dkV7jR8VzF52S9zOGrasCTk7c+AFJAxdYKubaaJfOXTDLYu0l549z99w0nzd2yPBTaQ6AgI2jRwAMIKOfyjGGnbVhgmIMu/nLPwDixHMKOsxf2/OUE2NonmMb6TdfAuSZF0Cc9rMVru/aAJG6dWUl+pLtrDQ+6iBlC9Q8K+WRZjd/ASbBDbBdTh/b2iEj2THpYDYO6POif9UIQsZ3+TvMp3lSrqYV8QDwspFdeY52SmtjWpWVla4u17dAuiD9f8sv/l+QboayHTFpsTAYt8Qwpf3gTI4UVfas7xm93m2OB/e9KU6f4eC4ff2/xKNb3xRX/eDcWGvK8vHU7S1pRJOcMWIQMD6YAPt0SWfu9vsDOnw2d3PWHI+PfyGah02M45Y8KFZ7bsG466d/jQUfnC4mnz08Rv3+3Vhn5h/G6SeflhdZcxr/WwJ8YaE8e9qWBCMn3QCkAPDYB4tPGGVg20KPdN65vqt0TFfWPD6yMR3fdui4Q4fGtluvO9WiE44KIyVdlY5nLFf/WcpQGm9/S+kiLJso3PU8KyfnMxgWAA7YwlT6KXhRp4UttAiKY2krbffkvdPF708amW/B19jYng7VR0N9/2nAZP6X+vq8lIGhxZwmow7MAoucpjariZOy5gCKq0axK4BSpdWcPg+Ym1Ol4jk9MxbFvHMtoBZzCoynnQf+E0SJhnkESALA6fg4DIw2Y205Y3WD5Zy3v+tPDLS+bU8AFIAeUAeQ/FTXLNX/59+f07rlTocla47Phw/L56Y511WSzvxOtnOBJZfryPrBqaWuLh58+oXc+QMmwJl5hUkTEAFUxDiwtcBaVwug5r70lVj840XMVQDF+AvOyolALdkS89pKfnZCcCpzpczB3Mv36Jxxxjy4oisAMyBWCUyq4wQm2RbATdDGdgK55q45Vi2YJO7l/jIPFugIfoBkzHm1YJIA9uknkqCSzptHWFn36kqplCVia5WxYI0tMusGk52TbkBZhXB+HH3a6NxkTud8b739NvHwF0/H0S+dGX1+OVds8ej+ceyXf4y1L986VjpwrfimcUzuIBk6INQkN0EZQs6b4QEyz7vyz/Hq2Lc7fDa3NvWdaUCcc8v5uRE47ODD4uQjT4zf/Or0GDdqbO7ktVfdHmMDsJQrtP7fEs5ArZX96UTsKcUislWXxKH6nfNmkIBMIBTLi93hYPMas4l3oCg73A475Cy10LRgCLADdhns0q0tEqDExGCQsFZYBc451XQRwBGoFJxwtKm+jmBlOfLS+h31i9gKOpiOhiwV4A/46jVpw7jk1Lni4bsiJk1szsFlZA0xZbKNnlumeq+GGWPuIYfECrPfNw2YLBUBjzFIqXhjIhBQq2ZxEAYOQCwKcGlssLWlwmjrOw6/yD7QS07QMwBo+saz6j/9QZ/TStj/LUkbt6ttxJgLHuiq4Ee6DEuW6joB8raALzaNHWBTOOZK9Z9pCy99w9FauAOMGwvXMF+0Zdx7r7ScMdgZqauP1RaYPWdMsVgAjfHqTH+ZK5h1c5susYH1PXvlZ1p3VqY0t9QUmpNsmpSze6Z+IuwIVqqaHRRqEfPN4hKBTpqv9FXAmwJdNc9sBh2ptC2YeloCpLERwCddeObZJ+IXR+0S0WtYDJjumxj20at5AMJ/0CvgstzCFSluRIGsQdpuDviTUWP/2aRaRaYA42vs2CGAFAmQ6lZrBZQAMhAu85D2Ny0Kmw7UdfX2QW0BSrZX33enuzsv3SnvKkVBNSeoFig5wZ+cuE3UrzIweg3qkycQmwvHgeVbgERdfvzXl4+PiMdO/kfMN9s8eeoKOFCT5oXat+L1/rFPxiJ7rhD1DZ3Y2zLqY9UZlo9DFtq99T1bT6RImGHnsDkjtD9AC1R+30cqticmOUaQoSzHXJV+Vr+lLYz8tMjDMxmfVx6eL+afO2upi+yAAGHfjO0T0y3wQtTVTd0vjKqNnQFbTCmGhEHCTBVXSHP6xZQ1YMT5SxmVnhPOATF20qfl0tkAJwePLSxXOO+aKa3KULs+0HrLrVfFc69fFKNGvxuXXPqn2HG7vWLRBdeNoX3XjLq69lNJQCRQwWGnOkE6zREAQ8AwJyoFrfyjuDrfGEqzGZcik6L+S58Zv7QYDXNi4RsH4j3Blvth9jhR31GHq4+7kjmrRtJOBgAEhwNcc4wYNy9t0wdqsMwn46yurK1zlIn5qF89k1IIoj6XLguMUhlIqtnVJ6n8g8P10zwWoAhOsFtjF1glBsy1UIdqE41r34aIx397SPRoqM91SvbAONE9wNCCrWpF22UX1Pq5DkAsIAC+5v7RJjFw6TVq3i+zVCZ9+Ul8cP0f8iBSf9Md4wO4YvwwfTIB+ibt4NAVAsiZh4Ay3RDsWqhmHutHwXo6UY1tMFbmNna9VIwf/QEU+YWZZ+8Ru/9s3thk+4HRlH3T+jmLLT94a1BcePY7sf6PfhFnn3VODugwmUlSGZbaRv2edj3gW9KhGR0V10ubqldjo8uJvjFO/BE7hyU178udSIZV5ZfaWwhZi6SyJERQ8XhKAT8brQa8uHl8t3RMugFllSIiVVSvPmq2OWaP89+5Ih78ojqGz0Kd8Z+MiccOvj3ef+nd3GBjYxhb7BpAt8PF+8YXs42N5g4trvhOphvbP1b+YKHcwHq5toiS88IuYfi8p2ZRVMwIASPps+l7xe9X815nPov5MqnVLYrqaxWghPN79eXHY/dNLoiukLoZ/hl1PebJQQXH4MXgcJbSr4SD5Fwwk+oMGStpqdK9A4EorIkUWLnI3ncUtquRKxfIMMYpnVYUKXhpJ7VJFjUBJ9oCoGJsgDSOBcC1wKXSUWvlQDvwpnYTeC6yiYAepwLI+Juj5oBL0T1Ai7UEOgEufZZAIHaP/mH50154QCcwDJBpr4Uorl/chsYJHBg/z+F5Srcs6koRMBhfANILuAOIpQw9j7bS03J7ZQL8xtB46JtK+7BiHKXFOWUsZwKRCTzq8yJw9LIYpwjMMZtq7TBkVjBj4L5o7h2zbNCykrd2yeJnG60a+6zbcioUEaABZ9gugF5ZDnvR1jGFdM8YahfApY1p9a9rYBIHzb9kzL3JdwFvR0RPzNsvYtidf837vXSBB/0BotQnWqlOB80BLwFBZ2pDBWvmmu2KjIvgxwp891LCAGQKpNJuFTIoKSNhbItintCF3r3r47r7fhr9ZpRFalkoWCrNTRFihZ71s8QHz/0kttvi6Py6AKR+BuAFdUoxzHMgtq1tfKoVtkdtYdpAnb6lYyxrFeBNe4FwmQ2Mqn4r1Sk2Ql+mmvOuECwxey0zZzukIsg0Z42ZZ+ve0Lxz0g0oqxSAgTFiYGfeboG469OWAuxqxcrrcSNGx/ojV4iYlOX79nHUDLU0xfVf3xP/+vyJfK/JzshXr3waD+7b/lFc/6liQncUvM47V0Pcf13XsK2HnTpHXHfTG62OHpOQGEcGEMOEncMMMEhApCi3ku74vnRRcS+4JGq8rNwtPclHhA6wlkbVBAjBRlrgko7nA+qwFlJUiUkQAGGX2tqUvVSwKZwUAC1tVgyqsAdAZFqhDURwqJgGzl06HDOCleLkOA9OSaAA+Gu3NgmmOA7jBohidirtZ4h54njVmOnjrtqgOjkVfQNAAgMyBsZXjSsACcxWW1clYMBgp2P2UjCRGEdBgXFKW80AWEXg6IW5qeTUBDf6mc7pE23EjAumdt1tt5h1zS3irn+/U8iTtC9Zc1MMzCbFfb/9RfTrM23qHXgFJpTmGB/lCmnLm6IIkr2vPcbe+BYX0gkeAPOZZp4lZt36kGju0bmtWc7cbu3YfsO1cn3UJynVrG/omTIiu3CYl4BC6nMsmTKFBDCLL0xwW4AiLeAo6r8A3bPJ/phvSj2w1bZMI/TJtbGm6ahSrCogqiZ2gQXnjiN+2xCLLl3PG1fx5HJhPeLGC+eIKy5+PvcdfIl5pI4UmAfGugoYAX4YWHPB81daTFeNCAaBSrZJOQfQTa+UCJXaS3PDGJZjdjsqAKX+EWQQ8xH4xvYb13QqUbd0XLpPyqlSGCYT9frHb4351mx7z61y4ojEAXMMjr8/e2v8+5yW1d4ACmPN2E35aFLLlkOdKC/K9wzrOTBn/NRtYhlE714cMlaSMxe9AjHAklSs55KKSJ9Nr+L323qvs5/FngJNyeB29F6DBzi+8h/RFfLN12PyPlLnBEQCZUXWSToNu6suSQ1l6QkURUlAqdy2QQSTgLnKa8wK9+AcBTFASlEAN2DCKlHfU1cl0AHapIk5cuNNklOv9nhHwCCdZlEEk8oLAEUgsbjdj2cDrL2PYebc1Y15Dgaa88GaAMsAKQfMKRkvDhDAKj37vFSAcWAPGPdcauPKAfNq54j5kVhI7ZJ6BNyxTxwnprEjK0wV9QMVHDCQD0ymUgiMGdCDEdG3aXPrahy/ecu5csTapZ3arB+BI+wvPWxsao6s/h9x1/PT1qaVE3eeuX+veOjcE2Pvka/l9b+luykAYACiMQaU09nSgIC+wk4DNJgfbcC6lRvPxOpLqX/y7AMx00rrfnfMYo0y5Zsv4/A9d8zvLYDRr3QVCwjwmjcAi+dRnwhYmqP+XnxZ+FHcM5WeVQKb9FkfCDCKgEoK3KIOn6FLQKLgz7yUjRCMYG3V3tJ94yc7RQfPOed3sfCq90ffoa9XCSaJwqopseW+I+Kfd09uBZPGRqq9rU3maxXlAnRZUGh+A3nmXkcBJVtmThCr1dWZ0iWgsVh2xdcCejISXQkoS08sk0EBMrtPx+k66WYoaxDO9pjHfxNzrrNgvv9jR6Rx/OTYdcLG8ewTz+TREuMjUpoyd32sckbnmBen8Lz2l2fj7SteyI0XY5DqZwAOBhY44eg5J0wWA4hNwByVO1rrf0JEqByROqLOSNY8NrLP215oUq3Mt+L78cHwxtyIAm4MnJQtRpDjAUzUEjJ6GBEgTJ9XEqCPEy5nIIElKVVOL9UiitIZXeAssV1EITswAoxZBAKgYD45KfV7nAoHl/Zyw5AAv4rzE8isJFgvqUppJrqewK10JfZMX7hHeyutsTWYE8xlAiUcKWPOgPupLUoxUrF8NQIUc2auqzwAI1aNGB/ANW3rgw1W04fhBYr0fa0b6hePI01p6wQePSPAB1xiPuhMOmVKbVi5WthyYlGMLV6wXYAJJtfYYLfcH4gAKIqLeujl5Q88F5f965n4etzEvIa7eCRjYuqypsYYOuGLOGab9WP011/lwZO20qW2NonHWrMXdI+ueGbBAd0WaJSm+t3PHBGM+Kz2f/jZyFh4t6OjoWevDlnR7ZaeI361+zY5IAc+gDNg1riaF+p/AZRUStGWYNjLgU0voDRJGlN6KwBMQJOemxfYf7WBAjo23TyVRgXwAF59JXhIGQNM5jwLT4iXP+tYmYL99J97bHz8YtdP8hrXVLfZVcIvsD2CCYCYYPKAeLapIwyoYESZTDodyFwQsKe9ZoticRsQruSlmuNHqxHtZz+SPRWYsXPGzOt/e+Hf/wXpXuVdgyyz6vIx+5rzdRhMkoa+PeOEq3+dR39SH6Jam8te8Mvfx+AebRfzVyPTj2iZFECjWhd1Khwxp8ZAApYMv8mEFcSyifJN9uRsJjZNio/GfxJvjXk/Phg3IsY2dnzVdDWCweqKWplPPxsTI8csEM3NHU/3NDVl8fLrk2LshMG5E2c8MW+MEEDJQXEgHFhyaBwq8NeWAE6lm+omSbVOmMckmABAqAia9JMaRbVY0rTApLEFVgAjoIg+ifyT1MJQWrwAPGISEzDAmkrXAZtpk+32hN6pv9N/AhppU47INYFJ9wGuagGT6VkEQnRVrSXmpJJw3Jgq/aINfgKT6ScHkoBOe2ASKE9nKwvIPB+2xbXML+MqOEub+WOtpLKNkQwAIAsEYxTbA5P6m4PFNvuusgd11oA84CpwkH1Qw5dW8xaFo9997RXi/hP3iTN32SiWnXe2GNSvd84M1jc35YtZfjRLr9hzoX4x8om7YsP1183TmurKPCPAVElPiayKMcDG0lf6grXTF0Uw6TkAYYGIa6bFZ/pntukHR+ML/+wQKNl21aXix4u1jJdUtv5xL7YUYAAQBFT0HfCtdLpQEoDPmMgwqBW02A7jC/zSWwAagNd+zDW9sdrZeANDafN9usYOsKf6g60F+Isp3BQMGkf9+PEYi2o6VqKD0FtpjX7xs0O2yfUynbneFSJYAyaB1OIuDrIi5m/pqTnVijlTPByCDimDKLeFEH3S52kR7PfFUBozNrUbTHaNdKe8a5Bnvn6pw2maVskiZlhtjrj6p4fljpWx5ZTI5I96xjUf3dEhwGr/yh7vN8fzjz6bR9OMq4UM7iGtnqIy0SEHZbJiJawilnbA1vzpugujxwqD4sHPn4wpWcvpE8Rq9ZWHLh0bzPqjWGLQQl1euMzJ1HJ+KgcihVZcLOMn1mbzjfrHDX9pG9y1JYb3zn9NF+utt2oOOPQTRsHqP4Dbfb1E2un0JKLYnHEENBOTWVxdyXFVSnkDo5yg1ZT0IZ3bbUNh40ikZYwRw8fIpgJ/4M84A3vqC419kYmsFlCm+igOtbiiF8uNPQY2ql3pi6EUMGEX0pGlWF0gCOjgkKUhAUPBTC3i+1LG+oujB2gwNNgjzFRiIQENrKi6rVQDZuup9nQXq1W62trzEPcEkMybVPvo2cpdE5hSS8dZGR8sfLlN75MAPkAnpg9TD0wC3dhTwaHsAYeI2ZLub+85evZoiPWXXTh/6RupX+yjGlvMOjnkZwfmOkzX6BFWD/Ooz4Cq0m2qjCX9ALzos4BUf2GxsHXeZ28AafaGPmP2vWfM6Cbw5Tlye/Pzn8dlz34QEydPbnN1ekN9Xb4qfOcfLReH/XT12GvPPfNgjn4l8Av8GV99B/SpTQeM6Jx5gbmsVbTTfQBo48AepH4HEo0rvVIX6IUpNWaJmWfX9Veq77Qwj51igxdadKYYOR5Y6sz+oQ1x4JGLxe03P5UTBMBtpcVg1YpnFWRhw83hop7Re6UN2Mty24K1J57fmLFFyS65j4AVm1vc3kl/sg36vK1yoo4CSvMt7Q7SvV1Q10l3yrsGue6jO+P6j+6O5k4ZgYjRw76KU+c/NJ+cjEA6JWb0lLFx6L9PidFTxtV2jyyieUpTPHf4vXHyQcfn7IwUbFpZyegTDkNaRkRoIpnIgMjVN18T14y9O7K5euVbD5W7d3p/jr6zxlGL7Buz9u2a0wSAJywfpyR9VyomPnCQQGMyyBxI8biu77bpWSrm7r9Lfk5363mTVbclYuy45lhktS/i+hvuzAEBB8tJAAj6EfgD9DhdxpszLgLLomAQGUlgGeOopsrnywnHi9ED8DGigCngCJAAyq4BhLlX2pgYg5lOcZI+toeg8bY4pNh/WEWMYTrPt1Q4YCyNPgTIkhMBIjlMdWnlNnQvFaCXE7JowZgC1TZA1ybX1I+YaI5eUIP5kypUBsBh17p9FaCIQVEmQNctsNGHaUW2a7eV8kzgsZi2TuDR2JWutnafWoIptcHYKvXS+qbcGcGYW30BcGFvBAOAmbHUHkwsnefkLVzSrlqE8zbPgSogoMheF0Vtm3FjG/QL5yvdLkVIf9goNYR0Uz2dvwHYRL9rmxIe/QPAAow+L3hg41wP2+4z5rx5gZn/7XkXxJ4nnBWf1g+Kuh498w3WGxp6RJa11EbX1zfEKgvPHTuusWysvti8ua4Kssw/baG36ntTTR7GVmCkL9kJYEQfYI87soOEsgXziQ0qB0rpm2DBCnigzj2BcT8tHgN4lZz4LhYx7R+5/hYD4ldnf3eiWkelb495Y+w7v8qD2HQyTkdFgCDYkMGik6W6zuYKMgS15ltbpRFtLWrC/qaMDrAtQ2CcSm2jecBuYXs7C5SJ8TeHXZPOpB0I0nZ63dJ56U551yBTmhu7hJ3r2btnPvkpeKrXIYN6DojjFjsoejf0rLpGO+11edC8u8QKcy+Tp65MEAbQIpfkUBkBIBIbiU1j2Eysn26/WVw8/qaIOVucXSUgm97/eMJn8cuXfhPDxn1XzN4ZEbGKGgENjomT4FwZZwBR/Z2Jz4kBWMAUcIMFAUg4aqwHRkTpwLzzLhB1g3/97ZKD2sTQnnF+35g4qT4fGw4QKOIUOShtUx+FAROtA+f6EWDAADGwGCYggLMEALFmGDTtxDQBBFJn0klpVTHx+ZTyZlilNTllDtR2QBgR4LZ4yoXxBTYBPtd3r1LAUA1DCdBpKzYl6Tfn5xmBM6nVtoSDwDZiFbBgggM6nfaRAzDUSwEBHImxkq7ElhlzIArDZU6U27A5CYABZHle6bJU26WtqXbOOGHb6HgRTNIzAM/qfHrCiQEDnD4GX0pfOplTxTylM+iNnT6ln7XMff3tXsYbQAOkimK8BFDGEyjWzxgTta5AkjHBeJuzFo8Y61rBJGeNFQXkAapKYDKlI6VoOW9t9V3pW6ySYCbVS0op05MEJrXPfAAW/J6Y8/zkr912y7MPWCbASi0y0Y/qja3y79U4MX7x09Xj9YtOiBH3Xx9fvfxkLDFj/1h5runj86fujXO3WyMu2G+LHEwSdeD0wFjTOQEMMe7GW2CFwaX3ggGBAuYyZ0T/9KfWsp5qhF2hoxi5cmDStQQEaVzcQ+BL99X/mVOETdAOOiUwANB333ObyDpRmpNkSvPXeTAqRQ3UdnTvRgGz+e4l4Cun62yxxU/GsiPnbafNzdPCHCLIoguYUX1ZFAF4qlXuaoZSkEbodTeY7ELJuqVquXn4P7OtHjsg2+Kx/Tv1WvPiLfIzTNJrttlmyzbffPPsF7/4RXb++ednx517UrbhzTvnn938kf3KXmPzR1ve3+GJQ7IXR72et6+5uTm75JJLsv79+2cLLLBA9tRTT2WNjY3ZTTfdlK2yyipT3bNnz57ZL485MjvkuVOyzR8uf49Kr60eOzDb/elfZl9OHNUh7dHOESNGZHfccUe277775u2ZffbZW9vWu3fvbIUVVsj23nvvvD8ef/zxbOzYsbXdY/yNWdMnC2dNnyyUNX2yYJuvKSMWyH/+7tSlsx49emTLL798dvHFF2fTTz99NmjQoOzcc8/NpkyZMlX7n3/++ezYY4/N/67N/fr1ywYPHpzNPPPM2QcffND6uWHDhmXXX399Nssss2RDhgzJ+vbtO9U4eLnGvPPOm9XV1WV/+ctfsoaGhvyeX3/9dd6WGWecMXvttdemer5vvvkmGzp0aLbPPvvk/z7nnHOyXr165d8plfr6+uyCCy4o20/XXXdd3oYrr7yy9b3x48dnyy67bDbffPNlX331VcuzTPkga574QNY8/vasecL9WfPkt7Lhw4dnP/vZz/L7astpp52WjR49Ov/8zjvvnF93jjnmyJ9vwoQJFceKnu600065TupHz/Tyyy/nf/M8+m+33XbL+zb119Zbb51dfvnl2aeffprdfPPNeRvWX3/9XE++/PLL7J577snbs8UWW2Rzzz13a18bo7XXXjs74ogjsmuvvTZ755138nHqajnssMNyXXrkkUey4447Lh/bW265JXvppZeyXXbZJf+bthx11FHZxx9/3NLHzc35eMw666z5HD777LOn0rtaZOLEidlPf/rTvF9uu+22mr//6quvZtNNN12ui6nv1ltvvfxabIp2XXHFFdnCCy+c/23DDTfMnnjiiez111/PllxyydbvbLDBBtldd92V//6vf/2r9fqjRo3K58Ipp5ySTZo0KZ8b5ps+2WijjfK/+457JGlqasrmn3/+bMEFF8w/P3LkyOzOO+9svVcaZ/aiKJMnT84OPvjg/G+77757m7qYxLXN2Y033riifowbNy6/5t///vf83+a9f/fp0yefO08++WSupzPNNFP+POm5Z5hhhuyMP62dPfzeAtnD78/fqdfjH6zQOmcXXXTRfN7qz1rE+Jh72tqevu211175HDVGtQp7oX/Y/aJ88skn+f3pe1G0hQ6aP10hbAEbQfbff//cLrLh3dJ10g0oa5A3R7/XaTC5xaP7Z8ff99t8Yh1zzDG5ceR011133dxYJgNe36shm2uDhbK1/rLVNCDSa4MbdsrWPHyj7L0R70/TzrfeeitbaaWV8mudeuqpuQMgJ5100lRAZt7NFpvqmrWCyovfvabdPuME3njjjeyaa67JjjzyyNwpMbCpDYyTnwcccED2t7/9LQcSHXWipdI88aFs/Ecrt4DGjxeeBkhOHt7y88s3Fsn22nmO7KOPPsqdCOd/44035k5lv/32y//NST788MPT3APwZYjPOOOMbOmll86fxec955///OfcWBKGjEErgkzXXmqppcqCTIBiwIABObj+/e9/nxvjomM7/vjjc8flfSJg2GSTTcr2A1Bx3nnnTfM+MMaJp3blfdbcnDtd137hhWez5gn/zJpG7lwWiD/zz7my/XabJTvj1yfmAJcYO2PpGegzAOV3QU17oj10lMP1HaAhzYfFFlssB4EPPvhgDhCSJPC4xx575J/VX0XwuNZaa+WBGv17++23c338vgVQdX9BATH/Vl999dZnMd85zwS+yXvvvZeDMn/fbLPNWoOSjgjAxOHri7vvvrvm7wPlhx9+eO5wOXpz4je/+U224oor5u2jM15+/8lPfpI9/fTT+bj/+te/zu/Jpj300EN5PwiUXMdnBWFF2XPPPbM555wz759dd901B9J5QDnHXNkBV9+QLXDMydkip5yVLX/2n7L1/nxZ9vNL/5Y1DByUX++ss87KrwHMFefNwIEDK44x+0KvzdkPP/ywzT4Q4NCfNL/aAkgAmcBnhx12yP8NZKf54DPm8qabbpqPuUDL+K+3+YBOg0mvR95ZvbU9zz77bB6o1ALA7r///rxPBB/FeVVJBNrsm1cKhKoV1/c9pEe5/qYryVcl0adAcleIvl9ttdXy31PQA/R3S9dJdw1lbWxuHPbiafkK6I6u9HaNf+14XWSjGvNULlrf4gKpTSkSqTyLCaRJ1NNJ4Wy537YxYuJn8emoz6Jx/JQY/+mYGPnyp3m6W2pHDZ2UqbScl9Sj1KJ0nbSbFKvUjTSclIXazccefzw+XGtsDJhrSNTVdyz10ru+V/xlxTOib0Of1no9RfDFhTJqiVKawerYtDl4qnlUwC7VKR30fcjWW20RQ/q9Eheeu0Y0T3x4qiMZv/xmvtjvsEdj/4Ovj6232T6vjZSelU7XHqlu9URSLtJ/0rbq0YxNSt9YeCO9ZfsQIh0oVa6fLd6RnrPAQspamrDciTd0QrpT+sV4Ss1IBZeeAOJ9her0Jm1cLj0lfSp1aoy1r1TSkWfFDYTd04pl6VRjljbvTu2/8bpzY7M174xoGvbtStRpN9zXvLw/66aLuukuitET5snTjeomtV36Ta2ccdYf6dzyUlELqu4sLaiRwk79IA1GlxXv2y/V34qLZmwVQ9R2SZu7p2eRejeXuqL2qhYxjlLV6Wg86Wb1htor1emZLFYp1pBJMSsDkC5W+9ze9k5tiXRkOh5U7V+1m9knkeY3/lLISguUDigLUBJgDtA3qe90mIASEBv7K6Ux362s9r20apZNkHaXUjVGyieMpb4wftLS0vyute2hh8esm2wZ9TPMqLhfZDZ141oIkMiGvRv3//rkmHvGGfI0djovW/pUf2pL2ry6VNxTyQOdUwZQ7nxr/cYWpH0sK0k6eEC9odR7qkVWw672lA30SntdKokxF1Zba8GYGA/H1nv37PARsen0nOsvGxsbr3pZ62b/+l5tsZIAetiW2DnAym3lPcagmprIdAyjvnYfdY61iLlpwVRpGU3a+L50ezN1v+o69WFHFlYVRbkBG24u0k82hl7/T9uI/8vSDShrlPs+eyz+/G7LKr5axcblX7/4Wcz0SK+8Hk5dl/oNk0VBvNov9TeU3upRzojxU4MFkACLDDPwoDbJxFCXxziaqGpTAKJ8YOvqcgBnQYSCeu8zcoCIwu3tf7FLHPdqy+ryDksWscCwmeLTf76fOxOrHN3HBFUDWASO6Si/UlG477uepavFc6ufAgzVYP70pxvHoAFZyxm49YNCV+lLQIVjU3+qXpGRAdr0ra1pGE0AyfikLUQYbvVGCbwUN9rm4Dg6tWMcs1oxv7sG4G9MFaGnvemSqFczhmoNOb608taiBtsBeR5jXe6YObVvxpZzaK2zbP4sovnrWGON1WLHnQ6MfQ84sfV+6mc5S4s1tCcZdfc+6oht44SD3ojIbBRfzclN9ZFlDbHH4c1x612f5AERB5fOGtaH6irVi6Y95dRQps3FzQXPpa4x7QvJaVmxy8Go1+KkkwBlFkwVF80IougdJw9E+QxgW8sZ1J0VesMpGjP6Bhyap2rrBB2CAX83NwA326+oH/OcwL4+au8c8LZE4AbIsh/0zUKNakUApaaTzqnJM2cA9ATQBExAm2cRANIxNkvQqu4VGPEMgELpvoHsDZBGJ9J2Zr4HjAL9bNROJ58eJ/7zgZbK53ZqVbn/6fr1jct32CpuuPjCPMATgBE6Te/UJwO65YQ9NV/VRAPz6lXTvNAPaj3pFL2rVDdLX80h4+czxs38TsGzhTjJ9pnnJ59yYvxgzT5x6PFLxuhJT0WW1eULj3y342X5dXHhifPHNVfel4Nawa8xQiDwFxaeVNronO6xdZ7THKx2Q/T8AInBg3PdSAsma6ktZv+A+HJneAu8zdviVkHGg41VV17tvrOVRLBjXhhXc5B+qKvulq6TbkBZo0xqmhy/ePHX8enEL2pe7W2ldM8bx8TVv/tb7jCxdya/aDL/e319q4Hzu/et9rRYw4TnNBXFM+pF48gJA3MibgCKEyu+0gKJ4p5sy/xstZh3m8WjrqHj0VnWnMVnT3wYjTd8ORXzyIBWa6CsYgaItL2rxeIYgASLhRHRRv1dXE2okN2/sS6cDPBm5TRmwaIPUTgwABQxnAycRUEcI4CPhWScAZwknDCj6ZrAMofJ2GPh7F3HqAEfvp/ApfexnpyzsfeZUnYJOwNYcvgWC7lPKcjs17cudt12+jh4n6Gx4LwlLHrDPFHXb5f4eNSKsfgSK7eyaERww7ksOP9Mcc/VfaMuszNAU037d06cFPHna9eLY467MAdJ+pGkzZyBDQ4PC4kVBbwAWMBHYEWXOUHBRdpXL60WB8b0jT5UqO975om+Kz3dxXc5S/qObS5uR/J9ibHRn5wh3QdwLIKhO2k1KTGnjZ/VpsYOoAIG2IPOCADBDtA3/VvtimbtttNDWphlgRJdpVvAJebNIj+skcVKgl/X1+cCVOOMgfS8gAlAgDnHBqVFONg+1wPyLNYRoAGYdJ4t++Ptd8Us2+3Sss1CleCkoa4uBvftE8t/PCxu+Otluf6yPcC0tpon2PdK21IJfLXD1j52PzAGWCsMv+dgLxOLTN/Y6sQ4enmOlEFgv4CTdKIWO1LMFjQ2j40n3topos8r+UKcurwCoLPSENP1XS0Wmf7CnPFljyzuEpQYE3MGALPAsVS035zTN+ZHrUEM/QUsMZw236fD1Yp+AkjL2fvERrINSXcIW+o7xd0rOiL6R3bOuGNJi+d6d0vXSDfXW6P0bugVxy9+UAzuObD6LcSyLE9PH7LQ7nHV2X/NI+MknG1yJgyYKJ8jlqpOVDyDVkmsMAaCOBAOjSFlpDEkroE9w3ZxFhgFjsB1F19uibxNnRGp8jXWXzM34gyyaJ1xqeX4r67a1LxU9BnGjuFIm3FzhqUr+vQTZ4ip8wwMJfYMeJSGtMITA+JznBDngX0EetL4SGkWN+yVDpLeTRteczxWgnpfih9wsrcj0MPxCBowGt53D4a1XKpSm6ThtEFgwTEIJAin8reLNo9PX1kg/nj6kJhvrmmVs3nKsGgefXJM17RJHLDbwFZn45kZcu29/oqtIzL6VtuZ8g0NddGvb4+YbfAduZGmw54Hi2NFO/BoaxlGnJ67H30FVtK53/6OxQQS9RPHKOUNRHKYdNkYAkCux3EDZtL5abU88R5np5+sUMa8fp8iaDOGgEg6QUkQp71FMOlvQBk2D5gEOAHMzoJJwYntiYAejEu1YFLAIz2OKdR+6XogSF8bP7sYCMAEtDIj2ppOjQIG6bN5QIc5e4Gb+WZ8pH59Lq2aFwwTzJAgDyvNJp1xzrkx05bb1wQmSVOWxTcTJsYzvfrn89AcM9fohfkjPUq/pKHLCRZd8G47L+0VoJj/9M5qfwwaRlXWQKAnNSy4ZBuws8Yw7SKgH90TUNGXWDjPl7ezeUK8/OnOEX1ey//dNWDSzh69Y97pjsqfgz0C/NkrIN/YYYBtAcVOFMUYsy3GA8DvCCOOZTfWmGb2qDObmxdFpkh/l7KXthoSqJVmZzq6yjutUFfO0S1dK92AsgMyY++h8ZuljoyZerRsXF2XVTCEWQuL1zixMfaeYatYdYYW58LgM8QcD2OUjqJitAFCERknycgRToLTz+9VxuiaKIw0Z+AlJVVOMA/AD+P7yiuv1mTAK4ktizoqwBMDnY4b7EphlIDndBwiY8S5lNbhALOAnRSfv4ncgRhjQThIDhM45SzSViAYAMYbqwHwcJTpVCLC2HJWgCPjXtzYnCPmoDgw4y/AKG5nApBxjlLlxc3QsSJYI6xqSisCwpzbGcfPHztu8kr079eiIwBeqcC/hqtP74hTj+obF5+7aA5mBAEM9vHH/yqy8VfmewF2ROrqmmLLn/SKmWfskwMOIFkKkk4LfAgmCSsCgGB7sVf6CXgE7PUl/TU39GlpfRMHyvGkvf6kxwVO+hszlsAjx+QzUnMCLEFXV4s5DNRy4Ngw89V4SnWXBkmeTzv0B6CDwTN20vKdEboKIAAKrgUAtifmv1pIzC12XTsAKT89C7aSDcLSAUqJLVI/B7izRXQMg18Ew8YggS5AkmAvtY3upj0+iXmm//b57dlR59z0DtgRoPLrfgNicp+Wes20cbxaTaCBPtGVtLF46Z6KxgwYBxyxYslWANR0kq4JdABOoNjY0kn2GBtsHpp7padHGWdAzpx+68ujY+xkW/l0bu/i1mduzGLypCwWHHJe9O/Vcma6sVCKYwy9tI2e6WNbN6XteAQ5MkLmhmdo71jKSsJeCOwEfvSjFqCXynrKCbtoXghCi9uHAZTp+NSuAJRYfOVXXXWkY7d8J92AsoMyfe8hcd7KJ8fnF74VzcPKT6jmUVNi9G0j4u7N/hbH73zUVH9jrDjA/FrTT986cRhroEFNHAaJQ8WQifZJ2qS8VIAn7I9aJ7VQ6kVKF3WQVFe04Jzzl/17LYLhHNxz6tM0ahEOxvN2NUPJWYjapXzSfnnpnOVye46p4wR6OD7sAvAnXQ78ECAdwExnbnNCiV1VYoBtMpb6XdorLbzBGknzSpEzouVOyjG+nC+wmxYIABzYR84QEGO4gVpMH9BbPDNc6ujXJ/wgek85r+Z+OuKAwbH6Ch/kDDbnd89tx8aQgRM7tddqzx4RE7++KnfQCSRzaOojXRcIx6py9voJS6QWtRx4bE+MlUCAcxOAWYiCPVGLZTEb9gVQ9m+gQdDVWfFM9ABoUOYg5cdRcd4AbGmdsABEqk1b6TtHrm0CHvoBkHb0DHuAXDAE7AAw7S3CIIAdW8Jxu7exBwDNQdkRgMM8AKhSuth8woBje+kjh0xH6We51CVgIPjSH17E/JIOpstp0ZZTx16PHp3b27e5OXosvnReZyeASeJ5BGTuK0DDHgs8tMsCMaAT+PZc+g9zRv+0hS7pE6AUQPacdNh4Y51tnC4DAaiW2xuUbvj+2+8/Gl+Ov6NLwGTdt0c0fjK8MX6+3edx+M8unmZPTUEY/RIkGGOBLFslKMYoGlvtNSeSz+mIJD1j+8zjFHxXI/q5EqAkbDafoI+TuI/xVAbUGTFPBfxsbTFz0C1dJ92AshPSUFcf26ywady+2xVx6jyHxFGL7Bcjr3wvnvrVPfH1+e/Fs/v/I1bqsUSsvMxK+SRn1JIAI1goE1tkz1gz3H4CMNKPVlUywv4tJUWkY9QImVyJtUzCGDKaUh3YMt9L0bmfIjwT1efuv/DOqO/RueG30n2FoUt2+PtShaSrGUqpfX1ZXNXcFqDEkgECvscZprOAMTVJgH3MGgfMYQD22s/Q+TxWCuPCUTHmQJKgQDo3pf7KnZEMbAK/REAAzAKl0owYBYt/GGCAFSASVQs4pI04rRdeeCr236njK+R/e9wMMWRwjzwg2WCdGWLylM6n5DbZYNYcpAPBwAlnDHgBP/qMg+jKlZVppT1gwLlxHPofiBWMAZ0JAKWa0VrF/MGcYOQEFfQLG8RBuj+AUXrSD+CknphjxyAZ0xTQFVOz5nNbG7qXE8EOPVQyI72KMW9L6LOSAu2nO2wREO97AiHgFtjExHs/CfDhGcwNNgVoB449L3CGFWwr7SlwJtqoVlnNsT6gA0effU58PNrCr05IfX30X2q5vI2eUSADDNMHKWDsIQBv/srOYFiNn7mmXtc4mmPmEtuoL2zwzjabr4CvulJBiQDFdwRFbKgxSwFrUdhwf3/4+ZOjxER39CFjaL91ov/4k2KHtT6MTdY/IH/GcvWRAhvlHoINKV1BKL1NJQoCj7SjQ0eFDcU0CpCw8rWkvc0XgXU66axUBAV0ij0tZuWMH59Xy8b0pcIuJOnMTgrdUlm6AWUnBcCj8Pfe8I9YcehS0fDmlBjx4HvRPGJSzpwwdKnmS/rBJBHVmSDAgfQeNopzMNGAQcCFUWfITDDOF1Akok3X5SCBTYCFMSwKIATASGEBJwkwuQfjimVYfIaFY64+s3aqjtJ2QatO3/FID6jWdxx/VwmngvUyLoB6krR1R7mtJ6StjA3DSzgRDBI2Qh8mUaqAVXMthhQzmWrDiL5mzAE+YMIYMvqctDHEVhUXRhlTTl5NofEETqUX04k50o8co9Qc9pIjYMixKr7DcW276aDo1bMlDd8R6dWrLi49/6c5aD1g/52iV8kCl1qlvr4uVl91idaABsuVgJYx0X8J3He1uA9dB4Kka7Fh5pC0t78BEoB5uRWmlQTDY44aZ2lEOiUwUzdsrM1d87vITOpLbBHgRN+kioGbtJVOEsGH1D/GBDhLOzS0J0AR4AAYakt7NZjKADAyUtTqIum6F5BL7+gxgJUWURE2SlAgnS7go5NsTxpLAYj5oowGA5iCokpBIzuI9VemoN+wfRd+O986Kw39++eBC3vqPsCgeQsAAojqRNkZAQDGVF205zdfARuMv34wvkAnoI/dxMSZY+ag4NQ8LILt4ik5pfXbQ6cfFLMv9E7UeJrotM9WNyh+MOfTsdhM58eyi+6Q6xMbYuW8ZyuXBla/qq3ArtpKoFoAzCekhUadEX0p7W0OGHu2rljO0Jak7dYq1VES9k2gVDyNh790j2QbOwso0zZL3dK10g0oOykciZoVoIGkuowEHExuoJAxxipIgXIe2CssgWiMUeJURF/AHgMvChZdiriLx2mJrNJKWA6Ss2PwtcE2QxgErBdDglVhaEWlHInvcebury2bzP7jDu+naQuk3m82RTal4+kczka0W+6M444Ko8nwcAJFAQL1c6UidLVSxgArCJQCBByR1GCxzMBKcQ5R3wLypSABcOSs0tFz2oH9AXSIuivCqdEF96ULxodgfwCQogBhXqJ2YCktOAJ2Dth9UL7CuqNSV1cfP1l7VLz88kvx6qtvRmMXUCpvvvV+DlCAh+KRj2lFdqX9KLtS1AdixIw7ltJ84aDMRQ5LGrottoPDUz5iAQbgJV3ImZmzGGdgSq2dMUkr/FNtIvaNk8XccPj+XUkAVYAU0KnmHGbtcn/z13fYl0oiQFX6gp2il6k+DSNndwG6bt/R0pITTJDAxlxS50vnioFTEuDS34Et+z7aCaFUMJL6PDlzYES2Bbg7/8KLoivENedbcMEcDJonmEO2hT0EovUvQCKgKT2aUPBtLhfPrmaTPYvSjHR0qmuX2qlSQGmlPZttTGacpT4GDOokmszrREdHc9YSMGofIKTkQvvoAVte3FIrCeCJrafjAlmZD+n7zjB8RQG2BSr0iA2slvkvd/xiqQh+lCMgV5IA9mx3Z9LeyVYbx//J7cT+m6R726AuEBN3+712jDP/8ad4+O3H4/MxX0bfnn1i5AdfxHkHnhkrzLBUDsCARZE/Q2yxBieV6kY4IGAUYElMGWABjHAiFnGoj+FEipvxqo1R88N4ps3BRaTYETVSaUWtyeSe2BoMGmbhq6+/ijM/+Eu8Ofq9yKo9PFyqu6k5Jn45Ph7e55aYe6Y5c3BjP8BahYH3bKnOqrPCWGJrgFRbm5Q6DvdpK8JNW/1w1pwF4MaxYnZLQZAUrjQYlsnYVapfw2ApXUhbQxHOFxCxKtT9XEsQwekzot7HnEgXeiZsKKfAgKdUMSeyzNLzxcg3pnX0HZEFVn4/dt12SBz98yHRo0fHWeum5oi7/1UXm+3ydt527C+QzEl4ARKe7fteeV0qwB5HnDIABBAENorno6tnxGpykNqOVRMMFksl1BByeOaVVDBHDzxjuoylYBAAqaVODRAF+Px0z3JCV1ImQwpZLWAloZOuI1ih1wC1fjfvAeTiMycRUHlWYwS4AFlFlr+SGOe0xZZ0MTY2gTOMsFKEVP4ApKWf706cHEO3bakj74w0N06JP664ZJusE7AHyOoDzBpbnPb5LW7xY/GH+Wd+srmIAYvmjCfAX6z3NBYAkvSzPvM99l0gssyKg2PIIt8Bos7IcrPdFf17tYx1ajPAzF+wu/RMkFsMboFq/kVAxU6lLXe6aqsc+uf6ADpwy76xYe3Vw7KrmFP2tK2z5f2d/zKv2A+iZIW/KNrSWoSfEuRjmTtat9wtbUs3Q9lJeX/cR/HWwp/FhjfvHA9Mejqa5uoR0y8xS/RbeEjMsc788Zu3L4r9nzsu7vzsgdh8qy1y4yu1lMAkYcwAQ2CI00uLZUwkTsFqvHSYvUnBaQGRnBrmQO2PiAvblVggbAxgCmSK2r3HoHIsHLt2vPLSK7HxlFXjm/dG5qvRq91Lc0ivQdF49Rcx6esJuXPDgGBFy62mbEsYxa6snwQUAMZypzdUc9ICYI9RSewyZoVjsfCgFFCmGiD9z7EUN+MtigABa1xsk2tKy2GPXBuQSEBRys79sUcEI8aAFreRIoDQLDNNzY52RpZecp644fYxnQKTxLamm2x1Xu5YPTdng6HzO10G6ukgFse/gRb/LpYCfB+i77D4gjLOBLsD1Jo3HLSULRZZil4wAhxhurGbRTBpPnFsGFDjSP+lHs0pjDHwYT7WuugBGBV4CDbKBVjYcMBQYGE+VwKT2sdpCigToPd54JduY23LgUn65Jk8OxtD76oBkyRtsaV8g12SPvZvAaPUs/pxNk92Rb8Ck1jRTX64Sst2QZ2QrLk5Jg3/KC8FaUuALzbReBlv4Fyfa5N6WyIbJDDE2hpbtti8lmUwxvow1f/RIfphntIhwJmOsQd06aCDfhFdJQ11381zfkOgqW2yY8gM/cl2JfYReAauBZ3a7zPsMzHnUhlCZwSQNe7AOX0TNFQD9PgyOtkWQ0n4Mfa6WJ6CZeb7Ki1MbU+0NdnYbvl+pJuh7IQ8OfKFOOetS6M5y9rf5DyL+OL5EfHO2c/GJx98nEeUaaENAAlYqemx8KK4WSyHC3BIu0inJBGNMhqcJBazWBvD6AFAFiO4FmAk2uNYTHypLE7R9Xxmzvnmiq0u2j2e+ualHDCWe5b0/iID54/DFtozBtX3z52f72PQ3AebxxlVu6+emkDXkH7sCmFsGVOGozRSxkZpF0apknDWgICfqSCckRZJ67t0rB/x3NLU2EyOU8SeH5O55ZZlr50YzSRYZA7Kd4DdBEBcD3uiftN96YSIXuq0+Ez0Y7mlZ4g/ndwCPDsrK67/Ybz0WlM8e+9CscTCjVFXA2M9ldTPEHUzPhx1dS2LMYpCL42NUg3gRc0gtkpfC3iATItEEpspoCrdkqUrhS5wxPrVHOTojKX6z3K1cT7DqXkGi7NkEOgvB0eHBQidKd9QHpD2kwTCUipasJlOvaEH5dJ19NSc1x5zALjxHgAhmKlUO8ex+w7gx4kDnCktWUksVgGoimyjn2xLmjf60pxLxysC8AA3UOv5Us3dbDvsGv0XXfLbMzw7Jp9c/dd45757plrlXUmAHn0JrGDLzGnP67kxkOwwMCxFbF4Cnl6eQ7CadKUoMk7qwDFf+ll/vPTKk3HHC/PkNcWdXd29ylwvREP9d3v7ar/0b6oxZEOAYnpLn/kFmRE2qbiaGTuPgWZr6FRnTmUi7L1UNAANSLO/bdnXJPRXewUgbYkgWgCS7KOMkcBBKUnaIaUWESzSW8GBQLFbul66GcoOyvOjXo2z3rwkmrKm6k7MqYuYYdnZYofrD4iGXi2bMqeIkvE3wbAbHBl2gIGWejNZfS6BSc6YgZaaAXwsFCl1FuqVpDUUZjPegAmg53dAVFTO+KrjYzjvuPn2+OXi+8Wflzslfjr7j6N/w9TMV9Okxpj47Kg4cta94rQlD8+3TAIApOfUcKa9MwEEbWMEirVz5USUzxF31ZZBWC4GlPMsl3bhFMqt8C4K8IJt5TASY+Za6WQdADKNmSgf02O8BAGApHom7EY54ZCIRQ6YY9eXfmIg096WBOtgPIEVoNJPhrX4TJwBwLHOuuXBa0fk1NP+mLfJSTodBpNRH3X9dioLJpNeYnOtPnUv+gj80FO6CDwbRzWOADOHJwiQQjYPgPJyK+VrFf0tIOBU8rOhsywHEkCPecI5mm+ltWn0WtmIhVaO18RocqpAiTRnZ2uBzSmMNZ0yRxMA47SBFkFNOTDJ4QIRav+AJLoiCLXoTb+WA5OeWaoXsGd3gFGgsggmXcvYpNXPbI9+Mo6AisyK/jKG0sMWwwmAgXLjy3mzU9hpfUefU30yEMTGXXXcMZ0Ck43jxsbY11/JwUlbrJf7pgML6KC+YQOxwuYcUM1+qX1mm7Gs/qY8SDsxrJ7L2BinlF4WYNAn46QvXFfAcfKJZ8XI4XNEY2PHGVjfffPfg+KhB5+cqvbRWKeN4Yn+BIYFNHSFrcFglm6NY16xJUob6G3xMICOSFqYw39Z0ESHym2NVsvm5kWxKMxzJ5BqvDDIxcU61Qr7n9LcnT0TvFsqSzdD2QH5ZsqY2O+5Y2NKc2PNi1qsqu79cmNctd9FOWBkBEiK5AEME176mNHiZEXVHKDok1MBIoEYxfAmpmtY4FFcxVYqHLG0FoNfTE1IAZaeeQskj54yNsY3TYw+9b3j6YeeiD13azmODWDCZBRFWxg1ESC2UrpIqpeBLR6hVRTRPgaqyNR2RtKeehxC6fYtnAnGJJ3p3ZZI2UkPYXEBxCQcvX9bAcpx+116MaW6gVAGO51aAZAkEGhRFGes/1J/Y460x5ilTaKxB5wVh+EZGEB9WmpA6Y02YkLGj/hpLDDPhOhRZiPzaqS5OYu33psSy6z98bdbgXwY9964WKz5g1pZyoaIHotE3fRXRV0hRVdOBEwccbE+qigcJf0wnuklHWkc9Ys+SSwmRpOutaX7xboyC2kwNelEHulM19UeDJPgwRgDUYASYKf+FjACMgAnAEntLGAJHHdqH8UyYlwFNp5NStWzARCljjBtaUMXPANASweBv7a2hsEOSvdKb5u3bAf2p5RxTADN8wGSwKe+95NzT6UZxeMIMZQABl1SvwkQKHvAKJUynwIE70/80brRd94FOrQ88PPbbogpL/871wvzC0um38xNICKxjJ6vCMo8k39LH2uvsRUUCzr1s5dnTNseJXYYyEynUxH2lF0WCEml013AWabhiuuPjF+e2bmFOb/9RUPcceNbee27+wBuxsW8UeKTTtRi3wW4fEeyUZXEmPuMkga2ybU7IggFQFzgo3+RA4Jl5TxtiXlHd0rr3MuJYJKNFcAbC/ZZPav+rSWA47fYXGMuSJCm75bvQbJuqVlu+uiebMvHDsi2eGz/Dr12eOKQbND0g7NevXplZ511Vrbhhhtmffr0Ye2y3r175z///ve/Z+PHj8/ef//9/N9/+ctf8p8PP/xwazvGjRuXnXDCCfl35phjjuzaa6/Nmpub22x7Y2Njts466+TXSq+11loru/rqq7OJEydW/N4XX3yRbb755vnn99prr2zMmDFT/f25557LZptttmzOOefMrrzyymzRRRfNn++MM87I71kqt956a36tjz/+uNMa+O6772b19fXZ+eefX/bvH3zwQX6vu+++u91rabvP6qNS2WabbbKhQ4dmn3zySbbccstle++991R/1/fGw/cPP/zw/N+PPvpo1q9fv2zNNdfM37/tttvyzxpz1xowYEC288475+3XZ/fff392xBFH5H+rq6vLXnzxxWnaMe+887bqy/abD8yaPlmwE6+FsleePiabffbZ8/v16NEj69OnLrv76jmyKSMWqPIaC2dNX2ycNTd+WdV4TZo0KX++o446KqtW6Oazzz6bXXjhhdk+++yTrbDCCrl+6QN9t9hii2U77bRTds455+RzZPTo0a3fHTZsWHbIIYdk/fv3z+fKvvvum7355pvT6O+MM86YX2f48OHZ2LFjswsuuCBbfPHFW++R+vxnP/tZ9vXXX2e1SmPTuOyT0ddmb395XPb654dmb35xZPb+V+dk4ya/O81n3du9pp9++rJzhF4ZM5/p2bNn/nyff/55xXs3NTXltuSggw7K+4BOLrLIItl0003Xagdcx/NvueWW2XHHHZddddVVeb/8+9//zq655prs6KOPzvV21llnbf2OPv3hD3+Y7b///vnYPPXUU7ldIscee2z+mR/96Eet76Xxdy19utJKK2XPvvRStuGFl2eLnH5OtuBpv6v6NcPGm01lx4qvmWaaKfvxj3+c2ypz8uKLL87uuuuubL311suGDBmS64DPNTQ0ZPfee2+b48Z+bL311vnnV1lllfwZDzvssPzfP/jBD7I//elPeZ96FuO2xBJL5H9bd70fZ1c/OFf20LsLZA+/P39Nrwfeni+76oH5cx/w0EMPZTvssEOu717bbrttNsMMM+RjTqZMmZKPmb95brbJ9yqJv80///y5PtOvJ554IuuIPP/88/lz0kXCj6y99trtfm+//fbLll122ZruccMNN+T/fuGFF/J/33fffTW1dZNNNslmnnnm/LvGqFu+H+kGlDVKY3NTtvczR3cYTOavR/fPltpx5Vy5OXHg5Xe/+132y1/+stVJXnrppa2T379/85vfTAMoi4Bq0003bQWHr7zyStm2AzgcCkN+9tlntxpfjjQ5L4by9ddfr/h9hpkzWmCBBbKnn356qr9zxAwFkHTTTTflwMjzMbpvvPHGVJ/l+Bm09gBwNXLggQfmz1DJiD722GP587388svtXgsoT+PCAReFw3YffT148ODs17/+ddlr/OEPf8iv8ZOf/CQbNGhQ7lA//fTT/D2O+Z133smv/+c//zlbeOGFsyWXXDI36quttlr+mRVXXDH/udVWW00F6H/605/mgC+Nm/H6/blnZo2fLJ81ftwxQDlp+KLZTDO2gAvGGpBaddVVs969e2TnnTFPNua9+XNgWQouGz9eIJvy8UJZ0yeLZk2jfpk1N00dYLQnQOE888zTqfEHTDgcOgnQcOgpINO/rj/33HPnv9NJ+mgcKgkdFRD53ttvv52/N2LEiHwMiwDq0EMPzcewWpkw+cPsnS9PyR4dtmQOFh55f+Hs4fcXzB55f6Hs4fw1f/bixztkX4z9Z94f9BQwmGWWWfJ7/vWvf50K3ABwCeQC0V9++R2QBy6A5Ztvvjk7/fTT878vv/zy+ZxNzwBELbXUUtmOO+6YnXrqqflcNedHjRqV6yG9BLjM2+L3ANiNN944+9WvfpVdd9112VtvvZUD1UrCxhgPfbb66qtn33zzTR4gLb300rke/+IXv8jt2fXXX5+dcc452Q9O/HULWDzlrIogcoGTz8x/Dl17vfw5UtsGDhyY/xRoaCPbAjiedtpprcGv+/iM8QWePfsyyyyTzTXXXGX1gj056aSTsr59++Yg+oorrmjVV0FK6ks/zd1WILnuurnNITvtvmZ23xsA5YJVg8kH350/u+eV+bN5Fuid/fa3v53KBujThRZaKL8PX3HmmWfmYFJ/ClbNYe017m3NLbZb2z27vqIvtcrkyZPz72oToafaVWo3S+XEE0/M+7NaoTtrrLFG/rtnoocJTFcjxjGNoX5K7e2WrpduQFmjvDjq9c6Bycf2zzZ/ZL9s61v2a2UYXnrppVbnxflhoIpggkPjDH32kUceqdg2DNyCCy6YGwpOr5RFYZxcg8PA+DCqWDaGaeWVV86ZFyDFZ0xgBrQcSONIgB6Tk1EuMpAACcDF2f3+97/Po1dtYniA5uSAfv7zn+eMXGcFyGMsTj755HZB4ldffdXu9TjX5KAwLKUiUk5OzHUrCbDpMxggbdRHiWnmSDF0+hZ40P7dd989N5Z/+9vf8n/7LFaCkU56koCSF4eATeXItt98UIcZyn13GZyDscQgHX/88fn1Mcjas/lm62UH7jE0e/XhebOJH7aAysnDF8jee2be7OUnD8rGjv4w64g88MAD+fM8/vjjWVcKkIkpS8wi3abnqf/o4nbbbZc7YmwwEFUUgI3DBuiMYWIlBXtApJ+JPRYw3HPPPW2CqlHjH88eHbZEK3Cs/GoBHE+8sV8208wz5KCL3tALzwAsYKbcNzFl//znP/MAxZhh0ACaFJB6CXqAQnNbH3gm+kUX2RqMHdCJeffM6drsh2sBJTIo2CBgplphA4BadoDuYqTcX18mFryUUfQ3rNnKW26drXDU8dmCp57dAiBPPeu73084I1ts932yGRdYKH8moCJ9109MP4bM78YIkNYf2DzAUFDh2QTD2G7y4Ycf5swVkD5hwoT8PXrPDiTgacyLjDf5xz/+0dpXCVQCp6X2GRGwwqpDskffXypnHdsHlAtl97+xWLb0ioPyQJkdkhEpivZ5nmQPEqDFZPobZtl7gva2hN5oO0LDdf74xz9mtYrgk16mcdfHAGNbgiHkH8plrspJCgSAZSLYoSvVBqN33nln/n16p31t+Ypu6Zx0A8oa5d5PH+00oPTa/elfZq+99lo+kTm5JNI0ACUQKQIk/s6xtAcoCaAozYwVYCgBEg4vGZljjjmm9bPYxD333DN78MEHc+fDIIq8pb8xnQkQHXzwwdOwntqGqWAYGLNiVMpQAE2+f8ABB+TMBADp36JNjpkz3mijjbLOinQWFqXI0pQKIOsz1Rig22+/PW/nLrvskqfwMT6lIm3mM5xKJaaL805pJQwlcI+tER1zdvonyeWXX97KSvtckRFLL+PAAXByQH+RnfE6eO8hOdirJk2d2MwzjpsjB45JgBPXSswr1sZ9UunC2DFjsj/+4az8M5x0KtHQH+eee24OIqo18nRE/2LMu0KMEx2n08m5+7f3vQB3/ex+nGCReTNOQJVnlP4E1BLj5SUwKopA4JJLLslBn79jmTnjUtDx9YSnW9nI6tmp+bKzLlukVZ8xevQltUV/A2nmXXrPPFdSYa5pB6AsTc6+AJ6JNTOP/UwZCS+6JnjUL4IdKe4ErErF2GqXFDgnDbjTyT322CNbf/31cxCPFSzVXfcolvRox0UXXZRfw/O5Zqne3PbAg9nApZfPltp2h2z5HXbOTrvy6qyuV698LFLZgYBPPwB95oX3BUcCdPbGfdlX5UCpLUBmqa148skn83YBpK+++mpug31Wer+0NIL861//yu1ruiabBri7F4BefJZnnnmmxZ7suX526gWzf6sL5fQBY71w9vpnh2QPPnp9q6039vq3VNiJFFwKkPgI3xGkA5LAqLmrrZWEDZcel50w/r7PLrUVIJWKjJa+T6Kt/Fdb17jlllvye7WVLSiK+WsMUz8kG12a9aokdCIF5VjKI488sqrvdUvt0g0oa5TbR9zfqfrJYh0l4cgoOgdFOL0UdWJxCIOlBqQaQJnko48+yg2N76iLEp0BSUVjB0ymWhZGmINnDJIRxUSKzpMDEsVrX7EeSspKWpHxxpgVhdNwX86GAQRcXZ8zN7EZvc6IiBi4ag+UMHoYmGokMQ8pqi0CriSpnnWDDTaYxhG+9957ufHS51gdDC0nq5+BQsyz75amTBlLfVV0VF4i6pTeTnpRfAE1akc5jh23HJKNfX/RVhZxWiC5UJ6q/vrt+bNzTv/BVLV5HB+nLw2angmwTOxeCiikE/UlZ8SgA+tASmLGgDPOXv8V9aScYNGBoXKgvRYdADISoNAWoLCaWmLgAWOH6TLHUl+ndHL6KW1ajqFzD/qPHeS8gVC6aP5MbhyZPTZs6ZrAZPH1ixOXm0YXtAXY0W/S/HRr5MiRre0RuLEPwL3UbwIc6fvmKdZQEIaBo6upn4wBmyHljYV3DVmR7bffPgecKTgqtse12QzZCvXVxp3OyGzQR/cTTJnvvu998x74wQy2JdplztBv90m1dDIqfmIoAWi/m99YfaUj+kigCtzTDfYrBV90OQFM9jYF7MS/Ux9jMO+4445p2gQksZnFPgCO0t/UnXpPCjoFF/TMOCYGcNKUz7MPRp2XPfn+xtnVD82VPfjmytkLH2+ZfTjqz9mkb2uQfdfnBZjqM/1ufhb7JgXsnjm9J5DgTzyn+ahkAlHQVgraHACmzQHzyL0wjpWCilJJQehnn32W/5v+FX1XOVGD6jMCk2qFXmmneciu0EXseXuiX5SxJBYW4Kan3fL9SDegrFHu//TxLmEo93j6yFa2w+RgdKTrOAX/5twSiwWEJKYhFUBXK8BPco6McTE6Z6wYn7QYR7pPtIp9MumTaJeaKc46pdJMyrRgBFgERFKatphGlC7zeewFw6aeKRXEM9wY0Y4KA81ZtFezw8hWUyxOGOUE+LAZmNRkmNQJNjdPyo1bcvYASRIOGbDxXEWwpp8Yd4ARcwmIJmGIjW8xLet3oBRAKQciOXFppQRKOU4sGbbh0EMOyHbaamD21D/mnAZQvvH4QtleOw7OZpxhwFRsmvSna3LSyZFwkPPNN19+XcDA80tPuz8Gu1SMq7QsNsDnUyrSs6opTTWJ5RxLe4siyol+w1BhcOgAvQM6OiqCHbpvrtBz80//F5lg9WaAkzIP6eLkRNPYY+xT8HXi2StlD71X+2KMxFJe/9jcWc+eLfcGrMw/OgesACnmqv6Wvttiiy3ysSoCPT+lraX2BUkACScP1GFizV/PAgwa+yLjmZhE1wQmgUrgEsgENoFOz9tWIGBOpnbQiVTHSGfph1c5nSgNSF3DGJx33nn5HAIGgeWU5k1Bn9IDIAr7bOwAUUxoSrFjEKXwza30rK5l/gLn5mWag6WlLHTfc6cFTL5n0Z3fS/tALSK9EVAKyI0V+6dNxRQvFrxcYJkE8NFvrm8cBfMJ/CfgimQA1kvBH72Uak9BlnlIDyqV/AgKfU4QcOONN+afN+7VlAilRaNYw9RX7N+uu+5a8TtpkWSlDE85ASS1CwOcAlusfHvC9rqXQIotY+PKMb7d0jXSDShrlDdHv9dpMLnZw/tmG126Q84sWciSFnFIaxMRIuPFKBHGPxVi1wIosQCACePKiWAROWA1LIwbx+CaqZ6IAJzAK0PFaZYKA2iFZloxZ4ICrUCNlenuwfGq50mi4J9zYrTdMy1Qwboxvgx6rYszGFoGk7NrTxhj7Gw1gnHSNm2++KLzsp22GpRN+HiTlpXM3wKzse8vkl1z8WLZLw/bPGcfATLPZIw8O4NZrt9S7RggrK9EzkUQUEzDloID/ZRqKxnGIggD0P0N28Bx+Q5nO3niZ1nT5HeyHbf7YTbTDD2yxRZbNB/TYmG6gAao4CSLtVocdAKvmCAClHNu7aXEjKV0KwYBM5AcNUcjFanW1319DnNVi4HnpD1vCsKAhs4EJRzVbrvtlreP3gOlyj3oqrkp2BJU6FOpfX0AIKTx0W+clZo2rBYHe+mll2S3Pt0CDDsCKNNr7Y1nyNPKasdkBlKWosgUshMWI1mwJc2fAj7PYqyKq7jTi84K8GQO9L20tftglbFG+qSji6VSHXAq2zjllFPK2iVzBVtJZysJm+I6shrAQyrDMXeAynSPtDgQqKHbWNGkc/SLnUnpVc+mlpxeF/tEf9EjwZ15SA88i/liAVNiL4E57wNh5lo5ofuezzjQ1QRqi/XognnvVQLl0u/mZQrK3V8JB0Dld4BRVsnvwGk5MU/VywPk2iBIYActGCqOr8/pM7YLOeDv+gyobW9uuY4gqlhvLuDSh6UlIEnMKe2m07UIdth8wyyn5yqtgS4V2QXjxAfwq+Zvqvnslq6XbkBZo5hABz9/cqfT3rOtMW+rMZMCSsbRiu1UI+LFQTHKqY4qrR5sT0w0TgMTkNgyRjXVYmKzMBYmJSagKFIKnJe/VZr0JrVoFgPFWAE8ImpOVfrQe+o1U1qJIW9ZPdy7taBceoRDS+ljrEe1klIt1bBSDCUQXI0kkD387dOzxk+W+7Yucdo6xMnDW34+due82S47rpmnnjjItlb/FoFIkQlKq3nLvTh9aTUA178xDdgDv3N+KVUHEHDkfmfMgUNMhUg+AY/k0OiAe/o3QA6Mqp0rCtYLAPRdQCMxtx1ZDcqxeAbONYFo95Sa9Hx0p60tq1KdmzbRK2CP0yqmezsyj6UUOU4AS/9xrClFirFM4v2UXtX/vmucARtOztgXQd6Kq/ftFJBM28b84ar5p1rAop1Jh/yeVrQXX5wnZn2zzTbLS0qw6fTC+EnFA2nfl1hElLYWS3WIlerc2CL9JhtSqntFEUwnph7o89MzsDPpmYt2Iy3UMQfSvCqd++YGBs3fimUFgJG0L0ZYu9hI79MHQKZYRw6Ee6+SAGYpo5MWiBW3ulG2UKydLxUkA8ZVdojo1zT2adFLWvHsWm1Jqp9nC4DzxF4LbBMg42f0cyI16IrP6sP2bKyAS7BVDBhSyr6SsEeVdsmoJIIdbcfWu4ff+YG2hM7oO/MCqcKvpaxTt3S9dAPKDsg9nzzSqS2DLMh59rlnc2OZgGJxhaVJneq5RLIYvPT3agAl5yziNGlFy+VAUzKWHFM59k7kbA83nzER22IsGCMRatqfDnvAoXkWv6eaTO2SdkoGPK1CB1gwBgymRUTtsSP+rv0MdnsCDHDK+rEaee65Z7M/nj5j1aukp4xYOPvitfmyVVcaUpZt0VbAo7gwoL1XMQWZ9q3ESABhnKlrqldN6VVMtr5NCyL0J2YF8PKSJi06L6lG12dYk4EuigDE2GHe3FOAIcIHVDq7zZPvc8yAGcYppZQ9MzCAGS2m3QVXCUB7BsCv2vquSmKc0jXpY2Kv0gr+0m1FPD/Qk7bmwhBLjxfBnnlM1wGpo09fMd/6pbOg0h6G6foYNyy/YE2A5N7YXm1iGwCEYp3d/7QINOgjgG5VrkBHu9oKFAQEWDjzvpJdM1bJPiZABUDSo8RCAl2CFnYssY2JkZNJoev0xuew5oCT8cJyydSwX0p20nimuZf+rY9Ld8zQ96l+sZIow0hZB+BQmjxJe4sSU3lJyh4hFfy7mPombDRdbE/c21wDas0xwZl/m98Yej4hBaepLtS8oNN8UVvpaW1je4qZC7aZrlYSNkt2oVbh12RfiMyb+dtWgEMP0o4bntu6AnanW74f6QaUHZDxjROyPZ7+ZbbVYwd2CFSue+SmrekAk1AaG7uXDFixbkuknGoOqwGUrofSZ0zbSo8zpIwsQ+d+VgYWi9QJwyUSd18GtL1UJxCqnkkkzCgzpphXbXGvvA6xubl1aw/GIDkc9ToJbIoiS7fKKEpKAVVK9RTFdSotriknn75zdO17OX60QPbFa/NnH3/09FSgzDgUayPLvYqghIOxUILjU0ow39w9s0v+vGfWPOHebN/dl8722eunrdc3FgyjPtbXadU1ViGt2LRKlVPAFBdXYpIEqMptjYT942gwyhwfcFrtxvC1ipphLDqwlFZieibOIjFM6t8sIql2m5FKgpHVF8YEOC0yRhhgQINucqzql42H/izWsaZMAgCnrg+TiQkuOvkPRv3p2z0mOwcoH3x76TzdXZqC9hxALd0xfznMzixs6owAWontK85brCA2uprxBzwwhVjUSiCiuOo+zeVUAoLNk9oGfNKuFoIff8Mgs60J9JsrmNsiu61vlZDQsyKgTAF3uQVEUtJtAaa0LRaWTnvzLWv6Ds7uvf2R7MUn3s6WXHCl7Gf7VwZUghh2WXnSZZdd1hqos6XFNLQskb+1V0dOP5SfsBPp+2yUlHCqtQSQE2uc6oMFsGyAtihtKiepPKbIRidWtFKdbEdTz+l5BXhqlo1pJbuQ9sWUgfPTM8mIKRHplu9HugFlB+X9sR9l2z9xcLZVjanvDX+/bWsKsli7SBi5tE1LMpalBi7VwFSaRCJRDtDEq0YYFNf3HamZcttMiOT93eKW9lKTSdQRWk1a3ENRLRLAZFJzAIyjaLO4ghbTgVVjKCz+KMeISa+oF6uGLUvbdrSVVkvSPOXtDu/nCFQ+eufSeXoxLUqp9ErOMa2MBg44X33b3Dw5a55wdzZ+xJblt/sZuVfWPPHB7He/a9mYnjFPpw6lFJ7rcrKpf9I4JAFSUoq29NQIeqX92BW6qM4XG2ycumIT+nKiLoy+Y56wlKl/EpDDwFjJy+lXq3+lgmEBWoFJYFG/eTZZAoClCOzd12cFRj4LFGBwEkuVFrphO1JKsijDv7msw6u7i69/vb7iVCuxicUtAgZt9CzmVGcZ244KQE5vjZc+KrYTWKhm0UQCT+Y0e5AWd5Qrb0kBtiCX0M9kG4GtBF7S59OK7FS64eU+xf0mgVjAMF1DkCCIoI9FGwwAsY3pGYFnr3JCJ9QfYhPNJwByxzWPzNaf59Bsg3kP/+413+HZqQdcnv+93NwSVAkaPaMFlcC3LBA7nMR7dLfSKWFFYWfNbSn9Yj0nAC5YlFVK/elzyky0Cxi1l6j32ZLStiIDShcouj5GuVzAStgX865W0RYMfWJV3bcScWL3BeBRcCMDQswdfq5bvh/pBpSdkHfGfJDt9tQR7YLKxGRe8M7fsylNU3IFT0BRCqY4Qa3a9LfiJuNFlisBAYYVuJSuZFSIVZgpYq9W0jYPjHA6gYMzKK1nBFAZfE6ilmPnGFT1TiZ2ctbAtGgZMJYm47yLp/MwfGk7Jena4pFy6egtEXA1AqCm6LQ9afrmpKzx4+8W39T6sgfknLNPu2lz8eX5GTqpbOBIX3tfCqpp0mtZ02erf3ecYdn7LJL/fOXhubOTT9g3Z7qLDpNz4QiBtAS+MI5AOsFYAgFAontynpjpj74Yld3/0tvZKRdfnQ1acOnskBNaiv/TEYDFmsKulnSSEd0GhgUcSjXomTQ0YJAWUQDMFqAIctpaMGBOCWroSXGxSrGOVV8Bq8B2OnWEfrW33RHRLt/BApd+/uNRd3e+hvKd+bIzL28pIUnzha6YL+mQAA7V7+2ditLV4nnZJ20DeMqNA3Bm3KoVugrQGJPSVdbuV1y5DuirYS3Oq7SAkH6zm64FzKRsj3pjY6a/2Dlp3cTSYzMBWWUk5g59AeQBrVQTml7YPHWW0upYynKiRCivw73vseyAjc7OweNGC/xiajD57WujBY7If/rcZ8OnXlWd6lDdJ2WHEutWXPQImFVbF9jeSToWGKbt5rz0hblmLqbUsZKs0myWRUil28Clmulyma1atnIrFYuqzD0Mq/lQbl9JoF42QTpefT6dIY57Lc3WdEvXSTeg7KSMmvRNdu2Hd+R1kUDj1o//LNv68QPznwlInvzqH7Nnv3p5qgmMIUkRsIUJKQXuM+p+GCSTrqF3j2z7k3bPFt1jhWzJn62SLbbXStlc6y+UzbvQdylCgFOqwu9qamqRtOeZtEpaoen+0o5FUJJWQEsBiZw7cgY3lrAIfrRZgTmnztGXns/KsXAOjEZiXNU6iZ6rTfEpPGd82l2Z3DQ2a/pkyQ6DyZZjDBfITj6yJQjw0u7EQgJCHJi+K4paI8HBSsv2ziZ8sEgrYGyfEV0wa/x0xWyfPVs2WffiWADnXG8aGvK0LmZO/SVQYiw5U6lkAcPzL7yQDZxv8WzjY/+QLXnI76Z97XNitvgG22Rrr/fdNkddKTYbly6lv9qLtebQyo5Pc3NelM+pYZQSUMAEAaACMcCZ8011X0UgkFhXDoYuAaycYjqCNJ0VXIsouTCuiWXX155nyHQDs1uembvToPLt4dfk9bDS9KWst/kCzKVFV7VuSN1RAWIBAcAMsKp0TxkG2Y9axHgYI4E2e1S6N6z35110iWyOldbO5lx942zGFdbOlt5w62yF1dfMAV4CgBjTFCRIi6ZFgIAecJQCdHV8AjvgQz1fAm/FAIHepb0dBWVF5hzTlU5vSQJcs50H7H1otu3yx7cCxvZePufzH73bEjwDyClzVFwt7RkF54BeylJ5rnLbB1WSak7SAThdE6jVDnrOt5hn+qLos0pXpSdJDGK5bcGAQoCvIyKTx3ea75jKcoxjWkRofNi7xJSa/+xyt3w/Uud/0S2dlsbmpnhm1Evx9pj3Y1zThOhV1zOG9BoUq86wQszSZ4ay3xk+fHisueaa8e6778bMM88c99xzTyy99NLxwAMPxE922jRW2W+d6PeD6aNn/17R3NgckWXR0KNHZP6b3BTv3vxKfHD7mzF9/eB4//33o66uLpqbm2ORRRaJTTbZJH7yk5/ED3/4w+jRo0ebbff59dZbL/7whz/k/x49enScdNJJ8fvf/z7mm2++/OeGG26Y/+2VV16JDTbYIL+m9i688MI19dOkSZOiT58+UV9fHwMGDIhx48ZFr169YrrppovPPvsszj///Nhnn31aP++9/fbbL2655Zb46U9/GnfeeWecc845cdBBB1W8R9Y8NmLyIxFNX8Ydd9wSDz38Qpz5+39FXY95Kn9n4r2RfX1gdFbeHTYlFl3to2hqasr71RicddZZcdFFF8Ubb7wRd911V7z++uv5Zx988MFYa6214s7bL441l/p99KifGD161FV9r6amiOGfTInl1/0wxoytjzFjxuR9S1599dX42c9+lt9jySWXjHfeeSe22WabuOaaa+Khhx6KuRdeLPa/8OZ499ORkTU3R119fZlOoWkRvXs0xDl7/jRWX3TeTvcPc/Pwww/Hb3/727wv5phjjjjkkEPy/jr22GPj008/jaFDh5bVm7feeivvu9deey1eeumlePbZZ2PEiBG5ziehR3POOWd88cUX8cknn8S2224b5513Xswww7RzUD+ss846cdhhh+Xt6cizXHzxxfHzn/88b39jY2P+PD179owfbfJ17PbzoVHf0IFOioi6bEisOs+Tcddd98S+++6bz8kzzzwzNt100/j3v/8dzz33XDz//PP5zw8++CD/Tr9+/WLFFVeM5ZZbLpZffvn8tdBCC+VzrbMyefLk3CacccYZscIKK8Rf//rXXL/Lyddff52PA13T/7WIftx///3zfjVuBx54YOy0887x9NsfxeSZ5o+B8y2md6KODcyyqKurj6iri9HvvRorzNw/brz4jznm1k9nn312zD///Pl1d99997j88svz3xdbbLG8jRMnToxLL700/9wTTzwR5557bhxwwAG5HS3KhAkT4kc/+lFur3/xi1/E7373u1zvjPOUKVNilVVWydu89dZbx/bbbx/PPf3v+NHce8RXX4yJ5qbvdLM9qW+oj+lnHhTb/nKF2GrbzWOllVbK58rjjz+e3yPJk08+mf+bTdl7773zucBv/POf/4x11123qnt5Ds9777335jaoVPQPu0F/LrvssrzvLrnkkvjoo49iwQUXbP35j3/8I2abbbb405/+FIceemiup8kGGR99TQ+vvPLKqa7v3zvvvHNu/+ltrWJO3HHHHflYbLfddvHee+/FvPN+Z5/M6euuuy6eeeaZvH033HBDbLnllrnvYGfct1u6XroB5f+ycJS77LJLrvwNDQ35JF9+u1XjzNcuzJ15fY/KzqA+AMgsnjnx3vjo/nfyiWny9u7dO15++eUcjDHswCBgAwj6d6nsuOOOMWzYsHjsscemeh8o4Sz/9a9/5WDOZAQwGZP1118/Pv/88xzgrbzyylU/L/C8wAILxIUXXpg7jDfffDM3gu6lDWTttdfOndGMM87Yapiuuuqq2GOPPXIDrq+22mqraa6dTXkzsvFXR0y4KSIm5o5H/7T6014/jLp+O0b0Xivq6qYG2dn4ayIbfXx0Vr4Z3RxDF343jj766DjttNPiV7/6VQ6SOSDOmCP+8MMP82daddVVc0f99P0/iZhwLXda8/2amrI4/rcjY/hXG8cVV1wx9TNlWVx77bWtgIRwDOtusnnsdO7VMWrchGhqbj+e5F452d/uslGst8xCNbexpZ1NcfPNN+fAjZFfYokl4ogjjsidgYACkJx99tnz4OUHP/hBDhoTePST3iTgONNMM8Wiiy6aOys/ARvP+uijj8Zf/vKX+Pjjj/PP0VVOZKONNsr7GgBIYjwAr8UXXzx3xO0FXUUxt66++ur8RWeB1bFjx+ZtMJ+XWmqpOOHkg2PmZc6O5mzyt6Ri9SLE/8vvvolXHp8rB43mr/kCKJcT83DzzTfPATbgI3gQYBJB2zLLLNMKML0EgWxNtQKwsFHm6AknnBBHHXVUm/2lze7z9NNP5wC3VtGPAAFbeMJJJ8ffnhsWA+ZbIrLmpqirgNDT38Z98Eacs+em8dONN8rfB8a0+b777svtiUAD+KF3ggngfMiQITk4oSOVRHDiWWadddZcX/xkZ4273+nTwIED86DuZ9udHO89Mzq3PbVKXX1dDBv9dMy1XN+4/vrrc90SkJYG0MYDmHv77bdj0KBBuW4IGAGsakTwwx+8+OKLud7MPffc03xGn7HNiAb3N4fvvvvuXBcFg8apf//+OSifZ555cgAMmJu/SX7zm9/EiSeemM/vwYMHT3PtUiBYrSA2AF7zHeHguQXQRLsAYeMrsDD/2Q/2AAhnDz1LVwRa3TK1dAPK/xABOkzaWdaYJ1Y+db1pouRKkjVnuRHavNfa8cE9b+ZOjuFnJNdYY43c2Pj3Cy+8kDuR1VZbLQeXGEyTzn1E6Mcff3wOOkodjcl544035gae4zryyCPzl+geyHRdAG/jjTeuqr3JkHB6AATgxXF4D2BkgBh5k52BxBho81dffZUbTd/x3V133TX/nufMSzfG/iFi3J8ioqENYPbt33ouE3XTXRh19d+B62z83yMbfXLNzr9Uxk+IWHi1cTmYP/zww+PPf/5z3jcMnkhfX48cOTJuv/32vP/uu/fWWGuJY78FwLUL8PHJZ40xaeA/Yv75y4M9LAZ2QZ/Ov9DCMccWB8aoiVOqApNJaGNDQ3389aBtY8m5Z6n6e9gdINZzM+rYEECS8wEUi6ARmwqQJTHeCTSmn17TTz/9NPfBYJs/+vaXv/xlrtscP6drLDh7OgaccTQ77bRTzuwBPwBqewKgCXIENpyZwExQgwEDlJ966qkcGLsPVkk7b/nHSTF04RaQX19fLfNcH+NHLhRb/uhfMW7chDz4AnbaywQANgCROQzImcfmJgYzvfQ/EXgWQSZgrb2lIJHTxYqyDe7/t7/9LZZddtl2nwAQMneNRTm2uRoxp487/oS46rUvo/8c85dn0MuIXl563tlir+XmiNNOOTnXAcELULPZZpvldgxAwo4ZT/YDyDz99NNzoNyW3dWfbBEdYhMBK0zXr3/965zRy9vdHLHG7HtFr4baWbfWZ6+fEtc9d2oMGjwwnycCJn1fFADWmABTAOdee+2VEwIp+1GNfPnllznbbIx8t2/fvtN8xpxiOzx7kZFGKiAYkAKCfPMNONSP5ncSwZ15zA4WM08JEJayr7WIecy+ALX03VwnSAptZWMFQ3yK8TG2f//73/O5b774Xrd0rXQDyv8guePJf8RfJt0SdQ0i1dqip4a6+jhjySNjvgFz5pM1MSgcoQiaERShA5dAHUDIWQGX0nRSIBw7x1JOkuHkYGaZZZbcmIhwd9hhh9zhSVFJK7UnIkTpIfdPjBGjDyAyTIyXyb7nnnvmBgDAYBxEwAAHRkh0LE3Kef/lL5fEuj94JmLCFbX0VkTDnFE3/XVRVz8kfyebcEdk3xwWnZWPP22MOZdtYYcqiUhZxI49uvgPa8fGazwna9cpqRtyftT1+fE07xtvTkN/M677nnR2jJljqaoDlqLU19XFKgvPFX/ed4t2PwtMcDac96hRo/KUHPDlfXomOMmvCeTOP3+ud8afU8B6c9zGtz0BCrHot912Ww7c3ZOuJMFqcoaYFXoD+HnP82PmgW0OrcheJgFEBUvmEeYFEMN4YLcwyxwVdsf3jzvuuJyZxNxzophPjOmRJ64bG+/64beBSlsMtPHI4u0XB8f+27wQG2+8Wc5Ccc5Srdjugw8+uE1mUV9g0fSlVCaAWxROtQgygWllBASYMEYJYGLGzHf9pQ0nn3xyzshVI/rFd417R/QsydF/vT3ueOGtlrR2LZJl8dXrz8aQES/l7CSWOrFR48ePz0Gx5zZWt956aw6CPB+bA/iU04UkN910U349IpAAUtkrwaFSpTkGLxZLDG0pD+qMHHPezrH6RkvnATW7Z86UinZ7PvbePNcu9r6o/+2J4F1ZlO8CraXjlfoLuwj8lQYd5rOMEtZeEODvwC0WUNBCMIR0z/eLYJY/Asy32KJ9e1JOjF0KEsx7bWFTBa/S2v6922675fNYeUsKPLH57E/KgHVL10k35/sfJMOm/zx69OxRM5hMTNVtH9+X/y4i54AwEuptsAWcKUOfauv++Mc/5hEeNgGYJCaftKnJXiqiuVNPPTX/vuszQCaz9xhi7CID115JLoMnYi0abfWbDNLqq6+eT3YMDwPAqWGjAF5AgxNXpyNFAhxhrW65ersawSRpimj6KLJRB7S29413+0WhFK+D0hCzzbN17kg5JqL96qowDancQCTPUDNq4795sEOpsaI0N9dHNvnpad43jhxdMpxYhJlWWKvDTr45y+LxNz6I4V9+XXL/5nxc6dgxxxyTjwvWDyuEWdbHHCLmwPsCCuyQMRSocO6cA/aAQ/Lv9sAk8ImZcS+gTo0URqLUmQISQBIHw6FxPATwUgMsRUzPsI1Sd+pcMarAhtorzsoYapu0J/0EHtXLAZiCM+yOgE3ghvn65ptv8vfMjTNO+GcsN9stMWP/jaMuOGN9/938rstZ84jJ42aM804eF0fv81FceeW1uaM1v6QksVDmqIyDPqwk0pZADvBrjpfORWwchti1gGTX0laAhb0A7D2P+Qw4sx1YMKwnuwCMmoPtCbvjWp0Bk9fcfFvHwCSpq4uhi60Ydz/4aD5OCUwKRtkYJScCFs8qeFEbasyVowhKUnlIOQF+6AQByAm9MN76da2VNolmNGUnJIvm+NftT+W/CwbppFR6qWgH2ygT8uMf/zifOwKnWgTokzZW06jcpFToOKApABEklIq5oYSF3hN2XXAHhCqFMqfYPzr5+EPPxL03PBM3/+XhePT212KOQYvHh8NGREcFGWK+s6f00ngSBAffpu10tsiqJ1ayu4by+5FuhvI/RMZMGRd7PXtUNGa119EVWcqLV/h1DO45rTOWvgLUOBLOF+jBomBbMCvAJEZDNMcAY11MWC+fK3UOJi3GhHHGFjIkDI4ieoapEpOiSB+QEs2XCgfIuLluqqeTbuNU1fxItWMIAA4F4fvsvUfst/VV0a9Px9LF5PJb145DjrgqN9g3XTZrbPTj/tGzhoUxpVI3/Q1R13OpPPJnyBSoA1NAMBDFuALUDCGgsNJC58d8c7SwdR2VxsYs7nu0X1x1x5I5qPACkoAEThQAAsQff+2d2Pei2zp1L5nbVWYfFHNM/LQ1Vc3hST0lMfZ0RllFYsywstXUKQIydBCYqST+hgHBzEjJYZeUdrQnAKz6LiADgKBvHCUgqtY0sXXEGNFVIEFf+rv+9Myctz4F8JJ4H9sJtAJkyjKwewI2c4hMbhoZn429McZOeiUam7+J+rq+MWVi//jTmS/EJX96IGf76Xy5BUTYThkAbCWgas5VmmOcuDak2rdqxbUFhthN44C50sf6yBgLHNgIqcpiuty/i+wlZy6N6tlrFUy61PPVT70RM628bscA5bds+u5rrxAH/2S1/N+eia3DtLEh2oyh9jsQDkiqFQcY55prrhxoVqpZBaAEiJ5Z4MtGqWUUbJ99+HXx+D3YuuiwWAo3ctL7cfQfd8rtHPsM9At+KjGmiTAwDwC6WqW9RTr0XQ24uWfcp2lzluV9hwGkp3Re1krQNufQRWPmXovG9H3Uadbl5R9Za7lWxLpbrhg/2WnVWHDJOWpuNzZS2RSbp38EmeaPwNF8Mt7mugwYMT+VhtBrNqpbula6AeV/iNzx8b/i8mE35sako2Lt405zbxqbzb5em58TzUkzA5eYIdEaB4BBAzY5EICRcfE34CeBS6vSk/Ng/E1gzCT2Q2qDM2PgMBpptV9RGOJUTF1JOHbGHihjLNQfaod7AUacq9R50/g74+/ndzxtMaUxi1vvHhvb7vNp/u9N1h8at1w+bX1eNZJFXTRm88ebX5yRM4PAB+YMEJeGwYhwysAx0YfS+XdeNVtssFbnankmT8nib9eNjn1/0TYwnedHP4kBS6/ZIQa8KOM/+SC++uffcnYQkwg8eXHEHBMw05GVmySB7lREXxRBEAZU7Rog42c551ZOpNywPdrLqQiAAAhzgFPGSnHc2Hfg+JFHHsnH0XMIsKQ1pfaAuWLNl7nE0Rpv80TJBhbM2HoOzh3zRZ/LrRCXTqYfF1xwQQ7A2xKstkVeaeGSmtxKtZVYKwABYyUD0JZoC4YK+MTgmJvKWYpi/tHdYrociBao6kv9lgDmKaeckjtz87UWEZzos9ffeDOWPvD0mNjJjMHAvr3jgZP2id+dfVbeb2po1cCmuk4st+yNPhJU+LtnYseMKxvoeUqFXdSnAkbMPN3yffbx9J/9LR69uyX921HhA75p+iie/PD6XOfYO4E6lp2NLgb37uMzWFIlEmyxVG+15QnVLtLRH3SOzTf+5eot2QAA2Hyhy5dcdGmcuv/f4s0XhuesbX2F4EBtdlNTc2y2++qx1zGb5P+uVtgELC2mFVPJV9A9RIcSEHORH1HOQTyfzwr2+KJu6VrpBpT/IfKnd66Ihz5/Kpqi41a0PupjtRlXiIMX3K3q73BSDKe0D2PKWIn0GHZRu1S0vzOYJimHw5gynv5uuyMTlwOTpgMyGBZOV7QKaBZF9IhdYRzbEsZemzhqAqS6vsJu0ScnNumzraOh6aVoOdyhY9LYlMXKG02I19/8MqZMmRxP/mPxWHqxidGjoXqWklGXLt9w+xFx/yNTM3UiZGlf4Ag4ERljEbzUUV589vSx/RYDO8WKNjZGXHJ1cxx3xqicadV3RTGm2jjLqhvF9MutGfUN1a9oLiezDRkQO87XJwcMWD9AwkIYDEUtq6XLCeAiLQ4AAI9E2wE/wQSwRyfUllW7UhmzJn0MJAJxmHqMI6acA6TrXmnRAecJrGE+1UPS4bToAsCQ3gY6tAtTKnWMPafTxSCKk8ZaYkjSFjiE4/M+QAt868fSedKWABiYRAsjKrGVgJ45ilHiPJU7lBMLUjDlQDVHrJ3ldoKoZDuMf3ELIyyd5wYqBI7FLYw49XJARD8KEI0vUP6nSy6Lg6//rt6uMzL3x8/GHdddlY+NEozSfgL86a2MCWDJ9pmXABGAS09KFxymRUeeGQMvILBIhm38w69uiHuueyqamzpBUdZl0TxwZDw/4s5pyo/cK2Uh0ouYK2yjwATgxaLXKoCooMv407HSoNDYGkd6jBksN47su/lx6y23xw9m2z56NQ+sqaRn7c2Xj1+ctV1N5RJKaNQ6s7Pubc4Ckcq6BLiCwVRilUCvuVeOie2Wzkk3oPwPkd++cVE8/dWLnWIoyQrTLRlHL7p/zd9LUbe0tcl2//33507Be5ytWjzAMYFLjooBEeWlVeOckwUSGEYTWB2V66pFI1ggAEs9GufVnqR9zLAAIm4pK45eqhGTOmji6lxCdFa22nNkPPF8r9yI1WXj4vYrBscSi/auClTmdZd1Wexz2Odx+3298vbqJy9pe05XnVpxr0RODfDyfBv/uE/c8JeZO/0Mq23yabzybXkdUKm/OG/OndMEMmdeZYOYcYW1o66TgLLpmy/jtctOz403hg1r3Zl6uVKhGwIZLw4AeKRHUtUWg+nXWoROci6CH+l0+iid7T4cZGp72pcQ4yj9K4gBRAAhui19J7WonhczQjhftWwAouuXinFPbKEAif5z/upagdtq9w0sFXqlba6rVs28KN0Xkt5hlbTBfC0FirITQAjwCYiU24qrVkk11spWBAdApiCK/tF75Q/FdLm0MkAs7QycY5je+eTL2Om8G6Mr5JNbL4xLzvlNnsKvJMadDQO8ZW4Ew9qOVWbr6A4dTGLctFW7U600ttKzPXjns7FQv46NaVFOvXzvWH6NhXOdY3uNkZQ2m5HsS3oZ56LQMf1bCjy9sHmli7XKLdIBsmWZSuc1IGnOA+DlUvBsgu8s2O/H8eZzwztUsrDr4RvGdgeuU/XnESHS10MWXSL6LbVszLn4EjH9zLPEpx99GBM/Hh7Xn35yLDZzy04OwCb7kRjlbula6QaU/yHy+7cvj0e/eDaaO8FQqkkZ+kW/+GnDj3J2gAGpdq+ttOoubUbM8YrEMUNShMCJCQhcMhpAi4gewORg/Zux8jfGz/cAGcwLZgjQSumG0q0i8o3IJ90b0fRZZNmkqKsfGNFziXj4ifGx5ppr5dEntlO6Sn0WJzXH7DPHi/d1ehVNLjsd8GlcffN3Re8D+tfFVX+eNTZet39MmZJFz57TgqUUdU+aHHHoCY1x/W1ft7JYSbBV0msK19VYcVzEKkhgm2Hv06dn7LLRpdG397gOrfS2D+XLr0+JHX7WJ2esAI0kxh54kubFtmyy/y9jWO/qt/wpJzZB7zHmizhglfnzCB8gqDW91p6kLZUwIVLIFrvYOxArWK2oHaXL0uJ+10YpQforICkyVfoMSLBHJnZK4IIhpbOlQteBCfPDdbAi9JFgd+i/l0Ar3QMIAD7SwQGeC2jFNnVWLAZRsyZ7gK3E8hWfjd4BnJg0dYECGQAE4JOKFwhiB+3c0BUCAEmdFvcXZAdSLWZiMzGbaYFP2s4M6NOfl11zYwz9yd5d0p6t5+wRO2y6Ud6WtmwhAGnc2CjBtLFkx1Jt4aGHHBZbbrBbDHvjk3jwgUfiiScfjzETRsZ0czfEW++8njPn5rrAYti/esU3X343D2uRfLP2Xo1x9VMnx5AhLfs2AtmCEowhtltgVRTjafEJ+4wlFUSykwlw0tUkwB6bUA5sppcyDcGW4I3eFkWfmPdsjb4qrV3GAl96/tWx+IC2yzfakl59esS1z54Uffr1rmqh4LUvvBSn3HR7NPbrH1lTU9QVWWilB3V1sdSsM8d+q64cK848Q+6TOrLpfre0L92A8j9E/v7BrXHLiHs7BSidpvPudS/Fy396Iv834wJYqg0r/qyU0mJMOFORcFEYJakfIFEEy4iIYNPmwBgQoBEQ8OJMgCkTl4NmyDktwMoqWe9hc1o2Ir/q243IMY0MAVSlD5pjxKc94283ZHH0SU9FfcPAHFBKb3DErvnek32ioYbUdCV5b+ShMTFbPQd4gAfnK6V4/NGbx/137BU/Xn1i9O419X2GfRRxzgVfxN+uHx3jxtfl7BDgo0gfG8NZAzBJrIJMp0VwWOqekmRj/xzNY39vG/YOtX/PQz+PJ16YpbV2KrFV2gNAYBPc7+kXX4m9L783N8IdFQ5vxH3XxahXn2p1UO4jVUl/Sn96lUtztiXYSKDEvaSSLQiopiZTClsQRE8ELfrCNeg8/Sxth1QYhknKWd/Znw57WC49LOAC1oyhdCKgmmo8OWxASoDlJ/YSuLBSHMOvHtR2W+YNphMANB86Wx5QBMT6CAAox1bSN22x8htQtwBP8KMW0+9dyS7rT4wwgFXp+cwP7CoAr6+1OdVkGq/6nr1jsf1P63Str2u9fsFx0TRpfG4LMaeltrC4T6agGGMsw2IRjM+M+mJMnHDIufHKox9H74b++SIS9i4Hflbr12Ux84K9o//sk+PPl/0u148+E2aPS359R4e2tJWhenPkwzF8/L9bU8tYeuMpE6BdFi0JHkrT98YzAcDi9kEC2VRTWO6FjQcUk7DTrk1X2Xlgvwg46Q5iACAT8BXFHDhil3Nj7iFLdTjtnx8QMN37sedhW+RZgkr2Y3JTUxx5+z/izte+W0zX1iItdu+AH64Uh661Wl4nzMZ3S9dKN6D8D5EREz6Ln79wUqevM8s/esTDNz+Qp55MTJORY5VuTmlXlH/RqHoxWAAio5q2XygnFpakPS6xH1jNdOSYVAnnpKYMsMReqsVJ92W8MQHjxo6N+kl/jWzMb9rciBwLmKehG2aOuqGXRV2PBXK2CTjDzHz80vwx0wydd4Z1Q6+Lul7LtDo7rBsnxyBLdw0ZXB9LLtorhgyqjyx6xgwzLRoDhiwfyyyzbJ4OlW5JtXMANlBpj0/pMwtVGHP9iwVi6NXzAWGifK+RX34Ut1zWP0+z11JLmWV1Udf7h/HXW1eNPfbYO3eaWIN03FwSY6A4HUt54WNvxr9eeTdfRNQR6de7Z/zz2N3ji88+zceCQyr96ZmKKX41kW0BzrRFEAeGEbJNiYBD2YS+awvw0OvEXtNbnwWeOCKMIPbGIoMicPCeWkEAzPetALX4q3QRULF+E6PH6fqOQKFSm7BDNhbnWNX8po2mjT0HJmhRm0kHtLkr2V0gGlg1BhbGSMUn0JGzbIcemv8OmGC6yp2O0lkxflLpbEM5AY6wXxg1bdReeykC2OaI2kSgtM+KG8ag+ZeoeDJOe9JgO4KRH0e8eG/OBiufwIr6CbgmdpQtLIJMemlxEpD11wuui4tPvDcmjJvUJjhMi0oGzDsubnv00this63ig0frY3Bvadbq55mFK40NY2OlrWaMSy+7JA+QzGllSAC44Iq+qFcW1NDLol6zXWyRPqbfxTR9W0JnpYKLIJOdUoZgrggMigcOaJPgyEIggZ/Ud5rLPep6x7E7XBENJSeR1SR1EVmPCXHPW+fn5If5KStQDJLMy8NvvTvufP3NmlfUj7rv7jh+801q2gGhW6qTbkD5HyQnvHJuvDb6nQ6xlM6MHfPmV7FdrJezDtgXoAu48ZJq4hDV1yTmCivDKBD/ZpxEn7bBAJQYWYConPM0oTkFRk36gAEGxIBS4FIE63tSWAwTR5NSwqccPWsc8/Na0n12eu/bshF5jwVa64nqx58Th+03pKbzr6fqs+Yshn/SHLscOmsMHjxd/gxFZ5Nq7tRGYV2wo6UF74w4YwxEYW99DsOZ6sYYXv1cFOwqtkR/pdcC8w2JDVe5Nvr1+jTq6tq3kPDa0y9MjunmuSH+fOHfcgdiDIEnjrEoasPU0mETfnvx36L3Kpt1qL9E+TuusWwcsdm0tVNF8dwWKZQDm37qq+LCIXqHdaaL+gaLrc8BjXILDDAuABtAJmjxb+lneqcO0MIAZQVqdYGstA8d5hCL44XV8xlOmo6XE2DWmKubxMb4Xrk6yVKhP1bbekm1+q4gC3vJQdMJ89Mzan8tG1G3J5hB4KPIVpp3nDKm1LzFWAKV34dgtASNnrUo7qsmD+umDwUNWEnMqr8BP9qHYWY3Vv/pNvHVPJ1bhbv3ivPEz3fcIk/1F8sl6B7AC2AmkOmn8W5dTNd71lh+pi3zhY611AF+OP7ZeO2zh+LoI46LL57vHx9/8GV1TF1dxPSzDIiPezweDzx8b25D2FCMpzEViHhPcChwYmfpkWCqON9TyYEaSragM1JcpGPRloAvAU7z2Fj5jOxB2rtzSO/Z8sU4XSHn3LlXXHrZpbkOyxCY44AlHbv19bfjuLsrEx/tyU/qJsfvjj6yS9rZLd9JN6D8D5Jnvnopznjjgg5//+lj/xnDH3g3X8VmJWzxhAjMI+eaAKa91BhWzhy4wSKlDXrTmbSE0SqmitKruCoVG+V7wCUjY/LbziSBS78DgRz3D5cbHddePGsHnq4hon7GqJvhrnjwoWfylamTJ7wXbz85Tw3H2k0tjh488uQv45wLW4CuZ8LkAd9ADVDEYGOUROj6FMvEeCZ2Ufq+yMaRxEZiCzkDACOdepL2PlMXlRijJFnzmHj58a1ikXnf+/aow6mfSyQubZM110dz7y1j1Q1uj/ffH5EDJWycNA6gxJEUa5sAiATKVlt99fjBzgfHPa+1OM9qxVnJvZomxT9POyimH9z+no9tCV2gaxwTB4mR8rtAh3MC7IuMiCAI+4EZAY6UVPh70jFjUgSFgHNaXQ1I0UcAC9tM5zklY1FpcY/2OQoVa0kn/C5VXI3oe+3BTPq+WszEQmKCLI4BhtUFY5II5+/6avj83hVnDJvrAkt9RT9d14IjTCsAhUXtyBnK7YlA1D5/+iwJEA2Ysw/mAYAtbSvoYqO0T9ApsNIPgiPB6vF3/zs++vLrmo4ITXW+PZsnx5azYJevyplu4LUSq5yCYwEKVvnjDz+L1efYI3rUW6hX+1i8N+nB6DPDlPjn3ffFn0+8LZ6877V88pa7FlZSu76c8H5cevcpsdQyi+eLIgUFNgPXlwIkdY3ayRYrPzJP2CjpefPePEgiUBHADHv3o3jynjfjwdteyFP3jY1NMWBQ31jqB/NXve9jpUU6bJp7s5cCNoG0gODVpz+MT56pfNJQLXLNsyfF4KH987lOP7DYynek5Of6+S9jXI+eHVrCypbN1dwY9x9/VJe0s1u+k25A+R8ml71/Q9zxyb9q/t66M64ar/7xyTjvj+flYAbQsYoSS6KOq9yRWgxWAphYrOTEOR9Rronrc1g7ToiT5BQJ45/AZQKbHLz7ADBYS1EtYMrgAJYMwt1/7xHzzNHYIRAIUB12wjfxh4u/22/xtitmi/XX7FczS8lHNTc3xN1PHxWTpvTNa5O8GEmAglMvBYrEM3p2C5CKDKM+l2rFkFlAQrCzwCVAwyEompcaxxbqb4CztF4PMGqc/HHces1OsdBc/46B/b4r7h/2UWOc95dRsc/P74pFFlsldywciWAAcMCUprHzN8IJABGAmPpAaUZGeOXdD4/JQ8szc+XSh0N694hnLjw5Vl1h2XxcO3sOLr3SFvWLUvRAZdrGQ79L92k3dpB+cfiJqeFYiwyntqQ0uhIPQYBrAewYwHQOMhbM4oa2WEa6jrk0N4Ag6dJqNk3XNqu41UoCVViVtPddJbHAh76ktLRARQmJ8QMuzdty55ZXIxg3NaFKX/SnRUIANl3xO0ACdFZzvGW1Ylz0FWY5nb7lHlZLmwvq/gQQwDT2zZxRFmKRCOAt/e2VWMO3PxkZO//+mpg4eUr1wCHf7zBiwBsPx0uPPdAaGOtXtYDFLYywlICKl4BGcA3QzjVg+Xjm7g/yRY41S13EjHMMiJueOyvXQX3/+EPPxsG7nhivPDoixo357hCG/gP7xNtfPB3Dx74UA4f2yctkMPJpmy/6AVgCw0Bi8ZxutZ6AJGAOCOtvqXFZimuuvCFOP+zSmH3gonmdZ+memClFP/dCM8X6Oy0TM83bEqgB/sWf6Xf3NSZ0h130XvEgg6IM7TNnrDTrNtEVstimEYsstnBuI73oizH79aWXx2ODOndsYl2WxWMH7xszDOg+z7srpRtQ/oeJiPUv710X//js4Xyj8ra2EWo5aaAu1p1p1dh7/u3zk3I4ewwJJyuyZQiktxgbQKaSSBtiLYAeTkyql9HgcETJ6mREqlKT6iiT0ffC1BFMAMBVBJjSJIxkvknwkhGP3Fb+9IlqVzS/+e7kWPJHH+ZMH6Zp/nkHxGqLnRt9ek+IHlWWWzGwbOx2+3waN945Nn8PiwQkcm4MOFCZVmXbh46h9syAWznhJDEvxRMYGGK/A5Wid4bfNi0K54EcTs5ikQQo0tm0HBFQjmV75ZV/xxOP/yv++tfrY/c99srBADDqen7HRhsDDKSxB6aAlMRwuI72S/tx5sCvlZgAz0wrrhOz/XCDaKpraC1aL4r3xCEbLLtwHL3FWvHcU0/kDpczdj3MYUcEQyf1CQADEmrCirWEQJ2+0kaf4egxW2rvpOCIVFtpOh0rg8EwdqXbNAGbgGtpHacXZhRATRuUq6XEcgIg1Qh23pzTDn3Lubd1HnRR6Ajg6POCP0EGEE3XOG9pa+laAFNg1h576dmBdKlkTpie0eNUW4ltdy1zml0Apqrdz7M9EQQA6/TQ6vF0RrYxcz9BA/tBZ+mmuSbIsRen8Qf+fF/JDaBE7n36xTj0r3dFfc9eka+IaUMAySmTJsWKvb6Oy885I9cBAMTqceCIPZJ9KB67J8Bjr3yGjs0662yxy6qnxFefT3vUYS3yzOfXxshxts2py+e82tDFF1s8+vUZGOPHTox+A/pE/0F98udXvqPeVdaidDEfW2VOK83wLOyq8fQ7XTAfAT36ys5sttG28crdY2LiuKaKG4l/d+2WOfLql/fF8LEv57+zc1h5c9vP9LtAW3CC8U9ne6e/a7+9XbGUr7/4Xkx8vfYTb6aRuuZ4K7s1hn0wrHUu0x063Xvt9WPkkBki68xisiyLo9ddM3ZfadqN67ul49INKP8DhRF56Iun4+YR/4zhEz7JgWJT4XzYhqjPN0AfPWxU/GSmteLn6+w9FQMJ9AA3nBJHwuEBOowmh9nWkVMcARYSuJG+Swyma6j7wmzY8gfA9AJqAE/XTwAzvVJdDeMj+v75bsNju80GdrjmMcmev+gbt971UetegEst1j/uvnqWmGFoXbvXZpv0789/NSoWX+HEHCQDksBd6kPAG6MCtAEV0rMMOKeH9WLwMQZFSTVpWM4kgJ0+1BfAL9ZQX1htC0SoCcJoYc08C8Aj+gfCgSjXBHaAK86CUXcNDJY2GifgknM2bq7rer6XHDYWQ99z4lgNgAuA8KzAzGxzzBH3vvhOXPPov+Otj7+ICZMbo2ePhphpUP/Y4gdLxhY/WDymH/hdFO9+AIl0KQYlnRNejQCHWEd7iALA0qLaRYAdrLZnpbcclTQb8AlQla4mLQekPLf+9js9xYobPwxxaR2n8U2iPzhn/Qlc6EvtSqBTarzcimXzASCWSk/nFpfqRTWiTcbG9TB20prS/vrX8wvIEtgqspeluzVIoXP4xh6oBebSYjFzFFCzaticlQ7H2AIq5c5oJpljYCc/FtE4LCIbF1HXP6LHXBG9Vou6MosupPPZBm1mZ9gMQEqg6nmAATqHaVIOgAkubgSPTTe39EfO1Dc25rsTDPt8VKy7/1Hx9Hvqi+vybWBKAx+B948Wmy9mGvNRHHfYQfk2UK6vT60mx4Zjr/WDcRUUpYUlAshkSxaeY4WYt2fbNcLtiSB/fI8R8fBb1+S2RrCQGHXPbnzNSe2g55hwY+uZgTaBpM8XWUL6KpBv6wQeq9BXmW2n6N3Qr+ZU/X4nbRzrbrly3kflSgOKJ+mwAfoLiEz+QTt9b9UfrhpDx6wYk0ZHx4/NbKiPDbZdOQ46dcs8a8afsX3p9cSgGWPy9J1lKJtj15WWj2PW/X5qif9bpRtQ/gcL4/HmmPfi3s8ejeETPo0JjROjb48+MVufmePHM68a+268ez7hGOxSI+B9zI/aOrU2jAEGJq2Slp4rtxhAugqTgKEsXpNBYXiTEcGsMXRAFnCTAKbfOXNtV+SeCt4BmT+e+HYsNH/lTXWrXUjz8199EX++/LvNfAGn5ZaZI47YP4v/x95dQNlVXX0APzNRiAEJBEKA4O4S3N2LQ3F3KFAoFEqxFgoFSmmLtriW4lagRYq7u4bgBIkQm7nf+p3hDDeP5zMBPnh7rbcmmXnvvnuP7P3f/y1nmcW+iLyuwpZJx+TravKu84cxzXuFZVc+JN5/Al55AUKMKaXuef0fu8EwMECUKdaF8RNyNlaYA2CPASWAjSR6LBvjzcvmwQuHu57rMvr+b1wZdob4wH1WCSefuE804AcceESYf6F1w7wLbRVWWmnlCDIZZkCVsabY09F75gxAYLAA0hSeAnZU+Po+v7MmMArAliKTYuNbKR3BfCZAo0CgUqPxlJMIfDFY8hl9P6CX2vx4Hn/DuPib9WptYXA03ZbCUaohM4MDfKa+eMYSuC4XqgbQMKGAD/acQTeH1oQ9gm1rXzldukSnI89uCtkrmGBIi/V/rFWsIc8MTGEo89EE+WpCx9aHv3HezC3wlvpeWsfm1vxjuUqxq97HyfSMOhK4HiAnPJ4kax0RwpirQjbmkhBajUPz16+2dl6heUBomnLbEKbYPDR1+cawK4JyHeNOB2DD5WpbH/aN9QdIYuyKHcsqZQT7Rr8QLCW2lZOGXT/mxJNDv/mWCjMsNDRMNe30cQym6jVFWGWB2cNmyywYpp+6T9Q72GLPBDjbW3ShiA1nTtEKh7rw+ELjgb285ZJHw3vPTIzRoY7IF+M+DK0zvRqjNxwp6wuYBXCLpdLkxbrnXIow2WOJDbROk74VIbDP9Uq1/l17qRk3C1N3n6mtnVEt0iS61DVc8uBRoe/U3w4B04PG0VrhsBpPz2AOE7lgvq0/DvrwF8aEeaZatUPtqGZbNYsV78bLXs3/HL/mBqHLwHry8HPS2hq2WGyhcPy6HW9C35BvpAEo/x+L5G1GQX5eqXOAUwgcGKHw5aJhLni8ClsY+XxOWQq7UoSMaDmQAFgkDxVgcU2giyLHvlE0Ql1CFYzvagv/JgyctoOntLQ2hX/fP1c466I2toxSpXQZVWOw9ppLhH7d7wxjPrs6jB75dujSJQtjx3UPAwdvGLr02S40dVsgXgcwowyNC3CcBx9COpLRKUmAIYWBhJGBQspcKNFPYpy8D4BOOWkAl+8AqPMNrpNxxUqahxjGbBoTVl56ZNhv16nCPHO0gSZtfQDjeK8fdA8nnTE8zDBkj/DFyJYYGsuf0ey7gSg5qgQLxfCkVjeMDvBkbhls7DUmpFjj7moFY4tlZNSBysJWRUkYIuwsgO0ngGi9AJGYtwQkgEgMemFOn/HDGhZb40LcwqrWFgOHyQTqq2kYbvysf6AWIDSvhc3OzWdhWB1rDdDlG8jnm0WnMHoefGKequnFaR49oz0qzFnq+Dx7E3vJwGM0071wLuxn1yh3lGNiK60j6x+ItgewrNm4h0L2+Z4hZNI9ygEfoKVHaJr6L6Gpx/LR0Nvv5hsTCeR4ZuFlwAiQNP+lxoHDYG9wHjB0wJPnwC76HKbec9o3HONCxtheM2ZC+ACo9eA99oWQujY4dGW5E1LslTN/e3X49xWPd+zoRClErSPDF9M8GnWTNQwMSfOwJlKomK6kv4B8Dpe5sD/TfNJJ+Rx1DLB5N1ZAHkbc2vX/BeZeNEw/ZsW6QRxWdefD1gub7bZydGDoVvvaXuVcWzN0ivVsD1hrHBP36/8AfyoyGzLLbGHOpvVCc+haM0sp5eur7NPwUc+Hoy6wl9PP9O9Hpx4YPmjuYOFPa2vYddklw6Grrtix6zRkEmkAyv/HAqDItxNa5l2XUiaUKRABJAEbFAHmClOFecSuYMt4wqn9D/BRbWUrocCBlDzAxPIw0pLgKc9LTn8/zDy4Y/lazt4+/vTx4Y7/DYqGmpIDCoRCKLZ06gZjJIwIVDEwQrNYsBRiJe4X4MU2Ms6JAXNdFd4Mj3GQr8coCtWqSk3iexU6MFqen/HAWGJAMGQqRjFneVEVycPH3GAuV19p2rDm0GvC1P3aFG8xdrD9VJ4JPcNqm7wWttnhpAiAzL/cTc/ICAEJmBkGzN8UPphzxlxY07NgJRkMAKKjAnAZY8YSOMynUvidPD7rzO/lPwIbDDojZBxSm59KYfPUZQAITfOGWQQezYv1D1wDFJUMKgNuvXOu3LsG5dVWO3MggBvfl4rdUsPoQuBpH+WZKE5buV6cCQSbR2Mi91VVdOH6SWJ+PYN1BjgJ9wuJGht7AFOUzhw3dsXGBZCxBjkHGLxXn78gTNf9yOjOlAeTSVyzKbz+6cFh3Y3/0J5fnAra5GInIFmpMT0W3T4CjowvR8s+pq8Aa+NszF0viT3PYQYigR46BmgUkbG+6AAsGnaXCJ9bl5warKE9nn/57ln7LhVmn2rp0NzUMT01cvzH4f7hF006Wk1NETRjaq1bL2vfT8wfUG6NpXEQCveM9rO5TQWRrqHgMvUP5izeevHjYfpuC9QdZpYyML51dLj//X+0t02rJNadufZ+utN9YdqN+YKzLRN6fqLgsKlqkEv3TdmnZ/jTdQeEQbMMKPm+P/zn3vCPh58ILR04oIGctMFa4WcL1u9UN+Tb0gCU/88FeEvJ9ZjFUmLTU1QUNyMlt47SxwAAGRQ+ZS1sytD5qcCgQ+H6l19uB5iM/c2XThOWX2qKDp9uc/W/lwu3/uebM20xNknZEobF/91DYgMYeopNuBUYS0rOvQEGQtVYR58xFkAf1oBSZ6zSaR6pp2ESoWYNcgEqL4AOmAB0sUXSC/KpBcKajDdgeu5f9wi3XDZ9QIxVc274xIkUaHPoOu3F4Z33p4uMByCs6AZQdv/YJs9rbt2v3ENg0v+lP3j2whBnR4QBwTAm1gw4Z+SBXECc0bMOgAQAF4gEukv1fiwmwCMwgTEBMAB1Tg9gaB1jawD0ciHuBMAURPm3dWBuqjF2nsPnMKHmDwitdP+pF2exPpypF2d+zQJfCWB6Ng4ZZ0AKiu/OF0ABxdhV4wyoa7OT8il9R2IvgVIMIfY0hcaBs/y1ME+cydtvOTc8edfMYcop5NdWb6jZ9HHjWsPyG34Unny2rZAF0wa02TvVnHBErBtjKo8WGOSMcniBUXvR+jYeXglEAs8YT061MLBiKixvAojAWEoHyp8Ek+4RACp8fTmsOdx16UuhI4Jl++SrN8JiG0wb17rvdt8cPnNLX3s+e4dTan0VHtuaBDijS+g015Fuk06AssZSTuXKM+0eenbteMX+e13vD0PmnS46cSIY1kqeIfTimFuTIi2cMSwp/QlgclI4AiJULz36flhk4HoR5FaqmJc32btvz3DChbuHORYoX9Tz1ojPwppnXdCxB50wPjxzxMGhZ7fOOa2qIW3SAJQ/AmEkGBmhskpVoIAdVoJCxfDI8+OtS1oHPjApAAlFgU3qLKFEN1qrJey/o9zM+q8zbnzX0DrNvaFX7288WIo2nfSQD00aD+wskJUXY8RApcILyhzYkBNJMaaQmBCOUC4jBwh5X94Yp2P9hH+AHMLQAezYL8wIgy4U6NqYJ+wwFuraf/45jP9g3TBFz6wmgJ2F5jB+Qpew+OrDwmdf9oogDQPrmRQhAFkAKwPL8GAi3Q+AYp0AmYxtsRy2eoWRA2qlQDDqGBXfDQgYP2PnVW+I3ZrFOhHrElgBBo2lUDjQUO7a1gNwI8zNwHOgsETViHnlXHHIOGPlTsmpRYqt2fxPjFxhL06A07gaX/PtmYyrNWw/F8ujFooELj27ghhGHyuf2EvAIRZoPbJ1mG3QYzWd1JTEefcXX/1l2P2QjyMLiAmvpa0U9k0xk7G2TuUVm1v6iH4yv/YZEG4PAlfGw/7z/zxY9DcAOgFEoMv9WJ+As/6jKSew2Dxq67PN0GPC+LHftKWqR57++Mbw/qi2IwHTaWW+N19hXkrcF5aZw0EXY/8SKAY+zaFnzzskaw75RcWq7mrk13/ZPiy/zqQHIxDfJRqSTh2SLkSP0SXSWfKnLkldsS/NxQG7Hx4mvDdNePmpYW2Edla80nzZNRcMexy1URg4+JuTf8rJjpddEx5+e1hdLKWWQdnzT4dXLruw5s82pLw0AOWPQHiMvEIFDkBLJcmHwIVaEmMHQPGihdooNCFG1+uMRsvYh5123Cocvc8dbRWjdUhra1M48+9fhD+e3S0yVY58rMa4Y+fkmwpPA9FJEWO0KHvsWbG+aphLRtx48bwZ5dRmxvgwfsAi5kyojcIH8ISxsEMULjYFc+j/QBzAzss/9dj+YcUlh9dnwCdm4YrrQ9hx39fid6VTfPI9C7GClL77wajJa3PPQqSAUWcKIOkeUjEFMCFvTf9BgKBeAGbMOTrG3dgJ76XQJrYVC5ovhCoU8wGcAKAYPGxyqfy5QsEeYYCBHMw/ttq8f1dizQp7KkzBKGN8/B/rZv14tvya9bti4fT0E4AGVo2lV1qf8n9/tvEa4ZRfPRy6dqkfRE1saQ4D5381nHb6+dFhLSfuHUOXmER5k4r2RAHsKQCqWNgVKDMH1rL7LsYw2tOeK1/IYf+Ze7mZGFMOhTUDeHpPYeFHjy9mDX1bnBBWu96LLcm6jA9htlfCq6+9GnUH8AvcS/VIFd/mU247hyvlBlpviobMDX0uGuL39HvK7xXGNzbeZ/4xnB99+FE4covLQ2fIL0/dOqy68eLt/3fPCgvZCc/CERHJwiLnT9LhuBhbzp/oCyDsmSORsNFG4eB9jwiH73VKePi/z4XRX44N/ftPE9sm3fvkjWHYyGfCK2+8UFPU4sG33gk7XNbmxNciNFFzloWRF58X3n3phZo/35Dy0gCUPxIRiuPBM+7VVJvmQ+AMpgTvFDZTWcmTJ5SakGmx5ujViu8CCBSN7LzliBBG/73KHK1vpM0RbQpPvnNCOP73l0TWQagr5ehVK5QwpUxpk6TgUz6mfDLPSTl6ZmyRHKU8W4QhELrCNlC4wj+YM8beWGEFC6tshcGxoDz8CeO/CO89M1vo3at+oD7mqyxcedf+YZuf71qy0IFxxpRyHoASosIWwOyoYNAwt9qzpGR8LBODLp+XMwLw1yOAKSBpjjCPiqGE14ArQE+o09wDsRyLYuI9GFuFDAy1kHk1DcpTaBxYtY+Ek6t1XCaXmDPjbK0CtsA6KdYOKR9WT029iTVijSeACZABXvIe5xr8eDj64Ka6T5xK58ofdPRHYb3NrozfUZifmH+Zy8IQNP1gL6Wm3gTQco8iAPYiPVJY8VsIBvMN74tJapnlBcxZE4WFH92y3uHVO9rK4mofhyx8nD0XTv77YZGtBWQ5cRhSvSZFEwBo6zjtGbpb2giHkAMm/xWITEQBHecaRCEfQGzu82ty4/kPD+O+6hirSn577s5h6GrzRSfbvUsNEf2yB+w/DmpedFbguIqCcCQ8JwDJiZM7nxxBjoBCK/vKvlbYRuSCiiQpAlLMWYvsdcZfw12jvtHLlaRteTeFNZsmhItOPKFkmkFD6pcGoPyRSDqvGbuYP4arkvAohZd4lNgem5onKnQpvxJwo9iqaY5eSoA0rAImb9VVlwvZpz8PYSLvcFKjUkn2/OWH4dxLvowGSx83oReKVQ6jfM9qG21jf4CU1H8PIKX8VMxigZIBxm4JCworAtuUeTLaQCbjzkgDm+lz+eT7VHCRL75wzen73RP+9oeBHQr9x2zKvseGpinLzzVghykkkv+NV+HZxtVKvs0PRoJxBgzMhfxCDBODbj1Zh0AQFqaq5/n6jGlAEhDWJ9AcMVQYcuFhIAhTwuFJ66mwgbi5MK8AJMAgbCrEW40A/XITjY/cRIbbmH1fAkwx4gCF5+WwuC9Me6XG6SkcXAxspp+p9+LZp0wXdtiib+jWrf4FKb/3iutGhh32awNKSdwnR40TlgCQCIF5qrb4AwtPPxWr+K32d1hPrKQxxG7b03Qf8FMoUgT23OqIMP+A4lX2pUT49ouJw0PL9G+GRx97NDoyHEjr2XcDVkAV4CiiAUhh/KTGpDQUY8Tp5VRhAaVb2Fv0DSc25UxL6aGjkxy69V/D84++2V7AV2+l96nX7Rkuuuz8qNvcB5CIXLDHS4m9bl0a45Ty4N8+q4UVSV0a5G7bZ6lfr/Z1dHetdosgQt7t1TeMnF+njKay4W9/79G1S/jrZhuGp265KZIAlZyPhtQuDUD5IxLhPGxRqvSsVhgXLBYFx2ADaJSeFh0KSygxHif2kwKWhC33qloB1Hjg2BBMXtb6WchG7BbCxOcqMpWYD0UCZ17QO6yz6ZXRs02FPkL2hBJmtCgkvdAo7moYJawdtgdgScpQKCmdkJOuwSgC0gAGoOP3gA9jwRAwdikEi/1zvWS4k/H2vlT1e96p04VtN+9bV7j7G+kSwhQbheZ+J1Z8p/tyf9gO98qAmetqQkxYHwYitfnxDOae02EcgDeFE/n15j2MKSYGw0F5lwM+QrDGE5sohKY6nPEpnENODUYE2JcDp+diXjwXVpIDIyxnzVaTK+oeAE85dsL17ruWDgeTy0GUr4kJts7sSeF3zgG2DrCvphVROcFCxSMHuxwbBk799NcMTn1iDG++Y3T4+T4jI4jD/KVTVvIgL/WnlZJBV+UbdafzxoXnRQiwdRixdIxoRwXTxmF2b15YzcJcSiDK+gbW9tzy1+G8390UmdtqgNpHY94IT390Y5iiV8/IKltH1igHwPPTz4A1fYqx44DRLQlQKqZSZJaOWAQgE0DDWnJ00mlEhake993ydPjdvm1RiPokC1NM2xJufebseI8cK/nYhT16iwm7YFw5CZ4NSCacQI618RUe55RjY42Fjhl5skE6Qmp7Vo3Q0WyUorWNdtw5XPLYU+HaZ18I46QztbS0ObutLaGpS9fQr2ePsNViC4VtFls4zNC3T5wPTq/7LdXbtiF1StaQH4089thjtF528cUX1/zZcePGZQcddFD8/MYbb5ytsMIK2c9+9rP2v7e0tGSXXnppNttss2VNTU3Z9ttvn7355ptVXftvf/tb1qVLl2zChAntv2tt/Spr+fKUrOWDxbOW9+fMWt6f++ufba+xw+Zo+/fHm2YvPHVWNs0002TzzTdf9s4777RfY8SIEdkNN9yQ7b777vHvXxN3Wf/+/bMtttgi+8tf/pI999xzWWtra8l7u/fee+Nn+/TpEz875ZRTZtNNN13Ws2fPbKaZZspOPfXU+Hv/93Pw4MHx+3zHTjvtFK8xevTobIYZZsi23Xbbkt8zduzYbMUVV8y6d++eXXvB4Gzie988a32vubKWEXtXNf4HHHBAvPfm5ubsuuuuy2aZZZZs6NChcc5L3av3GcMpppgifnb55ZfPfvOb38R14f9bbrll9t5775X8TmN+2GGHxfcec8wx35oD//cdiy++eHzPMsssk91yyy1l52q11VaL773++usn+f2XX36Z7bvvvnFdLrXUUtkzzzyTVStvvPFG+3V32WWX7LPPPsu+TzEnv/71r+NcLbnkktmLL744yd9vu+22uEatpc8//7xTvrPls0Oylvfn6dB6nDB8zuyWy+cqev1XXnklO+mkk+KaM85du3bN1lxzzex3v/tdfE6/22qrrSaZ+9tvvz3+3v7sTHn22Wez3r17Z8stt1y8vjWYF2u8W7du2UsvvRT//9g9L2WHbHFmtvasB2frzvHL+DO91p3jkPhz22WOza4+57/Z2WefE69pHfbo0SP7+9//Hr/H/w888MA4DgsttFDWt2/f7I477ojf0a9fv2yttdZq141fffVV1BE+b03PPffc7XptnnnmyY477rhs+umnzw4++OBJ7nvC+InZVkscPcn91fqapufM2UorrZR9+umnVY+nZxo4cGC2yCKLxM8OGDAge+utt+Lfvvjii/js5ni33XaLv7Pf99hjj0muYT0ssMACNc3jrbfeGsfk+eefb//d8I8/yfotuXTWf/V1sv0uviKbZrW1s62POCobl7M75Kqrroqf/b73+o9RGoDyRyYbbbRRNsccc0wC3moRCnaqqaaKSo/iKmbwADV/o3j322+/7IMPPih7zUMPPTSbddZZi/6ttXVs1jrmuqzl0x2ylo/WzFo+XDH78q2Vs7NPmS574Zl/tr+PYQWEADogsZjcdNNN8T2UBSUHxPo3JbfJJptkf/rTn7KnnnoqguO8vPbaa9mQIUPaFTeFDkwOGjQom3/++ePvGLg777wzgjPXTiBzgw02iMDbd73++uslx+Doo4+OynXvvffOLj970LcAdO2vubOWzw7MKsmYMWOyqaeeOj7TnHPOGQ3YFVdcEedu//33b3/fxIkTs7vuuiuCKvPv+RZeeOHsxBNPjIbP/bsGhwKoqVaABtfirAAMxp5CZ1j9HjAyruWAJLn88svbQfEZZ5zR/vubb745zhWQdfrpp8fnqEbch+v4nDVjfr9vAYQZZgYWcCi1h++///44j4sttlj20Ucfdfh7W778Q4cB5bh358yuvXipeD1z+eSTT2ZHHXVUBArJUbMHL7nkkmjIH3roofZ1BnQVzr99Zf1VWhf1yI033hj34swzzxzHO30HcGSNA/SF8tbL72eH7XhatvSgrbN1590v22/D07IT9rkwe/g/L2QTJ36jT+gYz0QfeF122WXZH//4x6gr7L9///vfEUCaY4DT/72PXkmyww47xGtcdNFF7U7PggsuGK+RHF+f33rrrbMLLrgge//999ue6+L76wKSaw75RTZ0hq3bwb21VQ0pwbk3hoCudfjJJ59EPbroootGJ/uvf/1rHOekW5N+LhxftsS4l3Jwiwk9yqbk18f//ve/+D0cBvvbv9dbb71vfZbO8Ld333236u9rSHXSAJQ/MqHIbZZ//OMfdV8D8wiUug7DVkypjxo1Kvv9738fjUKvXr2yI488siRjstlmm2Wrrrpq1d/PS6c8sYN5GT58eAQivvO+++4r+llGmFIHiDGPFPURRxwRmTVKyzP5PIN1yimnZI8++mj8jPckhUoh+bnrrru2M3Svvvpq+3d4FoboD3/4Q7bsssu2A1EGHvByzTxoTQrMWJ533nnZH48ZkE3soAFveX/erOWL4yuOJaPku41FMvAU/AknnBB/D/BhTzCs/g8wUvgJtAOZDCEA6vcAaq1y5plnxmuvvPLKkWX279VXXz275557qvq8ewFIfv7zn0cDgc1kwLbZZpt4LWxXtWw5AZATQ7XPPvtEhvP7FCAYcLc+OTCPP/54xc9wjDg2GKw8a1+PtI5/qYNrse31y1+sGx2HBCDsM5GMa6+9NgKM+F2trdnZZ58dnxWQ8pMuyQvHDBA599xzs8kl9m7at+7PfQF67j3da17sAzppww03zMaPH1+VE2XP+AlYcYgxtHSMMRLd8Dd6M+2Ps846K37+5Zdfjv+fa665srFfjc8+GPZp9tA9T2b9+06f7b7bHjFCYtzom/QMwPfKK62czTPNKjWByXVmOzjbcaUTsnv/e3/cW4lh9dNYPPjgg0Wf8cMPP4xrD0AcNmzYJOuSzrRX6Wrr2f+NrfVqH5922mmTXCvtxWodVXMFyCIz8vLnP/85jq/vJOYr/Tsvd999d/w+49yQzpUGoPwRCiaA91ZJ8VUKDSVlRYkKLxcTv//Vr34VlQbQcvLJJ38LdAhzAGe1CPCBbS0UoNXfKAuGoJRgTZPSpngfeOCBeF///e9/s9/+9rfZKqus0h7G5vV7TTvttO2g098YPOFv/8caUGQMg/9jWggg6r2MAsYgsS68bmwfI8HjX3/99SPIxLQtuUiPTjHgreOeqjiOlLWQLrbVc7/99tuRsfV/jkBKEcBWYo2S88BgCOEnFjEfWqpFrEEsSmJ1AddqgWSab4YVQwN4GPcEVqw3gLlaFovjALgJJ3KYarmPySUclRQW/eUvfxmdqWoFo8agY2g7ahzHDN8oGz+8/nD3I7fN1L7u99prr8i8Feofz7bzzjvH9yWHtTB0Sw455JDIqhcDdp0l1ow9bdytrxQGxV4WCucVEAKKpINUI4BiPlXm2GOPjeMh9E/HzDvvvNGZ8Tfga88994ysI+BKFpl36Wz+AWtk6881aZh99Vn2y/b42dFZr25TR11kn2ITExPsNd90K7eDxXKspJ/7b3R69tknI9vvm56kG9O1vJZeeulJQCOGmUNtT+cd7cJoghd74Kf1kNKSEvOaZMcdd4x7sjAUXo7JT1GjvNC3iITESlqLdFuhcPh9/oknnqjq+xpSvTQA5Y9Q0obriIcP/ABZGAbKneECOEoJ9jApxRlnnDE755xz2kN2Po8Rq0UwfT5XGJ4mlPrmm28evdHk1ZcSHnbK02NA8uF51xEmYdTynnliKrF1CXQlNgHjCXj6rGsxNAB1EkaDB8woMlTpuhg5qQLnn39+/N0Xb66SjX93jvrD3R9vUBFIYfZ8F2NpTgBL4aj0PICI3wNryXgbbwwSwEYZC8vVE3YUvrIGODa+i3OAFWJMKfxqmE7fK58XIGe45GalfEeMDGNay56wDsytuZmcYKUa8WyYK+vHOqs3V1DYDjixJusxkPaokOzPN+vfIedmu837RPBQbL8SjswSSywRAVZy9LzyQIWYF/veHE1usYdTSos1VsyBffjhh6Me5MTWumZSTnqKeHDajI99aS1yWK1ve0IERQ7idNMMyvZe/+SvQd+BRcHgWrO2gcFd1jom++KzUTHX0vXtL2sAQ7ryMmtn80+7RrbGLPu3fWbIQdlaX4PIeO15ds+WXXDtbML44mkVHG85vHlgKW/6448/jg6QOSqXq5zGVY6756Sn6T+/k1udl8MPPzyOMQBYav3kxfPRy4XgHnHgvjg06f9Y4kLhHLuPUlGuhtQvDUD5IxUFFcICteSlFApmynUYcuEaYJHxKQcwGP4UihQqFXr3b7lEtch//vOf+DkhlFJhwqRIgc9y9+S9QBIPmQcr5JJnTxjCxCQAjWussUZ81rwyTS8KKhk7IReGqBh7636S5+39wuT5a/72sIWyie/VCyjnzFpHf5NfWkqwwhS1gpqUdwWI/+tf/8quueaaCK6wkNhlRp6BSCF898541CpYKIYDWAWkpTvk5xBTAUQxnpL2y4mUihSSlB/JiLgu4yucVo1Y/5hZ88bIAQjftwBRwvSeDSszcuQ3DFE9Yp4Yf2u7FmCqiI/RNU/77bdvNvajg9qKvWpYhxPfmyt7/+WfZ9pHvvDCC0W/R44sVlwIVf6uvYYhL5YGwwl2P+XykTtTOIUp17owN1v6EMfKnqh3jsyvawM6iY2ke7ykwFiXs88+e9Qj88y+ULb6rHu3A8aKr9kOytab74CsR5cpo/OWxL1KFxIN6NLUPZu+19zZPAOXzYb0XTybqe+Ckd10H+7H3JQSOkwYmsOS14H0SKlQeGIwzbHnGjhgUDZ0znWzjZfcL9tr/ZOyxQduki06w/rZLVff1w4e5TKn9AAMaSUxH/mCUWI8AXO6jN4gdJ1rFjqv7FktIfaGVC8NQPkjFV4YxazCul6RW0cpJMOcmDwh8EqVgEBEysnxAghqYbooAQpCPmQpcb0EOlQRVipEkjTOe015NkArEdLBnrgOptU1gc9HHnmkPc8r5f4lBtP7/QTEihkbANZ7L7zwwknCt8cff/zXSrk5u+bvM9TMUk54T3X3Xllra/HiE/ciLLz22mu3s6P+zbgIseUl5W5hHvz0rIwHhrVWwd4A6oCCceFUlAqTY4WBHyDInBQTVbCpOpQz4zk4EPIdFY6530pheKEt7CsDKH+02nDl5BLrVXgSeDBOKlU7S4xLSuOQs1tOrBF72/hiehPIbm0dn7V8dtDXQLECkEz/HrFPdsEFbdXNheF6zyvE63tSnqtQd2KvsPWF73c/8pu/K+FEpciE3NwEcoBLIBiT2JFqes+03XbbxesLEVuL6667bjvbSU965im6985Wnnn39lB0LQU1P1/uqJhraS9xruku38MppKvtM06veUg6maPrJ90mciNMXWovegZOaMonT6xrqcIdALFvzwHZb3Y/K7KskR2d9aBvGNavn3G7ZY+L1fGXX3ZFvKbxlvZRyXkyX4Vrxzime0vpSBzJYiDVNfyeU92QzpUGoPwRC6OuKrqWvKxiBR359gpCGLxt7Gc5LzUJLzxtdKxUNR5oksLWRaUECwoMUZ7VhFKFhRITJ7fRTywe8EGwsJg9ihQrxvhToNix5Elj2fIeO9Cjmp0xB1Qp6hR6KZaOEBVo/97ZHVcPiTlo1bFBc2a3XDYou+H6Kye5JrCvlY7WK0nppxy1BBY8W2ESOxFySyDZc2CtahHgRKhNrqk5YJyqyeczBwyI3K/C9kMpz1Mo2D0BuSqbkwCGmCNscjGx3oXVPJMQP6bp+xZFRHKbjbVc21pas1QrnlvY1piVigjIEbR3rRNgL8/Uiy784Q8nZX88fuHs7SdmjWtuXGrf1b4G27oTjHhl/qxl5LlZa2tLnAepE4UAd9NNN43PK8+Ys4cx4khIEQFoCoGaEGSx3LjJJfa3fa9KOeUgahskN1X41Z4pBbJq/Z4091haukPYOEU27N+dNvjVJCHpml6zHZztsNEvoq4yr0Lr9hDxbCqikz6lI9mEX/ziF7HILq8rADXgk/PF6UsOOpDNcU7pIlJhkg4z73md7lkXnXv5bO3Zf5GtV9BmqXhR0CHZrmuekHVr7hnXi3spRzwkm5Qq25PI0073lFh6VeWJzMgLG1Esl7MhHZcGoPwRi2pWSkD1Wz2Sck3k0+SFssLqMVwqpcspAH+n6Biy1CqGUlP0U0kYKsqrmrwaPQwpakCxGmPtnimU1IYDYKRkk4eN6QECksebwsYSvylR/waisGVy4bB8jFBSap6ZYgf08iFxLYrak+fnmy/76MP3spYvT88mvLdwNNSFjGUCmxM/WDRr+eK0bIstNo33RuEDrhi8FE4zvopOhHTMD1YoidCmHNd82DUZudR3kzKXplApFJ1nW80PkC28XmuYUlGBscSCpyptYBGAdE3ri4Evxiwq7vC5wrVnXFSfAvRyrTpSmNZZYg0YY2Mln3VyChAg7xk4sC6TYN6lH5hvxSVa0Rg7zI4xBp78DSDhxF180QXZ7Tcenl1/0aBs3PsrZS0fDM1aPlola/l0l+zfNx6WdekSIsNNAGTpMXm9Yw7tLcwWoYNc/5///Gcs6AAuC0V6jbzjavZ7Z0gCIQphgJC0LzF8gFgtObqVxDNhJl3fte1ZY86ZGjd2QrbZIkfW3T8SA7jSzLtEfZlvI5X6QMqDzuceGnv6wVqxh/xfLq730WOpeAaTDuSlvOXE/PmcbhUpN9TLnOo2cPnfr4usZLmCoMLXurMfki09wzbZcce2dZ4o1RYurRGgt1DktnP8fT71wUxMZOoXnMS672j0riHFpQEof+TCuAh31tPuRe4hA4OxKxSGWnjChhWiKgXieMepaW1hc3ShIIatlMjvcf1qwCdRNMRoM2bJQ68kvPakiPwETFMjdtfzewwXtpeC9X8FSikUnsLylBRFC9AypIwyRjN5/sJaAGZqKQL85guERnz6XrbzNtNk7zy9bDbx/SWy8cPnzb54fd7s4dtmjQUPg2aYJuY9CeMArqlwSNFLvs0Pefrpp78V0sGgAsPukcfOGLiOnDbV0xqCK+xIBqeUkwAcC6thCD27+a12rIsJIMmoYU2woykc6me5eRcS9z5pCcQzGF9jzViWyuf7LgXoFnZMTHghqzK5xD7DRvtexXByWjGDQC1QgAmUvpIKpqxrubTAX77wRIoEgFdMhMztAfNgbXlOIt/V+geaUlN2c8RBYPRToVhhQ3GAhgOR7zE6OYW+st7t6yRYw7Sv6IHOFvpUcY/rC6VzpszB5Wff0qGG5On1zMOvTfJ9iIC8/kxhYWvDfJhrxTKeGSubv0+6z4EE9mXeAeZ0yz1kT9iA1O4qpsw0dctWH7Jv9Tmgk4DiX2T7bn5C1EuiWsXE91nH7qtQODSp6C45kXSY/yMDCsX3IDsa0rnSAJQ/chHGovgLe39VK/KK8kq3UDCPPFphtGLh7HXWWScyknkR4sGepObocuOKNUen8Py9FoZVuFVYibKuBER58xQO5gZDJySfvG0/gV8/sYqUJgWkItHvsGAMUmqHg/VhMF0vtf6g0ABmIXkGN6+cUzUiQAdoSKL3rIXjkBqBU5gp7ymF2QGBYmkHQJ6xzbNzlKr8qVSE4T35VAbfy7glEFxo2Hn7QpfAgrECKLBenSFYGusn5bIJ3VdqUO7vxp6B43i4d86PdV5tc/PJKdaAZzJe8r0mR4PucuL7zHFaL9anNZhYdD8x1sLLpQr3OIKl2n1xTFyTY2EtM/LWh2tjtVJvTw4IB4zD4nvsH/qi8DuFWRn5atjxzhDPDpykdAt7MK1998u57Kz1XThuHB7fY08D7EvNtEm2zuxtp+7U+1pvzl9m5/1+0pZHig05ril0bU14LiRDijxJk7CP9LYslHRKGAabDspHZ+gA82+/cbhVtM/cd+HIltb7DOvMcXC22c+2iDqqXKFmYTcDz2Uu5RAXpl74vfksFM9cDJg2pGPSAJQ/AREexE4UNhCuRoA9bEM5wVABnkBOYesQwCt/CkS55uiYtsK8KowfwFeLMBIYQYCrXK9BlZEAICCpcIViuvrqq9tDPn6P8XSPFChWQ/sfQMG1MWvuWwgmsZeUdTERDgJ6KLiUs5naCnmlak8MknC0l7FMzYt9TugGyMU45XvFCVUDVhQuAw7E5E+jMKbJEADLpdo/YZTMBeBrLr0P0JQ35Tm9sNKVTkaqRYQVAcj8OAhbVyOMYMplxfwU64n3XQsnCFOa7qmWhuudJdgjDKS1nXdCRAb8Xj5qpbCy3MFKeWYcEikSib3yffIyE3j2U/QC4BSG9J32Tj71gkhpoJ9Srt/kFowp5yUV/HGWMOLAFpZShMO/7et6IjuVhKOXnFZO3qpz7tRhdlKI+bAd/hTBHQfYHgXsC9k5tsBc0VeJCaTfOMz5XObU3qywxY85xTKLWumGkdaXeV19jj3rzwP9+nXUvqfF6xWLegCt5qXQOZNq4zNC8+xQXlLrt0Lx+8Jna0jHpQEofwKCJUtgr1aRV0P5VmqbQUkqSknhPQaJAaFwylVqF2uOrsgjKXKsByawVoYHiNKWxPeXquYDIhPzlz+VxzOnQhWK1vdjd7BOfi80KKQKIFLMGGBAKLGVWoXkwbtwHtCHOQUa88cHUuKJ2UkMSWE1OTa3mGFTjZ2OQ0xh+1SUgzlgKDELsX1Ily4RZFeqhHdNzwIEYIzScW8Aaj1thEqJ+VQBb759lyIcBTRSEIBE7YXKiYR7n/GswPR3lXdXTgBwToIxk1bwXd+TfWQP5nunYhkVXllLAEa1le6pkj7lo5WSxGLRL4VtWNJpNKlZOOeuWP+/FAn4LtIUsNdCowCdvWDMrDuAlkOVCoPcu71UeMZ4R8R1fJ/QMx2S9MXyQ7btMKCUt7jAgLUm0R/pxRnlUHLu6Qq/4yhjqTllSAM6kAOkO0VKHeEMAN/GhQ7DHhey/xwo6QG7b9/W77Jjr4OynVf9fdQ/xWyGvVWMSZWX65mQD3JA8+KZPEvhHMpf9dwN6VxpDg350cuss84adt5553DSSSeFUaNG1fTZxRZbjNMRnnrqqbLv69atW7z+TTfdFB544IGw6KKLxn+PGzcufn85mXrqqcPvf//78Prrr4ctt9wyHHHEEWHOOecM55xzTlhuueXCxx9/HF588cWa7rtfv37hlltuCRtvvHHYbLPNwt/+9rdJ/v7555+Hu+66K8w///zxHtdaa632v/Xp0yf+XGSRRULv3r3bv/8Xv/hFWGqppeI155133vDwww/Hny0tLWHChAlxjM8+++xw8cUXx3F7/PHHwwcffBBWXXXV+B1//etf4zP26tUrjB49uv27/v3vf8ef7733Xmhubg4LL7xwWH311cN8880Xr7H33nuHueeeO2y33XbhvPPOC6+++mqck5VWWilceeWV4c033wxbb711fK+x9Ozuddpppw1bbLFF/N3iiy8ehgwZErp27Vp23LxnxRVXDJ999llcKzPNNFO8/vHHHx8GDBgQOkPeeuutsPbaa4cddtghrLnmmnGcPc+1114bbr/99rDKKquE9ddfP/6/UD799NOw/fbbx78b48GDB8exNG7fl4wfPz4ceeSRYdlll41j/+STT4YDDjjgO7mn999/P67tlVdeOfTv3z/84Q9/CF26dAm//OUv4zp59tln4zj+61//ivtxww03bF975eTee+8Ns8wyS3yVkosuuij86le/iv9ubW2Nc5fkf//7Xzj88MPDYYcdFueKXHrppXF9Gae8/PnPfw6rrbZa3EuTW+xP+8SYffXVV2GdddYJb7/9drjjjjvCPPPME5Zffvm49zzbP/7xj3DFFVeEE044oapr2+P293//+99w4YUXxj2z++67x7VuL/ft2zdMM800cb1vsskm4ZNPPon7ceToz0IWWjv8bPPMP0d45JFHwn/+85+ogwiddNRRR4Vdd901rLfeemGFFVYITU1N8Xvptcceeyw+O/199913hz322COcccYZcT/eeOONUd+ZF/vM2vY5+mvgwIFhjjnmiHP5u9/9Lrzw9Gsdvv8QmsIn738R10Lh3n/llVfiK62lvLBN008/ffjwww/DzDPPPMnf5pprrvgsw4cPn+T3eR3ckM6T8talIT8a+fWvfx0V5JlnntluBKoRirBHjx7hiSeeiMq2klBaNvhWW20VlSZhRKqRGWaYIYKugw8+OPzmN7+Jym322WePhpmSdi+1iPu+7LLLorIBygC2Y489NipUyhII9KIskzF7a/in4Y0Px4UBQxYPX07sHQYMmiP07/9ZBEEUFoAGaAGAABaw/Oijj0ZQCRQDfMbq5z//eRg6dGg0IJT1PffcE43MVFNNFZWZMdpmm22i4hw7dmyYbbbZIgjcfPPNo7JOMmLEiHDfffdFA+8anofxNlaAH1BpPn03Ze8Zt91223D11VeHKaecMipUoGLMmDFhiimmCPvvv39Uyj5nfJIwhK7hHhkOSh3gBkoAe+Cgo2KMgAdrEfi5+eabIygHioGRBF6AH+DZWFiz/k2uueaaOI8A3AUXXBCBJefD/blu9+7dw3ctxtZ9PPfcc+G3v/1tHKdKoL2jYq4SSHzooYfi/rCmze9xxx0X15H/52WjjTYKt956awSUa6yxRhx7jkYpsdasr2Ji/A866KDwl7/8JSyxxBLhpZdeiqDC2uKg+Q6OIbABVCWwddVVV4V99tlnEqAN0HiGYs5DZ4v9a73stttuYcEFF4xgkqMIgC200ELt7zOPdB1g7t8AWQKb77zzThg2bFj8mV7p/66fFw4dgONlzNO/vThq9jlQu8x864Sm0DHno7mpS7j70WvDkd13iw4ZJ5XQDZzzvLzxxhsRZLnfc889NzpmHBP7z+/dqz1FL9F1I0eObP+Z/3f+d0/e/Wbo3QnLfvzYCXGtWiecR3qCcIZ69uwZ9VKhcOA44WxEIaAE3gmgTc8naQDKySSdzHg25AcscpSEGGtNfJdLpL9gLSIEnproCi3X088t3xxdbp9G0PWEn1KD5dT2R6hLvz75NvKJdtpp5+yOB17Kdv/NZdnSW53yrdc6u5yaLbTcxtlss88Vw2BCyHIdUysUIbvURFd4RZsYCf1C5X4nbC3tQEhb2CZVkgq7CMsLUaYihmpC+XpdCm2qrk2nfKRQt+93fblyKU1B4r1cKt8v1ym1SdI2SBWwVhyuIwQnLcLn0kk/ruWaha2jahX9NxVmtJ3Ksl98XqHQVIlcKEJrCkL8XY5XankjfJvP9UoV7ULg36W4v1Thag09/vjjk+27zIXntMZS6y1hdfm88pv9X5V2vmVMKdGXlA5ILWuKCf1g3osd3WpdCy0KS6oQFoIUPnaPUj38nr6w9vNFLUK8xcLa1pg1+V0UUukqIdQrfGvs7LvU39R6lBtIxwj7Smehc6TE5FMI0ktahrGXR0inKPCQKqNATMV0LbmXH37wcbbGkP3qDhXLW1x55l3jmJsLY6mll3ScYmkXqX1QPrRs/fq/9Vzs5K+y9//hh9mgPvN0Qsj74GzNWQ+IOaD0hGLGJHLGtV0qJtJ9UleDwu4BnsvvFYPlRaFoOvO7IZ0nDUD5ExKFHnJlSrVlKCUMRWr6XYswgOlMaIUe+ebUtYh2OamheK3N0fMiZ0+uF4DLIMsL7NlnQLbmzqdF4LjsNn8sCii9hm55crbKDqdnt9/zeDu4ofT04Evi5IgEwORKUvBa7MhBTBXMcrXkLmnNo9LVvztSjAD8KSRKjZnTC2gAmuW4accDNAKvDD9wp1Aq36BYJaRqTiA+gXb3R5EbM++tp+2NnD398QoblDMa1gbFXirX0O/TiT8M+JVXXvkth8L/ATpr5LsSxT+KN8ypgqV6Dw4oJ57dOnd9aym19/GcOgNYu4y/v1XKNy3WX5YR9tlibbuAKt9X2KBer0brVT5e6i4AUHFMkhMpT9hnC09Rkb9ZWL0LANNHgPnkFPdlzNyXwja5hBwo1dYAunVYmLucnEHgWUcDzpicXW2SOMedXbX/599cXXdBi1NodtjooPbjYzmPetAqUikmCndSfi1dJkfSsxkLz15rf0bO+tS9pu8wmPT8yw3ePtob4566gyj+oj/yfVXzYNazpHZshRXgqYl54TntcmPlVzakc6WRQ/kTEpS/MPIf//jHmENYrQiJvPDCCzE8U4sIrQgVCUkIpwihyfESsq1FhI+FpuU/ye0TShMWEWasRYQmhbqFRoRzxkzoGhZY44Awamzb/bS20j3FRQhx3PiWcNw594Td9j8yhmKEYIRr99tvv3hfQs1Cdxw1YUmfOeaYY2JoOYUXhWyEyX32uuuuizmWe+21V6hHfI8wsM+/9tpr8fuEfnyXe/niiy9iiE9Y0n2ZB+FQ+X1/+tOfYthH3quw15JLLhlOO+20GCIyV0LLd955Z8x7E463XjbddNMwceLEqu9PHp3r+Q5hbt9v7oTfpUNIGRBiL5Zr+O6778bQ6W233RYWWGCB+BmpBMXmRXqFsfSeySnGW+6dMZZaICx88sknx7nsDLHG5bMZe3vVWMmFk9NnHD766KO4f4VhjanUECF3IcpaROrI/fffH/8tjPv8889P8nfpFdJEUqjUc0spkAsshUIO4tJLLx3/Zp1LS0mfkxoircM+T/na1o59Zx/n5fzzz48/d9lll7rHzL3JRbQ2rAH3KX80hdyNo/1njRApFC+//HJc49af5xcWlkoitUQ+pfC8sZbfaw/Rlw8++GBMXRH+tm8KUwo6Ktvut1aYZmDf0JrVmEvZFMKo8Z+EU887KuYJ2sf2nZC3MPYzzzzzrY9Yv1JmpMRYw3SS+aYX5Ztb09Xuc7pceHzlNZcJU0xtPjqSC9oUFl9t1qjn2Q3PIM/RT/cjnapQUm5/ynsvDHlLAzFvbFFeGiHvySMNQPkTE8oTmDr99NNrApTy34opp3KimAMYkS9EWVH0kvQ32GCDaASqFYU58pkIUALkAJPynoBE31OtSJAHbHtM2Tfc+0oWunTrURZI5qU1y0JLa2s4+i+3hSn6ThdBNsMpn0+COpCkOCYJoyQXFPgAQH2v3DXPIOdKvqgkeYCpVpG3xsDvuOOOEVD4frmRAInvkpMIbDLmDL15kOsESJoL+YbAAUUtf/SSSy6JcwJEeg6fp8Bdl5JmlBVbAaiV5Msvv4w5UJ4NuPC8QJBrAABAEQAsB9Df8+Lv8lDl4gEJ119/fQRNwC4Q5bqFDokxZ3jkWU0uAXCtHWAPWH/66afj83VUgGBg3zqebrrpIogBHj0TYAAknHXWWbE4wrNbQxwGYyNvkcGsR+Q1uz5Q5ZpyzArzJ4Em9+fe5EdynKyPlONr7QBg1hbwIicY+PV5e9I4mSvr0HsTqEufBc59plyxl+8HAH3v3//+97iOAFBrXqEaYCBXUdHZz372s3DIIYdEYKngxPpWlGI9c1rMl/zWG264IQJhIFceKJ1kvIFLaz3lwB599NERbP/zn/8MM844Y7wuAKPQxjrtTJlqQJ9w0qV7h35T96oaVCrkGd86Kjz2wTXhpVdeiPna9r/xSPoHeLSPgeV0z+bVWra2jJPnBdp83lgAX+asGgH+jKUxfWbYf0NTU/2QoiWbELbcbe1YIGkvs1P0kH/T9YVgkdAtwCQnAED2DIVCx3Dc89IAlJNJOpnxbMj/A9HPSyuJas8TFrYsFXIoJ0Jj+X6IRIuJFAKvtt8gkZeVb7BebXP0QhGelD+42S5HZkO3/EPJEHe519AtTsr2/s0/4vjJt5KLmcJlwqDuRUgwnSCRmqF7dn0J86HmwtBgJRHC0QTaM2tFJNyptUc+j1BI1ncIfcl91Fze34UX9ZcTuhRm9Pt09KRwmfC2NAWf8T3y3bRPkUeW8j69hPkfffTRoqFqeZHmVo6W1kiFuXF6aLpGsbOmhV/TMW/65eUbrxPHvRlf+YKF7Y/kqcqv7GwR2pQvKywqd7YzTlDxXObdaUop91X4UcqBcGQ+nOrfxkqqhD1rzXdmOyL5csKL9oS2WOkwAccq6u+n1ZR0g2Lzlfr/CZFbI8YnHVdoHZgrLbGEFoXG85JyKn1WaF9IWv6uXDjhSeHx1BYq/7Lf5eIK1WoXpT2WtmD2gP1fODb6v7r/1Cez1qMvhY59Nl3XOLiPyRWm//DdEdlua/6+vRVQ8RZBbaHxfTc6Oes/1XRxnPNtz7Rgc49yvK2zdPqUeb7hhhvis8hPTGNa2E7OXKW82GLi91pEpb1qvWiTNeLTz7LtljsuW7eKM7yLtQyaY6plYz61HFf7TYoHnU+XWUfFRJsgek5aglSGYiKU7x7zQicXa3jekI5JA1D+BIXipWQLwV45oWAkn1crgBtFBwQUy+WkBOQxUczVGEi5ZMWa2jKArkEBpWcqbI6eFwo1NDVnq+5wasyLrAdQxteWf8h69uoXjZTcRMoMOEiNno2V4hlA3P+By5RrR0kmIAcI5Y89KyfAo7w3yhGoTIn/vquwsAFwSyCQQWQYi+XBAmbAoVOA9J1L+WTuV09I+Y/yxhhmBjxv3AEIhTMS4YFByt3vAdVi/QsBB/euz11ezD/waf48h9NbSok8SmMKdORzFzVads+FILQjIsdP7l8C0dU6YMVE/qncNPOQ1oQcPvlnpebfmDqNxHsBqMlxcgvRM9X3GL9jjz02fp/1oz+o9SbnttzxlxqV28v5QwTsU4Uqaa1o+A/oWPvWVcr3y7+AWuBH3qxiH4Ul8p45OMBrtT0082L+UvP7Wp23tGZ91rpLYk+k4rvJIcbu5n/+N1tk4HrfApVrznpgttHSe2W9uw2IRVOpNy7nMulGusFcAt/2g/0F4Mv79V7FRMCUfyvE47zlJV2zsK8oJ9755+nc95RzmT+F7Z3XPsw2WfCImk7+8d4jdjg7awpNcQ3QHQm4p8bppfLm6V1OiHkudFqS0BWukS98tLY4LA3pXGkAyp+oqBK2eattVk3paABcrbz00ktxEzu9pZgAMom5A0Aq3Qf2zXtLnYaSb47OEOabo+dFtfqCQ9eqH0i2A8qTs70OOy0afYDSWCo48VyMMWDmJcE8GUyKjfE2lhSxCleGAJsHeJdiBIARgMY1sD3pjGQCPDOYgIDPM/IMtvemAglzDQwqiqkkQCmWDOOAQUtsKhCEiU3HU2LMXJNCT88HLHqmYmCSE5NOIskfu6fwIxk6Z0dXU+0OqAMkGJJUyY7VYORV2naGAAue0fPXymolAYIAdcyQewO63LP14X7LFZEAmtayYpDUGHxyijlRKJbm0f2qgi0F0IE7xX2p2IwxBwKBQQ5McpjSy7MDMdamgw9SgYx9DbD6ns4udLFO0vc7FateAbY9U3LYADR7w54vBbY7Q1Qo9+w+Zdanx4Dsn5fcnP3vv49msw6Zvf0Qg8SwpVOz0tnU9Knfub/CU4lUoac9bZ4V73GC82IeRIRS0Yq5sR7T91oXQD5QZo0WrpEXnnwjW33WfWKxUKViIj+P2+uCbNzY8fG+6Ex2hp60pnyftVSsC4C9b/2JurjfUoRHOjiC45wECHbvDelcaQDKn6gAcBROtcdPMYIUULUsQaoUrXT0nPfxFIXHC0/QyAvgBIQVYzzzohWKqmkAiAIUkk5nWvsJbG655/GRYewoqDz4pGsi4wTQFR7xiN3abbfd2g1uUuBCedjZdLwYpUgR+j8jlW+vxHBhtYR+jBG2ptDoJibSEXnpjGCsJ0DkvekkE8q50HBUI+5BOxXfo1I8ne6RFH1iOoRGgYXEvmEvsMVC/9YMIIoxSSwb4M1IYSCA6nJHZJY60cf3A7nJoPmOUixFtaJlDqDjGQCfWirbUwW9tAHjkVIJOBKYnWpaZ2nrk5gfgL3SCVWdKRjYxAhxkpz84xQSxte9YIGEm9N54PmX9Wlte1aMkTAqVi+13/GZBKKdYe//pc4Q7wzhTNrr7q3SSV2VxBp2HWH5JACPObb+q2nXVK9g5tJJXBw9+0d6ROp6YY7SyV5eUglUqEufwPr7XUotov9UTluTQt7p+EcvR6rm16c0Ar9XDc1OYDzpKR0CCIDn2TmQhSL83HuKftlpR16SbbXE0e1njWMiMa7rztHGXu661gnZ9L3mju2nCOZTlAPQ083AuLoHDncxZ4MDnyq7y53NnZ5FGkcSDobf/RBO2PoxSQNQ/oSF5wYMpbynapRqtf325HoBF5WO+iMMDTBCceo5WGqTM1jy56oRbWkoJYAOYGEMhHA8w37HXJAttcVJHQaUy292ZFTOQkSlBDhJvSK95MGlM5YLlR62AAjGMmrfkwAiRV4MjBgnSj2FqYGrwl6d/p2OUsO4dVQSaEpnlyfA7CcDhRHRAxP4TEwIA+HvWFSAzeeBXuMglUHaQj0ib86YMezWMMPkmv999vns2meezy5+9Mnsmqefyx55e1jWUgX7ZR6F3BlQrEc1jJk5sDcYZOsszbHQLjBWLSA0LnJvjZN1rtXT5BL3BBjYDwyrEC6gkfI5C19+r3+q3o3YdYCZowbQAxpSWIpJ6hHK2ZFXa845fACCdlqTUwBi3219dYYk5jXPlHEIARkOYj3h+GrFukw6Q+QH8E8Oy4ILLJhdc9Ht2Wz9lspWW2ibbJ4BK2aD+yyYXXX5NfFeOQDuW3pIar+W8oBT+6CU4sIWAIP+niIi3s9OFDpW3pMAbV5EpPw+5XROGD8xu++Wp7Ozj7s++9UOZ2Tz9189O/mwC7M3X3qvPWJET3gmzjmn5fLLL4/XsC7T/RXL308kh73jPfm+lXkRRfJ3Dn7hcZ/5I3Ib0nFpAMqfsNjEjAIAUEkYfUqt2tARRe7c2GoF8EyhCcq7mNePJRECrCU0lm+Ons6v3eOIszoFUM636p5lewC6TyADqARQCvPGCnOwAGthpgTQhKgV0BQDMcKwCcDw7IWySo0LwyJvyjXzYZ96BEgQXnKtxGZRzlgSxiGF2b3kwzFoKUTuZ+rTyRCXOmO9Fnn22WfjnM4533zZKTfcks2y/y+zOU84Nb7m+vqn1ypnnpf9/eHHs8/HfFV0bQPd7g/LWYlVx/QA/ZhweaTp+RgsgL5W5g2rhKEHtBjiapywUuKzgA6237xw0NwnthXzmVi79DIXfmdeAOkEwjQB9285ssXCjSmftlwhlFQLe854YZEAFmCZozm58kFJ0iOc1M6S5FADO4UMIjBmj3d2yD4vqcgJuAeQPhj+cTbngKWzFQfv2l6os87swsi/yNYaclBkBE855PLs5mvuiuNtHxYWJblf65cDJF0BiEwRBmsh6c1iZ6xjooHa/DMDdhwye6gYKSBX2PXyhyQAqr7fGpVnK/2FWIPuN+WBe24kQV6sTfcgDcp76MBSe8LfFY4VnlVfDZnSkOqlASh/4iI0AuiUOjUjLwBCYU5OKeFpYjRqFaxJCoEXgikAjBIo1oy5mhBpChPNs/QmdVd45yu9dz28PLhODEBKbgeSU4FAeikmSUrZ8wHMlDpWU2hLuDkJww4kYBx8ljEApqoJ25hn1wXkKgGmYoLhEMJ2Dd/PkFLw/m/95BkMgAYrZQ0UhvwT+EoV8K4FeABA9QKp2x99PJvj18dlcxz/x2xOrxyQzINLr0VO/nP24JvvtH8Ww4J98wxCu6XGUgiVEWL0EijDDgNW1mk9J71g9gCyFF4vlnuaF+sEUw2cuRdVvJhRYUJ5mljAfDW+F/YakAQOhJoBTFXr7tn86fjgfcCEkCEHM80Dxtf8AZcpbSRfoW3MpC0UE+NoD8uLTSIEnhygySWYrMQSdzb7xNHl5BXOtbWe9vLkFOMXIw39Zs62XPyobO3ZNAMvnaeYqq1XXrAtN1bOY6FYz8BaYqflL5rvlC9pjgtPlLFu6adC1hCotn5K6RcEhmti7vNi31m3HFJFYMQa5IzQGaIh1jGwmR/7xRdfPIbcEytarriR3uXsFhaU1WNLGlJaGn0of+Ki0bX+gHr8VRK93oo1ly4meplp4F2r6EGm15veds6kdb506juoj5weanfffXfN19WHTuNoTXuHv/Jwh/qlkabmLmH7TVYp+x5nF+uLpl8k4cC5h9SEl2hOrX+eRu1eelLqu6d5tPcbcz1D9brUL1JzaD0E9SrUY1JvwGKNwQtF37X0WnfddWMj9mpFDzsNyvXcPPLII2Pvt2WWWSY2tNajT7849+nZiH5xG2+8cezhp0Gxs5PdozPC3bv+eM6D1s/QZ/RZNLf+r3ehZvHVNt5/5r0Pwi//e3/o0qt3W7PpEg2nE8L6asLEsNPl14Q7X3olPovm13379o3r+sADD5xkLN2DnqeaPeuV6JnMy7777hvfr9fiqaeeGu899Umt5UxzDcadZe7cdX389KF85ZVX4hnqGnBrir/rrrvG3pTG0dy5D31h3Yu1o1+gM5n1C91hhx1ib0dnduvTqim3edYzUy8/fU/1obWG9HA0L/qS6vHpOTXv1vM19WHUL/Tyyy+PL2NgnvUc1PtUz9N0Bn0x0YtSn8N8M3PzT/QVnRxnd9sj+oQSDeGNV2eKHpjO/jZfeXHWvP6N+uzecsstYXLJFltsEU79/V/CQlNtGD7/dFRc0OUarLe2tOnNnqNmDgsPWjP2qEy9KK1tOl8vTgdWeFk31vdFF10U17a+n3SV3rn2O53j8xrSa+afn1vr15qlq+zxYqIfpP3ljO686K9qfVszevb6Dn0l9c31/faWudQHV5N5Qm9YR4suumjs6UvyZ3UXin2j52aStDb0r21I50kDUP7ExSZnmBh1m7mcMGSMUwIO1TQ1r0c0Ef7Pf/4TjZ8TVgAgykBDZw1uKZ5aheEdNGhQNIQjRwwPfbuP79CpDgOm7hWWXaz081GKDA+w6KQGQhFTjgwTAaAoZs27KW0nTvhp3DQkdpoJAw/077TTTvH3jz76aHwP0GkeNG6uRtwDIMNoACDui9Ku1KDcKTyaXAPGgL5mz5qiJwGCDz300Lh2nLjxddQj3i9FD3Q4Dee4446L77EuNBk2Nptvvnl8ft+Tml0zyBpgMwAcCoANyComH40aFXa94towbmJLbDpfjXif195XXR9O/fs/4vMwVMA6MTbmQeNnAA/A1dRcg3pjDqgde+yx0ZDVclqKsff8gA4wp1E4w2tPcZqsBY2Z/U1zcPMKHDpMgFFdZ511wgknnBDHDQjVSBwIAPA0qjfGxx9/fGy67d41hgeUi4km5hwAgB94BaTdn/VmrvPixBlgARjh7GkSrnG2NUnSKTmFkk5YSifqkDPPPDM6JsCpcU2nnHSGXHHFFXHMAAUnLHl1tgwdOjTOA6BvvPJibjQQ1yDdgQeTQ8aMGhseu+7j0K1Lj5od4hl6LBheeeyj6FCbO4dNWNMOmUhOFEcirWl73B5+9dVX45g6Acmzm78zzjgj7tG0vuhmzolr+Uwp8T10eCGgpJs4WL7DmnbCkkb2nE5Ogv9zTjgyTiqyJxzs4O8JUNqr5Zr8e17gMZ0AZK+RBqDsXGkAyobEo/hsMIatnDB+QAgvvZxgRXjA9TCUSSg3BpJXjA2iyJz4svLKK9cMKAEcp7IwhhQVBXbAzuvVzVJSuputuWjoUoYZZCydBoNVIAwQ0E4RpyPtKGKAi1H2d566YxApVSd4LLjgghEsYMAAOuxB8uCdUAHMOTKt2vGkTJ0eAsA+9NBD0QCXOgYTc4FBc4IOZe9UFf8vJpgO94jJtJasIwDeKSeAEkbTCTsJWPsdUOG6jIMTejBW7iexG8YDYwasAll+f9BBB8XxSA7NpY89Hb4cN65qMJkkvru5OWx9wh+iUQUYE9PoSDosl+/A3A0bNiyOFQbK2JUSbCDGBNg3z54XaFpppZXaj9rkKDl1Bghk/MyHF3CHaWY8OVLWjTUAeAN/xtK9AALGzak55r0aZrpQnELkObE59pX7IxxFjFAhoCSAhBNLjINntEYBb1LMabSmAV/PnwCKiIWxwe4CvxgpoC9dpyNi7fguToH1jHWdXMIZBGZEH/LCUQSisfOAVSFo6gz5z3VPhE8//DLUe0jPvNOuENex8edEOOXIv7H09qY9XihYZe+1NpwU5DlHjBgR9TKHxx7HZBt366KSk+UUr2JjI4pDtxPrH6Nu3xtL1yV0nz2IEU4nO3G8AUqAsZwknWuvkwZDOXmkASgbEj1N4RrMDANaSoA6CqNS2DsdhVgvQ5kX4T7gjELAWAFhPFnKsFp57LHH4nOlIwWxfmuvsGBYbem5az6T17vnm31g2HLdxaoKd7tngnmj+AAKRp04T1i6AaVIgVLWlDMljsFi+DFigDQjls4wF+7EgnhvtcJgJCDmiDlMmfOLefx5YeCxUow9NhiLBQRUAi/GFVAEErHKACyQVg6I5o2MZwKarC0OCUALZFlzvtt8AwoMj/FZe911wwUPPlozmGyX5uZw/3sfhkWGLh3XKQBovoT5jAHmDsAHvDAhABFHxrhho/bcc8/InEtRcD+YfuOFATdewIV7BiKdr2yPmQPPBChiRswhw2zfmQcha+uFg9FZ54Mn4QhiLzFJgLu0EfeWxBrzne61mNg/xqF3794RcHMSzFsKY+fFWsY650Oiwu3YKUctcl45NdajPVmJKS8nGHfrFTuOQZbGUCrk2hkCzJt3LHUhS4lJtm49O+BvvDpLOJHXX/i/UhkdVUn3pj5hhn5zxGMrRQySM+p5AMJSjjpdlI7e5XAB7nSIde4aAL1QdDqSsx5ASTh35MQTT4zOh71E6Ez6n46xfxAaHGr7xL6iV4sdy5gXe5Ok44MbgHLySANQNiQK5WBzOh+4lFCYPMRKgJLxJR1hKPMiVI1ZZPTlcxGKu1rB8AihCllhuITumpubwm/2Xjsss8iQqs/lFSIfOeLdsODAkaFn924Vw92MZWLlePOAC4MqfJjuC/CkkLF6jDVhaAFdgNOLCDNiCLBflK3rFp6DXU3IOz2rcLPwl/kGaPw+5WliyYBN31NJUSdhPBnbJIAZRq2W3MIknosxcX+cAWw34IWtZBgAkPvffT981cHzlFuyLEwzdNkI8J1lDNBhGo2J8bFerD1Ai/HCoDBugK+wszEFAIEY61LIGPDC0AGT8kvTWsDuA5DChQxvrY5MR8Q9cU7kxpkXa5EjkxdgQp5cPp0hCWcGGMUCSrnASgGIeUCaF2AaME2MrvdL93AGdwpLAurWPdZdWkU9Z2Nbp/aYEL/vkEcqfWdyizQJYyLXt1CAWdEQawH46awzv194/K3w7usf1c1OEjpv/eW3jzrHfsoz0CkiUCydSTjZ3MmP5Bjb11IMOCX2IoeP/UipL/UCSuFrYt9I6UiAknBSiTQoURDrMOkm67uSnkqOEn1CGoBy8kgDUDakHSxSCBQ/BrCUMIyMQCWG0vUoj84SjBevmiIEUtxrNaFvCh1ww4AJk2CGAErSvVvXMP+0X4Thz98ZWiaO+zr/b9IQcNv/s9DcFMJHrz8cXrvv3HDgfntF9q2UYG+ENVO4m+HDpADaWEbsDKFYhRAxNgwQwAl0YHYoeIBKaJABcG8x1L7ZZvH5AUzX4s0XMiXFJAHbvMFgfLFwDLp5lf8kDwwDIBesWtDDyMjZA0CTosbgYYw6Q6wlcwZ0p9DsNgceFJo6aqybmsIrn30RC1+EfjfddNMYEuSsYEk9E0ZPyA3gNC7yuYTozbF5xMhi96UymA9AiYH1GXPHEcJq+jzA810LB0pIHetqjRXLccNOSVcoFu4G1Kw5BhsQFYbEOvuM+TUfeREOtQ6AzzzABNSts7zIrzROijmA9FrE/QIc7hmb7p7kaFrn7q3Yyz4p9kqpB4Uve6XYC/BJuZRSEzhT6QVgcaysC46a5/I7TkaxVyqIKfYy9un18jPVR2RKSWtrFsZ+HiKbay5S/qAICYfbfVrXxYSusCc4InSD8fT89BCdRY9gDZEInA+5l7UCSmw3h4YDR8fZT0nMsd/ZW/aSf1t79mM1DGVybkR8SANQTh5pUuo9ma7dkP9nQsEANTZvylsplFNOOSV66MI6pdgnykqhQ6Gx6SxhFHnIFLjQ0+GHH14yJCvEQWECdAAowCzk6P0SvRl9SqlL1+5hutmWCLMvsmYY19o9/r+1ZUJoHT86DH/pvtA7fBKylnHRoMjDYYiADyCnEHi5H+NH0TEoxss2w2gwzhheRh4j6RkAGteQN8n4UtiuyysHUHwfJoyRokx9L3Dq/fIXGVXsUzmlikHDjnrWpEwZTffH63d/2DNMQ7UCPMivApjkMAEtDL0xZkwxWAwUo9PZctiNt4cbnn8xtLR2TH2NfeuNMOKyf8T1UC6sX0pNFv6eoQUUrA9OEANcuD6qvVal31f6TAJLnis5FMXen7oP5IsykriGZ0qV30lScQPJ6wHX8v40lqlIi5RyUBomqLLM1m+pMMfUy4XmDnanaG0aH06+dtfIvtvrnFai4IUOod/lKheK9ZHSNgBC4BEDSx8JoRNOgwgKnaKTA11HV9F1eWDK4cDwFhOANHUnwOy7Rj79yd/YFeAX+OS4YN0L31tsjVnD8tJTMRjgqnOFkH5DOkcm1RIN+UkLoAFcYFz8LFbBSTnwmFXepsrYzqzwrkawaMKzQh9yzwBFxSNCM4Ui/MTzlXsnZE4pMXYUDE+awaSYALsTf71HDOtQOGxg9+7dYr7cmseeEcGd3DCSClCAOeAUeMwbbIyi8OESSywRx8nfMF1Cpq4DuBH3hPURVvU5zBvFLi/JvcobEmI1zkKogDGljpkBNIFO4T5J6kLBqeinGoYS0BbGSiFH4S7PKgk+hdnLCdYXK0GxJxbP92Nn5D1ig32H/Cz5eeUqMOuR7l26hKaY0doRQJmFOWYdEtY5+uj235QCPZV+b1zlXXrJxRQyT4UA1VynI99dKNYyxwSYVzGeKnlLvd9aZpCBi3zI25qwr6QCACB5MMkIy13kHIloyOeVTwqQuEYy0pgq+XX2amEubbofAFQI3V6hd0qF0r2fk+Y+7RmhV+FRxULWbrEUkM4a02K/F6XgRIkSFDoj3u+5PLsxwObJP6z3e1984MPw6C3vdmy5WxsTx8XCInpTziInE+NKpyrQkadYDFBi7ROrSkdyku3/BCYJPQtAmmvXMk90oDVoXum7cgwlsXesJ/fkPjDByQHWmQKIpbfpTUwrMEkqFeUYR/eXD8m7bqPKu5OlTI/KhvwERQNnzbKLndFKnJts2Vx88cUlr+HMaA2fJ5c43cA9aNCsQa1G2Zp8a15eKJqDO67xgw8+aD8GjjhbOd9sW0NfTXPTMYkagGvk7ji8JM7E1Tw6NRX3U2PvddZZp72JstMaUttDRyFqJpyOT3QSitcBBxxQ9NQNzaMdP6YpsxNpUuNt96KJ9uabtzUo1ljb/acm3CNGjIjNrf1NU2InVhTKtddeG/+uKbGTRNy3sUlHpxkfjX81Gk9nYxcT79tss83itZyW4aQgzY8LTwrR3DwdM6nBeWeemWv+d/nz30o2Ma/2Nc/vT8t+dePtHb4fjZU1R7eWjjrqqNgE/vuSl19+Oa5bJ50UNpAuJY7J1Bg9L9afeXUaSaG8+OKLcf7tN/pCU3bPrtF62pdJrNm555674vx/+eWXcT1qbF3qzHNN/h164AjHzz//PJ76pNH36aefnn0f4vsLn7dQ3Kdm6HSixt71yv9ufaZkA/NqX2sN+UW25TKHxTHT0N54aw5O79nzfl/q3Gx6aejQobG5uybonqdS43jX1YydbjVO5s2JPHRCqfWQzhc3tk7icphC/iSxpHc0KqerrZdSp/kUitPC6L0kDpFwvGNDOk8agLIh35I//elPcdOXOnnAkYqlACMl4hQUxmVyCuCTzmZ1yo8jC93zcccd136aAuNK2QBTlL5/O9GFYnL6ghNEEvhztnECel7O0V533XWzDTbYYJLvpUQBvHRMne9keClL45bOrf7b3/6WvfPOO/G93gNcUY4ff/xxvD+fdRxjMcNKATtlxOeJE1ScLkIZAvtbbbVVO2BNZ6szAsCykyoAQ+A3LzfddFP8jLkzP87VLjwiEFAAVldZZZVv/c31jaGzsxl1Z6MzkK7nfgGLQknn/RoPJ7rUK8YL8HXaTzr2sduA6ToEJtPrf2+UP52mnAA+HC/P6Dxna+j7FCctWWcAXDUGNs2rNfWrX/2q/XccEoDBsXbF5vXmm2+Oz5zWJ0fIOdHmxdpK55fbZ4x+tbrAqSVOR3EOd/5kHkIXuU971rqzJuw599iRoyo7KsA0Z6LcPTiRyL5ZbbXVvvVc1cq4seOzTRf6dYdB5ZBpFol60/yZc3PmpBrCEfF7emDihIntwPL1119vPyubg+HfJ598ctX37jq333571CtJv55xxhlFzz+nu4BawjmznhytmASotQ4AXCexpZPHnPRUSTj+3puAPYA5OYmPn6I0inIa8i0RUhB2lZ9YTBRwlKr0FlIQcuusCu9SooginZgjlKT4QbWtMI4wsFCUcLeCF2FuoRwhYxW2wnNy24TYhEIUfAhn5/vXaXEi9FvYnkiYRDhHLqLcR3k5wkBCx0I9rqcASLhXyoD7UJwjjKOvpuR3OWe+v1i4JZ1M4brCPSqc3YcCEOF51/Psii2EyIWUhKzlMwp9yy8SMpRXKawlFCvvSIgoPZdQqL8VVvTKJ/U9ijc8W8ptk2sqr1a+krGShC+kKxwv10n4u1hI2/0L3RPhLyHxakXhi7CtAiVzpoBDqoB1pYjjnWefDkvNPDgGveuRrLU1dB83Niw+aPraP5tlMW/UeKm8ly8q7aJSe6TJJdaF+dRSShhQukGpdJRC0fNP2kYqyEmpIKn5fLF5VXBm7aTQtHQKe0LI2d6X20vMt89bJ9WIubWWpEjIzc2n0AiXur4OCcKixlzFrnVdmN/5XYrQLz0ip7uU0AOeyxpJDeFrle49uoV1tl46NHepvztAzym7hYWWGxL3j3ViT0qHoDffeP3NsPLiG4alpt8yHLzh+WH9uQ4L6891aPj50seGY/Y7K0w79YyxsEWqkXlPhYXVCJ1IBytOVDhFpERIi5IiQY8RepSuSWF+YXJ2KD9mwt7WplxIY27tmX854oW9QQsl7U9rnjRC3pNBvm9E25AfpvzlL3+JzFoxpsN5wJiQYmGLe+65p53xm5ySzgUuPIM8hcB5sZga4Vn3iSl0ZvSFF17YzkD62aVbz2ynPX6R9Z1u9myF1TfM+k83Y/w9xuXEE0+MTGYx4RFjU5w/mz87ObGW/oZBcSZuMfYCY2EcSwmWwHtWWmml6MljBHjriSE48MAD4++xoubCe7GimBvfh4HEDmGaPHs6q7fcebdJhOK9Vzjo3HPPjdcX4nd+dBLnPmM3sJDlxL1gjzEJxgW7VUzM0cMPP5z99re/zZZaaqn2M8Cxn0L0GNf8OGLRNtzvwA6xkwNWWCWG8EaPHp1VK9gSzIh7wxTnzzD/PgTb4hmMrfVULFxZTs4777z42ZQmYd97tquuuqrkZ6w9eysvzhdPTJGfQqr2Yf4s72rlnHPOiddwL1I0Zp111hjaHD58eHvahX1ZLBz/fYgoRiWWkpx99tnxuQrPwK5W3n/nk2zdOQ6pO9y9wMDV4ncnVh1DZ2/PP+MK2dpzHND+vmKfXXvWg7KV5tguW3TBJWMqhc/fd999NT/DU089FT9Lf++8884xVcI53aI3oh4popGiTNdcc0383Y033hj//8ADD8T/H3LIIfH/a621Vly/M888c4yuFNqDvFx66aXxs86oJyuuuGLU8w3pPGkwlA0pKgo2eKLFWEoMpSpvTEWppuaTs7kwSYxKYesgCeCKarAd2prwdv0fs6egCIu47HLLhedeeS/MtezPwxI/Oya8+MWMYb5V9woTBqwY5ljlwDD3iruErn0GR2YQu1fsXGmMHXYOU8VrzotkfI1/NQXHHhZjUDCniptKCfbLkXf6HWIeMTKqGBW/qPbG1vm/JtUYEuyU79JvTY+2VASkIADbp9iHVNNiSGGP5HqMquv4Hs/iO4iKeYn9XljIcpLYA8wrdhRbm1qTSM7X79LzYSEVfqgQNe4qxbHdmHAFF/kzphW+xFOELjg/zN9TZXKoSbo0NYVlh8wcLj3qiFiQgtE2z+UE86Y/pe/FcBgDz1XtSUWTQ6xrDDVGUjstjE6t/S3tHwUQir0wftgghQ8Y6FJi3xcW7KWiOJXCilW8VPoWtgqqRqw5DJb7UNxmzZpzhThEyzBrQTHMD0ESS5l65JYSzK9n8sLW1SrTz9Q/HHhiWyuyWqS5S3OYc6GZwlLrDIlN6UVdjLFK6zn6rBBm6r5UCC1te6vY6WFtv2sKPSYOCHN0WyssufByke1TlFirpFZy9IE9rlsFHabQRzQCo40lp7MI3UqnY6wxmCJDeZYRu6m9kGIt0Zh8ZKVQFI2RpH/o4EZRTudKA1A2pKgIyQqFaHWTenflASUpFvamIBjZdFbq5BLfoSdeCnvnRQg89WsUtlONSlEJ9XTv2Tt8OeWiYYE19w9TDV4oNDVP2vqIQZ5q+rnCy59PGy65+9PQs+90k4S9NdwFuLT2AXyAR+GfVGEKtAKzfqeXnCroYsCxmnALEAVweQbAMJ2Mo92HED0wALgCO6odVeW6fwrWvQEcnlmVbgp5J0VdSjwPwCo0pa2R6lUgEBhMDgPFr3rb+qh2roSnAEitOoTsjZN2Qq5lfTFwQp3uT+hKayjzmBfj5dkZGIBGD88rD9g7rDlX9f0dGZuFpp8unLnp+mHNNVaPIVTXEQIsNTZaYLlf6RTAgPsFQr9PAeDMs3Un3SJfbVuLGHPOGecIiJQWklrJlBJ7PN/FAeADpuwLQA8oTX/nkNZzYozWW/asEKi1nToPuF+gFZjszD63HRFrQ+hYn9x8O6ViAmgL39NPCRTVImtsumTY59hN4j7XqLyS6KPbd7pu4XcX7hHO/0dbA38OAb2y3tCdwnTd56n6u7UsGv3luHDE9ueG/fc+KOqgQttQSdKcpUpv3SpUwtOxQGZyeO1/aUOek/Ps794HDEq3oPuMtabm9MkhhxwS9ayeuIBqMUlpWKk/biPk3fnSAJQNKSlYLYpcy4u8yAPU87AYoJzcLYPyUu5cb6dwYM/kVibv9a67HwgzL71T6DV1W7/G5gIwmSSBzM9GjgsLrrF/eOiJl6OikxuGOaSUMYGeFfCmJOVIEQpP7lg69QarpaG1vm35puLVKjMeejpBIt9Q3rPJdQQEMHv+hiHKt04BZrGr7iexCek882KCZaGcsUNAqHHzPYwfcAoga/4NXGJmqzlLmuEANoACz+z/WAbGFHAFGIyZcdKOqVQ+nGcFdlzH5zyDtal90J82WT8ctPJyYaqvjytsLuz7+PV55VN07Rq+evTB0OWuW0Pvr0+KwYBxSpJhcj9JjB2GDWgHbjB4+talNibfh1hD5gerC+gbl3qjAYy0l3FnwD0vMF94ik4hIAco8wylfF6OVmpmjiH3HoypHFPMdjk2vlCsaQ4Lp9QcA/EYZM+OYZNPi9X6IQm2ntNXiaW0vjnpnCkgtFj0o5Ksv+2y4YSLdg/zLTFrOwM5qbQxdH2n7hX6z52F6x8/Pbz9btvpZRwPIHCrn+0YWj6apubvbm1pDZ99PDJ8/mqP2KrHfqhF7COvwtZB1o+xSPm39Jn9rp0RR09kSaTCepcfbI1Yd/YrW6SFGqBu7XpvOq0tSYvm9l27hZ69+7QTBA1A2fnSAJQNKSk8Qcn+er0VNikvVZhjI0/ugpwkAICwjXB2XiRtUzzAD+MTuxmE5jDvyruFLt17h6YqgFA6WaK5S/dwyZ1vh2VXWD2yY8AUZUYhCj8LSVOE2DpGQgNyAAxoSidK+IyTY4SJMHV+VynknUTYkAGgLDUFxlYmEX71/bxYr3RiAADWM0lEQVR8z0nRYh+EP4WLgQ6fAUgVMhDgg1Hx+3SGMk8fK0WBGzsAi2J33+4XE8zAA5lOi1HslBjLb49ZazQG2BoMGpCr1531Y/zcZwLbettVanouzKUvKtAjLJ6ukwezAOSeyy4V/nfA7uHUjdYNiw0eFKaeYooINoHMHqO+DANeeS48eOCe4cTNNgqXX3pJfIYknlvoW/jM9xhD42w8MYGKtbC/+mt+n8LoWgccBH0bsc8d6e/pmQmGFqOusKYSOLU+OBZ5p9EY6bkp/E6sHUBQyoQCM9+jKKMa8GQOODGMvjB3Wsv2knQI6w/bXo0z810KfSgNBiNbiaW0d6x9Y4nVrfT+YrLocnOGk6/YO5x1+yERYM698Exh0JABYdZ5ZghTD+4WXh39n3DJg0eF8679XZhtjlljJMBeIpjAhWdeOTRVwXCWApX33fJM2G/vAyPTWVi4WEmK9aLEdgJ4KdUCeOS0cmox6OmseSBS5IbO8930DUAJqNNVoiHGk+77avz4cNPzL4UtL7wizHfin8KSp/0tzHT4MaHLjnuFX95wW5g49TRhVBVOfUNqkE7Mx2zIj1C0uZAQv/HGG0/ye0UfkqALiwAUoWj38F2IJP1iBQQSzxWkKFhI7XIGz7dSNnTLk7Oltzql5tfQLU7K5ly6rc+j5HuFPfkEfMUr/qafn56Q2l7ooaYHnZYc/qa9iDZE/q3Xmv5vm2yyScVnVBjkWtoNSSBXmKPwKcmTTz7Z3ufNy7zk50SxhB6D6e9XX3119sc//jFeRwuWf/3rX7F4SGL7wQcfXLRAReGJoh+fV/hTKJ5ZQv32228fCzG8T/siz6foQ/uYfKsdCfSpJ5zCilKFJI888kjs4edeFSWlRP1a5ZRTTomtnbTA8V3W8rTTThv7WeZF70wFIMbbM3ifopAfgtx///2xMMrLvztDjL3ntVeqbeukEMPY6AlJrBdzrUiLfPTRR3H8TjrppPbPaPlEV2jxo6CmlGjJtcIKK8SCm8cee6z991rOxFZR3brF1l4/VNHCy9jQD9WIAkJjr8ipMyW169KuKPUUtYdSi5xRX4zJNpznsA61H1pntkOyS864LeqF/fbbr6b7sw723nvvSX633HLLtduYfMGi/UqHa8uVdJgitL322qtd16S1mIp+rL++SyydLXBCW5/auX932rd70H79uzkOPiJ7/oNJ9UBD6pcflpvXkB+caMsgd0zoKh9y5ZFj6vLeKeYCm/BdMZSS9IWTC/MosU+YQqxcOpWm/5ChdbeYEQKfZuZFwwUXXRpb5miDkg/NprPB/Q3DggmQ+4MVEK4TBtO2SNhcuBxDYCx525jUUsL7VowjtCnNQLhX+FUI0ee15MEKCQXK83MKj7mSmJ7y1rCTzjlOeXE8d8xkClMKgTva0X1o4VEs9xVL4Lkw1kL7ni9fLOPeMC1C19IkzAcGwntTcVeencD+YQGlLJx33nnfSu5375hx4Wj347vkSJU66rOSyHd0z1gO84Lhw1oLZ6cEfqwGJh7bbZ7MEdYZE/J9ivvD+GHjrXVjkT/juCOiMAQDbpzNZTWSCvHSHse0WRvWOjGfxti8J5GSYex9l/WrhVahmB/ttjyfgqf8cX3YTSyydV7s9KEfitCJ9mY1uZRELjD2W0GKcessSUyxFA3iFC17DMNL/zx6z0th/LjaWdHCdXn/rc/F9Av3/vHHH9fNUAppiwA4AYxgGbG3xFoS9sZyY+UJ1tpetZ4KT8nxrD8/9Yww8GdbhHFfa/zWIkU6Lel3U00TtrrwyvDgW+/UNxANmUQagLIhFUXIUg8yeUJJksLPh70TuPyuciiFpJdYft3w4Aufhb9cdm845+r7wyXXPxDuu//hGO4GmOTa9Rs4R5ii73S0U93f1dzcNUw53bxFQU0qyhGadhyZ0IwwIMMI9AFblCDQ5/8AFcALODGwcqkkoBeKe5dCkIpxADpgGVAWOpakbk6AS6BAiFHYUqgIiAL4k1JOoSTKGVjz/ZS6XFDKW6guKfG8MBTGkkFXXQuECNmZf0ZKGBpAk4PoGfwO+ElHPRYTxzO6d8/n2gow5JUR1/B3RReqZxma+eefP3REpBoAteaAuGdhU2MpbGb8gB6gFRCSC+czxiiFhb8P4aAB6EL81pUQcGdVlXP8rC2h49TPrxrxGcVSyfGwzq1FOZVAlHGlLwoLZlTYcmxSBwTOVxL7QJqIvwt9Wst5MW9yeM2Hgp9yTtj3Ldas/GA9VKsROaHSYfwEujtDpJFIOZDLmgTwk+piPQ1/58O6w915+fzTUXFt0i+pv2Q9gNL8WhfSaog1TncXk3TefB5EAsrpen9/5Ilw3+fVh7GlP41rmRj2uOr68OKH1YPihhSXBqBsSEWxiSlKyl6LkrTpGZY8a5kSoSc3Q/nlqLHh8psfC5sdeF54a+zMoft0i4Qrbnk8XHz9I+EvVzwYFt7g1+GtUdOGrXfYOyqq/oPnC62tldvlVJJHnn27qKcOIAKNmEs5Y0CSF1ZQ0jqAJ/eNwcAGMqipSh17KS9Mfp6ihnwyuUIeYCoxUgoTgLoEBOS7YUDzDcrdA6Am15ChT5WkCTCkc8x9xti4D1WRHAM5mRin9FwMkmtg7fwdYMUKY5N8D2YBKFOhXSuTxxABuZhbuWeup60KdsV9WWeAb7VAp5wwQAC270oCwPh+ABKoBoaAV4y2cVX97ffY5wREv0tR8IX9tbaANixWZ4xFEjm0aY2VOju7Ussg829sUjGONlccC3NbTDiaQCOHRF4cBs24A6DGm2OGtc6LteZ69g8HDdjEqteat/ddiYgAprValjJVMdMJniu1Xeuo2EeJoUz7XlNy4P3yy67oiG/dLhMntERwaP8rlEstfWoFlOyK+01dHfIMZV5EQDh6wDenT+4kB58T6997HnxIOPmu2kE5snJ8S0v4za3FixUbUr00AGVDqhKtdxQpAJalCnMoQ0avFgNVq7w+7JOwzS8vCH++9J7w/sdftoekJ7a0xldiE+994q0wrv/yYfACa4bQ3O1blb+1igDJ519+u4gG6GLchKUxc4BYCsVgUzACFK7iGaARS8mISCGgVAHRVGiA/QMysVEAIQOLnUzvN/4AqNAPY+F7ANfCtiyMte/LhxtT7zXV74yd7wZWMD8UtJCl+wPuVLIDjphC4NVP9+c5AQYV2Vq3YPfqFc8kVMaIeH7VmYqcVO8a01TZ3lkCUPoe4ftkxMyF8D/23Xcaq8ITi4QljYkQ23clwpIMLAcCyE3h5M4S6Q4YYUy3YpdaJN8yKJ1MYu0TLBUQXG7uzLfODELXwKN5sc6Nr9B2oQAL5kzY3xrxPuyo0HK1AOa7FmkngHe1LCWdaS+KcohW6PHbUeEMcfbzfWftaXvuqWceD60txXs11iK9+7YVhB100EEx7cH+rRZQOtmLSGPglKRwd1ojpQCltSWakk4a83z0Jgfpppdfj9Xc9Yiw+NPvfRBe+LBNdzekPmkAyoZUJTxB4dUUuk2AktJKeWiMjVBLvbluleSNYZ+E3X9zefjsyzHRqywn6e8A5QxDFqi6srucFKssZQhUMgNxmCTgxBh5pXw94WGsBXYSeytkx3gwlNhEBgVwxCbKZQMaGQSfxxBi0rQPcp3ULB2bCGQKyQJhWL28yLcDRoQahQoZKoI1FXbHUAKjQAHWR9gotRPSPigdh6YdB1YJe4gFINrBAMlepVoQVSOqvQEDbAOxdoR103d3pugzaf4AKeNpPIwNA6svHYBcKFIX5IFiMzlUqqonp5hDYB3IAm45DVINOlMYaiAygbJaJc9QWu8YXCFW6xJQLcVO5gWQxRb369cvzjdAktZn4XdZf6r8OTnEd2FC/Q2rXbju/z+ylAlkiQ5w2DgQ1RxAUE44JAC3vZwX97XGhsuFjkqXLs1h4WXa+r/SC+5ZGks1PUfzDCVdyHHKA8piDKVx1I0gdaywLlyDreEwH3X00WHQqmt2SM878OCyxyftZtKQ2qQBKBtStTCsjHBiKQEcOXbysSZ3D8oxY8eHA37/zzBu/ISYO1mLtHTp02HDg9+cpt+kBSuANEAGmFHcDKqxAV6APh40T1pYGGikzLUKYhTlTUklkDeUmD5GXkgbwNIOhlEBLIT65EYypPncIYyocDomJJ2ZnRfsI9AKmCbQD8SlYhlhamASOyekmE6SwFTK30unrhQaN7/HkmLvhOmK5X9WklSUwwjJ7QIiMaWMC6CTWpx0lgAvQtnGiQEy5sbVOADk2ORixSLmzRgrdPK+VOTV2YKVso4UVgn1Y1BLtWaqVxjlxEham4Xh5UoCoGDF7XHOI4clhbuxk4CA9VBJrEV5s/LkAB9rwBgXvgc4dU1jkhfOlDXPocpHTH5I4r6scaC7WhGB4PBozm18OiIpxz0f9k6y38G7hy8mvBdas/p1YktLa1h/u2+Kw+gtPSGrYWUBQmsJ+LTOMafpsAxizu2HfFs17eFEE1LrLnsRmLQ/6denhr8fPu+gzlCoc+uLkwLwhtQmDUDZkOoXS3NzbHKOlWKUkxJIeZSTswfl7f97MXzy2ejQUiOYTMap2JFiNV1DKHmJSU9kkecHsGG8hIQxlUABVpKHnRrCKwIBBoVcKUL3AywYT/ljvHsnaCQRAqRQvU8IHLjCCqr4zjdHT+FGnxUaTInxQBnGE7DFHghzp0p0TCPHABgQbjeXPH0/MQAAsuIiANz8MmyugznJCzDsvZhQoBj7WtU4ZlkcK8ybz6gIF+LVWBsDjimVRqHnZWexT55Hjpr1CQwDwIBVAsy+k5ErxvQShsucYso0TZZLWup4t3pEgQpGWujOOrFuJkefReNr3yrQyB9fWq2k/F4MJeDAOZEOoL8khpeTlM/nLSbGzThySKxn6xDT6CUPL4k1i+UH4It1HvC92FxzkQq6fkgC+IgquL9a+kxipwFskQROZL0iAiKtIF+Yw8GkL4D4Tya+Ek++qUcU9My10Exh9vm+SW2S22hO5IxX2rf503IASoWC+SNDU+FZnqVMKTsJUKZwN90ovef14W2kRkdl1LjxRavCG1KdNABlQ2oSLJtNzQOfuv90YbaFVguX3fZ8+N3Zt4cxPecKrb1nDyO+qP5UjGokFr7c9mTdieRJWTmGrF5pDi1h1aFzFQ13A16UPxYLIwlkYZkAPUqcGDNGl/ET1mYkedxCrkCbHCChPwoZ6ON5M6hAKPYzsZ4Ut5B4Xmlj17wABWyO9/gu+WxYEoo+VSsDKsAc8MJwuW46GcU4Yy/9X7EPoEP5A5pYoULDLc+QQXBNRqFS7hdQCthiIrUvAuwSqAGGjZv8KLlYxrYY61qLYFldQ5hMxTtQCJCnEHsS51hryYRhTid1FFtDQDuAYG4xMp0BKo03Ftp8Y5OKhX47Q7Cx1p0XQ87RqPWEnXzRHeYNG2kdW/vYJuu2mvxC6w5QtF84JorCrH3r1/xjqwF3Y2HtlhLnzXPG5CkXY+J+KCxlIftaSTw75tx4pvSijhTmPPTQQ3Es7QP/tw+eeu3e0GfaLnWzlDv+sq0iOy+cXkwip6gaQMlxlG6SD3eTVJyTB5T0KGZcpIEkBzcdOXrPvZ3TjcGOrjcPsyENQNmQGgV42P/gX4e3Rk4d1t39L2G6edcOb4/oGm659/kw9cyLh+eGN4cN9zk7HH3mzeH514q3fqhVnnv1/fDm8E8r5k2WEwCsXpbS0X3DX7ovHP2bI9sLAVJ1N7YP0PL7vEHVgkbeF6YwhYyxl1gigCS1TQF6MC0ACqaMkXSvgGViFSlSRkmhjrAYVhOIFRqLpwBlWQT6lK1rCSXy3AEHjAQG0L+BIt8jbAnEAIp50RPPs8gVZPAZB/mXEugxT6mSPQ8chauAFQU7mNpCBjWNlQpTIXUAWf4cljKdmEMAEwUX7l0uGYYGgMNi1SMYVyAYeDHeDBIAw5gVq9oGrBVDGf9CwJnE+AHsxkbPToxcvbluWCvfZf0A44z+5OqxyPgC8Jhk85/O765VgCOnmbgeJ0e421rlDHiOwrPXCyUxiuaVw5IfV+Ppb0BYamllPVZT2KX3oDSJlHrzQxGOG9DtuYrti1KSUkrsUSxnPRXtKQqCvZPWIj+bk2ne6Kkpe00ZzrrxiBC6ja/a0Y5+eVMIB/xu83hST6H4HutKfmM5ZysBSnqD82rv5aUUQ5kv9krFdb6LU3LLtd+cfNUR6dG1S+g2mWoAfgrSYCgbUpPc/cir4R+3DwsD51gmTFApSMs0NcdQdHOXrm0eXktruOvBl8OuR10WLr/lm7ZC9QiDdfcDbeGOjgLh7t26hOYa+695f7fmCSH74qVo4AA6QJKiptQYUqwWL1tRSRIADBgSFgeekgA36TOp9QqGEvDBGrlPr9Q3Mi8AEu9fkQwABogAdAyHfEqhRwZfMYk2LMAblpQX73epAt89+QwGk1InGEwg2Mv9EffjWV2LEWDo9Cx0H/legFobyWPC8AFZeWPCKDD2QtqMIxBbrJqXKGjCVgmlGz8AD5tZS9seOb3Ak2eWb4oFxYoxXELXfp9vH5QXQMd4CreXA4rAENANzABVtYCFdI8ptOmFcc6D684U96agyHoBKIQKMUP1AMpU4S3czejLu+WsACt5gFhMtD0CxjlUQG0psO4lhYYzls8XLiXWtVxKn+dUcdB+SGLtGbdaWcp0iIB5w9JWW9Fu79nTjhAFSulPzpm0D/sifyDDNNP1C6dds18YOfHj9kKbEleNar5r967hiD9vF9baYqmS34+lpF9U8lcClBwba4jOygvdRFclQOmZAMr80ad0Lz3JmYgFj089Ebp2sJOHopxlhrQVHjakPmkAyobUBCYPP+2G2J6nEtuXch3PuPjucMmN3+TxVCOKe4Q9MWIM14kn/TFkndBHskf3rmHOmQdU7ZF738Rxo8Kig0aGlvFfRVYRM4j1Y6QpRgoaaBGOLhT9IwEsYVcJ6/l+cKlvI8MO9Mmbwwg6dcZ7GJH8GeWUqkpaxgEoTSE+bKOcSTlTGEvsEaOPjStsDkxJAxi+GygFQgFhYVAAlhHi8ReK4hvsqO8GzDBB3us+EphiGIBBoWOMDMF2ApsMjLxQz+0+y4n7AE6kAGBinevsd4VnyX97rrII8gAR4+A+UhumvAByqeVSoTBswrfYQkCvnAizAr6MPhaqWiDjuxVMWDNYVKHefP5YZwtnRR6de7VehVCBjHoZSmsLAJaDCqBjJzFHhc3I8yLEKiUDIwtglZtDjg2m0/iY92qKs7zf+gKahIo7M7/1+2IpieI9bD1ACgyWy030N3mnwtyYaA4RZ5AuAdBKdd6Yb8G5w75/WDc88v5VYYa5+hRteD62ZWTY8dB1wqUP/iassG75rgP2VzqZp5TQAdY8fVYY7ibuWd550l8YWs5ynqGk5zh/dFrM2xw3Nkx48bkICjtSlLPdEt+A1obULg1A2ZCq5O33RoTf/Pmm6KnWqq+dYvPwM9+uoM0zNsCHNjQMlhcgpurW7/bea4/Q3AlhiJ49uoXuIx4Mnw17Oj5Hqd6UQtxk3lkHhFfu/lu4/+5/R0CI3WO4sIT+Ly/PfcopK8W6AWiASp7BYVhSNbxrMPiYGS1UAB3AizLVMogxFjbHfqYKexXgwBbFrJhE7hmwgLH0PSlX0P/zLXgSoCQYMcyOSlpHDGJA5MXlGYxCxgTIEzIDphltRpKST83TGT2tUoAGvSs5BBhBhr5cLlyhCH+6rmfE5GIuPUupwh95WACtohrGFDDHiBYDammesK7FBGvrOYFlBq+cSGFg8M1b4VgXk3R0JgCEJay1yrpWsVZTgYe1RDBHjLUxrVUAG8DEGsXMApjAezotpZhYy5wta9ReKAeerT+sFSbVvWOmqxlXAqT7LmDXKUs/JLFnOcm1spTEnvdMxsOaLJY6oWMBEAe4plZMHAeRBhGVfGFOMeEcrLf5yuHK+04OJ1y2fTjm/F3CoadtE/ovODq83/2BcPc754Z+QyaGPlN9uziqUMwvxyGdblRMrCE6EQg2v8Uk3zooXacw5J3amNG/HMd37rz1myMV65BBffuE5Wb9JsrUkNqlASgbUpVcffuTsV1PPftV2PiSG9pO2CHAi7AMwy2MobAF+BBG5bGmpt+YIuzZCssu3qH8yQQS33rthXDuOWeFhQaNC8fvsWzY8WdDw9R9J1WSLRPHh54ThoenbvlD2GbVweGC889qb96eAA3mAAMAWGEt5RhiqooxI0CfUDn2gFHwc7755g/PvPJBmHbWJUOfGRcJx556QeyxCQgyAMAkJQlQM8aUs3Cxn5gbHjwmDRvg+10/NUcXdpaDBrgAeoxKApF5QEkSa+Enhg14r1RYAwwx/JgkOX9Al3t2D56fARSGZMQAVSFyrGstArxi1FIrIQDeM1sbeXChqEkRB2OKsRB+ZbTNT7n7xxqVCnsToFgls3zRSqySPFfXEqbF5KaGzXlxnxwP7JlwOtA0uc8IB/58l3WjyCNJyp+slRW13q1H42y+GXchVexXqebo5j4Vlwh5l/tOjpV0C3rAOAIa1rt1JMcuf7JKKRE54MyICNhrPxSxPjkf9bCUxLrH+MlBTS3GFEGJCGDkFSZxOOlPrDznKo114Yk5pQTTbJ/u+4s9w2IrzBlW2WixsPDys4XXhz8br51O0KpGzIOCr3Ispfvzffk0obzkm5sLd9vT+RxdgDKfEmGvtnz0YRj/4nNfn+Bduxy++kodPgDjpy4NQNmQijL6q/Hh5rufq6tlDwFEH3t+WDj018fGUCkjhEnCSqbqZ4wfcKTgQc5dPjS69MJDQp9ebZXI9YpQzoi3H29vILzaysuGQ3ZdN4R3bwr9R/8vPHfbH8J0Yx8KL9z6u7DIzCHMN8fgyOy4l2SQE8MA7PCg5RICP8J9lCj2CztWKEJ3lPx2O+4W9jvqr2HICvuGWZfZIcw+dMswZLGNw/BxM4afH3pheHPsLOGjUd3DUUcd3V5gA/wwpsaLMcfEAC9AN+YigafUHF1BCRCOgWN0hFUpW2CvEFAyTsbbi/FmkDB01RQBAKxALAYM2DvwwAPj2AIwAAH2zXWxk/UIQwO4Oq3GuPuJ5THOWBmA1toB/jgmcjNTxWclSSCwVAgRILYmhdnNQSWxpgH51FszX0zACZFaIBwvjcNRh6mqfnKJMLE1Zz6woglccBqkH9QT7vYc1g6HBoDRI9C1pVZgzAuF44TF9OLoVAKwnA/3l081MG7aSpl395zSRiqxgcCbe6ynP+rkEkDXcxRroF+NANscBCy8f+uIYOzpB/rA/khHtOYFoDQOnJpyotOB/caJT2kvWGzOP0DPqas2lUCUQ2soetKeKOacmGsh61KSZyhTQU5+DeUZSkLvuO6H114ZWocPa48yVZL0TEesvlJYa57JUxT3U5IGoGxIRbnzgZfCuPHV91IrJnIgr7vrmQiAsFmAF4AkTCVUWk65dO/WNfxs9YVrLqjJy8QJ48IHrz8awSFFBZAIzbRMnBjuuP2WMOrzj8JNN/wrfPXVmAgksAJAmXBLUrB++r9qZApM0Q12BtuqfQ5WCBshMT1fDc7wvjL8qzDvGgeHmRZYK2TN+V593zxTn/5DwpzLbRfW3+NP4fwLr4j5b0CeHoVyCTGIjCVWsNQpJ6k5unsBtCh3TFE6KSb1xAPAXM/YY0GBMT0BFW2oLk1HN5YTzKYcQEYSSMIy+Q7gGUOEZQWE662+9czYJukAiQVO1dsABscEewz0FQM1pQSzK2xbLi+TIfbdWKX88aKlRG4t9g/4BzCBcmCIA+D55awCAN+FmHdrJB3nl8ScAoX15k8SwEQqgsIcbHax3GFhcOy9tYpFq9RTEyACOjkHhXrAuNqrmOnEupeTxN5jz6VZFMuV/T6EXhAtqJelpE+EdTlBQLd1xVmzJ/JNwQuF7kiOQCUBSAF7+dyAZUqLkAdNV1fKY86LlBMOjfSVQuHU0ENAbCkpDHnnw93GwP3kASWm1pz37dUrvHb2GWHe7l9HX0o5MrE7Rit0G5Zt+SrsuFTpMWxI9dIAlA2pKFr2lK4ArE6ct73+xlvHamBhTMqxlrDbxqstXHcoQ5XiR689GMPZmIIUHpJviKkCLIVfvABAhlcolWy4xS5hq/1OD0tucmxYZKNjw56/uz0MWHSHMLLrrOH9T9pCskSIjhGnkFM1uEbNgNzhvzsnDF500zgG5ZpppmPD3vvoi7DLkZeE4R9+FpktYb/U3Jlyr+YEFUACUwnYYFAxaBgeylxluXwrLIcwe5oH/SsZEvmdmDaApJww8lhRYUpsEudAbiaQKWcPSDCe1ebBFRPGDQDyHekEIc4IQA+kAZe1ChZWDlel6nFzKYSP4a3E8KTxc0+YEswRptbnASaG/bsQzoNQtDVYCDTkT1o76USkegAl0CGcKUSqt2FhL0v5e9YWZ6BcTm4SYwWUAlyq+osJsGBcRQOAykrgyNxyaDC1xc66/76E7pE2UEvDcsUogLZxxr5inoFu+7qaPqLWoTmotk+nPE1rFcPL+QfQ6R7gr5awt33Keae/8sWFhPPNAS1XZJQApfx64DFf4c1JAJLzgJIOk0bib9P17x++vOW6cMtu24dtFl84TNGt27eu3zxmdPjklhvCuIvOCQNHfVH1czWkvDQAZUOqOvawMwonn3/x1ViRJ/SH5WN8hDMoWZXK5RTMDNP2DUfuuXbN3yknZvSId8M6y8wSPWxACbOC/aOYtTHx3ULMKfyh6vqiq+8Iy21xXJhx8W3ChyO7hC7dp4yAsKlL19BjyqnCqx+FsOj6h4dL73wnDPvgs/ZQKaPhexg/hQhPvPhumG3Jzb4+rac6SCy14ItRY8Nm+5wRDjjwoBjqwnJh6oS7ALZqT5GhmIHnFPaWZwhQu545KDyFRD6rPCyATXgZ+1cs1IV9AwIwVUApcOY+U+9L4XDGH1sJjPhdPcwMYygXC0MJvEsrMK5CqtiZesTcuK9yeZTpfal3X7VH/Bk/INea8nn3Xi6nszNFcRLWGYNYrMk4BhV7Ws8pPKlnKUYbY+j/hed2A31YQXtMuFOKRSWhCzhMQHA58Ak8+F57lvOCTS8n6YQoDhTA+kOo/LYusJQcvUogF5DCkHsOexDAs4/sNwywNanTQCU9QCf53kqFOUnMAUcAMBO2pitEO7D6lRqWF4r9ag0U9hMFKDmtIhqlRL4kFtOaJcV6UOZzKDm/nGbivjlPj911RzhqzVXCgwfsEa7Yfssw7uZrw9xvvxLe/vMpoc8dN4bPH7g3NE+cEKMyDekcaQDKhlSUKXp0q/uUmry88/YbEcgxdjxtDA4WRWgUo0b5CJNgznjJwIPQGYNAuT770M1huXnaQpvV3I/3TBzzUZjw7n/DqX88OQIgSseL5y6MxPtnzAAAYIjheWtE1/DXa54Orc1ffxdm8VvXbts6Dz/zZtj6oPPC6X+7KOYkAk4UOCXMcM+04Nrx+IVaiyBiAVTXXuHEMy+Llc4YAuEyzJACB7lp1bBmbffaFMPuruHf8t+8zEFqjl5ohBguIAqIFb5K3+Vz8iUV/jB22CIsZXo+BkluLEMApANkQuOALANTi2EHQDkgAIprGU9slecHmoCbek8SYSAB7UpFSOYSSyqfthKIEY7FzHKU9KjEWFrjlT7XGZLmE0sjT7NwvQEw7qOecDcB5lzTd2DezUO+ITXgJr1Bdb8oRDV5okALfaBwp1j+XzGwbu9iWI2rNVVOMPPSUqz9Sk3SvyuxpzjQpXIpRRG0WALkjDPd5/3ykROAoruAPg5hiqSUk2oLc5IoSPPdIg50BvDKUXCNWtJXsOGK0egv+jWBQToj5YaXktTc3JrFOOeb/idAmRhKjgxdIP0IEDWGHGKpH3T8lN27hcUGDwotb78R5uo9ZRj/wXthxNffDZA3AGXnSQNQNqSizDBtv7oLcvI5lL26Z5EhwVwJ1+R7ozFWQKVXanRLCQFmDD+wxrP/42/3CS/852/h8w/acqkK+1OmZOyJ48eEr95/Ijx+82lh6aUWi0qNkWfsUl4jIEkp8YSFgSmX/rMsGu55tk35VfPEgOXElhCZyl32PCB6yp6FgrvrvsdC7/6ztIeyaxU5o0+9MXoSECYsmPofVnPcYRJjnUL6wlFCo0Caa2B88o3K256rKbK3DJfiHzmWWEihJ4DFqT6Me2p/VCjmmWIXqha2M7bGv1hT62ICoDCEAAejZB0A1NaA+zB/wAtDVymvrlRhjnnHxlYSjAcHBwMLuBUTrIv7BdykTABJrs1wGju5n5NTpG8YB+uvWJN0YXeFELUASmvlqzHjwycfjwyvv/523CuugfnLtwqS42Y8gW9h0WJnbxcTa4GTUEubH2sWs5x6qAJV5cScmT/gopYG+ZNLgGGg3FrOs5Spo4P9BMi5Z7/DcGvzVCiaedsLnB36oJxYl9JxSq3dUuPmPkUaFEtKYaBDrPNaBDiWekBnEMVDnE77SdShlIOZAKUIlj2UZ9UBSmtMyzSsPB3AeRBeNy7WpzxT1089cYnvclwshzkBY45yA1B2njRlP4RYQEN+0OJsbscpOgGnI/Lcv/8URo0Y1q5YMZAAClZSFSnQkH/lQyI8ZcoWmzlwhsFhXLfpwzuf9wijvybp4hGErS1h7MiPw3sv3ROav3o3fPThB9FjFXp0rUrgq0v3KcLiG/0mNDV3rZlR9N2jRrwTen72UMwX5NUPWfxn8USheo98THLusVuHBeactFhBSEdhjjHBMiYFXErkXGF+sTyUKvYPiAQGgDY/gUvhNUxuXgBHfwMmKHcMZGHD8HLCiGAUjYt5ktcGqFLshWKOsKIcAGEuDJMCBAKUytuT58nQAE4MiWtiMtIJHNUK1gPTlT/JqJQwXNYqdj3PdrknLBHDbj7kx6Xzhgkj7nmBS4a/VDFVRwQAwSL7CQgUE6ANALEPKuU1fvbZ6HDrzU+HG659PHzyyTe5r01NLWHgDFn4951/D6+/8WxcR4AKBpmDCDTnn70S4wncml9h+loFGPOsxtQ1APhyeZrG3XcC+9jV71MU09hjQFY6qtB+AJCks2DyyxWsJLHuRSo4yZ4NcCwm9opIECZP/nC1ApBhKzn2gBfHyJzXkktJzC8gqsrdXgAwRTVEnzibxdaMfYNYkOIAJKaTxYgICadC2o39z0Gmy5ARCinZFYV0QvTWvPFWYKSPsP1rzaSjb40zgoOOakjHpQEoG1KVOJvbcYr1MJWwWb+eWXjlnr9FoEiAvNT/kLfJKGE5hCIZeoCO8aOEEsB87fU3w0sfdg3jewwOoamN3cwDv7YTcJoiuPv4jYdDv9a3w2233hJBlPdhpChH182/sACxorDvXGHmRdbrEADs/cUDYUC/7jHk9/pXs4WJzZMeK1bz2IUQ9t9u5bDVum2gKi/y2IyX76JgS50FTYFjDL1fKIgBo4iFR4FF44/ZUoQiTwv4A5KAVYqZ4QaoKGyGHAMg5F2LCG/K40x5iwAwgwogpjlMjdZTIQLWrRD8CJMxjhwFYXUJ+8LMQAJjUgyklhLfxZBYW9U4EELtGBfg0PNbOwy6Kn/3C5gXy080ZsnwA33+3VliTlXlC/epqC4lwtHAbzmWbvz4ieGvf74j3HrzUwHRX4xrsMfsj8UWHxK22GbBsMEGa7aHogGiaoQzYw4BBikL9eR0JqBoDuXwSkmQX1xKOCrWfGKQq73XySV0HYAHOAFN2FrAq1p2Nwn9SXdyyOVJFuuWYbwBQXou35O0GpFyomhR5woRDjrCHqzlPjnX9qewvTmifwBqzlw6famYAHtC1hyGfIcEoJSOMKeiIBzMFP72rHKW5Vnbj9JOOL/2KECZoh0cP7rF2rMugNOGdFwaIe+GVCVbrL1Y3WFvdmmJufpF5UHxYRN4lem4OiAAYBGWsvkpGOEfLBxWTSL7PvsdGLoMWjlMnHLWdgaxEAQwdH7nTPHpnDXef9kw40xDogeMXeIRY2oAD943thPAomjkJw2ci/fekWTRLLT2njWCU4zfuAkdY3RJa2tLePe9SaskkwgxMsgApRy0Uon3gBnggRWmQLFJFKxqaWMCaKQm7YwzcMCjF1IGVuS2CpkyDCm3Vci5FgE6fKfcLHOUzvjGfGJXzIMXVhLrBbgVY9KwkMAvoMsIY1AwEfK7sHTVFisRYFxYUfV4NcJICbX6HowoRshPz4VVLQWMOE/SBgBqr2oY0WoE4yssyZGQW1sOeAEv5cLdX301Phx28OXh5hufCi0tWqoU3+vJ2XrqybfDwQdcHvr3Hxz3Uy0ADbCw1oxDvWCScEilrcivFiL2s9R9pypl+77eArHOEGBWiFb+JzCp2AbAAfRqBZOEHq10lrn9S//VkkeZxPoiALu9xjmtNX2DLlH5L/qB6ZSqkKIJ5fIo5WCaz3xBToq22LP0l+hMvtrbs6bDMYwNJ5ATm/poGqfUcYHd4WA0Qt6dJw1A2ZCqZP45ZohMWa0S81bCx+H4w3ePQJKSkEvHw8QwqbblaQKb3qvdDqBEaQEYFM+KK60ctt7/9PD0y+9WXdTB8PUZMEvYZI+TwxFHHBlZLAYYuwYYABMUHaVDub/69iehZ69pOniuclNo7jMkAjKAcuaZv6lC7Mg1r7j8sva+loUieR9YACqwZoUMlLH2YrwZ/WRIGRiMmWfntafG50JClC8GMQFUTAI2M50Xbh69MBe1ADhji1FiVFPRhrECdIASDcx9d6nTM5IAunKkhJ7l0GEYfFZeaLHj6UoJZgfYqza3DviRpwUMY3yBFEAb21QN+DEP1p6QZkePBzRf5gpDA2CX68Op64C1XwpQSmU57rfXhuefq35/KRrr2mXKsMA824Ue3b+ds1lKOJQKU6yDQqBQj1hTwpoAD+bL2ALQxYSjar1wVIWWvysxpr5TyJgeAoYU5QC2qdipI4Ktt2+EdjU+LzaHnJ9qK73zAqzZI74DS0nP1FrtTegKJ4C5jmtUAyjpCGOjVVoSz8YZse7NZb6dUBJ2gwPNpgDvdL0wOV3leoVts9iihnSONABlQ6qWrdZZLOyz9QptC6dCk/GkJEe8/VjoOebFaEyxNMBAyl9hlFXE8qoxDdhISeCYhMRgAQg9+88dPhrZXEfroqbw7ifjwuyLrhGZN+BJ4YJQpdAjxSOMw0vNunTO6SWjxowLE1XpOKJx6t4dro5X0PPhe2/HsHMp8EY5A+DAuRByOtEHI8FwAx5YtcKTchg4YVIvIW6GWFgM24nVFdrFAspfYoz9zeeB03RGNPa4Vg8fQ6CoCEDDeAh9SkcQopLfVA2o8VzYEwaUgXYf7gcLYq1VI3Iw5U9Vah+UxLNj17AsxgowwnJXK55XMZPWUp61HKNWSaQLANCetdK53MAMNqZUL8z/3ftyeOSh1yNIrEU4bSM+HR0uu6T6SntATvi1murkWkQo1VgIj0opKMVAcrqwuV50wuQUc8tZAeQ5L1oBWd+An6I96yAd7tBRkUIgjGtNFDvdCaAUBaq2iC/vCGEm3b9iGHtVPmQtjmT6fsDUvjEu1QBK78Xa5tNYFNmwF/RhKUcOgPQZ5AE7xPEEQOmpPEBNbG6tY9KQ0tIAlA2pWmzGbTdcKpx++KZhsXnbziLuUgAsu3wdwppzlmnDb/dZN5x+1PbhlptvjlW7XhQRw5ZvmyG0KcQthCHXDljgnWpOzGiPmIg5rG+imMirb3siequAkRCr8KsebgCXMBFQMNNM5VmxWmTi18VLay8/b4f7d3br2hxOPuYXUTkq/CglFC/GkaIVVk1H0MlVAoLitQoAJfFeDI+KbukGgA5vHvPG+PqbsWOkgXugH5gRRhdWAtKFgattJ0KpA6mcBeNO8TMciQVRFQ4YVzqy0VoEIDCpwCTjIGXCOsK4Vmopkzc+WFLAtpxwcDC1gIjxBMZV3JfrpVfqvs2jE0QwasaxVuMs3C9E6vulKlQSkQDMWKlWPtf967G6T6ECQm+56akwdmzlEDLgjk3ljFRbvFOLYM0VjHFW7OtSVc0KQugYY596F3ammE97I51wZc9xkhXHcIJSdwvABktZTV/KasS17WN5jnRBXpIzYV/XKhwWYFh/XpEXjcprZTs9u2ek35EICSiWA5R0RT7tRacPIJyUy0MGeu1Pc5Dun25wPfsViSDakpjsRsi786QBKBtSswxdaEj485FbhCtP3Slsue7iYdlFZg0LzDlDGLrQLGGjVRcM5x//83Dh77cLay0/bywGSMwBJUcRUaKAD9ascDNLqJZnp42P966x/pahW68BHcptHPbB52GxZdeKRphCw0wKjWEOKDo5OW+/WXvrmWKiIOilF5+P/15zuXlDzx6VmzuXEmDdNbbaYpNodLA65VqEUL4aRcvn897EiCQgUQxQMn4UsM8CjpLwMZF5VgBoMycYDqDK2ElNEIbHfgFbci0Zm3KCrRFuci1FLJhqToN7AvLNt96G6WQMeZSpf10xEXIW9pLbCRwAa8Ae5gLIrOa4Oe8FRoUeS4k8SZXmvkfyvu+SQ2rtCmHXIwycPYGZ59ykIzErifAc4CAtJH/udSkxv6miupi8/dbH4dlnhtXMThbmX/73rraoQykB2IE4TooCoskl5h2DZp44C6XWD6YY6+b9xc6brkcAFFEYThwdg4kVObB+5PUVC20nllIqRWeI69GvGND8flQUA8TVk0cpRC0KAIin5wDuahFzYjykOaR0DyxlKUBpP/hbAtrm0z6Rv13Y1LyYGH/55emUnpTjLGWH5DtZVNvPtyGVpQEoG1K3zDzDNGG/n68U/njYJuHcY7cJpx++WfjlLquH+WaftIUNRSBUgTWjcClPYR5gJx8CLxYmWW+LPTt87COQN2jOpaLCp1ApQ9+tIINhxpb06dHyrZ6WtX9Paxg9YlgEXXLFpujZLWy4yoJ1sz+KoDZdoy1HSP6S6mtjWe5s6VSs5AUo+VxSmEBjHrh4fgAOI4nVA/7NUSmjg1HELMvJUz2poAArhGkDCIWPi7UUodSBCGwNhlN+EyYUK8lAAFbpNB35leZJmB44xi4I5ZVi8RgGoEzYPlVuYqmE6bDRlZhT848ZLRb2FpoT3sfAenbjntquyCkFXrV7wR7XI6p6rUV7wrNXMmzuhxPG0GL6qmkeLoXE+0sByvv/92rd6zOJtfa/e18q+x6OCsdNlKCjOYOVxJoC5KwzoLHYed5pncgrlmfXkbAn0MPBANrsUXmH8pqxn/ZXuee1j7DMHMbOADa+i37l8HmudB42VlRYvB5AaQ/SFek5rTs/a0nXACjtf/seQ8l5LAcoOa90FR3G6cc424epSMj+KyepewSHNaW3cJztB47tTMsuFQbstk2Y4fhfhoEnHRGWufyssNmNl4UrX342fDXx+ynY+jFIA1A25DsR+WKYLcCFcsFQprCJcEypPKIRX0za2LsuaWoKraFbVN7ChBgbRobSB0QoyC5NLWH8Z6993Xqozq9pbg7T9xoVlSRAI6y57fqLhlkGTfOt1IBqZMx7j4WurSMnCfFi+ISLk6EoFAnzwLs8KqE/YR9AkcFMDKXxBNaAKW2ZKHisIZACoAFiqb1TMfE536P3GzAubG4MGSz3hv3xHUCg72FoGXi5nULRQGVe5EEKpwP5mEsAT1gd4MJoAdHAaikgDWR5CXcDEYxHasBc6Rxx44qlLCzMYcjcV1qz8kndV16wQJ4Xc4MNrkeE+M0R5oQRLBd+U7HqvYBztbmbGGTgSci7mHzx+ZgOA0pz/fnnpZtmcxasR3mOgM53IQq1PLtCELna6XSVvACTHCD5dYBgqWKeUmKNAMjWM8fK3gHYzGUt/R6tfQ5oZ7GUmEhACiDD1KV0Dnq2nsIcgNJephNEkOTBik6US8HJC13le7Gbqr2NlyhIOUCZZ1d9TqEefcZB5LyWK0IjwtqcqBT2JvTfkHVWC3s+dW+4b/bpwhSLLxi6DZw2dOnbO7w3emR47MP3wqH33RYWv/Sv4YSH724AyzqkASgb8p1ICkfymrExeocBePIqeegAAeBQaFAnTmztcB5irOxbcKGolHjWDAwPF2DAUjAMXhM/e7lDPSj79Zki3PLP8+KxhZS5XMH5550rzNnn/XgWeS1gde1lZw/jPnwyGsZ0ig0lig1j+PKGIomwFJDDm1dVSXmrngbEKFdg0vgCmBhArKGwsJzFZIgYWCBRuLASSFK8IxSlbY57AdQBHQbHtY2z73Gv8mPlPZViaxgn9+6+sTWYUiAXM4IFBAox1kBjMSMkt5GhwmB4r1ZQekwCM1tusX14/rlhMbT71psfx36Lk4z12mvHVkWMOsGkAbAKHDCy1i02tVA8C+DL2HbkvGig1xgKjWLXilWd+pv1BJTV0hxd/iQgkU6fcq9AluthRx9++JH2IrKOSKlDD4yJtABpE3L7vksB8DiNmDUAzxosFM6OeTb+2LNqBJjiLCpU82z2lpxfgCc14a9F6EGORWqr0xli/QNTgJk9aB7sHw5kubzFYpKKvlJ7LVEP4ePUNLySANj2SjptxzqW/mRPlboXrGTqqUmXuoYUF45Bvk1QOaEHOcuc6djFYrXlQusma4XWadryd5tyJ7WR7Ouz0UZPGB/Oe+6xsPlNl4cRY6s/XaghjcbmDfmOBXCTME25A0rpxBWGm1EG+jBlqRLvxPPuCDfd/VyHTukRip5jUPfw693XjD0YGRkhTq+kEClIHvNsS28buvQeHFrrAAe7b7pE2GmzleK/MZ+a8QJVwrhdu08RBs67Rhg059IhpqtlBUc7AptNzWG6aXqHnTdZJmy02kKxZx5QCHxjpVIBBhDOiPk/ZpeyBhSBTwbJ3/NFD54RC+d6jCvjju2k4IsJJsK1gEPMXDX98QCV1Bw9HYUoDxPriHmrRtybewKA5T/JfxNWxyZjPT2jHDGMG2OGwcwf3ynHkdEEmC+88OJYvXzB3+8K7783qZPSq3ePsP4Gi4b1Nlw0DBo0dTRqWA+hd8YKGJbvxehV09rGc3OSALSO5AeaN+DWHrA23RORT+w+3BsAj2kpJQyn8QIcvLCn2HLH9/k/sJwHLfPNvW6YfrqOn+a0+JKzhpNO+fazc4CsYeBmcpwSVI1gIAF144KJLgb6UtP6cqcNAfocF2uR04KZB64KGfd6RCiWzsN40oOdJdIpsK8YQY4dcGgMqml1lV9TwBwnLzWPl9ZDL1lb9Fu5AwXMv7SX5BhzPumWdMxusTA8J1e0wdo3N6khu/sWgQDeK4m1Tt8bgy/nmz2c8Ehtzcu7qAjvPzBcvf5WoWfX+nPhf0rSYCgb8p0Klk24lLFkPLElhHKmWAA7jIrwD0W28NwzdvjIRyHvO268PDIBjLKcOx6870gJ+QARYPHoLX8Joz8f3taNvQYZOfzx8JtfbNsOUIXAFG9ggjBcE8aNCcOevC48c/Pvwyx9vgiDp+8XujZnoXXihNClaWL44sNXw+8OXC/868+7RTCZQnKAhcIBDIZkdmMi7xTTCoQrzEg9CT0LEFRYQStMJUxNkXsvo1kKTBLMC3bPs/jeagpGzFs6kQjIM8++j3FmcKoRjAVDYW6AQkYHw4J1BB7T0XmACaNrnRjfJIwlIH/H7Y+Fjdc/Jfz++BvChx98m2EYPWpcuPrKh8P2W/8tnHLSzaFv36nitbQXsSaBUtWw1fZJdH/GSTpFtdXuxcS8pjAthwFjal3aGxwxbDowDRgBn8C63ERjYT6Fk4F/DgOHIB13iaHxe0yo9wuHYqYB9qv+eXaHwaQ5X3yJWYsyeYCAkKXIxPcl1hOm1rqWQuHfheI+RSzso/yaIph6RR2AvnQS48pp4pR1Bpgk5q6zWUrCweHkAb5YeLqh1jxK86swh8OWBDh1n4gB6UylxHukueSdSuATeHe9VDSTF2se+OQA0yt5sIqhrFSQk8R8ScO59I7bwu9qBJOkJcvCc59+GE5/ovq2WD91aQDKhnznAijxkoVgU35fUqoMJYVNuQMjQxcYFHpP2bEeka0Tx4cvhj8bFSPvFhsgvAVE5Kv9hFjWWnO1sP4SfUL46oP2k2pKimPoQgh7bbV8uP3ykyPDKVSaWpFosyGRHLDU0F2i+QH77RVuvfKMcP1f9wnhnevDI/88PKw934Tw4t3nhh4tI9rbLiWRmyj3UJ6Ve2bwjJsxYiSEjwAK7BgwlW8CTFRBy7vE+vHuKWehoFTtWEqAKsyb96nOLRfOBcSlLGAVMGHAit9hM4AW+XvC2dW02EnN09OJGgwK8OxesKWYEaFzRt/fhN2lSqSc0mn7zx8WXWinMH5c27yVql5Ov7/91mfCoQddGr74YmRkRIwpMF3r0XyYK3MF+HYk59dccbiMG0ALAAnHAkOJnTHGqupTMYex8N3+rkAqhTo5MsbI3HM0rEchWuCOg4F1mm/+GcNMM3vW+u9Z0dxa60x6/juRDwuMuY/JXYhTSVKvVnveOBWe3ez+OJpAvf0BuHAOpG9guTgb2F4pGFIxqg271iLYd2xqradQVRLpJJ7JHhQRqrcwJw8o7U2OJhCMsS3VpouDJLLg/XmRl8yBLAYonXokWgHkW+tpb9tXtYS8ied+pPWr0Fzn+hOpuuTFp8LYRqFOVdIAlA35XoRSYCiF4YREUnsITArPH4hiBJdbdpmw3MIz1F04oHJ73KcvhYUXWiACLsYBsMOiMSwUThKMEEbw7v/cGVaYu0t4++ELw2fvPls097E5tIT3XronHLPHsmH7jYa2syAMkuvKo8QmYQgAQIwdBo+RFYoRPkqJ5wCEvwvzFhPGThugVB1POQPhwARAJY+PsaDckwB0vht7BtRiJ4BnoBkoAyoqNVTGegkDu36xZskUvHmShwbEeC8Dggn2PBqNM0IYBXmQ8laxrKX6A+bXBoOP/fAMckZTGyAGUeUsoGy83ZsCHL8/6sg2VlKLqWpZN8/wzNPDQvcuC8f/Y/HyYfRaAIsCJGC4XHGF78O8JJCHYeZwYHASyAMWGVHhPs8I3GIdPTeGzOd83nWEYa0j4y80qGIfg7vwwgtH4KD9Uqmej+4F6/nIY/+qO08ZmFx19flCv36TpkVYbwAsdqyW5u+TU6QxWFdYaPu+sPUNUI4hl1KA2aIrgDstnuxZ7K55mFxiH1nvnc1ScirsU+Fpe6raiEGx1kF59s8aszelMHHqrNdCsTe9t9DRtc6tZ7oxDyql9lg3BJg33glQWu90Ry2Acq0N1g/dl1w4so31ysgJ48PNb75c9+d/StIAlA353oQBZQiFMgvPYcZCMYhA2alH7xW6d6l8Ok+hAIItE8aFz95ua6pO8WEPgVhsn1xBwC/PjnkP0HX++eeF9998Nrz6wCVh9EtXhdn7fBSWGBLC/APHhJ5fPBYeu/a34Z2nbw6bbLBmZC4YeQaawZL35/6BRuEgAA7AE7r0jAy83ycmgpIX0gQIyvVypLQxuwwCJlTiujA3EC5ElBLcKXFMF3DMaGL3hL0ZSgaA0RSSN+YpjF5KMMWpWTJln0TIT16aZ/J8WF/sXOHZzIxYOsmGMRA69DvteMqdp4ydSwwpVs09AqSKjABVrBcwbRyAVuN9+y1vVN3PsRCwT9t/gTDjoHmrPjWnmAD6xhSz4r7lD2Jv/B/IA+jNPfApj0/jeayUNen5tLgx1sCyeVapKsfM34y/ZxYqTGeeY73LMX/AaKl2QdjY1BNyhhmbwvgJI2rucGA/9pyiW9h2++Un+b37Ff7Hqqacux+KYOitq7RHsZJJOJoYfykH9hJWjq7gzKWTXSa3iERgRjm/nSnWEcfVevF8AHItYizcV/4IWE6QdY4AQAjIGc/rEv+mi0r14JR3TOg9Ym+7hrVt7XPSAcqUFpUq9WsBlMOm7Baau3cs/7E5NIV/vtLWW7gh5aUBKBvyvQojir2SOK3Ct9BjB5623Gyj8MhNp4asdWLVoLLpa3bylf/9PQx/+9UIphhqgnlgoBkQxiUJtgezwghjMHwGMFti0QXCg3f9M5x54iHh/D/9Jgx/7fGw1ZabR0ADCKokBA4YHWFfhpRiZIiEeRkHwBV4zh85l8Kqwj/YQJ44ZUpRS3gvJrx64NG9+n4ACiARIsX0Ap0+j2GRAwkwJGWe2gYB6Y6dA14Aa4CnXMsUoMfzeAHMGBTOAFCJZTZ35ZgbzI98P+waQI29TM3RAd5SPSYxSYAno5+aeAOsQAoHgREDzHz/AfsfGfr2GVx3PiCmbaEF1q3qXG/ssF6cchGFQoE86wUbCKwzuphO8wFAM5TmSYFWao/k/oWDvdc8MbxCqdgw11JEYZ7kchon864gp1phfIVnCwGldQOgW2cMtbl8/PFHwsef3RkmTBxVNai0D7t17xp+d9KWYdCMU0/yN2sdU63ApJpemd+1GFfOnHEAfKV0SB8wzubKWlP5rT9uAjvflUwuljIBseTEFoK/Wiu9iSgH/QZ0A5X2Q/7YU06mvxWGu5Ok/FORDXqeDuXQi2hYn/SWVl2JodQAnlSbQ0k+/Gp0aOpgm5DWkIX3RjeOZ6xGvjnXqCEN+Z5EWJZxA2x4pcJ2SbBvQokrr3xp2P/gI8Mcy+0Ymrv3jgatWH6cXBl5Ly0TxoSj91w1bHrjMRGwAB4Mef7aFBYFnv8/kAcgJKYLC0e5M4w8dGyqF/YHy0MUSVCa8tuEb4TGkicPwGGnAA2ACsAAxijP1MoFKGXYgDPtSABQRRXAqfdjkvIevvCR3FOK2PcINQGGgJZ8Op/HlBWyAvmTcvwNgwoIAneUtiKfYtWa3gvYAdupuALw8fn0DJXENTyL0BlWE/iSH4UpMl7C956p8J6xntgUeVUMYmI1fB6DjVECCNZY9ZXQ3Dx93Se+KPxqzaYJTz35fARiiln89GIU07+98rmgxouD4mXOgAGf9TzyGTlJteYPynkDyDgqQvny04BMTgenCFitJKnwBIgl9oBQvHVivbk3OWzm0Toz/28NuzpMP92aoW/vmWLucHPzt0P/ad/1H9AnHP/7zcPscwz8FmB1TQANc/1DFY6JueJAAL5CsBwX+yaBYOy/NZuOSPyuhLPLSQLO6IXOlPwJPqmyvRqxb4loQCpWo1PpD63G6C17lX6VYgOAcpLob6RBMUmsr/0kTch30NHGO6XvuL59kJwkOozeqFbGTZwYmpskKHUMVI6tI/LxU5QGQ9mQH4RgC4ADCk5eV6EAHg/cc1sY+9p14a1HrwwD+hRfuvPMPjDssuGC4ckbTwhPPnx3BCsEGAK2kpebJPVypGR57ABAYjIZHfk8QuAUu88yLAow5PPJ6UlGE9vkc9hCDAigIbwJIAtjC/NibgDYFM5PYAwoTI2nKUuMlWtRtJgpTCTlnBgFSlfuIBYLGAAwgEngA2D0KgQxPtvU3C20NnUPY8e1NTcnwvXALqMAsBQ7qg5ISBXr2EWgGwitFkzmxfhh2oBzxsmYSDUAyLFpWjoVirxT8w+I5v/OWJkLYzNubO8OHR9IkHP9+s4Sc/6Ep4Fn44qVVVigoAOwZeyNBSfI7zExnAGg2/rhOBgf951aKFUrQu4+77PJEBtn85Ny/4rtj2KAkmEWOsSGWl9YKYbb+gKSGX9g3FoB2vfZd/fw6BNnhedevCB8+PEzRaMBiyw6SzjmhM3CJZfv/S0wmcAQwJry4H6IYmw4imnP2Y9YZ+OUz58FvoFOrH89Z2B3lKUE+iudMV+rmGs9OVM6gnVbjdjzAGCeoaQfRUOE0on0DmkpCgZFD+xLjGOplkIJUNIpdKAIDlYWcOQwkpRDmQpysJOFaTXlpE/3HpFh7Kj061G6LVJDcpI1pCE/EGlpacm23XbbrHv37tl//vOfou8ZM2ZMtscee8ROjpttvVN2+33PZrfd90J276OvZm8M+6T9fYceemjWs2fP7LHHHovv7dq1a/x51FFHTXK9e++9N/5+8ODB8ecNN9yQ7bXXXllzc3O29957Z88991x22GGHZTPOOGP8+1xzzZUdf/zx2dtvvx0//8QTT8TfX3311dno0aPjfa+wwgpZU1NT/H5/69GjR9alS5f4XL17946/8/fll18+/nvttdeO15pnnnnidyZpbW3Nbrnllmy55ZaL71t44YWzU045JevVq1e29dZbZ/fcc08222yztT/bwQcfHD/v///973/jNYZ98Fl2xiV3Z6vv/Ods6a1OaX9tsNdZ2QXXPpR9+vno+L777rsvm2qqqbKFFlooGz58ePv3X3XVVdn0008f7/uMM87I3nvvvWz22WfP5p577uyTT74Z71rlzTffzOaff/6sX79+2b///e/stttuyxZddNH4HOutt1721FNPTfL+sWPHZiuvvHI2zTTTZC+99NK3rrf2aidmq614Qgdfx2fzzLVqtuKKK2b3339/HAdrsh4ZOXJkHKdll102mzhxYlWfGTZsWDZgwIC4Hop974QJE7Ltttsurp1zzz237LXMzw477JDtvPPOcUwXWWSROMeffvpptuqqq8Y1cs4552Q77bRT1q1bt+zOO+/MZp555rjuvd84jxgxMvvzny7Ipp5q9uyRh1/OPvrwi7Lfaa/5/GmnnZb90MRatsbSnrPOr7zyyva5ueiii+Ie3WSTTeJay+ubJZdcMu5/a/+7EmvcWJ555pmdfm06cNppp83WX3/9rG/fvtnzzz9f1eeWWWaZuP7ycuONN8bxTHvy0UcfjWvrwAMPjPdfbp0a26Qf/bzsssviOvTvF198Mb6H/vH/ESNGZFtuuWXUAZXEnD744IPxORfaYO1s5nP/0KHXrOednB16z61VjdFPXRoMZUN+MMLzFK7FzGBi5KkVCm9W/p/cu9tuvDrst8umYYa+E8IKS8wRZh3cf5K8P2yf4hcsIQ+Xp5zOFE6SGIBUCYv1wkAJESpIwfIoXPEZoUdV3ELgKhexg+4Rgyj/zWd53dgr4WCsh9wgjJNnEkbniXtOTAFGhAi7zTXPAqHHtAuGh9/pFTbe95z42uHwi8Obn/cKV15zU2T1FGFgFTCQGFHXlGOEIRO+wgphzTAQm2+1bdj7t5eGzQ88P1xxy+Nh1JhJ87E+/mxUOPuq+8OG+5wdTjrvjrDU0KUj+4d19Txa9GAfMIqYHN+BpfR97lfRAgYPG1WPCBGrahcmxowKJWNt5a6lsBpWMvUJFYZU+ISx8P7C85k7enxgmzSFZZZZOn6/+8JM18KG5EX6gyp6awFzU0nMqTCfNaoit9j3Yr5dU5so4cVSLKDWMyk/WGGQUK6xxVaqILdmhTyxxMLg9pwwPQYIEyWsqGvA1FP3Dn2nagqfff56WHiRIWHa6fqWvH85uO5LzjHW84ci9jHmC7uM4cWcYdREDaztxEh6XusLG40tTykr9I3P0x90Ur3rvVYRbcD00TWdzVJqCUZ/iHBII7HPqzk9p7B1EBFBSb2F07XlicstNvbSWIqJ8RQdIRhgzDk9q9CQHk0h9pSbjaUUISpVkCPtR7SDzqD37V+5sG/f+2CY8MHHIetA9EKF+LbzVdeT9qcuDUDZkB+UyOsS7pWwDTiUqkYUEhKGoswYSfmE+SRzYULhUCBQeIfB08NRSEVlsJAfSQZCyJuo/Bbi9RmFLUkYHuEbxp5ySyfUAJ2MtTCaXCxhRcpQP0OGGQAFAhlw+ZWu6VoML+PWbYq+YfahW4VpFt4+9By0ZOjaa7rw4acj4+vVtz8Ol974aNjswPPDdQ9+EnpPMzg+L2DhekLFxkGYSf4p8ADsjR6XhSHL7ByeeKmtyXapULDxkjt4/X+eCfudcHWYdfY5Y36oMWIoAF5G1nV9RxJzI5xF+VPgtZ6BnETemlCuoiQv4WTV4NIThPSBaOE/4WNAGaBWVWrOGMF8+6E+fcqf7VutDB/+Vpxf99XRM+StM61P5OF5pnLiPZwP4WzAr5QAmta19SVXUWFV/j6NGWNKFAUBAICePDSOgf1lXgF1n5XrCVgZ42SYgVvpBSQVhpQ7nYfI93Nes7C/9fl9izXJMdTaRt4ggK/gRrGbtVMsr5WDJATsPVJZOFeEY5GawXe0z2gtooDLWswXunSGAH2pu4R1zvG171LrtmpbBxH6iF50nSRSl6xha6bUKVscfroUYKQHrGfja39LN0lAnwNLjEO+qTmwar0Br9a1lmwplch8WedJjy3dZYq2Ks06K7wXHDAwvhpSWRqAsiE/OAHuKBbKiudaynvmMVP+PFzeLnCDaUmCaWBM0uk1GEKKBiDB7gGPhYAytY1hYEsVU3ivpuuMNGZN3hgjipmh5LBriVnLCyWrQluRjoKeTbbaMSy45oFhwCyLhabmLrFCufA7ExZ88Kk3wkdd5g89p5419nkE8oyN3FPgF1vFCN56+12hddrlQ5fufWroxRjCc6++H/Y95tKw6aabReVNkWNpip1hTYB4uZwMrVy8eo2scQOQtMTBsgJBDAHDLf9QHhnWUg6qnDbGB5gF0DA4CcyusNLcoblLx1jKlpYJ4c23n4z/NkeMnfvBdAB7lQxuMcFOu3frpVSbJOyOVkgYI+xwJbFGjIuXAh6gFXuD4VTA5Xs4AAw2xtzYcs4w1xhToIBzZc8YU2ySOcfS23PWVyq8MBfY4XKFRdhi1+FcVXP/k1M8O9ZVxbb1YRw4SYC2/VGpQMr4yYO29hSXpJY1QBgnEguW8rInt9BvdFpn51ICXF50lUgBp5FeEoEot4/dD5BdqI8B9HzbMmDPuuH8cBQLr6nI0r6w3kV6fM5Y0yn2Wf6EqsRQ6hGMeeeUc3b8nrNO7/m3IjCOLgeKo2lf0LGY2OuOOSm0fv5FyOpwfOVf/mKx5Wr+3E9VGoCyIT9IEbZIodVCNiovQoRYEaAD0FB5mA+VM5YJCDAUQjC8XEaSEksMaCowASgpQiGwakQIBpPAqKdQFZZDqJwRYswptfz9YqH22vfg8PbYIaFbj16hqYqwagSbzV3CnMtvH8aG3tETB2CBZWBBMQjlfO5V94Qevaep6pp5wWK++NaIkE05OIJ0gFiIELAqdXIHwG7sAUKAqCPCmGE5hNpVJjMgwA12F/A3vsYSeMY0qUj3fkVcDNYGGy0WWlvqZ46A0fET3w5jx46K6wKzBdQqjDK/WBCAiyOCTTTHmOxKYr717xRiFdIrFEw5sCmcWm3FbRKsDhDuZVyAJt+l56iiE+CKQcdeuzbgal6xUdaMeQOYsDyAFgcisZMJeCVAWU5SJTuA8H0JwCW0D1QAtiIA9oh5whTXIvYtEGrufdb6I0AL5xF4TiHeyS2+D9gHwjpTPGM6Mcd+k0YkymNNVGodVBj2pgeAyHT6llQWrCcWkq7TFi6J+cCYc9hFJDg8QKr1Y43S85xGJ9Nc/fKzYeMbLg2D/3xc+PVX74UZ/3xsuGlw3/BINjZsu+suMZWEjnJNhYV0v8iN++O8A6bmcYG55gpjz78qZOPG1wwqjxy6clht5tlr+sxPWRqAsiE/WBFikdMEIArtlmtaTdkLgQOGPF0hU0ADeFQxS+SVYSwZd0pOOCadAJMqERlVRkQIpVrxPcK/6T4YaV6/7xaWxAak1kHJc2/pv3jo3rN3BInVSgSVoTn0GLxy+P2JJ8X7TGwo5b3OuuuHl99TwV31JQufJCy60uZx/IA5OXhAlSboQqPF2AtMF6MHVBSePFKrAPuJ6XAPqbJWaB+jwbAD+p5V1b1QrdxVgGrmWQaEhRaZue5cSmD05FMPjIbReOpBCLClHp+YE2PAAApBulf5hlpAMZDWE7a62BjJ3wNCALe0Toi14BmE8rFqtbYXsjcAAOFBTK1QNyDJyZBa4d+uyyHQ1gVId9/SCDhg2GHP6Hs9d1yXLS2RFcvfYzlAKe8WcwcslwvVTy6xXzHIKvM5JfYEZsr+AzDqFQyntWhMXDNFOdIxhsYotQ2bnALECeV2NktpTQKUab0C4Zw20YZSxyimvpGFgDKxhQlkc+z9ztqyX+1VjpPTnbSIswY5+tad/ZSYTQ5xaGoK//zo7TDfeX8Mh9x3W3hl1OehuWeP6CA39+gRus84ffhqxSXCNTP3Dcc+cnd44tlnog7HXlrT5o3uoLdS+N2+HPvu++GD358ZWr4YGUMyWYnet6RLU1NsP/e75dYIuy24ZCeN+E9DmlTmfN830ZCGlBMeKJYSsOFJlzO8lC4Qh60A7njdgCOAiHHAQMqVAg622mrrsMRSS4ePP/oorLvuWuHGrxUiYwR4Viu8cOFGITV5SYBPyjmTk0bRYdSEmICHDTfbLrw8smNnAS8y4/jw1P03RICS8tz6z7JomHOZb8BAvXLRiduFOWdpA9TUAzCXQBxDUHg0ofcwSMKB5kreUkcEI2OOhLVdM388JmGcFD0BcVhDgM8cLL7YSmG/vS8M48dNrDEEn4V33n0gLLP8gAgO3T+mRFpB4Xen5wU6AQ6Ayk9FS4TzAIAIL/spHwxww5IzugAbQw6kAUDWJ0anFvAjHIvNYbitOcwtZ8l6B3ABccx5egb3Ye27J/tD2FsEwE8haqy6NYvZBDZT3z9inBXtAKOFgs0EXDlxnqHeAqZ6BDssZxlLZf6xqgBMKuboLBFilVoifw8Dh6lOTqfvlY9q3CanSFEwL55ViktniOgPltq1E1C0NulZc8mBsi4KRQqBFCM6IS/0KaeCvtPyx/hgVTGV/s/5soasS05aighhz61jAPC8f/wjfLH60mGKReavyrnyjgUHTB8uWWfz0Ld7jzg+HFvEg7UupUNOuxQlqU305NwLLhC+mm2mMHbhuUO3QQO/PgDja3DZ3Bx6d+setpp7obDtvIuEWftN2rC/IZWlASgb8v9CsCCaDmMIgJtKIr+PMmE4/TvlCK240sqh14DZw4iJ04TmKQe2s3lO1Rkx/Pnw2TuPheGvPVkyd7BQhGt4xRSo+6I8fR9PvFCADsDypgeGh17TL1ATO5kX3vO8s08fzjtum6g8JbMDytc/+FEIUwyqOdydly7NTWGnny0ddtls0lw4rBwFDWgDcoW95YALxghIEWYCpDoiwJBQMFZXKFXou9DIYI2En9ORcnLbVl1l03Dkr64OEye2VN2X8pMRz4VNt5gvnHji79uZLqFiYVNjW41xw7IwxAlgch6ASIYTCLE+5KW6tmexTgBAjg8QW43oeYmNwTZigOSPyfFM9ycVQAgQ2ygPkqH2PEAkUPTyy2+FI484M7RM7Ba++mp8uPnm68O48Z+GJ566LbS0jIvXwWYCDEkwq9ZzsZxg3y9s6VnzBWyTUwAWjDRmGkCwx91DZLcmI3gV1k1npgPxUmU4CECXMGu1+qJesRfMr3kQPeiMcQSEFS6lJuIESMZ00ytAJQc4LzpbYKKtifj+cWPDC59+FJ559eVw4H77hyMPPCgcuese4bprr41RGcLJxEqKNHB86A5j5veuA3TaJ/132Tpk889Rk/7CJs7bZ+rw1gl/Ci8882x01JAOBAEhSoS9TEdAigiIpKyz7rrhuL+fE57/9KNw7a23hPvvvieMev+D8OL1t4ZZZpyxw+P7U5UGoGzI/xvhBQuv8nwZkmqYHApE+BLYOOaU88OQxTYO3afoGwFkIaBLv5tp+qnCr3ZbMyw2X+UjvigtoMd3YKfk2PH0gapigt1adcczwtjxHT954Z+n7xJmHDhV/D6syYEnXhdeeuuTDl1TxHiBIb3CWktMF5VzejECwKIQkvxCuXpY3/Q3rKWCKM+PYfTeWs7cLSaAkfxFIMp8A1/Fqo2dKsN4MYaAzWGHHh9uufHt8O6wEfFIRZXsxeahNZsYJrS8Fr4c9XQsLBEexm6nalJsM9BUa24jAeIwhQlgeqVcMd9tvITmMKv5Cvpi4v0MLyAqHxcL45WvoPUeQEvY0ncArAAIQLDZpruGN14bH6btP1/8W5PTblpaQ0uLo0yFyyeEMWPfCK+98d/w1tsvtBeoEdfDZlnfeWGksWacPAzp5BYtjoS2U4QCCHdvqQp4cgswL/dUji8QBsibU0U8wB6mudaUhVqELjPe1mNnsZScjVR0lhegFVi2l7Cy+T3H0ZJjffGdt4eLX3gyXPvaC2F866R5iRM//Swcvtp6YdsFFgtTNDXHKnDglNMpRYeTBrB6HjpT7u+/Xnw67H9vdU3WCwXD+Pm1t4WFR02MupjTzsmgp6RLcYClKHgOTKi8b3s6td3SVSQRAOb0+y4s+/8sDUDZkP83wmgqRJEfiSkodUZsoWFniK+545kwZLGN2k6MqaD4/Vn47tj91gurDm1LRC8mQjc8dkYu9VQTLnesIjBRjLXRD3KNXUonvtciHzx1Rfh42IvR2JH5V9s39Jl2SIeu2do6MXz8+iPhzcf/VdPnACTgktJOvTYBSsxDHpgWgtRq/saAYUgVOmGoMSSF7zcGcgYBLszgOuusG3bZ+eDw3DOfh/vuEY7+Zs6nn75feODhq8Kwdx8J0043dWRIgCgATf4YpjmfD1prCkTxcW2N7AyQBwjlWy1h1/Jhcs+ZwsdYWKwmows0M4IKcPLieRU5CE1b21hFThcGaoF51w+fftwvrulyWQDO8Paeo4/bLKyw4jfHkUpzwLzmcz8JdhWQ90yph+vkEPlvnEHPhpkDpoRJ0ykr36UYZzmBAIj1CEynyIlUkM4CeqUEcywSIT2hM1hKIIojZR4LxXoDBAFIbHCSE/94Sjj9zedDj0Xmi+ygHo3fkq91bJfQFLIb7gxv3tjWOcOatq/ltNtPAG1KF1r3inPDs59/Gpq61B5dodP7NXUJT+x4QDjy17+O6wWLjAUVBk/H7Uo9kVoC0NLbcpAJx1GUiQCj1RZkNuTb0gCUDfl/JQwxRYg1wRak49PKyW33vRCO+eutdYV//3TEZmHx+b/NtMnJEdbFkFC+CQDwvLWJobAwXoXy6eejw/p7tYVkOipLzPRVmG2GXrEq0uvmRz8LLw/7pm1SPYLR23KthcPP11skhhS9gPL0by9J+UALRZ56zuX/jr0CaBh9oN+c5f9eeL1yf+toirdQZHNz19C925Rh/ISWMHDgNGHgwP6xzU5qlWPssJJAsX9jteWWWV+ppyIQI7xZDyBuu4e29YFpTVWv8v6EolMuJtBm/bgnRRNAMmbHesICCmcXC11yYIBuwBPblPI5N9n44DBoYO0tT3573KZh+RXnbr9foNb1kwDd7lt+q9Y8k0OsMYUoxkqoFAgHmicneK1GrGX3gZFM7DWHFXARwuXUTG6W0hxbjx0VwAu4E9IvzIsmnpGjjNEDLMdMGB/WvvTs8Nb4MVWFpZPzPsPTr4Zj1t80sv5YeUwv3Witiz4c97e/hEHHHdLh51nkpXfDDX88I7KR1iYWP99ZwTO6H7mjHDvOJ0fSfSTHV4RC3nBD6pMGoGzI/zsB5njPPEvGuFjyeJLRX40P6+/1tzB2XO0hZozNwP59wzV/2vVb1cNO4KHYhVQo+UJFLVTLCDP47jO9Xn7ltTDT8p3DZMihnH+Ob0J+51zxn/CP65+YhI2rR8749WZhyQXK56QBjQCOUKT8pNRMOwlWS3GL4hohwnoKNhgkyj4BTUAJCGMAjT0mrxCEeo+CAXOiQhb4wUAqChAST0UowKT7Ti1U5GyaH0wiwyIUp4igVO/IWgVzawzcI4Dk30LgCiIAb98JvLoP4Nb9uRfCCMqZxGRiJz0XEG9tKUzBnAH4cvwwWJ7run/9LzzxaH1rnuE978LdwuDB00S2xv0kFstYK/wBDhTvdHaYV+U0kCHEL/9Z6FIngXrOjZ9cYl0ab7m9UnAAEOu8XDFLZwk2lDPdGSwlh8keVfwm57aYYF2lmlhXl7d8Ee565/VQuj66uFgh563xs7D6LHO0M7pC7dJidMTou8HqYar112jLt6lXWrMw5pGnwo5TzxhTP6zbxNgnsee86GUOWz7XXXhcARaHAEvZkPqkASgb8v9SGGPhQeCSIi+VS3XNv58Kf/zHXaEjPNdpv9o0LL3wN6FkIROhE6ARQ4fNyoNGjI73JMFQAQFAjtdD704VRn2VtVnvOqVb1+Zw81l7hSl7dovKHptw6+13hkU2ODI0dyl/qkkpcTuDpusXrj5tl6qAAmAnDKsoQ+hKUU5eVBhjz4ScSh0TWM+8uyZHgsEoFp7Sn1J1NmMInABjQBcwtOKKK8Z0CbmF/o0VlJoAMAGQgIHfqRbWroVzIBQNmPoM0AYQVsOu5l8AgF6dWG2srfdi34Bd9wo8Mq5aqxhX+alArfXt/9hK/672VKLFF94j9Os7uOrm9oXh76xpWOg+xdsR4PlODhzQ6/+q1OUOO9K03jSG/AvYdk050hrlA84qtoV4C4u/fkgCULpPaQGYPuvEWAEshcUsnc1SKsxKodx6xbpyn/Kh08lIhcKhU1Dz5Mfvhyn3Kf6eSkKTTN9jirDxe6PDv665JuoLAszS4We89kzos8JQIaEOPc9ME0N48uDfxugQ3ZM/scn+4ijJDQX65RgD0Sm1BdMuRE5PixY0pD5pAMqG/L8VzAnGSa4YQCBcWcgkbHXwP8Kw9z+rG1Aq1Jl/9gHh9weuH8Gi4gR5fPIEsUSqPVNYNrVd8QIoAU3ABzihzLxPC6Ffn/SPMN08a9bN7vjYyosPCVOMeSHmchkHHrbw1MetM4V/P/BKaKnj7FrXPXD7VcIWa1dfsQsYCTEBaXJbC4ulMGjyXjGKqfl7RwU4FIITNlPlrb9jIQOKVWHoGV4hSXlgHADADNvFEeCEYEtSPqyCIoYHWMKkpJZEDI2X8Jk1BnDm8xhHjRwbXnh+eBg58qs4p/2mmjIsuOBMoXuPNoNmrWBEGDjGLBXTKH4wbwAyUKXCGvunt6Rm08XEXGPHhfTcH0BqXQEGAIIUkNdefT8sNF9bH756pampJfTt/2y4//57I0iSY2YsAErf5bsLQXS5PrHViDk0N66dB5/1gNR6/+b3tRwdyZGzFvXJxVYClRhvxSylrtN25GlLZL+9jFv6dzUva5rjkXo51vLZwpc8QnqMzir2d/NqXU1Yf5Uw5RILhaYiofFq5cOTzwrjXmlrEp+XabbfLPRadvEOXZu0vDksDLnniej8FR75aP9yijDesUDzmGOikyvszeGPoffjjotrT3SgIfXJ93/oakMaUqco+pC3xPgKoVDi+fYdwz74LLzz/mcdGl9V38+/8WmYfoZBbVXgX1fpMhzAbAKQwlz5QgGGFxuVQuIUl9wrCf2rrr5WGJ21hNBU3/aDX8844YAwccwnkUUDJBkx9/b+x1+E/z35Viz+qa0VY2sYPP00Yf2VF6jpXhhgoSNsoApKyhjIS2AZqJOvKDcJo6WYo6NijrGTxhxDBLgDgPkQoLFW0AFMEoDIejFOQIswpTC4HCpAwrnWKRcWUHUknd8RQJKREub1PJgNrYpmHbJQuOG6x8Od/34uTJgwKXPYq1ePsN4Gi4b1NlgkHHrYfpH9xMLlDR0mbr311oshNvcE9JrLUkCEcXdPwKSQq9A+sIoR8zvX8e85Z1svtLa2xArueiXLuoTddz0yjB59aDwHW5N7zCpwwakqFoIGkoD9SmwtplX/RuuGk6bKXRGFOUqfL8b++pyf7sHP9B1+ps/56QUMpZSBesQcWAscwRQqTa9YKf/1ixgfTJcxsh/k5/mdf7uH9DI+6dUZoro8ifvilNT6sv45CtZl+p3xlMpCZ0ltaZ2iR5ixg2BSSHq5A/YMa3zZEnUiljK1omod85VWsB0SOrlHSxajE8XOD+dgktSnVFTAXuJIygfWIiytKWknpc4gb0h5aQDKhvy/FowOdoxSwDY5vzixVZ+PbDunu6MibNirz9ThuN/+OrIQFDnmrdJ9aSmimAIAAhQwEViw/9x5exi69uAQpmqrLKy1RcaEkcPDDP2nCK99Ni4yVq6fjNsM0/YL+26+aDjhvHtDc5euEHHFa0pdGvvVyPDpC/eGpqz2IgtGF6smRGt8GKF0ggvh/QNUwmry4oxBR8XzSrqXgyjsbayFS10/CSAIuGCvNfZmPBlzc6KYgkEBwoAy75FTJlxGAE73j9XEbgjnA7GAxp577h1+sf+5YYaBi5ZsSzR69Ljwz6seDldd8VB44+0PInubz63zfYpoOB6ANsCB6S0FJlXjYjIZYmucI0EwpvK+7r333ni/nJplll49vDusrfK/XrGF7rrzwegMCPErAuGwyWfEitfDhgF6gIrwvxZTQCmml/GWT+cZSn22o+xnMTFextvP9KoEHgtBjFcCn4CZ/wOSgIl/+71778j9u4Y97pWYVN8FYNMzxq9eRlcerKgJplxUxTzQKZ6J82Wd9V9miXD6+692bLCbm8LLE8aE/xze5qQRz2NuW94eHpq6doydbMpC2GO9DYumGlhzdEO8ja9tA2dflbnQONshHzuJ9QlgNqR2aYS8G/KjEOwA9gsTls6VfvLFd8Pex17ZKdfv/uEd4f5774wKi2ddGF4vJnLkUo6fnJ0UHgd0dt5ll/Dr028K9z3+Wg1FNFkYOM2U4eI/7Bx6T9kjsmRAlYpYIFfIhlEU9px64JAwy5Jbh49GjI4FRcWafKtiFxqfd7aB4WfLDQxbbb5xZF4p33oT/oVtgQ65iFiblAMHTMjFwtLJUepMhe2aAB8DqSAlf20tnfQsBLQwi3ITscRJsEmpMhfAYVyxhomJ9m8sOMbJmJx33vnh4gueDSM+0Wan+pyvDTZeLOx/4FoRbAu7+R7zhJUEgt0z1kQ+W6EAnZ4PSOE8FXY2AFaE74FmgPPsvzwRXnv1w9DR9lHvffB4ePm1Sc+sBjQAgVpYMJ9RQGTfCNGbAwAGY1zrtTrr5Z46u6BIeov1oirf8wH+nBFnw+cLzKrNvS3H8ooEYNLlBMr7q+d61YpwdP+dOh5ZwFLuP6pLWG7Z5SKAs18V8z3z3HNh4O8PC136ftP/tFbp2tQUHv353mGant9mFulFHQMAcE6hU70IW0FH2ZNp/xsj+o/+akjt0gCUDfnRCOYJk5J6j732zsdhu8M6p2JvxVk+DX846fdRCaqyrMSyeY9cPN4xZgwjg6EDdtM54U5z2WiX48KI8X1Kgj4SjwfjVc89KJx8yM9C397fFCrw8LXowbZh2gBdXjhmTpj+/ideD/+8/cnw2PPDJrmm71tlqTnDpmsuGhaZZ8ZoXIV8gT4pBIBLvaASqNN6B8NBOSfWAKuiEEZhDSakUkPvWgSTJiTrWEah1NRiR09J42NczIV7EubKCyBnvBTFEKCaATIOKj8V9QDqindGfj44zDiDYxJrByNzztMULr70hGi4FHRYD4kxASQVoRj3dMIIEcJTMICJNZb5ZvFAinsG4OXCYaswfp9+OHPo0X360BHBvK67wYLhHxf+On4Pp0WxGbBUrVibQvHG0ucxQdIhSuWH/hhEOJeDgtWVm6hPJ5CPDSMfjhkVrn7lufDqZ5+EURPGhym7dgsz9ekXNptrgTBbv2lq+i76xbxj1CqFaDl0HDksMwdJ2gJQLbdXmgR9KU2kWMrBbcPfDNe0fBk6Kt2am8NrOx88ye+kPHD0+q6/eui3/mpt1HiN4hMbzzFfOG3l9b71NyDe2JsTzq5Xyps2Htaiok7Alm5QdEdH13OYQUPa5qIhDflRiDw+xRaUgarjIYOmCVP17WAD4CwLX33+XgSTQBfFLblbkQlvtlAwMHIJ9TpLoWhgUmglnS6TpGvXLmGhQePDC/85Kwyepq3zdAyjxZMnvgGXC80zYzj+gPXDX47cYhIwSbAtDAHFLOQMALkvQMR1VlpyzvDnI7cI1525Wzjr6C3DqYdtEs45Zutw09/2DMcfsEFYdF6VwG3gCEhmoJzyo/FwseerRgA74WPtSCjsdA60hHfGzPcBrgBmZ4n8RgYCYMUSpZQErDCQ5XsZFw3nMRV5MX6AGdCGWfL3dB2/Z2jM2+uvvx9mnGGJutsyvfj82LDrLrtHcAU85guJgEssJHCIzbMOFA8Al+aFkyQkDCBrBK3LAJAsXJ4aNAPqAMDA6ft2pIFAFCH4WWedPhYxpSMuqwWT1o3ehfLVGG+AAajiZP2YwSSxfqxD8yCHl/NgXv/35qthr7uuD0tfflb44+P/Cze+8VK4853Xw01vvhzOeuaRsMrV54etb74ytuWpVsyJIz/TUYOFYt9xpuxlDL2qaowchhtLb50BU9hC8wx4WZN0iVQQRXTSLP52yqQn6dQrU/X4ti5OvV1H/veB0PLlqJAVSR+plALUtak57L1w8X7EALRxsK9InpUGIhVS0s1ElIDOLnbMaEOqkwZD2ZAflTCEwr9YKgbstU+6hwuue7jqc52LSe+xL4aH7rwyFngIr7oucMLDp5QYfGGtVH0s3w27x7AKb/J4VebKL8wLxsy9CouRhRcbGka29A6LLr50WGfd9SJ4XGL+mcOsg8ufCgJ8COvKbVOc4noMglAYUMKg1RLeAwaBKc9F2dbbuoVhwhTKW9TaKPW6w45gAR3DBugxKJ0lvss86UXHwVCRjQllSLGmDCkjyeFIgM6aYdgAcqDN8zO25gv4Y3AZpYXm3yR06zJbXa14khx86LphnfUW+dbvFQJgigBILKS1k3oN5gGwewTUzC1HJYXO5b8B6Nbkc88OCwfue3HoiHTr1iVc+a/9wvTTD4jzD1hXmiegRK6oKmSOjRQUxUOY05+aWC9YMaHp5sUWCL22XD90aW4ufrLM15JOntlzoaXCYUuuGJqr2LO6KnAeMfOcSwAxsZBSJTDrdBQHjpML8NIF1pu/ixRwVlLf08JcTwBr1jnnDOP3+Xlo6VZ/yYVn23H+xcJvlm7LUSZCzcBuaiPUc+YZw4BD9ghdp+hZVa/LGLlpbQ1fnn1p+OcfTouAuVA8t70sHcGzSBPIn1XP+ReZsc+RBIr8EAbGryG1S4OhbMiPSoAEeTLAkFDmnDN07VAFYcuEseGuGy6Migk7RHkz3Pqnxb+3tEQ2TJWq9wCJwACDD3xqT4F9UmUYE9BbWiIgpUgBh9QwWgj00YfuC+88f09YbYkZwy6bLhM2X2vRimCSAI0MuRYmkuiBSm1FAKnEcCWlXY0oTBG2pmhVz9eSb5UX1e0MnJC38aLUSaqS9jcMVkeqcQuFAWUgjbd5MQepRykGEiPhvF9Mdn7NAOSMq3uTc6XhMYYVwwMcjRw5OnTvOqRDYBI+uOKy++PYalniOxlB7Comy7+lLQDcwKQx44gAjeYT+80ImxcspecwfqrVvRdQiEfZbb1OGDX6g7pPGRLuXm2NBcKNN14bwSwgUg5M2g96SKpal9Pr/ZwJIP6nCCaJvcc5mWGd1UKvrTaIKqgcmAy5v2Msf//It49DLBX2xlJyKoTY7XWREOkZ1oJKbU6UIhROJkfO+6w3nxHNUYTDGbaOFLdhPuk5DCtd9tJzz4XdFl82gsJ6xbNtO2+bI2VdukeMd9JLwN7Yd4aHPlffHgb2asulLAWogUjRnN7deoSL1tw0LD3djNEBds95AbLpWk5+2guFjjU9rLenPcdxpJ+lKTSkPmkAyob86IRyokQBiG22+FlYb8W2VhH1yNtP3Ry6dmmKjCdwpfBB2BsLyHDKvUunnKTWHUKR+g1iA7ADvH4MD8aGEvU5gEHOZwrNKszAaqSjG6sVp9DwqlUjp2TzVASk4ARbweBI3ldFzEhUI8ANBS3fsCOgMrF+DBrQnaothT4VLQFL7r+zBVgDWgEi38FoKqwBXvXvw0aoRE+CtQBGsaae2T2bUwyQuZp6qsEdborBpg1/94uw0UY/i+wnACsUyeHgBDCygAhG0Bqy5rzPunFfcnEJZokhBPwBZykK3i9kB2gCqJtvObTuohNjtNoac8eiBWs7nXNcKInFBSSBcN/NOHPoUnuWn7J83NQaxqwytP1s61rknGcfDbe8+W1gQz8IqQN91oTWZUAQAI+Rp/c4voCgn1Ii5ABLQ+FoWXP+Zq0oGBTVUDxE7HfsvHZU3m9e033/fN6FQ2udDgpguNygmWOOKF2EAbTfONip9RFAqyXXi/fdH7b8ZHw4baV1Q99RJbp0fPp56PO/J8JDW+8ZVhoyR8w7BijpKSC6fQzPOSfuC+sySeE82EP0gkhMKuaTj91ZrZ1+atIAlA35UQrjK7eMcb74T4eGFRf75qSbamXmfl+Fz95pY7iAVGFbShyI5PFiIRNYZIQZYOHu1KtP2NXn0tnNlJawIGCH0fET4CLYp5S7Uy2gBHooZoYBE1oo6dxaieaYNsZCaBc75x4rSQKAWosIE9cLKhUoYAoYKUqfoifO9GXkpASodu5sSa1AzBFALccQA6hdj/wwBVwJ4GJnGB7gDPjNj6e1tNxyK3XafT311PPxPswL0GgtyC+VyylXkzMi1C3vq5Bl5HSYU3mhnAnMttA3IGHd+Kxw3dPP/jsMf//RuljKAw5aO/z9H3+KazW1l8mL9S6tAOCwxoFubBCA7ncNaZMLnn+iLZe1DmAPhJ39TBt7hyHnbHAsMOycMXvIv1UjYyOBM+vIngLMACvgXnTAPuZwplQOa49TgrHEcPoM5wmbX0pm7jNVOHTJFWt+Dmxiy1djw07TzxaBn/VBn1ir0jRSfjWhC4Diw395aDhnv4PDcwf9Nuye9Ql/XW3DsN3UM4YR510evjj13DDktgfC8xddGV58+un4OevT82ou78WhAVD9BFgRAKUYSvZBZIlu5sx5L32RKr8bUps0AGVDfrTCMwcCKdH7rjs1bL7WwvH3hedyF4o/b77aXOFf5x8TFTFwSPGmY/CwAlggCpBgmbCT2Ejernykf/3rXxEoAX3YGvl7RDEFBkxeIxADhBJAIOU85St5SwlGQkhfqBPLUI4BSUybBuBCqFgtCh1TR/GWE3lgmD6MLMNTL6ikuDGFQJOenAAbJQ/UGQM/hXA7UxTkENdVcIARxs4wGOYGy8cAcRCIe8NkMjCML3CZZOjQJTvtvmaeaXB7/qYxUAXtXgDFxOYCDELjmMt8aNl7fJYToVhIdb//SyfwfsCZ4b744ovCxyP+F5Zfsa26uBKw7NJFr8UQ9j1gzTBocFsjaCcQASoJUBpPYMVYclCAcoy3nMlSR5/+VOWLcWPDv157oWKYu5RgA5/6+P2wyFqrRz0mtQEQ46ACPXSaCIS9KR0inRWvI4A1wzm1twEj7zOXwtn5wxfye9OaKwcoyV4LLRXW7jddLQ8RsnHjQ7erbw3rLb1cXONyN6VF0F+cKc8EGBMOH31LXzlIQIeAX++2Zxjw0efhtO13CytPO2P47e57hwfuvz864vlewD7juYW36Tq5kcL9dA0pBSiJ+zKGmMnUK1ZUoiG1SwNQNuRHLcAcpvLpp54K9153Zjj/uK3DAnPMULZOd8DUvaPHO/c880XlJ9+IgaW8Ux4khU6BAymUNnAn727o0KERbGILhFMUWvDE5ZMxxBgoXjlwJ+8Ry0koTwYaoMQgAgUUbDHBWAAWlCqwlD8dqJwAuxp2+26Mo++TM4jdKgc4gEpMHsPkGSuB0FLi2YyXRueAEOVvLOWAYl8wtp15jm4ClBgcABHYIowrwyLUJzUAuGdAtFBJrUMKWcrVV+8chlJ+Yu+vK/WBW+FuIF940ppLJ9BgnrAr2rmkHDdrDFBIbDi2HEjAWHFyCFBgjoDAxx9/LExofT689Oo1YeYhqeFza/tc+5ns6xJLzhb++Kdtw4YbLxbTBYT/MLkcCEBWOoUUEvfoXt2TMLd8vIZ8W254/cUwIXZrqF+ylpbwzoA+7XMlXCzlhiMqbGwe7BcgTVGJNW1NWDcY7MLjSMuJdV8pz5reumavg8MXl18fmse2OZbFviHlWk54+93w8Yl/De898kTUm0QkQh9eL/tQqo+8TmJti2JY3wAiRw/wFM62T609rD3WldPNQaWHk3heIJP+xL467Sqla5QDlBxIgJzONX7pXhpSuzQAZUN+9AJIaHx+x90PhT1/c1F47rX3y9bpfDRiVGjqv3CYd9W9wqiv2qoesYcqtinvJJQTdgm7RhkDR5QgkCAsqOcZgOl9wJQzrSlBgJBx5kkDlQSYwl5iECi21OpDHqYwEODI4xaGpHQZevmRwsm1CjYJAwbo8sgBEEpdkUwp0UPQfWF8OwIqjYXKX9WWQlKJ9cQuYHgBqRdffDF0hmDPsB8YHSFkeWcEEML4mBNOgjwrRuX/2jsP8KiqrgvvSSGhBBK69I4IUkRAKTZUEBAUrNhQf8snVsSun1g/C4IKFoqKgqiggIgINqrSizQFAwhI7xACaTP/8554wmWYSWbmBoSwl899gsnMreees87aa++zc+dOo1JyjQxcqCeW4DZrXl8yMrEJRJ7hxXKI23cul/+98rIpXwQZhMzTJiCv/gSAcDLnxrnyfEjGgYSiSvPsUHj4SYkjgLoJuUSBxWaBmv7666/JnXd3kQcfbiVzF74jWbJB0jM2ScNGlSUjc5MUT9ojIz6/R1569Vpp2KiKUbtpw0ygaPMM7kxCsCwQXoekQ4AJ0SuCY+2+3RITQU1FJ1jqMKlGNUMQeT/oU3jvUNJQ8GgztAvaNuSJdsLkjD4iXEAoicQE+y7vKO8q7c87b4mMbtVRdgwaIVVj4o9M1klLl+glK2Xw2RfJrjcGS9qmLeY7vFcQQ/pKJo8okRBiCKElcairEDnaMddBBIjqGSi0dklFNvpDJn20TfrYI+6Zx5Pjy+T9p6+xKxoFA+8YnnHC3kwk2QeTbkX4UEKpOCXQpFlrad75UUnPigqphBDZvJt3pJqVdp56po+ZIZP9BxEkMxtySYdGJw8pRHmkI4QY4neytQGdQOVhJmw9hFY1BJAJCCmECj8anSH7oaNnX3TmHAMySGeKcuW23A4eQ/ZNOJtwPoMTx8F7FQiUAIJUQi4I4UdKKgHeT8gcAyNqCwMZHTpJBKivtsi4G0B+nJ4+u7oR6gj+Q47L4IHnEDKJAkhWPCSd+0+GslUp+Vy1GtHhrY/uB9bW/mv9L2Yw5bkSZqMd2SLs/uD5op6irqI88nyoCQkB5dwg3pw3hJLniJLMwAk55lqYsNj1zrm3nqgUmTXnY+nctZr0e/smqVpzn2zeOlPKn5Y9KWHCwmc5JpYAlF0AUUHBRdEOtIa34mikZmS4aisW9ZueZcgkJAlilRsg+iiYdt3qcIA6T39Gma1AIBucv/GeUqGgaePGErPqL7lsa6qsvu1hWXHLA/Lnrb3k2/O7yKahI6Vzi5Y59hgmbky86TuYNDMR4t1jYkyfxzsP2DcTON4NLB20NQgn0R1UWQtsF+yTtk0NTv8EGvpjJpK0YSZBKO32M8GsQUzg6b9RPnmHmEwpwocSSkWBBx3Eo33HSkYWS1uHvmYsyxL+tXGHjJ6y1nRgdNioj3TudFaQS5vNikIJUWFWTekeOkSbjGMBUeG7FH22ZMyucIFRntk5oSoAEeJYqHj8nhAj5no+B7EkFM8AQ0iHECUkI1ISxuwcxQwCi5eTMDiEFbLiD8ge5AQSRhKLDWVFAutVJKyFskZyCaorCht/I1HJLaFEufEn7yiDqI8oMpROYSBFAYG0oaRAdlE+IFeQbatSdr2qlWRlpUeU6IJvt0rVUvLU0z1z1obGAkFGLc8R1YZz4H6igtOOaAtWwWYiwvOxtTyBzURHsYJAsj/ODVsBG88UxRFLBJ5evku7QwmyEwpKI9nr4bp5BpwHZNUmSvEsIq1FeqqiaCyLGrjfz9wZ2cuU8nyxOdB3YD1h0ulfM9KNSmmXQgzkoyR8zHGZkPHu4Cen/dL3oeTxb643yucz3lraL+2M6AqlwyBz9BcQ3XmLFkqzS9vK1N+XyaP/e0mi4+NySnjRp0ES+T4TO1sxAyXT+c5BLokg8H7b0kAWfJf3hHMkcYzz4bjYa3IjlEzkOQb9LNDSQZFBCaWiwIM1vZPX7zAEMVygVJasdKZccElH01Ez06bWG+U3GHQhQ8zYGdgJlRIywRAOcYQQ+q/NTNibpB27njREFRCeZDAPluHNrB5yw4wczyYbM3dCQiT5kFyCp5IOmc4WT6YzgzIvoJByvnixUOUgVJwLxNl/xRwIBiF4kkDckkosAYTaGQgIeUMiGXxQxFBL3aigqIxOhdKW3YGUEzbG38pzg1Ryjdwz7jPPAf8qx2Yw537wzPr1e11WrPwybKLg83klIzNdUtPmm0EOcsDGoAUBYMCkLTGo4Q/Dl4hyybEZ5EgsIAMVwudUYyCU+HUZPBmAuV72z6BJOR+UGa6NQR/FhXvL5MEqQpAIfodaiwIPmcfTxuQEso3PFuRn4flTBdVLJEmmy/qqDM4tatYx/Q3tE0WfZ4oSzWSDySgebN5HwsBMIvDS0pfw73AAeaMN+BNKoiG0PyYjkFQImiVlHJv+AtB+OSeOS/tlYsYylLzD4Ik335A+86ZJ1YEvydar28lpzz4kazq0kgr9/itlelwtSfXq5BRWp09BDYUoYo3Bv83EyAnUcu4J74UzOQefpV2tDKDS817TpkGwckBM6uh/mGhyX6knrAgfulKOosDjyf7jZfr85IgIpS19kbFzmdx6RTOjPgbyLaL0oDLxE3JGUg6hY4gZnaGzRiThHkgLhAZEx8RIwzMbyeLFC01HSsfuBP5PQsz4gUhoCQQIDwSDcDxeOwgBgBRCOu1qPqFkkAPKH2Gah8DSaXNcOnqnzw8lC9IBEYKUMChFCtRV1E9UBwZOBhZCwRyTkF+4dfwYnPCWkYHMIGyvCcLkXC+bwZdBj/uGFYHBCHUW5Rd1BIKGZ5RnjkrH/UsoWlc83tPN9/MWK32S5c2UJctHyK7dyUaxYWJgs1QZGFFyIHqokRyf40CwuWY+z/nyfHmG2esM9zKkFh8j7cgm7qAuM7DzTCCrhMch0UyEIK2EIFGbUM8hqpADmwXLveI52zWenQqvtSUoQse+9DQ5a/gAyXAZ95505S1Sr9ThzGombzxr+hY2ohf230zCnFUYaKuQPvoAoil2s2TUH7wnPGurzhE+J/xMe7ArydBeLUiso39gAkt/xztH/0i7YhLCZOmLCd9IqTuul+iaVSEb4gv0HkO8o6KkTGq6nL5inXzxwUemb7FWEDtBpm+0SYyAPpVoCe8w18914pfHe+6/0g2Ekkk3fSsTWNq7P+grsKMwCeUecP2ReNRPZSihVBRo7NmXKh3/876rpRdBQtE4mTS4Z64lh1C0GLjx7QAIAAMyhAiyYNeTpbO89sY7pOcT/eS35F2y/0D2IODNypCm9avJdR3PlpZNakhMdHY5GMgG9RsJoYeauYkfDoIJuYQsWU8Q52PJJRv/nxtZo2Ml9Gv9T3S6fN8C8gchg6ChmLohlWQTc51cMwSVwZFBAKsBA1a4BBXSxvnhCQT4RBlIuY94XZ2DNMoxhJKwG58j3AvpQuFgQkCYDbLFNT79VB/5fOSPMuqLebJ50x6TbIM/0gmfL0s8nmipVj1Jxnz9P9mz92/j64LUEoKGBGJVwCbBAMxgjNJEeI7rZmDkc5zLoUOZcm4Lln2sJj5vnERFxYjH45X9KdukQiWf3H5HJ+nUqb0ZdLkWlEzURgg6sMovCibKC8oPEwQSemhPHItEHGwb1jcJIBEo3rQfm/ijyBvcL1TtxRWTJKFNc0OWwgVrWifsT5XJ191hiH4ooA0RucCiwaQBFR5yZUmnMwzOu+EkmWy0b0giBI2JCO807yJtn/1AxGxEBaBGkmQDIF7YKgiJW/y1a4ec/9Hb4itWxCQYhXABkrl7rzxeoY7cd9Ph5RE5b9ol58Q52KoWTJ5Q2XmnCWnTV0CAUTSZ5DpB+2cCxnd5H+iDbcTCgntEGJ+/E4HCMuJ8HxR5QwmlokDj99Vb5LanP82XfU0e0tOsr50X6PRQiVCV6GgpH0RnC1no0OVaeXnQZFmyipAKJPdIMgdhhfyWSiwq3S6qLY/851rTaaIcuAk9mlqcM2bkKJiQCQgTKoYllxBF1ItABJPv4uGCdEDQIM22JAcdOCoeYVwIl1W4IgFkCrsAqiwKHuFpwr94uKwPKhQwIBD+I+yGDQFwvZwb+/XfF3/Dt2hD0ih/do11lOevvhovL73wocybs1l27zq8ggdkMi19nySWKCNpaZkmvB0d45MDqWvl701zJC19p9k3IXSIHn5HPHDcY8JvnA+qDqoTflIGaBJs+PvUKdPl85HzZdLEJaZNZJf5OUxOOBb/7/Vlite3TkZ89oI0bNjAEFPr34VgQEgI6eGxxBcLUSRrn6x3szrJ77+b++FfXJ5JCPcOJR1rgiJ3MIGDkGFBQQm78+kn5PU96yOuRZk+Ypzsn/+beU4og+G8/zxPbCl4DPEO03aoLuGvatrNudABxAt1nraK7YL2gbJNm7HJMdh88D5CYiGRtFmn6rc/PU0uGP6ObM9MD41M/gNUzOqJJeXrLjdJ8UKHr5dQPESPvsAZpWECSp/GeZBYY/2l/n0Qk1X6Yog+SivKPyqmM9kHkOwG6Vy0dIm899FH0vXKK6VEXLwUCuMaTmUooVQUaCxYvl7ufXF0vuxr7IA7pHzp7EzhvAARQpFEaQOoQCtWb5Em7e+XLF82aQwFBzcvkJ/HDDyq43MLwjmQRKtg2jIc+OucBJMZuyWY/B2PIaF3Bht8SgygNowMqaSDRylzQyo5DgMohdcJQTHYQQIh5TZUnRdsiIvvOkvcMKjgL4Q4BgLkGAJJyN2UG/GK9PnvcJk2Zc0/9yGQmotXLkpq1iorq//6RpJKFjI+N8LJkABIOKSM+wXZY3LA/iF6TDpQfyANkD0GPFTeSZN+lDGj1sjKlZvFF1JVApGY2BSZv/hDWbFiaU6xaEoPcS9tUgNkGcWXrF4AyYR0opz6h/cYxPlcIBuGIjiR5N8oZLSXMX8ul4emTQz7dt1xxllyX/3swvUQfZ4Tz5LSO6EAuwLvLiWyUN3zAhMeohGQQyawVCBgEkL7dAJVj7aLck47RREnKgOB5fO2r7jrk8Hy3aHd4olAneUbvZq2lvuanHvE7/Gv855wn+mfADYPfMIAIsjfOR9/0A/gT6b/IjTO+0lfx7tI/wXSsjLl9tdflp9Tdkhstco53+WKzq9UXXrUP8v8DLbGuEKTchQFHEXiQyv6HQqWLF4YcvYkqgBqHR4fQjJLfl8r9S68U9IzvGGF3wuf1lR+mhva+tvhgM6VQQ+lgdAOZIYwECSMJA7CsYQ7CY3xO7xSDDiQLRKRUCghbYTKCEfTQdNZQ/pQ3PwzUMMBYVjUQo7BgMg9hwhxHtZ3GsqACkHyr5fIc0F9DATOGRKFSgohLlWytJxZv7tMm7L2H2Uw2ECSPWj+tXa7eLLOlsWL1pjJBIM/AzCKKyoP+yQUjS+UUDpJUyiSKD+EwPFH8pkSJRLlycc+l5V/bAqJTAL4YnpaEWl7wf1SsmQpc8+4h5AJyCS+TIgh7dGSSdQcwuCEMQPVlbR+PE3KCU4kiT5AbpigcW8hYkx6LLHqWru+vHHeZYaEHFGvMQDs3w9MmiaL+r1n2g7PEJWdSAJldtiClfVyAh8gHkPaFJPbvMCEFQUQRRrvLXYJCBfkkskG1wVppF1BJvm8nbTgtaaf4N3CD9z8nBYyYev6iNeSR9Ed+tscyfJLakIRpRoE4XyrqKKcM/GlfWM5IkEtEJyFzQlj8+ywBWHlYHL85apl0nzkezKjdGGJqVzxyO8Sodn4l/SY/JW0+nyQzNyY//1xQYFmeSsKNE4rUzxfZpSZ6Qel3SUXmVAQnS4dF2FYCEhumcgQIQbtxm1vk6io2Ihm7G9+MlW27QpMgvILkC8GKwYg/HQMkJAfyBAhJDyGZHqiQtCh04ET5oIYoaphliesBIkm1MZn3JBKOn4GELLkCbdBbiiAzDnazNJwMrwtGKQDDbB4CynLRDgNgmz8g7W7SOmSdUMeGLOyfOL1eqRC2cvkqSdfNN5IyCKDMWorSQ8MuPjS8E7a8BuDM0SdRBzuWdXKraRo4Yph1zGE9O7YJnJm/YuN6oIKS9tkQsPzc6qM3E/C3YT4yJZlUPWHEsrwiCTveqC2clWdBjK+y01yeY16EuOJkijxmJ9G7/Zlr4gDWlesJsPbXyUf3HSHjBs7NmdZVkgd9gtsINgQ+H9U5rwmt3wG76AzCxpidegf9d0ftAMmYkQIIJdcE2XLUP5oP0wqmVxQoYIJKMo2n2PiRISCyR/EctmhFIlJKhHRGuaAe7gnM0NeGzvqiN8z8WF1K64JcmuvgUmTrUQRqB377xvQlxGhoY23fvxBeXj6d7InLXsfnuij+2hrW9h8IEVumvSljEvOTnpUHInI41IKxUmAxOJF5LxmtWSGmyxvn1e2Js+S0qWzV66BlKD2QHQgAHS4/N4u3cdP/IXWwH4gPUokvkyuyz3mhfE/L5X/uyp7eb3jAYgzKoVN7ICE4Q21IXIKHRPuokQIYTJm+2R1QrZtNjpKI4TQTfibUkbU3cSTykBKeJjsTzySNlQVSlHz3BRKwl6oqoTwCKehWiz5bb3ExR6uYRkOqYuOiZMVS9OMH5V9kgAEGbBrvNM+INyUXYJM2ix0Bv7GjZvIM098+0/6uCeitlqsaD05eHBazoALUbXlWyyYODBRYNKAukx1Av8KAEoocw9tQySdamRuOLN0OXnrwo7y33MulNF/LpPk3Ttlf0aaRGVmyWfvDZKLSlWQTz58JPvDlbLXnYfE0YZRrzkGzxDLBJMRMvchVyTJUQEi0DnwPJn4vj7gbUm4uLWMXvO7rNu3x5Aj1NCKxYrLDfUayzV1GkjJ+OwVaCDI9Gm8v6jneHtt2SIItH8yC15EFE3uA+2ZBL6GTzwguz1RkolfJFJ4vfLG119K2T0HjlAduSaILdEKiKwtgA7oh3mHbAjciUBLLxL6fvSzYfLq8tyXnDxiP/znE2NjKF24iJkEKA5DFUpFgcdVlzaOmExakvDea48YYsDAy2wcNQ5SRfIDnToEkoGGzg/VhxAixASV4dV3R+eaHZ4XvD6ffPXDYsnMdLc2sBtAxCAeDDQobAw8hExRCgiBcV8AmaIoFZA9/KMQwmC130IFBJJ7CwFCPUGZYTBxKo1bNu+RoYOnyEP3DZfbbxksB/acIR5vI/n5x+WSQUX7AAolAyd+SvZPGAwfqc1m/nrsArPudiSI8kTL3j2F5IEHHjVKKW3E1sJDqeTfZFpzn2zYEPINsY2SkuKRIkck34QDvle8WEWZPWu5aYeWzFMpgGfBMQiZosLSNvk9A7J9fk4ooYxMkcwNpQoXkbsbNpe+518mgy6+Qt5r300yf/pVFk2ZdsTnUI9R6PG/ovhboDYTYuY9o+oC9gnOLdDKLulZWVL0ynZS5Kme8urCX2Tt3t05Shs/1+/fK6/MnSbNRr4nVw59W4Z+PCxnZSjeExL3IKuQMSaG1GjkegmBM2HD+kK/gJ2DfoGkGIh2mcqVJNPtOua05aKFTQTEJjZiI4FIM0kjUsE9ok+gggb9DWo87xjnFwqh3Jt2SPr/vjCy8/OJ9J4+yfTNisPQpBxFgQedyU2PfSJ/bdwZNrGECLZpWlNe6ZWdDAI5QqGDLBH6wctDJiQzZjp3FDsGGxIxCIfzs2SjWyQ2PnuVFjd455lr5KwzDpvFTyRAKvE3omByXxhkbCdOmJyBkUGBAcdZeiQc4O0khAwhRHXDT/X6a4Nk5IhZMnf26pwMeX8kFI+Xzlc0leu6nyvXXnuVOS+rcqC6sloNg7ctybRrZ4pcd9UAV6WmGLdu7tFGburRJud3WCQo+Gxr9pE8wL2g3RDyJqmpZYtbJSaqsgmfRwqI8OVXNJaHH+lijkPoG9KIokUon7Alag6F+FFz8KGh/lJE2gmKRHNuhBj9S6ycKkQSgkX2Pe2WNc1DVSTDAcQQn6S/RYRnxyQWAguZY+lN/7+jGDIxgFixAhKki0nE7gMp8sbGVbI6IzWk1eeptStbtkvsqO9kzfLD4VzIG/YWFMpQFzAoddcNUuSsMyOy9zjPJ2rVX5L6yVcm+oGSTxY5yUP0Nc7z47yYEFKHk4k+/m/eaXzizioXTN6IEEB8wQfL5ssLs6eEdH+CYVi7bnJh5ezVzRRKKBWnCDZv3ye3PTVC9h84FDKpjI7ySKVyiTLkhe6SUPTockHMiBmUIZdkB0NyGJwhKszsWXcb8tLqhv4RLdfnjxcf6CRtz6krJwMgIWRoQ9y4TwzC3ANC6dTHs7UwGQjCCYkTNibsR4JQ8WK1pP7p1xgimBf5g2zWrFVO9uyfKstXLDZ1KiFWKBqcjxOTJv4mfV89ei32cFG9RhkZ8lH2ih3AkkgIJSSPrF3uCYMcbQXv6geD5klS4uHM+kjAOF6uvMiIz58y94b9kiUMMSAkCHnmOfCM7JJ7kBlIjRNYOvDQQiZOpcQcJ5HEykKYOxQiafyJhw4ZwuPc6Bdy+39qpTKxYULBc3F+DjWe58K/SZKBPNm/O4uYHwGKhN/bQ+LPqBPQDxgUXq+krV4nW/sNFsnMMhEJ3g2IHMooP+1m/x/FG6Wd+8R1kGh2zbB3JbppA2Y2EikoH1Rp534pM2eZsRehiNo+JBBQSrn3TlLOJIh2T3IhK0qRgEimOMlKpUqXlvNHD5W/9++NmFBiGzivUjUZ1u5IO8mpDFUoFacM1m3aJQ+8/KVs352SJwExa9VWLSP9H+sqJROzPTq5gY4ftQBySX0zOjZI07Ws9DIlfxJq+vTsIO1aZ9d+PFmAYkColcEGVQyFkcERDyQ/GQgYtGypIjyoeRVHhwh1veIO8WVSX/LI2ox5kcr0jN0yc9Zbcmm7toYwoSj7Y9Tns2XooCmui+FnZB6Q5SsHmYGfLRSFp1GDm00ikBsYz+/2pbL8jyOTGiwgmdx31FHIvk3uwKZBKSN8arYOIUQHawcEAkLqJBXOLdjf+D1bfqt6oQDywfXlRuacvyNsjA+QOo2oWZT6guhDVHL7nnMLB/YeMaEiTIs/mKoJ/sSN58V5ER2h9BSeYv/7zOfs0ogz9u2QUj2ujigpBmUwfeIU8cz5zUy6cgNJLbzPXDcTRyYnhKIrXdRG9ndwXwh/yCVXyKVVa5t/M/GjHyEqQXidfoWkIBR/ng8+bn5SRoiJW14oXLmClPnvg67PkTu86tZeWqfyHyihVJxyK+eMmrxIxny/WPamHJJoo255Tc9Ax52V5ZVypRLkqnZNjPcyPi78lV/wWaE6QS7x/jXt+oJJ1HCLRuX3S6e2ZxsV1HrvThY4V9XAb4pKh+8J+wAbvkxC2YRmKUhu62CSwGJXxrDYuzdVrr9qoKSnQ9A8YZOtnbuXysLfPgu66tAXI2fJB0OmuiaUXt8h8UZNN+oe5I12xkCI4hJIXeJ86tXpJuXKNIzYQ5m9H49s3DxPVqwcaxKkIOwMtqzYhHeT33GfLQmCSJGcQ5sivMh5WKLN/6Pw+BOncDP4LeG0BJN7wsSBjecLqWLj2HaDhFoiCjnk/rFBrNg4B0g6G8TREnc2S/jCjQzwnCDThEuDqXL58Tt/ks09IMEF32IgoNCRUY1Kia3EJqL4g+s9b8S7sv5gSkQr9GAOLBkdK4v/72HZ+PffJms7EJhoQCZ5P/Hk0idBevk5dtw4aTfxM9mamne5omDnkFQoXubfdK/EOK6BTHfC1RBXKkxgLUJF5f953nigUeDJbudekaFO9QaIMVYPvKdERGgr2+JjJP6u7pIfmN/9HilTJG/R4VSAEkrFKYmMzCyZNu9Pmbd0vew7cMh07okJhY1fskXDaq6SaPxDtD2fGymbdmeJuCAJEKF1M9+RLRvX5WQo4n+zGyEnN8seHg9QUohsaogk9wVVgYQmOnlIAQOEJZioH2RjM/gyONgQOQPW12MXyZD3p0RsI/B6M2X8xEelWMJhGwNeWDyvKBy/zFgraanVXatqKQe2ypwFbx/xOxu2I3sXpRVViXWy7eo47S+9XdIPVhe3WPb7F7Iv5U9DCCEfeFrJwCfkjhXBAmLGYEsZFdadJ0RI0hlqO540wKCNWge5sISS8+b5MAlg4/9tjUKIHASWzRI8BnGecSjqkf/9ApE8a0tYIa9s/ioq50XSFP46PHoQbxKZIlFh+ckxIm0zFCEnXJybyglhQqHjPeAZBbKKLN62WbqMz14lyQ229Rsio159I2fZUiewUNBm6XOIxphFG1asMElKTKKNtWLxbOm7YGZkSStMvMb/IDdWO92QQOeiDryjWF5Qc3mHUCnxmFJSjCx46nZaVRlbjF37m1WC8HLbpVhnbVov1038wt1Nsvej+3+kXBH3HvmCACWUCsUxxqzFa6XXq2Nckckdfy2UtI0zzUo0DD4kqJAEg9rFQE0nTrjYSTJRM040kOFMqQ9qPjKAQnQgmSiWzrI1qE8MoHapSAgm6h6DdqsWj4hHIIORDd6Qky5X1pOYuC1mcIREkrEKUKeaNG4pMYKv0uPqmTVpWlquujY7CQnSRVIHSiyDMWQGwkZZFidKly4nDevdIx5P5KWWMrMOyYxZ/5MKFcobogjRQ/nimHawtcQw1EQLp5KGN42QebiqXLhqnn/yll2hxbkF8izm9ns27jnvDWSb64Ao28QT/++FU6EAMulPOvMioXZjQsE58R5wPsG+Q5Ifmc+8M7YupJPEvjRnqny4bIGrkj3RnihJm7NIbi9fwxA6J5j0URmAdoXajQqIJQJFl7C9Jbksvdj56xGybt/hzPKQ7qHPJ9VKJMkl6/fIq8+/YCYEeDRtshGg7yPBj/6DKg38HfWdsmUsrkC/CLGkAgXL3QImsLR9JkqE5X/fuU3aj/1Y8gMrezwk8S5KoxUkKKFUKI4xCJ12vX+IbN0ZuZfy4e5N5PtvPjcKAAoQ9SHxU9G5E7KkE7WbJSn44ZwEEyXQud7uvwXK6OCHYm1rQmYkQKAQUm+PcGygVVsY2CFFX335k8yeGbyQfKhk70DqNpm36B3jR4NEEmLlvqJkQLwa1b9ZSpasZUoARXYMn9Q6fbsUissyxATiynNCAWPwtYSFQdG5jjKoW6uzVCh/tkRFRUd0bX9tmC5r/vrBKEeQdAbTmTNnmnAhYdVAZA7lEsUH0mt/RzkWBmjUJ86ftkcJG8gxqjETA5LPUItOBjApIcHGmWzDalHBrA/AmQQTCXkN9W+0gWArOIVDYmO7XSbe+rUiC3c7kLBpu1SZvcxYISxIDiKqwISWZBxqmUKAIXeEwJm4OO/lxpR90mn0h7Iz/VBo63l7vRKf6ZWfbrpHKiWUMO2W8DXVB3hvsM0QqQCs6U2SDZMbyDg2GSolUMqMjf4OAkoBdhR6wt4QdUsoM7xZ0vzT92RXWni+VydYMKNR6fIyrsuNEe+joEEJpUJxHPDT7JXy9FsTIuq0WjWtIa/2ys4yZdDBoI75HrWCTpKZOfUvCVcCfEOobpBLkl8IEzFo0cFS/sRJMim+/W8kTFDChgxizpuwNyvG8BOSA6lhHWx/7yT4YfJSefXlb1wfPzPzkEz79QUzGFsPH4qY9eoVLVxF6tS8OqJ9e31e2b07WZasGG4IK8cgtEr4jRJTNsEFBdaul21r+vF8ExNPk5pVrpPo6EJheSm93izJ8h6S2fPelsysVDMYE+YjxM2AGyxMCsh8hbBzPhaQewglSSoWkG4qGjApoMIBBILJDeSSgZrrOtGJpC3/kxuRPN5gwoQax3PCd50XCSWhjGL5TMq4Jvu3n0vEyPqEuIhXqbGoeDBT/ny+n1Ed6R8oXg6ZZNLBc2fNbCYc1IXEw0hdWCayZFNbQAgbtTxXoq/pILG1qpms6EBqpf193Nad0jh5i4z6aNgRf6efw39NX0ZYm0xtiCVRDsolMdnhXnDvsHVAeLHVUPYKT+VVPW6W+WuSpVv36+XlPs/JJc1byDfDR8o7y+ZJ1PktXJU3evvCTtKl5smVKHksoYRSoThOGDF+rrzz2Yyw1Kas1B3S6ewEuaH7dSYD1AkICcSSwR0iQiiV0BCqi9NPicrir2ISNgIkX1hyieoEuTleNQcplgwZRmmlRiMqAkoZigQeUdbyRlVzEt4J4xfKm29Mcn1sny9LYgrPNOpFoJArxOi3hR7ZsS0rrCUQOVX8t7/OHSDXd+9kroVQLd43agnyXCCsrILCNUOkqdEJmaOoOiSHpK4WzS+VpISLTJJYKMlBXl+WeMQn+w9OlXnzp5jfoYSyLwsIMwN+tWrVcjYmIfxEcULxQX20RIvzIqyJQhkIkA0mN7Q/Bn2UZUrfEI7lev9twnYyEEknrEfV+cyCgYkPoW+IJc+ISAV4+pcf5LOVSyQzTK+q/yT2rLgEGXPT3WYixCQCAsf5oViyog5Jh0OHDjXvL30JkyWSZux5QJBJ2oHs0TeN/Ol7WVLIK1/9uVzSHDYCX0aGtC1bSR4+v538987/mOvHlxnoerHLsMwinlc8udhHiLpQfxNvJOcD4eUcHu7dWwZMGCtlO7SV6Hq1jvJypq1cIzVSM+TvRrUjJpSJcfHGPxkXreFuCyWUCsVxxPifl8hrH/5kSEKwRAPqX1Irs26lYpK+aaaM/3qsCSdB9mwRbKc/kr8xQx88eLCZxaOK0dEz4PiTUAs6ZTp7SzBRNEkSgbyhojlVTMKkx2oQxvuEOgYRxu/EcSBX1EpECaGYM8qlXU6NlW9efuHrfDhyhvR8sKEJ1wUKsYODqenS+8FPZdWqzSGRSogk2w23NJSbb+loQsQosKz0gWpMtjSeNJRC1BMmA1w7wE9J8gtqIGFq1J533xkhX49ZK5kZ3PvASzHaYu5FikTJz9P7i3iyk2Mgp6hKhFIJD6IuQQ7YUHXsvwnxO8GxaTOQTL7P3yGM/D+EIlg7QGFlwOez7Jf9UJQbconf7njiZCOSFiSLkCkNAUOtzgtMFE2CyaxZxtJAWPib1X/IvVPcK/iPNWguPc+9wKzshCJIBQBIG30Kx6L9ck/teTAJIyRNUXFAO+e+MzlFVSThC2zavl2q1j9drr/lFvns448lNi1Tnnv6adNGmVgSVqdfCgYmPDxT2jB9IGF39s+qOfR/LEu5Ye9uGRObJrGVK5h10gOG23mhPR7xHjwongjLWr1x3mVmnXbFYSihVCiOM3btOSDfTF0mX36/SHbszq4BaBETEyXtWtWTrpc0ljNqlje/QyFgoIGgoBDQgUMYKKBOZ+r0sEECICqElFE6IEx01Ch9uRWnRjWDFDhVTPZli5GTXW0JJv/OT98cKh7EizA3pNJ27qhmDDR2CTgGtihPgvxfjyGujofyu3vPWlm0NHuQIyxMuAx1DVXFucLGoUMZck23ZyU1pVjQlXjYH6HppKSi0ufFbpJUMsoMdhBJwm+EMMmkhiSj4nB9DLZsAEUG8kU2K+oPSQ4QOMhcZqZXOrTvIX+v90jxhKOTrM6oX1Gu7Ha2tD7vdLntth6G0JF8gGKIWgMxIfkkWAUA2hYlafg8FgTaCWFxSKFN5LHAGgBRdCqbTqXTrq2On47zgHRAaFGRIJa0V+71scLJSiQtIF28ByhtzvWrcwPkk76AZ8w7W/a006T5yHdld9qhiM8jPjpaFt54r9SsXMVMTnjmrH5F+6CPwIdIprkTTJbIviYZhvtPOJrMayZKZFszyQV8n7Jh7INnw/eYwEBWWQecibHTYuEP9sfn6Qu4XiZnZOdDfPn3y+8NlBrPPypp0SZUkPfFer3ZE/t/ylSFit5NW8t9Tc4N+fOnCpRQKhT/ErK8XlmevFl2702VjEyvFC8aJ3VrlJMSxYInzjBAUyYDckkIlcESZYvBmg7ahqsJHZFAAblk5Q8IIAMC5BLFMRSgWEI0nCQTZRNAlJwqJuqIm7JFdjBF4cD3ZDt3QmeQYzxbDJqEig+l1JfkP7e5qhO5ZfsPsvz3qebf/itwoMZAmiGYDNZ4xO6773GpXKGFfPftb4ZkOgE53bRljixdPkVKly6Vs8wbdgJIOUSLe4kVgXvIAE2YkDXE8bAS+mYwhoRBQsmcRQmCwHH9EEQG3sGDPpXNm/ZIamq69Op1v6z9a4Vc3vkiYx3gsyQ1MbAyccA/aQkrYWlU7dzA9XNsfJMM7ABfpF0r2V/ZtP/PUngWHBcSawkmSWFMahYsWGDCk1wLbZX9UmImWC3FSIgkiV28DycjkXSqb7y/eFEhXKECqwjvIEo792LIn0vlnd9mR1Syx5fllYMz50r3kpWM4sc9pNICEwKeJeF1iKI/OGcAGcanjbWC5z5gwACjHlpQsQG1HJJJG2fSxPvCu439gyQf/yQ1J2ibtEfKBaGKMkHDX0m1iFvuulPmNawu+6J8oSUBOa65UEyMyYynLwh03yzVjI2KludatpXupzcKef+nEpRQKhQnKeiMmdFDLlGF8P/RsUMuSZSwCRKoAnT0hJfJesTfRoi5W7duYWV9QzpQCJwEEx8nHkH2Q0jeSTIhQuHAEilWvxg4cOARigFKGh4/fJVlSjeQGlWOro8XKtLTU+Sxp9tIkybZy8WhbKCq2NCdLZbtBMQSFbFDh8slPS1ahg4dJoMGvSuTJo2Xlq2amnuAisP9hzQRFrSKKwMm5JEC0CjMeFXxvjHQogCRSMAkAXJpwfNhMsA9YFDnGTrtC4TKmSiwmg2eMY7N9/E1QuYgfJBIzguitXz58jzVQc6LY0DgAaowJIKs2WCAKKNwBiKb/HSSAyYcqJ82QYzrpp1yz/DMQsDDUYmcRJJ92SUSTzYi6QTqOO8SFolwgM8Vewjrgg//6ku5fMJI2XUoNaySPXgni8XEStNFq+XjtwaY+8gzYzLKhIWIARPJQMBvCwlmskRbYxLF90nycpZ/suvD0y5o30wU8UMy8cJ2w6SSdy9Q8hhqOUQVzyTLllrwedbuHjB/phTrcmlEnkgSg66oeYZUKV5CPlmxWHYeSj3i71USSsit9ZtKt9r1pUTciZd4dqJACaVCUQDAoI4SBbnEh0SYmpqVkEvC3nTQdMiQJ5QHCBSKFOV7UC3xTUYCyAG16Zwkk1I4gMHFSTBRNvLKAmaQgUyhROLJ8icYkOj//rePLFtcVOLjEiNaUWbV6m/ljf4PGgXSGTrEs0kGM2VIIFIoPhA+iLSzHiG/R5HlWgljc/2QOwY69sM+IEgQbGrkQTAh8gzIKGgMuISWuRaUH5RkjgeRZoCFVFBTFB+lVQBt8g5IT8+Uxx7pK5Mn/yqXtb9cJk36VkokxsuCRROlQYPahliyT0KBDOAoRqYg/Ndf50rYIPNcCxtARYSQYreIFBAHJ9Fk4/pJEkOVchY6h0hx7v4JQ3bDEsD5F0QiacFkDzUXkuRfhzMvoCTS1phIPNG/r1w94TNJzcwIiVRy5wpFx8hbzS6Unl26GZKHWoryh/JMeyKTOxioiUn75fmgGBL65jqwkjjBO01iDRNEbCDWn83EiwkPbY73wobInaBv4x2DPBM2B5BQ3o2vxoyRCv97XKISi0ec4R4fHSPzb7jH1JRM3r1T9qanGZKdFFdYaiVmtz1F7lBCqVAUMDAI0PmyoYrROUOeIJeoUHTg/B7VEv8iqha/h1iiSrkNRUIonWWLCH1R0gS1A1LpJJkQBf+OGsKLunffffeZEG6gjnz6tHny/H+/E68XBS/0gTc2bodM+qG/CT+jCgYiIQzmKIyQW+4h4J4QduZvXJ8zE5cBF7KOisNATAYsqwIRiuSzEFJCc6g7KMokTEGc+ByKIKQVxQX1FaA4Qvz5DITMqnzjxn4nW7fEyoSvF0lKyiFTJig2Nsak62RlZhPe4onpMnX6cLn1titNuJH7SPY/AzUKNbaHYIAEECon9AqZQT1EsYVMHAtAJpnYoEyj3KJ2Qhppr9wz7p1dZ9wSTp4Xv0PNRNlk4z5BPpkgnewg5Euxbny1qNrhgkkl7zkTk1t795Jrvx4h2zPSTMg2EK2M+ifE6zmQKh+0vULuvvKqHMWPtgPxw7rAs8CqgHcx0IIJkLrevXubSQntBYJP3+IP2hfvBhMLwDvFu4R3meNBqJ2E0Ql8mzx/3iUmR0QsIK28Q5173Sdfxh69nGk44B4Rzr7ljLNc7edUhhJKhaKAgkEZtQlSxECD7wjVkJATgw5qGYMHoSpIHKFNVAlCu6iEKFv5AUgWCR5OFdMa7yEPzrJFKHMkkuCTYqULq3YEIpUb1u+UB3p+JHv3MpD4gqqV0dHZa7Rf0fVsubtnWylcON4ojmTIEt5FzQ0Ejs+9YUO1ZBCDHKP2orxAtvCU8X3IkAXkEyUWdRGig3KE+oI/kYx17j9k3p+4ExpHbcNDyjE4R4gtatz8ecnS8IwbJTY2PlfvKOWDKMbe/aaWkpG1Mme1EJvAQGjRWSvQCRRUBnb8nQzSKNucNwTgWIN2SPvjeXCeEHRsBhBhSAT3C1XTLrmHMg4pcS5ViHIcSN20/w72nE8koEpzfRB/JgCRgMxnlHNUw4+HD5e95UtJ9Ws6y9J9h/2uFk3KnCbnFU6U3p2ulDJJJc2kCAURNZzEGiankEN8xJBUyDzt+OGHH86xy1BvEqUYxRmFlMkk6mMglZGQNgo17RFAQvEQ4zmGRFMRAAUadd0JSCbnQN1NogFYbyCfnAeTilfmz3C9QhA9TPtqdeT9i7Oz1xXhQwmlQnEKADUIcgK5RCUjBEu4CWLJhnqG7w21iAQZ1DVCtqiWEKD8rk3J4GNVTDZbrw7yQDgZgmkLOOdGKlHqJk38TUZ8Mk1S9mca1Y59oLBByCDVrdvUlSu6NZPGTaqafTDQof5AECmFw0+75u/h/aaYv5FxDaGzQKnBd8l3UNesf9QSGwZW7h3XZwG5hCCyTwZjVKhg4TP+jvLCfnlmELs773hUJk3ILu8TToj/6utayPLfvzaEEjWUkCQDNqH9QMdnwoEaBaGDRODJ474EUpqOJSDnqMcorBB4SxY5f+qUWtsEz5b7HCxhiJ/OLHWsBMHIJlsopXqOB2hPPAdbKzZccF9Q9yFqtCEmPbS5jakpMvCzEZIR5ZGisYWkavFEqZVYykQo6AtQwiFoqI30CRBaJpcQRkgcS5+iXBI1wB9NUXN82ExCIHxMoJgY+CfiOEHYnHeB9wewX5sxzuSXigC2/TnfOSYW/J12SxQFwkv/ZPHo9EkyetVSiZxOZqNF+UoyqtP1Lvdy6kIJpUJxioFOn7AR5JKBG6JDR84ggv+KwQJFjpAvqgFKHH9DtcT0fyy8RJA/1BCniskgZbOvrWqDismSgoRGnUC1mzt7lQz7aKzMnDlHvN4Madionoz7erBMmTrJfM+CECnXidrBQEUCBCqc0yMGsYZMQ0w4diAwwHJO1pvIuRLW5yfKHgMh4WsyW50eTELkEDVC0ZwD/lW+j+rCwM79RymirmOfZ1+WA/saSkyYq+ZYPPZkJ3mt78OGmEEUSOaBaKBc+oPzhnShbhGaRC1mQ+k6nmDig1KLR5LQJ8SBda6tQskEB+8pvtDc2iJkCrLkTzjtv/Edo55bsO9A5ZD4SRvIr6z0vMCkhCQs57mFC4g0tgBC1pTewk7BBIgMa39VHCUa0kg/wMQIMooFg4kZpJGakrR16+mE6KIsMrEi4kE7Z5KCjYS+Ag9kMP8n7Yk+hAgEYOLEebJ/1GnC6rx7tFOeOZMr+ineH957JsMc0wme4+Xv95M9VU8TT0xkS6VatKpQRUZ2yL0igiI4lFAqFKcwGEAgj3Ta/GQgIpRka1zifUSxJOTIwEEYHGKJOT5YQfD8AoMMyiWKCOeGMsX5WO+V04sJKbOZoQySJMOgzEEqIIqoHtYvSaifcCpKCmoYgxhhbdQXFEJICvuEtDrXMvYHYT2IKvuA4NgQpfVUAvZFgg4KIWoaJJEQOITGkkzII5/hOxAgBnZqV7I6ycjhv8hHH0wLa7UeZ33M0mWKyHtDeuSsbcxPllMkcYtj+gNVEgLFeaIUQza4/8ebSEKqKP9jQ94A2wSllTg3JgGot9x3tkDXkhdoGxCpQGSTjfCzM9sfZTsQ2bSEM5yKCbmBWqS0Ta6XZxAJeF+ZEPGe0E6ZQFk/sAWKIhMe3msUe+4twHpAuBvQDmkDWCUIOQcKrQPeA/zSkEXn8p3+QHmFLEJSLXj/aJP4L3m2JBPyHJiIcV9tm2XCxb12Pj8mR4ToE69oJ9HnNXe1hjmZ3h1rnC4DLswugaQIH0ooFQpFDoGDeDHwoGACVDTIpV2RA68lWb+QJgYpBi06/GOdAUkZIZQTPFiQQRsuhxhBzFCPnGWLUK8IoTMwQgwgwvgXGUAhTYT4LQFkYGKAI7QNiSbsxwAJCSQbOxBsIhP3AeKHugIRBCQlcJ9Qbay/EuWSzxHKQ8lhYIUsE9JHOSJJCrXGdMoejyFL5513vuzYUkdS9h9ZwihcdOlWSS5t18LcE1QejsXxGbD9k5KYLHBelINCRYXQoVL9m0TSHzxvzh0CRLkk7jvPAmJCODS/iu5zHIhroFC6JZxO5RlVOpiHE1Utt4UFnOD+86xQFiO596iStG9CyaiFTGBQ5Xl/7b0hvG3XwsYPzISNdwyvNW2b94rzpU8g2ck/oQsizjvFRI4+gokYoL3zt0DVHFDA2Sf2FWdIHLJIX0KpIRs25/p5D3n/eLaQec7RArWafgk/JlaFtJIl5LRnHhC3eLdtZ+lYva7r/ZyqOPnrLCgUinwBiiODBp4rfICU+MCEz+/wE6JUMmhTlJiQKOoFgxEkgM+GsgZxpLBlhAiHoZYw+BHGhazhw4KEoChS5BsyQtiYBAGIkx1kGUApIA4s+QMQFwgN4X+uHUXTZhEHAveEv7FPLAHcN/aHmgIZpDg79wYQOoR8EG6GuFJ8HHJB6A/CCYFjcMTbiE+VkCFhXupLjhs7wzWZJFnp/XcnmHvEwA1pg3iT+BBIeUSFItwKUUIxDZUERUokeSYo4qi3EHHCnChUuZUAIpzKxABvJ4SJCRCheiYcPHdIO0TTqtmRwq59zvnR7p955hnzDjABQC1j/zxbyC2EiyxlFEHeHZQ22gH+Qog5BIvsaCYzKKpkcqMi8jxIUHOGt3k+HJu/RQKeK/eT/XCuJHnxbnJfiEjwzqBIclzrqYVI4lFF1ef3tFdA2+aaWODAgraBt5K2znXyedouEz0IKLYNnqX/0rKcA2TRWQ8V8mkVTZ4l7b/TFV1MXV0qUzCx4e9YNHgnOD/OmT4HMgnR5BwzN2yShP0HxediDfNS8YXl0qqBl6pVhAZVKBUKRa5AiaGeIQM3Az6DB8qBXX2FgR1lk5AqCh8kiSzNY6FaMlhCyghzUcLE/xi23Iz1YVJWBDUTcH4M1BAlyCfkEWLn3AeDF+oIYWg8YqgvTqAicu2QCJQfrpvwOkoUJAiiwTE4NsQUIgwRsUAZgoTiuyScjoqKakSSFOA+o7KBd97+RsZ+tSTgGt7hIC4+QyZ+38esc0xYliQnrguSyfN0lmhBmeZvhEkhUpw/5OffVCRDBcoa9w+1GAIE0YCUQOC4luNdp9KWmAqWNEQSlCVdtEEIp1U2aXuQP9oo/8/EKJSVqGhHqJG0ISZIPEveW9ojoWsILsQNMsZ+IYP2cxaEsQm542HmfLrfdJP8sXenvD5wgPn7VyM+lUF9XpQfJ082kQEiAkz28GFDmHn3ecYopEyobLUIm6nNZAbVE6USlTm2aBEp0aq5eM86QwpVLJ+9DCIWgyLFRBYuk5Wfj5VqpcoYC4AFzxNSS9thosaEN7lItJS67bqInhXlk+5vfK481LRVRN9XZEMJpUKhCBmok7aAOv9GybNrYJNUg4JISBWVgnA4hdP5TH6CQYrsa5Zhe/nll/MkriQiQCJJ5oBgQgKtIkS4jFA0gyADI0QKQsxgyMBHMgOhN5t0g+qEsoTnEmLIwAtRQ9VDpYK0QjohDShtqETBklo4B8J4+FGtmsZACxFFTdq5vYSM+2qhWc/bDcqWKy51zthhQvokU0BqOVcGYcKMqEHWf4q6xu8hGdTLJJRpfXJuYUsgQVrzk0gGAm0TssLGs0AVhoBALlG4TgTw/FHdApFNiL6zJBL3CLU0mIcTMsozJPuZ9omCS/uFxNnyPXaVGogp9wPFkEkNEygnUNuZZNRveY5c2Ps++WDxHEnze8XivD75v8bnyOePPSO+PdlLtLI/joU6DNHkHbVLLOJPJrLAeVnCWaFiRTnn0ftleUKsHMzMNJ5f/1VurOJYKHm9rHv/Y6lxWkWjEjMZooyRTQoySTvnnCNVH+spc3dsDlhzMzfvJNnuYy6/QYoVKhT+g1TkQAmlQqEIG5ArwlG2xiUDIyoKqiX+PxQ8SAmAWEHSIG75pVqibjB45lWGx36Wz6HeMNARGiXMh1oCMbQZqZZk2lqcDFT4RfFqMUijjhLqxx/JgIgSBrmFkDFYQ065B5BLkgUYrFFPcltpBqWV8CKhPkLS7Av1EjWmRrWLpHoVsnLdEa6q1UrLBx/faVQk1Ekyy1GmCLUT/kRh5brsc0UxhURzX1GB+c7JQiT9wfUwiYBYcn8hPShpEEuea17LUf5b4N3hvYHMQ8ICeTgJF1tAJgn302YhmijlhOBpxxBOJipMUngWKKeot7S1QOSaQud3fDpUfji425CtYNMZj4/PeqVb2arSr0t2tALln3PmfeM4TKZ43kyYUP0JiZNo1OuRR2R6mSLy099rQl5vu7jXJyMu7SZP3f+gebd4Z7CdcEzeRews4yd9J3dOnSCFalQJaQlGrq9KQqJ83vFaKV80f0ujnYpQQqlQKFwB0sTgZGtc4t/CN8YABtGDIKFUQDRRLfFkooy5BSVFID4oFZCiYKQSxZQkBc6DhBjIEySYQZeBme9TNggFCGKMOkn4FMXVwmaYQ0IYFCkCTsIEagmDPIofn0cx5XPsg8Ga+wLxDgRIHUouiiYklXtjwT5f/d8wSV7pzsOI6lO2XJQ8+0JX44XD8wahxEMHoUQFQ7FEYSL7fe+eVOly+V2SkFBW1qxZJ23anCuXdThf2l7cQIolxJ80RDIQUKkhIpBLSD73nVAv/kjO63iVBQoFTG7wr6Ku44MMBJ4dJXMswcRXTFvnfeRdcPoy7bvB5In7z9/IJic0DgGFWPN7CPgj1HT8c1lY59v99EbycqtLjMpPu8cGQ7UFCCUTGVuX1fouv8raJ/MO7g1rmURaTda2nbLlfwMlI+WAuRZUUKIInDuqLmprhs8nVw95SxZkHTTLTvKfPwxR9vmkXbXa8lqb9ro+dz5BCaVCocg3MEjjjbM1LlHA8FAx0ODdYkAnPAXZRLUkKcMNwSBzm2xYfH5kagcjlRA3kgYgbpA+VEtn8XG8k3gjUXgYxFENUXYgWgzUKJlO2Np5JIMwaEJUIaGE4DgHNs4JVZOBNRD4DveDxCabcQ3xJmTItmTJcmlz7hMSE+2OVC5ZMUK27/jdkGqy9Tl3iB7PBVKJulWrZhPpesWDMn1qdkIOxIItmrp+PhSwaLn40gZyZbdmUqPm0SugnMhEMhBQKpn8QC4JDUMmUQRRLlEEw11H+1iA8DHPwvprcwNZ2SxrSjgZYoVHEqWZmpGEnJnUcP9R0WmjTH6chBP1kKSyYh0ukp0Nwi/BBB49u43M6jvQ7JtqAiTI0YaYQBK54H3Ay1mofh0pe/9tER0DpXL/D9Ok3qY9pgqDVZgh1CifhOt5t/FZ7zyYKqNWLZWPVyySzQf25+wjKS5eup/eWLqf3lAqJRzb0menGpRQKhSKYwKUOggT5BJFiP9HQUAJxE9FaBjSxoCHXw/vXiSw9fBYRcW5qo0TeAdRISGMZL3yeadHjXPj+CiLDIh4KVGuIBgkGqHeMVAzYKHooCASNiSpBkWIgRq/JB5E/oYaRtiPkDHH8S+jYuv74WeDeENoIZHcF8gNxI/jbtpQRL4Zv1i8WREUohSfpKXtl1nz35CsrExzrwkRQnwJ63PNkI4YT1WpU6vTP2Q8uGLEEpbs85HHLzfk8mQkkoHA86JtEDaF0ENS8LXy7CHdx7okVjCgImPN4JnlVeOSddchkSjstG8ytiGMrGTDPmwiC/5hnj3tk8kcEwraKBPBlRvWyYRaZcQX4fOK9Xgk+u1PZNWSpWYpRdowbZm2TrvmPnLsGk8/KLuKFxEx7Sl8FPZEyeJbHpD4f3y/EG7KF2EB4D2nP/BHWlampKSnS9HYWImPyTu5SREZlFAqFIpjDpRKQs6QSwono1yQYQ2hgkzht6IUD6olCT7hKkSEn/EjQmLIIPYHCiDKI8fCn0hxZY5pk1E4L0gEhALCiGeS7GwGKxQ9lEj+DTGkNiE+PJQtyCTli2xWOZnftnwSHq9DB9PlsceelMs7d5CmTZsYJYjBm0LcZM+zbxRM6vehWEIiKXdkCcTGv3fJbTcPNmuRR4Irr2oo8xd+ZciSVR0Z6Dk+CUGpKaWkbq3wCzk/9uTlckm77KLbeBS55ycbkfQH94Znyb2iPaBg47OFWOJFDLYG+rECxJAse0LEtM1gICSOqgoRxlZCG0TZRBUkW5zrQn1nP84yULRTFE0mPNSoHLd1nbwyd7p4w0ppOQyOs2/0BNn7w4wciwjvDbYCiC3vVEyZkrLiwqYRHuEw+p/fQbrWrm/OnXeRySkJR0wM/q0JgEIJpUKhOM6AQFGnjkGbbE1IFiFpQsiErhi4KWAO6QtnECfbGlUQcgOpcQLyiGqC5wqSQGY6AyrJCgCyyYAI8QScC6FoSB91J4FdGQivI9ndhNgIu9lalwCCeUa9JpKeVloqVWghhWIPrw+dlr5P9u3/Xdau/0X2799pBj7ICgM/alGwmo8/TF4qr758ZMg9FO/kjp0rpXDCn8ZegHrKPWdQh9BCpG+7tZesXhlZyC8qyiN33nOWDBrc1xBJ7gX3/WQkkrktTwq5RNWzvlirWB/rVaIARb5RkCFjqNeBQHtD9acEERMeJktMFiCgPG/+ziSN+o2BJml4MLGjVKxUSWIeuk02px6uzxouyMjO3LFLNj/1mjmWs+g7Cj7trmzndiIXtwzLO+kPigpdWLm6DLn4CvPeMrHjJxPVE8GqcCpDFUqFQvGvgRA02beQS9RDVD1Cz/yesByZmxA4SulYNTE3EL4j6QY/pbP+IyChJjl5jdzb8zF56KFHTGZ2nTrV5FDaTkNorRJEqJDj4p+E7EL8GKwZnFEvSQaCROK547MM3NTfS01Nkzf7TpKff1qeXQLFb+3t7JqD2drM5q2LZGXyN1K+fJkjlpBk6TrugT8mTlgs/ft+Z8Zh1i0PCsZpn8jZzapK7XoZ8u2343PCpqhXEFeUN5SrenWulVIl60iUJ5JB2CubtiySmLg/DXlHASsIRDIQsDUwccBviT+YNoGajCUCNZ3/P1ZAuYa8EsoOBLvKDG0UbzB+YkgvbZv2xrtAyZ7cVDusHBd07iSJzz6YL+e8sfeL8sZzz5v27FxViAS20td2Fs+5TcTjkvidWbqcFPt8orlOwt28q4FW51EcXyihVCgUJwRIILA1LvEx4r+CXEGAKImCYonf0rmebyBQ7oYEADK/bVHuLZv3yKuvjJCF87ZKbOyRfrS4+CxJXjNVfp09RkqWLG5qZzJQMUChGqKoQh7wpUFSUa7wozFYQ2AJF/Z9/S1ZuihG1q3bkTvhy4FPypQtLBWrbpP582ebARHSh8KCX9MSTJadQ3GCECz9bb2M/PRXmTdnjVEInceJjvZIVpZPKlRIlG7XNJdOnc/6x/OYnQ0MEcJyQHIRyVHlylWV+nXucBUehD+OGvOAJCadONnRxxoogbRPyCWJMCiIhFohcSiF+R1uZZ/WEuJP2JnMUC+S94PJAhUFUPYJ+wI8xZwXzz/YhvJqQt5r/pQFTWvnyzlvfvYNydi0NeDfEq+5XBIuPFc8IUwOc0OJtExZeu+TOX5siLfi34cSSoVCcUIBZYXQna1xSVgOcsmgyiCKJ4sae6hEwVYPQZWB/D3//IuSVKKZjPtq/lEkzHk8eEChQrFSqdoBGTL0eUMk2Qh3U2uStYdtcXMUP5QgBjLKrhSKjZc/lheV4gkVjlIlcwPnc0b9ivJav+6GnLE/68Vkw88JIC1OFbNK5boyfVqyrP5zq+zbd1DiC8dKuXIljKexcZPs5R+DAZWVtaLfHfCdbNwQG9b5Brpvter6pOd9nU3I+1TzrpHQArFE2YZoQuqs35J/c39or7kRuby2KXNnS3KRGKnauKFEF44Xb1q6eHbtkejlybJlzVqTBAZIdqGt8nzDAW0cv27hqpUk9t6b8+W+FB02VsrFxpkELfseMVlCxW/73OOyqlwJdwqlT+TQymRJ/2CUmXieqLVET0UooVQoFCcsGJRRACGXqIaoMdbwT0FjwuGolgzg/nj+uRfky1F/SNnS9cM6ZvLa72TLtuyl+wh1MhD6g+NTv5KSQaWTmkitGu0jImdwsHsfaCddrmwa0EMH+eP6IZgsIYm3E+JGrT8nyUSpCsc/9vyzY2TGtJVHrbccHryybcdvsnTFl6YUDQSfhB8K2B/LMHCkwMMXKpELRdWzG2QJFZuN8Dj31NZ0DOf+YumA3NG+C9esJlGtmoq3TrVsk4SZ9GRn2dNoKCp+cMES2TN5mjSvXM2cE0ombYCSObTZnH1BGANs/M2qnmu2bZELxw/Pl/t8wbw/ZfmChTlrdAMShWgXcXVqSLlH7na1f7yaByZOkTl9BwZ87xX/HpRQKhSKkwIQAkqQQC5JUmDwtuZ/QsMUasbLZ5NbBrw5Wb4ey6AWvnKWlrlARn050ITaLVCbCB1zbMLH+Cqp3Vejyo3ikcIRKXR8pVLlUvLhJ3fm+X3UJ1RLp4qJqsnvUaio/WcJJqFSkpBM5u2+fYbscL6W+Ewcv1F2bHeXa4vC2ua8unJO6wTjySScjprMuVDyBnKJFxWF1R+cVyTkzg0hpP2Eg2BELBg54yekEM8gCjvqGc+ULGS8q9RBZZISbB/WIzxs+ULpM+snifJESZYvuOLoy8oy+6+TvEl+fP1tsw/Uc+wYoYDC+pTz4rmRHFfy4TukUPXQVpgJBIqFNytXUZqu2GAiBEx+ACF4lizlfe3/Zn/5olSsbDp4IOLEHGpRDmnQUtq1Cu06FccPSigVCsVJBxJ2WEubkCMDoi3SjOcSD2T362+X5575PsK9s/xggowcfa9kZKSb7FFLIhkkUUXIEifbNzO9uDz52CjX19P/7RvlzEZVcj8rn88MypYUQhBJ1qBoNeSFeorU4uPeAMg2ZDOQStbkzJskKbGuqzC115sle/f/IalpC00WL/ceWwLnxXlAZAG/h3BBmPi7JYbhAMXTn7zlxxZsX0xK3IbwqfeJqk4bRWmGTNJm8ONC+gIlMX30D5kMGTxbj0dSR0+UH1970/hvgwFCTYknSCQbpXa4r2RIQ/7/KlZIRmXsETd4r21nSf/tdzOxW7hwofFxciwmOUyAqDjw077tknR99ipa4QIS3bRoooy90Z3KqTg2UEKpUChOalBsHLI3ZMiQnNqQtWpcJlUqtnTlEUwstU6+//EzQ+IIKUMG2Jx+wX6vT5TJ3y2JuE6kVfoan1VaGjYpbIgiRITEGcL7bBA0wt8skegsxWIBKYC0OYkQBNuqeYRkAb+3n6l02gVSptRZLj2UXtmwabr8vSl7fWinAsgxIJmQSM4FIs5zoe4mtSrJZqd8E58JhfSd7OVgUJbxWkIuIf5YBPBa4rm062nP2/K3XD3hs7BrNJoQu8cj4zrfKI3LHlbUAe1m0qRJhtQxAaMNsewpNV/ZUE55BngxG1Nh4Kme4osrFPY50IqS4ovInO53y6rf/zCZ17RJSDQli1iKERUbVK9bR8o+dZ9sSz9klkYM+Tq9XomNipJvu/aQ00uWCfMMFccDSigVCkWBAQPoiBGfybjROyQqKtaV+paZtU0uuaysqQNoB31/PPv0l/LLjFUuzjibmG3ZtkRWrBwd0ff9VTb//4dwQi4hddwfCKs3K17OOdtdmRgI6shRPaVM2ewMW/ZPpj6rDPlvkHILa1PgPCGXFHInUxrSXlBLDznJH9nYEEvUS2qhEhKHWC6sdZr8su3vsEiWM9zcoXpdGXBhJ6NWWxUSRRIizzEgkCiR/Nt5n3kWEEtI79uTvpHec38261yHoyBCaD+8tKtUy/SYagzUc6VoOlUW8DhTBoz94TnG9/x3yj65YvwI2X0oe73tPO9bltdMvIa1v1ouqFw97PujOD5QQqlQKAoUli3dIA/e6z7BgPG0Q5fCRtWBiDH4szn/fVrZdlIqyV3omBB7Ysl0OatZnCl/Ek7IFiUwEhJGVvLjvUfJ5k2ol+GfO2WKzmlZW5578aq8r87nM4qrJZcQFxKMVqxYccQ61dxDMnYJ27LkYZ06dXI2lM2ClkVubRsUT584c7qUeaF3xP5F4EGpfPsTWbtsuWkbVEOAROJjrVixYtDvUUcUzyMr7phkr7t6SGb788y55En1fNkKe9827WXT5Cny+OOPm2eFMk5lBvykPDfqt7I2OQlmFqyvfcukL2Xl7h3M4LLrUPnD6xOfRyQ2yyufXXGjNC9/eBEBxYkHJZQKhaJAYdYvf8ozT0am9vljxuwXJSrKZ1Q+yJv9yYbCVrxoC4mOqigeE/SLDPCkylWjpdFZ2Vm3bKh4zp+h/i6czy9fulU+GDwv4vN+rd910qhxVbO/SMkeYXIUOxKtIDTJyclGUaMcFGF0C1Y0chJMu9WuXduEbE92vPLrT/L+8oWGPEUKQsL1Nu+RB5q1Mb7IvNb/BtRURSGmZusDDzxg1penCPmb34yRgWuWyYb9e03L9gZQRFEWvTt2y7PNz5ePn33RrOVO8g1JWaynzUSCyQGF/ym7RQicqglOzJk7Vy64/WZp06unrMo6dBSBTd+wSapu3Ss/D3hfisSeeJUDFEdCCaVCoShQmD0rWZ5+3H2iDIgrNlt8vkwTFoTo2J/231FSQeJimrg+zp9rxsqOXSuOOEYgv2R+o1b19lKlUuuwCWHy2smybsP0I34HSXVLdiEheD5J6GHjHvB7mwXN/xO+d5JN69eEyLDZ1WX4N8Q0v4n4sSD4729dI3P27zyKuIUDSB7rW/c977KQPm98k40bG9KHv5GEGRRESvw0adLEhL1/3bROPl6xSH5alyy2NcZGRctFVWpIxzKV5JrmrcwzQYFkiUeIJL5fJl54NSGngP1RiQE/pRMs1YlSTZh+y8EDkrxnp+xLS5OPBg+WCZ9+JvXLnibz58076T20pwrclatXKBSKEwyJiUcvXRgJYmOjZcKEr3MlW2lpGXLNlW/LgQPZmdWRoERiEVm9drbExBw9aEKw/ElmIGIb6e8yMjLl+0mrZdbMjUYpzc3OZv+eVHq3VBMUqkomdM45otayghEbpZRYwQQS6O7cMgzpsUv3YT2AWBAWpyQSIVVCqyRl4dG0We9OIm79pFZVZrMk0//Ybu6lu3qeImXu7SGFGwX26YYKCGDKP9UOQlGGWYqU+/DJJ58YnyO+R0LwkD/ri2xdsZrZuL7/9e0rTz/9lLw3YIC0LFfTeCV5RrwfPItHH300pw4mSUdPPPFEzoSArH8IphOUViKZjoQdPlOxWHGzsYTk2Nf6m3Y069dflUyeRFBCqVAoChRq1y4vJUsWlV27DkS8D5YtbH1e3t7IuLhY6XB5Y/lq1NwQl1w8EvjPOl9xVkAyCTi+Vf6OFdq0aS0zpv8hoz+fIyuWbzTX7sxaj4r2iDfLJw0bVZFrrz9Xmp9TM+dvqIgsG+msjUlWMSAcjSpla2OSHR/KeuyBAKHBe0mJKNQ0wuT8jtqbt9xyiymqTtY42LRpU8DEoDVr1uRkokMyOT/WcHeG0OvWrWsK5kdyfm5I6Ysr5sm07RvDzq52AgJYNMjKUf5grXsqImAz6Nu3r6kVyapUhLyDtcMneveWDWvWyH/u/o9RVblfqJrjxo0zy1CShDN69GhD+GkDeEQh+EwuUC39V7SBODIBIdvdgmQlFgzgGVAOS9fnPrmgIW+FQlHgMOKTmfLxhzNcKUdvDrxJGpxZOc/P7dyZInfdPlT27T0YFqmEqJVMKiaDPrjdqJQnAtas3ibffbtYNm3aIwdSDkmxhHipXLmUXNaxkVSpWjrP73O/IW5OggkxgMjhoTv77LOPWOHHWTg+HJji7BMnGnJJMW9USsgJxJKNOo/+q/WgpqF2BiKbZCFbUIg9kF+T+qNcw7HA6/NnyHu/zYkowzsHPp90LFZG+l15fa5EjLqq7dq1M75JPte7d28ZMGCA3HvvvbnunpVvbr31Vlm+fLkhlHyX5R6xGDCxoNZms2bNzGdpA6xBz7MhrI46OXbsWBPiBkwOyOp/7733zDKqgEUDSCRiv/wdIqo4uaCEUqFQFDjs2pki1189MKL6kKiGlauUkqHD7gjZW7g6eav0un+EHDyYHhKpRAUsUrSQvDngZqlaLW+idjKDsPSCBQtyCCY+PVREQGjUSTAJt4arSqGEEa6FXLJBDiE5l112mSGX/ExKSsp1HxAjEoL8iSbEhmx+C0hOILIJmY1UfQXr9u2W80YNFVfw+WTjYy9LfHqmdOzY0RQXJ8Obe2HBfYfgsVGqCHX3ySeflJdeeinX58e63PgjUXTxsEIYQa9eveTVV181zw1VkefAO2MnEP379zcrBFEeiufOMwY9evQwxJb9YEOApLIPJiQQ19wKtCtOXCihVCgUBRJfjZ4r7w38MezvEX7u99YNckaD8EqUbFi/U5567Auj7kFKAxFLyu1kZfmkcuWS8tJr10qFCrkTnYIKSJ9TxYRwQlTwN0IsnCQTshYqsYeQEH615JL9YhdAsaQGIwQz3PWf8WYGUjXZ7Io/kEkUuUBkExU2lPO/8btR8uum9RHXobyocg15uHI9owSSTc21o9Ki+nXt2tWQS+p9Uiu0X79+hlCyqtTQoUODnh91LPFKQvwoVs695R63bdvWFGjnefEZbA8QdzyR3GOAAkkGOfedc2AfJO/wk/vyxhtvmMxyfLI8E4griiafVZycUEKpUCgKLD4cMlVGjvg1pM9CAtn++3xXadmqTkTHQxGdO3u1jBszXxbMX3vU3/EfXnHl2XJ28xrmWIpssJoOSRpOksla04BwqZNgEjYPtVQQSUN2vWpK5KBmQnQsuWR/kfpT8T9CjAMRTcgWfwckrAQimmyUQ7KY9vdauXnSlxE3ic87XCvnVji8fCfrqltySUkfa/+49tprzf3AL8nfAymrWAjwMhIKh9BD+iDPEEJ8kqx0hKKLRxbfKWoj9xPP5NKlSw3RxF/Jc8UjyXKTqMColoS48V3ae8Q+sTAMGzbMKKaKkxdKKBUKRYHGhPGLZOigKZKSciigcmhVw4qVkuTRJy6X+mEqk8Gwbds+2bxptxxMTZciReOMGlm6TEK+7PtUAIkcFEC3YXI8ehAd/Hsk+DhJJuQsrwLvEBqID2QKksmKQRThJjwMGUJNy6+alhAplLhAZBNyZkG2upNgrq5UWr4/dDjEHioePbuN9GycHU4OhFGjRhl1EosBRBNAzFmTntA4CUoWeBnJ+iY8TuklFFqSmEjeueeee47YL88GYso9JKubfb75zkCp0PY8eXny17LTmymxRYpI2v4UaV33DOlQrrLc3voiefH55024nBA6EwdC7oTeFSc3lFAqFIoCj/S0TJk+7Q8Z+9U8WfnH4QEdgtmqdR3pcmVTadSkaoFbjaUggWxoahY6VUz+H6D0tWjRIodg8u/cfJMoYxBUGxrHw0d4GHIEuUTBrFTp2KzKQomjQEtU4tckuaVE50ulxOUXB189xq+4eO+mreXexucEbbvWN8kqOJBJPIuU9oFcUyaIUDMEnZA154VqiR+SFaHYJ+WFPvzwQ/O9QEBtJKR+/4MPysJiMfJX2eLiiY8Tj0+OKNSeUww95YA80rKtfHr/IzJ3zhy5++67TXKO4uSHEkqFQnFKIT09U1L2H5LomCgpVjTe/FScnKA2pX/ZIogQIBQLubSliygrFCxxBjXRliSaPn26SSrBy2nJJetfH+vJBiFpVFnI5bcrl8mPB3bKtiKFDLH0eTzm+KyGQ/KNJzpaErbvkbPSPXJ+peo5CifLGzrPk+uw63STvc79Qu21GdQUkce3+Pbbb5uEGidq1KhhCCf7zQv93xkor6xZIvGn18ouWJr3xcqBeb/JOVv2y4Tx4yO5XYoTEEooFQqFQlEgACnD2+ckmCSSoG7iZaSsjVPF9K+NCCBd1FGEXEKo+H/WwoZYsqFiHq/6iKv37JIvVi6RtXt3y/b9++TQnj0ye+JkOW3LLqmakGjIJ6WQrD+SjG5nCJ2STSTKoEBSHB4vpa3XCQhnkxjz6aefGoWWUD3+R64PJZWEIkLiKJBka/M3f2R6vXLb92Nk+oY1hviGDJ9Prq5zprx+XnuNDBQQKKFUKBQKRYEFKhylaJxli1i5BZBw4vRiEhp2hnapXQkJs6FxlEyIqc1exjuIKng8AdljFRlUR2DL+PiH0EmOgQxbEMYmU9uSTRJhBg0aZIgjFgA8qHgk33zzTfN57hMJPWyEyvk+1wy5JBPbrhU+bPlC6TPrp4iLsg+6uIu0rxZZEpzixIISSoVCoVCcMkDNIxvZv2wR6hwqHeFtJ8kkkcWEm30+s+a0DY1DuACfsQXVySA/1qFx1EbIJOcbDPgmqeUIOSYJCBWSBBuIJn5RrsOuGgT4XMuWLc2+nQonoXGuZ9GiRTnkku9CqilDhHr5rmefbEjZFxGhxFfZvHwl+bzjdRHeDcWJBCWUCoVCoTilQTkhQuNOkklZG0DY10kwKZkDoSJL3LlaD0oovkNLLlmKMFCI2O163d2ffER+3LVFGpzfWrKio6RYbJzUSSotN9RrJM3KVTThfXyTCxcuNOrj4MGD5Y477jCEePjw4UaFJOMdlChRwhQZ5zytsknWNcqsVUOpEekkmbYQOde8LGWPlOudvdKNG/x01W1SK7GU6/0o/l0ooVQoFAqFwg9bt27NKVvERlY4RIy6laz84iSZKHnO1XpQCMk8J3OaMDE/nTUnwwVk8NM/fpNBS+bK+v17xZeVZRJz/DOoa5YoKeVXb5TPn+xjvsOa3c8884xRZClibhNvSE6iTE+fPn2OUlRRLglxByp5hA/Tgusp3eMaSa9XI9ds9LzAuZOl3qtp64j3oTgxoIRSoVAoFIo8ANGyZYsId/Pzjz/+MH/DX2jLFvETZW/KlCkmPI5SCIEjqcUWVEfJDBUZ3ix5dPokGZO8QqB+oYSW90/5Va5LrCADBwwwPsn7778/J8SN/5O6lKiT4QIVFgXTEsxR0QdlV1Kx0DK7gyAmKkqurt1AXmnTLuJ9KE4MKKFUKBQKhSICsM43yqUzVG4TYfBTQjApX0ToGZ/mzz//bLyPZFpbctm8efOgq/WgMj46Y5KMXrUsPI+izydXVa4lEx96Kof0UlcTDySZ7vkBQuvdxg2XRbu3u9oPCmWXmvWk/wUd8+W8FP8elFAqFAqFQpEPIFua4uBOgsmSkvyeVXjwX1IPcu/evSbRhZqZZInb1XrInsafaTEueYU8MPXbiM9n21sfStbK1WaVG1TKcAGhJRs8UPib60y49Wop3KSBeFyEvFEob6rXWPqc2zbifShODCihVCgUCoXiGIHlIlEnnWWL8GeCChUqGC8i9SD5HVnmJNRALjt16iR3z/tZlu3YKt4IcqjxWRbftV/mP/RMnnUz8YZCEMke9yeOztJDZLyjuNoEnbWnJcnYvVsiLhlk8eYFHeXKWme43Ivi34YSSoVCoVAojhNQ/Uh6caqY+CzJrMZrWaRIERMij6lcQU575gHXx5t+zf9J1eJJZv9krgdSGzdu3JjzedY3d2Z1241sb1t70mLXoVRpNvI9U9w8UhQvFCfzb7hH4qIDr2KkOHmghFKhUCgUin8RFCdnVRtLMH/99VdJadlEil147hHZ3OHC4/NJmZXrZe/4703xc3yPAGLoJItWdaxdu7ZJMAoHD079Vsav/t1kmUfin7yrYXN5rNl5YX9XceJBCaVCoVAoFCcYbpnwuUzdssHdTrK8kvT3VrnogBxBIAm1szJOfmDV7h3Sadwnkp6VFVboGzJZLLaQfN/tVilfNCFfzkXx70I1ZoVCoVAoTjB4XSiTFlEx0dLmwgul30WXy7ECRdXfvaiz3PHjOFPTyBcCrYzyeEwyzrD2VymZLEDInymKQqFQKBSKfEOJuHhDvNwgSjySUOjw2uTHChdXrSXD218lhWNiTK3MYPD8syXGxcuXnbrLWWUrHPNzUxw/KKFUKBQKheIEQ72SZVzvI8vnzZf9hILWFavJr9fdJU80P18qOELYTlJcvUSSvNDyYplxzZ3SsEz543JeiuMH9VAqFAqFQnGCYVtqipzz2fsRJbtYkDm94IZ7jotK6b/m+OzNG2T9/j1yICPdrDdeM7GkNC1b4ailHhUFB+qhVCgUCoXiBEPZIsXksmp15Lu/VkWcQX117frHnUxaVbJlhSrSUqoc92Mr/j1oyFuhUCgUihMQdzdqEdH30ABJermtwdn5fk4KRTAooVQoFAqF4gTEmaXLSb/zO5h/hxooNokvHo/JvCbMrFAcL6iHUqFQKBSKExjfrlkpD0ydYLyJuYW/CTUXioqW9y/uIhdWrnFcz1GhUEKpUCgUCsUJjvX79sjw3xfLZ3/8Jvsz0iXGEyXkt8AvM31eU4rnxnqN5YbTG0mFYsX/7dNVnIJQQqlQKBQKxUmCQ5kZMnldsqzbZzOoC0mNxJJySZVaUigfiqErFJFCCaVCoVAoFAqFwhU0KUehUCgUCoVC4QpKKBUKhUKhUCgUrqCEUqFQKBQKhULhCkooFQqFQqFQKBSuoIRSoVAoFAqFQuEKSigVCoVCoVAoFK6ghFKhUCgUCoVC4QpKKBUKhUKhUCgUrqCEUqFQKBQKhULhCkooFQqFQqFQKBSuoIRSoVAoFAqFQuEKSigVCoVCoVAoFK6ghFKhUCgUCoVC4QpKKBUKhUKhUCgUrqCEUqFQKBQKhULhCkooFQqFQqFQKBSuoIRSoVAoFAqFQuEKSigVCoVCoVAoFK6ghFKhUCgUCoVC4QpKKBUKhUKhUCgUrqCEUqFQKBQKhULhCkooFQqFQqFQKBSuoIRSoVAoFAqFQuEKSigVCoVCoVAoFK6ghFKhUCgUCoVC4QpKKBUKhUKhUCgUrqCEUqFQKBQKhULhCkooFQqFQqFQKBSuoIRSoVAoFAqFQuEKSigVCoVCoVAoFK6ghFKhUCgUCoVC4QpKKBUKhUKhUCgUrqCEUqFQKBQKhULhCkooFQqFQqFQKBSuoIRSoVAoFAqFQuEKSigVCoVCoVAoFK6ghFKhUCgUCoVC4QpKKBUKhUKhUCgUrqCEUqFQKBQKhULhCkooFQqFQqFQKBSuoIRSoVAoFAqFQiFu8P/tCbKSnTzLgQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import io\n", + "import urllib.request\n", + "import zipfile\n", + "\n", + "# Request the football dataset and read as a networkx object\n", + "url = \"http://www-personal.umich.edu/~mejn/netdata/football.zip\"\n", + "req = urllib.request.Request(url, headers={\"User-Agent\": \"Mozilla/5.0\"})\n", + "sock = urllib.request.urlopen(req)\n", + "s = io.BytesIO(sock.read())\n", + "sock.close()\n", + "\n", + "zf = zipfile.ZipFile(s)\n", + "txt = zf.read(\"football.txt\").decode()\n", + "gml = zf.read(\"football.gml\").decode()\n", + "gml = gml.split(\"\\n\")[1:]\n", + "G = nx.parse_gml(gml)\n", + "\n", + "pos = nx.forceatlas2_layout(G, seed=42) # for a reproducible layout\n", + "colors = [G.nodes[n][\"value\"] for n in G.nodes]\n", + "nx.draw(G, pos=pos, node_size=150, node_color=colors)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ryandewolfe/miniforge3/envs/abcd/lib/python3.13/site-packages/powerlaw/distributions.py:743: OptimizeWarning: Initial guess is not within the specified bounds\n", + " result = scipy.optimize.minimize(fit_function,\n", + "/Users/ryandewolfe/miniforge3/envs/abcd/lib/python3.13/site-packages/powerlaw/distributions.py:808: UserWarning: Fitted parameters are very close to the edge of parameter ranges for distribution power_law; consider changing these ranges.\n", + " warnings.warn(f'Fitted parameters are very close to the edge of parameter ranges for distribution {self.name}; consider changing these ranges.')\n", + "/Users/ryandewolfe/Research/abcd-graph/abcd_graph/abcd.py:422: UserWarning: Typical degree exponents are between 1 and 2, got 2.39348027429513\n", + " self._validate_params()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ABCD object parameters now match those in the fitted graph\n", + "n 115\n", + "xi 0.3572593800978793\n", + "outliers 0\n", + "eta 1.0\n", + "dimension 8\n", + "rho 1.0\n", + "degree_exponent 2.999999999999999\n", + "min_degree 7\n", + "max_degree 12\n", + "community_size_exponent 2.39348027429513\n", + "min_community_size 5\n", + "max_community_size 13\n", + "degree_sequence None\n", + "community_size_sequence None\n", + "alpha_max 60.0\n", + "alpha_min -60.0\n", + "alpha_iters 10\n", + "rho_tol 0.05\n", + "model configuration\n", + "max_swap_attempts_per_bad_edge 5\n", + "rng Generator(PCG64)\n", + "logger None\n", + "verbose False\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAH0CAYAAACD0737AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeUU8UbxW+SrfTepUtRERCwAWJXROwde++KBXvvBTv23rGiYEEERVSUjoDSe+9l+27y/uc362AI2d3sJlH8O/ecnN3Nprw3b97Mnfvd7xuf53meHBwcHBwcHBwcHCoIf0Xf6ODg4ODg4ODg4OAIpYODg4ODg4ODQ9xwCqWDg4ODg4ODg0NccITSwcHBwcHBwcEhLjhC6eDg4ODg4ODgEBccoXRwcHBwcHBwcIgLjlA6ODg4ODg4ODjEBUcoHRwcHBwcHBwc4oIjlA4ODg4ODg4ODnHBEUoHBwcHBwcHB4e44Ailg4ODg4ODg4NDXHCE0sHBwcHBwcHBIS44Qung4ODg4ODg4BAXHKF0cHBwcHBwcHCIC45QOjg4ODg4ODg4xAVHKB0cHBwcHBwcHOKCI5QODg4ODg4ODg5xwRFKBwcHBwcHBweHuOAIpYODg4ODg4ODQ1xwhNLBwcHBwcHBwSEuOELp4ODg4ODg4OAQFxyhdHBwcHBwcHBwiAuOUDo4ODg4ODg4OMQFRygdHBwcHBwcHBzigiOUDg4ODg4ODg4OccERSgcHBwcHBwcHh7jgCKWDg4ODg4ODg0NccITSwcHBwcHBwcEhLjhC6eDg4ODg4ODgEBccoXRwcHBwcHBwcIgLjlA6ODg4ODg4ODjEBUcoHRwcHBwcHBwc4oIjlA4ODg4ODg4ODnHBEUoHBwcHBwcHB4e44Ailg4ODg4ODg4NDXHCE0sHBwcHBwcHBIS44Qung4ODg4ODg4BAXUuJ7u4ODg8M/B88LSl4uv0m+TPl8bkhzcHBw+CfgRl8HB4d/FbzCGfJyh0gFk6SiWZIK/vxPiryU1lJqZ/ky+0qpXeTz+f7ho3VwcHD4b8DneZ73Tx+Eg4ODQ1nwCsbL2/yAVDRdUkBSsIRX/vm/QCv5qg6QL+MA17gODg4OSYYjlA4ODjs0PC9f3pZHpJy3GLIkhWJ8J6/1pIxj5Kt2u3z+Kkk+UgcHB4f/LhyhdHBw2GHhhXLkbbxQKphQDiIZCb+U0ka+Wm/I56+Z4CN0cHBwcACOUDo4OOyQ8LyQvA3nSwU/x0EmLQJSSjv5ag+Wz5eWoCN0cHBwcLBwZYMcHBx2TBDiLvgxAWQSBKWi3+VlPZ2Az3JwcHBwiIRTKB0cHHY4eEVL5a09PCyDO1HwyVf7U/lSd0nw5zo4ODj8t+EUSgcHhx0OnknAKSmLOx745WW/koTPdXBwcPhvwxFKBweHHQqelyflfpAkQhmU8r6SF1yXhM92cHBw+O/CEUoHB4cdCxQs97KT+AVFfyb6ODg4ODgkCm6nHAeHHRy5wVzNy5qvBdkLtTJvlYpCRUrxp6hBRn01r9xMrau0UmYgU/83KJzx51o3Eck40ZAir3B68W46Dg4ODg4JgSOUDg47KJblLteIVSP145qfVOgVyv9nQMGTR2qJ+T2kkFJ9Kepep7sOqX+gmlRqon87vKI5fxYlTxaKpKLZSfx8BwcHh/8eHKF0cNjBgAL5+fJh5gFxhDQC+9OSSotCr0g/rBmj0Wt+0JENj9DRjfsq1Z+qfy283CSqk/Y7khlSd3BwcPjvwRFKB4cdCJsLt+iRWQO1JGeJoYzhxLE0WLI5bMWXmrJxqq5vd42qp1bXvw2FhYXKycpV5RTJn0yRUv9iwu3g4OCwA8LVoXRw2EGQVZSl+35/0Pgkw9XI8oLQeN30urptl5tUNbWqdjR4nqc1a9Zo1qxZ5jF79uytv8+bN093Xl9d111SU6mpyWKUKVLmMfJXvz9Jn+/g4ODw34NTKB0cdhCS9dL8V+Mmk4D3r8lfo+fnvaTr2vaXz5dUqa9E5OXlae7cuVvJYvhj48aN5jUcW7NmzbTzzjtr9913Nz/XbVqg1NREFzQPR1C+1N2S+PkODg4O/z04QungsAPg53W/mFB1ogCpnL55hsas/Un71e2hZBLhZcuWRSWNixYtMv8HNWrUUNu2bc3jqKOOUps2bZSammoI5+jRo/X9999ry5Ytqlatmmof3VMhb478Pi9ZRy2ldkvSZzs4ODj8N+FC3g4OO0ASTv8p12lz0ZaEf3blQGU92Xlg3Ek6kD0bmg4PUfN7dnZxgktKSopatWplSCOE0RJIHnXr1jXEc+TIkfr222/NzxUrVigtLU377ruvDj74YPPo0qWL+ZzQhkul/O+SUNzcL6V2kL/2hwn+XAcHB4f/NpxC6eDwD2PyxilJIZMgO5itCRsmaZ/ae5X52mAwaFTFaGrj8uXLt76uXr16hiRC/k477bStpLFFixZGdbTYsGGDUR4HDx5sSCSfQ4i7c+fOOv300w2B7NGjhypVqrTdsfgqnSUv/1slHiH5Kp2dhM91cHBw+G/DEUoHh38YY9b8aBJp4vVORgNlh/j8cEK5fv36qKSR8HNBQbF3MSMjw/gZIYrnnHPOVtKI8kj4uiTP5JgxY7YqkBMmTFAoFDKqJeTxnnvu0QEHHKA6deqUfdzpe8nL6KtQzjD5/YkJfRcWefrtjww1bL+7mvz7y3U6ODg47FBwIW8Hh38QeAwvnXSlcoI5SfsOf5FfvldCmv0ncVy7du3W/+20005RQ9RNmzaV3+8vU9GcMmWKIZA8fvzxR0MqCW8fdNBBhkTys3nz5uU+5qKiIt12yxW6ot9w1a4VUGpKfIlFRUFPoVCa9jtms+YuyNZLL72k448/Pq7PdHBwcHD4C06hdHD4B7GhcENSySQIpYQ0e+kfatmshQ499NCtpBEFsnLlyuUiv5T1sQTyu+++M2onIetevXrpvvvuMyRyt912K5OMlgZC5SeddJJROT8fkqpxw1srNSVUYT+l5/lUUBBS71MX6b4HP9ULL7ygE044Qeeee66efPJJValSpcLH6uDg4OBQDEcoHRz+4ULmfwfe/vhttarSstzvW7VqlUaNGrWVRC5evFiBQEB77bWXLr/8ckMg+Z3kmkRg5syZOvLII7V06VJDYM+/+EFVanKUvA0XS8HFxRna5YJfvkAdzVh2lsZOuERHHHGE8XXy88orr9QPP/ygd999V926uaxvBwcHh3jgCKWDwz+IWHfCift7vFDM2dyQLJuNPW3aNPM8quOxxx5rCOR+++1nyvskGl999ZVOPvlkk7jDjjmvvfaazj77zwSaOsPkZT0lZb/y56vLOp9A8WsyT5Sv6g3aq14VffVVc/Xu3Vv777+/IcmTJ082SUVkmd99990aMGCAIcsODg4ODuWH81A6OFQQ69dna9GitSrIL1QgJaBGDWuoYaMa5SokTgHy66bemPRr8GCH+9Qws8F2z0Pcfv31162JNL/88ovxL+KttB7IAw88UA0bNkzasaFEPvbYY7r++utVu3ZtQ2rff/99HXPMMdu/NrhSyv1QXs6HUmhl9A/015Yyj5Mv82T5Uppu8y/O8/DDD9/6e/fu3XXHHXfowQcfNET5rbfeMufu4ODg4FA+OELp4FAOzJ27Sp9/Nkk//TRbGzds733MzExTp05N1ffoPdStW0v5y9iQGjJ10cTLlB/KT9p1SPWl6sWuz8rv85vvmz59+lYCSVHxrKwsk7kNcbQkEn/l37HDDkk8F198sd544w01atRImzdv1ueff26ywcuCF1ovFc7QDddfqA4ddtPpZ14mpewiX6Beqe9DncRLCr7++mtzzrQDpYxoCzyWeDgdHBwcHGKHI5QODjFg5cqNGvjIV5o0aaECAb+CwZJDroGAT8Ggp4YNa2jADX20e8dtVbJIPPDHw5q1ZXZywt+eVKugpnab3d4QSMgUvsj09HRTA9ISyD322ONvD/euXLnShNEnTZpkaltCLgl7d+3atVyf065dO/Xp00cDBw6M+T2WVEKw+U5+Jxnooosu0ocffmhC7U899ZSqVt3x9kJ3cHBw2BHhCKWDQxkY/vVveuLx4aZMDkQxVqBOhkKejj+hmy66+EBDRKPhhzVj9MqC15NyHSBMvzz0s+Z8OkuNGzfW0UcfreOOO874BjMzM/VPARLJseTn55udcSCzI0aMMOSwvEBN5Zweeuihcr2PLPVDDjnEtNGwYcOMv5LfUUuvuOIK1a9fX++8845JOnJwcHBwKB0Vr+3h4PAfwMcfjdfDD32hgoKicpFJAJkEn3w8XvfeMySqqrlu3ToNe3yoCrMLlQwE84qUOyXbeAUp8fPcc8/p/vvvNyoc4d3yojAY1B9rVmvMooX6YdFCTVm5QrmF5Tt2ds5BHa1evbr5GxXwp59+qhCZBHg+K6KuElaHxBLaJ7N86NCh5nfUSRJ28HPSbpRDYjHh4ODg4FAynELp4FACRo+eqbvv/DQx7eOTjj22iy6/oti7t2nTJpOI8vjjjxtV7NynztfGXTcn/FrsUdBJn976sfEIdujQwSSe4KHkb2pQUo/xrLPOMnUkS6odmV1QoM9nz9QHM6ZpxprVKgptS4xxWraqWUvHtNtFJ+3aQXWibKUI2DWHBJh7773XKIPjxo0zu+jgY6QYekVBEXZIIJnaFYFVKjm+Tz75ZGsyEAlLfCYEHGJJwk6zZs0qfJwODg4O/89wCqWDQwkZ3AMf+TJxbeNJn34yUT//9IceeOABs+/1ww8/bDx78+fP1+NnD1TLyi3NFoyJAJ/TvFIzXd79UlN3kQc+xUGDBhlV9OmnnzZZ1exuQzJOy5Ytddttt5ntFy1Cnqc3p07WXq88r1tGjdBvq1ZuRyb/PDXN3bBej/3yk/Z99QU9+ONo5RVtq1qihkJeUfsgf3xvp06dDJmLh0zGo1CGK5UkKUGoCZ1/9NFH5nn2JWe7SNqOPc47duxoss8rChYO2UXZ2liwyfzkbwcHB4f/FziF0sEhCh6473ONGvX71rB1olBQsFnjJjyhCy88XzfffPM25XjW5q/VzZNuV66XK39KxYllqCikDF+67ut8j+plbEvWCC1DkoYPH6727dvrlltuMWVy3n77bROKJssaf+XxZ56hH6tX0ZTVq8r9/SiWTavX0LN9jlL7OnW1cOFCHXXUUVqwYIEh0OxOQ2Fxvo89w+MFXkeKlHMu8QDiiFJJeJti56eccsrW/23cuFGXXHKJIZRnnHGGnnnmmZhqcW4p3KIxa3/S9E0zND97gXKDuVv/VylQSS0rt1CH6ruqR93uqpLiduxxcHD498IplA4OEVi/PispZBKkpVXT4MHfGoUwnExC5F567CV9eOp7yt+Qp1ApWeRlKZO+fJ8+OeMjTfp+4nb/J3RLiJl6k6iklMq54IILjKeR3Wnee+89Zdatq8eXL9HkFcsrdAy02tLNm3TSh+/pja+/MrvQZGdn6+qrrzZh/n79+unjjz9OCJm0CiWJPfGCgud4KlEqKXhOQo4FZZUgmW+++aaGDBli1NWxY8eW+FlZRVl6dcHrumrKtfpgyUeasfn3bcgkYMvN6Ztn6P0lH+qqydfojQVvKbsoudtwOjg4OCQLjlA6OETgqy9/U7KikWR+//zTYhUUFJgdaW6//XajCNaqVcsolnmr8lRpaIaa5DQyr4+VWNpQeddaXfTE3gPVfZd9TfiW0HI0kLn8xRdfaPz48SYZBh9l586dtSUnR77jj1JGndryxRFGDnqecgoLdceUiWrXtaup64h38qqrrtKrr76aEAK49buCwYSVPIJUEv7m8yDbZHxbkLCDOjllyhSjivbs2dN4LCG04Zi68Tfd+NstGrPmJwW9YJnloPh/kRfU92tGm/dN2zQ9Iefi4ODg8HfChbwdHCJw7TXvasrkRUlsl5B+GfeAcnKyDZFEwSMUjY9xzJgxJpRK0sypN5ymzud0UZ3OxWHrgC9gCIpFQAEFVfx3+6rt1Lvh4epYo4P5m5qOlMEhW5lQLopaaeB1EL7vCvNV/aD9E1bU3Od5qpOTp3E332ZC7YSlK/LZBXmFmv/7Us2ZulgrF69TsDCojEppatqmoU4+9xjdfNf16t+/vxIFvJ3UpoQsvvTSSzr//PO3+T/Pcz602T777GMsA82bN99aAsonX4XqivI+cEHL89S9zj4JOx8HBweHZMMRSgeHMJAocdSRjyknpyCp7dK9h1/HHHuIKU2D0kXpHBRL/uYYeI4C5CTJfPnjl8rYuZIWZi/SvA3zNGXaFLXbuZ12abiLWlRupvbV2qtBRv3tvoMtDEm4Wbx4sSGqbdq0KfWYZq5doz7vvpmU3cX7BtL05GVXlPt9S+eu0rDXf9Dw935WXk6BIaOBP/2lqMjBomJCnVktRf3699Whp+yrqjWiZ5nHQyopt8SOPpFgIUAIn6Lod7xxl6Y2Kt77PF5ALK9uc4U61eiYkM9zcHBwSDYcoXRwCMPmzbk69ugnkt4md91zvNq2rWmII8W9CU1TeBywcwtJK/gdSQaZNm3aVlWPBBe8j3j92OWmLKxdu9aUCsLDyHeUtk81mdyUBiJcnUhw5B3qN9CQk/vF/B72R3/n0S/14SA8jew8VHbonzaqXC1DVz5ymnr23UOJJpX4Xi+//PLtXkMJqEuvu1ShU/xKrZKaEHUXQknSzkO736eqqW63HgcHhx0fzkPp4BCGwsK/p4D1Rx99rD333NOokJTSoeg4STGoingpCYOTOIMqFk5Q7O/UTIwFderU0TfffGPeRwbzmjVror4uq6BAn/wxI+FkEvCJlByiIHosWLN8gy4/5EFDJlFrYyGTW8vybM7V/Re+ooFXvamiBFxLSgrRfng+2T2HuqGRoED7PgO6K71KesKsAoTLSeJ5Z3HFyxQ5ODg4/J1InDPeweH/AOnpf88t8e47b2nN2oXmd0KmkSADGtL42muvmW0Ba9asaTKNbfHxL7/80mSG87z9Hz8hN5EFyps0aWISTcjkPvzww43qFlnyZuqqFcpP4m4wfvk0dukSta9br9TXrVu5UdceNVDrVm6qUJ1G+5aRH45Tbna+bnrhvBK3vCwvqUSpvOaaa4xaSQ1Pi9V5azR+w8RiKTaBCOG1XferTtrpeNVKq5XYD3dwcHBIMFzI2yHpyC3aok2FaxRSUGn+DNVMa6iAb8ddyxDyJvSdTEye8ow+/uRt7bLLLsZ/R2ib8PSFF15oSOGKFStMeBoVk//xGh68BiWzJKCQQRYjiSYPMsvZchGCeeutt5pC5/Z/Q1cs0/PTpphi5smAFwyq0ZZsPXLwYSaJJZqShxLZv88jmjd9aYXLJoWDrzjtmiN0+nV9lAiMHDnSEHIIJaoySjIYvORDfb3iG0MAEw1C330b9dHxTY5N+Gc7ODg4JBI77qzu8K8FytLSnN81ecPXWpj9m7YUrdvm/36lqF5GM7Wr1l0dax6iKik1taNg2bJlqlotpM2bIVYJlpz+RDCYr3fefdkoX4ASNOD11183RPKGG24wNRvxSRL6DgdkEqLJvtN4LC3RDCedkX/zO+/jd5RPEn3YrSYctU8+QVX37CZfSmLK70SCEkTL83LNMe+8884688wzzYNtEy0+fWGkyeJOFODG7z3xlfY5fHe12q1k72isOOigg4y/lex5stUh6HfeeacmbZicFDJpQ9+TN0xxhNLBwWGHh1MoHRKKZTkz9cXyp7Umf5H8ChhVssTOZwibT51qHqaD6p+j9EBisnPLA8gWZXVQnwgLz5w5U40b7602rfsmzA8XjlAoqFatq+nlV67c5nkSc9q2bauuXbsaogIBnDhx4nbHAOFFYaSGJIk7FQGFzdm5pk+fPoYQkVTyzJyZmpi9JSkZ3hbB1auV88KrpqQRSUIsPFBTKfDepEFTpc5uLXmJbXN/wKedOzXV3e9erPT0dKWlpcV9XcOVyptuv0nL+6yuUImgWEGN0Re7PqtUf2rSvsPBwcEhXjiF0iEhCFGYefVbGrv246219Eojk6B4EvY0ZcNwzdnyq45tMkBNK++W1CsCcfv5558NeYQYUNgbryI1IMmaJot3woQpWjCP/aETP4H7/QFdccUx2z3/8ssvm/I+r7zyivHqUaYmGvGx/sh49oGGDLHry8knn6xGjRqZbQSHF+Vryu/To+7VnSjUr1VbR1x2mbkGJB/98ccf+v333zVr1iwVLquknau0TrgmHAp6mjVxkRrVaq7s4AbzHKQSpRaCGe0Ry/9OPfVUs5POC++/oCP7bH89E3oOCml1/ho1ziwudu/g4OCwI8IRSoeEkMkhSx/RH5uLd2Upr1rjKaTsog16Z+EtOqHprdq5arfEHVsoZHY2gUDyoHRObm6uyX4mhEnBan6imj300EMm1AyRa9b0EO3UpHtCVUrPC6lVq/raveO24decnBxTIJtdWKhFWalSJUNYoqG8Wd4l4YQTTtALL7xgtl3EQ9nq+GMVTCKZxEO5cOIkffzbDHXs2NE8UEn5yfXo3/sx5W7cdseZRMHn9+mSk69Xh8MaGzIb/uC6Rz4X/jw2gZJeX7lyZQX+piSugmBy66I6ODg4xAtHKB3ixvAVL2wlkxUFJBRi+dHie3Vmi4fVuFLbin2O52n+/PlbCSQZzevWrTMkjXqM7G4Cgdx9992N2jdhwgRdd911+vTTT5WZmWm28WPHk7vvPkufDVmtdeuyEranN8f2+dAH1G90a7PFnwUKIcdIogzPs+Ufhc5LI5TxKJQWkGlC/mQsX1OrprwkjgY+v1+99+iizKo1NHXqVLMfNmFv0KBeI3XyH7NV2U40vJCnok2pxrMZ9f+eZzLmuQb2QfJT+N/hDxYA2AT4mVaUrr8DAX9yvK0ODg4OiYIjlA5xYV7WRE3a8GWCWrGYVn627FFd2GqQUvxpMb1r9erVGjVq1FYSuWjRIrMXMxnSl156qQll77333ibUab7F84wSeP/995tyMCh01BkknPnggw/qoosuMq/ddbcluu6ad03QMREJOh07VdKYnxaZZJxzzz3XbOlH6JfvhNzNmDFDy5cvN99fEhJJKAFkGhXugRtuVNuBDypfSYLPp0+eeEIXnnSyIe9kmEP8IZdjvpqgWV9sVjIxe8pCDbh+gNZvWL8dcaQGaOR+3ID+gJLN7kX20bp1a/PTPl+lThUN0TAlG3XT6yT9OxwcHBzigUvKcagwikIFGjTnPGUXbUxoUgJKVfe6p6hXveg7q2RlZRlCaBNpfvvtN/P8rrvuatRHCGSvXr22q7UICSOZBSI5duxYszMNyhRJMNQXJLuakj3huPnmxzX2p2zjfawYirPFTz1tH513fi8tWbLEEErIFP7FY4891vgm582bZ0gmiiEFzUsChckhY5CyY45JjHevsLDQZC5Pqpyp6vv3NBnZiYQXCilv9hzV+G6MOX9UYEjzgAEDTBt8/+kEPXTpa0o25maOUM06NbYjifYR+TyqdmmAkA4fPlxfN/hWvirJUVdB3bQ6erTTQ0n7fAcHB4dEwCmUDhXGH5t/UlZRcaJDIgE5Hb/uc3Wvc6JRKSE848aN25pIAxlEUSLbGfJIyBYiSbZwNEBgqL/4wAMPGPJJNjVEhozps846y4TBo21J+Mknn+jBB6/Veeddp80bd9L69dnlDH+HlJaWqksvO1h9jyreCpAyOZTt6d+/v5566ikNGjTIFBzHmwc5efXVV0v9xEQqlHwnhdMfeeQRLViwQI3atZN69VAywt1n7dZRH4/4zoS5aQOSkJ5//nmjzO7f8Uj9HZg0aUpc+3xbPy5F5Xn8+uuv5rm+TxytmnvVTsq+Y2R471J9l8R/sIODg0OC4RRKhwrjtfnXaEXunKSVTEmbvqt+ePt3U9YHVRL18MADDzQkEgLZpk2bUpNmSJx488039fDDDxsSt9deexlCM336dJNJzfMkhUTDmDFjzFaFRx99tN577z3l5RXq5Ze+1xfDphqCWhqfI/nG5/Nrjz2aqf+1vdWoUfQ6m6eddpr5bIDqCMGjDmVpyhiqGEraxx9/rOOOO04VAaosZI5tBLELnHjiibrxxhuNwrvf1VdqZZtWCUtG8vt8OrbdLnrkkMNNu3322WeGwKLCch4k5FT1GqhTtcOUTHA+ny18Qqlp5VtD45WkHigEkhqUK1euNP5W+gZll8iYz6mao3v+eCBpx35q4CQd3iW57ePg4OAQL5xC6VAh5AdztDx3dtJaL1gU0vgFI5STU9PsSAKB7NKli/FGlgVI44svvqhHH33UELTDDjtMzZo1M+omyTgogRDKkkApGzKQ2dEFQkryTqVK6bryqsN09jn76euvf9MvY+dq9qyVys39K/uWLf6ys1cqGFqrV169W7vu2qLE76DOJAooiTioXmyvyPdAuErK8I63bBB+QVTRp59+2rQR6ixhZwqNW1y6T3cN+PVnZbRqYZTFeBDw+VS/ShXd2rM4AYlrBwnmAUm766679NNPP8lLjb6/eCLRpFW9mMgk7YqX1aqQVAWACEO2ycLHGkBxduvHte9pVqmpluQsTWiBc5/n0+a5m9T79MPVt29f3XHHHeYecHBwcNgR4RRKhwphcfZ0vbXwxqS2Xo3UhrqszUsxv57kEjKmn3zySaMsURoHEjN48GA1aNDAlOYhg7o0UgrR23fffc2WhaiUkZ7KcEAkyALPzy/Uxo0bdNxxfVRYWGBICCH10nDxxRfro48+Ml5KCo1TEzI1NXWrnxGySVJIJPBYkkT0wQcfGGUxFnBOAwcONCQb4F/EM4plIPxcUA7xke7UqpWKjjpC6U13qjCphEzWrVRZg084RU2qVTMeUawK9oH1gHAxpXdqVK+htkWHmW05kwGI/oEn7Klrnjgj6v9Rv0nqsiQSnycqMYsYisdzPViQlIaF2Yt054x7EqrWE+6+o/2t+vGzMcaWMXv2bKOKQiwjd1BycHBw+KfhFEqHCmF9wfKkt9ymwlUxvY4wJOHbZ5991ngr2VaQsCR1FgGT8VVXXWXKApUGyBrkARDeLI1M2jBqnTpVDXnt2/dEbd68KSYyCbkiEQdPJ4lDhJ/xUaJOEs7nuyHAbK/Ys2fP7b4zVoVyzpw5prYmKivEjYzuK664woSaw0Gb8TzHgQVg2rRpurdRUz0xcZIqd+ti8ttjpkl/7ljZyPOp55r1uuyMM0x4m2Qi0K5dO6P8kn3Pz/bt25tzuer4uzVv3Br5kmBEZI/w/f70sJpD9DzTNpZAjh492iRmodSinkIiKTEVjdCXhOaVm2m/zB4anTsmYcfN/t3NqzZT89ObGdWahRF9meoF9FOIJTYOBwcHhx0BjlA6VDjDu7iUTvK2nKMuJUXT/b7oiiKJJKhqJLKwe8lll11myBzPQTIhLYSU69atW+Z34bck45pEHUghGeCxAA8g4UiOhczzVq1alfketjvEM8nxsksMtTLffvtt1apVS5MmTTJlhNgrGlKDkonqalXVWAglIXQ+g0Qkvue+++4znxOttiVli1BHsQGQfY5fFW8p5Nyfm6uCBYuUftjBUvVqRnUMlvC9tif48vO05vMvtOCnsZpUpYop18R3Qx4hP5yjBUQcNZkw/Nqlm9Wzbsmh/nhQt3FNtd+ruVGCLYmE1NNnqPtJf4GghYf+ywsU15sPu1Gd+3dRvf0bxH3MB9bdX30aFi9uANcfzy3Xiut69913m7bFzgGxpH0dHBwc/kkkIS/R4b+AgNlXOJk7P0NS/FHJJB5HilRDAJhcb7/9dpOtDGFAiWSiZVs/yEosZJLQK59HKPbzzz/XLrvEllVLePqkk04ye25DUjp06FDme0gIYss+iC6KKWFoStQcf/zxW19DggznCKlFNWzRooVR1MoilBBhQqKdO3c2GchkkEN0yYKPRiYhzyigvA8yDbG97bbbTHicupwoi6NefU1bnn5O1UZ8p8NbtFKjKtt/TtHmzcr6bboCw79V99/n6IpeBxivJ5+FVxLyA2GzZHLhwoUm5E5mPSF2iPOY8SPVs+8e8gcSPyStTZ1j+gHHgAqMfxb1lwQn+syVV14ZF5lkK0/KVDVu1Fivn/2q+jbsY0pfEbIuD3g97zum0VE6s/npUROjIJannHKKUZHff//9rRYNzgk/qoODg8M/BeehdNhhPZQ10xrq0p3/8lCy7zZhYmow4v+DKBH+Q6GhQDnJEiTiQChjBcQMcgP5xNMYa+a0JaF4GUmoKS3JJxx8PgrizJkzzWdAGs855xxz3JGw9RoJj0PQOPdLLrnEhMnZi5swKMePukhtTTyfJI/cdNNNRsmCFJYECopDPvlcMpUpsk4pI4g5BBaiBQmD/JGJTgINiSgosqGUFFWtX8+Ex/fs2EkH7L23aXOIsQVbWPKZJLiw8xCAoD722GMmQx07AcolKq1Vgzeu3aILet6t7E25CSmLFPJCWl+4VFV3z9YRfY4woWxC7IncTpO2h4zjaYSk2tqnc7fM1YvzX9Wq/FWGKJaarMO//FK91Hq6ZOcL1bJKyclc2701FDLtCWlnsYLvk/sh0irh4ODgkGw4QulQ4SzvR2eelLTWQ9/ZrXov9W18jQnDQpioQ0mpIFQtFCH8ZPgD2b0EryCFvstLFlDj8BYSVobcxALIDqoWCiC+tliTYyDEEOA33njDkFHC3GQOE/bmvEoCyiHliwhPd+rUyRDSt956y4RsIZmTJ082n0s2POF3mwleEiCLHDPfCQEh5HveeecZkspzECS+A8V21apiHysEnox5CCsEFxW0tOQmjhXyRlY9hBmPK5/HtYK4kmGOrzMSk0b/odv6PWuKocfDKSGTKZnSc9/eqqatYrMvlBcsJkjyIuzM75EeXY5h+qYZ+nbVKP2x5Q8VhAq3+4w0f6papbXUs5cM0lXHX6lrr7m2QscCsWShBbEk/E55LYgl6q+Dg4PD3wFHKB0qjFfn9dfKvLlJq0PZZPX+ev7mj42yBZGy5YMgQE888YQJ4+JHvOCCC0yGdHkBgerXr59R9CCssYKJmombcDXfHStQMQlREq6EjKEiofpRzqgskIkMYbavReHDg0gSD8eP/zEWMs0x4y2FBEH4INSQPDyFlixD9CCo+PJ4oD6SyEOyEOWUCLlCiksjrtS6hDjaQu0sAFCCjzzyyDIJ768jpune814yReRDwfKX4aE/5gWz9Ou6T/XwE/ebhKNEA/UV9Zj+wzmW1f8glyvzVqn3qb21OXuzvCJPzas315A3PjVZ7iww8OBSL7U0ZTkWYklYn/7JoqBn70N0Uv+LlNmsgXKDhUrx+9W4Ug3tWqORmlepbeqEOjg4OCQCjlA6VBi/bRypocseT0oL5mcV6YFeI7R3t30NkURxIWubiTInJ8eQE2ooRm6vGCsgZnjqCBu//vrrMSubEFmIEooo3x8rUFkhfbYgOaHg3XbbLebyP5wzu8tAZslGBxBS1Maytgi077/wwguNf7Nly5Ym6xoV0YIwN21KtjnHVRKpQZGlzVBzSaaJbLfFixeb5yFcfCfZ6hRshyiVlTUfjvkzluqRy9/QwlnLY7bq2oLybfdprC+mvKmNW4r36saHWtr+6OUF1x6f6+WXX26sEmUR5HCwmxPkGnsF79tjjz3MNYTQd+3aNa6C9RZ5wUJ9uWS6Bk0eoeXKLX4y5CnAcZrEqmKSXiMtUye36KqTmndRo0qxXxsHBweHaHBJOQ4VRrsq3eUrSCvndoRlg8/75d1FSvWnG9JExjYkB18eoV8SVKgpWVEyiXJDWBeSCkmLlUyiykEmCbmXh0yi+pG1TVFqvhdAjsnA5nxKA+SRLG3qIEL48AFaYoJnklA0SSGR3wexg/zRZvj7UHMhkyiikEXIJCV8AOF7CB8ECSW4NIUMbyYEDYsA6rAFW2OiXEJWCYnj9SQhiGPDd8n5xwq8o2uylqlOj3xlVVuk3OCWrVn/27ctofHi53P9GzVh/TA9+ektUiBoirdDlPFq4g2NF7Qr1x4ySSIYxLk8ZNIqzWS7c21QE8nqR2XmOOnrLFjiwS9rFqj3N8/olsmfa6Xy/vqH36egvK1kEmwsyNVLs3/Uod88pedn/aCiUOKKsjs4OPz34BRKhwqBLGrCvWsCc3Tms4krssx8V9lXU6c1eFjXXn29SQhh4iUsC6EjozUekGRCGJdEEFTDKlWqxPS+IUOGmELp5557riGD5fFqkgFOAgxKFKFmiA7fT+i5pFA73kVbW5MaiXgc8XryPryThFkh1pQHguiQJU6YGmKHV3H58uI6oSTEQGIgpvgtSbShTicJNSTmoPiScV5e76lV6fBHUnCbDGNKJkFg+fzwdoUkQYY5rpLqJq5fv94kuNBWtBPKIsXlaa/eh/dWk+o7a+msdZo9ZaGWL1ijosKgMiqlafaS6Vq8dq4++uYN7bFvB5OcBdnHR2hBG3Dd8awSoq4IILmQZJRXzodqAuUF/RirA5/BHuaolJBwnsN+QNvRnhMmTCj3jjj0gcdmjNTLc34yueKhCthQdqneQC/s2091MmK7JxwcHBzC4QilQ7kAuYHEWNUMT96axr9oVt4Y+fxx+rE8hJSAegUu1aM3v2CSDFAm27Ztqy+++MIkPZDZjScuViIYDsrEkAlOuR+Us/r168f0PnZRITxu9/WOZfvHcBIBOUBNhcBC3CCDEArCnChT4YD42Nqa+PIgnRANQseAY0dlhNxALCnLQ/gc8Nl8Fz5TSDMKKN48vJZkIKNaojBCziGj5UlECgfqJoofKh2fTckdaleSEBStbSicDpHkJ2SJ84IAoRTbupD4ZGkriC4qLA+8m2X5CfGV4hkkhB9esB3lDzUZXyKgzei7KIOUeioPqFFK8hS7F6G+klBUEdBu9AP6EEQSUPYKCwHnyXXBe0ptTJLNYgVtec/UL/XeggmKBwGf34S+3+t1nmqnb58w5eDg4FAaXMjbIWagMOH5IrsatQyFC1Xqlr6vaN6PG+TFEfo2CRghT8uGVNZ+u/UxtR3JZOY7UHIgXxR2JsxKWJVkEjx6sYLXQnhs7cFYySSZ2RBJJnkUrvKQScCxQ5wg4FYFROFEeQsnk9SdhKhAKvBVEiJetGiRKddD6JhyO3gtbQme5557zhApCBj/I2wKsYBIQayo+WgJHmQN2wDEBYWTzyP8XV4yyZaEqH/Uj7Thd0L4XBurvkUDZImFB8lIKK08OA76EosTrgVtwufTVqi2eDljSU6xheS5ruHgs9kBh3Nt2rSpIZMAQg1Jj7UsEWoyiUi0NdeyomQSWM9qeE1QrinJYZBt2hHySn1JMupjxTvzx8VNJgHh8OU5G3X5L+9vExp3cHBwiAVOoXSIaSIkMYYyOSQOELKDyDBZ40NkEtyctVnnPHqgGnQPmZI/0fxuJYG5K3tDvj64frIWTdxoSNS1114bdes7VDbIGQoexIkMZ5JNStsmj8makDBlhyjBQ2g41rA+vjZK6aAERitzUxr4XhRWCDAqHKDED2QH9RV1Lby2JiQLGwGv53UQeAgiZIjzwwuJaoeCCYlEgYsMy0O68SwCVEpqZBIGhxQRQuZaQowIwccKVEW+D6KLMkyCC35LiCWhYMLIHD8qMsTWAtIGUbYqJGqhtS9A0iGkEEfUw4oClRXFujTlkfZjQWDb0mayE+qHIJfkg2RveNoJIgyhpK/HA6wBqO0Q3chyPhw/7Yh6SxITqjSWh7KwKGu9jhr5rApCQSUSN+52qM7a2e2+4+DgEDscoXQoFRASwqt43CByTN4oUYRMCa0yGTMBkhzCRLlOC/Tl8qe1rmBZmcTS/N8L6fev1+rTeyYpEEo3hAP1jlBguOJVWBTU6CnzNGn2Uk2fv0KLV65XTm6e8nNzFMpZrz13a6VL+h2tLu2abuMHhDxw/CTfsAuOTWopC6iDhMdR+jivmjVrlrunEBbGc4naCokEJIgQfsYPCpEknI6vEfsAKiJlhQB/27I9HffupNBOnpbmL9WinMUaN2WcmjTaSe0bt1Xzys21c5XWalu1uI4lYWgSlgAkFIsA4WhLuLmekLiyAFHkOCGSJP9Acq3HL9JuAEmDHEMYeQ+eTUsiWQBgVYCM8YAM0xYcRyIKjKO0UgsSPyftWRLwZLKQ4Fgg3CyGABnyKLWoouGKKAoh/RAvKuWSIPPxgn7Agiy8P0SSShYE3FO0P/VJy9rB59Kx7+uHVXMSrygWBXVnemed1Lf8tV0dHBz+m3CE0qHEpBASD5jkmFjJ7LXhVpQ7yCShO9QlEj7Y6o99tIHZvWXiB/pmzttKa5SnqnXSt/lsagtmFtbWxGEL9MWzE3TEAccYZQ7ViqQbSvpAXghr5xUU6q3hE/T+yMnalJWnlIBfRZG1CT2vuGSMP6CamX5dfeohOmKfXcxECLliC0C8b5C7WM8dZZJJnW0JyaguL1BtUaMgIpBjwO44KLu0GaSL46Ot+JvXWQLJg+9cnLNEXyz/UuPWTzA7rQR8AQW9v5Qoki+g5fyvblpdrf9+rd64/jXdctMtxqtHRrINRUOMSVghi7s0cFyUUSLxhBAs5JPwNgpnSSFtFheoo5AyW9IIAoq6B4GnTI4t+o3SB/mkTUhyihd4DQlDH3LIIeb8SgNeU9oWtRISTD+DaHPOXAN8kpw3fkw+j4USnxnrVpyxlo5CqSyJKOKvhCBz3dh5CHXY3neRWJazUYcMfzI5VWA9T6te/0YtluWbUlXYJxyxdHBwKA0Vr6Dr8H8JCA7qGSQCpQQfI6E4O5mQPUtYk4QPVEmyeyFdkEneS0gZYsFkDaFCOTq62xHK0QajVo74aqQuOPUqBQtDhrR9O/SHrSFoJnOIJQkrKGNVG7TQlPWZWrZ281bP23ZkEvh88v255/f6nCLd8epwvTbkO/VsnmbIJJnMsZJJCBFbEUIyKkomrccRdQ7FiVAsSmS4z4+QJ/5DCDQkLzzsWxQq0idLh2jo8i/M33bbvnAyWfw8bVLcLqvzVkt7SxeNvFTndTlfq2asNEk7qHEQYwgUfsCSgDJK+BgvI2Fx6+2LZg+AaKHaWhWSkkMcP4ouqhrfRcY2oe1IsGiAUFKqCNJWntqUJdkKANYB+khppIddfiBskCMsFbQLtgLC3pBoFh2oyoSdue5c/5LIXEVAnwLR9lW3sNtpcs8Rcuceoa0h6JEYsmjK1kVJwuHzabfzjpb/8a/MNWNnJNRvfnfE0sHBIRqcQumwFShS+OMgg6gkkDrCsRZ40CABJDng5SPRghAnBIyfhBxRKpl88FxCmKyqRQgZzxqJLYDQOUWhI8PTFHUmdLr/sWdpYaiR/AHC4uW/SF4oqKL8HNVaP0nfDvskpmQaEndQY1GyOAb8j7GCECnkhAckm5+AMCrfjWKJSgepgfyUhNxgrh6b9aTmZFVsByL2jeZ9Y+/6SfO/mWuSVlA/bbtD5Ng33O7swjXlOqNEE/7Fj8q14RqHg+tnCST9A6KKh9JmZBPOJhRu1V2Inl1oRILkG1Q/lEVIbDzAz8sxW6U0GoktabtN3kvInBA0HlnOiz5qiSnnxPHZep3xAjLLAgNiWZYfl/uH+4lrgt2ChVqkqnnuj2/plzXzk7RPVTF+6TNAU8aOM75mjgGFHWLJoqC8NTgdHBz+v+FGBAcz+eNt69Chg1GbyIJGmQwnkxBFwtwQFMgmIXCICCoK+zUzwaCI8V4maMKZECkUPxQg1Eombd7HZ0BoIpUO/maSr9aknRZ5jf9UXyp2gQh/p6RX1vpae6jzXj1N0khpSg6qGsdMMgykqTQySekeQpFPP/20UZRQsSBOJP6QoUspHY6dJBhUMFQdQrOQMCbmEo8hVKBHZz2uuVnzKrydJWom4dK9bt1HPc7cz5BbriVkADWQYtxcCxKsCP1SZojXQDJRKekHNiua9+DBhARzjhBN1Esy7UlUgWRyPQmHW18lGdskP9FGbDUZmX0NIKJYEaixSQZ6vH3Xeh9LI+rhQH3HC4p3EgJJ/6Vvc0woxuxWA3mDYFIfEt8jPtJ4QdvRL2LZ2Qi/MhEAFjkQUBRtLBMW9OXpG5YllUyCGRtXGMsCCjtKKWF4+jmqOsld9DUHBwcH4AjlfxwoVIQ1CU2TMDJ9+nSj0oUDpQllEmLB6/Dm4QVDYYRckkDChMuEw3uZNFHkCGFDHiEvvA8FCQWUz+F7oiI1U432PbGYUMWZDODz+5Veqaoy2x2o44473hADMpEjiSWkD7UMAoEXEPU1HKhuPM95M7FDzFD9ULmoG4mqSgY0dgAUKDymtAETLyQA9Q9yBlGLbNtwfLTkE83Lmr81xF3x8/ZhrVTri9tIVYrbEPJIxjXKIAkpZGlz7HgZWUTgl4XwEPbluMmgR6FD2aSGJK+DHOIDZIEA4S4p9Ml5snig3VAvw7d4tOD7SUyhP0A+KwquHQsX+hnZ7DG1j89nLAn0e64XCwmIG+QU9ZLrSegeoo0ixwKJ6w7JhGxWlETRDhDvWELGvMYuPqhNic0AYmdrjhaGgtpSlK9kY3Xu5q2/0wbcI9zrLBywRdA+9H1HLB0cHByh/I+CCRRiwKTKREqIFsUxMoMXZQIShJJF/UkmYBQhCBKkCkUPkmYzhyFrECiUHXxqkBMIC6qW9Y5BRuzEGIkH3/5WRUFCjonpmpTGDGbU0r0vDDZhxiOPPNIkZkB4OFYeKG9MioQkmbQhEIQ68bHhXaOoOOF7wqNMpChZFEZnoqfdOE9+8rm0IaFAFF0yyyk5hEqLcklotqTQ++wtczR81YgKK5PRSGWRV6RXFrymZcuWmRAq7Q7B5bqhEKMwEr5EscOmYMsWEb6nb9AOvJcSTZCu8vgdCROjVkOuUa8hROGgHfBrsrCIZ7tBq1DaXYJiBWo6hcohpJRfol9AtvFXQrwBaiV1MVGjWWTQj2kH/JWoq5HnVBZQGkvzT0aCe40oAeopqjfnSv9k4VL0N9WJjPY93OvcPxBulHlqexLdoI/Tng4ODv9NOEL5HwQqAxMA4U8SViAO0ZIvSKwgUxcCQliQZByUR5JMUHAgjuFZw/gOUbPYBQQVkrAoPsvIxBb+B1GxGcEWc5et1feT5ymY4L3Bwfd/rNXIkaO2ZgITjmVyZjJEreJvFFdIE0omJAtPKeFqzpMEG0LCKHX8D/KIFxCSSIFykjn4neQUCCafYUHIGRWutMSgj5d+Kp/J2k4cUDpnbP5d3Y7e0xBkwryQLgg0vldIHYSPfsBCAsK8evVqQ5YJBaMgxuOTYxFCeSA+D2uATaAJ/z+eTrKIUUvjUSjpv6jt5VE7uS6orhBSzhOSxOIBAkcmdvhxsmCAyPE/2ohwOWSPhVK0sH5pCmWsIAOdkld8Nyo/9hKAR/XJRweaTOxko3LKthUawgHhZozg+qJKc40ZV1iYOWLp4PDfgyOU/yFQSxJSAzHEx8YEiXJlEzTCARFArYEM4k3DL0hSCZ43/IAobxaQEogXBI3QF+olSTollVux/sRIlfLj76cqEO/2jSVgw5ZcfT9lrvGAEaYnBMxEaEv6oEJBEFBhUV5QHzlXiktDoGkvC9qNyRMvIrUtUSxR+wDkBHXPAgUUJY72KSljfHnucs3cMith6mRkiaYjbjjShJixLrA4YDtG6itiQ2DfbcD/8MTFU2Q8GgiT8rn0J7L3I0OjLGi4JhA0qxjnFq3RloIF2lKwSIWh4szoWBRKFMMSrRRh4DsgzBB/CuOjVHIdUUrxf5IEQ7ifBUU4IEv8n+9A0URxJCzNdWX3HVvbsjRCWR6FkvuVewjvLaF4FjuQV/rmzTfdrLwlq5VsnNfneHOukH7u6Wg7+LC4olYn9wuLK5RV7nEWKI5YOjj8d+AI5X8A4WFoJk9UQ0LZ4aQwHKghJFowGTCB4ZGETOKRRIG0oBA3vksmWkgWZWZQwCBrpQEihqoUPvlzjN+Mm5UUdbL4C0K69KYHjdpEiBNFjPODiBCepfA1ZXUgQCgv0XbegYAyueIbY/JE9YNEQCCZ5AmDQlIgSBaQU4gz7VQSfl033mRnJwNkyec3LtDzLxXXEUVJhRRAoCHC/M01I5RP4hIhfrv/daKAys0ihAfqbriHFYL19KDHlZM+Vp9MPkHDFu6vrxYdqhFLjtOIJcdo6IKe+nrRERq/6latyZ0Q1f9KXyJkz8+ywt4QWsgrSS8kIFHiioXTQw89ZH632d4kzkAq7UIhUmGHXLGQwkcIqbXJZlg8aNvyhLzpO/QtjoH7js/hfqMfofZzzJBbvsdmzfM5RfNX/VmLNDkIBD2d1ec408b0bY6N7+fB7ywGsLvglQWMDfyN3cMm70GIUYIj1el/EzYX5mjy+rkas2a6fl4zQzM3L1ZB6N97Pg4OyYIrG/R/ii0bsrRmyTotX7pcDzz6gL78bqiZ7FAaS1LKCFFDfJjc8Jjhr4NoodxARPHC2YkRxYQJGUULtYdJmvfECsgtiT6EW8Gq9VvUZ8BLSiYqp3q6r99eJnSNPxK/IOFuSAoqGioMHkM7WUIcDdH95htDNiBaTJAoe0z04couySW00fz587chDRTLJmRJCLWk8DGZ3dM3zUiKQmlxa9ubtHP1kkvqQKZpD8KVgFC0vb6JAm2NkoeqR9/yvKDmbnpHf2x4SUWhLIWCnvyB6ATJp4A8BVUltZk61blR9SoVJ05xnSBzKK6E6CGWJBZFA+Fwkq9YXLGoYk9xC64zlgB8gCyc8JOyuCA5hr/JuC4JeCs5DhQ5Xg8BIyxNP8FaYK87xBqVkr5HYgv+TAirrU9pYetg0tdQ/1DHiSzQR7mH8bSi9jY+oKuqXB77FprlgVcU1OYx07TltW9NX+f+RrnFHgNh5sHvqKiA9sHmwYLN/uTcaBfIN+WcGCc491j2aP+nsSJ3vYYu+0Xfrpyk1fnbWnMARL5V1Ubq22hvHdxgD1UqxRrg4PBfgSOU/ycwZUR+nKkvXhqhqd//rrVLt/V1BVL92rlzS/U8fm8dfu6Bqlb7L9KD2kbNO8J+ANUOlYZEFSZdSsqgvKEyoGhBBphIIB2EzCuyLSHKDuonSin48bf5uvqpIUo27j2xg44+6sitSTbhSTIQAQgVhAeSQCIG6hFJGoSKOVfIZiQx5LWonChMtJMFZJyJljA65XdKwuWTrtaWou0zoROJc5qfqf3r9SrzdaiUKEskbaFW0idQ5BIFiPktt9yiZ168V7v0/kMb8qMnZ5UM2j6k5lWPV8c61+vuu+43BAs/K6SexRALo0hwPvQ5FEiU9Gi79OAPtqFubB70B2wcqNVkt5dV5J7FBOdHkXTA+ykdxQO/cKRnGPLJDkZkj0PC+G76GWQ2MhPc2kls+SJI8/kXXKDWL/ZXoGbV4sz+BKPF13M18vUPTAkpALGljSHl9GvGHJR+Sy4t0SSBCOCr5Lzwpdq96VEuuf70sWhWm38aWUW5enb25/pyBVEDdqEqeZFHi/PfjECaLml9pPo23lv+BCUTOjj8G+EI5f8Bpv80U09c9IIW/b5UgRS/gkWl7J/t9ykQ8KvvpYep+YENNPCJRw2pY9AnhI0SQi1IVBkSVfgbZYnajJTNgVzhkSJkGM8uIiQz8Lk2XDZ83Ezd8uKXSjbmfPqQ9t1zD7MFYDT1DRWL0CxqCu0BmOgJ+RGqjwYmR3yjEEu7xSBAxYWEooiG1/SMxHnjLzIZ2ckC4fQTdjpOfRr2jun1nDelcyAAEG4WGxDlRBSyhoTc8cClannIj6paI1U+f0VVWb/qZHTWNy/U0TtvDTbWA0gWKiuEJlwlhsgR1obUQJhRxksCCTeQOogevlLaAjKHfxFSGX4dIVqUwsK6QUIQoV7C4HxGNKDMQcpsdQUUyGjWimjguLkmEF0S5PDl0rcC3Vqr4RXFkYNEIeDza886zfRK9zOMLxVFl74cblGhjYhmoJiGZ/9zfSHW4SomDxZmACsB5J72RRGmLdh1a0fAbxsX6M5pb2pjQVapRLIkdKzRUnd1OFM10mJPvHJw+H+CI5T/YgSLgnr5xnf00eNDzWRPAkasILya5+WosN0mdeje3kzGhLUIQROeJdTGpEHIisQFuw8xYVDCWfGC8B2KEYSSCeXbCbN14/PDlGykzx6qEV9/sV1xaSY52oDzQ+0iiYY6k/gf8RoSUiV8jTobvg0ekywTPOQY9SZ8YoWAotCgiJWG88dfpMIkE8oTdzpeRzQ8POb3oIaRkMQiAqUNfxzXrLTQbyzIK1qrkUtOVm7ResXPT/3asLiWHrxwoSF2KJNcC/oqJBDQvwg7251+ImuMRgN+YHy0lMsiaQuSyOeRoU1VAL6H685CIdLTyX3I4oykFJRdu1EAiiMEFFKJsk/dz8jdiEoD1wB1D0KKBxYCjVLYtl1bPZM1XZV3bylfIDHqWEYgVV8cfJkaVdq2TBTjAv0cRdgSRFRGfMWQQ9or2iKNvkQ7WILJ9Zk6derWhB1IOu0LyeZ+wboQ75ac5cWE9bN145RXFPSgkl6F77OGmTX1TNfLVTMt9uQrB4f/FzhC+S9FUWGR7jnpMY39fPtEhfIWwJ5QNFrnXHO6CW0ThoY8oEwxOVPIGSXl4YcfNkWqE7WPL5M0n0v2L+VQ3hnyjdbU+KsEUTLghYr0zaPnq3atWtuoV6iP+EQJ4+MXw/tWKVRVvwybqNkT52nu5AXasHajsnOylB3aomYdGuvMq/qpz5mH6oQTTzAEBO9leAgP1ZcSM+HkpiRcPfk6bSgsLgmTLFzQ8jz1qLNvud8HcYJcozqhpkEmyHCvCOinY1derVU5Pxk/ZKLwyVMFevvJGYagQETwwmIxgESiRuJbxAdL8lhpgPgQwuWcIZIUdcfOwfujJZWggrJogAhxz+C5xfoQ6SWmRBYLFcpScV9BKvk8+hrHyfvKAgo4BJLFDlUaIPu2WsJjLz+nZzVXKTWqxE0qubsf2/MEHd64ZJsDKj7JN/ixOS57bWl7ohdUEaA9ShsraGvufSIdJFLRZnyGDa9bG4D1Y0Iyy5MhXx4syl6lC8Y9borFx+tjRt1tUbmBnu92lVL8ZW/36uDw/wRHKP+leOTcQRrxxugKk0kL3u9P8eu5CQ+rcdsGJkPbFE4uKjK7paBQUlomEUZ6QpF4wEhegWiFl1nxBVLV+az7E1bQPNp5tm9aR2/fcdZW5QoSCZnEO4fCwuS+5o8Neue+j/XHL3NMhjS1/kIRmefUd0SN8KVLs/Om6a5Xb9JZ5xR/rgVKFu2IRaAsEv70nEGauGFyUpNy7tvtbjWp1LhC76V9yM6mrQDJWXhp8QaWB8uyRujXVX+VVEoE6P6F+Z6OafutMlLqGPKO4k2/xbKBYoZvMlxVpi9AzFCfeXCdCIejwFlCU7ztp7dVdaQcDp9B/8XqYRNNygMIEeQIAgWhgkSh9EF66XsQxci+wrGxwKEsD++lP2E/wJcbjodeHqSXNL/CpBK/IP3v/j2O1jHNYl/YodLiGUW5RMW3ZJk2ggCThBO5B3kkIPCcDyQedZfrxiYEXBMSlyibRLtA3m3SDw9q4Janrmc0FIWCunTC05qXtdyok4kAV/DsFofqrJaHJuTzHBz+LXCE8l+Inz8brzuOfThhnwdx2qltI01KHa3JUyYbHyBhbkgEA3tFsGbNGhPeYiJErSPkFW1nESZVSAATz9DZRVq4cmNSaJXf51O/Q7vomD2bGSWWXWyY/CgcTRmhymlV9MwVr+i7938yyq0XQ/kiSwDTa6Tq1nf7a5/D99xKVgkNo0pdffXVZX7O498/qcnpU+UrIcM5XqT70/V8l2fiThiAmEGUUXVR7iAA+Etjxagl/bSxgP2oE7vLC4R/19qXqn2tCw0xs2VqSKLhd/qiJY8QFEgZFgdgfaG2PibePpRMVEcUevyDqJsQSZ6jT6M88xr6dqyEBnKKOklGOoQcTyLluThOlD18lyiV2CxoY8La2Cvw8xLqJtmHRCL6ExYKCu2H+3XBwBcH6fH5Y1R1r/byQiGz9WisZLJ+ZjU92PUY7VmnYr5oW3+W7Hm7AxHny/lhM8BnTD3X0rzEXBeIJW1OYhJjEKTUejJt4g/XkEUOJNPutW6JJiQzlr3SLT5d8pOenP2pEg3a9M19blCTSnUS/tkODjsqHKH8lyE3O0/9ml2sLeuzE/q5kKO53nS1OaSpmYSpSxjT+zzPKBMkJVBzkezw8Ak7HAz0qAwkSBBGJYxOONBmrn703VQ9+M5IJQs7F83SR++8aiZwPGwU+4YYrVy4WtcdcKfWLF1XLh+qhfcnQWp1VEPd/8pdJqmJTHHODYISDYT5ySinluXCNQt1wucnJ8wDFw6U1APq7a8zm/dLyOdhiYAc4AsEtCHEuazkkg35f+i7pacpWUj11VSVxbfokYcHGqLHQgjCYUvyQBwhOHYnHewJVvGCyPGAJEYSHhZBeIcJhZMQw0KBqgioinZv+FgIDGWZIJ+QQWsZoAoAoWtCxyijEGC+ByUTVQ4FmH5EopG1U7Awo34sxI3SQZEY9Owg3fT2s2p0+iHyNawpcp48X3E2cjhSfH6zrWK11Ayd2qKrLmzbU5VS0hLWR7ALkDiEtQXiCwHkGuBnpf9QLSGSEFvwHnzLlHCiTVBoOVfbx7iGjDHhiT94MmlDvgMrTXi4nGsb7bsYu077+QGtyCsufZTwRLimPXTpzkcl/LMdHHZUOEKZRLBqX7dykwrzC5WalqpaDaqbDOuKwuzwcc7d+vXNaQnfpg8EMv0atvEdpaSmlPj9hKkhjzyoy0hYKhp5ZPJm8qWWH4oMKmR4wW+Afwq1EO8ik392XoEOv/YF5ebHvn1eLPBCQWWtnK/s34YaBYgJ2iqvG1Zt1OV73aR1y9eXmh0f0/fI08z0icrO2GgmTlvT0QLVBsKND3HIkCFmYuS8CaWe/9GF+iNvlgmn70jh7pL6gU3iYhLn+FGlSvMCztrwin5f/+xW8p0MXNNnphbNytsuZE0YlfqUljiiPELKYrVxoDiToAbZpM/Td8gAJwmle/fuprRSWYSabHHIEa9lQRUO+j+KJfvAQ2DtsVerVs0o6CTx2ILmgMUYpY1IDopmp0D5hOi3O7SH1tVJU9djDtPmyn5tzNqiUFGR2jdopt1rNVbXOs10SMN2Sgskpy4k50B4n2gARJpxgsWczcJHcYVcMjZE2+Oe7V0hlryXa0iCGPduNHJIPyR0Hl6+iPbhHuOz8ZuGh8vpA79nL1H/yc8rWagUSNeQ/e5Smn/Hr7vp4JAIOEKZYKxfvUnD3x2rCaNmaO60JSrI+4scpaanqNWuTbTH/u11eL/uqtso9vqNKBPsFZ3zXUBVfeXzrpUHt394ralVCfnBUwZhhDwyMTBYRyOPADWFyZpJlgmP5ISyysxQugeyiZJnJ8yPR/+mB976NuGE8vchj+mEPgebiduWKTEEve8DmjB8aoWUye3A3B6QfigcptTKATMBooQSzsRn9sYbbxjPGQoKhMaeP2rOZv8W3TLtNhV5iUtWYdHRs04PndeyeHvFRIM+ST1PJnImbSZ/Qs7RyMEvK6/T8mwSOJJDKLmWg25coskjQ4aUQVJQtiAOJanE5QFhVsgjiWmEZOnbhHj5mxA4hLq0IvBkoXPNeU/4TlLcZ9RDve2220zfgPRw33EOhHN5H2QJSwiLITLH+QysBlgQ8F1GgyWVECmuD4sYSBZ1Ormn/26Q2ERdW8glCi+qLu2FfYLwNucHuYyWOEV7sPjkPiFywn3FWFiSwmmBKgqpDA+X0xaE4VF8u1zbV+kHNscPk7Tzfr7blWpXLfZsfgeHfzMcoUwQNq3L0st3f6JRH48ziQKlefD8ePQk9Tyysy66+wTVql9yiQxW2CgX1G1sVLexWi7trGQBD1/1dhlaVnWuIZEMyJFqD2AwxtdFaRVq46FCViQDE0KCYX/48OHGiA/4nksGfqTJs5cmaBtGTxcfva+0aoaZiPh86iqidIx690c9dObTSih8nnIrb1GHfi3N5AmsT45QJxmwTKwkBOHdJFxsCdjXK7/Re4sHJyzkVi21qh7c/T5lBkqfeOMB/ZOs6gcffNC0LUoe3kq26wzHN4uPUVbh9tsYJgpFhSEtmtBA15z6pSHpHJcNyycKthYk3kZC0QB/JYojxJLrWlKxbkgcmcqQGkgjbUW/p0+SeEM9R0gTYXgSdbBCsPiBiPF6IgMopXwPxNKWHSJTuiTwGVdccYUh1XwHYXq8l1Qk+CcBqUPhZoGF9QPllvPEnsCxQizJFodohgNybYklajE1LCnVVR7PJESdtuA6DK06UzkNqIWaPELZv+1xOrpJ+asrODj8G+HK+icAv46Ypgt63q1RH48328eVldBBEgGv+fGLKbqgx90a/dnEqK9jVU0iAAWMCS++8cw7Sia8oKelM1YYBcGSSUC2N0oI4WlCbfwPnxOTAtvJVbScB5mzqAwkS1hAXh+6+EjtVK+mAnEO9Eza6+ZOVMq6WcaDRQgNRY2CzPvsvY9evOHNuD4/+pf6lJlVTZ+88ZlRnwjVQRhRY8h8hXhR6xPfHAuFcDXv0PoHq3vtfRKSEJDqT9U1ba5KKpkEECgSRvDBcq5M1KjTJJOEL0KKQrlJPQ6/P6BDDjvQtCf3DIp6vBUQIkHfgdCQQY5KCVgIoU7ipYQIlbRnNYQJ4KPkvuZ+6t27twlroxpS49MWzuc57nn8lCSpsPDCl8jCjfsPdZLP4zvxEpYEFEpKFUGgILMomiQo/dNANcU7SuIRPklUV8gkYwE/2VSAepu0Ecq+rXnJ4pO/uY9pO9Rw7BYQbzyqsQBrAv2DLUBrtGyQVDKJT3V57rY7ljk4/D/DEco4Mfy9n3XnWc8ra2NOucOmvJ4kmwcvflVDXiqu5wYYHFEhGPiYFCF4TFy3X3dnwifJSGSqqgnJsvJnAiI5gJAtv1OuhAE8UbUomfz5rvAdOED1Kpl6+YaT1b55g+K6MOUEGa4gddMCLf/lE1MSiCQGiDEkGP9bcI1PG1YUbxGXaOClPHTXvkZVojwNJAB1iBAs5WZQR3lEgizs81ueq15194tLmcwMVNJN7QeoWeVtVcJkgnAwyhe+OFQgsnMJ2ZJ8wc8F85ck9fvpSwFfsTrIfYPyRbsnGmQeE56llBZJOoBFFQSTmq30NVuwOxqhRJHEw4enEj8lnkw2EYgGFmq8HmLJQoT2hVzSl2zSHO9lcVISocJ/iRpOxAHFD78mf+8IoMIDGe2MLWRyM77Qdwjx47/m3mGnLs6Vmp0QaJRnoiOE8AmFU1Sd+4rFKWp/rMQSJNJeEh0+U5bIweG/AhfyjgNjv56qu899cfsUygri+qfPUrD6JkPmWL0TSoTAkQ2NqtG9yYGqtKJ2TCVtKgyfp7onp5nEA0JJ9hH+d0m/279RGmLdpg/igeIAaY7ERx9/rMvvfEZN9yaJwadQGeTS80LFdSwL85Q/d7RGfvqWmXyZrFA+UAYJAYKB5z+r4a9/pwSVntsOlaplasiGNwz5Rs0lVMkxUPCZLGQmd5QYCEi0MOn49RP02oI3lF2UYwhqWSQeIklCT7eaXXVm89NNuDuZgDTRrqjLLAjsT66lzaQGJL5AuE6+0VN6nSWmfyULnercopbVTzCkiQQwvImEThMNSA8+SMLHkEobmiXkja0Bskmmv70HUAWxOhCCR8XFa0q/L29tV/zLfC57xhP+ZmzgGtA3sFSguqFKRqvQYC0WZketUMiMKSXtL899VFi0QIVFi+WpQD5fptJSdlZKoEHCFpMlAYUXKwB2ERZftBGLThYIEGsWhZBL1GAWDhwPCzdsLLY2KotxIjrhJZ3ok1wv2osH7xnfLVfBGsnbT5wi5yc33V8Xtj4iad/h4LAjwRHKCmLj2i26oMddyt6cWxERLTr8nr5f+Zb26tnFEBDCO5ARypagjGz5o0DPX/NGcgml31NRz3Vm8mK1z0/74G9bry+W0FIspJTzIzxJUoJ9jp8osdTcI3x6530Pa9y8dfp2yiJtyS3cmmjDZAKBtK0Ryl6v0OqZGnTv9erVs/vWouyoZ4TNIBp2Ir2gwzVaOCO5qtmbc5/RrMV/mFAppIOt//C9oTThwUPVIgyOJ48JMpJgZBVm6ZxHz1PqHmlKrflnwkfor5qJhrD4i5Nv9qjZWYfUP0jtq7VL6DnwXUzE4aSRn1w3W1eU0kt2q0Ee/M7EToayXSjc89Khat9rTRx7d5eNuV/20oH7nG7CuyTAoF4lS41DYcQvCnlDZbQ+Pvx9kEcWhXZ3HAgghIb2QqmMtxg3nwPhwmrAwhPCxTnj8YSQ8f2ofZF7z6Meo6LifSbMTvie0DrwvKCy877Xxqw3lJP/szxv++Q7v7+mqmQcqppVz1ZGWtm7+ySijfFZElXAP0kYnPsFZRJCTQic+wbFGHJN6SDueZRf1E/ahbGEHZPow/a+YdzAVtD8+oNUvVuzpJTrsrhpl1N0WMOuSft8B4cdCY5QVhAPXfqafvh8UmKyg8OUgbTaQU3NGm4GQMz+EEkbEhv/9WTdfMT9SiZadGiqF6cOLOH4irdGK4lslvR3af9j0iC0haKEN5P/lRzW9ym9eh1Vqt1E6dVqKzU1XQX5OfJyNqpWpuQryjNkjYQQVD+UCPYLZ3KxCRMQy75HHqW8r9KTS8wl9bqiq+5+7jaTcYxHLnJ/YsgZKjQePAgQvxMCtL5K+gChvOeef06HnHaoFmYv0nvfvK+lq5aqSqXK8uX4dNO5N6pllRaqllotrmOlzcm2j1Qc8ejZMCIh2HDSaH+iukVTriABhFxR5tp1qaz7Bpe+Y0o8KMj167L952n9uk0mix8iwfX+9ddfy72jT6wg0aZHjx6GuOIFtG2AikgWMsfA/YJaRv8mbG3rYiYC3C8opaikkCXsBSxYSIqCcPE3iycWVIAw8XnnnWd+79mzp/G9kux33Q2HaNX6a1QYXFxcpqDUbTFZ9BQpM21vNag1UGmpLZRs0Dc5VorCQ4gh59wXkGf6rC2iHm414J6nfVikUUGCa0G9XEoWAcjprhcdrNy9ahVXZ0gSXtvrOrWo0iB5X+DgsAPBEcoKYM2yDTqr221J8zNW23OTbrlngMl4pPgxZUK+/fZbff35cLVZ1U3JAjvmHHbOAbrmxYv1dwHSBAEkW5XQKG3KueIZJUTHhIHywgQBwaYsEUSBciAktTCxkHmLagNBZXLFL4ZiAynifUwolCeBvDLp+72ADvAdk/Rzm+GNV+9zDzITYUnZv5aYoFLSBqgqqJecE5M9ChsToVW1ICqUsIHMoRJGswqUBtoXT2yk4sjDTrZYFixxDCePTMJlhTxRj5j0ITWcF5+FIkZiyG1v11bDFummykEiQSJciyqnafe6/TV27FijBKNscb1RcSFPKP48OI9Ehm1ZDJChzbXiGqKO4emzmdR4ZSnwTXIN2xOiKCYSNnucRDOIO2FhynZRwotFFMfBgpQwMH5oFD2UTZTJAw/cX3t2n6izL6BvodKVZ3EckE8B1at5n2pUSUzRfPom9gAblo58UFYpcswl2c2WHEOJBCwoINjhCUgQS8g/yjEknEXQQ9OG6avV3ytZqJNeXYO732JC3w4O/wU4QlkBvPnQUA1+avh2ezwnAky2HQ5srqzqC02dQgbRcOytQ1TZVy0phc3B2gaLdOzFR5owEub3ZIMJAuUOPyFlQCCGhLlRxQhR45mCWBI+tQofJIiMV8gBfqvwsiFMJGSHQmwIOeKho8A4vitei5rUaffOqjE5+Qkr7Y5vqqc+eDRmAoOahkrJcbKYQLnluO0e2oDzgShBEgiv2kk0GsgMjlQc+cnzALJNW0cqjoQVY/XAAogtCiwPiCNqEO1MiJVsXP6G7D/6aj/t1nuhEo2iQk+3nbhCF597o/ERcl6EdFHmIE4sPigozzGg4FlySbZ0RbcWDQeeSCwbhJjxkFKXEmsFyV+U96Fvo5ZRzJ5+mWhAkFDrWHjSJwhlk5DEAoz/MY4Qlqc8D4SWfvX+++8otfKDOqxPpuLl13Wq36za1S6P6bXc35DekkhjeFINqi6h7MgH9hEW2pB32pREJRvOhjhit7FZ47QBhJ/zxybAc4wnfc49TWdNeE/VMrcoNRCKuw0iwfh8fqve6tc89q1JHRz+7XCEsgK47OAHNH/GtkQvkcgp2qwf1r699W/UKTJl8VI2S2mjTx/8OmGJQOHIrJaumn0D+mTIJ2ZAjnUP3ngBOcIPBWkkWYFQKZPfLbfcYrI8wwsYM+mgNOBdYwKNFs5kwoSQkZBDGIwtIVFqeC2JGpzTwSnHS8HkJhg89M1t2uPg3cv9PogIbQEBRLGkXBM770BMmSD5iYJrs2IJ41uVMZw8Eva0kywh9XDSyE8WDOVNDLGLAD7fkkjC4oTDCbFCIlGRo291F9Kn049RMG2xAimJaXsEq8lf1tCaGW2M147sYHx0KLxcb2oxot7RTpAKMoV5QLggnhAulHEIZkUWUBBIbCmo6FwXMq4htXYRwaKGhRJ+S0gf6nmiAanCp4sX2X4PiyiILgSWc6M98GTTtyj0/to7XdVmF3baScwxNKz1jKpVPs70DRY84ckv4YSRiIMFqj0RhkjCyHM8WEBy/9K/iDzw4BztDji8HyWWXZD4XruDF+fHgoY+SJ1QjoF+Qf9EhafPNrrzDGW0aay01CLVqFTsBU4UsNKE8gp1TnY3nXPy6UlPZHJw2FHgCGU5UVhQpGNb9Y97m76yUHnvNTr6uL5mogg38edsyVW/5pcoeyNew8R9H4PeWXedrH63Hm+UHDIsUTtscWhIAqol4bTyFBIuC0wETHhMdNZfxjmTsBIZJkZdgUzil8JTVdp+44T78CMSMkY9gkRapY9Q+TvXfqaavrpJU3rB1Oo/aM/u3UybQVxat24d8+QCYWTyJeEFQgzpRm1DwSTMB8HnGlnVCaAq8h2RiiNkvbRdXGK9ToTaLYmEqDDhc274VFGFy9p+EGwpWKSv5x0nBfC9xdf2waCnNYsC+uXt9nrzjbfNooFFCGFodlxB7ULJJvs3EixaIJaEx0ePHm28jpBuSy4Jk0M4SwJtjjUB1QuyQribkDb2BIhP+FaJVsGEJEGqEg1IF9cYawH3bPjz3Ed8Pyoy5YqoE3rzrUfozAsTt1sO41B+vl+XnVtVkyYuMqF1C8LP0VRGHrRReB1W+hjtE04eIYiMR9w3LKrJ7IY082DRGHmN6AN4RSHPhLx5PQtxFE36Bdniuxy4j0KXH7b1PdUzc5WeUpRQlXLty+M14/0fjArOooZjd3D4f4cjlOXE0rmrTBHzZOPxL65Tuz2iG95HfzhW9578WMK+K+SFlF4jRYMXvqyq1bctN8NADDlD2SOMSIgQtQOCxmBZEYXLfGcoZJQV/FyURLJ7WjNB4AuLJECEv0luYUKAYEXuxBINZLvyHYS48LBx/BAw/HWD7/9MDfKbm9qPyUAwvVA/Br/cpoQOKh7EELURooO6Eq39UP8gRPi9IG0QHshceLF5SyRJsmDChDwSvo6F1MUKJniuDX5ISCSTPeoPO9GgRBLaLQ9R5ZqTpDPyl9d199ttJV+w4kql59eSuTl6YUCe9uqy/zakEesA9RtpNxY/hLtR20sCCxleA7mEZELkWcRBkiGXhO0hjYAsbVRHimnTVwlno0jS7lwPiA5Eie8OV2kJh0PCWeAQBk80+FwScLBAhJNZSyzxtbIgWbBgnkaPa6I6dQnzJm5FSj7M/DmNNWf6adsojaVltNNeljjyE7LLfQ54ryWOPPCJlmcDBRYIeJIh/CyK6QcsfCB2n4eWaG3rmvL9SWZ9vpBqV86R30d5rvjJtT8/TWOPf8xcB9qe8ySaQF9JhMXCwWFHhSOU5cS86Ut0+SEPKtl46OOrtfu+JWfF3n/aE/r+g5/jzlQ2pXf80kTfaO20ayNDHlC5ogFC8e677xoVhFCfLTgMuWR7uEj1zSSAbMjSH4tWae3GbAW9kDJSA5rz23i9+uxj+uP33w0ZQo0jbAggfZGFnlGaCF8zIaNMxrraJxQMacOATxgOcgx5YFA/9vATtPKT2IsglwfsvnH+A/10XP8+ZpJkYsPHRuguvOwShAQFkckTQkI4DoUF9czCZKP+mRxDKBOVFZKKUouqS0iPtkkUOD4meKtEQlDwsbKIgESitJaWYFQSOHYSVCDzlNH5+MunddEDdVS9TnHt09hBH/NUv1J3ffa0X48++IwhCnbnmvC+d80112wtG4TqzeIF0l0aeB8hVate0h9pEwg+/QjiQ/gcUkjyTaTlAkWNa4Nyy71i7wnIN+ol15driKUhkaCvQ3qps4qHMhpYqF07YB8992r8e5tHh18tG45Tasq2hBaQFMe9YMkjDxv+ZhwJJ48oqYm02GCBYcGBJYIkwHbPXi012Pa6Bfwh1awUH6mETBYUBZRXUFWvNj1Sp55yivluojv0Jc6TMlL0DRcGd/h/hCOU5cTi2St1Ua97lGw8NvRate/assT/F+QX6o6jH9LEb3+rMKmE+AQCft356QClN/KbiZkMYEJGGNlLgvUroVri1YKsES60e/BWq11fn/4wTZ+M/k1rN2WH0YDwDwmpc8u6uuTEg1S4YZlRkFCDmMjDgSqH94mJHc8kk00s4BiZtJhcMe9b4AdlYkE5GXDo3Zo88jezXWIikZKWoveXvqDqdaptJVMkDqD2kXBDZjZEDRUlEkykTL4UQId8ofSEA9JAsgmkhzAmYT+uF4S+ooAw2e3/ULJIBGPyow9AIgn/VlSJBpwndgl8hrQ9Wc+c/7gJP2lt6oeat+n94t2NzGTuKzGT2x9gS8mq2r32dWpata9ZaKCYQvT4vMj3WqUXZY6+andeISM7cp/okkACE55MCInd7QbVGNWS8DhkIZL80I7cS7yPUDcg9Mq1ot9BKlDObAmfRIG6rSz2IE0sViBs4f5F6jT2PfEnde+ZrpQEeVi3hV+1q12tSqmXGvJqiSMPu0ii/iP3cDiBjKV6QCKAWjj82xG6NusXtqXa/uh9IVXPzFNaStCQw1gPyVqPcgpSlZVPCN6nYQddqvr+TFNonvuYBQ39lQUg4xxe28h728Hh3w5HKMuJvJwCHdf6mqRvgXjR04dr/4N7llpDr7CgUKd0Pkeb/8g35LA8xJISQTXqVdct712t3ffbxTyHQsae10yIKDBkqpYV0gzPLv3k0yGq2movNdrj0G0KjpcE9uoOhjyl5K3X1KHP67orLzGh6fAJgJ1HIITsLoOaWRZIRHnrrbcMAUARhIARHofEQY7wHfI8zy36fYku6nS9gkWJ3R5t3zM7K72NtibHoEpZ8kjmKqokDzKO8YeRIELINVpJGRQ1wuOoXhC7Tp06mdAZ6huTM2FVlFfC0Hj6IC2xgLZF7eVa4y3juwnRWRIJaQ33t1UU+On4TM4P6wRKDf42EmQgzSCvaK0Wbhmi8XNfVWaNnO3KChXme1q9KFWfvLxAbz89UY0b/WV3YFIm6QKFksVC5DlC/vCdEmqnfBP9i4md/k1YHI9qSfj+++9NQg2ECPLI4gR10obGrVWD87CZ4ySI4GWFTPK9tC/nj6oOCSVUTogcUg3ROOOMMyrcttyv4YkvkDhUUXyLWEPC7RbcB012aqTnXl+szMzkkDeGxJm/p+iEI5ebtofU0h7h5JGFZ3kqCCQay3I26uDhT5byCk+ZqYWqnF6ggN8rlVja/xUG/dqSl6HC4F/3y0v79lOP+sWRHsYjFGmuATYW9jFn4c5Ch/6VSJuKg8M/CUcoK4ALetytpfOKM2iTgQIvV6NWFXvCmIgIAaPg8ZO/7UQPOUK9u7v//Zr92VKtXLBankLylbJFu5msfT4dfu4BuvDhM1S5+raeHogyJnI8P0wGkIBY/Ior12/RlU98rPnLiz1Q5QG73jCQNyxYpGFvD9p6HAy+qG+oZoSJSgITJxM8JJKfqGkQLLY1xAeHAkfCApMsBA41D5IKGXj/wU/1ys3vKlFe1Cxt1DiNMkQmMquaB5N9NDXGJiRAOlAoIaAQhvAyKBYoPOwARHIRr0f9gkzyfkgVClw0WwDkH2+fJZFMaqhDEEge9LGKTPbBUEhjVizUpNXLNHXtCi3N2qSg56lSIEWLf52oFRN+0/PX3KgNi5eZaxqpznHuhKMhypdcdr4K/cs1btIP8kI+NazTWlXTmmvmzNlG5SXBhJqKFiiQkFZIIopt5AKMED0KIlYOGxoma956ILFaoCKF+x1RfwlnQxwhQSys+JxIoMzjz6PPoTzx2ailXBMeFDtnIYQ1gf6LOsp1oj8S/odYQwBJHosGrheqakkldqzfEKB8Qq65pvQdvoesdZ7j/qUPrVz1qzYVHKtkorAgoJ++vUV77rmX6fcVsUckE4uz1uuwEU/H8ErPJOpkpBYplQSysB2eIJJFIb8hkLkFqSoKbb/wem6fU7V/gzZb/8YixL3JTywfLOC4f1lUMt7iq3Zw+LfDEcoK4PlbP9TQ139I6C45FoSgex3bVUdfsY9R1SjUzE/q+zERYUxHEWEiJXwICWBSIxx38B6Hy788Uw0r7aSs9dnbKZJN2zfWfsfvo94XHKQ6jUr3UeF1YgBkknzzzTdNGY6SsHLdZp3zwPtavznbKI4VA+/z6bazD9XRPXYzEzoDL5MupYSiAfUPEokCQEYnRJFJG1UzUnnCfwlBRnkbMWKEIan4AmnTR84epG/f/kFxwecpz8vVOG+UWu/S0lgBYlULLVBOIZ0QEQgeiTgUeeeBomdVTsgDJAoViAkbDyWLDfoA30uoE+sBChlkYtSoUYZEEnImhEudSUKyfAeEqaLhxryiQr36x0S98cdErcrNMgWcIdXhPcALBk3yAzQ1e8J0HZxeS+88+uQ2ZBKCyOSKqgepBKh37DDDOfMazpWwIdcRwmePmbJKKLecd3gmvwUKEOplZL1OyCBq5YsvvmhIIAQMBZxj4LshY5Bc2iiW9mFRg23Aei9Rp1n4kQwCSYcckgnO8QDOhwUPoXj6OdcpkjByzHb3Fz4DhaukjGl8rhwnqirnEc1bu2b951qfnfxNC1o1mqqUQPLKjMWDNblbtN/X5U9o9Ak7RnHPDhmLTOl94o2eZ2nPOs23eQ51m4U6fZT7j37POEeEh7EIvy8LPAeHfyscoawAFs1aoYv3v1fJwmPDrlP7LttmeKNQYWq3BBMSaQkGJUMgGIQ+IX9MvI898LgeuOMh7btvdz016Ent1LaR0jLKVzoGBQQyR1IJ4UHUoUgvXUFhkU67620tXrVBoThtABAHFNT9GhXpsbtviJoRi8oI4UK5pD2YSAkbMjlDsksD5AGFDBJFggQEjrAxk/Yj5w/SyDfGmGMoL8Hi9ZD1GwdfrmNOPtp8Ls+RXQ6pizU7FQ8cihUexkirAdcXssJERNIUah3gepDxDaFmwoJgMilxfvzN59BPeI8lkRDreD1rE1cvU/8xw7Qka5O8WIuihkLy+wO6tMPeuqLjvgp4xTv/sCjAU4ZSGA6sABBjFjcA4mTLylgvLSFU1GjOmb5iSyxF+hlRhCCOkaAdIXm2jiTXitA2xxVPqSXIIMSS74fQA8glx0tSGIoqBb5Roy3oi1ZVjHygZMVyPPRfri8e0Ug/8sYtQ7Vq40VKNlo2HK/UlNg8qskEJB/VmoUZdgAe/F7v6YsVqLJ9ndRE4ucjrlfN9Ojl1VjMotDj/2Uso59jYWFByKKDcSDeMl8ODv8EHKGsIG488UlNGzs3oSolKmLLXRrrqeE3lDrh4wXDk8OewYTqKGOC4R4VA8WNCQuiBTGBPJFhTKi1IuDzCA8SGiRsjBIUntBw27Mf6auJi2J3sJcJTwVZG9V3Z7/uu+cu8wyEDw8exIOJH7UHvxokEm9brIOvrXkJ6YBsERZmUEdNgpDVUUPtoq5K9RV/Xlk1KrlefOapNx6rfredoLT0VBNSR21ABYXsEW4lCYPnSrumvI92pQj3Aw88EPU1kCkIB22BlxI1FnWDBBqb9ABp4dzCs8kB54riR+jVlsCpKD6cO00DfvpSfp/PhLbLC1qhU+2GCr05VF988qlRBEnaiQauNQsZFETbfiTCEEoGtAchY9RG1HrOnYQxG2qF2KHIYnGgKHw4eO2gQYMMgYSwQ8zxI9LPUQ3xrZYFrj+qb0lhaULW4deCPsE5oV5y7JBfPLYcMxYWzi1eoOpzb/C5lCuyyModpWVrT1ey0brRdAUCycokjw4W3ERxLGnkJxEMW2qLtoZo8xi3S6Zme5uTsTeEQf2Mqvq+9zWlvoZ+RoUMjpM93m2yGAsrrhkqZjSbhYPDjgxHKCuIZfNX65ID7jOFzhMFslifHn6jWu5a8oSPB4dBEeWQQsoMPBAFfDhMIkxMqJiQTgYtmzyEymG9mDwop1MefxM+MCZuVv0k4ODJuufhJ7S+/r4mASex8HTuEXvpsI4NzeQI4WBihhRxjiiS0dSmcBCqRymM3D0mMvGFci6ETFEJOK/vvv1ePwweq69e+k6VVawsEsaFBaWmpCjIAoImTfF0/BV9deTFh6rJzg23+UzayIYzaWfIPh4pJouSSjJxnkwqKGYlZX8yYfJ51FnENwnpQdGArEJGUL3wbvL9EFSuL9+H8oFiaYkNhJLJivOGNNGusSqWn83/XVeNGaq4EQqpYMEyPd31EB1/VMn+WAvIIBnyVWtJHbtXVe/jO6lLj500bcZE1apRR+1bdlfW2mo67+S7dOEZtxtFHdD/6Ssojjbhi3bg2hBexx6AnxElmdexECAMyX3EdxL2JgIAMS2JNNrsb8ACJXLXF+wXNmGIY0AxtaFxrAxcLxaBEFyuKaV/4lGoIFEomqjREGaLwqIlmr+iOBEqWSgoSNdOtSeXmkwYL/CJhquOPFhQca3p89hGGCNZdPGTewb11+L9BRN015Rt1duEIeTp0KrN9eShZ5f5UiIHFOLH08vCmDGA/kjSFvYJ1Hn+x0LHweHfAEco48DQ10br2Zs/SNjFOPOGvjr16pLN2Uw8qCeQJSY8snQZiJiAbL09C1a/hMUpPg4RtH5M3sfnQAgJG4Yn/JQ1cDGQo6AwmINOR5yjlEa7JXTHHotgQa6mvnOHqlapbM4FsgWJiiQ+ECfCWpH7VVM6BfB61InwxBjC5pBwFEHUPTx2TDqQDjIwAVm4/S++VlVVQ93a762li5cpIzNd+x64j17+4HmdcNaxevX1V0s8fkgLIe+nnnrKqG8Qcnx7KL2QncjMTq4Bk7DdmSgaUFYhgCjGXE9UN8gDoX6uMdnEZIXz3bSD9V+SiEM78Z1ceyZeiA+WBl5L5jneUkswKSIdjdAs3LxBh372igpMElX84Eqet0s33dqt7P2O3/n0YU1Z/pz2OrSG8bIFizylpP61kPEpYBLSYPsLZuSp1643qEvLM81iB2LI5E3b4i2k/SH5EHEII2Fo+rYliJB6wtSE2iF54UBhRPGMFpaGPEYjUixWIPYU2seSYv27ADLKNeJaov5zPYk6sADh3ia5J7JQeSxA0SWZiCiF9RObQvV/NFLVqknK8g5JP/9YoP6XFpp7CQtCPGo4x8uiODxczU8WRwB7AqTREkceeGrLIuPZhfnq8dVA5QX/yoJPJOZf/rS6tWhn7n/sGGVVS2BhQd/g/qQPcC+yiMaKQb9lEQLJjKd0l4PD3wFHKOMAA94bD3yuwU9/E/eF6HNWT132wMmlKkXUtCM8wuqVwYeBh91j2A0mctAiu5nBlwGN5B0LJkieD0/4Qf0DqBrhBJOBmkxYQs5kyfLdTMT41ZYsXaYuZ98v+ZOXxTl/1JsqWD3XTL4oPBBeFNpw8hiuwjLRR2ZVQ7CibRUJCccywASOQsfEbvek5jnKJ9lt7PBe0s6omfhUUTtoAzycpYHjIpzKdcOiANlAcaCdUY5seJPrAYkjnM/1igQLCHysvIdrD0hA4j2cQ2RoMxJMSlxniAukiuO2XlFIEO2El48yOBBPCA2JX5Zg0hcqV6miE796R1PWLq9QmLsk0Ns/6t1PXepFJx5FoVz9vv5Zzd30toogkTHUT7Q1K+tkdFGXenfrsQdfMcofxJt2gPxhBSHMbUkk522BXcRmR5Npz33CfUNmPeH38tpHIEKQHb6bxQDqJIsD7q9woDCTUMM9Rr+lf0P4ea8tS8R1iaWcE+Wz6GccLzvoWDz7cmMdcAhJPolfBdItcjaeow/eDZoICeeDykbySVn+ZhY63H/hxJGf9H2AemxJoyWQXKOKliB68vdRemHWmISGvUlA0+/LtNe8IpM8xvVmTKJkFZ7JcJU0EjaRjoUnoW9KCtH3+Mn4w4KXaFTkpg8ODjsSHKGME0zMQ178Tq/c+6kZUMvjqbQevNOv7aNT+x9eKpmESDDBozxAdlDrUJZQKaNtb8aAyyAFGWNwLw28LpxgQjggVaz0URhQsiAc1EMkC5afb3/8hZ78eraSBaob1Qts1oIxHxrFKLwIOBM652dJIwQSZaK0bd4iAZmAlKHgQCZtKRvUS5KaaAtUAgZ4rAWU2SGchmoE6cSzRbvEEtqj/VEYmDBQxzDdo4ARkkQRZdInZE1Y1aoQtDeqFUkdhHo5f0KvhPaYbJlUmbQgkvgoy+O3YqLi+1C1UawtIacdmbgg4KiptAEEmkl7l6MO05ZjeinRCFDHsX5TvXvYKdv9L69ovX5ccbE2F5CAVP6pHyG1qFC6/4KFmjb2r+QX+jVEuiSVMTKJimtNFjpeZdqCa4j6Fus2evQh7l2UdEge9w+KKApopHWD70KVJJMdJZPXQUBZCODVRFlGvYRc8pMxoCRgu8BvC2G2/erIo5pr4KDtC+onAgUFnnp0Wa39ex1p7iX6Kv5hFqwcK8SSiEm439ESR8hzeJJhOHHkZ1kWl3Ifa7BIR498Tgu3rIVdx/15jNwZCqj10Nn6/N0PzCKcxRhjOmM0izTGbcglJDMa8NaiRvJgYcGClkU0SWgsSFnw0a4s7Fn0RENhUVDzlq/Tuk3Z5r6ukpmu1k3qmJ8ODsmGI5QJwqJZyzXwqrc0Z+piQxRLJZZ/bhvTvH0jXfvEGWq9e9NSPxvCw0TP4EIyAuojRIgJqaSQEgoaAzTKHt698gCixKBGEgzkA4JhFRzCxCiY9drvo3Erkru7Rf6G5aq3cbIhi6zuIZaQJxJoIFKEknlUdMcJ/Gsojyg+JKtAGJio+XwSmZgQmBgIuaMQMimiLDE5EFInLE5oLxZQz5OyNpRy4Xc+n8xOJlcmElQkQmSozZBI1ERUG1RoiCcLA0goJIHrCrmlX9AuZIZTKqkigLDgwyRrnskPRZrPhXRZlZrzHV7br/W1qlCNXsnAqGMuUMvqfyVyFAS3aPSys5VVuEieKh5iDwY9BQs93d5vrk7sc7WZmAkhV0TZoq1QnFlgMKGjJGHFKCsUyT1Lv4JYcb+ygEMhRQGlP0faH1Dl2I6UBQP/596nH0IsrPeShQDnYIuqs9DhWoUvSq0ySn+j3xECh4wM/qyOdts9NcEqpV9V0s/QV5+3MiQSgshiD78zixOymflJ/7KloOjDLGLClUfOtTx7dseD+197Vm9kLFMgIy1upZJWH7T3KTqgYVszfuLRJXrAwoBxmzGKqArXlgUr9zr2pWgiAteccY1xgZJoRDK4/iiVKJZcdxL3IKj8npNXoK9/nWl2J5u9dE2xzzvi2BrVra4j9m6vY/froHo1/572dfjvwRHKBIJBcubEBRr62g/68auJKszdnlQWhvKVm7pez33wkDrs0zqmZAgmLULOrOZRR1ArIEOlbbcHCSBBA1UMdSUWMBCS3MOEwMAHAeL7CL8xGaBe2seCvKqq3X4/+ROwm0pJqFm1kkY8vm3dPAZZiBUDNqohhAziwwAMeS7PHsD4KFEmra8Qcob6yYSNSgJCXr6yc+bokkvO1fhxk3XwQWfo5pvvMSoDkyOkHsIbC0j4YDJh0kQhhMhCBCCpNimDECcKFiSS14Zn1HNtUHnCfX2osqjGkNN4QLISkxQkmWPhGGgX1JWsgnzt9Nyd8iVphxNUyqs79tBlHfY2/jgUtRWpg5RSZ458CSE9fm1eV6RpH/bUwEeeifvTOD5IOESefoIPs7QsfggdHldUZ+5JADm01xlfZeR7eS0LR1RraktCzsJBOzEO0FfxhbIIgLjY0DjvpT+zYOIzuJ+JOqCoH3TIzhpw+2wlquY4pH3D+oDSQu9q0cLVhuyijBK6t1nWVhUmMrBy8So1rrOTTu93uk4/u59adWiRkF2ZygPag2u3zyl9tfiglioIFVXIyuH/sxLEQ12P1ZE7bRvWZ0wh2sMYgzeSa8RYyndz/VhUQCzpA5EJkixe8FUSnSBJjHuc1/A83kqiJ3vutZdOvvQWffrrQuXmF5pCG6WdAlUZwPH7764rju+pSuUsI+fgUBYcoUwSzjvvfE0ZP00vD3pDG9dv0oknnaBHnrpfL7w6SOPGjzOTdSyDKGEvBhwUJPyDqAx47UrbOQY1EVIAOcL3hX+sNNhdGwjNQtjIeqUAb2k75Dz90Q96+5uJcRQyLxvVKqVr1FOXlXqehIUhlzaZhdU8RJgdhKJ5Jy0gxSgEeNrwmKIeMGATpmvU2K+NWW8rK2+ECgopx/OXQhYKefL7mujXn4Ma+NBsrVhWyRBFSGIsgICidKJKoVpAJs25VqtmJhqIB4oyxLgoFNScLcs0e8tSLcxepfGTJ2jq5Km65dJr1aZqE7WrtpM6tu9g+gLezEQAFQ0VjjYhnMrkVWWXnXX/qt+VNNCmc5do2aMvG/Vqz4Or64bnWyT2K0LStNEB3XV+6b7X8gAFkCQr+p7Nuo9mPeDeJVRpywVZoNqhLEPkIQ3RFniEPvFDklhVkk+WNqMf2S0hCa2jmpKMhpIOiYPwkiBG6J36l1dd21QXX1mQkHblcfYp6zRhXPHnoQDbcDW/Txg/QSM/+EE1cuupflojeQXbkmdfik+tOjbToWccoEPO7KUqNWKzEsQDrhsLZ8bU/OoZGjDhE/2xcWVZ9cq3I5P1MqsaMhlZxDwS+EkRBSCXXCtUWMi9Va2pwUq0I3xDBhaX3NeokvQvSKkdk7/8ZpRufflr+as12LopRMzH7fOpbs0qeviSvtq1RWKtBA7/bThCmSSQQY0RnbAxK1UIBKSNSQUPHaEMiE9pYBXLZzBJQUIYcCBAZalRTCIMPBBKyCEevZKUFsK8HCNqG4odxxZL0sGrX/yqFz77OamEslKKpwFHtjVJMyiCpRFwvH4oQfiO8P6h3DGJolzi2woPS0LmuT4QSMLZhJv5f81a0uvvdlGrNiQpocaVHGoNhXwmZPj79FTddXOWXn5p+NZi29FAmBNFlXA2qh99whYdZ6JAXWWygVik1MzUSQ9epiX187WpMNtMFQFfwIS9mGQCKQGxH02aP0X545er/mKfPnjmDSUSJDthe0A9a3jMoQoc2atck215kVEY1GW5VdWiZQt5bQep0MfWpontW+x1f1CTIaqRWfrkX14QokTJR3XkPiWsHL7AgLhACiAVkUDp5P4saZGI/YL7H8WSqAQksTTQP0je4NqhZqF80tdYXLFIQa1koYAf8+3Bh6rrPtPiUiY9z6cP395FmzfsbsYRxg7Ir/U8/vrFRD112ctavXitqC5GJng0UByfuq8paSk6+fqjddqtx5u6rskAfRulkHsNTzrILyxU58tOkq/XLgpVSmM/0aj2DtT04m1F03RKy666tF0vVU4pn9IH4WfBhsrIuMV1wbvNeIClBX+ujZAAxjPGKRactHGPAw7R+Q++rxXrNld4/IVUpqYE9Ez/49S5TXx1aR0cLByhTAIgLKxAURMxYVtPI6Fro/hUqWIyhvHJlTYxWHM+oU6UKzwzTBZlhclt1jA+L1a+1NgLB/4mJj0UEkz+hF1IGrHhuFgweso8XfvMZ0oavJC2LJul2cNfNn9CyCnvArlkMuAnD56L9KBRpoVwJMolCgSlgVCCIJfYBFj1M5lQZgfVADKw3wE+1W38mipV9sWUSfzXYfpVFAzpqYH5Ouf0odpnn323IfYozJBIkqrsNokozhwHIU/CYNSVhIwy8b8361u9tOhrhXyefLH4FZlQfNJJzXrp3JaHKyOQ2DAWiu35bz2nhc3qyJeSvLBkhj+gP06/VmvzJmrM8guS8h2UGqoZ7K2Dd4leOB7M3LBGwxfPNnuSz1i3StlFBWbybVipmjrXbWiy0Y9o1laVU7dtZ64d15q6grQZVhNIHWFeCCOqM0pjtPucxQQqJ8pVpNLteQVatmKknnjqUjXeqUBHHnmwqlSpYXaiSU/bXZlpXZUSqGO+H6Uc5Y2QM2FvlGZUTfo+nl1LLgHPU+ng8CM9BQOPm+8pbQEVCc/zK+Cvq8Z1nlOljL3Nc9xrLN4Y+7764mt9cPdQffvWD/L5fYbMxw5PtZvW0v1Db1HLDiVHSSoK6oByP+JRtYlVVi3+cezPympSTRc+eoca7dlB2ZUDKgwFleLzq3GlGupYq4n2qttcvRvvpsyU+Agvi0kiLCwkCW0zPrBoxibAVreMyywmuG4QTlTuIZ99rh7n3qt8X3rci3n6dXpait674ww1qZe8uqEO/x04QpkEQNhQFlmpQxoABA8DPYZ+wkB4/2xJjGhgAoKMYsRGQeO9JIbEUoyciQVTP+ET3sskY8O8hNcYxCC4kFtIbmmh4ZKwesMWHXH9S0oWGOzO77uXenfeyazo7YMSOfxEfQG29I0lmPYB6SSkRGYkxBIVkAmdMDNEDwWFUD8E/aTTKmvVhgF/ltKp+DG/+WqBdm/3jJYsWWpIJEQR1QHVChJJPUSbFc4EQT9ALYJUfvzZpxpZc6HGrq1YaBl1p3FmbQ3c4yLVz9h2H/OKLIgIxdmSOkM3LdO02hlJS8gBodw8he59SVc/2lotumxOkHdyewTzM3XiLsWll8Lxw7IFemLqj5q0ZrlRoZirI7eUhFQUeSFVSknVyTvvrqs6dleN9Mzt2g4ViYQd1CeSgCCNJObY7TIjgXJJKBrVEEsEC6Ci4EptyHpDG7PeUChEhrrPlE2ifxYr9XRUNlXwqyB3Tz3z+HK9+PyvxsbBPc64Q38mk5/7nGNA3YTsoojxO99lnm9dRdfdnKFeB6aY8DUfH33Rap9LUY0qZ6pu9Rvk929bWYFzPGj/g9V0XXtlFlYtJ5H8C2wm4AtIx917qC66/vyEeSyJDtA2KO8kDAGUf8ZroiB2H3aShfCBQpArsh1reYFyTL9BuSThkoiRrTGLbxqFkrH//Fuf1JSVwYQdT8Dv024tG+qlASebbW8dHOKBI5RJAGFXBqtwEz6kgtUwKgb/4zWEXqKVkGBAQ7EiJM6gBuFDvYhVQbSrbXx57AaCl4nEAUJzKBOocygo8e4Xe9pdb2nu0jVm8k0Glo58UZ3btdhaGxMfkSVk+MsiSSYP/GFWhWFitgSTEBLJLJTpIYwIeP6Ouw9Rp70+TNgxP3zvZr39eqFJtoFEojREqz+Hnw2fKsd+0WWXaO3BNVSzU1N5cYzpAZ9fNdOq6tmuV6heRsmKA+0DoY226wuqDeH58O0Cq+zXVbXOOT6pk2ptf6oOmrZSrY74VnV3Sp6NAjTPeVJ7dChe6G0uyNc940ea7STxxGEliAWQzuppGXpo3946pOlf4clwkkioG18lHkYWDpC5kkpb2W1SW7Zsoc++uEjrs+6W55HQUnYZsqJCirz7tHn9nuq826tKCdQyYw+LRULpjAUoYNwz9EUWs/b6EqFgXDIlsGrl6bQzqqnrXn7tsmu6UtP+aouiwnRVq9JNlTMPUvVKJykQqFli3+p/wK2a/sOsMrcuLQsQ+iKvUCubztGVN1xu/OAVWfxacM60MeSUxbXN9GexyXhod6BiEU/EhjYsTymyRAByiyBAhjgVH2hPuxHBeZf113crKiVlI4nbzj5UR/fYLfEf7PCfgiOUSQArSvxyTNAWZOxBIFkh44lBSSCkEZmBzaoU8sQkhMLIZzDQlVS7LBoIkeOzhACgxKHIEWJFqYxl54ZY8fmP03X36/EXdY+EFwqpXpWA9q2btTWrnAmP84EE2sLr/CTDOrwEDIk6kKJwksmD58JrWWKEr1otpNfeC6paNZ8phJ0IUNv4xCM36pGHPzJhx6jn53kmaxf1gV16nvjjEw1Z+lNx8c04AalsXaWRnuh4sZYu/ktl5EH/4yeWgHB13IbaaB9LNPCUovzy3HKvQI3uvkrJAgWhCyf/oT0WrtM5j61Mmjpp8eCFi3RS75t1xiUX6rQRg7Vg8waFKrgnOe+6qcv+umi36FsaojqiPtIfUQbxTOJrjraY+/XXHzXht2N08OEVXegFFCyqrE/f76EH7x9sxhBLUiw4Bq432/yROGOrInDdycqGTJGcxy1Vp65fHTvtqtmzFumgA4/Xiy++VObYMfT5b/TUpQmMXPgkf62Qvl03RDVr1TQ+b2w85anmELnHOXVBKcdl2wY1ksgFCU2AbW2JMhHd+CdBFAYllQ0NWCjvtPcxqtt+X/n8ibWesE5s0aC2Bt/NzlJOpXSoOByhTALwR6ImQioBHpxLbr9Z30+eqGeefVZVUtN0yO57aKdadQzRCQd+PkgmZT8oF8KDcHesIOSGJ4vwOAlAKHMQTLx7iR4s8goKdfytr2vNhqwKTcil4chdq2jA5WcX10b0B0wozRZe5yfeUiZBFBdUhfB9ylnNl5QtTzkliDwJTz0OHKO9e2SXyzNZNgJaujhdvQ9YbJKEou18Y+tfoj7X6dxcV056NoHf/+eWdS+P0ZLB483fEG5UKMgAKm142SFKzUDSUa554EnlJ+F4FC4I70uvvqKHA+uUF0zcvvXhoPX33hBU1vff6ZyBa5VsPDNgqb7/aotaPXC9QjWqKpiA5J+79jxYZ7WPXsaL8k+oXSTKQRAgL/gquU/tYsjzCrVs7bnKyh1ltpasKAiL52R7Ordftlq1OMiEtVFLsbkQ/qbvkTjDIqu0xSiLT9RVfMb0AYgXnmxbVJ1qCpH32fqVG3Rmq8uVn5v4wukZnUOqvHOqKbfFfY9ayXGGJ6+UBlRZ+jbhbiI4Fnit8VbTTqiXgG0yOUeiCDsCuJ+/Gz1GN7z1qzx8AEnCKzeeoo6ty7/Np4ODhSOUSbj5GXgvu+oqdep3nN6ZNUW/rVuhwrAQokVw0xadved+OrPdHtq5Rh3juaRMCL4dyAaEBAN5LECNwINDIhB+HIzxePNQHFBEkoUJMxfr4kc/ivtzTHirmqeCep7yM3LlVU+T96dilxlI0a6165uEiBNa7WbaigmCrFpLMO2uLoCJI3wLSRTeiy++2EzeKA/4K4uCqzVvOQQgMftSR+Klp3fXE499a/ybJFSFg/Aa6geq1QXjHtf8rBUxh1pjRaigSGNPel5FWfkmTGgJY/iDdooW0oNwcsz4/phwIeK3jB2u9+dMTei2ixZQqnPXBZS1bqn2PHe0ko3X7tykseldVHnfPWJLfIoxBD7syLPVvtb2FRJYzEG+IGYshMj4ZsGHrxrSxuJxzaaHtH4zBCb+9qUCgU/1dcxh65WdHTR1Klk0ML6Q5IEVhLqy0YDNhsUbYxDXHmUMQozfmONExaNcEvcS95Ytqr777rvrnXs/1lt3fWBKayUa+Sm5GlP4hVlc24Lw3O8cGxGhsrYkZPtTKlqQOGRL70CSiRRAILkeAJ81UR1IZ+R9+09iypxlOv+hwUn7fPyTFx21r847MnbxwsEhEm63+QSDZIa8nZvoo+aV9OaPX5jkkpLUu0D1qnpn1mS9NWuyDmjQXKOuucNM9JBJPI+xkElClyT6WG8ggyCTBwSTCSSWJJ540LVdU53du5te/6pYDasI8muFlNM8qGBlW1Jt223CcoNFmrB6mSavWa4Xpv+qbvWa6PY9DzLkm4cl8oRzw7eQxKcaHu5jMsXHhp/Nn/5ewsvSbIUX0NXXNdeqFaca8kjY2CYAcI1I2CHLfubmJZqbtTwph+BPTdFdQ57RmW0PN8XRY1WnIeqoqnh2yQym0gA4vW1nvTN7SlLC3Zt/maqH3vtSDRs10B5nVDZ+wGRihZeuKj1LLvFUUfQfM0xf9D1bgYgC8CzsLInB5oDKhvWFaARk89zzu+v62xbEpUyGg3JWodAKnXtRuk45/iez3SNAnYMsYR8pCdw3+H7ppzasjD0EkomqygOPLVnpkEsSgMhsb9SwkXbb1D0pZBKkF2Vq0H3P68MR75uFNn2aMkuE6bEPEcImAZHEt8hdkLD8UNkhsrYu3kkIJuOEBdnfgM/ckTBz0aoyC5fHBU/6Y9H2VQgcHMqD5KVt/geRXVigK34cprqXnKZcr5jIlBUKtrrld8sXyLviVC2tkmrCOdEKHYeDAZ9VN5MFviwKeTM4oipAomyB3HgTb2LBZcf10MkHdir3+0IBT5vbFGnLrkEFrde+FC5h1bFJa5bp6GFv6tFJPxg7gXmbz2cyVwlfEbaDEFGHEtgiwiQ70U6mVt6Pj8grqShevPAFtXz1EE2fPs1cH/yzKDnWw2q3UTvurgsUKkqOQko7zqq0wZCBWMkkYVlCmSi6EAbIJGoliveWuQu1d2r14irWCUTAkzZ98o0hOpUyK2vhzGLfXzKxoV1P49NNJOibMzeu0ail87b7H4QyUgmGWLJoxFZwUO85222XlwjF6egTCtWw0V/Xnn6A1YIFDup4NM8e/lrUPtQ/u180fYikIQvIHCVssPTgEaX82TGHHKdQbvK8r4EUvyrn1zDKJAopoXcUdMgtyilhfe4tPNUktITbOhhLuf/Dx1S7bzYENLx+LOMGFTB47EhYumbTdguVRIJ5auGKdUn7fIf/BhyhTBCyCvN12jfv67eC4mSHcg+tfp98GemqfdlpOvKm/iWSABRQio+z0kaVZGBHmYOgELoBTAaWUCZboQQc63WnHqAbTz9IqQG/vD9JXmkIpXra1LHIhLiLP6R8kzch4kHTxuri7z5VfoS3j0kO5QffGCE8JhtUX3yThPDee+8dtWnni6tEUFmoXt2vTZvnmu8DTH6oklYBQSWquftO8iextuPinNXKDRZvfRcOCC0hTyZmiCPJCixOCIFjI+AnFgH6EJ5TEsIINX5w/tUq2pQlL4Hk53BVU+Mq1Y0Chto0a2K2kmTVNMjZkqngTq2Sso0kYe83Zm6byIFyDlGnvVH38CTioaRtUdfH/vq+unQLJNjHa+EzOz6Fw4aGo/kDWUgArCKRCiXnEK0wOwtWPOPHHHSCkolQ0NPsCcVknVqd1G6E5LKYxg9KX8ZCAHFkAwjGR9qb/o0SCXkP3yOc5/CvR9bohVDahJ0dCYXJWnhu8x1JWmA7/GfgQt4JAJPGZd9/pmnrVsqLg6VYEnn92K/VpFpN7dXgr1Uygx9+K3bYQe2gthyFiQnfRgJCZUsM/R2E0h77zjWlOUMfV+v9TlRRlYZba9BFTt6e39PmDkEFKeEXxzzKp3+3dL4JNQ7qdbQ5BhQWlDXK4uBfJNTMzhNMNhAp1Lapv32nzt2TP0CfcNJeWr6koQkjM1lb3xpJBWs3rFO7htuXE0ok8KVe+/Btyp65yny3fbDgCC8LBAgT0n60EwsTFEMe+O1szU68uL2WZmly59qGxMflp/Q8bRn1i5576zPz3T169DBJEWN/+kR9zlbSSMn3EzLl+YPyJWHvaNrjxxWL9Pp77+qPKVPNBgMQHcgZ/km8jJTwwvfHTx51Gg7Rxuznk+TlDWlT9nuqU/3GrWOLVUpZREC4whNrsIpwrVHVOWabDGj3k0cNZLERDUtnL1cgNaBgYTBpY+zCGexg9RdQUFH98VBSHokyTSzYOF4URs6PJEWIsa0HbNVJ9sYmWkH1CwtUTbzNRDl2NFCAPNlYs2qFucb2ejs4lBeOUCYAg+f8ptHLFyhh8En9fxymb48+T7OmzzA+JXx3DPastC+66KJtVtuRgDDYeo1/F6FEYSJc2rxJE3313C3qsMeeqtt2TwXTa6pBq920YXOOIYDpqSny7Zai9ZW3JOR7USq/XDRLH82briZrsswkgfrD5EhheH4nYQBvKaE5lMHdOtTS2Zds69NMBsaP/0ljf5TJREX1IFzH96Og3HjPrTpn2pNJP4avx4xUw00ZJps7nCjah/V3MsnSPtEIA8ouNgzUrdcfeFSzNq/TmSM+0KaCvHKTSkLNLDA2fT1Gmz8abmokUqbG1urMyblXn0zvo/QaGxRIUCknC5/Pr99zO0tVkuvRvPiuW1U/N2jK8lDYnB1rKHSO1zAy8vD7/GvkT6FQdXKOJRhaqylTRygvt6q51niIAb9TgocNEChVxgNvIvcLqh++Q/yUHL+t28qCgoWqfT2fYX+vtKy2qhXWkS+JQa/C/MKozzPGkTHPY8KECUZ9JamGtmbhRCkx+jWedMjn77//bsYrzjccvBcCuqP5J0HzBrXMjlzJAt1vw4qFJmGR7SgRK/6uucPh/weOUMaJjfm5unv8SCXaz7Iie7N63nq1Jj38nAmRkXhDfbTIbQYjQTIOA+jfqVCyqiXEDIkltMsqf9nCuaqU6jNE6rXHLv6zQK80Zd1yHf/l24lNh/E8DfjuMy25/mFlFIVMVjMeNeujovZcONasYeeR+ko28vPZYcNvFClUUwoVkxGLPcFfLV2qcL3B2LEla4tq5sko2pRXCgc+Ovxn9CmSRMITFv46h3wTpqUuJdtU0p92q91AI4+5QHf8OkKfL/yjePvHsmpo/rlFpLJyteaVD7VnzQaa16iRmfjpGxAuEtK4dod3eEw/LD83wS3hU7va5ym/Xki+vBwlCxDmSi12UuVFawzhwqKCMg6B4bpbAgZJHzHiG7350TpVTk2u8+jaAUfpuxHbWh84JtqeB+WkCF0zdqBgssc09w52DX5y7QGLIcYVyD87ufAefvJY+2uWVo3fFEsd9gojNYa9vfFDUpqJ/gShh1QSqocokaSIUoyNg7A+/48Md1NeiwXojoZdmid3vKKdrr3kbE3dOdMkN1ExhF3EqKHq4BArnIcyTnw0d5pyi6KvnOMBhGtdq4Z6/e23TLINqmRZZNKGu4FVMJNNKPk+VA67wwPhJULNkGDUEEgMagflUn78cYzuGDEkzv0zogAlIiWgen0OMOEaSn8wETLhoViiWKBYQqAI+S6Yv1k+ld2W8aJ1y16GPBB6Q/WgjVApwYtPP7d1R59k4vEHHjEqDRMoahNWAEAoljAgi4CSyCTHRxFpQrckYBD+tqiZkamneh2ll/fpo5wJ04oJo8naDskrCprsbV9YWN2/KUvr3xmqTmP+0KTBQ0w7QLJQJ5nISaZgwYRloU5mZ7WuTtgxMT3Fp4CqpjZX+5oXKqcw8TUSt0HIUyg1xfj68O8xMQNIGr5UaqASpqUm5Jw5M1W5cvKH4CeeuMOUy8I2Q6jb1mW1XkLUae4PwNaD+GgBhILFIXYNQuNULMCXTKFtFmkQL0gzYeYfJ/2QVDIJ4Wm2S5OYX481iHuPfm5tQtz7EGKIM+ori07aw254QD/kPrEEekcAVTzoQ5ecc5oKc7OS9j2IGAd2a2+2/OX6s7BjfCAyYbe5dXAoCzvOnfMvxZszJyXvw9PTVHXvTuUa4GwtxkQQSogIGaoY8qM9IG6vvvqqNm3aZJRIspkhLL/99tvW72ULM4tAzWpqPPDGpCRE8JmBvTrImzTL7HxBWAsiHp6tyQQDiWHiaNC8hmrVWZm0UOOmTSEN/Xy8IbgkD+ATZJBGLeH3JvUbKW/FJmU2KnmLxESg754H65TxfYzCzTacEAmIDSSbUDykJ5oPF7zwwgsm+YFrbIs+20mOJCe280O1RLlKrVZFnY88TM327qpaLZqZXU2yN2zSyHcGa87on7Vr/cZ6+5lntgknQvgJ/0MkyczFzsFiBLJy8y03qG7GbK3JI8klFBeZTPVX1T4Nn5Dflyq/L7kEjnv12v79ddYzr5nzw7MLSSG8DDGbNGnSVv9q0qoMRKBJk8aqVW1X87vN1oYMkhREP2CfaAgWSiWeQnZUApAwwsAsBumzEEx8itz3gAUuCwE+q0+vVvpx4NSknQN7e6/JX2Xua8qilVa5gHPEb07yIsokD3yR7JBDtQXei0rJvUhfw4pAiJdxgev0TwOCj98WIkxUg3GLa7VvmzqauDQ/4ZtIUNqOguYtGxWPA/ioWWCwrziZ8ZQPw7aBqJGoXdYc/j/hCGUcWJWzRYuzNilZSPH59cvKxTquVex7rFqFktANYPXNpFYSKSztAVEsSUVjMmFiZPCjODCTJ2oXRJL3MMmQfQ6R4XkeP+dv0BPzE1/LMLyu562DntRZBx1uJgbq5EEq7YMQnp3M+w+opfMvSVdSxkcvoIZ1+2jDhuIt6PBysvJnUqNUCd4tiNOGGcuVXq9q0jK9i9bn6OarB5iQOySSAuVkvXMMhC05ppLIJJMrx007QvggFhBIHihSqK2UaQKQRJ63CR8QEiZp1C/C2KFV63TujbeW6E0jZIoSSsUC+gvZ8Ch6F11yro65eg9tCk2o0PkHg56Ceak6uN3rqpJaXIuxfqUqmr+55DqM8YJdd3Zr2mJr7UfuPUAYljZjgsbHx0JtypTJKiq6XCkpyU0Qe/GF9zTg2tMNKYRIARR8CBe1HLmeXD9Uaop/jxo1yrwGGwv3siVg3NuQCpQ9HnhyLcHg3E556yJtXJ2c8ZBS7cN++kQv7/q06XdEHniQzBW54KZwPAtq+uDW9/t8ZjFJghznyo5BLJgA7cJii3OgtBg2hb+7bBDtjBoMicSGgCrIuEronnGDTPu1G7N0zM2vKq8gsWUQIKhn9f5rwWjbBM8sYwd9lnGAhSWLikjrjIODhdspJw58u2Suzh9VHDpKFlpWralX9zi0TOJnf4c08WByZ/AsCahlluiV9CA8FO15yCrEBHWLwTk8g5JBHgUDczuTDsTA4uaxw/XBnN9UlCxlxvO0/q3PTPawHRQhTkyGdq9q2gSPab36fn33S72EJ35Y7FT3Y1XKKC7RQqFowsb45gjxMimDT6aN0lOrv0zK9xN6zhk5X0vfLM4u57rhGUOlQcGlDSD8hGBJwgivk4gnlgxkEjT4iRqJ8s0kzQ4qJF/x4DkygekH9m/C+0w6ZOBi7kcB4j38bbciLQtcI8Kq7PqUk5OtuwYdpTa9FrGXkigYVRaCRZ4CKT5tnN9CVx7/uT4f8o05BnDtj19oyPwZSdnxx4JkumaVq5tQJeSGRR4qIFuqUgMV0gJhh8gd32+U2u0SSuoeyof2XKPDDzvX9D2sBpT54boTTbAhb7sBANeJZC1C5KiRqKsQG8gn4WMbDo+Gt+76UG/f+5FCCU4eoVpBnZ1q6bWZT5rjJ+xOcXjuJ/ooqiPjDn2QhSN9MnKHMMYjlEruARvuh1Rz/pwnJavsQpnXkiwG8adEUTLBgoPFJUQSSw5tj7WA8dV6QMPxyejfdP9b3ya0XunBXdvo/gv7lPo6FEuiTbQT7UqiaLQtbh3+23CEMg68+vsE3Tt+VMK3zQtHKL9ASy66PWZCSLgHTxx+OSZ2dohALYwkirbguUmWUb4hYz5fukkiKfV4QiGjJLG7hE0ysWDiZECEVOATI2QSnhBz7Jdvmd1ukgW8e1mjxxlSCfBzhpe+iXw0avGq/Kk/JLRki+f5lZ7WVs3rf2smAyaMFi1aGDWE0CFEiYx9Jr0HHnxQE/bNV1rtKvKVldRS7gORlgz4QvMnzzTEnonSkgF+h1TQB/DM0U70E9RK/uZYIZyAEKglkGR5h1soCFezoIB8oHYSZqQ/sQMMBMSq5NT64/8QzshdTEoDoXUm+4EDB6pKzZBueOQgNeu8VkViocS2IT4FqXn65+0HiSTEvXZePb1w3yT98NV8QzQgcEyEkLl3Z08x20gm646tmpqmWwKNdPtttxkPMUkN3I8QOI6D0DLnhaoGWb/u5kzt3nmefP7kLLKKitLV/6LWGjHiW7Owwj8IuPb0CxZaqM/c11wjlCiIJyFgFmD2erE44HnKR5WEdSvYy/syFeQl3lP+uzdBexy5m7FFcNwcL/YBiCUEE7JLm9LneKBAWgUdoK4xbtEPIpNu6LMs+iD5KMe0Df2c31FpSVIheS1RpB8BgDEAEkmiEGM5SiDVFrgvS7M4caz9nx6in35bEHcfZsipU72K3r3zDNWoUqxclwYWHswp1Kyljbjf8ViW5552+P+GI5RxgG0AH540OqlqB7fqC432KJEQRoL6aoQNyWZkVwxWvYQdw5FfOEebsz9Qbv4E5RVOk+fZrNdUpae2V2Z6F1WrdIwy0rpuM4gymLF9GQkFEEpW0uFgwiF0iTKDnxIFDDJlcehnr2j2xmKPZzJAIkj9lZs05OyrDEkqyz9aFFyjBSt6KuRRwigx1xChp06Vj1SvTnF4l1AaEzWqHxMHu3lA2pjI+fvUB67Q7zsnNuvYL5+OaLSnrt75WLNHMeSefgCRZGcWiCNKDxMoYAJDlbHhZ34n1EaY3Ba3jqYiQspR/gjVUVqGRQznG/keu4c0BAASVV6gpKHu0e9S03wacGc/HXFCZxUGVmje/D80ZsxYrVlaoGVzPR172OU65ICjDWngHoDQoTKR/UtbZBUVqtvgp5UfQ/H9ityrgfEzNHfQWybkTXtDKrlvuGcJz9ptAvGkcv1z86do8eojlAwUFXka/HaOXn6uslHy8B9CWFCc6YNUHoA0cR1ZQBAShoQxhkAcwvf7ZnGIMoWfr7T76snrn9OwgcUh80TtkNN+nzba86JddNvtt5kxBeIFwaXgvgWJf/RZxh7uLRRX+gALChRMwsZ4AyFy0YAvkz5KeJdzx9NLxIcIBwSQPgSxpDRRRXzp3FMo+YybEGDakWvBuUAmSysDF4lXX39TD34wVtUasZFFBUmuF1JhXpbuP+dA9Tn4rwhTLKBfoN6irNKfaa9kK7kO/w64pUUcyAikJNwgvd13pKSaVTITEEkUTNalbaeISghhsAQhfPDLK/hNi1cdp4Ure2n9lueVW/BrGJkEhcov/E0bs97S4tVHa+HKA5WV+1d4BXWA3XkgSJFkEjBYkvGNWoAHKXzAByl/w0q2Z/ceatSoUUyDfkqgrhrUGpjQPb2ffixLe+95uglxcw2YiJk0SABgECYTHpLOA4/noIvu0l6128mfoFsRMlkzraou2bmvIYpMtJBJJkImVZQaFGTInfXHMWlalYGJjpp9KJJ2671I8D5CuZwTChGWB74DNTEaASVsCrmyGe7lBWQI3yfezAvOv0T33Pim9ms/QF8871PHmnfpmQGL9fGza9WxxQkacM2dpswR4U3IBfU38S9Szoq+Wy0tXSe07sBKWolGMBTSwg+LLQyogRBH/KcATxyElnZjoQeZNK9L7ySf1ybRO1oasPvOsM8CRlWETHJMkEkAoaQPcJ+g+NEPIJYgfJccC5LLuO4lKZT8j+t/3eNXKlg9z4RS44U/4FdaZpoGvHa5Tj3tVHMObKuKKs4iGRXc1sjkeDk3PKEkieFThlASEYD00HfsPWdV2vAxk/7L9cJHivKGj5IFMt5FQPUBwtAskFncQMTLAm0ybtw4o/YyJkFuyf6HsPP5jAUsvMtDJokKXXj+uerRqEgn7t9pa1JNedGxdWNVWjJG55x2gllIlAf0E8Z67mdIN0Sda4Hy7vDfhiOUcaB1jdpJDHYXY+fq0Sf1kmD34A0nlJ5XqDWbHtKiVUcot8B6oEpTaIpN3wVFc7Rs7Zlase5KvfjS40Z9YjCMlgnJgI3iBWn5/vvvzWo/MkTUomrNCg1+sQJlomXN8rVX1Up9VKf6Peb3eK2dyxfvpReeyTJqFOFhduhhNc/kw0QEuaQeJJMT2bEkyRASv6H9yaqXUV2BOG9HsyViyNPdu5+lSoF0Q8I4BiZKrBCUSME3Rv+wixL8cSTBMFFBKiFvTK6E5JkEr7nmGhM+tB47QrYQIhYVeKgIo+NDo0xUSUD1ZFKvKKG04LiZ7FGpUFpZ4PC5EGLCcfRPFjOQAs4BRYi+yL7PkHmUWib4OtMWKJibl9D9vPms3JG/yL9xi0lsgThA3plsIdMlLQIhOFddOl2JXmt5IZ9GfB3SzN/zTB+AYJGkwvUGEDPsDHhnqcoA+YHcQHLoK5GLCUuswvf0toBIsGCBVFx51ZX6dN47atOtlSGEcZHJjFQ9OPw2NWxZXK6KNsTHx/2D75cFA/0OtRJPH2SXtqc/UMSckDLHCwFikUTfILTNuREp4Prg97bboYZvuUjYHEsHNhUK/pNlzXgGgaUvQbBRM/FxRgIPO4s2FjXcR3g2CQ0TbqetUTorshsNhJkNGo477ji99MLzuuH0g/T8dSeYouegtL2+LcEntH1DvwP10g2naNinH5h7mMWjzdwvDxjjWTjT9ii6kHzGgr+jHJrDjgkX8o4Dm/Lz1PH9J5Oa5d2vbSfdtdchMb+HyZPBEGWE1fqKFYtVFLhF2XkoExW70T3PpzmzCvTzqBN1//2DonqJKCvBwIIpnnAfAwyTvgUD1hXvv6Jx1XyMbkoW3jj4RPVqXDK5iQbUq2eeO04Dn24onx8iXp5waHGWa53qN2jj2t5q3aq1mUAgaExogEmbyRZyZvdYpz2YwCDBEPFQlRRdPek5rcxdXyFPbnH9x5B+u+ljHbvHwYb4Qars9+MBs15IyC0eNMgDxAJSA5jkmLQIf9J/mPwgQ5BQjpuJGgKMUk4ol5AyRCIW0D8gg6hHiarzx2QOqSTkxiRGVjrkmGMmU5bFDX0VGwZkknuDWowoVEcMuFIzdmmUkOPwe9JO1Wro44NO1i0DbjAJIYRZWUBAWgjVR9bygwCjVkKA8Phedk2ejj+J5LFELLj88vurq27lL/Xwwy8YRQ3iwDUg2cRmekPOIJj4O+mHXGdLBmhDCAOhTB5EGyDvEFPImgWEi4URZA6ChzoMcrPz9PDZT+vHj8f9Oe7Efl74iRu1aqDbPrhGrTpuG+WIVBYZc1jc4PeE9LGICCfvjEMkwdGXOVfGJ0LOPCyRRMVm0UfiCQu9krySEFkUT0ppYfmgzWgvIhDYAfDIcs/jmWUMhvjxP2wh8Zbb4X7mHsbCQRmf8HPkGKbOXa73vxmnYd/9qowa9bZ5b53qlbVby4Y6bM+2OqBza6WEVZWA/LL4ZcHAgi88Oa88QHGlHzH2cR1oJ2wEDv8tOEIZJ47+4k2zh3eyQt+vHXSCDmjyl7m8LOAVQ3kg9MxAP3/ZWSoIEraOT40JBX3KyGivZvWGyu/f1sDNgMZAzPeSzdq3b18TRmFSYrJ/9913zcCV1monNbwteXXemNgnnXKlamSUbTAPB8QbojRuwpdaveFmZed98ydRLI1YFv8/I62TGtR8TOlp7Uw7MDBDzEhUgbig+jGRsddweJKAnaCYpJmsTSgyI6D7x72ln3Nnx7b7TBg2T1+mPx7+WnnL2QWoGFglMNATci7JAkCIGxWFY2HSQ21CxUGFhgQxSRDWgoDyf4gQP3kQEkTpsSS5NDB5Q6CpxZjosiMQVdQi2prEG4iarW/JJGkTjDh2SBMKK8/vcumZyt079pJc0RDw+VQjPVOfHnGGmlYtrilKaJsEENoMOwAqDmQF8sUDckDIObwKQ526lfXux3XVpCmJMF68Tk7tVPf9rVUGuPcg1JBsyCHHALnmGFDMyabHDsC1hgSj+BFChmihqkEWLOjfvJfPgURCVlH/8Cay0AiHSdp6e5S6Ve+lTas2F3PKUk4NIsd+4Cf0P1Jn3HGi0jJi20mKRQ0EEVKJOo0yjyWH682x0b9Z/EQCtZHFFIojfdyWwiqtJBGAfGKjoM24bzhuS8QZf1nYQCZtUlq8gAzTZ6nOQLjf2iUiQRUFCP38BYuUWbWGgiFPVSulq1rl0jdxsJsccH/SjvHULobQs4DDasMCmvEnUe3gsOPDhbzjxNntuiSNTDasVLXcalt4yPvYEzJVEIQcxR/a8wc8FRTO1NrND2/3PyZM1DAUIQYkBhAGQCYfFCQmJDygz9x4mymD5EtSQs7msZN1cI+eW31VDPJrcydq2trHNHrZuRq6YD8NmbenPpu/t75ZfIwmrLpNkxa+om+/+9IkoKSlNFKTuq+rRYMxqlnlPKWmoI5sf7QpgYaqVulENa33pZrV/9KQSdQSQoqQMJJU8KXZPcUhlpBt2iYcTF6oo3jDIP/pXoom3/Op1jz2o/aoVTw5e+y8UrQtsSWX2fdnl8tZtE4zH/las28dqtDanG28b7Q75IGkgqht5nmGOHLtqD2I4keGNwQE0gDBYPJkUuW1hPAImxPCRvFCgYbAQVxRJEg8Kglcf/pFvGHvaMDbBljIoMCiBlMjEeWP68G1gLxBJiH7JAmhGu40b5Xyhn5vyLuxC1TAr9qkSnV90vv0rWQS8sr3QuBQdJnkaU/CrrQTGfA8B/lBZeJ5+sCa1Vk6sPtkbVhXR6E/dx0qPwLy+dLUpO5bW8kkYMFCKBJSb+vHMuGjqkEmIURcSxKmKFQPEaN6A/5YXseYQv+gb3FO2BwIo3Nv06YsQiCmEFGUeewv2CRQB28ceK0Ovr2bpupndTxoV1Wttb0ClpKWojZdW+miR8/U4OUv6rwH+sVMJrnXILMQW/o6pXZQBTkXEgg5fsLj0cD5QDzxAnMukEuuEeQTlY2+Td/ib3sPcR+gRHLP2l2nrKpnM+apmMBn0Y7xgkgA4gBRBRYqJZFJwHXBptKieVM1qF1NjetWL5NMAtqMBS+LWhYB8YSsGTdYTGM/4R5DaOCzXRj8vwGnUMaJvGCR9n7nSW0oKpAvDs9QNHTfGNJrl1xbahJOJDB4M7A3apyhNrvfrcpVEr1m8KlpvWHKTP8rW5fJiAkL76D14nDMKGOE1VCxICHgvdlTdNPY4UoKXvxYi34ebwjQvYNOUadDtyg7uMiUkvGiqI08H/KCKsgLqXWtE9Sx/pVKCxTvgW4RCmWroGieRo78SjfeeJtGfz9btWr+FYYjhMtkxo4jKBys9FmlQ7jwTVHyhsmI35lsIRr4UMOVDwZyMm5RRCBcDMC02bKctRo84Wu9MPRt1di5garWrqHsLVnaNH+VcuetVctAXR3WoYcOP+xwM4Fj/rfKIQ+IPkC5Y6CH8KO82EmJ15CZTaiS4wMsRCCVTMK2sD2vJ4SLL5DJAlDPEjUIkszx4lVkAoU4krXK8UeGvDhHyAwqS6JB/0KNglQQ1uQeoE8CFBdUK0g/52p3k7Loc8HZmtepuXIrZ5gVdlnU0mwr6ffrhEY7q+vmkGZOn2FUJL4bxcomO7FgoH9APFjkcX1pKxLWIPsoa4THuW94D966p54eqKuuraHzL6n852ImFvtF8VFnpHVRw1pPKi215EUo3wMppJ9ApPhu2gXyRxvio6Rvor6hNIWD0C19gYUHhIq+jIcRhQslk4dtW/ocCwg+D2KKDYbdXyC0a5et1/oVGxQMhlS5WqaatGmkQAWK+3MuLFw5fr7b3lMs4iC49FHanT5KWDcaUIv5X7hyzueSsGRD45wf7UV/Z4HFgpWFCfcT5BXlkD5H6B2FF9Wfz4DcoZwzPlZEpaOP0Gdoc+7vkiouWBASZ/ynj1UERJI4JxbGeEDjBfcCaq2tKED7REZpHP6/4BTKBGR677UiJ6FkkgzU2jmFGnzd7Wb1iKISCxjIUGIYRGvX/0kZmcnQAv1av2WQIRZMFmSUM0lbpQIwiKDUcNyYyC2ZBCe13l0d6zQ0ocJEJkQU/jJVKyZM1YOP3qJbXm6lnQ+ari2FC4v/X8KkzPMcRnqmX0tzh+ibxcdqRfYP256tv7Iy0nZXaqCzpv9WqC2bi48bkgDpslmf+LRQZlDqAESC1T5g0kaVQg3igeIQboKnfAjKH2SSiZeQMxPcK48+qzevfFSzHx2ucRe9oTGnPaddf5Qe3fsSTX/xW41883MNuH6AUePsntF49s4//3wzmdpsYkJPTPT451DPCAWjHnCdIA2QSSZA1CkUBZ6HeHI+1hvFteSaMzFCFlADIc4ou3gxUQLJ/OT48erxOSiaTKhM2hBJVB+Oy+6dnEhwXiiBANJiS95ABCDJHAfXieuFihnuabugzzHKffQNtZ44T13qNdmmX1HbVPhT/1RtAkVBBcdO1bIbB2rgYSfo1BNPMmW6rFUAfx2JPxAP1CV8iBAV7k0metoPQgJpJwRN34CIEyJn8cFW4/t0fUXN6n+lqpl9t3p0Izc1oyQQ3maQltrW2C6a1vusVDIJILqUHmOhx8KGfmx3RYFg0o4cTzTywjXkmnOuXFPqi0KoOG4SV+gDqNS2AgR2DlQ1VEKuO0oe5OuqAVdoyKiPtWTTAqXXSq0QmQTcU/gVIb/hCzQIovXPMj5xHCxwUBYjgX8ZT2l4OSveR0QBpZv+TRibxSK2GEuYWTCyaCb6QLuQkIIfmX5HP4NwQry5l2hTbBjlSXyhLVFLORbur7LIJMeAQhm+RWp5wXXD08v9S5+OF5BHrj/9nrbH+sNCj7nC4f8TTqFMAFBkFrRpqI27NIv7swi9+YqK9P0pl2vzwiVmQGPFDQngZi9tYGEAYyAbNmyImra9Vmnpia1vGL6l3QF7r9bqVSFDWCCPTJCsyCEaTKSQnJIwb9M6HTH0NRUE2aguPkBMqwdS9fuld6hNm2q66qmaqlk3TfJVJMxfrPTsXvt6ta6xbVkkSAJeLJQCFEUIGcQIhQ81hEkDQDyYoPjbbrsXDkuyITQkONjMUgZaHvb9TFQoSZAyvpvJEwWS9ib8aLNumdxpcwgopCW81qMtzIxSwHGj1KFCQF4hi/xN/2KSR1nhe1ASSGyJLP7MZ6NoMskCiBEEhIkXEsXCx4Jjp42YSFB4mITx4zGxY9rn+CGXiQDtRdY3PlgmLdrFZiJDYJhgIeqolyTkoJpSrxCVkAQHiAILHs4PkgTxeey5Z7U+w6+a7VqrgP15CgpVtGGTChctU4cGO6l1y5bmPFhQkRRCaLQkQEYg4nwH9wlkjWPg/fxkcsV3TIgU8sBGAHZLQFsrNTvve1PyK7/wd4VCWfL5UjTk0wlqUK+Xjj7yVqWnFpf9iRV4HRmzUKIgl6jqEDPakutJGJn+xmsiE4isQgkRjgZUbPoCaisqF0SVkD59nXZASUTxQ9G1HlLaj/fYBCB+h6CVlrxFu7FooQ1tUpkF15JzRN1jkYNSjZeP+5Frxn1mt8bEc0j/tIt23ouiRnKNDVuzAIQ4Q0rtPtv0a/7PwpG+zWKCRRiLQ+5f+hWfg78X0sr1gbhD2mj3yNrA4cDPyf2BR5X+WNpYaoFCylgB+USprCjoAyxAibjQRznnRICxgv7A4oO2R61krHH4/4IjlAkAHqUTTjxRvmMO0Idzp8VFjoJ5+VrzyCvKml1cN42VJ5M93iv+RuFi0om2OwGDNAPy+IlvqGrdG5UsMOgM+6S9DjngcUOsGPSYrCFWDN6oWmVNcGOWL9A5Iz8yfrGK7jREe1VLy9BHvftp4qgh2lz/cVWvnWJ2TIkXnevephbVjtv6N94oyAkkhUkFIsY1sbX7LCA1EDSUMIhONDBRkCkLgYHUMEHTfoDJif8zAaKAohaQ2IS6wecRduTaQ8ognDZzGZIIAWCSIzxtwYSHUokSxXXi8/kbQsl3E46EGKPqoWDifSqpBBATMf4wVAcUUcgpbUF/4L0QTo4pHEysePcglzxQESFXJC0wWTGplKcOnyXNfKbdvjBS+aH9UYo5P/ohpJ3jQpGjTVHZmNAhlShr0cD/uN68jnAwx8h1sdm9XH97PjZrOhzct5BN2tNmyhP65N6FZPE+2hPSAZHnuqB40c9iCY9ybhwj16C8YLGAcgoBYsEBCeT46De2ziTEh8LV/M0CiHbm9Vx7Xhtt/OGc+VxUOsYi+hWLTMaFSB8jr6UPhofL+R01E9BHULTCiSYPCDCAqEHMIKkQqXCgruEN5l60tguOBXsB1gcIG/8nZI+/lmvCogwSiV+Se4VFGSSSfh15j1vQ92kXyCWZ1yQi0hcgoLQVPlQWlhwj9w3XypZz4x7k3g4vVQRYdPB+LAWQXI4vFnDskGWO3bZRRcG14bw5L+6PyGOMB/i1aXvGL8Yr5g9L7h3+/XCEMk5wAxP+YPA9hUl1+q96bPIYs/9seXfQaV+zrppPmKvn73nAKDx2/2EbAmHVT3YhNziTNxNnOFBieM+seQ8plPKECecmBymqUbmfqmXebgZMzO+EvwjtoQzQFrFg1PyZumDEhypKTSm3ZYBTa1Gtll496AQ1q1pDP624TKuyf5EvrgzZv+BXqg7a6QN5ebXMahp1Bk8hSgQTEwQgGghxsX856iBkzg7ukC5bGxEPIZ5DyBGArDA54XlESSNkzXWG7PFZTOq8HqCyoIKgAkJu+Q4UE/oCkzDHxvvDwfshIIBrhPJA2BfyyWIIwsAiAIKEkoCSSMgQj5+tRwgxhGjyPr4D2NAtkyVtg+KJYsuiJ9zmYEEbQDggDbQLBAIShaLC5MKkbpVeC76DSdsSSAgX7cbEjWLMsdJ+HANeOv6GONvMW8gm5IOi26bqwfz5xusYLezOsfA8542SYlVgSBTHBuzOU5AHfkJcIZeRxwwZ4TpDPiFfEH4bCoY0oDZjT0CFg8jRL1hgxLqTkI1c2D2oywP6AOSMiZxwsd0Skz4IgbOhYa41aiXtAtHidVwn2jSaKotSDVm2YxfEjvOkz8Zad5HxFDIaTjQhZPZ64WOk3bkf6DcoaSzewgvzo+ihukYbh1gQEJKmv9CnuRYQRkgwBJ1+TyKOrdcZK+hr0UoS4SO3WeP0bcZtvp/7FnC/QyxpV9ofpZ3+C5HjvbGCcYf+xjEkArQji1Xan/sukSWAaCv6E0oo4waLDWw15ckVcNgx4QhlnGBgIzzBIEwIBszasEZ3/DpCv6xaUqw6lkAsyRJFnUsNerq6ay9duNueWr1ipZnImNSilbqANDJpE8bkhuRmtIoGHjjet2hFf2XnfSB/IDn7AwO2Zfx19OmGjBDiZoIhq5kBk0mlLEBgWMEvXrNKhz15r37NXV9qW4X72shyvqzjvrqy475KD6Ro0ebPNXHNHQk8u+KEnZx11XVl7ylmEkJd4twgepCFaICMMXFCHJhMUWshDAz0PDhniBbkztaEZOLgOmJl4NoykTGxoOAxMaPwQCD5bgsUrYMO7KNq1Zrp5JMvkN9fVQX5Rfr117Fq07aJ+vXrq86dm6l+g7/CkihikAUGcI4JQkffwftpB3KOn8mQMCHHCymzyTwQOBRFSA9ELhwcL+QINQ4yxefhHyVMGkm8USTwM6ISQXRRdiCyTKJMNBwj3isme4gEfQvQriyk7NaFECLUHlQmSAVKDkQRAszx8jvEJDwBh8+gzXkti0CIsd1+kusC0YZYcNxcc46TkjKcO4QAgk+0wNZXpe9DcJnEbXiWz+MexIrApGwzqMM9aRAslEGOjfPktahLLB5iBYscjo1rVt66nqhjkElIDWoUIelIUmgBIeZ76CuoZqi2kEwKtoeDdoN00EdQr7mWkGMWLCSjxQOuM21sVUzuK1R962tlQYHqSp+gX/F/jjEaOWfRwbhKf+U19tpzH7DwQE1OBLgPUJ+5n7iXuE62JBHjHv8nBGzJO15P7nXOk+sRLibEAsgnRJp7N1GgLSHmjBksXji+RIJ+j/2E+xdizeIsUVYYh38GLiknTjDAMQhxQ1i0rVlX7x9+mr49+jyd076rOtSqr9SIEFGdjMo6sEkrdVqwXltuf1oXtOuiVH/ATHpM9laRigQ3HAMriiA3IiSWiQ4wQTEBpKYWsVRQMhHysszghdrBQAYhsCGvWNqMAZCB6qdvR2nwSRdoxNHn6fS2nVU1dXtlyyK9oEi5X/+oIfsdr+v32M+QSc8L6Y8NxYpZIkHCTmbt9brk+t6GvEMImHgYZEsCExmDJEodpApiSWibtoEgMsEwieNzYpJGVeQ5VBcIOW1JWAyCQMIGEyJKGOTHYtiwn3Tl5a+qW9f+atvmOE2evEaTJy3SjBnLVKVKUy1f5tMjD3+h0059VjfdMFiTJi40xMaqiIDv4hqgHoWrAixMCHWhXDJhW/WK5/Ca0S/5DLtrjgXHC4FERWdSoJ1IULALI9QaO/nTfzkeJiiOAxJAiI9+w32ESksZGEgmkz/tZhM7IAIkEUEgUEFRlPgeJmMIJOB4uR9Y3PBaSCKWAM6B9xHy5G+SYMKTNDgm1GcWDKiJhOV4LeFU/H9cf8gh38e5rN6SpdMvu0JLNm7WOx98YPo+KjYTMCFhCCkLP9qU62vBd0KIaUNUSc4Z5couVErrX+Fg4YFqR98sL/hOFG4WB5EqGP7TcIIKQURRQxXk9SBaeSi8tbyPfmYXPYxTELV4wf3EvWLVQ9s3+Qn5IvRNXyCMyv3D9cG7CsHFn8p15DUsjljgoOahSrJQg+TxGgg6bco9zLWMFywQ8b3T/+iT3Oe2JBHKKn2Dvo8tgkUOfZ0+zLHb98QK+gH3c6Lru3K/074cE9aUksqPVRTYUOhbWFgY4yDRXOOStvd0+BfAc4gLZ511ltetW7cyX1cQLPJe//hDL1CrurdgxbKtz0+fPp2Z1vvggw+2Pte7d2/z3Pr160v9zLlz53qHHnqoee2xxx7rXXfddV69evW8Feuu8X5f2Mibubhh0h5zlhzopaSkeE899ZQ5lgEDBniNGjXyQqFQqcf8xRdfeFWqVPG6dOnirVixYrv/z5gxwwvUqente24/r9M5p3gfzPnNG7VkrvflD997Pp9v6/dZrMwe6308t1OSHl28sSuu2fpdtO0999yzzfcvWbLEe/nll70TTzzRCwQC5lpUr17da9q0qXksWrSoxLb4/PPPzev5mZWV5Z1++unm78suu8zLy8vzJk+ebP7me2fPXuDdeMOb3oH73+8d0Ote87Osx8EHPmB+dtnjTC8lJcNr2LChN2zYMK9atWregQce6OXm5nqx4JdffjHnVrduXXM8DRo08Pr37+9NmDAh6vXOyckx/YH30Ed4T+fOnb1HHnnEe/31172MjOJjCW+vww8/3Lv77ru9kSNHmn7x0Ucfeccff7zpK7ymcuXK5vtTU1PN3zz4fZ999jHHwjXwF1cE995///3tjumTTz4x/0tPT/dq1qzpPfDAA17jxo29U0891atfv77Xq1cv079at25tXnfwwQd7gwcP9o466ijzd49e+3stD+3jNT7zIq/T/U96be5+7K/HXQO9XW++16t/9Ele7ba7mM8fMmSI+d60tDTvmWeeMb+PHTvW/K9jx47e8uXLvSOOOMJcW35/8803zXXZaaedvO+++67Ma7Jy5UpzXB9//LFXXhx99NHe/vvvb94/fPjwrc+PHz/eHAPteMstt2xtr3fffdc77rjjzN+00TXX/HVP2Hua/7399ttbnzvnnHO8Zs2aeUVFRV6iQF874IADvLZt23oFBQXb/Z925vg+/PBD78UXXzTHTF+1/cX2o/3228+79tprvSZNmpjX8FnTpk3beq07derkffXVV2WOZRU9B+6b22+/3XyPbVN+tm/f3svMzDS/cw2YB2bPnl3mZ/J5vOfnn3/2kgHmqBo1api2Z1xKBoLBoPfaa695derUMX3wiSee8AoLC5PyXQ7Jg1Mo4wQrw/AM15KA+lgzJU3B9ZtUyf+XAsCqmBBoeEjThtSsV60ksLpG5WDVi3qAT8xkE/oSG5qIBCVLhn893agsqD0olazAyaosLRkHlQcvGioVhvNatepo9qwV+uKLKXr3nZ/1zts/a/D7P6pSfiVVXbZejVdv0YmtO6hH/aa64bIrTAYq5U7CsTx7lAlPJwdBLc8arZBXuHXFjnJACIswNdcOZYQQIYkNtAcZ0rwGBRm1JzJJJVxVwHuKaoEyhpKFSkUbkQRCWNKqbpmZtXT+uS/p11+KExZ8vthuW1sgu1rVNtpnr/76+usfTLgNxQ/VkJCtTRIoDYRxUb4JeaI88T78aahAKOSE7sITkAgR4wvDgmETfFCr8ABTooh2QhEk2YhzxApgaqc2amRC4Ci7eARRalD6UDxpH3yp9ngJW6PiYhlA5UBxRAlE6QhX9/HIoWZyT9E3OV6OleuCwkUoF2UHFQyVlNcTsiWEy3kWFBXpzEee1Or9eivQ/UBVarmzciIKzWNWLsyopGqduql2v/O1192Paqc9uplrzAOvK30GRYw+w/HRNtwzfBeqGeokIXr8gCg1tJX12EYD6i7KbLRSOLEolHYrSM4dBYp+h3KKYo1yRgIT145sbtRnFHXuWVRI2hvlmXbk+nBPojJbjygqK9cGL2+8Ww6Gg/AxthC+P3I3F1RhipMTUqYdUf7IVOd8sEXgM+ZvzoM+gurM/clzXB/an+dRL7FwoMhxHawqmyjYkkT0d9R4vIO0P2oq0QiUY6JUHBPqIJEvrofZSasEUC6I6xLLPFQSQl6e8gpmKDd/vHLzp6gouG7r/+iz1hfK/ZsIBTcSeGD5bEL+9CPahfGFSIbDvwfOQxkH7GSBLyyS6EQDoUTIA5J+eOagLShrDf9MuAyEDBDW51MWCEfgbeOGPOvcdrrpzsSGJ8JB/bsXB0lvv1ZoyIPNzGSwJERIeIoHkz4/8VHhSyMcxoB94YXXa9jQyRo18g8V/Tk5B/5MyikOp5JQEVJmpS16+OHLNeyLd8z78atF+qJGLTlVGwuK96xOFt66LUP1q3U04TC8UByj9ePxIITFpMX1xavI4M5kC+En/Mo1jwRJH2S/QrQik6uYIEggIQwmZWj/XtcrO6tQfn/FJ2e/n/qDlfTMoLOMt5LJiskX0gSRjZa1C5jsmFDwqEESLJh0meRYTNhkHiZFSB0kgzAW5IyJH5JEmBQySP+AfPM7oV6+14a4+B37BP3GPvheQueEk5mEITmQbSY3CC79j2tAUgMJQhAlSAxEFbLGe3gOUsR1waeIh5Fz4nMgxracCe+hf0GymECfe+c9PT1lprwatcpVlgcvMLtnndppF915zBG65uqrTUgV0gWRgTjgRSTsydgRDvoWhIkQLW3F8ZWU6cvxQ0bDr0ssIKuZ6w+BYoFAWJoxCIsAIXTaifPnmJnYIUCMTZB3dsihfenfLJy4PnhdIbZ28YDtgdcxLiTKdwe55prZRXT49eA4aEusEoDFAlYTSCKL9Wh9m/MnGYr2tYXRedAHLJGn79JPGZNZ4LAY4/tLulfKC6497QsRZvzALhNZksgeA+BaU/2B6xV+DCymIKfcc+VBYdFSbcx+R1k5X6mgaO52Jf0D/vqqlNFDNaqcrsy0Pc19zrjEYtpaG5IFxkCuKfMfi0H8rTZB0GHHhSOUcYCbGHM6Cg7JAmXBDmJMruEDLQMYkybGfCY2wMqUiY+Vd6yTGatqXh/yNunZ11YoJQHlc0rCSUet1YDrXjNEGCWJgQZVg8mbCYaBuZgQFRv7mSj37NZdrVsfqZUrPENwyt5ijv/7tH7DbPXcr7aeemr7QYytFEMqW2WLB09dt0ijh2ww5wGRZMBnIrXXhYmA64mqhDJpjtzzDLlCyYkcfDHkQ5zwg9lC6JGg7SA3descoWpVm8RFJi0CAZ92btNQTz19hiHwkBv8YwzceAOj9TO7B3d4fTvODVJkM6/xiEISLfgczg9/Hln/kBSUfPpFuP/SltOxCh2KbWT2MKQRLxr3GpMuE6r1faKOk/DBRIeSxPdaf6CtR4naQb+ECPB6yAGECmLJZ/M3kziklMUY5wVxuOmRxzQ8lKbcgsJyV2vY2g7UAp05Q8sHv67TTz3VJIJADiCTkDZqh5aUBAK5oX9wzBAOiEckkWERS/1Iq2THCq435894wXWD+JGMQ19gUWrrkqII044QFtqX13bssZ9RY2+57Va99vLLGvLGa0oPFhnCj1LPPYKixvVH/UsU7AIM9RFiSb9hsUa5HMZVFjgcK68jChKtlFM46EcsQMhYD+/3fA5tTvtD0FCW6Se231KHM7xeJj8h/OXdCYfFDkSJcyKqEXnvhZckgiiH17S1OxoRkeI8+X7mn/D6paUB9XH1xju0JYcddfxl7MbEuBNUWmp7Nag5UK+89KPxXrPooU8mE7Q5UTrEBPo+qjOqd6IIvUPi4QhlHGBQYLCFUNj9XEsDgxPGcAZwQqXhYGBhEGcSZJAgNMPgyIRBKLk85UAIn7/zUTt16ZallNREk0qfNm2soQP3WWQGYwZSsmGZoAgh2oHR7nkLoWKS7tnzKHlBlJaUmEO2FqiVlSpl6M67jlXXbn/VSPS8oD6d3zXB5xf53VLa6qOkdV3NYAZhhiiySmdC4LqXVB6FQZ/JCGU1HKgd2BTIYC5t1d21y3GqXq3iO1+UhIsvOUgnnrTnNlm9DNqEqSNB/0aJZOKGVNjaj5BirjWqJIsfkmCYALjWTMYolhaEZglfQdpoLyYJ2sSGy1GJIIZM1oS9SIiBkKDgoNShcNK/Sks6oO+RQIKyYcGxQShRL/kujpddVCCnKFicE0AJ4hhRW1kgXXL9AI1Iq6HUjMwyt2EsC1QlqLVpnX5+9F4zEUICGTdQXmxViJIAaeL8mbwJx9MG4TX7WIwwqdPWkSHg0oASyXsh5rQzhMWWhYF4szhEEQLXXHut3hk1Wkdcfb1+nr9IStn+ewLBIm2YNkU1Vy/T+ccerWuvvcaoiFzvRIC+xsKEawnp5bphGSAqQ59gLGVRwYIgliLggHA2SmYsGegs+CHMPGhr+jvjG/cvfZ5+xfFFEk3GgmiLNNqbyAD3nU32iqUkEQt3xnZbuB/Ygv3YZCLLhUVDVu4orVh/hUKhzTFu6xlOLEOqVe1KPfbgBj344EMmYsP1SDYYc6n5S7Ic1xurDKq5w44HR/XjAKoLA0ksZBJYP1E0DwohOSY2G7axIfTybIFF6AeCwvfMndkxCWQSeHrr1TwzedtVOZ4wJrzwgZFBjppqKG1vvjFUKf49FQikl5tMAt6T9z/27gJMzvJ6H/9Zi7sRA4IECe5SnBanSAu0tAVarEIpNeoGbaFKCwVaHFocWrxocXcLJARIQowkxHVt/tfnXZ4wGWZ9pr//l+bkmms2uyPv+8g597mPPMtq44c/uC6efPLN/+rydUsbbbRJxnoIEWNHAHyAknFn8Blnfy/stWdMgJf8yl0MC+WvXUZLYPLSS6+Inj02WVEdXUq5/LKHYunSpr5+jBAGFQsm15BwFBhoIJkSZ8BUL7tmbKNQLGAGWGOtGGVgB+BMjayxU0Kk3iO0ypny+V7PIDAM1gi2kHEHRH0fI+XzjQ2nCpuGKWoJTGL6sHkJTGKq5CtibgAjjBvDi0G2VwGEdCwmcX32sfCvUPX8jbaKqi5dOw0miTO/5/YfHHe9PiHLD7WfVSi3BiYJ9pJTCdAbd6w48J3WhLWI8TR2bRX3jpEl8nfdc36PQeAtncb17DtT4/nV149+h34uHp88rSiYJA1V1dFvi22iYa+D4k+vvR29R6zebJ/WjojweWIkhfmtK2tFGJ7u4eRguNsKJo2ZNdPWht0YQS2x7APPcn7T4QMcfk4ZosC+ATqluAC51rB1SFfYHxwt+cuAMUBJb7Ql+pRSiega3+17OKUcsHQggn3CSZJj2lxe9IIlN8XU2UdFY+O8doLJeP/1uZiz4M/x9W8vjKOP/kIWOfB9LYm1Om32/Hjkpbfi3mfGxwPPT4jx78xakerUFhG14IQZa9EHDD+nqK0dEVbJf09WMZSdEMpNLmSxfpHFRFsLCoZxKHYaiRwrHnDqjceDBtra2kZBAj0lxxBjej62+2Oxyx6OXyxVEnVVNNStG5uMfiBuv/3fmRKVL6dYhXJMLUIc8wdwGpsrrrg+fvaTf8fy5U0nqnRGvF9B5FZb18W22zXlab7Z9WuxvLGpSXC5ZMeh58TQnjtl48qoYQuwzBg0AIGxEz70//z2UYV5lK7f/GPThCmbY5V85mm/uDDGbHhY2e7pW9/ZN/bff/OMYcGiYpkViQATQAVJR0CaR45BMlRyH4Gb/FxHAKm5MKP7xkgCQwAjxiE1k8YeAq8YTEBTEj7gl3KUsZOcK2xwfvsk4roZeO+3FhhUKQcMNgYQ4ACgADKgF6DLL0YBdoFZgAEgzXq7nndh/Pi2e0o61iBDzy41MelPv46dtmvKRWtPTiZJp7vIdcT6WyPmjrHF1mEVWxP5vd5rLsyJ+cxvEWSsgFjGe/bq68RFjz3TdFpXO/ZtLgsN52LWnbfEZ7bYOMthbeloyubEPMkNxWaLdLguoNEDEExhT2FfqRL2pL3WFkmnXrU1VanYtaXzrjHbCrs4ZvazcaUbCk8Ayi9a076Ksy2lJbGaHc0PBKzp3nzdaqzsK99BR7MLS5Y9Gu/MOqJktqBPj+PimCOfzJxIQC//qNYsOvX2jLj+/hfjoRffjIVLPlxcVlNVGZusMzwO232z2G2LdaOmjee5W7PSc4w5QA3AWxPt3U+rpDyyiqHsoNg0ba3wbgtDSXidwolYLCIHjdGVy9SaML5C70kx2Xg3XrNaVFVR5qWotNSGvTpuuGrdGDRoyIp8OkqZYQOuCYOH+TAucuuuvurFqKvrPJgkSWk8/NCcOOywwzNm5dF7J0Vje53tdkqvqtHZM+CcvGLspFAkxS3ci0XDIvh/OiUDGMJUpKpjgKa5KtUkFCQAtdmm+2Sh/nLJxRfens0TY8MYAJOuKYHJBDD8XU6h6wLMGFNrEsuFPeO4CD+1lLNm3hhwgFv+sHBoao4OXAGk2B8gDxsl7AzAYpGwwZgZ7C+jzUAz2ACm92GAhUDtxRR+w1QBGBwxYFHecsrFci2Ah/f5PQDtfYCVOfzbI09mALCUYuUvWl4bvTbdMmOzOmL8rL0EyI29e3fPrr8tld6KPOR7m19Fcu63sCF61vuwoiLuXlQfFz72THbd7QGTpKKqKiqqqmPI/ofGLW9PzeYCS8zpak04L5xzzhemG1BMzgdWzhzmF9l4vfxDqSVtBZPE/hTuL2zO3lYBkAFZa8weAvQ5VK495U4Dc0CPMDVHhZONHDAewD9mkTNEj5pDrLp9Zq3LbfbZhf1ei4nxAbA9p3VsrF2L/3PCDjhwj3hj8hebFmKJZMGSi+LKa07N7ocznQozp8ycFyf87ro45tdXx51PvlYUTJK6hsZ44Y2p8YO/3R4HfO/CePjF4sfUFgodJc2Ds6hbCJaU7ZGfvUr+38sqQNlB4e0DcO0BlEkRNgcohU2FilJyNWNNhEhbk1QAw2NOgLKhvlusPvjaqKzsE40NnTGTrrsqhg24JP563u1ZuCYZI2AJY5WOEAMGKDKg4ZWXZ8YLz0+KhoZShm0ro0ePYXH9dQ9njO+6w3Yv2xGTioZmTqmNUSM3yowZjzi/ua8UBYBIiFf+pHmi6Ch4DwCSskvHLGI4MQb5Z20nYYiwyz7rRz/6ceRyfTqUHtBWmTOnPu69976MEU85YEL62BKOD2NonWKrgCBAD5uXwqEdFetGbp1xAxKNh+8HUtMeES7HTgGhKtCF+RhfoNd+A4gYasDceGMXXXPKS057IL99EPAB2GAz5KHZHwCa8ZYLJyRZNWKNrFF5OY4EML8jP77vimvrqNhb2G3OlIgGYJQc0GIClBg7IM2axM4BlcUcPL8f9PH94tm5rTuwbZFeH9s9PnHiSRlIcr2AUuH3WmPmSa4u4Oj+6DKHNpiTdLxnsfZb5tHffX57hBOMEe/sqTgcRusTsFfc5dqtWYA//z6tUQ36gU7MueIszhKiQAqItW5deo8UE/qVc+qekQoiP9hQQLiQXJDmwRGzLzkbOivYu2m8fOa2H3s1arosjKgopYNaGfOX/iBuu+2mzGmzj6+668k4/KeXx0sTpmWvaGil6DI5K3MXLIlvnnNT/OKSu6K2rr5N3053GDfFgsA0vUC/toV8WSXlk1WAsoNCiZCOAMrmPE/eFxYG4yKUzJNlbNsSUk+AMp+h9Hlda0bHUw8dFZMm1WXtftovlVFZ2TdWH3x1PPl4Q8b6MOBJ9KaTXyfBnOES4qIUGbp//vOZrJq71GJM7rlnXMZWrDvw0PeDiqUX8zXvzXUyx4FSFxYGDIUYsQCMibmUB0ipptNXAEnvxVbK98J8Oa2DE5Kq+POF0pdnpUAF6Pna176d9fosp1RVdYk//7mpOAaoxJjI3/V/jg3nACtWrOVRqeZQuDEx8kKx7j0dD2k9ca6AWWvJODMWQAAGyJzIyfRIYBRLij3CIgMw+YCSQ8DwAO2YDeATa2TNMvIYoV6jN4BwynO/lZUxa1ltTF/QeYOHzQJaML7uXV5esZYxWD2gU3Wsh3VpbOkW41no2D751qTov1P7jvxrTSYMHBb3P/V0xqgCShhneZvSFVTtcw7Mh7ly2o51KO3B/KvO58Skc9TzBXCyXjBU7WEn7TWAsq35k20RDL85sJ6sz9RKDNhLx2xal6rR84ExJwhwNC7mh8OEwbdOASX3z9EzHtqtuWbv9zu2gT56++23M2CbACydTwdzdkWLxoxZMw76VGXW4aG00hj1DVOiV9+XM/JgWe9R8cfrH43a+oZWgeSHPun9l9/2+Ng45Zyb2gwqiXEWtTBWUmbSyVblyD1fJa3LKkDZQREyoyTy+0l2NuRNAEoGnrfJkFIWNkxrGyQd1ZUYECFw72dojv3iz+KWaz8ZA/t89f0pb8u0N13r+LEjYu2hD0ePbjtmjI4QBy+cMEyUJsYECMYo8I6BhalT58TLL73ThtZA7Zesbc0b78bqq28Yu+64Xzxx18KyhL2F+L959GWZkmcIUw4h8GPu5ethEIS8kwCSmD55RQwBxs/1AmjGrXC9aA8ifAscAJ2M5113/Sf+G/Lxj+/7oXB16tVoDq3D5DiVWih9BhQwBMw5TdhC4A5jKIzJKAIWxpeRFEYUWmNE7QlgV8hT+gFm3Hj7mRFXEJUAZQqNcoSsX/vQ52M4/I1g2AetP6apCquM8perri1JY2jrDGsMlNnrUgiAkuSsWn9y9Dg4UhWAD+/Jb9Sd3zgdW3T5+EnK0qOUUtfQEFeOn5S1vzHnnCrXqqAI64atlxqjsMgcA0vE36wDBUzFUgSwk5zo9rKT1o/9XEpAmYSD614Ad2Aec5h6zAKIbWWnsY2AkpA/vcrhSr1dRQyse/eeWo7Jo/TZgDlQ7jX2LVb04cd/Fl27lmtNV8XcRZfG5AURAzZpSoHqjNCTT782OX51RftymDnz0lnSWfMAOlCfCpZWyX9PVgHKDooNS2G3Jx+qNYaSMIhyaShUG4zCpfjz26G0laH0fmcwU2p//ONfYnC/H8Xaw56KgX2+kTWtbU4qonf063VU3H3LkfGpA5+PyZPnZ4ZXmJFRTves0AEgoqAxJox0kldf+fB5v6UU9/bJA4/KDOTPjn8waqp7lPzzr/jNO7HNFrtlFYWMRTJCGBEhM2CI4QZ4AEsMJQZMUYm8KkZPAn6ad2Eu84NlYADkVGEUMLrEe4XFTv761+O/Ic2t3NTXj9EXyurIaSwtrVOhQUo/5d0W9vDjRClewlBaa2m9cWjMAybXuAqFyr0EFq0DjKd8NcDSzwyKAiivExo1vkkwW9g6xj9Jrm//sgJKBSt/u+bazOiV6gQQ7Fe6H+DKmDKuwAVwxvEFrpMYp+TUJDBNHn97crxX1xAVJeh3mi/YqvvfeDs+ccih2Xnq2Dd6E/tNr9kP+T1d0xpRMMW5zi/2SMLRSexkseLGliTlN+tSUA5xHxxKzgwW3Bhbg+6n2Bno7QFNxk0aFJAtFxvgpHusYREOYylXloMqP1RHg1vv+FnW+qw80hBLlz8ZZ/z9zpLFiFzr7Y+/Fg++0P4z6rHdbBK2mIOCFReBwGavkv+OrAKUHZT2FuS0laFMxTkMARDJ+yTo/NYYSsCFoiZYC+FLRlMoM+UL1VQPj0F9vxvrjng+1hzyTHz5i3Nj3MsHx6A+v4mnHzkw9t9zQey+/cJ4+L4t4otHN7V8wRyoVBZyxAQRTJLrTKxHvtEijlRMp9+UQ6qrq2L06K0yhq1hWc8YVdNUYV4KaajPxVsvL4/bL5+dsa+YFexPqr4HWvLbZVBYwKLcKEyk8Ko2OQCN/D/zjQVUfQxMAPtz587NwKTxA1gxceYOq7z//nvFf0P69C0OwoWZATc5qsKrQEt+lWpHxRri3HA+hOMofoAgjSUQj8nC6gILQDswyziknoaYGi2OvA/AxzJyZLBZPk8Rkbw0IUKC6S9WuAFseT8wz+hrI1RXpnB3kuxY1Joume4AeBUz2OPuqaMhOqCfCG27f3rDWvV/6RaF7XsA2dSyKL9Q5qpnXtTyI8ohenHO6js4q87F3GHaMIUAkRQQ7LAevMnRpm84NMKYxYSjhr0GFtor9rC570jleVvFfIo00AvmV1suecHYcf0U7f1SCP2OBQVgjYVUHPuAngac5aFuvImUpSij1MfAvtNKmnfMt/jl5Xe3K/SdLwgZesNYKya0R+ieVVJ+WQUoOyA8aEChvYCytaKcJIynPDGKk7LlaQqZtHZNwF/6DmFBnjFWh+dWTGbPaowH7lsWNRUHxsC+X4jPf/Zv8Z97hQ22zVqwCO0CjcIuGFOhKkrR5pQ3yUDavMV66s2avTAaGspnoH32VVfemIEyQGzzNY6OG89/t9OfK3Ret6RnxMQj4g+//2MGroASni8FTbBnSfLPKjb+GGbjAnRSakJ82EighUEFPP2OUQP2rQXG1PcI6TIIP/npd6Ou7gP2qBxSX788/vznMz8EZKwbQATbiv0A/jCIQnDWU0fEfWJNGD4OgIpMbJVxkiMHUMo/A/CMAWNvnDDiciGBR8yLQh7r2zXLIcNScriAJu9jyDHD1oQiB6+VqA/E+J7Ce8X2uD/MjzloanlTPvH9jfV1K/a/3DOAwH1INbBOgF7skusVsjRuqlqBLJXF0hGsRQwYYAo8CJG6D2Ph3r0Xy4wFzq/atwa9Jx3lmBhK1/X42+9ErkzsrPzRdXbaNdMlqfWTe8Y0y111vdhI980p4zwDSIr9mmMn5S03p9daklLnTxYKkK5lmr1vfq0t88chE7kQpraeOTmdYc6y8PD7BTmFwl5gYE/88hejZ+/mz4MvlQzpX9q2bbbp3IVL475n3+jwZ3DgOSR0jYIpuseDflsl5ZOV+0askjaJ/C3SUUDZWjsIIAVjks4YxtQwIJRpc0d8pabmBPjEAFBmWJDmJJ24gIVKAhClnn0MFJaK8ld8w6BRiNgfQJLREhItJo0lrewuLqPXWz9OPuXSbExUYF911ZVx5e//E0d+W6jUWDe2W0m/9erS2HrgaXHkNz9cCKDYw70zdEJQwItKY2weww8oUmAeDL2QuEcS86hQh/HnkABL2DQgIBl7wMpnL1gwOQYNWr8s4SqFUkOHdo/f/e4XsXz5six/M4UcGXQh+dTX0L0CmHJIMZWurz2VyvL3GH9jB7T5OT+8KbwNTAvVApvGBngtTCXxf4ba3+SaGneGGdgHGJ1yI5SOiccAYwABWfmZWEsAE3OHDXZvxl9xSDqFxOfXvTcrqnr0LFtPOy11Lj7rj7Hd0EEZ4MBcYbKJ6za+QJLrNl4eim7Sz37fHAgxtvSLcDYQaW1hLO1nY0ZXYcYwfx4k9aNcXFEVi2ubGt2XS8bPnB31jY1RXUCXuT5Or30lbMuRsZeb01vApvsQ1m+v2JPyEe3bcohx5SgBrcCk/Z7EngJwfLf1K/3CWenysOmOwhZOxcRcmX+Ok8px6QN0n+9yb37vkX5eXjs3TvhGlF26VHeMSWxJKisq4rr/vBD7bv9B0/2OCMedneKcyi9FfnBWOJr07CopraxqbN4BYcwsShs3n6FqTQAN7IAQcerD15wwJHJwAEoeJ0WL4WpOGQoRYsUYWJ6+/CTKraXzXYXCMZGJ3SwUSokSFDYgQIWkcx43FjXl1xVjKH/9q1vi/v+MLUtRDmHzd9xxdJz2y0+vdDYuI/3Fr+0dz8z8USyqmxwVURm5VoGlHpsVcedly+MfZ02IHt17ZaHDfKBNMEuJSZLbii2irIAVRlBhScrNYvSEd7FHnoVmvT+fJRPe9nqMJxADuAHuAFCvXuvE+qNbb1bdUTnxyzvFe3NeyXpeqmBnqFMPPeG6whOaGDCstL8DicXauOQL50fIiQOCgQJUvTeJMLYCLuuVUPb2VVvBnHXn2gFcTJz3Mrb2C2Y//6xw92ctc46KHRIAiJnPd0euE/NWG5kBv3LJiUP7xOcPOnBFyNU4MG4pl5MBBLBS4VuhSGVJgBOQtj85kBgZ42ncEwD1d6DRWqRDAO38QpwkPdZZL0Ye/eUot9x/8rExvG/z68ZeSr1BXbPTXwCu5MC4N4Abc9vWc6vzxf4C2pvTWZ0RexvjnaIZ7sPaKwR56WeMpVQa80P3ysHmDKTXFHtfW1IjrHkEgPnu27dHXHNLeQ99IOfccEA88eoGZXF8Hz7369G1pjS8V7JnclA5o+xpykFuryyoWxKvzJ8Y4xa8E1OXzI7axvroWlUTq/cYEuv3HhEb91srelZ3ri3V/0VZBSg7IPKx5MflV0y2RVShyedo6wkNQs5AqHxFniilk5LKCwVjCNzyWoUmARygD6vYnGCmePqpF2FzIjFeLiERYsF8+Fy5goxWsfdeffXjcclFD5YNUGqDceTndoxjvrhLFjKVMwZ0p7NxG3N1MX3xQ/Hm/Ktj1tKmEz+UoQCYOvwmkFlR3zs2GPy5GNXn0Hh3yuLs/hhseXwKbgq9WPNQV9U1/nTJ32Po6mtmyej1SxfHH37+w3j20YeyNjbAkZAWA59CLgwMNirlUxKsJFDp2pKhZxAYjdra+thpx+9HTY08x1IyZrks3P3k07+Po4/+fMYQWgMcEoZaWIiRK3ZWLpCt2APbxfg318zc+vZ51qHxAPwSOw/QYWj07MR+KlbgBGAo2wsSjBNmUi4eMAlYAiNCovkn/hCOAEBrLsxr6ldnftPYj9zuY9Fj/0+16xracbVRsWxZjD+jKe+PQ6laF3jnZALsABSHghgPeaYafBcT+gfTCpC6b2kp9nHhejVG9gTQSj8ArP5PlwD55t+xipdN6ny6SGty99e+GGsOaMrxLsbupRNjMG7SS+Qjp56oHGn6iiMvLSTfOWmrpLSBlG+eL9ZAc0CuENQV+xvdTvcChyJQqTVTS2Lv20OcBLqAbrE+sbYAoUcCh4U/czpErTzScaJAqohHipJ43P6f7jFktfI5SOSHf/tCTJrRfJFnZ+TyHx0ZG63V9k4q7XVG2VjOaOGxuc3JuAVT4sZ3Ho7/vPtC1OcaoqqiKQXHv4pMT1dEYzRGl8rq2Hvo1nHo6jvFWr1Ke/3/f5ZVIe8OCMPakTycthblJJFzhL2SK0PJ+N7mhJKkxChbLCLWrLnTWJKoOsTCtQQmhQWBSdeejumj9LAGKY+ymKy/3rCygUmiWfq4cU/HAw80ZpXsgI4QUrqeyoqaGNFrz+hZv1WM2HBQnH/Zz+Nje46O+sYlUVlRFd2qhsUe2x8Znz/8a3HIz5oKekaNGpzl6glhA/HasiS2a9KsuXHd4y/Fmkf/IKq694zzHx8f4ZFkqwNik632jd/86z9xx/0Px+P/uTsLrwJNgAIARhh2hhLAAbywFJLpAXOsFebEPHfvXhFvvn1XbLCePpullIr4+jf2if3f6pkpUqALSyo0jMHhPDR3gogUCuPDq6eIFRrkrzGMDOMPIAIs7jm1gcGYAZdAAdAs/AwkMKiKNHx3a5KOtWMoGYX89ALfDSBZp8ACh8qz/Eq96bA/xhqLX2xPMuYnf/qQuGZ5RSxsaCx52LuisiJ22mrD2P1f18ez70yOOUuWxgVLl8RfLvprdJ07L7YePiK+c+qpmSOCUQUsRShEGYDvfPAusoCNBzbtT2OruAjITPmRK763oiIznlhicyutIrHC9r5ium4T34nL/n5DlFu6tRDW5ZwCQ5wZ94rdlh6BobRnMN0Am98x/hjMtgDA/J+lU1gT1nvh35o7/zp/nSRAVwjy7CHXJrWAXWgNDKYHQJnEfLtnucN0K+BczKmTQmPt0xE+wx6yB9KRohwK6Q6iIvKKe3R7KCL3Yombmn8g9Q2VMWVmx46NbItMmTWv5IASqQOIA+XWFv3AsZV20ZzNXNZQGxe9+e+44Z2HMxDZ8H57rfRMcllpUpPNw1jeMf2puG3ak/GFUXvGF9b6eNRUfvTh1iqGsp3CcNnI+WdXt1WAPUU2qRl4WwyoxU6xUEiULuPLsBcK4EKpCF0CMCj91DC3OWGsABmhwGJCwadcNNds81G8rolR8h3CO4VGjGDYDv/0ObFwYetHrnVMGuKRx86I2tolmQHSZ09Lo8I2IgAQJsjYKyjKl1TIIYSbL8KP8vXIXy+6JKb3Hhk3PvlKltfT2lF0YIjXzHnx0Thw/aFx7VVXZkZAiNg4qmIubNQMqGPNhMzl+jBQ1hjmYtONj4o+fUaVpH4ul2uIhob34rIrTs6YKawIEAbopaPTjBGDlW/sCgXT6h4AeQwhYwsIYCUxZhhIrKHfYw6FlgAlLAr2VnFC6kaQn3ohrxHIse6lfOSDRj97JGbR+DCaHgyEZ2uTIbZHfLfPNPYcLGOMwSOMhtd6jVy9VBVL+u24a/TbY9+SAcrGqlw0dM1lrruPtIYaCtaQ6moFMQ0LF8XSJ5+K7au7xui11srWA6fPXBhPeXfYZKAcoJd7Si8AV5gxezIdP1koxpZT+tmjD4unxt8fPft1iS8d96U4YK+Do6ZhWHzi7NYPT+iMVDTUx3WH7p2NeyGYo4NU7itIklZTCBQ5y/KTsZjmpbWwL9CYD9yMEYfBHHPYRCFaA32FABBQK7YmpAPpn2oPpTPoOyrui+4xx3Qvx03kxf3bAxz7tE8JFh6TnfaBhzHMz8ect+iKeHfuD1YAnVJKQ2NFvDZx9Tjj74dHueTnX9onDtixtOkJ+cIZs6/YTWuDXS+0zTOXzYtvPf+3LLTdBBrbJxX0au8R8bvNT4h+XYrXQHxUZBWgbKdgriRbtyUPslCwIww2AIdRa4vI9+C58q69R1iXIckXhpYyATRdH8WH3eDNN9d6g2Di5CQJlxUKDw6oAjqEa1XYAl68cKEjzIH3KuyRTI+ZKiwYuujCB+Laa54oOVMp3L3//pvFtdefnt07Nkz4Atg3BoCOcCAmFdCU6yj8WmgQ5NtRJpRKIYASGvvBGX+INQ86Nmp692l3cYxWKXWL5sfU2y6LkX17ZGF56wXIKXZaTuFcEteUy1XH9tudHDXVvTsV+paP1Ldf13j+hQti3ryZGRBMhQ+MPDCOwSPCjv7OmDUHrIBADks6Mg8gELI01gncyWu1Vjg6isyAvcI2NvJ3MbXAPRYNaGA8tYUh2EyKPoHGBCBTNX2hCPu5DmCkULyesXZNvtf9uk+sELGO1l1vvXi492rRZdCQTuVSZkkV3XLRmJZVG6cOuKxcsjSmXnJ5LJ3wZgb8gWv7MIVpAUrsd/79YyvNBTBfKAvr3osrHzkrJtQ/Fv2HF28VtXhJTbz1zvAY/9aIWLy0+XPZOwqUlk58K6Zc2tSIu1AAfPMujM3RKAR29oF1Zc45ZQAoIKXVlvcUAkAOZuHaUEgpVYNeS/1POyuYY+ta/08FlB0R980uJMcJaPSMbTZuXfsOiYEj141RG24RA4YMiwH9+0efHl3iHxeeExef89s49ICmdlrNSWPjopgwbdPI5crj2P/xmoPi2XFNUYhyyK9P2C/22rb0+ZmFwgnF5NMFonscBSTNe8sXxFefOTtmL1+wEhvZXqmMyli9x6D4y9YnRe8sjemjKasAZTtFNSUlwnMWVmuP8LIZCOG9/NYzLQnDylgAhgyhcEi+l+o6AFwKKLGThJEXDslv5lworgWjUchiApiME3AmpJZfzZ2OuqLssB7CppSpcC0mKp99mz17YXzhc+fH8uVNzEKppKZLVfQf8Hr8619XZQYCEAAgXCegg5XERgEeGCohIHlZhdeQ2m5gLgobHb8wcVocffbVoVhd25OOSK6xIRrr62PUrLFx7YXnZvMBMAL9xcR1AMLyDOUBYvMA0auuujHeGNcrunUb2KHzvXO5xliyZFaMff3KWGut4RmYArDT3HM+jBEm3JrwO/MLAAOB8nOLzR/wkk5G8sywYv3MQcp103vT2rU+EuOYzzymYxMJMCHvN591xDi3VPjGIHPu5PWad59JvMe9YEwJZ8drCvulEq+xHzFBGNWeI9eI4V86qQlQdmDd5ipyUd8j13TYVAeWPRYza9zfs09Mu/verE1XfhNy4yTHUM6rdW7tG+d0Ykhi/xYumR8Lh78Wjevo5pDLwu4tiUwctzvurZHx3CvrRH1DaUJ0vnXThqXxz1/+NNMfALF7AP44pCIcdFtzldvWo5CkeeKQAHLWm7nibGNvm+t+kYRulMICkLZXbxcT7LEIDxCSn2rTnCR9mQBjemAiUw6vPWLNj9lo46hZbb0YP7ciZsxrAoJaWlVW6SnZlLOXfPQt1xsZR+y5eey+xehmj7mdOfcXMXfRhe3uetGyVMV783vHKX/+UjTmytd9cMJtf451Rw7O1oixSc/p0INSilQ0ERtrSkTjl7/6ZYzbLmLsgsmdApP5oHLHwWPi9E2OLlsnif/XsgpQtlO00gEIKYL2CiDIoxYyxP60VYQShe1sIqCDEeGFUyxYIkCKAREuUVRBAE8hGAxdMUnFIQBhqhz3eUAC9hG7qdpYYYCwWwqj8OAAOCA2nd7Dw/YZ7gurydgBwcJA5577r1h/9CFRSll3vYa44IKfZJXT7r9QGF+Mrr97EKkGmEsPOYI2NDDCsAHdlEiSGfMWxsG/vSKW1ta1GuJuTbKinWVLouGh6+Nzhx2aGUZOQn7I13XIqzT2WBiGh7HMz+dZtGhJ/PL0q+Lpp2Zmc1fZhhNNMLlyTfc/gJHqFuPGjc0MmoccrJQ3xhhbU9YOQMfAWTfYQYBc7h1jD+ymXFp5koy6XpUpZAmQGkd5elhCDgl2EoB0HGI2HhUVGUtfGK6Wqwo4cbpaE+PHQQAgrX0hX+E/TLqxtGat13R/KUya+jlis5pzFM+77Nq45JqbY2aXHlGz+fpNeLIdyh8zWd8r15Sh0BmbYd1phH73f+LN2+/IQJB7Ahbb0gR90Fo94wt/2Sb6ry6XtH0X4uOXLO0a9z++WcyZ/+Gxaq9oFfTwN0+I+/99R7ZfseEMN3CEmeag0qfFirzcr0gI5ycdNUgAQ3tGJMHcW38+t7DYJokDGQDSxEZ3Rqw7eg6glLta+J3WfD5ozM/1JdZffpgaSLIPAMqX3pwWP73o3zFl1vxs2bU21eZWBGjTdYbHL760d6y+2gfHwCZpbFwcb8/YJeob3i0ZqLQGf/rHnePNBduU/HSlJNVVFXHY+rkY++qrmc6iR1LbLCke+SAzjSGb1VnhWDrS9I6Zz8Tok9tG/LRHfrLR52LPoR9OW/soyCpA2U4RJpbnlRLb2yOpCKal/o3FJB0lB8zyhlXDMn48fUZSWNwz0JmKheTsAYa892JC6aH05UBS6vL1fKbQEsYRMABugIjU0JvY0JgFQAKTlkLFFIziEqwaZY8hFX783ve+Hz26bRMPPTSu0z0VMW31DTPi4UfOjV/+8vRWz/GV94mRcv1AjnsFRhioBC6BIvfASKT7+PIF/4wnJ7yTHRtXCslyL999O964/m8ZWMvPo9Rol7Fj6ABbykxKhOKnYrLfvofH3Lm9o2ePdSKXA5RUkjZVFzbBmVxWdOT3++yzeRzyqa1j9OgPJ7UDpYCX0Kk5BVawgXoypj6FgBiwSXlzhlIaBbCOFVQYYnw5JcXO/OY85YNGD/m3xYBDylu1ZjCL+WJOGBNzhGXkVLl+gBV7KkdWmx33Yc26fsabocf0AhJYU44GIG+/SD1ILMGy2rq45p5n4g9X3BZdeze1qGlsaIjGHlWxbFBELmMa2wbK6rs1Rs6WKAEBkQHH+vroddNtseOYjTIg4gHAy7VNhRjEfgSsAZzJc1+P+h1fjKquEVXVHWOPsJUNjVVx98NbxHtz+3Zq7R+2xcZx2v5NZz3Tm4CfCIg54Fg35xgSQJETwGktbONFmnTM97L55dBYi8Xy01O7IX/vjNApdLcHJ8R+KQSOhQUyCfikh31UjKH6x93Pxp+vf7CpS0U7dU9VZUW23s84cf/YbYuVc8XJkmWPxzuzDn8fUOY6vS4vvWBJXP7PjWLkjuVpbeZ+dt5s7fj91w5a8Tt7nr5MLG96Ngepot7+z2cyPdM57e05qQjnoAd+GstydSVlEyuA4S594tqP/SiqywTE/1/KKkDZDrGgGSRAJp/RaqsAYJg7RpEhbM8Glv/DQGNxgFqKVk6lMA5mSV6Q1iPyBgl2SR5IOrqxWM4IBYxlxBhRtnLZ5L0Jn6WebYBO/mkMwE7qmwjcFvbFlN/pdwCqBHE5altttU386vSb4+GHx0VHxZ7Wju6Gf/40hg4dkoX4WwtzAcbGAIjErGGsGATGWIUyxQ94y73EeDFE/3n1rfjW5bdFOWS9RRPjnxecnQEs4yovVcgMm2ycOAMMLMDu+gpFU2bMn5SExx57Kh568KX41rd+Fk8/PTYmTpwc06ZOiQULZ8TixdNj7ryJsffee2SMaH6D5UIBXCld84ntcWIJAEZZA46qvxmq1qpgAVJADlCQ2ybvsRgT2JzIYzUOwpmAKvAnnSGFsjGcWDpr0t7BRqr29Z3YVQCSM2NukwDL2FWOlvsA3IFRRgkbZN3Xd+kXdSO2iYqurjX3oZSCXEXEsv4R9b3e/0ULxqWhsjEaO0/orSSuZrOhw+L6wz6bgbN8kY6SmLck3fvUxMm37BI9+nXpMJjMB5X1DVVx8z3bx9Jl7e+p53oH9Oged371mOjd7QODzmnVs9F801fmp5jRxo5zLjCB0mlaktQfV3EYXSY6ko7aTI48hzc17G+P0A90K0cQK2pdW4siCdl9VlZm3QwKgWNhgUxLcvm/n45zbnw4OiNNZHpF/ParBxYFlQuX3BrT3pMS9UE1cnuFLRr70hqx83a3xlFHfylmDNoxqrqUp9/ied/+dGy74Rqtvo6Tbn4SyExAM6WG0f0iVIWMprXVHKN9+7Qn43evXR/lkl9uekzsNLgpV/6jJKsAZQeKaoCPdLZwewSzgLkrVunbmugdBxwyhIwvYOtaFMowupSo6uB0Wo5NJESk9VAxcQ2YSUaJcgd2MXjJu/c7ABNwy1f2GD35SAw6wGFMADvXBEhivRgAoELIHXBtOvXnV3HPPePj0osfypSZUGxbJIXrDjhwo/jlr46L4cOHZgYUIwVctwRazJFxuOOOOz70Nx6t+wOiEngztut89uRYVNWj5DWRPO7tRq8Rr1z+hwzUCM1gciWAA+YpVMPDxuBwGAoF0PdeuYkUInYwtTUiGDrgS0W1cU/CsGE/9U8tNNzeD9RiHoUhfSaHwbxTygBnfjNs4+0z8k8AIsLzgLB14J5UIbvGfDaGQ5Zy/oq1dkmV4RhM6wpYtLYw6da770gnhaT35Z9HXUx8N+Pve30Oh46zg9nqvdaWMXL7Q97HiK3kF1ZF1PWKqOsZkYMRCsax0UkzfSLqayo7nHPbklxx8KdjpzWaei/KOzVXAJI5SowyOezMzWOTfYdHZVWJqtQbK2L6zP5x32NOBatoN7i55HOHxg5rfRgUWCOcKLpC+5ZigDKlgVgLbekTmFh34Uq6VhsYubwav1uP8oYLi8LaUiBjv6VWb6IZqRdrPuvOge+oPPHqxDjprA87kB0Ro1hdXRXX/eKoouHvxcseiOnvfT0aGudlnTLaLti0XLz+8jZxyAE3xd/+dkHmPH7hu7+L1+dVdSi3u9lvqqyIdUYMiit/+vlOsYP0q8hGPqPpkQr+6IUUPUkg08/0xNefPTdenT+pQ1Xd0YZjND42eKM4fdNj4qMmqwBlOyS1N6HQi50z25oIZ8r3SWHm9ggDzhjyhIUXefc2R0pS18IotUKh/DxjC236lgCqzwEEgK7EbmKH3B8DL2yeL5hQ71Gp7PXCUZg1BgKYADaxJgm0+R75d0CC9+z0sb3jkosfjMcem7DCJheGdxpzjVFdJWybi223WycOP3zL+OyRB2afJ/wvxKFCWThJ+oBwXzHj4Pe+m4FpTgASLCU2a2lFl3gkytOgl7jd3apnxTm/PSPzjAEkjDCjSoAkgA2DA/zlC0PHyxa+x0gDns0xLoldFt4TYkxH7JkDYWVMDmVLyTLaxjWFiYlro1wZTXNqjIEwzgogz0ALIVkjmMPU7xEbo8jCa1fcc0VF9nvfnw98WhLjYk58n/1S2AIm/2fXbs0x+oRTYy4ZBuw0Bt/1+b/CK3uFXHXX0/HH6zvGCGEtG2siUi3C/NeejKmvPxIjv/etKIdUVVTERj16RdUdd2UMu6KqNLacBSF/edaf+8aBceR5m5XlGh54YpOYPK3pdJ/WJDGpfzhk39hvoyadki/WHj2GIeLQytflQOWDB6/xd85VfspNW4TTYe1zrAA9a9k65US0t0AmAQyf5xkTWkzfdFQWLV0en/7xZTFnwZJO52vnj//Gaw+Li753RNH82YaGuTFjzs9i4dIbszSkysrmv9eWRbJ2rdk4hg74fXSt2STbY1rYcej3/Pgn4qBT/xYz5y8tmSMFUP7jJ5+P0asPjlJLaklWCDI5zqnwbdDgwbHR3z8v+TfKJf1resW/dvl5fNTko99ps4QCyDGcHQGT7TnLu5gwsIAar74musT26+4c9/zt4Zg5eXa8+MKLsWnX7eKOC+6N0VutHWts3JRr1FJjc6FrwJPSxlamo+AIRQFcJGCYxIaTO8dQex+wqoIXKBOGZ+zkKiUBahl37KnWQkAn7z4Ds9/YK/5z39h4/fXp8drYqSv6VVZV5+Ltt1+IU075UhxwwNYxYGDTub7C074bmJVPmk7H2f+wj8c5l/0uevXpHlUVNdG/y7AY0GVYlugPoLmuloTBUWQkPPKZ7/wsHrm+9QbbHRVq+++33p39jBkFjrGOWh7J68MKEkC5UIw5gCUcLOeM8dVmJ/vcXO5Dx7wRP2PC5UZiNoX+AMzC/F/saMrPM8dApPFLZ9bnO0SpQTtwiPHxXuuZgXZNmCSfIZ9Plbg16POw51ijtPYxPdafzwF0OSXYAuNC0QPPrUlqbQV82FucvRQaxYz6vrTnrDuRBfLKW9PjrBs6Hl6sUMCdd/T1wLW2i6WDa1b0kyy16Fv54sL5MenWW6JXt+4Z824dcCzymbG9vrpJNDbkSsZOJkHObbju5DYByizM3bN7/P7gfYsykwR4xBhLT+AU0Q0cFOkZSbD2gGFzRYUtCeYJM2mM9M613n2+vEeOebECGY4Slj6/QIZY43QIECkaVEowSa6657mSgknisxT3XHXHw/H5Az7IJ+Xs2b8enMIePZfEl04YEvse2CeGrOa0tJULdqqrRsSE17vHr097Je6566bo1qXHirmhS+w3Ov+oXdeJ3938YpaeWQpQ+fVP7VwWMEnoKDbcI78wll7icFgbT0x4IZ6sbupZWy6ZW7co5tYujP5dSpwj8/9YVgHKdgJKrE1Hpb0n5RTKoKqhse6STWNwxYhY/lRFXPVcU75YQ0NjDMoNj7NPuihDLf2H9o1RsUE0LCv+PYw2thU4A8wKiySAVmCgsBE4QId9EhbFEgIpgAzWkrJtrr0LZhUIorCFV+W1MRSYwyO6bb/SayW6H3fcVXHMF5ty94TOAS4KEKsBPE1d+npMHnJfnPrgblEXy+LO+X+MmP/BZ9RUdI3GBb1jzG7DY+utP3zaRKEI8/O4Nz3i3awitb6D89Oa5BrqY4+DD4snF8zIPGLsoDHWFsX9JfCryTmwlMAhMM0oAllSDeRSdu/eO7bfbr+oqOgTlZW9siMlGxrrYvGSmbFw4dSoqGg6si5fkQJ3qal3PouIQcR0mReMoGtj7ClZTChACCQCp+accTbfKUeNYM0YGmySawZ+hZvci88XiueoYHhSLrKHz2XosKrptByGynclhggTnu8ceX9qo0XS0YUqz5PIN06V5cSaBTbfnjgpfnrxf4o2GO/4xOai95hNoqGMrUAY6psfeywO3Lr4Gd96TQ7cqLIjXY5aFRhhtUHzo3evRbFwUa/i11eBSa3MCnC+vcdOK+VMFjLtignloctrxJZjBekC68ozB0E0Q9SluaMnmztBprkCGetdFwpAgiOMwW+pQCataaDDe61b6UqllPr6hrj+/hdKCibz++D+8q/Xxg0X/TG7R8APE5dOCqJ/6RI52U2tiGqjtn5iNDYuiYqK6qipHhlVlf0it2RCPPbI6Cyqxvkl9PwVl/899t5rv9j7E/vFoiXzY9s9Doy6NT4WdfWpSLCd15uTv1wRM168L6559/7YZtTvV0TM/huSjiXNmPO5m8aTz51f9u+cV7t4FaD8XweUhaHI/wZDOX/2gjjjmD/Fs3eMjUEVw98/MzSiof4D4JOdUf2+Xpo7Y36sExvFDd+6O9bqOzp2PXzHbLP6XmwAow8oAI2FYDKxUMWqISklFb9yD3n+DIJcSw2iMVCtKVzMCiWPoQCi5E4JV+Z7isALNtYGx8oBmELAQOusZZPj1mlnxfSlb0RlVEVjMzlAdbnlkRu4PI78yxZxyTvfiANHnBKr9xjTIqAE7sZPmV42MJlJZVU8++prmXePpfXIN7TpWEAnb+SHdo1JalZfEb1jtSG7x2pDGAKh5Ma8NjKUsnymiqirWxK9+yyIk75+cOy88zbZ5+QLb1zhjDUhp4jB9AAoGWGtlbwGc4utAXgVZwFpmFEPoDI5HZwTDJM0CcBNdXU6E931YdLkZsrrZcisvySYqHQGMUDh+6UCYIcIMMm4pER6xUxej+W0lqU1yNPNrwIGKFMYnKTc4POvuzsmv9vETpVMVOX2Km/Fph2/oGvzpxdNWfJaWcBkEktsYNVbMb9uw6jMA/c9u9TExsNWi11HrxWHbrZR9O/RclN0a9t6oj+SADdApXkEKjlSHNVi7OTchQvjnqefi8dfHx8Tp0+Pd2fMiOlvvxXTXn4xamfPzIqYOF7AIueVWJeKD+0732vNWHOKEpsDk5yiFBnh0Hbk7PDW5MnXJsfchR/0Fy21A9Jr6Drx72uvjtpFc7O9I+9WqhUd/qHXV3SJrjUfjgrY3xzdSy6+JEYN3TweuffVeO3Fd2L6lDnRL7dbbD1yt8yRXa/P6rH6qNXj0TkzY/p7C9rVaitVqE985MaYO+HpuP2Z5XH7bbdluakKK0W4ytW3MZerj6h/M6L+9YjGhREVVdG7oT4GVS+N2fXY//JtqlwZ8jP/X8sqhrKNAjBRSJ1hKBOgbA9DOeH5t+N7e50e899bkAFJzVHbIjZg7dK6+NVn/xRP3/VCnHjWF+Koo4/KWCJGnVIFUApFCCr1tywUoIIRp6gZcKCT9857tfFbq8QkAKxEe+F0TdiBTD3mfBb2QKhUWEmhjEp6oSsg/un3bol7Z1y8YhM2ByZX3P/79n1e7Yy44u1TY4eBn4rdV9NQ9sPjx2M3N6+OfS2iT3lCLdk1yW3adLP4+OBjM6DsHoFwYM+YGwv5PcYFi4IF1gRdOLxv3wEx8e2aGDliq1htyAd9KN1PMV1bU9Mjli3tHmf/6ZlYvqxPfPKgLVfKpxJuZ8QV72CpAWrAMjE6fi+1wzxbMxhDLCkgybEADhMzTfEDf/JwMZHWiZCmcHgq3jHGCoOKnS4lRMm4ewj7y3P0edZCflI9wJsfrsd8WncAN0bUtaScNwAg/0hNQNnfHh0/KyoqunW6hVWh5NrZ67G94tPHTpgQY6tqVqQnWDepinj6sglRkauMXJnObM415KL7e8/E5N9eHY1dusWen/hEnHvO2bH2sKFtNvZYd2teBKSwuTg23XrkkNARIhPWDkb8pZdfjicnvhNv1/SM3Mg1M7CUOVHVPaJi9XWiyxqjY9Sue0fXqso4ZNMx8YXttox1Bze1f7KuOaj0tvUl7M2Rw24r4AFisaT5qQOJjbf/XLP1XQ6RegFMlao9WTH5zTkXxYzXn8r0PTBtj8uBbGsREVu1y9afikf//XacdspVWXP1xoaV11hVZU1MGDs93h73bnYvFUNqI9YYEo1WLeaxmTA4fWQed9p07fjOZ3eP8a9skZELHgA/4kKOOD3C5rAFpWhKn62duhcit+TKiGXSYJqiNUknrFURcd36Ee/VdY3b5q4Zt89dM2bXl/b0KNLnI3hiTvmyTj9ikvLJ/psh7zdfnBjf2u2nsWDOwhWsZLvk/Q1y9+UPxIFrHxH33nNvli8JsAgzFqucxBra0Pk5lalPIOXOcwcg9cJUgQv8AX5CxtqxtFUoaXmc2rkkUALoUnhAq2R8lZkU/4Mz/xF3z7ggA5G5djbmTa9//L0b45apf8wYvXzBhiQ2dt7sWWU58zaJMOuY9UavOBGEIQaEMJPmhSGjMAFzPRYBbVXY1dW9Yputvharj9wpe09bmpo3SUV2pvo5Z98dP/z+tbF06QdhboBWGBjjh3k37vnKGijDZJhXzhQm0ykn2B5hSCAUm8RIYzqtJSFKrxXOFJYHCFXkYy8ZB7mqgKj5bq45t1xHnwFI+n7siPXK2Uin4FgX1mNiM30+RtT1AejWLtY8McHAM3CyzS6fiOVRejD53xDj/5dzzllx7KR9h7k1Z+73qpsuiYasJ2l5pLK6Igas0TNqly+P+oXz4/7bbomdt94qY+/aev2iIxyKVIRGrAOsN2ckFWLZB+aNTvjs8SfEP95dEG+vs3FUrD5qBTixD7KG2nkO4vKGxrj+xVdj/79eET+7/d5YtLw2W3ecmaR76RaFWtalFlmArO+RkuNapINYX4qFOEf2Yblk7MR3yxLuTlJVWRlVvQZnxUnuVyoJXY3BFQForUhu1ox58b3jLoln7p0VXaqbWrQVgskk7JP8XfnFA2ZUx8Dn5sXSl1+IHg3zom7pyhGBysjF5usOjy/tt23ccuZx8YeTDophA/tkDipng0NqzugBXUrMiYiW9aEALT/y0B6xrl575b6Y8fq+kZtzRDQsvmUFmMzuoWJlYnVgzfL4/ODxcfV698YXh7we1SV01npX94iBXfrER01WVXm3UeRnMaYMU3O9q1oTbB4jXKyKt1CWLFwax445Jd6bPidKcOpTxuzt/40945tnfSVjdBgkx4dRnkkAQgUcNnUqyLEJhakS+1js2EhslHw6QBRAbK8AM8AB8MIb9Xl6JwKcry99MO6Y3jrz2VbZcdCnY/fVjsmUlCp4gNV4YK/mDV43em28QzSUKexNV23WsyEqJr6UGTCORUp/AJ4AMMUpgJdxxNjUVPeKLbc4MXK5mja3WmqODdho45Hxm98eEe+8MynLFTKvGmEbf8ZFmJvidl3WO+AHvAh1K7pJp4xgN4AZzgVD7cEwU/7AXaFgHQHDVJnNOQMsAGsGIn8/YSasTd+vC4ExEaaTi+l79eBMle3YSQ+AHJDMb/linXqPz04O3Kgt94wBm+9blvDZvA3yzu0uk5yywcaxVc9e2binR8qzrdvylahefWFZw94Tn50Tlx/3zIpuEmnt2vsYdWkF5q4Ygyrc6jWYMsCtuRNkzD8dYE0e+cOfxks9B2S5ru1l8Thvg3v1iLHn/iFO/sLnVsonLlyb9gEHxZoEWrCSWPmOtIZrjxz5i7/H+Hc4seUR7Od+24+Jn31p75XuV6SAw6X4T/qR/VW4J955e1ac+qWLY/68Jc2CyNYlFx//5BbRY9jM+Nap34/Nttgyli9bGltvvmlcdFFTt4ViYo0A/XJtPWICOygAAQAASURBVFtnALC9nvKiWwqHWztSYuRV5z9vtsHMuPyc1aJLl4qoqW7fRrH8Ji/vFT+YvH28W9ej022Dthm4fvxm8+PioyarAGUbBcByLByPt6NiY1CwNofcw5bkz1+5IG6/8N7IlTAcUl1TFX978Q+xoL4pp8a9qJhOIjwEUKiOxT5irtw3Qy3UqShHjmUxQI1dBAAwU8BZR4RnKiQFAGTswW++F1fNODXqc3kltZ2Wilhz4n5x+rf+lHm6Ks8VeGT5sd/9aaxxYHl7g03614UxoLHp+LCkKI0XYADk6e2pYEBBwK677hbduuwUfftKTeg8UgAqDzhwi3hnyj2Z0k7NyrGUGkE7OShfOQt7axuFPTLnrjefWbSWGV0K27pw7flN8PPFusBAWHeYKqwwwOf/nAnsSQIfXgdgy6GzHgB+BkRRRcq9lJ+po4D5K9ZWhuGUd6myG9sKuFz98ISYXtsjKqtKn+mzcI1c1PVtOi6xXHL354+JdQd8GLCTm6f8Pl6Z92BTCXoZxLy/8cis+PtXm1pQAY6c69bywQHPwsb4/g+4cT44AnJfrUGOBkcAK3/pg4/Gu+ts1KYeoc2JLIS6pcviJ9ttEkd/8oAWX8t5kuZj33HqRGrKkTeZL5/9+d/jjSnlBZT7br9h/PxLHz6VTSsx+854YwOxmCnP+L1ZC+OkI86N+XM7AyY/kIOO3D622mNItsf1O8b6tnYEJpDPqUR6eF8SKUDSIugOdoKd4oDTC+wU4IjZJHQZgiRjug/pHZ/Z79n3f9+x+6jPVcSC+i5x0ts7xQwNaTshP/mIHr+4KuT9X6rwbk9RzjvjpsZtf7unpGCSMAQXff8fWSiQ5Bcx+BtmUhsWOUw2M4+dkbeJMZUUTnPsrJwnBp732xHBkMkVzPIMN944y286/aYvRn1jyye0tFcoyKcbr80UjfOsscUMx0477RSLJo+PEndcWUmqK3KxyybrZXmSPG1pBxQjhka+Fkn5WllhUuWo6NOnNGAy9fu85ebn4pJLbsoMvCprrDDwhfXL8m5razPjKq9MyF3TfGtASBsriWFX7Qn8EqFpitw9MMRYg9TPLV9UkAOm1pLvZMiES32uz3PfGGOsrFA8IMjQAZPypwDS/EIenQqaK9wgKT/YWNu3Uig23WLrsjQdJzVZl5HyLZ5eXbrEWv2Kt6wBrh++49lobCxfyFs0ve69mhVgEgtkzjmZgEk6YKBQP9AlmEpri6OADZOfKAIhr9X8SkkAIhUDWpdf+9lp8e7aqYiu42NKfVZ2qYk/vzIhbrnzrgzE6GCg0AzznR/y5cwCkzpRWM+cEQx6YQP/jkrqfWndc741XX97wuttOpe9o2LMe/conitp/N2zhz1vbhTLsXN//vm/SgYmyc1XPRGVtf1W5GVLJxAZain1C8ClFxAanG5dSeTec0TNSTryVzSLvvIaBAGdBYRyTrDdQv23/vP0+Oz+z38opN0R/d2nujZ+t+bj0bWibT11i0mf6h6xy5BN4qMoqxjKNggDSSlSeoBTZ4TClX/Y0uece8olcdM5dzR1UC6DkjngzF3ilO+d3BRSfb9iMx3FKNQqDCrczBPEWiYjgr10vF1zIhwplM/IFCu+aEmwm/Km5MoJw3/x65+NmxeXr/HrkWv+MtbqtbKDgC0bvNshMbumX8n7CWILPvuxzeN7B++WGWIhQGMJoJkH943lA3LlyV100WXxjysmR1VV871EOyJySBcvmRUbjpkf559/XmbwMdKpoAbL6PrkSQpHO+ZQigMmAIgwRxhBuYscCKy9+QIwgTxMq9D0IYcckjE+GMz8AgAGzOdyXDgNGCxrT+gtFSlZo4pyjI3fMXT5AoRgtDTzFhZrThgvBQgp3Pn9v94W9z4DuJd+XzVW5WLemPJgSv0t11m4OLZbXp+NpTljUM2bfcpAj9q2XxxzQfv2XHvlph+PjWdueju7hlRFn0ABsG8upc1YCyqkdQlg7NMZ6thkcw+8FJ6tbI50dXjp1bFx4q33xvSFi0uWX6iFzoIXn413/7Vy/1XiXlw3YGLNW1fyUjl7HC3jzMGRsiEUn9I28sP6+f/n5HAOCx8+C8AhdC6Hp/f6u0TV0DFNuaBlkhEN78Qnd9o4u37zUizdg34H2OQ+L5rVJTZd/eCSXkNFZUX0G9AzLr3tW/HrM3+Z7Vl6QooUEkPerD1dGKYG/lPnC4LRFqb34IB6BvylKHBkUw6/v7FbwuG53LLIzd4/ogGJUhqAzFG58b214/x3OxaJ++b6h8ZBIz+IDH6UZBWgbINoOSGUR3FrgNsZwfbwUBUwFBMKer+en42G5eXJ41Olt/qug+P2V2/Mwg9JgEeFGhQO8IC5S7mSmCRGgOFvKUkd86pNDEOeX2HbmuhfyGMHtBkWzdB3OG54PPneTe0uwmmLqJVfr/f28ek1mopjCKMHoDzy/Csx4IAvlVzJ11RVxs3fOzpWH9hvhRJnlAErBkuIh0I0/1n/tdzqMXzY7mVrl/HVk7aNV199NGMgrW/fwwkAIBl989jcdzOanAcsNkPJSQIuFWvJo7RPGEz3w8hipYBLoXxAQtsfjKjG09jK9D06DGASU49MBToAJTCSL9gNDAbA0tJRehwkDKhQPiP1+Dt1sajr0OjapTHWHDozhg+eE11r6rLzqt+d0y8mTh8Si5d1vJpz0cjGqEUilnrOcrmouvLaWDxl6orjJgsLKmq6V8UPHvx4dOlRnsYdDXWN8Zvd740l85oiBoAW8CXcmNpAAbocIswegKaXJEeFwTffWGcsHRAGTGAqvZdO9Fmc7PUOOTz+eP+jZSmc+uXOW8WILtUr5aC6PmBKhMKaz89NxVgCNBhgoNM6betpT8R9AaeiDYml9bkcAWu836hNY509j45ySuPYW+PFJx/K9IriLcAyPdxvfu9g1/T5vX4d89+rK4ve+cbPDornx92TRbHMNeKCJGeV+F56MYFGeoV9MG5JrzQnohicdF0oUq/bqy/aNT7xsdeiosTFltbnsW/uFhOXt72wpqqiMjbpu1acteWXy6bX/1/LKkDZBtHGhKG0qAv7NrZXKGIeWuqRVijXXHxdXHx8+Q6l5y12G1kV0wdPyIAE4R3yzoEqih+wy+9VJsdQOBqD1lzz8iSS24EkTJSq29YEK+bEDyFWDAXGQFij6z7j4t1lTUellUMqG2pi6Q0bxyuvNDVDZjgS2zJ424/HkI+Vtnjju5/cNY7adcuVfofNFTIWBqbgpSAI8bj/RQs3jl49296SpT2SyzXE9OnPxbQZ92UMIgCJURKCbI8YL9XpitWEmABLjhLWkkOR1owQFLYBw4O5TOcqy5PlyMjf9ABEAG2/F/7k8DDEWEaGIp1jz8gITfp8r8eWAoyFj5TaQUaNGhkHH7Np7LLHrNhgjSlZs+6me1i5unPKzIFx99NbxKMvjYllte2rsmmoaoz56zc6YiRKJS5rxKw5MemKf2ShWvsP+MKgpdQUwAzIfHzRVTGh4ZHIlTiPUr/bl++YFjf88MWO3cP756knNpDjia1LqRGcjCzsuttuMWvnfaJOjmsZIgT7brhe/OHQD9hu7BjW1Nqy5wr3mrA4dtFaFFEw5sCPiEIClvQ53YlZx7QBMZwooft03KN1WHjmfAZQq2pi48/8LKpqylPNNbRf9zjzmKbDEuwHekanDsDMPbhOOfQJYPbpNjy+f1wTyCu1KApdsvy9eGT831bMuXVs79rTdCFSgTNd2BqIHnCdxl6KUGunFbHT0jD+/vfLYuxDg2PokNI7WfIptRQ6e/qmbQaTA7v0ifO2+XoM6to3PqqyClC2QRg0Xjbj31lhBAAnLFyhMBh7brRPjFq8UZRVujRGr30bM6ZI/pLQgFwzniP2p1CxYioZdmCxNWHg5b4BG3KWWgJEQAhmwOc7mYWSozT+fuXl8c5mN7baa7KzcvmRL8eaQ5qaIDMGPGY5N9jJUYd9JXoM+6BNSUdFtel2o1eP848/JGvjkS+MFPDEO9dAmGETdtphh49Fj24HlNWLHTioW1x51UktHs/ZHlEwo9DMOjKHWAbGGJjEENo7fvbAanJYtC+RHpFOtUlrTAGYELgHR46Dw4BjORkfTohEfe9hKBn+ZKSNYwqLYct87/Mv/T3mL/l+1DVMiobGiqhq4exi4SyjvnR5l7j0jo/HYy87BrPt8zB52oPRa58PjrvrjOScsT5vfvS5+fbYa/fdM8ZGSgpQgN2lR/Idv7m10+O8cSdGVJaY1c9F/OXTD8dn9zs2A/EEiOIEYii1kBJ6N5eAk70kkgG4yHfD0GkVhMUEIr0mHc+Zeq2S7uusFyOPKh65KcltNDZE11uuie5VlRmg5eRw4ux/gBarCoxYY67N/5Ok6nUFH64fwEEKyM8FgNwPB93cGIvU2gZLae3aE5w3zrZCs+S8nfH3e+Kmh18peS9KenjyYzfG7NcfX+n3gJz7sO/Tka0YWSB/9NDdYq1BOxTt1Vsq2fmwvvHjn56azbmuEsZdf0wspDUiYlF4CAOxToy5uaJr2tJHs3HZfRHzvlKmO4lY1lgZB72+b9Tlqlqt6l6tW/+MmRza/cNN5T9Ksqqx+X+pICdJqpYtFGCKkexR0yurxlVAUS7J1TadZ4pZkntCWTLqxcCk66Ik5aS0RbwfEAAShUAxUsUEQ4UZAypUVAIDFDnpOahL2cEkufiac2No9fpZLp9xSIUFDE/3sQ/H+ltsGRNmze9wLpeh3HKtEfGnYz75ITBJhLopdQBJeA1g4LiMHftObLNVeUMic+csz9i5UgljaU6F7oU6Ab10vjZGHvuQjksUmtK2JLWYAgwzR+Lvf8+cESDQuDDomppjMnyeNIy0xjgj9iRmNQFIYDIl65Ozz/5zjNnsiZi90JFxTePfEpgkqT95ty618bVD74htNhwf5/9z/6itbx14N9YujVl33haNPSqjzy47dTqm1r26Oi458gux5Y9+ljG4xlDID/ubznFPAgDtt9+hUbXBzNjn2xuUzBmx9Je/PCi6LO2XzSeABMyaG3MNJHJE5d5yIqXHCCNri5VCxd4n/xwb6DmfgdKsGrDLjs6858G4a8rMspyHTjiKfdZaJ6Y/93SWjuFehOA9iOu0flJ423ViGj2Mb3JciA4ZrXX88HmAD0BNxyIMRLusc8RCxth27xO5akcMuufS3DcndlC/HvG3K8+L2mVLVmovVazlFNCPBayev3ZZC8vIojlNSgcoBCbpXFEKRXtaBNnXUhDs53zBXErPYVesI+urtWhZ1D37PsTpeAFNS9KtsjHW6bYgXl9anDGtchxuNMZ+w7eNr4w+MHpWt62Z/P9lWcVQtiLAn1Ad8JV/XFhHhXJhVHn3hSyoKtczv3ZW3HnOgyWrsCsm8hLHj3w6AwCqZBVZ2NRaxBSKEIPq7uRRtlXky/l84KFw4zNGcjKxWViMdF4vIMEDveeJW+PJXn+NcsvlJz4VbzzafNuOiuqaGLrLgTFw852yxP62spVeC03Oe/HRqHzzuaxyPPVrZGTSzx7C7ZQqltL4MnQ9e4yK9UZ/0CqjXHLNdV+LwYPbngPkvOipS8fF9KUTYlH9e9GYa4yuVT1iSNe1Ylj3dWNot7UzdgMoFtZObBSGBpMFTMjbIsClPQU4ApP5bFC+cHSsJQYGm45Vx8oB4MCq0Fb6zHzxuU88+5kYsNrDnRghIfGKGP/O8PjNPz7dIqhU7DT9+Xtj+vN3Zf8fcOB+0ffjezTF1NvJcgMEQ3r0jCsO+XTMHv9Glm8GUNM/GGwh1Pw+jvZQAkXIpS9dvEOsuWX/qOxkywKh7n4VI+K2UydGz+69MgAkz1X+qmsBBM2h3+lFSX+ozDXnHEXzIkeSwwQEA2aYMSydfGUgQlN8TJ/G9Mde9c949M1JZTtawL6cfe8dMe/R+7MCD4y3AjhgxYMeKgbEAWXOLrCMfXRiE5IhVWh7j5/tZ/fjoQAG05bPyDb73GNExBqlK6hyLe89cU1ULZuzAri29gxIP3Xr8oiG0hYB5gt9MeHdB+LtWSuzpvmSxhKDK42gsAAKQ2w9cTyttfy/FxZJ9W38elTUP13G+4n489SN4tb566z4XXVFZdTnnBFUETsM2jCOWGPX2Kz/B3//qMsqhrIVkVvH2JWSoSxsl5DOtGZwR3VdL+5ouD/KKfW5+kyZAYsMES81NTIvFAnOAHUxo92SYCkVMslTYjySuHeFFxgJijmBSZIYgP69B5TzwJoV0lCby1gI+UMYFooMWAHusGdCsxq6z5jyRoze/3OxMLpk/ntmSD5keHJNf4uKGFjdGK/+67J4782xWToBY8UxSY3M08P/sQTpzGo5ggqfNhqzW/lvPiL22Xuf6NO3a5b3ZY6LPffp2yfqB8yKqd2ejRmNr2fvc456Ook2OyHjfTa5T83g2HrAAbH9zntnBpfBFgZVpOXZHjK+GJH84ob0fVgSlfYcDblVwnPGSCgde8sRw2Jgy6UnACE+E9Mt/5KRAbYUf8yad34ccnjTuHZGKitzsd7q0+L4T94V5/7zgGZZTUVXM199aIVRnHPrHTFoybKo33PXaOzRo4n3aYV5E+KuqKqKIzbaJE7abIv4wbe+nbGyCouESbE62F5Rg7Re6BPjlY1/nz4ZO/j6hLHx5IuXxhpbDOhwKqJTT2a/vSRO3uuM+MXT62fjruWNdZvC7IATphmrBEzKg7PvgTSAX/Ehdll6D+BkzrCZAKhHcjTNvVSTqfMWlHXbixL0Gjwkxuy4YzaWHJnmBPgVwgYgPURpUt6h67U26VDAByCjRxW16XSgJU97hD752SV3xr+feK0kxUibDW6MNQ8/oCiApetFBABk+5Bt83v3u8eYb0dNibtKrCS5XOy5xyfihrtey450ZQcKmVM51xhcRIQoGkdFeoJrtbe9hjPAueRItdSC7+2nR8UaI8sJkCuj95TJscmIPbMz3LpW1cSonqvFer1HxpYD1s3C3P9rsoqhbEUoTIaRgWtv0UIxSQ2bhYsIhoEiUgxD4Tpu8StbNv2tHEJ5zYmZ8XL141mek/tilFTTMgSFOXUKa3ixTo5or8idw2zKf0ltQlJIVK4cIJAvvkOBzrRpU+OKuSeVuKH5h+XXO98TS+au/B1CeEJTDCG20Bgx4sDxm7Pmx+3PvR53PflczFhcF5XVTWPVraY6NhwxJDZdc1gcuPWGsf7wwVlembAkj1lifnNrJ50g4vtUJcv7u/66e+I7374myi2j15sSCxbOzUKTDEz+M0Xfe0jXOOQXm8Z6Ow/J2Kqq6paZtgxo5yJqF+Xi4bOnxdO3TmiWecSIfPe7382anNsTDAPGQZqEdcBwWyucjvxTVPwNuALaGEHGB9A0Z6kF01prV8XNdw/OTsQopZx17SfjmdfXK/7Htx6IZ++/NcsfNOcKkwCmxqqq6LXVFtFnt52jy9Ch2UuNYkqBqBOJcORxfX30mDwlJt1yW4yo6ZLl4CUGzL1j7j0Abs/uX889FcPEXpK64bXOOz/qi5+PM279ciwfPinratDWbgkcBK7CC7dOiTvOeC0O2v9T2ecpvgIq7QlzpHK/WLNsc4qhtt7lvmIj81k/86OTgxC+3wPLdJDw5+jv/Cwq+pSvYAFgr5k0IR4968wPdQ6w/gDjBCCxkdYu0CnPEiBLLDBdkLohcGjcB4AqyiPKAlhzevL7/LYm9Q2Ncdpld8Udj7/WsXvDilVUxlcO3jG+tP92mZNReFKMZ4VFSVwfR82cIBf23ux7EY1l5JgqIt6Y8WAsr3k7sw3Ad/F7yWUEiygencgGF1Z3c2BEOehPNqNYWH/vrX4VPbotKtvt1DdUxBXXN8Rxp0wo23f8X5NVgLIVwXxgq/I3YmeEoqV4gMrsfOFttskMIQYHW1ZfVx+f7POFqFtenrwP1uzthtfiMz86OGPgMAUpzOA6hKFsYg8/y/PTUNY1t1eExBhAgEyfSflDPFOKRD5Yc30sKe9rp/0kpiztmHJti1TWdotJfxuUGT2CdRBedc8YY+MBXKcTPpLx4zH7G4NzyWWXZwp5/dHrrlQckYQjYnxV4TZX0ARs+kwggTHCUn/2s1+Igz/ZfH/FUsiQIX3i6mu/1uzf317wYlw/5fQM1Le3dRN2S7j10Sveijt/V5x1ScUKgCUQL6TNyDNsmAhhUP8HFoV8NS42H9YGVtu4A78cstRmKMkV160WW28rvaB0fJegwsKl3ePks06M+oaVjW7NnHHxxL8u+FAEIrWisVbkgvYeMSIaBg+MgeuvFyNGjYqli5fErLffjvdeey1qp0yLivr6Fe8VMnbuMoeOMU2gzNoT9hZ29rPvw6IrXkqvSUfXWUt7f277uGfGRTFz+dsZs9xsbnJjRURlLgZ2GRkz7+8ev/nmBVkFeepGAUwJ42Kz3A9Wv5iIdGCI7SPAkkPG8ANg+cASOwUAA2yKi7BRpz0zNhZ1KWOeWWNDfHaLjePnn9wnGzsgKwFI1ypCgm20tqw1ToEQK+ZXm6PUDQEzXEysZ63XsLDADXDNKWqJCc0X13TTwy/HH655IOrqG9pcqGNUq6I+Xrvr0ugTTaCKU5j2mXlLfRvz+zdyfIB7+eOuc+k7o2L8Kx90RiiH9Bs1J6677a9ZGpUxb0kUdUprseetFakv+WNFL2DwsfL5f0vSOGuviIaJUS4RZPnnnYPiM8c9Vrbv+L8mqwBlKyIHiNKWEFwKEf4DpgBVm0V7HZ59OnmEnHnU2fHANY9mrFA55PHc3TFz8fRsMwJ62BBhV9eBUfTgzSbjRgFRAECmcA4mM7/4oSURrtR2g6LFVjB8KvqK5SoxhIwoBfLYrOvjgZlXvB9YLa1gbKqmDIvv79MEAhKgBnY5D4A1kCNsKwwrHCf1IT2Mj9/li6R7wDD/ITTDwGI6Cs9NT+J7jSWj5WeeO7Zj5PAjonuZKgIVfe2y6wbxk58Wb2A8bvYz8c8ZpzeBj06SfOtUfix+/4UbszEzzqkoTXI9oKSwwVgyfAx1Ch8WgsSWhPEH9q3TIUNr4we/GBvlkr/cuH88/sqGK3JqZ770n3jn6duz+3IdHCj7iMgz9Hug1+8wcfmi/RGnA3gE3NJBAwy9dVfY/Nu4AJgcQeKeMbaFvWG1VGKA6RlgjUxbOj5emndfTFnyWsxaNmkFsLQXpo2bF+v02yw+td2JMbzrBtkpUgCUnG7AEUtsX3D2CMdHuLtQOMXSDrwP6y5dBrjiJIjCAJYMv7AmRl6LKaFxesj7uu++T0zp0rPdOaftkf36dot3n3g4A5HYXeONZcQsuy4spbUHcCUW0glQbdV3BFEg9K8ing7ws7Fr7pSxQpnx3oK4/M6n49ZHX41ltfVZy6OVwGUul+kK669u2eKY/dpjsXjis9Gja3XGTNJjWHz7wVwW6+RgD0pF4HRgi4Hf8864LW6//qmy2R1y3g1fi4/tumUG1OnX1o7pNSd0KDvJueRMpXEE4DHlHBxrrTDHv3HuKRHL7yxZQ/Nics2/t48jv9hUXLhKVgHKVgUboqqRF1eqz/vKV76Sea1YP0UGgFa+jH1ifHxjxx+VBUj0Htkj7l94a6bIMSgp76pQgCAhB6yhcLxQLI8eyKRc85lMD4qhmNLl5QPLAAO2kwFMZzYXCoWBMQRuF9fPi7PHHV22au+/fOrhmDVhcdauSA86SolQxgCzucGAFWMXUqN3OTxAUj7YTA8sW/6xapQgEMUQJ8ApJGpcFZYkUanMkPXutXk88fiMslX7DxoyNY499pMZgMvv3fj2tPFx+N9GR9de1VkT/FLIv376UvSYNSobayFuebWEEZMHif3HYmsZwpgDWXLWGPxU7Z0vwrqMJUYfSDPewJjUjFN/1DcOO7IimllinRIth8ZPHhGnX3p41C9bFFMf/2e8N/HlDIwkFhWYSCeiEKx3CldzrMw5AIm5tpeS85LazACT2C2hPMCQGAP5iPZjyj3leHiN/VsoxoZTZq0V29uNuYaobVyafe7cWfNjxPDVMwZd6FDBAxCVDnHArsslxHilXorAroKJYu3CzAPwnPIj/V5BDmAJcAKoQJaxUK3rs+XLeV2/bT8WQ/Y/tKznoU8693exyeojsjmw1oB9zjPQZU+n06Hsw86K9AB7mzMJ9NMzdGAxSf1UVzop5vXxMXFObSyJ7tFj0Mio6dYrqquront1xGq9a2KDNQbHHttsGBtvNCazK0Ciz5f+AawVi5oQ9w3gWoOiRuybvfaHX14SLz1YPEWlFNK1e1Vc88AP4nvfOzXT8xxIa4Jj1JK4L1EyDgmgzCZZQ4RukFokL1ReJUclSW7xRZFb+PuyAsrbHv9GfPKQ5iM9/2uyiqFsQWwyilMbAwq8FCJvhffP42dceYfFlMuPDzwjnr37xZJ7i6sf3D+effPJLA+K98q4N1eQk042SeyszcuDz2cy80EmdiYBTEwmIwqUAZSMJMOPlWlOGEzFManf5+1Tz4kX591T0tNyjOfEZ+fElV95PjN0gJ9ctNSwXohSjidWQhFCOi0oX1LLGiEZ+VTFhPFlULBvmCIKD/AwngxysWRyhozBbWI3R8SvTn+wDGf95qK+fkk8+thvoqGxCZwAxb4TANnixJ5Rs8ZCmqE039aYi4rGqvj6mIuzoh33gxXBjBsDTBajJtwI1GCv8ytok1hTcixFDLBH+Qy3tASMk1yrAz59e4zZuHwMV119ZezzqfVjxquPRUPtB82qARKOkmvhPDDa2HhAIhU42WecM5XRCr8ARsCN+DtABmjRERwZKSPGBchheBPDa4zyQ9z54nMZW+8B1Ky7lkQonnMIwPt+oBLAT4wyFhmz7rrsdQI0FjqPGFH3Zx6ccJTEPNoDnDCtXjwn9hmQoGOseXP6s9/8NiZvtUt5zlvP5aJHY32s9fKT8Z/77ssAsmiRPefhOlLbsFKLsaXbzDVGzdoH+BN4TAAyv5+q/VjsmEFrqSXBYtNNyAI6vnCN0OEKBYWb6X5rliPE8aiuqondx5wSuYbSHwUp0vTWu4/E/NxrmV2gO61TkR0MdjHHqFBEbqwxe4NNTqfWYTv1qHSvxpqezb6z/q3Izd6n5PeSfXYuYtybtdHQ95bYZJO2NTf/X5BVgLIFAW7016MQbfBSCCWKxUDPAzTNsXWzp82JL234jVi2aHlJQAV28pNf2yfumXRLptABJmdzA83FWDivsdmxhi21S0ogMwFMD4YQyGRkGZ5U1QwQYKGaCx8JjxvrVIixrGFRnDfuhFjcMD+7/s6Kcaxf3hhnH/RgdKnvkykkYJkiYnwZSmAfY8QQU/zuv1D8DTC2Porl7uQLtoDC9jlpHq0BbAgjwZDI2STWmBBPyn8ave4BMXLE9iVvNNy7zzux+RZDMtBrrIWdsRnHf+8z0Xv/lgFIR0Tu3ib99ogDRnxjxe+wCfaWfC+GnMORhfHeTz9Ixt3fE5tpvbbUey6Xq49x76wTFRVNea/lks9/enk889ScFX0GgUSSTj3inAAM+ffVnHi/fZLuM90/sUeBECDV7wEgYVTAD7BghAvDqPIX5fkJdRszuqYloAQAcpowpJwd61pBhHA0Q41FwrAJpcrLdB2cxHwAgJEFejiRWC97CUjwsL681/sA15QC4Ht8J8YJ82Qvuu/9fvPneHNZfVbtXkrx2YvufyhGLJq6goWkg9sahm6vGBOpCfnnUgNRqbCHYNgLQaPnwn6q7RUFVIBrYa46Z8N9mx9rRJiYvuGscW40Fr/j2hfiyr/eX3JHVkHfj/78ybj2hr9nDqT9oZUYh8YzQNuWe6ZPpYpxOkU1kmMlF92+wFBa06nXaeN7X4io0zqotMSM4Tn5R7PjrL/O6NRcfdRkVdugFkQ4kjLOp9E7I8JVQs1AJCXdHJgkg4YPiB9d/c346UG/yfZCZza40OX626wTx57xubh0l/My1oR3KtTeXMI4FpJSBHxaEu/nHXok8T5jR5kBm8J+NrxcKeApP1yemEzGjIeeX3057pU34+ofPhefPGPdbAN3NhJG8dz6y1di7tSlUVVVm4FJ38uopVweSlaeGiOe8nYKJbEEqRF7vngfsERBCh8ynkAQ1gnzQ9Hl995MbI7/MwIKISh+bO5jjz0Z11/7TnTp2jcqSwAqq6oqYostR8WZv/n+SswFEI81fKfm4Vi/fmCr1dztFWkLr8y/PzaO/eOBex7JxgXbkEBUeraGRAIYO4ZVnrEwIecGQBIyVzwgXFd4BCoH5oILfxu771deMEl691mcRS7cQwJ38n+BBukS8gUxQMYVWwJUYl9dN4OeWEihfe+1joQ7E2OeJL9xtv0PmDH6Scwh/ZTf5omDaE2nY1XlnIkc5L8m/2eAgrhOBtr65PgRe5jQF4BiOiIRow+00F+cEo6X66YnU1soRhZI5CRiIM2t93qNOQQisUzYWiw/ZtRe++1Rn4nDLr66tJnTekTWRqxftV2sscGA2Hrr7WLLLTcriZMKdBerpuZ0Jp3NEQAWAVlRIesEm248rQkpUKU6sYoYS+AfEcApoWfpIc6y62WHMMVSDgBJ6yPJYV/cOe699fmYOW1eSdNtjj7p47HjzltnD/pWpIGdQEhY99YAfdxaZTxn37VLSZJ3bI8InxtXOpe9sq+kklmfFb2+Erm5T0ZppTIWLq6OJ19cbRWYLJBVDGULQnkDATztUghFyjCi7VMeWWvy2M1Px+mH/yHb3B1pds7obLj96Pj1HT+Mnn17ZoYQkLQJGTabu5hIJFdJCty0BHybE9WD8l5SuoC8SCBBOAYTl5hMzGUqZvAa4FPVKk/+uK98N9be8jOxxtbLY4vDmsJtHcFVWdi1siKeuGh6PH/9u5nxA/IofEAkHYfJ2/V7zAkFhylkIISa8sV7jAm21dGJjDhmCFDCWnofZgcwojixmL5DSNl6MuYABmUq7OMBxCaGiwgPYolyjb1iyy1OjMpKp3d0HOg1OnauW8SPfrxXbLHFmA8db1bXuCx+/9oRZctZNQe3nP5KPH395BUsHEMrR4+xE9IFqoEYY5cKNzT815sT6wAAcch0SrCHjK+5AL6FgecveCMeeHK1KLf88Nt18ddzx2bXAYRJXcHEWTPGFaBk9KQ8pBQPoX1MNaAFOHlPMRChRY97y3cgATh7EYNe2N7Jc/7PQK49ZSyNa2JLm5NUbS8tRb6zsQf+jDVgxPmRliP32Ry5P+AXcPaz9Qooui/OUToX2lgUHo+HMbVnjEvK73Ot1jpgCYDTFese9rm4afzEkoLKgS/URvfslJam7qkbbLBa/Ognh8Tw4a33CrTG0jGfheDReiSYTqCmkG30KHb2dDrqVrGisedIApylOuHIWjGP0mvMlfQdIt+QA8CxaQ7Ejn1xcnzn6AubTgjr5CTo9rDuhsPjrCtOiKr3z7g3bnShPcKBsS60WXPvbBOAjTVvjT22V+hfeoKzSU/Tw3QKoMzG+czG+T+K3NIbs465pZLvnzkgJk5bI3MMVskHsgpQtiCUAkPPWHVW9HmkLDEBkqAVI7RV3n55Upz5hXPirZealKxecW05lcBmGrJtn7j8ob9FTZeaTPFT8gCOkAFg1RxYFI70NyCpvSI/VDNzRlDVdhL37Kg1fSkpXx6q8EvKyWRYUuJ/7wGjYqOdT1gBpAauPTc2/dRr0bVnbbtAZWNDRN2yhnjukrmxbEKvzBsWUmK8ABpgEMuDJQMEGDwMKm+ZYgIaOBT5oJKBEfKjsLGqrt9YY2QASA+sQKFCpNRTiFxiOcPM0+ZVa5vi/hliY5LGgfTrt2ZssdmxTafCdgBU6lG3bPm8eO75C2P58qZwOuCQX5E+ctO+8e7690W5pKGuMV68bVrMurtPxsQybMbf+HFaMHycD0YOoMJsC4fJBcNuC3W1JmuuOSDuenjlyuhySPfKv8QaIw5tuq+GhowFwsoBw9YEMOhnxs06AB7NN1bQWilW8AEAqLpVIV1MOILy8DgZzeXRWZeAGgONmfQ9xhogTK1kCgGp3EdgmJ6Tc8eQW8vJmUrrML8RfTHBLHGMChvjp5/tBa3ShCuxZ/mvAUZ9vggGkDVj1qxY+8RTonLw0M7nU+Zy0eudhug3of5DDlZFRWNsuVVFfOaz+2bhb3PAmSwEjvRVGgcAvbAFj2egsLAqvy1indMB9JKxl7/d3kMkCsX16mmsaIuOMZ/sjvXY1tPOHvj3S/Gb71/XhCdzHQeTw0YOiD9cfkL0G/BBJMzaA7KBMeuBcLI4FRwhxAKdZK1juFvq/4yUYFc56u7X51lH3ufzEBsP3/V4rD345FhttYVRVV0CN6X7UTFknabjZH3+KvlAVgHKZgR7BGjI98AudEbk0gjtCjkwkkISqZ1HW+WJx5+Iw3b8XGw7bOdYMGNxUzPk7IinDxRuRVVF5BrEhiNm5CZHzzHV8fRrT2ThL4ok5f4xOvrANddYVtiWotc8NjVgb6vwOhknoRxjl+9xA5CMHMXJwBaKAgDKY+y4ibHFnt/OGofnA6jqrvWx3ifeitW3nB4VegxWFA+DZ+TO+3pj+quDYuytw+PVey/LznGmaIE6ykDlrHEBDoUoPZt3Cp5BptxSSgAPGAAXVsHsCh0xIDxqABLr2FJ/OiwaA5XOsm66zqb2H4RRBfh9pt9hx3ngxPxdddU/4567pkW/fmutlGfXlmbHffouiksu/X4cccSnspC+OeUs5Felj9qjW+z/g41KEgZsTua9UxtXHzc2A5AtsWbEPQpvAdh+ZnwwktIQAHfhLgy4veXvgJNcxk22/Wl07dbyZ3dWBvd6MAb0/6DNFybQOgKYGDYsdSr2SqfLmFeGD/teDFRgjLyHwwe8pNA4kAiMWYf2D0aHoQXKgLhltXVZa5nqqsqY9NaELHUjnfVtTIAkQKI5AWLtWWONzZKKk/IfRVFSH1bXb5ztX0bU6zjJ1qEij9QXtBho9ZzSGooJJ8I9+i7363uqunePYZ8/ProNX71joPL9HJmeU+qj3/j6oi64/dHYWB/PPv+3WLp05kqFcvRQPmhMP9NRpc67NIYcdyFq6zl1FSmspG9JODTmBAsu5Yb+VvFtDVkDcm9POeWUdl3X4/e/Fr/74Q2xbFldh6Jjm2w1Kn78x89G3/49P3S/gHk6nz79zlrEKiIi7InE/tnXWEuOWzEG19rSZcH92xc+FzD/yY9/Fkd98ucx7c0lMXDg0jjzd/fH0GGLo6qqE6Cy+2Exa+lJMXTY8MwmWPur5ANZBSibEQnUkoUxCliGjgoj4HNsasDAz8CH3LD2CLaM94w5+9KnToh3Xp4W22ywQwzsPiirXO7Zt0cMGz0k/nTJH2LLT2wSjz/7WKbM05mywlUeGJ90f81VKFNImJaWXlNMXJ/7E9amyIolK59//vlZGJPCyM/dYXQwHBTLRjudGH0Hr/1+y94PS033uhixxYwYPPq96DtiYdR0+8AQNNRWxvzpveK9t/rHlGeHxbIF3TLD0S03I6654AcrvF1Ki2FkRAB9ikHOHuXkd4w1423ehKdS6xrXzNhTduYRKM2fa+xAfhseD+OSDHM68YXhTKAQyPA6n+V7GRcMLxZZ6oHrw57+8Ic/ip13+nRcf91T8eabTjiqyK41H3RXVTU11vbRPXstj+XLx0WPnsuynCIgzrVb00LI6Yg4gPf2t/4ar9TeHVFRvhYbjUsro+G2LTN2glNT+GAErRsg3dgwJNgGxge456SkPEu/c+9+lipgPbnv8y/pH7vs3jXLFy2HzJ3bGPOWfD/W3WCIevmoruwVfbusG2f/9rr41em/ydhI4cvkLMjnMoeAWKFz6vo5bf7utcbF+qMbGFfrgsE1NvaUOVt/gzGxsLp/dF9t3Ri85gZRV/HBHutSFTF78vj45vFHxqf32DLO+u2vM8ctvxAkX3w/kI6tF4bmUAEmjLaQpHGVBoI1tP6s4UMOOSTbw9YMhtm+pSdaOm7Q/hGWTKFWgFfum1QG7085xubYGHB27KPxb70Vgz6+f/TfYZcVfT/bJFJcchF936iPntMaWozn0A253JJYvPS+mD59auYQAIzWWUpZwRiWKhTdkhhfucyYNXpHyyHrqTBfOIn1zhEGIoEbjghdIdxrDJEGQJixpa/YH+Hv9sh7sxbG2afdFE8+OC7TLQ0tAEuV3Mapa9eaOO5b+8T+h2/TLPi2HjhcCu3y1yM9bH1wfKU/IQCATGvUtVuPcj8LWXr7x35BBliLl1/2j/jOMRfEsoUfRHV69V4eXz3pudht93eygwravJwaK6Oysjoqen83osdR2T5Emlij2k+tkg9kFaBsRixiSp2CL8wFaqtY5ICBzU7ppqPTMHRyr9oqAABWhpemqIXSZSiKnVaBKQEcbE5MkIbkQllCisCUTWwzY6WaU5I2OSMnHNnW/EnfBUxSIABpsbwhgoXj6RuHdHqMkCbFbYMOXn2LWG+bpqKAtkkuuvR0DGJj5BoqYvniLhG54vd1wZmfizGjh2WKWEhFqJnSBUooL+FuBh7DlM8Cpj5nDCOG0jz6HUXP8CTgmJ+IL4SdmI38B9YBsMAyJcEa+2yfa3wAWSwm4CmvLeU7WUNAuu8YP35GPPrIq/HHP1wUG228bfTs0StqulTF8OF9Yu7cSXHBBWfEr8/4SRZGBijcpzkSAsOaAciuRcEIx+PjX18vdvrSOlFdU76WO92rese3NmhiXZsTzC+2LLWWAWyAYfMC4EiV8P988TtjYqwOOaxb/Op3fcsCANQozGvsHtMbVDhXvn92ezKwlfH6U3Vxz9Xz4sHbALimljvWRGr4La0jhRztP06idYP9A6ow3Ax/aodCrEvh/p//4rSYU71aPDxudlTWdFvBwBWKcciOdayIWHdgl7jh7B/GrGmTMwOcnNrEQGqxkjoK2LfYHboJCMG60i+Aeuox6zPoIOxZOpKWw2qd5hea5YvwJRANJNgT7sV3Mfr2kEdinuTRcZgV/KQ8Z05bbf9B8VpNr+ix1jrvhx+KnItucpomJLrPbIy+b9VF9QdZIy0KUDlt+uOxcNHz2d6jH+wL+wVw5pDTWYqTAGv3UXjuPQa5VGuO3jXGUq3sUc4vvZ3AGfDP0fJIfX6FeDlcwKOUIywnhlpKA1uAGLA2zH+qgG6PvDV+Rtx+7VPx4J0vxaKFy4qCyUXLZsV3f3ZMfOKgLaNnr5Ztpv1gTIHhfLGW5OLm95U0H0AcsM2W2S8Kx4DLQrLHXhP2HtF9t+jffc2ip3Tt8LEpcdTRr8SaoxZEfX1Fxlh+aDllhbAVUVGRiycfHx591/xFbLx1U4GqyJ5ULjq0pa4T/4uyClA2IxQnLzqFJzsKSi36/F6PvF0grz15mZQq5Q/c+hxMVnN5VFg24Q2AyaYTYtVHDngDkIFFxpkX3NL3UY7YorYI488zZoSAntZaLBkPXiaFQdml0Bwlvsdhp0dtY/eSt62QM9WweFJsvPryzEHQGoV3zzhIjAe4U54UIEBZMCiEAmMA3V8ywEny+8Xlh8YKzwrOl2SM0zF92Cf5k4CeOcJiAhWMLwDCIcFWALCuyYPRYVgYfEAEs5Sfd5kv5hIwSUwggyLM6fVAtWvov82y2PiI3lneU7mkf5dh8dXRF7b4GuF4hoMhtG5TGJLBTn363AM2G/Pr3jyE9xiSgw/eJ+Yu3yMqK9uIJtopE+oGxPJc8WKGhvpcVFVXxJuvLIkrfjk/Xn/hvWxNM5rYOfvXWrL3MSnASsoZw/zJAStcN4DnxtvsFGvv/oXo0X9ou9LZZC/ULV8Wa1S+G3Pfej4DffYZgMQRAhh9J2eG44t5TGI/mAvXrPDEPrFvnFEt3cAal2tsroAsazCtKfsqHWkoB5H4uzQOgJX+o784Oth4D4CTI8y5svfMKQAOIAlfMuAHHXVsTMytHfV9qqK2d2V27LTVWlmbiy4LctFlfmP0eLchqjpQ6A9QbL9jbSxe/EGY3noDbDlh5rFY79gkgEWxKvrmngt/51HovFvf7psDRf/Qy2wS4G0O6RBsZOrBSOh+rKZiFXOTAA9njE5hPzi0HRV6edaM+XHUZ0+MZUvr4xe/+HkMHNI77nng5vjWt0/J1hCb15pgIoHHYukYxts9GQ92L79Bu71CX3P+scnGxfcB3CvSk/7+QFz4u3tbu5PYcMx7sfMu78T6G8yJtdeeF13fj3TNn9clxo0bGK+NHRj33Tsq3nuvZ/Qf2CsuvPkbGVAWXrc2MeyrZGVZBSibEWwbOpu31xHhCQovW3z5eVMAAu8sP1Taktg42CwgQMJ+ftuQYpJOcVFEwoAAEjabfCcAhvGgqJo7CULYBbsozJVfUNOSgqHU5PsxCimk3pJQzECUZ6EMyjQ7R7fXarH5nt+M8kkuFr51Xbz0QtPReEmMi/Ad48mo8YqNEyOSL0AMpcXIuH4Ar7kOAMBCKjgpfMj9Y7RSoYNQI4OLbWiu+IFhKAwV+3ygnBPh+v0OODQfHAaspHWGDZcTKj8rPfLvzf3u8MkxMeb4KJvI9R3Td+c4eOR3Ww2NMibuV9ir8AhGfwdE3Cfwgd02noq9ksye/4d4b4GUktI5JfybRbkuMbm+9arg+vpcBnQu+sWUOPO792SG3TypwBbGZyRTmNdaEiIX2i7GcD0/fkocf2ZTG52KyvazISmPtu/SSXHgNmtlIJJTm8DLwDXXjNrhQ+Nz3/pmzMw1xuLa2qiurIxZb0yIxW9PjMt+/euonP7uipC2ECSjLl0ESMGgYcoAZPuBY0OwZthHc2WPcI44ShxOLCQQyVk3DnRGOifb5/o7ttR+xOB6v/keOWKHrDdrOdhnH3nil/eMww5vPsWHA8cxd+0KmYBnUR/A2v0aC/qjuTxSj/xTlAqFbikEnda//Woc6VpAkgMuquL78gGpqJKHXF7PheMEiAGadDWb0FGxT/XSBR6dLEZcp/kXeZKq05pwSuyD5l7LRtEDHBd504VRQnoS4eEagFI6FEN71Oe/GL86+dZYuqTtR7cmqayUU2vMPry+pBcd9Lkd4sTv7pfZb/azWB3A/7qsApRFBNCh/IQdeHvtFR494MirZxTzq/8oZp5iPhtQTGxQTKJwh42KHRPaa00AQooJwKCEAIuUpGwTA6aFR9nlSwrPecY8tCYUF7AiFJ/617UmqehEEjUQ5HowH384/6ZYZ/ODioYpSiXjnrwsZk99NTOowngMQDE2lLFn4LAsjKRQLKVmfIE/BQyUmPsoBhqbK0JgQK2vFLpOuZXAonGwVqwd60ZlpusA1P290EAAkhwejBCjI2WAseA9m3/XmITho5w5Ghwlz6nnoGvoM7BnHP+vzbL2SuUQnQn2XO3Y2G7QyseMAtGYWQ+hTvPhurBYDLX7yc8BNG7WNNDsHhlP63vlowprY+KMvaK2/k27udPXbnkof5tQNzDqo32gbtlbO8eff9yUqmBe3B9WEqBPla7N5SlPmDIrjvn11bG8rqEkjP13Prt7fGbPpnO/X3x3Rpz/9JNx14TxGZqqqaqKenG+JH623ioqYnB1Tbx29bWx8LEn4oK//jUDe8Lg1jLH2XrmbFn3ukNwgrH81h8HQGjf3gEA6EavFeZmlOk2awCTqWAxORD2gXXq7xxjHSLGvdY7Jk78cO/XUsl66w2N8//WtIZaE2DSHk1FegCQOebMp9xL11+4Z+01ALMl0MnJ0CXAfqYTpLvYE97bEiAlXlcYks8HnfaYymh5uqIp+a+hz9oSwuWgIhsAy/zUJmuCA8DRbe3kG04gokWXjeaEDRL+tn5EcJrLxwT0sa4Ac7eGNWKD4Xu1qRNKe6Vb95q46j/fi9WGDs4c2LYQLv9rsgpQFhHKzWZL1ZLtEco1FT6gxOWD5Qvjgd2idFv6/tQ6xedhAHhfbRWspE0NCFHy/i+kha2i9PytuTwaihuQ9r7Wmu2m0C0DD/y2VREz/BREahcCTDAkX//xZTF01NZlO78619gQk1+7J6aMuy8DVAAJxcfYpbN0sS8UenPh40IxtgxHv34DonufoVHTrX9069Ez+vTuFasP6xfrrT00VhsyKOuryDlhKCj81KPQ9zAS7l9oW46QkJbrMP7WgM/3/gQa0wPYzT+JxX1gcgAW68c9+lysBDYIe8Cg8+gTo5x/n8detGOM2rZ/h3p9tiYU/EnrXRoNi6qy604gEkPNUNgTrlEoTMI7Vi+FlAAPxsu9uR9A29rDtrl3IS/svd+lI1KX174Wk2YeGLnGZZ0qNEo4bkp931iQ61gu9Zknvh1P3zd/hUNJN2CZhMKbyzWur2+Iz532j5g4Y040lGg/VFVWxGU/OTJumvR6XPTcM5nJbdPIKDDi5E6dGu9deW0snzZ9Re/UlAcp9YN+EdrHMmLShF+TU8MJA1oAavvLXBK/o2uNA2CWmvvbG9aFvEX75bbbbo8D9vtD1Na23L6oM+Kc7Dvu/E5WfNJeAShdP4DJwZNagAAALAFMKRkt5S56PfbTmpDDTTday3QlUJXAlP3O+U5N6Ol1oF4o3J6Xc1zYmzT/me5vSbchUloL05tnuhMozP+ba0+HEWhx1ZLYr9hN+7mlPH3hfuPg85AiLYnP+vwnzoz5c5eXBVCSL5y0c3z+xH0yFp2dXyUryypAWUSAHcwTI54OoW+ryFn0YLTlFRYK9k+1WrF+c4yjvEvAAxC1aRlSoaX2NBcHWikZoJCiln+XThyhmORG5VfX5Qvl5zpaajWSvEdK0maXE9mWMBRvVAVval4N8FJyCkd432f87bHoPWBlAF7qPMpZ7zwXE55takfBGy9WbWzMsCaUhrAScEepewbqEoATShwwbKPYaNtPRmNVv6LMamVFRfTrlYunH7w2usZ7MWni2xlwlEtGCQOkEtApcmADw5HyWzHZrhF4TPmDqZ0OsAhwAZte79m1WXOMSzq5CHBl2CTtAzKY7hXX9r7BTrl0ux2xWWz7jdbP1G235Cqi/p3ecfvPJmQsHTDhegESD4ystA4A1/0l1hYAlkuZmA/3xDAaJ2uI82Ov+DzhfeOqATeWjMyd/0hMfvfwqK7JRXV1+w1Mms9pDX2yYpyOSGNDLhbOb4hT9hkfvboNyvaAlmFauLS0Zy64+dG44NbSnvDRUNEQi9fJRUOPqg4lA+TkEOZysevCpXHpT3+2onBN2gEwT2cI7af5yxdrtlj/RnoAA21OMdI+I+m61LfV8/rrbxFHf+FvUW65+NLjY9SoprOgOypYRaAynZZlf3P26JDUpzYVktnDgJh1bo+zD0Ck/OGWzu0Gyulx7zMPUpSKnerVnO4WARCdkLPdWrP8/GcOaUstoAid5f5ayhullzgcdD+HMf2+2HGimEyOChCNHW9O5r23KD6z+5lRLpFfPnqTgXH237+Z2Qe6e5WsLKsAZRERRrNR29JMOV8oQ8rCxrbBi4lQD2NaWN2GHcMkMYgYFwZSbpGQpgKW9ohr4C0LKVNMwrXAKQUmV8l1MsjpuMEk2EJgSgjbGDQnNpNwuLwhyr4tVfCAjO+mbHnflIbcGLljDAqFceGNb0TPfiOifJKLmZOfj7N+/rlMoWJRWjLqAA7ATJFibY0LJoHXfOqPfhtD1ts3uvXonzGfLeW3pZYnFbnlMXfSfXHbjZdkOa3yzlIyP2OSH9Z0XRyD/BC1RwoTpvOugcl01jonSE6Sh7wza1iIK53mQSht68N9AXMpNMUB2WPPPeIrV+0c/daqzqte7rwAVVed8EpsvtaOGUAAplP4DRDByAAh1ihG3hpRFKI6OH9+3JN58zpFLFhMjCYwjK3xO+yndQV8Go8XX74lfvW7HjFmYz1N2w4qTUV9VMbU+j6xONe5ZumKde66anZcfNrULJSrDy1mn/OWWCtGWk6Ze3zokUdj4Rofj6ouHQOxxSRXmYsF60Q02KqdIG+sO+Z+3Vdej/H33pcVRuTn/VpfqTG6fZ6auxeezJQEY8mh4bxzeLDPSRShAOBA10MPvRCn/bxlJ7cUcvZfvhAbbdTy8X/tHS8RpxQal+NurUtB4QjZm5xWTCOnD8hui3gfhkyaAHbYs/HC4mEpWxP7CzjDilqPSWrr6+PFidNj7JSZMX767FhaW5fl1A7t3zvGjBwS91x/ZVxy3jkrmr0Xgk76nC5TZU63NQdMWyogLDxO1HPq40tvqW8oxqJOGj8v/vijW6Oc0r1XRdz78p9WtNdaJSvLqrO8iwiDjLlpj/BChRxsasCjObHJUrgnCWXDK6V8GFk5I0I/AFtrRTjFRKiUAqfMAcr8sKj/C88ArZRbvjdIcXst5rE5oQwoMp8vPNsWMJmug+IU3vVeRh9rIQcTEwe85Ro/3HakpJLLxaAB/docqgB8MC7WAkCJ/dtqq61j9rLVYo3Nj8yAYrShWCL1z2vM1US/UfvFngd/M9566Zbsd8LTDIAwNzAP/FsfwLe10Jyk3pjWCKHgefty1yjkxBKZX2tOWFIoEetXTBGag9tuvS0+e9zB8eXrdojK6oqS5FNado9eMinmTlwen/rOpzIAgRVRoOIaOU3An3F2764D412saAzwSOkc9ow8ZHlM3oOddN40kGZ+OWQcKuPzpzMHx2ZbT4jjvtwrunVf+r7a+3DoNKUN2ilzG3vEzIae0Zh3cEBHReX3Jz4zJL580LVx3z2PZNelOAe4dD8AGSfNvAMaW+xxSCwpIZgki4d3HkyS7Ci7xsZ4fZ1RMfXa92L1kSMzkG9/2x90j7WIgaQbAKTmwGRKV5DTh1XPB5PSH6wRhQ8A2XHHHRtrjGw6VaWckrVcKqFkR99uuGG2nj3MOX0IQCfdmYqPsJocjMI0qWLspLFGQtDhGH5OrhOSsLxCyUiNlk6Y4cBzvtgd9q5Ln/5x9SMvxPWPvxQLli7PIiv2guMXhY/9X45tLtcvNj7qW/HGnCWx4/prfuhaAVsMvEhPS4d3YLUBYRE56S7N5ZSm53QKE0fc+BWrA1h9wFax4fC9ywr0li5qzIiYVWCyuJSv6dz/YbHBLPK2CtaKgWDIGcOWTlJIrWJIMq4MoJCPzQhMYg+BCSxnR87RZqiBNxuP0sZUpcIghhuzQ4FjdvKFQlPQ01wjd5+rNYvQr1BOvgFoTuTbuD+KDmBQZIKFSYootcPgKS+cNzUqSnqC78rik3fYdmVWtjVhDHjb5mzXXXeLE7/7t7jm1qbzttt7gkd6/dC1d4z1t/lcdO3aLTMCcs6APWxMWhvNNaNOIrxNrBOKmeEGTISSGCpsHYAl7QGz6T7MQUuK0LyvOWiDuPFHL3YaeGT3GxWxZvdNY791j8/WobUjF5gxZWzco7B1Ym2Mg+rZ5joQEIYUQ2k9A/nuEWOLMQeojQdDat1xyjhPP/zhT+LJR9aMv/xulxg+8MLo2/Pw6FKzQeRyTY6AnN1FC3vH4ugV0xt6x7i6wTGjoXdJwGSSmppcjJ95U3Y9yRjSG+aLcQXE7H2FBZvvsn9JTyyq7ZWLWp1XSvSR1nFNj+5x1OUXr+iJmH82tBBlyk3GfjV3KpL2SSIwnuk5c6fHn3QADpXP076NwzVp0hvx35ABA4uD346KyIxIBL0n3UdOqdAtXWgdAM70PNDEFnAwABbhbPq4MH3Avhfl4vjbK/asPY2pB8ztJ/reHrLHrLFi4j30P33/qZN/EAeccWlcev8zGZgkgKTc3awgLZdbUbDlfQtqesWXL/xXnHLZrTF74crAzhq210XgWjquk+Prs9hDkRiRC/pBlE7ERX5mWh/WBZvBieZUWlcAuDHjiMkzVyB1/PEnlK2oMG/kYqON2mdD/pdkVci7QGx4rBFPiFFui1B6NqeQVWun6mCKgD0KQw4LhQxMqMBOxp7ikTdp03QEUNqc8iUZauAUy5n6xAkPCOXzUG1U3n86MlAoVMgRM1AolIT7ZPD8vbViJcpEfhulQNml0JeQfsoN8pnakFCk2bGMm+wZq43eJ8opPZc/F5/65G7ZvVLyrYlrxJIISW296+ejy4CWQVm7+rlNejwmvXL7h1rj5DMR+c2iGQfMrvxbc5AfNhJelLeE/SpkIYW2MQbpKLPmviudxpQxiGP/EYf+crNM4Xck/O3+3nlmUfzj5KdiycJlGQup1Yj59wyEWONOTQKi3Y/rbE0UE9k3nL5UYS/XFYjxmZgy/8fKGlfpAgwOY4XtMH6E8QVCFy9eFN/97qnx49O/Gve8s3IFeimlvi4XD940Jx78R5+M0WMYPaxB+xwwNneua9PP/CRqejbfx7S9Mn90riTsZDG59TOfj42GrLbi/0LgHBxFenJZ3atnhSSiOAAAnad9EBCQjppM4v/GRIgT0AAihHfpnauvnBoLFpSnvyjp1btb3HRzy7mtbREMunUKVKUwvugVNrClc7oBJOszFfdwMJEU9Dl9BYRh3n2e/eL/xYTDhqHE4HPcgUyER+F9CW8f9+d/xPPT5GdnjanaXeTVs2uXuODEQ2Oj1YeulDYF8NrrHIPmhN0RIs9v+dWWsQWorRnkCOcyyR03PB1nn9Z0WEa5pKGxPvY/bmi7j7H8X5FVDGWBpL5YbWUogQ2MH4PWliMaGWhGg7LEsihSYFTTZgcAsXUdZScJQwqICJ8AukCjQiCgw0anaIBY38l7ToqAx9tcuFsCtfCEe20NTMovwUxoHp7yQiWkA5UJTPLQ5cNg/zCUgO47E57N+uaVS3KNtbFkwbQMvFPGlLuqRPftmtP5sbxjeavmiHIEJuV2dhlQPFzcEfE5Q0btEI8/Oz5bA76rcL4BL8yjdZWOggT6rA/An/HFRkgXMOfmqBgLqUo2v4VQsTUPXJkTY8H4H7TlcfHXIx+JeVOXRg5T0cZK48aGiIa6xrjzD6/Hhcc+FAfud1DmwGDEjS0W3pgKdSvEATzl67YFTBLriKQQIYMizC0fTOEZYOYzzSEADowIDabip8TyKH6wF77yla9mrbnmLR8b5ZTqmopYb4ueWfiXcQeGk0ODPU59HZ9/4aWSgsn67rlo6F4eMFlVURH/ePnFFSF7aRsYaDrOXjIndJxwLJbRPHFWgC3ONx1l/2k55v8iH1g7DqhxwjybP6FZjsJmm69ZtrPmfe7GG4/s8P5Ojrj+jvYboOQZMcFZw0q2BCYJHcjxobONBb2AeLB3hbEBc2sWS28tN8cAApwceXvNuBs7zov2S0nqGhriW5ffFi9MT22Y2n/fGMxFy2rji+fdEK9NmZn9jg4zz+ausE6gUFrTS8UkdQPAeqec/CRrrNV8iL9Usnj57A/VHqySD2QVoCxiXIVrtK1oTWxYRlEyNeDUmgjxyVOkbHk4qu0KE6hPO+20LFzR1p6OxUSYBNgA/ChzniAFDaDwkiVuAydApRA9QALIyuVRZVwoAIwwhHy1/LOIiwlFx4NkILCglCMl6TpSAYKfhWEpBoCA0sUeLV86L2oa55TFaMh33Hvn9eLvV1yWVfEDiQCHMaBsAV1OhGIJyl8YEggHduTnbbTD50qeNyMk/IcL7su+i7JnbEkKHfo++WjPv/xizO9ZH6vtu1GMOnrH2Pyb+8f6X9w1Ru+zdQxYfbVsDgFkTEZzipuBKibYPOAOg6k1BzbD6xX7zBy3JM468D/x1q2N0aOi/4oG5R4fDGwTiCT1yxtiymPLoueTO8bVpz0Qxx93QjbX+UaDc2ONWAtpPLEvbRXr5RN7rRczZl8RUXNe3HznDvHr3/eJG2/ZK96cdFFsOKZflm8llQBgAy4ZYmFwwDadN8+BsAY4gq5j7qJJWQ5lOWXw8C4Z8JCba64UQhXKOu/nxJZKamHTMmWRNORycc3zz0W37t2zfpP0DVDJcbXe/M6aBmiIfqEYJnMBTNKDHGe6DsC37pLDK4qDgeKMpqMo991vs7K1FPO5++/f9jSnJNaTnHn2gmPMJkjFwNSKAIlyGY/2ClAuNxJ7RwcBaoAMRx0Ap7PSUbqY+WL9HDkq9reiN+ud04jhZIcuuOfJeGjs253ubyocvryuPk665OZYvKwp0iL9AeAzd5zU5sQcY6DbK5xDDC5d4v4TsF5nw2FlcZySaKc2f8m0VYCyBVkV8i4QgMIiF45pSQAgio5hBJ5aOx8VOwN8ouq9T/i5uWIgYWDGrqPi830Otgqok/gOLDKoPlsYEJDCIGAkGXygGDNF4ecrQACY8uJ1uoeW8kOFseStpYpbjBH2VUWh7wYugLVUPQ/gUpAABcNCMcxekIt1tj4mSimUZq6xPl554E+xcH6TJ+0eFWx4cCCEm1J/RwCD8nVdlGOXnkPjyz+8Ksolk1+4Kgb3q8jWXT7w6zFqYGz4+V2i7y7rREPl+62Kcu/fj2T59/vlzX9laiy4b0LsOGDD2HqLrTJGEzhOxRCYS0YvHWlH3C8nIVVIp7/JaU3tfISpOR+M2h/P+mMcevye8da8l+LFSY/GzEVTYuHCBbFk/vLIzesZGwzbKg7Z8Usxes0PqlQBduuLAbPeAQost3G11owxVsa1pEMEmmus3JhbFgsW3xhzF14ctfVNx/k1Fdc0jUt9XX3GAmbfu2Td+OGpT8edty+PE074cuZAcKrMLeAsTI7p1Torhcyn1F4TB53Yf8VnlENqlzXG81fsk4En8yFSYZ+49+RYLl1eFzt/re3HsrYmC9bJRT3VVEZDe1xNj9hq7bWzfDdRCGylUG2xdBkMMxacziwWBbLeOAPWAX2RHzIF+j5/5Hkxc+bCkh7NaksMGNArrr72a23qQUmX0oUYOMw7ZxTjzFmne0vpeAKLnHjrhOOI8eWUCKWn0HhyTOzd1JbIz/l7yXvsdXt5WZeesebhJ0XTeU6lEUU7n9pu4/jpYR/PwC2w6PvZmebCw2yOaIG10BHBCNPPyBxOSBZxO/rCeO3FyWVzPN54798xYcozq4pympFVgLJAMGc8TcnhzQllJlwrFGNjt1REwDME6ihbnjrjyYBTloUi1CNJm+fV0XA3oaixhJgYISisE+Vjkws32chydeQpyWcSiuFhe/Bmk/CyGX3AL1UgNicULBDMqwZohFyEjRly3814EoAU6MTEYgCT8pV3RTlQevsefmq8u6Bn5v2WSmqWjo2D995sRQseXm4x8AJcM4qKjowF47HJTkdHn8FjmlzUEouWQ7Onvhzjn74y+78x3nG3nWPiOvUx4qDNI1ffGBXVLX9vrqExA5eNM5fEq7+6Nea8OiUb1xQu97PUDEUrnBb3lcJfjCEvH2PG2Oefm5t9di6XAT2OgLk1j5wiIXrrWfi2pX5sADLHJoWmgFuOFWcmVfAyOoAEppQBxWzly9Llz8X0OV+Puvq33w+qtEwlapdoat9+s2t89bh3Yt6cJoehJRCy31GD4os/HlG2kCqpX94ljtz02Wzs7TlMk1xDDpZ96mc5b7uffG4sXtaBA6mLyJyNc2WPQ/15n/1j8+49Mz0od69YyzFRE7m9QL1ikdTqKl+kbWCXsZRSOYp1uHji8Qnxox9eX/J7+MXpn4qddlqv2b/L8+UUAZH2EQaO0wVEynkX4i21cMilJAl3Sx9qztkC4IAr4NJzqopmx4BLDH3qp8weHXTa+TGroapDR3m2Jrd+/5gYNbh/BmilmnAYMdHFQLb+yPKGRWg6KuwFwK1biM976K6X49ffvTbKIRXV9bG09xPxwIMPlOXzPwqyKuSdJxSZEEZrLYMYP4CQ8WsJTCYvPL0WU5I8zEJh6L2uM7mT+cpb2FQo2zPgCBymnC15S9gwylFYhHJ33wBe/lhgcVL1ZXNgkpHGsKS+egAjMOk+AQYPP6cQDkAixF3YegEzCrgKu95x3e9j2Gq9s6TvzksuFs15K+648bwMxLhGxSvNKWdhN0aC0ZDczmkYNHyDsoBJQqkPGLreir6lZ/39r9H/BzvFiAOb8q1aA5PZa95nVaqH9IxN//yZ+ONjV2YnMTHgmHbMBgH+KF5Oi7Hn2VsX8mI5SPlgEgDkJEhXwComttrrUlEFY9cSmMQ4U/jmNnVCwJYDma7P+4WwAQwOCyYT+FShbc0CXo888c2Y9O6Bsbx24vuf2npcOk3t6msuj1vuHhI77ly7AkxaiwnUYnAZ2uzYtnNvLSuYlBpcuXxYBvKNu+sBIuWCAmD2BKcKWz5twsslySXOzrcpt4bP5WLKrFnZunLtKW2jULCSdIzxxibZW4XCsaF3sGjNtUvbfod1Y6+9NynhXOVixrsvxBVX/L5ob0TpGSkNicOFkQRcsLAcM9dZajBpbWCw7Q/fZX+2dCSiPWQtsS8pD9r6lpOrGIhTL9ogr/jhZ1+K2bkuZQGT9PV1j72U/UzP2vdSANKJV4WC4ODAd4ZtloMv/zjl4u64x5gYtFrvsuTiz6l9NTbeZFX+ZEuyqg9lnlj8FndLBTkMNAPggWlrDtDZvMJ6WELALrEuFEOxkyQoLQaFAuispM9npIA4DGFq2UOwdACgYgTeHS9W+I8H7v554xQlo06B2vjFRGU2gIHR85rEuqaTWQAa3yEkw0h4FDvOkddM+TA48oLqapfFg//6dYzc9DPRtXv/Dis/oGnRnEmx51YS/Nt/bJ6w+Dbb7hi1f2lqE1QuqarpEasN6x891hwYNw8YF0uX14ohtftzGt8P/9685LmY+dTz8dp1/8lyaYVYOTcYcOsXg8FRUC0uDImxxWSaL8BPPi2mAwuDacA6ea9nDLe10VqOsbWDoQY8hbwYXfsBY6GVCgdDsYL1bm16YKisqQRKjjmuZ3z/p02N1zsSRWzyyyri9+f0iYbGhrjztmXZd1jr2BPGKPXMq2to+fSPzooChluueipefXX6ij3I0Fvzwu7WqjkB5BdOfzP6DF+vrGHqUokV971TT83O+ZYXefzxTpoZlem79EynYLMBMuBI9ASrl38oApaa/pCCQne2JN84Ze+YOmVOjB07tejpVG0VoHS99YbFEZ9ZLb5xyklZEQxHEkBzLRxuDiVn2vVLF5L+U84ehMgGRYMcLmOSiibbKtaQ8fWw3zhv9DP20lrv/u9HY/B2n2h3y7M2XXtjLm566tX47id3yWwKokGBkHEsVrDKeU/N0emFjop8byw/IiA7eWnRQ9Et2p8P25xIg1h3w2Fx3vW/jS+edHbJPvejKKtC3nkirMD48ZKLJVLzprCX8p14p8WYRGcTS3wWChfC4mHmvw4AYzSBvCRCAkCsjQeIdVYoctep8TjQkAqGKMt01jHvFUvo7wBGOgVGaJ5HKe9R2FfYJF9UXQIbwKpiHSwUhYudwDoAKIAE1gfbSGlgyOQW8eqFvArPpM7PG6QQfB5mYOjwNWLwOp+I3oPWz2xrrh2GQg7Nxmt3jwv+eEqMH/dai0xyS/Lya5PiKz8ufYitUHILHoyqL68Z1f16RGOJTqk5LLaIYz/2qWyO8s/oNa8ADbYY0DSP6ajOJIA9ICoHkjGwnoBCLCMDhYUGFhIY9DD/gBrAaB9k9/V+vmehmGPrlMHxXenh/4zDCy9fGude1LkTapJYC42NFXH4gfNj7KtLst+lavl8cPDQ1GNj9jJdHspTnXPdr3rGzVc/2+IpIVj63gOGRPetPlMSFmnumFzkykwbNNx0W0y+/4HMSbB/Paez15NwpDkn9iGnMhWWYL853JhrQq82V1yWL0uX1saXjjkrZs7s+FwNGlwZl152SvTo0TVzoqwJ69i1cqa0PAJSrPnmmrOXUuhftgOYpZdLYQvyhTN15B+uiHGzF5Q1qfaOH3wxhvfvna0FjDw9w3YWHoKBwFAEiqVv6wlBLZEo8m05zH7++bcvjEfv7HgoPd+WdOveJU46bc/Yc6+PZdds3a6S4rKKoSwIOwOLxcCkRcpLpSyxNIVgktEU3hNWxdZh9uQftuWknMROUialENea+uxhkyTE+x1jlUR4G+skVCXsLX+NQecdA9TCjsCk+zIuPFwPlemu3xh5KLQQGgUiAA0A0mcBKvLEVB9jgjBWqd8ixYKJwIxR2FpBCLun3p8At2t5d/o7cfutX405S7rH+f94KGbMXJCFVXjCxaSqqiIaGnKx9hqD4pQv7RFfO+Ezseceu3UYTAodHfeV78Sg9T4d5ZZ5W1THoD5dSgYmmYu7qsfF56sa4v47781+B1BiDIFLYEqLHQUpxttcUMjYOswh5kyVrb+n9ZrflF9eVxJhZPNlHuVzAZX2kfWFFU9gkdMh7wxwFQ3AZBeTxsbFMWHqfdHQ+G6UgkhhFETATvtNjzj5hN4xe/bcrAIVE2qdJ1mn72di9rLi4bnOAtrJ45bF1Dd6ZuNiL2BlPri+pnG116QgxJQpsfbAMdFv1KadBpVVSyPqYaEysp0zX3klY6/ta7m2HET50MKwHEtGHjgCpFMfSvoI+5dOeqIXrSPOp32Xz3JaQ4X6tnv3LtGQey7q6iujV88to7a2oU2hU6FQa2rosEVx/Q1nxbGPbJHpN868dc9pAiaFjHUA6Gz6UVuFzrVfABZdJZqLfnVG6OsZS+jg8lLfr055N1Yf1C/L3ZReg7Cgb0TF8oWtIMBmZwElJ4UN4ZDQb4d9ace48fqbYmjvTTt1dne3bl3ijAu+GM+98nD2u/y0sFXyYfmfBJRZfkXDWxF1r0ZOon9uWURFlxgx4MnYf+/1IpdriIqKlRU5phGYSr3vClk7BhYgEkKmVJvzaPONMrHhvA8YLZXy4uliCFwHJkgoE+tY2MhbCFpI3IaWg8LAy8MBMIFizCYQ6e/uB3OAwWUkeJ/+ruBHuBrjBQwqYkni916nTQpQm86jBjLzq8WxAyQ16nUNQE4KA+75sQ1i9x3Wj2dfnhT3PPxaPP7MuJizoDYq3s9rFJJYa/WBsckGI2K/3TeKDdcdlo0rUIuVba8wfFll8x//GDvs1Dpb0mnpXxeD916npB/JtC6sWxJH/OWbcfe3L8oULqYSyE/HOxrfZIQTW0wAPwCQk4NZ9l7OABBkXWEQU6sORSTCa9YHQ+jzPDOOhSJH0mcw2vaJwrBia37uoosjF7NKAiaTVFVHbLxpTRxyWJ/46gn/yZhXEQmGXH4zGdZzt+hVMyoW1U0uKUsJ0F579ox46pFxH9IDcka12wGcGHyRAw7a5Cdujj4jN4zKGkfgdXwgqpe8DyjLJDXY72jqZ+vUFQ61ghrh1QQgRCqEb/P3vPXE2aX77Htrw9rEbFsX+a2mgE2vyQeZHg88cH+2zk4//YS4685X4uabno05c5qKv6rfzz22vBsamuayV68u8dLLd8TMmc/FueedFbfc2iUDPYCszxGVEZa37+lDkRTkQaG+L7WwH0LEmDpOeUtH33ZG7M35S4qfnFMqAVXnLV62Io/S+CngY98KAWVKpepI66BCoVfYYNEUTi3H1Rr6+lknxA0XP56REJXt2EfGatS6Q+P7vzk81lh7SFxxzStZSkdh0eIq+R8Oeeca50QsuS5yS/4R0TgzD1M78E8Thfcbxeq51+PIqOhxRFRUDc1AieIEyfyFLRAov+R9A1rJkDIWb704KcY/82a8+eLEWLxgSVRWVcYjTz0ciyrmx7V3XhmDRw7MwikAlWrXYvmFHREgEqi0oQA6zCo2iqeYGosnEdZxrJV8F7lLKY+LABRC8ZhNuT16zKVq7SRACdbF9zEGNjRjIne0rcnqmAqg0/spBgnkcuswGz678Exrn/+rX50Rb018JzPWvXp0jerqlR0A7YoYK+CnPeMqVQGzgkUyJief/I3Y+wt/ifr3jVI5pHLnBVGx4aI2FeC0VxqW1sZjh/01Gt+vGsYiMZAcAOwQJamwhjPhWcg5HdPZnACTCmb0D8RGWm+MYhKfbR0IcaZwOZBqTlR1YqGEF3U/YLzzhTP35rStomHF/iyd8OPGvtIYn9p/Rub4YPAZcY6SNADr5J93nhuNa1+YsROlkIb6XDx597z4w8mTMjAEeAFS2FwOGd1iT8kj1sSaA5cczvW2+0T03rhzJ0c1dMnF/M6RPy32dp1/3/1x/JhNMscyX4SxNeDGQmH+rAkMknQYaxAT5+/0k78nZjxFh+hTexebidVMzObkyY6qnLRS30XzxrFZc01s5nrRu/eI6FLTL3r16hMDB/aPDTZYI9Zff1i8N+ed2GOP3bOxJqnqnG5PhWtJ6B5FQvSbNVuuMCdG2jhIFwEmOfjlEqZ+0+/8KcopMki+f/DuceROm2e6AWhkH+WfSmMqPN2HIypCp5NEZ+6LvbCHsc3sF+dEARgCaMdt94i9tz8udIzLTv3KcdI+vL+bMEBFVNVETJ7zVDw//t9RXdNkV+T8Yq6LnSK3Sv7HGMoMMy+9IXILfxmR46Hlg4MmELnS8srNjVh8fuQWXxgzlx4dxx57eqZ0eN9JKDxeLJDJINkwjDPg+O+L7oub/vLveHdiU1NXizL1xWIsqnK948g1vhzrbb9WPPj4Y/Gbi39ZMjBJgLuU9E/SmdtCSUJRxOYAEFPeXDr+So4d9gBoAKo8gExhBIwjcCA0it3xO8wDQ0jBA9SYp/YmrQO6SeR4yu0UigQIKQpMI5CZhGEZNWqNGNCvZ9HPwzqpLjdfbR1X9wxASgGgjDC6Kbyx9pqDYvxbpQc4mVTmomKDJWUBk9nHd6uJNffZLN69e2y2DzgUQpKUezqGMAljzrBTxM098v9u7oFKYFKlpbkzboobPOTwpnOcgSnfKY0CoDDO1g3Qmd/Ef8nyR8sCJrOxqMRSVsbceS9H/36bZGkacriMg7lmzIGHb/xqm9jliLqSgMl5sxrjviu6ZuPFsALVRMiXkfJ9gH0aJ6Be2gnHVKrGZXc8FX/55yMdvoaq2oqoXpiL+p4qvkvcmF/R2+NPxW9v+3cGzIEC4wkIAmPpdCz5uZxAYWTdDKwTudqYbXpEREREwvtSekpTWsyoGL36G5HbfmJE7fMRDU460iGjXyxcsnrceuc7se6Yz8dL41aPCW9OzUDn2LFPx8SJ169URU5/YTnpxaQPrHUFQhwjDCq9mF9Z7j6s5XQfALP7K2VBDgY05YvSzXR2OcW19+rWJTvdplzC1Pbr0ZQryf7Y3ykqYc7l6ucLh6OzDCVdjwnFjNMznBl2lr0C1vsO7BqX3vLDmD1jYey9y+ejb9cRMbjfmlFX90G3lS7dK2La7DfiV7//brw57Zn4+slnrORU0hXlSEP4qMlHnqHM5ZZGbt43I5b/p8Of8dQLERvt+ED07jN8xeJiBHm3FI1jtoRznvr38/H7L50b82YuaGrZ0drIZl2qK2LzPTaO717y1RiyRuePjgK2sE1YthTKY8hstnQiDBaOZ1w49cKcGEEAFJjDJlC2jADmRAhd+EIog6cpVCdM5Hc2dUdzFRXyYGt8rhw/YERIi1LAkAIxwG9S5l7XtVu3uPLqazOPuFtNzUptRCS0C38Yi5ba2iSRz2e8zCtgzVHIB6KX3/BEXHTNI52qKG1OcgOXR80RztItj1RFRew3fLuYcsGjWSEYJty8A92AYLEHJ6PY7/Pz/vLFvDDYQBlGIgFOLBzglAq5rLl0xjbhkAAS9o8G95yV+orLYvb8378PHMojN1y1fqw54thsfXhgCfNTNcgR3xgah399aOYIdqRFTROYbIg/nTQnJrw2OwNPqVoYk2I8jCdgYzwYVqkCCqE+dL33vxi/v+b+bN6ayx9uSRbOnxB1H1u7pIDSJ81/4KH47nY7ZsAB02z/2K+p56d9nPofJgBlf4mW0JfSYOxxusO68Tt5u/3794pYfEnkFl8SkeNsVhVdD7IusoyJih4R3T8bFb1OiorKnpkzTH+plMZQuRY6kX6z3hRB5os16TVyv63h/LA6PefeAGIpPXItC6M8HRFglXPlmqyFwnSkcskXz7s+nnlzSlm/4+ZTj461VxuwogJbT2cRCcSA3Ox8UM4mGWdroCMiqkVvcMCSveOoIUKkM2jxJwpozRlzERPEz+TJ78TC+UuzdIhu3Wvi5VdeyPaetDZ6ynvoLbYH40lXsVNy/lfJ/yigzOWWR27ucRG1ThLoeMgyl6uMipoNIvpdEeece2l2BCFWQaWiHChDeNH3r4zrfndzVGQFAO0b0qrqyqjpWhOn3fy92GKPTTp4jbksxMADtPCBPV6hXEL5SYVhBuAPEPRaIqStutBmJMJTWEKK2PvlNTJ+/i4PkiEAxCiMdDRYRwXTxdAwrIBrfmW54glgA9PRf50x8e/nx8X1dz8Qlb0HRO59xdS1pjo2HDE4thg1PA7aZqM44oC9MwOloKQlcc8MBXbNfFI+3pdfsYxdeeiRJ2P1LY4rS++2ig0XR+VuC8raimSdXsNi/QcbsjYizYHCtghDLaSEaaKcKXFKW2NiawUIB5yAs3wgmgBkoRG3njD9+Sro/EuGxC67V63oJVlqqavLxZWXL44zT1uYGQsgxlzn55OmPfKdX+4Tm+z7TkRVfZsBrvRsqVpP3DUvDt324thrj4Oz8Ugn9BB5qdIOhFWNAwAj3Ivlay5Ha/zkd+O7Z98QU+ctz5rht7gW37+IumWLYuazt8WM15+OfnvtGf3226ck64wf3GX5sph79vnx1vjxGVA2dgoiGNyUaiO8r40Qx4IA70Cb9Ac5g/LqgE8MpeI+ju9B+28QF/yuT1Q0vtnOMyMro66xf1x6wwbxizPuzFgvkQbXI8qRojREKzM58cAu/Wfc/c7YAHaY9HwHQ26oeXFffhaFsc5TTqeoTnvGFcil0zjvnIt80F1u+cVVt8eNz44r6Sk5+dK9S0088auvrXDCEATSn3SFkOJizUuzSsLBwiQWRkvaIpxV80DH0EtAnzXGtiE6RA/tbyCWc4Gh5rxaD4UA1mdZp2yBVBh5rAgjrDECxp7FZqdjQFfJ/2DIO7fgl50Gk6SiojFyda/HI//eJU455cUslEoBCctQpH/91uXxzz/f3vSdHWAQGuobo7GxNn6476/i1//+UYugkodtg+S33kk/54MFIRSAycOmohAZTpsj9QRTfe3vQr02tBxKtD7l6NmGBBYoBZ4gD91mlfOF+cMmlGKDYTJsduC0sE2R8PrW+386vnPTExE9xkZVZWVU9Bm4kqlxluwLE6fHy5NnxKUPPBuL19khvrDPdtm157e0yW9xIzxmLFKLKPeE+cyXBDIA86EL34wufVWkVpS0OGxp/dTo2dAzKgpyQEspk+ZMj9mPvpHljjnWLoH/fACVfi58Tj97GCPhJOteCgjjyxgTjgamj9IFNI1pep/3mAthRaAUiBTi9eyarGfXJHdzwMDGFps4d1bY/TXX1NtyYWbIXJ/vE+7GXCXwyyH7xtEXRlW3pXHLU6dE9eBxWWEPrFZV/eE1UBFVkYuGmPduVdx43ux45LY5cVWfo1YAk5SXLB9YH0zODgAFSDFmwAUAhgFL4vfGTlhc+gDwtfF2u8da2+4ds2u7RG19Q9G8xp4Vy+Kgj42Jn5x0dCxf1tQmacF9D0TNiOHRc9NNOteDsLExGpYtjzfPOjtG9OiZpblgc+RZWwtAl3vChItsyI+jZ4STdbGwl+RMY2SBTtEAawCD9eVjt4jf/2hGNNbN7IBD0RgVudlx7Kceie5dPxabbvujZg+owIy6NkDEWuYQm2/ghA4QdTLWhfmbCqboPIxlfu4vgFxYMJT/cz6jmaqdgSos6n+jHZG157ukZT360msx+qjvluV7dOA4YKsNVmL0hbyBeWk2cvI5EfmAkgNfmJffVtGWT/2BjirpqE8pFMYbGcAxQKio1jfngK39LoWhUDjD0qoA3pQWxmYAlJh3ko5HXSX/gwxlbvmjkZtbenr6pUlfis23++BosXv+/mD89ui/lOSzsZvde3WLi149KxbXLSwKGtM52ARItOA9A5pek3o6An6OQrQ5eFuABOVOEWqXko6sYsgZPZtSZRyPmaGn/IV7fKYecTw8BoDnLw+M0Wjt/PK2iE2P8QRAKPH8StD5S5bFadffG3e/9EZmKNtqCDE4TPysp+6LmY/f1YQC3m+bgw0AorGulDlDJkyX2t5g3qQHADkUH4MnD2fxkto48uRLYt78JSU5EhKw6dOrW0wfeE/0+sTaUfl+8nc5pG7hsnj80PMyZUpxGmMPgDn/Z8Aq/3fp/wT4ssYobuyaz0l/S8/WDcMLNDCofg8UARcJQOQzOenndEKVz734yq6x7nqlOXawmGgrddfty+PbX28KywIS9gYmy7qwPrCFgCUWHgD2ul79quKTR60dex2yYQweVRu1De9lALKqont0za0R775dFf/517S44vym0DQmCzvHIZKHZ237LPeMkXNaTL5hlabh9dIS7EkgEgjAaqaDCDxSXq9Q/Dsz58Vb02Zn539XV1XF/FlT44iD9o5ePbqvYH59Jz3AqP7qjDPioslvR+9ttmrXfso/r3lQ9x4x4sln4r7rb8gAGEfUd8h7ZnjpCkadyKv2M/Y6gTfMkBxKY01HYSyB6Hv//afYbfMLo7oKwO+402ZnKqyo6Hd+VHTbo9nX0X10oHY1ySkSrZDXKxqCeS8mHKGkP7GMGDY6Nx98eqScWEKvAJb2FP2COU1REb8vB6g090gFIFLXAHuMHeDE3DmnOsZOnVXSo22T3PDtz8f6w1dO3WJLgEaOJmeKDUkA0P9FqPKL+toiUqAUcoq6YJsTcObkmhPrjJ0yp9aa707FnWxaaleVLz6LXbMeOEjAvzlOLe06c0Tk/4p8JAFlxozM3iuiQai3dNW5WQ1YZf+oGPxwVFTUxHvT58YXNzg5li5a1r7oTIvfkYs5Fe/G841NifiAFsULdKVzqBlewFJ1NuXH6ACVQBHlBiAKUTNAfuZBC88zWkAgJgRIsvkoNJvTmPHQGFNgK50MgYHkmWOPhHb8rpBFbK9gI3l/clXkLgKV8lryT02ZOX9hzF1nh4gefTrFqGw5clCc9undYthqq2VjAzgIOQm/UGYMP+XPqFE+jIFwHCXF2OXLc69Mjm/+4voO5bEVM84/+frH49jzjo91jt9FKm3ZpHttVYz+99Is7MSYWw+UrwdDk/+cfi4Wpi4UoJIxNIYefqa8sQLAozWGfaaIrTlrNL0u/z2erVeFOk88v1v0Gzi+neHO9oW8r7tqSUybeFi2n6SvAHnmmmPB6FiPhV0MrB3sm30AQKUenRww+wMIBBAZq5R6AjTYV1gaY+J91jnwnO+MGTNVzwxvaggu1SSBSGk1bQ2pciCxxPlhfHqBkUz9QX/9zxviojfHRy7lCbf22arOKyvj0xtuFJ9bfc3YauNNMhCg4wWgLGxsv6RWUgpaXDcjzrkA2jkVrgPwkmojX01uHYZps802iNzsAyIappRIX1dEVPSKikF3RUXVB6HufDEHqQjG3Kj4Nu4YSuFTv2upXRB9oXgKIMXMY98K04/yQSZwIj+PU8sxyz8tDYNXjNn0s0hQexx3dkHxCz0tj9DnAJH0bDqt7dm3psQx515fcnZyz01Gxx+OamL38oXtsbalD5n7VLyZxhGDzQFqrbtEEuATKDd/HJoU0UB6cGjMIeCOgKHriAgbEGlP+LlYD1wAXE6necJmXnDBhXHcccdmn8cOF3YbWSX/KyHv2iferwgsrWguFFoPLb83otu+8Y/Tro/lS2tLavt41wNzQ+NvZ14cHz9st0yh2ASpubjNaMFTWkI6lBoAJIxNeQgt2VipqARAJMAjIMjIYSN5q0K+qecZBcdrBCYBOwnOjC1jSRhChio/F4m4DqC1MKTc0v8LCyAII+47ff7A1YbG0o12i8qqbivyJDsqz0+dHX954KVYb9m0rEoTqBFGZOSE2nikWFvXJYwrj7Tw6M0U7n34vnuj2/KXY1HVhk0z1QGgixmqqq6Kn52yf8yZ9nIsemtmWcFkZVTE1iM2jG/94qAMUDL07rM1MUfYGpWwjL8QIfDXEghNPzOAABcFDHCk87LT31vyYa/6xzNxwld7RXVNeQZFtH/uewMzNkKolrgezpkHoyaHCghwH34GdjlymGsGjBOXeqzae5p6q9ZlvAALYNwaAiiwWYybzwVQAFN7lnNnH2MiARJA0h7DYmE0tbFpb76jPcbYeuY4ONoQ02LtaqsjpSTr2DB1etRceV0M2+vj8VavHlHVt082BhWN3Nmm7LqM6VOs0tAQja+Pj6EzZ8WpRx6dsbnuWx4tYWgBBvpFDqWQIUbMfbtPTiiHDfCmazCw9hswibEU/l5/5G3RNXP+S6VIFTsuidyCX0RF/3OKvgK44AAA8pgsz8aeDgJWADDXmh8xyReOqTQJa4ju9b5UBWzezLWH9SPKYa49Sy8y1uY7hdLznwFsujCBc2K884+yzAec5hUQTiHtdFSkPQ7oA0iF97DV2iPjcztvHlc/8mJJWErOca9uXePHhxZnhLG9xkTOvX0CRCZAmZqbY7PdS2ti7DD51hTgnMCk39NvdBU7iaFMYJKwn8Sas2fZwPzc1az4rmJwjNnw0Djz1/fHbrucFtdcNSuuvfrMqKvbOnr16BLXX/dUfGKvjaNfv85H5j6q8pFkKBvnfSti2b/LVClaGdFl+1hafV4cPvS4qH2/v18pRZHONvttEZt/YfSKE2pSmMCGxEIAhwxQEsbD37zWhmHMhXPT73mrGEHsAZBqw1Go2DrhKgYICPCZNnnKdWKAGEfgE2tpA+cDRM8Yx0Lhiecfp1f4sw2uahxLSBkK5aX8sV/eeF9c//jLJQ3JTPn3lfGpHTfPjBmDz6AJAwI4QoLAU34YhOE3dumBnWI8MVlbbLtnPPjC4ujaw/mz7TH6uahbvjD++pvjY4uNVs+M8sPPPh5DfrNXlBNQfmmdfeJzazYVaQHQEtNbErmEnAqevPmRM9ycYW1O5PxhqAApbE0KcVE3jEExQIppv/Gmb8UvzixfhTc5eJ9Z8frYDwx2YvIYbvuKIeJgAXWMdX740t4RavMAFtwXhrVL1yVZu6Pdd9s1pkydF5894ptxzjl/ydY6EI/RAz5SFan3uG+Az77yGuyN18npsxf9v63CQAKimB734fqxcFgaa51j4D49hKoZd9e2vLY2jv7ud+KPV/4jNtlt15i7aFEcdOCB0beiMi4548zIzXg3Jo8fvxJjTW9wzoAVa8n+db2AWP7+wewIgxtb60dKjfukA4QS/f/55x6KSc+uEd27lceBqBh0d1RUFz93PulGYn+nRtuAMRBkrwDQLYm8deCSI0qHcFRSjjLmWe4eZ0rBX1t7LXqf8csHmvk/c/q9ptj6tWZcO+YU4JS2VOzkt2V19XH8X2+IlybN6JSelS5pbi844dDYZt2Ve0zmC8bPtdgD1inGmpPGDiBG5Om3Zb0jS+jNdKpaElE2JAFQ6ns4h/kOmYgUfS9y4LhP323+6ae77nw5rrj84Xj3Xd1ZGqOCjS+Qpo+SDlQRe+wxJo4/cfcYOLD8+a//1+SjCShn7hLR2Pnu+81JXX2X+ObX94w3bv7gDOpSi4X9QO6WWG/D0RlABCIZgmLKgQhraMtgkzB6vGvGkTLTQocHTrlhK2xcRhNgxBp4H4OBgSpWBZxy6ihK76W4ioHF9OD5NXedhBLhSQItmBrKz/1RuuUIx1ji3aor49Jj94+Lzz83GxNCMVHy2BWMHHYFA2UMU6I4MM3oMH7AZAo/7bf/gbEoNzLqakZGZVWXFQqnuXPFu3Wtjuq6KbF01vPx4AP3ZX8TdpFjF0etH6/MnxiNZQrzXrH9qbFGzyaWgzIHEosJ8ARwU7oULuZJKLAjkqotjT1lznloC+M24c2xMX/5HtGrd+n7cmZ5h5MaYu9dm/rD5ktq38PA+FlYMt9oF4pb2WnXrvGpw7vHVtt2icFDVs6BXbK4Md4YXxljX1ot/nN3VTz88LPZ/sE8pe+yl6xBoDSF/jEoQoBeZ8/Kv2upl6rxtW+AUEYbm2p/cSYZauwoQGwe09GY+V0fvB4YBaKE1jHKfiZpvWDfPAtZSmGwx4VWE5CxhukWANO9WEdajmnVwrF1HQAANtY9EfeLUdpr51kxpPsFrUbdOyZVET2+EJV9ftjs2NmDQFpqLZMEOFSUaGxaAzo+x74R0aEjjKmxpt84VphCTmspxLibDzmcrpuu5Yx75tz7XX5LuHQ+fLGCoSHDR8Rv73k+nn97Wsc0T64xutbUxDnHHhQ7rNdye7aUv+/aAD6haXrIegTkjVNrfR7pZOkj2GMOUr5wXtkxzqs1Xxhlkuoh7cPfECAKc/bb79BYe63947ln2xfNlOPbtWtNfOOUvePjn9i4Xe/9qMtHDlDmGudHbmb5S/sP2m1ALH1jZFSUMV757StPjH0++/FWw8u8WRvWphFiwjpiGbE+xcLLlEyqUGe4gCQMpd9hCbEcQsO8PGEbypEhwcgwXnpTdlSECoWIfCZlnU5uATq0DvrKhf+Kx8dPKkme4kqSy8WsJ+6K5a89lbEqFJrcPuARiOQhGwseLgDpweNlPIuJSlBV8UuX1cawtbaJo477dox/e3bMmNV0Cgfp36dbbL7RGrHVpmvGXjtvGDvusG1m9ClDjDHAJbeqz3Zrxs9f6VgfttbYyU37rR1/2uor2f/lyMo7EhorZqgYPaBavqPQXFtzmoqJvqJaPgnzybVLFb/NCRCCzQKMNtnykTjq2J5RXaSaurOA8tc/XxD/uGxJxgQKy1qDQmeADmOcrw7Nvf0FCDLaikuEjWsbHo7f/Wl49O2v8EVBU2OzqYcVFblYtiwXF563OK64uD4WLVqW7U3ALZ/5bEkA0MKcUw/zY8ywa8Kv1qvIgFQO+cAcS+yk9zDG1j3HCJu4ZNmSGPmx1WOTfTaNbmt2j57De0VOP6D6iE1HbBJr9RwVJx/09fjeMafG9079XsbUyXHlGNirwv/y4jiDnFA6SPSCwQeWsdyAj9fki/XFiRUNwKDee8PI2HWH7iU9ZnMlqRwWlUMebJXxcu3GLTmM7gE4lEIgDJ0fPm1O6EsMLEeEk5qO0cTGdkY4NxhQ+1a6jkgDAIwZxRYXRg9cO6ehOYYzFW6SqpqaWH3n/aPnph9rcvjacDyhl9kmi6e+HV/eaUycetKXW31Pyp+0zzgW7kdo33dax/ZWSqMoJmwS3QkMskX5eaU+h2NgnxiTVBSWxD6zB/ydTTTXl156bVx80YvRtUvnDro/6uid4uhjynOK0v9F+egByro3IvfehxODSy2///aOcc/VTa1AyiIVET03q4zFA+esBCCLFUtQMDYNrwxQQ/9rvM7IpOOoADmMAMCJPfAem5MRssGFAdIpBhgSXrXwHBCZhCEBOHl6hUdotUWABsqVJ0kp8JQz9rBbt8x7Pegzn4/9fn1JWXi67HsqGuPTQxrjsUcfyUA3sG08jAFD6wHktYVJY5TT6T28XWwvefiRR2P33feI008/LX7w/e+tdO9AAK8cwDLecreEeXv06hnHPvmHeGfJ7GgsYREZOXPMF2P7YU2VwZwG95wYqCROmcAwYZeAq2JtNdojgDqGM50ukqpn80OIQrIMNQPjwRinE5M232L1uOyaxujSVcur0h2B+O67jfHTU9eIRx5+Jvsd5s91MMgMM5Y8nUfNOTMeACeDx6B16xbxm7OGx97757Jq8fZUI9OyM2f0iGOOnBi/PfOaDBBoewJkGx+5z/kpAAys3Ep/BxILUwQYUeDM9VuzyVj6mzWVX/SRL5VdqmKjIzeODY4YE90HdI/GuobslKb8NZ+1PsvJoayI2hm18cS5j0XDa3XZ/Lgejpdn+aL2LbBFN9EzmDNAMY0vEGB/WVN+tuZFTwCtv/71/Djnp09EnzKw0flSMeTpqKjs2yxYE3ExbvTbWWf9KSZNnRPj3no3Xnnt7bjwwoti9Lprx7e/cUKsv87QGL5a3xb1AxAp+mKfAUiq+TvS+5O+oieBSPrZ51mjIlHWTkoh6YikYy2BS44tZ6+m/5BYbbs9o37QGlFRVR25hvqIyg+6PLzvHWWP1bpXxb5j1oxnbrs2br/ttuyeW7MH9B8mUu6k6+d4sE2ib9KsRNE4a80JEgNQ5PgXso+YYWyyMbH2Cnu50i3Gjr62n2fNWhhfOfHSmDdPPnd0Wk78yh5x+OEf2Mn/ZfkIAsrXI/de5zzCtsg3Dh0Zrz8xsKwh79zqy2Lgdj0/FFbO/79Qhw2K6gcA5UYJXQE8FDhQyXBjnABGxiYlIwuLYTCEEFS4Zfkkd92VeebyKhkqLFMSTISWJ0AmD7O94hoUBVEkqecjhc6Iy1erGrVx/Pqf/ylT4LdJJl7z59h6vbVWhLGxpR3pewjYu27GlbJjWBklys78GM/8z6W8AejUksScyYv1OvLy7Lfi6y+c23rFbVslFzHjtpdi6b/GZblD5hojB4RYIwRAUDgBUAI0QExqQt0ZYTTMMWCZmATMI4DpOjg/jKW593cGGHMKjAifCj0uWHxDzJj7wVGnpZCfnto7rrtm/IrkfAYOMGOAgEhgx89Ya46P+ZMrKVx7yaXnRq+Bp8Wmm9d0uOm6CPqSJbl46O6D41unnJ+BBmvHHgTkOXr5Rj+dEsUgFhYfaGUilAyY5Z8GZWwZaE6hv9mrAKu1+dKMl+OG+f+MXiN6Zy3K2iLApddOefSdeOGsZ2PRu23vAODhejmuAEUKkbsXLN46a/WO8Y815S2WUyoGXBUVXbZu9u/W5lln/zVGrrtTbLDlPjF/4bLs91VVlVkRXX3Wy7dp/AHKT++3Zey7+0bRu2fTEYOF53JjNTknnG9hXKCQ49oWwSzKb/ce4MjcihzQ0fmV5KUSeouTl9oZadX2wMvj46nX3orXp86M+YuXRO3yZdG4eH4smT45pr/2Qsx4Y+W+kfYwsIYlLAyriz4lUOoeVM83VfZvljmd9jodrJtIYRg7CQcE8AQaOeP5Qodg/LHLnHTAtFA48akgyvP3T702nn9+YuYUlkI4vef99ZgYPbr8a/n/7/LRq/KubD00UQqpqmibguioUMaHHH5QnPC7o1p8HfYyVU6SxEx4P28Ma8BY20iMilAkscmBGhvbpmS4gA1AkgCfDJzNnxoEY0oYP0UEcqPaE8rBigGTHvkNxDGnBJB5/J13s81Z8nB3nvz1qhvic7s2b1zaKqmnoHFOFZkMk6p6YKoQpEpCJ0KEjClGMxXHyCM68ZDPx7SR9THqxA96E3ZUcg2NsW6fEXHeScfHt8edks2TxuMcBOFRgsVmqChiuZL552l3RoBIoU7pAIBQYiB1CCAcFOsJG4E14PAAtgwKVhCwMq59en46Fix+LBYvv6Ykp7uc9ZsFMf711bL1D7gCRdIesLbCuMK5AC+DBOQ5aUM1KaO+cOGC2PvAx2LxMrmyHV+blkSPHhWx+z63RV39T6Kmeni2b7FPQnXCcqnQAOCV62uMMDPYMw4dsO6IRobV9RbmKmM1jSfGmUF3LwDlsuHL454l/4lePdsOJkl67fDtR8SYm8bE3EvfixsvuiHbzwBEYkWtIfdCpwBTiUl1zUCEor50ZjNwSaqrynem9EqSa2ruXkwcvbfmmD1jq72cdlO5Akymv5EEJsn0mfPjnMvuj0uvfzxO/fInYvcd1s9+r/gJmLRWOYlC+uYSiMLGmZdCZi0J/SuHEIjkzJh74whgSQ9ob0FcW8V82If2QSqo6tujWxy03abZozkx5ymMrnUWIEePm2MAMel04l4SyKQnpUJ4PUeNA4vZ5tglvVQodCNWVj1AsWJCRAQdJiUlVY4XCieeKEi95+5X4pln3o5Sy5m/vjUuuOjYzAn5X5aPHkOpB+XMLSNy5QtH56Iyvrbf3vHmC+Uryqmsqoyjf3FEHPnDQz/4XjmPDY3ZaTEpFCikwtjIixG6SUddpZM4KHTgkHEELAAb3rLXp1NgeJFyc/J7c9n8wA9Fw4DlXwODIXdLXlZbmvJigZIXCmzlK0jhEiAWY/WnJ96KsVNmRrmkuqoyPrPjZvG9g5taJXVGsESp+hm7Z6wxngB3McXHuzYPlLFwv3wihic1V+cIyKecMGRRXPDmHStat7RXvG/hhJmx29Th8fvTzszmy/y5Vs4HIOX6XD+wAsC1pV1Ha+Kz3Y88WMYVaPCwJn2PB+bb+DACrgl743qwxdalPKv8aznjzF9FXfw2jvhczw6dqZ3C0m+P3z02Wu/MFWE5Bt54Y2oxK8YgFYlgc81RAt/G72vfGBlHH1+689br63NRt2zjGDn46ozN5mBYQ+bfvk2VxwSD7PqEPc0hA4z5UoRQTIwxIw6YACoYrk9989Ox/OP1nU+naIxYOm9p7LPoE/GlT39waETKp8wvvgIcXCegaW1wIqwLTgywjhF79qmb4sRP3xDllj9dtmnsf8ivMkYsXxYsXBqnnvGveGVc+/V4yiPcZ9cxsdf2g2P//ffL1jqgrQgm38HSwoeeA6AS6LGuRJFSSBsoUtSUQtptydnsrPgu603v1OaO/GyLIB58DnuALWRz6PzClkjC6+nUmSQconR0pzWUXzxk7fpsa6VYX1DvoS8ww+yHSEeheI1QOMbfvj7+2Etj2rSm1JpSy+m/+nTsuOOHG6b/L8lHDlCSxjlfiKjFiJT+1gzXa280xPe/uHXUTsYGlW/4Trvt+zF/eK94+LWJ8dKk6TF59rwVLR6G9O0Vm64xNB659YYYuHxu3HnbLSs1Z7UxgR2bmBeK7aDos8KXr3xlBZhkOIW5Uz+wfEmn6TC8ibkkFASPkLFT3NCSCHe5HiF5QKrw3Np0vZTRqTc/GRNnlc5wFwogfvA2Y+Lnh39gsDsiKW8NCwGIu/6UGO7/xRgF+VRYOowvNszRncaXUmfogAmJ/ORv918bf5/3cFT17BIVbfV4YYXKiLl3j4t1J3WLf113Y2awUg4sg4WlxEwS4V3grqPHHGJi8xnI1K80ATb3C0SmZsJJ8sETthKwBDxcly4GSeR1CVGRgz7VPX5yep/o1q2izYU6wstVlf1jxOCzo1f3PVf6G4PN6MlhxCBZmwA/9pLRYfgx+vbIVluvFRdftTTUJ5X6vPXvnDw3Xn5+tczZ4rgxysYRKElj4TrtZawjhgsD1FzoMzlnQt2p1+jPfvPzGL/1hOjSu+MFVitJY8ToPuvGDzf8XlRWVGZziIlj+OXIqnA2n9Y5gOX31rj5xZbSR4CCsZ006Y0Y2fXAqOwE69sW2emgRfHE0zMyB0Yub5bjuHhZfPVHV2f5kpyVzsj8ma9Hz7pX4447bi8KzIAZThwdLLqDiQfCATmAKIW06ZT/lqQccCxoS8UwbREhfvfk86SHtLRPvIYNkIPLDgnxS9EANN0/25KOKU0CXErjKuzDyQmlSzhghXnhSYwx/WpfXHH5rfGdb18d5RDO7hZbrBm//f1n439Zqj+SKLnb/pGrfbIsny1ac//jPePdJVOjb/2wkhsZonB8yZbD4zuPPhkLli3PTiEoDAPPnL8o/vPKhGhYc7OYUVkRp99wX5y838cyVoIIOwizYM2AFxseQ5jAZAozC3M3lzfHGGjarLeaPLskNrXQNXDqNfn95woFq8K7LGwkWyzkjUEsrzQ1be6sMAaS2hl3bDA2BhtnLJsLT1F+GF+iqhyLwegDN1gK+ZgEG/X1446LnT6xW+x/5nFx73svxNKG2qiqqIyG94+QXHE3WUiuIiue2HLgurFX903i0olnZ4CC1894+V65scBrytekjIEmwNjaaC1v0nrBtCTw6JGOIaOsAUfhfiDRPPs7Z6WYALAYSuAWM4uh1DoKgOJUCOMySoBdkvnvbReXnDsk+gz8d3zuaG106rITb2DhxFpa0hhJgHPZ0q4xbPCXY2DfL0dVkWIMgAYQwuaZO1XtQt2uH4g1ZmmP7LDz7Kip6VnyfZ7LVcTpZ2wY/7ho93j22eey7glAP+GgCHV6NpZpj2AAW8qjE0oE4vLbr/Q5oF9UL2i+7VC7pTLijUUT4j8zH4iqsRXZGua0uHYOkX0gD5YTK7UlpYT4nXvCxgEz8r2FXF96YI3YaP0Sgd1iUtEj7n/wxfjHlVdloX+Axlpba4sjY9KMpZ0Gk6Tv4PXj8AM+2yzLl86Pdt/2prVkjkSXyhnSbk44ddaSdJOUAtUZodelZaTWS/ROcyIXkuMB4LEfdAAbYh+yEwmgAoiANv0KTAKa9GbhsZZEtA1jX+y0IfqISEd49NE3spB0SmUopVhHzz03MZYtq4tu3Uq43/6PyUeSocw1Lo7cTBW4bWvL0R6pb4jY4uMLY8Lrc2PnigOyk21K+vkDuse8fUdH/eCe7SrQcFqB/JfKsY/EgzdemTEFAA6lZVPK05IPhuXAlMlbEW5LBRrNifdjs1R254eMgBFhLKFCm7YY0yWXDjvBMy9UXJYd71SIDDvEMI2tGRYxZI1OHbXYkkiwn/XYv2PAgqlZcRGQnZ7dW1uOOGMwKUOGHSgBxrBHxe4xX4RrMLoKYxh9n4OFY3gZFOOBMZN7iBU27ozx0obl8fDMV+LZmePihifujF7D+mdx7aEDhsTw6Bv3/v3mqH9ldtx11c0rwsXmQ14Ur59SxT4zZtIeXCdWUDgXCwdsyn3TMy+BJtdmvvMBJKXt75yH/BB2CkNpgg4w+6zWGqenvCaAIx1ZiL0u7IFqXOSayqPC3gEjlZW1scvu3WKrbXrFPvuvHcOH94hly2vjuWfejhefX549brt5enTr1nwVrJArporz5Tt8PscJsLWu3ae0kK985YT45BFXRL/O1yk1K2sMuTW6d90qG3PsHdZXaoQwMcOf1LO1CZgBv8YLq5nf0sq9YHo4jKnP6LSl0+IHL/+k5NecnaqzNOKafa/MGEtOgT6X8kCtI9fF4UjA0WELAAHhOFlD9IY1dfxn340Tv9A3aspwMlKjlk5ddoyqgZc0/b+xMduzvz3nmqjou1VJv8vW+dsZn4sxo4etGCPpR9ha69batl/kDiq6Mb8cyfzm3P8tSb2J6YnUqaIUQoezOZjy5tqtCV9buxhr4yENhU2iD4wJcGoti3IIhxvD/PZl6VhLTr0OEiJlPie/PVJ+0Vjq+cqJ6N9v71iyuLwc2tl/+UJstFFTpOl/UT6SgJLkFp0buUVnlzTsjZ38yyXz448XdM0YlleueTsqZnXJQj+lkNphvWPuoWMiV13ZdARBuyU7MC2m3XtD7Lfp2hkTRBhtwInnCMQAkkLVwJ7QZf6JO8XCNcCTsEJh/0IKyWbmnTJkxZqXC0kAjZQMDxSA9eyRDyCwMX033yUm1Qwsa5X3QSO6xIKJ4zLAhBFLPdmACOCrEGh6VoyURPI8I+DeASjAHAhh/JtjGlJlvfCSscCAGX/gII0xY8wJwNCpuixkxIQQMQrAhpC5zwR6KFJGyvfLm0un/TCegEfy0LEHGCwAEKAyX0Alpex7KXCf49owmVgC68bvE4CklJurVrWWsApAUXPsJKFuOBoMmmtOBRqAubGWC2Uc/d74AqopnxczIbXAa80fo2UcAWNrzTMGBAC2npqTNIcYKwVtWkil1kGMmrVpjwwYNC9uubu4YSyNVMWgPt+OgX1PKZqfy0nTvotRdE8pbSUV3jHGjLM5sh6AeeOfcqH/MemquO/d+0veiirJA9+/L9bOrZU5QuaL8U8gUq4n4agZU3sIi+Tv5jhV0J/wxV3i4F0/3Be1VHLMNxZH70EHZ7qPrqqrb4yDjjs/Fi8pbUEQpnz0WkPitG/ssaJKW86oOUoh7bQ36T1V+Jh41fr2c0vN60sp2G5Fmpw50ZBSCseMztTFAuArJtYJe2NM6DotfzjPCI+UWsUZdm2KfHxeMR1iXOkvays/wuLz07GWHj7LZ2dHDDfuHpWV5R3nb31739j/gOLFV/8L8tEFlLm6yL13aET9hBIdwVgZUTUs3pz75zj1ez/LjNL2m+wYvV8bUZI8yrqBPWLOZzbpBJhcWabddXVUzZyYKXZKCyuGleHt+b8qUb9jsICZlkSuHfAjHyW/cIdgvYQ5ABEGnkFjMORLWVrCQImdYEQYGCEMD6wGBgqgAeyee2tqHH3udVEuqamqjIdO+3J27mwSyt21A5cJZHp2zWlrYPgoNqAGU8Y4Cr8YQ2kFDDzg01w4MuUrAXNCudgmyhc4MD/CXwAjB0DVcTFhfPwNu6ygJx2tSTgFUhswpa6LssUSUspJ2cplTSyXnCkhyMQ+YhWA2hQOxjLpHYjZTqH4lgTzbWxS02uieGz2/MVZy5Uu1VXxn7tuX9FHLjEIwDgAiJVjHPLD3AAeo6cAzM+ANKOLwbUWgQOC/RJu93vjaQ0CY0BOoQBd9i1gBvT4XPepGTWACSx7xmL5rM8fMzB++POaMp3ikt1l9Oz28Rg5uAlQyR0TDQC4OWLmOp0zzggDKoCJZtyKNrC66ZGcswQyPSZ/fGosryxPJXWj+X1iZtz5rTtW/E7xgzXjAeBb71hfgIEAxkKPnBsFgmltNr73mYi6F0t6VK70h5nvRXzymB7x/7F3H1CSVVXbgHd1mJxngBmGnHPOSclJSUoGRVBQxJwwoYAKiIoJFDGQEVAEEZCcc84MOQ0wOccO9a/nNme4U1PVser7/H57r1WrZ7qrbt17wt7vfnc4b7w5PnOQ7OMd9/xkvDG9du3enrr919E8f3IGnulVoe5yjqZ5tV9STicd2J5jXy2xP60vYLdc3nxPRRGW4pr2Tr4xLsAiAEn3ciQJ3QX8Gbv2cjtTbj99SP+2B57ZH5EbjuiuO59elRSH9pyKY4/bKQ48qPNHpv7/Jv/fAkpSbH4lilMOer/iuydeOoXQJwojL4lCY9tRdIwwdmfKY3Ni9cL6PbvPukJMOXyDaB4xoCpgMqt0b26K8Vf+Job2qc+8QQbXRhaCwWSls4ixckIy7YkQhLwUCoIxIzxDCoFhlmANrGCQUn5LOjPYdyTwSHGoQM0L4InZwmC6791O+UO8N2NO9foxpjFpbY11h/eJi048rt1jIfPPDEDngSYlKHcyL+k0FaDE+AKecsnyDKMwt5xFoZ104kNqEA8w+S4Asb0j3rBP2GUK15wJL8m7SyIMxFjzyjGEwImKZdf0vQwb0J7ylBIAAMwwc+aJQsf4UcDAn+t1RoAcxUh3PvBYXP/guHj4+Tfj5bcnR1MuV6ll4byYM/ntmPfeSzH5pYfjrxdfmK0hAB1LmM6DN26YHGCKIQbaGRBAz9rDHKZG6Z5T+D7fhsr7GBKsIwG05EZa454PoLYusbD5NAWAHpvhexUHuO6d9x0eO+4mh7J2p2E11q8Yqyx7f7YWzClHBgAzpoyg+QEe6Rsst2e1V7xSJbA5FUamjzhtAOazrz8Xu1+2V9RSFkyeH/POnZ05U+lYPGudc8DQuw9zyCmxnjhAebY/SbFpXBSn7FdVQEnOvmTD+O0fnsr2MTF+y294eAwYOjZrEVR1KbbGWiv2i5//8JNln7OciCBgT7H1QGXGpNVIrBNpSphBpEIthA7nLGRr8Nlny+ZnyyOlL+lSDhDdY98B2GwJfVSpuEeurs/4yZFtr5Ap9a+0l4Do3Xc9I5qba8PWk0Ih4vMn7Br7H9DztnT/V+X/66ZJhYZVozDiooiCfKruVbNmx/kW+kZhxJ8WgcnU00qbkx/++cSY1XdqFHsQqJ2z+dhoHlkdMElsxLqGxlh9309lGxyYVHwhZIrlSe0V9PZKRraSMPQ2LiYHm0nh8aQBKb+Te4Zpwv7YuIntxPJgVgAUv6fISsEkYfwxQ8aSZ/roVRfUJOQtL/Pac36agRXebwIwlQRABsT0ZzR+AIZQEcPNuANjwKPfESyt8QTGGHoFUIC88A8wCfxQpDxy6QMAmHnwPVi7js4LBjRS5b45SIApiTEEGgEo4FK+JsDvHjCocpQAFIAs5YpiTc0Phs9nhd4YHc/gvp3fXKk/XBLG+sprro/NDvp6HHLyJXHRvx+O59+YuBiYJPV9+seQMavF0hvvEesc+L044bS/xGePPyEbD3MB5Fu3XsYaQDH+gKB153cAARAttM2oAOcpZJ7Ec6QTRjhAWPjUbxMox+ZiZdO59X6P0QSGUpgWcOUEHXTQft2ugu+sFIsLMmbaevEs9oH9kthizp/7srZS82Z75tvf/vaia7hfe9AeV/Bgbd34aPmq12pK31H94oqrrsjAo5QHc+YnNtl6NN6eSYQDa1UJZBUa14zCoI7zbjsvhYh+H48vfO3KjInTVsYY77PPvjFgyLK1AZPZ19bFguLgToNJwrnhzMgF5OSbw9I1XQ1hB7CT9F9ncpy7K/Yv/cqhTSk9pUL/2VcAX4pyEbn0bARWu1IRHMDJqWZ7OqqK172EiMaQUaO6f7pQZ6RYlCvf+bn//1H+v2YokxRb3onijG9HLLz//U59HT9yOof3gUfnR1P/U+PDOx9V8b0zps2IY7f5SkwdN6vr99ZQFxOP3SyKfWuTLPzyxb+IX//opGzTYkDklwB6+VAsLxm4YWxL8xwZ/AQ4gRlgQ0g0ha1taspByJVBEcpVvdfeuc2Lnr1YzBgYoARbRdl981vfipum940X35tctQbn2MkFLz8RX//IdhkYTOElQApDVQ7olgp2ktFX7Q7kYLh44IwBYw/gAHmJzVQQo+emUFuSdNQfoGRssbbYKEC/o3OzsTvGC6OHsXPfKY8SQAKaAEYAyhwQ4BHLaIyxcQAUR0h+qzmSq+kzQkscA+/PxqtYzEJXGC9gT5W/nMty4GqPw0+IiY3LR8ExbV0oprILB/atiyeuPjuaZ7ybjQ3ABKgD30AxkA0ISCXwrMAKRwU7aX1Zz54dCDOfxttzAmEEE4wJEWJNLZmScAYANtWlvldxlDlzPYybtT5p+o9i6iyMfGWHq6cyfdqA2GrDV7JKV2uhXIqBe+REyC9jJBlcINg+5qh5dsygeUry4JSH45xXyp88Uk154kuPxlMPPJkBdIbbmGLb7QP/lsZAr3S0vovF1ijO+G7E/A963nZP6iL6bBWF4X+IQmHxSMRLr02MT329unmDS3x7XSFuvuRL0bdP1/Q5hlKahjm01zFq1Ti1KgmdJ43C+uls5KEnwgmkoyp9nxxn+saJa/ZfAuGcIWCxnFhTdKaxSieOtSf2Cx3N5mUpX1+/MB57bHyPzu7uSP56xQmx1FK1Ba7/yfL/NUOZpFC/bBSGnx+FoWdE1Kc8t/olFhYQ2dLS9rum1mXi8ydOis9+e3Ac/onvLjpnuJwMHT40Ln3mvDjsh/tnI9qVJPj5a42qGZgstrbE2K12zgw0xQ7wABS8R6wYUEPRY+GycNDyy2chWEoN0LDpFXAAT54f6MBYyfMSppE3p3Aj9be0cbFo5fLX8sIDF4YEYrFJFASQRmF8+phj4vQj9sx6RlYj6q3l0uhhg2Kl5ilZSBN7CIBQWoyynFChltRuqZJgDoBn+X/yg1KLllSkomLdWBo/4AAzYpwBUGOCfQUkgVeADiMHKAD0QITcUuFa7JtcOSGjfD+2xFACe+7DT4DKPZhToW7zx6hjrPwOgMQyAoPG19xRsH66H8DXcwFtromtBCCz/MEjjsiegRHCbABn7ik96wknfCHW+NCBMbn/KtnZv12tzOcqzJrXHKvufmwMX2m9bH1J0PcM1pG2SowGMCmtAnDi+ADUQnbG2nMaO+wixhx4dB2/A7A4TELmpWBSni/Wz/WF24yDtZGYtpTz1tiwck3BZGtLxHNPLYhf/vx3i7WOKhWsuFxRzot5Y6jNh5/mDmOTWJ4kLzzfdjJTrWWjDTbM9rLxtNatJw6pwiI6hCOgAMv6bE+whoWhP44Y+Olumqb3lUW/PaMw/NwlwCSZNLXrDn9XRY7ejFld7y7CWdOyyvqmb+XAqoiuhtD92EKFpP8TYJIoOkIyWJfWZ6kIRXP86NN0ihinUoShnNB3mFX6U1Qo3/y/nCBB6C9AVYoM/XbZXx13GjWTUUsNjlGjOj7o4/9n+a8AlCQLp/XfPwqjrovCiL9GDPxcRJ8dIuqWjagbGVE3Op59aWhc8Lc+URh+YfQbe1fMbNorJk2amm0IuX4dKYRPnXRYnP/Cr2PrAzaNYqENVBZLm/YWtLNo+9v8mBtNG42omb+ENeq3wpoZwOHtYgEBoZQ8LywK2PAQKRyGAXABRCi1VL0tLGNjAhY2dGkzcyAE2+c98mJs5EqbHPOF2aTcKBD5gBhPADUxYKssMzJ+/al9st6L2MWegMmhA/rHX044OG66/rqMAWKAATHGmCLj5conAtY8V2lTXeJ9cnooR0rN/aaTSvLhLYwRo4/JBLr83/uMCYaJoRWmFQoEYBlhjJhxlhvnd6nwAkjC+hgfwB7YxvwIbQKLBNvqGowEVo0Bx165T8wApsP3A5PYX8ZerhL2D4hPBVo+y6kA6ITePCsFbs0IXwH99oDnEi7HUl9559MxZPW21Inu9mjMQGihLpbe4mOx6fa7Z6FR4+MZABFrQgjX8wOYxpaRMg7mwDPJC2UwAU+pGZwFoD6B39J1itn0jL7H2GJIPA8wafwxvUn69al8/Fy1uqLOeGuDuOH8t+PA7X4Sp3/rinjmsdcXFYPlhfNlf2q3Yn2YF615PI817FnyDtt5v2zLda6l1Bfq48+//3OWM5dn+e1ja8xaAf6tRSCA/kjseSVQWTf4m1EYcXGmjztjohZ1li0MicKwX0fdsLOiUCjPhtayIGOx7+lBn0NrF5BUTMLZxLj3NIiIIEhdAP6nhE7g8InQsA2lQt/Zt/Ln6R42SfQm9cotFfsUAJWjbx1V6qhhj3O+6Hj2hi1jcwDQ3579vejTRea4s9LWW3STmvSl/r8k/zWAcjFg2WeTqBv8xagbcV7ULX1H1C19f9QtfVfc9dQn4vhvjIuFsXH2PrlzNgSDjUEQUutIxq42Jn70t+/EFl9bK17s80TMGjY5psbEaBxRFyttsHyMWX9UvFZ4Pl4c+Fjse8aOMWdw35q2ySn06ReNg4ct2oCpzQIPkoHGQGJ1sAgMA8NUaVMATwAVY5byzQiwjXXjXQNm2J58HhDj7TOMCuaLAQekAC6bvlxoZ8vVlotBL94bxYXzsx6bXX5uDdiXHhGXfPGQWH6kc3oL2X1hBYETAA/ABOaE3D27vDTPzwjmvWqgBpCj0LBI2JckiaF0TWtEeNl7ATegEFgD3rCgxgF7a7zcj5APsGTs/Z3hxeQYG+/BUjDMlKzxBEz9P4mxY4DcOzCJ2UvGB1gEJDGMFLYiIKwdMOVaqfKeYPeMA8YaSFM9iSkQdhMuxiZwElybQh+yzIqx/BZteUk9lba1VogFYzaNQw87IluTKji1HTHeQK77ZpQUJaXG3e7V39wXMChcnSo+3TtgmZ9DoTSOjD1tbAHpfNsqaQRy2IRpk/RtXCvq6mrXhLK+vhgvPtlWaTtn9vy4+6Zn4utH/TG+eOjv4vWXlwRe7k+uLoZcvpk9DFCXhv5U9z/wr/uj4ISEGsoKA5bPQGWpAObyhjk20iowwqIbnDkRATmW7UV8Cn22iMJSN0Vh6C8jGjcuiSQt/kwz54yOwpAfRWGpO6PQb49273fggBo2UM/JgP4dF/21J3SQPS8fnW7ws6MISiXhZMk7tlfo5v9J8X2cWLqF81vKuqsyt685GXQOgoGeKhXPLv2G00j/5p0+Yh8L6YtQ0Kl0Ykrrcn0pF+zPfvt9JHbfY4MuH+HaGdEwfc+9Kh/w8d8i/3WAsj3BwKQzfokFDIQwRpQ5BZk/+L49ufn2m2Kb/TeLe967OY7+zUHxUNwal750bkxb/u14ozAu3pz9amy1/fZR6NdxW5aeyt/+fWtmhHm8FJXNq8jBpgaOAAWsVGdECBE4Td4uRg0wcx1gysa1mYErBl24gWLBhhpf3jcPMvUJNJ7lAKXQ7/3XXRU/3XfL2H2jtsKXzsQrgE/M5Gd32yqu+MrhsdzIxZOkzanQv/ui6OQvchowAcAfAAW4UOo8eyFiz4ilVcCEPcvfb2IoMb0AoZAz5ZnO801HggHg0gPk/+VFyEdoFoilCDETqhzdG+WJOQb6CYCF2SVAq3ljrAEk65OC9nn3ioH1OUoWqAQ+GPl0nGG+qCOfV5iALFAr/JvOcccoYKuBsrFbHdBj1qSUqew3eGSsv9thGSsLjGMhGBiA01hYv9I0rD9zYo9Ks+CkSBXwb2vGHACUwLa1DmRjMzGbxozjo/E34GztWaPm3ZotbZ9VKDTGsEGfqIma5G+99+bQePW5D84nTid4vDLuvfj8gWfHVRfdu8Q4cx4ARi/Pl04eSnnOWB9zu/fue0dxcmsUa8TK1UVdrDn4/X1ZIkABwGiuiHXsnjCqHFJgGLC05isBJSHrQv+9om7kZVFY+vEsqlQY8uMoDP5eFIacmkWRNtq1KU7+zcZRGHBQFOo6PpRg1RXacoRrKXWxMIYMrtyHtbOC8aVXzbNiPhGlVK3eFTEHcmwByv8NoffZBU5ifq7ta3s3nXGuA4i17Fnz7cOIdcJxwrLao9hM+1q0jV7iENNxdKHn5FxynAmbnWczjz5mhxg4qG/VW4F95tgPx/Dhtbfl/+nyX1GU01nJ2JchQxY1fia8JyBE2FiOEMOGuWlPfIbxogx8jlCwAAplirECQL75/R/E1dN6rnw6kjOP2Cs+uccOGchIifueVYGDZwHwbDqGmfenyKS9Rru8PkrA57AjQAuGJzGb/i8sSSkKIQvRAVKpIjoJ8G4cGCDgJUk6vgtoTakGo1dbK5bbapeYN2zZqOtbfsyWHT4kPr7V+rH/luvGqMEdb265c+4NyGDwAEn3I1xNiaVG0oSyw/T5XV4oSQouMbIYxHRKBHBjvTD2QI55x+LKCUw9IP3bXABSgCCgDVAC3ymMmNpsYM+AX6FhYW95QcbZfDHWpb00vVIbJ2DWfQCN/k7MGbCF8dJiCJBL1e96CAKnlHTqG2lvfGjvA+OdAUs2G66G9G1siPULL8Z55/4uW4/u133YT9aD/Vcp1GVsgS3gHDtpHD2rYiprOXUbSPOZmvIDptgNzy+3tLQpe1Pz+Hjt3W2jGNXv53jpWdvFg7eUB2VJDvn0h+KoLy6ZL0ZHyQEG8D0DBwlYMwbWHbW+xv5rxpbf2qZmYbifrH9qjO2/7BLzYJ9bv8a1nBhneii1gbLv6KauNvcGUsx1vhVWR3LAcefGxMm1yaVUWDT13eeiz9zHs/XGianG2ANISADjRldW6lVbKnSNtBdOYUrR+d8QQBh5AVymVmciJEAf/eTfHLrU3YBeSs4dvWYfC1l7How3Ryr1kaUr2S16Np0Ulhx9a5HDWDoH99w9Ln5wUucIlI4E27nWWsvGL399RMZS/rdLL6AsEcn/XhZ1EmFKYU9KEGOUbypdTrBzGCGGsPQIKkAl5ZQMGbl0rPDJJfNLqi31T98RT978zyyMyJMrFWyQe8YaUM7J4wMujUXphgSagBvG1085dv4ttEBhYCkpCl4n46bQopxg7YQw5cck5g3YUd1rfN2v7+axAm0AzVGf+lSc+INT4vnxk2LWvLZw+MjBA2PtsUvH8EFdB+dALcZKKFRVICdAJSFhqDGYgI37oMx4wOnMXgrefQNi7hdAT89iDNIxi8CikDQnw2d8p2sk8OilYAfoK3d/AKMG8FiKVPUMMBj70n6UeUlhcsASE2A8hZQriTF2TeFy68B3AwfG3efc/3ZHfDtenjS/6n1CiWd6876/x8J3ns2YBQA+7UWAw75JxwqWE4wjIMPQSO3wf9fxmdJz5LWSsS7tZc4jZtmclZOps86LSdPbLzTrirQ0FzJm8uzv7Jmd6d2RnPDdj8ZHDt5ysd+lXFkCVAId1igj6ieH4/unnhR/7XdlLGhtv0VWd9jJ1QevFt9Ze0nWC3jB8gN6Uj7aE2CBbpXjJoohH5Te6ezZ1qmJdt6J60h+85fb4op/PVazNKPmKQ/EI/dcnc2DPU1ncIbK7e2uiDx3AFpaByebHWkPgEuvoc+MqyjJ/3ZuH4CNVGAr0ulb7IV9iJzgHAON6cACADOdgS4fmi7i7HKykRhApD1buq+J6yrES/1my8kVlz8Y5/7+th49U119IZYdMzw7bnHo0I4Z8v8G6YXUJcIgUYZ5ASKBAkZZWFJeC/q9kmDugKJySi6dfYxNmDV1crQ21eYki7yMe6KtQIGBBvxUFGOmMF3yQt0r0KbVA7YOqyr/TugTuMJ+pCMKCVZBGIXBBkRtYMaN8mL8jRd2EZDBcFWSlD6QQshyYSgK18n3Ikv5fpTqZ487LsYMHxI7rbdq7Lv5uvHRzdaJbdZcsVtgklDKJ510UhZOpbQoO8qaQaC80z0wksL6AJfQqjQI40Yh8oyN6UorrBz/uOSG2HurQ+PMr58Xa4/YOuqmD433XpsaTQubs/fIlQRUgWnMoNwg31nO4PDsKUWFGMAcJZtO43Ff5fpR5oVhFrpP4WoV32n9JcHICpVbF7x5wIQCB6I9q0p+4XQ9KldbffUY9+6smoDJTIrF2Hq3j2VsPgMEzHtOhhSzLx/LfbT3vKq25Y2lk384guWMjmc25oyt9csBrCTDBx0d/fts1e1etnlpbSnEwgUNcekvt+8UmCTnnnlDvPPWB+2nCEaVA6jwBfjnPDDAnAIA61/XXB+zXyxE699q08LkiBUPW+J3vp+usC47ApPE/UsnkddMzwCHQBjHrDOBs1QR3N4eSEJ3WAtn/PBz0VqjoNzggf3in1f8PtONWDXOJD0LLNG1paHcrginTqSC/qCHPLt1W0noX04sJvt/G0wSIJhttc84EfStiAMAqR8l/UY8FxCIraSrpA/RRcCktBaOIr2J7Ci3r/PrQe53JTno4C3jy1/ZPWMYW7Vb6IasvdayvWCyRHoZyhIR0pQ3SQHl23hQCIw/pggDxTuiDEsFKAG4gCpApVRSFS8lKgyw3VdPj2nFtlyxWoj2O6OfuTFeefmlzNjayAo/yjUzFybACAEtQB0FCFykTS2EYyMz2Pr2CQNTnIA28Gx8UmuedJY0BeBZy/Whw+y5J3/nTQvLUAbClPmmtVgkIQ0MnZBmrYTSMmeMIuWHLcW0CtVQzAw1RZ2qkSlBgPqrx343RhZXiv4Ll8rOdW8zhsUo1BUcntHGHBWbY+8jdoiPfupDscq6i7exKRWflx9kDcnFpDgpV4o0L6X9KEslVXYKPWKDXBfoSkyW+fMTW5o8fiBOyD8fOvcT09l3yKhY78Alcy+rKcMH94+bz1r8XPgkGCzGyFykIx6J52JsGS37VkgwnVOsMloYuJxY4xgPY5IYvkrS0joz3pp4YCxoki7QPQOkJVnzwvo4+7t7xBvjlu705+rq62KjLVaJU885Mst1tkZTqxX7ikNjT5KjjvpU7LX5IXHB6ddGS1NLW7X+j5qicd1ilKmf6ZbsP3bf2G/skmOa0giEJjneXRVhTKkndICqdsxy6mhQSTg8QEg63rFUOG72KxZM+g2Q13/0trHMCptV3TE64ZMfjkP22Sxj4eg+z8IRpU/sQXpRyzVr1310V1wf68nWAGWlfRvtX+NCF1eKXvxvCDvB5rEN7Id1fMrPT4s/3/v32PWT+8dj7zwfjYP7R2tLSzRPnhvzXp0cA6dFrNw6Ip587IlszXeGvRa1QQawK9j7SkKHb7rpDjFk8NYxoP/o98Fl+84GHdHQUBefOXbH7EScWhT4/F+WXoayRNKJFaU9wGxOipty8hJ6ZKzKbXZGrZJCTRtCUYCQ2/Di/Az01USKxVh/hWXiiccfyzaZe2Z4AEWhaMot9ehzXwAVpYuhxRBhhBSiyKHDYHk2HjdlwBADI5QEhYlFFNJIx8G5HlCEocQMtMdQAkOMh/FMPRFLDQ3Jg4haCOOMneQhu2/jBGQnVoyjAGBSRH4/Y9Kc+N6hZ8cKC7dcBCZJ24kvdXpGfZCDWWiIm//6QHx+l9Pi51+6MGbPKF+MIE1C+ByjyPEQajZO5So0MUHprOckGFPst7UFiKaeouY59a80b5gt6xyYNJcMD0fJGk9FPcAo9sDnsZff+9GZUWuZNmtezJ5XPkQr1w7I9nyAPLGe06k+QAgALC84FSG0l++MScICy9fqyKGrrxsSKyz99xjUPx3z2DVDIsV2ynuD45ff2LtLYDL7bEtrPHb/y7HMyBUzIMGwYlc9mzUK8FubfesGxPP/nBF/PvWaaGmS09u2Dmf8tE+0vFOIYhVONtxqxBaxz7LlK/zpDGku+aMwu3TtrbbKHHasMZ1jfUv3aK8fIzDlM6XCAZJjimXH6mHq07o/7TuHx7ChA6rmxAMV66w+Jg7ce5Ps/4of6cjUrodOo08445h2e4w9SU5AV8X1jQlWV5iYfsp31RBmx1R31A/4f1rsN5E+OmjVbdaLo649NW7bYHKsePyHYly/yTF4jdHRb8zQGLDciBi8wdhYap/1Y9AxG8X4A0fFzicfGfNbmzr1PUgHkSckRXvCvr344uPxwIO/ie12GBhbbe2Qjg9scenyGD16aBx73I5x+ZUnxMc+LrWmF0yWSi9DWSK8PqDIJi3tPUkxCAfzxFNPP4AqT70zZBS9EHE5b4pHKfTMEDCMDz71XNTtcFDNcnq+uOMGcexHd6l4soDNjZ3hLWLAkpJlnIU6MZCpmhi4VEhSKp4Tq8mY+Jl/YXwxSsK8QHS50xtS3pV7oIhLBWsmrAfsdnTiRjUEsMa4prYz8giF5zAnwKQx2mrtnWPYjNXfN9KFLufeDBk+KE6+6HOxxkYrLsbEprOlsY8YQ4aCEQTKS49MS3mUjKp7kr6Q2jkJZXsG96uQh4HR/so1ORMYSw6A8Xcda7KjYrO9Dv9cTOy/+BzWQg7bsH8sM2JItg/zL8/gBShIieAkcUKEr4WA804c8MBwA+iquPN9GpOkM4TltaaQW2dk1tx/xYRp342W1knZ0ayVTmfETtvXrS11ccfV68YNl2wczU3dy6XTu/bdmU/EtnuukLGv5k5EwJwD/k8/9nxsNWL/6Fs/aJFjk5fC4GIM+/7CaFij2HViDlapi9ikz8bxhQ2PL3t9wBwrZr9LUeippM4TwpwAtLmW5yxtJC+pgI8jhc33Xk4hXW2tpMMT7CP6hVNqbzz2zJvxlVP+9n6qQPfvE6gYPLBv/OH0I2Ls6GGLrT8RHeOCKUunUAGY2FQ60V4VlQEArcWuiu/Qjsm4WPvWBT2JseVwlbbX+d+UdMb3rXfcFmMP3iyWPWjTbNzrGjpHphSiEEv1HRrfXueQ2HhE5SMXOfwii+wWu1ZJrBNsKb3uM+bJumhqaonXXpsUr706MebNW5hFcZZeZkisvvroGDGit4q7I+kFlBU8QAZIEUNeKB8hYYwaYMgD4o1LDk/id3Lr8kU9eUkVu1hMuZaYlaN/c1k8+sZ7VTtqkGgI3q++EJ9apX986YtfyPLSeIeVhEcPnKi8tInkMWEKVDELz1AIFCDPjzGnCBWgCOukXB7jYlNi1ADzBDa9AAKhSCxZAptyA5M3bcx9ZykIt9mxgRg2IKiW4p55/oyYFj2eJVU4p2dRGLLDBnvFr75yWdv57d2cMqCysU9jnPH3L8XY1Udl4IAxBviMb8p1BHZ49qWhW6kLGCG/T2ONaTTO5tp9A8IMjZcCIM9DPB/jY86tQcyka7RXDUo57/DRw2KVdo4grZY8fekPYuG8yvlm5iExMtYG4yEPN4HOBEAZV8+ErZV3Zh3n38MBMlapEr4rUiw2xbSZ18VV/zwmNt2ifwwYsHgz6+amunj3jWHx6B2rxoO3rB5zZ3V8vGdHMmfBpFhx8zmZXuLsYaazc9Ab+8b2Sx8SfWNQtLa0syDrijFg35YYeERz5gN1GAIvZis8BjcMjofOeCDq3yxk31muGATjxiGVTtOZo0w7K1JtpAlxNOkZ3SAwb6nQLxX2SYcA3IBQDgaWX6qOPqUArnZZpfnD9z/6anznp1dnYc7u6F7tyQYN6he/OfmgWGWFJfPl3S/QAtRyFvOMKEfPHrSHMZVC5JwE9qSzRUlJRBHkn1rX5gZ4RXp09TrVFjZDxMC6oNvefG98rP/j/WPoBst1ix2ui0K0RjG+vOb+sd9y25Z9D6cfoOZ0YqbLCd3hPaJq0gPyVeW90jPpBZRlBBNkk5YLSTDADDRmgLeJsaTE5KAJDQKivGaMWzmR28HbBrooS8rwrN//MS58ZXYsbK5CTCon46+/KIYtaDuKLvXWbE+0ceAp22AACS+XoqYYU76da3l+CpvyU0iDeTQOcgyxX8JxvHMgUUhVSMpzA6zGrPQoLqwjsFTKcDIAlC4jgkHLA/dqCCCBoUotfDAZqVea59WAGevBgHEA/G3vnfaP4rixbYCmh/gfu9Gnf2M8X7wp3nrv9Swcprgpr2zdkxA0Y6n3GiXpXtOJPul88PRvhgkoNUeljHAS+WTY93TMovnBXnpmnnq+uXcSLNBjz78aw7ZcshijmjKwf5+4/VfHZwbXmFsrfnoBKxweKRD2GYOFmQKusLjpfekz1mZnGkJjJ0uZ0HLsaOn/7fe0z9dZe5nYfr19oq6uNebN6RsT3h6aMZPVbktz87M/jWKxJQsPmxNOwb//8lCsPGCjTjNtdSOL0X/35ui/R0vUvd+mtZhSqnNAs3lScyx8ZH5c+L3z46lHnsrWoT2BFSvX9YGj4u+1EGtVFb4wsnmV18yZFe6ni0R8OKt0hfUhj1M+p/QkEY5K8tLrE+PUX10fr705udPb2fY01ltutFKcePzusdTIwR227rFvgZxSoVOBTawqJ5EO1nSfvksOYGfEWrT3rQfjYpz+N4px6EU6FdkASNIn0qWaii2x7dlHRd2KQzJQ2FP5xtoHxt7LLsnq6qxBv3F8UsV4pXPG2Tp2WJSxp1X4vdImvYCyjKTCGeCntOk2Iya3B7OBzcK6ydmwKAFJYFQhSv5IvrzYaFggYUhgSzWkUNFHPveN+PFVPWtj8MFNtsb0cU/ER1ccnOUx2uQ2j5xJYLYSg0CRAW0UEs+Z96YYRuUlI8JYUHKYRIUzPGBGBrhh2CkzY4ZBET4FYgFmyhHDBRQJNVCiwpDuBVilcH1OWB1oSgK8unfgAsMmPJvApnBmV5UAkAGgpVN6KD7AGbNK+VDIHAnMqfunCIWNsM6YwAfufzB+dfzfol8MbsuRrIIIZTYPmBHn3PCDJcJ5nh3wEx7Ls6Xmz9/8X7pFOt7MvKUc1vaEA2TdYndSKC4VPrkeViefxmEeJbf/4bzz4s8Pz46mHhwt15Fsvvby8buvHbjY76wXYULrj/Mh3xMjA2QAz+ZR1b3851IBqrHbmAvpKJ7ROsBYAtKcCs2fraUESEuBbHol4F5ORgxcMTZf5Yiotdw97pxY2Dori5RYFx/ZZf/YfHA3ewzWFaN+2WI0rFqM+tHFKDQUo7igEM1vFaL55bqYXXgrVtls1KLTSziX9IC9w1lMgj2UR01fpJZatRLzwvECwOiFlAcMPKkgBiA5ou4H4O4MqGpubokrr38srrj20Zg0dXaWR5eazCfJLpMxtoVYabkR8YmPbRW7br92p65vfVm/6Uz6csKuyN123/QrR9bndBTpzJ62l0UkRDOAbA6+76x0Pnw1hR6yv9g2elJURboNkoBjmx2msOPYGLLnGlVL7XIs7x+3+GqsPGjxVBWAnI2xr8sBcs4Pe8sho+tFGkUJe6U60luUU0aSYQKaSoUCocyE0yxGXjOmUW4O9hIwqQQmswF/PwyRQnaSquUmHrjVevGJD1X2pDstXOfpk2L8TW3H7qXcIUoJSBYqAjywPXkBkIE6gE74FbgCJBgR+XuAlVwd11K0k46zAsaAaRsVyANEtRsCthWUKOJJx+gBPhSM8VI97hpyWIAZypQiwjQYW8rpuOOOyxQDZQvk8D4xaQAlsIeRkBeaGubyiN1zYu9Si4nUmodzgFXFwAqL+QyQ674ocY4CMKkAxvgwSACI0Jn3100bFv3rhlYNTBL5aH3mDY8577WtByBJeMgapBDTKTlthT6FRUoTgASk5AiaU0q9M4aHeBZivJNQ/oCBsTB/eWAPRBiToz75ydho9bE1S0b3fFusvTg7ag9yhuwv65mxYCy9F7A2vwC/4o1yOVPyS42RYh5r0/gKd2GDpJ4Qc8yQc77sadEHTocWWtIsrCPjC8BY5/LzAG7gFiC3B7bcUluh2suYMWOzveI+VEAv33+9rAq8W9JaiJa362LBnfUx9/KGmHNJY8z9W0MsfLA+ilML0TB15GIAUbsshhiYB7DzxywKK9caTNIb9inH3fdax/aIf6eG/+7RGjG3nWXoGhrq49B9No+//f7YOPM7B8RBe28SG62zXAzoVx9NC+bEyGEDYouNVo79d1s3nrnrnNhq9bmx2w7rdPr67IW0DMClUusg1+I004X0KT3nWextjlC+bVs58V4C2CEFpHqYK3qzFuI5RJ3od6QBPSxP3zPaO3SL1B1ky6vz3qsqmMykGPHjZy+N5lzLH3YCUWHMKrG7bAEbzDFR1ETH90r1pJehLCNAGPBhI6eNWipYRoCJ8rJ5bSyLmDcmL7CSUIiMN4PNkwZgGD3Xkm/zh1seirNvvC9LQu5avzTvLcTAOZNj1r3Xxrjnn8sKFYAwtL4QnfCDY+zSsYjAHfaQ4eTNMrbYIKwYEAlkAjbCiRSDn+WEQqdQXMf3UCYJvGEfhSSBH1W6njMpYs8PDADU5QRQZDwYdMDC+GBBMZnlXglI5k+GIQz+WltvEct+eOsYuPpKMam+NeY2N0VjXX2sNHh4bDBqdGw8fHQcvt2OGcsCTFOKADRWzP1SVp/Y/Hsxafy0bG6qKQDBiBX7xhMzb8yMSerBl56BAgR6zJfeagkQJuEo+ByQ3hkBlgFE6QkMVyn7DrD4u7Vp7Rh3YSIM0G2PvhTf/N21UQuRk3bdmcfGqKEDs7CmsbdesaOcFwaynFinQKI9hT3LdwnQT5WRe+Tux+Kbn/92vPXa23HwoQfHr/5wVtx07/Wx9bZbd7qAgV7QjYBTBcxZ95gkjO9ZZ5wX/754cSetFrLJno3xkzN+kO2ZPXbbK3Ze5lNRX+jaCTNdkQ0/PipO/80HIW55Z9aDFB8svnkR+ZAexDmshQDy5gjoB/DpFU6x/SF3M52Uw6HiNMiHq0YIM0WT6J/E2AMgnFC5gV3JUQTsOGqiMuXOqy4nHG4OZTooApAXRQJO80I3ytv3Xvqe0AeiEICovet7eypYUICXE2f9sRfWghxs68E+zYNsJALC5MC/fTsmD2/OojHVllM3OCq2X2q9RWOMfayUHuWe6Tv22VryHPRqr1RPegFlBQHyAJFKZ1xTKMCQCkthbsykcGp7uRv5HEwbHTCwKXn22KEERO9+6vn4/O8uj+KAoYEMai9fXPGNeEzrwvnxnf0/HH/95Wnx4rhxmRJ2H4AWNiYvgBflg6Hj2acm2ZgGieG8TyHE1BcSUEkNtStJCovySikZwNkLgKTced+em3JkFIRigFp/Y8yBIveblLS/Cd8AqgB7ShFY9NzFYnadlP/olYp2jKsXBmvmiEExff1Von7NldrGqqgfX64awf+joMNPNE2YHPNufSDm3/tYXHTBhYsdcfb3C66LP554fdRKPM/tk86PpuL87N8AHTBuPfl3OlO7nHTUj7JUrA0MbzkgZV1SysAT9k0YntfPcZKj2dzSGjud8MuYs6A1O4O7mmByty3WilOO2SOr/sckWIdAPSPZEUDA2HEEPJsxE+Z+7v4X44pfXB13/f3+aCgDuuob6mJmTItNPrpu/OKSM6JPv8o5a0AFg65QTa4g5wjIwJYCvXffeV/86ITropbS0tocf77+87Hc8m2ngCycWhdLzdiwZt8HAKy785j4xSWL99OV12zdYHONgzCuYsNqCx1AX9CxWGagCDMvnOon0CA/EjOpzZb3yyWU5mDdeH9PClNSakhe96Rem1js9hpnlxP7Ddh130BPZ4VzJXdYHqb9SS/Q09YAXSH9gHMjKpTfJ8ZDTjanSv4mkqAreZnJgQC8gGvP7vs8fzrusJITAXyyA2tvtWG0fn69tgLGKosinY2Grxq/2OSz2f91ZuGE5k9eS2J8MJJyfYFzjjqS4z+h6fv/T9Ib8u7CiTl5UUBCOWAkbVz/p7zkZrU74O8rOEwgETbDdjBUBEN27MEHxIR//D6+8uH1Y8vVV8iMbSUZ2Lc5Fs5/KqY13R8/fvrSeGOftSJO2D2GHb933N84Pdb/6E6LnToBCGMUsCxAg1AV5YCV4kEDJQwyhSwfRj5pR2CS2Kyuo51Syrmk4DCKwCtwZ7MDJ74XGFdYAYQCr+lsagUw3sNYUQLygrCe0giENDGpQp+pr6L7x4zKpROCwVJRunfcf1/scOb3Y9bHd4o+a7X1cASAFgOT2S/bwCRpWGpkDD5071jqO5+Ns6+4NAuzUuLu+ztfPqUmSvGD2yjEdhvvnHnO6YQhhpIx6Yj5KdePsj0xFxjkfMg7CRAPIHE6jL91aZ2nyt7bbr0lnrr2D1UFk2RAvz6xz6bLZQwCY8toGYeU39iRCLthRMgeO+wVn9/qxPjydt+LB//5WFkwSVqaW2NA85AY94+349DlPxt3/72t32mpMKTWNMdKWE8aiH1q36d85I033SCGjajd8WvWXkP/hbH8CstnAEHE4KCPtoX+aylzJi9ZKAhEY+o4MfaqdIJqCvBOP0mhsffsbewTQAbIcXKwTZg3oMBaAe6kJdA5ACVWWpqLPLnOnLrTWQHeXNfe7KoA4dY2VrW9E8RKhe5DNgB32E2f5aC7F0ARYcDulO4TepMepX/taXpCrnt7YqwwsPS3NU/3pNxsoJZ+5byLYlXSS65BL5uPQ07+XJXjOR+I4p7Hpr0cM5raIlPmmigILRV2GuPLdshl9f9eMFl96WUoK0jqb9Zejzqbk/Ky2XmdNhijxluvFGJItDtPOh1mL8ncpqUcKU+g0/tSle7C5ub4ykmnxr/vfiBOO+On0VBfH60DmuM7f/t1NGywQhQBTknk+Vyq1mK2sQv1dbHCwBHx4cYx8fDZl8XVV/0jAw2MAO81tRKiKLCLwuTYAMID9Syd9Wopc6BUjpkUgFKRE8kIeO50nCKmLLUToih5www1BhPLiBlIjZyBXT+B/XQGNqVayspNmDsrDrnxsnhj1vRuHbNW8JnWYvT5+23x6k13ZN7sRsN2j2X6rlzV/MlSNqhxuTlx6nlfWZS4z+kAWBgv4f9K0plzvUtFHqZUhJSjWXo9zkEyxowJYMlACa0xqNMGrBrFUatXTSlvOHRWXPzbn2QhZEx5d5tjX3DaZXHhd/+Wsc5dSU1IaQ07HrJtfO1Pn4u+/ftmjo/xtDe1fsGcuj+SeqdKA8CI2Kuz3h4Ry43YKOqqdSRNSYX3NnusFN885ciMQbZGdl/vsLjugnuipcrdIfIyYtnBccmjpy/xe6kQ9KL9a19Wo0UNkG685RAnfYGpNubGW7iXs8jJwBLnc4alb8ij5YQYH86VdCWOMvAlVQGj1xVJc1xanJn6ESt+QSR0ReSeYlVdj6PSVcaQWJciXZ5JVMy+FOoX5alUcAlE0Q8YfCAzD7roGddJldl0s7FlizB9xtV3NLXMigWt0zP3pk/d0OhTX75WAHhFWiAknlh5Ztwx8cmqVHZXkjM3+kxsPnLNRW3rRCtKo2fGHJvu+dg8efG9gLL60stQdlCY0x5LiSXDYlGCwq28ReCI8S9d1JWKcgiAKfQNIFnslGC+5UufhoaYPf71GN06O/bbct14c/DE+MHL/4z6BCZJaWJ+XSEDk+TNWVPigmnPxHM7Lhc//tPZGXDjYeb7UjIOlDTF4x4xpxSCBGe/p+w7EpsWU6BlRf75UpiMhwuw8oAZCW1q0tGLQv4UnXCWUCuGDPsBZFOClBpQI1+O8sOE+q5SMDl1/tw46N+XxpvdBJOkCCTV18XCj+8c9autkIVcN1x7s5qBSaKydNqENmMjxzYVPgGz5Zpy56Uz53qXCrBejqFM1/PMGAbMM4ZajqJ8KHNjDh6/7k8x551xVWEf3nrg6vjzL36YpURgobsLJq/8+bVx8XevirosGNa1O0ss1h1X3Bff3vPH8d749zJjKrQIyMgnTWASKJA/yHhJNwCu5PG9NeXRmoDJJMd//aAs/GveMNnNCwHJ2hnqTCpcHnCzPoxFT4/3k9uN0bLO6AnjzeH2rNhKaw8YEs2QGyh0W1qABixyNtOpOUAkJg2j6R6xmAASXdPVNVEKPBAN9GU5Z6wjcd/0nKgKvdodoZ89C91JT3tWrCc9IeybTiDLi/xjDj9HhL0RCZKShGWmC9geDpMUI+BcyPriiy+K7fdeNp6fe1rc8Maece3rO8RNb+4TN725b/zr9Q/H9a/vFg+89/UYP/u2aH2/75T9i6xgA+mxF2a9VVMwaae/PPud7JlFc0pbRLFDHBOEhWiXFKxedrJ20gsoKwjGh/FsD1ASuTwUD3Ak75J3RnhonQl5k5THyLukBNNxiKVs6JiVV4hP3nNB/GHc3W2btLPVtsClM0jHjoxLh0+Ou6e0sYOlwkAICSi+EUKkvClPipOyklMpPN1eCIkXyNjkc/5sYpta6NRP3i5AaAwoAd464ww8MSSMCMFkYkCMi0pxrIDrVzIK7uvE+/8db8+eES09DHNlJ5xEMVb+1nFxypk/jYH9axfOJMDqvvvul6UYMLCYwFSBWO7YxVIBKI0zsNcZGb3UcjHhrbnx8N0vxuMPvBIT3pm22LxiCRlNRoixYqzNDRH6HT5saFx55hdjnaUbFjFoXRGV4oVia7x252Wx0sAF2f1jSIBWTkRX5c4r748/fKPt/O6eSLG1GM/c80Lst+ZhmWPH6Fqr1qb7A2zsDb9PTpO9jxUbsUz/mDzr1aoXHxjb1n6TYubsKRlgwB5j4B5+9KHF9EgtpP+A8owXECn0DDwIS1t7XRVry3gaO2w4xs0aE261FukKEQ/OuVQDBSGVeqtyjgEswD8Jncfp9D1AnLC5MK6wM2e1u0JXydnkVGAvu0NWeFZOAfDWHcGOCnMDhkCzZ+MAScdAAiAMpBuV3jcWE6vqfQCf8aKXpVCwMVKKAM7JTffGjW9+JO5794QYP/ummNf8QdeHJPNbJsW7c26PByd8LW54Y494acrfF7V2w5iSOc3zo5aiS8bspnnZ2iD5wx+Izg2ezXNJ46JfgOdeqY30AsoKQhl1lEdJhGSFkBkXzAFjwxjL5yuXqM74kGSMKANeoYpnADb1BSyVt957J97ebfV4atr4bvt7QFZLsTW+9NAVccd7Ly7xd8YBWEg5YsaA0sKUYRYBHaESVYZ+DwyW84S9hxfIKFC4gCjjQ7ljfCj+VAzCU5cjhHWg+IXbgUg5UECGBGoMg3FWBCFkzihI+GbU8u1t/vX6C3HTmy/1GEwmkSe4sC7ihw/dHAOG9K/KNSt+VyFi4OD+WeEHIM8AJlYYWwjc9DSP8pUX3o1fnnx1HLrj6TH52eViwNyN4/ufvzC+fexf4pN7/Dw+vu2P45SvXBpXXvzvLDQESJk7zpF5ZLQZYvMlteP0006LC0/7UqzS+lq0zm9rVt9evm/+77PefSXG33pu/OoHX8pYcYZNmod0B+vDOHSGFSfTJkyPs477fdePFGwHVA6eOzLOPfUv2VrEngHXxoLDl/ZwCi8CdYy3df+NH+vz2vUwZsV7iWIsbJkXdzzWdsa9vFZ6xT09Oe7hHh0b2JEAxquu13YiTV5UdAPX9IV9Ln1Ciktnmshbo8ZQxCG1F0uFeq6HcZMCBDh6Tv/mQJY7NrZUOPTWUWl0hBNPnwBhAIbvB6o4SumUr0r3SsqFRn3WvEsT6o4I5XsmAC+vwzoj7kshKCffdYjxMo4AOTAJ7ErBEjHDhBpv0R9OOcKA/rWPOUrC+vS2cWpqnR0PvXdiPPDeV2Pu+yCyGJWdlmJ2LmfEgpap8fT0H8X+X50fF112brZvSLU7YpS7A6DSeiT5A0XYY4QPFtY8m/+sJ2av1Ex6AWU7AlBqydAeI5cqC4UysGcEs8TzRvunfMRyDCXWjVdJsWAeAIlyysX3z9l+9Zg5qL7bYdxF13r/el9/+O8xcd4HJ9bIAQUa5ethBih2rADBKPLI5aIIqwqDptwmvy/t/2cchADllgJ/gAGjYEyEVVIVZvKaMXDSBYRjjIkG0sJdAA3xU76n+wYuFYgYV22dgHlA1XV/+ugdVVdfwOk1rz0fwzZaOuobahfO1Eh55bWXzf4NsDCAnpnSF34S1mIw5f6UE2OImSgX9n737anxrWP+FJ8/6Oy4+erHYtqU8r3w5syeHw/c8UL86af3xI7rfiE2WW+HDCSl83FVXQNR1rwxxwpYN7PefTne/PfZ8Z1Dtokt11kxWpoWlL3+4H6N0TzxxXj+6l/Eh5driWcffygDjslg+y5Ml9QI4JITojijUu++JOedeHHMm6U6Pqoq53zxL7HbLrtlp52k9BDrL91v0gucIfuWs3PwYfvHF79fnVYk2fWLxXhz5p3x4Z0+6BwhtxmA/fv1l9bUYLv2WpssyY4DeQmc0BP2rLw7zmJ7z5JOr1GAJxfS5zBrmndbV1hKYe10UgzgCjiVO+qxnAiNi/ZUOhXMdXyX62II5ckD6e7b5yqOQxlAmQ5soDNTe7KuCDsA9Lk2UFkKgjuqPhcpUjBo/POCmDAvQKVIl/dKQUKM0OtslX8rcKKjOUrmJGsb1zw97hp/TIyfk9q4dbVtXcSG2w2OiUNOj3nNbSlfI/pUPkWoGtJcbI2mWcV4+JHHsj1qXpKwKdYVEInJxV6K/PRK7aQXUHYAKIVfU6ivnGBqKBRKCauUQj9YSkoDqMwD0sRuMMSMKc8em5laUKRK1bzc+urTMWT3TRdVI/dU3M3cpoXxvceuye4NIKRoKSKeNw+W0k+AMgnl5/eYA2NC8cuzBDDTSTyKFHiEBIMITAozUJ6MDkMoqT3lyfk+Shkz6l542UC2vJ5UuGNsgEoeJoaMAceKpEIKIOtTp3wv3pozsybZOjbJX6c+WNPiBze+2gZtRVr5fpHCgVhchkGeECbSHJSmHlTKo7zxH4/Gcfv/Op5+rG0Nl54AUiqt7/+9b/2Q+MbRf4pf//iqDNTKacUQy3X1vbx/oU6stbDdZZddGgfsslV8cvsV44kLvxvf+9iG8ZsvHxBnfWG/OGyLZeLJS38Yd5z9xWh944G47bq/Zwas9BSqtD8AaUY/tTqR+8QAljO60yfNiNsuuWfRfVdTGoqNMbZh5SzkmtIw5OwC9gQoIfZxHvTsss/G8ZmvdcyotScwjLSAp966Js7+40+yHGtr3v6w3jlfdz9yWwwd9UEedLXFmhq71uJzxLlRaYw1Twwttk+Ik85TLJIXupFe5Fhqd0OkC3AwhUelUgCVqccqB5EOlTpUKVpTSRROAVj5sHc5wZ7RXVhRTq/vwuYBHnnnpaPqcOuTfkvsWFclHS3LeUoh4o4EC8yZN15e6T4RH5hIa4QjZm3KJ+TkYGU5m/SsdAldAsyLlCJsLd3/hS8eHxfds1fMXPjyItaxO1KoK8bc5nfj7neOjebWubHO0BWyU21qKRf/4fFYafPPxwYf/lJcfu0jMXP2/Czyx2Hg/Fhv6gZE3nqlttILKNsR1aykvbA3BcroA5Q2sopQwoOnqAABG7jU26W8eN+S+ilVyoXSLdfk+9fj7ohilQ0mcHr3xFfiV1ddnIXyeOqMVbo/IRKGq1wYiwIT7gb6gBvhaHlvnlcOIKMraZzIz8E88MKFaNL1U+I4hhMg5T1TbkAjkEkSoMznEMrPUeUJUDFumEkAdNj2m0exRvlkRn766sOzdIFaycjRw2LV9Zcv24CcY8IQCA9iBc0JNg9rqVApGb7SPMq/nX9PnPWDf8TCBc1dBlzZJYsRKwzfIpYf/KFFZ2ULIXEazKu1Lt8N25wapMtXamxsiD123Da2WnfFePOZ++O07345mue19cSzlzgfHQnGn1FU4e85fZ/9WMrQ3nzBnV1id7o0BlGMMc0rZiyONSmdQJ6ZHCyMrT2AFQH4pYAAGIw8PXDoZ3aOJ968KppbFnQ5pxKQHDZiUAxbdVL0H9GW8uG7sfb2iTGxP48+5lPx9Dt6A9bi+YsxdeE7celVFyz2W46APVzadcD/AULzBIADwJhmY4HJAxTNndQNusE1rFNhbi3E7Ht51/Y1lrI7AuAqzkmFOR0JRwnIACzdt3VMv8gZd//thbwJfW0tdKeFUBL7hu3gnJX2Cy4nHGtsuPxLz6koFDBEfpgbP6WrcIDYHnsVYKQXOH50tegHJy2xq9bupbecEMPHzu0RmEwiRD676a14ZPxP471HX1nsNJtqS9GlpzRGoa4+Cn2Gxm8vuCP2PeacOPHU82PX3XbPbJs5dnKSNKleqa30Asp2hCERNqgEKCkcgJIiBQqFFmza5CHL57CQMXeUAMOXKgMpYN5Tvt1GOoYx7xm/OGNCvLRg2qKK7apKa2v89M6rMuDGeOdPwsEgUqoYL+F5ConilJMD/Mqj9FyUMaUF6DB62Emhe+EtrA0lWZZZeh/0AN48aGCJcQFsha6I+8JS5KvR8wK4Gl9s73p77rxkj8kqSv3gAbHNYZtn1djVFoCgZfjUePfdxY9X8/z5Cm+GDcsDvPPAGQPpEpgZ6xC4T3mUt1//ZPzxF4szzN0R37nssPVi3eV3z75P3hugkM7VzrPuRD4kZgSDDfRi7wBda4sR6+oJJp6fQ6bFivXkWoxE6uP3xO3P1KzQWch3aN2I+Pd1/872JhadMwPYGYsUjrf/MV7Avf0MVApHXnjFL+PMCz8ZH959/ShkhXGVWS/g1d8aGupij49tFmde8Mm4+oYL46ijjspAvGsCH/Yi/ZJOh3lr7rPRUmypaq/F9PSzBryVtfBJ7KzUByDEfs+f9Z69u1DInGN73RyZNyDcejFunErgy/s8g+taD/Y+p0Qhn3ntaSsXugNw7UoYWpjUfGHbgV3hYvfWma4J1oO12dlTqsoJcsGewdiWy0tPQq8ClEA64KztlwgRZxO4lAaEyZcSUXqqmXG1ftgX98qp4wApPj3tF1+LhuXuy9Zo9aQ13ll4Tdx47plRaKnNBuVHFV/qF9Gc7lvEKqKpuTWGLLtFjFjtgPjFr87N8idFVnql9tILKDuQ9gpzhG3kAqXQA4UoR0NuX1LwFDAjilmQSC/8QwCvUuVpwwslUhxJrn/7mSjUKvG+ri4Gb7teLLXMMhlQcY+UkmpvOUUAG+DLq6XwPJffMxQUE1AIMPKWfV4ujhAlEE5Je2EeeP3YS7l3SRJDiSVIRToUHe85gezE0HUkza2t8erMrldbdlXWOGjdqhtuS6Cxf0Pc9tQ1GZim5Dkf8kixYeWeP1WvYgM5MACdNQhcA+A3/fv2+PUp19CvVbrHQgzvs3b88Ds/y+ZIyJNjYZ6FDDGVwJWx0dLJTyyT+QMkhJ6ERYGG7op+o55XuoT96HpA3PMPvlQDMPWBuPSHNt0pAxqAHTAHRIpKAE32rOfEGns+4TWA077xt403XS++87ND46IbvxEHHbN9zJg3Plpamxb7jpZiUzQVpsSL790aZ150ZJaD+Y9r/paBIntRWJXDZ9w5coAHZxfg2f0ju8S4OfdWtadeXX0hYvisWGn9pbOxpcOI6ANwCXCVCr1gjwOdxkEI2U/pMflWLqIQmGasGZZVuFu/yEr9E7sq0hEwut2pOgeuhIjpX3pcxIZwliutMXl51kFPWEqOErtgbEVs8t9lXKULpaMN6QXrwvoS5ua4ISkA6c46a+bD90kfwh6/veCqmqTzFFsL8duLD419V9y2JmFvl2x9pnz3DfvhnYmz4tp7Z8bBh30626+9UnvpBZSdAJSMaDmWDSuEPUtHLVrEZ5xxRmbwUtscBp6yoZTky2AxSbl2H65DsaZTcySXX3L3jT0uxGlP6vo0xDUP3J6BRPen0CY9k7w5YWVAEuvFe2bEhBCwT6XMIUWIvQCKsQTyJYEkBlhoxrXlXjE0AKWwZmK30qkLwod5hq4zgNK53NWq7G5Pbn3ojnhp9sNVPTHHbZ/422Pi5dfGZTlQqToT+2vNtff8iXUQRhQqFIZllO67/q2YP29hVZm7+rq6eP2JQhxyyKGZ0QMEhNQ4ENa8cCHQZc7sF2tGbi7QQHoKKAlHQ86x71b49ftzzo1ZU9sv2KmGnPrtH2egzn6wt4FHY6DynSEHRPIsbTkZtcyQ+NQXd4/R602P56ZdHE++d2H86V9fivnDHowJhRvisTf+Gq9PfjBeeW1cto8wd9hnYCH1ULS3jCOGmo7wU/71hKaXo2nA9KqEvrXK6je0X0wf8HaMXmZslqYgJJr6TXKa8ydnYX/k9BkDeYDeLxcboMsDI8CHw4NFV4jHOUj6ptr62j7obNi7nAAfnKCkq7HsAGZp9IiYdzpN6k2lvq6dEXvenAN6xtmYA8eiQVhqa54+ENVK1crY3544EnTLz395Wux6kILD6hd3yaec0nx/HLzCRtGvrnqdD4il3jquX8TEytdtbS1GXX2fmFG3Xkyf2XEHgl7pufQCyk4oKMza8+OejZlNk2PGwokxv6XtqCdhR6Gw/GkHwj2MqJAgT9JnhXcoHsng2jOQcgAVmBQW4tXzfHmkswY3VDkUsaTsftQhGbvg/njbwC5FxgtmPFWtM2qlFYWlwqAwcEARpQwAABxADgUtZ9RPLAvWw/WMkbFgXIRxhMqNa7mQb6nw1rFD993bfkudasnlf7089jv2Q7H+VqtleW7VkD2P3Da23XujrJIeoPTMQv/YICIfqqPekoxKqgD/8he+GaMGrVH1imfK+Z03p8RKo9fPWDPARu4rAfIUiaSCjHQ8YWodkgeU1WAThfOyfqRPdL5JdU9k9dXXzNhY6xl7ZX/IW+NgdZX5wDSJarw36a14/KkHY/kVR2fr37U4WKIeWF7fI6zPGTOv9oYwt/VAJwE3QLs95P/v9HkyZsWkLj9blirbpyGKgwdG64ghUVhqRMyp7xdDF24T7zy6dEx5btlYbtD28bmjv5WFhLHCRNGUKAtQgjkFKoFGgAezB2BaFxxHFbbp9Bq6AZhMerDagu2jQ3sCKJMkZ866xv5x3oSZS3MdRZ7YgMRodlXsCfMtfUgqAdbfeJpbhU50nDXHtohgVFOmzH8iWmNh1E5ao6nlufjMcm051tWQzG9aUIjWexZvbl9O5FbOmrswfnHerVX7/l6pLL2Asp1NPn7uuJi16lPxhat3iKtbvh2/efGo+O1LR8fPXzg4znr+iFjxwAWx05EbLhHCEp6ifLELFBBWA5uD0UvtckoZSt+HdWBEKCyfp3zrB1YnFFRRWovx8SMPy9gkwE8YRNK/EGMK46Rm7e0JhkxIUPiT0Uwin0fSvbw7XjWmR7sQ+ZnYT4AR8+J7jRuljZ1jYBkoSpVCp6xdO53zrGoRAKf099x512hduPgc1EKOOeTQ+PZ3vh0nX3R8rLP5Kj1gB9pA1S4HbRmfP+2Qxf6i8tkaSRXE8tI8YzozviNZeRknPNWGrQWib7r6iSzcjoGSr2WNAIuYKkUKBMAozWHzHsC40glS7Ym1gK3nbFiLgJSw7yc+eWT8T0i/AR84jJ4bsExz31VAKTWEc4mZE763jlPenMIVusL6d337UDoIdsqeSQAe8JCfDeRwzjClU6dNjnNvOjn2+0xb/nFHayADkn0bI0YMjRg6OKJvY5kc5EJMnjArxgxdN6a8ODJ23eCr8cqzUzOm0XNz/LB49ikHIlVlA/yeDTgGLOX9CZN7DsV51TimsT3BGmPtOT49keT8YFWBfPmKdBYwrBAwtUuTGoRFpKPotc4IJwKwTsWcdKRx8l2KHY2v6nFpSAgGdoE9qfZxgdMXPB+FGsKAQjTEW5Meii/udES8+deuH1hQFky2RLRcNyJiQV2nneHb7hsXDzxe/kCPXqme9J7lXUbenvt8/Pvd38WE+a9GXdRHa4XGrq3NrVHXUBf964fEDksfHpsO33PR8XxAFQNI2chzk7eCXUhgi8LDOlAsfq8PpVChtg+8VQyEsPJ6V59a0+piR1d9a/3d4hOrLckYYEaE2rAkDJjQZgpN54VBEX7xjHLmSsN/iirkRgLKqQ8YQICxAihTjpLwuPEyDjz+vHJ2TSwRA+WFIcr/+wtP3h4vzZvRlpRYI3nr+JOjde68DOBtuslmMXz+KvHWY7OirlDIlFZnxO01tzbHnkdvEV/60acqGlcMHGAmTwq4ZKywmEA75rg06T7JV448N5574s2anVNbjOa45qGTY//991tUYS78C1gwsnLoFFgBTsJ3idU218CPHERMSxKOlVCh9AjrKP8z/Vu4NQkQBYTJzwUYBj21bPRtrW3T+dNu/05s9qG289WBPWkfUji8MPid7ZOYxL72bJwr4wZUWNuuxalL56crWDNu+esLu9trHDChZ/tCnp17SudKP/Pgy/G7714Rrz7rEITWJQBDdrTo4AERffu05Vx0cq24L+tqZtPrcejntonPHHt02dxHaxaTBoQRRXMcwf8poT/kaWJEUzpSdwSIx7Ia87TfrFfrWs4w5lA4XFGRtQgEcrLSoQ2l4j3WP6AInMqVNsecbnZBlMF4SvvhSACT9jvAqQq9O0c9diQPT/hevD37hqpUd5eVYsQLjyyIHxz5UvZMn7rge3HR67dkdqerRzJmZnBhIVr+NbzdUHclZ3jT9VeIs046sIsP0CtdkV5AmRNM4+0TL4wHp/wjU8Jd3WTLD1g39lvu6zHh9emZ0RTaErrIn3UrlC1xn9fJgPBKMRG8agwcRhNTweP1t+2u/1lMWdAWYq+V/GyzA2Lv5dvYj1JxD0JW2AfGTthaOD+doe2cbUrb3yjyVP1JeSoqAQgoXmEcSply9Dsedz7szzB6+ZxQKWCSjJG2McYkD1QpdgAVGJWvOnnT1WPIbtvVrNJ7+UFD47x1P5w9Y3oBTvULBsTqg7aMUX2Xz9rDMLilzaYVOSS7vc1eG8X1j10c0+ZOzNiuSmkEDJVxSiffJPChaMBcKGRQ2JD/vPHcb8tTY+GC2rK1y20yLf584e+y+RBuVeVqPhRYMa6AjaIdeyAVcmDVrH0MtPtPgNEaybOZ1lVyFvzM/1tunKIO+Wq+0zrZaemPxMK32063qYW0Rms0bzc5brn1lgzYcQI5QYCA0L6921URxgS4zBd23pxyLAA2L//2Nwxg6k9L/A344KhisYw3MAmkAOt58d4Xn3gjrr/47rjr+odi3rTmzNnNwOSwwRE9aNLPOK+0+jJxxh+PjsFDP3BsACTrEqjiGCtOsmbNPbayXN/RWoi1aI1hRQG/7krqFUxP59M3CD3llBzRBHNgLwL/2GJ6ITl0ogqcbKRBOlecQwpAeunQUC7/Vg4lXWsPYUJFrKoxfu5bGkJ6Teh/drQMeraWfni89kxTnPjxcdlz0P+PT305fvLcZTFpwYxMUxY7ASSzApyX+0brXUMj5nefUb387E/H2NFttqtXqi+9gPJ9aW5tiivfPDVem/N4t4susJmNxf7xx6Puj5jdP1MWvFEKVaV0YiYBJAyczY3JASS9N4mkdonXQMsxd14Q905+NTsGsFZy/S4nxMqDF28DkkTelv5dQDAAhKXkRQs7Ar+p8pUnj1EEgrywTvl8OYwLZYqdkRsKBGJYePWYOCHTdKQfZcpoJkaIYtXGA1OAuQUi/V34CQDxvYNXXTH6f/2omowPb/rrm+wQx6+/OIvL6FP05uniP10eLz70Tgzvu0wMrl8qGuv6ZEalvm8hRq0wKNbZbNU46Li9YpU1V8zCt9hcLGQlgwekMzwplzKJtcSIyTkFsl0DewHsTJk0Kw7f+YyotTw34Zr4xveOzZhCRpGDYe4wbZhsua1Y9nLnJUv7sJ7KAUYv6yQvDDI2B1uUitUUq2C8gKsHr3k8Tj+y+swNEX1YfcuV4twH2qq25Qe6Pw6WdQpkAApdFWsdI2ntCnfbJ9gbQMTYua48QEAkzzRrfQKwAxZynBOYBN46kiceezJO+OyXI6avGYP62es9QxCcpNXXHhs/v+Az0dLanKU+SMuwDv1UnINN5jTY79qQmcNaMeelgi03th01OW9PhO3pYs5tpSp0Oom+ohe9jy7yOf+m+60Tel46iL3ivqQudDQO1gQ7wXGSh84hrwQKy70A23K/L+0r/OVfrBjb7D0s6lX210iefXBOzHpiv+w5ksxrWRA3v/tY/P2tu+ONuW1pMHVR98HBC4U2EJm1Bnq1b7Q+MzDinZ4X9px4/O7xkZ3Lkye90nPpBZTvb96r3j49xs28r8cVvMLgC2YV49jVfxv9CoMz0KSCWsGFxrMKV9IxXxQvY1wqwIKwiXyzXz91S1w57YXa9KGMiIENfeOhj3wrC9sueobW1qx9EGOAXeR9C3UDEJhFQCGfn8TDzoOD0pC0zzE0vFNASmEOIMnIyC0FMrE0ecFw+RtWitLGOMjBw2ZhY7BdlLxwsBCg937+sZvj8UnvVL3iu6FQFw8ceHyM6j+w4nuEo7BOni0dQyckipkBFNIJHNgt4TisHecCA1muQEGOnWT/Sqc7yEcDLrB1rgnk7Lrj3nH0R34ZtZb5A56J8VOezVjT0pyx1E7HvNtXjKt/CxO6x+QUtCfWFvYPAOE8MM4ANhAJsGIHF713QVMcPOYzMXt6bVj8M276fjzw4j2ZYwM0cKQAWwUp7iflunZWAG2fwX4BXImd5SSko1uBDU5HHiimdBlr3vjSIQpP5N51Vs498/r4x0VtYeiqSCFi8x3HxmX/+nmmJ4yROU7OcxJrVIoL5wjj9z8h9iMQRmeUsovVBJRJONsKllIxkDmUh269cnxKuzV0BApTuyCgWKoLfVoJFCYRreBstPcyN34iNOTrzuh/TWz+kaZoqEGVN9HT/L5r58bJxz6SPUep0BFvz5scL858O/7+0EPx7Ovjs2blxbl1ERMbozipsdO5kh1JQ31dfHTXDeJrn9mlKtfrlSWla12G/z+Vp2fcFi/MvLdqrMaA4XXx8MIr4mPLfzsDk6nykRKhYBhK7J7+jULb+dYZlFdqxyOn5pUp78UKv/l81EKcvtPy6Etxwg2fz0LX+dy1PGBk+IRzMGKSxilZ7wGQCTZFeCsVZVQSTCxwin2lGIEq10kn42T3VCxmxhRw9b0ACOUMuDC+7gEbip0Ujpfkr+CHMj1p851jv+sWZ/SqIV/acNt2wSTxTATwZgzcM9bGTwBdVWxpuNzzYKYBBKDYC9gEmKVLtFfhDpxbR0KMjLh1tNYa68eKffeJWsuIEcNis+32zYAiA6UqnTB6WtnkRR6YMLd5ktaR2mmVijECrj0TUG59YLY8m/xb31VO+vRtjAO/vk/85fuXVbUWqa6+LlZad/nYaKf1YuOd1190tB1xFr1125WCHHMu/Iu1wk6KTADWnLG2huYfqGLznweT1taBBx64yHGzb7oKJsc983b84+IqgklSjHjo1rdilRXWyYB/adg9ifkT7gU4OQbtretqCd1Jh8njpGu7I+2dlJOOO5QfLlrCweM000/2rs8AmcLv5gowzANGeq2cAHoJkAPDKaeeY61lUyWA6NURcMZ+y+cHlLH+dOrRX9kuGhq6fhZ5V1oHbbHBfmXBZPb3QiGWH7BU9rrr5bejeN/smrXJa25pjTfH175f8X+z/NczlHOaZ8Q5L306Fra25exVU6bfuEz89ruXZmCN8reZGU6MXWqj4/dyfRhT+WG8RopQHhWgCWQ8snb/GLrFWjXptfjqCb+Jhe9MyUJ5QpGKZhKzmJhGhk9lJ8Dp/9hL9+U5MDaAIoUK1GBdKdVy4rkYY3logIUwNgVK6Xt+RsnL9zCe8sQoVW2YjBejDKRhd4yjVjXy0TB8Sen/7LG74rdP3V+dpt4trdE6YXJcsO0+seMOH2r3rcbN3KU5BITaq8pOrZKEq7WeMjZAZv4zgLpnT2Cz9HSSvBib73//pFj4xjrRUN9+e6eeyoU3fj2WHvNBHpJ17T4ZcdX+pQIQYaEZYXl2Uh8YGP9XgABEYjCFgoENzB9Gq7OAqbmpOT636TfjzefHV+1Mb5GKH998Ymy5c9vxq/Ywlokjg6EEUpwK1NExklhoQBLjKlohRQS4xuhxCjgU5t3e0YfQOpaXmlrTWP/2HIbb9wMmAEpXjyf8yTcuj3tv0fKousUXwpJ7HrB5fPGkfdt9n/umX+gMBUQd9e3sqVhb0gI4sHRSeyCrEksoXE5PcaCtWWFka1TkCCBsrwUWRpNu8zlAj67ysofbYxC91/fQjaIw0oGkxVhDiiS7WmTkHukj7DCmmDMi5O6Z7LGlxgyM61/fNTsusVay6/JXx+A+HziEQHYC2PnQ/D9ufyfengTc1i78vsFaY+OcHx9as+v/t8t/PaC8d9IVcefEi6rarJowbBNemBNLPb9TpliwG5g3QMKGTm0nUp4Z5Yf9kzcDSEhsV7iDjfvbnTfFgBMPiOZqVnsXi7HniNXj5E3bioQUDjFsWAYAV2gqhXlsdiFnjKQiAuBAMYL3A4+UMpYQiMKwAplYK151qWj7ohFwqhgFlOQhUryMDSXq5Xu8MH5AF1DLAPub9+uNCbzJKaSoXRMT8vqbb8RO5/40+m24Zo8qvusLhRjWp1/0v/iGePDGtrzOPJOaF8aFMTAOKdcU0AWeOhJAAltgPIVyrQetgoRXgRVgLIHMPJOJHTMnxk2IHQDxvQPnbxLD+i9fs1w1Peu22KdPVv0P+AAGQJaqaywxx6Icm+i5GEPOiB6kDAkgmZ7bfAKSAFZ37v21p9+IL2z9nZg/d8ESRVHdkQlDXo/W5eZlRjwBeYBZTptuBIllT8VpebG2rVcgwBrFMmGSPWOeiQSYPTuABTRiPe0ZziSDS1dY/35vbwh1AuxdPZN42pTZcfguP60a2C6VPn0b4rLbT4yBg/p1CK7pOGkc5VJ9uiuVQCGdZm1idyvlF7bHFNJ/9hdwZ+xdC6uX8oCtVc6stZ8HhfSg3sMKzjgOdL89br6tCex0e2tcvi6nmZ5jF0QysPscbQ5YaUpBOaEXXQMb6Tr0tP0FSJY6Iw9N+HaMn31z1UFlS3Mx3n25T1z7y6GLjXnKGy6VNbc4PEaO3WBRp5RayOYbrthb6V1D+a8GlK3Flvjti0fHrOa2nMZayEcHfS+euPPFDPCQBA4oIawOQyvPTkiZ0cCEyE3TIJwRwuhRaiscsXvM3GblqgAFoe7mabNi12eb4lc//XmmPNMZ0ELXWEJghWLTEoZSAwbcM5ZEfhKWBPjNCzZF+yMsos/7NwWWWuNQcnIdPRcjQFKyOqBISafwNk9dXuWRR34idt1+r5j85qxoaOkXDfWNcchhB8em22wQq663XDw17tE453fnZAUMjDtQU9fYEK377Rh9N123U1WE5Ypwlhs0NC7Z/ZAY3XdAVqkPBAnfevZ8I3uCfZIPSjABHAXzV64opVQwBqqigfR0LCfgLv/SGDNKgLviKNdL7EjZ+66riw1W2TWW6b9pTbz87JjIIbPinmcvWuRkeG7HAErfwCh7FmCqtB2SIi2gPOUcqviXJ8vIYfu62nqnVDgye22zTxSeHJwl93cHVCYn5/DvfSy2OmyjzLEDjoE4DD6j7F4ZauuzdB4AQA4F0IAVkr4AOFnb5dpDyZk0Jva8NW/tppxUKR+cOr0K7T/7xX10lFZSTpzrfsaJV0Yt5ZSzj4wttl+zw/cBV5wlUQkOSRLPR390VFRS7pXyk0uFs4MNo0Ot1c7kFnpZA/YePSasTYDKVJntvtvrpckB4AjQFXQowWbTe1hPIJRuBBJLBWDkMMq1zx9x6Zrm3mfolnJ2wJiJ5NBBHB/OiT1GB/tcKStsvds3b06+P55ramtYX225/uwhMWv86CXGuNy/r7zh6bjgyvujpUYdG+RQHrDnxvHFTy057r1SHfmvBpQT578e573SBvRqIa0txbjl1+Pirj+9sii3BrAETigXhpj3qP0EY8JIlbJalACgtNPOO8eUndeId0Y19AgrMLXNc+fH2yddEAvemJCFaimhfB4n4EKZYsooZIYtATwKiKIEeCoJ4Ci057pYRYYVaAa0gDFjwXPHVmBnSsWYbLD2xvHdz54Rz975VsyY0mYwtHFKDE9LcxvbstTY4bHPMR+ONbceE5//4ucWtdnBIhx/7i/j2tbpMadpYZsC7gCMYyXl7xy19qbxzU0+FP0bPgA5nh24xhpS6Ix8EmyscBIGQ74s1g0z5ZnLCSCSclW95GAB8RgMxhETkd+WKqgxWNaB0Lh1xOkg2DOGQ96m6zbW948d1/5SFAq1CSn+4qJjY411l80MpLw4L8w7cf/mGGjAQnGEOBCYSAY6tYYCHq13wLM7AKlUgBH5ZQDXOT89N/7wxYtjYHR8ikZeRChaii3Rb4PW+N01v8rYYMZd2xaOjogBkJCO5PO31F/RHhFNABI8P0cLkJQ72p4DiFFWpJZaciXdQKSFAAXmHnjxbJj47siPv3Vh3H3DuJqFEuWbHv7ZHeOgo7dbDBSWYwWt05S/ZzytkfZAobVSDoR05sUZw+Q7GCE5fJXEnnJfclyBPqwg5xn7bx93NcUAK2pfYLIT+LSnVX3T/YCqVBdrhn5Mf+fEGCvrq9TJcm/WOYczRUuMo4ItBTyubS1aJ0Cv+8eslgPp6d8pV/7TPxwbux86qu0c9yqxk8v03yF2WKFzHRjcx7nnXxOX3/hG1FK+/8W9YvcPlc/17ZWey381oHxq+q1x7fizanb9YksxJj9TjGf/0pQxNFjIfO9F4Cr116O0MBlC4Sl/USWpUKZcSwUoza2t8YPHr42r3nyi28zb0D79Y+vnF8QvvvH9zKjLZaPwJJfnG04TSkfoBoCkcAllRRlW8tBTWC71h6S0CPZV5bPqdd43wMHgyr/Li/E54+u/j9svfTJjIzvTX5DR7tO/IR6dcGPUj5wXk6dMzowVhT587JiIzdaNUXt/OBb2achC/Q3ZvbcpTs11gci+dfWx/6rrxifW2jTWGbF02e/BFlHoQC0ljkkgAAdgAFyZK0n0XnKfyjXsTlX+2ZzU1WXMHjAIGGFBhVkzBXvuuVkxD9CNgeVsmC+GSH9CDHdyBIwbVgvIufbiJ2NU/7WrGjoCGlZfZ9n45cXHLQGSVLOad3PsPhk1Dghj574YSSwJtkRagvHDtHJcvL8nx/C5vpxEgA47aI996xvfit98/by47ne3xNyZ87K+iZUaz3suKnCDndeO3950ZgwaOSADN9ghucHm0XhjXq1784GlMj9AvUpigNmzaGcESAKUk2bPiZteeDmeeee9ePqdCTF93vxsxY0aNDA2GDs6Nhw7OnZdc9VYb801M+DjOQAfQMS1rQUhVy/7yfrqqggxY4Tfe25wjBq0au2a3RdbY/Kcl+Kx1/7WIShMFcbAMmfTmmgPFGKyu3vf5tWalCuIQS8V6RlAmr1Mz1qXdCAdrDIbQJNuYy7yqQqdkdQerhyYzbqKXHVV5nhxPo2BllA+w2nFWkurKAcC6QJ6xL5vL2RP7MHOMINew0YMiMkjfxJNBbqppcdgstDaPz6y+nXRr6FyeN69i+4YC071nLkLY8uP/CAKdbWpFdbJ5Ko/HBejRrQVvfZK9eW/GlDeNuH8eHDyPyqehFMNmfVuUzz3674ZQGR0sX4EUJMjmICZfwNgGA5KkPBeT/3uj+OLn/xKrLPi+jF/zoKoayjEe2vWxTXD34h5xeZOnTaQTiVYZVZ9XHzwV6N/sS5TWAw/cCOcQ7ExPlpflCpwxh/7hIEjcsIYXPmdDJ68uMSyYZ2wmCnfUa4dw8srB0pVejKQnpOhwWaqeiWzZ8yNk486N555oONQcTmGSZjzvfmvxOmXfTV232O3jGlg5LPweqEQG+62Yxz05ROiZeSQmNvcFI2F+lhh8NBYb+ToWH/k6BjY2HGfM6ANqDRe8h+FQgFkY4JZBQzyx2oyiKWtlPItlrC1aRxcQ56d+wYqzE1qkwRAemGuSkPuhMMid1W4a/NNt4oV+u0Vs2ctqFrlc0NDXZzztxNihVUWB9upoTmj7V6tYWkdnglLzOgxbELFe++9dxYKBiZUg/s/ls7aKXVmOiNUFwAvX5VDpIMCcG89Y5EXzFsQd15xf9x/7SPxwoMvxeRchWf/wf1ijU1XjQ0/vG7scfROGZA0V7oxKLwwp8C7gg7zZOyzU2JmzswMMJDAgbC2/E0LJ0zTy5OmxNl3PRA3Pv9S5qjY3y05JzIby7q6zDnsB6S8Oi6evfyiaJk1M5t76Q0pVcLashbyYNIzC5Ezxl7Ab/7fXsCRMbVWsZ+brnhYxMLyVbbVEPc0fEwhdj901bJMYjlQKCqjVyVAB8DVSjgbnAJFa6kyO4FIzod745i5B7oq3zwcK90VQGnvp+IdL3sCWQAklmMJ7W/OhN9VMsP2URrPlNOJNfV+61PExN6iO0rHvaNWR6Uyp+mduHP8UbGgZWq38ym1CVowL2KvNf4aw/svmQLhua1NIBKYtJbtWTrV67q7xsf1tz9T9bB3fV0htttitfjxN9ovHuuVnsl/NaC86d1z49Gp19cUUA5qGBlfWvOCxUIaPFEhUpXTSYSKgDavq678R9x68V1x8el/i6lvTc/+Xt9Qvyhi29LcEs2D6mPBXkvF/H2Xjrl9dX/FiLa0EW9FzEt9FAttXtkuY9aKydfeH//6zZ8zY6UQQAgXA8ow2thYGNWrNrXKwtRgmpLkraeEekDQPQKPlLEwLAPMcAI7QKSkc4AyL0Bman6cvGqfxVxhQOfMnBffPOCseP2Fd3tWPFCI2PRDa8f3/3JsHHzIQVkYS+jHPfk37144CLA1/nmla34o93LH/6WfwHNe8g3qgSSVvFmj9cGDM3CVcrIqCQAgHIzJsCbSuc5A0Ze//OVsftprs8LYGT+ABuPMKeCcPPXwa/Ht487PxrIazNRnv7V37Hf41ouNlec1pyn3k5PCyTDewLa/yQ1lQICvdKIOwexZc5odW1vGKn8qTGdE8QOmW0EYcJKO3PN9wGqpzJszPxbMXRANjQ0xcOiSIEcag7Cz3EZOEIYS46uIzvNa+/6N+fZZax2b7Duvve66uPDhJ+JXd9zfFj7vpEG0Z1ubm2Liv/4ec595YjFnRJjV9+RBo1c+ylFJfA6gt/5WGrJb9C98kKJRG4by5fjpecd1ukWP8aRrpKjID67UGaKnAriq9LYn6Dm6SpqI/Ypptgbz7XbclzGmB+hBzCH2O4Xmy4WN079TIVWp0I2V8jX9m64AXjmpgCu9xLGX+2nuOUuKazhjnLe0p1LLtGrK3Ob34sH3vh5T53f99BxI4u2X58emo06P7Tb7ALiJrADwQGRKJ1DQZP7NAZ2Z5NU3J8cnv3p+dq1qy+9/clist2Zt1lmvtMl/NaC89b0/x0NT/ulwtZp9x9S35saFRz6dGSsvw21T8SwpuvR7L2zN0fseF1sP3Snmz3q/D2QHs1NorIuFK/aNfjuNiKdaX4lho0dlO3vsgGHx3U8dHxsMHxsj+g7M2EUKSj6kPC2bmldrMwMvjD+PmqKi3Bl4f2ewKVVgTN4c1jRVpFJ+6ag47AoD3NGpHQw2FojhpEyxWfIpz/vOtfHQLU9neac9Fca0efiUuPm5v2ahSkCD0eANU8zYYWAIIDYmwHPqiZkPIQFopae5pJ9YZGMijI+F8FnhSsYK6BSSAkZKxXgJmwKQXim8bR6AR2FbwJUxA8raE2wwhg4zKvnfXOUZljtueCpO++Zf3x+Tum4XqUya/1SsuF5DFuLnjDB8nh2rauwYPc/BoUggzTxj44EFQJMwvL/85S+z++RMcKL8NH6MDuPf0TMncR0suQIPc5C+k9FKa7MjYfzzQA1AlCphTBPjB0QCzK6ZF46h+8YwPfP887HC4cdEn1XW6BZ4L7a2ZidhTbvvzpj072sW/d5+NJ++Bzj0s/TfHBphUDl09pHiC9EAwC7dy29/9M+44apHFuUdV10KxXh1wn3x8sQ7M4dR/nR7RStJ7DmgGUiX+tCZz3RGzF1KuZFSYx6BNqkV9rsxBf4qgcP8UaB5AeY6Ch3n/21+hL2FtFPP3nIi9G4MOFn0lPA8nSByY4/JO+Zscb45SpxgQFJ6DLBL71RTpkyZFJ8/efP42PEjor4x6YHK79d8pKWlGDdcOCPqJn4o/vTH8zMWFRNsPyrAMrfWJhCJoCjnQLAJKvN/d9EdsezqO1YtRQOpsv8eG8VXPt29fqS90nn5rwaU2Ml/v2uj12gIihF9pi8dC+5YJQMZXsK+mBqbpXTo14gNY4XC6lnxibPEu/ZVxZgXs+Nnt5wcl//zsswjZGDyQlEBfYykZHXKiDesgARTIP8L4ARsfRaDif2i7BhUAIBQDIy4MKUwPuUm78ezCTGriub5lyoEzB0lCWAIxzEmwt/rjNkiVii2JaZXSzIGberVsfWuG2f37f7dX55BoJgxfBQZVo3n774xgkCjqvb2lJrvALAYMM/lGt7POAlTyoFM7CzAlUCkZwcEjF8KZTN0+VNFMKipQKNUAE5jTFkzWMa+XCsZn//BiT+PjVbcPxrq+nUJVMo7rG+oi813GR3vTH8yyydjJNL4MZbyaVOYldHIn2Djd+6J4fDsCSxIn+A8WXtAOeaSE6MIgVgbwowMZyqEKA3xYmycLMNQC3P7vTnGLCryUWhWyuqVhob9TOfFd0fcO4A9QP7z0NGxcOkxVTkederdt8Xkm9uOHcXcAunlxP3bdwww1o2hBuTyldNpjf7l7Gvjij88WNP+fqtsWozfnf+T7N9Cx3qsdubsaVEROoOD4KSpSu2A2mMG/bSusMrCyKWnN+XFuu0sIKQTFWC5tt93p3emyAEWnuNRbjzMj/3PSZO6oehLuoY1SpdwegFN+raUSaW7jZ/8+0qN/7sjHCqM6fMvPhHz+z8cdzz1yxi81LxoaCxdP3UxpHHl6Dd/q9hzyxNj4dz6LKrinuxn+lWevLWJEW6v3RGdKL+eHvna178Rk1vWiVfenFwx97kroe5lRw+LP595ZPTv1/OjG3ulffmvBpTvzHsx/vLqV2t2faBw26UOjg8tffii31F2NhplQdEoUsDOXPL9f8QzN77Yo+8DRPsM6hNjPjow/nzpnzJwwsAy4Lxr351O4cCEAQeMIu+d0cfcyfdhyJNyJv4vxwiD4++AE6OeFx41ZajtkDyw0jxLgulJvdCwhnKbDjn40Jh0R/9oLPStahGJMNzc1hlRt/Y7scKKS+YuAgTpWEf3RZlTggCNZwRqOjKIcrCMp/QBz40pNDYMj5COsQUghbSBF9+dAKSehuX6dAJYDLIxc/18uNs1OAXC2pSzPD/rpxzoxVphqeTQTZ08Iz68yRHR2Dym7Wzcdra8S/nz5NmvxOCxU2NBy6yMmcbWui/3bb1gHs2h70kgEysrHYKzYhyFCTkpWEfgOYFPRhYY5agkkIdBZxjzjd3LOV2VRK4ZAALAYj3zLF57DF/+/xhSzp71gCHGZmM6rX3/9jcGUx6e+zIe+3/7pDjj1nuimjL7n5fHe489nDkKqe1MEgCKo8DRw7LZX3JnMfFJzId7lE9rn86e3hQ7rFWb07bSXjv/hq/E6Wf+KLsvY8kZA4w4Fe2xgf6NnQSorIkEIv2+UsFJOmLQOsQmWmdJV9nXnDmOlnVonwDddI31VS7/uJKktCDj2V22DIlg32Nu8+dxlx7Z6j49s33DqU99gDlO1qWOIIr86KVU/c2Jot/tO/q7q4VD5YTOsS9FooBY+5KzXKgvxt//9bvYbKt12uxM3bAY0rhqPPboUxn7CoASewl4BCLlpqZT3yqJfcTucJCtGY6IFnUzZs2LE77/13hj/NRug0pgcpmlhsTZpx4SS42sXQ5xr3wg/9WAsrm1Kc4ad1hNTslJMv6KYXHQjp/OQmRYGgqQQvB/LSV4Zrf85e743VfaNmRPxWafE7PiweItizVrp0gBS0oH04QVoMCFnSgsrCOmAygiQBGFBoQKFWGUVCNTagwar72cArOcMJ4AFtAK0GDbgDShGWMA0An7MtBXnHt9/OWH10Wt5GfXfDXW3eKDHJ1K4r5VcSeWwLMBv+69UrsWBl+uEwMI7AHeWFDPyAi5BuWYQCTwmTdMU+bMjbtffj2eeXdCvDBhUsxRiDNpcrzy5OPROGt6rDywX9x6+WXZZ4TwgBlzRPmqEK2krOXJMuTmjqFiFISot99mx/jXlQ/GQ3ePizdemhgLF3yQrwfLDx3ZJ5obpsa4N++JZ8c9tgjMAWkpny/P8jHkioHS83Yk3ueeMY5AAVY2D+qwMUA9sJqxfwMGZEDD/dszwLpnU1VuzQq3p89hNN0PhqO7YkyBdWvfdRl67bGsB+vAM2NcpDVgvJ9+/c1Y6YRvRqEKhnyx8PeC+fHuuWfFoR//2CKW2zjbU9JF6BBAx9pLzJTfYdSAYfebognp5J21ltonJr09v8eMT6m0Fltj4oxxMaP+sQzI2UPuNX9OeTkxxokN5OwCMil/ENNdjjXkKHC+AVARGI4rvcZxSg4v4FUqqvABb5/Nt/vqSFLhUE8AJeFQSXNKx8nSEe4JeJKPa237Ho62VKjS77Lm6V1zC3ACmVKM7CfrnS3BTrd3IlBnhZ4SgmebsKqiNqJVHFnrzZxizkVHhLS9xzOxFfaHe+TkdkasE+uY0+35Af/8EY2z5syPM865Me544KVFjm5nJHVA2XKjleJ7X9wzhg9t/9jcXqme/FcDSnLLe3/M8igBsWpLcXbf+MthT2R5MLxUCoNiAyxsHuzNCcd8KZ790xvRtKCKeZyFiNlLTY5lthqagRBeMgDoJ6UqtwgASmdlVxJKAvPBqFNeksABRAoNg8O4Uv6VmlIDjXIzvRfz4GUMGALfK3dzxmMDY2j9MlFXg9MR6uvrYqcDt4ivnnVklz5nnBgTxpvCxDYCFMKrgFASzw9YmE/5jClMldqVMK75/p5Jnn9vYpx33yPx7+dfzIo3UtVvHlQYbxtzUEtTtD77RDzx97/GJhtvnK0fBrhSGJfylx/KCDLAQJdnSM5MXvo1Do66QmPW4H9B06xFe8B7U2gQKOV0eCbGDLBMvS8ZRiy44hhMah4YAjQcF8wQdi+lFhDvs/YYqHTyD3Yie/ZiMQtdCzW6rpd1hAXB5vi7F/YJiPTy3XJQhYAZqK6KFBBA0rMYN9+PTUrGTc8/hhvQtd6BTO/Z7uvfjUmDR0ShyscIZsVhN/8rVmuam+XhimRggIQ8rUNA13gB5tYdAMm453s5Yq7k2KW83gfvGhc/OKH659yTR16/OKbMeiObd4BISoZ1mLpHYLWNJ7CXwKF1kgdOxjYVywHOScwHhjxVZgNX5gXwUdAh7zgVELYHXDhFpYWQnQWUPTWRqd+oHF/jIc0HELafgDf6ECvYkWBY2QxRDPNrj3h+bKL1KC3FWHdXAHXjCizSX/aWOaIPAWDX59jSB1hLLKR59P2iMOyCCAP90xEAt2btK7YDE1yuiC7JbfeNi9+cf3tMmjI7Yx0rFbyl9mDDhw6Izx2xQ+y547o1a5XVK+Xlvx5QTl3wTvz+5c/WBFDuPuZzsenwvTJjxBsVfkpVvNgviv7ecx6PUYVlq38sWiHi5dGPxatvv9xWWDFp0qLWPhQHoMA4Cq1gHoU3KATgFwDk9WMQEzOEuWTAykk6nxZQALiyopjm5iy/ErDw3aVgxvts/g+POCrqC7XpO0bGrDQq/nz/yd36rHvGsmLAfigOAADRG0lEQVQtGQHjJYzDoGGDUrUv5Q50CllRxj4HlDH6ALRnBfZmzp4TL/UbHO+MGN3mbnci5w645J4vGP9WvHvVpdE0eWL2e+Aiz+75DobTiwgxA3/+hgFgBIAz/wfQ/JvB52BYk+4Vi+x+81WXxHMJrwN0mCUMKUfF7zBoDE57its6wtQKzTKswCEWGxBITBoDlcClqmmfYTA1jRfmw8IAkcKogHpqqu67Pbsxx5wzcgmcdiTCwr4DUEn9CoE3bXfkYSbB0BsrQMcasI/32Gef2PYXf4iFuarsaok5b5o+Ld76zRnR2tqSfaf0EfMjtYRDCGBJN/D/5MTYh8bI8/t96Wkza4/+SCw9ZM2qOW8M+K77bhLbfWS5bLwAJIDvmGOOyUAlvee+Oc+6Prjv0rWVF4cCWFv0lP1jXjDr5tgzKeYAIoGmvGPXGeEYW0OJ8e2MCMUqnOwuoLQmAX4OVXJW7Es613gB30CmNdcVwRAqvKKD7CvMpDQSYBXozOcyd1Y4fKIaGFzgnyMChFtHqU+qPSBv2RzYo8Cj3+n+YU+kfFi6shKwtQ49M4DKQacLkBQdiTPoH3ri9bjhjmfj1rsej0LDgMX+PmLYwFhvjTFZ0/JtN18tOxWnV/7n5b8eUJK7J14Wd026pHqDGnUxut+qcdQqP4u63IklABmAIlyRJVzXDYqtWnerytnDS9xDoRAvtz4TB37zo5lxTqFAwCe1OxFeBC6AEp4uNimFVIU4gEgsHMVI2VMClLz3uz4gStkLNeYlJa/nW6DkWc8ETAf3GRnbjug8Y9C9gYg45+5vZpX8paxeJZYv/28KEOjC8ALIXf76QiEz9CNGj4m6XT4arcNHduuMcaf4qFb8+T67xi7rrLlojBk7zgq2zz0b29Kwk2prRp4BMoeMKgMBxHFssF+YmI5CZsZAVbXz2AFabBMAAwB0JO4P4MPWYC4xEn5aI3Ix868EMlMlOKeGcVOxm29H5Rm8H8g3zvLoUog3sZfSFUqrh1OxhesBQQrVGHnjZ66wJ4wdcX+pHyUAwIAz2m/W9Ymv/eOGqKW8cc7PY+nGuoz5M/aV2tKkfWU+2is26d93cFxz3ssxf25zj/OVgcmRSw+J3//9CzFwcL8sNGqvaM8D7KT74eBYb9IJOJaq0QHDUqFDOAgAqGe1roFP4EU4G6jvTlFMEswncJdSemoFKL0X4yh/1T70LMCsdWjvWa+cKoCNXsZQ5sO8XfkebZCMNT0OwPleRVxsTFeZOXtTMY78R6RDSmPBpLpfLKLnyF/XngYIAVkOmXviEAKIwGWpGH/OIb3KSefAdfU+02lB199wc6y3wabZdw4Z3C+GDVkcYPbK/470AkpGo9gcf3n1azFx/ms9Ziq1vcG4HbvGb2NU37YG5aXCQDJob941MV64/vWaAEoyvzgvHupzcxbGACIZ2MTeCEkBA7xRYEOOJAaJMqDAeaUpdJWvhhWqZGRtZNdjvPPtdICUVITD62VEKGath5z2QwliVjBlS/VfIdas73pD667KXZMujrkti4Pe0n59ie1jvEnqRZfADc+dN27MGHYsLw9dSJuC47kD5AwXEaoEdAC72+++O7b6/k9iSmshWnoQPrNK6uvq4o+H7R9br7xClueEtcL2yYE1ruYwnZdNgDbKG0tEGGVgkHEzfwwHtgSbKcTXGRHqBrAYE2OG2Ra+ylehloo1xKgK12NsjKUxNEZ5sa7cM/bQcwljp3PfS5lML3+zXoXcpB64JmDCoAEpwqwph9WzcowASsVDwocMex6cM+7YHswoYSwZUqyL+wK8ORZn3fVAXPzwE9Fco3OH3cuEa66IePn5RQ5byks0hpgg607xCeDWmSbW2MM9dt4/Vh6yZzTWt0UIundvrVEsNMUfr/56rLBKW06icGjqZasgD4MNmGOh3bd9LzTKIbVGrR8OAPACJBhfbJh5kWsoT9a1qtVKCDvKSZCikg6O6EisPeu6M/nBdKU9b23LB6UvOGscFeuezuS8YPOkDgHgQKe/90Tcm3EW8kYOEOu6s/mU9rL7BkxTFMmesf6RDxwoUQH6LS90D0bTXvHZJJhKOs/+TSeJ0aXmnB7y3CJg6TCLrogx9J2IDOC0V/7zpBdQvi+zm6fFha99M6YvnNB9UFksZEcFnv/ZB+Pbx5yeAbVyQvln7T6umx6P3Phkj3N02pPBexbjlDN+uMTxf16YltIzdClw4CK1zgEUMRzaejBIgAhhxHmvksWBylTBmz+xI70o8+SJCr36N/ZpeMOysUb9h6LWcugp28Xyq40uW9lrLjArjJfQMMMHBCejnY44LE3mZ/A4BpSvMLexwBIkti4116ak9/rhafF644CqtJUxjIP69Ikdpo2P3/zszKxvIgMir44BwE4w1BwEcyU8nECyZ8BAA1T5kC7GyH0CYp0V4X7rxPhg+lzbfVjzlcKRcuEwKIydXpSAL+BRTsyJ8KD1ouAAcyXMBkBhOfNMZurT5+9eDBmQJTRoHhg5z00AHMCCI4XttD7zlceMPbBrzv1fM2lgCRAALo0t0Dlw30Oi/8qr1e44w5bmmP7w/THjlusyoOW+gV8gxb10la0DNjgd1v2lF1wV5/z4phj/htzYrt/b6OWHxJW3nh4/PPXbiyqX6TB6wL4BDomxB8iAFmNmLIEJIV73ASjTN0LR9Ek6dtZ+AmCwYhjPaoh1JBSMITXHnRHMqir7cpEWYv0Bc0Ak58c+w6hKG5EyVFq0KEUE+JJC5F7sw2qtH46VSIPokjXN2ZCiUi6Hmx5PPSLtyXQP5tBeA/z9znN5FixrPozufZwHtkT+cX6/0yOcbqwmHeT6xhtBIerFAe6uk5CKq1xTtKBX/vOkF1DmZE7zjPjHW6fHG3Of7vJAApLzpjfHEWucGr85+fyMvRFGSIxVXigeocM7TnksZk5ZHNBVW54o3huToy2vzkbGQDK2FD9GSSgcGMK6ACTCMBSC0F8pMGyvgCcJJcpYpJfv5M0CbpQNkMBAa7my3iqbxhNXtB3nWEt5tf/tsdb6q2dKjiJSXZwHkUAXT19iPBDpBXAx2pSnv+V/MiRAB8YVwyAkTvkyloAJUbjBGD07ZXp857b7q55jN+eFZ2LXvm0sMaMOdDAilC3AxSBgRgAwAAuLKLymaIWxyz+T+5Y7K6+y3POW+511grkADjG2GAOhN+vKHMsrTWGz/OfMfTrxA1MkpaL0PZ6FwTNHQAaHBjvoO4S+AXfXNtZAi/Xsec1LYjOBfWvRtQAC/06thdqrPk5i7n3GPXm/e0hFV/ZQ/48fGXUjO5er2a05bmmJWU8/FnHf7ZkukZLS1bzBJOYdmOTEYXI5QQsXNselv789Lv/TnRlT2S6wKbSx4w2N9XHYsTvGgZ/aPr75rW9k98WxSI3rrQegN5+DasxUOXMqk9A3vo/+wdLRBaXCMeEIpFZe1RBr0p6w3rsLKK0nLLj9znmznrBu9AAw2V6bHOuZ4+UzwtOVukf0ROwBDDGdZJzlK2IHgfoEIhVAGXtOk3uw782H1Bi9IJNg4+lGoLEc28sBLXe6VRo3zoTCRk6eeaYzuyv2oEiBF1a7V/4zpRdQlsuBmXZD3Dbhz7GwdX6uCUGFAQzVuMVYtX7rOGHHM+Mju++bKSz5JZL4U7uFvFA6p55yalz/9e63OOnss7wQj8X4eK3s35PB9GKssAgMAKWZzphmWNOL0sH0UFoYEwCTB6xnpc8Com3FNh8AEawORepagBwgQEFhQIcMGhpjJm9Ts5A/aWqdH7dObDs//X9DVjj2y9F32eWqwk6Wy7Fb8F4b81YLMd9e5qz0pzVinlO1bgKPQtv+llrvMFxp7SRmQl4dI83gAZXpe9I56P4uF1R6Rlqjfu93WC3XS0deVmKPyonv9znOjWv4rDXMwPs/oMhw+b9cMveEbXMPQANDirXneD26zEoxu0/lEH+PpbU1ZjzxSBTvu22J4z67IvYfMAl0A5OlTPsXPv+VeOiOV2OD1XaKt19vq+bPS6GuECuuunTsvt+mscu+G8fgIW3PbNw4YPaxMTJWxpPBF7bGmKfKbEyWaIC1YS6xTHIq5SdyaOlITHUe1NJDwA7HFpNXrpNES8u0aG4RUWqJ+rqh0VA/tl1gjL0zh9J4OsMMAkMAmfXAUUt9PTkywCn2Tni3s8dGpp6U1hqd2F0HoSORJ5r6Uxp7azqlc0h94nhymlOnDXsKSCsF9vQ1h0+oOgniwRyLTgDU5QRY5rhbDyIRWM+e9shMPUE5y56tV/4zpXbltf9HhaLZdMResf7QHePZGXfGY9P+HRPnvxqtZcLgQxqXivWG7hibDN8jhvZZOhacPjbzxhkj4Y10ygFFSoEmJdZmzFr/p55o0XP5XkY1AUSSb3VDwXkBje4ZaPS+BCz9ZJgoZCCSMCjCrhQutkL4itFyTcwIxcmYUGLGA5sFUFIK8mjeuLE1mj7oZV11aRzaGmMbx2YeejomsjM5UVmO51JLZYDHi9GQu4PdYVgoTTlWeaBFQSu4InKL7n1+XLy+3Aq1ebBiMUZsvX28+4+/ZvcnrMRYJICW7omxAIaAKOBCtWlqB5LeQ1lLyGcszHECeO0JowKoKNBJwoBwNhJIAARSwZdQpr9ZD3LkFIXpNGCd+V059jtVcGMHgT0/zWFiOBkpa0r+mJ9C3AohsDPC+H6PlbZeU8GP3C4/UyNs88pwupZ1b4wIVh37AsSKMgjnC5caJ8zN8Zf/M25/6dVorVG6Sl19XTTPnhlTJk7MAEx7p4xUEs+AzbWOgb5y1e8TJ78Tg0bPjvOu+VLMn7swXntpQsycMTdLrRg6bGCstPoy0bffkmDOvFr/Qp/WD5CIQfYdgKQXQJNC2cL0gI7iGnMkOiCfFZMJ6FkzrpNaANl/WEApEth1wCQ7rGDBPTFj9mUxd8GD0dL63mL3VCgMiH59NowhA/aNIQMOiLq6xdlC69V3YuPbqzZfNDYTJ2a6wvqwZukrc4+NBJq7Koq/OFh0IGDa2dB7ZwXwFXrHQto3QtvGUWqHdU0HYAutayFoutq92KulYJK+9Hnh77yIythfnJNSMVbG116xXu1rTHNPwSQ9Yf6x371g8j9behnKTjZAn7jg9ZjTPC3uf+D++MF3Tom7//VoLLfMB6eYEMbOotfEFrhirBTfAJOUiX8z1AyjXJrbf/B4NM3/oOCgFjJhqdei7wqFzJMGGLxSwQmlj7Fh7OVTAoap8a73+Ft7x5iVSgJrni8dQUgoLkaN0VfIgrXgbXr/87e9FwNmLVvVU3Ly8zFu3j2xznbLZ0oUsPGMgA8D4Zn1TBOiY3wTyOhIgGvMCceBsWGchOWA63S6DhBz+UtvxPkPPNajQpz2pHXhgtht2ttxdoUjGs0FkMlYA1JC0dZnKtBJgmnwPvMOMAOh7R13h0FUWa4IhpFKf0stscqJdcXRYJQZG/uDUcPyYKKEYwENIXFGSUgtq0wuU+gDEALJAKpnYUhFA+TJqRzt6Ex56yIPMtMrrVfCefB/659RBkaMUwrznXP3g/HbO++v2dySSX+7OKY99VimT8xdV0SBGDBpPo1ppVYyii7sCfPZVTHngDtn0p4AvjFe1pHvpl9K8+WEsIFLusV8Cbtae8KyxhyDmAdrwKSCvvsf+k2MGnNRNLW8YQdyXyrcVVtEqVDoHyMGnxAjh5wQhUIbILY+rSkh2Ur9St0TsAfMei4ijxOIdN/dzf+jY4BpDhg2kLNkzfU0hzL1IgUiXdeaxYIKv9Np9r4xN95AmeiZtYBIsG/sPWHt0vtIp5rlm8ED4va8iFtp0Y/9hEwBaOU7a0NnLQh7S+/qiWBIOXKIiPyJUL3ynye9gLKLQskIeclDKdeMFijxeyEBuTY2KmOnak5YJ/Wyw1y+ddW0GPfwK1FLWefo5eOK6y7LlHxSGkIgFHk6Po+RxzRgHW1aSomREbaiOLBICYgmUOqlBQQlQ1FSuN4nj4ryJKm1DBYifQYL5DOpYrVf/aD40KgjagIoo741Nv3kUjFi5LBFFdylr/zvKVheOWMstIIJw7KmNkcpTJokH6otFQD+7XU2jYmZ8audXHfckbHa0qOWAEzGWm6U9YZVoNwVQyjGovjzANG8Mz5YP4C/3PMsKqQaPjwzqsYJQGe8OjoXmUHDFmIlrQWGDeOILQHEfbe/MzwMnvvrSLA7mGL34mUtAiWdYZ7KiTETHgQk3Is9bi+koyDT3BsHYHXr/T8edza231C7pzL01n/Gw3fekY0LA91ZAdblyXJogcn2+vzZ51h1a6QzYv/qDZn6YKaTv6wve1/aC8YLSyXvtVxRCABD32DOFMABcVhg+tJnMJ8YT7KwaXacf8km8aGd5ZrTEV2J7BSiT8Oaseyoc6Nv4+rZb4RirZFUXJhv52Y9uQdCP2Jb/U5qRU/EfqIj6ReOHQBo7wBfcpy7Khw+ud9ApJ/0MqAlCuQFJFqn1q5/24NynoHKFMZPeoxOABBLAaWm+O5PxXoSzgO96Hfp2NjsrPi//CWzbfa7wqDk/Ah1y7Olc+iW7gg9Zr6E3kUIeuU/W3oBZReF0cFEqWy1yMuJv1FIjuazeQnPlNLksVG8wjxD3l0mrv39TdHSXP3myKRPv8b4/JVHxN4f2TsLeaQefjY6pc/YYF4Ito7yURnonhkEld2YvHLHmeXbajAorgO8AFIqSilRith7hImANMpFWIsCx/IArJims799efz74nureiwcRTe58cV4u+mZRWC4M6FuIlyUgCZQnPL4PA+HobTvpr/7vjzY9LuVvnVq1NUoTyrJqu++FoU3XlmCScy32ikVDkQKIXt5XowEkAZIlQOFDEJiZwBV61lIsLMMi/ERJgPWAApV8n4S4Ccxk5WqvpNgTKSTWGvux/y4P2BV9WxPBbgGkjGRgDCgpVjBvnC/qUm9mPDKX/1eNAwZVvVK70IUY96rL8fxa62Y7VVjBRB0Ruxje0rqA+CCSW9vTowfUIEBqiR0R8qHxOhb2/a7UDaQgQUDSlN7GfvDGGIBzVU5Md9SL1LUwIlaQJH71mlBUcfPfv7jmDTj6Ji34KGIQndThOqjrjAgll/6b9Gvz/rZeAI9gLEUCYBRpbZ75uxgzNPxj9a49dhTQJny/1IjcroE04eJNWadEaAbAwlEmlf3xCHDRHpVYu4AWOuHrk2MoTF3L3IqjYOiPaFtID+tZY6BOaaz86foqNwW5SBYVnmw7guLa//mTy0SyWArpf8Y9+6I9SPiwLG3TnrlP1t6AWUXBRiihDtqP6HKV18/uXZpszNMFAujZJPsv+OB8dUPnRS1kPqGuvjwIdvGCeccnTFLKs4pk1ShZ6OmXntJ5LtgH7BPjI0NjHkEjMsJz1O4XOsgABWIwUjwmgFSFbiMj+tgoYRO5LTJn/LepLzmzp4fx25/Skx5r3LItCvistMXToqvn3tIHPCxA7LfperhPMNajnXt6G+MEM8fOAfeGCK/FxpdrECkUIg1Tl48tFxtyZr6vvBkjJ0zfTEQyGCZD0aLoU4nGblfhoIBEK5PgmXCXggFAv8diYR+76+UlN/RPTNOgKW9kRrdM0zpFJN5c+bHU/e9FC8/9Wa89vw7MW/2/FjYtDDefO/VeOiZu2NW66SYMrvtTGd7C4DCjgMpnq8nYg7dEwAp1Aw0Y+LsA2E9hhh45SjdNXlGDNh2p5oUXI2/5I9x5pdOyIAVx6YzHRYAYGPBiNtjHeVdco44FqV9Bq0fQCTlQjLm7gEQAV4Ai5TakebU70VvsFf+Zv8bQw54pfuga3wvEMeJpZ98rxQZ17rw8rGx0SYLewAm86BycKw0+qY4/y83ZGtNeB3g4YSYW6/SKmShVo5/V9J+SiV1hEA+YL+TAGqeWbQmncdeKlJCUmU2ttA4YzSxkKnFUmeErk/tnZAa2Has4iOPPRU33f54XPa362PqzKYYNWqZWHvtNWPVlZaJn532vTjtlK/Hpz91ePb8om7Avj1Gb7sv4+jf+gyXa1afmE7zjHlur09tOaFnzQ97hVntlf986QWU3RAKUnjNq5IAGTw/ihizwQDne2nxToWbP7vRN+Ltce/WpBflr+77cayz1RoZ60T5YJZ44QyC4oxSZkVYnPLTKwwg0SfQZyTTM1LlRPgPYEl5OBQAAIp9SO2IiDwpLBiAI++Nx52X5x95Nb66z8/eL6jvPuPTWmyNlmJTvN7n3pjdNC1jS7tzEkXZa7e2Zmwtp6A0WZ2YQ8wGQ409W+2H5dmZaonv+/ZO28antvugJxtghQVhyBjnUsNvHZTLowT2GRvOQUdjYP0zUEBDT+49FTsQc3T5RVfFaw9NjZsuuz8WzFuYFaZokZS2hrlNxwbOb5gRJ5/9ldj+o5tkrCV2BfjD3mh+3BOxhrFUDLm9gnmxX9MRj0LKQOcGG28SU7fZJQqDB0ehrr5q7YLWGjEkXvzdWbHVlltm+oLzBVyUCx8nAc6NAecNmMzPe0e9RDGM2C7AOR13iLmyr+1bYBFQbQ8QeD8HBkDkOGOv6AxrRA55JdFUG6DkgFuTgJbPfOzgfnHiSdWrGW1tLcSzTzXGgfu8sSh3FPuMvavEMHPCOd09AZSYQeMBlOerwTkIqcgnf/QiXZtAJDZY9AeDD0Sai9Iq/Y7E2gH8sLKiLpz9fT72ydhtv8/FhOn12bnY9fV1i4pE2+yQHFQFexHbb75aNM18Ic4643sZ++2esdlyboFaTmB7R50iJzjfwDmHoSsif1bdgWt0pxF6r/zPS++Bl90QoIIRa08AScpSnqKk8iQSnRlkjJ3w8BEnfbzqYBI7uemuG8TaW7blDQldYFuSVysEU06JUnhytTALPGeKw70KWVRiczwn1gZbSwELGWKwGF5hMEaLhyyEqJKQ4Sln7IaN7R8vF+/JqukBh+4IADJk2MDY8vDlY9bCqZlRYzCBjGqMsWeR88Vw54VxYISxr6mwB9Bunf/BCUO1EHN44z+vWex3WA9rCxNdOs7eL78JcCg39+kc8PYEA6W4gZPSE5EWgrVg5OTpjmhZOc467sq49s93ZGCSON8+P235M6j7tQyN0477c3z7wF9HXXOf7JkwKJ4v5fB2V4RrGTEv4d7EsHt282odA5cP3X9fvH3FhVXL/83KSVqa4/6fnxZbbL55xgCn6Ea+dUupcEyBDvmo1npnwCSxx4kcTaAAi2afcjiMJx0HDGGzO2KXgF1OKOYLiwX4CINyINs7spRzDUTSOfQMYPnss/fEV7/Vp6opMHV1xVh/o4Vx651tKQSeVwV5R+kKPUlnkINr3rDxpa2FrHuOKaabM86R47QAX3KMrWX2g77BxAOeXQWTCm+AUNehmwcPGRaf/cbZse72xy8CkyTfcaQtL7xtPdt79zz8ctz/QkN85LDvx+tvjs+YSk4HgAr0tgcmiTWJYbQ2OtP/NYloCrsBhPaCyf870gsouyEpXNKRABiUA4UtVJoEG0Np8xZ/ftHpse3+m2dgqCpSiGjs2xhf/ePnFilDISTsDTBHCbTXfJdHjmWT80LpYRd4owxqaTgCQMWCEYZMeANgFebGTmI6KUnXZGTkUTI4vG5gFDPi+saJwn35vafjtcZ7YvBSfbr2yO8/54bbrhHn3Prd+PEvfpABWyyTMCVDCVj67lRg01Vxv1hdz8WAC0Uy4pSd8TQWQo6pFY9TQ5brX9v8SfL3887NvltOYWJD5H5Vaq8BcEmsT6fMdHVNC0V6Rs/XXZEPiHFhnObNWRBznh4caw/ZLjuytNPs9PtY4+kHXo7PfvhH8e5L0xYdv4hNE5buqmBzsHuAFKPJCbG+E3i2tlUAS+XwN+v7lQfujZP33KntlnrgtGBiW1ta4p1L/hQts2Zk4VFGNYVhfW85UTjmeYX63bv0lvZEZMA+ADTSeeWAM+cxnbOOkVXR3NV2LwCSz2HEOFmKPeTzWpPtCb2BpeNY+Dlg6O3Rp2/beeHVlUKsvPr9scsuO2eAuaOcavPZXUDps8CxgpLSvGDfS/dxzLwAXFEdehA7CURKQ0A+dLeYhTNtr9tr7MzBh34yNtjxSzF87KZtPUM7CdbT2ybPGRA/+PWdseoa62ckiQbonR0bkTzOS2pub2ymLXw3Xpr1UDw/454YN/OBmDj/9WgtfpAyhK0GQKWG9cr/HekNeXdDeNXAWTmmpxwQsbGFrIQMJC1jPLQ3wRxS7Ftvtk2MfWfNmPjm5Ghp7lm+kE3+/Su/Ftsf8EEYlOePJaW4O5OLIj9UpS1lJGzPaxYSSwnkjA4jBrT5PrmJCnooxXQaDiYHmKMgE6NHEWEFeM6YTcwFBlQBE6WKXcP07b3X3vGvC+6Oq35/a0x8e2qmaOoKi4cUNZPPnjcKscIao+OgE3aLnT6+xWJKDkCgpP0UXgUEeNRCu8BAaSuVrJBn8uQs7CRElf/J6KbkfOFO1/MMQLKQGIbWOHsW7xV6/vUd98Xv73moZq1l6pqb4u1fnLqoACeF5tyfOcNuARrpZ2rpwsiV5lHKn8WodMTuAQ1AjLXcHfE5oAPgPen7J8W3Dvxldqa7k6a6K5pvNzTUx2lXfjFWWnd0ls9l7Vp7pWeFl4o1iC31XowgoA2U+b29a16FndPYGkehuATGrAlM/F3jJ8TofQ+KZpXgXQx/F1tboq61NVZ588W44/K26mPrh+T7pmK7PBvnyzo3V6IBQLRClnxBRF7sw1SZLZpgnduHHCFh1c62y+qMSDHhvHG4gAK60lz4fbnm5HnB5P3kJz+Kx19YPfr2q90JYlPGnxzbbn1sh02y6TMRmzQXXRHFKxzadF69PcpecOg5K6kdDx1CZxqfajU6p698J+cZmFxx5dXj2BMvjXcmTOsZm15sjeHDBsZ5ZxwZo5fqWocDTn1xxIw4/swD4uXZj8TC1iXHtL7QGMsPWCdWq98udlnvoDjh+BOytKte+b8jvQxlN6SzbA6RAI3ho7QxSNmg18lZaclAGUPw0OMPxmsjnomlV1yqE0xlMUatMC9W32pGrLHt9Fhxw1nRp39L9jmG9VsXfmExMIm1SCGUzhoOOU2AmIR0jBwwyrvEsvIYARMeJ0AGRHkOnjQjJafG3xk7CeRy0BhcbTMob2CS4mSwGUPGTkjG96X8tfqG+tj3mA/HXx48OX502QlRXGp6LOgzPUaOHhpDRgyKIaMGxOT5b8Yme64cP7vmq/H7O74XOx+45RIeMwPmfoBCClb4Uo6X3CnMovs2J7xt9ydnDOCUXwU4YYXcJybSZ4yF/qFYOkDYMwLLFLgCLGG/1CSe7LvBOrXrU9jaGlMfui8bT2CHwQIojDVDBvhwYoAQ/5dXyHi5X4DTvEl9YOwxYZ1d08Jz3Q13A9rmPAHacXdOipF9lusRmCQ+r1PCKZ/6Q7QubDtD2nNy1oCoUgEaMYDWgqIUbCl2GaMECFgL6RQezpV/m1d5isLeCUwa8wQaLj75+7HauCdiwbvvdFqxypckc158Iab85Zy44fy2Dgjm0fxgcPMsGkfIujVX9prIg39jHPN5wtaf9Az73r6ypwAjEQf7wTwDlnIc6YVqCkeLvtAhguPhexXmGNeOxP1+/wdH1RRMKtBZdY1p2R4o15y7GgwldlZUJjXGp19SSgF9j3mkS5ES1hfHvDPkRGckdVDwfP5t35/yq+vjvYkzep6aUaiLqdNmxzFf+33MfL+dVmdk8oK3Yq+frhAf/v5S8dyMe8qCSSL3/Y05T8ctM8+O4/+xVRz6xT17dr+98j8uvQxlN0RuB5aivUbOpSLnRK88wAwowzSkZGwABeBZc9W1Yp+1D447Lr0vY+DSkYR19cVYb5epse1h78Wqm82MfoMWZzHZnGnjB8XwofvHamt+MRob2pL3gTUMo95rwJxqvM62eqHgMKgKaSilVOiRijLk5AAvALN/a2YLWAEy6fe8Y+EbgsFksIXTKDzGUF6QHBtjginBZgill4bk070kVg0AwAwKw6cTf0oFGKCogUmGinEDhIyJ6vS8YKSEcDGrmD0voCefN8b4AJbyXrUZ8Xd5XwBSXrAzQEdiDY++5O/xwGtvVR1YmsF/febwmPnO25mh4iwouGK801F9AKSUAwAfcAKwAWQMiXlxjwn8GnOGEJDGeCVmE+BI7YLMv/w8azl/5m9nhPG0hjgTwtH/uOT6uPrMh6t67Can6kP7bhrfPPuo7Nk4Rlh198t5wNJhiMwlVghwVHCCfbcHMZHWVTrW0T7B6gPt2Kz8mcYJTAKvQKtxte4b+/SJHQ77RIzdafd44PW206REbuV/elLrwOk6dYVCLFdsinv/fG5st8aqccvNN2f7Uz4h4O16aQ3V9x8Y/ZdZPoaNXTE+duBBMe755+L+W/4d8yeNjwUz21IXsF2pbZI1jgEzp/I9PaMK7dLiNDrIOMibrKa4prXop5QBKRn2oghFR7pn+uwrYsK09ltH9UzqYmC/neKoQ9/J9nd7nQrkf9LV7eWAlgqbYG+4rrWO3RStST0i6dL8GNh/dLT5Sz0wuyvWN/1El9nj9PR1tz0dp519Y1RT3POU1++MLxyzZ6bDU8FpOXl4yrVxy3t/zIiQcqfNVfyO1gy/xqbD947dxhy7RISqV/4zpffoxW4IViC1i2G0OyNJycgvYpTzLWYYNkYOMPhb64Wx7JYrxKSHZsXQ4shYf9cpcfCPXolho5uipVnBzZLXZu9HLs+rvyRefffiGDLgoBjS78RMgWEOsTEMovABg9mZY8MYf4oJCOZlUxrApBMwKL6kRCgXhiwZaIbY9/kOnwWUKTfgC5ADGD0/Lx34co8MOsMH9JTL7xQidT9yrDAgrieZHZgEpMqFqIWQUpgy3buKYiADwAIa3bfcTvmHckAZYcDYd+TDTz4rfMcQmEPjiNksp0i911j4CYh9c+cdYv8/XhLVFGDk8M03jNVGLx3f++2vszw1DAhgDBhxGjBUDLgQs5/AdwrZMzT+LW8OqypXDpsBfMnt0psv5Zpa38YKwEwhS/NnbDsbojNH1rZxMb7W0MB3V4sRfStXLXdHFPHcftXDceAJu8bKa4/N1gsm3ZwT64XTAChwarB0QKQcL4wO8OwZjYfxkfYB4HEk8u2IAD0pK8AkZ8j4AA3WR3NTU5z11S9m7OJeB3ws3p67II7/3vdjxvwFAVKOHDgg1h2zdKwzeukY1LdPnDh7cuZYer/Kedc1fy+8/Er88q//jKseeSH6jhy9KM/yltenRvQfE8vve0zbXPSpi+bXno6nbrxqUX5rYjUxkvQUIGyu7LMULifSH2pxlJ3xw37TH55NPrY9zMHU/aE9aWp57X2z1PkCjq5JayxoeiF22mm/LOpgTbaXK9oZ59t8pZQC+sT6MM72FzBf2o6o9Pp0ibUmgtLdtldSmTDY9Kn9az03N7fEORfd9X7CcfUcN/e81Mo7xJe+/LWMXMGmIwNKnfu7J14Wd03qnu5LZOqj066PWc2T42PLf6cXVP4fkF6GshviXFyMB4DSlWar8vMYDoyHnDVhobxQ/IwXJqiubmHcdc/+MWTpB6K1BfvSlTusj9mz6uPLx0+N3/7q7swrBn4BDuApNVsvJ4yM8C3AhlWiPFS1C5Olc62FbQBgzAYj4X2EYuZtC2+plE0CdAJh2oEwbFoRpWRrHj1lCiQC6piMUsUE3EgbwBZRzt7jmYDGfBjfvTHuCTCmn+5FQY1ecymnKS/uDwuKPQUYUwsdFYbyRY0XhlOIUIi4tGIzL1g9hsFzpZy23971QHZMXzU4Snp29JDBcd3nPhm3/PuGjGViGK0rxhqYT6eM5IWRA7QBTD3thD6F+NP4JVbO9Rh/ANU8WA+eB+uqGCmf2weQl+Zp+pmvMuZAYJcBfb83d3vsuE/E87VpA1JXX4il1uoXT065ddGRc0CzeVQAhhEHIhl+z8BRASoAavf3hS98OVZeeYP49ok/jp133j323nuv+MEPToy9994+fnrmydHS0pw5QwAEAO7ZgDLA1XybA9eXbqCIR4GUdVtJrD35hqn9ij00q9/w2ODQ42P63PltpbbtgJrEMDcWivHJLdaIEz62Z7ZX05nl6ZUiBda2PeolssDRpROq3ZydAJL2FGcW8209AfHtycRpJ8e02Yp4anckbXPTkLj3lq9m80J/0eXl8jvpZ2uGvi4VznFq75MKLkVd6Hh7CsvcWbKBc0ZHSaVor5q/0vy7R23MAFhzmfTnbfeNi5N+3vVesZ2Vw/dZN266+g+Z7uZQceDoD2vpyWm3xL/eWdy+dV8KsenwvWKPZT9Xpev1Sq2kF1B2Q7A9NhBFIpepKwKMCT9hSrTyKRXGe+ON144/XTwyNt2iXxePGvtAWlrk/9TH8kufH4P677LYmdqp2q4UUDF+lAMjDHwJLzM4cuwwdEBBYgYxrACbPCEvrA+AmU6DKCeMJpCGuTB2eZaToWeU5XwJHQIyiW0UwstX0Kb2MHngmIpkKonPY8k4AYB7pff6Ts8iTJry6IS33RvWBevanrgPxoTBSflpza2t8aW//StuffGVxdrgdFmKrdG6cGGcsu0msdlqq2SMEwfEfFLiQrCAvjXU0QkpqR8lYI/NtBalcZgHYCgxlMAzJtnL2jVunANgPgFNP/NzBBgBlgCnNZF6jmJrOBXP3PJOXP7rGzNGsRYiF2vkjrPjYx87IFsnQuy+19ymfYChBK45GObpyCO/HM1NY+KxR9/I2tW05c+lopiUFtA3mlvejLvuujQuvuS8RZXSKbyIKaYbrEesDfbGOu6oDypG0T677PLLY8zOH49h62z+/onUnZdisTXLkVt75IA457MHxagRi/cfNacJXCawmUCm+Uog05ryM+UD90Q4Hxw/11fxbf7b0w/22FPPfyFWX/vxaGi/fqdHMv7t5th5m7ZnT2KOzGH+ZcyMlfXu/5xya4ZTaZ6BUDrFc1kL3lt6mkxnRd6p1jq+s7NtnziJgDpn21qT856fs2+ddlXc62jfGjgLLrnO6mPi3NMOz3LJ5ZbTPdKrfnD6ifH00hdFU7H7/TvLyWEr/ihWHlR9Rr1Xqie9gLIbAmAx2KUnTHRWhHaxkIBNaYjj2Wefibse3CE+tFPfqK/vqSLw+YZYcZlro1+fDTJmECvBkDCU7oEyEtYDCoAAbIkQoZxGxpKxk1vHKAGA6UhCyiMfygGshUsp2krHgKUcPIDUewBrQIShB2ryoBEbyBjlQSMmDqOARRQi76oAQZg8irdcY3KCrQKsef0UNkY15cpinuQotWdo3bc8xtKz3he2tMSJ19wY1z07rstgIYW5h/brG4133RiP39bW5w+bZZ5SaxEhe+uJgVOo0Z6oXpb+AFjkT4DyOc4EUJwPmfuJXSQMqTxL85PAJiAqvApgei8gaX3n59S6cX/Lzts0mqfVEDFExFFn7BI33nFtBrbdF0eFM6WiGxsE8FtXn/vc1+P5Z+vipZcmZPuNI9YZ4HbQwVvGxEkPxEkntTV3t66NO6fDGgKmgYt0+k9HMn/Bwvjwl06O2QNG9Kh4Qlh87vhXY5XpL8dH9tozY0w5OaUiqqDABxCgCxLYFL4tBZkJaHYHZALzQL2UF2FZEZ183iJdKidZmBZQO+TwYfGDn/SvBQZ6XwpRH1vHgpknZ2AM6BVydh+lLzrRONF7lZqbW9PplCp7RsoOcMk+lALU/Mvn8mNp71qX9BLw3ZFg/tkeRIDCHqkSpbLr4WfFvPm1OdaX9Gmsj5sv+VLWGJ1g/a2n1Q9vjbV2XCaLFlRLClEXgxtHxudX/2Nv6Ps/WHoBZTeEkZSjgrVrL3xcSRSoAFKUa/4UHfKLX+0Wex/wQfJ/z6U++jSsHCuNviXuuOPeLH9N+FfYXnU1Fk7ejTY6mBqMDRYSwCMpzC0/C3gBPDAMinWAK4KFoQwpSDlTQCm2oTSvEdikqJMAJjxa4ESY3T1g2ShU4UpGKB3vBYz6DqBHfqb7744o0MHEuT6WudT4KRwChHyvEI4wpsIb85SOIJMHKOxZLodQ2J5xKMfEWDfXPPV8nPLv22JeU3NWnNHh7NW19Yz7yHprxvf32CkaW9sYU4U3nIGUH5hEYYd7Nz7mupKkY0DNR+pdyAga+3K93wBF82TNW69Appd1kooWALZ0PnDK1+TASDFITKafb99QH4XW2qZvPzn95hgwtjUL/1tTvhvTlPqmYpa+cMJp8ZtftzW97whIlpO5cyfHCy/+NVZeeZlszaQTpQAmoAJAS90LOpKf/fOuuPDOR6uSFsGM95/2djx56dnZmgUoAUsv7Kz5k8KhcEblOn1EjIO5Kw2XVwKZXkBpRyBTaJkzZu9x5u568IG49oXn47bnn4sJdYWoGzwoGhv7xOC+fWL31RriU+vWslVMQ4wcckKMGvrNbC1rVYRZTns59ccVygbU/A1YFK0RGuc8We/C2nnwCUzRkZhvaz/9nt4q15/UHJSCTA4eZ18uLdKhHBC1v+gXcynagh2XdlEqEybPiI8dd17UWi765VGx8vKjFv1/+oIJcfZLx1QzZXMxOXD578caQz7oYtIr/1nSCyi7KUKGjDnQ0VUR8gXSGB5tNRwvRWbMeDteeXfzUFxc3aa+hRg24Kvxr6uHZVV5FBxD4CQLIEHIApBkdFNSvwIb7AoARUGmyt904o33KmSRmybXyOcpO4CTEUuFAX6XGEbgDEshzw84TG1bsDoUsZAq8ObzDA+mUH6ln8LQwkIAimfAZvhMV8W1MWvADwDpeYWZACltglSC6z/HWCYB/LFN7leOkmKMfJ5lvp8lcIbRbI9FnTR7Tvz10afi0keejKlz52W6N6sAfr+Qp+59EImV3HnNVePIzTeKLVdqC597fqAXw4sxxLjlx8G4Y4Tk0QF8lU44AfhL+1EC6kAoIF8qmEt5vwxkvt8hA2z9aN5vDfh+DHQClFhU64YhTozmr49uawxeK9Eh4YWZ90bTsMkZcOQMcGqMC7CMnTz5h3+KNVbfp2ffU1SANS9efOmS+NjH91qU/2beGf0EXisJJpPjccHVN8Qj9aOrnsd41pF7xtw3X8z2rBewiEHTUkkqg/tN/RArP2MbyMyHyvMg09rPh8rLgUz7gf4Ys9pqMX75ZaPfxhtaGIxPW0VhThrqinHxHr+LoX1rd8rU8kv9PQb02zoD0+6X82W9yokE0DwbxxDLzPG05tvroWl86Dh6Sc5oXuwPz1+OAS19pUp4+0tUKF+4mcTeMif0BIfYWJcDnrfe+XCMm1zdordy8ttTDo6N1v2g9dSdEy+OeyddkdV0V1uwlCsP3DAOXenUql+7V6ojvYCymwJw2dDAUHc+C6hhMxy5pUhCyPjaGz4Rq61zcw1OiIiYNrUY22/2XgwcODRTOL6fIqW4GBfeN5ZFAj3whnllFIQLMS9CUoCGgg3sGECZF0qQcmO4AUzXp2QZq2RcUusdoSFgxnUZfGGnrLL1hReyzyTxnakQB+gD6ITngRKAVPi7OyJfEHByLQwEpwDwxa4K96Y2OXngpQgD60TSM2IwKHfhY6dhAHmYB6HySsUxeWlqaYln3p0Q1977QPzusstjjXXWja233DKWHTo41h2zTGy03JisKjgJ5sT4A7KcECDXfAGV+d6QWECFIpiOSg5PuXO9AQ2AWAiyVLCegFlironQvjGzBzy3NcMI+p1rWucpZJ5eChx2X+azVTuusJzox7rclv3jkhvPWdSJgYMi5QPAfeSR1+Jb3/hrlb6tNebPnxEXX3pCrLxyWygdEOE4ARilYq3rDZsaqQMSax/97agfOqqquW6ckWWGDoobvnt01NfVZfNt/BO4NJd+h50EgDFeHN382u8MyMy/UruqBDK9FPTZ5397+snos8duUejTGIUKrb6SHLn2vXHwGg9GfV21nY5CNDasFCuPvidbF/SH/U4/cTQ5jnSMiA32FjjEqnbUHk60gi71nN092SaJ3r3mQChbWNv6SGyoOeO4cQoUv9AzpaDUe/1+wJBlYuNdOg6d91S+dOQmsdP2G2Y2xThe8Oo34u15z9fs+xoKfeIba1/ZG/b+D5VeQNlN0VuNV9sdUINRAj4wgAACNom3/OS4dWPp0bzPqImcfnL/OP9Pbef3CsemghrhHkbFfVCOFEMKU+fPLOelAw5C3QwIjxpriDETQpNfiYlgsFy3VOSzyctUpJGKRhgmYW8/AWsKNS8ACaAjFCQUz0gLt7tP34kZ6Y4AtpS2Z1UdCWyUMwbmCICjrEtPIqG8/R2jaZyEdrGsWASg3Oc6EkDZMwDNwmaVerox1qlJNUBsLoAzeajGCEgB4JIoCgEmAc5KbaJK8yj9H4DOHxOahIMAtJoD60I+K8BvTIBpYFIKhbXgexXBlAr2UqrHV3f9VSyYW6u2MG3y1IxbYpOd18ieSYqHEKYx/u53fhDX/nNyTJ8+t4pnRRfjYx/fIo7//C6Zg8jZkAaSWmBZO/YEEAn8AzP2CR2y7nY7xWm3PBW1krOP2Td2WGfJThQAtpSJ1GybYwUIWk/Apd93dIxjKcj0zFhM+9g1rRMs7PCP7BnDdt05y+8sdEK5jew3K/6825+iT3318/9eG3dA/OGcd7L7A+6tXyFtTL01nmdWO9Nv2LPS4VJIOirY64zIy+fk5VMRiPUrT1L6AsBL99pLdDY9BHzm8zwb+w6OLfY+KWotj918ZsybNTHTW6PHLBPH/GP9qO9TswTYTI5b7Xcxqm91G/L3SnWk96ScbkrKlevWoL9/Ug62hFEGlo773AExetnagcmmpmJ8eOehixpSY0cxXoAkcCsfh6ED1hgFrCVWCkgA3ChVQAOjCVgIDwsFYflSyEtoE3NIWZeTdH503lBJ9KcoASTGTBg9L8AQw2y83Q/gh0UADrqTbuA5hXixpeYB8BXGrsQsuB+At9yxdkCxJHSKHVsJHCbjCvRVSuRPIj2AcfDsDEklMMkoywMEyLCHKfxmXDg0GFupAnJc8y1bFMoA4JXOLC4917vSaTlYasATA82ZsF6Et4FKLKU8NPcBTAIqxqScGG8s0Lqbr1bDoos2mbFwYpaaAFBiDYE343byyRfElCmzqggmSSH+/reH49VXJmRsLWbamEpPwPzLPXQfxhbg5KwZTyzzs9ObsjzZWojLXnn/B4xyXtxfaqEkOiD0LqUBkLHWpKJYHyqP5T53lKIAnLkGh4MzpQDO3jrit7/OwGQ2Sp1UblPmD44/P7tDVFNEjx9/tCn22u3sbB44XO6RDvF/Y1Eu5aC9NAT70pqnH7ra6D8vxtY+4nBYFxh1ujB/IAGdh8DwdyBXFwpgFrD0d5Edn+Fo22dHfeKQGDKoOkc5Vrzv1uaoa23Ln87yRmdPrDmYJM4B75X/TOltbN5NSb0ZuyMYrGTkGVih5Ev+qsfWiKiVNDYWYtDgN+OCCx7P/g8QAI0p/wc4EPLKNz4uFWEg4E8FNGWMbQQsMXTE5yi1SoASCwKYlfaZxL4BpcImqZei1kGEkpWnKU8PuANe/BuriBUTxgOoOhJAWFEGAykMD5gByQpTgMtyBSxAv7/5rvYEwwswYD2BLgo+HVVZLs8yGRG/F0L2PqCjksj78x4gFejLi1B96q2JVTJG5tE9JQZc+FWhVKkADO4DEACyE6AsPXIOk+V3wLwwOaCEjVGYRoRuGVS/w+p0lAu41qYrxxP3vBjFGrYNmtMyPWPMpSuYj7bz2F+LLTc/oCbhdhXip512UcbSGU850hxG68p4SZco17/04VfezvJlayEue+9zL5dt3u0+0/34m4iFlz0CgKfQuDmX580BTYU9ikDMvf2B5bdfrXcsWcpBtn9fmT8vDvn75d2693++snFsM+alWHfk+B6HvhVcNTfVxdzpX4y33jo6c2KTmB9giHMN/Hfl6EX7y/6ljyqlCtDz9BfHDRikN4FHZATmWpQh5RvnhXNvPF03dQ0w9pw5+k5KS7lDIKwzTj0n+cgvnB3F1kKngXxXxLCsu9byce8/ZmUhdrr97Smvxg2tXXfyuyotxdpGN3ql+9ILKLspjC/PnlKtdPxfRwxlEkb/ngcaMsXX81ZBlWXt9YbEc8/dnVVT82wpQ6AGoG0v6TwvDA4AKk8ugaA8UwvYULSYQMY8L6lislQoXAyBsJFCISyYsLj7lDNE6QOzXsASL1y+JYOIYWjvnGBGAfvnbF3z5VQU7B0WwN8wi74HMC2t2sbWuGch985IqnYGuih8ANl4aQWSz7MkjK7vxlDnC4BKxb0DafK5StMByoFK9yp0jjFOx1umoz7zhpQwUoAPUJAAJaYJIwn4Y0CMb2oCroJcIVp+rShsAh5cHzvVmcKSHfffPC79Rc+OmaskrcXWaBk6I/bfZv/M0AFHmFv7bYP1d43GxvJFSj0Ve/elF+dEfX1jNsdYWgxde2HjWfMWxLvTOn8mcnekKepit332j7+e/6fFnBaOJIeinAAk9oSX9cCRAS4xvgp5gElrSag1MZ32l3zEtOfnNzfF1/55VZbL2ZluBqXi4NmTH9gvTt/uilhl6KRug0qAqr6+X6w05q+xwepbLPF3qQfGheNYCijbE/qJYy3CQNdxquSG58EiJzYdn5kX9kKxnLVBV3BCEQvWjcI1/8dOGlc6GjjUWaIj4Uy6DwxxdvDG+Pmx5hZHRC3ElO61Y1sqDX1gDAeN6Bs3tLV6rak0FmrLvPZK96UXUPaAoeR9Clf7d3cZSoJBGjykX3Z+adTwyNKG+mIs8z4rKVcOkBSy6YpQgJQbpg/ooACBI78TAgb+MB5YytIcQsannIEFKBk3ignIEubxWUBA+F3eWRIsnJw/7KgKTEyjIpRyvS8xAthFxoLnDpTlTzYCfow98IehxcaUKmhgDZDtjKQTNVL4XDqA8BSAjaUCuIAMzwrUCg8zwpXEc2H9hCD1ymtPzEWqkk+gElAFyOWHGYfShvae370AlCSxn3IOU19AbIhcLgYD2M+LeQBEFZQJnbZ3hF1ellttmdhg2zXiqfte7HpDzg7Emdmj1myMZ198NnM6kuOGlW5sXCpaW1uirmvHTnVa6uv7xI9OPStO/HbHubNkwozagskkL745PptD0YTUyirPULYngI81a49gKYX0hewBpzS2nDPpHYCU99Bv/xz3QoyfNbNH9z23uW98656D4yub/Du2H/tSxrh2LTugLvo0LhfLjvpD1oe3nNgDGNfSQyYAQc/jJ+cAaOSciKYAi5wuDqk9ld9Xnt140AHANYctDxblaSZmv5KInHBGObnY38MO3TOKC+6KaH4poshpbYioXzaicd2I+pWzAyzSsaa+k9MMlP7jsvPj9D89EdNnVr9ivl/fxth1+8V1bv/6IdGvblDMb13yZKFqylL9PjiFrVf+s6Q3h7Kbkoxvd/Io8wwlVksPxo032jLqG2o7HcViQxaSSqH67rTdIRgv+X4YPwUIwDHgkoANo1Uu7F2OoWSIGDdsWRobHjlWL4FLoeRSUCusmPKWgJp0sktSyJQrBY6Jld+nSrvcMZkYCtXQvk9YNC9AWQK6nRGMRL51EHH/ClRSniXwLITI6PjuSnmWwl3YD2yR9dEZ5i+BSuwGUIlhNd4cB0n9WqJUyqNkJBkwgrVmoLAd/gY85KvICbCGEfUMrtvZc72F/LRouvDms7IijWpKXX1d7PTxLeLyf16cdSwwH+5fvpm8xqFDlq8ZmCQAxhprdL5IrFah7lL55FGfypw9kRApI8CQ+e4IUFqD0h2sJQDFZzkY9pKxxVByPuwz7LV9z/E47PDD45d33FaVVoTzmvvETx7aJ3784EdixoK2jgctre0dRfn+q7Uu6osHx4rL3LYEmLTnFLJ5No6dfa+HpL0GCKbiQ3oopcqIgsgl98xAtrk2FnSHyIq9hs21b4wvvcMZlrKj44HUGtGVjsAkXSiysGD+rDj8Y4Nj183Oi+LEraI47dNRnHVmFGf/LoqzfxPFGd+I4uS9sr+1zvp5/P7skzIHGvDl+HG2t9tu2/jckdXNRU3y6UO2jQH923K+6TrP6Pmevef1KucnLy4A6+CGD/pe9sp/lvRWeXdTKIzUukbeYFeEIZb/IpwJLCg2efGVC6Ol4ZtRK6Fkn36iOU78yuAMAEgkx54JVXVH0pnVlCYDg7GkzBgp4FK7Dco3r0CNE2UM3CShzIXQsYj5Br2AgKrmdKQgMFauaAXDp3BI8Y77EKbloTMEDKAwc0dghyHweewKEOk7AX1gTLi5sywuJtXcCgEDYYxUXtwTEA+IYyowoJgzuaBAHPBJGCvXcD1GLN9KqTOCCcbkCsFpZ4JdAroZGQUW+QKjNP6YlHQSDodBwUiq9lds5V5ck2BqsJKMr5B3e8c8JiOJHcNipt6M1sXBO3wuJj69sCo9KbXaGjx8YJx3zw9i8LDyx2p+/IBfx7RpbaC/FoL9bGp+KdZep08Gsow70FGuoIuce+Gl8dsn21rt1FJevvjnMX/i+CV+DyRy5OT3AoJe5pLDad3J2wW+AFGpDgpDKoXwOcg+IzR+7R13xMwD96v6c9QXWmKrMa/EHis+FeuNGB/9+iyeS9fcXIy33qiLf/+rOS78y+SYNrU10xlJB8lV9KpUpEY3GQN70n6gvzyTdj32iGv5LOAMbNNRnWXlOyP2Jh256QYRl/5+uehTPykrJuooo6q1tdDm1P92Zmy5419it90/6LBBR3/iS7+PxgFjolAFZ0oB2ZqrLhOf2ne1+N3vzsn0ZSIokAF7f2HT2OLTS9ek6K4u6mPdoR+KfZb7avUv3itVkd6QdzclNQPuDkOZQt4MqVCoSuuVVtgtXnmndoCSsn38sQXx6quTMraG4QDE5COWFnp0JOkcZ+ARIAVQ5VbJt9OEHKji+TNI+bwkQKf0uzB3JDGUSeRo+h1wCjRiVISWShPRMSNYOSF8Sh9DoHAIwC3NGawkDEm6b2Pi+wBTxqcreVWJoTS2ie1LYq5V0QJ5gCZAaQzlOwFvXinPkpPC2QC8uwomCaOvjRBmyf0D6+ZH31RsqRQFQAFIT8wywyjEbQxSTzmSQHEK+wPDrovF8R2VwCQ22nzpGiCc6PoJWGlWj/0ZNHBw/PATv4sn7h7XI1YDmKxvrI8fnH9cRTBJWmpUBJTEEXRDhy0Vjzxyaza2KX/OOgYuE8j0E0j5/NGfjHW+eHoUa9iTUw7j2+OejZnTpmbpOfIg7S3z716sFb83R1JhUtpGXkQDpF9IGUnAMw9C8/+WxrHNJ46Iz9/wr6o/S0uxPu59Z4247501YrnZc2LVV+6LefPHx4yZ02LCe7PimadnxcIFi68jezjNQ3JcAEO6wR7kxAJx9gknLvVkJdJg5DDmj1AVgjZ3aU1XS4yxtJyffHd0HHt4SxQKU7LfdyY9v65Od5BCfOdLQ6PQ+LsotmwahfplsggDXTZ2+VViza0/E1Onz+sRK04lNDfNjct+/7U474y2xvb0sQgSVlS7o5a6hfHLcUdkhXHVltZoiU1H7F316/ZK9aQXUHZTKKXkzXc35A1wCb1Q8A31S8e8OaOjb793q3oGar7K+5NH/CbWWqWtdxoQyMMGCiV/C7OkF6auvRCrXECgA0hxfjGWCoCUawRgYmUAR0AvD8jKhbyFgAFsbEkS4FCICfChpIyzog/XwoDkQQwQpzcb4KOq17hiT7sKkuUeYkIZRDlj2ENGp/Ss9c4AynRWe17MMZZOzmcyUK5dLs+SuBetbrorCVQaMwofqPQ9ns94A6yYQ6yT8bKOsaelrYMYT2HtFMYHOIX0rN3SkClWF2DBRALF5gK7xVD6vzXje/PFICf95bj48bF/jIdvebbDqtpKYe4+/Rrj1EuOj7U3WzKlIS/9+/eJmTXIJ1t0L3V1ceCBB8ThR/wsAzIcBvsbM+yn9Yz1SpIVMrQuiFl1/ara1DwvKy09PEYOG5q9AFuOge/FumOdgSlsOiaakyw0a91ZBwpPOBBeQGf+39g0//ae0hNdRu69Zwze+cMdNjDvroBEr8yeHXf9+cbMsbHvR4wYFZttul6279wb50042jOnyIZ1nW/Ejn2UXyw9RhSDc+q96dSfUibTupeuAnhWKmjqjtgTgN9F56wTH9srAfquOz/ZEmp+OYpTDo5fXLBVfP2bZ2R6U2h/YUtdfPmHV8Qb46d1KyIgPWX+vOnx7D3nxjKjBscnDj8+i6yU5q43RmNsNmLveGjKNdmJVdU8JWds/7Vi2f5rVO2avVJ96QWU/wu9KBl0ShiAwEAl0PXic+vGBptVv8cW/dHYsGyssurhseZq9RkTxqMUtsSMUbRApuP1KBtAKg8wKY1k6DEb3id/kbLCVlHcCmgwGBqdK+gAPFQeCxl3BChTi5UkPgM0pkbBCn0UjjB+Kp0ZQmMPhKm0JIwKttW9K67RysN9lKsqryTuH8gDjn3es3UF4ACU5hZwyjdDNg7CyNhBxUSlkvIsMatYI4YM+MQKMXZ+39kcxbx4dsDY+jKGrmOcsaJYat9pbtO53olBzgNKQF3+JLAobG6+rJVUzYv9EfbCRMoXw3ABLRhixtxzY18YYnNVehTk/IXzov86M+L1Gx6J5Rs2ysJahU5k33G6WluKseG2a8RXfnFELDW28jxjrTlPEYpEGLlCzSq9V1m1rT0UYMKx8krnrdtbqYBNnqv7evnem2Pp7T/SqWfuDju5+4aLG2BzbD6AX3MHUHEgzZ1ISX4fuseOxFq1r/Og8/J3347HW5trcPjeBzJmxRXjtYULl8hvNsYK2OhW7GOe4be2PWP+SNQEMhUbcbLl22ImibVqjqxhAJPeASrzOq2nYi9aD+f+cuf42F5vVOGKLdHS9E7ssMGlceqpP4zvfOf7i1oa/fGnR8Z5l90Tl1/7aBa67gxbmYrYCvPfiKP22SA+9fc3M13bnuyw9BHxwsz7YmbT5KodwVhXqI+Pjv1y1Y8n7ZXqSm9Rzv9CL0obHPgQElTNnDb8g/cNiVkz66o+LfbgiMGfy6oBk0igVhjCgDByGBRsAwMDeGAJeaDCpEJamEiAizLFsjgS0eYWIpI7yQuWsyhkrCBi5913j9eiGCffeEMce+3VceCVl0XDoQfGPUMGxu8feSgefPut7OxqACUf7maQAFZVyXnwQaFjxQAbDIL7wrIAaPIAgRVhRsAIi6mvnM+0AYnOCYMjAR9TIWTd2XZBSYApyhaQk5eJpZIeYDz1kJNXWkm8F/AQFjaech8BbaBaEZJ0AvPTVWFgMZSMPiOLWbHe5IwmdiH1o7zprjti8PqrxGt9F8TdE16Ox999NZ5+9plsrWCKGV5Mo7EXHrd2sZQYXWwP0Oh5gVhzgukSEvM5jkt+Ps0zRlseMidk2/3Wj3sn/zXW2GaZ6Dew7yL20TGKSeobPli/62y+anz3vE/Hj/96whJgMvUVNJccG/MB5D78yK1Ra1ljjcrMOEYf2MH2Yi+tl8M/vEU01ojJIx/fav1sPOQXm0M6C/svr9CeBaCsK3NRWpTWkaQuF9JWfFZ42FzTid1pFdQV6dunsWyxHJ2kUJDD6+W525MEMgG7NEeYe+FijpTrGSdjJ9+dYD+BTMwi/dUdxs/YccSluPz4lM/FMQdVL5fWctpkg37x3S+PWaw/psrsLxy1Y/zxjCNip23XylI02qS46Bn8BCLT7zdca+k4+9SD454bzo4Tjj+uQzBJ+tT1i/2W+8b7TlJ1AOBuo4+LEX077krQK/+70luU0wPB9FEoPP6uCBAE6DCq8pZSbpmq3lXXeDc+/flqeKpJ6qNfn/VjhaWvXQxQpjAvRq3S8ZEMHoYKI+UZ/Vs1tc9gvRKDieGiuIWatt5l51hqt11j3mqrxOymhYvUSVK5mYp5vzfdmEGDY8Zd98RmDX3i/PeVNWDIICj8wPTlhaIHYjAJgDDgJx+PYA4wLebE582LcXZPwsrpfR0J5hgzA1ArUsmH4jsSp29gTX0fMAUYMlaMB8azvXN+AWgtjIx1/ghFwCOdG04YSUaoo1A8ow7su6bv9znXBgCAW9W5AED/ZUfF5a89Eufe/++oGzl4ieu0NjVH/ynz4q2/3x6nHPiZePv1NzI2UpjU2ADLmGF5gebVOjBHmDCV8/6d79Pqc5wSxtnv9TrE0ACmqvDN2Sk/PDWevv/lePmpN+O158fH3NkLoqGxPpZebkSsvsHyGZgcu8oHPRWtSeMr9cJLmB6gB2YVUAi7e40atWJ89ti2cay2FIutMXfuhNhgo/kZ4ABgjQeGC0NtbQBbDDxmX4QA2LWOf3HtXXH+nY9VpThp0f20tkbT68/GGs2TMnAtBxn7zWnhmHEKjRUR7jbu1rz1K/xqH4i+OP2p0ovuyvdZ9CzC5v232Spattmqqz1+uiSbjRkbVxx4SMW/p1xqDjIHszO50FJ/REHSQQ3Wr72nVRCnC2jW11UKg7mkjwg9pYAwhcq92ksbEuWhj0QhsiNaj3g5YsFNGbtYXWmIwlJ3R6F+5GI63Zhw2h965MloHDA6Bg1fLjv7e+iwEbHc2DGx1WbrxUbrrRQbrrNcjBq+ZPP0zspLsx6Ov735oyz03ROmcselj4ptlloystMr/3nSCyh7IBgZhRMKLboivF2GF8uXlBfBBFH6p5w+KGbO1ay7pwamLgqF/rHSMjdEn8bVlvir0A7miLHpTGucVHmt8TjAgKVS7Sgcy7Cs//EDYt7WW8RCuXCdZF0YPjDmTwcdGmsNHpoxVlg5RRtJMCwUuxxALBcmFCDCqgrVJSaR0fZMGBOGDdAAaABeY015dyZ0zOBTuq6lYrwr68H9ALrCbZhBzJ10gPaKa1IhkMIgAKucYJGAQwwKQ48VlA8plJ03XJ5dvqZn9qxYZgAUy+wa7gnYbBw8IEZ/ao+Yt+6YRQC/kjjRplBfFy2z58Wcy++Ojyy3fhx+2GEZWEsMiGtijLHu7s2zYFaTCN8rAPKsHChMnXvLOw0+B2Rih9oT7D7QmAAkMGmNYP6kRCQAaS+lEG4Khd5z9/wYMXzlLA2k2rLGmgvjuuv/lDkiqQehVi5APJFiQl+Unoo0v6k59j/zwnhn6syqMHv2VOv8OTHuz6dF68L52dqzblL7LWNjrKztBA45YMYd4MdC2Tv53EiMpufhRHhJLbG+ABSACxjloGT6YJWVY9kvda4XZ3ekoa4uPrnhxvHd7dvPY7Qm7GWOFNa8ozZpum3QaeaM0I1abtl3nH06QdpHEvswn5PpBWTnQWYCmMAmkCkVRrTH+rUXDthvuyhO+lC3ciY7lrqIQV+O517fLnNIOeKc3OS4pL7BdKM1Uc0ioyRvz30+rn77zJjZNKlLOZVyJhvr+saeYz4f6w2rXr5qr9RWegFlD0QIGLgpVxnZngilYPsY2TzTJPyifcxJJ30n3plyXMya++8e5OrXR6HQN5Zf6rLo33fzsu9giLFhlFueFWuPReNVM5hyxLAAQsN33nVnnP3cM9G63jqZMevqUV/pEbdvibjkmydmxonxIvKWfC9FCIAIjzKGQt+AOUORjmoU1gVijCFQlQQb5rPy2YSpgNZKQtn6bqFB7CbjUlqBXkmAV2wQ718jacJI53O2SsX4GXvPIvzYUY4QdgOYBrjTsZOAJePld8YCE4r1cz+lbV6Ayg8fdWAs/NjmUTe4fwYUuyofWmb1+OlmB8SQPv0y9tP4AtMABtCuoCg9hzZBQs+AduoKgOUpd2ycv3G0Sh007DNDnwCka1p7ck8x5AlACuOXO7XKnALVwMEpJ/827ri9Zw23S0WF7dJLD4mzfnVQXHll21GkWD9iHHw/Vjgx6+Xk2bcmxCd/e3k0tbT2CFRmvT2LrfHW1X+MmW8sHsI25sYnn99LAMgEFu0resFcOXeckws8moMEmoy/n6nwDFACmNJrrfXXj52uuCSaqtxnNC9n7/XR2HO1jnM8PQ/WkfMpD5uTUUkw79h2zpH9L83EXEoNkh6C6exof7YHMu1L69ZL/rI85pWWvjli9lk1AZSW0dvvtsRKm76a/Z/zx97QlRjSvMNXS2lqnR93Tbw0Hpn6r2guOmbSGBYrAkl/W2vIdrHr6M/E4MbaHUfcK9WXXkDZA0kKiLJ1okpnhSFkiDGDeW8aC8A4C4ed98ffx7hXvxmf/uyg988e7orCKURjw8qx7Mhzo1+fdSu+C6vIk6bcFKJ0pJgZGQwagJCEsfz+7bfEpc8s3ianu7Lam+Pjpp/9ImNMgCIAQ7iJYgcYSu/fWPH05Qc6r9qzADWYutTXkTCCKpqxWwBZpRAYkK+qGZOE0VKRrXK5M8nglDQwJKwI1Po/cFlJGGQGm0EHRBmuzopxV7kNYAthJsAA2AGYlXKd7p3wSnz2/kujGfvUzZBkfaEQqw5eKk4as1189XMnZAxQOsfbenJvjLeQoYIdoUTrCwvbHkNs7WNLMGaYXeDRtTWNtl8Y+QQevfLFYu2Nk3VkTUhFMC8//9n1ccP1T1aVpRw24uW47rpLMrAAwBgPIVK5dpggIWbAzJqwZss12Xeu9/Hn/SOaWlq61d6l2NqSPe+b//xLzH7t+ex31oF1Zd2no0GJcXMPHJ8UGZG2gD3VHcB9ctCMsfSTpKsAzzx4xL6Vax11wj//Ede/+jIUE9WWYf36xf1HHxd9O8mo0c/YWeyr9VQpXQQY5NTT66IwAKUoBd0sL7wzRUrlBIOLubcW6CwMvd+R6y9dIXb9UN9aDNMi+cRXV4mPHXhclmJRWhT3PykLWubG0zNuj5dnPRzvzHsx5rV84Ng11vWLMf1Wi5UGbhgbDt81hjT2Ni//vyi9Vd5VOi2ns4BS+JNxAVrywotN7Jj3nPD5L2WGZ8Vljon3pn0rFjY9H81NxWhoLG9AGUdGAis5fPBxMXLIl6OugzNPhbmFCPVU6whQYiYpZuxSXq5+4fmqgUnyygpj44RTTo4//uS0LEzre7F35YBD6VGNQouYKOBBiJxBSML4YQuwAnJHhc89cz5pnQBA2FfvAWLlQjIG5aqzS4XRNoepWTxWqpIASPI9MYbaK3UFTBJrxHOm9j1CrEAYEGctlcuzfHHmxDj+gb9GizM+e5Df1lIsxkszJsbHH/pV1L/zTjZmDLZn4gBwOLBcQIr5A+TbO+/evDH0xsE1UjsiewFwTCE5wLQrVZ5pLoyTEDwwSYYNnxSzZ0+MgQMZrZ5b8ldfuyX6T3g3W1NAM70gxAxAcEowx6mS2JoSSpUSIddSKJWRF+UY3DQ7vrjlynH+I6/GxPnNi/Z0Jx82FkybHAesPiJ2/cOvF4Wl83qJU6VoDVun1ZYQMKCERU8nNtkPqV2O/SVfEIPuWRyGkPrvtiee9Z8/+kk0HFE5x7EnleuHr79hp8Fk/gQpa4gjac9gVUuFw0Iv33HvLbHlR9aK2SNejzV3HR577vLRWGqlwd1qa5WcVEVPIh3y1a1vgNI4bbf2t6KurvxpWdWSi/5yYhT6/u+HjfvWD8haCnmR+S2zo6l1QdQXGqJ//eD3iZNe+b8svQxlD0TBBA8ekyL01hkBIoT/hCqF8ZIoenENPyWTMwhYHowORTZ/4WNx/U0nxNDhr8byK9QvXjxX7B/9+20cg/vvHUMGfjzq6zrPlgoNyz3ElrWXR8mYYJ8UGCSZOGd27HzhX2Ju08KqdRwTsmueNDkOK9bHSd/9bqeqCo0PJoHSBiwxvfIYMRKlIV95YVg9YFN/RIA0/x6/Y9yxfwSgBN4YhfaKaghjJZWBsRIqx7gBDeUE8MOmYj/bA56lz2lNACSqwOXGeWbrxdylPEtsLYPluthK4KW52BoH3XFevDRzUhugrIYUi/HVtXaKT62xTcb6mgPPzUkBQDAi5QywkGIKXwOSUguIEJw5wzSrgPX/7rYJMVaOeATmjEc6Vx6L6tqf/MRnohCbxdtvT+1eU/U2tBfx5nux9SbLxHf+/JUYMLiN/QEapWkYe+2TOGIpV1E6hzQN64QjCsAJg2PBFkmhLlbcYc/ov9bm0TBwSBbC9rtSSa1fmufNjk1H9Yurf/mjOPGb31jUSqsSU5YKpdLhCgTLaLxT/iSnJBWdEL+3N4DQ9k4AUhEtF9HfN//Ot+LGt96oWsU3MLnUgAFx85FHx6Ayp2Z1JNadtUno2Xyv2rnNM+LJ6bfETeMuioZhi5/Ak6RPXf9YZ+gOsenwvWJ0/7a2WR0Jh4rOp9uNfX7MFHIVJ3S+z213pTDklCgMqD6475VeKZVeQNkDkYsEjFAa8lI6ElXdWBehJUZEmDOJZtDYMwpP/pUwX+lJL0JWQlR1dfOjqeW92GabLeOsX5wbI4av1W3Di9VSkQrcVkpady9CW3LAJLknOeWu2+OiJx/PGKtqSgag/3ldbDVk2KJK8jRm7QkQiYWSOI+RANjkuJYTQA6bhN0U3mYAhaMY1tSkncgX5TQIYeYLqEoFUMWoYikBJPMEuAIVpSKkCGwx/O21EsqPB2YDkJTvaiw8G3arHPOHbRK2k+Ob8izX/vR+8eTYQtUbaNcVI+aeckW8/uRzWVENIKlYJy9CpglAeqUcSYA4ha/NMSdKyBXg0Uu0u2K8hP6BR3MmfxZ48juV7+aWQzFnzoI4+7e3xE03Pt019gkAlSv88ltRmDA1a200ZOmBsc0JG8aNd96QzS9whnkEIvM51r4DE0YP0B1Cyfa7YhYsszWZWnJtvc02sXDIMlEcuWwMHrtK9B81OstL7NPQEKstu1RssMKY2HL15ePCn50ad991V6Y7sJCcH1GQlO+YXu4lCdbRWlVIY61iT1Peb5J0vrt9zzkCNFPleukJQNJR5BhK8bBXMMILCxG7XnR+TJk7p2oZghfu9/HYboXu5/5JhbE+jb21OHzEsHhwytVx58SLoqXY8r6jUPnz+qQ6sWW1QZvHXst+od0cP84MhtycGt/So2OLxeYoTlg8UlV9KURhyElRGHB4jb+nV3qlF1D2SBghoUrMjNBWR5KO2BM+ZUSEBZOogGVEKWvsWDnG09+ATn3k5D0BpD2tzHNNIErFZwJRpcLAMRaUcfq+uU1NscUff5f9rLbQ58OaW2LwP6/PxoghE7oDeBPA9Pzl8vGAQ4wdo81IY7wqpSMo9BGOlevmhBoGkrHBSLp+3jBgu9xL/vd5AULNIVYQWE09JEsBo/tJVZ/GtL1QMBDkebCZKuyBACAUcOsM+AFsffYqBTFnHRcNI4cs1texGqICfPQLU+NXH/10BizsCSxcHkB6ZgJ05AHk/2vvLMDjrNI2/MxMPHV36qWlpRQv7i7FFpfFflhgcXd3lrJA8cV98cW1uFuRKnVNUk9jM/Nf9wkn/TqdJJPMDAvLe3MNSZPJzGfznec8r5zOScKn/A7nCMezWdsTj7tzgfNOEQ6V58FcW8LfwbXZy5eu0J5rnaBYx25Sq+JasVjb22rVF/Y/R3AgIqfOUahq5bUfi8dUHarUZ/G31b5bW1fR7Suigw/2LTESwGeQ4jNa9jBx8M4h55ioAGKOvEyud3+/wQFNjG5w7DjeXPt+wQWEk8915CvngmuZySmCF4cYRxgRynHhek3mPOJ+kxvMduJAUliIGCUkzrXpcyyJDvicTB7VrVvp6snjFcrNTXvlnEu23EaHDV9V9DY3ssTxGrh2Hx0xZmPNq5rc5NeorUIu0J49TtfAlhut8jvOH0KStBuuRT6DiZ9Xzi9ufv/Weyuv8QYbaRFqfb1ChSuNAMPIFuZQpgmJ7VS1BgtVksGghmBhYEBE+KW/PDhW3Kxxlch/S4QEed4HsYmgQIwwkDTWCiMVqELG1SIUlwjhOnJ+CBMGXaOXJ07Qia803N4lXd489K/qXlTs3BUGPh7BVkUILFwZBgcGOF85TE4o4TkcmMZcQAZWCo0I1TEQ0pibwTMo9Bjw+R2DAmIzKOKXLa/Unfc9rquuuUGtW7XWdttsrpuuu0QjN17fteTwDZMBYcz2kjPI+a9vHWzeD4eRgYjBj9fBkSR03ZiQxFFFjOF4M9gTpt/2+EP044a1K7hkg1aRfB0xp43ef6/2HBEuZTsRFF5Ast/17W8QHGZcWPL8mgqDNA4pwp7BnEke7iATOD43vhsAbjLhXxy7+898UhPen+qaMMdbFCresa3UokhqWURMubYYFeG4ZLlCS5ZL88sUqkneLxBR2bJboZ6e9oByAk3YG4JtYdtY1YnJA9csKRN8HgnRcq1xDfuqXCZHCDvuO955ZGIEHHPEKsIdNxYByfOC1wxiFLEdLAjk3sTxwlHnemECFazUr9u/WMzd56j+5ppEoHOuSQthu3lP9scvNekr3XO7dlG3E/5PYT6fTXTIKQBjOy7balsdMHRtZYqPv35Pz5Zerpad8tNY6ra2dfeoHmdpSOvN6z7j9HxliVVfKEhPVMQjbq9/8Pnn3vrpqz21/vCCjO1X0q1s/6JCufW3LTOMTGGCMk0QdFT/0fKlIbjBMJhxoyXPjRwqQslAYjyDL+E+PxgHQeQg+hAitL1BQDFAE0Ln5t2UCvNkEAYkNIxoTXT92FZCkL6RteeaD8fqvq+/VE0WW4PctMMuGrXmqmvF+lZFXmDyILyHAMSF8ceGY4LwZrDkZt5QH0iECO4QN39WVeEcJTY0R0giYBlsDzviGL345vd6+Z1xmjV31TW7V27oMrUrWqb7x1yqdm2K65xecjYRxWxrIogIriMEEVXunHOEZGMtnRDAXBeISCYZuESE/elAwATmlolj9eCkT1weZbaYduodGta5V52AxKFLzF9NBQQ4brlfxjJVOIccKy94mKDh0JIfjFvH55Q8RUQkuYEInw7qqnVCmyrTHHv9Ydrv9N0b3FauMQQu5wzhyD0EoUgEgoknz8ExJHSMSGTbcSd9pTY5jcFm2vweFxbHnWuA+0iy6AXOJgKWe06yyQiTWYQtRVYUFiX73PD3RAF4T8QSApa8cN/qC8jJJlWEY0+f2N4DB+jDSEgr+vVRPBpt1K1ESJJKM6RjJ920w84a2D5zVb/RWLXunXKKSiqmKx5KP10Ht/LwPtersKKj+7zh2FJI6O9VREAQ49zXSWvge1x87jXXXdhCh+6br9x6ii3TJ1ehzt8qFLL6WyP7mKBME9+Khpy9hmCQBUJSDBTc9BGD5GHifnEzp1VFYpsZii+4OREepBqTSlfAlSDEyN/4JcGaC7NlBia2KZj/xqBGXhWOCXlUQQ555il9NHO6stm8+IjhI3ReI82L2UbCdWw74pLj6/u+MTAjzBiIKSZqqHAKt4AbPA4NAzF5sTiCQf52wol646OZ6tp/c+dcNVhs8OvvWN7swD03UHjFRP3fsUe7XCoG/iBcP4TcyflDXOCokX7QUM88v+IFggRnm+PAwI2IJM81GLY87P379XlJJldfWp1L1tpJ+w9cNfTXHMg/pMKe6zuxtQ4ChnObbNUWJmgIRd/3MQjOHp+bYOi5IL9AT576qqqW1GR8He28wjw9OeduFbdatXKf7cTVQ0gi6Mi5RZiRY0d1MSIzmPOIO82+MEEgnxoxyfXBpI9uC1Rscw8AnofA5LkcC653RHWy+xXXDtdMfRB25x7F9uI6ci0G280glJhkcs1yvMlHxRn2E2GuZ/J2EU1sJ8/z/DR/vsZ89L4r1qnmPMXjv/bOjLsWQ76Hbduly7VFq9baa511tc7w4UnD8M3lvfkP64MFT2Rg4YhamKctn1+jm3Z7S1UVtfmlTKb8Wu6cIzou0A0BdxgR7tlhq1Z65bHGK+ebR0TK31Hhtjdn6fUNY1Vs2pIm5Cv5PoD14R01ch+DrTl86xicRxyHxAGUvnnc2KkeJowZdHyY6RKm4oaNk0XYqbkgXHhtQsVBQUnOIIMcYbJESles7GmXDRggF1ZUNPo8BjEGYx44gPwduZ5+uUiEIQMogh4hscMOO9TlYQaXR6N6mvPBQMvgyDHH7SLUz3OmzSxVaXy4OvVZI7Wq4F9flyrcR579TOXLFuiwv56wiphkMoELRJoD7jDCgpyr+vrkIajYPkQkYhKBgfPGdcCkI3EFFs+0ZaXKJjmhsObVpHc9MMgiFjkOQJoCKQxB0eh793kQGbhi/C1iEkFNFABXGpeSz5Tvg+kd4Lpl5179WiO0WcbFJFRVVOnNh8ZqzxN2chMVqnsJafuuDbjH5NfiPOJm0QkAF53rj98jQJjMcE45DnwuvUvNOcbN9CFV3En+HmHKtYrDyX0E0ZpMUHKcGlu2E2ef9+dzzwMRTHET+cG44Uxi2RciG5wTnGHuFbjrTN7oCIGY5Fzg/AcZ3KmTbhm1j6qiUU0oLdG4+fO0oHy5li0v19KSElXOmq3548bph6++1u0//KCbf61+DxYA+a/N6QKwsGqOPsygmAQK8Is6RbT1MWtq1JAT3HHiXkPkBDHN5xO33E90yIvFySS9Y5ORI6WyHaXojIxuUy1RhYqtGMf47TCHMk38agqJg10QRB+OAW4ZgwiNlnFiGAQY+AgXIQgZ6MiVwgEg9ITYIETFjTtZ+IobFH9HcQ4J8ojb5oKrhfDCEfWwLTh+uEWJ/Rp3eeQB/VxaomxBWKzm+x9U9OEnzjlE8PI18ZHs54S7/faSLsAAzEBM3hir5HAeOHa4Pl5cIj45jvyOcCgpAAhKlkm75IqbdNY1L2rFiqpmNZx2+xOPqUVxgW6/4kC1Lg65QQZBgBhCZOIEJVuRB5HBtiEiEREILpqt40QysCfrp5fIyP9cp0VVK12RjBONq8fUpVp7jtyxR+gFv3Ltsp/kvhIKZaDFaQuKRX4WBEeMXonJClt8j0Ven7xeRBfOD4KK65VrGVHFZ47zTmoJny2OIcePfNvBsfU088v5ikUznwaAxunQp51i6y92zj5CltAxUQbeH0edzzj3AhysYJPwtdZaq64amIkm248gpaIfuH75XHJ94iTiePOV1+I5CGgKf7juuSclrkiECGPiQnFgKvA6uJHkVyMy+Td5gkyOvYNPERoTY3++cV8RpURUEu8bTYGJAS6tz8nkwfeIWiCagLAMikyOHy5tfbw59159Vvp8WmtL10dhqJW2qTlTt9z8Txex4hoPwvHiOkxcoSa+4gXFF5+R4a2JSLnrKNTu0WZ3ADGMpmIOZZog4rjxM0AkE32IGGb4zOJ9dSe5YQyuiEkGRL8CDAMlAw4zexwAZvdUVNYHNwrC3QgMXIpUV3SB6pqZWlbxliqrvlVF1Q+66OqZmje3RNPnHaqighGqqRqiJ598QhdddHHSQaFjcbHGl5ZkfE4dpDgSUafOnd0AgQAkH4sBhmPEA/cnGWwvg40XmJwjhAxfcS8RiXxPmgFig8EREYk7hEDHzSQ0yCB/9LF/03HnPqSc3EJX6NtcaNq7oqJaR51xn75+4wbVVJc7h4JqUN/I28O+4lwhgHCmce78kpJMQjjfXmySR+t7BvpH8N983/KKg5XboeEemukR14xfpmncMx+6cCeCAzHQ8PGoLSDhmOMkIvo5VxTu4HZxfhBIiQIVoclrI0ARRQhJck4Rk+T+IbRx2fnscPwYwJlsIbL4LCHGcOgO6fu3rIhJ+ULwySX6eOardS12aJXEdUyLLnJ1ubY4jw2tHERLK/6G69TDPcaLUYQzD4QLRWWIS64HHsB67r4anGsqHqty10RiO7KGQNTjijMJpmoemPyQI+shQkKIHlFHrjWOMA3u0xGTwD5yjHiQX+r3g/0Nikwm50zO+B33Vs5vUGTyQMxH4zX6euGrWRGTsCK+RAeevJN+fne+c2o5DkxQOYaMAaQkJKVgd2nFS1LV+85VzAwRhVpfa2LS+E0xhzJNqLbmhsrAnSgMgLw4xCSDgg9JMrBx82cWz40XB4rlBXFUqEz1RRaJOXyNbYNfWq4hVlR+rtIl/9TyCu9Ekhy/spFvPE5VJQNBVDOnRzWgzznq2fVEhUK5biBHgOECPTVrhkp690y7FUhDtPrgY0159XUnvgHhQaI/LgQPBg5CnrgwCEYvNHkE/80gx6CIu4PAx4lNlmuXCAPi4JGHqXXHwU1en7w+yBfr1KZGd19/7CpLQwLuD9XdDD4k8iOwcE9xsRAWDKRBoci/vWDx28vAiWDgWvSPjwflaWpuRVbF/6wbntKyj390QtA7iGwLAtG7xgyyuG84dkwGOK/JviISEKaEBvl3sI9jMhBlCC3+hmuEf3PeOcc4uAgLJm242YjS/EiBHjhy1ZzgbNBpt0JtsuNGTjxyDpuz7B1iBNHIfQQQ3kyIENGJcD0jruhwUFhQo4P3aan99+6jdYdFVJRfO/mqrolrRVVntWq/Re3qKfnbNFiwwUSLFBAatDPR5R7GfYbtoGCI+xbvywSMSAvXNPcvJj6Ee5Ot2Z4NOPc4o0Enk1Qjf+1w/fVdt4v2u615yyemQrQmpiVfF2urDoe7iQ6pUPShJYrVkGsK8egCxUv3lWLzMyIqrVWQ8d/ABGWa+IIWZuiJlbvcjJmlUnWMgwDkvRHaRNjgbDLIke/EDBxXDSclWHyTKr71Dc5WsjVnY7FylSy+RguX3fvrcnON37TIlcfwXLKoncaMbqennviqbtBee689NXeDembcGeK9w49Wj1atnBgnxyz4ICeJbQEGLXIovdD0D4SNd2zJR0MME24kT5G8Rb4i7jlutEwhBwyBxnnheROmLlKkQ207kEyz4cCoWuWvcGFJBj9arHgRhMsSFIqAMAuKxETRyL8Z7JO55Lf8+I7umvBB5lbIScK/hu6j9XoPanC1pVShXRICCheS44ETizDwgpN0AcQK+YLkujI5Y/D27h1ClOPB5wm3NChWuWYKVaxNQztnZL8b3I+Xz9MGO6XXN5Fqa869z7/mOif/jjSYZMRjC/XJmwdo+KAprr8hE8Tkcz5+yHruHRQqPlYqOlSh0KpP5B5FWgVpMAhKXErOB4INl5UUEcLnHHOcdCZ43H+YJFMwxOePiTGfxWzDvRYXmG0LtufxPVCZbG1yYD/teM6ArLp2uUva6/IdnnHnjI4OvhgzFeI1MxQvO1SKzWumqOS+Hleo1aW2Mo7xX8FC3mnil++aOW2mhg1dW7l5OXU3LHKbCLH6wYCZPAKGGzXujS+yITcOyO3ixtzYEn/JYADmxs8NnrY0wYG9JlqqmQv+ospq+sLFU75ZeVOuuGWpzrywTFtvc5AG9jvSCedYKKSN7r1DS35dAzjTzbJbr1ihsqlT1XP4cOcs8mAg9SAyWIElKDIZQCjC8a1VcKO80CRkzOCGq8KxosKW6lWEBueDSQH944KcfsW/9fm3U5u3NF8DxGJRvTZ2on78CHG/Eq4bXCwEMtcAgxIikWuM7U2WL+p/hgPD3zOwEvIM5id+t3CWosOa7o6lAld6t6I22qj/WhkbqMk3RFwzaWDygphECPIgjIuDy7XAeSa/j6+ISSZSiBjvVvLgb8nfTCUMn2kysYAUDrzv5wheNCd9v4q3FF98njYctjiFc/HrPSBWovjSq6QVL0ptblAopzaPlzQB0j9w+nH3Ee4eQshEVZiAcfw5toh4qstx4uhhiStMtwJC/LQe8yHrTOBX8OHhBSTuJNsBfF5whNkOX2nNNfXhwsf1Scm/3Uo32aK0YpZzcpmwNrUyPZTTU+rwjOKLL5YqqcJ3nfRT/Otw7eSAMHd+5lthGUYqmEPZDBCG3733o9578iP9+MkETfxmisJudii3nu+A9fpq6KZr6pF37teS6oV1K+L4NX4JWeFsMqOm+AaRQ6jINzJuLvRKpOqXEDv99yAaW6Lp8/ZUVQ3L3aVzI+XmFlb3Dg+oReE2bpA+4J836zsEdIbCwUGiL76i6W++5QYywka0kkklJwuhiYhPdDRxHP2AgwhDaOIEemeLwinysPxAPHfBEu173Mp2J9m4hqpmv6Ttt9m0dkWR6up6Q/bBn/nwfzJ894DEnzG56Hbtkcrr0THj54qjdVyvjbVzq751Ai74NdnPGvqd/76xdIQgiGkmHHxFjCNCE7/67xHs1115vXr+Upu3nE1Gf3iFhoxMr6E0xTfkgfplE8nDY+JJwV6Q+PKHFF96eRNFSJCIFCpUqN39eurZn10VOuF2wtjJisXg8ssvd3ngHFPuB0w0CYf71aQQ+jiZOHV8vsjBbCz0GwThjJgOOo4ISN8WjNQGJovB9jzkWzL5SsZbc+/TZ6UvKBZI8ck0kZoCnTP86bRfJ17xmuLLbpNqfv7VTY4lOa+MFTVSqIVUdKBCxccrFP5tUgwMIxkmKJvI2Kc/1n3nP6ZZE+cokhNRtJ5VM8KRsEv67zq0oy577FzNKJvqVpegDRAzV9adJh+QfETEDU4ERTXpQsUrYhKhxMAzp/TvWlL+bIaSvUMKh1po/Lfn66QTL9bssjL1ueQCVUfCGcvPo7pbC0o0epMtVL5smQvtkU7AsUJY4sA2ZVDy4NwRiiPXC+cCoYULg9Dkd8Dr4vbxtaDtALXrvb2yyYV/30U7bjmkriUQuZHJeiz6BxOOoGBkQGUigkD2YgnxyL6xT+QqMgjTnqjVFsPU7ZR9Mrr95IPGVlRq8nGjFVuevMUTYj1R1DUk+PjKfvA5IWyKy0VOnr8OALcJAY6wwP0nZ7DRbY3HnaNN7iGiZ5u8UQpXZy9Aw/t92fItjVh/hHPpeCC0gmkYqcB9gnZYnEvOLa9Db9hgO574Clytc9Le5lgspMrqsNbbbrJGrL+PSyUg7zUZiEPyvfm8UChHmyDSbhB85HFTMMXvOA64yqynTkicKAEtzxIhzSToOPLAoWa/geOGYPTikQeOdFMm4GPnP+paBmXToWyd20knDrwvY68Xr/pW8cq3pervpZqfONm1AjPSQ8odrlDe+lLBDgqFsrvajmGkggnKFFlSulQ3H3en3v/3py6vMFUDBWHJ82flT1H7dYv1xptvuMpeXEnCmrQEITeJ3m2EhtKFWb1f3u/Nd65QpU5TJkF7vfd2hV54aiO3qsn0nLCOfen5jAmUSDis7u+8r7HPPe8qchESOIx8pYcgAgrXg0d9fRdxS3wBS2IFNIVPuGAMzj4H04MQQ9Qg2jr23UZd+m6icDhLRUfxmMKV07R87iduGxPbTrEd7CthbwQj7htiC7FLYYsPfdbn9OFokoMYdPp6XHCwiof3zWgh1awbn1b1l5Pc9nE9s62EP3ngFLEPDbV4qm9y4MPXuMosxQgIMiZLrKSDwCbXOFhtXHdo43F3TH2DcKIBfPXtZhBJm7XZSTVz8Nwz765D+15ttc5xfV3UgId31Sha8uKSr6RacKzqg/YzhPdx3UnbIALB5Aqx5/a1ZrriJbswJcnIdlO0M+mXkCaVXq1ddt0jaU4sOcekh3CNIvr8Cjlcj9zXWCqS80pqCaFun3fJ5IDrnHxlPrtBAenXHmcyQQGVdxz5iuvY0DFKlZ+XfKh/z2h4idx0oKfpgJYbab9eF2TtPQzj94wJyhQomV2m07e6WHN/aX7furji2mTU+tr02BEatdco57AQzmG2zsBL6JtQdTogIMhtwonjpv/sK+3Uf2COIs1eq7Z+enV6RYX5tat03PTxh7r180/Sf9F4XCUPPaab/3aCEwUIbwYYhDaVrriJOEzkmeLAMSAz2OBiBEVjcJ1iLyB8EQtijJ56hPQIo7OUIk4fDZzJGUPAuTYkD3+uD7+Ykv4+1burcS2c+6N++vj+lCrOg4K3IYeP/aPIBxHFaxISpKUOrnh1YY6ur/he5fEaxdL1lONSxac/q+LBd50jxfloKFzvnaZEEB5BoelzQBFQbD+fDSZHiBHOD/vCz5lcIMY4dkwegsKRhxfo5Coj3nguwpRCEqrpP3j2U93xt4eUDULhkI666mDtf9aedT/juvz888+duOQrD44TUIAXFJk4kL4inMkUAsuvYkXVPyFowsiuFVDZIVI1S7hmznXjUjznihI9/Ey+6y9Jn1S/BCP3FlJ2+Mzg8CcrHmRfiSaQz8y2s5gA55SCnWCDbyrwg44jApL7YVOW3GwKi6rm6baJRylbsATjFp0O1mYd98/aexjG7xkTlI2wfEm5TtzwHM2eMk+xmvSrZGdrqmoGLKmr8sZNQ/AwQHDzbgrcpAmZ82BlGG7wgJOx6ebtdNFVtbP+zBNRq6K/qGv72kpTBojRn36sWz77WGGqcptYjcC6vXDSwMF6dfQ/nYtI7iRuDuIPcYDwQJQkE14IEoQlAxLCMbECGjHlq4Vx7xCSiByEKoMdSfRUY9LAnZ8hatbb7kRVh9J3RRqiILRYsbIPXSiWB5MM79AggEhZwLlG5Pp2OA2FSymeQNwxoLOvrJRCb8agyzRhyXwdNvZ+LaupbH7Vd1zaqusAndRuXW2/zbbOmWQ1F8RbfeA0JopMLz4JlyL2KKxwVdiFhU48k4PXkNDmWPjzCuwnx4rzj1ghxMpnAXcLB4ywKzl/5Ppdd+11Cn/URnkqyHjVL6kwj8+6U2061l9cxzZzvXkHE4FJFwKucQQV1zPikmuBvGsmiLh9tBLjmqYwKV71jeJlf1E2qIm10NnXb6IHHqhtBo8TzPXIBIztQ7QjAv25ZbKXWCjD/c1DoQxOKzmgtMQiB5T9Q3QG1wDPFtxnb/rHTVo44m217lGgcDg7ld5H9b1FXQpXXfHMMP4smKBshJuOvUOv/eudjDZBHnpQHz34yr3OUaQwh+R3KrTJsWwIhIIXkDzIXQJcAgQRDxwMBtF5Cy9S6eJ76mkZkj6hUKEGdJ/4a8/KWj6YPk1nvvGK5i9fnpL/RYibIpGqmbM0/+HHVD1nVQFMWAzXBmFBBSkDP/3t2E8EJgLs7bffdgKUY4ObRTiQrwgTcgdpFcOD7yloaUig4PDxYADts87+ateNyuXshETRMJtvOEBX/epiISQYpJkY8KBSn+1FRLLsHmkMnFsG9cTefgzcOEK0n2KQxgVCkHJckoWUpy0r0xmf/1vjFs1u0ja7yUIspkUvfqJ/H3eJNtloYycO6EWIu4iorC8NIRHOD+keFJzQxJ+QObmtOMfsIy2B6MmJM8k+0KQcIeMrtRHYCBFELILWNzxPdEg57/XRVWtorVBtAUmm4Brd/+xROuqqg5r8t2w/k8Kgk+mXZEQsM7lg4uEFZe92t0sV/8moO7nKvrS+UZWh7Z0riZBkm4BrDFHOcUY4ch/yecg4jEHXEVHPeaYVFOkPpMngcFKoyESOzzb7wiQvG+DW0x6MFYTYxk0O7qudz1kz45MIwt1dCwfor31vyujrGsYfCROUDfD129/rrO0uy+wBp89gQVif576lkkUL3CCMkGRgRlgGYfAICkjEJ3CTDgrIZCtfTJu3uyqqvlQ2ya15VHNm566Spzhj7lxNyM/RwjV6Sa1a1go439AS+HeYvNKQE5LLP/hI+b9M0/C113bPJQ8LcUXIk9djIGUgSKxeDoKYQHRQ2IJQIeyLyMaxRODgUPJAePhVVxhkcK14XUKg/NyH2li96P6nP1X3gVtnLYcyEgnr4FEb6tiDVq6dHoTjgNNDqNOLTCYgbCODOeedECjHiEpg9oPcQnJNqXhGaDfUtgR38oFJn+iO8WO1tLpSYYXqDYP7363ZqrPOG7qDTtrzIOcaE8LEHSZ1A1GJO8j1XF+VLecXoYyIpJiGfE+ufXJl+crrIKoRj+x7EF4bhw6xiVgm7NuYKODYILLpW0lYnGvEO58I9eqqam3faZSq5yGWMzBxCEn5bXK04UmD1b5j+3rbPDW0Ok4iHCOEGQ4fOaXkjeK2weJJ/dWiODtOW1xhLSzfUC+8u5U7p84RTZiM8bkjPI9AxMHETeWzlQxWjKHQikUYcCrpeMHnkXOKs07eJZ+7TIS7OT4UXtG6x1fH85kghab7Gl30Rdu71aJdfm1BfAbZr9eFGthyo8y+qGH8gTBB2QBnbnepaw+U8SXaQtK03J81oeL7ugR3hBACJyggEVXAjTooIBsKLXomzOyreDx55W2mOO2EhXr5xdr3YKBGyPkBIYoA7NxJuT26K697N0UKC2s7YC5d6oRk5dTpqp43zw2uCEgq3b3b5AUgggB3BKFN7hy/R8QgEHBzqCSlAjYY0iX0xkDCcWVbECvkpyaKdQYxQsKEEGmNQlU8x5z3Q9y367qWBo88IqvHr3/HMh1xwA5OGDZWrcpgzr55gYlg9IUMHDP2BZcbwUL4OHEVnvqojNbo1Vk/uMd3ZbNUVlW+8j1jMdXMXag189vrqr2P1rC23ZyI47pESCACqdrlZ7hUiEoEPNsRFJUM6pwP+hYi3hnc+VucNsLdiEg/WfLXA6KZnEjg80G1cypN03F1OZ8PPfSQ2w7+BrHtV1NCzODmbr/99s713WjExvrk1nHKixWmJypDccXDcc3rOVkLyuc6d5QJTjIQYqmsSe9/Rr9U/oZ1wXH1mGCdfcYB2mKt1Nbjbi5TZ1Sr/0bT6q4/mpwTISAvl3A91dsca44vlfYs/4rTWJ8o9LmvhPBJ12G/zjjjDOd+korAZ5HJRKoudyK4pX6NcyZkbAcpLVdffbWbXBKa51663q79tPax6TfgD+ZODm61mfbqeVbGXtMw/oiYoKyHmRNm669rnpy1A18RKtfdP9zoljUjNMkAzMDL4MzNzwtIBr1UxYEnHo9qwszs5iUxOPzjOmnsW23qltfzS9sF3UDcIMQg7gAtf/zyiYg+cuZo6s5gTxgNcZII4VAKcqj6xd1gsCH/lMp4RAoDGC1UCPMHYcDCpSBXi+peBjyEBMeTv+e1ECrOqaqudoMi2+Yrv/fZ9wDN13rOXM0GIcU19fMxmjnjF3fsEDpsI8Kwocb2DJQIagZOcgMJE7OvHEcvYHBnmXj4B/mEqYb4FlaWu/zKf46+RTdceqXWH76OO4+EDIMgbnCmcJrITQQEL6IA4c/xRaQjBBG/CDscNsQQKx9x/SCSyKnDceTB3xMa9YU3VAnjSOJqNrT9HBNybXEj2S6uOcQtx5Tzj9PPNUe4FSHJeefaQRBxHEtmlWrd0JZqEcJRV5Ohk0OLNsW67s2L1G94b/czth+nrLG+ovX9zDfnX+29wmE3+TjqkN669cpsLqZZS5dhc7WgZKlzlZmcJYJrjntJ1TmCjmgJx5dCnmTtgYDPGMsRcn5xmjlHiD/EKl/Jq+Rzmgocp3vuuVf/HHO/Fi+XIrkFatGiWLvsuLVOP/ko9eq+UpxybeGCuhV0Wr+rLxeSLpC+mGyZ215H9b1ZRTlNX5DCMP6XMEFZD0/f9KLuOushxTO8SkqQj+KvqVxL3cBKGxwEJG4VAiMZDFI4MOTMIZL8I/hvvi8tXaB7H6t1N7NJ57bXqk2LhlfAoKEx/TUJeRFyZCk0BA4iGpcL8UMrFCqrcaQQGMnyoBBaCBucRd9omddg5SEGYdbOxa1MbH6OK0ErE1wQQvO+CXMQxAy5azhjiDkEDYPaitxB6rTGBs3Oo2xRWKmiAsRqSIuWFagmGqkLd++05RCdffwOrhCDMCbODfuJWOA6QFzuvvvuqzSV5rkcT1xaXB4GZYQwy/MhmshVw9XFwcTJZOAEBvmgwERcNSYwCUkjVtkGxCTHGAc6CH0IKWLCEeW8MbhznOmFisgLhkg59zRwx3n0ApLUDe/M0lSekCiin2sYh5HKYrYVFywRXpvjwfPItURU81xCqGwz4pJtYbJAsRviEbGCs8bkhOOGo+bb79x/7wNa8lWVXrj9NUVywm5d5sbwvWY32XMDnXLHsWrbuXblq0zAtejFJRMInDuONUsgEga/+Ox1ddBuXyvbdBwyWRdf8g93vTWEPx8cT7aV3FVEPcd47733TtrPklxfVtph0ojzetZZZ7nzzwTCTyzqu05Jibjw8tGaOLNGbbsMUTiS3OHv1L6lRu04XCMGt9fGG6zjitZIC4nFo3pp1mh9v/jtZh6Z2pZTLXLa6dA+16hNXpdmv45h/K9ggrIerj5ktN594qPMh7sDbH/Kpnr5q+fc9zgljQlFviZbPo68Jd/zzz9Ou+A9FRRkpjddfXTrcJ9aFu5U7+/JW0M8IjDI7wMGD1wsQqQIBgYO+tIhegh742wlg9AobiSDKb35cHGBghsGIlxKhNg999zjxEuw+t0vXUeIFRBdCEsGQQQnQgM3BdGLaMV12W233XTw4cfr9id+SnnpxbzcGm2z7hRtsc4vGtJ7vtq1Wilca6Ih/TK7nb6e2FWvfDJYF59xivr2WjXXEFGI+EZckreG40iIDjHNsUQ4EW5kH3F02XZcOAZy9hXBFgQnlsHZ52Ai2HEIuT58CxoeHMvEkDtFExQD0QgeocrrIPw9vojooIMOcu+DuxvspYmw51hybhEWnNv6QtY4VLiciBZC4ghYHESEKhMIX3wGTEhwxBCMOJq4oWwD7jeV0TiiuFBcJ7w/zjUFXX6igbjExQwuxUjqBOFXGPfhz3rqhhf08QtfuOsjkhtRtHpl0YtbzIAClLg0bIvB2ve03TVy99r2RenA8azvM8+xJ3zPuUJIMSHaZ7dCPXxb80LDTeHGBw7QmWc3LY+ciQXdBRDxXMdM0nAfEZdMKILHimOMACWCgXPJuWNygHBmUkWahJ9g83smEDfefIcKO2+qVh36KB6LKtRInnNtW66oSqZ+oI/ffFBt29YK/y+/+kIXPnC0Nj6yu3IiEcVDTbvX92uxnnbrdopa5CY3AAzjz4YJyno4euipmvZjbUJ3NojFY5quCZqkcav8nEE3KA4ThWLi7wg3J0vynzH/QJVXjm3mMmyp0bfrF8rNqRVpyUBE4qoglHwYlwGCSl4GRYQfXxGWtAiiqjVRuARhoNlll12c6EB0ISAZkMjpI7zNg0HHO2OIGJ93ygNBiQhBgPpViRCTvkIVB45BD+fN992794kPdf9THzcYCo2EYzpgu2918A7fqEVhtZiDROoxNRGWOZG4lLu+Qq0uUih3zaTPw4nGtUUoIyZ8SH6//fZz/RgRaYgjQr08D4HYGIgsxJUXmHyPkGFCQlGFrySnsh4hQ4gaMUvomnAngs33esTRTZzcIBZ4HuFOJgBMHKjERiDW15iac4Y7zyorvDauFWKE0DTXDkKTCQDnGzHBduN2EW7HjcSd5RwyEcHRYvJAyJU8TRxcthUnHHhtBDqTF59ewjnnuCQK6gUzS/XVm99p4pdTNPWHGaoor1Refq56DOymgev30/CthqjnoNWL4YBzhchubHIY/J5tSIRt4zPO5IccU659HFbE8A1XH6q9t35C2WTpspgOP2MtbbjhRnVN2ElraQpsL+FyPvdECCgw4jNGFT/3Lg9uLIU5RBO4zvg9vWG5bzDp5PNKSkzrzkPVf919nYhsTuRgUN/Ouva8vfTlZx+6DgLcI449/RB9uvxJrbFhaykecvmwyQgr4lbZYTWcLTsdoqGtt854tbhh/JExQVkPB/c+XvOn166skQ0IufTboqce//pfzl0hOR2RyOCeiZtUyeIbVbrk5qy1FImEO6hft2/r3VZCXgzqCAUGBg8OBA6bXzkEcJw4Bn379nWOJgKqPnAkcSoRCghPhIsXB7h3CANcHEKwuFwMGECYmIEJt41BGnHK7xAZHnI1qf7GmfNUV0f1twse03j6kCZxKnt1XqSL//qW+vcorStkT/EIuv+HWpwkFR+32uCIS0r4j31AFBPOJySOsMKxw3FDOBMyZJuTVfo3Rn2tihAynAeKk/je52Yi3DhHTHpwChHviEicUUKdCEC204PoRFTiEiIqE1M5eD7XBwKU90aEkcbAa/KeuFSIDF/pT29SrhPEpG+dxDHB3SJPk0If8vLIsyWcjrglx9NDWJXtIIwMCCQES2J+aBCOMfuZTAzWJw7Zj8SuBFyfwdWDUpksMoHg7xBlpIYweeCzwnn54IO3FJ+HI52dCAoTqF9mdtRx5xa6iR6fOyBdINiEnXOfylKonD8mPlwnXMPsFxMjxCXn1TvITCq4JnhPPsPkWfvrr+egLdRrrd3T2q9IOKTC/JDGPneFttx8I3escbtJk7hhzOWanfOdZpT/oDkVk1Qdq6jLk2yf30PdC9fU4Nabqm/xiKy1EzOMPzImKOvh8AEnavbkVZfDy7SgnKHJmqjvnANBWxBm7MEHA1Diz/yDAbUh4VlVM02/zNkkSw5lWO1anaSOrWvD2MlgRRsqN3EP2TcPrhoDJALCw+BLjz0Gen4X7MnJ7xB9PnzNg+pmv7oMgxGh0mDuKauhIFIIYSMqcEgJkyOSEGcMbISQqfxGjPKVfEMEMM+lEASRwoCHiFqyrEInX/KkJk9bsIqoHNhzgW4++SUV5NXUuo7NpWBPhVpfo1Ao4vaJ0DYuKXmICCT2xZ9rfs8+ebGMI+casa+3ngsR8iCEncqkhL9DnPrVZRjEEd6J1cn+tbjuEEwMwriAbAeOHyACcKLoVegbXgPiHheRY49w8w7XXXfd5cQnThRhUVx2zhFCGieSHFa/4hHvxWTApywAExLEJgsC4CYjPnfdddfaPpD771/Xp9W/H8LTO5WAO8V1QBUw11pDLiKOYCKIvaaIQ67N5rbEQfgj2gghc21zrZKSECvZW6r5MUuiMqxQixPchMe31go2YffXCRM4zndQZJLL2tC++hxZxCWfbT53RC14cA8gx5HPgI8c4EjnFnfX0M2PqW2RkSaxWFS5oRWa+tUDKistccVavHdiKL4mXukiSbnhfIVDWWroaxj/Q5igrIdzdrpCX73xXUpL4jUHXnfY3v118zPXusISBj4GUx4MpP57HsnyJnGOGhKcPIZv+KiKWuJmZXrACalv10+Vm9Mj6W8ZgCkmYdaPcAhCWBXHClcgCEUkflk5ct8QEb64hGOAS8WA5UPYiD7yTnGgWN+Z74OiC3FCAj4CEbFCSBe3A2cSgcvxZqDkbxC3CFrEEQMLxRwIErYFYYegi+Tk68a73tRrY390f9Ol3WLdc84zKsqvViQdMekpPFTTFx7qhBnbjpvGQEcqQBD2lbxEQsXsn3f1KOzhK04SYWaOPQ8cQvaffcXZCi5RSO6lryZGlOHY+aIZwo7klRKKdEv8xeOruJX83qcScE4RTBxD73oGm68j5hCVvB4ijop0rnmKNZg8IBQJ55LbyISCUDtCkwehfZxavywpoWHEI0KbiRjuLEKS7UT8cd4QJLwe+ZVeHLKv9bXxQRTVJwbrSzPxSyP+VnAdcG0wmULUuaU1y59WfElt7mfmCSnU8V2FIisng0E4ljjQQZHpl1VEbHMdBUUmn/nESQ7P5W9xqsmjDJ4fPu9MjvjZy6+8rg12PlfhSKFbCCET8N7h8vF6cMz5qxS+GYbRfExQ1sO/LnhMT1z3vKI12QkZw4E37KajTj/C5UfV12KDGx+DaFBgpvJAWLCO97OvdFBububyfIjkFeYeod7drqr3ORRG4D7hEBEiC4JYQLRdfvnl7t+IZQZ7xCNCjsIO9plBHhHo2ycRhk6sFOV5hNMpqGCwveWWW5yoosgCB4ewJ+KUwY7nMsjhiiCyEAa8FwMa24i7hnDE/UEsIYpobYRThjhCAOGETptbqVvvf0dnH/iAK7xJy5lMYM/DS/TNj8UujwwxmAj7h8DFraPdVCIMvn4td/IQcfEYmAnrcg15p41rzVda88C58zmu5JiS74aDhIvr3WZELMVVFOl4oc9XnCvwjeQRtog5UguCFfc4WohKhDzOMd8j/jinXKukeuAIUwzF9vkcRIQkAgUHmvPoczf5O8QrLm4iXDs4ol4A0qYIUQu4kTiitJ2iehoHnWvy954LhzDj+CJkOe44v/H4CsXnbybFyb/M5MQ3IuVvrXDb25v0V6RLIHSDK/2QGgGcBy8u+cqD88KEMCgmfR9SrhNyZPlMPvHyOI39YnbGw8wsv/jkbUerSydr92MYmcAEZT188fq3OnenK5QtovGo5g0arx/H/+iKDoJh4XThRk44ksH+rn9tpY03H9fE/L7kMHbPmlmjfXddos0339YJr0RXlIGAXERyqxAVyUJ3uEoICAQF7iA5aggE/gYhiBDAtWJwSmWg9wIW8UjuJrmUvA9/z3FFbCKoEIiIBwQNUMiB+AFECsISl+3xxx+ve20/6OG0sp04h1desLZ6ta1tN5MpotG4lpUXKKfz22rZavWVZhB4pAuQa0uLpKAbiyjyYWvvQPolB3EOeS4Cja8M6DiDCFYENz/juewzoprjj/ONO4hoQbzg6tLUGmFH/lsQRKcXl8FWRVwHCHeuEcQmf0vuLILfpysAQhbRS3GW7wEahNApz0ckIohxunAtyeVMdA7JL8S9ZLu5BoLtj4D2Q4TdybdE0LCsIcfrjwDnjONDmgO5lLjtEF/xouKLT8/wuxUo1PEVhSJNz8tNhEkb9yMvMnn4VAYP55eIAykypCBw3yK8TzrD/AWl2nj3SxUKZ64ReVBQslrV/x2cWs9LwzAaxgRlPZC/c2jfE7RgRqkyTSgc0ozoJK1Yo8zN4BlQKTRh0CbMU9/yZY3BgEtIFMGBOMNpGjp0iOaUnqilK15Iy8Wgl2JVZa5uvXGwnnm6dlBANHCccCaSgVhA0OA64CQRlsQ9BQQfgobEe0KmuJGE9RhUqGxGYOCyUYBRH4hARAQuJbmEDEy8F8eB/SdUipjw/RNxtxAjbDvvR/g16HryvohPQndsWxD2kUFu9Oib9eYTUq8euQpnwdQKtbpGoaK9V/kZIg5BQRoAxwfB6MPWPPwATag7GLbmq2+Kz8COgOa12G+OL6IdEU5hE+eHim7cY8QmxxE3FFcUd5EwNcKav22ogpmQLNd0sjSNILiXPrcyWViZr7wuLhXnlgIsHGwEfzIQ1YgtipQQlcHm64Cji7OL00nOHsKZ/cSl/CPAueDY4+DiAvtWSi4dYdHfpMp3MpZLGWp1mUJFByiTcL3ivPN5ZWIJuK2+QI7PLNcEEwHvZHJvIMXk1Y8WKFu0bFGg//zrBCcuDcNIDxOUjTU3P/OhrORRfhx/XX/56z5OENCsmtAqbh1Ci5wwxCXuWbKGwMlggEQMkINGJTUtVHzfv3i8RnPLztSSctqMcOOMN1lM5uV2Uc+OTygvt78Tkb5/JAM0TgKDA4IC4cOAwcCAMCOHkfw9toV9Q5ghRHEMk4UreZ5fNg0hiGOBuAi6oAhuWt7gquHukv/HoIRg5e9wsXDMgkUcgKtDAQEhbEJsCDBC4OQBAtuNm4azRtFLMmrK31V4ybHKDmEpZ02FO9T2JmXfcA05nxwDjiMiCxDfDLw+bI14TGVJTq4PctYQxwhDBnFel3NDcRLHjOODa4looWiJc5JMIPK8ZGIQkUpvSUQC59BPInAZg+ec64A0AloEsS++/RXil32++5571K3PmipXgc664DIVFbdUfl6OendppyG9O6t7x9Z1Ti3hcj5LbDPbhXhGMPLZJYSO68X3THIQZ6RFIJIpzvkjQF4ox4Q2SrTP8UtVQjy2XPGFR0jV36cvKouPUajFGRlJASCVgeIaJiK4wd6Z5vPGZI/7nL8muFf4MDlfmfxxnxm4/l/Uoed6Wa2qfmT0X7VGj5UtjAzDaB4mKBuguqpax697lmaMn53RBudr7dxfo1++xlUoEwrESQHEFyE6hBIzen5H+BhxibBK1m+SQZuBhiIFRAUCxIf7Ella/qLmlp2lWBxHsfH9iUZDruDkrdeK9H9Hfq1IeFXnFNHGthGKQxQwaHjnhNYtDBw+B5JtIjSNg+SbideXG4oYoDAFEIBelCBY63NDeQ7viWBgsGWgQtwiJnyvTtw9xApuFbmAiBlEPNvEer8IVQY/8utwxZLltcaWXCmVP4K0VLY45JT+enfsN3U5jAg63DxcG+8+erGMGET8NVSljGtIQQ4CNVnFMiAseTC4M/AjDBGoDOwM/PS/PProo92x4bghHhPbxfA+CAgKrsiLBVIO2A8KH3AuWRGHc0reHI4wIBw4P+wf5+2Lb39Qh0Ebq+uwLVX5awozBlJtq6Rf14nntdu30v7bjlDespnaf59R7rPDduLk0fDdFxOxtjP/5rpANFMdTo/KTKeaZBMfuqf7AIISRzaIE5WLTpWq3nXHqOktrOIKtThFKv6/tMQkxxthz6Ql6EYi8pk4EwHgHDQGxWLkvV455iMtTr4KZca46ORdtMMWte3FDMNoPiYoG2HS17/oxI3OdYIyHaeyunu+KocXq7xvrqr6h1URq1FBJEddw8U6aqe9NLJTX/VtuXLNbgY/XEvEJc4abg7hOwQchQUMvKwk4ptIUzDBYJPYoDmRaHShFi1/VIuW3aeaaK1giccjTkiEwxHVdvuIKRYN6z8vVKpz+2N1xGHXODcLsYZAIVfOt/EhHOpBALOd5Hj5/Lwg5E6yTz6HsT78CjE4jrwerVKoaiY8yc8QjogXRA1hWgQWA5evkCfvkW3jdfh7BFd9biiiCGGLIOV1GOwYvHl/8jJXq54Pn6BQzbfKJmdc0VbT5vRwQghR53NAk/VB5OHbqwRhvxnEOS4cE56Dc0voGIFP38pEV5HzFVyth1xDnElei20g/xFhSCqCh8kEEyJEJEKO64+wLP0iCc0yweG6YTu4lpkgBV11JiIId1zmF154US37rqfuG9D+J9JoRa+7ukJStLpSLRf9rHee+Ze7LnlNhDZuM/tGY3b2DUeSHFiEMYU5QZfv9w6fdc4dlf0cV5zjRNz9qeJZLZt7rgoL4gq7z1/996w4rYGYWEb6KtTmeoVyhzV7+/iMMUnAmWZi6RcMoJDolFNOcWK4OZXxOx32Ty1bXitKswHLoB75l010+L4re88ahtE8TFCmwAfPfqrL/3KTW9e7KaKSZ1Zs0FJL9+igqiHFNJ90N/lYQGe5RRlCtc9dv/0aOnLAJtq666qV0dygvbgkdIcIQBBQAEGokEHbN/BOedviUVVW/6zKqu9UWT1en38xVp9//pVG7XmcBvTbVSXz26tP76F1uWeE33GY2BbwPR39+uM4EuS4IQ4QlMlacSCGCU0jVBojmP+G6EMQInoQR1QlEzJDHCSuL+1BaCFs2F5EJwUZviE64exgayYEOUv84V5ybH2+ZzLKxvdV61bZ60lHcc4Zl5bolrtXvj/731grG/89wg3BQREP+0XxCgVafvWYpkBPQAp0CK8jLDlWCDNei/OPG817ISq5Bsh3xCEkbxaByb99qyH+TaFPIlw3OMShnDxtuP+Zqspr+nrY8Tjtn8Jap3dbPXDZcYpFa1x1OJ0EuNZIYQB+Rl4x+0OxEN//UaBin4IyhDqfLyZUyUBQ777bNnr/jTM0rN/3UjQQGg84l/F4WKH8kQoVHSblb+EEfFPhXkiIGqfZu5FcH0zUONesgMQkLVX43CU67Lc9NU1ZbLThBCViElFpGEZ6mKBMkc9e+VpXHXSzViyrSCn8HW0d0cL/66aKjVpT0i1FGg8j1foFce3YbYguWmcXtcsvXu0Gjnik0tev9kHIjtk/Yo2QYXPDVQgGRAGiip6OuEcMEr5PYZs2bbXnDvtqrUFra9jQYeozsLd6D+qq/MJaQcd6ygxmhC4Ra+QmElYO4ns98ruGwH2hsILwc1DAU7BEyBURm8p+InQovqHqlwppQmgk+nMME+F9qELG5cXZwxFknyhyCobjd93gXEUi2RvhyFe97vZK3X5/jRPBTBTIo21ofymw4bnsF30deT7CjpxaCp6ac03MWTFXE5dN0jk3nqMOa3TUVttspZ+/+1kfvfCBysaXad7XcxWPxp2jy7HlvXwYHqcK4YNjzbHEmfJ5r96lYmLE0pxs9+Chays8YAcVtO1MxVqzjx3CcsnM8brhxD114fnnOaEdXHWJ0D2ihUpvRBBO5R8F3D6fX43jithKBtEL7g2kHLicxdhiqfoHTfjpLd1yy02qrArrwkseVK9+2ysUSj4ZS8WN5N5A1IDoic+xZRJ50kknuQkHkwo+f14YBr8m+xlf/T0tyIa7XqTc/OYVKaYCxTjHH7qFDtxjg6y9h2H8WTBB2QTK5i7U6OPv1kfPf65ITljRmuTCsrpnvhZc0kexlpGUhGQikVBIbfOK9cDmh9eFwRF25H4R9kWYUVSBi4ZrSSiPPDVcIy8uU1ktBRFF+NmHrxlofSiNnMce3Xpq3AfTNLTLxtKKfLcEWWK1es/+nTVimwE69fKjdMPo65wzQa4UeV6ESXEtfa4doWoGHARrMnDU6HnIvvl8Pr+EHXmiFAE1BQZVBCVCh9eG+pwyD/tPqJtwM9uAGPWrwUB07nCFtELZoiYa1/lXLdT3k2vD7zjRPNgH/xWnlnOH6EdEcg1QAIF4RNghJoONxVOFVUE+Lftcb8x9U5OX1x6vWE1MoV+vYQQkbno4ElZuNFdtZ7XWVw98qfdeedcJHtworkHOPRMLvsf5RYBwzSI0KIYhPYOKXyZDuN9fLWyh97+b0uB66SkTj6uDyvTafVc54cX593D8mIyQ50m/zcRK/t87pCwQxie/OpmD7hcHSOyOwOfAV8dT8BJcMShV+CzijJIHTUoEAtIv/4mQ5FzzbyZdXiAmy9fluvSOOl+D3yf72aWj39AX30/LzLVRDzdduK82XKd39t7AMP4kmKBsBpO++UUvjXldbz/+gVYsXfWmWdMlT/Ov6atYUfPEZFBUts4t1ONbHa2pX41zuZKIHYoJyEkKLm3GYM5ggrBgMOemTk9FhCUC04fDuflTnIGA9CLSr4ONAGWwZRDAvbnq9Fv1+XOTVb6swomIUCNLniFG9jp2a/313FHKK8h1r8F2MmgTrmcwx6UiFIt7FYQKT4QFAz37xWCF2KD4gxxN8vnI40MUppqHRWgdgUMO4rvvvuvC44hEKnzpR9mQ2OY44b4QiiVkS7ifY0z4/N9312jtIasXR2WSa8b00Huf5LowJ4Ujic6ND/MTSsaN5NxRtEOrJC88CevWlw6QjHkV83TXlHs1adlkd67jKXQCCCusvHCe9uk4SvM/mKfbb7vd5fr5bUS4c9wJOeP+UqHM9nKOaUbPuXjvu6m64O5XlEk4f+P/c5sKo0ud647IYlJAYRtimzA4ouf33sw8ESYMuNGkGuCgJ0LuKNc9nxnfVJ7iMq4PBCF5o7wG8DqpuIeE1rkOfaQiEZ8S0ZBADH5NZd3vIHc8PFaPPvcZ2UJZ46V//U1tWqXWTcMwjPoxQZnmwDV78lxN/maqli8uVzwi3dzmO82OL1U0AytXICqLF1fr86Ou0siNNnbOHcULDYEYY8BEXNJYnKpoRAY3fgYHBgkGdEK/PgcSF8evg71wwRIdtMmp0rKm3fi9Y9l1jQ664J5j1GdId+fuIWgRreSvISKCrhEDH24V+ZK+fQiDHyF9nx9JgQ3imPwsWqcQ8m4MjgEV9Ay8uDl+dR7cMpzco446yuXu8Z48l/AroTsEo/9KwUaw2AV3ldY0pxxVpgE9xykcyl7YO9TxvVWWvENQ4qwSSsaV5PyRq4pYZhsRnTx8RW1wmxPdzUTHk0Kj7xeP0y0Tb1VNLKq4S+ptwrb+Kj67L+2ma3e6yrmYvpURRTxUIyMiEDiIEsKjTH5wzKqqa7TzGXdpSXlFRh2oeCyqdkU52rjtQr3//lgXavfHhokJAginLdiq6PcKYfypy7/T1OXf6vXPnlGoVYUUiatLx27qmN9LXQsHqE/xOvrxg5naZeddXN4o4pnPOdc1EQI+V3QHQEB7oZisibzvC4nw47PB88ib5hrzn08mLTjNTFa5voKrIWUSuguQ6/zUc2+qx9r1RxTSgXz2Qf066+5rV53gGobRPExQZpA7x7+v0T++ndFF0BCtGy8q1L2Hn7GKK5kMbvyIOO8++nWw/U2f8DHijJw3HvRhDFI2b7FO3/MmzZ9ZqhjhzWZAOBSH8pqnT9agddZwTgpOn+/ryCBHniYtfBC+PmxGbhhCEjcp0TkiRE5bH6qFGeAaC+cSVsch5fVxqHh99hWHCpeU1jWICkQ0jq3vscgAyWBMuJ+v/A2OFuIU543nPff40dps7do2T5nGFU1EuinU8R13DBDchLTJVyMvFRGGMEakI4xW/du4e453NYNfg9/jYAXzUntu0ktbXr+NmwzwaPa2x+L65bXJ6jult3MjEY4IOdIeyF1le32YltxKJhddBm+k2/+TvYr5+849QGv36+bEJBMRcncRRWwbP0NMsqSnX4+c1VqakyqQadi2+Qvm66uylzUx/p4qc5aISr64YqucI1ckGJPCOSHNn7JM7987WV8/v3r1N5PQwYMHNxpq5n2JIPDZIWqAm4yTyTGhsIsK86YW/zUF7gtEKehryzXDdh144EGaVz1Ysxcsz0o/YGsZZBiZwwRlhlheXanNXrlBFdHM9ycsiuTp/V1OV1HOqiFMvw62D2Hj/pFLhyPEQIn7yGDJ99yM6e9I+JmvDB6ILcSJq8xt004n73Sdpk+cm3bPTURlYXG+xrx9vjp2r3U+CXMjjNg2wuoIJhxIQvkM9g31pkOUUq2MOCbkn2wdaw9ihhxOKkwRhH55Pd8fExggccsQkFSL41QhIhlUE+G9EKAcZ9zUJ598RPN/HKiWxZnrS7qSkJaH/qZ7H4u7CmQmBwhfqqUZ0DMxmHPNkEfHoP3Gh29o5K2bKacwNy0xGeTgXgdoYMUAd9xwyek5ibOMKEcwkDvJOeT899vxWLXo0jcrTasj4ZB222QtXXjEDu7fFFghkvxykoil4JrkXFtM2HDy+MzwwEnH2U8HPnd8JlMpSvG/y28f0z5XDVePYW3cJCOVVVxidJAIh9RBfTUy/1Bts/HObp8Qh6xD39D20YuVpUVpl8X1gVOJg0m0gM8Rxy5bQpt7AZ0CmHDiaHMOaEjPhJfeoYj/9z6ZoPOvX3XJz3ThWHXq0FKP3nKk8nIbbrVmGEZqmKDMEI9N+VyXf/tyRt3JIJeN2F17dF3LiQEGQAQk/Rm58eP4+P6CDIRUezcUymOAe/75592AT+9AnMtth+ynSEnmVotAVA7fdKCueOwEN2AgiIKFBPQjxDEi5JoKXigysBEGx63EcQuGqXHEKLbw4EYiFBEvHDcqignFItIIHeOKEvqliTrh32QwwFNwQPU3gpKChAlfn6STjspxoiVTIByqqkPqs/40lS2KuYp23EhaHTXWWzQVcC8p3sKBQkBwzexz334KrRFpcpi7/n2IK1Yd04sHPavK+ZXumiR/kpSDYJidicVJf/+7Njjyejw3ZYuendro2auOdN8jxrnWmFxwHQY/H1z/TDi8wOSzxbUFtBfyAhMXE9csWHiSilBMtsoQjm0yt7DdgBzVbPC94uHYrz3FmgaFcxXLqnTvkR/rlCMucCtm1Xc9eDeSzwyfK7/8IekmCEkmotnIM+U6wfFHRDLB5Xz4oi0muMlE/AXXP6+xn01ywjlT3HbFARo+uEfGXs8w/uyYoMwQB713r74pm5kdQRmPK3fWYk086w5306fKF3fR50CSD+mXWWwqDI4P3PmoXv/nT40W3jSH6aEv9OOcz9z3uEK0AkL4kcPGwIUzgjhsaPAhTOtb/+ByIUpwLakeBhwVHE7C6eQVjh492uV64VAyICLOyCWlKCEIIoIwOM8hv7K+ql/EJOKXcDvbunjRPFXM3l5tW61QTk7mjtmVt+SrdZdjnCPk1+BOB1xo3GjyL/lKSgT7i1s8eLshunnqP5VpqApf8tUiVbxY7s4VwiyxxQ0udWHbzuq7y9+VTTgz7916IhvlJhdcEwgnBKO/thJb2/gHObQILXJA/VrT9YHgb6xaOfgzhG2yz+vsFRP00C/nKBqvTqkoqj5cZX4sR/83+FZ1LFjZe5T9JYrh3UjC/1zP5OgyaSKkTcQgmVOfCTiWiFiEJMeXzyfuO5/rxnLDFy4u19FnPaSSsmWKZkBU/nW/kTrqgJUdAAzDSB8TlBkgGo9p3ReuVlUse8vxqapGR89qo6232tqFohrLp2wKt57zuF59+ENFM7i8ZF1fwJoSRQbPdcUwhD0phgHcMvoAMtDilBJ2RtziNAZdR74mrgWNi0JIFSeWXEcqwum/h3OJA4UD6cEdYgBnlR7y9hKhYIjG5xQsIbp8e5UgfulA2jbxcPtW9aVipQe5fUwlJNkQdEZaXr22WvV6Km1HyIcwGbgRDbg/hHERkQceeGDdet+3ThyjLxd+xZpIyjSRUFg3r3OjWuW2qhO2HMNgLueXE2bpp6rsL3v4l6EFmvLzd86JI8WCyQjuoBeOiYVMgPhMFINMWnD2uU5YD53JBfB63sHkQa5ic85hVaxCd046XkurS12uZLrgVHbI76Gj+t2iRWWLnYhDSDKJQkTSIQCRTAcD3Eic8EzeUzwcM4oDSbFAyOOMs346biST4aYU9cyet0gnXviEShemJyr33209nXjEVn+4Kn/D+L1jySMZYPqysuyKScjL0XvffaFjjzk2ozf+ivJKvfHEJxkXk0BuXOvcTrrl1hu1/hbDXB6kH2QIg9LY+pZbbnEiDufIr9ONcKR4iHA1rYN8kQyVzYg/im0oFsB5REAhTClgIVwZFJNAqJvXpaVKMtgO/o68LUQpgx/vEQTBSriddkO0ukFwhPLWU7ToekXKz3Qh0+aKSpa/C+cNUasu96c1wNEeBieSB04Qq+IgFJwbOXjwKs+tiFZkTUxCjB6ZZZ9r+87bun/7npQ8PB+Pm6qTbl65hGO2uOTSS5UTre0biohCAHIt1ecgMvlIpbUNIWOEO2FyHoh3HGBeh9A4DwQmk79UUhbenfeAllaXpOVMBkGULqiYrtPu2F9jTn7RXaPe9cYdxY2k32qyFa3SheNAQ3lELD0xEa60teLfe++9txOVzaFb5za657pDdO2Y1/XhF5Ob9Lekp+TmRvT3v26j3bcbZmLSMLKAOZQZgFD3ge81vPpLJphx9j3Kmb/UuQnkGSEsGaz4muyRyu9Kpi7X23etzDvMNGikfpu31a1PXukKNBiIffN03AkvMgmBEbonXI3zWF8PRQorEARsO44kApD+hjgghM4SoRk6ohU3qiEhTpEOrVAoDKA9E6G4ILwXgvb8My5Rt7xB+vSNcZr9ywKtv+l8nXHlOBUW1SjSpOnZr+ss52+nUOvrFAo3veiBUCzuLiKSJfBwniiwYttJiajP/ZmwdKKu/OkaZQv6U45sv7GO7XdU3c8QNLilPrz89YQZuv/D2co2L19/jC4+7yyXx4s7yvWXWCGfCUjBIJXDC0zfqojJB8U9PgczWauiZTULdcv4wzPiTCZSvSKq23b/VCVzF7qcViYZOITZaJdERAHRyPXIsSaFBCeSfqSJHSXSgUnkGx/8rPse/1Az5y5yyycmmxAzQfPrvW+18UD97bAt1aVjrWtuGEbmMUGZAb4tm6kDfgNB+csZd6pyyhz3PWLBi0N34ww8Em++rlgiFnNfcQ/43q9A07touAa1HJmVSlvf8HxuxSR9t/jN1X6XuA+++pscUVyi+oSxb/bt8hkXL3YOoqsSLypQtE1LhXJzlBOXCssr9em7Y124EoHVmODmvVktiB54hOeDf1NdHtd7j/ygvBVtnEgOdjBp3bZKfzv3J222/XxFa0KK8Ob1QGtLdG1NtFgzFv1VS6p4j5yUJwCIFEQvQpK8T35G2BInkrXLU3HXXp/7ph6d/njG3LBkxEqjmnHt1LrcRNIWgn09wzl5Wuewq7LqFLUqLtBbNx/vhBTbgDNGLu5vAeeJ9AsvMHEzccqTtSr6dsXLem/+Q1k5H3zmF77TVodufobLIc00HFda/SAk6fmKw0tqBZM7CuCyeX7Zt6/HzdC7n0zQjxPnaMr0ElVV115jbVsXaciArlp7cHfttOVaat+2ea6oYRipY4IyA8xcvlDbv36Lss2cU+7U4um1gjIoyhBMOHo+tIZYJNcQgZYsRyzI8PbbqnPuAOcqZY3CKr36yz0uzMZ2elHL16DAJRTu1ymmKpewt/9d8HmEu3keA0qbIQPVZfdtVdmrk2LFq6+iU1O6SKGJ01X4wxRpbmndazT0oFCDY8e28ugQ7q0BhSMVUkThBoR3j97Ltct+M7T59vPUrmPVar+vqorr828qdOeDi/X0S8tUWZkZAcGgzXWQOLHwj8TfDT58LQ3Yf5DCudk757HlUcXuqW5w5ZRj/vGCZs6vLazKNOiYjYesoZv/PspNUBCTuLe33Xab/hvwefQtixJbFZ3+0nZq2SPHbXPmCWmNoqE6pM/VGXtF7il0O0BEsvoU1xQdE3Ajmdw0ZYWmTFMTjbnwtuVHGsZvjwnKDICw2eCla7S8ZnURkSlYhvHjXc90N3McOta8Jske4UXlLo6dXzGlvuX6XFuSdu2cs0coDiFaM6WtqublSfHsOQnLqsv0QenjGX3NnK4d1f6ofVXQfw3Fo1GFGghn+99X/jxFix96XtEFC+sVX8BXinkQlX1bjtDA4pHuHDdlkGrVtkq9+y9TUXGNcy2/mTZF38ydrVgsvMr7JHtd/29y/hC3PBC6iA+EEfmm3lGt28eEps/JmkD7n/U5oJ96791X4ZzsCcriSLFuX6/hSdYdz32o+/7DsnrZcUovOmIHDeqYW1e9z0pDuGe/B3yrovfef0elm7yiLAUIHHnhQp2x5pNpiSyuHd+/FHec+wvhe9/qJxNdCQzD+GNjRTkZgBv1Ou166OP5vyiWhbAVS4St076Hex9CmuQdUrXKUoC0mMEtoMciuYUeXDwqUoMikwfVtnylcIOv3WJrq2fREIVDma/w9MQUdS2DaCJOiI/iDL9sW6KQ8w8qQlkikYGMlj2EoL0A2+nSszV1QJdaG4q/a6RIyf++aHA/tbr6DF280XY6aGDj4b+rzrpF7z80vm7bmsKShXn67vNgP72O2m6DPN32xFUNrkfOOUH4kIeGo0UIkfAhIW2KlzLhvLw29w09Nv2JrIa8W+Q0HmLca4u1naDMBsUFedphg0F6/rmVhT+kMPxe4NpnMtiuT77unZLZtcwTqYqt0JLqBWqd16nJfzt9+nR3LeJGUvhFURPFPFyTicVehmH8uTFBmSH2XmOEPpw/RdkAB2fvXiNW+zkrSZCntddee7m8LIpJ6O0IiBYqOBur4nx6zOu67/LnM7qWchBEy/LYQlf0wgopHrYPYZzsgeAkH/C7775zBSY0QadNEAU2+9/zD00b3L1ZHTOj5JDGozrv49dUuqJcJw3fpN7nlsxZpM+fmapMMuuzFVp/2Ejdef+tq4gbcuuYENDqh+pY3GQq2GmkTsV5JkOIFI/M+W624m2yJyZJn+jXorbYqiE6t2upPTcfquffH5dxl/KIXTZUQX6uq/7HjWeZzUwWhjQVJkI43hz/4GN21c/Sb2DuVcbKU34u2+Vb/bz77rvus7rPPvu4FaNoVJ+N9kKGYfzxMUGZIbbrNlht84q0qKo842t5t1COtu4yMOnvqTxm1Qla5xB6QmBeddVVKa+ustYG/bMmJh1xuV6UOBuIWxw4evjhoFLtzVd6TfLzYL4nhTaIS/6Gdj7XXHONHpnyvbRTZpoR3/jN++pUVKz9BwxP+vsxFzylqorMpjBwTrrVDHcFGVTb0krl6aef1nPPPecEN335aPjO4J2pSmRy9yiWeOONN9yDayWeG9eBbx2aseUWk00i+hSn1o7m5P220PvfTlHZkvKMiEry5/p376BDd1zf/Zs1oRFATXEnCUdzPhLFXyoPJgf1/c4XwgVZY922OubB+ic2mYK+lA1BjjKN/3EiEZN8LhGPrCXP9fh7WOPcMIzfN5ZDmUGem/6tzv3yOWWaWTc+rfXzOrpVZujJWJ/wpE/iWWedpa222srlOaWS11RVWa2D1j5Xy5fU9urLBh8tfEJ9B/d0TpEPvTNgBWHQJ78TIekHL3IIGaAp0lmcF1a3y09WKAPLEHoKIjl6Y9TR6tli5Uo9uEiP/OsJPX3Zp7+29sk8Fb0m6d3PXnff0y+SYiVaq/B9unAd0HjbC0h6dlIJz7FHINCPk8eroTf0zaJvs9KLEofyH+vcoDZ59a+AFOSbibN0/A1PKUpRVDy91JACeg3uPEgFoWon4ljHmmuIPqOEmFMRheSsNgbV2lyn6T7iRSv0wopLlW1OW/NxFUZWF4WsBuRb/TDBoxCOvEhSLDJxPRqG8efBHMoMsmfPtfXqzB/0wfxJLryaLpFQSFt1Gahdz7/ONdSmSTKNvgn9UrkahNw6chRHjBjhwt607KCpML0dGyIvP1c7H7qZnrnjLcUy3Nw8HAlp4IheevWlUl1yyb0udO1FDxXdCEv6T1IpSmhtwoQJrg0JRUM0X2Zw90vedT7vuLqcyUxRHYvqgo9f0/3b7edcvPvvv9/lL3asHqQ+LUZkRU7SRmnZtIhbp5uQPu87ZcqUBpefbAyqhQmVIyBpe0R+LAKdNIhTTz3VCUh6ewZd65rFUX216GtlGpb9a1larPzoqmF6zjkThPpE3O5DW+n57xYp5PzNph/5eCyqqqoKjXtmjPYbs2onBKBtD30SEwUdKwc1Rwg2d6nTRMhp1pKwlJudJvPQKqfDKmKS68W3+qF/KekAvtUP14lVSBuG0RzMocwwi6pW6JCx92nqstK0RCVism+LDnp4iyPVKq/AhYNvuukml4eI23T99dc7FyHZzZ9EesJUhJIp3knW8DvIvBmlOmazy1RdlfnVfg66YBsdduK+rsCExuYNQeUouYS4qwgk9g23dVa8SisO21XZIj76UU3/+jvnjuLOzH8/T7Mnr7r+dCZp17m1HvnmKhcCJcR95plnugkCy1KSO9oYiGwEEuIREfnVV185wUY1s3cgCZ8nTjqC8Pzrxt+on5eMz6hLiaB88eDntGJ2uXPIOYc4fohGwu8NUdi2i/pufYjy29SudtQUYdO3U5EO2by/enZpXyf6CO/zOeDzQlP1pizzl00475w3ujS88MILOnTM+uq7UfusVHoT6h7Segvt0unvbuJGXiRLjHL+afHD9U7Ln2w0OjcM48+FCcosUFa5XEd/+LB+Xjy3WfmUDKNrtemmuzY5WG3zi1ZbseWMM85wS72xAgeJ8skaFiM6yNMjB4qVZBCjDbkqz971tu66+N/KFOFIWFvuuZ56bpbvKtFxJBnYm7IKDPmF1113nZZus55abLZeo9XczYGWQkvf+EgLH/+P+3dhQZG2aHNYozln6fL4uGvVun2LugkAlbOvvvqqmyTcfPPNrro7KEBotu7D2PQxJGWASnnyMMkPxFnC5WxKXl95pFxtT+ioUE4oI/mUiJQVby1XxcflbjKDU4pIp8CIyURjrh/FH6zR/NQ73+j2p9/RipqQcx5d0/0EcRkJh12IvE/Xdjp85w2168jV19C++uqrddFFFzmBjZj6b4MbSeHcPffc444NXRk47xvvPUCvLfxn1t639PnOevCm550zybruTDBxJGkjZhiGkSlMUGaJqlhUd49/X7ePH+sEYipuJa4kcvLEwVvqqAGbKjdcv4DCwTvppJNcK4/jjz9el19+uQtdJQ7wuF6Ey2k589RTT6221rWHpcvO3/+f+v6TiYpF42mLyXadWun2t87TP8eMdmKWPMimwnJ5hMkH3XmFVuRlr7K0aHmlOj7xlmbNmqVlpZUaUbCHss1Jt+yjjr1briL6EIu4s4SrmSzQC/OXX35xQgSHGsFEH0pf9c2kgeKRxqDVVL1CbmhLhXfNrZ3FpKMp49L67dbVCf2Pr2v+jvA9/fTTXViV88jkgBy9Rl8qHncCtPfam2jQupvrxbc+UoeefVVdHVV1VaU2GTFYw/p108Zr9dbw/t3qdTJJ/SDtg88GXQL+G1DsEnQjOXcs8Ulup28DFY3X6JbxR6g8SpP3zFXIxWJxlU1friePnegmKgjJ+nKwDcMw0sUEZZb5ZWmJHpnymf497RtVRKsVxvsK+UyxkKtspXdlYSRX+/YeoQP7bKg+LVe6Uw2B4GCdanIqEQ1UQpOblxja++ijj9z6vQxeuH70gkxG+bIKJyonfDPNDUbNgXV1W3dooeufO03denfUMccc41q3UH3eFGj6jOu25U476vtdayt2swXn5MWN99TyxYs14bupeuTC95RtPit7XmVVs1b7OXmOiBDfhJz+neT59ejRQ2ussYZzIRty+XCBg/9GgDZW8f/lwq9026Q7apfobGb4O296jsbsfZtywqu+F+7qE0884QQdgp3JD65hQwVjVGaTC0xolrDsxRdf7FI9eC16kh555JEpbRPtp+gowKo0LHP4W0J+sHcj2QYEMm4kbn2yCv6fFn+gZ2Zmfn31QSV7aa/NjrBWP4ZhZB0TlL8R5TVVGrdwtn5YNFu/LCtVVTSq/EhEfVp00JC2XTWsTXcV5jQv0R8Hizy8Rx55xIkwlpejKCfxOSw9x2oXVIvjkCRzdirKK3X7eU/qjSc+cWHQeBOF5dCN+ums2/6qjt1r3VIakuOc4o6mClXJvojkrpef18HvZi4UXx+zz7tJ1bPnqyjSWlt0PDjr7zd0r7Zq3a3ACQ/ENsU5CCZEEMcMMUjlLT8bPXq0qwLPZrHErBWzdefkuzWtfLqb6KTS9JxqbgRk5Zvl+vHpHxqcNOCmMvm58sor3X6cf/75zmFPtvY4xWVcywhQL7AR1eRBkvJBGL0xcH3JIWVyxfeprHGeLmwn66vjRrLYAHmJ3o1MpdjlmRlX6+clHwtZnz4hjWi7k3bpdkIGXsswDKNxTFD+D4ETQ74k+Ws4gwzeQSeIKlsGawQnq9CQf1nfQPv5Wz/o9vOf1NxpJc51JCSejHg85nLcWrYt0qFn7qZdD998FYeUPpkURhDuTHVQJjxK0Qmh0tIW+dr/tUeVbdZ6/0f1zClUu7bt9c2DixTPXtGt461596k6XlvBTu4gTbepyCfHjbDwgAEDnNtIGygqcimcIH0BpzJb0PT9w5KP9NrcNzVzxUwnLJ2L/qvACf67IFygrTptoR06b6/nHn7WiaaysrJGq9Wp4r/00kvdvrDPuOqEpr3YonCHnqUIaFIl4JNPPnGuOgJxk002cc6lv8ZwVb8pm6lvy2bqh0VzNK9iiXP9o8tW6M0Hn1KXWL4+f+xFFUQyU5WdDNrteDcSwUs3Bu9GNqV6vzJarkemnqe5FVPSEpWco17Fw3RAr0uVE87efhuGYQQxQfk/BgPymDFjdOGFF7owF6IScRlc3YL2OPQ+JAxHE+P6VhBxg/UH4/XG45/oh88ma/7MslV+36pdsabM/VFb7b2Brrz1PNeCKFEcIlhxpgh1psIFF1zgiikoothxxx31zYLZGvXyQ8o2ZZfdrk6hXOd+tZozWLHl2RuIY5FqjTiknWvaznmhbdDEiRPrHj4vEtHkw9y0VMKt5Fzi7PG3qTavbyqc9+nl0zVp2WRNXT5NZVVlisZjKsopUq+inupdvIYGt1xT+ZHaymC2GRHsQ9SpQO4vYpm8QnIJb7zxRpc3ynlHPJMm4YvNKKphGVEmJbw+IvTUM07XE1O/1EOTP9WM5Qtd2gKatC5XOf7rGu45ERXn5OsvvdfVEf1HqlNh6oVhDcG1/corrzg3kv1mUkChC8Ka6EBz3WRE5VMzrtC05d81e9sGttxIo3qcpdywVW4bhvHbYYLyf5R58+a5vDWqvHG+cCODuZOEJ/fee28XiiQcTZuZxqD5+aKSpbWr97QuUpsOLd3gT8UxDbQToXoZQcTAyxKCjUF+J2H5a6+91okNWFxVoeGPjVY2wes6vixXk8dP0KeffqqqaS3UI29oXXFJRt8rEtZ2+22kU/9xSNLfc2xJT0BABkUmOaVeVAJClJWEcDJ5eFeTBxOE33J5PLYZV5GiD8ReU2B1FroW0PoIJ5vrkeuGNlOIMvqT0pCd4hqWGD3vvPM0+t8PaYPr/6750VrhnUpSBgVv+eFcXTB8Z43qNbzZgg8HkjxOHjiT5HriRiImG2rT1BRw/b8o+49zsaOxGu7SKbmSOeF87djlOK3dZlvrJWkYxm+OCcr/cQgXnnDCCW7APuKII9yATz6aDz+S4/Xee+/phhtucNXgTR1oCV3imPFaicUGvC59JBFDgwYNavB1aPKN4KXFDM3Fg9ux6dNjNGv5EmWLTspRywdfduIGR3WPnfbR4o8zIw6Ssdc5G2rtjQY5N5Sq+1R7ACImyS1EgJFPSPiXohsEJy6n7/NIJTGpBolCk0e3bt2y0o8RQUUrHHo/NhX2i3xRJkDklFJAw3KU5N7yPRMWJkCuqOyXL3XhVy86ERuKNG0/uKKQZgjKy0fsoZwUjwPHlUkRPV35SqEU4WzcSFIUMgn7xWeVpuPPvfqU+m1TrE0P7a+C1rUThLAidXsSU9T9rGVOB23QfjcNb7O9inKa3yDfMAwjHUxQ/gkgPEd+F+4O31922WWuRyUhUwZLBnIEJYMkjbYZMFMFlwZHjDw/xGkQQutUnSMIGiqKoD/eBhts4EK75E4mvv+Fn7yuRyd8k5HVhxKJR2Na8upYjSip1KGHHupcMpymy/56pz59Y1xGVw9CAiyunq9PSp9Z5ef0nERcNvZAPAIthjhn5MISJsYtQ0BSTRx0Nb3LidDzziah2f79+68mNHkw0Wiuc+cnFghdv51Nhf3hNTj/iGLcakLKhMF33nlnPT/9W52TgaVN2cPde66tq9cb5Tou1AdOqXcjKRAilI2I5DpvSk/VVOD1mSwgJFnRh4kGeaS4vkOHraWyqtmas2KS6wwQjVUrEs5Th/we6lLQX+3yutb26jQMw/gvYoLyTwTCDVGJaKSpMmHwLbbYwv2O1i60Y0FYEF4knJoqhP1YJ5kBMQjtXngvXKf6QNASDifEiQtFiDyRnxcu0E4v3KesEI/r8ZF7aONBQ1b5ccmcRTpm88tc1XumWgPm5EZ065vnqLBNjgtrN/bwy056EDFBgcnkwK/VjXBHjCHuEeZBYUgxFv0sE4UmD0K4vkURr58oMv0D0duQ2Pzxxx9dj8PXX3/d5Tw2B65FxCQTEVoLce0wEXnooYc0fPsttPc7d6omg9VSF6+zqw7os/5q1yM5kQhZ3Eiq7RF25K42toxpUyFXlpWhEJGseoSIHjVqlFu9hkr/bOXIGoZhZAMTlH9CEG5Ug5MvyGBJsQOhUFZjIU+Nal0cR4piUoHBH3HK6jbBQRB3ZfLkyc51rA8aX9MWhwGV8HgyEE5b3/8PTQtVZXS1HPLqtuvZX3duvfcq4os0Abbn3We/UHFJn4y933GX76s9j946peci8hCKiSITcZ74MxzLIIiwVBxPOgDQMJ1weWLOJo/gRIDwc31ik1QHtheHk3xCGok3FbYBl5VJCU45IW+uRQp2Pv38c6112ymKd27terZmioJIjl7a9gR1L27jXFycSKq12W8cc+9GIiozBU4xDd9ZApHcZVoaEdbns4Ijm86a7oZhGP9NTFD+SWFgwwk6++yznROGm0gOJQMcq2rgzlAhfs455zQaBqW9z8YbjdTD/3pGLQs6a97sRa7N0BNPPKp2nQs1eszV6tqj3Wqvg/PEQEoVOO5aMhC5DOxfTJ6gntecoVgT8+bqgy0pysnTW6OOUtm0mXXLGlIEwtrT7dq1c8sarlE0XONeq99hTZX9T9pBh5+7R1aKJdhezhe5laQg4BDiQCPwg8IThzoI4h8R6AUmk4qg4ETccG0wwUisROe1PSzhh7AkbAt+RRxC66mKMdIwWJ+eYjIEMa132DaE/XWvPKZ/VUzI8FGrnVCsE2+j0rtecf0j2VaufdxIXPdMwjHDieSaJzWBCADXPmkWTYkGGIZh/F4xQfknZ+HChc5hvP32213hDE3Pqapl9R2cJirBEZ715YzN+GWBXnz8Ez376AeKhHJd6xb6VkJ1dU1dble3Xu016uCR2nb3dVTcosC5pKxBjRuFM5QotMi7ZHUUxAlihRDkzE4tdc7Hr2Zs3wePm6nvHn3GOVKEG8lHRIzxQFD4Sum3n/5M/zz7MVVV1jQpp5KK7nA4pGMu2Vt7HJncfc0kuI0cM9oukYJAhX+waITf036nsVA7YtHnXALnBtEYFJsIbop7WK0JhxSxSjEJeYdBeG7QzfS5m7iR5HMC7iY/w6ljm1l+kiIfVniiUOvQsffrq9LpGXUnPbHqGrW57R393+FHav/99292/md9n60nn3zSuZEUK5Gby3sgJLnWstmo3jAM47fGBKXhIIeRMPgHH3zgQm/0BUQg4KDQTJtcr2CldlVltR687S39+4EPFAqHGxdav46drdsU68jTttbRJ+7nHDEqwRMLdlinnD6ZiBP6UtJCyFdC3/b9x7r+q7HNP2vkC4ZCKnv4BfWZv6xOQCJmGipGWjBroROVNHxHKDa0v74R/LCR/XXyDQere99O+i2hhyP5sLi7uJZ+ac5UIcUg0d1MFnpHnCIoEyGPE3cRkY5YxOVEXOE+MlEAxBTXFUISoUWIGzFMU3smMQhPVpuZv2Kptny1tsF5trhq3T211xq1PS/TheOB24kbSY9N/k3qCHmRdDDwItowDON/DROURh0M/uSwsYzjkiVLnJijzySuCgKCcB2D4vw5i3Tusf/S7OlldQUdKV9wvy7nWLLiRz371mj17LWyqXpJSYkTQDg6FGjgSiZrN/Svrz/Sld++X1ug0YQWOFR058Tj2i+/k07dfve69klNYeakefrPg+87YTn7lwWr7X/nXu213laDtethm6vvWtlb1aYxEDK4u4SSaYJObiBthjIJ+44z6UUmIW9aVNEwv1evXqsIUN+s3cMEAQGPC8y1Ru5qEBxRwvYdt1hH3w3PXl5hTiis/Xqvq4vW2bXZr+EWAPjmGyciaXmFGOcYICJx4KnYNgzD+F/HBKWxGgzwLI9HsQz5XfSuRGhS/X3W6RdoxtcttLhseb3LMabKdnuM0GmX7eXcKl7/1FNPdVW2tDCiajnYL5FwLY4VgzZtZCLt2mjAqUdqadd2LheuoZZC9IWOh6Qdew3U5Rttr05FmSmyoAJ81pT5LhSem5ejrr07qLjl78uBovoat5I13P/+97+7vNhMhnUTwWEkDxeXOSi4CIsncznJ+WS1JvI1EZWJBUYd9t9K7ffZ3K14ky2Gtummp7Y+psl/xz74Vj+4wZ06dXJFbghJckANwzD+TJigNOqFfngUy9DwG6HQv98AffzCIrUsJISbmfyvUYetr2dev90VxJA3949//KPOOUSIkHvGgE1bI3ocUn1LGJ4wIs3Qn3v/HX1YuVCVPTsrt2unVZpdIzQHtumgrbr300EDh6tny1Ubr/9ZIITN5OD88893OY30JN1mm22y8l6kSrDsJ+eKkHeqqyP99NNP7jqjP+qrr77qCmQQbE+WT9K44grFw9nLN+xe1EZv7nhySs8lZE94nmuSFkm5ubnus0FeJNektfoxDOPPiglKo0EQdRQW0N6nONZffTpsmjExCbF4VFOX/0ejb7vWNa8GWg2xcgohdr4nJ4/2LRSaUC2L+KSoh20j187nQY7cfDMtiUhV0ajyIxH1aNFa+RHr5eeZNGmSjj76aJe3SuU8IfFMt6nhvCD6aRWVSogdMUYuJtX1VIUjdDnvnqu+e0WPTfkio/0nE+lR1EZvNCAouc7ILfatfnDwKapBRP7lL39ZbYUowzCMPyMmKI2UmDl9no7e/Zba2HFmr0CN2LifzrpmLzdY4/wgRgjL0tyZwh1a1tC7jzw8eifycwQkX8nVM1KH6m2WEKTQCSFEnqoX8pmAlAUqwFnJh0dDsFwn5/fmm2924W5yd1mmE2Hpuf3n99wjG6skeYa366HHtzxqtZ8zmUHcck3SGL537951rX6C22gYhmFIZt8YKfH+qz+5FkBNLcJplHhIX388Wb17DtLS8hJXiIH7gxP5/PPPu+INKrDpk4mIJDctG2tR/1ng2B1//PHaZZddnEvJV0QSqQYIwXQh5Mv5wwVtTFDSHoj8WQq/NtxwQ5c3myjUhrTpmlUxSVHO2m271f2bUL2f2OBK0i6LkDyts2hzZdeeYRhGcsyhNFLi0B2u14K5i7NytOLxmOaVf6Nvp7zi/k0PSB/GRpxYq5XswOQAoUQxFG2F6EVKy550oYiL4h9aBTWUU0honNZBfKUIjElEouNcWrlcm798QxY6UK7k6hF7Ku/H2U5Ekh9JhTzXHkKbpRCbsra9YRjGnxUTlEajLCpdpgO2viarwqagdZUOOml9l0NHyxjjt4Nqa1xL+ibixrGMJhXLzYVCKvInqSxHLDa09jchZQq/WKGGpvrJOPrDh/XJgilZcSoj0bhKTr9H86bPcttDhTaV2oTiDcMwjNSx2KHRKJN+Sn/pwYYg7JkTa+0KHExM/vYgnnDmWL/97bffdsVP9FNsbnoDq/PgKhP2rg+EJCF2hCUtoc4777x6n3tw3w2zIibj0aiWj/1eB+y1r7788kvX+oc8ThOThmEYTcdyKI1GKV2wam/AbLB8WYWiNTHl5Gav36DRsKinkh6HmH6VuHTkOI4ZM0bdu3dv0qGjXRAO5dsffKhN9t5PJcvLFYvH1TI/X4O7dFSn4iJXxU+FN64kKzTRzqg+tuwyQP0irTSpatEqbaHSAlc8kqu3r7xH3Vq2zcxrGoZh/IkxQWk0SlPWr06HZ599Tt17dHUri/Cw3LXfHkLdCElWR6InJGFgekvSHD2VtafLlpfr6W9+0MItd9YyhfXXR55Z7TlFORFVrr2BFv8aIKHivD6o/qZ/5usP3at+/zzRNazKiFcZCunS9fYwMWkYhpEhLIfSaJSxr32vq858IqtHin6Ub4xbNU+T5tZeXNLsvL7vefi1vo3MQVHNaaed5gp3aNF09913u9Y5yaiORnXPR1/o1rGfKBqPuSXTGyIei7k14HvGqvTkmX9Xu6LVVxgaP368W7qQUPTVV1+t4QfsopM/e0px9196HNpvQ507bKeURLJhGIbROCYojUaZ8csCHbPn6KweqX5rdtWlt+/vmlzPmzfPfa3ve/oXJub3tW3btkHR6b8nR9NWM2karFxDi6GysjJde+21roAn2D5n9uIlOv6JF/TzvAVNPu/hUEitCvJ18z67amSf2gpvzu29996rk08+2VWBk9u57rrrut+9Oftnnfb50y6EjnBtCt7dPKL/xjpz6A7uvQ3DMIzMYILSSKkZ9t4jL1fFiuqsHK1IJKyd91lfJ16wR8rNs0tKShoUnf57RFAQHCmaozfmevK1ffv21nfwV1gd5uyzz9Ydd9zh+oKyfCOrFM1atEQH3P+4SpeXKxprnm+IrouEwrr9L3toWPvWTryyvjer+tD0PHHt8V+WluisL57VuEWzsbZRpY2+R1ghtckr1BXr7qGtuw5q1nYahmEY9WOC0kiJmy56Rm+9+I2iWcqnvPbeIzV8g74Zf10qiOfPn9+o68lj6dJVi48ikYjLKUwl7M6qM3+G8ClLJB511FGu1dDFl12utwrbadbiJc0Wkx6OHI7hsifv17KZ0114fZ999lnteePGjXNLID7y6KNa3r+9uu2zldSzfV2Tcu9aIlBd6J280IKWOrjvBtq/z/pqnbd6aN0wDMNIHxOURkpM/HGWTjpgTMaPFhqsa8/2uvfFU/7rgoylHb3AbEyArlixYrXK5lRcTx7khv6RWb58uS688EI9/NNktR25Ze1JzFAbn9zypfrPCUeq9xpr1P2cCQFhb4Tk119/7ZzjAw880PWMpEXR1GWl+rZspn5YNEcllctci6GWufka3LqL1mrTTWu36+4EpmEYhpE9TFAaKXPhCQ/qy48mZbzq+9zr9teWOw37w5wJcvxwM1NxPfmelVeCUL2earHR73WVoPHzSrTHXQ9l5bUv3Glr7TtsTb300ktORL7yyisu9WC33XZzIpK1xxHwhmEYxu8HE5RGypTMW6Jj9rxZK1ZUZaR3SzgS1sZbDtKF/zjov+5OZlN8Ui1dn+gM/gwnjnzVIK1bt64Tmg2JT0Lzv6XIuug/b+rpb8alHepORkFNlabfco1bV5s1vlkCkR6ZOJOGYRjG7xMTlEaT+Pidn3TZqb+uohJPrxCnY9fWuvnh49Sm3apFF39WotGoSktLUwq5U5SUCIIrlZA7RUnkhzaX8qpqbXzjGFXWRJUttqhcpNMOPkCDBw/O2nsYhmEYmcMEpdGsvpTXnP2kq6SIRZuuKsPhkDp3b6vr7j1SHbu0sTPQDAij0z4plZA7Tt+qxz/s2ielkvPJ8oiJ7vEX02fq4Aeeytp5i4RD+ttmG+nELUdm7T0MwzCMzGKC0mgW47+fqevOe0qzp5elvOYzQjIWi2u7PUbouLN2UYtWv8/8wP81KioqnLBMJeeTgpsgubm5q1W6L+3eW9/mZq+wCP26Zf8+uvOAUVl7D8MwDCOzmKA0mk1VZbWeeegjPf/ox1pYskyRnLBbjztRRAJCcui6a+iAY7bS+psOsKP+O2XZsmWNVrqX9BmkyJrDFIpkb+XWPu3b6tW/HZG11zcMwzAyiwlKI22iNVF98eFEjftqmsaPm6k5M8qcsCwozFW/wV01YEh3bbTlmlqjXyc72v8DXPLyW3rq63GqSSggyiTd27TS2ycdlbXXNwzDMDJL9iwG409DJCfiBCMP43+fwrzcrL9HUW7238MwDMPIHNbt1zCMJtG/Q/usupORUEhDupibbRiG8UfCBKVhGE1ira7ZFXssmJjt9zAMwzAyiwlKwzCaxICO7dW5ZfaqvGkaQJW3YRiG8cfBBKVhGE0iEg7rkA2GK5yF1Y14zZF9eql3+7Z2VgzDMP5AmKA0DKPJ7DtimIrycultn1Fi8bj+b9MN7IwYhmH8wTBBaRhGk2lXVKhLd9k2E0u6r7wZhULab52hzqE0DMMw/liYoDQMo1nsutYg7TFszYy4lCy32LNNa529/RZ2NgzDMP6AmKA0DKNZsMb3VbvvoG0H9UtLVNImqFurVnrwsH3VsiDfzoZhGMYfEFspxzCMtKAn5W1jP9EdH3zmhGU0xbXdeS7P3HZgP12x23ZqV1xkZ8IwDOMPiglKwzAywg9z5umq19/TF9NnuRB2NJZcWPrf9WjTSqdtvZl2WWugczsNwzCMPy4mKA3DyCiTFpTqmW9/0FczZuunuQtUUVNTV3TTr0M7rdOjq3YZMlAb9+mVldZDhmEYxm+PCUrDMLIGbYBWVFcrFou7NcBzwpa2bRiG8b+ICUrDMAzDMAwjLcwuMAzDMAzDMNLCBKVhGIZhGIaRFiYoDcMwDMMwjLQwQWkYhmEYhmGkhQlKwzAMwzAMIy1MUBqGYRiGYRhpYYLSMAzDMAzDSAsTlIZhGIZhGEZamKA0DMMwDMMw0sIEpWEYhmEYhpEWJigNwzAMwzCMtDBBaRiGYRiGYaSFCUrDMAzDMAwjLUxQGoZhGIZhGGlhgtIwDMMwDMNICxOUhmEYhmEYRlqYoDQMwzAMwzDSwgSlYRiGYRiGkRYmKA3DMAzDMIy0MEFpGIZhGIZhpIUJSsMwDMMwDCMtTFAahmEYhmEYaWGC0jAMwzAMw0gLE5SGYRiGYRhGWpigNAzDMAzDMNLCBKVhGIZhGIaRFiYoDcMwDMMwjLQwQWkYhmEYhmGkhQlKwzAMwzAMIy1MUBqGYRiGYRhpYYLSMAzDMAzDSAsTlIZhGIZhGEZamKA0DMMwDMMw0sIEpWEYhmEYhpEWJigNwzAMwzCMtDBBaRiGYRiGYaSFCUrDMAzDMAxD6fD/YLz9lm5r6HUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Convert networkx graph into an ABCDSample\n", + "edges = np.array(G.edges())\n", + "# Converts node names into ids\n", + "names, edges = np.unique(edges, return_inverse=True)\n", + "community_dict = nx.get_node_attributes(\n", + " G, \"value\"\n", + ") # Community ids are stored in an attribute called value\n", + "communities = np.array([community_dict[n] for n in names])\n", + "graph = ABCDSample(edges, communities)\n", + "\n", + "abcd = ABCD(100, rng=np.random.default_rng(seed=42))\n", + "abcd.fit(graph)\n", + "print(\"ABCD object parameters now match those in the fitted graph\")\n", + "for key, value in vars(abcd).items():\n", + " print(key, value) # Print a name-value dict of fit parameters\n", + "\n", + "graph = abcd.sample()\n", + "G = graph.to_networkx()\n", + "pos = nx.forceatlas2_layout(G, seed=42)\n", + "nx.draw(G, pos=pos, node_color=graph.community_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, ABCD objects fits the community and degree sequence by finding a powerlaw distribution that matches the observed value. However, if your graph does not follow a powerlaw, you can let the ABCD graph copy the exact degree and community size sequences. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ABCD object parameter now match those in the fitted graph\n", + "n 115\n", + "xi 0.5020576131687242\n", + "outliers 0\n", + "eta 1.0\n", + "dimension 8\n", + "rho 1.0\n", + "degree_exponent 2.999999999999999\n", + "min_degree 7\n", + "max_degree 12\n", + "community_size_exponent 2.999999999999999\n", + "min_community_size 5\n", + "max_community_size 11\n", + "degree_sequence [ 8 10 10 12 8 9 10 7 10 7 9 11 7 8 11 10 8 8 9 8 8 8 9 9\n", + " 10 7 7 9 9 8 10 8 7 10 9 8 7 9 8 10 11 12 11 7 11 11 7 7\n", + " 7 7 7 7 8 9 9 8 7 7 7 7 7 7 8 8 7 7 8 8 9 8 8 9\n", + " 8 9 7 7 7 7 7 7 7 7 7 7 9 8 8 7 10 8 7 10 7 7 7 7\n", + " 7 8 12 8 10 9 10 10 11 10 12 9 8 10 10 9 9 8 9]\n", + "community_size_sequence [ 9 8 6 7 7 9 5 6 5 6 6 5 5 8 5 11 7]\n", + "alpha_max 60.0\n", + "alpha_min -60.0\n", + "alpha_iters 10\n", + "rho_tol 0.05\n", + "model configuration\n", + "max_swap_attempts_per_bad_edge 5\n", + "rng Generator(PCG64)\n", + "logger None\n", + "verbose False\n", + "logger_ \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/ryandewolfe/miniforge3/envs/abcd/lib/python3.13/site-packages/powerlaw/distributions.py:743: OptimizeWarning: Initial guess is not within the specified bounds\n", + " result = scipy.optimize.minimize(fit_function,\n", + "/Users/ryandewolfe/miniforge3/envs/abcd/lib/python3.13/site-packages/powerlaw/distributions.py:808: UserWarning: Fitted parameters are very close to the edge of parameter ranges for distribution power_law; consider changing these ranges.\n", + " warnings.warn(f'Fitted parameters are very close to the edge of parameter ranges for distribution {self.name}; consider changing these ranges.')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "abcd.fit(graph, do_not_set=None)\n", + "print(\"ABCD object parameter now match those in the fitted graph\")\n", + "for key, value in vars(abcd).items():\n", + " print(key, value) # Print a name-value dict of fit parameters\n", + "\n", + "graph = abcd.sample()\n", + "G = graph.to_networkx()\n", + "pos = nx.forceatlas2_layout(G, seed=42)\n", + "nx.draw(G, pos=pos, node_color=graph.community_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparing to LFR\n", + "\n", + "The ABCD model was built to be a faster version of the very popular LFR model ([Lancichinetti, Fortunato, and Radicchi, 2008](https://doi.org/10.1103/PhysRevE.78.046110)). Both models feature powerlaw degree and community size sequences but diverge in the noise parameter. LFR uses a noise parameter *mu* between 0 and 1 that is the fraction of inter-community edges, appear similar to ABCD's noise parameter xi. However, when mu is large (think 1), there will be so few edges within communities that they become less dense than the overall graph; the communities are actually anti-communities. In contrast, when xi is 1 the graph communities will be exactly as dense as the background graph (because edges are wired randomly), so we never push into anti-communities.\n", + "\n", + "Lets test the speed of both models. We'll use the [LFR implementation available through networkx](https://networkx.org/documentation/stable/reference/generated/networkx.generators.community.LFR_benchmark_graph.html), although we'll note it's slightly different than the model from the LFR paper. We'll also note that our implementation relies on numba which can take extra time to compile on the first run, that's why the second code cell in this notebook takes so long." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from time import perf_counter\n", + "\n", + "# Speed test vs networkx's LFR implementation\n", + "min_n = 1000\n", + "max_n = 100000\n", + "n_ns = 20\n", + "reps = 10\n", + "\n", + "ns = np.round(np.geomspace(min_n, max_n, n_ns)).astype(int)\n", + "lfr = np.empty((len(ns), reps), dtype=\"float64\")\n", + "abcd = np.empty_like(lfr)\n", + "\n", + "for i, n in enumerate(ns):\n", + " for j in range(reps):\n", + " start = perf_counter()\n", + " ABCD(n).sample()\n", + " end = perf_counter()\n", + " abcd[i, j] = end - start\n", + "\n", + " start = perf_counter()\n", + " nx.LFR_benchmark_graph(\n", + " n,\n", + " 2.5,\n", + " 1.5,\n", + " 0.25,\n", + " min_degree=5,\n", + " max_degree=int(n**0.5),\n", + " min_community=20,\n", + " max_community=int(n**0.75),\n", + " max_iters=10000,\n", + " )\n", + " end = perf_counter()\n", + " lfr[i, j] = end - start" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Scaling of ABCD and LFR')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHICAYAAACiZIUjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAj2VJREFUeJzt3QV0m+f5NvDLzI6ZOczMjA0U05WZ17RdV/i2dV27dd3WFfZft3JXhpVhbdqm4TTMzGBmZra+cz9v5NqxyI4tC67fOTqJpVfSaymObj/PDS46nU4HIiIiIifk2tsnQERERNRbGAgRERGR02IgRERERE6LgRARERE5LQZCRERE5LQYCBEREZHTYiBERERETouBEBERETktBkJEDurBBx/E+PHjzV5nq7Zu3YrFixejX79+iIuLQ2lpaW+fksO64IILcMMNN/T2aRD1CvfeeVoi57Jt2za88MILOH78OKqqqpCSkoL58+fj5ptvRnBwcI88Z0lJCXJzc81eZ4vkPBctWoRf/OIX6nXz8vJCnz59zN7vySefxGuvvYZ58+bhnXfeMXjMn/70J7zxxhutX7u6uiIiIgLDhg3Dr3/9a4waNcrg/VavXo0PP/wQe/fuRWVlJaKjo9G/f39cf/31mDNnDlxcXNRx06dPR2pqautj+/v7IzIyEqNHj8YVV1yByZMnw9bk5+e3nr8p8r35+vrixx9/NHmM/vs/18cff4xp06Z1OE6e28fHRwW98npee+21Xf5eiDpNRmwQUc/597//LWNsdDfeeKNu8+bNuhMnTujee+89XUpKim7gwIE99rw33XSTLjY2tt11JSUlutzcXJ2tW758uXrNdu7cafF9GhsbdVFRUbrg4GCdu7u70e/z/vvvb33szMxMXXp6um7jxo26uXPn6jw8PHQbNmxod3x9fb3ummuu0Xl6euoefPBB3aZNm3SnT5/W/fTTT7pf/vKXOjc3N90rr7zSenzfvn11Q4YMUY8tl2PHjum+//573e23366OXbp0qa6mpkZnS0aOHKm74IILzB4n35sca+6Ytt9/20tdXZ3R4/bs2aNeI3lv/vjHP3bL90VkCQZCRD1IPpwDAwN1kydP7nBbRUWF7q677rJqIGQv3nzzTfWBePToUYvv8+WXX6r7rFixQufl5aV76qmnTAZC8uHbVl5enrr+hhtuaHf9fffdp3NxcdF99913Bh9v3bp1unfeeceiYOHbb7/Vubq66q6//nqdIwdC5o4xdlxLS4tu8ODBOj8/P11DQ4MFZ050/pgjRNSDKioq1GXgwIEdbgsICMArr7zS4frTp0/jnnvuUVs0cj/ZHtq+fXvr7U899ZTKmZFLQkIChg8fjltvvRXHjh0zez6GcoRuv/12zJo1CzU1NXjggQcwePBg9dx/+9vf0NLS0uExvvvuO8ydO1dtYyxZsgS7d+/Gs88+q86nubnZom1C2SIaMGAABg0ahOuuuw4HDhxovV3O5eGHH279uzzuXXfdZfZxZbtLvjfJd5HHf/PNN+UXPVhKtrBki6btfTIyMtR7JO+B5CsZIud44403WvQcF154IS677DK1xXbq1CmTx8r2nv59TkpKwsSJE/H444+rrdW25La//OUv6v1funSpel9mzpyJH374ocNjyvsj79XYsWPVa3/nnXfaVO6VvP7y77m6uhp5eXm9fTrkLLohmCIiExITE9WWzalTp8y+TrJ15u/vr5s+fbpa2ZAVkS+++EKtKJWXl6tj5E/9dkJaWppakViwYIEuPDxcrWqYWhEydN0ll1yiGzBggO7aa6/VffDBB7ojR47o/u///k+tXPzjH/9od+zHH3+sVkdkJUu2MmR7aNGiRbqrr75arabICpgpX3/9tdq2uuqqq3Tbt29X3+/ixYt13t7euvXr16tj5Ht45pln1OPJdfJ9FhcXm3zcjIwMdb5vv/22+nrLli3q/mvXrrVoRUi2bGTbSx5DtrH0XnvtNXWsvC6WMrci8tZbb6nHfPXVV00+jrwO+vdZtlPltZd/S/J6tSXbbfL6X3jhher73b9/v3p95Xp5L9u6+eab1Wv9wgsv6A4fPqz76KOP1OMNHz7cJlaExKRJk9S529r2ITkuBkJEPUw+zMPCwlT+yaxZs3S/+c1v1DaOPrBpuy0gAYlczg0o5Da5GFNbW6s+4J5++ukuBULywSx5OW3JB2tSUlLr101NTbqYmBj1PZy7xRcSEmI2EJL7x8XF6UaPHt3uermP5EsNHTq09br//Oc/ndoa+9Of/qTOQV4HPXkeye0xFghJcCqvRXR0tArOJAA9N+D57W9/q46VwMpS5gKBNWvWqMd89NFHdV3NnZIgRk+CBsmLKisra72usrJSfT/33ntv63WSEyX3lSCzrW+++UZd352BkPxbl9e27UWCNVOP1dzcrIJDOZfbbrvN7LkQdRdWjRH1MNmmSEtLU1tKmzdvxo4dO/DPf/4Tnp6eapvrvvvuU8cdPnwYJ06cwN///ne4u7f/0Wxb0VNXV4cXX3wR3377LbKyslBfX6+ub2xsVPfvCqkEkm2utmT7RM65oaFBnatsX+Xk5OAPf/hDhy0+2Y766KOPTD7HwYMH1fnef//97a6X7/Waa67BX//6V7UVJdt9nSHbd2+//TZuueUWeHt7t15/9913q9dWKtBCQkI63E9ev6ioqNaqKakyk8dwc3PD1Vdfra5vampSf8p13UX/3prbRpTX4rnnnsOWLVtQVFSkzkXeYyHv85AhQ1qPlQrEtlV1ss0n26pt/z2sWLFC/XnVVVd12K6T97A7STXduZVlbd8bvSNHjqitP1FcXKz+bf/qV79S3zeRtTAQIrICPz8/XHnlleoiCgsL1Yet/KcvOTmSDyJBhkhMTDT5WJdffrnqsSMfFhMmTFAfgBIoSV6PfJB0RWxsbIfrgoKCVL6M5JBI+XdBQYG6PiYmpsOxhq47lwQbQv/B15b+OskL6WwgtHLlSqSnp6tARsqz9SRwkCDx/fff7xB8CQmC9M8rf0rgt2fPHhVAXXLJJaqcW/996d+b7qBvX6APwoy9VuPGjUNycjL+/Oc/q8BCzmffvn246KKLOrzPxt4/CQLbPqah90r+7Vjy/nWGh4eHwffZWMAk/87klwUJsuX9uu222zBixIhuPSciY5gsTdQLwsPDVTKy0P/mLB9cbT+wDJG+K99//z0effRRlSAtvW/i4+MRFhbW7kOvs6TfjTH65OHAwMDW39zPZei6c+lXLAwdK4Fh22M64z//+Y9azZIgQRKx9Zddu3ap5HC53VISTJaVlbUmMktSuFizZg26y7p169SfU6dONXrMp59+ql6T9957TyVpS8AggYV+9c/S969t4rf+/TP070RWnHqDPmCSf8PSV2j58uUq4JNfEvSrX0Q9jYEQUQ+SxnvS4M8QqSYT0ixQ/yEsAc3XX39t9PH0KwFyXFuff/55pyqkumLkyJFqy2Xt2rXtrpctnp9++sni+xtqxifXyaqTfOB3hqxSyRaXrJLoK6zaXmT1TLYcJTCyRGZmZrugVM5ZGjvK1puxKq/s7GyDFVqGSEPNDz74QDUVlBWfzr7Pn332GbpK38hQGkO2JQ0iLQlkrUG26GSL9OjRo3j99dd7+3TISTAQIupBEiT88pe/VFtihw4dar1etmCkVF1yc/SjDSQPR0qb169fr1YyysvLW7dSpOOxBFUSKMhvzy+//LL6LV6CHwlC5INauiP3JDnXhx56CJ988olaqZDvrba2VpW6G9qaOZf8pv/II4+o3/r//e9/q9/4ZYXjiSeeULlTsgVkamXKENkOk8dZuHChwdul5Fw6d5tbFZI8o//+978qJ0pWl+Q1bvscskUlZfJffPFF66qMBCvyOsiWmrQ8MEVWYd566y3MmDFDvVbm8qlmz56ttqxk1VBeZ8nTev75588rYJE8LtlK/d3vfqf+/QnZUvzjH/+Ivn37wlbIz4OU9ktLAGnpQNTTGAgR9SDZ6vnyyy9Vvop8CMpKg+QLyTaA9H/ZuHFjux5DMnJDjpetGPkAl4t8eMlIDrmfJNp+9dVX6sNYckzk8eSDTD5kZZuhp8lzSTBz7733qq0WOS/J5ZCxERLEmEsq/v3vf68SxZ955hl1f7m8++676vylp01nSe8g+dA0llcl57NgwQIVvEkg2Zb0HNKvHEmQJwGdnJ8c25YEmLKiJL2M5HY5Z1m9kgRsfbL7uQnI+iRguchxkvck5ypBiGzhmcufkdUiWRGRQEueT7ZSZUVKVku6St4fCUIlcNPnlknQJwGorNRZqu331vYigWJ3kPdMzknyxf71r391y2MSmeIipWMmjyCibiOrPLKCIR+O5lY/pHGeBFD6bRpDt8tjyIe4kA8O2WbTzy6TJGd9wKRn6DpZZZDnkQ/3cx9f8mUkkfbcc5Xj5bFCQ0PVbTIfatWqVSbzmwytksiqh6FZa7ISILfLeZ5bQdd2FUeSmGWlSc7DXFNLCWhk1U3eg7ZBkZyDvB/yOJaQVTB5bfTf+7nkfdBXm+nfHwlmOrvapSevg9xfXgf5tyOvsTy3/nxla04CmXPzq2TFUF4jQyuF8vrKvwP9ay9bjHJ+527FmfreziWBuPwbkmP089vMPZax4+RjSb4v+fcsQSBRT2IgRETnRT5QZWVIVhlktYqIyJ5wa4yILCbbM7KtpR/LIKsOUuosv93/v//3//hKEpHdYR8hIrKYJBFLECR5ObJNI3+X2VDffPMNpkyZwleSiOwOt8aIqEskf0jyVjqTaEtEZGsYCBEREZHTYo4QEREROS3mCJmhL9GVjqdtB18SERGR7ZI2DNIqw1ALkLYYCJkhQVDbLrNERERkP2R0jqkmpgyEzJCVIP0LqR9aSERERLZNGqnKQob+c9wYBkJm6LfD9OMAiIiIyH6YS2thsjQRERE5LQZCRERE5LQYCBEREZHTYo5QN5XYNzQ0dMdDkQEyMbyrk7uJiIhMYSB0niQASk1NVcEQ9QwJgpKTk1VARERE1J0YCJ1ns6bc3Fy4ubmpEj2uWvRcQ0t5nRMSEtjUkoiIuhUDofPQ1NSEmpoa1bXS19e3+94Vaic8PFwFQ/J6e3h48NUhIqJuw8QLI1566SUMGTIE48ePN/riNTc3qz+5ZdOz9K+v/vUmIiLqLgyEjLjnnntw5MgR7Ny50+yLyBlkPYuvLxER9RQGQkREROS0mCPk5KqqqlTejZeXV4fb6uvr0djY2LoqI3lQlqzOyH0M5fJIPpUkP8tjyPO5u/OfHxER9S6uCDmx7du3q2F006dPN3j7XXfdhT59+iAqKgqRkZHw8fHBpEmTsHHjxg7H7tixAxdddJF6PD8/P5VAfs011+DgwYOtx0jOVUhIiHosOUb+vmDBAnz22Wc9+n0SEREZw0DIib355puYOnUqdu/e3S5gaUuCJFk1kktRURGGDRuGCy+8EHV1da3HfPPNN+o4CXROnDiheivt27cPl19+OV577bV2j/f73/9ePZasNh09elQFT7feeiuWLVvW498vERHRubg30U1aWnQorend7tLBvtKB2fzWlaiursbHH3+ML774As8//zzeeOMN/Otf/zJ5H39/f1x//fUqgMrKykK/fv1QW1uLO+64A1deeSWefvrp1mMjIiLwi1/8Ql2MkZWh++67D9HR0bjiiitw3XXXqcCMiIjIWhgIdRMJgsb+ZTV60+4/zEOof8dcH0M++eQThIaGYt68eSp3R1ZlnnnmmQ65QlKyLis4oqCgQLUVGDx4MJKSktR1a9euVdfff//9XT5vWTmSXkFff/01AyEiImdSkQP4hgHuvTc5gFtjTkpWdW6//XaVuCxbXd7e3vjqq686HLdlyxaVIyQXWQHatGmTWj3SJzqfOnVK/dm/f/8un4ucQ9++fZGWlnYe3xEREdmV6mLgwKeArnd7xDEQckKSmyOJ0rKdJas9sr0l21IS4JjKEZLjHnroIZXgfOzYMXW7vorsfJsdSjWZjCohIiInUFcBHPgEaKzt7TNhIOSsq0ESdIwePbp1tefll1/GunXr1ABZY2Tb7OGHH1YVX++99566btCgQa3BVVdJECVJ1rIqREREDq6xVguC6sphC5gj1I2JypKj09vnYEmPHwliPvzwww6JzHPnzsVbb72FJ5980uSgWZn5pTdr1izExcXh2Wef7XJ+j5xPWVmZyhUiIiIH1twIHPwcqC6CrWAg1E2kWsvSROXe9L///Q+VlZVYuHBhh9suvfRSlTD9pz/9qXWbqm2ydGlpKf7973+joqICl112WescsPfffx9LlizBzTffjF//+tdqSnx2djZ++uknlWMkQZeelNbL40kwlZmZqXoIyXM+9thjGDNmjNVeByIisrKWFuDI/4DyLJt66Zkj5GSkZH7x4sWqFN5QICQrM1IJJiSBeu/eva3bZ9JMUb7+4Ycf2g2jlVWhPXv2qOBJVpkkcfrGG2/EyZMn25XUy5aaBFLyWLINJjlKshW3YsUK/PnPf7bSK0BERL3ixA9A0cn21+l0QEVur74hLjrZ6yCjZPVDuiuXl5cjMDCw3W3SVFA+yJOTk1XQQD2DrzMRkZ07vRbI2N7+upYm4MSPQFUucMd6ICjeap/fbXFFiIiIiHpO5o6OQVBDFbD/IyD/oJYv9NE1QEM1egMDISIiIuoZeQe11aC2KvOAPe8CFdk/XycB0de9M2rJ4ZOlZUlMPyRUGgLqy72JiIioBxWfBo59r+UB6RUeA44t17bF2vLwA4Zfgd7g8IFQYWEhXn31VZXLIwM+//73v/f2KRERETm28mzg8JeArkX7WoKh9E1A+uaOx/aJA675BIgaht7g8Ftjsgq0fPlyNRiUiIiIelh1EXDwU6D57KpPcwNw5CsjQVA8cMuKXguC7GJFSHreSB8aGelw7733qsDmXDLvSvrRyLHS1E962hAREZGV1ZWfHZ1R9/PXh6SBYmHHY6NHAf3mA37hvfo22fSKkMy+GjhwoBr98K9//QtZWR2bMK1fvx7Dhw/HwYMHVddjaep3991398r5EhEROa2GGm2IqswRE+WZWlJ0hyDIRQuABl0IDLsM8Ojd9jM2vSIkTfuOHz+uEp4//fRTg8csW7as3cDQCy64ALNnz8att97arukfERER9eTojM9+Hp2Rux84+ePPOUJ67t7AkEuB2LHAsKWAX1ivvyU2vSI0cuRIBAQEGL1dOhfLsM/rr7++XZdjGfHw9ddfq69llIPkCB05cgSnT59Wf6+pqTH6mPX19aoJU9sLERERmRidcfgroCJHC3xOrda6SJ8bBPmGAqNvBAYuBMbebBNBkM0HQubIxHJx7tTylJQUFSTpAxupGsvJyUFtba36u6wwGfPUU0+pTpT6S3x893a6JCIichg6nVYOL6XykhckSdLZuzoeF9JXC35GXgUMvQxwNz8k3FpsemvMHP3KzrmrRtJKW3+bzLeSVSBLPfLII3jwwQdbv5YVIUcLhv72t78hNzcXL7zwgtHbv//++w7Xv/LKKyofq+3tHh4eavq8DGFdunRpj587ERHZkNNrgPzDQE2xlhRdW9rxmLiJwGDJB1qqlcrbGLsOhPQBkAwKDQoKar1epqTHxsZ26TG9vLzUxZHJSlpaWprJ26urqzsESomJiR1ul63Hbdu24eqrr1Y9mtoGkURE5MDStwKZO4GSM9pU+eb69re7uAEDFgKDLwKGXAx4+sEW2XUgNGTIEPWnlNYnJSWpv7e0tKgP6vnz51t/j7S2BL3KJwRw7Z7dTtkWnDZtmkW3S16WJLX/5z//YSBEROQMcvcDp9cBWTuBM+tkj6xjp+hhlwMjrgCSpgMuLrBVdh0ISVL0xIkT8dprr2HhwoXqui+//FJ1k/7FL35xXo/90ksvqUtzc7Nld5Ag6Nn2uUpW9/9O91ryWWRkJAoKCnrluYmIyIqKTgJHlwPHf9BmhJ3LPxIYdR0w+nogtJc/F+09ENqxYwf++9//oqqqSn394osvqmowCXr0gc/rr7+OuXPnqtUJyeX59ttv8eSTT2Lw4MHn9dz33HOPukiOkKx+OJu9e/e2WxGSGW36FgXnkuTzb775RjWzJCIiB1aWCez9QCuVbzs0VS98MDDuVmDElYDPzykrtsymAyF/f//WLa9//vOfrde3zQcaMWKE2gr74YcfVGfp3//+9yqhl86PVN61nct2bkK6PlCSHCHZmhwzZozaGiMiIgdVVQhs+Tew/yOgvrLj7UkzgMn3AP3nA65usBfutp4DpM8DMiU4OBjXXnutVc7JWZjLEdIHStKeQLYjZeVOKtFki4yIiBxMbRmw8g9aZdi5k+NdPYChlwJTf92rM8McMhDqTZ3OEZJEZcnR6U1yDr0QKMnWpORl3XjjjWqlyM3Nfn4TICIiM2T154vbtEaJ5/IKBMbdpq0E+ffuzLCuYiDUXTlCUq1lI10ye8Ozzz6r5sK9++67arwJERE5gMITwBe3AnkGkqKlJ9DM3wAjrgbc7bftDAMhJ3VuMrSYNGkSnnvuuS49nvQYkrlvjz/+OK655hr4+Ph005kSEZHV1VUAu94Etr4MVBcYnhx/wVNA0hS7f3NcdDKynYzSrwhJZZR0rG6rrq4OqampSE5Ohrd3707P7QwZP5Kfn28w12ro0KHqdvnejCWdG7tdktX379+vru/OSjt7fZ2JiOxyeOrR5cCmfxheBZLJ8YOWAAv/DgTF2+3nd1tcEequHCE70r9/f3Uxdbu5+xsilWWmEqyJiMhG6XRA1m5g/d+A1J+AlsaOx8jk+Al3AbN+a7NdoruCgZARzt5HiIiInKg30IangSNfGy6L10+OX/BXYOTVNt0luisYCBERETlrHtDON4Ad/wEqcwwf4+YJJM8EFjwJRJxfo2JbxUCIiIjI2fKAjnyj5QHlHzZykAsQPRIYfzsw5BLA23iOjb1jIEREROQ0eUA7gXV/A9I2dmyMqBeUCIy+ARhzAxAQBUfHQIiIiMgZ8oDWPwUc+R/QoM3v7MAnWOsQPeleIKwfnAUDISesGiMiIifKA9r+mpYLVJVn+Bg3L6DfXGD6Q0DsWIdLhjaHgZARrBojIiK7zgM6/LWWB1Rw1MhBLlrgM+NhoN88wM0DzoiBEBERkSPlAWXuANb9FUjbBOiM7GoEpwCT7wVGXe1QPYG6wrW3T4Dsw7///W/k5BgprzTg/fffx6FDh3r0nIiIqI3SDODru4H3LwNSNxgOgqQfkEyJv301MOE2pw+CBFeEnFh2djZWrVqFgoICREREYN68eYiLi+tw3Oeff463334b9913X6ce/7bbbsO2bdvg4mT7zUREVs8D2vaKNhusquP4pNau0IMuBOb8AQhJ5hvUBleEnNRf/vIX9OvXD19//TWKiorw7bffYsCAAer6c8kg1YcffrhTAc21116LzMxMLF++vJvPnIiIlIYaYM/7wBvztNEYhoIgF1cgcRpw07fAL95kEGQAV4ScsGrsjTfeUMHNihUrsGDBgtbrN2zYgLlz5yIqKgq33367um7dunVIT0/H0qVLW4/78MMPERMTg9jYWPz000/qNVq8eDHi438ewOfm5oarr74ar776Ki666CIrf4dERA6sqQE4+Km2CqQaIhqZnR42AJj1e60hoivXPYzh9Plumj7v6eWJsvoy9KYgryC4SvRvRmJiIiZPnoyPP/64w2033XQT1q5dq1ZzxG9/+1ts374d69evbz1GttByc3PVCpEETkePHlXH7N69W60y6X3zzTcqGCotLYWXl1eXvy9OnycikkqwJmD/R8DWF4HCY8ZfEr9wLRF60t2Ae9f/77V3nD5vZRIEzfxkJnrThqs2IMQ7xOQxErhlZGTgj3/8o8HbZYXovffew+nTp9G3b18cPHhQbZmdq7a2ViVD+/r6qq8nTpyI119/Hc8880zrMXI/Oe7kyZMYNmzYeX9/REROSXYm9r0PbHkBKD5l/DgPH2DkNcCcxwBf058F9DNujTmZkpIS9adsbRki212iuLhYBUJlZWUYMmRIh+NkK0wfBInRo0erIKstWUlr+5xERNQJLS3ArreALf8GytKNHyeDUfvOBhY8BYT15UvcSQyEnExwcLD6U7a2DNGXyOuPCwoKUsuL5/L392/3tbu7OxobG9tdp7+f/rGIiMgCLc3aRHgJgCqyjR8nlWAps4DZv9cGpFKXMBByMikpKWrVZ/Xq1bjllls63L5mzRpER0e35vrIatCuXbu69FyyJSa5Qf379z/v8yYicopu0Ntf1bbAjJXBCw8/LQCSkRhxY615hg6JgVA3JipLjk5vn4Mlfv/736ueQHfeeSdmzvw5r2nr1q0qP+hf//pXa6n8BRdcgFdeeUUlLHt7e3fqfKSiTB6/s/cjInIqjbVaBdjWF4AaE6kEXoFA8kxgyr1A3ARWgnUTBkLdRKq1zCUq24ply5apZooLFy7EpZdeqpKaJTn6yy+/xG9+8xt1e9sKMVlBktukN5ClWlpaVFXa888/30PfBRGRnauv1CrAJAiqKzd+nE8IkDwDmHAHED/RaWeC9RQGQk7YR0j89a9/Vb2CpJeQdJaeMmUK/vznP6uts7ZkZeiJJ57AP/7xD1xzzTXq6+uvv75DsrUEVW1ziT777DOEhYWpQIuIiNqQVR/J/9nxOtBQbfyl8Y8AkqYDI68FkqYBHlxd7wnsI9RNfYQcfftHyuKvu+661qoyc2Qkh1SSjRo16ryf25leZyJyYJV5wObngV1vA011xo8LjAUSpwJDlwLJ0wCvAGuepcNgHyHqVrJl1hmGErGJiJxSaTqw6Z/A3g+AlvbVte0EJ2kBUL95WjI0ewFZBbfGiIiIekJFDrDub8C+DwFdi/HjQvsDCVOAxMlaABQYzffDihgIERERdafaUmDj/2ml8M0NRg5yASKGAAmTgKjhWgDEqfC9goEQERFRd5bBb/wH0FBl+BgXNy3wkeqv0L5aNVj4IKlM4XvQSxgIERERne8w1L3vA2v/AtQUGT7G1R2IHqUFQLL1JVVgUSPZC8gGMBDqBjqdrjsehvj6EpE9kf/7D38NrHoMKM80cpCLFgBJErR/GBA/CYgbx15ANoSB0Hnw8PBQfXUKCwsRHh7e2o2ZujfIlNdXXlt5vYmIbMLp9cCK3wGFR40fI1teSTO0fkAS/Eg+kEyIJ5vCQOg8uLm5IS4uDllZWUhLS+u+d4XakSBIXmd5vYmIelX2HuD7/wdkm5jBGJQIJJ+t/pLLoIsAv1BrniV1AgOh8+wsLVPYZajouZPXqfvIShCDICLqVYXHgR9+C5xZZ/wYWflJnq31A3Jz1/KAZCvM1dWaZ0qdxM7S3dSZkoiIHFBZBvDj74Fj3wM6I78Yewedrf4arFV/+Ydrq0ABkdY+W2qDnaWJiIi6qrIAWP04cOhLoLne8DEevloStCRDu7oBLq5AwkRtPph8TXaBW2NERERtB6JKN+j9HxnvBeTmCcRNAOInaH8XvqHA4AuBwPYDqcn2MRAiIiKqLQM2PQ/seUfrDG2IrPjEjNbGYXj6nb3ORasIk+RoyQsiu8N3jYiInFdjndYNesdrQGWu8eMihmpbXj5BP18nfx+0BAhKsMqpUs9gIERERM6npRnY/wmw8Tmg5LTx40JSgOSZgP85ic+yMtR3DuB+dmuM7BYDISIici4n1wBr/wzk7jN+TEC0NghVegK15RUADFykzQkjh8BAiIiInEPeIeDHR4G0nwBdi+FjfEK0FaCwAR0HoUYNA/rNBzy8rXK6ZB0MhIiIyLGVZwMrHwWOfQc0Nxg+xtP/7CDUEVpSdLvbfIEBi4DwAVY5XbIuBkJEROSY6iq1LbB9HwIN1YaPcfPSZoDFGhmEGj4QGLBQC4bIITEQIiIix9LcCGz+F7D1JaC2xPAxLm5A7FggYbLhQaiy/dV/ARA5tMdPl3oXAyEiInIcez8A1j8FlGcZPyZymFYK793H8O2SCC0J0ZIYTQ6PgRAREdm/U2u0PKCCo8aPCel7thQ+wvDtUgrfdy4QM6rHTpNsDwOh85w+T0REvSj3gDYVPmOL8WMCYs6WwptofBicCAxc3L5hIjkFTp83g9PniYhsUFkWsOK3wPHvTZfCp8wEQg2Uwuv5hWnbZJIUbewYskucPk9ERI6nrgJY9Tiw77/Gp8KbKoXXk5UfOUbyhRgAOTVujRERkX1Ugv30rFYJZnQqvJlSeCEJ0IlTgOiRgKtbj54y2QcGQkREZNu9gHa+rg1GrS40UQo/RpsKb6gUXkgfICmVjxnDKfHUDgMhIiKyvYnweQeA3e8Cx78Daku7Xgrv7gXETwTixnNAKhnEQIiIiHpfUz1QdALI3gMc/grI3AE0GukGbUkpvGyNSfAjQRBng5EJDISIiKh3NDUAxSe13j9SBp+xDcjda3wemCWl8K7uQOxobRvM06/HTp0cBwMhIiKybtJz8Skt+Ck5DVQWAJnbgfxDgM5E3zb/KC24MTQVXkjis1SJSSK0d2CPfgvkWBgIERFRz2pu0oIeCX4kCJJgqCIHyNymbYeZEpSkVYIFJRoOgOQ6mQcmpfA+wT32LZDjYiBERETdr6UZKDkDFBzRgh/ZBtPpgNJUbQusPMPEnV20Bofxk4CAKCOHuGirQ8kztKaIRF3EQIiIiLov+ClN04KfopNaArSQzs+Fx7QAqLrA+P2lDD5quJbgbGp1R4aiSgBkLEgi6gQGQkREdH7qq4CMrVqej5S+68kWmJTBZ+0A6sqN318aIUp/n7ixWldoYyRBWgKgoHi+Y9RtGAgREVHXNNZqqzzZu7Q8oLbX5+zRrpe/GyNBj5S4R4/S+v0YIknQof20honBSXynqNsxECIios6RlZ6snVoQpN/+0s8Bk+tz9wEtjcbvL8NQZftLkpyl3N0Q31BtDEbUMJbBU49iIERERJbnAOXsA9I3Aw1tmh1WF2kVYJIbZGwSvAiI1hKgw/obHobq5g6ED9YCIG5/kZUwECIiItOk2kvyf9I2AbVlP18vs7/StwCFR03fPzhZK4Hvk2C4BF6SniX4kRUiY1tkRD3EKQKh6upqbNiwAf7+/pg+fTpcDP0gEhFRR4UngNQN2qqPXlUBkCEB0DETr5gLEDFY2wLzj+x4s4y9iBiqBUABBm4nshKHD4SqqqowceJEREdHo7CwECNHjsR7773X26dFRGTbpAz+zAat8aFeVb62LWaqCaLk/EiH57gJgE9Q+9vkl1Cp/JLgJ2wgp8CTTXD4QOjDDz/E0KFD8emnn6KhoQGDBg3C0aNHMXjw4N4+NSIi2yOBjwRAEgjpVeZpAZDMBTPGzROIHQvEjuuY3Ozlr/UHkgDJN6Tnzp3IEQOh3NxcvPnmmzh27BgeffRRgwHM7t278d///heVlZWYOnUqbrjhBri6aol4hw4dwuzZs9XfPT09MW3aNBw8eJCBEBFRW7L1JVtgshWmV5l7NgA6ZboHUNw4IHZ8+ynvkgwtjQ9l9UcmxZ/9P5nI1tj0v8znn39ebWtlZ2erlZ38/PwOxyxfvhyTJk1CY2MjBg4ciMceewzXXHNN6+2yCuTh4dH6tfxdriMiImjJz0eXAzvf/DkIklWhg58Be941HgRJUnPiNGDS3UDS9J+DIOkInTITmLwMGP4LrUKMQRDZMJteEbrwwgtxzz33qADo1VdfNXjM/fffj2XLluFf//qX+nrGjBmYMGEC7r33XpUYnZSUhMOHD7ceLytEt956q9W+ByIimyTl71LxlbNXK4sXFdlA2mag9Izx+7l7a00QZRtM/q4nzQ4TJxsfjkpko2w6EOrXr5/J248cOYIzZ87gyiuvbL1u/PjxSElJUStFEghdd911GDNmDEJDQ9XKUm1tLaZMmWL0Mevr69VFr6Kiopu+GyIiGyAjMDK3a40PpTGiKM8C0je1zws6l7sPED9BG4Vxbom7BEDJMxkAkV2y6UDIHAmCRGJiYrvr5Wv9bQkJCVi7di3ef/99REVFYc2aNSbL55966ik88cQTPXzmRERWJkFP9m5tJph+HlhZhpYDVJZu/H4ePkDcRCBmdMcASBogDrpQK5MnslN2HQjJ6o6Q/kBtBQQEtN4mRowYgWeffdaix3zkkUfw4IMPtlsRio/ngD8islMtLdrICwl4ZDiqkMBHtsDKM4zfz8NX6wEkAZBUhJ3Luw8w7HL2ACK7Z9eBUJ8+fdSfpaWlCAr6uV9FSUmJWgnqCi8vL3UhIrL7btAFR4G0jUBNifa1BEASEJVnGr+flL5LABQtAdDPhSbtBCcCQy4FPH177PSJrMWuA6Fhw4a1JkAnJyervzc3N6s+QUuWLOnlsyMi6iXFp7VS+Mr8n8vgT60BKrJMT4JXAdAo4wGQkFL5vnNZCUYOw64DoZiYGMyaNQsvvPACFi9eDDc3N9U1ury8HFdcccV5PfZLL72kLhJYERHZhfJs4Mx6LfdHyCpQ1g4tKDI2DNUzQJsDJv1+jE2CF3LbgAXacUQOxEWnk58U27Rx40a89tprqKmpwVdffYV58+YhMjISS5cuVRdx6tQpdb2vry9iY2OxefNm/OMf/8Ddd9/dLecgOUKyBSfBVWBgYLc8JhFRtzdDlACoqE3n54Yq4Nh3QGmq4ft4BQDxk4HoEaYDIHWsPzB0KdAntnvPm6gHWfr5bdOBkFR+bdmypcP1kvwsF726ujr89NNPqrO09BDqzuRmBkJEZLPqyoHUjdpk+Lb/lZecAY4tBxprOt7HKxBImKyNvDAXAInAGGDYUi1wIrIjDhEI2QIGQkRkm80Qt55thtj08/XSGFG2wWQ7zJCEKUDiVMDVzbLnkdWi/hdwOCo59Oe3XecI9STmCBGRzWmqBzJ3aIFO0zmjgqQy7Og3QFWe4UToQRdp1V6WkDlh/eYBcWO757yJbBhXhMzgihAR9brmJm31J2ML0GBgu0u2xk6uBJoNzFEM7QcMXKz1BbKENFAcepnlQRORjeKKEBGRvZPMhbyDQNomLR/I0ArRqZVA/s/zFFu5uAF9ZwMxYy0ffeEfoTVJ9Pm5LxuRo+PWGBGRLZJJ8JLvIxVhhkhvINkKqy3teJtvKDD4YsA/0vLnkzEZg5aY7iFE5IAYCBnBHCEi6hWl6VopfEWO4dvN9QaKGqHl9xgai2GIrBbJwFQZnErkhJgjZAZzhIjIKmTlR7o/S+m7qWox1RvIwDFuXsCAhZ0bgCpDVIdcAoT27do5EzlrjpBU3B8/fhxZWVq7dunbM3DgwK6fLRGRs5I8H8kBksnwUv5uTEnq2d5A1R1vC4jRtsI6k9vjF6blA/mGdO28iRxEpwKhkydPqnEWH3/8MQoLC9vdFhERgWuuuQb33nsv+vXr193nSUTkePIOAWfW/TwV3hDVG+gnIGu74dulOWLiNMt7A4mw/sDgi7QVISIn52rpgQ888ADGjBmDvLw8PPfcczhy5AiKi4vVRf7+zDPPIDs7G6NHj8aDDz7Ys2dNRGTPZBjq3g+Ao9+aDoIkEXrfB4aDIOkNNOJqLb/H0iBI8oESp2grQQyCiDq3ItTS0oLTp0+rlZ9zhYSEYPDgwbjppptQUFCAv/71r5Y+LBGR82is01Z3pCeQsSGoelISf/JHw72BQvpqFV6W9gbS9wdSOUSDOn/eRA6MydIWVI2dOHGCQ1eJqOuk0it3v1bpZaghYofeQKu0Jokd/sd2A1JmA7Gd7A0kx0cOZWk8OZWKnpw11tjYiJ07d2LKlCnq6z179uD1119H37591baYm1sn9qptHKvGiOj8/hPJ1VZ25E9zKvOAo/8z3BvIJ0Sr8LKkN5CMyAgfoAVAQQldO28iO9ejVWN///vf1VaZBELV1dVYtGgRhgwZgh9++AFlZWXcGiMikpUfWQGSlSBzv2+q3kA7gdT159cbyNMXiB4FxIwGvI3/x09E5xkIvf3229iwYYP6+6pVq1T5/Lp163Dw4EFcdNFFDISIyHlJUJOzR8sFkpwgc2qKgRM/AOVaO5KOvYEuACKGmH6MgCggbhwQPpiT4snuHM4pR2yQD4J8LWwCaguBUH5+vkqQFhIALVmyRP1dyuYlWZqIyClJMCPDT6UqzBwpi8/cDqRvBnTNne8NJJVi4QO17a8+ced/7kRWtiutBC+tO4V1xwtx/9z+eGD+ANhNICTbYJJIfOGFF6qeQl999ZW6/ujRo+o2IiKnIiXw0g9IKr0sSbuU8RmyClTdvh9bq/jJQJKR3kCeftrWV8wowCvg/M+dyIokLXnjySK8uO4UdqSWtF7/zpY03DEjBf5e1p/81eUcoaVLl+K3v/0trrrqqtak6X//+9/41a9+BUfAWWNEZFZLC5C9C0jbCDQZKHM/l5TCy5aZ3McQ7z7AgEVAcFLH2wJjzm5/Depc80QiG9DSosPKI3l4ad1pHMwu73B7eW0jPtyWjrtm9rWf8nmpHCstLW3XV0hyhIYOHQpXV4v7NNo8Vo0RkdHhqLINZmw6/LmKT2vVY/UVBm50AeLGA0nT25e4S8Ajs8Nk+0sCISI709jcgm/35+Dl9adxqsB489AQP088MK8/bphs4JcAW6kaO3XqVLvRGR4eHh2aKw4fPtzgsUREDqOuAji9Big4Znn12OnVQMER431+BizWEp71ZMtLv/0lW2FEdqausRmf7c7CaxtOI6u01uhx0X28ceeMFFw9PgE+nr2z0mlxIDR9+nSVE/TLX/4SY8eONXjMtm3b8J///AffffedGsVBROQwakq0HCBJcG5uNH+8LLYXHNYmyjcZ+CBwdddmhMlKkH6rS5KeZfsrbCDgQCvr5Dyq6pvw3+3p+M/GVBRW1hs9LinUF3fP6ovLRsfB0713/61bHAgdPnwYTzzxBGbOnKmWmCQYioyMVIlPEvRIg8WamhrcdtttavYYEZFdk0BGkpqLTgBFJ7Uyd0vVlgEnVwClaYZvlyaHkgvkE/zzqlDKLCDU+vkRRN2hrKYBb29OU0nPku9jzKCoACyb3Q9LhkfDzdXC7ui2liMkDRO/+eYbbN68GZmZmXBxcUFcXBymTZuGiy++WO3HORLmCBE5ESlpl+BFAp/ik6YHohoizRCzziZPtxj4MJBBpylztAaJMiJDmh4mzwAih1k+MoPIhhRU1OGNTan4YFs6ahoMtIE4a3RCEO6d3Q9zBkWouMHuR2w4EwZCRA5OZntJIrOs/JSctqz6y5CqfK0kXsZkGCLVXtIdWqbGS0AkU+Bjx7EBItmlzJIavLrhtMoDamgyPkB4Wr8wLJvdF5NTQq0WAFllxAYRkV2rr/x5y6ssQ1sJ6irJF0rfAmRukyWhjrd7BgD95wNhA7RcoNgxQOJUbRo8kZ05mV+JV9afxv/256C5xfg6yoIhkWoLbFS8kYagNoSBkBHsI0TkYKTMXQU/J7RVm+5YDC9LB06sMDwkVcSMAZJnAh7eWhm8bIPp84KI7MiBrDLVBfrHw8a7pkvKz8UjY3D3rH4YGGU/zT65NWYGt8aI7DnZObtNsvPPXWzPm8wQk07SefsN3+4bCgxYCPSJB4ITgZTZQGB09z0/kRXodDpsO1OCl9efUt2gjfF0c8UvxsXhrhkpSAy1nXYP3BojIufT3HQ22fkEUHwKaKju/uCq6DhwapXhx3ZxBRImaxcJfCQAYiUY2Znq+iZ8tTcb729Nx/H8SqPH+Xi44bqJCbh9egqi+njDXnFrjIjsm6zOSNCjkp3PWNbjp6t5RdJJWqrJDJEhqQMXASEpQPL0nyvDiOzEmcIqvL8tHZ/vykJlfZPR4wK93XHzlCTcPDVZdYS2d+5dXS5788031eXMmTNqGr34wx/+gGXLliEmhq3giagH1ZVr210S/JRlamXrPUWqwbJ3nx2oaiCp2s1TywNKmKglQUuDxLZjMohsWHOLDmuPFeC9rWkmt79EmL8Xbp+erFaBArwd5994lwKhF198EU8//TQefPBBPPTQQ63XJyUl4S9/+Qtefvnl7jxHIiKgMl9bjVHJzsYTNruFBFYSaMlw1PJM48eF9NVWgaQZogRBnr58p8gulFY34JNdmWr7K7vM+AgMkRzmh1umJuHKcfHw9nC8gb9dSpYeOHAg3nnnHUyePFn1BdA/hDRYHDduXOsKkSNgsjRRL052lyBE39xQujX3tMZaIO+AtgJkcDjqWR6+QL/5wNBLgb6zWQlGdlX99d7WdHyzP8dk/x8XF2DuoAjcODlJ9QJytZEu0DaTLJ2WloZRo0apv7dtkBQQEKA6TxMRdYnk90iej0p2Pq0FJtZQXXh2++sQ0GI8N0IlQ0cOB0ZfBwy+iBPhyS7UNzXjuwO5KgDal2n6MzrI1wNXjY/H9RMTER/iHCucXQqEEhISsG/fvtYVIb2vv/5arRYREVlMqq9UsvNJoDRVq/yyBtn+kmBLAqAyIzPB9Dz8tGnw/eYAgy8BwvpZ5xyJzoNseX24LR2f7MxEcbXpjunDYgPV6o/0AXLE7a9uD4R+9atf4aabbsIzzzyjvt6+fTtWrFihvv73v//d3edIRI5Gevrok52l1481J/001QF5B7UAqM7MCnZAlDYGI2aUVgovDRI5FZ5smKSqbDldrJKfVx3Jh4nmz/Bwc1HDT2+ckoTR8UFWH4Fh14HQfffdh7q6Otx6661oaWnBpEmT1D6cTKeX6fOOgJ2liXqAjLM48aPW5dnaZHq8BD8SBBkaiNp2+ytsoBYA9YnVVoKkIzQTocmGVdY1qt4/sv11qsD0sODoPt6q8uuq8QkID/CCszuvztLNzc2qfF6CoZSUFHh4OE45nR6TpYm6SdEp4MhX1tv6EvLfm2y3yUT40jOmj5XZX9GjtcDHKwAIitcSogMirXW2RJ12qqBSBT9f7M5CtYnp70IGn940JRHzBkfC3c3V4V/tCmsMXXVzc0P//v3P5yGIyBnIKsyx73u238+5E+Ul8VlWgGrNjNbwiwDixgERQwBXd8A7UNsGixxinXMl6qSWFh3WnyjA25vN9/7x83TD0jFxuGFyIgZE2s/8L2vqciC0a9cubN68GaWlHYcN/ulPfzrf8yIiR5G5Azi91jp5QDL8VL/91Vxv4kAXbRq82v6K02qFJQiSpogyHoMNEclGt78+25Wl8n/SimtMHpsS7oebJidh6ZhYh2p+aDOBkCRF/+53v8OQIUMQFBTU4XYGQkSknFkPpG/t+RejPAvI3G58/IWeuzcQPUrb/vLu8/P14QOBvnMAn47/nxH1ttSiary7JQ2f7co0uf0lrX5k2+umKUmY0jfUaZOfrRII/d///R+WL1+OxYsXd+XuROToZPXnxAogZ1/PPocEPhIASeWZKX7hQOxYIGJo+9UevzCg/3wgOKnnzpOoCyR9V7a93t6cinXHC00eG+zrgasnJOD6SYmIDfLh622NQKi6uhozZszoyl2JyNG1NANH/gcUHu+hx28C8g4BWTvM5/+E9tcCoKDE9gNQPbyBpBnayhDL4cnGJr9/uScL72xJw+nCapPHDooKUKMvLhkV63S9f3o9EFq4cKFqnnj99dd368kQkZ1ragAOfQGUmmlQ2BXSZTpnj5YD1GgiP8LNC4geAcSM7bjVJaXx0hMoaTrL4cmmZBTXqNwfmf9VWddkcvtr/pBI3DI1GROTQ7j91VuB0L/+9S+MHDkSn3/+Ofr27dvhjXjuuee649yIyJ401AAHPwUqcrv3caXpYdZOIPeA6f4/XoFa9VfUSMDdQG+UoASg3zyWw5NNbX9tPV2Mt7ekYfWRfJgqJwj0dsc1Z7e/nGX0hU0HQk8++aSqFsvLy1ONFYnIydWVA/s/0ZoWdpfKPC3/p/CYfGSYzv+JnwSEDwJcDWwPSDm8JEJHDO6+cyM6D7UNzfh6Xzbe2pSKk2aaH/aP8MfNU5Nw2ehY+HqeV8cbMqJLr+qHH36IlStXYs6cOV25OxE5kupi4MDHQJ2Jae2dbYAoAVBZuuljg5KA+IlaorOh6hg3d+12lsOTDc3+en9rGv67PQMVJra/5J/znIERavtraj9Wf9lkIOTt7Y0JEyZ0/9kQkX2pyAEOfHr+U+IlwbrgiJYALZPgjXLRVnbiJmhzwIxhOTzZ0PbXzrRSvLHxDFYdzTfZTsvfyx1XjItT/X+SwvyseZpOrUuBkFSMffzxx7j99tu7/4yIyD6UpGqJ0c0m8nYs6QCdu08bgdFQafw4Vw8geiQQN759/59zf40OjAWSp7McnnpdVX2Tmv0l/X/Mzf5KDvPDzVOScPnYOBUMkXW5d3W0xp133onPPvsM/fr165As/eKLL3bX+RGRLSo4Bhz9RlvJ6Yr6SiB7l9ZnyFQHaA8/rfxdpr5LybshgTHaKpGsAhkLkois5FheBT7YJrO/slHbaPrnY+aAcJX/M7N/OFylHIzsJxCqr6/HxRdfrP6enW2mkZmd4vR5IiOy9wAnV3ZtZIZse8nIjYLDpueO+YRo+T2RQ7XRF+cKjAbCzwY/7AZNvay+qRk/HMzD+9vSsTu949iptnw93fCLsXG4cXIS+kX4W+0cqYemzzsDTp8naiNtM5D6U9cCoLRNQJGZJouBcVoAFNqvYwK05ASplZ9BDH7IZnr/fLgjHZ/uzERpjekt4oQQX9w4ORFXjItHHx/O/nKY6fNE5CTk96XTa4DMnZ27X3URkL4ZKDxq+jgZgCoBkOT4tBUQqa38REjwE9z58ybqZs0tOqw7VoAPtqdjw/FCk71/ZLdrzqBIXD8pATO4/WWzLA6Ebr75ZvXnO++80/p3Y+QYInIQLS3A8e+0sRaWqinRAiDZAjPGxQ2IGq5VgPmG/Hy9f8TPKz9tryfqRYWV9fhkZwY+2pGpyuBNCQ/wwtXj49X8L87+cqBAqKmpyeDficiBSUXY4a+B4lOWHV9bpgVA+RI0GfldWbo+y/gLSYL2PFsi7B9+duVnMIMfshmSObI9tUQlP/94OA+NzaYzSSalhOCGSUlYMDQSHm6uVjtPsmKOUFlZGYKCzpnd4+CYI0ROq7EOOPgZUJ5lWWfpjC1A3kHjSdAyA0zK32UMhru3NvldrfwMBvxCu/30ibqqoq4RX+7OwofbM8x2fg7wdsflY+LU9le/iAC+6I6eIxQcHKwiZCJycPVVwIFPgKoCM8dVABlbgdz9JgIgTyB2nLYF5h8GRI/SAiAJhIhsyKHscny4PR1f780xW/o+PLaPCn4uGhnD0Rd2jsnSRNRebSmw/2Ntm8tUoJS5VesDpGs23gRRtr/iJQcoVBt1ETsGcGPFDNmOxuYWfLMvR5W+78s08W9e5vq6u6rA54ZJiRgZ71y7I46MgRARaQ0OS9O0i+QDybaYIQ3VQOY2IGcv0GIkV1D6/kgDRKkC8w3WVoIkGDI0EZ6oF6u/vt6bjX+tOYmMkhqTx6aE+eHaiQmq/0+Qr6fVzpFsNBB6/vnnzR7z61//uqvnQ0TWIKMtyjJ+Dn6kzN2UxhqtEWL2bqCl0XgVWMxobRK8b5AWDMkqkKdvj3wLRF3R0qLDdwdz8fzqEzhdWG30ODdXFywYIqXviZjSl4NPHVmnkqVllIafn/lBcFVVppPL7AmTpckhyCiMiuyfA5+KXNOdnfVkmGrWTm0cRnOD4WNcXLW8Hwl6pMtz1AggaSrgxcRRsh3yUbfqSD7+b9UJHMszPtcuKtAb10xIwNUT4hEZaGSsCzl3Q0VHCnKIHFpV4c+BT1l654ajNtVpg1AlCDI2C0wCIAl69AFQxBBt4CkbH5KNBUAbThTi2R+P43BOhdHjRsUH4Zcz+2Le4Ai4s/TdqTBHiMhR1FW0D3wkobkrW2ay/ZW1Xfu7QS5A1DAgYaoWAIUPAJJmaL2AiGzIppNFeOqHoyYDoKExgXhowQDMHhjRYYA4OQcGQkSOkOdTkgrUFHd920weQ8ZgFJ00MQ3eRVv1SZyqNT0MSQaSZ2jT34lsyJqj+fjHyhM4kms8ABoQ6Y8H5w/ABUOjGAA5uU4FQvfcc0/PnQkRWSZrtza6wtI8H0PkfhJEFUjwc1zbCjNFmh5KACS9f/rEAskzgeBEvmNkM+oam/H9wVy8uuE0TuQbXw1NDvPDr+f1x4UjYlRCNFGnAqEXX3yRrxhRb5Ecn2PLgYJjXbu/1EWUZ2orP4XHtUowc8IGAknTAL9wbQaYBEBh/br2/EQ9kP+TVVqLlYfz8NHODJwqMF4FFhfsg/vn9sdlo2OZA0TtcGuMyB7ICItDXwCV+Z0PfipyzgY/x4AGC/OGQvtrAZB/pLYNljRd6wbNHAqykREYR3Iq8NOJQqw+ko8TJsZgSBXYvXP64cpx8fB05/wvcsJAqLq6Gpdccon6+4wZM/D444/39ikRdU5ZJnD4S6DBghUcffBTladte0nwI2MwLBEQ8/PUdyl99w7UtsOkMsyVHyDUu5qaW1Tfn8M55TiYVY5tZ4pVGbyx/i9h/p5YNqufaoTo7eFm5bMle+LwgZCXlxd+97vfYfv27di7d29vnw5R50gH55OrtIRmc8FPdYG2bSarP3WmRwW0khUfNfV9EOB9dmSANEBMmKI1R3Rz+P8iyMY1NLXgQFYZdqeXIr+iDjtSS1QSdIuRCCjI10OVwd84OZEzwMgiXf5frrm5Gfv27cOZM2dwxRVXtK6+WNJw0Zrc3d0xb9481NXVMRAi+9HSApxaBWTvMX2cdITWb3tZWjUm+T7hZ1d+ZNtLyApQaF8gtB8QnMR5YGQTM8AkANqVVorCynrsTCvBoewKNBvpARzg5Y7bp6fg1mlJCPDmPDvq4UAoOzsbF198MQ4cOICmpqbWifRXX301li1bhkWLFln0ONLt8f3338err76KY8eOYc2aNZg5c2a7Y+TxH3vsMbz33nuorKzE1KlT8cILL6BfPy1h89ChQ0ZHeqxcuRKuXNIneyNbYEe+BkrTjQ9FVdteR4HqQsse0yfk7LbX2anvkusTEK0FPnIJiOzWb4HofLbA9meVY1daMY7mVuJQTgXOFFYZXQHy9XTDLVOTcMf0FM4BI+sFQg888ACGDx+OjRs3tlsB+u1vf4tHHnnE4kDo2WefRWlpKZ577jl1H0PTPh599FG8++67+PLLL5GYmIj7778f8+fPx5EjR+Dj44P4+Hi19WUIm2OR3akq0JKiDU1+l6Dn1BqgLM2yx5KtLv22l18E4OEFBCefDX76Ap62tXpLzk0CoIPZ5Vh3rAA700txOLscFXVNJifBy/aXbIOF+nOgrz2qb67HT1k/4bsz32Fo6FDcMeIO+wmE1q1bh8OHD8PXt/0wxZEjR2Lnzp0WP85f/vIX9WdWVpbB22tra1XJ/tNPP40pU6ao61577TVERUXhs88+w4033qjmiMjWF5Hdk5L2o992HIUhM77StwBZO8z3DfIK1La8ZPXHP0rb+tIHPkEJgCuTRsn2psDvyyzDZ7sy1fbXmaJqlfJmjIebC66dkIBls/txFpgdam5pxo68Hfg+9XusTl+Nqkat4u9E6QncPvz2XlnA6FIgJAGKh4e2B9v2pPPz8zsER+dDcpBqamowe/bs1utCQ0NVwLVlyxYVCFni8ssvx+nTp5Gbm6uCpr///e8YN26cwWPr6+vVpe3QNqIeJf/rp20C0jdrf297ffFJ4NRq05Vfnv5A+EAgfAjQJw4Iiv95y8svlG8e2WwAtOFEAd7Zkoa9GWWoNLH6o18BWjomFvfM7oe44O77nKGeJ7s9R4qPYPmZ5ViRtgJFtUUdjsmszMShokMYHj4cdhEITZs2DW+++SYefvjh1kBIkpFli6pt0HK+JHARERER7a4PDw9HXl6exY8j22kNDT9Pzk5OTjZ67FNPPYUnnniiS+dL1GlNDVqTRFkNaku2xiRZuuS04ft5+J4NfgYDYf1/DnxCUgAPTswm29XQ2Iz3t6fj4x2ZOFVQZbT8XW9QVICaBn/pqFj08WUStD1Jr0jH92e+V6s/aRXmt/TlOLsJhCSnR5KaV6xYoSK9G264AevXr1crRZs3b0ZPkwRoQ/lExkj/IEtJjtODDz7YbkVI8pCIup0EO5IPJHlBei1NQOZ2IGOr9ndDE9/jJwGDL9TmfknwExjLPj9k8zKLa/DS+lP47kAuKutNr/54e7ji4pExKgCSqfDM97QfRbVFWJG6QuX9HCo+ZPZ4F7hgQtQELE5ZjHmJvZPm0qVAaNiwYapi7OWXX4abm5tanbn22mtx3333IS4urttOLjJSq2QpLCxUq0B6BQUFGD16NHqq75BciHqUVIQd/gporG1zXRpwciVQW2L4PkGJwNhbgNHXc9I72U0JvHR+fmNTquoDZM6Q6EDVAPGSUTEsgbcjVQ1VWJ2xWq3+bM/bjhYLZiAODhmMJSlLsDBpISL9Iu2zj1BsbCz++te/oidJsCOVYRs2bMCQIUPUdVJltn///h4fAPvSSy+pi/RLIupW2bu16i99k8T6SuD0Wq0c3hCp7hp0ITD1ASByMN8MsnkZxTX4eGcGPtqRgdKac5L/DZS/XzIqViVAD4/rY7VzpPPT0NyAjdkbVfCzIWuDqgAzJ84/TgU/i5MXIyUoxWbeAosDoaoqC2cUSbNaf390B0m8/uUvf6kCrkmTJiEhIUGtOslKkb6JY0+RQEsusjUmlWlE500CH+kSLd2ihfzWJEFR2katMqwDFyBuHDDtQaD/fDY5JJvvAL3qSD7+uyMdm0+Zb+45PLYPrpuYgItGxsDPix3M7UGLrgW783erba+V6StR2VBp9j4h3iFq1UcCoOFhw21ym9Pif30BAQEWP6il+TvSJPHWW29t/Xru3LnqRZJ5YPqZYFI639LSom6TYEzK6KVRoq11sCYyqaFa2wqTuWGiIhs4+WP7/KBz536Nvw0Yd+vP3Z+JbJA0O/xkZyY+352F4mpDAX371Z+lo2NxzcQEDI3hL5j2QKfT4VjJMZXILJeCGiP/Z7Xh6+6LuQlzVfAzMXoi3F1tO9B10VkYtWzbts3iB5XVG0vIUxvaepJkaFvpCK1fEZIu2IGBgb19OmSPZGK8JEXLBHnJCUpdD+TuN3ysuzcwcBEw6xGtKozIBtU1NmPFoTx8sC0duyzI/RkR1wc3TErEkhHRnP9lJzIrM/FD6g9q9edM+Rmzx7u7uGNa7DQV/MyMnwkfdx/Yy+e3e3cHN50hqz8yC8wWMUeIuoUMQZXyeCmTzzsAnFkPNLVJkG4reiQw4zfAgIUcdko2aV9GKd7ekqa2wGoaTOdP+nu5YemYOFw/KREDIi3fUaDeU1xbjB/TflQrP/sLjfyydo4xEWNU8LMgcQGC9IOb7YzFK0Lnkr5B0t356FEtwVOSmSVvx9EqrrgiRF1vkrhR6wgtK0KyDSbbYcaGoI67DZh0N+Bjn/+RkGOqaWjCyYIqfL03W1V/ZZYaCeLPWf25ZUoSFg2PhrcHO5nbuprGGqzJWIPvUr/DtpxtaNaZLxAaEDxAJTzLJdo/Gvb++d2lQEg6Pl944YUqZ2fwYK2KRWZ/yRMuX74cI0aMgKNgIEQWkR8jGY3R0qglPktVWN4hIH0TkLVLDuh4H1cPYMACYM7j2jwwIhvY8soqrUFmSS12pBZj06liHM+rREOz6XLoAG93XDYqFjdOSUK/iO4plqGe09jciC05W9S217rMdahrrjN7nxi/GNXrR4Kf/sH97eLt6dFAaOLEiSoAku0jfdJydXW1qrKSKfKdySeydQyEHJD8k5cBphKwqOClSftTvtb/XR/QNDed/fvZi/7v6jj9/eXS/PN4DPmz6Lg2GqPBSLWldISe/YhWFs/5X9SLgU92WS0yS2qQVVqL7LIaHM+twqGcchRUmi+HnpgcghsmJ2L+kEh4uXP1x9YrvvYW7FXl7lLxVVZvYLDzOYK8gnBB0gUq+BkVMQqu0tDVjvRoICS9fTIyMto1OdQ3OpQJ8dJh2lEwEHIwFTnAiR+BSstHtHSKVIGdWQeUphq+XfbQx98KTP014M2qGbKu+qZm5JTVtQY+BZV1aGnRIb+iXk1+P5FfiaYW0x8JYf6euHJcPK4aH4/EUFbv2joZZqofc5FbrY2tMsXH3Qez4mfhwpQLMTl6Mjzc7HesSbcnS7cls7qKioo6BEJynak5XvaEydIOpqEGSN2gVWt1LS3OOHk8mQmWtRMoSzd8jIsb0HcOsOAv3AYjq6ttaMbGk4U4mluJlrP//mU16FhepVr9Ka4yXfYunV9mDQzH1RMSMGdQBDzc7GtlwNnkVOW0lrufLD1p9ng3FzdMjpmskp7nxM+Br8wydCJdWhF655138M9//lNd9FPcd+3ahQceeEDN6brpppvgKLgiZOfkn3fuPuDMhvbjLLqDbI3lHQSydwG1JkqIQ/oCs/8ADL2E22BkdYdzyrHxZJEKhuS/e1kRkuBHkqBlArwpMX28ccW4eFw5Ph6xQb1fDk3GldWVqS0vyfvZU7DHopdqZPhIFfzI9pc0PnQ0Pbo11pnOkF0sSrMZDITsWEXu2Wot88vBnSL9gKQjtKwumWor7xkAjL0ZmPkbwJs9qMi6SqsbsOZYgdoGq29sxuGcChUAmRt54ebqgrmDItTA0xkDwtXXZJtqm2qxPnO9Cn42Z29Gk870MFuR0idFBT+LkhchPsCxB4r36NbYqlWrzufciHqWrPzICpCsBHVXIC6PI+Xvsv1VdMJwFZieLCsnTQPm/xmI4Gwwsi5Z5dmRWoJdaSUor23EvswyHMgqN1v5FR/ig6vHJ+CKsXGICPS22vlS5zS1NGFb7jYV/EjZuwRD5kT4RqiEZwmABgYPtMkxF72pS4HQvHnzuv9MiLplG2y/1rSwu7bBpBqs8BiQvdN8grVfBJA8A5h4JxA7Xlqkd885EFlIVn/WHitAWlE19mSU4lBOhcntLw83FywYGoVrxidgSt9QuHL1xybJzsqBogMq+JGGhyV1JWbvE+AZoJocSvAzNnKs3VV8WZNttnW2AUyWtjMSpEg1mFSFdYfGGiBnH5Czx3gJvF5ofyBlNjD6OiBqBAMgsjrJ//npZCE2nSzCrvQS1fvHVPpPSrifCn6WjolFqL9jNcF1JDLaQoIfqfrKqsoye7yXmxdmxs1U/X6mx06Hp5unVc7T3nUpRygvLw+PPPIINm3ahNLSjkmiUj3mKJgj5GTbYNJfSJKf8w9rvYKMkf9gooYDfecBQy4CIoYyAKJeS4b+bFeWCoJOFRoP2mU3ZPHwaNw4KRETkkO4PWKj8qvzsSJthQqAjpZokxtMkZWeiVETVfAzL2Ee/D3Z0NIqOUI33nijeoKHHnoIQUEcCUB2vg2myt/PaNtfpWmmj5XeP7FjtRWgfnOBiCHaJwyRlZVU1eM/m1Lx/YFcpJfUmNz+Wjo6DnfNTEFKOD8kbVFFQwVWp69Wwc/OvJ3QmcpBPGtY6LDWiq9w3/atbKhzuhQIyUpQamoqIiMju3J3ItvYBlPl74fOlr+b2XPvEw/EjQMSpwBJ04HwQQyAqFc0NjXjPxtT8cH2dFUKb4y3h6uq/LpjegpiWPpuc+qb6/FT1k8q+JE/G6VDvRmJgYlYkqxVfCX1SbLKeTqDLgVCEgA1Npp/04i6VWOd1hQxZ+/5bYNJ+bvk/sh2WpOJ8ndJLpSqL0l8jhkJJE4FwgYwAKJeIUnPH2xLxyvrTyOvos7k3K+bJifhlqlJzP+xMc0tzdiRt0M1OpQVoKpGM/mH0snbJwwLkxaqTs9DQodwS9NWAqGHH34Yy5Ytw8svv4y4uLjuPyuitiToyTugbYNJh+iu0LVo218S/BSfNlP+7gNEjwZixgDh/c8GQPYxZJAcT0NTCz7ZmYkX1p40Of8r1M8Tt01PxvWTEhHobb9jERyNpOEeKT6ipruvSF2BwtpCs/fx9/DHvMR5quR9QtQEuHEeoe0FQtOmTcNjjz2G+Ph4eHp6dohQ6+rMT7IlskhlvtYUsTy766s/kkskHaAbKk0f6xcOxI7T8n6CE7VeQKF9+UZRr6hpaMLHOzLx8vpTKDIxAiMmyBt3zeir5n/5eHLwqa3IqMjQKr5Sv0dahZncQ/n9y9UDM+JmqOBH/vR2Zy8nmw6EbrnlFowcORK33XabwyZLs3zeFrbBfjq7DWa6EZzB3j/Fp7QAqPSM+eNlBEbceCAoEQiKB5KmAiEpXT51ovMhTRDf35qGNzalosxEF+iUMD8sm90Pl4yK4ewvG1FUW6RWfST4OVh00OzxLnDB+KjxKul5bsJc9PHiIObe0OXp85mZmQgLC4OjY/m8lTU3acFPxpbOb4PJvC/96k9jteljXT208ndZAfINAYIStAAomAmI1DsKK+vx1uZUvLc1DdX1zUaPGxIdiPvm9FONEDn+ovdVNVSpDs+y+rM9bztaLPjFbXDIYBX8SO5PpB+LjuyyfD4pKQnV1dVOEQiRlbS0aHlA6ZuBuopO3K8JKDqp5f4Ym/zeVkA0ED0SCB8MuHtpgY8EQBIIEVmZ/B66PbUEH+3IwA+H8lQ+kDFjE4Lwq3kDMKN/GBNme1ljcyM2Zm9Uwc+GrA2qAsycOP841etHqr5SgrjibEu6FAjde++9uOOOO9T2Ub9+/fhDSV0nC5IFR4G0jUCN+bbxrWqKtdWf/IPm+wi5eQGRQ7UAyD9Sq/oKTtYCoD5M9ifrK66qx5d7slUAdKbI9OqljL54YP4AjE9yvOng9kRWenbn71bBz6r0Var3jzky0V1WfSQAGhE2gp+VNqpHps/b+8T5trg11oOkeksqwaoKLDu+uREoOq4FQOWZ5o8PjD27+jMI8PLXVn9C+2k5QfI1kRW1tOiw7Uwx/rsjAz8ezkNjs+n/J2cOCMdvFg7E0BjmjfQW+Sw7XnpcjbiQvJ/8mnyz9/F191X5PhL8TIqeBHdXTrLqLZw+T7arLEMbi1FufnZO69gL2fqSsRdNZioSpdIicpgWAEnPHwl8pPJLtr5Ygkq9lPvz+e4sfLIzA2nFpvPe3FxcMGtgOB5ZPAj9IgKsdo7UXlZlFn5I/UGt/pwul3Ybprm7uGNa7DSV9zMzfiZ83H34ktoRTp8n63aElgBI+vlY0vVZpr7L6k+FBaXz0vlZ+v6osReDtQBIkqCJemn1Z/PpIrX1tfJwPppMTUAFEBHghYtHxqg+QNF9+CHaG2Si+8q0lSr42Ve4z6L7jIkYo4IfmfIe5O2YFdTOgGt2vVk+L1VRnr5weNXFWkfoohPmO0JL5VfWTm31x1wCojQ+lOBnyKVA8gwgJFlLgCbqJQUVdfhsdxY+3pmBzBLTuWvuri6Y2i8Mt01LxnQmQPeKmsYarM1cq7a+tuRsQbPO/P/3A4IHqF4/con2j7bKeZIN5giJr776Cp999hkyMjLQ1NR+Sve2bdvgKHo0R2jnm9q2TcIUwN0TDqe2DEjbpAU15kpKZW5Y5nYtWDI3cFC2vIZeBoy6Vuv9w6Gn1MujL346WYiPtmdgzbEC9bUpccE+uHZCAq6dmIAgXwf8ubdxMtNra85WtfKzLnMdapvMD22O9otWgY+s/vQPZpd5e9GjOUIvvvgi/vSnP+Hmm2/GRx99hEcffRQ7duzAqlWrVDUZdaLxX/pWre9N8kytr40jfKjXVwEZW7V+QPI9mpz6floLgMwlP8vU90EXApPu1l4nol6WV16HT3dlqvEX2WWmP0xlAvyCIVG4dVoSxiQEs3qoFyq+9hfuV8HPj2k/oqy+zOx9pLnhBYkXqOBnVMQouMrsQXJIXVoRGjhwIF599VXMnj1b/UDrH+Lpp5/Gli1b8L///Q+OokdXhLa/rpWB6wVEAf3mad2N7bUbdOY2IGuXVuFlqvdPwREgcwdQU2TiAV20ae8T7gIGLQbcOD+JeldTcws2nChUuT9rjxXAzOIP+ob74cbJibh0dBz6+PDfr7WdKj2lZnzJ1ldOdY7Z473dvDE7Ybbq9TMlZgo8+H+OU3x+dykQ8vDwUA0VZc6Yt7c3ioqK4O/vj7KyMiQkJKgndxRWDYT0JNm372xtFcQeSNAjeT2ysiPBkDFS8ZWzD8jeBTSYmLrs4QeMuxWYeCcbHZJNOFVQhf/ty1bVX7nlpisXvd1dcdHIGLX1NSo+iKs/VpZblYsf0rSKrxOlstVumpuLGybHTFZbX1L27uvhBHmbTqKiJ7fGJCdIgiAhg1f37t2L6dOnIy8vD66uXD48b9JgsPgkED8RSJhsuyshsu0l21/pMg7DRFO4+gptlUhK4KUazBj/CGDSPcC4W+wnCCSHLnv/dn8Ovt6XjQNZ5WaPHxwdgOsmJqrZXwGc/m5V5fXlastLev1I00NLjAwf2VrxFeoT2uPnSA5cNXbDDTfg6quvxqJFi7BmzRpcfPHF3XNmzk5mbqVtBnIPACmztM7ItpI/JEGPlLZnbNemuxsjjRKzdmjbYKaSpSX5eeqvgeFXOGbSONnVxHcpd/9qbzY2nSoym/js6+mGS0bF4poJ8Rge24erP1YkSc4bMjeolZ9NOZvQJFvuZqT0SVHBz6LkRYgPsNMUBLKNQCg1NbX173/4wx8QGhqKrVu3qmn0Dz74YHeeH9VXAke/BbJ3a/lDfWJ77zwKT2gBkCQ2G9tRleulYaJsk5mb/C7VctN+DfSbD3AlkXox72fz6WJ8vTdbdXyuaTBfQj0irg+umZCgtsD8vdiFxFok2Nmeu10FPzLotKbJ/GDmCN+I1oqvgcEDGaxS95XPO4teyREyRlaEIoZoK0Te3XwuhshqT+FxLfiR8nZT/1RkxUeOlQCoKs/4cVJ5MfgiYOr9QOzYHjltInPkv71D2RVq5eeb/TkoqjI/NDPMX2t6uHRMLIbFcuvWmu/VwaKDKvhZkbZCNT40J8AzQG15SfAjTQ/d2FXeKVX0ZI5QW5WVlXjjjTdQWlqKJUuWYOLEief7kGSMBCLSk0d67SRM0nKIujt/SAafSkAjM70qcs0fLzk/MjVekqVNbZPJ6IvR1wOT7wFCOHmZekdmSY1KepYA6HSh6WGnwsfDDQuHReHS0bGY2jcU7m7MgbSWM+VnWmd8ZVaany3o6eqpxltI8DM9djo83bjNTpbpVCAkpfF//OMfVb8gfdL0jBkzcOjQIQQFBeGpp57C999/j/nz58PeWaWz9PlUaaVu1MZPpMwGIoecf+dnWfWRi6UDUCVPSLbrcvaYnv/lEwxM/CUw/g7AjwmJZH1lNQ347mCu2vramVZq9nhXF2B6/3BcNjoW84dEwo9bX1aTX52vVn1k9edoyVGzx0tvn4lRE9WA03kJ8+DvyWHK1MNbY5deeqlqmCgrP/ru0pIovWvXLgwfPlw1Vty+fTtWr14NR2FTW2PG9InT8ocCO9HuXQIeFfwcB6pN9fJpQ5IRS1K1+8mKkankRBlyOuVXwKjrnGOMCNmUusZmrDtWoFZ+1h0vMDvpXZ/3c+moWFw4MhoRAd5WOU8CKhoqsDp9tVr92ZG3AzpzneUBDAsdpoKfhUkLEe4bzpeRrNdHKCIiAsePH0dwcLD6+p577kF6ejqWL1+uvs7NzcWoUaOQn58PR2EXgZA+f0imrqfMBLyMTK2WrS4VxJzQtsAsLZEv1Qc/J83P/4oZreX/DL6Y097J6oNOd6SVqJUfWQGqrDNfRSTjLmTlRyq/+kVwNcFa6pvr8VPWTyr4kT8bWky01TgrISBBbXtJ4nNSnySrnCfZtx7JEaqvr2/tIi1k9eeyyy5r/VqesKrKRKM86jnyvsioDglYpBtz3AQtEJEkZ/3Kj6kcnnODn7J0oPCoFjQ1mU8kRf8FWgCUONV2yvzJKZwprMKXe7S8H3OjLoR0eL5wRLRKeua4C+tpbmnGzvydattLVoCqGs1/VoT5hKlVHwmAhoYOZcUX9YhOBUJDhgzBu+++iwceeABHjx5VjRRl7pjeyZMn1fgN6uX8oTMbtA7OUsklZe8WBz8ZbYIf091zFVd3YMRVwJT7tG7YRFbM+/n2QC6+3JOFvRnm50Z5urti/uBI1exw1sAI9TX1PPnF+UjJEa3iK3UFCmsLzd7Hz8NP5ftI8DMhagIrvsi2AqFHHnkES5cuxX/+8x9kZmaqCrG2VWIyjf7KK6/sifOkzrJk9UcCJX3wIz2CLJjCrOZ/xY0Dhl8JDLkECIjke0NW0djcgvXHC1Xws+ZoARqaW8zuFk9KDlVbXwuHRyGQ3Z6tJqMio3XGV1pFmtnjPVw9VKWXBD8z4mbAW6pMiWwxEJKu0evWrcM333yDkJAQLFu2rN1SpZeXF+66666eOE/qLq3Bz9mE50ZLgh9o+UcjrwGGLQUCY/h+kFX7/XyxJ0v1+ympNp9LMjAyAJeNiVU9f2KCfKxyngQU1RapMRey+iN9f8xxgQvGR41XOT/zEuepae9EvYENFR0lWdpc8CPdoPW5Qo3mu7EqIX2BoUuBcTdrlWlEVpJXXqdmfMnqz4l887kkoX6eKuFZ8n6GxgQyl8RKqhqqsDZzrQp+tuVuQ4upUTpnDQ4ZrFZ+Lki6AFF+UVY5T3JOFdZqqEg2SgU/WW2CH/PN45TAWC3xecId2nwzIivP+ZLVn82nimBmzBc83VxVnx8JfmYMCIcHmx1aRWNzIzZmb1SNDtdnrlcVYObE+cepcvclyUuQEsSGqmRbGAg54raXJDvLpcHCCr6AKK3KTDo/950LuPGfBVmv5H17aola+fn+YC6qLZjzNTYxGJePicOS4dHo49vNndXJ8Puka1FT3WXlZ1X6KtX7x5wQ7xC16iOrPyPCRnCVjmwWP/HsnTQ1LE07G/yctDDhGYB/pDa3bNASYOAibn2R1Uvepdxdyt4tKXmXfj9LR8vWVxySwvysco7OTvKzTpSeUMGPrP7k15jvD+fr7ou5CXPV6s+k6Elwl8pSIhvHf6X2SOZ7lZzRgp/iU9rXlvCPAMIHA7FjtJUfaX7oxSZyZB3lNY349kCO2vqypOTdz9MNS0ZEq9Wf8UkhcJXZF9Tjsiqz8EPqDyoAOl1+2uzx7i7umBY7TQU/s+JnwcedCepkXxgI2Qvp6yNBjwQ/EgSZGm/Rll+4FvyEDwKihwOx44Dwgez6TFbR3KLDxpOF+Hx3FlYeyUdDk+lkWol1pvYLwy/GxmHBkCj4eLrxnbICmei+Mm2lCn72Fe6z6D4y1V22vWTKe5B3UI+fI1FPYSBkyxpqgOKTWrJzWZqWA2TptlfYQC3gkb/LUNbYsVouEJEVnCqoxOe7pdtzFvIrzCfTJof54erx8WrKe2Qge8hYQ01jjar4kl4/W3K2oFlnPj+rf3B/lfC8KHkRYvzZRoMcAwMhW5s+X1+hrfpIg0MpebdgAKESGAeEDQDCBwDy25lMfY8eqV049JSsuPUlqz/7Ms1vfQV4u6teP9dMSGDJu5U0tjRia85WLD+zXFV81VqQUxjtF616/cjW14DgAVY5TyJrYh8hW+gjVFuqrfpIAFSZY+GdXYCgRC3wCR2g5frIsNWIQVoSNJsekg1ufbm5umBicghumpKEOYMiWPJupYqv/YX71baXNDwsqzcfpEpzwwsStYqvURGj4OrCkSRkf9hHyNYHpBYcBU6uAnL3AtXm5+8oLm5AcJK25RXaH/Dw0S6S/yPbX33iOfCUrOJUQZUKfr7ak4X8SvNbX/3C/XDV+ASV+xPs52mVc3R2J0tPqmov2frKqTb/C5a3mzdmx89Wwc+UmCnwcGNrAnIO3BqztvQtwDf3aYnPlnD1AEJStOBHOj27e2kX2QaTQafByYArf1ujnlde24jlsvW1Kwt7Ldj6CvLxUHO+rp6QgIFRAXyLrCC3KlcLflK/V6Xv5ri5uGFSzCSV9zMnYY4aeErkbBgIWVtAtPkgyE0CnX5awrMEOvKbmTQ5DO0HRAzVAiM2PSQrbX1tOlWEz3dl4sfD+WYHnbq7umDu4AhcNT4eM/qHw53dnntceX252vKS4EeaHlpiRPgIFfxIw8NQn9AeP0ciW8ZAyNpCkoGo4UDeOUMJPXyBsP5a8CO5P65u2kWCHln5ka0wd24pkPW2vqTfj6z+FFaZ3/qS+V5XjotXyc/c+up5kuS8IXODyvvZlLMJTRa000juk6yCH0l8jg+Mt8JZEtkHBkK9YfDFWiDk3Udb5ZHgR4aaSkKiXIIStOBHtsMkB4jICvIr6rDycB4+25WFA9nlFg06lTlfl4+Nw6Cobi4koA4k2Nmeu10FP2sy1qCmyfzw5AifCFXqLnk/g0IGccwFkQEMhHqDfqZX1k6tYszFRRt2KtVeEvyw2zNZcdSFVHv9cDAX+7PMBz8ebi6YNzhSJT1z0Kl1xlwcLDqogp8VaStU40NzAjwDVJNDWfkZGzkWbrKyTERGMRDqDVLaLpeKLCBmlLb6I6tDRFb4YD2UXYEfD+dhxeE8tQVmieGxfVTww60v6zhTfkZVe0neT2al9BMzzdPVEzPjZ6qtr+lx0+Hpxm10IksxEOpNQy7p1acn59DU3IIdaSVYeTgfK4/kIaeszqL7hfl74tJR2tbX4GhuffW0/Op8teojqz9HS46aPV56+0yImqC2vWTQqawEEVHnMRAickB1jc3YeLJIrfysOZqP0ppGi+4X4OWO2YMi1MrPzIHhbHjYwyoaKrA6fbVa/dmRtwM6CzrJDwsdpro8L0xaiHDf8J4+RSKHx0CIyIH6/Kw7VqCCnw0nClHTYNl4mDB/L8wfEokLhkZiSt8weLqzL1VPqm+ux09ZP6mVH/lTxl6YkxCQoFZ+JO8nqU9Sj54fkbNhIERk75VeR/JVtdfW08VoarFsNl1iqC8uGBqlgp/R8cFwlbHv1GOaW5qxM3+nCn5kBaiq0XxuVphPmFr1kQBoaOhQVnwR9RAGQkR2WOn149l8n70Z5js86w2JDtSCn2GRGBgZwA9WKySmHyk5olV8pa5AYa35UTrS2Xlewjy19TUxaiIrvoisgIEQkR2oqGvE//bl4JOdGarqyxKyyDMuKUQFPwuGRCI+xLfHz5OAjIoMfJf6ncr7SatIM/uSeLh6YHrsdLXyMyNuBrzdvfkyElkRAyEiG15R2JVeio93ZOK7gzmoazQ93kJIfs+0fmFqy0v6/YT6e1nlXJ1dUW2RGnMhqz/S98ccF7hgXNQ4Ve4+L3GemvZORL2DgRCRjSmuqsdXe7Px8c5Mi/r86Cu9ZOVHKr38vfhjbQ1VDVVYm7lWBT/bcrehRWc+UB0cMlglPC9MXogovyirnCcRmcb/MYlsQEuLDptPF6nVH6n6Mpf03LbSa3LfUHi5s3uwNTQ2N2JT9ia19bU+c72qADMn1j9WBT8XplyIlKAUq5wnEVnOKQKhN998Ex9++CECAgLw0EMPYcaMGb19StTLW04VdU0I9Hbv9YThvPI6fLQjAx/vzEB+Rb3Zye6y3XXVBG2yuxsrvaxCVnr25O9Rwc/KtJWq9485Id4harK7BEAjw0f2+r8zInLiQOjjjz/Gtm3b8Nhjj+HYsWO48MILkZ2drYIicj5V9U1YcSgPmSU1am5WH19PhPh6ItjPAyF++r979mgjQen0/N3BXHywLR270krNttBLCvXFVeMTcPnYWEQEMJHWWsHyidITKvj5IfUH5FXnmb2Pj7uP6vAsSc8ToyeqJGgisn0uOvmJ72VNTU0oKytDnz594OHhYfSYhoYG+Pp2rvJF7uPp+fPcnZiYGBw4cABhYWEW3b+iokKdV3l5OQIDOWbAnqUVVattJ3ONBuWXd8mzkcAo+GxwpP97V/Nv5MdsT3oZ3tuahrXHC1BZ12Q26XnxsCgVAE1KCeGKgpVkV2W3zvg6VXbK7PHuLu6YGjtVBT8z42bC14OVeUS2wtLP715dEcrKysKrr76Kt956C7m5uVi3bh1mzZrV7pja2losW7YMH330EVpaWjB06FC11TVmzBh1+759+3DzzTcbfPzdu3e3C4KeeeYZXHvttRYHQeRY+Te700thSdgvx0igIpf04pp2t3l5uCJYVo3OBkchfh7q70G+nh22qmTlR5Kdv9yTjVVH8pFaXG32uaW/z9UT4nHZ6Fj1mNTzSutKWyu+9hXus+g+YyLGqOBnfuJ8BHsH9/g5ElHP6dVASPJ2vLy88L///Q8TJkwweMwDDzyADRs24MiRI4iOjsavf/1rLFq0CCdPnlQRXv/+/fHOO+8YvK+b288JpH/84x/VqtPzzz/fY98P2ebYiR8O5iK33LJBo+bUN7aovB65tOXq4oIgXw+1ahTs64GjuZX48XAuDudUmC179/V0U7O9rhofj1HxQVz9sYKaxhqsy1yngp+tOVvRpDO9Qif6BfVTwc+i5EUqAZqIHINNbI3JylB8fHyHFaHKykqEh4fjxRdfxO2339661KW/7o477jD72LKlduedd6rHf+KJJ8weX19fry568nxyX26N2Z+T+ZVYdTRfBS/WGHKaV6EFSBklNRYFXiPjg3D1+HhcNDKGJe9WIDO9JOiR4EeCoNqmWrP3kRJ3SXiWAGhA8ABrnCYROdPWmDmy7SVBybRp01qvk29m1KhR2L59u0WBkGy7ycrT4MGD1cqT+O9//4shQ4YYPP6pp56yKGAi2yVbUj+dLMT+zPIe22orrm5Abnlta/Bj6XR3qVRbOiZOrf4MjmbOWU+T3/Nku0uCH9n+Kqs3P5JEmhsuSFyggp/REaPh6sIhtESOzKYDocJCbTaPrAC1JV/rbzNn6dKlHbbdkpOTjR7/yCOP4MEHH+ywIkT2oaS6Ad8fzEVhpfn+Lpaqrm9SKzz6oEcGnVo63FRvYnIIrpmQgIXDouDtwZ4/Pe1U6anWii9JgDbH280bs+JnqeBnasxUeLix4ovIWdh0IKTvvdHc3Nxhu8tYddm5JDG6M8nRkrMkF7I/h3PKsf54IRqaWs5rNamgsr416JE/zVV4GRPq54lfjIvDVePikRLu3+VzIstIibtUe8nqj5S+m+Pm4oZJMZPUmIs5CXPUwFMicj42HQhJqbvIz89HRERE6/Xy9eTJk3vxzMiWSOCz9lgBjuZaNoy07baJJFO3DXpkJamTiz2tpC/R8Ng+GJMQjIkpoZg5IFyVwVPPKa8vx8r0lSr42Z2/26L7jAgfofJ+pOFhmA8rSImcnU0HQpILJI0PV69ejeHDh7cGQdIH6De/+U2PPvdLL72kLueuRpFtKaisw/cHci3O0SmracCpwirklGnBT21j19/f6D7eGJMYjAlJIRidEIRBUYEMfKxAkpw3ZG5QW18y7qKpxfyKXXKfZLXyIwFQfCC3uonIRgIhSYSWyrDS0lL1tWR2FxUVqaaJcpEtqocffhhPPvkkBg0ahISEBDUiY8CAAbj88st79NzuueceddFnnZPt2ZdZho0nCs3m61TUNuJkQRVO5Feqba+u8HZ3xaDoQIxPCsHkviEYGRfEye5WJMHO9tztautrdfpq1DS17+9kSIRPhCp1l7yfQSGD2JaAiGwvEPrqq69w7733qr+HhobitttuU3+X1R79io+MxpCmiBIASdA0depUvPHGG+0aJZJzkVJ1aVBoajJ7ZZ0W/JzMr1JbXp0V08cbQ2P7YFJyCKYPCEffcH/O9rIy2bo8WHRQbXutSFuBkroSs/cJ8AjA/KT5avVnbORYuLkyMZ2I7KCPkC3jiA3bklNWix8O5alVHkPVXafOrvzkdKKBojQ0TA7zw8i4PpjaLwzT+4ch0IeBdm9JLU9VwY+s/mRWZpo93tPVEzPjZ6rgZ3rcdHi68b0jIjhGH6HexBwh2yLx+q70Umw5VYyWNrF7TUMTThdU40RBJbJLa80OMBU+Hm4YGd9HbXPNGBCOMfFBcOvBIatkXkFNgSp1lwDoaMlRs8dLb58JURNUzs+8xHkI8OQQZSLqGq4ImcEVod4nwY5MjNfP/ZKtMUl4lm2vzNIai+aHeXu4YnRCMC4cHo1LRsXA35t9YnpbRUMF1qSvUcHPjrwd0FkQxg4NHapyfhYmLUS4b/v+YkREbXFFiBxCRnENVhzOVY0SzxRWq20vGWFhSYm7l7urmt0lIyxkiKlfFyfHU/epb67HxqyNKvj5KesnNLQ0mL1PQkBC64wvqf4iIupO/GQgmyRjLNYdL8Bnu7NwIq9SrQY1W7D0I7189MHP0jGx8Pfiyk9va25pxs78nfj+jFbxVdlYafY+od6hrRVfsgqkb65KRNTdGAiRTSmprsenu7Kw/EAOjuVWWjTKwt315+DnF2PjuPJjIzldR0qOqOBnReoKFNQWmL2PdHaemzBXBT+S/+Puyv+eiKjn8X8aI5gsbT2lNQ34ZEcmfjiUi8M5FRYFP26uLqrKS4KfK8bGMefHRmRUZKhGhxIApVWkmT1egp0ZsTOwOGUxZsbNhLe7t1XOk4hIj8nSZjBZumeUVjfgk12ZakCqBD/NFgQ/ri7A8Lg+uPhs8MMSd9tQVFukJrtL3o/0/THHBS4YFzVOVXzNT5yvpr0TEXU3JkuTzSmpOrvtdTAHR3IqLEp4luBnWEwfXDxKC376+LJHjC2oaqjC2sy1KvjZlrsNLTrzg26lu7P0+lmYvBBRflFWOU8iInO4NUY9qqiyTiU8Lz+Qq4aiWhL8SF7s0JhAXDwiBleMi0ewH4MfW9DY3Khme8nW1/rM9aoCzJxY/1i18iN5P32D+lrlPImIOoOBEPXIINTPd/0c/FjS5NDNxQXD4rTgZ+mYOAY/NkJWemSqu3R5Xpm2UvX+MSfYK1hNdpfgZ2T4SFZ8EZFNYyBkBJOlOye3vBZf7snGt/tzcDyv0rLgR6q94oJw8ahoXDpKtr1Y6m4rFV8nSk+olR/p9pxXnWf2Pj7uPpiTMEdtfU2KmQQPV76XRGQfmCxtBpOljcsqrcFXe7Xg50S+8QGo55a6j00MxqWjY3DhiBgEsMOzzciuylbVXrL6c6rslNnj3V3cMSV2igp+ZsXPgq+Hr1XOk4jIEkyWpm5bHZCuzpmltThdUInThdVIK65Wqz7yd0tIk0OZ6yXdnRcPj2afHxtSWlfaWvG1r3CfRfcZHTFaBT8LkhYg2Du4x8+RiKgncWuM1NR2mdkls7tOF1SpQCertBa55XUoqqpHfZP5iiBD4y0mJIeo7s4Lh0bDx9ONr7SNqGmswbrMdSr42ZqzFU26JrP36RfUr3XMhSRAExE5CgZCTqC+qRk5ZXU4VVCJUxLoFNWowEfyegoq61Fd39wtzyODTSenhOLysXGYNzgS3h4MfmxFY0ujCnok+JEgqLap1ux9pMRdKr7kMjBkoFXOk4jI2hgI2fi2lHRZlmaD6s9m+bNF/b3t13J7Y7NOm8peUInjZ1d2ciTQqahHeW2jRcnLXeHr6YYpfUPVaIs5gyLh6e7aQ89EXfn3s79wP5afWa4qvkrrS83eR5obLkhcoIKfMZFj4OrC95OIHBsDoV6sGvvxcB7Kahpagx0JZprPBjpakKMz+SFXWtOI/Io65FXUqT+LKhssGkzaFdLbp4+PByICvBDTxweJYb6Y0T8cMwaEw8ONH5a25FTpKZXwLBdJgDbH281bJTvL1tfUmKnwcGPFFxE5D1aN9WLV2Ltb0lQisjkS9FTVNyG/or416JGVnobmzufumOLn6aaCnXAJdoJ8kBDii34R/hgYFYCBkQHw4laXzZISdyl1l62v46XHzR7v5uKGSdGTVPAjZe8y8JSIyJGwasyOyRaXBDsS+Gh/1qG64fxXpiSBWQKdQG8PBPt5qJWdhFBf9Av3x4BIf0QH+ajbXWT5h2xeeX05VqWvUsGPND3UWbABOiJshBpwKg0Pw3zCrHKeRES2jFtjvaypuQWFVfXIK69DfmU98svrUFbbeF6PGezrgahAb4T5e6nVHRXsRPghNsgXoX5eCPH3hL8X33p7VNdUhw1ZG1TwszF7I5pazFd8JQUmqZUfKXmPD4y3ynkSEdkLfhr2wtT1VUfysS+rDOuOFajVHkvmbxkjAU1koBciA70RF+yDEXFB6Bvuj9ggH0QEerFyywFIsLMjd4fq9LwmYw2qG833b4rwiVCl7rL6MzhkMFf5iIiMYCBkZcXV9fjNFwe6dF+pyJKVHn3gkxjqi4FRgYgN8larPZLI7Crj2snuSV7YoaJDKvhZkboCxXXFZu8T4BGA+Unz1crP2MixcHNl+wIiInMYCFlZSpi/WsWR5Gdzc7jC/b1+Dnz6eKvkZVn1kaAnJsgbIX6e/E3fwaSVp6ngR0ZdZFRmmD3e09UTM+NnquBnWtw0eLl5WeU8iYgcBQMhK5MVm+GxfbD1TPvf8EP9PNUqjwQ9Kr8nwEut8MQG+6gKLrlIkjM5nsKaQq3iK/U7HCk+YvZ4F7hgQvQEFfzMS5yHAM8Aq5wnEZEjYiDUC32EZg8KV6s5Uv4e6O2OiABvNYKibeAjOT7szOy4KhsqsTp9tQp+dubtRIvOfCuEoaFDVaNDyf0J9w23ynkSETk69hHqxT5Ca47mqwGkEvRE9fFmY0IHV99cj41ZG1Wjww2ZG9DQYr6HVEJAQuuMr+Q+yVY5TyIiR8A+QnZg7uDI3j4F6mHNLc3Ylb9LBT+r0lahsrHS7H1CvUO1iq/kxRgWNox5YEREPYhbY0Q9UPF1tOSo6vUjFV8FtQVm7yOdnecmzFWrPxOiJsDdlT+aRETWwP9tibpJZkWmVvGV+j1Sy1PN//C5umN67HQV/MyMmwlvd2++F0REVsZAiOg8FNUW4ce0H1W5+4GiAxZVfI2LGqe2veYnzlfT3omIqPcwECLqJOnsvDZjrdr62pa7Dc0685WFg0IGtVZ8RflF8TUnIrIRDISILNDY3IhN2ZvUttf6zPWoa64ze59Y/1gV/MjWV9+gvnydiYhsEAMhIiOkt8+e/D0q+FmZvlJNezcn2CsYC5IW4MKUCzEyfCQrvoiIbBwDIaJzKr5OlJ5QSc/S7TmvOs/s6+Pj7oM5CXNUp+dJMZPg4coO4ERE9oKBUC90libbk12VrY25OPMdTpWdMnu8u4s7psROUcHPrPhZ8PXwtcp5EhFR92Jn6V7sLE29q7SuFCvTVqrVn70Fey26z+iI0Sr4ke2vYO/gHj9HIiLqGnaWJjKgprEG6zLXqbyfLdlb0KRrMvs69Qvq1zrmQhKgiYjIcXBrjBxeY0sjtuZsVcGPlL3XNtWavY+UuEvgI6s/A4IHMOmZiMhBMRAih0163l+4H8vPLFfbX6X1pWbvE+gZqLa8JPgZEzkGri6uVjlXIiLqPQyEyKGcLjutEp5l9UcSoM3xcvPC7PjZqt/PtNhp8HBjxRcRkTNhIER2T0rc9RVfx0uPmz1eVnomRU9SeT8y6FQGnhIRkXNiIER2SZobrkpfpYKf3fm7oYPO7H1GhI3A4pTFuCDpAoT5hFnlPImIyLYxECK7UddUh/VZ69WA043ZG9HUYr7iKykwSa38yNZXQmCCVc6TiIjsBwMhsmkS7OzI3aF6/azJWKMGnpoT7hOuVXylLMHgkMGs+CIiIqMYCJFNVnwdKjqkgp8VqStQXFds9j4BHgGYlzhPBT/jIsfBzdXNKudKRET2jYEQ2Yy08jQV/MjWV0ZlhtnjZabXzLiZKviZHjddVYARERF1BgMh6lWFNYVaxVfqdzhSfMTs8S5wwYToCarXz9zEuar3DxERUVcxECKrq2yoxOr01Sr42Zm3Ey26FrP3GRI6RAU/C5MXIsI3wirnSUREjo+BkBGcPt+96pvrsTFro2p0uCFzAxpaGszeJz4gvnXGV0qflG4+IyIiIk6fN4vT57uuuaUZu/J3qeBnVdoqVDZWmr1PiHeICnyk3H142HBWfBERUZdw+jz1WsXX0ZKjKuFZcn8KagvM3sfX3Ver+EpeovJ/3F25UElERNbBTxzqFpkVmVrFV+r3SC1PNf8Pz9VdzfaSrS+p/PJx9+E7QUREVsdAiLqsuLYYK9JWqODnQOEBi+4jPX5kzMWCxAXo49WHrz4REfUqBkLUKdLZeW3GWjXja1vuNjTrms3eZ2DwQBX8SN5PlF8UX3EiIrIZDITIrMbmRmzO2ayCn/WZ61HXXGf2PrH+sSrwkUu/4H58lYmIyCYxECKDpLfP3oK9KvhZmb5STXs3J8grSE12l7yfUeGjWPFFREQ2j4EQtXO85LjK+ZGKr9zqXLOvjiQ5z46frYKfyTGT1dgLIiIie8FAiJBTlaOCH1n9OVV2yuwr4ubihikxU1Tez5z4OfD18OWrSEREdomBkJMqrSvFyrSVKgDaU7DHovvIdpes/CxIWqAaHxIREdk7BkJOpKaxRiU7S/CzOXszmnRNZu/Tt0/f1jEXcQFxVjlPIiIia2Eg5OAaWxqxLWebanYoZe+1TbVm7xPpG6mqvSQAGhA8gEnPRETksBgIOeiYi/2F+1srvkrqSszeJ9AzUG15SQA0NnIsXF1crXKuREREvYmBkAM5U3YGy88sV1tf2VXZZo/3cvPCrPhZKviRcReebp5WOU8iIiJbwUDIzuVV52FF6gq19XWs5JjZ42WlZ1L0JLXtJRVf/p7+VjlPIiIiW8RAyA5Jc8PV6atV8LMrbxd00Jm9z/Cw4Sr4kYaHYT5hVjlPIiIiW+fuTHkzLi4usFd1TXXYkLUB35/5HhuzN6okaHOSApNUr58lyUuQEJhglfMkIiKyJw4fCDU1NeHPf/4zXnzxRRUMPfjgg3jsscdgD5pbmrE9b7tKel6TsUYNPDUn3CccC5MXqtWfISFD7Dr4IyIi6mkOHwidPn0agYGBSE9PR2lpKSZNmoQrr7wSAwcOhC2SYO1w8WEV/MiYi+K6YrP38ffwx/zE+Wr1Z3zkeLi5ulnlXImIiOydTQRCJ06cUJfJkycjNDS0w+0tLS3YvXs3KisrMXr0aAQHB7cLHOrr6w0+rre3twp4BgwYoI6pqqpS1wUFBcHWpJWnqWovuaRXpJs9XmZ6zYybqVZ+psdNVxVgREREZEeB0MaNG/HEE0/g+PHjyMrKwrp16zBr1qx2x8j1F1xwASoqKhAVFYWjR4/itddew3XXXadu37p1K+bMmWPw8aurq+Hm5obU1FQMGTJEBUOPP/44IiMjYQsKawqxIm2FWv2RVSBzXOCCCVETVPAzN3Gu6v1DREREdhoI5eTk4Le//S0GDRqEhATDybx33HEHQkJCsHfvXnh6eqpcn9tuuw0zZsxAfHw8pkyZgrq6OpPPk5KSoo4pKCjARRddhGnTpmH+/PnoDVUNVVidsVoFPzvydqBF12L2PkNCh6hePzLmIsI3wirnSURE5Ax6NRC66qqrWld9DMnPz8ePP/6Izz//XAVB4q677lLJzp988gkefvhhs8/x6aefqoTphQsXoqSkRAVEzc3NRo+XVaO2W22yEtWdtuVuw2ObzSdrxwfEt874SumT0q3nQERERDaUI2TMwYMHVQ7QyJEjW6/z8PBQ21z79++36DGWLFmiKsXuv/9+9OnTB7fccosKiox56qmn1HZdT5F8ngCPAFQ2Vna4TSa6S+Ajqz/S94cVX0RERE4cCJWVlak/ZWusLUmo1t9mjp+fn8opkoslHnnkERU4tV0Rki247iJJzfOT5uPLk1+qr33dfTEvcZ7q9TMhegLcXW36LSEiInIoNv2pq98Oq6mpaVcpJl/L6k5P8PLyUpeedGHKhWoQqmx9zYqbBW937x59PiIiIrLDQCg5Obk1hyg2Nrb1+szMTIwaNQr2anzUeHUhIiKi3uUKGzZs2DDExcXhyy+1bSR93pD0HDKV59MdXnrpJZWLNH48AxYiIiJH1asrQrLSs2/fPhQXF7f2BJKmh9IAUS6SLPzcc8/h+uuvV40QpcT+6aefxuLFizFv3rwePbd77rlHXSRHqKe24YiIiKh3ueikLKuXrFmzBv/85z87XH/ttdeqi540Wnz//fdVZ+mpU6di2bJlrflDPU0fCJWXl6tRHURERGT7LP387tVAyB4wECIiInLcz2+bzhHqTcwRIiIicnxcETKDK0JERET2hytCRERERGZwa4yIiIicFgMhIiIicloMhIxgsjQREZHjY7K0GUyWJiIisj9MliYiIiKy56GrtkDfb1IiSyIiIrIP+s9tc32jGQiZIWM9RHx8fHe9N0RERGTFz3FTM0OZI2RGS0uLGgC7e/duNQTWEjKxfufOnWYjVQmuMjMzOcOsE6+bM51fTz1fdz3u+TxOV+7bmftYeix/Ds//fbEm/gzaz8+gLXwWykqQBEExMTFwdTVeG8YVITPkxZMBr52ZQO/m5mbxGyrHcZhr5183Zzi/nnq+7nrc83mcrty3M/fp7OPz57Dr74s18WfQfn4GbeWz0JLPbpbPW+Cee+7p0ePJPl43a59fTz1fdz3u+TxOV+7bmfvY+r8lW2Xrrxt/Bu3nZ9Ae/j3pcWusl7Asn6j38eeQqHfZws8gV4R6iZeXF/74xz+qP4mIP4dEzsjLBj4LuSJERERETosrQkREROS0GAgRERGR02L5PBGRCQUFBaqfWFRUFF8nIisqLi5GaWlp69fR0dHw8/Pr9ufhipANksZSS5YsgY+PD0aNGoXt27f39ikROaXs7GxMnToVv/zlL3v7VIiczlNPPYVp06Zh4cKF6rJx48YeeR4GQjZo+fLlePDBB1U54bJly/DAAw/09ikROR1ZBXrooYfw29/+trdPhchpPfnkk9i8eTNOnTqlgqGewECoh8hIjhUrVhgd9lZXV6feXFntaWxsbHfb3XffjdmzZ6v/iOUSGRnZU6dJ5LAOHz6M1157Dfv27TN4e1NTE1atWoW3334b27Zt63D73/72N9x5553cEiPqourqanz00Ud49913jR5z5swZvPfee/jiiy/UL/9thYWF4ZlnnsHQoUPV5eTJk+gROupW7733nm7EiBG6qKgoiYB0jY2NHY7ZsGGDLjw8XDdo0CBdcnKyLiEhQbdv3752xzz++OM6FxcXXWhoqG7Xrl18l4gsdPDgQd2MGTN0gwcP1vn6+uqeeuqpDseUl5frxo8fr37+rrzySl1YWJjummuu0TU3N6vbf/rpJ91dd92lO3nypO7111/XzZs3T5eTk8P3gMhCv/nNb3TR0dHq51A+xwx55ZVXdD4+PrqLLrpIN3HiRPVzuGfPng7HtbS06J544gndZZddpusJDIS62XPPPafbu3ev7qOPPjIYCNXU1Kgg6f777299g6+44gr1j0X+3pb8p7x69WoVKBGRZeSXivXr16u/x8bGGgyEHnroIRUElZWVqa+PHj2q8/T01H3wwQfq68cee0zXt29fdZH/zP38/HS33HIL3wIiC73zzju60tJS3T//+U+DgVB6err6mXvrrbdar7v88st1o0aNMvh4+/fvN3rb+eLWWDeTnAJJcDbmxx9/RH5+Pn7zm9+or2Wi/e9+9zscPXoUO3bsUNc98sgjOHjwIGpra9XSYn19fXefJpHDGjlyJGbOnGnymI8//hjXX39960DGQYMGYf78+ep68ec//1nlJMjl9ddfx7x58/DWW29Z5fyJHMFNN92EoKAgo7d/+eWXqiBIfg717r33XrWVffz4cfV1RkaG+hmUCfbyOTljxoweOVeWz1uZvMmS8xMTE9N6nQROMuV+//79mDhxIpYuXYrbbrtN/WMYPHgwPvnkE2ufJpHDkjwEqQYbMmRIu+vl688//7zD8VKuK2W7RNS9OXz9+vWDh4dH63X6n0m5beDAgbjllluQnp6uAqo5c+aoURw9gYGQlZWVlSEkJKTddRIEyW+m+n4J48ePb10dIqLuH/Iozv1tNTg4uPW2tqRwQS5E1H3kZ83Qz6D+NrFmzRpYA7fGrMzT01NteZ1LrpPbiKhnyXK8qKysbHe9/Ofr6+vLl5/ISj+Hhn4GhbV/DhkIWVlSUpLKEWpbMl9UVKTK6eU2IupZUpIrv3mmpqa2u16+lqV6Iup5/fv3V9tebVvM6H8mrf1zyEDIyhYsWKBWf1auXNl6nfRP8PLywqxZs6x9OkRO6aKLLsKnn36K5uZm9XVJSQl++OEHXHzxxb19akRO8zOYn5/fbvvrgw8+QHx8vMmCo57AHKFuJkleMiJDEp+FBDySAyR5P6GhoSrSlYaJkgz9xBNPqJWgP/zhD3j00Udb90eJ6Pzy8PTVX1J1KU1LX331VSQkJGDx4sWtVWFSmLBo0SKV/yPHy8/mXXfdxZeeqBvILxay4rNlyxb1OSc/g+Kqq65Sn3UjRoxQVWLXXHONmqAgQdGbb76pChbkM9OaXKSG3qrP6OCef/551VH6XH//+99bo1zpFi2luHKcu7s7Lr30Ulx99dW9cLZEjkf+QzVUXSKdae+77752w1TfeecdVUEm5fM333xza/4QEZ2fl19+GQcOHOhw/eOPP96uavp///sfNmzYoPKCrrzyShUgWRsDISIiInJazBEiIiIip8VAiIiIiJwWAyEiIiJyWgyEiIiIyGkxECIiIiKnxUCIiIiInBYDISIiInJaDISIqMdJd+dt27bZ3CstHW+lxf8nn3yiGitakzSbk0ZyPW3dunWqw6+lNm/ejJMnT/boORHZEo7YIHJwBw8eVKNfxowZgwEDBrReL+Mnvv32W1xwwQU9Pt7llVdeQVNTEyZNmgRbITP/5DXx8/NT4zX69u2L2NhYqz3/f//7X+zbtw8zZ87ssec4duyY6lovf1oqLy9PjT7YvXu31UcdEPUG/isncnCy2iHzfK677rp2k54LCwvV9adPn4Yz+umnn5CRkaFWqmTW2Lhx4+BoZI7h7bff3qlA9/LLL0dNTY36d0PkDLgiROQEIiMjceTIETVxXYYeGrJx40b4+/tj9OjRrdfJikV5eXnrqoVscUkwNWzYsNbbZsyYgYCAAFRWVqptFU9PT0yZMgXe3t4dnqOqqgp79+5Vx8r95PkMrWBJcKafQu3m5tZ6m/75ZW7Y1q1b0djYiCVLlhj8fmSyvBwvs8f69++vzllPzkFWwzw8PNSQR3mOK664osNj6J9P5h/JfeT8ZVhrUFCQxc+lV19fr4Ivea62r3Fnvn8h21yHDh1SQ5xlRUteb0Nkq+/rr7/G0aNHO/39XH/99XjppZdUoEzk6BgIETmBsLAw3HrrrXj00UexdOlSFQCc6+mnn1ZbRG0/pD/44AP1oasPhGSLa8+ePaioqMCQIUPUB7YEQ88884wadDp48GCcOHFCDVCUD922Q0xle04+gGULKisrS91v9erV6nGEBEcydFGeT85BHkcCLAlYoqKiWp9///79alsvJSVFDUs1FAhJQLJw4UIUFxeroElWfebPn4+PPvpIBRYSbMjWjwQnEixIMGEoENI/n+QSJSYmqm2j3Nxcldsjz23Jc+mDEplyL9uDsj0pr4UEOoGBga3PZcn3/5e//EW91tOmTVNBjLwPX3zxhXpNDU3/jo6OVoFZZ74fMWfOHPzpT39CSUkJQkJCzP77IrJrMn2eiBzXo48+qhs6dKiurKxMFxoaqnvhhRfU9ampqbJPptu5c6f6esmSJbr777+/3X0feugh3QUXXND69U033aTz8fHRHT9+XH1dX1+vS0hI0AUEBOjOnDmjrquurtZFRETo3nzzzXb3k+dau3at+rqpqUl38cUX6+bMmdN6zJ133qlbtGiRekzR3NysW7p0qe66665r9zju7u66vXv3mvyeb775Zt3YsWN1VVVV6ms5t8DAQN1rr73Wesz777+vi4yMNPk4+u/3yJEj6uuWlhZ1zrfeemunnuuGG27QTZ06VVdbW6u+PnDggM7Dw6Pda2vu+29oaNB5enrqVq5c2XqfEydO6A4ePGjw3O+++27dggULOv39iPLycvV+tX0uIkfFHCEiJ9GnTx+1IvTnP/9ZrT50laxs6JOuZSVFtmdkBSQ5OVldJ6tBsvIjKxptSQ6O3FfISsnDDz+MtWvXqpUUWSmR1SdZUfnmm2/w2WefqS2ruLg4VfXU1vTp09WWkTGy9SNbgPfff79KhBZybtdee63KBeqsWbNmqZUu4eLiorb0jh8/bvFzyTHyvdx3332t24XDhw/HokWLWp/Dku9fEpe9vLzUalZLS4u6ztg2nCgqKjKYG2Tq+9GTlSp5j+QxiBwdAyEiJ7Js2TIVqDz77LNdfoxzP1zlw9nQdbL90lZSUlK7r/WBk+S8FBQUqARdyTuSAEC2e7788ku17SQf3G3Jdo8pkgQujyVbZ23J9lFnysj1zt0aavu9WfJccoxUqBn7/oUl378EJu+//77K3ZGcr1/84hfqWGMk/0q2EDvz/ejJ15L3JFtzRI6OOUJETkQ+9J588kncfffdWLx4cbvbZMVBv9Kgd+4H5PkoLS01+LXkL8kHrqxO3HHHHSpPxhQ5zhQJyiRokPyWtuRrea7uZMlzSSKyvLbGvn9h6fd/ySWXqIv0+ZEcIKkIk8q3Bx98sMOxsmq3Y8eOLn1fqamp6s+BAwd26f5E9oQrQkRORsroJSlakmHbkh46p06dav1agiKpcuouW7ZsUasjerLiIQm7sv0jgYBUmr322mvtSvxFZxsdSiL4hAkT1OPryerGV199pZKMu5MlzyXbh3KMJGXryerPihUrWr+25PuXVSV98CRbYr/61a9UUGSsUeXcuXNVpeC5AZglpPovISGhXaI1kaPiihCRk5HVib///e/tclT0JdNSHSa5O7ISINsuUlUUExPTLc8rW3Ly4fzLX/4SaWlp+Oc//4n33nuvtWnfyy+/rG6XiiWp4NJ3fZZtpxdeeKFTz/WPf/xDPY6s1kgQInk8khf1yCOPdMv30tnn+tvf/oYFCxao73XkyJF45513Oqy+mfv+5TElWLr44otVjpFU3skW2ltvvWXwvMaPH6+eS/oByWveGXIfWW0icgYMhIgcnCQuS5l4W1Lu/dBDD6kPU33OyNSpU1VirnyQSwm3JADLakJmZmbr/aTnzLkf4IZ6BkkCrr7kW38/+WCWAOv7779XH+rypyRZtz1PKSuXIEG2dGRrSVY9pPO1qec3ZPLkyao8Xh5r06ZNKs9Gytnbbo1Jzs6ll15q8nEMPZ+U+7c9J0ueS5LEpU/Tu+++q77H//f//p96T9rmLJn7/iMiIrBr167W55FtuZUrV6rX35jHHnsMjz/+OO68804VhFny/cgqkuQqdSWxnMgeuUjpWG+fBBER9QwJum644QYVaFnizTffVInWxhpvEjkaBkJERETktJgsTURERE6LgRARERE5LQZCRERE5LQYCBEREZHTYiBERERETouBEBERETktBkJERETktBgIERERkdNiIEREREROi4EQEREROS0GQkRERARn9f8BWOBY5Tun65kAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(ns, np.median(abcd, axis=1), lw=3, label=\"ABCD\")\n", + "plt.fill_between(\n", + " ns, np.quantile(abcd, 0.1, axis=1), np.quantile(abcd, 0.9, axis=1), alpha=0.5\n", + ")\n", + "plt.plot(ns, np.median(lfr, axis=1), lw=3, label=\"LFR\")\n", + "plt.fill_between(\n", + " ns, np.quantile(lfr, 0.1, axis=1), np.quantile(lfr, 0.9, axis=1), alpha=0.5\n", + ")\n", + "\n", + "plt.plot(ns, 1e-6 * ns, lw=3, label=\"O(n)\")\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.legend()\n", + "plt.ylabel(\"Sample Time (s)\")\n", + "plt.xlabel(\"Number of nodes (n)\")\n", + "plt.title(\"Scaling of ABCD and LFR\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Although both model run in O(n), the ABCD implementation runs about one order of magnitude faster. If you wanted to benchmark an algorithm on graphs with 10,000 nodes (10^4), and you needed to generate 1000 graphs, the ABCD model would take 30 seconds while LFR would take 5 minutes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What to do next\n", + "\n", + "### Run a benchmark\n", + "We have examples of benchmarking community detection algorithms with ABCD using the following libraries:\n", + "- [networkx](benchmark_networkx.ipynb); the most popular\n", + "- [igraph](benchmark_igraph.ipynb); the most algorithms\n", + "- [sknetwork](benchmark_sknetwork.ipynb); the fastest\n", + "\n", + "### Check out the extensions\n", + "We have notebooks detailing the extensions to [outliers](outliers.ipynb) and [overlapping](overlap.ipynb) communities.\n", + "\n", + "### Read the papers\n", + "\n", + "Defining the model:\n", + "\n", + "- [Bogumił Kamiński, Paweł Prałat, and François Théberge. Artificial Benchmark for Community Detection (ABCD)—Fast random graph model with community structure. Network Science 9(2):153-178 (2021) doi: 10.1017/nws.2020.45](https://doi.org/10.1017/nws.2020.45)\n", + "\n", + "- [Bogumił Kamiński, Tomasz Olczak, Bartosz Pankratz, Paweł Prałat, and François Théberge. Properties and Performance of the ABCDe Random Graph Model with Community Structure. Big Data Research 30:100348 (2022) doi: 10.1016/j.bdr.2022.100348](https://doi.org/10.1016/j.bdr.2022.100348)\n", + "\n", + "- [Bogumił Kamiński, Paweł Prałat, François Théberge. Artificial benchmark for community detection with outliers (ABCD+o). Applied Network Science 8 (2023) doi: 10.1007/s41109-023-00552-9](https://doi.org/10.1007/s41109-023-00552-9)\n", + "\n", + "- [Jordan Barrett, Ryan DeWolfe, Bogumił Kamiński, Paweł Prałat, Aaron Smith, and François Théberge. The artificial benchmark for community detection with outliers and overlapping communities (abcd+o2). Journal of Complex Networks 14(4):cnag023 (2026) doi: 10.1093/comnet/cnag023](https://doi.org/10.1093/comnet/cnag023)\n", + "\n", + "Theory:\n", + "\n", + "- [ Bogumił Kamiński, Bartosz Pankratz, Paweł Prałat, and François Théberge. Modularity of the ABCD random graph model with community structure. Journal of Complex Networks 10(6):cnac050 (2022) doi: 10.1093/comnet/cnac050](https://doi.org/10.1093/comnet/cnac050)\n", + "\n", + "- [Jordan Barrett, Bogumił Kamiński, Paweł Prałatand François Théberge. Self-similarity of communities of the ABCD model. Theoretical Computer Science 1026:115012 (2025) doi: 10.1016/j.tcs.2024.115012](https://doi.org/10.1016/j.tcs.2024.115012)\n", + "\n", + "Other extensions not supported by this package:\n", + "\n", + "- [Bogumił Kamiński, Paweł Prałat, and François Théberge. Hypergraph Artificial Benchmark for Community Detection (h-ABCD). Journal of Complex Networks 11(4):cnad028 (2023) doi: 10.1093/comnet/cnad028](https://doi.org/10.1093/comnet/cnad028)\n", + "\n", + "- [Łukasz Kraiński, Michał Czuba, Piotr Bródka, Paweł Prałat, Bogumił Kamiński, and François Théberge. Multilayer artificial benchmark for community detection (mABCD). Expert Systems with Applications 307:130920 (2026) doi: 10.1016/j.eswa.2025.130920](https://doi.org/10.1016/j.eswa.2025.130920)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "abcd", + "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.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/how_it_works.rst b/docs/how_it_works.rst new file mode 100644 index 0000000..9c14be5 --- /dev/null +++ b/docs/how_it_works.rst @@ -0,0 +1,131 @@ +How it works +============ + +The Artificial Benchmark for Community Detection (ABCD) is a method +for sampling a random graph with known ground truth community +structure. This page will detail the algorithm implemented in this +package for sampling an ABCD graph. It's not exactly the same as the +algorithm proposed in Kamiński, Prałat, and Théberge (2021) and includes +parts of Kamiński et. al (2022). + +The Big Picture +--------------- + +An ABCD graph is a union of many community graphs and a global +background graph. Generating an ABCD graph follows a five step +process. + +1. Assign nodes to communities + +2. Assign degrees to nodes and split degrees + +4. Generate community (and background) graphs + +5. Merge Graphs + +.. image:: _static/big_picture.png + :width: 600px + :alt: Four panel image visualizing the generation of an ABCD graph. + :align: center + +Each node has its degree split between its community graph and the global background +graph, with the $\xi$ (xi) proportion going to the background (subject to random rounding). + +The Configuration Model +----------------------- + +The Configuration Model (Bollobás, 1980) is a classic algorithm for +generating a multi-graph with a specified degrees sequence, and will +serve as a corner stone for the ABCD model. The input to the configuration +model is a degree sequence $d_1, d_2, \dots d_n$. It creates $n$ nodes, +and each node $n_i$ is given $d_i$ half-edges (or edge stubs). Then, the +half edges are paired randomly to create full edges. Since half-edges may +be paired with other half-edges from the same node (creating loops), or +there may be duplicate pairs (parallel edges), this algorithm creates +a multi-graph. + + +Rewiring +-------- + +However, we typically want a simple graph without loops and parallel edges. +To preseve the degree sequence, we can perform a series of rewirings to try +and fix the bad (loops and parallel) edges the multi-graph. This is accomplished +by iteratively selecting a bad edge, $uv$, and another edge at random, $xy$. We +consider rewiring these edges into either $ux, vy$ or $uy, vx$ (chosen randomly) +and accept the change if it does not create any new bad edges. This process is not +guaranteed to terminate, there may not exist a simple graph with the specified degree +sequence, so we typically only try to rewire each bad edge some maximum number of times. + + +The Full Algorithm +------------------ + +========= ===================== ================================================== +Parameter Range Description +--------- --------------------- -------------------------------------------------- +$n$ $\mathbb{N}$ Number of Nodes +$\xi$ $[0,1]$ Level of noise +--------- --------------------- -------------------------------------------------- +$\gamma$ $(2,3)$ (recommended) Exponent for power-law degree distribution +$\delta$ $[1, n-1]$ Minimum degree +$\Delta$ $[\delta, n-1]$ Max degree +--------- --------------------- -------------------------------------------------- +$\beta$ $(1,2)$ (recommended) Exponent for power-law community size distribution +$s$ $[\delta, n]$ Minimum community size +$S$ $[s, n]$ Maximum community size +========= ===================== ================================================== + + +1. Assign Nodes to Communities + + Sample a sequence of community sizes $s_1, s_2, \dots s_{\ell}$ from a discrete power-law + distribution (minimum s, maximum S, exponent $\beta$) such that the sum is at least $n$. + Let $a = \left( \sum_{i \in 1 ... \ell} s_i \right) - n$. If $s_\ell \geq a + s$, the decrease + $s_\ell$ by $a$. Otherwise, delete $s_\ell$ and increase $a$ random $s_i$ by $1$. + + This step can be overridden by passing a community size sequence directly. + +2. Assign Degrees to Nodes + + Sample a degree sequence by taking $n$ i.i.d samples from a power-law distribution + with minimum $\delta$, maximum $\Delta$, and exponent $\gamma$. Like the previous step, + this can be overridden by passing a degree sequence directly. + + When assigning degrees, we need to make sure that we can generate a simple community + graph from the result. In particular, if node $i$ is in a community with size $c_i$, + and it got assigned a degree $d_i > \lceil \xi (c_i-1) \rceil$, then it would have more + community degree than other nodes in it's community. A further problem could be caused + by edges from the background graph that fall within the community. The specific derivation + is a bit technical (see the paper for details), but we only allow node $i$ to be assigned + degree $d$ if + $$d \leq \frac{c_i - 1}{1 - \xi \phi},$$ + where + $$\phi = \sum_{j \in 1 .. \ell} \left( \frac{s_j}{n} \right)^2.$$ + We sample a random admissible assignment by assigning degrees in decreasing order, and assigning + each degree to a random admissible node. If no nodes are admissible, we assign to the node with + the largest bound. + + Finally, the degree $d_i$ of each node $i$ is split into a community degree $x_i$ and a background + degree $y_i$, where $y = \xi d_i$, rounded to an int such that $\xi d_i$ is the expected value, and + $x = d_i - y$. If the sum of community degrees for any community is odd then one of the maximal + community degrees (of that community) is decreased by 1 (and that node's background degree is + increased by 1). + +3. Generate Community (and Background) Graphs + + This step samples, possibly in parallel, each of the community graphs and the global background + graph. Each graph is also individually rewired to remove loops and parallel edges. + +4. Merge + + Finally, we merge all the graphs generated in the previous step and run a final rewiring to fix + and collisions caused by a community and background edge. + + +References +---------- + +- Béla Bollobás. A probabilistic proof of an asymptotic formula for the number of labelled regular graphs. European Journal of Combinatorics, 1(4):311-316, 1980. +- `Bogumił Kamiński, Paweł Prałat, and François Théberge. Artificial Benchmark for Community Detection (ABCD)—Fast random graph model with community structure. Network Science 9(2):153-178 (2021) doi: 10.1017/nws.2020.45 `_ +- `Bogumił Kamiński, Tomasz Olczak, Bartosz Pankratz, Paweł Prałat, and François Théberge. Properties and Performance of the ABCDe Random Graph Model with Community Structure. Big Data Research 30:100348 (2022) doi: 10.1016/j.bdr.2022.100348 `_ diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..27ef30f --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,37 @@ +Artificial Benchmark for Community Detection +============================================ + +Artificial Benchmark for Community Detection. ABCD is a method for +sampling random graphs with known community structure, and is useful +for benchmarking community detection algorithms. The generated graphs +can be have similar properties to those generated by LFR, but ABCD is +much faster and has a noise parameter `xi` in [0,1] that transitions +from disjoint communities to no communities. + +Documentation +------------- + +.. toctree:: + :maxdepth: 1 + :caption: User Guide + + getting_started + how_it_works + benchmark_networkx + benchmark_igraph + benchmark_sknetwork + outliers + overlap + +.. toctree:: + :maxdepth: 1 + :caption: API + + api + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/docs/outliers.ipynb b/docs/outliers.ipynb new file mode 100644 index 0000000..c644d6a --- /dev/null +++ b/docs/outliers.ipynb @@ -0,0 +1,286 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ABCD with Outliers (ABCD+o)\n", + "\n", + "The original ABCD model forced every vertex to be part of a community, but it was later extended to allow for outliers: vertices that do not belong to any communities. This is accomplished by making outliers have their entire degree in the global background graph." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from Fstar import fstar\n", + "from partition_sknetwork import ECG\n", + "\n", + "from abcd_graph import ABCD" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generating ABCD+o Graphs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Outliers can be added to the ABCD model by passing either a number of vertices or a proportion of the vertices to become outliers." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sample has 10 outliers.\n", + "Sample has 100 outliers.\n" + ] + } + ], + "source": [ + "abcd = ABCD(1000, outliers=10)\n", + "sample = abcd.sample()\n", + "print(f\"Sample has {sample.outliers} outliers.\")\n", + "\n", + "abcd = ABCD(1000, outliers=0.1)\n", + "sample = abcd.sample()\n", + "print(f\"Sample has {sample.outliers} outliers.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Detecting Outliers\n", + "\n", + "Most community detection algorithms do not allow outliers, so detecting outliers is typically not supported by networkx, igraph, or sknetwork. However, there are methods for detecting outliers post-hoc by looking at how strongly each vertex belongs to its community. One such method, the particulars of which are beyond the scope of this notebook, is available in the [ECG algorithm](https://github.com/ftheberge/graph-partition-and-measures) that can be pip installed for networkx, igraph, or sknetwork. We will use the sknetwork version because it is slightly faster." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "sparse_adjacency_matrix = sample.to_sparse(matrix=True)\n", + "ground_truth_communities = sample.community_array\n", + "\n", + "ecg = ECG(refuse_score=True)\n", + "communities = ecg.fit_predict(sparse_adjacency_matrix)\n", + "refuse_scores = ecg.refuse_community_ # These scores indicate\n", + "# how strongly a vertex is connected to its community, or how\n", + "# unlikely it is to be an outlier" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "How well does this work? A typical problem with outlier detection is that even if we can rank the vertices by how likely we think they are to be an outlier, there's not a good universal way to pick a decision threshold. Instead, let's look at how good the ordering is. We'll use two method, the number of true outliers found so far and how similar the communities are to the ground truth communities. Comparing communities (or clusterings) is a whole research area with debated methods, but we'll use [F*](https://github.com/ryandewolfe33/fstar), a recent method that was designed with outliers in mind" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "remove_order = np.argsort(refuse_scores)\n", + "n_to_remove = 200\n", + "outliers_found = np.empty(n_to_remove)\n", + "fs = np.empty(n_to_remove)\n", + "for i in range(n_to_remove):\n", + " communities[remove_order[i]] = -1 # Set vertex with next lowest score as outlier\n", + " outliers_found[i] = np.sum((communities == -1) & (ground_truth_communities == -1))\n", + " fs[i] = fstar(communities, ground_truth_communities)\n", + "\n", + "fig, ax1 = plt.subplots()\n", + "ax1.set_xlabel(\"Number of vertices set as outliers\", fontsize=14)\n", + "ax1.set_ylabel(\"F*\", color=\"red\", fontsize=14)\n", + "ax1.plot(np.arange(n_to_remove), fs, color=\"red\")\n", + "ax1.tick_params(axis=\"y\", labelcolor=\"red\")\n", + "plt.grid()\n", + "\n", + "ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis\n", + "ax2.set_ylabel(\n", + " \"Outliers Found\", color=\"blue\", fontsize=14\n", + ") # we already handled the x-label with ax1\n", + "ax2.plot(np.arange(n_to_remove), outliers_found, color=\"blue\")\n", + "ax2.tick_params(axis=\"y\", labelcolor=\"blue\")\n", + "\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These plots show that if we knew that we were looking for 100 vertices then we would do fairly well. Out of the 100 detected outliers, over 90 would be true outliers and we would have almost perfectly detected the communities (F* scores are between 0 and 1, so 0.95 is extremely high).\n", + "\n", + "One way to try and choose a threshold for how many vertices to make outliers is to plot the refusal scores in sorted order and look for a kink or elbow in the plot." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sorted_scores = refuse_scores[remove_order][:n_to_remove]\n", + "plt.plot(np.arange(n_to_remove), sorted_scores, color=\"blue\")\n", + "plt.ylabel(\"Refusal Score\", fontsize=14)\n", + "plt.xlabel(\"Number\", fontsize=14);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looking at this plot it would make sense to pick about 90 vertices to set as outliers." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Benchmarking an algorithm with outliers\n", + "\n", + "Let's suppose that our community detection algorithm sets 10% of vertices to outliers. Of course we encourage you to replace this naive algorithm with a better idea. We benchmark this algorithm use ABCD graphs and F*." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHGCAYAAACIDqqPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZJZJREFUeJzt3Qd4m9X1P/Bjbcny3jM7cfZO2CVhhISUPUvLLKVlBVr6b4ACZZS0paW0/OikLauklBkS9gqFEBKy9473nrJla+v/nGu/imxr2pK1vp/n0WNLeiW/vpat43vPPSfJ6XQ6CQAAACBOyCJ9AgAAAAChhOAGAAAA4gqCGwAAAIgrCG4AAAAgriC4AQAAgLiC4AYAAADiCoIbAAAAiCsIbgAAACCuKCJ9AgDgm81mo48//piOHTsmPr/zzjsxZAAAPiC4AQiS2WymP//5z67rSUlJlJqaSjNmzKC5c+eGdDw5mDn11FOppaWFlixZQhqNBj+vGPT8889TW1sbXXnllVRQUODxmD/96U9ksVhc19VqNRUXF9Npp51GGRkZXp+7u7ubvvrqKyovLxevxVGjRtGsWbMoOzvbdUx1dTW99tprrutKpZLS0tJo3LhxNHPmTNLpdAF9H19//TXt3buXbrrppgC/c4DISEL7BYDgtLe3izebqVOn0tlnn03cwYRnVd5991065ZRTaM2aNZSZmRmSYeXnuuiii2jr1q00Z84c/Khi0NGjR2nChAnidfLAAw/QI4884vE4vV4vAhL+ebOenh7avHkzHT58mFatWkV33HFHv+MdDgf9+te/Fpf8/Hw6+eSTRdCyfft22rVrF11yySX00ksvkVwup/Xr19OiRYvozDPPFMEMP7a1tZW2bdtGlZWV9L3vfY8ef/xxn0EU+8UvfkHPPvusCJYAohoHNwAQuLa2Nu7H5rzpppv63f7GG2+I27///e+HbDh/+9vfiudsaWnBjyhGrVy50pmSkuK85JJLnMXFxU6bzebxuOTkZOeSJUsG3c6Pk8lkzqNHj/a7/cYbb3QqlUrnv/71r0GP+eSTT5yFhYXOnp4ecf2zzz4Tr6Onn3560LEfffSRMycnx1lWVuZsbW31+b089NBDzqKiIr/fM0CkYVkKIEQuvvhiysnJoQ8//LDf7Xv27KFvvvlGLDlMmzZNLDO5e+WVV8R/15dddhkdOHCANmzYQIWFhWKZ4dNPPxXH/PWvfyWtViuWG/i/b8b/fX/55Ze0f/9+UqlUdNJJJ9HkyZMDem7+L/4vf/kLnXHGGeI5OaeHv978+fNp9uzZ0j8+9Mknn9CRI0fELNXpp58+6Hvm8+IZBsazBtJzp6enu44xmUyur8WzT/w9HTp0iMaMGUPnnHMOyWSD9zXY7XbxvR08eFAsn/DSTFFR0aAlu//9739iZoOXcPj5x44dG9DPqrOzU5xHTU2NmC1ZvHhxv2WcoZyzJ3yOzz33HH33u9+l6667TvyM3n//fTr//PMpUOeeey698cYb4vuUvr/33nuP/vnPf9KDDz5I119//aDH8Pfz+eefk0Lh/088zz7yOfI5Pfroo/Tkk09SKPCMEP98eKz5vPl1wa9TgJGA3VIAIcRv8PyGxgwGA11wwQW0YMECWrt2rciL4KUCfuPp6OhwPeb3v/89/d///Z9YXrjxxhvFG+mrr74q3hw4T4Px5xx8cO4N42UBDkQ4oOI3kDfffFMsN/AbqNVq9fvcXV1ddPfdd4s3yQsvvJD+9re/0QcffEDz5s0Tb25Go1G82XFuEQc+HFD9v//3/wZ9v1VVVeK8+LJjxw7xZltSUiKeSyJ9Lb6Ng6ynn35anDOfO+cRcRDljpdKysrK6KqrrhLB1dtvvy2+Pn8fEl564UCOv18O2N566y2aMmUK/fznP/f7M+LvefTo0bRy5UrasmULPfHEEyJPhZdbhnrO3vDPvb6+nm699VZauHChyMn6+9//TsHgc+QAddKkSa7b+Fw5v+b222/3+rjx48cHFNywZcuWiTF4+eWXKRTuv/9+EdD861//ok2bNtH3v/998TPduXNnSJ4fwK9ITx0BxMuy1FdffSVuv/zyy8X1iy++2Jmenu48cOCA65j6+noxrX/ttde6blu4cKEzLy/Ped9997luq6urEx8fffRR8Zz8Nd2deuqpzvz8fGdFRYXrtnfeeUcc++CDD/p97qamJnFsSUmJc/Pmza77HnjgAadarXZed911zo0bN7puf/jhh50KhcJ5/Phxv+PDyyW5ublOq9Uqrktfq7S0VIyR5M033xS3v/baa67bmpubndnZ2c7TTjut3/dsNpud69evF5/z0gk//5lnnuns6upyHfPee++J5/vvf//r9dyqqqrE8s/5558vnlNy2223iaUf6XsO5px9WbZsmfP00093XX/22WfFONbW1g46ls+Ll4Z+//vfi8uqVavEkhT/nP/85z/3O5Z/bqNHj3YGyteylOSiiy4Sx/BrlHV0dLjORbrwsllaWtqg293H6IUXXhDP84c//MF1G/8sZ8yYIcZTWioDCCcENwBDDG5OOukk8Yf9ySefdN5xxx0ir2LMmDHOY8eOOQ8fPiyO+cUvfjHo8b/85S/FG1xnZ6crANHpdK7r7jwFNzt37hS38fMMdPbZZ4vgwOFw+Hxu6c37sssu63f7nj17xO38Rudu//794vYXX3xx0Nc8ePCg86WXXnL+8Y9/FOPBQR8fu2/fvn5f69JLL+33OD7H1NRU5+233z4ox8g94BqIvwYfs2XLlkH3nXzyyWIMvOEx48fyGLrj8dVoNCKoC/acvamsrBQB0+rVq123dXd3OzMyMpyPP/64x+Bm1KhRzhUrVojLrbfe6ly8eLHI0xkYlOj1euesWbOcoQxu+HvnY/jnyTiQ5euBXO6///5+PwMOvOx2e7/n54CQj3311VcDPm+AoULODcAQcS6BtP2W80L+8Y9/0PLly0VuDOe6sNraWrGc0vePhLiNczd46Yp30fBSEuMpfN4tEwjeisuk3Bh3fBsvIzU0NIgdNP6em3Np3OXl5Xm8XXouzlGR8PLXtddeS6+//rrIp+Cvw7kv0tJZY2Njvxwgzjdyx+PG26Ldn5OXm3gpxdP3JuGdY/xYzsnZuHFjv7Hlc+LcIl9jx0uHA8+Fc4Q4n4bzo9wFcs7ecE6MtHT31FNPuW7nr8OvFV4W4+dzx0s37sdKeU0//OEPxTly7g5LSUkRr79Q4qU46bkZlzdYsWJFQFvBeZeghO/nZcSBeUnSz5THmJf6AMIJwQ3AEHFy6MA3IomU98Jv9JyQ647fpPhNwz3pNisrK+Cvy8m2zFM+hXSbdIy/5x4Y9EiP93a7ez4P1275z3/+IxKoOclW8uKLL4ocmIF5KZ4CLH5e99oufN78pugrYZfPgR93/PjxQfdxsravIFF6/oFBhXQu7uMW6Dl7wsnenG/C+TkDAyFOzOaaNp999pnIv/KH84o4Z+eFF15wBTecBM7jznldHISEAgcdXMJACmT584Gvb94Kzvle3l73jMcw0NcmQLgguAEIA05uZWeddRb96Ec/Culzc80Uxruk3IMKtm/fPvGft/QGFU48y8JFBQeeA98+nHHjgIlnX6Qx9HQMz4z95Cc/EcnLwY4dF2HkwMh9ZxXvjuLbli5dSqHAgUdFRYWYRePE3oE4+ZoTiwMJbjiZmAMyrq8k4bo0nBjNu5y8VaxuamoSAQo/3h+ekeGdaTfffLPHwC/YMebX5kD82pTuBwg37JYCCAPePsyzCLxLqbm52eMOmKHiXVK83MPLXfyfu/sb5rp168QbXyBvaMPFO444KOAtyhJeanOvhBss3tbM1XLvu+++frNETHrDvOGGGyg5OVks6wycBeDz2b17t9fnv+aaa8QMAhesc8e7ynhZhp87FDhw4eq/ngIbxkEU73CTlvB84Z8pL2O6b8XnSsfnnXee2B3Gu7gG4uCQlwoHjqEnHNTwjBBv4+eZmeHimSb+WfH3J+Hz4N8FLhLIu/MAwg0zNwBhwluuudrsxIkTxbZmnmXgJQrOFeFtvVJeTrD4v3ie3eA3N966fcUVV4j8C/4vnqvU/upXv6KRwP/l81ZxrpPCQQlvb+ellp/97Gc+tyj7wmPEwdHVV18ttk3zFmUO1HhLOC/xPPzww+IYrtzMY8rLMxwocM4TL//x1+fAaPr06R6fn3NaeEmIl3l4ZoXr2HAwxF+THxeKmRvONeIt4D/4wQ+8HsNfh4MzXsK76667XLfzOUlLPlL+0L///W+Rw8LVjd1fA1z7hpc3eXaQfwb8s+fAjWfOePs8B9gDl4e4UjEHSrxsxjNBnL/00Ucficc/88wzIsAZLq6kzLlQHIBxTha3kOAAjXPNeJz5ZwUQbghuAILESbP8psJvJr5w4ilP9/MbLte44Td/TtTlZSr3hF1+k/ZWj4Rro/DX4q/pjvtY8ZsFJ/Pyf8n8hrF69Wrxpum+rODtuTnpmZ93YC8s6Xvj2SF3XHyNb+fzkXDOEJf559oovKTDyw38BszLIXwsv6n5+lqMZ5kGtqrg74Gfj//z5++RvzeepeJATsJv6JzMzW/inMDKS008U8E1a9yL8XkLyvjNnPOCOOGbz4vP2z0gCvac3fF5cfDEx3nDPz+uG8TJzZLbbrtNfB/8eMY/N05o5uDDUwFFPkeuT8SzN1yPhx/HAREX/eN6Q+7fD/8spORgPo6/Lufq8EwWB3tc4ybQPDN/OBjlwJ2DeK6rxDNiXOfm0ksvFUUuAUYCeksBAABAXEHODQAAAMQVBDcAAAAQVxDcAAAAQFxBcAMAAABxBcENAAAAxBUENwAAABBXEq7ODRev4toWXKJ+uGXGAQAAYGRwvzouWMrFJn31n0vI4IYDm2D70QAAAEB0qKqqchUJjdrghnvscDXL3Nxc+ulPfxpwUzoux85N+7jqJVf7DBTP2EiDE6puugAAABBe3EuPJyek9/GoDG64vwmXr+dlIi4zzg3wAglu7r33XvrLX/5Ct9xyC9XX14uS7Nxn55JLLgno60pLURzYILgBAACILYGklCgieXLc04R72HDjOO5D4g/3mfnNb34jes5ccMEF4jbuO8NN+vi6t/48AAAAkDgitluKm6sNbM7nD3eW5dmW888/33UbN6erq6ujb775JgxnCQAAALEmpraCHz58mEpLS0VgJBk7dqzrPk+4yy6v07lfAAAAIH7F1DpOT0/PoESi5ORkEex0d3d7fMyqVavo4YcfHqEzBAAA6MW5pFarFcMRIKVS2W/yImGCG71eT+3t7f1u45kYfgF5Sw7mBOQf//jH/Y7HVnAAAAhnPRbe8DLw/Qr8S09Pp/z8/GHXoYup4Gbq1Kn03HPPkclkEtvA2f79+8XHKVOmeHyMWq0WFwAAgJEgBTZc4kSn06FgbIABIa/ANDY2iusFBQUUt8ENL0Px9nBOGl64cCFdeOGFdPfdd9Pzzz8vtoKzZ555hiZNmkQzZ86M9OkCAECC45UEKbDJysqK9OnEFK1WKz5ygMPjN5wlqogGN48//rioGMzbwPkjb+lmTz75JKlUKpEMzMEL17Lh4IZLLj/99NO0YsUKev/996m1tZV27dpF7777LiJjAACIOCnHhmdsIHjSuPE4xmxwM2bMGJErU1ZW1u92aa2Nv0kOZk466STXfTfffDMtXryY/ve//4nlpiVLliA6BgCAqILehZEdt4gGN1dffbXP+3n2RprNcTdu3DhxAQAAAIipnBsAAAAYGbfffrvYsDMQdwCQugIwbpvEqSGcUsI7kEePHk1nn302zZo1a1CS8EcffURffPGFSCPh1BLOj126dGnItnzHRRE/AAAACI/nnntObOThVBD3i3sHbs6P5RzYW2+9VSwhTZ48mZqamkTKyMqVKwcd9/3vf1/kz/BuZ4vFQv/4xz/EY9ra2sL6Y8TMDQAAAAjc0JoDEk94JoabVPOOsD179ojacwP7P0rHXXzxxaJB9r59+wYdV15eHvYSLQhuYoTN7iC700l2h5NsDifZ7b0fHU736w5SKWSUolaSXqMguSw0iVkAAACff/45bdq0iT788MNBAQubOHGi+Lh+/XravHmzWJLydBwvY4UbgpsQ6jLbqKLF6ApAHFIg4vroILuDxEfX7XbngKDFMSho4fudzuDOhRPOtUq5CHL0agWliI9K1+e91xWkkGNlEgAgnHgmo8dqj8gga5XyoHYgvfzyy7Rjx45+t3F9OV5W2rhxo7h+6qmn+nyOr7/+Wnw85ZRTKFIQ3IRQU6eZPtzbQNGAg6Fui11cGsns9TitSu4W/PRdOPjpm/3h25UIgAAAhowDmykPfhCREdz3yBLSqRRBlWhxL7/C0tLSxEdOHuZ+jv5q+Hg67uDBg/TEE0+4rt94441hDX4Q3CS4HotdXDgw80atlFGKRkkpbsFPv4BIoyC1IryZ7wAAENmcm9zcXDIajWLnU2ZmptfnkI7jpOGMjAxxG9e0k4ImTj4+7bTTENzACbzU1Wm2kaHHSgYTX9w+77GJ5SidSi4i9d6Pckp2fa4gnbr3NpVcFvBUpdnqILPVTM0+AiCR66NRiK/FwZBGISeNki8yEfjwR76udruOgAgAEgEvDfEMSqS+dqjwdm+2du1auu6667wed9ZZZ4mP69atE+2TpF5RUtDEwU24YeYmynCuTRcHLB4CF/7IeT3+8m86TTYOSXwew8nG/QOf/sEPf57c91EpT/IbCFlsDmrpslALWQL+Xvkc1Iq+oKfvowh6+KNC7hYkDTxGjmRpAIgZ/PczmKWhaDV9+nRRfPe+++4T27zduwvwLM2GDRto+fLlNGPGDLrqqqvE1nA+Zv78+a7jeKfVSIj90Y7B4MUoZl6kAOZE4MKBDAcvDj/BizwpiVK0CkrVKClVo6BULX9UUqpWQUmURN0WGxlFvo2Nus29eTfSbbwEZeGdVzwDZLL1BUK+KaRASN0bCHGeTrL7bJDbfcHk5/A5SHlBweKZIg52egOhE0EP36aSLnLZoOvun6M8OgCA/4RiTiC+4YYbxOf//Oc/RX/H2bNni9u5MF9lZSVVVFTQAw884HrMv/71L5GIfPrpp4vCfePHjxcFAjnZ+IwzzugX8IRDkpPTuBMIJzpxclRHR4dYAwyl481GenNbtQgiBs64SJ93mqx+gxfewZ3SF6z0Bi19QUzf5zyjMpw3Zqvd4Qp4xEeznYzS566PvZ9b7cG9PDjwksuTREDEMzMnPsoGXO89zut97re7jvN9PF8CHRc+zHMAJB8UDKk9BUduj0WQBAASfgM/fvy4SMzVaDQxNTDPP/+8q/HnwC3eHJC4a2hoEIFKZ2cnjRo1iubMmSOSiAfiAn+8fZzzdPLz82nChAlibIYyfsG8fyO4CZEP9tbTY+v2UW2HScxIBBK8cI6KNOOSxtf7ghieBZGFqHnYcPFy08CAhz9yMMSzQOJzc+9tvHU90ngJjccvxW3Xl0h8Fp+HPvmZf0w8WyUFPryExlvupcA0xW1mje8HgPgWy8FNNAhVcINlqRDhGYuqth7XGx6/kYo3t743ubS+Nzi+rlcpSBbiAnsZOiUVpGvFm6zJaieTjZegHOJz3obIQcpQ9M5SqChd57+OA8/y8Nfl4K5/scHeZbAT9X7cPzoGFSYcdLunx/QdOzCg4nNo77aKi9fvSS4bFPC4b31PCaL+D8978tiK8XWlOQ3uzcJ4OS/V04wcgh8AgJBCcBMic0dl0O+vmEm7qjvEzEE4qwNzwJGXqqHCNA3lp2moIE0r3jj97bLqDXg48OkLeix2MtvsZLI6+m4/cb+57/5AZ2N4aUalSBrx2QkOqvgUpaCHgwzOWxL5RGabSM7mpUDpNjMHInYHtRgt4uINz8C4Ah4pAHILgvRD+BlL2+4bDN6+ptxr4MO3Y3cZAEBgENyESEayimaVZlB5S3fon1unpPw0LRWm9wYz2cnqoGd++Pje5F9F0Pk50uwPbwmXPjf1+1y6OMTxUrDDZyitrvV+ntTvOl+Rvgu+na/1fux/Gw18DvfndXsc44rPrUaLCGY8ORH8nAh4+OJ+m5iBEt+fmZq6vO864wRqqdaPVAeot/pz73IU3x9MPo40jo0Gs9fg58QyV//Ahz/y/QAAgOAm6gxlViacOJ+EL/yGHUs4SGjuMvduTzeaqbnLIoIelqlQUWayyutMEM/uDAx4xHVpNshs67fTq8HLtnteqnTN+PTlV7kHP8Esf0nfE1+8FVzkrfPSEmiGjpcS+z5PVokADAAgUeAvXoSFYlYGBuNZjOIMnbi448CktctCzca+wIcDIKPFlZPEMy3StvKcFLXPPjEnAiAp8LG6ZoI4yZp7gnX0WMXF3+zPwMBHuh7MbiyeWWvi2SYPwQ8HzRzocMCTru0NfHovCHwAIP4guInArEyBmJGJ/KxMIpL6Z5Vm6foFK1wwUQp0+CPP9LQZLR5zjqSCXHzJ8/J1eGaHAxwOdLgMQG/QY+133eY+++NlKYp3f7lmejwEQYEmp3PwxkGPv8CHZ3zcP+f8MQAInsMxtE0cic4RonHDX64w4jcIDmBEIJOOWZloxcEKv6HzZWxO/yTs9h6rK9hp6Zvt4Z1YXIzRF042FjkxWiUVkXbQ/RxQcV4PBzwGt8DHPfjh2SHO/+HlNGlJbfC59wZsUsDDuThZyWoxC8ifBzLrE0jgIy1zSbM96VxvCYEPwODfGZWKZDIZ1dbWUk5OjriOWlj+8d9Ei8Ui6uLw+PG4DQfq3IRQo8FEhxu7+nJlNHFRbhsGs9kd1NrNMzyWfjk9HKCEsiQmfx2pjxh/7OzpW/oSH/0XhOQdXzxTmN934c9DOVPIgY+0zMXLq2l9gU+2XoWdXZDQ+E26rq6OurtDv8Ek3ul0OtGHylNwgyJ+EapQDImNt9W3Ga2DlqGkxGRefgpl8MOzR/yc7stdXAW7sdNEzZ0WkfMzEM/C5KWqXcFOboo6qKTmQHAByuwUFRWma6konfPJtEhohoScibDZbCPWSykeyOVyUii8zzgjuPEBwQ1ECufhSE1RT2xD7/2cl6b4Pt4NFQpc84dnkxo6TFRvMFGDwURtHgobcrpOtl7tmuHhwId3koV6Gp2DqhPBjiYsXwMA4psB7RdCMzgAI43zXwbW4Bk4AxRsvy8JF2bsDXTMItjhzz01LeUKzrluszv8kbe0hxLvRuMghwMevvDXCGfhSwCIfQhuQjQ4ANGIZ3ekpa/eCswc+PQmJov8nAA6vUvT5py7c2J2pzfo8bRDjJOWeVZHCnY4+AllxWRufirqO/XN7PBHFCUEAHcIbnxAcAPxjgOfiuZuKm8xUlVbt6h/EyjeIcbJ0vUdvUtZHPRw0rSnuSJeWpKWsvhjll4dstkXXrHKSu7N25EuvLQFAInLgGWp0AwOQKzjYKXOYKKKZqNoDcLJxsEmNXNLDW4JIQU7fPE0O8SBDScol2TqaHphWsiXsni7+4lgR0M5ejXydgASiAHBTWgGByDedFtsVNHSTRUtRvHRU85NILhAYUOniRo6zK6EZW5bIeEJnHE5eppZki5aiYQjeZi3ooslLFHhWytKMHCrEACITwhuQjQ4APGMc24aO81U3twb6NR1mPwWJ/T1XFzwsK7dRPvqDFTT3uO6j2dYZpak0aS8lJBvO/c0czQ+V08zitNHvEM9AIQXgpsQDQ5AoiUqV7Vyrk7vzE6gicmecLXjndXtdKC+U2yBZxqFjKYWpdGMojRRuTmcOBl5dmk6zSpJR2IyQJxAcBOiwQFIZNxVnYOc8uZuqm3v8biLyh9uIbG3toN2VXe4giVeoBqbk0wzi9OpOEMb1rwZ7pQ+qzidZpdmoI8bQIxDcBOiwQGAE0nFPKvDy1e8C4v7awWDl7uONxtpZ1U7VbWdWLLiHVEzitNockFqWPNleIlqelEazR2VgZ5YADEKwU2IBgcAPGvvtriWr6rbekTxwUBxI9Kd1R10oN7gKkjIwcfUglQR6HB/qnDhLuu8NDZvVIZoNAoAsQPBTYgGBwD845yamrYeMaPDwQ63fQi0YjInH3Og09FzYiZodJZO5MqUZurCtmTFycdTClJp/phM1M8BiBEIbkI0OAAQPF5++uxAY7+Axd9OK54F4gRkXvaScMdxzsuZXJASti7j3OSzrCCFFozOpIzk8M0YAcDwIbgJ0eAAwNBzdDYfb6WtFW2u3VKBaOu20K6qDjGjY7E7XL2uOMDhQCdcAQgHORPz9GImhxuJAkD0QXATosEBgOHh/JpPDjSKZatgcA7PfrFk1d6vmzkvVXHNnDFZyWFZskrqKz64cEwm5aZqQv78ADB0CG5CNDgAEBq8HfyLw83UE2RFZF6yqmzlJasOsdwl4T5TnHzMSchqZXiWrHi7+oIxmVSQpg3L8wNAcBDchGhwACC0RQI5wOFAZyiFkDmHZ1d1O+2tNbhaPXA38bK+JatwLSfxbNHCsZlUnKELy/MDQGAQ3IRocAAg9LggIC9VNXeah5zPw5WPuWZOi/HEziwuCMhBztjsZJKFqDu5u6IMrViuGpWVHPLnBgD/ENyEaHAAIHzdyrdVttGm461B1cgZuGTFPax2VLXTsSYjOd26h88tzaApheEpDFiQphHLVWNz9CF/bgDwDsFNiAYHAMLLYLKKbeMcnAz3eXZXd9Ce2g4yWXuDJa1STrNK02lmUVpY8nJyU9ViJocTkMPZQgIAeiG48QHBDUD0OdLYResPNg6rWSez2R20t85A2yrayND3XLyVfHpxGs0uSQ9L64VsvUpsIeeu5whyAMIHwU2IBgcARg4vT319rIW2V7aLXlTDwbV1Djd00paKNldejlSVmPtL8W6rUMvQKUWQMzk/NSw5PwCJzhDE+3eSkxeuEwiCG4Do1tRppk8PNFBtu2nYz8V/3ngLOQc5dR29z8dhx8S8FJo3OiMsO6zy0zR04axC0qlCP0sEkMgMCG5CMzgAEBkclOypMdCXR5rFFvJQPB8nH28pb6OK1hMtHsZkJ4smmoXpoa1lw60jLp5dFNYmoACJxoDgJjSDAwCR1W2x0f8ONYtqxaHSaDCJmZzDjV2u2wrTNTR/FG/zDl2zTp1KThfOKhIzOQAwfAhuQjQ4ABAdqlq76dMDjdTqVtdmuLiPFfe+4sBJan+Vo1eL5arxuXrRb2q4VAoZLZteIGaIAGB4ENyEaHAAIHpwkvCW8lb6pryVrPbQpQp2mWy0raqN9tR0uJ6XE4458Zgbdipkw6uVw0HSWZNzaVpRWojOGCAxGbAsFZrBAYDo09FtpU8PNlB584ncmVDosdpF1WO+mPoKCyar5DS7NIOmF6WJWZjhOGVcFi0cmxWiswVIPAYEN6EZHACIXocaOunzg03UZR5ebRxP7R14FmdbZbvrudUKmWjtMKsknbSqoRcE5GafiyblYqs4wBAguAnR4ABAdDPb7PTV0RbaVdUx7No4npbBDtQbRPJxe7fV1aiTl5fmlKZTimZotXLG5epp6bT8sLSGAIhnBszchGZwACA28A4obsZZ31fLJpQ4aDra2CWCnMa+Zp9co29SfgrNG5VJmcnBb/fm3Vm8k0oThrYQAPEKwU2IBgcAYgfXstlZ3UEbj7aEpDaOp+evbO0WQU51W4/r9nE5yTR/dCblpQa35ZuDootmF4WlWjJAPEJwE6LBAYDYbOPADTS5v9Rwe1V5U9fRWxDwWPOJhp8lmVpRK6c4QxtwrRy9WkEXzi6k3BTUwgHwB8FNiAYHAGKXw+GkQ42dIgjhlg7h0NJlFrVyDjR0kpTyk5+qoSVT8wKuTsy7sL49o5BKs3RhOUeAeIHgJkSDAwDxoaLFKIKQipbQbh+XGHqstK2yjfbUGkQiMi81XT63OOAu5NzU89ypeVSWj79JAN4guPEBwQ1A4mrsNInlqoP1XSHfXSUVBHxtWzV19FhFteNL5xaRWhFY0jCvZJ02Ppvmjc4M+XkBxINg3r+xFxEAEgbntpw3rYBuOG00zRmVMezCfAPpNQq6aFYhaZVyauoy07pddWRz9BYE9IdjrS8ON9P6g40ieRkAhg7BDQAknFSNkr41MYduOm0MnTo+m5LVoduSzbk2HOAo5UliV9WHexuCmiXaXtlO7+6uJ5s9sKAIAAZDcAMACYvrzCwYk0k3njqGzpmSN6SaNZ7kpmpo+YxCUQ+Hu49/fqgpqNkYrr785vaasGxpB0gECG4AIOEp5DJRefjak0fRBbMKqShDO+wxKc3U0ZKp+eLzXdUd9E15W1CP51mfV7dUUaeptzoyAAQOwQ0AQB+uTzMuR09XzCuhqxaU0IQ8vUj0HaqJeSli+YttPNYielYFo7nLQq98U0XNXeHZyg4QrxDcAAB4UJCmFUtL158yWjS85L5SQ8HNNuePzhCff3qgkY42dQX1eC5E+N8tVVTdFp5t7ADxCMENAICfBOGzJufRTaePoYVjM4fUFfzksVk0pSCVOOvmvT31VOPWviEQZquD3txWQ4cbOvGzAggAghsAgADoVAo6ZVy22GG1qCw3qJ5QvNx1VlkujclOFkX+1u6qDXqpyeZw0ju762hHVTt+XgDRHNxwQZ4f//jHNHPmTFq4cCE9+eST5PBTE2LHjh10zTXX0OzZs8Vj7rzzTqqrqxuxcwaAxKaUy8RSEy9XnT+jgPLTAusLJZMl0dJp+VSQpiGzzUFv7agRlY2DwRuuPjvQSF8cDm73FUCiSXJG8Ddk8eLF1N7eLoKatrY2+v73v0+33HILPf744x6Pr66upqlTp9Kll15Kd9xxB3V1ddHKlSvFc+zduzegr4kKxQAQalWt3aK9Q3mL0dVjyhve3v3a1mpqMVooQ8dtGkqGtNQ1uSCFzpmSL1o3ACQCQxAViiMW3Kxfv54WLVpEe/bsEQEL++tf/0orVqygxsZGjyf++uuv02WXXSa+wZSUFHHbRx99ROeeey7V1NRQYWGh36+L4AYAwoWXmj4/2ESVrb6Tf3l793+3VFOX2SYabV4yp0jMCAVrVJZOzB4F2uIBIJbFRPsFDm6KiopcgQ1btmwZmc1m2rhxo8fHzJ8/n3Q6Hb399tviut1up7Vr19KUKVMoLy9vxM4dAMCTbL2als8soHSd73ycFI2SLp5dRBqFjOoNJpFLw7k4weJGoDwLZDTb8AMBiIbgpqqqivLzewtcSaTrvPzkSWlpKX3yySd0zz33iGOzsrJow4YN4ja53PN/LhwscbTnfgEACBeeReHZFH9bx7kaMhcM5OM4SPl4f8OQ8mgaDWZRC6fNaBnGWQPEl4gFN5w4rFT2/++GAxSZTCZmZDypra2lK6+8kpYuXUrvvPOOmMHhmRxOMPaWiLxq1SoxjSVdSkpKwvL9AAC4N+g8c1JuQLV0lk0vEIUCD9R30oYjLUMaRO5C/sqWKqrrCG6LOUC8ilhwk52dTS0t/X+ROamYgxS+zxPOybFarfTss8/S3Llz6YwzzqAXXniBPv30U5F748m9994r1uekC88YAQCE2/TiNJH06w9vDz97cu+y+tbKNtpWGVybBkmPxU6vb62m483GIT0eIJ5ELLjh/JmjR4+K5GHJl19+KT7OmzfP42N6enpEEhHP7kgyMnorfxqNnn+h1Wq1eIz7BQBgJCwuy6Msvf9mnFzg79TxWeLzLw4304H6oS2fW+1O+mhfPVnRURwSXMSCm+XLl1NBQQHdd999ZLPZxKzKY489JpKKObeGdXZ20vjx4+mNN94Q188++2w6dOgQrV69Wlzn5atHHnmE9Ho9nXzyyZH6VgAAPFIpZHT+9ALx0Z+5pRmifg77aF8DVbQMbQbGaLbTrmoU+oPEFrHghnNleKfTV199RZmZmZSbm0vp6en03HPPuY7h4IVnd6QkYN7y/dRTT4kaNzk5OWLWZt26dfTqq6+KQAkAINpk6dW0uCw3oCrGZ0zIpol5euKNU7yDqr7DNKSvuaW8jSw23wVRAeJZRIv4SbjCMC8fcZDjjvNvjh07JrZ5S3VtJLycxY/hJOFgoM4NAETCx/saaHcAXcF5S/jbO2tFrRytUk6Xzy2mjGT/S1sDnTYhm+aP7v83FSCWxUSdG3c86zIwsGGcW8PLUgMDG8YzPcEGNgAAkXLmpBzKTVX7PY4rDvNSVm6KmnqsdnpzR40o9hcsrphstnneeQoQ76IiuAEAiHcKeW/+jVrp/88u5+hcOKuQ0rVK6jTZRB8qs9Ue9O6pHZXIvYHEhOAGAGCEpOtUdO6UvIC7kF80u4h0Kjm1dFlo7a46sgW5C2pbZbvoZQWQaBDcAACMoPG5KTS7tHdXlD9pWiVdNKuIVHIZ1bT30Pt768kRRJokBzbbMXsDCQjBDQDACDt9Qg4VpGkCOjYnRU3fnllA8qQkOtpkpM8ONAbVpmF7VRtmbyDhILgBABhhnDS8bEYBaVWBdfMuztDRkmm9y1l7ag206XhrwF/LbHXQtoqhVT0GiFUIbgAAIiBVo6QlU/NFX6lATMhNoUWTcsTnHNwEU6hve1W7SDAGSBQIbgAAIoT7SgVTi2ZGcTotHNN7/GcHm+hwQ2dAj+OCflsqAp/tAYh1CG4AACLo5LFZVJyhDfh4Dm6mFfUWMPtgbwNVt3UH9Lhd1R3UbQm+Xg5ALEJwAwAQQTLOv5leQMnqwPJvuE3Dokm5NC4nmexOJ63dWUdNneaAZm++KUfuDSQGBDcAABGWrFbQ0mkFJAswAYePO29qPhWla8lid4gifx09Vr+P213dTsYhVDsGiDUIbgAAokBJpo5OGpsZVMXjb88ooCy9irotdnpze43fZSer3Umby5F7A/EPwQ0AQJRYMCaTRmfrAj5erZSLIn8pGoWYuVmzo9ZvN/A91R3UafI/ywMQyxDcAABECc6nOW9qgQhWAqVXK+ji2UWig3hjp5ne2V0nOot7Y3M46RvM3kCcQ3ADABBFuLAfJxhzob9AZehUdMHMQlLKk6iytZs2Hm3xefyeGgMZMHsDcQzBDQBAlClM19Kp47ODekx+mobOnZIvPt9Z3e4z/4ZndjYfQ+4NxC8ENwAAUWjuqAwan6sP6jG8PTw3RS2WnnZU+a5gvK/OENAOK4BYhOAGACBKnTMlj9J1yqBydqSKxzurOshstfucvdl0zPfyFUCsQnADABClNEo5nT+9gBRB5N/w7E1WskrUv9lZ3eHz2P11ndTebQnBmQJEFwQ3AABRLDdVQ9/qa5gZ6OzNvNEZ4vPtVW1ktXvfGu5wOulr5N5AHEJwAwAQ5bhh5uSClICPn5ibQmlaJZmsDtpd43v25mB9J7UZMXsD8QXBDQBADFhclieqEQfar2reqN7Zm22VbWRz+Ju9Qe4NxBcENwAAMUClkIn8G65lE4iyghRR4M9ottP+2k6fxx5s6KSWLv/NNwFiBYIbAIAYkaVXixmcQChkMppTmi4+31LRSg4fVYudTkLuDcQVBDcAADFkSmEqTStKC+hYPo7bMhhMNjE748vhxk5q6sTsDcQHBDcAADFm0aQcyklR+z1OKZfRbGn2pryNnDxF43P2Brk3EB8Q3AAAxBiFXEbLZxSIPBx/ZhSnieNauy10pKnL57FHm7qo0WAK4ZkCRAaCGwCAGJSuU9G5U/zn36gVcppV3Dt7800AszcbMXsDcQDBDQBAjJqQl0Kz+padfJlVki6qHHNOTUVLt89jjzUZqQGzNxDjENwAAMSwMybkUEGaxucxWpWcphf3JiFvLm/1OXvDNh5F7g3ENgQ3AAAxTC5LomUzCkQfKl/mlGaQPCmJ6jpMVNPe4/PY481GquvwfQxANENwAwAQ41I1SjpvWj4l+ajvxwX9eBu5lHvjD2ZvIJYhuAEAiANjspNp3qhMn8fMHZUhAqDK1m6q95NXw7k5/mZ4AKIVghsAgDhxyrgsKs7Qer2fm2mW5fU24PzmeKvf58PsDcQqBDcAAHGCG2YuKsv1ecy80b2zO8eajdTsp59UVWu3uADEGgQ3AABxJFuvptHZOq/3ZyaraHyuXnz+TXkAszeoewMxCMENAECcmVvqO/dm/ugM8fFwQxe1d1t8HlvT1kOVfmrjAEQbBDcAAHGmNEtHuanee0/lpmhodJaOuNrNlooAdk4daw7xGQKEF4IbAIA4xDujfJnfl3uzv85AnSarz2Nr201U3mwM6fkBhBOCGwCAODQxN4VStUqv9xema6k4XUsOJ9HWgGZvULUYYgeCGwCAON05NdtP36n5Y3pnb/bUGshotvk8tr7DJLqGA8QCBDcAAHFqWmEaqZXe/8yXZGgpL1VNdoeTtle1+32+r4+1+O1LBRANENwAAMQplUJGM4q8z94kJSXRgr7cm93VHWSy2n0+X6PBjNkbiAkIbgAA4tis0nTRXNNX24YsvYosdgftDGD2ZuMx/13FASINwQ0AQBzjhpll+b0tF7zN3szv60m1o6qdLDaHz+dr7jTT4Ubk3kB0Q3ADABDnpIaZ3kzI01O6Vkkmm4N213T4fb5NyL2BKIfgBgAgzmXp1WL5yRtZUhLN66tavK2yjWx2P7M3XRY62NAZ8vMECBUENwAACWBOqe+ifmX5qWIJq9tip711Br/Pt+lYKzm4SA5AFEJwAwCQAEoydZSfpvF6Pycdz+urasxF/Xh7uC+tRgsdqMfsDUQnBDcAAAnCX0uGqYWppFPJqdNko4MBBC6bjrdg9gaiEoIbAIAEMT5HT2k+WjIo5DJXVeNvKlrJ4WfLd3u3lfYFsIQFMNIQ3AAAJIhAWjJw0T+1QiYClyMBbPnefBy5NxB9ENwAACSQqYVppFHKfVY1nlXSN3tT7r9gX0ePlfbWYvYGoguCGwCABMLBy8ziNJ/HcHCjlCeJLd/HW4x+n3NzeavfBGSAkYTgBgAgAVsyKHy0ZOCZHakn1TfH2/zO3hh6rLQngOJ/ACMFwQ0AQILRqRQ0uSDV5zGcm8Pbw+sNJqpu6/H7nLyE5a/4H8BIQXADAJCA5vhpyZCsVoit4dKykz+8fTyQ1g0AIwHBDQBAAspMVvlsySDVxeHVK565qevwP3uzpbyNrJi9gSiA4AYAIEHNG93bDdybVI1StGWQtnz702W20a5qzN5A5CG4AQBIUEXpWirw0ZKBcUNNXr0qb+mmpk6z3+fcXuk/ARkg3BDcAAAkMH8tGTJ0KpqQq3clDQeSe1PXYQrZ+QEMBYIbAIAENj5XT+k67y0Z3JevDjd2iYaZ/vBxAJGE4AYAIIElJSXRnFLfszc5KWpX8vGWCv+zN4G0bQAIJwQ3AAAJbkphKmlV3lsysAV9szcH6jtF0T5f+P56LE1BBCG4AQBIcEo5t2Tw3VAzP01DJRla4lzhLRVtfp/zcGNnCM8QIAaDm6amJjIYgmu8ZrPZqLGxMWznBACQSKR+Ur7M75u92VdnIKPZ5vNYLE1BwgY3u3btohkzZtDo0aMpOzubli1bRi0tLX6Dmp/97GeUlZUlHjtmzBh66623RuycAQDiES9L+WvJUJzRu3Wcm2Ruq/Q9e9PebaVGA3ZNQYIFNz09PbR8+XKaO3cutbW1UUNDg7jccMMNPh/3ox/9iFavXk1ffvkl1dfX0+bNm2n//v0jdt4AAPFqrp+WDJx8LM3ecKuFHqvd5/Nh1xQkXHCzbt06qqmpoV/96lekUqkoIyODHnjgAVq7di1VVVV5fMyBAwfo2WefpT/84Q80ffp0cVtOTg7de++9I3z2AADxJ12nonE5vTVtvBmdpaMcvZqsdiftqGz3eezhBuTdQIIFN9988w2NGzeO8vLyXLeddtpp4uOWLVs8Pub9998ntVpN559/PnV1dYkZHwAACB2uSOxL7+xN7zE7q9vJbPM+e9PWbQ2oqjFA3AQ3nETMeTPuMjMzSSaTifs84Rmd4uJi+ulPf0pFRUUiV4cva9as8fp1zGazSFZ2vwAAgGcFaVrRlsGXcbl6ytApyWxz+O0lhV1TkFDBDQcxnBzszm63k8PhILlc7vU/hqNHj5LFYhGJx+3t7XTzzTfTlVdeSYcPH/b4mFWrVlFaWprrUlJSEpbvBwAgXszx05JBlpTkqlq8vbLdZydw7JqChApueAaGE4LdSdd5VsbbY9j9999PCoVCBDsrV64UTdrWr1/v8TGcj9PR0eG6eMvnAQCAXuNyksXMjC+T8lIoVaMQScV7a73PiLd0WailC0tTkCDBzZlnnknV1dW0b9++fjk1nFx88skni+s8i1NeXi7ya9jixYvFRw5SJEajUcwApaSkePw6nKOTmpra7wIAAN7xP45zR/XOzHgjl/ExvTM8WyvaxPZwb7BrChIquDnjjDPouuuuow0bNohdUvfddx/dddddYvmIcX4M17F57bXXxHWua3P55ZfTD37wA/rqq69o27Zt9L3vfU8sNZ133nmR+lYAAOLO5IIU0vlpyTClIJWSVXLqMttof5332RsEN5AwwQ3/Z8CJwCeddJIIVh566CG655576PHHHz9xcjIZjRo1ivT6E1sTX3jhBVq0aJGod3PTTTeJ3VZffPEFpaf7Lh0OAACBU3BLhpJ0v8dITTe5JYPDy+xNc6eZ2gLoJg4QKklOTlhJIDwbxDNDvLSFJSoAAO96LHb6x5fHRE0bbyw2B/1rw3Ey2Ry0ZGoeleV7Xvo/dXw2LRjje6kLIFTv31HRWwoAAKKzJcPUwt40AW9UChnNKu2d4dlS3iY2eHiCLeEwkhDcAACAV7zsxFu/feGO4iq5jFqMFjrWbPR4TKPBTB3dVow0jAgENwAA4FWaTknjc323ZNAo5TSjuHeGZ/PxVszeQMQhuAEAAJ+kLd++zC5NJ4UsiRo7zVTZ2u3xGOyagpGC4AYAAHzKT9NQUYbvlgw6lYKmFaW5dk55Ut9hIoMJS1MQfghuAADAr3mBzN70bR2vbuuhLlP/9jqSww29RVkBwgnBDQAA+DUmO5my9Cqfx6RqlVSQpvG5O+pwg+fbAUIJwQ0AAARUeFUq2OfLxLzeVjiHvMzQ1BtM1ImlKQgzBDcAABCQsvwUSlb7bskwoW9nFQcxhp7B+TVcBgeJxRBuCG4AACAg3G5hVonv2ZtktYKK+5KPD3lZmjqCvBsIMwQ3AAAQMK5nw1WJfZmY63tpqrajRzTbBIiK4Kazs5Nqa2vF583NzeICAACJgwv2TS303deHi/5xUeMmbpjZbfG4NHWkEbumIEqCm/LycrrzzjvF5z//+c9p9+7d4TovAACIUrP9tGTgnlSlGTrx+SEvu6OwawqiJriZPn06lZaW0rPPPks9PT20aNGi8J0ZAABEpTStkibk6QPaNeWtrk1tu4m6LViagggHN2vWrKGLLrqIdu3aRTfffDMdPXpUXH/uuefCdGoAABCrRf3G5SSTPClJNNNs7jIPut/hdGJpCsJGEeiB55xzDi1cuJDefvttslqtdO6559JNN91EycnJ4Ts7AACISrmpGirJ1FGVlz5SaqWcRmXpRJdwnr3J1qsHHcO3zyjurWoMEJGZG51OR2lpafTvf/+b3n//ffr0009JoVBQSkrv1CMAACQWfw01paWrgw2dHjuFc5uGHos9bOcHiSuonJsDBw7QihUrSKvV0v3334+EYgCABG/JkO2jJcPYbL3oFN7RYxU7pzwtTR1twq4piGBwY7fbRULxJZdcIq4vXrwYCcUAAAlujo/ZG66HMzo72WfNG289qABGJLj5/e9/TytXrnRd//jjj+n1118f1hcHAIDYVpafSnq19/TNiX1LU1yt2NPSVFVrD5msWJqCKKlQvGPHDtq4cWNozwYAAGKKXJZEs0u9JwWPyUompTyJOk020W9qILsDS1MQemi/AAAAwzKtyHtLBu5HNTZH73NpCtWKIdQQ3AAAwLBbMnCA483Evk7hXJWYk4gHqmjpJrMNS1MQgTo37PPPP6d77rlHfL5lyxYyGo2u65IzzzyTli9fHsJTBACAaMdLUzsq2z0GL6VZOlIrZGS02Km2vYeK+1ozuC9NHWsy0uQC3z2rAEIe3GRnZ4uWC1zjxt3A6wUFBQhuAAASTKpGSZPy9bS/bvDuJ4VMRuNy9LSvziCWpgYGN+xwYxeCGxj54Ob6668XFwAAAG/bwj0FN9KuKQ5uOL/mzIk5JJP1b7xZ0Wwki83hNXcHIBh4FQEAQEjkpmhEywVPSjJ0pFXKqcdqp6q2wS0bbA4nHW824icBIYHgBgAAQmZOqeeifjxTM74vsRgF/SDcENwAAEDI8MyNt6J+UkE/brnAScQDlTcbyWp34KcBw4bgBgAAQiYpKYkm5XtuqFyYrqVklZzMNgdVtA5egrLanSLAARguBDcAABBSZV6CG1lSEk3ITfGzNIVGmjB8CG4AACCkclM1lOWlW/jE/N6lqWNNXWTzsATFScWebgcIBoIbAAAIS0NNT/JTNZSiUYglqOMtg5egeDt4uYfbAYKB4AYAAEKO826S+peyceXkTOxbmjrsbWnKy+0AgUJwAwAAIZemVVJhmtbjfRP6dk3xEhTP1Ax0DEtTMEwIbgAAICy87ZrKTVGL4Mdb4T4OeCpaBxf6AwgUghsAAAiLiXkpJB/QZsG1NNU3e3OowXO7BixNwXAguAEAgLDQquRe2zFw4MMqWrrJbLUPuv9Ys+dCfwCBQHADAAAjvmsqW6+mzGQV2Z1OOto0eGnKbHVQJZamYIgQ3AAAQNiMzUn22unbtTTV6G1pyvPtAP4guAEAgLBRymU0Lqc3iPG2NMUzND0WT0tTRnJgaQqGAMENAACE1eQCz7umMnQqyklRk9NJdKRpcG0bDniq2rBrCoKH4AYAAMKqJENHyWq5x/sm5mLXFIQeghsAAAgrmYy3fnuevZFur27rIaPZNuj+o01dWJqCoCG4AQCAsJtc4HnXVKpWKfpNeesI3m2xU017T9jPD+ILghsAAAi7vFSN2Prtid+Cfl52UwF4g+AGAAAi2o5hQl8jzboOE3WarIPuP9LYRU7OOgYIEIIbAAAYEWVeghu9RkFF6VqvbReMZixNQXAQ3AAAwIhI16moIK03v8Zbp/CDXpemBgc9AN4guAEAgBFT5iWxeEKunrjFZmOnmdq7LYPuP4qlKQgCghsAABgxnDwsSxrcKVynUlBxZu/S1CEPszSdJpvIyQEIBIIbAAAYMRzE+OsU7q2nFJamIFAIbgAAYESVeWnHMD6HZ3WImrss1GocvDSFRpoQKAQ3AAAwosZm6z12Ctco5VSaqfNa84aXpuqxNAUBQHADAAAjigObcTnJPpemOLjxVNsGBf0gEAhuAABgxJXle941NTYnmeSyJGrrtorlqYE81cEBGAjBDQAAjDheftKpBncKVyvkNDrL+9JUR4+VGg3YNQW+IbgBAIDIdAr3UrHY/9IUZm/ANwQ3AAAQVe0YxmQnk0KWRAaTjRoM5kH3Y9cU+IPgBgAAIqIgTUvpOuWg25Vymci9YYc8dATnfJzGTixNgXcIbgAAIOoSi08U9PPcEfwIEovBBwQ3AAAQdUtTozJ1pJLLqMtso1oPtW2QdwO+ILgBAICIyUhWUb6HTuEK+YlaOJ52TXEF4+auwfk4AAzBDQAARNQkP7umeGnK4fCwawpLU+AFghsAAIioSXkpHjuFl2TqSKOQUY/VTtXtPYPuP+Ih2RggKoKbiooKevHFF+nVV1+ltra2oB771ltv0V/+8hcyGo1hOz8AAAivZLWCSrO0g27nSsXjc/Vet397a7AJENHg5p///CdNnjyZXnnlFXrqqado/PjxtGnTpoAe+84779A111xDP/rRj4IOigAAILpMyvO8a2pC39LUkcYusntcmsLsDURRcFNXV0e33XYb/e53v6N169bRhg0baOnSpXTDDTf4fWxtbS398Ic/pMcee2xEzhUAAMKLZ2iU8sFLU8UZWtGmwWRzUFVr96D7sWsKoiq4WbNmDclkMrr++utdt91+++20f/9+2rlzp9fHORwO+u53v0s/+clPaPr06SN0tgAAEO5O4WNzepeg3HEujrQ05WnXVFOnmdq7sTQFURLc7N27l8aMGUNa7Yl11ilTprju8+aXv/wlKRQKWrFiRUBfx2w2k8Fg6HcBAIDYqXkj7Zo62mQkm90x6H7M3kDUBDccZKSnp/e7LTU1leRyudcA5Msvv6RnnnmGnn/+eUrykFnvyapVqygtLc11KSkpCcn5AwBAaI3OSiath07hhWka0qsVZLE7qMLT0hS2hEO0BDc8Y9PZ2X+KkXc92e120ul6290PxDk6p556qljS4l1SnKvDXnrpJfrqq688Pubee++ljo4O16WqqioM3w0AAISkU3je4KUp/md2Qp73pakGg4k6eqz4AUDkg5sJEyaIQIODGcnx48fFR9415cny5cspJyeHduzYIS5Hjx51LWPV1NR4fIxarRYzQu4XAACIsV5Tub1LU8eajGT1sDSFmjfgLsnpqSPZCDh48KDYBv7222+LoIWtXLmSnnvuOaqurhZ5NRaLRWwXX7RoEU2aNGnQc3z88cd0zjnniCCpuLg4oK/LS168PMWzOAh0AACizz+/PD5oJobfqp77qpwMJhstnZbvysORFKRp6KoFpSN8pjCSgnn/jtjMDQcrvOPp2muvpQceeMC1LfyPf/yjCGxYd3e3qGOzcePGSJ0mAABEQWIxL01JAY2npal6g4kMJixNQRQU8XviiSdEdWIOYjga4wJ+V1xxRb8lpVtuucXjrA3j2Rq+X68fvEYLAACxqazAy9JUX3BT3tJNZtuJlAbGaxBc6A8gostSkYJlKQCA6PfvTRXUaOjf9Zvfrl78uoLauq107pQ8mjwgCCpK19IV87EjNl7FxLIUAABAMInF/pamajt6qMtsw6ACghsAAIg+k/JTyFM5Mym4qWztJpMVS1PgGWZuAAAg6nDRvpKMwTXPMpNVlK1XEffQPNI0OMcGjTSBIbgBAICoVFaQ4rNTuKelqZr2Ho8NNiGxILgBAICoxA0zFbLBa1MT+xppVrf2ULelf44Nb5F5e2etqFoMiQvBDQAARCW1Qu6xU3i6TkW5KWpyemmaabE56K3tNdRmRLfwRIXgBgAAojqx2OPtfUtT3ppmdlvs9Mb2GuyeSlAIbgAAIGqNyU4mjXJwp3CpkSbn2HSZPG//NvRY6c1t1YN2VUH8Q3ADAABRS+6lU3iKRin6SbHDjYMTiyXNXRZas6PGY7NNiF8IbgAAICaXpk4U9PPddqG23UTv7KojB+8fh4SA4AYAAKIat1VI0fQ2VHY3IVdPSX1NMwd2ER/oeLORPtxXL1o4QPxDcAMAAFGN2y54aseQrFZQUYY24OJ9++s66fNDTWE5R4guCG4AACBmC/q5lqYC7Ai+vbKdNh9vDem5QfRBcAMAAFEvW6+mnBT1oNvH5+hFD6qmTjO1dQdW12bDkWbaXd0RhrOEaIHgBgAAYkKZh8RirUpOpZk6r+0YvPn0QCMd8bHLCmIbghsAAIjtTuG5ge2acudwOum93fXoQxWnENwAAEBM4No2vHNqoHE5ySRPSqJWo4Wau8wBP5/N4RR9qBrRhyruILgBAICYMblg8K4ptVJOo7KCX5qS+lC9iT5UcQfBDQAAxH6ncLeCfsHWskEfqviD4AYAAGIG95kanZ3ssQcVBz1czK+xM/ClKQn6UMUXBDcAABBTJnuoeaNSyESA46tTuD/ch+rtHbXoQxUHENwAAEBMGZ2VTGqlzGun8IMNnUPuBM5dxt/djT5UsQ7BDQAAxBSFXEYT+rZ/uxuTlUw6lZy6zDZ6Y1sNdVtsQ3r+Y03ch6oBfahiGIIbAACIi4J+HPRcNKuItEo5NXWZ6bWt1dRlGlqAs7/OQP873ByCM4VIQHADAAAxpzjDc6dwbtFw+dxi0qsV1NZtpde2VYtk4aHYVtFG35SjD1UsQnADAAAx2SmcKxZ7kpGsEgFOmlYpdk+9urWa2oyB9Z0a6MvDzbSnBn2oYg2CGwAAiEll+YML+klStUq6bE4xZeiUIgeHAxxurjkUn+xHH6pYg+AGAABiEi9BZetVXu/XaxR02dxiytGrqcdqp9e3VVP9EFotoA9V7EFwAwAAMavMQzsGdzqVgi6ZU0T5qRoyc6uFbTVU09YT9NdBH6rYguAGAADirlP4wKrGF88uouJ0LVnsDnprRw1VtBiD/lpSH6r27qHl78DIQXADAAAxK1WjpEIPncI9VTC+cFYhjc7SiVmYtTvr6GhT8JWMRR+qbTUijweiF4IbAACIaZN9JBYPrIOzfEYhjc/Rk93ppHd219HB+uC6iDPegcUzOEOtggzhh+AGAABiGrddkHvoFO4JH7d0Wr4oAsjNw9/fWz+krd7NnWb0oYpiCG4AACAuO4V7I5Ml0blT8mh6UZq4/smBRtpe2Rb010UfquiF4AYAAOKyHYO/IoCLJuXQnNJ0cZ1bLWweQjVi9KGKTghuAAAg5o3NThZJw8EGOKeNz6aFYzLF9Y1HW2jDkeagG2ZyH6ov0IcqqiC4AQCAOOkUrg/6cRzgnDQ2SwQ5bEtFG31+qCnoAGcr+lBFFQQ3AAAQ9+0Y/Jk7KkMsU7Gd1R308f5GUZk4GOhDFT0Q3AAAQFwoydSKbuBDNaM4XSQa876rfXUG+mBPPdkdzqD7UA2lQCCEFoIbAACIC7zENDHIxOKBJhekiq3ivLP8UGOXqIVjszsCfjzP9nywt566LSjyF0kIbgAAIG5MHmZwwybkpYhif1wT53izkd7eVUvWIAIco9lOH+1rGPZ5wNAhuAEAgLiRm6qhb03KIZm/hlN+jMlOpgtnFpJSnkRVrT2iIrHZZg9qi/jOqvZhnQMMHYIbAACIK3NKM+ii2YWiuN9wlGTqRMNN3mJe12ESPaV6gmi58MXhJmo1oslmJCC4AQCAuDMqK5muXlBCWXrVsJ6nIE1Ll84pIq1STo2dZnp9azUZA2yaabU76b09dUEnJcPwIbgBAIC4lK5T0ZXzS2hsTuCtGTzJTdGIACdZJacWo4Ve21pNBpM1oMc2GsyiMCCMLAQ3AAAQt9QKOV0ws9BVhXiosvRqumxuMaVoFNTeYxUBTnt3YEtO2yrbqLKle1hfH4KD4AYAAOJ+i/gp47Pp/BkFIkF4ODNBl88tpnStkjpNNhHgtHSZ/T6OawHy9nBTEPk6MDwIbgAAICFMzEuhK+aXiNmXoUrRKMUMTlayiowWO722rZoaDSa/j+sy27A9fAQhuAEAgITB+TPfWVhKRRnaIT9HslpBl84tptwUNZmsDnp9ew3Vtvf4fdyRxi7aU9Mx5K8LgUNwAwAACUWnUtClc4ppRnHakJ+Dd09dMqeICtM0ZLE56K0dNVTV6j+vhptytmF7eNghuAEAgITD1YfPmpxHZ03OFZ8PNVn5otlFVJqpE9u+1+ysFRWNfeFA6L0h9KyC4CC4AQCAhMXNMnkGRqcaWsE/pVxG355ZQGOzk0XAsm5XLR1u6PT5mAaDib4+1jLEM4ZAILgBAICEVpyho6sWlFJOinpIj1fIZLRsegFNzNMTT8jwzEy5nxmcb8pbqboN28PDBcENAAAkvDStUhT84x1VQ8FLW0um5ovGnbzgxAGOr9YLvD38/T3YHh4uCG4AAAD6lpi4Fs4p47JoKH03uVkn5/EUpmvIYnfQ2ztrfda24Vo5nx5oxNiHAYIbAAAANwvHZtG3ZxaKhplDmcE5f3qBqKXT0WOld/fUkcNH8vDB+k7aV2vA+IcYghsAAIABxuXoxTJVuk45pK3m355RKKohV7X20P8ON/k8/rODjdTRHVivKggMghsAAAAPsvVqunpBqdjqHSxOTj53Sr74fGd1B+32UbyPt4e/v9f3DA8EB8ENAACAFxqlnC6eXUSzS9ODHqPxuXo6eWyW+Hz9wUafu6Nq20206Xgrfg4hguAGAADA1xulLInOnJRL507NI0WQBf/mj85wbRF/Z3edyMPxZvPx1oDaOIB/CG4AAAACMLUwjS6bV0zJanlQHcnPnpzn6kO1dmetWIbyxOF0iu3hZhu6hw8XghsAAIAAFaRpRR5OfpomuCrGMwpFFeQWo4U+2FtPTi504wHP7HyG7eHDhuAGAAAgCCkaJV0+t5gmF6QG/Bi9pncHFW8VP9ZspK+Oem+/sL+ukw7UY3v4cCC4AQAACJJCLqPzpuXTGROzRfG+QPBsz9llueLzLRVtPgMYLu7nKz8HfENwAwAAMERzR2XShbMKSa0M7O20rCCV5o7KEJ9/vL+R6g0mj8eZrQ6fy1cQxcGNw+GgF154ga677jq65ZZb6JNPPvH7mEOHDtHDDz8sHvPzn/+cjhw5MiLnCgAA4Mno7GS6en4pZSarAhogbu8wRuoivrOWusw2j8fVtPWIHVQQY8ENBzQrV66k2bNnU35+Pi1dupSeffZZr8dzIHTxxReLSHbx4sVUX19PU6ZMoU8//XREzxsAAMBdRrKKrlpQQmNzkv0ODC9jLZmaR1nJKjJa7LRuVy3Z7J53UH19rJXqOzzP7oB3Sc4IzXnt2rWLZs6cKQKTRYsWidseffRReuqpp6iuro5UqsERMN+el5dHMtmJmOzSSy+llpYWWr9+fUBf12AwUFpaGnV0dFBqauDJYAAAAP7wWyq3U9hZ5b0isYRzav6zuZJMNgdNyksRAQ9vHR+IW0Bcs3DUkHpdxZNg3r8jNlLvvfceZWdn05lnnum67YorrqDW1lb6+uuvPT6moKCgX2DDiouLqa2tLeznCwAA4A8HJ4sm5dL0ojS/x6ZplbRsegFxXcCDDZ0iydiT9m6rqHAMgYtYcHPs2DERmLhHqaNGjXLdF4jm5mZavXo1LVmyxOsxZrNZRHvuFwAAgHDh97WzJufS1EL/qwMlmTr61sQc8TlvDz/W1OXxuL21Bjrc0Bnyc41XEQtuOOjQ6fo3I9NoNCSXy8lk8r++yMdcdtlllJubSw8++KDX41atWiWmsaRLSUlJSM4fAADAV4BzzpS8gGrhzChOpxl9Mz3v762n5i6zx+N4d1WnCdvDozq44UBj4HJSe3s72e12Sk9P9xsYXXLJJSIH56OPPiK9Xu/12HvvvVesz0mXqqqqkH0PAAAAvgIczqMpy0/xO0hnTMyh4gwtWe1O0aKhxzK4BYPJaqcP9jZge3g0BzczZswQy09dXV39koyl+7yxWCwiiZi3gH/22WciD8cXtVotEo/cLwAAACMX4OTTxDzfAQ5XLub8G87DMZhsoskmbxUfqKq1m7Z6yc2BKAhuLrzwQlIqlfTMM8+4MsyffPJJsS2ct3ez7u5usfQk7YSyWq0isOFaN3xbYWFhpE4fAAAg4K7iS6fl0/hc76sMTKuU07dnFJBKLqOa9h6RROxpQzPn5jR6Kf4HEQ5ueKfU888/T4899hidfPLJIqDZunWrqGXjPkvz+uuvU3l5ubj+xBNP0Lp160SezZ133ikCH75wQT8AAIBoDnB4ZsZfHZwsvVq0dWB7ag20q3rwlnKe0XlvTz1ZvdTGgQjWuZHw1u9NmzaJ5aNTTjlFJBVLeKZmzZo1NH/+fLGTas+ePXTgwIFBz8E1cS644IKAvh7q3AAAQKSIqsS7aulYk9Hncbz09OWRZuINxRfNKqLSzP4bcNiM4jQ6a3IeJQpDEHVuIh7cjDQENwAAEElcjXjtrloqb+72egy/NX+4r4EO1HeSWiGjK+eXUIZucHHbC2YV0rgc38td8SImivgBAAAkakfxb88o9Dgb069WTlku5adqyGxziB1UZtvgHVQf7Wsgo5feVIkMwQ0AAEAEAhyedeHt376OWT6jgPRqBbV1W0WejWPAYgtvGf9wH7qHD4TgBgAAIAKUchldOKuIinwEOMlqhQhwFLIkqmjppg1Hmgcdw8tb26vaw3y2sQXBDQAAQIRwM0xOGC5MP7GZZqC8VI2odsy2VbbTvrrBbYQ2HG6mpk7PlY0TEYIbAACASAc4s4uoIM17gMNFABeMzhSff7q/kWrbe/rdb3M46f09dSJZGRDcAAAARJxaIRcBDs/SeHPS2Ewal5NMdidvJ68jw4A+U81dFvrCw7JVIsLMDQAAQBTQKOV0yZwiyk1Ve91Bde6UfMrWq6jHaqd1O+sGFfLbUdlOB+oHL1slGgQ3AAAA0RTgzC6m7BS11yUs3kbOrRqausyiFs7AcnXv7a6n/2yupPJm34UC4xmCGwAAgCiiVcnp0jlFYobGk1StUuygkiURHWnsok3HWwcdU9dhoje314gg53gCBjkIbgAAAKKMTqWgS+YUU2ay5wCnMF1Li8tyxecc3Bxu7PR4XF2Hid7aXkOrN1fSsaausJ5zNEFwAwAAEIW4xs2lc4spQ6f0eP/UwjSaVZIuPv9wbwM1dnrvFF7fYaI1O2rp5U2VdDQBghwENwAAAFFK3xfgpHsJcE4fn02jMnViK/janXV+WzE0GEz09o5a+vemCrGkFa/tJRHcAAAARLEUjVIEOGnawQGOTJZES6fli+Cny2yjd3bXkc3hv9ZNo8Es+lX9e1MlHWnsjLsgB8ENAABAlEvtC3A4mXggtVJOF8wsFN3DOcfm0wONAQcrXNWYZ3xe2lRJhxviJ8hBcAMAABADeObmsjnFlKJRDLovQ6cSMzhJRLS/rpNWb66iXdXtHjuJe9LcaRaFAV/6uoIOxUGQk+SM9e8gSAaDgdLS0qijo4NSU1MjfToAAABBae+20KtbqsUy1EB7ajpo/cEmUcWYccNNbt0wvSiN8lLVohBgILL0KlowJpMm5aUE/Jhoev9GcAMAABBjWo0Wem1rFRnNg2dmeqx22l9noL01BmrttvQLWKYXplFZfopYygoEb0WXghzO74kkBDchGhwAAIBo1dJlpte2VlO3xfPSk9PppNoOk5jNOdzYRXZH72yOnGdzcvU0rShNNOsMZGaGt6MvGJMlAqNIBTkIbkI0OAAAANGsuS/A6fES4EhMVjsdqO8UgU6L0dJvZmZaYSqVFaSKlg6BBDnzx2TS5PzUEQ9yENyEaHAAAACiHRfve31rjQhg/HE6nVRv4Nkcg0gc5vo40mzOeJ7NKUylonSt39kc3no+f3QmTSkYuSAHwU2IBgcAACAWNBpM9Nq2ajJb/de4kfBOqoNiNscgmnC6z85M49ycghTRBsLfDi7OyZlckCoCpHBCcBOiwQEAAIgV3GLhje3BBTjSbE5jp1ksWR1s6CSrvXc2h2OV8Tl6mlqURiUZvmdzuP7OAp7JKQxfkIPgJkSDAwAAEEvqOnrojW01ZLEFF+BI+HG8XLW7pkMEPO4zNLxkxTM03PPKV5DzrYk5Yokr1BDchGhwAAAAYk2nyUrHmox0vNlIVa3drryaoeTy8JIVL11Z7L3BEk/KjM3mnVapVJqp8zibw7M3S6bmU6ghuAnR4AAAAMQyq91Bla3dItgpbzZ6LPwXyHPwbA4HOpyMLEnVKERncg5muMFnNAU3vjOFAAAAIGYp5TIal6MXFym3RprV4ZmZQHoU8HNwEMMX3nrOuTm8rdxgstHGYy309fEWGpudLO4flaWjaIAKxQAAAAmoy2yj401GOtbcJZavpETiQNjsDlEYkAMdLhQo4RmcRWU5dN+yyVSQpg3p+WJZKkSDAwAAkAhsdgdVtfXQ8eYuMbPTabIFVSl5T62BDtQZyNSXyMy9rNbecVpIzxHLUgAAABAwhVxGY7KTxWVxWW8y8fG+5SvOs/G1fJWlV4sdUqeOy6IjTV3iMVfML6FIwrIUAAAAeNVtsYmAhWd0ODnZ3zZzTig+d0peyLuJY+YGAAAAQoKrFEsJxdx8s7qtm441G8XMTkeP1eNjQh3YBAu7pQAAACAgXH14VFayuCya1Nu483hfoFPXYSJHINuvRgCCGwAAABiSbL1aXLiJJncmL28xRkWAg+AGAAAAhk2rkov2DNFAFukTAAAAAAglBDcAAAAQVxDcAAAAQFxBcAMAAABxBcENAAAAxBUENwAAABBXENwAAABAXEFwAwAAAHEFwQ0AAADEFQQ3AAAAEFcQ3AAAAEBcQXADAAAAcQXBDQAAAMQVBDcAAAAQVxSUYJxOp/hoMBgifSoAAAAQIOl9W3of9yXhgpvOzk7xsaSkJNKnAgAAAEN4H09LS/N5TJIzkBAojjgcDqqtraWUlBRKSkoKeVTJQVNVVRWlpqaG9LnjDcYKY4XXFX4HYwX+XkXHeHG4woFNYWEhyWS+s2oSbuaGB6S4uDisX4N/mAhuMFZ4XUUOfgcxVnhdxefvob8ZGwkSigEAACCuILgBAACAuILgJoTUajU99NBD4iNgrPC6Gnn4HcRY4XUVedHwe5hwCcUAAAAQ3zBzAwAAAHEFwQ0AAADEFQQ3AAAAEFcSrs7NcB06dIi6urpo6tSpASdLHT16lOrq6uikk04ihSJxhryiooKamppo0qRJomiiP3a7nQ4ePEgqlYpGjx6dUGPV0NBAlZWVNGbMGMrOzg7oMTU1NWJ8eazS09MpUbS3t9ORI0coPz8/6JpVGzduFL+3c+bMoUTQ3d1N+/fvF6+PcePG+T1227Ztg26fPn16wLVFYpnNZqM9e/aIvz+TJ08OuMhra2srlZeX08SJE0mv11MicDqd4nVlsVho2rRpPv9Wc9G9nTt3eryvrKws4L93QzlJCEBdXZ1zwYIFzvT0dOfYsWOdmZmZznXr1vl8zDvvvONctGiROJaHuqmpKSHG2mg0OpcvX+7U6XTOsrIy8fGvf/2r1+PtdrvzF7/4hTM3N9c5efJkZ2lpqbi8//77znjncDict956q1OtVjunTJkiPv7sZz/z+ZgvvvjCOW/ePOeoUaOcM2fOdGo0GucPfvADp81mc8a7J554Qny//DrRarXOK6+80mk2mwN67B/+8AenTCZzTpo0yZkI/vOf/zhTU1OdEyZMcKakpDi/9a1vOVtbW70ev3v3bvF3iv/OnXrqqa7Ltm3bnPHuyy+/dBYUFIi/Ozk5OeJ38ciRIz4f093d7bz++uvF63Du3LnOkpIS59NPP+2Md4cPHxbjw+PE48XjxuPnzd69e/u9nvjCr0l+rX3yySdhO08ENwHiN+uFCxeKFzR79NFHnXq93tnQ0OD1Mb/+9a+dH3/8sfPdd99NqODmrrvuco4ePdo1NqtXr3YmJSU5t2/f7vF4HtOHHnrI2dbW5nrDX7lypRjf5uZmZzz7y1/+It549uzZI65v2rTJqVKpnK+88orXx7z00kvOffv29fvjwW/4f//7353xbP369eJ19MEHH4jrFRUVIiB++OGH/T6WX3v85sNvRokQ3Bw7dky8jv70pz+J6x0dHeIN6Xvf+57f4Ib/kUskXV1dzvz8fOedd94prvM/CUuWLHHOnz/f5+Ouuuoq8SZdVVUlrnOQ/be//c0Z7+bPn+9ctmyZ65+p2267TYwf/1MbqBtvvFH8c8b/2IYLgpsA1NfXiz+qr732Wr835OTk5IAi9ffeey9hght+sWZkZDh/9atf9bud/wisWLEi4OcpLy8Pe2QfDfi/ZH7DHRhI8x/XYPAfCp79imfXXnut86STTup32z333CO+d186OztFQLN27VoxK5YIwc0jjzwiAj/3Nw8OpHlmkN/MfQU3GzZsEMEgj1si+O9//ytm9Nz/UeVAmseCx8QT/oeC73/77bediWTXrl3i+3afqamtrRXj9+qrrwb0HPy64n9c+TUaTkgoDgCvF3IgOHfuXNdtWq1W5N1s3749POuFMYrXntva2vqNFZs/f35QY/XNN9+Ij/7yBGIZv6b4tTVwrBYsWOB3rHp6eujLL7+kDz74gH74wx+KNe+bbrqJ4hmPiaex4twufs15c9ttt9HixYtp+fLllCh4rGbPnt2vuSCPldlspn379vl87BVXXEHf+c53KDMzU4wd51XE+1hxk8fc3Nx+YyXd58knn3wicnOWLFlCx44do127domcpXi3vW883H8PCwoKRO5boH/fX3nlFfH364YbbqBwSpyMzWHghDGWlZXV73a+Lt0H/seK/wAEor6+nu666y669tpradSoUXE7tEajUbzZDOV1xYnEK1eupI6ODjp+/Dg98MADVFRURPGMx8TTWEn3ZWRkDHrMSy+9RJs3b/aYKBvPeDwGvh7cx8oTbnD43nvv0XnnnSeu85sVB4WcjPzLX/6SEul1xf+88sXbWNXW1opEWP4btWnTJtLpdCLIXrVqFd1xxx0Ur1pbW8X3qtFohvxe+I9//IOWLl0a9gbWmLkJgFKpFB9NJlO/2zn65OgdQjdW/AvC/w2NHTuW/vznP8f10A5nrEpLS8XMze7du8Uf19/85jfiEu/j5WmsmKfxamlpoR/96Ed066230tatW8V4VVdXu2a9fM32JNpYSa8pKbBhPPNzyy230H/+8x+KZ57GimdVecbK21jxYzjA4Z2K/M/F3r176e9//zutWLGCtmzZQvFKqVSKf8gGNjYI9O8777DiHYs333wzhRuCmwBIswe89dYdX+c/CBCaseI3m7PPPltsG3/33XfFfwjxjLck5+XlDft1xcujy5YtE/91x/try9NY8R9c3hY+EL9hzZw5U0yD8ywXXz7//HPXrBf/oU20sWLBvLY8vT7jcay4VIf7GzZf59IU3saKgxrGwZ/k6quvFn+7OHCO57Gy2+2idIXE4XCI2fZAXlc8a1NYWEjnn39+mM8UwU1AZs2aJaYg3377bddt/Ifx8OHDdM4557hu42UXrtOSyHgKe968ef3GipdO1q9f32+suF6Qe+0DKbDhgOb9999PmHoRPCZr1651Xec/HOvWres3VlVVVeK/HfflLE+1lAZOrccbHpMPP/xQ/OcoWbNmDZ155pmuWTCereE3F/6vm5dl+HP3yzXXXOOa9TrllFMonseKZxD4Tdp9rLiOkpTHxq8jHgf+/ZSuD/TRRx+JOibxjMeK//588cUX/caKl15OP/10cZ0DHx4rfhNn/LeK85ncAz9+Dh7DnJwcilenn366+KfM/e87/8PAtafc/2bxa49ntNxZrVZ68cUXRa6NXC4P/8mGNV05jnCdFt5p8NRTT4ms8KlTpzoXL17c7xjeKs51NyTHjx8XNUl++9vfigxzrovD1+N9e/OHH37oVCgUzgceeMD51ltvifoavENF2kbPrrnmGlEbgvX09IjthYWFhWJnGY+RdGlsbHTGswMHDoit4DfddJPYecHbS7OyspyVlZWuY7jsAO/Mc99h9ctf/lKUGHjjjTecl19+uaglxNvI4xnXaOG6GrwNlcfqxz/+sdjuvHHjRtcx/LvJv2vS9tyBEmW3FG/T5d8pvvBrZNWqVeJ30r3EAO+I4rH67LPPXDvPuF4S7x5as2aN8+qrrxbjy7/P8Y6/Vy5f8fLLL4vt3Pw76b6bh/9G8Vj9+c9/dt129913OydOnChKXfDrUfo75203Wrx4+OGHRf0kHiceL/6d/M53vtPvGN7BOHB3LO825l3HXKZgJCChOEA/+MEPxOwNR55coZh3FPzkJz/pdwxPgXPmuOSdd96h1atXi89PPfVUkWzGHnvsMfHfZrziCP7jjz8WOTMbNmwQmfW8DMAJehKuWiwlpXEFS16v5f8qeWzcPfjgg3TuuedSvOJx4FmZ3/3ud/TUU0+J/6q//vprsXtDwjMN7rMMvEPqmWeeERfeJcXLUjxjGO4EvUjjhOGvvvqKfv3rX4ux4t+1//3vf7Rw4ULXMfw7yr9r3qqH83LCwB1X8Yj/M+ZZF87D4tcJz6jyf9ucyCnh2VEeK6n6MI/ryy+/TK+//rr4neTXJs9Qc/5bvHvuuefo6aefFh/5b9Ef//hHuv7661338ywNj5X73/ff/va3NGXKFPr3v/8tZna+9a1v0d13303JyckUzx588EHxN4lfJzxDeueddw5KoubdsQNfNzxTz8t4/Hd+JCRxhDMiXwkAAABgBCChGAAAAOIKghsAAACIKwhuAAAAIK4guAEAAIC4guAGAAAA4gqCGwAAAIgrCG4AAAAgriC4AYC4xY1FP/3000ifBgCMMAQ3ABC3uGnmI488EunTAIARhvYLABC3ZsyYIcrpA0BiwcwNAMQk7jLMMzPcYd7dZ599JrrQs8mTJ9Npp50WoTMEgEhBcAMAMUmpVIrGrMuWLRONHtkXX3whGq3abDZxHctSAIkJwQ0AxCzues3d5rkrcXt7O333u9+lFStW0Nlnnx3pUwOACELODQDELI1GQy+//DItWLCAtm3bRpmZmfT4449H+rQAIMIwcwMAMW369Ol0xRVXiG3fPJODBGIAQHADADFty5YttHr1apE8/Nhjj5HD4Yj0KQFAhCG4AYCYZTQa6ZprrqGbb76ZPvnkE9q3bx/9+te/jvRpAUCEIbgBgJh19913k0wmo9/+9rdUUFBAzz77LD300EO0devWSJ8aAEQQEooBICaVl5eLLeCcUMw7ptiFF14oKhKvXbuW5s6diyJ+AAkqyel0OiN9EgAAAAChgmUpAAAAiCsIbgAAACCuILgBAACAuILgBgAAAOIKghsAAACIKwhuAAAAIK4guAEAAIC4guAGAAAA4gqCGwAAAIgrCG4AAAAgriC4AQAAgLiC4AYAAAAonvx/FboPKqSo8ZEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xis = np.linspace(0.1, 0.7, 15)\n", + "reps = 10\n", + "n = 1000\n", + "prop_outliers = 0.1\n", + "\n", + "abcd = ABCD(n, outliers=prop_outliers, rng=np.random.default_rng(seed=42))\n", + "ecg = ECG(refuse_score=True, rng=np.random.default_rng(seed=42))\n", + "fs = np.empty((len(xis), reps))\n", + "for i, xi in enumerate(xis):\n", + " for j in range(reps):\n", + " abcd.xi = xi\n", + " sample = abcd.sample()\n", + " predict = ecg.fit_predict(sample.to_sparse(matrix=True))\n", + " outliers = np.argsort(ecg.refuse_community_)[: int(n * prop_outliers)]\n", + " predict[outliers] = -1\n", + " fs[i, j] = fstar(predict, sample.community_array)\n", + "\n", + "fs_mean = np.mean(fs, axis=1)\n", + "fs_std = np.std(fs, axis=1)\n", + "plt.plot(xis, fs_mean, label=\"ECG\")\n", + "plt.fill_between(xis, fs_mean - fs_std, fs_mean + fs_std, alpha=0.5)\n", + "plt.title(\"Performance on ABCD+o\")\n", + "plt.xlabel(\"xi\")\n", + "plt.ylabel(\"F*\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "ABCD+o\n", + "- [Bogumił Kamiński, Paweł Prałat, François Théberge. Artificial benchmark for community detection with outliers (ABCD+o). Applied Network Science 8 (2023) doi: 10.1007/s41109-023-00552-9](https://doi.org/10.1007/s41109-023-00552-9)\n", + "\n", + "ECG\n", + "- [Valérie Poulin & François Théberge. Ensemble clustering for graphs: comparisons and applications. Applied Network Science 4:51 (2019) doi: 10.1007/s41109-019-0162-z](https://doi.org/10.1007/s41109-019-0162-z)\n", + "- Code: https://github.com/ftheberge/graph-partition-and-measures\n", + "\n", + "F*\n", + "- [Ryan DeWolfe, Paweł Prałat, François Théberge. A Pragmatic Method for Comparing Clusterings with Overlaps and Outliers. arxiv preprint (2026) doi: 10.48550/arXiv.2602.14855](https://doi.org/10.48550/arXiv.2602.14855)\n", + "- Code: https://github.com/ryandewolfe33/fstar" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "abcd", + "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.13.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/overlap.ipynb b/docs/overlap.ipynb new file mode 100644 index 0000000..e10cd26 --- /dev/null +++ b/docs/overlap.ipynb @@ -0,0 +1,225 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ABCD with Outliers and Overlaps (ABCD+o2)\n", + "\n", + "Another extension of the ABCD model allows nodes to be in multiple communities: overlapping communities. This extension build on ABCD+o, so outliers are also allowed ([read the ABCD+o notebook here](outliers.ipynb)). The ABCD+o2 extension adds two new key parameters\n", + "- $\\eta$ (eta): the average number of communities per non-outlier node\n", + "- $\\rho$ (rho): the pearson correlation between the number of communities a node is in and its degree.\n", + "\n", + "By default, these values are set to 1.0 and 0.0 respectively, which creates no overlap and makes ABCD+o2 equivalent to ABCD+o." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float64(1.5)" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from abcd_graph import ABCD\n", + "\n", + "abcd = ABCD(1000, eta=1.5, rho=0.3)\n", + "sample = abcd.sample()\n", + "\n", + "sample.eta" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The community information is stored in the `membership_matrix` property of the sample. It is a sparse boolean matrix with rows representing communities and columns representing vertices. A True (or 1) value means that community contains that node. Not many community detection libraries are built to handle communities with overlaps and/or outliers, so we leave it up to you to work with this membership matrix directly." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample.membership_matrix" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## How it works\n", + "\n", + "Once we have an assignment of nodes to communities and degrees to nodes the ABCD+o2 sampling is fairly simple. The non-background degree (recall each vertex has xi proportion of its degree in the background graph) of each vertex will be split evenly among the communities to which it belongs, and community generation and rewiring proceed as normal.\n", + "\n", + "### Assigning Overlapping Communities\n", + "The first challenge is assigning nodes to communities so that there is realistic overlap pattern, and our proposal is to use a hidden geometric reference layer. We assume that we have a number of non-outlier nodes $\\hat{n}$, and a sequence of community sizes $C_1, C_2, ... C_j$, such that $\\sum_{i \\in 1 .. j} C_i / \\hat{n} = \\eta$. We shrink each community by a factor of $\\eta$ to get a primary community size $\\hat{C}_i$ (randomly rounded to an integer), and make small fixes so that $\\sum_{i \\in 1 ... j} \\hat{C}_i = \\hat{n}$.\n", + "\n", + "Next, we use the hidden reference layer to assign each vertex to exactly one primary community. We randomly sample $\\hat{n}$ vectors uniformly from a unit ball in dimension $d$ (another new model parameter) and assign each to a vertex. For each primary community size, in decreasing order of size, we take the vertex furthest from the centre that does not yet have a primary community, and assign it and it's nearest non-assigned neighbors to this primary community. After all primary communities are assigned, we expand each community back to it's initial size by adding nearest neighbors to it's centre of mass." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Picking the further point for the origin as the seed of the next community](_static/overlap_geom.png)\n", + "\n", + "Example of building the community $C_3$ with $\\hat{C}_3 = 40$ and $\\eta = 1.75$ using a 2D reference layer. First, in panel (A), we select the seed as the vector furthest from the origin that does not have a primary community. Next (panel B), we build the primary community $\\hat{C}_3$ as a node of the seed and the nodes of the seed’s $\\hat{C}_3 − 1$ nearest neighbours that do not yet have a primary community. Finally, in panel (C), we create $C_3$ by expanding $\\hat{C}_3$ by a factor of $\\eta$ (from $40$ to $40 \\cdot 1.75 = 70$ nodes) by taking the nearest neighbours to the primary centre of mass. Image from [Barret et.al (2026)](https://doi.org/10.1093/comnet/cnag023)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Assigning Degrees\n", + "\n", + "Now that we have each node assigned to 0, 1, or several communities, we have to assign each node a degree. There are a few conditions on which degrees can get assigned to each node depending on the nodes communities, though in practice these conditions are not very strict so we will ignore them here (and refer to the paper for full details). The main challenge is assigning degrees to vertices so that the pearson correlation between the number of communities to which a node belongs and its degree, restricted to non-outlier nodes, is $\\rho$.\n", + "\n", + "This problem is hard, so we instead take a \"guess and check\" approach to tuning an internal parameter $\\alpha$. We assign degrees sequentially in decreasing order, and we decide which node will get the current degree by choosing a random viable vertex with probabilities proportional to the number of communities the nodes is in to the power $\\alpha$. That is, if node $i$ is in $\\eta_i$ communities its probability is proportional to $\\eta_i ^ \\alpha$. This way we can tune $\\alpha$ to get a positive or negative correlation. We simply run a binary search on $\\alpha$ until we get an acceptable degree assignment." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Benchmarking Community Detection Algorithms with ABCD+o2\n", + "\n", + "There are not many algorithms that allow both outliers and overlaps, and several of the existing ones don't have readily available python implementations. So, for simplicity we will only benchmark the Egosplit algorithm using *not-official* [egosplit-sknetwork](https://github.com/ryandewolfe33/egosplit-sknetwork) implementation.\n", + "\n", + "A non-exhaustive list of other algorithms include:\n", + "- Order Statistics Local Optimization Method (OSLOM): [Paper](https://doi.org/10.1371/journal.pone.0018961), [Code](http://www.oslom.org/)\n", + "- Hierarchical Single Linkage Edge Clustering: [Paper](https://doi.org/10.1007/978-3-032-16719-4_8)\n", + "\n", + "For comparing the similarity between the detected communities and the ground truth, we will use the recently developed [F* score]( https://doi.org/10.48550/arXiv.2602.14855) that was designed explicitly to handle outliers and overlaps.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from egosplit_sknetwork import EgoSplit\n", + "from Fstar import fstar" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "xis = [0.2, 0.25, 0.3, 0.35, 0.4]\n", + "etas = [1.0, 1.25, 1.5, 1.75, 2.0]\n", + "reps = 10\n", + "\n", + "abcd = ABCD(1000, rng=np.random.default_rng(seed=42))\n", + "egosplit = EgoSplit(global_clustering=\"PC\", random_state=42)\n", + "fs = np.empty((len(xis), len(etas), reps))\n", + "\n", + "for i, xi in enumerate(xis):\n", + " abcd.xi = xi\n", + " for j, eta in enumerate(etas):\n", + " abcd.eta = eta\n", + " for k in range(reps):\n", + " sample = abcd.sample()\n", + " predict = egosplit.fit_predict(sample.to_sparse(matrix=True))\n", + " fs[i, j, k] = fstar(sample.membership_matrix, predict)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fs_mean = np.mean(fs, axis=2)[::-1]\n", + "\n", + "fig, ax = plt.subplots()\n", + "im = ax.imshow(fs_mean, cmap=\"coolwarm\")\n", + "cbar = ax.figure.colorbar(im, ax=ax)\n", + "ax.set_xticks(np.arange(len(xis)), xis)\n", + "ax.set_yticks(np.arange(len(etas)), etas[::-1])\n", + "for i in range(len(xis)):\n", + " for j in range(len(etas)):\n", + " text = ax.text(\n", + " j, i, f\"{fs_mean[i, j]:.2f}\", ha=\"center\", va=\"center\", color=\"black\"\n", + " )\n", + "ax.set_title(\"Egosplit Performance on ABCD+o2\")\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "ABCD+o2\n", + "- [Jordan Barrett, Ryan DeWolfe, Bogumił Kamiński, Paweł Prałat, Aaron Smith, and François Théberge. The artificial benchmark for community detection with outliers and overlapping communities (abcd+o2). Journal of Complex Networks 14(4):cnag023 (2026) doi: 10.1093/comnet/cnag023](https://doi.org/10.1093/comnet/cnag023)\n", + "\n", + "Egosplit\n", + "- [Alessandro Epasto, Silvio Lattanzi, and Renato Paes Leme. Ego-Splitting Framework: from Non-Overlapping to Overlapping Clusters. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD '17) doi: 10.1145/3097983.3098054](https://doi.org/10.1145/3097983.3098054)\n", + "\n", + "F*\n", + "- [Ryan DeWolfe, Paweł Prałat, François Théberge. A Pragmatic Method for Comparing Clusterings with Overlaps and Outliers. arxiv preprint (2026) doi: 10.48550/arXiv.2602.14855](https://doi.org/10.48550/arXiv.2602.14855)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "abcd", + "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.13.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/pyproject.toml b/pyproject.toml index 1768262..224069c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -37,17 +37,33 @@ dependencies = [ [project.optional-dependencies] dev = [ - "pre-commit>=4.0.1", + "prek", "pytest>=8.3.4", "pytest-cov>=6.0.0", ] +docs = [ + "matplotlib", + "jupyterlab_pygments>=0.1.1", + "ipykernel", + "nbsphinx", + "numpydoc", + "pandocfilters", + "sphinx-rtd-theme", + "networkx", + "partition-networkx", + "igraph", + "partition-igraph", + "scikit-network>=0.33.5", + "partition-sknetwork", + "egosplit-sknetwork", +] [project.urls] Homepage = "https://github.com/AleksanderWWW/abcd-graph" Repository = "https://github.com/AleksanderWWW/abcd-graph" [tool.hatch.build.targets.wheel] -packages = ["src"] +packages = ["abcd_graph"] [tool.pytest.ini_options] pythonpath = [ From a5fe9d4cdf61afb500a1041846ec4b48a2a011dc Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 30 Aug 2026 20:32:57 -0400 Subject: [PATCH 57/85] Fix docs picture file format --- docs/_static/big_picture.pdf | Bin 16955 -> 0 bytes docs/_static/big_picture.png | Bin 0 -> 55950 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 docs/_static/big_picture.pdf create mode 100644 docs/_static/big_picture.png diff --git a/docs/_static/big_picture.pdf b/docs/_static/big_picture.pdf deleted file mode 100644 index 2d7ad33d5a6d83917caa420a0a4ac6089b7b27d4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 16955 zcma&O1#BfTvn3p+2{Y%0nK=_?W}46qb8^Fs6PPeFGsA>AnJ_c+gqfND`F7vaztXO> z+v=9=vfD1Xt8BMU9aAccOER)DaUxL8EDWw7Z~<5VAY*F;etraIc{6(p7fS#)J2xxf ze_RO6l2*1ZW=;TRNn0ZqGjTH$kf|Ahpdf;?i<6m=9fHSNmwrbAMVtM@5&c+Fl;X_? zOOuyvaA*9G+K5g_O_ZI4bc`Pmj2)cNTvMZx{`=d|Ryr}qX`CTCg)~5^Z5?QT`S^zN z)VrPY>B8-ABS-hSlzKdO5&J~)emSl;ik~d^Y=1t~ zem>TIT`UWIJpTelG^vpl<<88kEps0;d_0!^7!c5vt*B9sH92LP+Yb5E0)5@3e&xo* z8o{^SyL_W$qTJsHT{W~a^tzLj*V^Ck4vN+{5B#-heNj%;Bm7}oFLb;|%Gi}8XcbzV zj0s8hQy!lrmy1;Z4WAHSTVlfQB;VUsNBsTASrOe&Mg;d^+t+)4r#*8t#1RnN_3OSi z^OFL-k2Tc}J9ZW~*sE2v?;v@}iJIE!g=AsfJ$~P7m`K*h{>I&8hq!Q{WHFAYWqMBh zw@A5aj<{Lrhwh>*KI_N!0YZ;`EEMrMHh<0H=#7@<1$&s~Q*^p$*hYFXzs@z0c{O&- zi=4srd1xC$h8QLH<3)|gMxb9i!4v_Q@5TH@G&cOQNB45^k*NJc%-k+E{)#5(KFh~8 zkb&8VmY2edKi*Gj51Gu5KgL1t8^F#k-|@gmiwDE1e-}N1KqB9 zlYfb2GyK}@+Cwh{6=MHR8*)=C?O-a&8O$9F5AeJpT<4f$u0@z$L$0`jyB`pJB%aSx8~;T)Y@bhNpyGMy_!lx_12Q8vpak72S*W~E znp7qH!(2N#G>RCmkrw?k?@?iK0&I{^r(IAbAefYgUqv(0S3|ZI^qXLU;IB_{tf~)j zRv{}&peRBF?HWE&Ws+#j98K8u!kz&Eb9Li{hLlOO>F{s5yq!_Grw#q&!Q!?xFe&Ic zLSI=kt9%(@u^N_ruX_S7)wML)mC`09x{#c2D?}JAu;ponuQ$B)OC@(+n4JZk;1kQ2 zrI^omxBaXNKpH{De%!=4aZq)9gXyblWjsScx?<)eqngJ$ISDKmxX_R|4DBCqbMj9G2>0QMhaV6$EB+p7m1`yUuTyQk zo#0bALQ}G5=;?Swyf%!Ew)j+09P8PY-1u~BstA#m-j(_L1Q$^ph#Y^Zbfj8R6a_)5 zYoujudSJ-na}55PMS)YC)w6haB@X%X6$@E+OEuxg4QnFG8&xcgg>`4_&}xR5$kQ$w z>q!PrGf0O>4&AS5_?|!RI@4y9>QWz)tmi~o#VK&|{BI*h#E9|jG|~_8i2#r!B*Kk3 zvzJ-}l_B{$ zN1hy0Z8?|IGwO7#|MbR1b_=EF3~=V3bj%n&Lq?dBBtVm>?>tKYMXKg7*G6aZCb zQwg;dh7S#Crl^ZnCz=<)pZbW2$JyD%DrIua{M;CALYkcqYWhO!Dkpo zlM!ERkr@Ov-SEJ4ipeDzpm=bnareKBUDK$+)*odOMxhDQ87UNaeCI?qrnr@HVH-(b zf{2P$%?p{Ag3FjoQ^OKtL>2i1p&D+BsIW(3g9S->mMz;06Wty&RHK9`oGT$KcHvXj z*vlW8Jmpz+&dnpFK-F!go7$dt;dortj8~!FA|C`9@A(aGuo`o+Qz)51=`J5x#c@IX8g8SrwTY%t*Sb;wg&2tZj9K zy!5Dtjj%hZ+KCiHi)CPJY<#hZyOlljW(`2hD~ga2Sr znSod2yOQqdjN)&#gxRS-RLzO?A_a)IzJR3#fUqnK8vZYNa+i6`Mf|}Ii|5Cv-V%#) zNnYh#1x|!1*K$b@IJKd^ft32+7KLqa1fjGx;L}6uW+UJ#5@{k}<)-+EQ@3bKw@IzP z6@ON&(uBEBZ0#ca@lEN9qjuu*CHF?fmf29AhRgM9>WwbI?jmiEAK*LoT< zpDxwg#&9P+tcP$m#-xjEJR-nXGq}@V?O6)icVW6bh50!xS8lcxC08>FEzYsJKMKGe zRugtsvhh+Bv1V4lio*Q!-3^q3*s3Iu{=lK@*_X(jb;cG?*zv|j4ZUqqXNtmG0RmqmvJKshd<%yiC2uMDw|NEM7GQY*N_$)tDIDE!KY$Rn7xpFPb z)cSkoHtRIlf~^%+tZpL>yuhGJWZeTAwu?i9T@o!;6QqP=n5*B1)TI*abcwC#P$Tza zj!qJmTTstrY^o^3dY`iBb;9T}C1xLb8kPi~ict)iqmP_9-eglw+N%Z&o!*$oG9YqUF28uit0cE z%tc94M|?yu2UV`50CZT|HDdbG

FM036#0Z3eEQ3<7*9t(~u|xwVjr+64H(_Y{y4 zUX@qMETLC*j-u5+1LB>OjwFM2wv#;wR921K0N3I7bX^pujMbL$@eaXLAl6N_W=y0C z;iUBz7f(0CQK9pc7GCfvZi-Gvd)6X^qR3lq6Rit3Vsa;AN4}|Kf$UN&3-2K_pNoVk9D~Ca^hi^YC zk&fC4OYKB?eyGsZn0I7&QJni9cmCGMsIV{pH+FY`q=-tq0?#5&LEc(749-b>3I4UN zZSP#KTHAE$O)dAW%KDsBleAmN{6pI6fcd#}zTu;RQVsc^71){(MWcWxcvS^I`~owf zYR3tGQK5hP0+oTF)qh`f!Gd-s|8V+9m^-U7AsLo{T#jBWp3JmA}%lBvH;L{lkFGg{6Wex25_{o;?wi(hMC(}=Ke^Fb6RSHO_9-r zs60WcvFmG+1xA&%k)&o z0NS)P*_^0Spr+1|{#c{S?Jy)Q#dPVe%~~l|Vu4c67QsFCh8Iq+qXe-x5;S@F(0g0) zgfev{;sazQvE2=dUqhysPqY5C#Qee?2jXN)!EvDzkGsj=ME10_b0kM6Ne@<%O@=zczqu5_4;N@pu`X&{{+?-Zf|g9~%s=lANf66dp~S4Id|8T)4v8;}_wNbEZ<6(H&N|Rt z2F?fX+L9Xf8gn0PHeyaVjdiY$3s77)`>YP#45Vpete8S>%V*VtP|*=z!S2tgQlvzd zM}mWkRfV;d-U6g8oTjhHmfM39UNt7~zC&k^YnL2iguFJICC6s;2o=G|jvKDueuEjk zih#}_$4OV8Lw8zng12$ukZfdZ;_-79D=dr*O_HNoYmG?>yYf}|*|d|4edB8`zgU5% zQSF7K@x~XM{P<8<*WSbZy~hJ*SYN1=+ZshRVK}mgX&Qs zU+)AyHqY64FOm2Wjlk}7l#8I3@H4BP8|~7LdgH$|Yza&uj{;6qlzMtV@TX@BA^Nghv zMNZb$*}HzMonAebN!g7v7amivgX*#*WvP zam#|IpAixFg>)Z0KRF{$F{!u@8Y3*W9Ah%8uCUzoW0znTosC(#Oy73EB}VVDBUCQ+ z+(ta2TjTaKYjY(Tmwy}T&(Lw(wA|)jj%^&P9ivsr7>#?JEE+pB_W&fM#6Ly@WlN+} zVRd%+v*q}l1BCnO#CEwC)a5X*b7s8{Tda79*?OvVj>7-7O18y~u#X?Y;acEZxT@$4 zn_arN{tTyL)w|fn2x01jk^UOHTPB_<*4&bkI^zSwTu3yxyp%7H3|P)AFXu&YWpNn3 z4-FL}^CI9o;h4_s)swg@sU=im06n5N#Fd^9jLU{nC4~Q-TnKKM%#)|EQ{1e|ohF>>16#q680FzLXw z;Po`21$IUUAYAQAdi~R+U15<+wi(I%EtLZ*%TBL6leS0$ZkRda!4@eT>}5?|roEEI zJJU_w&hV7HpgG?uqeMZ4iPTChg?`^s?U12ZOf7}Mh(`@vxv|{V1gM7l($Z)KWhZ+` ziQD%?c`?!xpQ&KF1Qg-T;JmBPZ$hzLdc+7urd zhlyb83~iQaQ~{W)B~VMClhN2ILye45v9U`##86#6ugu&_x!6`tS#fa%wS`7S#{%Qs zp3_-E6?MBDchI2#=?!$!8)WE3kt(F(BtN0ateguX^BXjryQ$!WAQ%NO%`h!BBrx=& zXd~bw+!|e`ae~CI<56+J!8jSJzEopAZrPt_aMuQ!t?Es_C9 zndRxa)yi~n*nz>(o$N`S#O9h=3pl`5bn#5J(SbiDb5QQgk*Vu%;~ZK*kUCW5bYS*lac84N*AG4^(l5<2R7;%m?BtjimKQP3NK!kbM{CLmN4(33N9a?W8(#`E-U&__C)hxaR4(g7es z+_*?mB63{cQGCrmPmJBXu1s4T(Hvej#Awg~T9%(JhAp-lOcXzqBl59f0je{sXmv9H z>EifV(u;EmK4Ze=l8^JKkg=I?RHB?{I@8>Fg}&dpI9c9EGuLK#l}bujQXR@~m@pw; zrUr@+dFzhZ1zdON?y|lf8S#qKW#eQNLdIgvl>rG{@zRstQw+Cfv!RkwgM@5Xt^a%{ zKpN?O0z%@S?~toz4*eC3&v04GC0E@$vf}CBhS@KSd-ATs3`!;Au1CufvOBwgK|z=K zXfZNFLjP3fnW>ul*eI#_#WWXkU3zQ?kJ zF4Qi>d?|et!9Be#!||AOI^Qhyy6_@v*NM7l)ePK3yGqjy#Tj75LsuK>itU$)mN%P& ze8Ek%{dk!}JlSwL0xF>AmzW?B;Syk$tH)26h^f(>9maUB1v9gAT$k*ddaZv?}uy&dI!*TQtG zV9FKN(Tpkl{M@YS?OrXSxSQunl5&p5#=*xp{LCtD;xT@l13d(aV!iazIG4jt?h}Wf z1@ir%8qztfeCyo9Vw?FK*>Tyb_=%J2Ic;tpB^l$`Hb1*2MhX=T6T+{@z*_SCW5VWi zrCn{G<+Uk&NWN4)V^CL>I(CZ=|K*LFmwME|z{}IsPEigq{c7H0HE(aqtsG5t|NGCr z^igf5Tu~n}iRxJ9t_*Mt=(81n zXmNhTfq8z{O;)nw$dkd^Qo`vGKoeuG>4rF54p`jcx>qdewILCg>R`@*MohhL~| zPRS2#qTi|3BOVH6I}~i_n%>^LT}JX;48;t*y{+1^XCX|o@uZ7+hAcyyuqDHT>ei+# zBSn-}qQMm;l%HT!X*XGUs;_3v>o%s^ExgQw3y7*W9RWhs%^0VDt-p{+4$ScSC4>^Esz?XgMX?LkPtud4|wa!4NeGLWf`4NK=+` z#vD6!ZyYV3km`VmuukbCV%&5l7OH+gtJqB(6dd#L(SXj0|1^HUlYT%p_!0c@)|!Nc zD|;Q4y0Q@5h5K6_s>y+>iNIH);fi=(vkq$7%Ob)$sFx^u6N6Bwx);M>H<8mr7UZLX zlvDq%s92#|)`ziV_#jveE=i4rZ#<7)VH~77yI)MD(Sy$7ENJJ3FppTTeP5F*QoQFGw(2bJN$ZRq8jndcv#Dlb|2PLY$Ie8Z_=RZREvTtqZ>+2FWHSqoG7XVP>VXg;TxTt+2dem zlghWC0v1%rtO!6VqUy)1Ldg8p@q#(2x80^1C#Oh0a>^xMMDAg2i1xE7gzigtE!~z{ zjX{;68mSL_f$CQu4l!N!m3p^Da9r~$3 z;bnSwuI4R#{`IJ;-~nZKMGDF@cwG|GplXmsRFG;JEa6Y(8CZ(Y3QN6TFtBW8HIQ{F zJKzP_XCmv`OBUHs3QdEkS82X~C46+&O9#TJBj2L%ZYoX%i;o6xxiDl!a^gR%XLHb> zjqP%0VS{phBhurC<*gtWsU}-E=ya4$8b{~4Dixat1rRB0vZ4u9Ut_@RBvSgxiu-6p z=c3>4W*5U3Lya8!HYtwKc-Q5O&;*I7q=g_&i7W3ys+L2ED(+S5z^%qsSHO8DNT^gR zHwM*tKkk$!OAvsrN5{yFNV-e@OnZ2gYL6D-Z_?D&4hoMge212k#kP$QrM0!B>s6Ks z!QY}u2^C(Wl9XNJR#SsSJTpAWad`Hu;#g4pB}+eM*5oJr6GaW9XjfJEzUPIAZ8tNB zY_f+2-?gV89ZnDWpL|5O^PikBGYA5!{sXHW6d!h#r9c0%24+A`*ag z8%bldYv7EWGN%pZZOo3h=+4n#peU42GoLbiNKZb0+_ZDKGbtDmed4#SQHAcardklG zI*vg#=Ppa}YntS20?4teZ6{dvpcuse{)Zbrbs5TmYr0e#ReOe;jk4Nd;Zq;lmvA+8 zX_#J9d3N|s;*hQ!#BgFl_2cje#aRY;{LX0H$eUArvZseAQJ=3Q;k!4kMbHEOrLW-| z2y_E29`#of3~I9a1NBMXG@J_`Yi4mdIGr`SVm(rG<`ng*)%=(G4OHR@VOpO4$Hh92{K#onr^E z{C5(-&B4O<|B9eSyFjZa*)1~_qR-9IqEPZ8iXo6m%gF{6^+O>dvh#3Arv{+YNrxp# zyK{%lF;bGDqyG#pN_sy&d+Yjo%WhcWwOR5yT=fQaT)wpv8z>5h{U(F3h*a-4((hG9 zQ~4qMLuwR}4kj!jBJ$r8e|w9cug^Nt^HJ1ECEfWA|5x${5YCJr{m|=DEwC*I($zs* zcpeE-co4iSi9uaQQymi(11tH3Agq5Jf{w+V17ZdZoWoJO=o@V<+tli}*yaXzfvdYG z`adW*V0mn8bA3JY;1bjn#7Mu4z=_f-1?EmV$q7Tj5gi>k<`&O@l+Op}`uf>sq^Kw; zC}?Skk#NW$YGweUN1px#IAqZ`^s5+gupUhq7bC?Hp~~>MTL{TV%hVo-P@bepSj1SU zDI#1B!f;n!CC7fUIFG-b-wn(1kv1G9jlUplzMxTIJ_(V*umV3zH*(K`Au}u6qbxjx zNBfBVUio!yUg>!H{am;TmMeo8C|k)z?gd@KMU|7DyuEP8XggR zu1-V8NPX{U4{Ob1?Qsi!r*rn3sL&2(n;L}=cXcKG;LJt9j}6Yv?ZDZeKHxKUB-YOD zVZ_9b6#meG+&M&K9V)o$Amvp5G@Q~e`g%T(s|hG7D=TYELJa6c0SN3o#sQI{Itfvf|<+cUztGRMf4-yu z5Py1XPIjl#BcYzZNZX6cifG>7!9TuA-ma3q2*&+2Ui{HNdZ<;M`wjhuU%nvTNgUHK z@b?~I9jElTmz}YW|4uape1OVmZ<$Z%c38r`Vys&Grke7?n)=_5aA%pUEtM!lQ7#Z# zz9O0YU!witk%ETE9vqmCfw|aVh*(%3wJUAye`AhvQBs{1KaokN2k)*@Dztf!Z{*C3 z6I8(vV}E(ZN93r<$g84X2j+~U1>V0;8iSGj9Bj)e1v?slfuJGGxnGW!m4QGV1lII0 z(1I1*$5J8*CwdH?{pet{z$K57kZ^5FvCV{8( zv)r%$CI};wCunC7W^R-;G^SU}CIahfg}EUx+MZE>r|atv#mtQ{QJF*{_eb}-t8AD2 z8VNCIQGkBy!2kRk0dN6G7e7b#eUt=Th|A9uFO7XH(?31L4&Vfhm;{+VG z43+4TtkaEM9^qE$y_8FGZ1#y8zaq*yGkdkhD9ci6Vj;waT+ThxIQ@)ZmA5f3kg1KE z!s88DGmURQ=4Q@i^N_-d?*0Qy@50kwa~2*#-6YhjhqSt<1+X@N2g;EEhWcNILBYTlfXh^tu47+YLCBH#PY2Yd@9TH<8H zyP=(U_*O+U8<4!qwa$1FbSGFE7Is(HI@Bq3@k6>riIh>9iuBqkaA3TXQR7F4RSE1{ zGM)2=nZ7IYW^v!fozoYH!{6-p{+9flkvz7uiT%Z=J_sEoZI6|#U}+uLdNN}QM9q_Xv$!N)9U&Kax4$w*8cbqBnWlO@N?o`eyZIBq63e-}y;FW-kWIB000aVv@d@ zTb4<#G0bWTjIc&FXEY}`4wnHfb%tNVmAfJ1esAAe8U%2Ix^N!Mn4?@VxE+*ZrXM2t z2}*u>FCDR)wy_ILTkI$y7sRutMkZy*r!2hkWaxo=G4K02Np#VQVN%ST#`fqwbEvu% z1lJJcz#A(UjEu)EvEY58fz$REBDl$63 zERjP!{H5U4+}^6#ojb)~J?axNN2SyY%pmN++{X1dx=1G(T`2v0I8G|iq?;Ke$V2@k z?k=Z{`Ez7fR&N-AA2{`UA}Fu(*XpQYS&lBdf(S z*9qCNPU&hyou3WNUN#f-cG#5`(}b>bCmG6?j;c%Xpl43%Q~|;L&CkFxJJ~~F_--dX zJc75CBEOo)YQaU8zPGI+*oVBKnXi9(`S;pFzI3BsPMazjMDQgIqc`%x4U|e303VY%*~(ZAj}@?>yzpV6?t`%KU&= zDovkhbLVyE`k8`3X+mDxqO&Vk@JI*hkUO^JANnCxOe-N=u9HJ*f1pUJ<0RJZ{DD3 zaVV;%pPozpNs5fM2T^W{ja<}8kI8vRo-FsbNJ0v`dE|yXZ%CQ?L&c$=i-@h#A?6j`_u0H7u z7;*G_jUEPyYq;Ngm?dWvb{UVpSt8{^fJO-ha{FCKj^Q(*p{Uw&94(D$HE9fot-q~c zx9!XvE$Y|V#^McZTR_L?xZ~S|w?IfJAr7twvXw0TSRLU4Oim`3;nj)5{7Mo)x*?j0 z;S{+=ZVmrl{K~-1hqkCv{A2pBF1yID3o*yW3XrsNGPFkXJoim9}Bu6M;X?~T39C!3SD za)xRswG8fNju3`yX;_{Wj`Y~#G_Nflwt30e@6cloXeSAfPwJ9u3>nP87V2vsk~lF1b^& za*7A-wV97yP}!pa@8(P=sXCKaqfGXM4BWQ<@NX`gXUM1r4P8WUry}id0)dqvarM5H zl>v4^hC!Q~0rq*bYCT13sNlhm@k9(s!M4WI3Kp)3Zf>4PkBpC@umZk36az^;z#}75 z8u#^p+@NadZAAXW#VF&)aI{Ie$3l%)%tLr_k*Np&Qy;9mSL94bP%^~*IHC>^v7vgE z?&G(sj07Kp`EcKIt(i#s0z(k}*F};+>Kg>epS3taa%YBYz?&=Uf&Bl=%)qaBYte1TGWWL4H+vxd`7T<{cN za~fb7S-zW0**5T35+r9Qgz}?uSaCYnlw3Qd68}{$e(oDz_NsH14ZG|H?>~0kFP%6d zn(}+bH{gK61_Rmo;oL7s99tV4UpOJG7AaxFPVtxkO2A zg1)+4=fV^A2N!DzD)tmVdjQ1_r9pLd73(qK0ToLWT9JI2=d-&V8Rbhsb@K=Pr0&CO zEuVW}0X0cA;a_4fR%1Si=(PbXm>r;>Iq$avJ1_SDWd0^z9i{W14vs)x?vQYy7%5H>BZo3YNA znAnlhX3?DHD&Wh{j>X}f6~qQU>bFuhc(#<{rh=tgur|*J15=SaAjwkA>)>rOWEX8) ze#_;t(@Myfj(&X)RAQwrp{ zrXNEDm2QEv6#KTP`L8~y-U_JkeF9>utDHX+iW)?ufUew&C|{oGNf1A!PP%gUFNw7c zJ94yeF5IT{!VJjsy@l5Kxru#zlaI14e$r6o zV=Bhg8H;ZiPD48xK|5wFK`WgEU#V_XF= zRko33KC<8s!@Ov~qJLl3^H#<`{OTiO5 zv|7-RG*?y{+QGMem;h9tIQQESyoLQ(ev#*vxw-7E-%IBUGJ0NON#`|Z;Ii#)7|^;U z*Ib_H0+D*tWhE&OL_C>8_P=v&0{SGwk2t97?{3VRE5=W#G)ZSp(Gsi0baxDE92m1Q zX!^LYhg83!U#ghxU?}tLH?@wRgSRc(x`1vONfhO$M^RX~=-ZWYwDE8pI5{%6*3zJqD?lflp+l^N{5$G z5-OvUIxMr@`JIC$&!bl5PYl>cLySu%j*rNEEBPjbhP5e`00Np3e8?|$ap(kGpcjpg zA#<0fKDC;$L-IxaQ$*CcC~z>VUx~W&%^+gSo`XB&J<$by9c=m{6go2~bh&Hoq6suV z(uvS_n+ubAi7cy%M6mJmIdADcx#tZV;H4wePWAXfg>#JsF!TPx7``$`Q$6fV*W zl2tlTy+~*dgE9)9Y;M8idN1`UF}-IgM__M@3*{xb*F5K55v?2a%c*m%mWl`7xF&Z*DNwPeM~yU0c8sRnf@?ZG$1)ZGJL82%8>rL~tp$bWFG*x;D%8gB8yT0pHU<`kri|MZ0a4#CK z9q{qYm4`C6iV8@az|}BhB~V_Zzdb_<*l%a=pu!uG0eiOAN44zy+Ul#fVTNpe|Ho49s-YdCxVUJ~Li~o;iE! zfh!sG*(A1R#pLcwrcT#JIpPOZ`TXaWfyjR0+OVMj-F@z}O>bM|WVQUZ;#xevsUAaEB1anxRR6}nX+lQr02#lF;dOXL{# zG`2OanWPzW!;Vq^L)Mn-ujW^Q7o=p#jUx1^bTFmHs+&RIx~S zag`19b4UMK?YJws+XT4XM0V$VXQwmAcWXX?rn$i2Jvp}c zNwq<}A4Hz(yc7(AqEeT#0#~So9?5>J#QEh#1C2~Mb7GELHSHi!;6yadZa{PPLSi|+ z{1rW^OB)4AUo>NmW2LIdh~?F@QMFXuQqNxcF9v5@gf{lgY!Sv?q>#|$*)7||F~$#X zL>6C!80#mQwi2CtX|DMjDq*af&IuNt(oKv+M+6tJn6< z6&27UTahHbW!KI+?i8FO5EgIC41WpiQ>)u3@(~cOh4k*`MSg6QOb^Td3in4muX`rE+!T31hCn^Ah1nLEw30?O5JCKZcanp_kurrTWR3w5X`;5qAJxH{kQJ)ad+@24%O}KfcZIE)- zoO&x!V}R0|o2>w-Rk5aSDp}au7luXlzsx;gRi0Q(j7Z`M8hhvzT7aY{SblRH7`SKH zW`)#%=`$N#mI_NfNPzR_>mM_i$m zYknnkq9}S^s3oVWg9ir6#_JG##_aH-j1T8dmn{Ty{o}hPhWwD6u31nxDaOLABF;yU zNc1Z2gs>k-XhOe1`sOnmg~k4iLO|A4;O@MnK#QW=B-Bu7?l?Uk($B%SWC82I1Bu zvIt-J(dS$Zg7yxkK~PTvmx{|6Fp%*U8>ExG5ZJ5Pp0Dq+m$_JnS;98ucA=@bcCxJa zjeZ$^Zd$VO)zzQ?9#rMs)0#*8D?`Zi6Z7Dv^U^Pi$hCCfa7OS&d+F{vI$sgm;gIYg z;`xZT+N(bviKVtwZ)c>4eO@2~U*v1_hEICsj-$gc1nSYPr_2Ue4(a8@R%_D3F?MBN zC~jdRB}T-POsP6N}wF18MHY}&7Q-tYPM?)vGWSg~U_ zvWrUW?O&9{IYzbb0+f{RclEQfn4W|2tiU2&lkuNE2@2A}F|LaCSrzkg7qw2Sr1Q+l z)DS|#R~|yG8ACX9PFaku zJ=o(j6O8>MiOt|C8r}%3nLlNkyeR$crKlz1AOQlC?K$ z%B+SJ5(QB8J}jK$1d8@J^~cxVnpm$KDqX<{~&~G z)4`_LN*IHV3k+Hbo`lw4`^Oq=chbKWF&*|}H==6izZ;I46n0nV)GVC1OSO>~W~OJv zX2qXM>0x1Ck8AMRt6E#c!%D65V*fpi^fVJYZ_;a8?@Zp_U(;-;H3>_OaJHwC3s>BG zvSyHeht~lrVM|_SIr4lC1W?gN$>zObya4Upw_kl4-p1@beB~S+jYkS}lKL)3Q?XQ3 zXj);4Kh0!GbA28kZe9M0@LqFD{?3`~zx4+*-Pca|KLD)%Ak+Vid&==&)KkF!oqKAh zp#a)t!R$QJ@<2&mgB)~|hQJc7zaw>AvD2tnG$3W&l#a_oExPCd#sYt)+M(p#+&y~^ z5l?Kkq)v)!TujOLNlh6{wspA_rx$Ivl>WVBvKb$r<@i7`p;L=)IHG=>YdRRZKNr-u zI4ij%Ves5c`Xy&3xwK4Sw{i2gT-n4U^WL9 z8zeZ@#aolYvpF`%$to2!-k8ZNw1mSbz%AO zwL*-P>34E7=K02hN42RPS5sd-@zThs&|v)31msW$fq~ zL8B2Ng{@J0h{hq(4m>fxq;CVeuWvUD0ULH)TRV$J>o<=!Rhqmi$1a2brdQdZD^8`2 zdfbGR#KDyvx8>0e#5fPW+^C76j4RDwQX?dO@+?THMo8Eg_zuDTDSJj2SyFu^Hnibq z!>rdEh`otewWvG)XY$h4>Okr&ShQURDE^g1`2b4Cd?g+fz3G5#*mS;_I{>>SmJ1TX zF9!4q`oFx@u7pR?7BOP(as81FTjEe(KYg%blyX#uN5jbjM}MtrA+*~arzX^}LMp=b zyGsjT@sK_s_QIb;aomfGK{-&NIg&XPWW9@usmC$jNAcd|la7`l`-#3I`l8RBT&gCx!*XFVfM*s{3lpDk}3UHbmuwOHl4`ilcRch zmxPd8s{YDf+;EoN2JC(--m~kI^YVQhlUrWJnH6Zc%V|C8~#F$ z%8C5T>}6kJ{C{v7&i}<}l$}7Pt|tHZ*)$HO=IUnJ|9IUTEKF=%v%{|MSHpnoO* z#Q&YO0@;iIqj3Xh#QE4**tl4D*jZS)*m*g58Cf`}Sy-t5)l&eO{@<#oI~h4Rn3?|L zgd5p9n;|eOt4nAzNxItF8XMW$|3?>fODkuz&zc36*D<@|c0N4K?kio&l^FQM;{vW0lGgWxt=snoQSwazf0vWuMp6%qWX4*kRm!2tJzIHSyRM8YLNMeUS z%+kVO7KGYh{0Lx5{Nbd5EYX0VG!qbP zsLL2xe^RT)cgDLNM1=r&G_!GO2UIdWg!pDCBg854@T>0jTd07tU%d;3=a{E`KP{XU z)5#;U`=%}2^}nBBZuL^bF{;2-X$s557dYgKb9h;V)@UN*2d^Xvx165mWrrL1gSni4 zMV0sm9EL>LF90{oPx(Ls>WQIcLu0y-S-`-uXP(tmzRA>v}-QK$qQR@og*hO?hD>_1DK_{AFGW1L#~ z*!B9{R3^f1R>yvbhzMI=EbKA+OhnDReTf+zvp&vwa0||GPFjg@lUP6(5AhB$ZT;O9 zg>(0EP&-bHn$gqYeEGQ40bO1#TdoDF5}fgK51{39-||Yse^k5MgFdztve$QxRNVWK z7sH;c-^YIRI8*OS5^dj4iDJAAJ=$52&c@|a-;JEPeL&hYjR*W6yy$;D_TYb7khZFs zIRdkcy{VZ8K$iu;%B_#UtY+n9_AiCNtOd|z1+W2F|H)KAAeVn(K>sXI^*`0kK>*hO zxa5B_;s9NK305&N4lx!99u_ekQBE#45m5;iaY;6DE=hI~9&R>vLBRjL%D-Oz>nH{; zmj5!_{|CD@F*JOh9{AG>H83GO0WlCIJn?7b&oo%kD&9p*fF&}(+$?Dks%{mxx?Pxq sy70meMp8->1}sqm>i^pp%?`SARDy0Ph#5LjV8( diff --git a/docs/_static/big_picture.png b/docs/_static/big_picture.png new file mode 100644 index 0000000000000000000000000000000000000000..c1caca3114b88801782f09acbcb517fe1792c1b6 GIT binary patch literal 55950 zcmZU*Wmp_rv@Hsq1{#;f-Q5EOcMTp$aCZpq?(UG_PH+$I1a}MW4#C~!b@o2{yzk!o zqxg!FxullNG3J;ZuB0G^jDU{-1qFpHBQ5?33JUrPa!i6?Ay?`@1pbEnLt`N(req~1 zC1(58)E^aIt zX!_p&cuO|48bl}SVOq5MMB*OzJ zSbu!N;=f9`al(v3iWVp`}y&>e}f1=I_6YDmwZj+26n) z<=wkC)u5C#vUh=gg711dc!mljOq7gpQ={;3K^M^I#UGU)H4!!-J;!aLE@LV$4@D0- z2SGuHT0j9IXV8!XA96rJ0dfHUU4g#JdH28PlYegtJL7Re{zA!!i>SImA7{dO5%xXY z`SRYZdDfVWB$ch$vn*@?7J$-*9|1r>P}0UTSX!EtEGPj=W-Vy)oj(*=Zn8cSE^9y6 z>8e8_)ksqLTI;F889&7r!4WkVMc1O%WwYn_s^jD1QCHi$#`jnJ6Ts^*pn{wqJS#MH z7cj+d0)zGb>sa&F|9^$D%Wzx>`1d9hSRWv$;Mcb@ph&8g{XcI&Me@AC{&NfR$~`wU zwj+s(&ok~l6X*l}wYIShR3G(z20GlN{xt=;Se=m3xEm?cl#cnv(nmdY>1~vL$?c1lK%{nC2V&WQ_oFT{Q4*Z?8{-gM-yi z$?55l?pJ%8W<8q(z0^hQe}C^Lm&PGu z%Hw`X`B7H(#AM%EPBw-I6=nBswDclFZ32ZKCYkx*q3|{O`Q`B zbu(C2TDqfPZ*M<1Iy&tvMXh zBBUTF_=i>3btcbk4hh$F@4Fjk1lUi^XCuJpXg{s}Q44ABnPTOp*T*CK{Y=-b9#o-Y z@HLO)p8m_@&1-++au1|Ik^tkC!qL=NB0lVEsgjZsc+cBo5qEc<1D}iY9@M+VHFJKT znHj)Gv8%%H74kI=7Jr)LxHGfsv!##Wa(%^(ArWH!b-LVGb=H03IlUqb8BygJ)tFaW zw(VGII?kW+%|)8Slus;pSN&2yIec2GCNM5L*QBcbpax$K#>qz9Bn)3 z?(Xi%l@&(RdWYSQ&lj=2-_C~6POE%h%J|B{e4w&ah&4JwW>T$_GJ->$KUr)LGt9>T;ZK#*9m0c zc0oh;p=Rz)>UmvAz%{$S2TzhfH-+R>s48-Qd|3|i9Ai<4uMS*G!qjOGeaUGK0kmN z%kh$kg@NH6JO^I0a!%;n+}wLjDS;dN?fxNYg*t_kga%vI_z;CxoPykvlk{8!nHu@CFt?hvJzC>3!L-n@pWk~bQbZ4&dnVs0-QPckcX z-0pHGl%2~_LWJKXt+K&2t7IT%<%4*fvkDb5>5bO46pZc(_}c3R3Jfc8%vTitS>cM{ zn?xry1_iw5_+9yvQEELam%J$dxzhm(k__3{(#wkcW&qEcKAIM~qA~dLbk{9#CBomC zX{~c$ekyKcf_PBEN6v*bH54BfhA5?EXG{1bQcg^g23ZhUDD}%i*FLfEhvM^1s;<(9 zZsjMEqY;Bcr0sUiMMP$7Q@B#*(UnOx0J`;f_`JfMT&mQi>aK|FMiWI%9 z!J!-}Pk+98)m(wK?RT+SI7sW@2V%LZQ#|jD8zOS6V_#d)i%>rE@n4oR&=@{HP@oYG z2b`i|o9P31DV3N{DQwp}v10(kz+m9k@*RuhCzlKqx#%F z^7jY9pGC(M-BueYlUdd}2ttN~lQ=2sAXG$72^UN#%&!~S`eK2W6R(|*ck6mpzgln_ z7RP_skDPLbo>zS)$=NcG?icX>z!%vJH=z^Ol=3N*#*)`?I?hf0f#*GBC_j>->4Su| zJ?akoKk3>=>De1^+jGp<8J^KdX_FsN?i}f@K&OS|u-_y=D&$q@SY%30tEwZ6dx;+X zQD4syHJedy1-Z_Oz5(Rz-1OwEe% zPe#(?qcbin(n59xWSknB=8;t=pAa9WNhYA>B@U?m6cy+?NYa7iL`{*#J58to)wMqgoyU4hx5PAwthR9sm4as_%+{iAs#|iv3)Z{R- z1HVSJ_xB)wylv=rnMwYzx$%fW_|k$|PeWkrX`U5}WY5h8S;YCFspdR9J^7Yem+Vf6 z)P`Wx@A?@bK#CBLo2JpQD{wB~{S*%LkyX8*cjv+}-(ROhi< zjj$wsq&?xgr-DdYhKf*46+o)D{fE;X-5)GW$^Z-HQ1kUA3Wu1CQVFpmkE3{oqCko+ zI!f3--@PU*YOrdXrSOY_BtlU>$!j~RYo=$-mHM7-PAIn&ZIz4G_9?Bel+jQK3cykx zXF&XoNl9UJ2dkR7p@Ya*Qs#=uu(*zc_y%mVDHr33-L>;!h2!US5jixnimO7C?H-{j zDc?KJh$tS52lJ_M{qnbYl;)0B-QbLIq{!xdpX?THjJ|X|Cg!#!a5UF)dP2J2nP7GA zp37Pn@HtpmLjw;30|Slt6n`1VQ}i?}wF>@mim6~Ll~S1b#*?;oR3aPrY=HJjgk?%6uOXVt~W4sA!+7Bq7wO%mDMlZ{}eB%32L z8m}@a&H3lP(!tJ&kMjq2EDHuHS?9xEy0VH&;MSI*s#;kq^VfRk9MQ^eM+^Z9DlmLP zv_N^WQkmto)heEr!ZZhOI@HK!mP{s=DywibbEa@$CK!DF0gxn0jDr(OljR2B;o*5_ zY3k@$J2FQhBsLiwEvx1^?{~NtlgX#qqNMS|M<=4x$eGnSeMK27n=WxI!h28E-Bn`f zyrQ5%UWF>%s&02)mD|h|5GdT07KchA=+(uk(dU!p%z+qqMI8mRX(fl zKM?TgAD2r>oe1JCm-X@>3M;uGbYl!4yqyAZ1H6`zN0)tqc)-&&RySm`v%|#6g}f|~ zl`~MjYhf|$bWY`eBd4)C=598cL{kAAMjE*d`a0zI^BQ~uEpRhwtbYV;ijuJ0zp5b=jn+R%B(ak zMQhQkaK+=iaOw2$lng5J2s9Q`L!56R(Hy{sZl*I(o>x}ElX&p9gsG~9?EGM%ClCIzf61cm}&-?DJw%?>eh!I@wt+tb?C^&pc6hZa(+ z@{_m*7sT_#XdfQ4wMDy`+_>KlR%Hu8OrDv1U~5AANc z)OQi?$@_g-cSYV***2^~fiEV^)+``3@1$vp7V``Sc5D{+OGsp~#YD3;7BXyKO)NVWvJN z)?7|7O1_%YPyBq(s=`Pu_REAeiLWA5K_)if)YXuAybf*OW;Qt(^YZ=4w(8jk9ub%n zy6E%P-x4T=DZDik78jV$grH$>zfE;VU*6(e!jX6>AvBxt)P=Oxi;on2ny$^!qA`k2 zs`A1i_3-P)m9RztA%TglR*Y0fBCpt>1<*lAv!=@ipcu?M67MHIzN;rCik+BYqCt;? znBm*t6CavAXn!(L`0$r8K}ver#QQSll=tkAo#zTTm?c?BQ~Hx?6W&N-z3a@Tj9%+Z zyP%DE{Ie4`FsHmvgy}^q8FL%}_L$H*lHy#tk%RP;b4+SZ|>DZhbBS3b` z!JQA9_THJzNp`|YO(5)AO!T3|ptwjL$A1U}e;?pC^&{inhejbGKiq8_yy1F1F7$C{ zS`10Oz@?Xo+}3ssnfxknW>DMf;{AKD9Ru`Rt?3&q4sxbc!Gvg2SkKz57ofl4qs4(_ z&7xSZl6nrVAR_C%_0{TQ{$_WoUnf{8C}WPINd3rE40G#}Ik5SNAKknZ)E@(jmrhQ} zrB;50#$pFzNh78R0&`d*WSfcH-I0XhG)&lf?&%JumGwekDJt3l%T66}bDH`Qreurh z`tNokxGCig;uh45uR^7H>v&xcQ_Y)&5a_;P02oK$`J5PKo7le^lmkMicuptg4NltY z1@enPd`|GU2i(67j{wAdY@X)Eb_xb|dZa<2)_SIKlf**Y&nk+^nVBGl$|k@tVe?Y1 zvlj9np`ENxc6@`*(O|G04)keiYb0ax$Y0t8jZ|oVgt=7?zZF?^uw*Jp;QBnszFq80 zP%Mz)FcR2gb{c6GeKZPrR0}jSKTjc;RsLHiakQTc-GE*0vuYC&2_`wjg(>Gfz+XRT z=tnu$^hSH%p#}Ah<#{U&eArh2@#!yyHcKIHQVuGhRggcdN_Q>1`T))ANG%eU5#oc| zzWFd6j-;`Ays|R3ShNTVA2xmGAFbR@oRI&EYxzJ(nHk{_$I*$ybu$xgF2cE$Afqy+ zAntcW@PlJ0uMYOv0pDMKXJ6Z19)e2GRRH!DQ%yTr64(K+sVV_$dV?%2j)Fh?L25h- zK8le3J5yx)5cdxtuq(`QjUaB}5-}sY3$8ux;JwUfep(n#;L~iKoSmC>{Wckf27zYR z-g|%P7FK9k05aB?+tX{kd4(;G<3X+=ig#{?*oX8nbE^Zi3-eKOxAN)~oU(x6fennF!ZC50z581-9)&!%}@5zJWP*YR<1NtbccPqTP+cvq)V=_YL zydP)yblkBWi>4OWYT8TQ!F6zl$iFShAF*U)0{r?K$G_o_-^@T@w)Li2`tZx z{Km1eiHg5b-aEqn1u9ZG&4pNHZ|iEs^rf}SF8DEe4;!DvX(SiM1_+42v_k5^Vgw(n zH{gEv4yWbq?^1*#Z)khvnS+kI%p^)bzT96#o0nLrd{2J=cWkf#1onst*VMO^2E#u} zInr>oHz4W|tv&|qY|U}aH*B>FdHKIsMV|jr(F+{+ucE|u#K|s6d}5efrJLjY65qlX zMazJBRPJc_m&3cJ5SFx-NLRdln!6p?ZdH&Ga$e?fi=+Tdg~zA-G%O!=IVi)(#&E)R zlrmG>cB%M9Y$;2?N$g+ym%4%j^xGsB#`CeaaJrNnNgw!U*IH+|45`b#Dfq9fCId73 zRu`k5nGs8nk0@@4bp!HLzYju4Mu=rQ1Z%D-4Ei#GbBVSi{zrK$GjXkcl-n) z5*AWYDEQQxw6tQ*&cbdUM-qR9%_A01=1gkbAYU8(YLUlt*w9O=Nx1NJH!SGKXvzMY z5Vy}NY>!NEp;u=b$PAqB(vx)7*t&oju_C9nSkuAzxqg?Fpqlsc-(f>x!k=Vv_|*a} zSO?5>v+(C%lHZdNh4`L*nH4LFwMc$Ke`%>_LNKFb7?}Zn-lu0cX$hDzocKk}eFgsf>L?kOhBlP;bC?-M_ zm}zK07(qg=6C3=?b9fRM#V3R+*7uO-IigSLBJap{V`CuS@^(e;byJmzBAexKfh+ei zr*3yPNk(79KAB;(8?V{+Hi*L-LEK!AnTZ*W)v4~+DO7YjmNe!1CwnJOlDl*+4Xz)Rl_8G3@A?O@Ea$=^nR9b#lPCbo9>i!s>2dnAfrhVb=&yvo_;{$z--VJA0roW{noP7 zV&Y|`sS^>pOf+?wb#fD`3-Mvmm#l6{Ib65_V%u#+4)4n0;UAb9R|1ImTsFEkA#XbSl-!+!vzevN@BBuWXix6vY`A z@JB>TBmJd!4Iv6=(@H=fVvbT$dQPxn{H#q*Za+GO6BC^nWq!WWonjub zK2#noYJ2pA5$QO$02GX?9rW(vzTZNUe4lSdE0tk3ZQP}~RW+!2J zj8@KNmD|tgQg|(uYu|V%qhH8G^FomvDqwxwBnBfRBhm5kBbIGi<(*IrS?>;qa(J}C zOm*Y|sc~b-OiMe~S35mLW=6+(o9ySqF?R@5aT>{rP6$XhgEE5_Y5v5z*z1Cbuz~w< z-xQC_;_mD@qgfGS1EyDtcHSkWJy#C*7@pE6d>PKwC5{ZlVkN$hD3|-AXq`ulS|Qmt zk|uth>HP;O!V&B%&%YRC$ET1A53qPIkH}&>R0i_U zS10$7%lsL7TIP6g8?>V3R#p*8egK)>;sKQ=D68o~8Hb80MVg=Va|X{gwIb#P_EMuW z^Fn9nz3$U``xc?a>^P7_;td5EC6VNv$&}vH-iAp6lC5Oe;>zu4!>Wa#WOZ7<&7Q3!ZQ>ZN^aEPZ1!0z5% ztCp&TH!m*u_a~qRiHzuy?VKP;0Yj+BcpU}1G5X0_dmBERt)o2m7XS|o85Wg8#%zxz zj7((p7CH1jeAUDr>|Z1P!*Xg0c$k9tyXa=A3f z%3PQfKVnVPRW_A&BYn_(t93GEGYs!1@K^kw?u{uv8-Lr*7p`wS4kNkF159_PgfB4d z(&Yn!K2xA(ZL5o0cDkL9h=T%7!x3!L7%K!JbKgCttUP>v9@kB_Pb%mAiDRt6FDy!& zzfUDtwo>xkaL47d{K_7N5kQ<-FU_xk8l%!N7V&Ta>*28Wx(24l&vedM{9RSL zjQVc&ieC8LTT|s*VXffA>l$U0kZsUFa>FeGTM=UQ>EuZ1v&6PkxwzZ3cvTbB1aG9z zEsVz4G>kMfn6MxtfCJ)d@sjtkrZ!SWSn0U_gnt8f?2U2GC8x>bW5go9*)k(GH)e3) z%;eYBfHVUsq)sPvDpTM|~IOtfkE7b_`x%mN|p?06@Izu9Q zRB~fhQ*#T0*BC@2kJf%=_ZP?FV3?yTPGr9smD!cm5(|u7Dsen#39@TAe)Sk(*M7+g zxi?qvJuq&e1BNXeuTC2ZsE=L@nDyptJjbUv?}|_U49$2B^ebtVK&t3`r&46}>wqni zOvU~kO7xhKCn0LaYksov%TEb4w1 z`-)I~g*iePHV$HixLAml+0^^5^MdVo^##bJ>(>SY6Ic95|1;A^cbVTUZhx5mc=qs0X&ss=S#-|)<~xdWdw|V z8%(jqM8)yj!=YtuF+awo)-+jFoVi6i@q5(9FkG}HqzqLOzxN*j9P?hPqse9R97u}3 zfjl=RbUUhNeC9C; zJdg@2DQp$?d+k7VRhMcH0a`51-}@B{*XQ}8WL@_!HD^RR%JQV=QpCL|GqfB|hQU`! zS@QJcUmxd!o(t1$4$DxYaToA8tF<#E*t!a4=T?{w0?&@9R>lBGWZrQzZSbI(Bt7}m zjQy_wO`Y)ovB1^WK!MhzXJjz9JZV?Xn0&$+RncPe6_LFA)Tdlcj0#6K+@bimvJx;n z@69A#e2(wqw-%*p%i)IaW|Ms@q~#w2$v;`oP8{ADmkbZR05N_Vau89H@kxeg&(wh- zG#N9cu%SW?-Ao}V`d3LSGg0fsj57{@w9WpHF7%e*8$%-%{BME{`SIpT)uOQnzY zOTQaDP-3Gieu){Qlbe=wg*PN=a^0pq+pmw;UB$;wJ@fF6x7p0unUm}50_k1hKkJWK zL>=b!v_R1$Bje-h_qOh|%&aInKQXBj-PRMzbtMOR#JPpUMlD*~IvG-NB*%g<^})~% zdRQi6eU`DNHYhQKX`YBQ0qM4}6X2j(8x04R4s!4Tdi?rv!Fex0yine30@pK6yP2t4 zict^)4guSUB|dDT)dvCNy@2gETs*w+X2*SUPR`HxZHr|^OV+9RD#l%Snn(P)j49id zKPvf-EAxF-m|^_kBS&zQQ<>4$)lto@K;a_&QBP=u-*@+x>@JdkTkrE~p7*b;ndd(` z8jPG}#M(z*wy~F&nP}a&zk%-|VbzQFGFv}7i{JxNSKPV9hy?uDi?*`phV*E-BQ0TU*z0af;+3S9&6wGKRQ5^oEYfBZIcEEbyHN{^ZP_QO8KVJB%U_8U&r}RLJmQ2ES7qbv1ol5dHxY7L5A&ll^$9 z9sFU%p6Id=CEg|v^Noy_LutGymdBNw)?>+&q$Bcf%@eiN^-NMt4QHHZpU~DaW`3@Z zfxPRcNUUSuG(SZP4dsdQk^{9rvi!Pe=V78Q#6e3X6se6|AxwLal3P4IxOCrYOlsyG zw8Y?$pT*%!iQ93_02=lj!R_MADt+6;APu)L5EUUY6JRJBPxHM`0{{?vF%@vKR=$g&Z^gyg9q}J5BL}z*dLGR%^EDI^N)IpVsG-@3iTM?98aBDO+-{oka$I`x zFDQNj!jkW(vM(M5(Zoo3u0rFrmA0G4g3frg8JmyS9^{`YE?+9%p*vU#+)SEHWJND6 zX%h0g#f7eXex_6({Vcr2_?OHe@%Kk)o+gKo89`RMaP&JLnbaq-Fb;LwyVG=ZKJ(!G zQzs68qk)*AhuK%hog&9#-=gwRV%mVgYfw6okyPemCeJ<|a8Ru^H+Qp~=kh&!$+K{P z&%BQ7W`Znpyyv%X-@1$)+RhV)w_fN8CQ_ef|LpX$LVKgT-L1OTKw|BJMveXrS$mVM znjd#3pM*!IuU`Ku2kh+ZvTK%wH6{sp@p>!NYXBl5U!AO?X(F3B=^>%b|IwI`kazVQ z3p)L5D*cBjfWYH&bbYo)$>2_iK;$2#2_(`FAt?@w?LYq~LQ$vaGPH?C@E!P9;Ud=+ z3aUn$X==?A#?>k*6ZK!<=-oQs1T!fxru$BP5#HKel*noQxU^cF`CG- z;s31SL!>cQs`q^VnuI86#34pQ6|mL5|7*1^UD&{YEFvO8TXRTE53A=Z*D_OL-wHGF z+Tj0~5GI1gxP-Xl$c-xwkt0BF2=2KU0_$z7T+ADt)@Yz(JEohv{SE5<)6yFtIR(Wo zf=?Z=oB@~_K@83t7?9g~#6E1p59AkN@qSLQ0FALoov*FQ&i9Gh_KxHt<6>`~v0Q z7*V=y2OcLUXINxp4_J}kf3qiaC&`ZR1WIcQ;qeI*zKk#1zj z`!PzVmucDW9DVwBDj0lQs1PI$q%ctjNREw3XlrtaQizSO#djJ2~lj4%RZWYAS@ z_w>93QMAunxR#1sd1dVc=xheKygcBZi6POcq{IbCKy65VY_f$)AKOtD|2Yd@9gQ`- zXuoSixb1%1bxQlUX-&ah1=*zEgHTFD+n+_o1GA}37D$|q6hL_Zp>Y{1n;$jhMpHvL zeOJS>vT7@)ja2fh&-)$EXGi$r9`h=E*%eF+mx^-sgk79J6(YS*c&3 ztY`U@eRqV47w?c-v_|SrPv;+G21&fmMJ({VpH3R{^YeSEmXFS&kBX1__vY_-zf!N- z3i{e04hl+H8M4iPjJi4s5Kc$CilC@3U9vpn+8!+2c6rBJOfPMgDw^krhKup8wk8^8 zb!&w|^mWbiY{=GZG=;vC=L6F<&gEatm8SU7bJ5oCF`BZQmPF*zWqq#H zDfQVr-p+*hK5epJRdQVc!bR2Wvk8OrvtN0aizQ_7JVr+Xd>+e>WCmTUc!DDGIg1E{ zx?G8vbf)d1JbtYujgkYcTtk&r>LCc8W4CA&BB-e?LF^xg#pOHf)oXV=voCzL(&HtRSy9GYR##EtIyW$$e&YCyYy1l4qp9d}}PpdU4Ke+Wf{O zX%OPwdnP)1k>!`rVV6Iv178n=YT99$O!V@~cDYAI?~z0{K{3OUs*j97i60=fY+5F3 z{JJ&))5N9&%P9}bcf16V;#!($kQi3Zxv}^UIWhBNJ2w6U0&6^uFhQ@4-g0h>%(dCV z%FwJ26mXc&{)vu2Op&U^r*ELq-(gGL$vbFXW-kVHpU?bcoRB<5by&lAZYS@(#0#_D zEzyv6F}f zO2NzC9{iC0?9TKa=JgBZ2up^yEw*CDH+ok=g#2o`liUdb$?Fu}pf0t%3d>fsZcKY< z>M)SzuW{mjil@}ERaV>prTT4jC(iJK{iup9$!Vr#Lkz&Wa;qA@vMU)Qv*L=}J?v?G z;?`#1V6hxI?&yV15g{=TCkuKaGhuX`-Px-S-`7D>GghDkDWiS4o10+7Jvu{Q;I*2$ z;03%~=FR0&zEvD?X={3He!EMyTh2K6!?|=7j#F(DoXZ@M@M^AFZ+o?7gTxv^@FvMB z!*a0a+5!BPvhr$3^VQzN3n34T4!$50!9YWDZhOr;sZK%v(HgqRC4v){9h_Gu<`B7S z1so~-W(Gb|C#AZ1<+O`cfN`{ZeQR+c~aG|9Fc2> zb_j0xo^#tJ)GJ}OE~S@5I7aiSBH zH|w%2lCMYQ4Nr?+&&yEyV(I6}vXpufsXZ#7(pu7{?5>g7%J&zTO3MDExUu5Vg+A2< z+zmV%*Dua3#3-MiD=C6Dj8VG{J|DiURdg*CCxeCNz-eW^o791GkX8~r6A zlpQ+QWH-fE*UphE#c%=#XN5z4s{Y*Dm3>h1TU9*;*X3?*s^fGH!CvU0Dx!9pLW;5* z+#fLoYkgHlk8n54m?YqISfhD6X|Z}b_lWYxR{jpdqZ$Q?D@-8=x`TQL)5?2!`DvGS z-TlKvoV6u(K5LRyq7)5eFTA5MT5)$b>$RA7*wS_=Igg~JS&&C}f*1M+9s(xk6VkUUG&VTwbn-bS?5Q--?rYDr)n6G%auy33 z)`wrY8CRDExdxU$orUc(D>FIkqV(U=8+_G@?V41#wTf6i6uat4UaKvx3Vj^{r=M5o zF?DYuQ*pO6t6nc@1y9w;2r8My%Jx9w+zYjPtPqyQmROUsL@Kq}rBN|Er2(cO1ldBsIqiGIc941OAB3CI(O_t)_I^|Y7%$MBQqg|g=l1C&L$ z1JzNwPgC*o1>L;PPk0w0bP39TvQ#c@*XmVREfp#!Linh9(o%M4ABvts9%coA=9ZCr zgR_Ne?oR05inu-QTI4Lm7!Wnb-i(-0h~;A6{uO<|>y+LH{YTe+qZ_@s{L(O!lxQnm0Zh4xe(Web$2 zs$hjB-8_|hr#+Uk7It%`yS3H~SND*YX+9obpY|j~8sriZcgJ!%;%g&y5tB%$S|Eh` z`t>`Mj*8|d#n`(C?7KO=6}%wy>Ll?yNdan%>jI%vrqKK+#Ad44m_24M+BsQui1aEO z(_y5c>9Jk5H)Ex~j&fLWZfh+CLJ@O(j?^|m@_$U(K13~Su9O#Kx_et&+OMDZirzDG zoNpVA?CY8)?AOGCE1IY1yLqkyg`|6U`tc4X!lsBSzBN-wKan|+lEq;SfM+S8Wf0iRzK>B9~41k;gb=i zGDCUTN3uQ?X;ExYu+L99Y78voQucDS^-d|Y=sn*Fw@fD|`8epU7F*I@B35ae({MsV z>*F5jZA(#a(#%d$F;)GP-}6%%!s@9J_k7V{MtAghjKcHCtuV^C@OB$kB}-a+x|XpH zCvq9Wb8fgHqx1lE2UV5ns#Juy_4F1Os*1N^*oQ&_VOqdJ20x(EYCY>)c%%rq|U^rF_^#TGj;QCqyKE|eJ+iSM73&x@xJLw@}h zRd99=Payz^p~dq{fF2!MPf(*tq8Bo#@@UEgR5MotbeiIAsL7Ny!p3wA8fS9CRM8i< z9CS3YZsA1Rt(j!{nbph|$_muSkEDQ0%gYy`16ktww|7KQad>DSEe;Bphw`h(H`FW*9aB z&vVQWl4TVSN&G1A5{R-cqA;79R5o66!h@Z~@uDq>L8ntequr}YQ!JNo9f23ARSPzc z;peY`np%u(n^V(WEg^BMyqB}S^1n#!?hsZFfdtm(Kyh(Zn)L{LuBW}PFHaY-MQ=ed z5iAAzzu8OLhe$z@|ldI>1tV@U(c~Kyx7QnQ!tPtoZmNtqSmR@$4FsZi(1Ot0y3|Zt1H(bv890TJjbjHz&np+yX#Tbj(~o=ZfMgG1CRQ z(8%{1$ou$p!YXu}ue>FFerjurk3|Syza!zIQu*+;DR&8^j==Ms2$1k27AtPb77vH(VRf20PO4e4x)s>w46vcw5hr7}h84}P?d_3F3!@X# zY1(xeg3{s;r8|q}y<}*-Da#3#rtM`|+$@&)v$ZD1Ho=ogy^&y7SrobL3K3Zxvk!Hl zWD7pj_n7`BoaX5c<>1I*5e}_(O3Lkw`|W@(o5ZLr;ZNR07g-y}jpBmZ4!O$jHX2t@ zx|DY(H%1;doYrYA+=u=Ypb)>&aZ?s7O;R!zIlTUGnNrl5ZSbKXHl*L2Gsn@_EoL=8 z3WF`2hJ~a@)FwGW@B@nYV0g;UC49WfX(j%fNjNK%%;1%WbykV!=fmAh^~>!=>Cu`K zV!6AF0@u<0_isKJPq!zIuYNvFGUU3+6xy@CrTPT1_kt&bP5Z&@*~xzH6w zfSVr#VWe1(F2mhk>&-46kE$rx*)e=yj`Y}UGVWSAp+SP~$@brd z#wev3#YGXn4@yWQwSmH6sC}N0{pWQ(k$qpUvQ79cnZ%A7pfnLYq(@mPW8dN{%9-Cf zYBy;uZ-ppEc5|I?+?awhqKv+)A8`arb?om9f6RP`uUUiwJ(j5U<;$>%;mGi?`XrN5 zZHiXcM&n;K$DE<#S zAPJ~Mb12odw4~4Sx|A_CHO;H9#}azIh;_Ec956iXCt<=F`xlOzVQ@EfESMa{-{D-F zWqaR_2L3q!qt+fB7(1%`LoKWc>;JZDjc21@G#N>mj(ggU6^dy+Z9!C4&Z_@@4x6P4 zhwW&~1J*|Uj}cJ7*f4OR`E_CQZ(X{8ZNU&$p)mu#67D}xPXkGr;e(HH{a-eN3BqQy z@5VL1eAwsB$|EnhY zY_1rDXZ`=Zq6MKuJV#PDJpLs>pulzskg6qaxPADq@@t}ya<#^R^MU`7B#Dr!Wda9U z{}DVu$~wn}l)L6Y-9-Ff`!XQ8MW>Y9YtesS*^mJg;ag7q{=NNE3_n_ukk4h*WY^tM zBovjz#p1@&(o#uHZGV~_P7^osK^Xq>^&cZ2z})IS0Nhj>9k^7TU&Fxo##B!3l37LXx*KzBG&5v&4)pTuwrB^OiU6I5-`KV z!?4Z4MW`hATJZ|LJFfq>Zo?WFQe@g?%%1zB5X0n#)BMnU;2`QN5C}9cErqCNVuT)s z6z%%3)XeF7lGzE6U>P;*q!BzI2{Ikem$JqtCS)uuijMCYgZcUS34I?%^jHnLfn&Q( zR*+HS8o%rC&k$p#j7v`9Ar)z)-ci$aFF>?9$drJAfq~Sn0{)>l9Nb>|i*Zlaj@KMi zJYp=a?cU)eCeq~abT=1 zee4H?%P7h3B{Eo&37rRB`94;4@S;o%K)Hcz%|u&S*}EB$cyMqk>ZH!yZ-Oi#sZDN3 zPEM4RJCCH(Z!^=_upzu?pJ7=H#>s(~nPQ_I9G5UuWh56ByNL){t^fl_PSzqO5IvFS zO`~xG`?ibnDhuE}6)^J)o6$MiGBCh2r!-=5Xn4_2XHP_e4?AF)(2%*CNs7i>m4kzW zE=Z_O6o~L5z%cHt%#8)LwBH9e0oAi+czX!Inx!l9^@Pz2NUzv zWsjYYd>W%z7{p#D2ZtDnV=CQC10-R#ZFLMj<35pOC{!A#Bd?3*H7C4jil3=o(!Q< zD58R*^H4aF?vuv#N-Z+A@ec9><2K2pQ>&O$7aQ1lQig5|##iQl?BScdFB->j>1$IpXb6`0_-b0Oao5&5 ze%VAy6_|~L=2pj{wLZ8}fX|%)eX~V&8^$G=&Ysq(?;Qvw#ruqA2E9BNoob_jFDV-h zr}t#v!lsn9!ihspb?sqFgLfaRR}30{y7%4jPaSOjo+J$k)mywz)gddQpE|$jobwI9 zHmDyiNfu58rCr3lBP+^)Q_Sp|GYT!gT}h<^pW^^HSafF>4wME<+VzOm;2e!pIyt<% zPFNA+*FHN>SH}Go3A@NA>4+)r4T2{5y$VyE(wc79c^RvkRDyjFXvo}NUz@K7|M)E3 zbCe!K=%@KEcC4GEvE=2L4#|6Z`^yuBKla5_Vd$57i|x&KrDp<`BiFND);dHBEMIMA ze#D&Gux0Cd&0&V5c?+b5LUKXshU|`{gC9xX8K=9o6%Ge-UayJOhm*NnR((z{4Mtb0 zGAUgW;3ff|GXYi&(-cNH?LTP?>5zvZ(B%BAA>M({=OQZO4R$d&g2;v;=FA3Y87Y=q zc{zz{>Jvj3vGg@r3Kgc(_j`eu0OP8k`S)R$Q&d%$S5K2eh#o zZfD9`l`MO|dADTlh!cqjXl(V-c96eM$`Xl+p96lz%_J<)w9I z#k_wd0N6ozEUo^$==u}5+fBTiC-WO_1%z=4NqzgAbamJHMnoYMLui+(i2y=D5|1OB z%zcUeWGZf+a-Op%4$SKz=kO21JPvr*uEpGJR{7@}3Zr9O(|tck$e}(wK+u?mvTO`O z3l6$wXy49IU&5Z>Mk-osaj$p5$E`cdxt$?hJGCW0iv3Ra6qMg<_(v+Zc?i z4+xE^s7q|56bum-dh&5_9yUT@;L1#sv$J+@jv+yWY=wDa!laClx&^n-!SeVCp|t4I zAz(BN%&6vvZ4p#)%jq`dZSC&sV#BS}#7NDrqo_`{OALNbOi7Fj zpxQ2?C9&>!)nCK-G2qeZ`F#ww$xW>IfRGWN56|5Yn!q!h*rzhJ75B4z^etqDaCL@_ zDSX*tA_qZ9d^tjYYjbz|{)LCU=ldqzpXubb&L>RkY(X!~FXJgy?mnvwKFT)bz%kTm zC5yBsx=b`#QJ07-o7CdF4)v9VLgbPCxXL8``xiW*q=|99e3MsJaTzQV(-NI_tYn0N zDpkC_YC0=+{?o^t`>`oB0V-RtLn$~~l`4{KyLi$r1M}n$Nm#_5M^$E{y2AVg8Xr1e zrg@!V3TXM`T|9z;)YSU7xYPHIS)Bk|>z9uqpp0CSfp+_Y!T2m=6aPMZTdnmwE+VFHFy$%yV9LuKMQwH6h%Zw- zAVidS6+@Ljo0DikWz3y~98!WQ5C>6Hb|jxG%xcTny8c)K9|>AII$X-s>x>sQDY9~b zUaV?eg(mKlhH4h87>gGJ3!9q62P4Q$W#T!QW!_KwcX7T1MPQ=%pt-G_Aj95F>&tPM zLiuXv2>pC{5GCI9dph2^LzmZtzuv|9>237S(AOTAk@I=Zv#@mc-x^8>)E!^DIaE&t zg4A?<@D%wkfUrg}&*c#pIK*Va9SI{M%6uoXoP zDbEm(WaIU56`2eD&4$tkyukNLNmyw*8F}3*1tGjaH052(p!z|bQm?^T%7|A^^06znh1r?tD^_SoTX{_|Q}?rMb%O2S6bCW$ zJ*7XQ~f>zW_WNDIf0Is0~)K9UNVu^O5d7R2V&{;{v0|F#1Oe1mK15vnMQ2g zL-MFKLI#~Ra(P(>X#)EvdGbMayU6wG?Ve>$Of_}V@>pdF-m>L!-^fJqK1oadn?dgh z99;K`1?@iW{t_s*wf-~m@hY#*aPBAk{sxI&c~T97`Hi4jdFYxe8jG*v^S!;c_s#49 z8ktS!UHjSQ?XoS2QZyu114)PQI{yV{;YbDf)qsD03*fKn9}*o2>Fw=>{yxMP$^FuS z;E#=)bK~Cm!HP_?m3MM-i5>?p=kt*H6tu@KMCT3#Ruc33YHu0_6C-K1lhfReEKg+p zlR{X)A%awft;HfN6QDeGS@P|g`~Z?9)pXvCc(IpmyJdnto|I7g7h9{2yLLY5U^@Ud z19oZ!9C7M0BmV&u=H$XPD<6n?NbjapP%~F9h~0P4=?-Sx%sdWWf}cZ$p2=*QHeuzT zd1|czJ~hD7lf4VnwFynK0PrI#;eyTva6niFn=~FH(fA7Aa;|mgX_; zl(Hhzf+HXN&L3{aGgo!kshzdVXlUJFVS01^Aey|GuGq zLjRy89;V&Wh}*Zq-3(J3*Shbz(5XsndZs82mp$ZG-BFKc)e8VieBU)cIt&uwcOQ_F zG%Bw?&P@Fv>4qeJ`wUN{B6c@0-(IPVCN>J zFgGi`T%dp9-B4|jMiT{N6`S4rR-s9yH7Is;$~X1@vG-O%b#&p@E*>0$2Dbpg9fErx zxVr?m0KwfMxCeK4*M$ZN?(XjH3+FW7-v3{9F3*N-D4Be-=s~@7$KwfxP-|koFd2Ln11M_pp)fBs{lucL$&<{5y_?5* zL7ZuCtB2RWjF08mxi~KgL9$ZN>wgUee*G3u?M5Kmk@vZSY!N?S(aVK}Va%$5u!~i^ ztG(m|ZmXk|@9(Mkv-KdS?hGJkXt)RZl*SFyMTj{6k+!Jm$#~*Zk#^ZNk%i6kcKb3R zBDVo8&alWCkoX^Mi~Kw%=ppoB$WU1aDizEggGf6VFiJ@&_T`f1VH*p4Rhs zXL5vPN=?pe4c6;}h88nhR;N3U?}-<0s34PmRVET?Y4s!(^_EU09s#IuP?Vg&?MS5Q zQ_peY*Hp0!WbNyt#D{x+V0b^03*j7L8(OZxZbW?z6(?xzwUjJn z(i2b8)hU2IY~){0Zr*=M#F=q9EeNpOpwgsNRoyTD#fF*SBc#URDtL;hCjHgh{0s1v z#`YCmsM49Tz&GSjA9Hdvw3t;@ZGpKW%*OwR>m(85jtOw|LYzNhxW{YAMs+8( zF*QekBFjMj`H3W4u#EbzVP$5*`tIkZI<=ZF{-Az(#vzEBzfur}-Q=!0*qyx7E2LB# z_&{b-j&kba;bFUIpxYt``^ay)9p*r|IGMVrVT0!8n3w#d0^=$HR(H$(!H0g2QDO-8 zKXb%$v@buI%ZwI|qeLKF2VngEFcu^I-#l^80mNds{m8N$SrgM@xwPybuQv3aZRbrp zP4^D_YLfp?Nah{A00;O?lr;gL$(fr8iwl}Mnj}(#9PSD|lZ8#xVh%B}*`91>*fzAc@Nh^quxMsOFdd-MU}DTSQ*5?4kc#m}G>` zf#3h%9{|`t9+U@A{#RmY2goJ!PfWhc0LbG%NXmP>WnZ3*>wnoMHvlw6=e!fbM(}?` znR`Cq3;+KH{C~RxI<$LK@d(s%=|V0pU_2dOUf#)-70*7GXTSdyoB&Y@#V^|rr_SkE zjSomPE_C_`MiFvDVVuRpphw_yAiAu%QLB|}kiD6XB>M#uyPIbRZ@;{kPnb~Gd!s#* zc@ox*R6smLG#FJ}SQye2FiE|KxBUG4IIpkasItwVAoW zi~hOUXuX{OW12rOFjJuO`D*wJ6H|Y)-S)+jRh0n{_4AetNb7}x`}UUxa1vVsbQFy` zQxqV^eetlLHC(j+s!G;XM12(S0j)L}9Nd!yTu2Pe7(ZCY6EKrpwNIM!m4S5?70GxJ z3Ak*;+}(K&65Rg_o`047Tf%+aPvWD4$c-(^Z-Wn4mneCV<#EPsmG(dOBwt!63k!>T z-~s{wW=A@Ylhm4n%IQE#vTqdpSIRxWnCmMh)^psn>YS#lQ)fEb9YZF1vbP!e-|+E( zsjaR3H7SleNdIpC1~4u*OuV*6P%RYMnj;oxrM0z6{^YSyVPUmMkr5i1-j5bK?uP}= z*O%Y^8=U-5L-3?-qdymG|LLi%^#SoFp*oJIu?*fPQWI0tyY?oq>0lh?9q0A?@|Wx@ z3UzsT>E#v{9{#j;O#u7}VwC^7v9VFW#=yY9>->KaIvFtZt5XB8iSO~CA_ViZ6m6~8 zx%v4l#=)`Hs3=rCNh%(mB{@d0b?$b&34cLvuUO#k-!11qbXbA^U_&-BH8rJvc7M73 zf4{>}P9PIN>X@6G$8_YF*5Sbgyr90KaIN^ZwedagadlpPa=^HFw;z_NS0z^3smM#I z%me*PdcI|MI4M8^m(N-1UP$JL5DY32&rH)>AOhy&|1>}SlWBBF$X`IfWLgAFQ=0`z zdbPu`o>PM)UQ6{B&etIO?YqK$*RzN3aXK;Nw`L>w9Xw8vBzrqGAHrbLWDJdCGB(oUxX;9jY z^Mf}cxz->M==tHBdA%MFi<*He5XPx;Yzt@V_=JQ*FC-@y#m5e+FV}8DJ#V{41>TmK z_=Y{5cai`sC3~0IW>4T-%h7*fvH#xdw{Seye|t=d;QT(h^&5r2wBYk=7{Wo4ud<lVvM4-OAby=&H-eo@ zR&=%V?d9BLK;5N>9J2Fjh|Yu=L2GBXq$m@hKQ*uRD2=BR3z;)UAwTH>C48O8_az2j zuJ=Z;Lu&PRO^VR5=YAuC#MkQFj^bVD`)9G#me+~-DJEIF+rrv9A)IVtniDoY=hIN8 z%z4LCUDo zbD)q*@W)Y(3iI-xiGbf1icfLxK|g8L}w!(KL5y~*z(Wd8Oe zOtj|}G@@v)t%OhUW1CxH5&1)q(h5L{Qkepnl7|r4aJZnky`4@NojEoV88PGgZ=rhw zgTXphMqz0{Zpom;-nxldnDyDvY*My#6{KwY3`DDdgoA&rUmoN36>+&(y1< zDQt0nv55-3puyXUMHT12q@XlZn>dcWt{Ck(?E~IeXpCQPIPOS{%bl8JXlS{nhzdnFCrs@=NTB{g$|rFPqZf7 z+EIBgK%n;5uZ$LPasjU+D;CeWvtr4$G2n5cB1{lI+_|6?*Vg42+^>=l1r9C{ASeen zKX(jzlkE-VB0(dJmLk{DnSi!O;=7hNWsl|!Y^)B1yfpK8OS?_p``R|lQW~!v;HElK z`*T7s$d6p*&NOyF2lEWHBQ7&;R|Hv09s)F{s5CUy(wX{v^LbUn&HX(@!mh$zHrVI( zUisibrZU;uDs{T+XnTDaSz!Y&>xb%V)b;oF4q%F1re(+ubx3KBC2pGw1_-B#Tlfxi zK18+y*dxruvrx&Ar~tAFrpzwFoUK#fF)WZ}FMicsamO!9t+72-bYuFC4UR8{0S7NM zPQ$G2h(G}shL!(Y>HGK4`h}Szf8n0>dL~NB->uIZTW|h7{`uh{iG~0#>2kKy89v;_ z0GnFrM>XUi2*C^2=;-2e?`Lq7j5$rx_4~Ci!yM#f5?@*H$jOp#R??RCjG-Yu)k^dQ z1&HZBNPh$;#$0Rw7_dGU`1_z_x^Tvc+9GQC%o$)}lEXgD8%c;4Z)?Q}Y9?Y~llYVy zQb6d@uy~e}i$M`sW&ZWbbSJyE7$*{&0RV$2+BJWBrQr?k54_Wh=)o+=av!RO0kX(n z(jMN6RKd^aI7DG&n5+uTXUU~=C>e2n%{S(NgGN-@N&S&5zVv(Vwt zTEws`ZNvH!RAWeUqDP7VT#t;`r;{}=Ux zGu`s6J;~ESz6AUAh#gA9BUkYi+k5gUMyRX2I6x@R*HJ#_P~gb?*A?UYvkY{6yg7WI znT5)lCu@teFiu57MJ8L=oLpSC*Vb193ZxSawrV|3v>4nE)Z)mPA+CLxQFeoAYc6MX zHN5vd-982(7!*<4Jt|`a*?cyj&T@P#6VPLd)cGO_^FpMvehgQHJWhv85$Y*p|3?YA z^ZmIS!5|_bUEXg;Z|@7f!gkz0q2hh+)50`V&SQQ`MYzAWB``4_{MR%p0{Du7#PI94 z(cy$v#e?~yI38|9NiarBRZKJwY#l9Ad7_WhLpvv*$cjaX9z0(tKiW8*Bi#P12~q{J z+^syxE%4T`>%Ei%{eC!_EmN(k6cfFcPGU^3N}G-=In$a?4@^%CEtuUkADm6ncg4;~ zpgMVLll<*)YI&ZxsXhJev*B|s-}CkC{zv8X$RB}2%vFw%sA+LdEnS>zDG^kfnf5G7 z@|nN)D=3FI-P{yWr5zV9JYAALo|2avTj}x+1pSV}rYS@wH|*(+?6u7#t1#F-Pxf6# zh>2PEemXU`vFY=FK)M)K?d%31RN_o8SX#%+|EgUf$T7QPc_}f;L}l;yv-JKQ#8}ko zIYxsH_ODfg!l|qt!txB+6=bd_`GdYeTe!ZKfBwCX$!b*4tUR7^MqNpmS;Rs2WkW5z zIV(ooJ3sji4R;#ZQGRnq`mb$odLkR8B9&bSux9Oea8N%0*uOsy6y)UDyJSMLi&DhW zWJTwaGZrXjQr3~D2RQN_TUzLsf1m@C;kJKGl7SdKlF2ZVB3t0h(V#RNvOHecBe>O{ z(!I|wp1Imx@RcxesZhqXrS0%04Zob-V7eGa-EBUc$x%4B`9M4gFz`@h!}5oF5< zsDwtofTze)oZie=PUo=S{1CP$n(vLTs^Uy$v4QG&kRlNYH%t*s65kAQ->9xe>z4REOy(REdD|Hp;fr^y21YLOyc$IR7q(GCpk% ziSSS)@6GUywoH6go`8T7CA2>x0d`h`dNEeD!JkCzUQSfaY0euo3LfrC*72=u)m4|x zUG+epEWSn>c4=P=C-hv4dN4^o^fLUOF;x1AHa;ySiv_AY5lR?!kI?<9BSRr$g3Fs0 z2sr(#<^CqdXpgTxF*rF^c05{6*pDm!9v2fHpa-Sm^Xo8mI`|Q~H#K$US>K>5s_HPE zQMcdmIqF-K9z`xs`snjeg||w~i%B-v1dsFTi z4>%7qG!3ke0~L|&7qzn&ABCa)Jc;P7(z41pk}UTlns+qi;!d2pSx`Ev+?hRl#5Xkj z?+D+U4Z7s*>|LsaqPSf?;e_b5&@sr+j2J~G+ZN@pi|<&&mXpzGnS2?wcg_6W1$fy| zBsddzcDMjwolL7Ep$Nso(Ha^3*k2eJNHZV+>vDf#pyRUYlaJ@j3IetKtnM5w%bG_I;ckM(?aJlD|6=vXdoEIV`K8XFm z3ua2Zz8i9J_q?TJDZ-SL&kjZ<>W0PD@m&W>cjxg#Tc0Ow?s@^snJ;bkTj9>vmaAXU z$<(7%m6a(-IKO0%-Z&I)$Azx1j?A*UKzG4b)&Kn4dyo=qNic`v~5NpgaBRt1liZ6~{4m?CgY{7k!7H zIJndYkFL~#u9&MiGzR7LsW)qM)6F1VVpvF-@8KoucI}){^^1c{STo63?Dav^)#LG< z5Se-BZBgIk3V1)uCkhDXd>4+6ifUYHySlRHyO|K35(f&=Ghe!wVO_Ev6$?wGS*y`h zjxRuo{2F19%xcXlcT$FhYfu+4%=gnWaTz9qUT?dXXTULMXPh_;fD(}U$T1H1{)SRe zfT3lz$#W~0tZ`*vI)DmEigiTT=#yC5FKW-PVa)hM$5a>G9?#pFPIz z*|Ds#F9iv2hOjM-ZzQH&40xidHeCz_91j#|ydxtcv#}?Dpl){hIh)?QD~OQWUJNc7 z1n@w0IgL+g$<%431+Llm8(hxy4n^N8%9y%CE_;IH-BRjL_^7-u9PI+dgJ@fuZxdFw z2h1{nAD^OOGU-jfUsy0WU#Y650mVSjd6^NCSHrHI0M&*qj1J`vBCh>r!I&^Wa788J z4&fzk#=E6X6H>OUH%G#om~5!v2rE?TNK|*fr}nu8fOFkoege$IJtKgd7|YEAd)dwE zy-qC=RE=cCj~&W`WweKe`SJ3`YW2)TQOw`p{}?E6+9%sUPy`Skjtswn-0(QC?s@9)E)A!Y`JgyR;Ci4-K8c%90 z3}3a=Af+@MLp&8OjlCW;Wd5qdH){=)tk%@jGy{-all>qbc&4^{KF0e_P_4T3@^>Ni zw_UncII}j5k{4o_vbs8T@CsA=mLW3s_1?eb z;r!#i%}7dn`0#EHRJB|(7JM3oG{nS+zfMhh0g(h;Lmv{#%jp9HtA*3Gywk_)U`G1n zJ_;2;W}rw+kiE(fHFT4NJc>dZh7C4!YP-OLMCce8WY?4jez=Zj@+W__BR6Fdl=!rI zm;L;s0hv=g?I;+b&p?Do zi8tu@W(Wr5ALe}IY~vDiN->Fpw#!>DVI-V4t)HcgEmu z2zgF2L~oxw6_(<(d7t-BNzEzZVVxNCHYs2DbZX2daR3IM;Y5ZW08L92oC)v6dr3gG z0SU$5&D~nEBU-QW6RVQyTQ~(iI(}C40@*M+RxCLW95l&^V^ItpHnlCD{qSmy(T8{8 zXNaz9U>=%0@OXdRI@Xza>@kO>@T|c4{klDN4VYe?SgLX@W$ zp{5~Xq?)>e8TrSztE}Z+eO=AG6ZDB(mHKKdyr(5;njTE%r=joUL&nMNKfOCgnf|qv zfv^BrhqLPy&k-sqy+K6vR)kaXycV21BFO&PVT@Zs>v(={&TxM$qxm2=93AH)Eo=rO zR9L^BbGA~S1u^+vCZEAT?o6cE66xMVe4wAsVJ2c(A01Zb!*4St@p@)&q>sYHtgNie zwrhOlIv}NvcSf-CyHpvYSaz_Nn3cs;B=cwcf)4Wn3o^b&_hvvnJopXT8O`F%M%Zkc zC9p3Fecsn0cZ-Hh9UlY83a_l_cs^hDUm5Vw(<5V2$;1%TFTz@U!SP>PTL|qTkjh7M z`B{2gbnzJebvBZIjV7uu1Wz=EgGzN}SWA&Q;-X4soFtcBR9_8%2AG*hcfBO#)S$!KBy&WdLUZW|a4?BuR$qgdcv2 zsq1D^Y8@De?p^`3KjI>}3=tC(O34|ZY_*PY5dnnN@shH8SqGf?kIbQZZbp;Kxqqh( z#H>TjGpUiA>Z7ULv<4D5cXoEN0rw@~e2p)Yh$Edc*ZA{`gXld};}VX&SRCAO z_%%0(js~HEE{^|WmdC9z2m+ZXnD~|LTj-&J!KDpGj_#mtBA*LJaIXQtnE2%J%KUs$ zc)YtJ=ti9Zh{254GWO!U{F=YlLqVWcJRq>3)ZTBeH_WM2SA!BuL!PP?^JtLY1#lU$ zLqkKSXcKU(xdAg^x;|B&;8Bn=GoJkeDKw7!eJ-6-ttSdre^EAiL96`WW4gnl>x2mF z4iuYKbF@PAiXORWGa&m(Ulu|L8Q(Pdym=q`33-E4Qc~`m0h0G$6Br&#Fw(Z>Q@j0e z0PH9Kf9C7vvJ{2^lsi)G7Ny}43Kj?!sU3Nf0<2;M!Dq2-!C|vg?kJNwo8gsey$LOo zbh7KG&)MjHA_Ie7)>}aj{pgSm1QwXw7EVg?z-9%Elh#q~H$)GiCMOuacUf*ZHELnkb z%Syy<$&krd;N=O+mQc;AgVOQ8Re~J(Y1UZTX&ZlSiY%IjF@LA9{M=ptH>|GXU@W8= zDnrfx`Tkr#uccW|jyjI6e0L}ua6E~bn-_bc=LGuztMJ_c!$VebICo{^5Q7@BYI)WY zgeW}uv{@;JgY8HA0!rh*BG0zRTbwTnipmWD5Ud<%_ zdr0D&oDIz0CV&f~90fk%u2afqlkUFV>spDSc+qlg4@3GT*^%;eS zfTl38d1qOZEd^*GHOIp`eBo81)FgMPqGbT7Vrw$)6 zGESMBxDY@}npcTA$6@}KzzYgkKq5Y9ZIqN8R1PvMPr~K76L$#;p}Xa|FK`XPEn}WS zw1SoXMysE7D+TtCi^F(euCOpiHR61s$az`H6cQeMd zywpVyq*Fr2FFVbQcdJ4J0mGl8HAbWCDvFpOc|G4=NmbC@Oi4J{4f{{`9VSb->Ip?g zPQC)*~GZ*m5VyQDDYX%fsD%2JAdZnCP9L zu|mU1?rIxZYd1d8Us&XauQi-%!CB-Fq6MBf8zHRIdnBL-XcF5+NDB>nw-l|GX#kK=U?O>lnxXE*xSXoTi4 zh{%N?YI%(I>x%AwZNttrklo=F=l0J#V;^=}Hg9}OWZX2*c1A_yZjn(@1%|av$I`hI zWn+%Bz+iD|X)uHB$?-L25m7yAQI=hdt-yrm0}qRge9e539v@EBiFL7&=p|RNnOxs5 zc57yjyPp;=Mirhuk7MV(>2jz+YRHj9aPieDT#bp^{Q8P1`{d3Cu+9|=UVxR@?nX?? z@NP4hWaz;mOrq2AQ0bw4%GLgmR2Uq{)Uxa8){@+$ek2*rJ&~@hF40tPseZIKLN^*3 z8;i>C6+h08z@yu1XV;cr%EsqL!VA+oVedNSx@qMt3FBkMOGkk>UMSm6K;qp7Y1?rd zb%GbC`c*fcoj?DxEv|h*<_?2sU%m0B95DMlulY2mswscgzaeLVl4xWBLYidf3@X3r z#B@r+Qy=UptFELH?;V-4XW0(dgwS3btE%~MrSyE52KqnJR}4h4Qf13IM03QE^U z@+IxK8|cVU-KgqbJCOnF@%X2(7&^gkT8s%R(|>lAENoKTPZC2TRLdW8kwkISA9A(R znADGiC}4t)qXs3N^7c@U2~w3Ct-K1thl|Len>j@>}@~V zNjGPr_1`IvbNH#BSi<6B*#)E%wu~Rdud%dnUTs?g6jj_D5G7-F*wJEwjZWTK=uSo=mgS#d&MJoPSNCIYIU{RzBCl}5^i#u^V7Q(UM+3rV)t zVO)Q2zL)!Sm6Ue*aj?VtPEEJ2+0L}|n+t2d$ZD=|He_sVA8q<~Oi!1yY04z%*bSkE zt0WS=Ycv|cTBWp=y5%Uf>yT9GRFoL`ecQOF4luN4v7wp`@VZGCJ+#ewMb|h5ecJEo zn91iMJgTwJ=jmozo;rvm2|V;ino^1oOavdlHhK79?V#c*V}$l2p*xAxx?B})|1Wok zH(l$iz5YH%&bVzC|EFFV0CUI!(J>}H=jEi7oTYO3`JeXMTqlB-YaYESr6hvwtA9bn z=Q7~>NFNe9AV^2->LS$`TbO)6ASx)FEN)-UopdyX*peO%H^WLL8E1C^Y4{A&Y-;!ohgm|I9wbY#0D6k{;KSf7Ge_nL2>`fMbQC* zFJx#)s=fO4SpO{*%b&0#=U*H{z!R!8^w-nY!i01qxev27;Nmeehe>tuLdF(lA5hgg zK09v=WeP#_2k-cnFbs9-AZ{%;)kSa0UhVI4Mc*46>Wy)C_(ot>U6Z5%>Rox&zD{mz z_}Q?&P5alfd+ayWU31mYoeOaWgX4|64BZtpC&fz9lY zL#s~NvsO@t_qxN~EUd7NO{v9nq5Ew#6J9oU9S=u;#j@mH?gyZ2SsD8CdgrT1w2~+l zE4}oUbYqnYNq-K3H+SUy( zr1al7n5)o^j3#Wtg)}ivQqYH}^Kf$malSo(y7>GccBq^9?rZ5#o zcTykFZOiD={$SW4K|?eH9knQ8E0zXY@N>#wjqQ3z%M!l0xyH=JDlimsevu}t**xYy ze)>Tt6uPx{I9ryq0vyA^A#i1u>GsX0<**RHj#sO#%G_mIpRY-cOl}Wprp>5B$Dv=9 z)$FoJNk^&tyoXo2k7w@(=wPnVPat?3Xd;u^M>;9OGwv05r=X)h%xL0tRpI_CeCf%{ zvhKf`AmFE?D$aFo;G&M+@2qweY_bgZ?5axj$m?iu0r+67p*pd`I>UPp_MgvpbW&kn z6@wnEqqt$nBEsstgfxK?3g7eeazv=gVv-*y&OIkl5TB!$)$3aisr9t=MOIP`=UNZ(iCFxmaN4tXi{l zQDL@ybt_hG0%noOWMkt>OG~xKzxF-Y?Ccm+4r_LRX&LOo+&hh@EV=Z>z5fFN8VTaV~)!V zGj`deig1_VE^G0rQV$2+>y;&{nQ`+ine+{5qen4b>hm?=i8^y{h|v|vE0JgUyt*+A zJiG!JC?wEQ#{lmVQ629%t(H-_uWUNJ-7)_?U6Q4>(F>ua?v3Q*aK-kfgRXdJ8C&;C zsG6QW49G3y66pc>CrcVl@FE%Em8F!672!7Xz(AI(Lj~2kya>}MifcHRIwoe~I^jq$ ze)D&~IUsujd@l8a8UG@Y?-{OV*(YmK;L&B@QLzCp>#;*_VidmaDg?7(gf& z+3o-io#F8OLZfg$pegxCk$J6=vf6{aHRti(gr%{^hxC>MNc+jWU8bg};BhAu%1SwS zhgK~&J{WFFXgWC+si2`U0aYid`K`#n>ML*N0533OQked@7US&tgR{eA#{F=`e6G8e z-ZA0g{ev?N_b;8Nahhd(grj1m-+CUW92FTxS2BgqYmzIS%fSw)Unhs!VYvrvl5;fK zN%-AWtoHp3RYnfdlUHfTbiCU{XopL&%p+-O3(C#>zQl>FxD(ZygrNQ1+SmQBxr;W8 z?)A^Rb2Z81P6(8Yhe06S3cfl2^jVY3j_q2lgclt?lM2Q+kkcSBw_UvqtNoM{!i40m zdfErJg*l)Ip|wiRtk_k0$snP}T`lQcdE$XtWal%Q60Cj*NzGQucN)LgB-M0d+svhe zT-ik9>-XS013wN!wrYWxgrgKpbL8Z>Dc!qVllk22D-eIbekB+=kziWUjid8H3 zkcn%%+6DzxqBgIWvYojpFQH#6M*WW(?La@4+rtNClQfKt{y*}c{Q46=xNPt9=IdsO z=$;dFVM~kn8o8UQo|fs9cGkcQiKG3~Kl37zdF)5cP$<01OO-G`VQ3A~pTcr@0&Gt7 z00L~T(3wkiH0}D#rRV*M1chxL$^PB|BEaM#7N1Xk$PyV$M$@8KBJC#k<`tbu4>hlG zpFZxuCXs{_(Iuw1i59wzlIrj;`ODXQ6OK7pg|?dM3L4Y714mvX#F;*e#)t-{ba!vKQ!Vg<}y85%9${uS+Y`OK1NouNX5tKGATR?=hu(nk2P~l;CYGc7ou^i3aVlwdt>#Q6O9^qIn}JhM$1V| zR0B8H+gX4OO805hkNlwr6y;%a z5-2B@KBHyq{E+g4+=0;4UdHuq1BvYPIa*{MWp4#Enf7mZ&ludz$SV7ixx2aX{k`1t z2^>(+(BqFLZ%{+$FF|TvDIF!G>mOQf<-i;|T_aj>)n#jDCFqtN93Jd+{Y*6FX3mSU zfKhCnAH7JEbab9dh1+f}U&EMK>oE$MBjWTy;o18;xuZ1p7RTu1Lyw73+FRvoUj@s|L73zepBtFgeNeoj72 z`imGOj%Tt^oA+h7K5_vPIGtzA?}ru$Qy8`E*Zw{2->tw%2-?vnFk(iF#eUni#E|jH zeDL7J@#DAh%;t>asXld(O6wxUoX$<{7NXbSPt`z+i~M_`3Mx7&oec%a)=p!>C8Fia z*bdr+$*F6r0JdJ~7`E*8V^r>~zO~2?L=Dl#+qPcE+AVyfT?X$_Q^%R6)z^A z#{c=R0W}Y00kZ@h6K|WyHD~K;vzEZVE26#3z6q^$FG5N}al8ZhERNusQ8a(yH3JPg zaF3t6?dC0H#~z_B(>gEf4wc&8lDEA*GlXQioY3@3>tAHJOO)(PU#4%54V+#%&hdcu<`A75~~;s7xU*DsybVD(_zEvdlrW2h?YAB;EP+ai-2^Rsyqp z5ewP`Ar}#Ph%NB|IFz_5@7uD+E2g#!e@3cpWBN!oWvg<}bS`khF6%J~Qp4NIcfnZm z;g$PdO!)&u*O}Z-;LVGZUy9@nQH4O<)X3SmIm0T9ugu?mmdbF=ySoux*k%UdM}i84BGPOB^GyM4bz>= zRNUO?1M0+4q+Bc2I6u0YWM=AhMPh7Io7l{sBM;H67PIL*z89Z;nU?>moqMUt%sZO6 znVR`*A01x1|1ZPQ6bTXP<8uaF6AHHt)yxw@AcjPTpdDf}^xy+^FfpAWAI)JPNKoIc z4Hoq9k)WVx2>-+02AMiIPCiqgemOzkb@A!giB`LWRkg^3BThz@m>ow9hPF^>r~tzc zX(Xo;n20Vlu7@RjZaok40vR=qlb5(gRtxhi9JEce1r05D&z}rzxB4Ka18Hi~+GUpO(iz#(VDeucG+L9!gUVf3vFi zF#HMkE{HGn{6t(YHiT2Y+T~hj#x}Z(nS{kuS_H!joZ1;kkU=o&1&Rc`c>)MXB^4E{ zdYw|I^ttD&GH+(7l;)THTcNsSZsuGB2CUKOD7Nodm|${u%CF zu?bawSpIqJmANWRAvox3x#hy!dkg9PWld0y`b`|sf^1d9GQlz)&m~1mP{vQ*tL|0* zea^d9)hd^dP!^GuV@tVOK$IU9BCtW{NL5|8;Kj@D@p_D@zji`(bvkO-qv3al-5RPz z?j6VZACh8%<^I%0b8;`n(_EzbYQqnzw&%Y^AA_b6QEpj3%52LjdvgO@(ni39q)cZ) z`7FHCL*3*wXv3kIXif*^cFH)*gnB=Y<9Q{#$$+?`SBFqM$QL>xMy}iB!=*{zX@+mO7PmGZ-{LSv&-QOEN zZCWL(;=AyZ`v*I)Z!Dfr`h4J*t5>y`oT!V${zb!*5XN2Uzk5TDV4q3C93sqS$e~-` z-)Y-q(gcO~HK&MORWXg9@t{}`+9)+=N;(9CNf|99>OgIB3qBW{#3rVPH`?-=*`I%^ zOwdy--=sR1>L~3;%@2h?9Ty8;d%0z^?rC}qEwAdJdUjOih?M`lNILhi}CPRU^zsKUR7swUlw4X zq~qdLlkTbWe})>Y{7Gdi@Ep6o?zjE{*T`%a17eqL4nFHU_HH{M(E5AV-c$Dh5`!m*!D`M7Da9zU%8F{)m#OtQBm$sB3WwE=?!gnNh zPqu!vBm^P0U>6*u5P1m6lht1ePnP6|W*;EPd3jp_F$GjxUj3pN*||d3xuVY465n$0 zT4}Z#JqIPC^ETWftyfk!grQK#VOvhF@}md#m(asP4F(KFHDqm?S*fbi0ryo`=ijRb)OI;~y-f}1;Nv-RR+jpX3Z^eeMODQ#&$roYIfwU|f6PZ(>$ zF1YU$@At*xPgb>m`uYcRaZ(%)+MI~F4?J2`lNpp{Ns_A5_B7^8GIL`~xucV$eNF_6 zIf;$3=t$kA^OPA0e~+jD(dJKz?oKlXpD%5;qTycUWgXonHi96pFb}ZMYrX7J*x+Xe zfXl}z;}z7U8F@H{FJ0;^QPc>#m*lI*cWRZ83&97BL*!F(R`dO+NmAqCyu+o@T#w?L z*Jn*i!WYhjGdz{A-_BV;>v{c4 zV`@(3LAA-Na6O&Xfoh%t=G!6PVRuPC_t#L>u5OqK4B&9e?3mG8(N!LrB+J{RIw3HX z6(f&uBbF&SF43P>jfuNm591fJ<)6A?4|w5FJ~jFIANSNM`07rvuX;#cnaMcpkE4TW z2yFZPyh)cUiV1h2|wYogB7)(DA8>JX*2LnT*vWK5dI;BmWE9thYtVzx!lZs|YMCwR) z4B^f+^CDsOM+QuAT}w&R<5q%;xqAmajq+BxTP{4PmPV~!pYf@Jn42tjHBYGr<%!)` zH(^0lBp*UVNr^Ah6px#|z?_IL3=$He7cl4;meC)qO&`K`r%CZ?P z{RwvJoh-5OO0zQTOUw`M$1ksA=S+OnN4y>YiO6V8J9mO5)LI$R3?|1~(ez9G56`tp zQYtPeMD-FZ&Q>uk`E}{mmhKhCp19@=Rl0TkRsFMBJnG*C_-(tJb(x z1*#lNS~A4e8jjdP(pQahLP5HY)n)r4PUSo zN~7k~OufuQ?Zz)8n@DCM9G58(I3)MLQf~Ar)k>co(mj%mz=|1HEsL+YYrsbL=Eutd zzg&42FfN`@)Gp6H#1k<_{_wmM7=OuJApEN8r35Mn(WaSo7%VxGqTz2AD;-7~?1=Z; z^$_$d-}8#7w^&VM+r;^Cc{cvUi=?C@>oH%J3Ma)aB$VIgRO9W|Ul+?AeRO8DD zN%_2mrVe#X*6JVW)5W?Z9nZBdDc~ikl($DI&D^6pTjf`G=0ya7VWq<#JM$m%emG4A zWSsAOjV)-~5z<*AGsO8D80`d8no$F?PIuV2Ikcp##vYhJ6Y_+U(@Tu2PIxXV3vXb-oS7$Mb{mx` zAiS6VGO>S2V$^yuCrtZ`rST&eWoC5gliujpygNw2xyjM<;w0;Wb1Qbq*p*7IA(E^o zp%(B#3bW#I$A@E|^X?#|UBL1*X@XHCn?^-ijn{2kzacyRlI5bxgy(iGE>T(8Cz!ReG8K90^wzd-Ps?YaU{IZOz@biQh#Fobm@&g%81%s1UKcm;gWBsc1(JT0cJjQ`~&~_!*#3#@nna?vALj!T@8I! zqwqQYYtSp}&e4*%ak;hV!^qO<-#rQ`w)Fxp5e=yFz#s@8&hCsa&lz;!5-cA1qpXGu z@IG0*$M9b|cPaNqenD3d>#V%j6{ZQs4OStZvzMT%Q$>|alY!TVi7vL+MGiWfbJQ9c zna53Y{z*+-mbKHB^T8g!cmBGbk{{(3G_mhM0EqRPk)mX(p)A=vPeQV zy&E!GE-+s9FqMI9O8A#XNzqxwE+dP!z^I6}6-+MK@9|-;0aycY$qBQKnX%lgOi*YPR^G z%|a{8TfYbq$d~WI_J3Fa>>KgG+ukbZp4^~Fzi&}A?$ggiLr&^s+NwghRIa`mTf(jL zC-aoL0eaf)d8E8?DY>KDv_G61Sfj178ixubl5O~mh(9zDt%HE0O$?-rhH)}Lw@uey+a$0v8Xc(!_kpYNH%MGI^5 z>fhA;fkDULJaeb1YVx6=Wve(p9~P~pcGV(+K+kbfoYm{mF@?)EQ!hh%^e6l>i#|!I zfkf!z>kdh{;~9Hlo;mujSklQ$^-9_fMc(vordBnQn8Kq^!fwt83*RS7nG+VtV2*az zI}`*w>_Vg3icp^s5^P)^nwYA01JE2%Mk1!OUUfPTgy^8kyM`rt1-B_WNEzs4ZJ}?s ziKQ7)(GS$@9P>_vlZferBe2JDH&I;FRU2Zgjr85_8QqK zDwP}lLv1QmgZP;$Bch&zdZ}qVyaW)3yI{!{Z?$%74<5JgECskra#w(W0kXIE6dXlp z&ZaH>>s`Mto1jyziWC~X0@RZCg3oq3)^scvX=sebLmcFI1{g%zID z#ImiLk%gypxETlca|S!Pc@u4KY2%I~3RTiP7B_PB?lBLkoVL09I34}Gu5+1)Ch-qs zTn_jFE=w+?Y6J7pm!UB29~Tk4?o!S}KV&B$thY*1a2trE-UTn#N~e?t(Mk;ig^`U6V&+#l$HRcse5;LB~PLqB+-&jar;glc6o6wx?kyxw= zTnyHP9y*k#?1@$#Ex+w}4n#2$cJ(DMe1cg$j z*TRi%v2l9Yfj&R;pzZe(&A}37Jks$FHxRs zawOLQjt4P+y1NJnPAiIZimj~{t-3ZIgvh5~?d49Jl;{Z;?*4d@!9IfS3cB{Ex)vxrVV#$jiuc|24!@T2F+0gyvVR z)27WSUAG{X>{iPRc@ew_bFLIRyrtap?(5?YC29fV<4RJJ#SER&$izh&?OU_-Z8)^~ zVo6F6?Wn4z8P+cuQmN4|f70dDX{YPhB3Tr&M(B{Gps6_fwIMz<| zP7GPY4)V9OpD8~A(fc^i5yF(}sq(K@aB@ZDT64C-9-QC^Y-6h=|Lh{i0ZJ+o1!C&_5 z*>h&*o>}W!8+H;%kWl()YT>FP%|x=Fr5yf#+XyIJ2MCG37e7B}?V97GCM|D(6Ea~m zZT0k0{#{mYgxUGhb_dO~x^Q6~uKq6NN-)i2Fl```xj<#*Wu;(?T!sCGZC|7oKU@)I z5p882^5E@b}Uq7WV+RR*h0R`zwBFZHYCw^*A+E7Is1UP3}wYUk&KtEe8`q zw2${x+=EU}@<^tW$`@*R&b*o;Oc*TQB`eUKFd4A@j3pSvy37p_f$78vlDg7?^OGJQdjGl&50P#ik58G;mR? z;abJHR07nX94J8uV))O;Gc;;6b6P)%C^+&XvEP(R36}<0mC5+{ui|Lh+-8=>SC}I4 zEVzRegDyY9Qp3Tdo8oS<4}30CNcBSIOuNwmFmI{9G=6Q#Y4}yNT5$~MNZ)Xk7QYDu!lQAjE5>}X~8T$(9Iy5@1 z*ox<>my%==>KtX9F@;4_8?~_-1FXLRp7e1DEZ3F}&qnRy17>)yrtoVI+@OWACAp(; z4x5>FH58O9w~Md!hGA=nJqqoKhgR|>b^7bc1n#gqD8a+%d6=l9|Wb9}NR5`z2rxhy(}>naSKsa*+m(L;A{9V(7(i$24;g ztk>45^1meArz)Rb&Ds+fqN|ZsSobjspwkLhh2`(N&w!9=zTpN-QK3|~1HK*?fb0}5 z1N~d{q@>7D_&IO2C>9JjoO@*7^kk?1OMHI+f0qvj@LKUg1>>?@&tpE+} zd;}ji@EnV9m&#>B2?XSHCOw~Fy zP8(o7km|Fa+x0pfCZ7;`5NV7|H9i)($dHhHl~ASy3gxI-A|MiQEmkALZbLwt1ZWKuVku+n!d9JCqg>( zH+E#cjBjt$vl1;A)mP9Al05SDKe~?w^t5hcl}`jnAi~6r zLXn3Qme6dE*0%*a^lvD<8QS7?r5xHSOZhtkK)z`1kR3{Ozt;s)Lzy3+!qp1b0(4_{ zCz()Qjf@M^{{DXJJ1*ZrZ;_M&7^o7R%v^lVW)iU>@7?Vqb(f28A07FReW`=lmO5Q1 zm$aNv9u97z-w}~8F1Vd6hPXaSR-F`~K)Eh~Sw7j|MQ-ZhsEY=wa4_14IqXR1=WMG4 z$Vs;CFX@zy%1zXJn}%N9Fng|#y3w1k}>rQ@ExOTKu)!^c;+J0lZ+J}Sxz6*77r6lT56*Y$Z_amm?| z`#91baOv}4Da2`E{#$lXsE4PSD<>ZYd-vN`sjgw^y;MW5MTi z)h~kAb9Q+{V@Gjn-?Uzsf)xqF^xC}fkyV4{%{od&cpzH(Xx=*D7iTkOgspUdZ*_|$+3ORJxp&ozHlI&ZOg${q+6-K2z z&Q*Q6u_BV9!M;1ajT0iF6V6NgS1-%R>(lTr!s|Z2v=-tE99qGpbwd6qp=s||btJqD zj)rv!0h+iCb1Ir{eYDdZ!O2mwYQai>i}tXoA0niS`QkrUFm<)>JmU48yyW$V`uAPghOE{D+i+= z_a%!|U{jfBJk(Zusq<2X%vntTLX3?G+0ddx#(}Hhr512esp^R*7g6Py(}T6J=xc9! z5K;t38m;PlNn&8!;~L;SO%?m;R1X>i0ezVGoy>vRwJyH!O&75|T?36-j40KE#S5qk zT6B`)!(j0S(zsn2=^Rr~ZkSWT2ZZS&v!w>dJRI(e>~j1!HBd=O?&Rhrcp>uTVC=JS zTkFWpn|@sQ(olCmN9bZ0s!yLGWV{>BjzLj2Prse={-J%w@QAr1!#x92)NB` zzO7ru02;Mcnf#amt^dATdA=pC)Ny8fBRSPLvJXA87Lt`swO9!NaA$Ts zkUCT{M185;Zspw=bF$4zd-%AR%5P&WW}<N)&scSv$boKqqizSC$2)tYYDLMe(4c6n*oXeqP#%3P?fk(I9GJ21xlG}ykz~B4 zM#kHpVTFZ|uD1Jx88@9?4i--?rsH`dFb?}?I6R*&30-oF$5%ccg1^C)>&{Jg$DmUm zCwh0CZ95ya9Fn2294fb=#fQR-CzkhtE#a00G8!-A??u~py#M0P#Y1P>$F)OCBqZ`HOL|N&)f;2k6kt5M)C@H zJOyXQz@~mqUX-N56jc#DecCh6y3?J0k?}~2+FIz+GW-boLl7rnvwis z36q&reo^7BOE?9?6gbFxf4niOzNpBnCt}|*?%($c^Kdwmr>=Jt{v$So4dYiR{vp{5 z=?PnQ!~9+@0j&y)mqD=T4+EJTN8wl)+)^+)Ulz@8KpWuKVMD=r5cWC6Ta!) zFA?*$LmJdged;lhi(i!JuIPYsK6a`fPAaY3#(MXh@I&-mU)7haA1#N@SO+(xo!rxX zX@E`6_wjm08Q^Y_7Td@T>EBqh==j`G;t`(FQwiKGWvxVvbM*?XKr^b$PN#Ep@8!m} zFPl@k0#ZB|HuhCoPMB4D!4IIj43f z;4VFtK=P7!j|MbG%&6(_3RBdEZC0xFf32a35U$JYZCdpEIQe2Zy+s+9>+W!#OMzMv zQc20L^%z+h@*1|)Fm1lS>yjFJaPk^-DtKPH;x@BxaBV`OxVGyC-MN77Q30b%7&cJ>#b9y&oxJoYi74zomcJ-K?#pb<{Y+RTq{Tir;%0nHEWgvV?t}-U8A zs0j3vGFn@#5N2GLlWFiat^?#FF5C9sug}C9rYFW^`>Z-&bevxMx0-Up6M8~>aJz23vpVW}@^W6u`|^~Af z@n7GCS`InQ^$CP;d)pB@-KsVG7RqjA1Y>`fth0f(f-_xS8+>nc{2QjD*`_8Ze_vm_ zf^4OlGzF;a(X-Rk=B6bGfBx@ncS$gO>}rUVuKqRPFaR1h-_dxg?QtiPb%me0(B5Z3 z02)mD?{8g|&p$F$8u%~w!k!K}*Ho_Ryq=Urt5hZNAH0}hQ z-1k$w*3%RpR_a&W34YLlz`mNg2-AL4}pn&_!=of+H6{ zLC|utgYSN>f4Oau#$j%Kv(jz3aQ5u}Z(F1>LjTVc#9;fR`0uoo5%8FE#41;j3)1)6 zf}+ShHR0;OkoX3aJ+TKq*wI{E{&$4dZ!Il{b-6=OFqR`U=Pn?N!c5EGDED-%Of(j_zJ=ujzZ@s#YCUJ;_=mW>8#I_jJ8 zdT5`U)>Z3IXa~(84>O8t({sKxs%<=O#&XL%AHWNKnTVRW+7um6Y$AJ*bFbKN6x0#T zywhH)H1xA*NEgv6$>t`O_Yz+ZaBP4OQ|m+H`e(5TXe3>Q8KemQEhyXhpHVwn!ffw>_()Ey7@^qdiZW|ASwFTM)S z6xtMn1;xrM<8iBhQsVODde|{U^?lUH)IXF-mVMk$yGyOJwVrABm}?r5?z)KlZZV$} zHq4dS*yL7o4#SN5HTm&mN^@j66pK44rKb7w8wuM{#Sy$Oo~4BO8`{ZMoD^gCPV4~u zsV4I^BJfvV*D!r|wnmFECLI4;#EytamuN;#65^2+c$;Q$4WYS-XOUbT?K;aUW%At@ zQ8mqcI41}H>3z9a5FZb2k^dk+bwZCu9D+V^bV74{+=)dcW4%{|L#r}8TcBv}l4fO> zLqInHu2<4%m}W%RJh79#+Lt^r6mZKpTaxFlPi7N0%m+(nd|5C0oap&t(ygeSRsNfx zQ&_sH8J5QtLnaEgVe50+QkU3@6jS%k`4ID8eF~io|3>`Bs3LrMh3}f{Lh*-=i(K`W z9;;=c2ae-$8>%ba>o4k~TK>5H9al;hk!Cs?Ws(!O#ZYB>1P zr{>Yf`JA%PC|5q6E;@VJ=ETMa-L|OvUj1?v<(9gd)0fK+_7s|(F2Az^gY@KEzFy|V zd1p;25OeV-ne_#7WMF~x>EV~-f3I@$5GYrd>7rJ*14IX8p4OGVnnelLWi5t0eU)E9 z&z3=q?AW*`TwF!wGW3);O||o6t~_*JGuBHAq2;)GXd_x-iaX5 zg?S0quaqTdL?ZPfQ?2&x3?w}h6%~_Fj2=SJe-(?ghtmcr)lypT_1!sTJFNSf{Ux*g~)o@X^`j$ zG#0CK2&LcllAB0y?qO6YK;sy6>DU6S)c%uor%DkknZn){fXmhjqkjvhVVd>cOO*eU zo6@X0hs6WqXUWnK2U1($Csl5Kc}J+cdNkUcTd%IiE_80{Go{z#p4^XJK$q`1E@8`@@n1?@LxfsJqopi$O9@wUl=Hg=RRX zIYuKhV~z35>@^;tVA#<_Ewx*)wFcg4b|aZ?ThzxJ$Ba^ul5=?GY;gsBrG`NF(-nEZ zKJ#U@(LSi8LyopXF*()N98czmcODIe?d zD|6VFw?e8~f5?YKN*CRi#iG4zm9ei(CDD1e0`RS_8KMZYt0lJFEhVQT zvoEt0+>+`Dj1#?AwHS3tT8GQ946`k^bGThd=X zA2kF#gY1afuUddbNwHXu>6hWakkYhmerZm~m?#tc6EAyKao0o`JgV`gvmv!|qN%$? z3crm?>PaJ3hVQqdQpOmChnZ;gPxaa=8A3V6?e7|b98&#SxEy8|FQIllCETQIG)Y!z zzJzI)dh-{;d+wI=#Ltv><>&7!_GyCOVeI=&PhuS;uK+m2Nwrp_2NKFm)>RSe_SiH2g9Kh$hFC>F$hf-VUIfuc ztwCUsj)6t$D7}(Y_i{?nOf03dF2K#_a$smNtkUUHo*Oo#LlDlv)YQS1Pf;i-V_Ie? zTIk^Z`m12}_)$S$#Y$dz4Alm=X~U}w{{SF=;?^1=r7ByPiRihx=A`>?sFkd2$Q6fV z{$7wPwgwnpL@R_&WpX-_b%N+zXRrz;=YmwtDH=XDTg1N|enTf+qZ29FRYpeE+2nwd zEc-3V$rgb_=e_CUF8Ky8=nBo8*;%4OOL@O3*5d`&zWGD3ApI)BNh@{QVX#o`Hr~yS zeaQmeoy*rL+W5I6+eEV^0pZ-8Ugd7+uE!9QtniF|-8 zjVE#oY7f`&n_KK1Dt_4yBkoAcf(W!v>Nl_sw9P(x@uL~)`3YAq7t!heGyv- zg{q4?jx|Ct-cqLB2gPaihuc`ft)}AYSL9ETZ6BioV@|+!1$W6ri+28MU zJl%D~E{Rz%G7+ZHweat9t>mlIE;+TZpz^l%{OgPFy3_egMuPTYAf$9?(`gimosdnzX-%EQ&R%AW66JT*x(POIsb@|{?lkX z$v2n?X`&T9P|Hw%2-Mx(&R*j!i{f*2*kbJLu}M z-H(2FsWwK)(^7iQQiKaUQwI)Gjx9>k|8$8dG zf2Bv{rR@zr`j;*i`DO+#Y+s~y$!~9wGn^Q2d5q{F;+lvjr@=6Fc->qrFnzey11DhV zWK?~Z;q~j3{5N2i<-81M`49Qb<3inCt2mO%?lyEU(Cr0}aTJ4EsyvH?xRbav8fHOzeC#Z)%Xh_gM)O~DyXJ53MjfSIJ>MGhGs?}0MB+oTFjl?6Ey<-^# zkMZGb%%Jl4K@Kpy>048^qqZHOcJqz<0vy_(00vE5&XwSXH68>s`sT{JXlhUH{?X z@@_SEPHQx)NtcM8Q}27|q|SU}rE?)xp?mN{5Ikx3L&k1f?2k$CVvz zNK&l+VL;afjDz-cupsVxrGapihEa#|U_dfI*QDn1*-A0di(RrJ6yf*fGQsIjbOzI& zE#(!1jSo|hTAPWslz?uFg4tPh?(Gg5zyVO}uIE(#iK@U*HJuK(h7Gu(_`)7Z0UGm3kU zyhNSs)nwFq?&>eM+cyE(dB;0+Uni_03Z!zs9#)(7U4QR6cHiy|(btHDHy%f|HWC3T z+vdOqRe#2#0L0y4?M~;vKqe^si}x=#E)Tv0*39cF++6l7qUIZBAz#M~Vz#vX0hgBA{ zI|oTgi$JCJH*DtVr|1(J!QbaI($VeFgsZ>L;(o8Ejs%|@=Wn`!I=h%_R0p0k*WT$d zC|H~K2-XY#Y#~845|8E(^7_0WvrBC>%|W znKPNCHJmoJ$ZUe?({#oO4nhc{7!m~n=bnwYBoN0@51Gf0fEvfsK5cZf^Y(Xo`9(gt zmofg_Y@4bNWz&mg?kztdNa&O;iG1agVDZQ5mgm2bgNm~AR%`-3_tgjs-vAmJd<98R z7VnzV_cfO><_4NX6W^90^FHXJbBeg_aGs>@5*Y@_fZ!JMd&HV|p%UZl$*$}*<~>i3 zOISSDM8hzuS9VEQX!39AvKh;g-x+5mZ*0q2 zm{}o9#-@O5+KBMM6-h@XYiKd zyZ!a@Mjd|v$aU{Uy+cahCdTlk zTM`x6z(E^j(Ccv8GkN4p%7afMK z_{uEQWQat?e_+)corabRLKzI1i*}{jCd?OO=x&Zj&19Dpl?BUc1Oz^D(@Z`8Lk+l- zn})QWRJNtNV=dfjo1UFWm@Wj`EF^A`}>AmYls|>j@@}3;C>l^*sY=RaHzjiQ1%Kj7e%&;YwLIBaoe4}jw8A-&VkxW ztYN%MkT$@w5W!b}I4)>EKj|w6r_V}s@WKa z2@%!WWUY?k7;dP;C)TTpQwNUkACUO3W(azW0;-kb2Aol52_~uO-oUP?;IY2VhV_?i zP`0TpPNMsw7C3SBh?zT2t)nVsMcA^)w|rHzOd8n_Bp96Lc#_HS@X+LlHN8FdY}thnW@{zF)DGShWXfb6Q9h|@C4 z2D;;m&j#T|Q$Zr|}hrY{F;$}qy>z}0c6LdN6#8}_l;&RJ^ zuS*7G<>$ zd7u4Mfr31l64_(y|9YFi0;m#RDb$NzZ=1So0$=}G_%>}s?$Sa6wWf(p&+I-`18^X{ z7MBA2U^tItp7ie}o!7~Aqaum6H^Q%HaYT9(U?|ByE$*lK!k)fYBedLB9snjnHlepn zPRp|NXzc~l4IK(@&g&0VEf^Fck45pmK|bx%sNoW44m+dzLQvO0_mjou4lQo-Z~u0f zwHRf6rP6_@d@cP_hu!@ z%;S}P6y1VQ+|o}ne#RrGw;{zvP74N{Q5aj)VApnuf~oz{OW{(43KW+*_1(X>>eDA< z$3{d$K9nCW&`ebn;QY3GC7!g=&qD%lGJSjp4Wii)gLhJ_GD{ZVD*PV&Grmw+@Y-Rs zi+6rq=6C>BM-~V;s{z67e8UhiH;PPnMVn2rg4m_&<2yuMHI3B|T}!9xwf4vSGpG0S zHJM+yi1Raxx}C|xoiw(pfenK4rlK@^;a=UDT#!RreWz~iKXi(Gsq5e5vI@t$HBfAO zS%B<@*9r4-r*GSM3a9K_gZ-*D>J2gujhwrCxGZr7TKIMKk^0h8&qv@(>8hT-1ZI?CCK;j+JM(+wAoH$bxetLdh_$F{hQSKE&AY zhEk{QCLQjzoGQ0`MB@3dsbR4(b^a3oo{E@iM+7!Uwsgp+u`4K&=h7tj66vJCVC?+@ zy%RMQ`Y|j&uG#)xs-f;G20sOHbxDEfG~1ATi-W4s*C+t2ccra zZIaL({S3XE221NQv9L_VzkxF<3WkP6n3=5=$|JX z{isxhZ+_wPw7+c-6Ib?8=L;})*UBwZ8YvrB|fRI*fsDbDkQ?k zEi7kzVl7Tn4Zz1uKQs4p__lVzZji0~VE1dL{lGe0|3l~1@k#3e3lhJMp_|r3jnpgD zqEFv1816v271Fl=3xf&zzUDsQrIZ6x5G!0#e!AZcBzmuwPJ7u&p{huF?kJzQ^OmU~MT4 zOL@293Ls)0VCs(F*W^hDa)B!4Gw(v0G6`^1TT&#xwC%<8#2-yFg~q-C)Z!|?9G)Ou-r)H6WG8-be`4Gd?B?{oogFYkc*IUQ&OyJOk zbu|G9O1f?{CavbN9c4=vQsCquu>6#VV_5AQc zAeQkjaRb#E%AGRKa}Tn^zP2ou!ZsyiF7?pc^}Ns8;F*j^b3kd19dY&L#Ny7nRLTh_ z|FSOYg^A&Acr+6p7H2S9{5y;hEL`(!-af;5yVN#=PO-^vE_>~%VHKTyG&@vJe^RU; zL71{8X+mB`PUkzcuah2kOXTQ4nu$`8eVpDU@N3aHQyZ1=r7Qx#WgKV+_|tmi#i?!r3@Gu_;%g?5s1I(hSO*98_OHyWn{APl8C15AYCpZxRk z#gjl(ypIBNpzU6sZpmq?#GB;X?Xs1dC8A9lQjNuBhAbq>#Nh=fr5m0C8EmyFbz=^{ z(h{;QLi!$}K1W5pFOLXV30BA-t96nb=@tM18PXYZcqt-CUiT)hT9^XRGvW_9)#`@% z$tlaGnJ0p=YgECDQAa5z=(9tV%7aWYU4i3&w+#rgXmL2GVW126UG{#+SnpC(YrzGO z====p+ivxB@V&`EeAKFOHye@ow!`GP9>kK9V*ty!-UL_xg0c^!}zWg7E%*Gf6cZ=hQr4)59=h7;m8{V_5P)r|qTM z(tNr;$`kw`%{*&iBqBzaE~cMS>rz<_EqLGI(O;Q$ktN{FBKcnH6wTLWa;pY0@tM&AuM3CHrs zQijt1s6A^kg7YkK{O*8-ZRdy}8u~+w%$YWO-D~ZcRU3&@17s_m176oUTrU-#Tim*z z70XI&JR;EVW#g`s_8+Pzx{CkX`K`W`0_PB-2vG4qWW7C*e=u3ZEcpg^ypyE*i^08WD-nRwEd0OOtvE^m7$^MXmJ)oLQ_wBM+ zBseQ(1a|IyDnE{*A-a_FC~K4NxBuS!x$i3E%R31<;w=`J&K?ky4;Tn7?m$TGiR$pa zbFi-*gi}=@{^iq(*=`oS<~;|o=fJj%!oYQjn3zXpxM~@|i2^GpH;phVe?S36x3ipMMHMcuDSF?z z6V+;;-x(Ch)GeA2#aJhQIC(jmkWsBGd)jxGcyk*1D=?S`RK;wmrlYgdnt9b+>7Xmn5`x#q&Nkk-Z@=MUXr2p;bVHW!L+P zr_LOjZ9o;t0u-5bzmwg@O7`CXGHAj#5eL#X17Q)5qi}7@{cp;Q7Yr)?Vfc;n14E&T4!0#de;^v`}}{&4RmKoMaX~rnW3al z6v#F>G!Ussl=Aucp4ARdNtnAr)KjYR<6+Cr_$d{^1DHNlz8{7`an-vi zt(z#k=YWK3amLDACWsw6Su(kK0&WjOFPm=*C62hE;t4}Zs(yl>PE3ZL%1SLeI=iMe4xQrU zDj*&eQmf>15{!Wk8x_U)KLmSXu?FOAkz0OCWra#2Ip*r?$(w8Q2C^hq>v}?Zu|Dp` zj|EEY1$_R*d|xHej_SYxqtWxV2vfc}c$4^q6oN4W4o&90_yWt?X4)4@L|{}Ok!6A> zR*a*>>-YSv;~SfK$=E7xV%wb)C6F75O~ycm1cxo!u6WB2#l#?y9R77YnVtJ0`qulR z9!@i83*QK7OS{J&;m>|3vBR`JA1mTYEC7?iPK1SX$hpkHqZIlP?Cy+a`=&1ytePca zh?x4pntlzJgG&}Kswn@ zFTHlyt%L`0dN>?6tWYIGKcPdtP0M=oP!Lmyvr=G`2S?cv&evM!${(Kv3K!#0r|VIR znY{C@F8)alkeyf00E5drdAbnLOXaXf%3oGXrhlhVVM9%QSLXU`+HR3NC;#B|LFd$I z);>Xwgrar1Gy_(3R3vHAC1BWnd?z_?I~q8vXbgdRTj87vS-P$=g zby_tfHlX@$ux9!3q;LJ)g(8kWz&$4PhdX*ywPFK*092SPCX0&QcKix6tUpz>8vyq8 zx_kqcLLEljboQ@**z8rnoXb3Ph;S3HKxiTE0Rz`J6Z7yJXde9hCMOf~mY75*#6?=y z=3wlDXG{l+wi{>H+Y~M=g&$WgpLUlBwk1)tpZo6{(|72eS~J_G_Ql%y0w`#;(17{l zwLpV+m;1L=N2LceKJBhlUg15mkROn7Y!{KGHh~q)cQvFeZysbL?-mk@PFl*?6nH3; znjRQUol2@ktnfhtB#fO*c!NyJvK`z~mLcewVcYbjz)o$cJ*0)+PvVzV_6}|ND_}~caEJ)1i)+K96Uo+x;v0bf;ieB@*HGlL>)t}ROu1b2DMnEh`?C$nAzo=H?AT8l6GA@NV!J@Uh@SgHPqSPMd` z;zc5G87FV#b1Cf!>>h7&11_B^1Eb+{-2kk@Vx_(RV1^p`^ftCSu;#a%g0IsDm$%;WzTmD*)s?FLkQ^MBt+S+@CxEQ;`oF+bewRLQ(VImdYO^q0o}K+l<){Mykx? zG64tx6g9cTskA-7Vfk6}hV!Bp5J&yu)na{nXGOv$X(>C=+ zb{pP8YbaJWnCg}AnS&)`3>xMWQ~*VFbg`k2KIQ>616CZP120F088Z{ozaw*HW3bW0 z`mPJb10U26Wc`oX3IIGECci|{iXY0A6U6LPwpI9#cP1OeYS64^*CQ2*6CGnRkcfzJ zib-#Kk#2qCu->}NU!YBV;G=Yxyv^FOhn+DP8k^ZncER=|#tORk{`-V8+*Zz??3;v2 z8AA`K#$y!fdRNy5NOvsZ0j=?XsuCtiA>H`C3f+8SeS%%Hy&-yk>c9R^-`z8nM3RSD zc3SxG5lBXI5T44W7j)}L8Gqkqc`KHej{q0wGOtJLguabNHpm38Jof(brOpJlWtJRJ zvX5f;UBLP#i?zetbe4wLK(F zKH>VEyrV0NK3*X;*_MuxX8{6ks0lC7Jg6^FH%O+hH&y=YJY!L8vHc1wx6+c z^&1hAM9HBDYUz|;Y1|WumdnZoC8;_@nIo5tF@zAVKzpfb97ouFF!-beUWXLF(`lMK zIx*HSk3GvI$SQLeqbE8@QrYc5{uj|}CUfxtG( zvWBZ}ghH&M_O7cR4a8!S-h7@=EA!Ijq*^Ei;t> znJk}2DGnm&k)-H#lhn?nDvpC$KHeAphP*=!djb6u-k24|bDt?Vn_i<3>3~{L%7Ipd zQ~S8w1Sfhl@gzIHUDHUdUC^~WfAOMrcJ_|()0Xaix<-6HT{42aPYG_`N)_4uf~U;O&5j<- z;*&3$8Ku9ccq~w}p=89aQh!ZeY;DSg_dvQg#r7x+6kBY3OGP#G!S(%4m;`EfC zPI#wVW<){}j11f*{GNK!z(_8Y(QdmP1&}Y9JH`(qqt+Nhr=rOGCiS3DBLcPUQ3l4n z?AiXTCkvo-N%v+Fa5gY{@G1QIr%9vHezVYb!ua(n$qtSm0#|5L?#r}MbDc8m?lT7$ z5u$KeeT9`AHZAjzp`v3c2V(5mN5Yc7@R<)x{Y;woMLyCerlhgz@=qdh>}uteJGrAL^C z^CTTY+;tLSo9c;kwn0fUfFU%&PQ%cLGxIWAJA24tmWj1T_J}K!05YnoXut*3L@!GU z(EvbmL4Ut(^H`VLMV$&z_p&q0$X!4a2z>76E4W@ z^*3w6l^vd|yu(cZwy1Q4b4n=hWn`m$Tadm2VNN6+hRISSyeSdm%g;j(vnr&kJ|gE3 zj;5*gL%l!uJArQG&PXS>f9uZ_hNqCpp{$xM>p|Lj_ujg~0?KV1z5{lj0kEXb>6-1+ zReOMzP06g=A5RX)6R%ZpN~jh;;jGQQCz1G3BH`R*pgz~>xck#B>8yjC{|m>|W@FD^ zl^^y`LHM;dTOzCG%N0Q=j0-T`Ky}l}7vTPSTvoNHscD{*{xvw(qwOkjl^QqPd&t-j zClcpS=y@M*2&?Kl%~J@g&j&S7)=-pXCS3$H)?@PWgCt*)V*>_8o8=ukf0en8JOnHG zFXUjin$sqjzkNGI@nG29NaVRy1qm`4Z=dG+t26~bIIp)`V*BDg6^LS?1z1vyRE?^B+Dv3XedF33|i-sm>62hIu~IuO#OIU zsmYdit@K@Y|6V8OA#6WJcfQSB=w41Rj+|e`KjFZh>e)W=w=?sX zQlj5M@NDAA2Wj|OY7Xi|OLVFPJweCx6}eX2#@`EVO{-os#jmTC*)8u*XXmuNjiWIS z0NrA*zwb5N2LNvt2h;pl^c-1E&10Q=#<;Heuk4sZ3$w8-c!dzk6CAA`e|FgjvU5m7 za;6}x2bEpO1duoM2XakK#%Z@a2#BtrD_W-&9#FJdpj4~<35H=(3FgO~la2Yt6nKde zfa;nR!r!9Lw>w%dNvf5q->OcBor3LMvi%(-BM8Rq1PR`F_`2dW84Bw+Xb}~5gym{P zYNIq$2u%ZNTrdFDKDKky#M$*sGCG!bK&<(qqkFUt_sS$l7w&katv4u+39WFLp&)To13fL8IaC$$$Wj+%_@9-S6tN=qW}t5 zyt-Z2)4+ZJFJhGYNk1doXt1Wj0+-#chHX!b<8b>e5Cmx)e+Ts zHG$}HOv8)b)(?JZ5i~@<-w9aoP{~1eiD$=w<$*Dh{7CtgVvYTi+WY1h@0tte z89@X=jO#ML59OASt%TcZElq4S=I`QXMg`-}J(rO5yYRmPE{EwKcJMo%X3IXxBKwH^ zM=cElJnPgbQhTX@hxH+-Z6VfKUD{(uR)TZPG2VVPo%Dn}+yrHu=k)6HaBGL4E1P0V zuf(K!;hu=SU@1XM0hxL}KFu#oxJgXhk5Co?cGom(cnGKTpF;S}{f@||6lZ4gt_sq+ zC_cxKsegKvw%rjf(D~#0Yx(QsHKEJf$@wwNyN$a;KM(#b07d{demU0Jm(ojlN9Y!p zc^|1lG6zBItv9d3KYp-PM_paj5$(KP#@jFm6NUQ*f$Cjd;>P5`K}6GGn-;cMzMXK9 ziWV*qmo%(037B2`%r$|m_Y>41{vAOcxSsn0R4n>}h~mue2`7XyLGoV~ zBe1F)b?A+_b%X+)HhqtJorzBE_bcsNwGje?Nar0lK968+IVDiv(%6J}s`zED`AzZe zXMsdS5ar-B$$jK^AJG=eN=-0~gksEL4gzgA>a)#U#&5rII{UoZSSbZ zk$-W1s=4$5sBMB}zOxo$&d24|`Hq?`Rd}{o{mpap$Ntg1>3+9W{tJd`NxuC*umW2_ zu`MLU+fXa~pb-d2q;z=*@p(ykmSgWRhd{pQfLROk7vg5SHq}^?E|TNezO9H^!xfVd zN`V1#4Z^W;>eY>z;Sac+4AF~jSeU`bv-LJWqt#904cHj%SWG{0x-I)81|9U2(o)=( zLPDRe6YAdgMh9M4LI+?cMy0UH(~r|LRZ9d`wKq65Zh~F67tvhWbCn#3*jJndk~dZI zT*YLQWtO8rmjeWLrYaR?0TfC#&>%%i>Isja1MIj=-&;NAVdpwE3j|OKJz38;`Ho$Y z8j)w!EvP;u81*aGMqH1=^IwbKl89&ufIPqdaM!ss5ZBV@S zuE)&!|2n(wuO`;68)^`wNtG7FOAFFLfk+4GJqXefsY>W2bVQn{T!>U@A_#;gy-F7Z zLJQ3Z2pW2qVhr^i?)M*j^V?Z#=A4;l&6;`EKKtw~$5Uaz%k$;b(vzvSWzKk+@GF58Qk==4?L+3^pWi8<}V%iCaJtzK6vo}PVcgP}A52|^l zG*jEnzUW(r{rH(VVxXK@@0_CY1SSv&eE1*UjBHkx0!BEo*r-N|9^}u}0NJb~-bMp< z37N8?%oBV`?zxU2M&#{Ha(!F-ZlexFCiRo>G>C!)QE5~9R)Hie@@PWq`_!&c=0FI) zC*dARJ1Jlb8@X3wead?hc(gvjvHS}lm6V8JDltCF`MuHjm6ckoK%Z~cjWZFrE|bZ` z99&aW{XuY$`-ByZ4?bCTU~7n#%F}y62iEHxuR_oQMomJM98->4Qo+m?QcB*gnklit0O49k%$bZJvddQzGm-f{D$f=Xq0kln{=> zh)~^sn@P_?c^_8Vw3uE}sCUr#dlD=cR=ZTqHG13L1Qfs?aPC!o;@hvA3HZ4)0yc}f zvaQD+_jCd?OFAK~UjH;$Vgxz=>|otpnAM`cb_y;$OL&=qPTpOeXu=o6GQbRYSwbn4O`QIl;tsy661&3riM{IHn+J=OO0&5h`QF!0k*WR@#*) zxb%>=^1Y|oRgYA+uOp9?n-3_tC+r~<@)$#fksQby5WPJSr<8xE0ku9_;@VzvzAEZ> zP+X~INUE49y1133%~hwF-6Wz|9o>y`CqTEnh52M2+OtF)lZd zw}(htL$Bjop-UwHO7@(EE}q)a(lD7zgO}sZ9#XwRw#m3)*oo8C5&X{3piGr!m59K$ z@YbD89`Ja@q`B2?Ir_j->*2;)Hy5xT9O-;fF(h`TES#?A9A50e+|5qKUbINH)bUsLrAJk( zbKLJa`>!4IFRs=(i9v#rA1yJ^NzeFqrY*?p95)*2_G@|O3XT0>(b6+dH@j)ic~)_| z_0PyruM{N|q$7AF`OvSgQtMIq*7%PFGu4 zo_|jc1oXCP0MTs56MXDN5=sC37Id2Cu9hb3`No2|Bh#TPmDy*;ZI`FkU4mtli&eI; zjq&#}&lWpu*PH-(33GiCRTty>4@R_mJBYQBcO~!WAWHMQ!m>LFj4GK|SP$9o3s}vR z|8_*FG#3c(Xw!N4Am7#*x-^eeu+BVGC*goRqb5nzwP0w7bllwpWhR=F6efwXv+C6 zp($pe98x}ipZgzGj=AVxd|4ILES4i{Dnw1IE;eXgL?IbH!?fW9`S{YV@u%k1m6-UH zBcDf+C}ZU-7$RQ*z*z@uuX8KF^VOlWNf~drVG6switl&*cr{1Z?xC%&Eeng!HI@k& z;pXMlPOY5;(MuEX&Mf9*gD!v?@6afn@%P5+dm%~$It#g(wirY zPlp9on3OAQydOc8;%!z~(SHKcr3PTdDx^OwNl`crFVU`Az;-=k6@*d?&Rg982w&NegA9F#o%?ScNjWh$+**byB7qvl!x?fA+h#X{C{- zAH6=gsx)`{{n0G>edMgXyu7K6O~v`(a=z7O%2ed+1`hI&!Yk~DqnRX=-V`$!h> z3Nmg5`tyQZONwjBpl@y|=3Qpw6jA~wPnh<9P*?)29m#NI!&v#v(y9@0c`=2 zdpIj>R<(*M1-@8?@J2h?nrbFlA%%t(CH zm~i^II>zAcJHfh-xlKL|Y*#GO#q0%eLzMw@J59rYbT#RWqCNUC(+~TOu7~E*e#*Od zCBU1nCE{txYv(Je`HeZ~!w9l%L0`R;gUzZ;qJ7?WCQ%Yu_J;V<{Bt3J_O#2vIYkPW42dBeKic*A2Ioql$E-C^|0bofODegb) zfLtC4VueJ^?y^8q*OX6C{6xBFa``du z5+g#N`qH%F-Dk;N0*_)Lo16n@T~{Ju*jeVlyWWFL#Qj9-EU-xoyh#fFCAyT=q!6$L zy}WmP{Jj|>_-2DEj5N7ZYLhw*o54S6A?9N?Quud#8s>-y#u-sy0^A-7T|SbrrjcNX zD~*%!8JA$;UzA;)K-JvXXU;?V{L$i={I=f{+NM4I+$%e!%wqWW)Hn?d&GGo3ZQO^g z%#yP8$0hZib9cjEZVYb_5uq7mgZ(5hQXX1llPOQB3@bXZV-wy`VLmf5yBhf`Lld-d zwt^=tcMMmjaYHlmbAF##O=HASeEtQ|*eQL(h!?H;9f))h)i)dQ@f^P#-^sZ(`#;-d z6iD>fdJr?aigf;XPdl)qf1TERt{5p2>))Wy>bbC9PLw}I+?0PnSx?~Y%k`6>gz4(( zQCL3YnYglq!Vke(?l{QhBxmL68pVJCxx3b@_bhi6w8xUN+&}HgvfqK2p99mw|3H+( zw1j9mUyWm`;a}WKjn_VAQ{W%E4Qy4qAe`BR`Jx6uDs`6b#hLl}7k_Oxs>yLH=W*Jq zfo4w+n`#=_w-ToidN^@2MVNzOBOm)FYM>}R1J`E)bjzfnXeeF)^ONa| zxlsMVm3kQ96(dYRLDBdvNS9?A32e~=tPh44(C&@jR_~(MxIT$29Wpn9UHk;=xAxzc zQgFa-YT0^jW#i7zYRdyXQSQTR9#e9YMP74n)DQ}#euLU`bi1>x;5MfL`-tS17hrA? zI}OiePDHb6aqISM%WoqkVo_yq+*)3!;k(tc`6B?j(gmDw@c}fu0l*W>)4@d|iRJlY zSc>ZHAM*)_&(5{fN`b-(TyE^S2vny9Ie{QxBi;n<^eLB4Fs2HAE}s{6Nt*>=dvEi8 z*9e|0?3yEwA(d8qC5HK_lysEuDqpm)4FBjZV|=PRK6g%7tUe_JpZp$xWI$JfXf%KZ zWoH9#32gyu6)%0CC?Rv0WQ_|1g>@!M6K)&NiD@R23Db+bv?B~INDBz+Z}qnQ!ItXs zI~Q}Pj%q}X;yzh{lb7C&j(G6BhTn?Q;FZ{nuFC!FnD%le|90I>)i}$0U#VLE6DopZ ze5t9%g<@EOpvektA>AoJ$(Hrtc4m(b<{z6L&z60Fgr9$f$|oQ;CJV)VDo0RB{bew{H&6JCcBzV-_kJ z?W)^68a6!|vQenHa1+KX-Jz|3uRaL&1`?eejZXq4sZ7u#yaiE(C0>!n$dX!vXNXcWO5|z+`a$2Z>$vTu^pX6-RNKOf)*l}gy?q}^BtdD3^|uf zwcK87@nrcY*RON2y21CasyjDugc?%=krD+8Dmwz3@S_;WS`VKw^XBR30nDv! zH?kyl^j^!vF`bi=LVCEhX-nr`<6@Pwuj1!TxjOZm3-vZ(PPoiv&#DT2tHRleljGs% z%3Dd2&UAq&RzWc>*m<%Fh?F4;L~csTe)yK$mFmAxrGWgR@0c77T8IOY^MXjI`V2u% zJg3}I7gwk9G62hu+*eQd??PS%7!Yj-flkz~GO6s7ORRR&-=hA%MB6}Avq-W|PjZ#H zo2e@kto%X<$OuF=Kr|2mE>Qlj1i2AV;*6p2|4|S@VssoM75}KB8w4CWnuZ!xY7Wo; E2S$VYuK)l5 literal 0 HcmV?d00001 From d69d317e6f1973126269a55fc1a9fd701260fda7 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 30 Aug 2026 20:36:35 -0400 Subject: [PATCH 58/85] Remove nbcompess from precommit --- .pre-commit-config.yaml | 8 -------- 1 file changed, 8 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index bac7c36..16ca408 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,14 +1,6 @@ exclude: '^examples' repos: - - repo: local - hooks: - - id: ipynbcompress - name: Compress IPYNB images - entry: ipynb-compress - language: python - additional_dependencies: [ipynbcompress, nbformat] - files: \.ipynb$ - repo: https://github.com/pre-commit/pre-commit-hooks rev: v6.0.0 hooks: From ebe10d91a197261a8ea245ee5354ff5d99f51a59 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 30 Aug 2026 20:36:58 -0400 Subject: [PATCH 59/85] Add fstar dependency to docs --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 224069c..9d551b3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -56,6 +56,7 @@ docs = [ "scikit-network>=0.33.5", "partition-sknetwork", "egosplit-sknetwork", + "fstar @ git+https://github.com/ryandewolfe33/fstar", ] [project.urls] From a8c6e5f49d87bb3d85e82fd6416fd131dc9d4698 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 30 Aug 2026 20:37:20 -0400 Subject: [PATCH 60/85] Remove outdated demo --- examples/demo.ipynb | 637 -------------------------------------------- 1 file changed, 637 deletions(-) delete mode 100644 examples/demo.ipynb diff --git a/examples/demo.ipynb b/examples/demo.ipynb deleted file mode 100644 index 793c8eb..0000000 --- a/examples/demo.ipynb +++ /dev/null @@ -1,637 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "9b6b0991-8012-485f-a8a0-37e5036c97b5", - "metadata": {}, - "outputs": [], - "source": [ - "from abcd_graph import ABCDGraph, ABCDParams\n", - "from abcd_graph.utils import seed\n", - "from abcd_graph.callbacks import StatsCollector, Visualizer, PropertyCollector" - ] - }, - { - "cell_type": "markdown", - "id": "bd31ad23-37d8-49a0-8853-78d0688cf436", - "metadata": {}, - "source": [ - "# Building a graph\n", - "\n", - "Before building an ABCD graph, we will set our seed and initalize the various callbacks to use for data collection later. " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "1e450b1c-f24c-4242-b9fa-e891efa0310d", - "metadata": {}, - "outputs": [], - "source": [ - "seed(42)\n", - "\n", - "stats = StatsCollector()\n", - "vis = Visualizer()\n", - "props = PropertyCollector()" - ] - }, - { - "cell_type": "markdown", - "id": "9a2cd52b-0dd9-4ba2-b0fc-c60414fff145", - "metadata": {}, - "source": [ - "We will now build an ABCD graph on 100 vertices using our default parameters. A concise description of the parameters can be found in Section 2.3 [here](https://math.ryerson.ca/~pralat/papers/2022_modularity-abcd.pdf). We will experiment with the parameters later in the demo." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "e9e64ff7-a4cb-4ac8-b9c5-d662aff7e80a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ABCDParams(vcount=100, gamma=2.5, beta=1.5, xi=0.25, min_degree=5, max_degree=30, min_community_size=20, max_community_size=25, degree_sequence=None, community_size_sequence=None, num_outliers=0)\n" - ] - } - ], - "source": [ - "params = ABCDParams(vcount=100, max_community_size=35)\n", - "G = ABCDGraph(params, callbacks=[stats, vis, props])\n", - "G.build()\n", - "print(params)" - ] - }, - { - "cell_type": "markdown", - "id": "6641b711-8d59-4a7c-a947-42a3b45581cf", - "metadata": {}, - "source": [ - "If all you need is (a) the edges and (b) the communities, then you can do the following: " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "53fccabe-1837-4125-96a9-16651f2d1511", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ABCDCommunityObj(id=0, vertices=0-29), ABCDCommunityObj(id=1, vertices=30-55), ABCDCommunityObj(id=2, vertices=56-79), ABCDCommunityObj(id=3, vertices=80-99)]\n" - ] - } - ], - "source": [ - "E = G.edges\n", - "communities = G.communities\n", - "\n", - "print(communities)" - ] - }, - { - "cell_type": "markdown", - "id": "fb4364ef-c91a-46e2-845a-4efc3ef5baf9", - "metadata": {}, - "source": [ - "Note that the vertex labels in a community will always be a range, with the first community containing vertex 0 and the last community containing vertex n-1." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "69c0cabf-904f-435c-bb63-26c412d43473", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]\n" - ] - } - ], - "source": [ - "print(communities[0].vertices)" - ] - }, - { - "cell_type": "markdown", - "id": "7efde531-6b94-4b98-ad40-e4f841e03015", - "metadata": {}, - "source": [ - "# Exporting\n", - "\n", - "We currently offer 4 exports." - ] - }, - { - "cell_type": "markdown", - "id": "202afd77-d25e-4dec-bc8d-e3f117a81688", - "metadata": {}, - "source": [ - "We can export the adjacency matrix, with an option to use a sparse matrix." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9d16b234-c7a9-4e13-ab41-6788cc186ebe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " Coords\tValues\n", - " (0, 18)\tTrue\n", - " (0, 21)\tTrue\n", - " (0, 22)\tTrue\n", - " (0, 62)\tTrue\n", - " (0, 93)\tTrue\n" - ] - } - ], - "source": [ - "M_adj = G.exporter.to_adjacency_matrix()\n", - "M_adj_sparse = G.exporter.to_sparse_adjacency_matrix()\n", - "print(M_adj_sparse[0])" - ] - }, - { - "cell_type": "markdown", - "id": "ed9d6f7e-cc07-4dc1-a6d3-dba2bf4e9584", - "metadata": {}, - "source": [ - "We can also export to both igraph and networkx." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a659166e-a817-4b8e-8fa2-48fa9ba4a6bf", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n" - ] - } - ], - "source": [ - "G_ig = G.exporter.to_igraph()\n", - "G_nx = G.exporter.to_networkx()\n", - "print(type(G_ig), type(G_nx))" - ] - }, - { - "cell_type": "markdown", - "id": "8fa9d058-5f65-4878-b8c5-3d430901bb39", - "metadata": {}, - "source": [ - "# Statistics\n", - "\n", - "We use StatsCollector().statistics to obtain the a dictionary of statistics for our ABCD graph." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "64b006a5-dfe7-49c2-bb18-4b0a5626c797", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'model_used': 'configuration_model',\n", - " 'params': ABCDParams(gamma=2.5, delta=5, zeta=0.5, beta=1.5, s=20, tau=0.8, xi=0.25),\n", - " 'number_of_nodes': 100,\n", - " 'start_time': datetime.datetime(2024, 9, 30, 15, 16, 56, 904087),\n", - " 'end_time': datetime.datetime(2024, 9, 30, 15, 16, 56, 915652),\n", - " 'time_to_build': 0.011526491998665733,\n", - " 'number_of_edges': 321,\n", - " 'number_of_communities': 4,\n", - " 'expected_average_degree': 6.52002839527186,\n", - " 'actual_average_degree': 6.42,\n", - " 'expected_average_community_size': 27.7585580858053,\n", - " 'actual_average_community_size': 25.0,\n", - " 'number_of_loops': 8,\n", - " 'number_of_multi_edges': 14,\n", - " 'empirical_xi': 0.2461059190031153}" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "stats.statistics" - ] - }, - { - "cell_type": "markdown", - "id": "414b387f-1dce-4106-b4b3-9c791d786c89", - "metadata": {}, - "source": [ - "# Properties\n", - "\n", - "We use PropertyCollector() to obtain the various properties of our ABCD graph. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6620a1e7-7eb5-4aa9-84b1-a1afd62025c9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum degree is 5 and 43 vertices have this degree.\n", - "The maximum degree is 11 and 1 vertices have this degree.\n" - ] - } - ], - "source": [ - "d_seq = props.degree_sequence\n", - "d_min = min(d_seq.values())\n", - "d_max = max(d_seq.values())\n", - "num_min = len([i for i in d_seq if d_seq[i] == d_min])\n", - "num_max = len([i for i in d_seq if d_seq[i] == d_max])\n", - "print(\"The minimum degree is\",d_min,\"and\",num_min,\"vertices have this degree.\")\n", - "print(\"The maximum degree is\",d_max,\"and\",num_max,\"vertices have this degree.\")" - ] - }, - { - "cell_type": "markdown", - "id": "b6e24ea6-1fa9-446c-be31-a4d3acebed70", - "metadata": {}, - "source": [ - "We can also get the xi-matrix here. In this matrix, cell (i, j) is the number of edges between community i and community j, normalized by the expected number. This is also the case when i = j, i.e., cell (i, i) is the number of edges within community i, normalized by the expected number. In theory, all diagonal cells should be very close to 1 and the remaining cells should resemble samples from a normalized binomial distribution. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "49b978d5-eba0-492d-82a7-b126bed97ef0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1.0031746 0.98987854 1.23734818 1.30608974]\n", - " [0.98987854 1.01265823 1.24168975 0.83406433]\n", - " [1.23734818 1.24168975 0.97652582 0.95321637]\n", - " [1.30608974 0.83406433 0.95321637 0.96969697]]\n" - ] - } - ], - "source": [ - "M_xi = props.xi_matrix\n", - "print(M_xi)" - ] - }, - { - "cell_type": "markdown", - "id": "e0ee6b4c-47b3-4136-8612-48b746584609", - "metadata": {}, - "source": [ - "Finally, we can find the CDFs for the degree sequence and community size sequence here. We will address these in the next section." - ] - }, - { - "cell_type": "markdown", - "id": "cad0142d-aeb9-45fd-991b-bc080fc05506", - "metadata": {}, - "source": [ - "# Visualization\n", - "\n", - "For n <= 100, we offer a quick drawing tool for our ABCD graph. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "02b27e7c-d799-4a8b-b642-84db0cff29b8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "

" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "vis.draw_communities()" - ] - }, - { - "cell_type": "markdown", - "id": "fe228929-e6bf-4e8b-a795-54312833ee57", - "metadata": {}, - "source": [ - "We can also draw the CDFs for both the degree sequence and the communitiy size sequence. In both cases, the actual CDFs are compared with the theoretical CDFs." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "64ea46be-5da1-4e49-8ae4-34eababf67f9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABtmElEQVR4nO3dd3gU1dvG8e9m0yGFAKmEhI70HgKiKCAo8BMrIpAAgg2VYqOIBRVeG4KKYkG6igU7ggjYMFJCkd5JaAkESO+78/6xEIgkSCDJptyf69rLnZkzs89uYvZm5sw5JsMwDEREREQqCAd7FyAiIiJSnBRuREREpEJRuBEREZEKReFGREREKhSFGxEREalQFG5ERESkQlG4ERERkQpF4UZEREQqFIUbERERqVAUbkRERKRCUbgRkTxz587FZDLlPVxdXQkMDKRnz5689dZbpKSk2LvEUrV582YGDRpEcHAwLi4u+Pj40L17d+bMmYPFYslrd+Fn5ujoiI+PD23btmXUqFHs2LHjouMeOnQo3z4XPjp27Fiab1GkQnK0dwEiUvZMnjyZOnXqkJOTQ1xcHL/++iujR49m2rRpfPfdd7Ro0cLeJZa4jz76iAcffBA/Pz8GDx5MgwYNSElJYeXKldx3330cP36cCRMm5LXv0aMHERERGIZBUlISW7ZsYd68ebz77ru88sorjB079qLXGDBgALfccku+dTVr1izx9yZS4RkiImfNmTPHAIz169dftG3lypWGm5ubERISYqSnp5dqXVartVRfMyoqyjCbzca1115rJCcnX7R9/fr1xpw5c/KWAWPkyJEXtUtISDDCw8MNwPjxxx/z1h88eNAAjNdee61E6hep7HRZSkQuy4033sikSZOIiYlh4cKF+bbt2rWLO++8Ex8fH1xdXWnXrh3ffffdRcf4559/uP7663Fzc6NWrVq89NJLzJkzB5PJxKFDh/LahYaG0qdPH5YvX067du1wc3Pj/fffByAxMZHRo0fnXSqqX78+r7zyClarNd9rWa1Wpk+fTtOmTXF1dcXPz48HHniAM2fO/Od7feGFFzCZTCxatAgPD4+Ltrdr144hQ4b853GqV6/OZ599hqOjIy+//PJ/theR4qHLUiJy2QYPHsyECRP4+eefGTFiBADbt2+nc+fOBAUFMW7cOKpUqcLnn39Ov379+Oqrr7jtttsAOHr0KDfccAMmk4nx48dTpUoVPvroI1xcXAp8rd27dzNgwAAeeOABRowYQaNGjUhPT+f666/n6NGjPPDAA9SuXZu//vqL8ePHc/z4caZPn563/wMPPMDcuXMZOnQojz32GAcPHuSdd95h06ZNrFmzBicnpwJfNz09nZUrV3LddddRu3btq/7MateuzfXXX8/q1atJTk7G09Mz32slJCTka+/l5VVobSJymex96khEyo5LXZY6x8vLy2jdunXecrdu3YzmzZsbmZmZeeusVqvRqVMno0GDBnnrHn30UcNkMhmbNm3KW3fq1CnDx8fHAIyDBw/mrQ8JCTEAY9myZfle+8UXXzSqVKli7NmzJ9/6cePGGWaz2YiNjTUMwzD++OMPAzAWLVqUr92yZcsKXH+hLVu2GIAxatSoQtv8G4Vcljpn1KhRBmBs2bLFMIzzl6UKeqxevfqyX1dECqbLUiJSJFWrVs27a+r06dOsWrWKu+++m5SUFBISEkhISODUqVP07NmTvXv3cvToUQCWLVtGeHg4rVq1yjuWj48PAwcOLPB16tSpQ8+ePfOt++KLL+jSpQvVqlXLe62EhAS6d++OxWLh999/z2vn5eVFjx498rVr27YtVatWZfXq1YW+v+TkZIACL0ddqapVqwJcdLfZ/fffz4oVK/I9WrZsWWyvK1JZ6bKUiBRJamoqvr6+AOzbtw/DMJg0aRKTJk0qsP2JEycICgoiJiaG8PDwi7bXr1+/wP3q1Klz0bq9e/fyzz//FHpH0YkTJ/LaJSUl5dVZWLuCnLtsVJy3vaempgIXB6YGDRrQvXv3YnsdEbFRuBGRy3bkyBGSkpLyAsm5TrxPPPHERWdZziksvPwXNze3i9ZZrVZ69OjBU089VeA+DRs2zGvn6+vLokWLCmx3qdut69evj6OjI1u3br2Cqgu2bds2zGZzgYFNRIqfwo2IXLYFCxYA5AWZunXrAuDk5PSfZyBCQkLYt2/fResLWleYevXqkZqa+p+vVa9ePX755Rc6d+5cYEi6FHd3d2688UZWrVrF4cOHCQ4OLtL+/xYbG8tvv/1GeHh4sV7qEpHCqc+NiFyWVatW8eKLL1KnTp28fjK+vr507dqV999/n+PHj1+0z8mTJ/Oe9+zZk6ioKDZv3py37vTp04WeXSnI3XffTVRUFMuXL79oW2JiIrm5uXntLBYLL7744kXtcnNzSUxMvOTrPPfccxiGweDBg/MuKV0oOjqaefPm/We9p0+fZsCAAVgsFiZOnPif7UWkeOjMjYhc5KeffmLXrl3k5uYSHx/PqlWrWLFiBSEhIXz33Xe4urrmtZ05cybXXnstzZs3Z8SIEdStW5f4+HiioqI4cuQIW7ZsAeCpp55i4cKF9OjRg0cffTTvVvDatWtz+vRpTCbTf9b15JNP8t1339GnTx+GDBlC27ZtSUtLY+vWrXz55ZccOnSIGjVqcP311/PAAw8wdepUNm/ezE033YSTkxN79+7liy++YMaMGdx5552Fvk6nTp2YOXMmDz/8MI0bN843QvGvv/7Kd999x0svvZRvnz179rBw4UIMwyA5OZktW7bwxRdfkJqayrRp0+jVq9cV/jREpMjsfLeWiJQh524FP/dwdnY2/P39jR49ehgzZswocLRewzCM/fv3GxEREYa/v7/h5ORkBAUFGX369DG+/PLLfO02bdpkdOnSxXBxcTFq1aplTJ061XjrrbcMwIiLi8trFxISYvTu3bvA10pJSTHGjx9v1K9f33B2djZq1KhhdOrUyXj99deN7OzsfG0/+OADo23btoabm5vh4eFhNG/e3HjqqaeMY8eOXdbnER0dbdx7771GYGCg4eTkZFSrVs3o1q2bMW/ePMNiseS1u/Azc3BwMLy9vY3WrVsbo0aNMrZv337RcTVCsUjJMhmGYdgvWolIZTd69Gjef/99UlNTMZvN9i5HRCoA9bkRkVKTkZGRb/nUqVMsWLCAa6+9VsFGRIqN+tyISKkJDw+na9euXHPNNcTHxzN79mySk5MLHSNHRORKKNyISKm55ZZb+PLLL/nggw8wmUy0adOG2bNnc91119m7NBGpQNTnRkRERCoU9bkRERGRCkXhRkRERCqUStfnxmq1cuzYMTw8PC5r0DARERGxP8MwSElJITAwEAeHS5+bqXTh5tixY1c9V4yIiIjYx+HDh6lVq9Yl21S6cHNu4rrDhw/j6elp52pERETkciQnJxMcHHxZE9BWunBz7lKUp6enwo2IiEg5czldStShWERERCoUhRsRERGpUBRuREREpEKpdH1uLpfFYiEnJ8feZcgVcHJy0iSMIiKVmMLNvxiGQVxcHImJifYuRa6Ct7c3/v7+GstIRKQSUrj5l3PBxtfXF3d3d305ljOGYZCens6JEycACAgIsHNFIiJS2hRuLmCxWPKCTfXq1e1djlwhNzc3AE6cOIGvr68uUYmIVDLqUHyBc31s3N3d7VyJXK1zP0P1mxIRqXwUbgqgS1Hln36GIiKVl8KNiIiIVCh2DTe///47ffv2JTAwEJPJxDfffPOf+/z666+0adMGFxcX6tevz9y5c0u8Trk6l/uzFRERKQ52DTdpaWm0bNmSmTNnXlb7gwcP0rt3b2644QY2b97M6NGjGT58OMuXLy/hSsuPqKgozGYzvXv3LtJ+oaGhTJ8+vWSKEhERKUV2vVvq5ptv5uabb77s9rNmzaJOnTq88cYbAFxzzTX8+eefvPnmm/Ts2bOkyixXZs+ezaOPPsrs2bM5duwYgYGB9i5JRKT8O/4PVPUDDz97V1JmGYZBZo6VxIxsLFaDWtXsd3NOuboVPCoqiu7du+db17NnT0aPHl3oPllZWWRlZeUtJycnl1R5dpeamsrixYvZsGEDcXFxzJ07lwkTJuRt//7775k8eTJbt26latWqdOnSha+//pquXbsSExPDmDFjGDNmDGD7JX3++ef55ptv2Lx5c94xpk+fzvTp0zl06BAA69evZ8KECWzatImcnBxatWrFm2++SZs2bUrzrYuIFD+rFfYuh6iZcOgP6Dwaerxg76pKnNVqkJKVS1J6DokZ2SSm55CYkUNSRg5J6eeXE9NzSPrX9uxcKwAd6/rw2f3hdnsP5SrcxMXF4eeXPzX7+fmRnJxMRkZG3vgmF5o6dSovvHDlv4yGYZCRY7ni/a+Gm5O5SHf9fP755zRu3JhGjRoxaNAgRo8ezfjx4zGZTPz444/cdtttTJw4kfnz55Odnc3SpUsBWLJkCS1btuT+++9nxIgRRaoxJSWFyMhI3n77bQzD4I033uCWW25h7969eHh4FOlYIiJlQnYabPkU/n4PTu2zrTOZIat8/eM4x2IlKS+EXBBEzoWR9OwLQkrO2bbZJGXkYDWu/HXNDiaMq9i/OJSrcHMlxo8fz9ixY/OWk5OTCQ4Ovuz9M3IsNHnWPn16dkzuibvz5f+IZs+ezaBBgwDo1asXSUlJ/Pbbb3Tt2pWXX36Ze+65J1/Qa9myJQA+Pj6YzWY8PDzw9/cvUo033nhjvuUPPvgAb29vfvvtN/r06VOkY4mI2FXycVj3AUTPgYwztnUuXtA2Ajo8AN6X/91RXC681HMuqPz7jElieg7JGRecZTkbVlKzcq/qtV2dHPB2c8bb3QkvNye83Z3ylj3/tZy33d2ZKs5F+4d5SShX4cbf35/4+Ph86+Lj4/H09CzwrA2Ai4sLLi4upVGeXe3evZt169bx9ddfA+Do6Ej//v2ZPXs2Xbt2ZfPmzUU+K3M54uPjeeaZZ/j11185ceIEFouF9PR0YmNji/21RERKxLHN8Pe7sG0JWM8O/FktFMIegtYDweXqz0IbxgWXev59uefspZ6kjHPL+befu9RzpTxcHQsMIl5utnVe7k54u9mCiffZ555uTrg6ld/R3ctVuAkPD8+7lHLOihUrCA8vuet6bk5mdky2T2dltyL8Ys2ePZvc3Nx8HYgNw8DFxYV33nmn0PB3KQ4ODhj/Orf47xF/IyMjOXXqFDNmzCAkJAQXFxfCw8PJzs4u8uuJiJQaqxX2LLOFmkN/nF9fOxzCR0KjW8Dh4r/Buecu9fyrz8mFl38S/3W5JzE9m+TMXCxXca3H7GDC280pfxA5u2wLKbZ1/97u4eqIo7nyDWln13CTmprKvn378pYPHjzI5s2b8fHxoXbt2owfP56jR48yf/58AB588EHeeecdnnrqKYYNG8aqVav4/PPP+fHHH0usRpPJVKRLQ/aQm5vL/PnzeeONN7jpppvybevXrx+ffvopLVq0YOXKlQwdOrTAYzg7O2Ox5O9bVLNmTeLi4jAMI+8U44WdiwHWrFnDu+++yy233ALA4cOHSUhIKKZ3JiJSzLLTYPMntv40p/fb1pnM0PQ2CH8Ygtrma348KYNP1sby4z/HOZmSRUoJXerxKuDSz4VnWKq6ONr9Uk95Ytdv7Q0bNnDDDTfkLZ/rGxMZGcncuXM5fvx4vssbderU4ccff2TMmDHMmDGDWrVq8dFHH1X628B/+OEHzpw5w3333YeXl1e+bXfccQezZ8/mtddeo1u3btSrV4977rmH3Nxcli5dytNPPw3Yxrn5/fffueeee3BxcaFGjRp07dqVkydP8uqrr3LnnXeybNkyfvrpJzw9PfOO36BBAxYsWEC7du1ITk7mySefvKKzRCIiJSr5mK0/zYY5kJloW+fiBe2GQIf7watWXlPDMIg6cIr5f8WwYmd8gWdcCrrU8++wcuGlnnPby/OlnvLEZPz7ukMFl5ycjJeXF0lJSfm+pAEyMzM5ePAgderUwdXV1U4VFl3fvn2xWq0FnsFat24dYWFhbNmyhX379vHiiy+yY8cOPD09ue666/jqq68A+Pvvv3nggQfYvXs3WVlZeZejZs2axZQpUzh9+jR33HEHjRo14oMPPsi7FXzTpk3cf//9bNu2jeDgYKZMmcITTzzB6NGj827RN5lMfP311/Tr1680Pg6g/P4sRaSYHdsEUe/C9iVgPXvWpVod6PgwtLoXXKrmNU3NymXJxiMsiIph74nUvPVhdXwYHB5C00AvvNyc8Kykl3rs7VLf3/+mcHMBfSFWHPpZilRiVoutP03UTIhZc359SGdbqGl0c77+NHvjU5gfFcOSjUdIy7Zdnnd3NnN7myAGdwylkb+GtSgLihJuynZnEhERkcuVlXq2P827cOagbZ2DIzS93dafJrB1XtNci5UVO+KZHxVD1IFTeevr1azC4I4h3N62Fp6uTqX9DqSYKNyIiEj5lnQU1r0P0XMhM8m2ztUL2g49258mKK/pyZQsPlsXy6K1scQlZwLgYIIeTfyICA+lU73q6rhbASjciIhI+XR0o+0szfavz/en8alru/TUckBefxrDMIiOOcP8qBh+2nacHIutN0b1Ks7c0yGYe8NCCPLWjRAVicKNiIiUH1YL7F5q6yQc+9f59SHX2sanadgzrz9NRraFbzcfZX5UDDuOn586oU1tbyLCQ7m5uT8ujrp7qSJSuBERkbIvKxU2Lzrbn+aQbZ2DIzS7w3amJrBVXtNDCWks+DuGLzYcJjnTdkbHxdGBW1sFEhEeSrMgr4uPLxWKwo2IiJRdSUdg7fsQPQ+yzvWn8YZ2w6DDCPC0jcpusRr8uvsE86Ni+G3Pybzda/u4M6hjbe5uF4y3u7Md3oDYg8KNiIiUPUejbbdyb/8GjLOjp/vUs9311HIAOFcB4ExaNos3HGbR2hgOn84AwGSCrg1rEhEeyvUNa+LgoA7ClY3CjYiIlA1WC+z60XbpKTbq/PrQLrb+NA16goNt8Lx/jiQyPyqG77Ycy5tY0svNibvb1WJQxxBCqlexxzuQMkLhRkRE7CsrBTYttM33lBhjW+fgZOtPE/4wBLQEIDPHwtLNR5gXFcOWw4l5uzcL8iSiYyh9Wwbi5qwOwqJwI+VU165dadWqFdOnT7d3KSJypRIPw9pZsHE+ZJ29m8mtmq0/TfsR4BkAwJEz6SxaG8vi9Yc5nZYNgLPZgVua+xPRKZTWwd4am0byUbipIIYMGcK8efMuWt+zZ0+WLVtmh4oupkAiIgAciYaod2DHt+f701Svf358Gmd3rFaDNXtPMj8qhpU74zk3d2WglysDO4bQv30wNaq62O89SJmmcFOB9OrVizlz5uRb5+Ki//lFpAywWmDXD7ZOwofXnl9f5zoIfwTq9wAHB5Izc/jyz4Ms/DuGAwlpec0616/O4I6hdL/GV5NWyn/Sb0gF4uLigr+/f75HtWrV+PXXX3F2duaPP/7Ia/vqq6/i6+tLfHw8YDur8sgjj/DII4/g5eVFjRo1mDRpEhfOq5qVlcUTTzxBUFAQVapUISwsjF9//TVfDWvWrKFr1664u7tTrVo1evbsyZkzZxgyZAi//fYbM2bMwGQyYTKZ8mYW37ZtGzfffDNVq1bFz8+PwYMHk5CQkHfMtLQ0IiIiqFq1KgEBAbzxxhsl9yGKSPHKTLYNuPdWK/g8whZsHJyg5b3w4J8Q+T007MmuE6lM+HorHaesZPIPOziQkEZVF0ciw0P4Zex1LBrekV7N/BVs5LLozM1/MQzISbfPazu52+5pvEpdu3Zl9OjRDB48mC1btnDgwAEmTZrEF198gZ+fX167efPmcd9997Fu3To2bNjA/fffT+3atRkxYgQAjzzyCDt27OCzzz4jMDCQr7/+ml69erF161YaNGjA5s2b6datG8OGDWPGjBk4OjqyevVqLBYLM2bMYM+ePTRr1ozJkycDULNmTRITE7nxxhsZPnw4b775JhkZGTz99NPcfffdrFq1CoAnn3yS3377jW+//RZfX18mTJjAxo0badWq1VV/NiJSQhJjbePT5OtP4wPt74P2w8HDnxyLlWVbjrEgKoZ1h07n7drQryqDw0O5rXUQVV30NSVFZzIu/Kd5JXCpKdMzMzM5ePAgderUwdXV1bYyOw2mBNqhUmDCsbyxHP7LkCFDWLhw4fm6zx1iwgQmTJhAdnY2YWFhNGzYkG3bttG5c2c++OCDvHZdu3blxIkTbN++Pa9j3rhx4/juu+/YsWMHsbGx1K1bl9jYWAIDz38e3bt3p0OHDkyZMoV7772X2NhY/vzzzwJrLKjPzUsvvcQff/zB8uXL89YdOXKE4OBgdu/eTWBgINWrV2fhwoXcddddAJw+fZpatWpx//33F9p/p8CfpYiUvMPrbf1pdn4Hhu0WbWo0hI4PQYt7wNmd+ORMPlkbyyfrYjmZkgWA2cFEz6Z+DO4YSse6PuogLBe51Pf3vykSVyA33HAD7733Xr51Pj4+ADg7O7No0SJatGhBSEgIb7755kX7d+zYMd8flPDwcN544w0sFgtbt27FYrHQsGHDfPtkZWVRvXp1ADZv3pwXQC7Xli1bWL16NVWrVr1o2/79+8nIyMgLZhe+p0aNGhXpdUSkBFlyYdf3tstPR9adX1+3K3QcCfW7Y5hMrDt4mvlRu1i+PY7csz2Ea1R14d6w2tzboTb+XvqHiBQPhZv/4uRuO4Nir9cugipVqlC/fv1Ct//1l22SudOnT3P69GmqVLn8Qa5SU1Mxm81ER0djNucfR+JcMHFzK/qsuqmpqfTt25dXXnnlom0BAQHs27evyMcUkVKSmQybFsDfsyAp1rbO7AzN77Ld+eTfjLSsXL5ed5gFUTHsjk/J27V9aDUGh4fSq6k/zo7qRyPFS+Hmv5hMl31pqCzbv38/Y8aM4cMPP2Tx4sVERkbyyy+/4OBw/o/K2rVr8+3z999/06BBA8xmM61bt8ZisXDixAm6dOlS4Gu0aNGClStX8sILLxS43dnZGYvFkm9dmzZt+OqrrwgNDcXR8eJfx3r16uHk5MTatWupXbs2AGfOnGHPnj1cf/31RfoMRKSYnIk5358m+2xgca8O7c71p/Fj/8lUFny3na+ij5CSZZu80s3JTL/WQQzuGEKTwEtfVhC5Ggo3FUhWVhZxcXH51jk6OlKtWjUGDRpEz549GTp0KL169aJ58+a88cYbPPnkk3ltY2NjGTt2LA888AAbN27k7bffzrszqWHDhgwcOJCIiAjeeOMNWrduzcmTJ1m5ciUtWrSgd+/ejB8/nubNm/Pwww/z4IMP4uzszOrVq7nrrruoUaMGoaGhrF27lkOHDlG1alV8fHwYOXIkH374IQMGDOCpp57Cx8eHffv28dlnn/HRRx9RtWpV7rvvPp588kmqV6+Or68vEydOzBfKRKSUHF53tj/N9xf0p2lkG0W4RX9yHVxYuesEC6LW8ue+83c81qlRhUEdQ7izbS283JzsVLxUJgo3FciyZcsICAjIt65Ro0bce++9xMTE8MMPPwC2yz0ffPABAwYM4KabbqJlS9vQ5hEREWRkZNChQwfMZjOjRo3i/vvvzzvWnDlzeOmll3j88cc5evQoNWrUoGPHjvTp0wewBaCff/6ZCRMm0KFDB9zc3AgLC2PAgAEAPPHEE0RGRtKkSRMyMjI4ePAgoaGhrFmzhqeffpqbbrqJrKwsQkJC6NWrV16Aee211/IuX3l4ePD444+TlJRU4p+niGDrT7PzO9v4NEc3nF9f9wbb+DT1buRUeg6f/XmYT9bGcjTx/OSV3Rr7EhEeyrX1a2jySilVulvqApX5DpuKNnpwZf5ZihSLzCTbZae170PSYds6szO0uBs6Pozh24TNh22TV/74z3GyLbYzOdXcnejfvjYDw2oT7FO0foMil6K7pURE5MqcOWTrILxpAWSn2ta517D1pWl/H5ku1fluyzEWfL6GrUfPn0FtWcuLweGh9GkRgKuTJq8U+1K4ERGp7AzDNnJw1EzbFAnn+tPUbGy766nF3cQmGyz8PYbPN2wmMT0HAGdHB/q2CCQiPISWwd72q1/kXxRuBOCiaRREpBKw5MLOb8/2p4k+v77ejRA+EmudG/ltXwILFm1j9e4TnOvEEOTtxqCzk1f6VHG2T+0il6BwIyJS2VgtsGkh/PYqJB+xrTO75PWnSfJowBfRh1nw9W/EnDo//cx1DWsS0TGEGxr7YlYHYSnDFG4KUMn6WFdI+hmKFOLQGlj2NMRttS2714AOI6DdfWxLcmbBHzF8u+UXMnNsl6Y8XB25q20wgzrWpm7Ni0cSFymLFG4u4ORkG38hPT39ikbblbIjPd32r81zP1ORSi8xFlY8C9u/ti27eEHXp8luPZSfdp1h/oK9RMecyWve2N+DyE6h3NoqEHdnfVVI+aLf2AuYzWa8vb05ceIEAO7u7pq8rZwxDIP09HROnDiBt7f3RVNFiFQ62WmwZobtkZsJJgdoE0lc28dZuDWdz15fQ0JqNgCODiZubh5ARHgI7UKq6e+flFsKN//i7+8PkBdwpHzy9vbO+1mKVEqGAdu+sp2tST5qWxXSmS3NxjNrlzsr3tmK5ezklX6eLtzbIYQBHYLx9dS4UFL+Kdz8i8lkIiAgAF9fX3JycuxdjlwBJycnnbGRyu3oRlg2Hg7/DYDVqza/hY7i5QP12fdVMpAMQFgdHyI7hdKjiR9OZk1pIhWHwk0hzGazviBFpHxJiYeVk2HzIsDA6ujGqhqDeepYF07Hm4E03J3N3N4miMEdQ2nk72HvikVKhMKNiEh5l5sFf78Hv7+eN0v3727dePLMbcSn+gBQr2YVIsJDub1NEB6u6mgvFZvCjYhIeWUYsPsnWD4BzhwEYLupAc9kDmJTZgMcTNCziR8R4aF0qlddHYSl0lC4EREpj07sxFg2HtOB1QDEG968knMPX1uvxaeKK490qM29YbUJ9NawFlL5KNyIiJQn6afJWfky5o1zcDAsZBmOfGS5hXdzb6VR7QDeDA/l5ub+uDiqz6BUXgo3IiLlgSWXU7/Nwm3NK7hbbHc7/WRpz+vGINq2as3i8FCaBXnZuUiRskHhRkSkDLNYDbb8/g2+a56nVs4hAHZZg5nlNoKmnfvyVbtaeLtr8kqRCynciIiUQWfSsvnpj7+otW4K11nX2tYZVfm++jBqd3+IaY0DcNDklSIFUrgRESlD/jmSyOI/dxKy410iTUtxMeWSiwOb/O7E/3/PERFUy94lipR5CjciInaWmWNh6dbjzP/rIPWPf89TjovxdUgEIK5GJ7xve532QU3tW6RIOWL38bZnzpxJaGgorq6uhIWFsW7dukLb5uTkMHnyZOrVq4erqystW7Zk2bJlpVitiEjxOXImnVeW7aLT/61i4Rdf8MKJx3jd6X18TYlkeoZiDPgM/5FLcVWwESkSu565Wbx4MWPHjmXWrFmEhYUxffp0evbsye7du/H19b2o/TPPPMPChQv58MMPady4McuXL+e2227jr7/+onXr1nZ4ByIiRWO1GqzZn8D8qBhW7ozH1zjFJKfPuM1ljW27c1Ucrn8a17AHwNHFztWKlE8mwzAMe714WFgY7du355133gHAarUSHBzMo48+yrhx4y5qHxgYyMSJExk5cmTeujvuuAM3NzcWLlx4Wa+ZnJyMl5cXSUlJeHp6Fs8bERH5D8mZOXy54QgL/47hQEIaLmRzv/kHRjp/j6uRhYEJU+tB0O1ZqHrxP+5EKruifH/b7cxNdnY20dHRjB8/Pm+dg4MD3bt3JyoqqsB9srKycHV1zbfOzc2NP//8s9DXycrKIisrK285OTn5KisXEbl8u+KSmR8VwzebjpKebQEMbnfZwLMun+KdHQcGUDscU6//g8BWdq5WpGKwW7hJSEjAYrHg5+eXb72fnx+7du0qcJ+ePXsybdo0rrvuOurVq8fKlStZsmQJFoul0NeZOnUqL7zwQrHWLiJyKTkWK8u2xbEgKoZ1h07nre9V4wQvOC3A70w0ZAOeteCmydD0dtC8TyLFplzdLTVjxgxGjBhB48aNMZlM1KtXj6FDh/Lxxx8Xus/48eMZO3Zs3nJycjLBwcGlUa6IVDLxyZl8sjaWT9bFcjLFdsbY7GDizkaujHX8HN+9n2HCAEc3uHY0dHoMnN3tW7RIBWS3cFOjRg3MZjPx8fH51sfHx+Pv71/gPjVr1uSbb74hMzOTU6dOERgYyLhx46hbt26hr+Pi4oKLizrliUjJMAyDdQdPMz8qhuXb48i12rox1vRwYWC7AIY5rcBz7TTISrLt0OwO6P4CeOsfWSIlxW7hxtnZmbZt27Jy5Ur69esH2DoUr1y5kkceeeSS+7q6uhIUFEROTg5fffUVd999dylULCJyXlpWLl9vOsqCqBh2x6fkrW8fWo2I8FB6ufyD04oIOLXPtiGgJfT6PwjpZKeKRSoPu16WGjt2LJGRkbRr144OHTowffp00tLSGDp0KAAREREEBQUxdepUANauXcvRo0dp1aoVR48e5fnnn8dqtfLUU0/Z822ISCWy/2QqC6Ji+Cr6CClZuQC4OZnp1zqIwR1DaOIUB8sfg30rbDtUqQndnoNW94KDZuoWKQ12DTf9+/fn5MmTPPvss8TFxdGqVSuWLVuW18k4NjYWB4fz4wxmZmbyzDPPcODAAapWrcott9zCggUL8Pb2ttM7EJHKINdiZeWuEyyIiuHPfQl56+vUqMKgjiHc2bYWXqTBb/8H694Hay44OEHHh+C6J8FVw06IlCa7jnNjDxrnRkQu16nULD5bf5hP1sZyNDEDAAcT3NjYj4jwEK6tXwMHrLBxHqx6CdJP2XZseDP0fBmq17Nj9SIVS7kY50ZEpCwyDIPNhxOZHxXDj/8cJ9tiBaCauxP929dmYFhtgn3O3uF08A9YNh7it9qWazSCXlOgfnc7VS8ioHAjIgLYJq/8bssxFkTFsPVoUt76lsHeRHQMoXeLAFydzvaZORMDKybBjm9ty65ecMNEaDcMzE52qF5ELqRwIyKV2uHT6Sz8O4bFGw6TmJ4DgLOjA31bBBIRHkLLYO/zjbPT4M83Yc1bYMkCk4Mt0HSdAFWq2+cNiMhFFG5EpNKxWg1+23uSBVExrN59gnM9D4O83RgcHsLd7YLxqeJ8fgfDgK1fwIrnIOWYbV1oF7j5FfDTjN0iZY3CjYhUGknpOXwRfZiFf8dw6FR63vrrGtYkomMINzT2xezwr2kQjkTDsqfhyHrbsneIrbNw4z6aMkGkjFK4EZEKb/uxJBZExfDN5qNk5tg6CHu4OnJX22AGdaxN3ZpVL94pJQ5+eQG2fGJbdqoC1z0OHUeCk+vF7UWkzFC4EZEKKTvXyk/bjjM/KobomDN56xv7exDZKZRbWwXi7lzAn8CcTPj7XfjjDchOta1reS90exY8A0qpehG5Ggo3IlKhHE/K4JO1sXy67jAJqbbJKx0dTNzcPICI8BDahVTDVNDlJMOAXT/CzxPhzCHbuqB2cPOrUKtt6b0BEblqCjciUiFk5VqY8uNOFq6NxXJ28ko/TxcGhoVwT4dgfD0ucSkpfjssGwcHf7ctewTYJrdsfhdcMEq6iJQPCjciUu4dPp3OyE828s8R2/g0Hev6EBEeSo8mfjiZLxFO0k/D6pdhw8dgWMHsAp0ehWvHgEsB/XBEpFxQuBGRcm3VrnjGLN5CUkYO3u5OTO/fiq6NfC+9kyXHFmhWT4HMRNu6JrdCj8lQLbSkSxaREqZwIyLlksVq8OaKPbyzeh9gG0n43YFtCPJ2u/SO+1fZpkw4ucu27NcMev0f1OlSwhWLSGlRuBGRcichNYvHPt3EX/ttE1VGhocwofc1uDiaC9/p1H5YPhH2/GRbdvOBbpOgTSQ4XGI/ESl3FG5EpFxZf+g0j3yykfjkLNydzfzfHS34X8vAwnfITIbfX4O/3wNrDjg4Qof74fqnwK1a6RUuIqVG4UZEygXDMJj950Gm/rQLi9Wgvm9VZg1qQ31fj4J3sFph8yJY+QKknbStq98dek6Fmg1Lr3ARKXUKNyJS5iVn5vDUF/+wbHscAP9rGcjU25tTxaWQP2Gxf8NPT8Pxzbbl6vVtoabhTaVTsIjYlcKNiJRpO48n89DCaA6dSsfJbOLZPk0Y1DGk4IH4ko/Bz5Ng25e2ZRdPuP5p22UoR+eL24tIhaRwIyJl1pfRR3jmm61k5lgJ8nZj5sA2tAr2LrjxvpXw1XDIOA2YoE0E3DgJqtYszZJFpAxQuBGRMiczx8Lz323ns/WHAejaqCZv3t2KalUKOPtitdrmgVr9MmBAQEv439u2/4pIpaRwIyJlSuypdB5aFM32Y8mYTDC2e0NG3lAfB4cCLkNlnIElD8De5bblNpG2uaA0a7dIpaZwIyJlxood8Yz9fDMpmbn4VHHmrXtac22DGgU3PrYZPo+AxBhwdIXeb0DrQaVar4iUTQo3ImJ3uRYrr/+8h1m/7QegTW1vZg5sQ4BXIaMNb5wPPz4BlizwDoH+C3QZSkTyKNyIiF2dSMnk0U82sfbgaQCGda7D+FsaFzzhZU4mLH0CNi2wLTfsBbfN0mB8IpKPwo2I2M3fB07x6KebOJmSRRVnM6/e2ZLeLQIKbnzmkO0y1PEtYHKAGybCtWPB4RKzfotIpaRwIyKlzjAM3v/9AK8t343FatDIz4N3B7WhXs2qBe+w52dYMsI2g7d7dbhjNtS7oVRrFpHyQ+FGREpVUkYOj3++hV92xgNwe+sgXrqtGe7OBfw5slrg1/+D31+1LQe1hbvng1etUqxYRMobhRsRKTXbjibx8KKNxJ5Ox9nswPP/a8qADsEFjzacdgqWDIf9q2zL7YdDzyng6FK6RYtIuaNwIyIlzjAMFq8/zLPfbSc710qtam68N7AtzWt5FbzDkWhb/5rkI+DoBn1nQMv+pVu0iJRbCjciUqIysi1M+nYbX0YfAaBbY1+m3d0KL3enixsbBmz4GJaNA0s2+NSz3ebt17SUqxaR8kzhRkRKzMGENB5aGM2uuBQcTPD4TY146Pp6BY82nJ0OP46FLZ/alhv3gX7vgmshZ3dERAqhcCMiJWLZtuM88cU/pGblUqOqM28NaE2neoWMNnxqv+0yVPw2223e3Z+HTo9BQX1xRET+g8KNiBSrHIuVV37axUd/HgSgQ6gPb9/bGj/PQuZ72vUjfP0gZCVDlZpw5xyo06UUKxaRikbhRkSKTVxSJo98spENMWcAuP+6ujzZs1HBow1bcmHVi7Bmum05uCPcNRc8CxnET0TkMinciEix+GtfAo99tomE1Gw8XBx57a6W9GrmX3Dj1BPw5TA49IdtuePD0GMymAvoZCwiUkQKNyJyVaxWg/d+288bP+/GasA1AZ68N7ANoTWqFLxD7Fr4IhJSjoNTFbj1HWh2e+kWLSIVmsKNiFyxxPRsxn6+hVW7TgBwV9tavNivGa5O5osbGwas+wCWTwBrLtRoCP0XQs1GpVy1iFR0CjcickX+OZLIQws3cjQxAxdHB168tRl3tw8uuHFWKnw/CrZ9aVtuehv8721w8Si9gkWk0lC4EZEiMQyDRWtjmfz9DrItVkKqu/PuwDY0DSxkPJqTe+DzwXByFzg4wk0vQdiDus1bREqMwo2IXLb07Fwmfr2NrzcdBeCmJn68dldLvNwK6Qi8/Rv4diRkp4JHgO1uqNodS61eEamcFG5E5LLsP5nKQwuj2ROfitnBxNO9GjGiS92CJ7205MAvz0PUO7bl0C5w58dQ1bdUaxaRyknhRkT+0w//HOPpL/8hLdtCTQ8X3hnQmrC61QtunBIHXwyF2L9sy51HwY3Pgll/bkSkdOivjYgUKjvXypSlO5n71yEAOtb14a0BrfH1KGS04UNr4MuhkBoPzh5w23twTd/SK1hEBChg2NDSNXPmTEJDQ3F1dSUsLIx169Zdsv306dNp1KgRbm5uBAcHM2bMGDIzM0upWpHK41hiBv0/iMoLNg91rcfC+8IKDjaGAX+9DfP62oKNbxO4/1cFGxGxC7ueuVm8eDFjx45l1qxZhIWFMX36dHr27Mnu3bvx9b342vwnn3zCuHHj+Pjjj+nUqRN79uxhyJAhmEwmpk2bZod3IFIx/bH3JKM+28zptGw8XR2ZdncrujfxK7hxZrKt0/DO72zLLfpDnzfBuZBB/ERESpjJMAzDXi8eFhZG+/bteecdW6dDq9VKcHAwjz76KOPGjbuo/SOPPMLOnTtZuXJl3rrHH3+ctWvX8ueff17WayYnJ+Pl5UVSUhKenp7F80ZEKgir1eDtVfuYvnIPhgHNgjx599621K7uXvAOJ3bC4kFwah84OMHN/wft7tNt3iJS7Iry/W23y1LZ2dlER0fTvXv388U4ONC9e3eioqIK3KdTp05ER0fnXbo6cOAAS5cu5ZZbbin0dbKyskhOTs73EJGLnU7LZsjc9bz5iy3YDOhQmy8f7FR4sNn6JXx4oy3YeAbBsGXQfriCjYjYnd0uSyUkJGCxWPDzy3+q28/Pj127dhW4z7333ktCQgLXXnsthmGQm5vLgw8+yIQJEwp9nalTp/LCCy8Ua+0iFc2m2DOMXLSRY0mZuDo58HK/5tzRtlbBjXOz4eeJtqkUAOp2hTtmQ5UapVaviMil2L1DcVH8+uuvTJkyhXfffZeNGzeyZMkSfvzxR1588cVC9xk/fjxJSUl5j8OHD5dixSJlm2EYzPvrEHe/H8WxpEzq1KjCNyM7Fx5sko7C3N7ng811T8KgJQo2IlKm2O3MTY0aNTCbzcTHx+dbHx8fj7+/f4H7TJo0icGDBzN8+HAAmjdvTlpaGvfffz8TJ07EweHirObi4oKLi0vxvwGRci4tK5dxS7by/ZZjANzS3J9X7miBh2show0f+A2+HAbpCeDqBbd/CA17lmLFIiKXx25nbpydnWnbtm2+zsFWq5WVK1cSHh5e4D7p6ekXBRiz2Tb7sB37RYuUO3vjU/jfO3/y/ZZjODqYmNSnCTPvbVNwsLFa4Y9psKCfLdj4N4f7f1OwEZEyy663go8dO5bIyEjatWtHhw4dmD59OmlpaQwdOhSAiIgIgoKCmDp1KgB9+/Zl2rRptG7dmrCwMPbt28ekSZPo27dvXsgRkUv7dvNRxn21lYwcC/6erswc2Jq2IT4FN85IhG8egt1LbcutBkHv18HJrdTqFREpKruGm/79+3Py5EmeffZZ4uLiaNWqFcuWLcvrZBwbG5vvTM0zzzyDyWTimWee4ejRo9SsWZO+ffvy8ssv2+stiJQbWbkWXvphJwv+jgGgc/3qzLinNTWqFnLZNm4rLB4MZw6C2QVueQ3aRpZixSIiV8au49zYg8a5kcroyJl0Ri7ayJYjSQA8emN9RndviNmhkNu2N38CP4yB3Ezwrg13z4fA1qVYsYhIfkX5/tbcUiIV3OrdJxizeDOJ6Tl4uzvxZv9W3NCokNm5c7Pgp6cheo5tucFNcNv74F7IZSsRkTJI4UakgrJYDab/soe3V+0DoGUtL2YObEOtaoUMypcYC59HwLFNgAlumABdnoAC7kIUESnLFG5EKqCE1CxGfbaJNftOATC4YwjP9LkGF8dCOt7v+wW+Gg4ZZ8CtGtzxEdTvXnBbEZEyTuFGpIKJjjnNyEWbiEvOxM3JzP/d0ZxbWwUV3Nhqhd9fg1+nAoatX83d8239bEREyimFG5EKwjAMPl5ziKlLd5JrNahXswqzBrWlgZ9HwTukn4Yl98O+FbbldsOg1/+Bowa9FJHyTeFGpAJIyczh6a/+YenWOAD6tAjg/+5oQVWXQv4XP7YJFkdAUiw4ukKf6dBqQOkVLCJSghRuRMq5XXHJPLRwIwcT0nAym3imdxMiwkMwFTY7d/Q8WPokWLKgWh3ov8A26rCISAWhcCNSjn0VfYSJ32wlM8dKoJcrMwe2oXXtagU3zsmAH5+AzQtty41ugX7vgZt3qdUrIlIaFG5EyqHMHAsvfL+DT9fFAnBdw5pM798KnyrOBe9w+iB8Ptg26rDJAW6cBJ1H6zZvEamQFG5EypnDp9N5aFE0244mYzLB6G4NeeTG+oWPNrx7GXx9P2QmgXsNuPNjqHt96RYtIlKKFG5EypFfdsQz9vPNJGfmUs3diRn3tOa6hjULbmy1wOop8MfrtuVaHeDueeAZWHoFi4jYgcKNSDmQa7Hyxoo9vPfrfgBa1/Zm5r1tCPQuZHbutAT46j448KttucMDcNNL4FjIZSsRkQpE4UakjDuRksljn27i7wOnARjaOZTxN1+Ds2Mh/WWObIDPIyH5CDi5w//ehuZ3lmLFIiL2pXAjUoadSMnkjvf+4vDpDKo4m3nlzhb0aVHIZSXDgPUfwbLxYM2B6vWh/0LwvaZ0ixYRsTOFG5EyKiUzhyEfr+fw6QxCqrszO7I99X2rFtw4Ow1+GAP/LLYtN7kV/vcOuHqWXsEiImWEwo1IGZSda+XBhdHsOJ5MjarOLBgWRu3qhczmnbDPdpv3iR1gMkOPyRA+EgobxE9EpIJTuBEpY6xWgye/3MKafaeo4mxmzpAOhQebnd/DNw9DVjJU9YO75kJIp1KtV0SkrFG4ESlj/m/ZLr7dfAxHBxPvDWpL81peFzey5MKqybBmhm25die4aw54+JdusSIiZZDCjUgZ8tEfB/jg9wMAvHZXi4LHsEk9AV8Og0N/2JbDH4Huz4PZqfQKFREpwxRuRMqI77Yc46UfdwIw7ubG3Na61sWNYv+23eadGgfOHnDrO9C0X+kWKiJSxinciJQBf+1L4PHPNwMwpFMoD1xXN38Dw4C/34MVk8CaCzUb227zrtGg9IsVESnjFG5E7GzHsWTuXxBNjsWgd/MAnu3TBNOFdzplpcB3j8L2r23Lze6EvjPApZDbwkVEKjmFGxE7Onw6nSFz1pGalUtYHR/euLslDhdOgJlxBub2hfit4OAIPadChxG6zVtE5BIUbkTs5ExaNpFz1nEiJYvG/h58ENEOVyfz+QbZ6fBJf1uwqeIL9yyC4A72K1hEpJxQuBGxg4xsC8PmrefAyTSCvN2YO7QDXm4X3O2Umw2fR8DhteDqBYO/Bv9m9itYRKQcKWTmPREpKbkWK49+upFNsYl4uTkxb1h7/L1czzewWuGbh2DfCnB0g3s/V7ARESkChRuRUmQYBpO+3cYvO0/g4ujA7Mh21Pf1uLAB/PQUbPvS1sem/wKo3dF+BYuIlEMKNyKlaMbKvXy67jAOJnhrQGvahfrkb/Dr/8H6DwET3PY+NOhhlzpFRMozhRuRUvLpulim/7IXgMm3NqNn039NlbD2ffjt/2zPb3kNmt9ZyhWKiFQMCjcipWDFjngmfr0VgMdurM+gjiH5G/zzue1yFEDXCbbbvUVE5Ioo3IiUsOiYMzz66UasBvRvF8yYHg3zN9iz3NaBGCDsQbj+qdIvUkSkAlG4ESlB+06kct+89WTmWLmxsS8v39Ys/+jDMVG2W76tudCiv22QPg3QJyJyVRRuREpIfHImkR+vIzE9h5bB3rxzb2sczRf8Lxe31TZIX24mNOgJt84EB/0vKSJytfSXVKQEJGfmMGTOeo4mZlCnRhU+jmyHu/MFY2ae2g8LboesJKgdDnfNBbNToccTEZHLp3AjUsyyci08uCCanceTqenhwvxhHahe1eV8g+TjsKAfpJ0Av+Yw4DNwdrdbvSIiFY3CjUgxsloNHv98C3/tP0VVF0fmDGlPsM8FwSX9NCy8HRJjoVodGPQVuHnbrV4RkYpI4UakGL28dCc//HMcJ7OJWYPa0izI6/zG7DRbH5sTO6CqP0R8Ax5+dqtVRKSiUrgRKSYf/n6A2X8eBOD1u1pybYMa5zfmZsPiwXBk3fmJMKuF2qdQEZEKTuFGpBh8u/koLy/dCcCEWxpza6ug8xutFvj6Adi/EpzcYeCX4NfETpWKiFR8CjciV2nNvgSe+GILAMM612FEl7rnN56bCHP7EnBwsk2EGdzBTpWKiFQOCjciV2Hb0SQeWBBNjsWgT4sAnul9Tf5B+lZPgfUfASa4/X2o391utYqIVBZlItzMnDmT0NBQXF1dCQsLY926dYW27dq1KyaT6aJH7969S7FiETh8Op0hc9aTmpVLeN3qvHF3SxwcLgg2f78Hv79qe977dWh2h30KFRGpZOwebhYvXszYsWN57rnn2LhxIy1btqRnz56cOHGiwPZLlizh+PHjeY9t27ZhNpu56667SrlyqcxOp2UT8fE6ElKzaOzvwfsRbXFxNJ9vsOUzWDbO9vyGZ6D9cPsUKiJSCdk93EybNo0RI0YwdOhQmjRpwqxZs3B3d+fjjz8usL2Pjw/+/v55jxUrVuDu7q5wI6UmPTuXYXPXczAhjSBvN+YN64Cn6wWjC+/+Cb552Pa848Nw3RP2KVREpJIqUriJiIggJSUlb3nLli3k5ORc8YtnZ2cTHR1N9+7n+yE4ODjQvXt3oqKiLusYs2fP5p577qFKlSoFbs/KyiI5OTnfQ+RK5VqsPPrJJjYfTsTb3Yl5wzrg5+l6vsGhNfDFEDAs0OIeuOllTYQpIlLKihRuFi1aREZGRt5yly5dOHz48BW/eEJCAhaLBT+//AOZ+fn5ERcX95/7r1u3jm3btjF8eOGn/KdOnYqXl1feIzg4+IrrlcrNMAwmfr2NlbtO4OLowOzIdtT3rXq+wfF/4NN7bBNhNrwZbn1HE2GKiNhBkf7yGoZxyeXSNnv2bJo3b06HDoXfWjt+/HiSkpLyHlcTxqRye/OXvSzecBgHE7xzbxvahvic33hqv21ahaxkCOkMd83RRJgiInbi+N9NSk6NGjUwm83Ex8fnWx8fH4+/v/8l901LS+Ozzz5j8uTJl2zn4uKCi4vLJduI/JdFa2N4a+VeAF6+rTk9mlxwtjH5GMzvB2knwb85DPgUnNzsU6iIiBQ93OzYsSPvkpFhGOzatYvU1NR8bVq0aHFZx3J2dqZt27asXLmSfv36AWC1Wlm5ciWPPPLIJff94osvyMrKYtCgQUV9CyJFsnx7HJO+2QbAqG4NGNCh9vmN6adhwe2QFAs+dWHQEtv0CiIiYjdFDjfdunXLdzmqT58+AJhMJgzDwGQyYbFYLvt4Y8eOJTIyknbt2tGhQwemT59OWloaQ4cOBWydmIOCgpg6dWq+/WbPnk2/fv2oXr16Ud+CyGXbcOg0j326CasBAzoEM7p7g/Mbs1Jh0V1wcid4BMDgb6Cqr91qFRERmyKFm4MHDxZ7Af379+fkyZM8++yzxMXF0apVK5YtW5bXyTg2NhaHf3XK3L17N3/++Sc///xzsdcjcs6+EyncN28DWblWul/jy4u3Njs/+nBuNnw+GI5uAFfvsxNhhti1XhERsTEZ9u4VXMqSk5Px8vIiKSkJT09Pe5cjZVRcUiZ3vPcXRxMzaF3bm0+Gd8TN+ewgfVYLfHUfbP8anKpAxLcQ3N6+BYuIVHBF+f6+og7Fe/fu5dtvv+XQoUOYTCbq1KlDv379qFu37n/vLFLGJWXkMGTOOo4mZlC3ZhVmR7Y/H2wMA3583BZs8ibCVLARESlLihxupk6dyrPPPovVasXX1xfDMDh58iTjxo1jypQpPPGERmOV8isr18IDCzawKy6Fmh4uzBvaAZ8qzucbrHoJoudgmwjzA6jfzW61iohIwYo0zs3q1at55plnmDhxIgkJCRw/fpy4uLi8cDNu3Dh+//33kqpVpERZrQZjP9/C3wdOU9XFkblD2xPs436+QdRM+ON12/M+06DZ7fYpVERELqlIfW769++Pt7c377//foHb77//flJSUvj000+LrcDipj43UhDDMJj8ww7mrDmEk9nEvKEd6FS/xvkGmz+Fbx60Pb9xkuaLEhEpZUX5/i7SmZt169YxePDgQrcPHjyYv//+uyiHFCkTPvj9AHPWHALgjbtb5Q82u5bCtyNtz8MfgS6Pl36BIiJy2YoUbuLj4wkNDS10e506dS5rTiiRsuTrTUeY+tMuAJ7pfQ3/axl4fuOhP89PhNnyXujxoibCFBEp44oUbjIzM3F2di50u5OTE9nZ2VddlEhp+X3PSZ784h8ARnSpw/AuF9zxd3wLfHIPWLKg0S3wv7c1EaaISDlQ5LulPvroI6pWrVrgtpSUlKsuSKS0bDuaxEMLo8m1GtzaKpDxN19zfmPCPtu0CtkpEHIt3DkHzHadik1ERC5Tkf5a165dmw8//PA/24iUdbGn0hkyZx1p2RY616/Oa3e2xMHh7OWmpKOwoB+kJ0BAy7MTYbratV4REbl8RQo3hw4dKqEyRErPqdQsIj5eS0JqNk0CPJk1qC3OjmcvN6WfhoW3Q9JhqF4fBn4FrrqrTkSkPClSB4JVq1bRpEkTkpOTL9qWlJRE06ZN+eOPP4qtOJHilp6dy7C56zl0Kp1a1dyYO7Q9Hq5Oto1ZqbDoTji5CzwCbfNFVa1p34JFRKTIihRupk+fzogRIwq8v9zLy4sHHniAadOmFVtxIsUpx2Jl5KKNbDmSRDV3J+YN64Cv59nLTblZsHgQHI0Gt2q2YOOtS6wiIuVRkcLNli1b6NWrV6Hbb7rpJqKjo6+6KJHiZhgG45dsZfXuk7g6OTB7SHvq1TzbMd5qgSX3w4HVtokwB34Fvo3tW7CIiFyxIo9z4+TkVOh2R0dHTp48edVFiRS3N37ew5fRRzA7mJh5bxva1K5m22AY8ONY2PGNbSLMexZBrbZ2rVVERK5OkcJNUFAQ27ZtK3T7P//8Q0BAwFUXJVKcFvwdwzur9wHwcr9mdLvG7/zGlZMhei6YHOCOj6DeDfYpUkREik2Rws0tt9zCpEmTyMzMvGhbRkYGzz33HH369Cm24kSu1rJtcTz7rS2Qj+nekHs6XNCP5q+34c+zfcT6vAlN+5V+gSIiUuyKNHFmfHw8bdq0wWw288gjj9CoUSMAdu3axcyZM7FYLGzcuBE/P7//OJL9aOLMymP9odMM/Ggt2blWBnSozZTbmmE6N3XCpoXn54vq9hx0GWu/QkVE5D8V5fu7SOPc+Pn58ddff/HQQw8xfvx4zuUik8lEz549mTlzZpkONlJ57IlP4b6568nOtdKjiR8v3tr0fLDZ+QN896jteadH4dox9itURESKXZHHkw8JCWHp0qWcOXOGffv2YRgGDRo0oFq1aiVRn0iRHU/KIPLjdSRn5tI2pBpvD2iNo/nsFdiDf8CXw8CwQqtBmghTRKQCuuLJcqpVq0b79u2LsxaRq5aUkcOQj9dzPCmTejWrMDuyHa5OZtvGY5vg0wG2iTAb94G+MxRsREQqIE1xLBVGZo6FEfM3sDs+BT9PF+YN64C3+9lZ7BP2wsI7bBNhhnaBO2ZrIkwRkQpK4UYqBIvVYOznm1l38DQeLo7MHdqBWtXcbRuTjsD8fpB+CgJawT2faCJMEZEKTOFGyj3DMJj8/XaWbo3D2ezA+xFtuSbgbE/6tFOw4DZIPgLVG8AgTYQpIlLRKdxIuffeb/uZFxWDyQTT+rekU70atg1ZKbaJMBP2gGeQbb6oKjXsW6yIiJQ4hRsp176KPsKry3YDMKl3E/q0CLRtyM2CzwbCsY3g5nN2IsxgO1YqIiKlReFGyq1fd5/g6a/+AeCB6+oy7No6tg1WC3w1HA7+Bs5VYdCXULORHSsVEZHSpHAj5dI/RxJ5eNFGcq0G/VoF8nSvs7N4Gwb8MBp2fgdmZ9tEmEGaCFNEpDJRuJFy51BCGkPnrCc920KXBjV49c6WODicHa/ml+dh4/yzE2HOhrpd7VmqiIjYgcKNlCsJqVlEzlnHqbRsmgZ68t6gtjg7nv01XjMD1ky3Pe87A5r8z251ioiI/SjcSLmRlpXLsLnriTmVTrCPG3OGtqeqy9mB+DYugBXP2p53fwHaRNivUBERsSuFGykXcixWHlq0kX+OJOFTxZn5w8Lw9Tg7EN/O7+H7x2zPO4+Ca0fbrU4REbE/hRsp8wzD4Omv/uH3PSdxczLz8ZD21KlRxbbxwG/nJ8JsPdh21kZERCo1hRsp815bvpslG49idjDx7sA2tAr2tm04uhE+uxcs2XBNX+gzXRNhioiIwo2UbfP+OsS7v+4HYOrtzbmhsa9tw8k9ttGHs1OhznVw+0eaCFNERACFGynDlm49zvPfbwfg8R4Nubvd2RGGEw/b5otKPwWBrTURpoiI5KNwI2XS2gOnGL14M4YBgzrW5pEb69s2pCWcnwizRkMY+BW4eNi3WBERKVMUbqTM2R2XwvD5G8jOtdKzqR8v/K8ZJpPp/ESYp/aCZ62zE2FWt3e5IiJSxijcSJlyLDGDyI/XkZKZS7uQasy4pzVmBxPkZNo6Dx/bBO7VIeIb8Kpl73JFRKQMUriRMiMpPYfIj9cRl5xJfd+qfBTZDlcnM1hy4av74ODvZyfC/ApqNLB3uSIiUkYp3EiZkJljYcT8Dew9kYq/pyvzhnXA29357ESYo2DXD7aJMAd8autELCIiUgiFG7E7i9Vg1GebWHfoNB6ujswd1p4gbzfbxhXPwqaFtokw75xju+1bRETkEhRuxK4Mw+D577azfHs8zmYHPoxoR2N/T9vGP6fDX2/Znv/vbbimj93qFBGR8sPu4WbmzJmEhobi6upKWFgY69atu2T7xMRERo4cSUBAAC4uLjRs2JClS5eWUrVS3N79dT8L/o7BZILp97SiY92zdz9Fz4NfnrM97/EitB5kvyJFRKRcseuQrosXL2bs2LHMmjWLsLAwpk+fTs+ePdm9eze+vr4Xtc/OzqZHjx74+vry5ZdfEhQURExMDN7e3qVfvFy1LzYc5rXluwF4rk8TbmkeYNuw41v4YbTt+bVjoPNj9ilQRETKJZNhGIa9XjwsLIz27dvzzjvvAGC1WgkODubRRx9l3LhxF7WfNWsWr732Grt27cLJyemKXjM5ORkvLy+SkpLw9PS8qvrlyq3efYLh8zZgsRo8eH09xt3c2LZh/2r45G7bfFFtIqHvDM0XJSIiRfr+tttlqezsbKKjo+nevfv5Yhwc6N69O1FRUQXu89133xEeHs7IkSPx8/OjWbNmTJkyBYvFUujrZGVlkZycnO8h9rXtaBIjF23EYjW4vXUQT/dqZNtwJBo+G3h2Isz/QZ83FWxERKTI7BZuEhISsFgs+Pn55Vvv5+dHXFxcgfscOHCAL7/8EovFwtKlS5k0aRJvvPEGL730UqGvM3XqVLy8vPIewcHBxfo+pGhOJGcyYv4G0rMtXFu/Bq/c2cI2+vDJ3bbRh3PSoG5XuOMjcDDbu1wRESmH7N6huCisViu+vr588MEHtG3blv79+zNx4kRmzZpV6D7jx48nKSkp73H48OFSrFgulJFtG8vmeFIm9WpWYebANjiZHc5PhJlxGoLaQv9F4Ohi73JFRKScsluH4ho1amA2m4mPj8+3Pj4+Hn9//wL3CQgIwMnJCbP5/L/or7nmGuLi4sjOzsbZ2fmifVxcXHBx0RelvVmtBo9/sZktR5Ko5u7Ex0Pa4+XmdHYizH6QfBRqNIKBX4JLVXuXKyIi5Zjdztw4OzvTtm1bVq5cmbfOarWycuVKwsPDC9ync+fO7Nu3D6vVmrduz549BAQEFBhspOx485c9LN0ah5PZxPuD2xFSvQpkJsPC2+HUPvAKtk2E6e5j71JFRKScs+tlqbFjx/Lhhx8yb948du7cyUMPPURaWhpDhw4FICIigvHjx+e1f+ihhzh9+jSjRo1iz549/Pjjj0yZMoWRI0fa6y3IZfh60xHeXrUPgCm3NadDHZ/zE2Ee3wLuNWDwN+AVZN9CRUSkQrDrODf9+/fn5MmTPPvss8TFxdGqVSuWLVuW18k4NjYWB4fz+Ss4OJjly5czZswYWrRoQVBQEKNGjeLpp5+211uQ/7Dh0Gme/nIrAA91rcdd7YJt80V9dR8c+gOcPc5OhFnfzpWKiEhFYddxbuxB49yUnsOn0+k3cw2n0rLp2dSP9wa2xcHBZJsr6tuRYHaxBZs6XexdqoiIlHHlYpwbqdhSMnO4b956TqVl0yzIkzf7t7IFm7QE+PkZW6MbJyrYiIhIsVO4kWKXa7Hy6Keb2BOfip+nCx9FtMfd+ewV0OUTIOMM+DWHjg/bt1AREamQFG6k2L30405+3X0SVycHPopoj7+Xq23D/tXwz2LAZJtWwXxlU2iIiIhcisKNFKsFf8cw969DAEzv34rmtbxsG3Iy4Icxtucd7odabe1ToIiIVHgKN1Js/th7kue/2w7Akz0b0atZwPmNv78GZw6CRyDc+IydKhQRkcpA4UaKxb4TKTx8bjLMNkE83LXe+Y3xO2DNDNvzW14FV92lJiIiJUfhRq7a6bRshs3dQEpmLu1DqzH19ua2yTABrFb4YTRYc6FRb7imr11rFRGRik/hRq5KVq6FBxdEE3s6nWAfN2YNaouL4wWzeUfPgcNrwbmq7ayNiIhICVO4kStmGAYTlmxj3aHTeLg48nFke6pXvWCS0pQ4+OUF2/MbJ4FXLfsUKiIilYrCjVyxWb8d4KuNR3AwwTsD29DAzyN/g2XjICsJAttAhxH2KVJERCodhRu5Isu2xfHq8l0APP+/plzfsGb+Bnt+hu1fg8lsG9PGwVzAUURERIqfwo0U2bajSYxZvBnDgMjwECLCQ/M3yE6DHx+3Pe/4EAS0KPUaRUSk8lK4kSKJS8rkvnnrycixcF3Dmkzq0+TiRqunQFIseNWGGyaUfpEiIlKpKdzIZcvItjBi/gbik7No4FuVd+5tjaP5X79Cx7fA3+/Znvd+A5yrlH6hIiJSqSncyGWxWg3Gfr6ZrUeT8KnizOzI9ni6/mtuKKsFvh8FhgWa3gYNb7JPsSIiUqkp3MhleWPFbn7aFoez2YH3B7eldnX3ixut+xCObQIXL+j1SukXKSIigsKNXIavoo8wc/V+AP7vjua0D/W5uFHSEVj1ou15j+fBw6/0ChQREbmAwo1c0vpDpxm/ZCsAI2+ox+1tChmIb+lTkJ0KwWHQZkjpFSgiIvIvCjdSqNhT6TywIJpsi5Wbm/nzeI9GBTfc+T3s/hEcHKHPdHDQr5WIiNiPvoWkQMmZOQybt57Tadk0D/Ji2t2tcHAwXdwwM9l21gag8yjwK+DWcBERkVKkcCMXybVYeeSTTew7kYq/pysfRbbDzbmQEYZXvQgpx8CnLlz3ZOkWKiIiUgCFG7nIiz/s4Pc9J3FzMvNRZDv8PF0Lbngk2naHFECfN8HJrfSKFBERKYTCjeQzP+oQ86JiAHizfyuaBXkV3NCSYxvTBgNa3AN1u5ZajSIiIpeicCN5fttzkhe+3wHA070a06uZf+GN/34X4reCWzXo+XIpVSgiIvLfFG4EgL3xKTyyaCMWq8GdbWvx4PV1C2985hCsnmp7ftNLUKVGqdQoIiJyORRuhFOpWQybt56UrFw61PFhym3NMZkKuDMKwDBsM37nZkBoF2g1sHSLFRER+Q8KN5VcVq6FBxZEc/h0BrV93Jk1qC3Ojpf4tdj2Fez7BczOtk7EhYUgERERO1G4qcQMw2D8kq1siDmDh6sjHw9ph08V58J3yDgDy8bZnnd5Amo0KJ1CRUREikDhphJ799f9LNl4FLODiXcHtqG+r8eld/jleUg7CTUawrWjS6NEERGRIlO4qaR+2nqc15bvBuD5/zWlS4Oal94hJgqi59qe95kOji4lWp+IiMiVUriphLYeSWLM55sBGNIplMEdQy69Q242/DDa9rz1YAjtXKL1iYiIXA2Fm0omLimT4fPXk5ljpWujmjzT+5r/3mnNDDi5C6rUhB6TS75IERGRq6BwU4mkZ+dy37z1xCdn0dCvKm8PaI2j+T9+BRL2we+v2Z73nAruPiVfqIiIyFVQuKkkrFaDMYs3s/1YMtWrODM7sj0erk6X3skwbJejLFlQ70Zofmep1CoiInI1FG4qidd+3s3y7fE4mx34IKItwT7u/73Tls/g0B/g6Aa9p2lMGxERKRcUbiqBLzYc5r1f9wPw6p0taBtyGZeW0k7B8gm2512fBp86JVihiIhI8VG4qeDWHTzNhK+3AvDojfXp1zro8nb8+RnIOA2+TSH8kRKsUEREpHgp3FRgMafSeGDBBnIsBr2bBzCme8PL2/HAb7DlE8AEfWeA+T/65oiIiJQhCjcVVFJGDsPmrudMeg4ta3nx+l0tcXC4jD4zOZnwwxjb8/b3QXD7ki1URESkmCncVEC5FiuPfLKR/SfTCPBy5cOIdrg5my9v5z9eh9P7oao/dHu2ZAsVEREpAQo3FYxhGDz//Xb+2JuAu7OZjyLb4evpenk7n9gFf063Pb/lVXD1KrE6RURESkqZCDczZ84kNDQUV1dXwsLCWLduXaFt586di8lkyvdwdb3ML+9KYN5fh1j4dywmE0zv34qmgZcZUKxW25g21hxoeDNc878SrVNERKSk2D3cLF68mLFjx/Lcc8+xceNGWrZsSc+ePTlx4kSh+3h6enL8+PG8R0xMTClWXHat3n2CyT/sAGBcr8bc1NT/8nfeNB9io8CpCtzymsa0ERGRcsvu4WbatGmMGDGCoUOH0qRJE2bNmoW7uzsff/xxofuYTCb8/f3zHn5+fqVYcdm0Oy6FRz/ZhNWAu9vV4v7r6l7+zinxsOJs/5obJ4J3cMkUKSIiUgrsGm6ys7OJjo6me/fueescHBzo3r07UVFRhe6XmppKSEgIwcHB3HrrrWzfvr3QtllZWSQnJ+d7VDQJqVncN289qVm5hNXx4aV+zTEV5czL8vGQmQQBLaHDAyVXqIiISCmwa7hJSEjAYrFcdObFz8+PuLi4Avdp1KgRH3/8Md9++y0LFy7EarXSqVMnjhw5UmD7qVOn4uXllfcIDq5YZyUycyw8sCCaI2cyCK3uzqxBbXF2LMKPde8vsO0rMDlA37fA7FhyxYqIiJQCu1+WKqrw8HAiIiJo1aoV119/PUuWLKFmzZq8//77BbYfP348SUlJeY/Dhw+XcsUlxzAMxi/ZSnTMGTxdHfkosj3Vqjhf/gGy0+DHs2PahD0Ega1KpE4REZHSZNd/pteoUQOz2Ux8fHy+9fHx8fj7X15nWCcnJ1q3bs2+ffsK3O7i4oKLi8tV11oWzVy9j683HcXsYOK9QW2p71u1aAf47RVIjAXPWnDDhJIpUkREpJTZ9cyNs7Mzbdu2ZeXKlXnrrFYrK1euJDw8/LKOYbFY2Lp1KwEBASVVZpn04z/Hef3nPQBMvrUpnevXKNoB4rbCX+/Ynvd+HVyKGIxERETKKLt3sBg7diyRkZG0a9eODh06MH36dNLS0hg6dCgAERERBAUFMXXqVAAmT55Mx44dqV+/PomJibz22mvExMQwfPhwe76NUrXlcCKPf7EZgGGd6zAwLKRoB7Ba4PtRYFhs49k0urn4ixQREbETu4eb/v37c/LkSZ599lni4uJo1aoVy5Yty+tkHBsbi4PD+RNMZ86cYcSIEcTFxVGtWjXatm3LX3/9RZMmTez1FkrVscQMhs/fQGaOlRsb+zKx9zVFP8j62XA0Glw84eZXi79IEREROzIZhmHYu4jSlJycjJeXF0lJSXh6etq7nCJJy8rlrllR7DieTCM/D758KBwP1yLO2J18DN7pANkpcMvr0GFEyRQrIiJSjIry/V3u7paqrKxWg9GLN7PjeDI1qjrzUWS7ogcbgKVP2oJNrfbQ7r7iL1RERMTOFG7KiVeW72LFjnicHR14f3A7gn3ci36QXT/Crh/AwRH6zgAH/fhFRKTi0bdbOfD5+sO8/9sBAF67swVtQ6oV/SBZKbazNgDhj4Bf02KsUEREpOxQuCnj/j5wiglfbwXgsW4NuLVV0JUdaNXLkHwUvEPg+qeLsUIREZGyReGmDDuUkMaDC6PJtRr0aRHAmO4NruxARzfCurMjOPd5E5yv4JKWiIhIOaFwU0YlpecwbN56EtNzaBnszet3tSzaZJjnWHLh+8fAsELzu6B+t+IvVkREpAxRuCmDcixWHv4kmgMn0wj0cuXDiLa4Opmv7GBr37ONRuzqDT2nFmudIiIiZZHCTRljGAbPfbedNftO4e5s5qPI9vh6uF7Zwc7EwOoptuc3vQhVaxZfoSIiImWUwk0ZM2fNIT5ZG4vJBG/d05omgVc40KBhwNInICcdaneCVoOKt1AREZEySuGmDFm96wQv/bgDgAk3X0P3Jn5XfrAd38Den8HBCfpO15g2IiJSaegbr4zYFZfMo59uwmrAPe2DGd6lzpUfLCMRfjp7u3eXsVCzUbHUKCIiUh4o3JQBJ1OyuG/uBlKzcgmvW53Jtza7sjujzln5AqTGQ/X6cO3Y4itURESkHFC4sbPMHAsPLNjA0cQM6tSownuD2uDseBU/lti1sOFj2/M+08HpCjsji4iIlFMKN3ZkGAZPf/UPG2MT8XJzYnZkO7zdna/8gLnZ8P0o2/NWg6BOl+IpVEREpBxRuLGjt1ft49vNx3B0MPHewDbUrVn16g4Y9Tac3Anu1W23fouIiFRCCjd28v2WY0xbsQeAl/o1o1P9Gld3wNMH4LdXbc97TgF3n6usUEREpHxSuLGDzYcTeeKLLQAMv7YO93SofXUHNAz4YQzkZkKd66FF/2KoUkREpHxSuCllRxMzGD5vA1m5Vro19mX8Lddc/UH/+RwO/AqOrraJMa/mTisREZFyTuGmFKVm5XLf3PUkpGbR2N+DGQNaY3a4yiCSfhqWj7c9v+5JqF7v6gsVEREpxxRuSonFajD6s03sikuhRlUXZg9pT1UXx6s/8M+TIP0U1LwGOj129ccTEREp5xRuSskry3bxy84TODs68GFEW4K83a7+oAf/gM0Lbc/7zgDHq7iNXEREpIJQuCkFn62L5YPfDwDwxl0taV272tUfNDfL1okYoO1QqB129ccUERGpABRuSthf+xN45pttAIzu3oC+LQOL58B/TINTe6GqH3R/vniOKSIiUgEo3JSggwlpPLRwI7lWg/+1DGRUtwbFc+CTe+DPabbnvf4P3LyL57giIiIVgMJNCUlMz+a+uetJysihdW1vXr2zxdVNhnmO1Qo/jAZLNjS4CZredvXHFBERqUAUbkpAjsXKw4s2ciAhjSBvNz4Y3A5XJ3PxHHzzQohZA07ucMvrGtNGRETkXxRuiplhGDz77Xb+2n+KKs5mPopsR00Pl+I5eOpJ263fADdMgGohxXNcERGRCkThppjN/vMgn66LxcEEb9/bmmsCPIvv4MsnQGYi+DeHsIeK77giIiIViMJNMfplRzwvL90JwMTeTbixsV/xHXz/Ktj6OZgcbGPamIthAEAREZEKSOGmmOw8nsyozzZhGDCgQ22GdQ4tvoNnp58f06bD/RDUtviOLSIiUsEo3BSTpIwczA4mOtWrzuRbmxbPnVHn/P4qnDkEnkFw4zPFd1wREZEKSNc2iknHutX5ZmRnqldxwclcjJkxfjv89bbt+S2vgYtH8R1bRESkAlK4KUZ1a1Yt3gNarfD9KLDmQuM+0Lh38R5fRESkAtJlqbIs+mM4sh6cPeDmV+1djYiISLmgcFNWJR+HX16wPe82CbyC7FuPiIhIOaFwU1Ytexqykm13RrUfbu9qREREyg2Fm7Jo9zLY8S2YzLYxbRyKaeoGERGRSkDhpqzJSoWlT9ieh4+0jUYsIiIil03hpqxZPQWSDoN3beg6zt7ViIiIlDsKN2XJsU2w9j3b897TwLmKfesREREphxRuygpLrm1MG8MKTW+HBj3sXZGIiEi5VCbCzcyZMwkNDcXV1ZWwsDDWrVt3Wft99tlnmEwm+vXrV7IFloZ1H8DxLeDqBb3+z97ViIiIlFt2DzeLFy9m7NixPPfcc2zcuJGWLVvSs2dPTpw4ccn9Dh06xBNPPEGXLl1KqdISlHgYVr1ke979BfAoxtnERUREKhm7h5tp06YxYsQIhg4dSpMmTZg1axbu7u58/PHHhe5jsVgYOHAgL7zwAnXr1i3FakuAYcDSJyEnDYI7QptIe1ckIiJSrtk13GRnZxMdHU337t3z1jk4ONC9e3eioqIK3W/y5Mn4+vpy3333lUaZJWvnd7DnJ3BwOjumjd3zpoiISLlm14kzExISsFgs+Pnlvwzj5+fHrl27Ctznzz//ZPbs2WzevPmyXiMrK4usrKy85eTk5Cuut9hlJsHSp2zPO48C38b2rUdERKQCKFenCVJSUhg8eDAffvghNWrUuKx9pk6dipeXV94jODi4hKssgpUvQmoc+NSF656wdzUiIiIVgl3P3NSoUQOz2Ux8fHy+9fHx8fj7+1/Ufv/+/Rw6dIi+ffvmrbNarQA4Ojqye/du6tWrl2+f8ePHM3bs2Lzl5OTkshFwDq+H9R/Znvd5E5zc7FuPiIhIBWHXcOPs7Ezbtm1ZuXJl3u3cVquVlStX8sgjj1zUvnHjxmzdujXfumeeeYaUlBRmzJhRYGhxcXHBxcWlROq/YpYc25g2GNByANTtau+KREREKgy7hhuAsWPHEhkZSbt27ejQoQPTp08nLS2NoUOHAhAREUFQUBBTp07F1dWVZs2a5dvf29sb4KL1ZVrUO3BiO7j5wE0v27saERGRCsXu4aZ///6cPHmSZ599lri4OFq1asWyZcvyOhnHxsbiUJHuIDp9EH59xfa858tQpbp96xEREalgTIZhGPYuojQlJyfj5eVFUlISnp6epfvihgELb4f9qyC0C0R+DyZT6dYgIiJSDhXl+7sCnRIpB7Z9ZQs2ZhfoM13BRkREpAQo3JSW9NOwbJzt+XVPQI369q1HRESkglK4KS2/PAdpJ6FGI+g82t7ViIiIVFgKN6Uh5i/YON/2vO8McHS2bz0iIiIVmMJNScvNOjumDbZJMUPC7VuPiIhIBadwU9L+nA4Je6BKTejxgr2rERERqfAUbkpSwl7443Xb817/B27V7FuPiIhIJaBwU1IMA34YA5ZsqNcNmt1h74pEREQqBYWbkrL5Ezj0Bzi6QZ9pGtNGRESklCjclIS0BPh5ou1513FQLdSu5YiIiFQmCjclYflEyDgDfs0gfKS9qxEREalUFG6K2/7V8M9ngMk2po3Zyd4ViYiIVCoKN8UpJ8PWiRig/XCo1c6+9YiIiFRCCjfF6ffX4cxB8AiAbs/auxoREZFKSeGmuJzYCWum257f/Cq4Xno6dhERESkZjvYuoMJIO2kbhTiwNVzT197ViIiIVFoKN8WlznUwcq1tLimNaSMiImI3CjfFydXL3hWIiIhUeupzIyIiIhWKwo2IiIhUKAo3IiIiUqEo3IiIiEiFonAjIiIiFYrCjYiIiFQoCjciIiJSoSjciIiISIWicCMiIiIVisKNiIiIVCgKNyIiIlKhKNyIiIhIhaJwIyIiIhVKpZsV3DAMAJKTk+1ciYiIiFyuc9/b577HL6XShZuUlBQAgoOD7VyJiIiIFFVKSgpeXl6XbGMyLicCVSBWq5Vjx47h4eGByWQq1mMnJycTHBzM4cOH8fT0LNZjVzT6rC6fPqvLp8/q8umzKhp9XpevpD4rwzBISUkhMDAQB4dL96qpdGduHBwcqFWrVom+hqenp375L5M+q8unz+ry6bO6fPqsikaf1+Uric/qv87YnKMOxSIiIlKhKNyIiIhIhaJwU4xcXFx47rnncHFxsXcpZZ4+q8unz+ry6bO6fPqsikaf1+UrC59VpetQLCIiIhWbztyIiIhIhaJwIyIiIhWKwo2IiIhUKAo3IiIiUqEo3BSD559/HpPJlO/RuHFje5dVZh09epRBgwZRvXp13NzcaN68ORs2bLB3WWVOaGjoRb9XJpOJkSNH2ru0MsdisTBp0iTq1KmDm5sb9erV48UXX7ysOWgqo5SUFEaPHk1ISAhubm506tSJ9evX27ssu/v999/p27cvgYGBmEwmvvnmm3zbDcPg2WefJSAgADc3N7p3787evXvtU6yd/ddntWTJEm666SaqV6+OyWRi8+bNpVqfwk0xadq0KcePH897/Pnnn/YuqUw6c+YMnTt3xsnJiZ9++okdO3bwxhtvUK1aNXuXVuasX78+3+/UihUrALjrrrvsXFnZ88orr/Dee+/xzjvvsHPnTl555RVeffVV3n77bXuXViYNHz6cFStWsGDBArZu3cpNN91E9+7dOXr0qL1Ls6u0tDRatmzJzJkzC9z+6quv8tZbbzFr1izWrl1LlSpV6NmzJ5mZmaVcqf3912eVlpbGtddeyyuvvFLKlZ1lyFV77rnnjJYtW9q7jHLh6aefNq699lp7l1EujRo1yqhXr55htVrtXUqZ07t3b2PYsGH51t1+++3GwIED7VRR2ZWenm6YzWbjhx9+yLe+TZs2xsSJE+1UVdkDGF9//XXestVqNfz9/Y3XXnstb11iYqLh4uJifPrpp3aosOz492d1oYMHDxqAsWnTplKtSWduisnevXsJDAykbt26DBw4kNjYWHuXVCZ99913tGvXjrvuugtfX19at27Nhx9+aO+yyrzs7GwWLlzIsGHDin3C14qgU6dOrFy5kj179gCwZcsW/vzzT26++WY7V1b25ObmYrFYcHV1zbfezc1NZ5wv4eDBg8TFxdG9e/e8dV5eXoSFhREVFWXHyqQgCjfFICwsjLlz57Js2TLee+89Dh48SJcuXUhJSbF3aWXOgQMHeO+992jQoAHLly/noYce4rHHHmPevHn2Lq1M++abb0hMTGTIkCH2LqVMGjduHPfccw+NGzfGycmJ1q1bM3r0aAYOHGjv0socDw8PwsPDefHFFzl27BgWi4WFCxcSFRXF8ePH7V1emRUXFweAn59fvvV+fn5526TsqHSzgpeEC/912KJFC8LCwggJCeHzzz/nvvvus2NlZY/VaqVdu3ZMmTIFgNatW7Nt2zZmzZpFZGSknasru2bPns3NN99MYGCgvUspkz7//HMWLVrEJ598QtOmTdm8eTOjR48mMDBQv1cFWLBgAcOGDSMoKAiz2UybNm0YMGAA0dHR9i5NpFjozE0J8Pb2pmHDhuzbt8/epZQ5AQEBNGnSJN+6a665RpfxLiEmJoZffvmF4cOH27uUMuvJJ5/MO3vTvHlzBg8ezJgxY5g6daq9SyuT6tWrx2+//UZqaiqHDx9m3bp15OTkULduXXuXVmb5+/sDEB8fn299fHx83jYpOxRuSkBqair79+8nICDA3qWUOZ07d2b37t351u3Zs4eQkBA7VVT2zZkzB19fX3r37m3vUsqs9PR0HBzy/zkzm81YrVY7VVQ+VKlShYCAAM6cOcPy5cu59dZb7V1SmVWnTh38/f1ZuXJl3rrk5GTWrl1LeHi4HSuTguiyVDF44okn6Nu3LyEhIRw7doznnnsOs9nMgAED7F1amTNmzBg6derElClTuPvuu1m3bh0ffPABH3zwgb1LK5OsVitz5swhMjISR0f971qYvn378vLLL1O7dm2aNm3Kpk2bmDZtGsOGDbN3aWXS8uXLMQyDRo0asW/fPp588kkaN27M0KFD7V2aXaWmpuY7437w4EE2b96Mj48PtWvXZvTo0bz00ks0aNCAOnXqMGnSJAIDA+nXr5/9iraT//qsTp8+TWxsLMeOHQPI+0etv79/6ZzpKtV7syqo/v37GwEBAYazs7MRFBRk9O/f39i3b5+9yyqzvv/+e6NZs2aGi4uL0bhxY+ODDz6wd0ll1vLlyw3A2L17t71LKdOSk5ONUaNGGbVr1zZcXV2NunXrGhMnTjSysrLsXVqZtHjxYqNu3bqGs7Oz4e/vb4wcOdJITEy0d1l2t3r1agO46BEZGWkYhu128EmTJhl+fn6Gi4uL0a1bt0r7/+Z/fVZz5swpcPtzzz1XKvWZDENDeIqIiEjFoT43IiIiUqEo3IiIiEiFonAjIiIiFYrCjYiIiFQoCjciIiJSoSjciIiISIWicCMiIiIVisKNiIiIVCgKNyJSqoYMGYLJZMJkMuHk5ISfnx89evTg448/1lxQIlIsFG5EpNT16tWL48ePc+jQIX766SduuOEGRo0aRZ8+fcjNzS2x183Ozi6xY4tI2aFwIyKlzsXFBX9/f4KCgmjTpg0TJkzg22+/5aeffmLu3LkAJCYmMnz4cGrWrImnpyc33ngjW7ZsyXecl156CV9fXzw8PBg+fDjjxo2jVatWeduHDBlCv379ePnllwkMDKRRo0YAHD58mLvvvhtvb298fHy49dZbOXToUL5jf/TRR1xzzTW4urrSuHFj3n333ZL8SESkGCnciEiZcOONN9KyZUuWLFkCwF133cWJEyf46aefiI6Opk2bNnTr1o3Tp08DsGjRIl5++WVeeeUVoqOjqV27Nu+9995Fx125ciW7d+9mxYoV/PDDD+Tk5NCzZ088PDz4448/WLNmDVWrVqVXr155Z3YWLVrEs88+y8svv8zOnTuZMmUKkyZNYt68eaX3gYjIlSuV6TlFRM6KjIw0br311gK39e/f37jmmmuMP/74w/D09DQyMzPzba9Xr57x/vvvG4ZhGGFhYcbIkSPzbe/cubPRsmXLfK/l5+eXb3bwBQsWGI0aNTKsVmveuqysLMPNzc1Yvnx53ut88skn+Y794osvGuHh4UV+vyJS+hztHa5ERM4xDAOTycSWLVtITU2levXq+bZnZGSwf/9+AHbv3s3DDz+cb3uHDh1YtWpVvnXNmzfH2dk5b3nLli3s27cPDw+PfO0yMzPZv38/aWlp7N+/n/vuu48RI0bkbc/NzcXLy6tY3qeIlCyFGxEpM3bu3EmdOnVITU0lICCAX3/99aI23t7eRTpmlSpV8i2npqbStm1bFi1adFHbmjVrkpqaCsCHH35IWFhYvu1ms7lIry0i9qFwIyJlwqpVq9i6dStjxoyhVq1axMXF4ejoSGhoaIHtGzVqxPr164mIiMhbt379+v98nTZt2rB48WJ8fX3x9PS8aLuXlxeBgYEcOHCAgQMHXvH7ERH7UbgRkVKXlZVFXFwcFouF+Ph4li1bxtSpU+nTpw8RERE4ODgQHh5Ov379ePXVV2nYsCHHjh3jxx9/5LbbbqNdu3Y8+uijjBgxgnbt2tGpUycWL17MP//8Q926dS/52gMHDuS1117j1ltvZfLkydSqVYuYmBiWLFnCU089Ra1atXjhhRd47LHH8PLyolevXmRlZbFhwwbOnDnD2LFjS+lTEpErpXAjIqVu2bJlBAQE4OjoSLVq1WjZsiVvvfUWkZGRODjYbuJcunQpEydOZOjQoZw8eRJ/f3+uu+46/Pz8AFtIOXDgAE888QSZmZncfffdDBkyhHXr1l3ytd3d3fn99995+umnuf3220lJSSEoKIhu3brlnckZPnw47u7uvPbaazz55JNUqVKF5s2bM3r06BL9XESkeJgMwzDsXYSISHHo0aMH/v7+LFiwwN6liIgd6cyNiJRL6enpzJo1i549e2I2m/n000/55ZdfWLFihb1LExE705kbESmXMjIy6Nu3L5s2bSIzM5NGjRrxzDPPcPvtt9u7NBGxM4UbERERqVA0/YKIiIhUKAo3IiIiUqEo3IiIiEiFonAjIiIiFYrCjYiIiFQoCjciIiJSoSjciIiISIWicCMiIiIVisKNiIiIVCj/D8ITGtyxc1vxAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "vis.draw_degree_cdf()\n", - "vis.draw_community_cdf()" - ] - }, - { - "cell_type": "markdown", - "id": "55d5d10b-7ffa-4f30-84fd-88b6e64840f5", - "metadata": {}, - "source": [ - "# Modifying parameters\n", - "\n", - "The ABCD graph has 7 parameters, excluding the number of vertices. Let us recall them." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8a61565c-3acb-46ac-b0c6-9a198a00fd1a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "gamma=2.5 delta=5 zeta=0.5 beta=1.5 s=20 tau=0.8 xi=0.25\n" - ] - } - ], - "source": [ - "print(params)" - ] - }, - { - "cell_type": "markdown", - "id": "2d25b6c7-d9f8-4c6f-bf74-c529d3e51729", - "metadata": {}, - "source": [ - "Now let us modify some of these parameters and build a new graph." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e87207bb-3c98-4db7-a54e-2de991643359", - "metadata": {}, - "outputs": [ - { - "ename": "ValidationError", - "evalue": "2 validation errors for ABCDParams\ngamma\n Value error, gamma must be between 2 and 3 [type=value_error, input_value=3.1, input_type=float]\n For further information visit https://errors.pydantic.dev/2.7/v/value_error\nbeta\n Value error, beta must be between 1 and 2 [type=value_error, input_value=2.1, input_type=float]\n For further information visit https://errors.pydantic.dev/2.7/v/value_error", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValidationError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[14], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m gamma \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m3.1\u001b[39m\n\u001b[1;32m 2\u001b[0m beta \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2.1\u001b[39m\n\u001b[0;32m----> 4\u001b[0m params \u001b[38;5;241m=\u001b[39m \u001b[43mABCDParams\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgamma\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgamma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbeta\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbeta\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 5\u001b[0m G \u001b[38;5;241m=\u001b[39m Graph(params, n\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m100\u001b[39m, callbacks\u001b[38;5;241m=\u001b[39m[stats, vis, props])\n", - "File \u001b[0;32m~/anaconda3/envs/abcd-graph-1/lib/python3.10/site-packages/pydantic/main.py:176\u001b[0m, in \u001b[0;36mBaseModel.__init__\u001b[0;34m(self, **data)\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;66;03m# `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks\u001b[39;00m\n\u001b[1;32m 175\u001b[0m __tracebackhide__ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[0;32m--> 176\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__pydantic_validator__\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvalidate_python\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mself_instance\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mValidationError\u001b[0m: 2 validation errors for ABCDParams\ngamma\n Value error, gamma must be between 2 and 3 [type=value_error, input_value=3.1, input_type=float]\n For further information visit https://errors.pydantic.dev/2.7/v/value_error\nbeta\n Value error, beta must be between 1 and 2 [type=value_error, input_value=2.1, input_type=float]\n For further information visit https://errors.pydantic.dev/2.7/v/value_error" - ] - } - ], - "source": [ - "gamma = 3.1\n", - "beta = 2.1\n", - "\n", - "params = ABCDParams(gamma=gamma, beta=beta)\n", - "G = Graph(params, n=100, callbacks=[stats, vis, props])" - ] - }, - { - "cell_type": "markdown", - "id": "e5ad0a2f-1deb-4750-b57a-bbb091c93692", - "metadata": {}, - "source": [ - "Here, an error was raised since the parameters of the ABCD model each come with some restrictions. In this case, we were not allowed to choose gamma outside of 2 and 3, nor beta outside of 1 and 2. \n", - "\n", - "Let us try again with vaild parameters" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e3ea2546-6849-4a2a-822f-4c688554e56c", - "metadata": {}, - "outputs": [], - "source": [ - "gamma = 3\n", - "beta = 2\n", - "params = ABCDParams(gamma=gamma, beta=beta)\n", - "G = Graph(params=params, n=100, callbacks=[stats]).build()\n", - "stats.statistics" - ] - }, - { - "cell_type": "markdown", - "id": "b7a164a4-8104-4db8-84e3-d18ef4b40c4d", - "metadata": {}, - "source": [ - "The speed of the ABCD construction process is highly dependent on the number of loops and multi-edges generated, since each of these collisions needs to be rewired. As a rule of thumb, smaller gamma and larger delta imply a longer build time. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2d22d003-c86b-4109-8bbe-277cc1c894c2", - "metadata": {}, - "outputs": [], - "source": [ - "g_list = [2.1, 2.5, 2.9]\n", - "for gamma in g_list:\n", - " params = ABCDParams(gamma=gamma)\n", - " G = Graph(params=params, n=100_000, callbacks=[stats]).build()\n", - " print('gamma = ',gamma)\n", - " print('number of collisions = ',stats.statistics['number_of_loops']+stats.statistics['number_of_multi_edges'])\n", - " print('time_to_build = ',stats.statistics['time_to_build'],'\\n')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1542e8a7-cd3b-44f9-b5b5-9f33732727de", - "metadata": {}, - "outputs": [], - "source": [ - "d_list = [2, 5, 8]\n", - "for delta in d_list:\n", - " params = ABCDParams(delta=delta)\n", - " G = Graph(params=params, n=100_000, callbacks=[stats]).build()\n", - " print('delta = ',delta)\n", - " print('number of collisions = ',stats.statistics['number_of_loops']+stats.statistics['number_of_multi_edges'])\n", - " print('time_to_build = ',stats.statistics['time_to_build'],'\\n')" - ] - }, - { - "cell_type": "markdown", - "id": "5c03a4fe", - "metadata": {}, - "source": [ - "# Alternative Interface\n", - "\n", - "There is another ABCD interface that effectively adds a .sample() method to the ABCDParams class." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "290408f3", - "metadata": {}, - "outputs": [], - "source": [ - "from abcd_graph import ABCD" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4ce9619e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "abcd_sampler = ABCD(1000) # vcount is now required\n", - "graph = abcd_sampler.sample()\n", - "graph" - ] - }, - { - "cell_type": "markdown", - "id": "d87a411d", - "metadata": {}, - "source": [ - "Calling .sample() multiple times samples different ABCDGraphs with the same parameters." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7997dd77", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "graph2 = abcd_sampler.sample()\n", - "graph2 is graph" - ] - }, - { - "cell_type": "markdown", - "id": "46d9c7b4", - "metadata": {}, - "source": [ - "Other ABCD parameters can be set with keyword arguments in the ABCD construction." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b30b5d00", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "abcdo_sampler = ABCD(1000, num_outliers=100)\n", - "abcdo_sampler.sample()" - ] - } - ], - "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.13.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 9cb2f8f0fae775c3d746031b7cc5f1b3f6d6d624 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 30 Aug 2026 20:45:00 -0400 Subject: [PATCH 61/85] Describe building docs in readme --- README.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/README.md b/README.md index 770b221..d31d73c 100644 --- a/README.md +++ b/README.md @@ -164,6 +164,24 @@ The abcd-graph package is MIT licensed. Contributions are more than welcome! Everything from code to notebooks to examples and documentation are all valuable, so please don't feel you can't contribute. To contribute please fork the project, make your changes, and submit a pull request. +To install the packages required to run the tests, navigate to the folder of your fork and run +```bash +pip install abcd-graph ".[dev]" +``` +Then run the tests with +```bash +pytest +``` + +To build the documentation locally, navigate to the folder of your fork and run +```bash +pip install abcd-graph ".[docs]" +``` +and +```bash +sphinx-build docs docs/_build +``` + ## References If you use the ABCD model in an academic work, please consider citing the following works: From dcb240f986f305b3a52c6269368df34898183c16 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 30 Aug 2026 20:48:51 -0400 Subject: [PATCH 62/85] Remove fstar dependency until added to pypi --- pyproject.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 9d551b3..224069c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -56,7 +56,6 @@ docs = [ "scikit-network>=0.33.5", "partition-sknetwork", "egosplit-sknetwork", - "fstar @ git+https://github.com/ryandewolfe33/fstar", ] [project.urls] From feec9cda42815f9124ac570a55a187feeff4a2bc Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Tue, 1 Sep 2026 08:46:08 -0400 Subject: [PATCH 63/85] Add more params to abcd tests --- tests/test_abcd.py | 29 +++++++++++++++++++++++++---- 1 file changed, 25 insertions(+), 4 deletions(-) diff --git a/tests/test_abcd.py b/tests/test_abcd.py index 069a76d..3e24860 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -8,15 +8,36 @@ from abcd_graph.abcd_sample import ABCDSample -@pytest.mark.parametrize("n", [100, 200]) -def test_abcd(n): +@pytest.mark.parametrize("n", [500, 1000]) +@pytest.mark.parametrize("xi", [0.2, 0.5, 0.7]) +def test_abcd(n, xi): + rng = np.random.default_rng(seed=1) + abcd = ABCD(n, xi=xi, rng=rng) + sample = abcd.sample() + + assert_no_bad_edges(sample.edges) + assert np.max(sample.edges) == n - 1 + assert sample.n == n + assert np.abs(sample.xi - xi) < 0.1 # xi is noisy + + +@pytest.mark.benchmark +@pytest.mark.parametrize("n", [500, 1000]) +@pytest.mark.parametrize("xi", [0.2, 0.5, 0.7]) +@pytest.mark.parametrize("eta", [1.5, 2.0]) +@pytest.mark.parametrize("rho", [0.0, -0.3, 0.3]) +def test_abcdoo(n, xi, eta, rho): rng = np.random.default_rng(seed=1) - abcd = ABCD(n, rng=rng) + abcd = ABCD(n, xi=xi, eta=eta, rho=rho, rng=rng) sample = abcd.sample() assert_no_bad_edges(sample.edges) assert np.max(sample.edges) == n - 1 - assert sample.membership_matrix.shape[1] == n + assert sample.n == n + assert np.abs(sample.xi - xi) < 0.15 # xi is noisy + assert sample.eta == eta + if rho != 0: + assert np.sign(sample.rho) == np.sign(rho) def test_abcd_raises_large_n(): From 8eba60411bce7b9b5541ed69657cf15f0d9afc0b Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe <61296655+ryandewolfe33@users.noreply.github.com> Date: Wed, 2 Sep 2026 13:37:12 -0400 Subject: [PATCH 64/85] Refactor/remove powerlaw dependency (#9) * Add custom powerlaw exponent estimator and remove powerlaw package * Fix abcd_sample rho --- abcd_graph/abcd_sample.py | 67 +++++++++++++++++++++++++++++---------- pyproject.toml | 1 - tests/test_abcd.py | 6 ++-- 3 files changed, 54 insertions(+), 20 deletions(-) diff --git a/abcd_graph/abcd_sample.py b/abcd_graph/abcd_sample.py index 871901a..08a05eb 100644 --- a/abcd_graph/abcd_sample.py +++ b/abcd_graph/abcd_sample.py @@ -1,8 +1,8 @@ import numpy as np -import powerlaw import scipy.sparse as sp from numba import njit from numpy.typing import ArrayLike, NDArray +from scipy.optimize import minimize_scalar @njit @@ -30,6 +30,53 @@ def icdf(points: ArrayLike, sequence: ArrayLike, weights=None) -> NDArray[np.flo return icdf +def fit_powerlaw_exponent( + samples: NDArray[np.uint32], +): + """Find the parameters of a discrete truncated power-law + distribution for the given samples via maximum-likelihood. + Sets the bounds to the minimum and maximum observed samples + and computes the optimal exponent. + + Parameters + ---------- + samples: NDArray + An array of samples to which we fit the parameters + + Returns + ------- + exponent: float + The fit exponent. + + x_min: int + The lower bound on the fit distribution, will be the smallest + value sampled. + + x_max: int + The fit (or passed) upper bound on the fit distribution. + """ + x_min = np.min(samples) + x_max = np.max(samples) + + values, counts = np.unique_counts(samples) + x_frequency = np.zeros(x_max - x_min + 1, dtype=np.float64) + x_frequency[values - x_min] = counts + + domain = np.arange(x_min, x_max + 1, dtype=np.float64) + log_domain = np.log(domain) + + observed_constant = np.sum(x_frequency * log_domain) + + # Log-likelihood equation for truncated power-law, negated + # since scipy has a minimizer + def objective(exponent): + weights = domain ** (-exponent) + return len(samples) * np.log(np.sum(weights)) + exponent * observed_constant + + sol = minimize_scalar(objective, bounds=[1.0, 5.0], method="Bounded") + return sol.x + + class ABCDSample: """A sample from the ABCD model. @@ -146,7 +193,7 @@ def rho(self) -> float: """ if self.eta == 1: return 1.0 - degrees = self.to_sparse().sum(axis=1) // 2 + degrees = self.degree_sequence coms_per_node = self.membership_matrix.sum(axis=0) inlier_mask = coms_per_node > 0 rho = np.corrcoef(degrees[inlier_mask], coms_per_node[inlier_mask])[0, 1] @@ -194,13 +241,7 @@ def degree_exponent(self) -> float: float """ degree_sequence = self.degree_sequence - min_degree = np.min(degree_sequence) - exponent = powerlaw.Fit( - degree_sequence, - discrete=True, - verbose=False, - xmin=min_degree, - ).power_law.alpha + exponent = fit_powerlaw_exponent(degree_sequence) return exponent @property @@ -242,13 +283,7 @@ def community_size_exponent(self) -> float: float """ size_sequence = self.community_size_sequence - min_size = np.min(size_sequence) - exponent = powerlaw.Fit( - size_sequence, - discrete=True, - verbose=False, - xmin=min_size, - ).power_law.alpha + exponent = fit_powerlaw_exponent(size_sequence) return exponent def to_sparse(self, matrix: bool = False) -> sp.csr_array | sp.csr_matrix: diff --git a/pyproject.toml b/pyproject.toml index 224069c..9bd8e4b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -30,7 +30,6 @@ dependencies = [ "numba>=0.66.0", "numpy>=2.0.0", "scipy>=1.18.0", - "powerlaw>=2.0.0", "typing-extensions>=4.10.0", "tqdm>=4.0.0", ] diff --git a/tests/test_abcd.py b/tests/test_abcd.py index 3e24860..18bb471 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -67,7 +67,7 @@ def test_seed(n): @pytest.mark.filterwarnings("ignore::UserWarning:powerlaw*") @pytest.mark.filterwarnings("ignore::RuntimeWarning:powerlaw*") def test_fit(): - edges = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 0]], dtype=np.uint32) + edges = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 0], [1, 3]], dtype=np.uint32) coms = sp.csr_array([[1, 1, 1, 0, 0], [0, 0, 1, 1, 0]]) sample = ABCDSample(edges, coms) abcd = ABCD(100) @@ -75,10 +75,10 @@ def test_fit(): abcd.fit(sample) assert abcd.n == 5 - assert abcd.xi == 0.4 + assert abcd.xi == 0.5 assert abcd.eta == 1.25 assert abcd.min_degree == 2 - assert abcd.max_degree == 2 + assert abcd.max_degree == 3 assert abcd.degree_exponent != 2.5 assert abcd.min_community_size == 2 assert abcd.max_community_size == 3 From ef33880471ccca8680f7ba2bb60839586a174126 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe <61296655+ryandewolfe33@users.noreply.github.com> Date: Wed, 2 Sep 2026 14:48:06 -0400 Subject: [PATCH 65/85] Add benchmarks and ci workflow (#8) * Add benchmarks and ci workflow * Add pytest-benchmark to dev * Move to dependency-groups in pyproject.toml * Upgrade packages in lock * Run everything with uv (and delete custom actions, specify everything in each workflow file) --- .github/actions/build/action.yml | 22 - .github/actions/test/action.yml | 15 - .github/workflows/benchmark.yml | 29 + .github/workflows/ci.yml | 15 +- .github/workflows/coverage.yml | 18 +- .github/workflows/docker-in-ci.yml | 2 + .github/workflows/release.yml | 11 +- benchmarks/test_benchmark.py | 21 + ci_baseline.json | 1795 +++++++++++++++++ pyproject.toml | 3 +- uv.lock | 2965 +++++++++++++++++++--------- 11 files changed, 3861 insertions(+), 1035 deletions(-) delete mode 100644 .github/actions/build/action.yml delete mode 100644 .github/actions/test/action.yml create mode 100644 .github/workflows/benchmark.yml create mode 100644 benchmarks/test_benchmark.py create mode 100644 ci_baseline.json diff --git a/.github/actions/build/action.yml b/.github/actions/build/action.yml deleted file mode 100644 index 0ab22c3..0000000 --- a/.github/actions/build/action.yml +++ /dev/null @@ -1,22 +0,0 @@ ---- -name: Build -description: Build the project -inputs: - working_directory: - description: 'Working directory' - required: false - default: . -runs: - using: "composite" - steps: - - name: Checkout - uses: actions/checkout@v7 - - - name: Install the latest version of uv - uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1 - - - name: Install dependencies - working-directory: ${{ inputs.working_directory }} - run: | - uv pip install --system -r pyproject.toml --extra dev . - shell: bash diff --git a/.github/actions/test/action.yml b/.github/actions/test/action.yml deleted file mode 100644 index 88890cf..0000000 --- a/.github/actions/test/action.yml +++ /dev/null @@ -1,15 +0,0 @@ ---- -name: Test -description: Run tests -inputs: - working_directory: - description: 'Working directory' - required: false - default: . -runs: - using: "composite" - steps: - - name: Run tests - working-directory: ${{ inputs.working_directory }} - run: pytest --junitxml=pytest.xml --cov-report=term-missing:skip-covered --cov=abcd_graph | tee pytest-coverage.txt - shell: bash diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml new file mode 100644 index 0000000..cfd6907 --- /dev/null +++ b/.github/workflows/benchmark.yml @@ -0,0 +1,29 @@ +name: Performance Regression Check +on: + pull_request: + branches: + - 'main' + - 'release/**' + +jobs: + benchmark: + runs-on: ubuntu-latest + steps: + - name: Checkout Repository + uses: actions/checkout@v7 + + - name: Install uv + uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1 + with: + python-version: "3.12" + enable-cache: true + + - name: Install package + run: uv sync --frozen + + - name: Benchmark + run: uv run pytest --benchmark-compare=ci_baseline.json + --benchmark-compare-fail=mean:100% + --benchmark-warmup=on + --benchmark-min-rounds=10 + benchmarks diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f9cb6af..27e8b1f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -16,14 +16,17 @@ jobs: os: [ubuntu-latest, macos-latest, windows-latest] python-version: ["3.12", "3.13", "3.14"] steps: - - uses: actions/checkout@v7 + - name: Checkout Repository + uses: actions/checkout@v7 - - uses: actions/setup-python@v7 + - name: Install uv + uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1 with: python-version: ${{ matrix.python-version }} + enable-cache: true - - name: Build - uses: ./.github/actions/build + - name: Install package + run: uv sync --frozen - - name: Test - uses: ./.github/actions/test + - name: Run Tests + run: uv run pytest tests diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 32e7545..0064200 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -5,17 +5,23 @@ jobs: test: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v7 + - name: Checkout Repository + uses: actions/checkout@v7 - - uses: actions/setup-python@v7 + - name: Setup uv + uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1 with: python-version: "3.12" + enable-cache: true - - name: Build - uses: ./.github/actions/build + - name: Install package + run: uv sync --frozen - - name: Test - uses: ./.github/actions/test + - name: Run tests + run: uv run pytest --junitxml=pytest.xml + --cov-report=term-missing:skip-covered + --cov=abcd_graph + tests | tee pytest-coverage.txt - name: Pytest coverage comment uses: MishaKav/pytest-coverage-comment@main diff --git a/.github/workflows/docker-in-ci.yml b/.github/workflows/docker-in-ci.yml index 6154020..7354206 100644 --- a/.github/workflows/docker-in-ci.yml +++ b/.github/workflows/docker-in-ci.yml @@ -2,6 +2,8 @@ name: docker on: pull_request: + branches: + - main push: branches: - main diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 1a02aea..be391d3 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -9,11 +9,14 @@ jobs: publish: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v7 - - uses: actions/setup-python@v7 + - name: Checkout Repository + uses: actions/checkout@v7 + + - name: Setup uv + uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1 with: python-version: "3.12" - - name: Install uv - run: curl -LsSf https://astral.sh/uv/install.sh | sh + enable-cache: true + - name: Publish run: ./publish.sh ${{ secrets.PYPI_TOKEN }} ${{ secrets.GHCR_TOKEN }} diff --git a/benchmarks/test_benchmark.py b/benchmarks/test_benchmark.py new file mode 100644 index 0000000..206616c --- /dev/null +++ b/benchmarks/test_benchmark.py @@ -0,0 +1,21 @@ +import pytest + +from abcd_graph import ABCD + + +@pytest.mark.benchmark +@pytest.mark.parametrize("n", [1000, 10000]) +@pytest.mark.parametrize("xi", [0.2, 0.5, 0.7]) +def test_benchmark_abcd(benchmark, n, xi): + abcd = ABCD(n, xi=xi) + benchmark(abcd.sample) + + +@pytest.mark.benchmark +@pytest.mark.parametrize("n", [1000, 10000]) +@pytest.mark.parametrize("xi", [0.2, 0.5, 0.7]) +@pytest.mark.parametrize("eta", [1.5, 2.0]) +@pytest.mark.parametrize("rho", [0.0, -0.3, 0.3]) +def test_benchmark_abcdoo(benchmark, n, xi, eta, rho): + abcd = ABCD(n, xi=xi, eta=eta, rho=rho) + benchmark(abcd.sample) diff --git a/ci_baseline.json b/ci_baseline.json new file mode 100644 index 0000000..442e632 --- /dev/null +++ b/ci_baseline.json @@ -0,0 +1,1795 @@ +{ + "machine_info": { + "node": "MacBookPro.lan", + "processor": "arm", + "machine": "arm64", + "python_compiler": "Clang 19.1.7 ", + "python_implementation": "CPython", + "python_implementation_version": "3.13.13", + "python_version": "3.13.13", + "python_build": [ + "main", + "Apr 8 2026 02:29:07" + ], + "release": "25.6.0", + "system": "Darwin", + "cpu": { + "python_version": "3.13.13.final.0 (64 bit)", + "cpuinfo_version": [ + 10, + 1, + 1 + ], + "cpuinfo_version_string": "10.1.1", + "arch": "ARM_8", + "bits": 64, + "count": 8, + "arch_string_raw": "arm64", + "brand_raw": "Apple M1 Pro" + } + }, + "commit_info": { + "id": "dcb240f986f305b3a52c6269368df34898183c16", + "time": "2026-08-30T20:48:51-04:00", + "author_time": "2026-08-30T20:48:51-04:00", + "dirty": true, + "project": "abcd-graph", + "branch": "release/0.5.0-beta" + }, + "benchmarks": [ + { + "group": null, + "name": "test_benchmark_abcd[0.2-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcd[0.2-1000]", + "params": { + "xi": 0.2, + "n": 1000 + }, + "param": "0.2-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.0029559999966295436, + "max": 0.0044283750030444935, + "mean": 0.003469490323250366, + "stddev": 0.00029624454884841933, + "rounds": 331, + "median": 0.0034133339941035956, + "iqr": 0.00039794750227883924, + "q1": 0.003243791747081559, + "q3": 0.0036417392493603984, + "iqr_outliers": 6, + "stddev_outliers": 109, + "outliers": "109;6", + "ld15iqr": 0.0029559999966295436, + "hd15iqr": 0.004252500002621673, + "ops": 288.2267730503878, + "total": 1.1484012969958712, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcd[0.2-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcd[0.2-10000]", + "params": { + "xi": 0.2, + "n": 10000 + }, + "param": "0.2-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.026882584003033116, + "max": 0.03276170900062425, + "mean": 0.02969279175807527, + "stddev": 0.0014452392518996165, + "rounds": 37, + "median": 0.029796083996188827, + "iqr": 0.0020345940029073972, + "q1": 0.02876535424911708, + "q3": 0.03079994825202448, + "iqr_outliers": 0, + "stddev_outliers": 15, + "outliers": "15;0", + "ld15iqr": 0.026882584003033116, + "hd15iqr": 0.03276170900062425, + "ops": 33.678207429856755, + "total": 1.098633295048785, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcd[0.5-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcd[0.5-1000]", + "params": { + "xi": 0.5, + "n": 1000 + }, + "param": "0.5-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.0028616670024348423, + "max": 0.003829417000815738, + "mean": 0.003131192106535854, + "stddev": 0.00012936535712445974, + "rounds": 347, + "median": 0.0031089579933905043, + "iqr": 0.00015624949628545437, + "q1": 0.003042687500055763, + "q3": 0.0031989369963412173, + "iqr_outliers": 9, + "stddev_outliers": 92, + "outliers": "92;9", + "ld15iqr": 0.0028616670024348423, + "hd15iqr": 0.0034448330043233, + "ops": 319.3671822027983, + "total": 1.0865236609679414, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcd[0.5-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcd[0.5-10000]", + "params": { + "xi": 0.5, + "n": 10000 + }, + "param": "0.5-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.02686520799761638, + "max": 0.031799291995412204, + "mean": 0.02902545404989117, + "stddev": 0.0012002596376647786, + "rounds": 39, + "median": 0.029081790999043733, + "iqr": 0.0015020109949546168, + "q1": 0.028256125002371846, + "q3": 0.029758135997326463, + "iqr_outliers": 0, + "stddev_outliers": 13, + "outliers": "13;0", + "ld15iqr": 0.02686520799761638, + "hd15iqr": 0.031799291995412204, + "ops": 34.45251875409506, + "total": 1.1319927079457557, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcd[0.7-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcd[0.7-1000]", + "params": { + "xi": 0.7, + "n": 1000 + }, + "param": "0.7-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.002891124997404404, + "max": 0.004149207998125348, + "mean": 0.0033139612765594123, + "stddev": 0.00027456266737635785, + "rounds": 340, + "median": 0.003222625000489643, + "iqr": 0.00035297950307722203, + "q1": 0.003114832998107886, + "q3": 0.003467812501185108, + "iqr_outliers": 7, + "stddev_outliers": 91, + "outliers": "91;7", + "ld15iqr": 0.002891124997404404, + "hd15iqr": 0.004041625004902016, + "ops": 301.7536768076572, + "total": 1.1267468340302003, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcd[0.7-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcd[0.7-10000]", + "params": { + "xi": 0.7, + "n": 10000 + }, + "param": "0.7-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.026030708002508618, + "max": 0.028684750002867077, + "mean": 0.027065393051322106, + "stddev": 0.000609934905673318, + "rounds": 39, + "median": 0.026996749998943415, + "iqr": 0.0008793742454145104, + "q1": 0.026601917252264684, + "q3": 0.027481291497679194, + "iqr_outliers": 0, + "stddev_outliers": 10, + "outliers": "10;0", + "ld15iqr": 0.026030708002508618, + "hd15iqr": 0.028684750002867077, + "ops": 36.947551365826236, + "total": 1.0555503290015622, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-1.5-0.2-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-1.5-0.2-1000]", + "params": { + "rho": 0.0, + "eta": 1.5, + "xi": 0.2, + "n": 1000 + }, + "param": "0.0-1.5-0.2-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.007397125002171379, + "max": 0.027816082998469938, + "mean": 0.009359424099914446, + "stddev": 0.0018031998960169517, + "rounds": 140, + "median": 0.009212437496898929, + "iqr": 0.0011574165000638459, + "q1": 0.008606458501162706, + "q3": 0.009763875001226552, + "iqr_outliers": 3, + "stddev_outliers": 6, + "outliers": "6;3", + "ld15iqr": 0.007397125002171379, + "hd15iqr": 0.011811208001745399, + "ops": 106.84418072359183, + "total": 1.3103193739880226, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-1.5-0.2-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-1.5-0.2-10000]", + "params": { + "rho": 0.0, + "eta": 1.5, + "xi": 0.2, + "n": 10000 + }, + "param": "0.0-1.5-0.2-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.19009324999933597, + "max": 0.28015420799783897, + "mean": 0.23324437929986744, + "stddev": 0.029126901925567984, + "rounds": 10, + "median": 0.2351295834996563, + "iqr": 0.04477983399556251, + "q1": 0.21181762500054901, + "q3": 0.2565974589961115, + "iqr_outliers": 0, + "stddev_outliers": 3, + "outliers": "3;0", + "ld15iqr": 0.19009324999933597, + "hd15iqr": 0.28015420799783897, + "ops": 4.287348758421157, + "total": 2.3324437929986743, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-1.5-0.5-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-1.5-0.5-1000]", + "params": { + "rho": 0.0, + "eta": 1.5, + "xi": 0.5, + "n": 1000 + }, + "param": "0.0-1.5-0.5-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.006786541998735629, + "max": 0.012181000005512033, + "mean": 0.009141294124395072, + "stddev": 0.0009403677553085131, + "rounds": 153, + "median": 0.009126833007030655, + "iqr": 0.0013253020024421858, + "q1": 0.00850519825144147, + "q3": 0.009830500253883656, + "iqr_outliers": 1, + "stddev_outliers": 52, + "outliers": "52;1", + "ld15iqr": 0.006786541998735629, + "hd15iqr": 0.012181000005512033, + "ops": 109.39370141600988, + "total": 1.398618001032446, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-1.5-0.5-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-1.5-0.5-10000]", + "params": { + "rho": 0.0, + "eta": 1.5, + "xi": 0.5, + "n": 10000 + }, + "param": "0.0-1.5-0.5-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.20281158400030108, + "max": 0.3133059169995249, + "mean": 0.24046116689933114, + "stddev": 0.035199303522770065, + "rounds": 10, + "median": 0.23274977099572425, + "iqr": 0.04598708399862517, + "q1": 0.21368820800125832, + "q3": 0.2596752919998835, + "iqr_outliers": 0, + "stddev_outliers": 4, + "outliers": "4;0", + "ld15iqr": 0.20281158400030108, + "hd15iqr": 0.3133059169995249, + "ops": 4.158675651851299, + "total": 2.4046116689933115, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-1.5-0.7-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-1.5-0.7-1000]", + "params": { + "rho": 0.0, + "eta": 1.5, + "xi": 0.7, + "n": 1000 + }, + "param": "0.0-1.5-0.7-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.007178833999205381, + "max": 0.010990832997777034, + "mean": 0.008845027692932092, + "stddev": 0.0008128205048515552, + "rounds": 137, + "median": 0.008853499995893799, + "iqr": 0.001108968997868942, + "q1": 0.008247020501585212, + "q3": 0.009355989499454154, + "iqr_outliers": 0, + "stddev_outliers": 45, + "outliers": "45;0", + "ld15iqr": 0.007178833999205381, + "hd15iqr": 0.010990832997777034, + "ops": 113.05787101142518, + "total": 1.2117687939316966, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-1.5-0.7-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-1.5-0.7-10000]", + "params": { + "rho": 0.0, + "eta": 1.5, + "xi": 0.7, + "n": 10000 + }, + "param": "0.0-1.5-0.7-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.21186166600091383, + "max": 0.2844615840003826, + "mean": 0.2484365000993421, + "stddev": 0.024293758420164107, + "rounds": 10, + "median": 0.25075358350295573, + "iqr": 0.033030582999344915, + "q1": 0.227515124999627, + "q3": 0.2605457079989719, + "iqr_outliers": 0, + "stddev_outliers": 4, + "outliers": "4;0", + "ld15iqr": 0.21186166600091383, + "hd15iqr": 0.2844615840003826, + "ops": 4.025173433050823, + "total": 2.484365000993421, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-2.0-0.2-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-2.0-0.2-1000]", + "params": { + "rho": 0.0, + "eta": 2.0, + "xi": 0.2, + "n": 1000 + }, + "param": "0.0-2.0-0.2-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.008587500000430737, + "max": 0.013842125001247041, + "mean": 0.010957652387504995, + "stddev": 0.0010488069272412111, + "rounds": 111, + "median": 0.011119499999040272, + "iqr": 0.0014352915022755042, + "q1": 0.010138843495951733, + "q3": 0.011574134998227237, + "iqr_outliers": 1, + "stddev_outliers": 32, + "outliers": "32;1", + "ld15iqr": 0.008587500000430737, + "hd15iqr": 0.013842125001247041, + "ops": 91.26042373276044, + "total": 1.2162994150130544, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-2.0-0.2-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-2.0-0.2-10000]", + "params": { + "rho": 0.0, + "eta": 2.0, + "xi": 0.2, + "n": 10000 + }, + "param": "0.0-2.0-0.2-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.2482442920008907, + "max": 0.36096804199769394, + "mean": 0.296105183599866, + "stddev": 0.0295616854678615, + "rounds": 10, + "median": 0.2955246460005583, + "iqr": 0.029917667001427617, + "q1": 0.27520991699566366, + "q3": 0.3051275839970913, + "iqr_outliers": 1, + "stddev_outliers": 2, + "outliers": "2;1", + "ld15iqr": 0.2482442920008907, + "hd15iqr": 0.36096804199769394, + "ops": 3.3771782980716876, + "total": 2.96105183599866, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-2.0-0.5-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-2.0-0.5-1000]", + "params": { + "rho": 0.0, + "eta": 2.0, + "xi": 0.5, + "n": 1000 + }, + "param": "0.0-2.0-0.5-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.008269457997812424, + "max": 0.013024833999224938, + "mean": 0.01047461503976956, + "stddev": 0.0008363100167574075, + "rounds": 125, + "median": 0.01043970900354907, + "iqr": 0.0011304275030852295, + "q1": 0.009915020498738158, + "q3": 0.011045448001823388, + "iqr_outliers": 1, + "stddev_outliers": 34, + "outliers": "34;1", + "ld15iqr": 0.008269457997812424, + "hd15iqr": 0.013024833999224938, + "ops": 95.46890231318704, + "total": 1.309326879971195, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-2.0-0.5-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-2.0-0.5-10000]", + "params": { + "rho": 0.0, + "eta": 2.0, + "xi": 0.5, + "n": 10000 + }, + "param": "0.0-2.0-0.5-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.2800248340063263, + "max": 0.36508670799958054, + "mean": 0.31594537920027504, + "stddev": 0.029191917328542084, + "rounds": 10, + "median": 0.31433299950367655, + "iqr": 0.047445583004446235, + "q1": 0.2875319589948049, + "q3": 0.3349775419992511, + "iqr_outliers": 0, + "stddev_outliers": 4, + "outliers": "4;0", + "ld15iqr": 0.2800248340063263, + "hd15iqr": 0.36508670799958054, + "ops": 3.165104052261225, + "total": 3.1594537920027506, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-2.0-0.7-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-2.0-0.7-1000]", + "params": { + "rho": 0.0, + "eta": 2.0, + "xi": 0.7, + "n": 1000 + }, + "param": "0.0-2.0-0.7-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.008843333002005238, + "max": 0.03805295899655903, + "mean": 0.011252464215326016, + "stddev": 0.0026684073814934443, + "rounds": 121, + "median": 0.010975416997098364, + "iqr": 0.0012014062431262573, + "q1": 0.010385885501818848, + "q3": 0.011587291744945105, + "iqr_outliers": 5, + "stddev_outliers": 4, + "outliers": "4;5", + "ld15iqr": 0.008843333002005238, + "hd15iqr": 0.013422749994788319, + "ops": 88.86942280944878, + "total": 1.3615481700544478, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.0-2.0-0.7-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.0-2.0-0.7-10000]", + "params": { + "rho": 0.0, + "eta": 2.0, + "xi": 0.7, + "n": 10000 + }, + "param": "0.0-2.0-0.7-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.24899320799886482, + "max": 0.372320624999702, + "mean": 0.3046488165979099, + "stddev": 0.042356485575355755, + "rounds": 10, + "median": 0.2966226039970934, + "iqr": 0.053521250003541354, + "q1": 0.273939207996591, + "q3": 0.32746045800013235, + "iqr_outliers": 0, + "stddev_outliers": 3, + "outliers": "3;0", + "ld15iqr": 0.24899320799886482, + "hd15iqr": 0.372320624999702, + "ops": 3.2824680271771673, + "total": 3.046488165979099, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-1.5-0.2-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-1.5-0.2-1000]", + "params": { + "rho": -0.3, + "eta": 1.5, + "xi": 0.2, + "n": 1000 + }, + "param": "-0.3-1.5-0.2-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.007012166999629699, + "max": 0.03527524999663001, + "mean": 0.009235525737565708, + "stddev": 0.0023881378902466635, + "rounds": 141, + "median": 0.00894516699918313, + "iqr": 0.0012323849987296853, + "q1": 0.008417229497354128, + "q3": 0.009649614496083814, + "iqr_outliers": 4, + "stddev_outliers": 4, + "outliers": "4;4", + "ld15iqr": 0.007012166999629699, + "hd15iqr": 0.011941666998609435, + "ops": 108.27753919113425, + "total": 1.3022091289967648, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-1.5-0.2-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-1.5-0.2-10000]", + "params": { + "rho": -0.3, + "eta": 1.5, + "xi": 0.2, + "n": 10000 + }, + "param": "-0.3-1.5-0.2-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.19326479199662572, + "max": 0.2878250419962569, + "mean": 0.2436970582995855, + "stddev": 0.03162555013028535, + "rounds": 10, + "median": 0.24023702050180873, + "iqr": 0.04343129199696705, + "q1": 0.2239560000016354, + "q3": 0.26738729199860245, + "iqr_outliers": 0, + "stddev_outliers": 4, + "outliers": "4;0", + "ld15iqr": 0.19326479199662572, + "hd15iqr": 0.2878250419962569, + "ops": 4.103455359607437, + "total": 2.436970582995855, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-1.5-0.5-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-1.5-0.5-1000]", + "params": { + "rho": -0.3, + "eta": 1.5, + "xi": 0.5, + "n": 1000 + }, + "param": "-0.3-1.5-0.5-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.006758125004125759, + "max": 0.02741487499588402, + "mean": 0.009405895065264559, + "stddev": 0.001985080058785662, + "rounds": 139, + "median": 0.009071207998204045, + "iqr": 0.0015213639962894376, + "q1": 0.00850121925213898, + "q3": 0.010022583248428418, + "iqr_outliers": 2, + "stddev_outliers": 14, + "outliers": "14;2", + "ld15iqr": 0.006758125004125759, + "hd15iqr": 0.016931791993556544, + "ops": 106.31630409028735, + "total": 1.3074194140717736, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-1.5-0.5-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-1.5-0.5-10000]", + "params": { + "rho": -0.3, + "eta": 1.5, + "xi": 0.5, + "n": 10000 + }, + "param": "-0.3-1.5-0.5-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.20416329200088512, + "max": 0.2889777500022319, + "mean": 0.23817810000182363, + "stddev": 0.024521545997528038, + "rounds": 10, + "median": 0.23086762450475362, + "iqr": 0.03140329199959524, + "q1": 0.22271737499977462, + "q3": 0.25412066699936986, + "iqr_outliers": 0, + "stddev_outliers": 3, + "outliers": "3;0", + "ld15iqr": 0.20416329200088512, + "hd15iqr": 0.2889777500022319, + "ops": 4.198538824486145, + "total": 2.3817810000182362, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-1.5-0.7-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-1.5-0.7-1000]", + "params": { + "rho": -0.3, + "eta": 1.5, + "xi": 0.7, + "n": 1000 + }, + "param": "-0.3-1.5-0.7-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.007344915997236967, + "max": 0.011280874998192303, + "mean": 0.008909142089982601, + "stddev": 0.0007624667154571049, + "rounds": 144, + "median": 0.008909874493838288, + "iqr": 0.0010096669939230196, + "q1": 0.008435354000539519, + "q3": 0.009445020994462539, + "iqr_outliers": 1, + "stddev_outliers": 46, + "outliers": "46;1", + "ld15iqr": 0.007344915997236967, + "hd15iqr": 0.011280874998192303, + "ops": 112.24425313907558, + "total": 1.2829164609574946, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-1.5-0.7-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-1.5-0.7-10000]", + "params": { + "rho": -0.3, + "eta": 1.5, + "xi": 0.7, + "n": 10000 + }, + "param": "-0.3-1.5-0.7-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.19696445799490903, + "max": 0.2783504169929074, + "mean": 0.24509692909923614, + "stddev": 0.022626059299145313, + "rounds": 10, + "median": 0.2469841039928724, + "iqr": 0.02933787500660401, + "q1": 0.2306758750055451, + "q3": 0.2600137500121491, + "iqr_outliers": 0, + "stddev_outliers": 2, + "outliers": "2;0", + "ld15iqr": 0.19696445799490903, + "hd15iqr": 0.2783504169929074, + "ops": 4.080018479526174, + "total": 2.4509692909923615, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-2.0-0.2-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-2.0-0.2-1000]", + "params": { + "rho": -0.3, + "eta": 2.0, + "xi": 0.2, + "n": 1000 + }, + "param": "-0.3-2.0-0.2-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.008970625000074506, + "max": 0.014820707991020754, + "mean": 0.0117596729155891, + "stddev": 0.001154986491544229, + "rounds": 107, + "median": 0.011741624999558553, + "iqr": 0.0015115422538656276, + "q1": 0.010923499998170882, + "q3": 0.01243504225203651, + "iqr_outliers": 1, + "stddev_outliers": 38, + "outliers": "38;1", + "ld15iqr": 0.008970625000074506, + "hd15iqr": 0.014820707991020754, + "ops": 85.03637874777618, + "total": 1.2582850019680336, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-2.0-0.2-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-2.0-0.2-10000]", + "params": { + "rho": -0.3, + "eta": 2.0, + "xi": 0.2, + "n": 10000 + }, + "param": "-0.3-2.0-0.2-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.24632070900406688, + "max": 0.35589916599565186, + "mean": 0.3044511791013065, + "stddev": 0.03281391105391568, + "rounds": 10, + "median": 0.30642572899523657, + "iqr": 0.029378999999607913, + "q1": 0.2972966250090394, + "q3": 0.32667562500864733, + "iqr_outliers": 1, + "stddev_outliers": 3, + "outliers": "3;1", + "ld15iqr": 0.2580289999896195, + "hd15iqr": 0.35589916599565186, + "ops": 3.28459887378938, + "total": 3.044511791013065, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-2.0-0.5-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-2.0-0.5-1000]", + "params": { + "rho": -0.3, + "eta": 2.0, + "xi": 0.5, + "n": 1000 + }, + "param": "-0.3-2.0-0.5-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.008295625011669472, + "max": 0.01284549999400042, + "mean": 0.010612029106942401, + "stddev": 0.0008683837573711138, + "rounds": 113, + "median": 0.010652500001015142, + "iqr": 0.0013466457421600353, + "q1": 0.00984962525035371, + "q3": 0.011196270992513746, + "iqr_outliers": 0, + "stddev_outliers": 38, + "outliers": "38;0", + "ld15iqr": 0.008295625011669472, + "hd15iqr": 0.01284549999400042, + "ops": 94.23268537265874, + "total": 1.1991592890844913, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-2.0-0.5-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-2.0-0.5-10000]", + "params": { + "rho": -0.3, + "eta": 2.0, + "xi": 0.5, + "n": 10000 + }, + "param": "-0.3-2.0-0.5-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.26717112500045914, + "max": 0.3489547909994144, + "mean": 0.2983141875010915, + "stddev": 0.025419207950137357, + "rounds": 10, + "median": 0.29689262501051417, + "iqr": 0.029552666004747152, + "q1": 0.27858854200167116, + "q3": 0.3081412080064183, + "iqr_outliers": 0, + "stddev_outliers": 3, + "outliers": "3;0", + "ld15iqr": 0.26717112500045914, + "hd15iqr": 0.3489547909994144, + "ops": 3.3521704360653013, + "total": 2.983141875010915, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-2.0-0.7-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-2.0-0.7-1000]", + "params": { + "rho": -0.3, + "eta": 2.0, + "xi": 0.7, + "n": 1000 + }, + "param": "-0.3-2.0-0.7-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.00826766699901782, + "max": 0.01312287499604281, + "mean": 0.010788111051279602, + "stddev": 0.000970783159878924, + "rounds": 116, + "median": 0.010707104505854659, + "iqr": 0.0011794164893217385, + "q1": 0.01018443750217557, + "q3": 0.011363853991497308, + "iqr_outliers": 1, + "stddev_outliers": 33, + "outliers": "33;1", + "ld15iqr": 0.008618958992883563, + "hd15iqr": 0.01312287499604281, + "ops": 92.69463349484039, + "total": 1.2514208819484338, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[-0.3-2.0-0.7-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[-0.3-2.0-0.7-10000]", + "params": { + "rho": -0.3, + "eta": 2.0, + "xi": 0.7, + "n": 10000 + }, + "param": "-0.3-2.0-0.7-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.28354141701129265, + "max": 0.36696970798948314, + "mean": 0.3150786083991989, + "stddev": 0.025866469157950194, + "rounds": 10, + "median": 0.30813664599554613, + "iqr": 0.030095875001279637, + "q1": 0.29795808299968485, + "q3": 0.3280539580009645, + "iqr_outliers": 0, + "stddev_outliers": 3, + "outliers": "3;0", + "ld15iqr": 0.28354141701129265, + "hd15iqr": 0.36696970798948314, + "ops": 3.173811148527793, + "total": 3.1507860839919886, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-1.5-0.2-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-1.5-0.2-1000]", + "params": { + "rho": 0.3, + "eta": 1.5, + "xi": 0.2, + "n": 1000 + }, + "param": "0.3-1.5-0.2-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.015430125000420958, + "max": 0.02190066700859461, + "mean": 0.01792282709020447, + "stddev": 0.0014547644764399765, + "rounds": 67, + "median": 0.017584583009011112, + "iqr": 0.0023255939959199168, + "q1": 0.016787155756901484, + "q3": 0.0191127497528214, + "iqr_outliers": 0, + "stddev_outliers": 22, + "outliers": "22;0", + "ld15iqr": 0.015430125000420958, + "hd15iqr": 0.02190066700859461, + "ops": 55.79476914925655, + "total": 1.2008294150436996, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-1.5-0.2-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-1.5-0.2-10000]", + "params": { + "rho": 0.3, + "eta": 1.5, + "xi": 0.2, + "n": 10000 + }, + "param": "0.3-1.5-0.2-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.28215504199033603, + "max": 0.4027796250011306, + "mean": 0.3357164042972727, + "stddev": 0.03524501552785211, + "rounds": 10, + "median": 0.33002497899724403, + "iqr": 0.044074958001147024, + "q1": 0.3136279589962214, + "q3": 0.35770291699736845, + "iqr_outliers": 0, + "stddev_outliers": 3, + "outliers": "3;0", + "ld15iqr": 0.28215504199033603, + "hd15iqr": 0.4027796250011306, + "ops": 2.978704606625396, + "total": 3.3571640429727267, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-1.5-0.5-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-1.5-0.5-1000]", + "params": { + "rho": 0.3, + "eta": 1.5, + "xi": 0.5, + "n": 1000 + }, + "param": "0.3-1.5-0.5-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.01567491699825041, + "max": 0.022578124990104698, + "mean": 0.01773013108111392, + "stddev": 0.001573148591676798, + "rounds": 62, + "median": 0.017269416501221713, + "iqr": 0.0017023749969666824, + "q1": 0.016624249998130836, + "q3": 0.018326624995097518, + "iqr_outliers": 2, + "stddev_outliers": 17, + "outliers": "17;2", + "ld15iqr": 0.01567491699825041, + "hd15iqr": 0.021569916993030347, + "ops": 56.40116226017058, + "total": 1.0992681270290632, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-1.5-0.5-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-1.5-0.5-10000]", + "params": { + "rho": 0.3, + "eta": 1.5, + "xi": 0.5, + "n": 10000 + }, + "param": "0.3-1.5-0.5-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.2589037090074271, + "max": 0.40089520798937883, + "mean": 0.34840142920147626, + "stddev": 0.040943908163030035, + "rounds": 10, + "median": 0.3458976254987647, + "iqr": 0.04354891799448524, + "q1": 0.33493229100713506, + "q3": 0.3784812090016203, + "iqr_outliers": 1, + "stddev_outliers": 3, + "outliers": "3;1", + "ld15iqr": 0.32141137500002515, + "hd15iqr": 0.40089520798937883, + "ops": 2.8702522899861935, + "total": 3.4840142920147628, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-1.5-0.7-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-1.5-0.7-1000]", + "params": { + "rho": 0.3, + "eta": 1.5, + "xi": 0.7, + "n": 1000 + }, + "param": "0.3-1.5-0.7-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.015050957998028025, + "max": 0.02153445899602957, + "mean": 0.017561495576184385, + "stddev": 0.0015146670499599898, + "rounds": 66, + "median": 0.017042396000761073, + "iqr": 0.002310790994670242, + "q1": 0.016471666996949352, + "q3": 0.018782457991619594, + "iqr_outliers": 0, + "stddev_outliers": 19, + "outliers": "19;0", + "ld15iqr": 0.015050957998028025, + "hd15iqr": 0.02153445899602957, + "ops": 56.9427584149568, + "total": 1.1590587080281693, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-1.5-0.7-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-1.5-0.7-10000]", + "params": { + "rho": 0.3, + "eta": 1.5, + "xi": 0.7, + "n": 10000 + }, + "param": "0.3-1.5-0.7-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.3186905839975225, + "max": 0.3619770840014098, + "mean": 0.34071871679770993, + "stddev": 0.014728457014852543, + "rounds": 10, + "median": 0.3412488334943191, + "iqr": 0.021631665993481874, + "q1": 0.3295088339946233, + "q3": 0.35114049998810515, + "iqr_outliers": 0, + "stddev_outliers": 4, + "outliers": "4;0", + "ld15iqr": 0.3186905839975225, + "hd15iqr": 0.3619770840014098, + "ops": 2.9349723120544495, + "total": 3.4071871679770993, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-2.0-0.2-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-2.0-0.2-1000]", + "params": { + "rho": 0.3, + "eta": 2.0, + "xi": 0.2, + "n": 1000 + }, + "param": "0.3-2.0-0.2-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.020013291999930516, + "max": 0.045262792002176866, + "mean": 0.022320754322728526, + "stddev": 0.0032628341305891836, + "rounds": 56, + "median": 0.021949145499092992, + "iqr": 0.0013337705095182173, + "q1": 0.021141249999345746, + "q3": 0.022475020508863963, + "iqr_outliers": 1, + "stddev_outliers": 1, + "outliers": "1;1", + "ld15iqr": 0.020013291999930516, + "hd15iqr": 0.045262792002176866, + "ops": 44.80135328498873, + "total": 1.2499622420727974, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-2.0-0.2-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-2.0-0.2-10000]", + "params": { + "rho": 0.3, + "eta": 2.0, + "xi": 0.2, + "n": 10000 + }, + "param": "0.3-2.0-0.2-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.3831134999927599, + "max": 0.4746140839997679, + "mean": 0.42215338759997395, + "stddev": 0.029073952529774922, + "rounds": 10, + "median": 0.4267398954980308, + "iqr": 0.045314833012525924, + "q1": 0.3917572089994792, + "q3": 0.4370720420120051, + "iqr_outliers": 0, + "stddev_outliers": 4, + "outliers": "4;0", + "ld15iqr": 0.3831134999927599, + "hd15iqr": 0.4746140839997679, + "ops": 2.3688072377796114, + "total": 4.221533875999739, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-2.0-0.5-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-2.0-0.5-1000]", + "params": { + "rho": 0.3, + "eta": 2.0, + "xi": 0.5, + "n": 1000 + }, + "param": "0.3-2.0-0.5-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.019128833009744994, + "max": 0.026091874999110587, + "mean": 0.022011778172712253, + "stddev": 0.0015231809954711355, + "rounds": 52, + "median": 0.02160689599259058, + "iqr": 0.0021595620055450127, + "q1": 0.020911500498186797, + "q3": 0.02307106250373181, + "iqr_outliers": 0, + "stddev_outliers": 16, + "outliers": "16;0", + "ld15iqr": 0.019128833009744994, + "hd15iqr": 0.026091874999110587, + "ops": 45.43022340828822, + "total": 1.1446124649810372, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-2.0-0.5-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-2.0-0.5-10000]", + "params": { + "rho": 0.3, + "eta": 2.0, + "xi": 0.5, + "n": 10000 + }, + "param": "0.3-2.0-0.5-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.3537323339987779, + "max": 0.4666734579950571, + "mean": 0.41915485430072297, + "stddev": 0.033456744786961, + "rounds": 10, + "median": 0.4196883545082528, + "iqr": 0.043411374994320795, + "q1": 0.39895483299915213, + "q3": 0.4423662079934729, + "iqr_outliers": 0, + "stddev_outliers": 3, + "outliers": "3;0", + "ld15iqr": 0.3537323339987779, + "hd15iqr": 0.4666734579950571, + "ops": 2.385753116633475, + "total": 4.1915485430072295, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-2.0-0.7-1000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-2.0-0.7-1000]", + "params": { + "rho": 0.3, + "eta": 2.0, + "xi": 0.7, + "n": 1000 + }, + "param": "0.3-2.0-0.7-1000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.019069667003350332, + "max": 0.024570540990680456, + "mean": 0.021275301472368564, + "stddev": 0.0012563924951222067, + "rounds": 55, + "median": 0.02134470899181906, + "iqr": 0.0014893752450007014, + "q1": 0.020486104251176585, + "q3": 0.021975479496177286, + "iqr_outliers": 2, + "stddev_outliers": 17, + "outliers": "17;2", + "ld15iqr": 0.019069667003350332, + "hd15iqr": 0.024311624991241843, + "ops": 47.002859221466565, + "total": 1.170141580980271, + "iterations": 1 + } + }, + { + "group": null, + "name": "test_benchmark_abcdoo[0.3-2.0-0.7-10000]", + "fullname": "benchmarks/test_benchmark.py::test_benchmark_abcdoo[0.3-2.0-0.7-10000]", + "params": { + "rho": 0.3, + "eta": 2.0, + "xi": 0.7, + "n": 10000 + }, + "param": "0.3-2.0-0.7-10000", + "extra_info": {}, + "options": { + "disable_gc": false, + "timer": "perf_counter", + "min_rounds": 10, + "max_time": 1.0, + "min_time": 5e-06, + "precision": null, + "confidence": null, + "warmup": 100000 + }, + "stats": { + "min": 0.38168966700322926, + "max": 0.4672677089984063, + "mean": 0.41305805029696785, + "stddev": 0.026318642089112318, + "rounds": 10, + "median": 0.4097345419941121, + "iqr": 0.03927583400218282, + "q1": 0.3919935829908354, + "q3": 0.43126941699301824, + "iqr_outliers": 0, + "stddev_outliers": 2, + "outliers": "2;0", + "ld15iqr": 0.38168966700322926, + "hd15iqr": 0.4672677089984063, + "ops": 2.4209672206631745, + "total": 4.1305805029696785, + "iterations": 1 + } + } + ], + "datetime": "2026-09-01T12:39:27.063329+00:00", + "version": "5.3.0" +} diff --git a/pyproject.toml b/pyproject.toml index 9bd8e4b..708a0cb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -34,11 +34,12 @@ dependencies = [ "tqdm>=4.0.0", ] -[project.optional-dependencies] +[dependency-groups] dev = [ "prek", "pytest>=8.3.4", "pytest-cov>=6.0.0", + "pytest-benchmark>=5.3.0", ] docs = [ "matplotlib", diff --git a/uv.lock b/uv.lock index 7cdd513..37a9035 100644 --- a/uv.lock +++ b/uv.lock @@ -1,988 +1,1688 @@ version = 1 -revision = 1 -requires-python = ">=3.9" -resolution-markers = [ - "python_full_version >= '3.10'", - "python_full_version < '3.10'", -] +revision = 3 +requires-python = ">=3.12" [[package]] name = "abcd-graph" -version = "0.4.0" +version = "0.5.0b0" source = { editable = "." } dependencies = [ - { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "numpy", version = "2.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "numba" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "tqdm" }, { name = "typing-extensions" }, ] -[package.optional-dependencies] -all = [ - { name = "igraph" }, - { name = "matplotlib", version = "3.9.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "matplotlib", version = "3.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "networkx", version = "3.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "scipy", version = "1.13.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "scipy", version = "1.14.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, -] +[package.dev-dependencies] dev = [ - { name = "pre-commit" }, + { name = "prek" }, { name = "pytest" }, + { name = "pytest-benchmark" }, { name = "pytest-cov" }, ] -igraph = [ +docs = [ + { name = "egosplit-sknetwork" }, { name = "igraph" }, -] -matplotlib = [ - { name = "matplotlib", version = "3.9.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "matplotlib", version = "3.10.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, -] -networkx = [ - { name = "networkx", version = "3.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, -] -scipy = [ - { name = "scipy", version = "1.13.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "scipy", version = "1.14.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "ipykernel" }, + { name = "jupyterlab-pygments" }, + { name = "matplotlib" }, + { name = "nbsphinx" }, + { name = "networkx" }, + { name = "numpydoc" }, + { name = "pandocfilters" }, + { name = "partition-igraph" }, + { name = "partition-networkx" }, + { name = "partition-sknetwork" }, + { name = "scikit-network" }, + { name = "sphinx-rtd-theme" }, ] [package.metadata] requires-dist = [ - { name = "igraph", marker = "extra == 'all'", specifier = ">=0.11.8" }, - { name = "igraph", marker = "extra == 'igraph'", specifier = ">=0.11.8" }, - { name = "matplotlib", marker = "extra == 'all'", specifier = ">=3.9.4" }, - { name = "matplotlib", marker = "extra == 'matplotlib'", specifier = ">=3.9.4" }, - { name = "networkx", marker = "extra == 'all'", specifier = ">=3.2.1" }, - { name = "networkx", marker = "extra == 'networkx'", specifier = ">=3.2.1" }, - { name = "numpy", specifier = ">=1.26.4" }, - { name = "pre-commit", marker = "extra == 'dev'", specifier = ">=4.0.1" }, - { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.3.4" }, - { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=6.0.0" }, - { name = "scipy", marker = "extra == 'all'", specifier = ">=1.13.1" }, - { name = "scipy", marker = "extra == 'scipy'", specifier = ">=1.13.1" }, + { name = "numba", specifier = ">=0.66.0" }, + { name = "numpy", specifier = ">=2.0.0" }, + { name = "scipy", specifier = ">=1.18.0" }, + { name = "tqdm", specifier = ">=4.0.0" }, { name = "typing-extensions", specifier = ">=4.10.0" }, ] -provides-extras = ["networkx", "igraph", "matplotlib", "scipy", "all", "dev"] + +[package.metadata.requires-dev] +dev = [ + { name = "prek" }, + { name = "pytest", specifier = ">=8.3.4" }, + { name = "pytest-benchmark", specifier = ">=5.3.0" }, + { name = "pytest-cov", specifier = ">=6.0.0" }, +] +docs = [ + { name = "egosplit-sknetwork" }, + { name = "igraph" }, + { name = "ipykernel" }, + { name = "jupyterlab-pygments", specifier = ">=0.1.1" }, + { name = "matplotlib" }, + { name = "nbsphinx" }, + { name = "networkx" }, + { name = "numpydoc" }, + { name = "pandocfilters" }, + { name = "partition-igraph" }, + { name = "partition-networkx" }, + { name = "partition-sknetwork" }, + { name = "scikit-network", specifier = ">=0.33.5" }, + { name = "sphinx-rtd-theme" }, +] [[package]] -name = "cfgv" -version = "3.4.0" +name = "alabaster" +version = "1.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/11/74/539e56497d9bd1d484fd863dd69cbbfa653cd2aa27abfe35653494d85e94/cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560", size = 7114 } +sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c5/55/51844dd50c4fc7a33b653bfaba4c2456f06955289ca770a5dbd5fd267374/cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9", size = 7249 }, + { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, ] [[package]] -name = "colorama" -version = "0.4.6" +name = "appnope" +version = "1.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } +sdist = { url = "https://files.pythonhosted.org/packages/11/f7/a82489c2b6ebe32d3e2831895ae19c77861f0eadf3bb16034484d965dbb2/appnope-1.0.0.tar.gz", hash = "sha256:685db59cb6043c3c2e528adc0b3bce3a5f8d09bcf7492c6ea650d1b7421f3c49", size = 5454, upload-time = "2026-08-20T21:36:13.748Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, + { url = "https://files.pythonhosted.org/packages/46/c7/6b687cb0f83d2a51017d47953f2ee430ffad6fec2a8ebc964e0718a33eb1/appnope-1.0.0-py3-none-any.whl", hash = "sha256:6fe0c04218aab65c54c4ff81638cdbf848d89f5653b74d68638a137f200dd16e", size = 4158, upload-time = "2026-08-20T21:36:12.444Z" }, ] [[package]] -name = "contourpy" -version = "1.3.0" +name = "asttokens" +version = "3.0.2" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.10'", +sdist = { url = "https://files.pythonhosted.org/packages/25/1e/faf0f247f6f881b98fc4d6d07e14085cb89d13665084e6d6ac1dc2c03d0b/asttokens-3.0.2.tar.gz", hash = "sha256:3ecdbd8f2cc195f53ccada3a613538bb5f9ef6f6869129f13e03c30a677b8fe2", size = 63136, upload-time = "2026-07-12T03:31:49.084Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/2b/04b8a15f3a1c77bc79ddf5c73875327f34b4fa75982df2b76e45e402d364/asttokens-3.0.2-py3-none-any.whl", hash = "sha256:9da13157f5b28becde0bd374fc677dcd3c290614264eff096f167c469cd9f933", size = 28702, upload-time = "2026-07-12T03:31:47.542Z" }, ] -dependencies = [ - { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/f5/f6/31a8f28b4a2a4fa0e01085e542f3081ab0588eff8e589d39d775172c9792/contourpy-1.3.0.tar.gz", hash = "sha256:7ffa0db17717a8ffb127efd0c95a4362d996b892c2904db72428d5b52e1938a4", size = 13464370 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6c/e0/be8dcc796cfdd96708933e0e2da99ba4bb8f9b2caa9d560a50f3f09a65f3/contourpy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:880ea32e5c774634f9fcd46504bf9f080a41ad855f4fef54f5380f5133d343c7", size = 265366 }, - { url = "https://files.pythonhosted.org/packages/50/d6/c953b400219443535d412fcbbc42e7a5e823291236bc0bb88936e3cc9317/contourpy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:76c905ef940a4474a6289c71d53122a4f77766eef23c03cd57016ce19d0f7b42", size = 249226 }, - { url = "https://files.pythonhosted.org/packages/6f/b4/6fffdf213ffccc28483c524b9dad46bb78332851133b36ad354b856ddc7c/contourpy-1.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:92f8557cbb07415a4d6fa191f20fd9d2d9eb9c0b61d1b2f52a8926e43c6e9af7", size = 308460 }, - { url = "https://files.pythonhosted.org/packages/cf/6c/118fc917b4050f0afe07179a6dcbe4f3f4ec69b94f36c9e128c4af480fb8/contourpy-1.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36f965570cff02b874773c49bfe85562b47030805d7d8360748f3eca570f4cab", size = 347623 }, - { url = "https://files.pythonhosted.org/packages/f9/a4/30ff110a81bfe3abf7b9673284d21ddce8cc1278f6f77393c91199da4c90/contourpy-1.3.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cacd81e2d4b6f89c9f8a5b69b86490152ff39afc58a95af002a398273e5ce589", size = 317761 }, - { url = "https://files.pythonhosted.org/packages/99/e6/d11966962b1aa515f5586d3907ad019f4b812c04e4546cc19ebf62b5178e/contourpy-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69375194457ad0fad3a839b9e29aa0b0ed53bb54db1bfb6c3ae43d111c31ce41", size = 322015 }, - { url = "https://files.pythonhosted.org/packages/4d/e3/182383743751d22b7b59c3c753277b6aee3637049197624f333dac5b4c80/contourpy-1.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a52040312b1a858b5e31ef28c2e865376a386c60c0e248370bbea2d3f3b760d", size = 1262672 }, - { url = "https://files.pythonhosted.org/packages/78/53/974400c815b2e605f252c8fb9297e2204347d1755a5374354ee77b1ea259/contourpy-1.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3faeb2998e4fcb256542e8a926d08da08977f7f5e62cf733f3c211c2a5586223", size = 1321688 }, - { url = "https://files.pythonhosted.org/packages/52/29/99f849faed5593b2926a68a31882af98afbeac39c7fdf7de491d9c85ec6a/contourpy-1.3.0-cp310-cp310-win32.whl", hash = "sha256:36e0cff201bcb17a0a8ecc7f454fe078437fa6bda730e695a92f2d9932bd507f", size = 171145 }, - { url = "https://files.pythonhosted.org/packages/a9/97/3f89bba79ff6ff2b07a3cbc40aa693c360d5efa90d66e914f0ff03b95ec7/contourpy-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:87ddffef1dbe5e669b5c2440b643d3fdd8622a348fe1983fad7a0f0ccb1cd67b", size = 216019 }, - { url = "https://files.pythonhosted.org/packages/b3/1f/9375917786cb39270b0ee6634536c0e22abf225825602688990d8f5c6c19/contourpy-1.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fa4c02abe6c446ba70d96ece336e621efa4aecae43eaa9b030ae5fb92b309ad", size = 266356 }, - { url = "https://files.pythonhosted.org/packages/05/46/9256dd162ea52790c127cb58cfc3b9e3413a6e3478917d1f811d420772ec/contourpy-1.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:834e0cfe17ba12f79963861e0f908556b2cedd52e1f75e6578801febcc6a9f49", size = 250915 }, - { url = "https://files.pythonhosted.org/packages/e1/5d/3056c167fa4486900dfbd7e26a2fdc2338dc58eee36d490a0ed3ddda5ded/contourpy-1.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dbc4c3217eee163fa3984fd1567632b48d6dfd29216da3ded3d7b844a8014a66", size = 310443 }, - { url = "https://files.pythonhosted.org/packages/ca/c2/1a612e475492e07f11c8e267ea5ec1ce0d89971be496c195e27afa97e14a/contourpy-1.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4865cd1d419e0c7a7bf6de1777b185eebdc51470800a9f42b9e9decf17762081", size = 348548 }, - { url = "https://files.pythonhosted.org/packages/45/cf/2c2fc6bb5874158277b4faf136847f0689e1b1a1f640a36d76d52e78907c/contourpy-1.3.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:303c252947ab4b14c08afeb52375b26781ccd6a5ccd81abcdfc1fafd14cf93c1", size = 319118 }, - { url = "https://files.pythonhosted.org/packages/03/33/003065374f38894cdf1040cef474ad0546368eea7e3a51d48b8a423961f8/contourpy-1.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637f674226be46f6ba372fd29d9523dd977a291f66ab2a74fbeb5530bb3f445d", size = 323162 }, - { url = "https://files.pythonhosted.org/packages/42/80/e637326e85e4105a802e42959f56cff2cd39a6b5ef68d5d9aee3ea5f0e4c/contourpy-1.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:76a896b2f195b57db25d6b44e7e03f221d32fe318d03ede41f8b4d9ba1bff53c", size = 1265396 }, - { url = "https://files.pythonhosted.org/packages/7c/3b/8cbd6416ca1bbc0202b50f9c13b2e0b922b64be888f9d9ee88e6cfabfb51/contourpy-1.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e1fd23e9d01591bab45546c089ae89d926917a66dceb3abcf01f6105d927e2cb", size = 1324297 }, - { url = "https://files.pythonhosted.org/packages/4d/2c/021a7afaa52fe891f25535506cc861c30c3c4e5a1c1ce94215e04b293e72/contourpy-1.3.0-cp311-cp311-win32.whl", hash = "sha256:d402880b84df3bec6eab53cd0cf802cae6a2ef9537e70cf75e91618a3801c20c", size = 171808 }, - { url = "https://files.pythonhosted.org/packages/8d/2f/804f02ff30a7fae21f98198828d0857439ec4c91a96e20cf2d6c49372966/contourpy-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:6cb6cc968059db9c62cb35fbf70248f40994dfcd7aa10444bbf8b3faeb7c2d67", size = 217181 }, - { url = "https://files.pythonhosted.org/packages/c9/92/8e0bbfe6b70c0e2d3d81272b58c98ac69ff1a4329f18c73bd64824d8b12e/contourpy-1.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:570ef7cf892f0afbe5b2ee410c507ce12e15a5fa91017a0009f79f7d93a1268f", size = 267838 }, - { url = "https://files.pythonhosted.org/packages/e3/04/33351c5d5108460a8ce6d512307690b023f0cfcad5899499f5c83b9d63b1/contourpy-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:da84c537cb8b97d153e9fb208c221c45605f73147bd4cadd23bdae915042aad6", size = 251549 }, - { url = "https://files.pythonhosted.org/packages/51/3d/aa0fe6ae67e3ef9f178389e4caaaa68daf2f9024092aa3c6032e3d174670/contourpy-1.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0be4d8425bfa755e0fd76ee1e019636ccc7c29f77a7c86b4328a9eb6a26d0639", size = 303177 }, - { url = "https://files.pythonhosted.org/packages/56/c3/c85a7e3e0cab635575d3b657f9535443a6f5d20fac1a1911eaa4bbe1aceb/contourpy-1.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9c0da700bf58f6e0b65312d0a5e695179a71d0163957fa381bb3c1f72972537c", size = 341735 }, - { url = "https://files.pythonhosted.org/packages/dd/8d/20f7a211a7be966a53f474bc90b1a8202e9844b3f1ef85f3ae45a77151ee/contourpy-1.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb8b141bb00fa977d9122636b16aa67d37fd40a3d8b52dd837e536d64b9a4d06", size = 314679 }, - { url = "https://files.pythonhosted.org/packages/6e/be/524e377567defac0e21a46e2a529652d165fed130a0d8a863219303cee18/contourpy-1.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3634b5385c6716c258d0419c46d05c8aa7dc8cb70326c9a4fb66b69ad2b52e09", size = 320549 }, - { url = "https://files.pythonhosted.org/packages/0f/96/fdb2552a172942d888915f3a6663812e9bc3d359d53dafd4289a0fb462f0/contourpy-1.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0dce35502151b6bd35027ac39ba6e5a44be13a68f55735c3612c568cac3805fd", size = 1263068 }, - { url = "https://files.pythonhosted.org/packages/2a/25/632eab595e3140adfa92f1322bf8915f68c932bac468e89eae9974cf1c00/contourpy-1.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea348f053c645100612b333adc5983d87be69acdc6d77d3169c090d3b01dc35", size = 1322833 }, - { url = "https://files.pythonhosted.org/packages/73/e3/69738782e315a1d26d29d71a550dbbe3eb6c653b028b150f70c1a5f4f229/contourpy-1.3.0-cp312-cp312-win32.whl", hash = "sha256:90f73a5116ad1ba7174341ef3ea5c3150ddf20b024b98fb0c3b29034752c8aeb", size = 172681 }, - { url = "https://files.pythonhosted.org/packages/0c/89/9830ba00d88e43d15e53d64931e66b8792b46eb25e2050a88fec4a0df3d5/contourpy-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:b11b39aea6be6764f84360fce6c82211a9db32a7c7de8fa6dd5397cf1d079c3b", size = 218283 }, - { url = "https://files.pythonhosted.org/packages/53/a1/d20415febfb2267af2d7f06338e82171824d08614084714fb2c1dac9901f/contourpy-1.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3e1c7fa44aaae40a2247e2e8e0627f4bea3dd257014764aa644f319a5f8600e3", size = 267879 }, - { url = "https://files.pythonhosted.org/packages/aa/45/5a28a3570ff6218d8bdfc291a272a20d2648104815f01f0177d103d985e1/contourpy-1.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:364174c2a76057feef647c802652f00953b575723062560498dc7930fc9b1cb7", size = 251573 }, - { url = "https://files.pythonhosted.org/packages/39/1c/d3f51540108e3affa84f095c8b04f0aa833bb797bc8baa218a952a98117d/contourpy-1.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32b238b3b3b649e09ce9aaf51f0c261d38644bdfa35cbaf7b263457850957a84", size = 303184 }, - { url = "https://files.pythonhosted.org/packages/00/56/1348a44fb6c3a558c1a3a0cd23d329d604c99d81bf5a4b58c6b71aab328f/contourpy-1.3.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d51fca85f9f7ad0b65b4b9fe800406d0d77017d7270d31ec3fb1cc07358fdea0", size = 340262 }, - { url = "https://files.pythonhosted.org/packages/2b/23/00d665ba67e1bb666152131da07e0f24c95c3632d7722caa97fb61470eca/contourpy-1.3.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:732896af21716b29ab3e988d4ce14bc5133733b85956316fb0c56355f398099b", size = 313806 }, - { url = "https://files.pythonhosted.org/packages/5a/42/3cf40f7040bb8362aea19af9a5fb7b32ce420f645dd1590edcee2c657cd5/contourpy-1.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d73f659398a0904e125280836ae6f88ba9b178b2fed6884f3b1f95b989d2c8da", size = 319710 }, - { url = "https://files.pythonhosted.org/packages/05/32/f3bfa3fc083b25e1a7ae09197f897476ee68e7386e10404bdf9aac7391f0/contourpy-1.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c6c7c2408b7048082932cf4e641fa3b8ca848259212f51c8c59c45aa7ac18f14", size = 1264107 }, - { url = "https://files.pythonhosted.org/packages/1c/1e/1019d34473a736664f2439542b890b2dc4c6245f5c0d8cdfc0ccc2cab80c/contourpy-1.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f317576606de89da6b7e0861cf6061f6146ead3528acabff9236458a6ba467f8", size = 1322458 }, - { url = "https://files.pythonhosted.org/packages/22/85/4f8bfd83972cf8909a4d36d16b177f7b8bdd942178ea4bf877d4a380a91c/contourpy-1.3.0-cp313-cp313-win32.whl", hash = "sha256:31cd3a85dbdf1fc002280c65caa7e2b5f65e4a973fcdf70dd2fdcb9868069294", size = 172643 }, - { url = "https://files.pythonhosted.org/packages/cc/4a/fb3c83c1baba64ba90443626c228ca14f19a87c51975d3b1de308dd2cf08/contourpy-1.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:4553c421929ec95fb07b3aaca0fae668b2eb5a5203d1217ca7c34c063c53d087", size = 218301 }, - { url = "https://files.pythonhosted.org/packages/76/65/702f4064f397821fea0cb493f7d3bc95a5d703e20954dce7d6d39bacf378/contourpy-1.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:345af746d7766821d05d72cb8f3845dfd08dd137101a2cb9b24de277d716def8", size = 278972 }, - { url = "https://files.pythonhosted.org/packages/80/85/21f5bba56dba75c10a45ec00ad3b8190dbac7fd9a8a8c46c6116c933e9cf/contourpy-1.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3bb3808858a9dc68f6f03d319acd5f1b8a337e6cdda197f02f4b8ff67ad2057b", size = 263375 }, - { url = "https://files.pythonhosted.org/packages/0a/64/084c86ab71d43149f91ab3a4054ccf18565f0a8af36abfa92b1467813ed6/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:420d39daa61aab1221567b42eecb01112908b2cab7f1b4106a52caaec8d36973", size = 307188 }, - { url = "https://files.pythonhosted.org/packages/3d/ff/d61a4c288dc42da0084b8d9dc2aa219a850767165d7d9a9c364ff530b509/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d63ee447261e963af02642ffcb864e5a2ee4cbfd78080657a9880b8b1868e18", size = 345644 }, - { url = "https://files.pythonhosted.org/packages/ca/aa/00d2313d35ec03f188e8f0786c2fc61f589306e02fdc158233697546fd58/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:167d6c890815e1dac9536dca00828b445d5d0df4d6a8c6adb4a7ec3166812fa8", size = 317141 }, - { url = "https://files.pythonhosted.org/packages/8d/6a/b5242c8cb32d87f6abf4f5e3044ca397cb1a76712e3fa2424772e3ff495f/contourpy-1.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:710a26b3dc80c0e4febf04555de66f5fd17e9cf7170a7b08000601a10570bda6", size = 323469 }, - { url = "https://files.pythonhosted.org/packages/6f/a6/73e929d43028a9079aca4bde107494864d54f0d72d9db508a51ff0878593/contourpy-1.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:75ee7cb1a14c617f34a51d11fa7524173e56551646828353c4af859c56b766e2", size = 1260894 }, - { url = "https://files.pythonhosted.org/packages/2b/1e/1e726ba66eddf21c940821df8cf1a7d15cb165f0682d62161eaa5e93dae1/contourpy-1.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:33c92cdae89ec5135d036e7218e69b0bb2851206077251f04a6c4e0e21f03927", size = 1314829 }, - { url = "https://files.pythonhosted.org/packages/b3/e3/b9f72758adb6ef7397327ceb8b9c39c75711affb220e4f53c745ea1d5a9a/contourpy-1.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a11077e395f67ffc2c44ec2418cfebed032cd6da3022a94fc227b6faf8e2acb8", size = 265518 }, - { url = "https://files.pythonhosted.org/packages/ec/22/19f5b948367ab5260fb41d842c7a78dae645603881ea6bc39738bcfcabf6/contourpy-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e8134301d7e204c88ed7ab50028ba06c683000040ede1d617298611f9dc6240c", size = 249350 }, - { url = "https://files.pythonhosted.org/packages/26/76/0c7d43263dd00ae21a91a24381b7e813d286a3294d95d179ef3a7b9fb1d7/contourpy-1.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e12968fdfd5bb45ffdf6192a590bd8ddd3ba9e58360b29683c6bb71a7b41edca", size = 309167 }, - { url = "https://files.pythonhosted.org/packages/96/3b/cadff6773e89f2a5a492c1a8068e21d3fccaf1a1c1df7d65e7c8e3ef60ba/contourpy-1.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fd2a0fc506eccaaa7595b7e1418951f213cf8255be2600f1ea1b61e46a60c55f", size = 348279 }, - { url = "https://files.pythonhosted.org/packages/e1/86/158cc43aa549d2081a955ab11c6bdccc7a22caacc2af93186d26f5f48746/contourpy-1.3.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4cfb5c62ce023dfc410d6059c936dcf96442ba40814aefbfa575425a3a7f19dc", size = 318519 }, - { url = "https://files.pythonhosted.org/packages/05/11/57335544a3027e9b96a05948c32e566328e3a2f84b7b99a325b7a06d2b06/contourpy-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68a32389b06b82c2fdd68276148d7b9275b5f5cf13e5417e4252f6d1a34f72a2", size = 321922 }, - { url = "https://files.pythonhosted.org/packages/0b/e3/02114f96543f4a1b694333b92a6dcd4f8eebbefcc3a5f3bbb1316634178f/contourpy-1.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:94e848a6b83da10898cbf1311a815f770acc9b6a3f2d646f330d57eb4e87592e", size = 1258017 }, - { url = "https://files.pythonhosted.org/packages/f3/3b/bfe4c81c6d5881c1c643dde6620be0b42bf8aab155976dd644595cfab95c/contourpy-1.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:d78ab28a03c854a873787a0a42254a0ccb3cb133c672f645c9f9c8f3ae9d0800", size = 1316773 }, - { url = "https://files.pythonhosted.org/packages/f1/17/c52d2970784383cafb0bd918b6fb036d98d96bbf0bc1befb5d1e31a07a70/contourpy-1.3.0-cp39-cp39-win32.whl", hash = "sha256:81cb5ed4952aae6014bc9d0421dec7c5835c9c8c31cdf51910b708f548cf58e5", size = 171353 }, - { url = "https://files.pythonhosted.org/packages/53/23/db9f69676308e094d3c45f20cc52e12d10d64f027541c995d89c11ad5c75/contourpy-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:14e262f67bd7e6eb6880bc564dcda30b15e351a594657e55b7eec94b6ef72843", size = 211817 }, - { url = "https://files.pythonhosted.org/packages/d1/09/60e486dc2b64c94ed33e58dcfb6f808192c03dfc5574c016218b9b7680dc/contourpy-1.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fe41b41505a5a33aeaed2a613dccaeaa74e0e3ead6dd6fd3a118fb471644fd6c", size = 261886 }, - { url = "https://files.pythonhosted.org/packages/19/20/b57f9f7174fcd439a7789fb47d764974ab646fa34d1790551de386457a8e/contourpy-1.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eca7e17a65f72a5133bdbec9ecf22401c62bcf4821361ef7811faee695799779", size = 311008 }, - { url = "https://files.pythonhosted.org/packages/74/fc/5040d42623a1845d4f17a418e590fd7a79ae8cb2bad2b2f83de63c3bdca4/contourpy-1.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1ec4dc6bf570f5b22ed0d7efba0dfa9c5b9e0431aeea7581aa217542d9e809a4", size = 215690 }, - { url = "https://files.pythonhosted.org/packages/2b/24/dc3dcd77ac7460ab7e9d2b01a618cb31406902e50e605a8d6091f0a8f7cc/contourpy-1.3.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:00ccd0dbaad6d804ab259820fa7cb0b8036bda0686ef844d24125d8287178ce0", size = 261894 }, - { url = "https://files.pythonhosted.org/packages/b1/db/531642a01cfec39d1682e46b5457b07cf805e3c3c584ec27e2a6223f8f6c/contourpy-1.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ca947601224119117f7c19c9cdf6b3ab54c5726ef1d906aa4a69dfb6dd58102", size = 311099 }, - { url = "https://files.pythonhosted.org/packages/38/1e/94bda024d629f254143a134eead69e21c836429a2a6ce82209a00ddcb79a/contourpy-1.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c6ec93afeb848a0845a18989da3beca3eec2c0f852322efe21af1931147d12cb", size = 215838 }, + +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, ] [[package]] -name = "contourpy" -version = "1.3.1" +name = "babel" +version = "2.18.0" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.10'", +sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" }, ] + +[[package]] +name = "beautifulsoup4" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "2.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/25/c2/fc7193cc5383637ff390a712e88e4ded0452c9fbcf84abe3de5ea3df1866/contourpy-1.3.1.tar.gz", hash = "sha256:dfd97abd83335045a913e3bcc4a09c0ceadbe66580cf573fe961f4a825efa699", size = 13465753 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b2/a3/80937fe3efe0edacf67c9a20b955139a1a622730042c1ea991956f2704ad/contourpy-1.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a045f341a77b77e1c5de31e74e966537bba9f3c4099b35bf4c2e3939dd54cdab", size = 268466 }, - { url = "https://files.pythonhosted.org/packages/82/1d/e3eaebb4aa2d7311528c048350ca8e99cdacfafd99da87bc0a5f8d81f2c2/contourpy-1.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:500360b77259914f7805af7462e41f9cb7ca92ad38e9f94d6c8641b089338124", size = 253314 }, - { url = "https://files.pythonhosted.org/packages/de/f3/d796b22d1a2b587acc8100ba8c07fb7b5e17fde265a7bb05ab967f4c935a/contourpy-1.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2f926efda994cdf3c8d3fdb40b9962f86edbc4457e739277b961eced3d0b4c1", size = 312003 }, - { url = "https://files.pythonhosted.org/packages/bf/f5/0e67902bc4394daee8daa39c81d4f00b50e063ee1a46cb3938cc65585d36/contourpy-1.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:adce39d67c0edf383647a3a007de0a45fd1b08dedaa5318404f1a73059c2512b", size = 351896 }, - { url = "https://files.pythonhosted.org/packages/1f/d6/e766395723f6256d45d6e67c13bb638dd1fa9dc10ef912dc7dd3dcfc19de/contourpy-1.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abbb49fb7dac584e5abc6636b7b2a7227111c4f771005853e7d25176daaf8453", size = 320814 }, - { url = "https://files.pythonhosted.org/packages/a9/57/86c500d63b3e26e5b73a28b8291a67c5608d4aa87ebd17bd15bb33c178bc/contourpy-1.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0cffcbede75c059f535725c1680dfb17b6ba8753f0c74b14e6a9c68c29d7ea3", size = 324969 }, - { url = "https://files.pythonhosted.org/packages/b8/62/bb146d1289d6b3450bccc4642e7f4413b92ebffd9bf2e91b0404323704a7/contourpy-1.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab29962927945d89d9b293eabd0d59aea28d887d4f3be6c22deaefbb938a7277", size = 1265162 }, - { url = "https://files.pythonhosted.org/packages/18/04/9f7d132ce49a212c8e767042cc80ae390f728060d2eea47058f55b9eff1c/contourpy-1.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974d8145f8ca354498005b5b981165b74a195abfae9a8129df3e56771961d595", size = 1324328 }, - { url = "https://files.pythonhosted.org/packages/46/23/196813901be3f97c83ababdab1382e13e0edc0bb4e7b49a7bff15fcf754e/contourpy-1.3.1-cp310-cp310-win32.whl", hash = "sha256:ac4578ac281983f63b400f7fe6c101bedc10651650eef012be1ccffcbacf3697", size = 173861 }, - { url = "https://files.pythonhosted.org/packages/e0/82/c372be3fc000a3b2005061ca623a0d1ecd2eaafb10d9e883a2fc8566e951/contourpy-1.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:174e758c66bbc1c8576992cec9599ce8b6672b741b5d336b5c74e35ac382b18e", size = 218566 }, - { url = "https://files.pythonhosted.org/packages/12/bb/11250d2906ee2e8b466b5f93e6b19d525f3e0254ac8b445b56e618527718/contourpy-1.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3e8b974d8db2c5610fb4e76307e265de0edb655ae8169e8b21f41807ccbeec4b", size = 269555 }, - { url = "https://files.pythonhosted.org/packages/67/71/1e6e95aee21a500415f5d2dbf037bf4567529b6a4e986594d7026ec5ae90/contourpy-1.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:20914c8c973f41456337652a6eeca26d2148aa96dd7ac323b74516988bea89fc", size = 254549 }, - { url = "https://files.pythonhosted.org/packages/31/2c/b88986e8d79ac45efe9d8801ae341525f38e087449b6c2f2e6050468a42c/contourpy-1.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d40d37c1c3a4961b4619dd9d77b12124a453cc3d02bb31a07d58ef684d3d86", size = 313000 }, - { url = "https://files.pythonhosted.org/packages/c4/18/65280989b151fcf33a8352f992eff71e61b968bef7432fbfde3a364f0730/contourpy-1.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:113231fe3825ebf6f15eaa8bc1f5b0ddc19d42b733345eae0934cb291beb88b6", size = 352925 }, - { url = "https://files.pythonhosted.org/packages/f5/c7/5fd0146c93220dbfe1a2e0f98969293b86ca9bc041d6c90c0e065f4619ad/contourpy-1.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4dbbc03a40f916a8420e420d63e96a1258d3d1b58cbdfd8d1f07b49fcbd38e85", size = 323693 }, - { url = "https://files.pythonhosted.org/packages/85/fc/7fa5d17daf77306840a4e84668a48ddff09e6bc09ba4e37e85ffc8e4faa3/contourpy-1.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a04ecd68acbd77fa2d39723ceca4c3197cb2969633836ced1bea14e219d077c", size = 326184 }, - { url = "https://files.pythonhosted.org/packages/ef/e7/104065c8270c7397c9571620d3ab880558957216f2b5ebb7e040f85eeb22/contourpy-1.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c414fc1ed8ee1dbd5da626cf3710c6013d3d27456651d156711fa24f24bd1291", size = 1268031 }, - { url = "https://files.pythonhosted.org/packages/e2/4a/c788d0bdbf32c8113c2354493ed291f924d4793c4a2e85b69e737a21a658/contourpy-1.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:31c1b55c1f34f80557d3830d3dd93ba722ce7e33a0b472cba0ec3b6535684d8f", size = 1325995 }, - { url = "https://files.pythonhosted.org/packages/a6/e6/a2f351a90d955f8b0564caf1ebe4b1451a3f01f83e5e3a414055a5b8bccb/contourpy-1.3.1-cp311-cp311-win32.whl", hash = "sha256:f611e628ef06670df83fce17805c344710ca5cde01edfdc72751311da8585375", size = 174396 }, - { url = "https://files.pythonhosted.org/packages/a8/7e/cd93cab453720a5d6cb75588cc17dcdc08fc3484b9de98b885924ff61900/contourpy-1.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:b2bdca22a27e35f16794cf585832e542123296b4687f9fd96822db6bae17bfc9", size = 219787 }, - { url = "https://files.pythonhosted.org/packages/37/6b/175f60227d3e7f5f1549fcb374592be311293132207e451c3d7c654c25fb/contourpy-1.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ffa84be8e0bd33410b17189f7164c3589c229ce5db85798076a3fa136d0e509", size = 271494 }, - { url = "https://files.pythonhosted.org/packages/6b/6a/7833cfae2c1e63d1d8875a50fd23371394f540ce809d7383550681a1fa64/contourpy-1.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805617228ba7e2cbbfb6c503858e626ab528ac2a32a04a2fe88ffaf6b02c32bc", size = 255444 }, - { url = "https://files.pythonhosted.org/packages/7f/b3/7859efce66eaca5c14ba7619791b084ed02d868d76b928ff56890d2d059d/contourpy-1.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade08d343436a94e633db932e7e8407fe7de8083967962b46bdfc1b0ced39454", size = 307628 }, - { url = "https://files.pythonhosted.org/packages/48/b2/011415f5e3f0a50b1e285a0bf78eb5d92a4df000553570f0851b6e309076/contourpy-1.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:47734d7073fb4590b4a40122b35917cd77be5722d80683b249dac1de266aac80", size = 347271 }, - { url = "https://files.pythonhosted.org/packages/84/7d/ef19b1db0f45b151ac78c65127235239a8cf21a59d1ce8507ce03e89a30b/contourpy-1.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2ba94a401342fc0f8b948e57d977557fbf4d515f03c67682dd5c6191cb2d16ec", size = 318906 }, - { url = "https://files.pythonhosted.org/packages/ba/99/6794142b90b853a9155316c8f470d2e4821fe6f086b03e372aca848227dd/contourpy-1.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efa874e87e4a647fd2e4f514d5e91c7d493697127beb95e77d2f7561f6905bd9", size = 323622 }, - { url = "https://files.pythonhosted.org/packages/3c/0f/37d2c84a900cd8eb54e105f4fa9aebd275e14e266736778bb5dccbf3bbbb/contourpy-1.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf98051f1045b15c87868dbaea84f92408337d4f81d0e449ee41920ea121d3b", size = 1266699 }, - { url = "https://files.pythonhosted.org/packages/3a/8a/deb5e11dc7d9cc8f0f9c8b29d4f062203f3af230ba83c30a6b161a6effc9/contourpy-1.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:61332c87493b00091423e747ea78200659dc09bdf7fd69edd5e98cef5d3e9a8d", size = 1326395 }, - { url = "https://files.pythonhosted.org/packages/1a/35/7e267ae7c13aaf12322ccc493531f1e7f2eb8fba2927b9d7a05ff615df7a/contourpy-1.3.1-cp312-cp312-win32.whl", hash = "sha256:e914a8cb05ce5c809dd0fe350cfbb4e881bde5e2a38dc04e3afe1b3e58bd158e", size = 175354 }, - { url = "https://files.pythonhosted.org/packages/a1/35/c2de8823211d07e8a79ab018ef03960716c5dff6f4d5bff5af87fd682992/contourpy-1.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:08d9d449a61cf53033612cb368f3a1b26cd7835d9b8cd326647efe43bca7568d", size = 220971 }, - { url = "https://files.pythonhosted.org/packages/9a/e7/de62050dce687c5e96f946a93546910bc67e483fe05324439e329ff36105/contourpy-1.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a761d9ccfc5e2ecd1bf05534eda382aa14c3e4f9205ba5b1684ecfe400716ef2", size = 271548 }, - { url = "https://files.pythonhosted.org/packages/78/4d/c2a09ae014ae984c6bdd29c11e74d3121b25eaa117eca0bb76340efd7e1c/contourpy-1.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:523a8ee12edfa36f6d2a49407f705a6ef4c5098de4f498619787e272de93f2d5", size = 255576 }, - { url = "https://files.pythonhosted.org/packages/ab/8a/915380ee96a5638bda80cd061ccb8e666bfdccea38d5741cb69e6dbd61fc/contourpy-1.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece6df05e2c41bd46776fbc712e0996f7c94e0d0543af1656956d150c4ca7c81", size = 306635 }, - { url = "https://files.pythonhosted.org/packages/29/5c/c83ce09375428298acd4e6582aeb68b1e0d1447f877fa993d9bf6cd3b0a0/contourpy-1.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:573abb30e0e05bf31ed067d2f82500ecfdaec15627a59d63ea2d95714790f5c2", size = 345925 }, - { url = "https://files.pythonhosted.org/packages/29/63/5b52f4a15e80c66c8078a641a3bfacd6e07106835682454647aca1afc852/contourpy-1.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9fa36448e6a3a1a9a2ba23c02012c43ed88905ec80163f2ffe2421c7192a5d7", size = 318000 }, - { url = "https://files.pythonhosted.org/packages/9a/e2/30ca086c692691129849198659bf0556d72a757fe2769eb9620a27169296/contourpy-1.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ea9924d28fc5586bf0b42d15f590b10c224117e74409dd7a0be3b62b74a501c", size = 322689 }, - { url = "https://files.pythonhosted.org/packages/6b/77/f37812ef700f1f185d348394debf33f22d531e714cf6a35d13d68a7003c7/contourpy-1.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b75aa69cb4d6f137b36f7eb2ace9280cfb60c55dc5f61c731fdf6f037f958a3", size = 1268413 }, - { url = "https://files.pythonhosted.org/packages/3f/6d/ce84e79cdd128542ebeb268f84abb4b093af78e7f8ec504676673d2675bc/contourpy-1.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:041b640d4ec01922083645a94bb3b2e777e6b626788f4095cf21abbe266413c1", size = 1326530 }, - { url = "https://files.pythonhosted.org/packages/72/22/8282f4eae20c73c89bee7a82a19c4e27af9b57bb602ecaa00713d5bdb54d/contourpy-1.3.1-cp313-cp313-win32.whl", hash = "sha256:36987a15e8ace5f58d4d5da9dca82d498c2bbb28dff6e5d04fbfcc35a9cb3a82", size = 175315 }, - { url = "https://files.pythonhosted.org/packages/e3/d5/28bca491f65312b438fbf076589dcde7f6f966b196d900777f5811b9c4e2/contourpy-1.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:a7895f46d47671fa7ceec40f31fae721da51ad34bdca0bee83e38870b1f47ffd", size = 220987 }, - { url = "https://files.pythonhosted.org/packages/2f/24/a4b285d6adaaf9746e4700932f579f1a7b6f9681109f694cfa233ae75c4e/contourpy-1.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ddeb796389dadcd884c7eb07bd14ef12408aaae358f0e2ae24114d797eede30", size = 285001 }, - { url = "https://files.pythonhosted.org/packages/48/1d/fb49a401b5ca4f06ccf467cd6c4f1fd65767e63c21322b29b04ec40b40b9/contourpy-1.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19c1555a6801c2f084c7ddc1c6e11f02eb6a6016ca1318dd5452ba3f613a1751", size = 268553 }, - { url = "https://files.pythonhosted.org/packages/79/1e/4aef9470d13fd029087388fae750dccb49a50c012a6c8d1d634295caa644/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841ad858cff65c2c04bf93875e384ccb82b654574a6d7f30453a04f04af71342", size = 310386 }, - { url = "https://files.pythonhosted.org/packages/b0/34/910dc706ed70153b60392b5305c708c9810d425bde12499c9184a1100888/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4318af1c925fb9a4fb190559ef3eec206845f63e80fb603d47f2d6d67683901c", size = 349806 }, - { url = "https://files.pythonhosted.org/packages/31/3c/faee6a40d66d7f2a87f7102236bf4780c57990dd7f98e5ff29881b1b1344/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:14c102b0eab282427b662cb590f2e9340a9d91a1c297f48729431f2dcd16e14f", size = 321108 }, - { url = "https://files.pythonhosted.org/packages/17/69/390dc9b20dd4bb20585651d7316cc3054b7d4a7b4f8b710b2b698e08968d/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e806338bfeaa006acbdeba0ad681a10be63b26e1b17317bfac3c5d98f36cda", size = 327291 }, - { url = "https://files.pythonhosted.org/packages/ef/74/7030b67c4e941fe1e5424a3d988080e83568030ce0355f7c9fc556455b01/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4d76d5993a34ef3df5181ba3c92fabb93f1eaa5729504fb03423fcd9f3177242", size = 1263752 }, - { url = "https://files.pythonhosted.org/packages/f0/ed/92d86f183a8615f13f6b9cbfc5d4298a509d6ce433432e21da838b4b63f4/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:89785bb2a1980c1bd87f0cb1517a71cde374776a5f150936b82580ae6ead44a1", size = 1318403 }, - { url = "https://files.pythonhosted.org/packages/b3/0e/c8e4950c77dcfc897c71d61e56690a0a9df39543d2164040301b5df8e67b/contourpy-1.3.1-cp313-cp313t-win32.whl", hash = "sha256:8eb96e79b9f3dcadbad2a3891672f81cdcab7f95b27f28f1c67d75f045b6b4f1", size = 185117 }, - { url = "https://files.pythonhosted.org/packages/c1/31/1ae946f11dfbd229222e6d6ad8e7bd1891d3d48bde5fbf7a0beb9491f8e3/contourpy-1.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:287ccc248c9e0d0566934e7d606201abd74761b5703d804ff3df8935f523d546", size = 236668 }, - { url = "https://files.pythonhosted.org/packages/3e/4f/e56862e64b52b55b5ddcff4090085521fc228ceb09a88390a2b103dccd1b/contourpy-1.3.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b457d6430833cee8e4b8e9b6f07aa1c161e5e0d52e118dc102c8f9bd7dd060d6", size = 265605 }, - { url = "https://files.pythonhosted.org/packages/b0/2e/52bfeeaa4541889f23d8eadc6386b442ee2470bd3cff9baa67deb2dd5c57/contourpy-1.3.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb76c1a154b83991a3cbbf0dfeb26ec2833ad56f95540b442c73950af2013750", size = 315040 }, - { url = "https://files.pythonhosted.org/packages/52/94/86bfae441707205634d80392e873295652fc313dfd93c233c52c4dc07874/contourpy-1.3.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:44a29502ca9c7b5ba389e620d44f2fbe792b1fb5734e8b931ad307071ec58c53", size = 218221 }, + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/c6/92fcd42f1ba33e1184263f25bfabf3d27c383410470f169e4b8163bf9c17/beautifulsoup4-4.15.0-py3-none-any.whl", hash = "sha256:d6f88de62e1d4e38ecb1077eb9724cd0eff29d2a08ca16a401e9b9e93f117cf9", size = 109924, upload-time = "2026-06-07T16:44:21.566Z" }, ] [[package]] -name = "coverage" -version = "7.6.9" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5b/d2/c25011f4d036cf7e8acbbee07a8e09e9018390aee25ba085596c4b83d510/coverage-7.6.9.tar.gz", hash = "sha256:4a8d8977b0c6ef5aeadcb644da9e69ae0dcfe66ec7f368c89c72e058bd71164d", size = 801710 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/49/f3/f830fb53bf7e4f1d5542756f61d9b740352a188f43854aab9409c8cdeb18/coverage-7.6.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:85d9636f72e8991a1706b2b55b06c27545448baf9f6dbf51c4004609aacd7dcb", size = 207024 }, - { url = "https://files.pythonhosted.org/packages/4e/e3/ea5632a3a6efd00ab0a791adc0f3e48512097a757ee7dcbee5505f57bafa/coverage-7.6.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:608a7fd78c67bee8936378299a6cb9f5149bb80238c7a566fc3e6717a4e68710", size = 207463 }, - { url = "https://files.pythonhosted.org/packages/e4/ae/18ff8b5580e27e62ebcc888082aa47694c2772782ea7011ddf58e377e98f/coverage-7.6.9-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:96d636c77af18b5cb664ddf12dab9b15a0cfe9c0bde715da38698c8cea748bfa", size = 235902 }, - { url = "https://files.pythonhosted.org/packages/6a/52/57030a8d15ab935624d298360f0a6704885578e39f7b4f68569e59f5902d/coverage-7.6.9-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d75cded8a3cff93da9edc31446872d2997e327921d8eed86641efafd350e1df1", size = 233806 }, - { url = "https://files.pythonhosted.org/packages/d0/c5/4466602195ecaced298d55af1e29abceb812addabefd5bd9116a204f7bab/coverage-7.6.9-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7b15f589593110ae767ce997775d645b47e5cbbf54fd322f8ebea6277466cec", size = 234966 }, - { url = "https://files.pythonhosted.org/packages/b0/1c/55552c3009b7bf96732e36548596ade771c87f89cf1f5a8e3975b33539b5/coverage-7.6.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:44349150f6811b44b25574839b39ae35291f6496eb795b7366fef3bd3cf112d3", size = 234029 }, - { url = "https://files.pythonhosted.org/packages/bb/7d/da3dca6878701182ea42c51df47a47c80eaef2a76f5aa3e891dc2a8cce3f/coverage-7.6.9-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:d891c136b5b310d0e702e186d70cd16d1119ea8927347045124cb286b29297e5", size = 232494 }, - { url = "https://files.pythonhosted.org/packages/28/cc/39de85ac1d5652bc34ff2bee39ae251b1fdcaae53fab4b44cab75a432bc0/coverage-7.6.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:db1dab894cc139f67822a92910466531de5ea6034ddfd2b11c0d4c6257168073", size = 233611 }, - { url = "https://files.pythonhosted.org/packages/d1/2b/7eb011a9378911088708f121825a71134d0c15fac96972a0ae7a8f5a4049/coverage-7.6.9-cp310-cp310-win32.whl", hash = "sha256:41ff7b0da5af71a51b53f501a3bac65fb0ec311ebed1632e58fc6107f03b9198", size = 209712 }, - { url = "https://files.pythonhosted.org/packages/5b/35/c3f40a2269b416db34ce1dedf682a7132c26f857e33596830fa4deebabf9/coverage-7.6.9-cp310-cp310-win_amd64.whl", hash = "sha256:35371f8438028fdccfaf3570b31d98e8d9eda8bb1d6ab9473f5a390969e98717", size = 210553 }, - { url = "https://files.pythonhosted.org/packages/b1/91/b3dc2f7f38b5cca1236ab6bbb03e84046dd887707b4ec1db2baa47493b3b/coverage-7.6.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:932fc826442132dde42ee52cf66d941f581c685a6313feebed358411238f60f9", size = 207133 }, - { url = "https://files.pythonhosted.org/packages/0d/2b/53fd6cb34d443429a92b3ec737f4953627e38b3bee2a67a3c03425ba8573/coverage-7.6.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:085161be5f3b30fd9b3e7b9a8c301f935c8313dcf928a07b116324abea2c1c2c", size = 207577 }, - { url = "https://files.pythonhosted.org/packages/74/f2/68edb1e6826f980a124f21ea5be0d324180bf11de6fd1defcf9604f76df0/coverage-7.6.9-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ccc660a77e1c2bf24ddbce969af9447a9474790160cfb23de6be4fa88e3951c7", size = 239524 }, - { url = "https://files.pythonhosted.org/packages/d3/83/8fec0ee68c2c4a5ab5f0f8527277f84ed6f2bd1310ae8a19d0c5532253ab/coverage-7.6.9-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c69e42c892c018cd3c8d90da61d845f50a8243062b19d228189b0224150018a9", size = 236925 }, - { url = "https://files.pythonhosted.org/packages/8b/20/8f50e7c7ad271144afbc2c1c6ec5541a8c81773f59352f8db544cad1a0ec/coverage-7.6.9-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0824a28ec542a0be22f60c6ac36d679e0e262e5353203bea81d44ee81fe9c6d4", size = 238792 }, - { url = "https://files.pythonhosted.org/packages/6f/62/4ac2e5ad9e7a5c9ec351f38947528e11541f1f00e8a0cdce56f1ba7ae301/coverage-7.6.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4401ae5fc52ad8d26d2a5d8a7428b0f0c72431683f8e63e42e70606374c311a1", size = 237682 }, - { url = "https://files.pythonhosted.org/packages/58/2f/9d2203f012f3b0533c73336c74134b608742be1ce475a5c72012573cfbb4/coverage-7.6.9-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:98caba4476a6c8d59ec1eb00c7dd862ba9beca34085642d46ed503cc2d440d4b", size = 236310 }, - { url = "https://files.pythonhosted.org/packages/33/6d/31f6ab0b4f0f781636075f757eb02141ea1b34466d9d1526dbc586ed7078/coverage-7.6.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ee5defd1733fd6ec08b168bd4f5387d5b322f45ca9e0e6c817ea6c4cd36313e3", size = 237096 }, - { url = "https://files.pythonhosted.org/packages/7d/fb/e14c38adebbda9ed8b5f7f8e03340ac05d68d27b24397f8d47478927a333/coverage-7.6.9-cp311-cp311-win32.whl", hash = "sha256:f2d1ec60d6d256bdf298cb86b78dd715980828f50c46701abc3b0a2b3f8a0dc0", size = 209682 }, - { url = "https://files.pythonhosted.org/packages/a4/11/a782af39b019066af83fdc0e8825faaccbe9d7b19a803ddb753114b429cc/coverage-7.6.9-cp311-cp311-win_amd64.whl", hash = "sha256:0d59fd927b1f04de57a2ba0137166d31c1a6dd9e764ad4af552912d70428c92b", size = 210542 }, - { url = "https://files.pythonhosted.org/packages/60/52/b16af8989a2daf0f80a88522bd8e8eed90b5fcbdecf02a6888f3e80f6ba7/coverage-7.6.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:99e266ae0b5d15f1ca8d278a668df6f51cc4b854513daab5cae695ed7b721cf8", size = 207325 }, - { url = "https://files.pythonhosted.org/packages/0f/79/6b7826fca8846c1216a113227b9f114ac3e6eacf168b4adcad0cb974aaca/coverage-7.6.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9901d36492009a0a9b94b20e52ebfc8453bf49bb2b27bca2c9706f8b4f5a554a", size = 207563 }, - { url = "https://files.pythonhosted.org/packages/a7/07/0bc73da0ccaf45d0d64ef86d33b7d7fdeef84b4c44bf6b85fb12c215c5a6/coverage-7.6.9-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:abd3e72dd5b97e3af4246cdada7738ef0e608168de952b837b8dd7e90341f015", size = 240580 }, - { url = "https://files.pythonhosted.org/packages/71/8a/9761f409910961647d892454687cedbaccb99aae828f49486734a82ede6e/coverage-7.6.9-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff74026a461eb0660366fb01c650c1d00f833a086b336bdad7ab00cc952072b3", size = 237613 }, - { url = "https://files.pythonhosted.org/packages/8b/10/ee7d696a17ac94f32f2dbda1e17e730bf798ae9931aec1fc01c1944cd4de/coverage-7.6.9-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:65dad5a248823a4996724a88eb51d4b31587aa7aa428562dbe459c684e5787ae", size = 239684 }, - { url = "https://files.pythonhosted.org/packages/16/60/aa1066040d3c52fff051243c2d6ccda264da72dc6d199d047624d395b2b2/coverage-7.6.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:22be16571504c9ccea919fcedb459d5ab20d41172056206eb2994e2ff06118a4", size = 239112 }, - { url = "https://files.pythonhosted.org/packages/4e/e5/69f35344c6f932ba9028bf168d14a79fedb0dd4849b796d43c81ce75a3c9/coverage-7.6.9-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f957943bc718b87144ecaee70762bc2bc3f1a7a53c7b861103546d3a403f0a6", size = 237428 }, - { url = "https://files.pythonhosted.org/packages/32/20/adc895523c4a28f63441b8ac645abd74f9bdd499d2d175bef5b41fc7f92d/coverage-7.6.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ae1387db4aecb1f485fb70a6c0148c6cdaebb6038f1d40089b1fc84a5db556f", size = 239098 }, - { url = "https://files.pythonhosted.org/packages/a9/a6/e0e74230c9bb3549ec8ffc137cfd16ea5d56e993d6bffed2218bff6187e3/coverage-7.6.9-cp312-cp312-win32.whl", hash = "sha256:1a330812d9cc7ac2182586f6d41b4d0fadf9be9049f350e0efb275c8ee8eb692", size = 209940 }, - { url = "https://files.pythonhosted.org/packages/3e/18/cb5b88349d4aa2f41ec78d65f92ea32572b30b3f55bc2b70e87578b8f434/coverage-7.6.9-cp312-cp312-win_amd64.whl", hash = "sha256:b12c6b18269ca471eedd41c1b6a1065b2f7827508edb9a7ed5555e9a56dcfc97", size = 210726 }, - { url = "https://files.pythonhosted.org/packages/35/26/9abab6539d2191dbda2ce8c97b67d74cbfc966cc5b25abb880ffc7c459bc/coverage-7.6.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:899b8cd4781c400454f2f64f7776a5d87bbd7b3e7f7bda0cb18f857bb1334664", size = 207356 }, - { url = "https://files.pythonhosted.org/packages/44/da/d49f19402240c93453f606e660a6676a2a1fbbaa6870cc23207790aa9697/coverage-7.6.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:61f70dc68bd36810972e55bbbe83674ea073dd1dcc121040a08cdf3416c5349c", size = 207614 }, - { url = "https://files.pythonhosted.org/packages/da/e6/93bb9bf85497816082ec8da6124c25efa2052bd4c887dd3b317b91990c9e/coverage-7.6.9-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8a289d23d4c46f1a82d5db4abeb40b9b5be91731ee19a379d15790e53031c014", size = 240129 }, - { url = "https://files.pythonhosted.org/packages/df/65/6a824b9406fe066835c1274a9949e06f084d3e605eb1a602727a27ec2fe3/coverage-7.6.9-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e216d8044a356fc0337c7a2a0536d6de07888d7bcda76febcb8adc50bdbbd00", size = 237276 }, - { url = "https://files.pythonhosted.org/packages/9f/79/6c7a800913a9dd23ac8c8da133ebb556771a5a3d4df36b46767b1baffd35/coverage-7.6.9-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c026eb44f744acaa2bda7493dad903aa5bf5fc4f2554293a798d5606710055d", size = 239267 }, - { url = "https://files.pythonhosted.org/packages/57/e7/834d530293fdc8a63ba8ff70033d5182022e569eceb9aec7fc716b678a39/coverage-7.6.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e77363e8425325384f9d49272c54045bbed2f478e9dd698dbc65dbc37860eb0a", size = 238887 }, - { url = "https://files.pythonhosted.org/packages/15/05/ec9d6080852984f7163c96984444e7cd98b338fd045b191064f943ee1c08/coverage-7.6.9-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:777abfab476cf83b5177b84d7486497e034eb9eaea0d746ce0c1268c71652077", size = 236970 }, - { url = "https://files.pythonhosted.org/packages/0a/d8/775937670b93156aec29f694ce37f56214ed7597e1a75b4083ee4c32121c/coverage-7.6.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:447af20e25fdbe16f26e84eb714ba21d98868705cb138252d28bc400381f6ffb", size = 238831 }, - { url = "https://files.pythonhosted.org/packages/f4/58/88551cb7fdd5ec98cb6044e8814e38583436b14040a5ece15349c44c8f7c/coverage-7.6.9-cp313-cp313-win32.whl", hash = "sha256:d872ec5aeb086cbea771c573600d47944eea2dcba8be5f3ee649bfe3cb8dc9ba", size = 210000 }, - { url = "https://files.pythonhosted.org/packages/b7/12/cfbf49b95120872785ff8d56ab1c7fe3970a65e35010c311d7dd35c5fd00/coverage-7.6.9-cp313-cp313-win_amd64.whl", hash = "sha256:fd1213c86e48dfdc5a0cc676551db467495a95a662d2396ecd58e719191446e1", size = 210753 }, - { url = "https://files.pythonhosted.org/packages/7c/68/c1cb31445599b04bde21cbbaa6d21b47c5823cdfef99eae470dfce49c35a/coverage-7.6.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ba9e7484d286cd5a43744e5f47b0b3fb457865baf07bafc6bee91896364e1419", size = 208091 }, - { url = "https://files.pythonhosted.org/packages/11/73/84b02c6b19c4a11eb2d5b5eabe926fb26c21c080e0852f5e5a4f01165f9e/coverage-7.6.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e5ea1cf0872ee455c03e5674b5bca5e3e68e159379c1af0903e89f5eba9ccc3a", size = 208369 }, - { url = "https://files.pythonhosted.org/packages/de/e0/ae5d878b72ff26df2e994a5c5b1c1f6a7507d976b23beecb1ed4c85411ef/coverage-7.6.9-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2d10e07aa2b91835d6abec555ec8b2733347956991901eea6ffac295f83a30e4", size = 251089 }, - { url = "https://files.pythonhosted.org/packages/ab/9c/0aaac011aef95a93ef3cb2fba3fde30bc7e68a6635199ed469b1f5ea355a/coverage-7.6.9-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:13a9e2d3ee855db3dd6ea1ba5203316a1b1fd8eaeffc37c5b54987e61e4194ae", size = 246806 }, - { url = "https://files.pythonhosted.org/packages/f8/19/4d5d3ae66938a7dcb2f58cef3fa5386f838f469575b0bb568c8cc9e3a33d/coverage-7.6.9-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c38bf15a40ccf5619fa2fe8f26106c7e8e080d7760aeccb3722664c8656b030", size = 249164 }, - { url = "https://files.pythonhosted.org/packages/b3/0b/4ee8a7821f682af9ad440ae3c1e379da89a998883271f088102d7ca2473d/coverage-7.6.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d5275455b3e4627c8e7154feaf7ee0743c2e7af82f6e3b561967b1cca755a0be", size = 248642 }, - { url = "https://files.pythonhosted.org/packages/8a/12/36ff1d52be18a16b4700f561852e7afd8df56363a5edcfb04cf26a0e19e0/coverage-7.6.9-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8f8770dfc6e2c6a2d4569f411015c8d751c980d17a14b0530da2d7f27ffdd88e", size = 246516 }, - { url = "https://files.pythonhosted.org/packages/43/d0/8e258f6c3a527c1655602f4f576215e055ac704de2d101710a71a2affac2/coverage-7.6.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8d2dfa71665a29b153a9681edb1c8d9c1ea50dfc2375fb4dac99ea7e21a0bcd9", size = 247783 }, - { url = "https://files.pythonhosted.org/packages/a9/0d/1e4a48d289429d38aae3babdfcadbf35ca36bdcf3efc8f09b550a845bdb5/coverage-7.6.9-cp313-cp313t-win32.whl", hash = "sha256:5e6b86b5847a016d0fbd31ffe1001b63355ed309651851295315031ea7eb5a9b", size = 210646 }, - { url = "https://files.pythonhosted.org/packages/26/74/b0729f196f328ac55e42b1e22ec2f16d8bcafe4b8158a26ec9f1cdd1d93e/coverage-7.6.9-cp313-cp313t-win_amd64.whl", hash = "sha256:97ddc94d46088304772d21b060041c97fc16bdda13c6c7f9d8fcd8d5ae0d8611", size = 211815 }, - { url = "https://files.pythonhosted.org/packages/93/fe/8873d88999b8e4b0d8150df554d72d6943b3938bba328fcb5422572cfd84/coverage-7.6.9-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:adb697c0bd35100dc690de83154627fbab1f4f3c0386df266dded865fc50a902", size = 207022 }, - { url = "https://files.pythonhosted.org/packages/23/c1/5dc48dfe3714a6ae9d2cd128a9df39570e46d3831f19a9be84011e767209/coverage-7.6.9-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:be57b6d56e49c2739cdf776839a92330e933dd5e5d929966fbbd380c77f060be", size = 207458 }, - { url = "https://files.pythonhosted.org/packages/e8/08/5644e101c823f0b18aa5c408037c2438fad05e6eb9f9e6581459aa0bfb92/coverage-7.6.9-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1592791f8204ae9166de22ba7e6705fa4ebd02936c09436a1bb85aabca3e599", size = 235494 }, - { url = "https://files.pythonhosted.org/packages/b2/02/995c019c0a2d70188d4d8184a0376eb28fcfb759981bb0e9961b463344fd/coverage-7.6.9-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4e12ae8cc979cf83d258acb5e1f1cf2f3f83524d1564a49d20b8bec14b637f08", size = 233416 }, - { url = "https://files.pythonhosted.org/packages/eb/d3/48ce8c9a89c7013f89ec7e01402e7a136a2e849c8f8664ea7f17b225295c/coverage-7.6.9-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb5555cff66c4d3d6213a296b360f9e1a8e323e74e0426b6c10ed7f4d021e464", size = 234546 }, - { url = "https://files.pythonhosted.org/packages/20/d2/11ac147bd76cc5d8a6254c9a9b6beaab51c3532ba0abdfaf669bf48d2c67/coverage-7.6.9-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:b9389a429e0e5142e69d5bf4a435dd688c14478a19bb901735cdf75e57b13845", size = 233655 }, - { url = "https://files.pythonhosted.org/packages/18/cb/6e35c5766041737f14c31ad02b5404ae6ec05d4e17ccffd69f6d99431e0a/coverage-7.6.9-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:592ac539812e9b46046620341498caf09ca21023c41c893e1eb9dbda00a70cbf", size = 232145 }, - { url = "https://files.pythonhosted.org/packages/ff/62/5de767f225e09ce959b71d1f3efc9e86e1c3de1fded85886bf705248905d/coverage-7.6.9-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a27801adef24cc30871da98a105f77995e13a25a505a0161911f6aafbd66e678", size = 233131 }, - { url = "https://files.pythonhosted.org/packages/65/72/bacb4b4c9da226e2343aa4bfebcb2bc008eda2f28aa913474aef27bfc397/coverage-7.6.9-cp39-cp39-win32.whl", hash = "sha256:8e3c3e38930cfb729cb8137d7f055e5a473ddaf1217966aa6238c88bd9fd50e6", size = 209735 }, - { url = "https://files.pythonhosted.org/packages/f4/4d/096d19dbd8998c9aaf8798078dd884f65652eb891fe7b0e657b5ac07411d/coverage-7.6.9-cp39-cp39-win_amd64.whl", hash = "sha256:e28bf44afa2b187cc9f41749138a64435bf340adfcacb5b2290c070ce99839d4", size = 210517 }, - { url = "https://files.pythonhosted.org/packages/15/0e/4ac9035ee2ee08d2b703fdad2d84283ec0bad3b46eb4ad6affb150174cb6/coverage-7.6.9-pp39.pp310-none-any.whl", hash = "sha256:f3ca78518bc6bc92828cd11867b121891d75cae4ea9e908d72030609b996db1b", size = 199270 }, +name = "bleach" +version = "6.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/3c/e12ac860709702bd5ebeb9b56a4fe334f1001246ee1b8f2b7ee28912df7d/bleach-6.4.0.tar.gz", hash = "sha256:4202482733d85cedd04e59fcb2f89f4e4c7c385a78d3c3c23c30446843a37452", size = 204857, upload-time = "2026-06-05T13:01:13.734Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/9d/40b6267367182187139a4000b82a3b287d84d745bccd808e75d916920e9d/bleach-6.4.0-py3-none-any.whl", hash = "sha256:4b6b6a54fff2e69a3dde9d21cc6301220bee3c3cb792187d11403fd795031081", size = 165109, upload-time = "2026-06-05T13:01:12.504Z" }, ] [package.optional-dependencies] -toml = [ - { name = "tomli", marker = "python_full_version <= '3.11'" }, +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "certifi" +version = "2026.7.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" }, + { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" }, + { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" }, + { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", size = 184933, upload-time = "2026-08-03T21:20:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", size = 185002, upload-time = "2026-08-03T21:20:52.173Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", size = 209919, upload-time = "2026-08-03T21:20:54.783Z" }, + { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", size = 208529, upload-time = "2026-08-03T21:20:56.066Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", hash = "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", size = 177683, upload-time = "2026-08-03T21:21:14.901Z" }, + { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", hash = "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", size = 187897, upload-time = "2026-08-03T21:21:16.108Z" }, + { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", hash = "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", size = 182935, upload-time = "2026-08-03T21:21:17.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", size = 188464, upload-time = "2026-08-03T21:21:01.163Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", size = 188262, upload-time = "2026-08-03T21:21:02.382Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", size = 211520, upload-time = "2026-08-03T21:21:04.863Z" }, + { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", size = 210673, upload-time = "2026-08-03T21:21:06.223Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, + { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", hash = "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", size = 182707, upload-time = "2026-08-03T21:21:11.226Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", hash = "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", size = 193772, upload-time = "2026-08-03T21:21:12.39Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", hash = "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", size = 186360, upload-time = "2026-08-03T21:21:13.636Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" }, + { url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a0/47b18adeed31c8f16ba9700f32c1b18594cfa09f47eb672a488c273c22bf/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893", size = 262222, upload-time = "2026-08-15T08:17:14.571Z" }, + { url = "https://files.pythonhosted.org/packages/38/fe/341861ac118dae06f3ec0eb487488af52128f2ef2faf0b11003944d22259/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0", size = 258951, upload-time = "2026-08-15T08:17:16.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/89/bb5108dc6c3651dca963f2b0a3ba19bbcb370c94e1b6d3e0e844a58e6dca/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08", size = 248801, upload-time = "2026-08-15T08:17:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ba/ef83ae3aca816393decfa3530976f38a79812d707b80b580ac33b83f9877/charset_normalizer-3.5.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada", size = 244070, upload-time = "2026-08-15T08:17:19.191Z" }, + { url = "https://files.pythonhosted.org/packages/f6/0b/c5292a2462d69b7378ea89793bbb5b2b6fcf6f7dd6d1667f9619094ad553/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9", size = 240110, upload-time = "2026-08-15T08:17:20.547Z" }, + { url = "https://files.pythonhosted.org/packages/46/22/111e5be3b740d5c2a5bfcedb3d237b6591e5c2e82ae9d6ffcb121fe0909c/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e", size = 232836, upload-time = "2026-08-15T08:17:21.895Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d2/d2aad6fe0dbb44b194bf3becb60f5a0ac48446ade999a47fe7bb41eb09a7/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6", size = 262712, upload-time = "2026-08-15T08:17:23.727Z" }, + { url = "https://files.pythonhosted.org/packages/35/5a/337e4663a5eae6de99db940ee8066d4145caafb61327db62deda15313cce/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf", size = 242977, upload-time = "2026-08-15T08:17:25.157Z" }, + { url = "https://files.pythonhosted.org/packages/ca/85/f82f8a92e31c7519410e2e1afdc630f28ec47490ce2c09a11c1a43cbb459/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71", size = 260207, upload-time = "2026-08-15T08:17:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/b7/52/643d11ffd60e9ac2fd1fb87e167a19285b9eefeff4a40e63c87cbfbeab36/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573", size = 250562, upload-time = "2026-08-15T08:17:27.971Z" }, + { url = "https://files.pythonhosted.org/packages/62/16/46556278c2168d12df9da7fede5dc6fc70e60301b26a82bbeec238c9cfe3/charset_normalizer-3.5.1-cp312-cp312-win32.whl", hash = "sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2", size = 178507, upload-time = "2026-08-15T08:17:29.277Z" }, + { url = "https://files.pythonhosted.org/packages/9d/7a/4c6c298171e6b3e745633180ff59350fc0ca0db1ffd28df1e369e0579f71/charset_normalizer-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2", size = 200551, upload-time = "2026-08-15T08:17:30.668Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d7/eb95a042f0dd22e304b0b6472b154f3546a1a039a9ee89ccb2a7f61591fc/charset_normalizer-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a", size = 180700, upload-time = "2026-08-15T08:17:32.028Z" }, + { url = "https://files.pythonhosted.org/packages/bc/61/2cb6ad133dbbb449fa2d37ccae973232f4827e799af258d15e589a3d1e9e/charset_normalizer-3.5.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9", size = 211584, upload-time = "2026-08-15T08:17:33.597Z" }, + { url = "https://files.pythonhosted.org/packages/18/57/a305c968be1ca13f3dd1b32f445877e97addf55d80b65c7cb35fac82b777/charset_normalizer-3.5.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491", size = 223359, upload-time = "2026-08-15T08:17:35.022Z" }, + { url = "https://files.pythonhosted.org/packages/09/0a/d3646670292ce8d8f8cc11ac067d44885e697a5591f57a9221128da5e7b3/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7", size = 194464, upload-time = "2026-08-15T08:17:36.452Z" }, + { url = "https://files.pythonhosted.org/packages/de/93/d51ec556e01042fed6f993ea859311bc7917b466684182fbbceb6ca24762/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e", size = 197676, upload-time = "2026-08-15T08:17:37.819Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a0/562247944386f7d4ef94467e84876600cc1e0f1b93239aaa9213d2bc3cbd/charset_normalizer-3.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d", size = 340473, upload-time = "2026-08-15T08:17:39.303Z" }, + { url = "https://files.pythonhosted.org/packages/31/e7/1d994be1b93d41e9502b8b0460eaa88a1dd8df335df415db87d6c3e91ab2/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a", size = 240156, upload-time = "2026-08-15T08:17:40.66Z" }, + { url = "https://files.pythonhosted.org/packages/09/53/27923ce5cc6cbccb832037b27dca98882d9c53e9b69e866bbbef4aae7fc8/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe", size = 228246, upload-time = "2026-08-15T08:17:42.003Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5a97e84d63af1d55c07439cb80e56d99a8efb4295700eb4e18c0d1615d2c/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac", size = 263660, upload-time = "2026-08-15T08:17:43.627Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c2/071575791dcc88316c0a9a65ce38897a82e4cfe4a325f0f7fe1b1ac47bcf/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e", size = 260354, upload-time = "2026-08-15T08:17:45.094Z" }, + { url = "https://files.pythonhosted.org/packages/fb/af/63240b0c0248c075c2535a1f1bd992821d8251b9f173abc13329661d09e4/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3", size = 250638, upload-time = "2026-08-15T08:17:46.496Z" }, + { url = "https://files.pythonhosted.org/packages/4d/66/70dfad64f15be09c15ccfee81330a7e515895dbe296dd23114e9a231268a/charset_normalizer-3.5.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876", size = 244583, upload-time = "2026-08-15T08:17:47.963Z" }, + { url = "https://files.pythonhosted.org/packages/c0/24/ef36367d38b9ddd4bccbf72888c342e8de1f5ae506fa0b2dcf970e2732a1/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6", size = 242038, upload-time = "2026-08-15T08:17:49.481Z" }, + { url = "https://files.pythonhosted.org/packages/db/ab/55e683ba0fff2e43adafc10daa3001eac90fdaa419a97227d5a7067eedde/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2", size = 233677, upload-time = "2026-08-15T08:17:50.845Z" }, + { url = "https://files.pythonhosted.org/packages/bd/67/0f40eaf8d1b6e7cf15e82382a2965efaca787fc1c2794b7021d37aaf5036/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591", size = 264491, upload-time = "2026-08-15T08:17:52.61Z" }, + { url = "https://files.pythonhosted.org/packages/5c/64/12b4c2a11ee8df4fcc518c78b0d93e3a92bd3d5253d1617ce74ff0e8c7ef/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c", size = 245196, upload-time = "2026-08-15T08:17:54.023Z" }, + { url = "https://files.pythonhosted.org/packages/37/2e/651d910af6d0fba325eee1cda37ec5443462ed25360e666c144166eb6091/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c", size = 261660, upload-time = "2026-08-15T08:17:55.491Z" }, + { url = "https://files.pythonhosted.org/packages/90/c6/b09e05e6db7f64338e0dc067c79577b1138da86c1e38369096851d96be88/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f", size = 252618, upload-time = "2026-08-15T08:17:57.025Z" }, + { url = "https://files.pythonhosted.org/packages/76/4e/362d4f9fdcdf5556fb2aa3ce7d4a58ebce03ed1ff03aa1d9aca8d02f13f3/charset_normalizer-3.5.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4", size = 140362, upload-time = "2026-08-15T08:17:58.425Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d4/703be739b26acce318bd29eb3b25b7209e1b1f527f9eae3d1f1f01fdde2b/charset_normalizer-3.5.1-cp313-cp313-win32.whl", hash = "sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3", size = 177755, upload-time = "2026-08-15T08:18:00.037Z" }, + { url = "https://files.pythonhosted.org/packages/8a/33/56d97ade41c8db611e727168c52ae46c9224c362ec28d4b65d7e9869e8da/charset_normalizer-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6", size = 199295, upload-time = "2026-08-15T08:18:01.506Z" }, + { url = "https://files.pythonhosted.org/packages/5b/75/5b20dd1e6573a01a08158fe104104fa2c8abf941745596954185726cd46c/charset_normalizer-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0", size = 179856, upload-time = "2026-08-15T08:18:02.929Z" }, + { url = "https://files.pythonhosted.org/packages/29/cd/2b812ce5e888f1ce69a5350281e58aab07ae64a958ecae8912f30865718e/charset_normalizer-3.5.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:774d157f112367ff4abd29019f38f023c24e00e56edc7829c20e358a5a913ad8", size = 212318, upload-time = "2026-08-15T08:18:04.403Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4a/a6ee107430768a5334e6d63f31f148a04a1a491ef161a1ac9415a73f2fa8/charset_normalizer-3.5.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:26422d45fd13551cf564c58932f7d72b4f58b93b0fcf18c35ba6be12b46bb102", size = 224897, upload-time = "2026-08-15T08:18:05.997Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d9/35ae3f64f29d0179c35c3baefe575904df2913dde519129c7f75995a2b1d/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:09a7bba9f739468c8e78c36a75c33768e53cb1959fc638f510454c14683f00d5", size = 194848, upload-time = "2026-08-15T08:18:07.397Z" }, + { url = "https://files.pythonhosted.org/packages/74/76/f2fc7380f056cc273a53af37f50d08ad54b2c59f61078f31432edcf1c2bd/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c9548dc78002099910abaebc0a72ac58b7d30931869e0351c09b507dff4ece3", size = 198163, upload-time = "2026-08-15T08:18:08.989Z" }, + { url = "https://files.pythonhosted.org/packages/e9/40/095ce62fa078483cccc1fa2b36e6bc9580b85422a20ee9f925341c50e44f/charset_normalizer-3.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c428c6c31eb5f4277d7f8eccaf767fbd548ddd5ce3c8b4f4cbbfab3d96b5904c", size = 341823, upload-time = "2026-08-15T08:18:10.458Z" }, + { url = "https://files.pythonhosted.org/packages/f1/5a/0e58b1c04a1596e0256f407274a92d5fb2ee21324409d1fab1da48a65b5b/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f06b7eae9dbe77fe1d644ca244dad508de8d302870a43f3c559b521270938a0", size = 242458, upload-time = "2026-08-15T08:18:11.989Z" }, + { url = "https://files.pythonhosted.org/packages/22/95/b4618ce912e6db0b1aae89ba788e38e8a7eba0f3025cc66e8c0699f977b2/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b7430cf5728e68f6c462254009a6ef4086e1bea43cf2f57aa9c55fb4f50ff96", size = 226717, upload-time = "2026-08-15T08:18:13.401Z" }, + { url = "https://files.pythonhosted.org/packages/8a/76/c681192bbda3d55356db5dadd64381d5202b37c6b598fcda5282e88b5d3d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab743e9bc90c1f73552ec33e10e3331315acd2c397b36065b591b0181de533cc", size = 266111, upload-time = "2026-08-15T08:18:14.961Z" }, + { url = "https://files.pythonhosted.org/packages/88/be/55127bfca72c0cff6c022488d140d7c5b04c771e3b72e9bdb4836d54979d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6f7deae3feb4edfa2efaf7c574fe88cbf055038a6abdb40188e4fff66d5699f", size = 263128, upload-time = "2026-08-15T08:18:16.515Z" }, + { url = "https://files.pythonhosted.org/packages/e0/91/39c3af510b0aa32bbda03374259200f28430febfd1bf5e511fe765282ce5/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15f024313246a4ed976c60f440bb8d257815513a681d212ff74fd46f7d715a90", size = 251240, upload-time = "2026-08-15T08:18:18.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a5/cbe418bbc6ecdfc3e05a0116002897c4b403a5e838d697e64c78e9f0190d/charset_normalizer-3.5.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:823f82903d189af463d7df250ef1f7f696f3cee08cc8d91deb565e8d425f6506", size = 245282, upload-time = "2026-08-15T08:18:19.625Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a4/689bb42e8e7cd492f3cb64907c6bc00ad247ec9a3628cd3f8eed126e8ae1/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:01e93745f7f219b703b60ba7afead36cfc4242782be5af484673fc500df12da5", size = 244597, upload-time = "2026-08-15T08:18:21.121Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ce/9962938e179cf9f699d3f1e7b3114b5d7642dee6a893745229f9dd04f274/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:329fc3ccb63ad22d867d84c2adea759a64079a37ba4a343433b02c7a2816871e", size = 231376, upload-time = "2026-08-15T08:18:22.57Z" }, + { url = "https://files.pythonhosted.org/packages/85/54/46000450ada53bd9eac5429a2c8c54cd2d9b39c0c255f229aea9af0948a5/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bb57753e36e4855b8ca375069482250a6246372331a3e4f3407eaebb007443f5", size = 266715, upload-time = "2026-08-15T08:18:24.235Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/618749d70f792b44252a777bf89bfb86823b9bbc1ea13fe8ce759b07f38a/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fce8cbd4997efeb450bd298b54f755dcdff18d496f7a5ddbb4867c6d7c88fdc3", size = 245848, upload-time = "2026-08-15T08:18:25.726Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3f/ffb64458527c7668031d5eb095d978de561958dc9f5b53f8e488a533e603/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6c9cdde8becb25a7fde49924511aa2644d6f8081cc8df8e9452724303348d8e3", size = 264521, upload-time = "2026-08-15T08:18:27.193Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ab/74a55fd803916a35ac461daf002708191aac19b546b80dc8cabfedc63d98/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9ac4444d8d4fd4c4bd08bf451ed3167aa9e7ec6cdb41b648794f1d1103652e36", size = 253054, upload-time = "2026-08-15T08:18:28.568Z" }, + { url = "https://files.pythonhosted.org/packages/a0/2a/6a9034b7d3c60b17499afb482df5878bf9fa20b50cc3887d5ef017a833db/charset_normalizer-3.5.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:f03ac127268b43ef4fe9e6ab6794a6794b49485a0cc0c1db79876d2f33f75bc7", size = 140580, upload-time = "2026-08-15T08:18:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/f3/46/1d362e1a00d035d66b9869e1281eee115907f7e390a16a07824ab5737360/charset_normalizer-3.5.1-cp314-cp314-win32.whl", hash = "sha256:1f5883d77fd409a261abb5dc8ccbe335720d798b1de4abb3b1d47ccbbc76b53b", size = 180325, upload-time = "2026-08-15T08:18:31.877Z" }, + { url = "https://files.pythonhosted.org/packages/7a/7c/4938c329b6a9d446f6a59aa2092ff7118f274209b5ed0e26893d1d30a63c/charset_normalizer-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:c658c50ac0c98cd755a2dd50b7977d3bca7df401dcc47fbdfa87db53ef7d4e8b", size = 204175, upload-time = "2026-08-15T08:18:33.466Z" }, + { url = "https://files.pythonhosted.org/packages/ac/33/eeb384dbd8dec570661354592f4f2e1b2fcc92585624d146a000caf53841/charset_normalizer-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:4bea7f8ebe90bbd7f0e4a2de42ca6924ba23e3e76418c408ff82f1d46fabd687", size = 184123, upload-time = "2026-08-15T08:18:34.913Z" }, + { url = "https://files.pythonhosted.org/packages/1c/6c/c73fa9d5a85f6ab05395de61c5f6984e0a9ff40bb5ff888d46dff02526c6/charset_normalizer-3.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fbc597639158fd7c14d55e808718848319540f51b0e6746e3eefa59723a4a348", size = 381682, upload-time = "2026-08-15T08:18:36.349Z" }, + { url = "https://files.pythonhosted.org/packages/30/c7/63565f860921457feba93bae6c86fb7746deb4cffeed2f375cb845318146/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71c909f353863b2b89c83de2ebed71ea6d0df8a6ef65a128193c5e650766bef", size = 240826, upload-time = "2026-08-15T08:18:37.887Z" }, + { url = "https://files.pythonhosted.org/packages/06/ae/7ae8807410dfa33f8e6f1715740adeaafa8a816cc4cb33508f54b1f7c896/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7ac76cf9afd34929d76eb7fcb63be476a4853d8a96f0dcf2d0db68a0cbdf9885", size = 227861, upload-time = "2026-08-15T08:18:39.315Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a3/887c1642f0da26000b0e0652d91071113c0e72cea33952e225cf589f49a9/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a3a370082ce34d0612f421e15fe011c53bb1feff21a26d06ad4fb244dab5a375", size = 260758, upload-time = "2026-08-15T08:18:40.88Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/e6f5b9a3d0e55b0ef7505cd3765cdd48f22db89994c947b316f52f801fd8/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:256dd4d85d9e4dc595e2bc983c980e73f62ddeb3165c58b4c3dfe78c5c8548c1", size = 259950, upload-time = "2026-08-15T08:18:42.351Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ee/e4e10a94d51cd1ee638aa7e00b65399e6b2a4e8376ab6d2eac9f95586671/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:58d4aa13a59c969dbfdf9e6a9560e242cbfd9e8a8f50c2747714df1a423adf65", size = 249329, upload-time = "2026-08-15T08:18:43.914Z" }, + { url = "https://files.pythonhosted.org/packages/c4/25/d5f4198819e6059735a84e8d0bfb72dc33976da67b97adcd3fb5a5e07ec6/charset_normalizer-3.5.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0c6dfb5ca6723eeed15aa8e564a014d69fcb8812f94eef11fe3631e0508199f5", size = 243137, upload-time = "2026-08-15T08:18:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/a5/e9/e925ca7569cf9fb9701fd82503fee73eea5268fdb856bdd64947092d3daa/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c010f5581d9c612804cc59fcf7b524b707fbcb72828551237ab545bb5c7034af", size = 242820, upload-time = "2026-08-15T08:18:46.842Z" }, + { url = "https://files.pythonhosted.org/packages/34/17/672c251a888ed2aebcdd2fe830ad0104e25ff83c43f5c4f9c15e9fc6853c/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:52ec005752a56ae79547a05c0139ca2501a0c866390b6115008456b9f0e7cde1", size = 230504, upload-time = "2026-08-15T08:18:48.353Z" }, + { url = "https://files.pythonhosted.org/packages/3f/fc/f6a85abebd42ce4da2f1db0aa56cc6a0df1995e318b3875d14401b8381d1/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2bced4061f000f7187254a02ad3433ae17eaf991747ceea2f478422590a5bba9", size = 263087, upload-time = "2026-08-15T08:18:49.859Z" }, + { url = "https://files.pythonhosted.org/packages/98/66/7c42677e739ba66746b297e2046918d793078094dc239e1e72768cffccc6/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9eea3ab2597a5e65fe65296e2d6a84570845a6b55532d90333d740d48bbc850a", size = 243269, upload-time = "2026-08-15T08:18:51.601Z" }, + { url = "https://files.pythonhosted.org/packages/de/d8/a50b79237f417af10f8c2a501ce8d1ca87829a22e69117891ca4ba20a69e/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:496846868fea80e479324862fa877f02411f2fd0f83b79ccee2607aa68b2a032", size = 258766, upload-time = "2026-08-15T08:18:53.23Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1d/0fc91aeaeb3c83b748f532399ce67cf84604b48297405d740000f7a9e786/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:85d5855daafc240cc045c026d7a15fd198a09b0fc8ff6f5ecbb5297b509cb11e", size = 250814, upload-time = "2026-08-15T08:18:54.768Z" }, + { url = "https://files.pythonhosted.org/packages/ae/10/3d8c777cf9024615295aa1b808324ad5b4a77855869c00824bad74ffaf8a/charset_normalizer-3.5.1-cp314-cp314t-win32.whl", hash = "sha256:58d3e12c88e0950bca850ae1f7c256055c097639c2edb9eb123af9807d8b15e4", size = 191074, upload-time = "2026-08-15T08:18:56.305Z" }, + { url = "https://files.pythonhosted.org/packages/4d/81/ae557d3c44d1a1d688696d60563413a0866a91b7ebc50f20df838be3d8c8/charset_normalizer-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:acaf604462bf330b0d07e7a07c1d6e4adac79e5fb13e9c5140590542cafacc00", size = 216476, upload-time = "2026-08-15T08:18:57.889Z" }, + { url = "https://files.pythonhosted.org/packages/27/e9/61c01fb8b804692569c036b3fc50495814502dcf13a60649c6055390b02c/charset_normalizer-3.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:fdb8a068947befafba9952162645dc2fecaeb400e64584829ed5e9b2fbe21a7f", size = 194115, upload-time = "2026-08-15T08:18:59.418Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4e/8544831ef59d8f27ce92c80871380fdacc8076a8a56ed62f82e54f991333/charset_normalizer-3.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9085f87b0e38a2b92b8923059b4e8789fe40d9279712d15dcc670048d77079af", size = 342048, upload-time = "2026-08-15T08:19:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a6/e3b46852424246065355644f4fb6dbccc0239a42a2eee27ecfc8957f0bcd/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2679de311c7946dde5d3b6f44941844133ff5c7cb86099c0061ab1e8901c20a8", size = 242997, upload-time = "2026-08-15T08:19:02.492Z" }, + { url = "https://files.pythonhosted.org/packages/03/3b/0cc9a26777334ab2f2e3089b948bbf4e4fe72ea70b897715ef6415043ec8/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:baf3775a2635e5a11fbd5e4e64ee69c7e86875d224a5c72aca4c141064589a90", size = 237014, upload-time = "2026-08-15T08:19:03.943Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c2/027335f0aa337a2a2e121bac1ad88c4f02ba6053ea0926802784f3db11af/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ac8c94b6539074e0f40899301273ac8402b9b3e01c7b7ba269ff30340aaaf20", size = 266174, upload-time = "2026-08-15T08:19:05.598Z" }, + { url = "https://files.pythonhosted.org/packages/86/d3/e367787febe4e74769dec0f406f2c3c8d1b955fce5aee1fd0f94e8367a45/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe532b3c966d1fb794e0698e4589d0444017ae77fc0b31edea13c0e35bcc449", size = 263361, upload-time = "2026-08-15T08:19:07.251Z" }, + { url = "https://files.pythonhosted.org/packages/af/3d/391b193eb9f3e84b02f9314088c386debdc0debee843535aaea2e2c6715d/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5c84bec0ab5ae0c64bfe73a7d2adcb5ce73b467523fc27fd6a28ab2aa6cbe35a", size = 252143, upload-time = "2026-08-15T08:19:08.816Z" }, + { url = "https://files.pythonhosted.org/packages/2e/57/de221f1745a90d418199761967e2776bfe2c275a1194220985e8c1d37833/charset_normalizer-3.5.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:854066be00447fa8de2ccbbe893e2ffc4b123ef16d897af794c1e18bd4a714b0", size = 252086, upload-time = "2026-08-15T08:19:10.255Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e3/d119f86a01f9331e8186175f24873b1d74a7ee9e2e4b4d68f9947dae5afd/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:21b82d8082f6f5e7f456ef0bd16323d08de1266efbfeb476e64b2a91d1471a4e", size = 245231, upload-time = "2026-08-15T08:19:11.807Z" }, + { url = "https://files.pythonhosted.org/packages/26/de/d8e48c135ae480879539cdb179c8d3b50c7879497d75dd899b5763b69cee/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:838648accb3a7fd9803fd45c87bce8509648eb0c11bc34e216141300977244f2", size = 241546, upload-time = "2026-08-15T08:19:13.416Z" }, + { url = "https://files.pythonhosted.org/packages/67/c4/217755fd1abc50d326c252922cd642002758095a81ff45010337b8b3ef65/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:195ce897c6153c0700078142cf8efe3e6454ca4cf4357499e4078dfd83396626", size = 267033, upload-time = "2026-08-15T08:19:14.981Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d7/34d8e404e358d2adcc5a228c2134643af00104c8fb0bf525f3688d756f05/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:978eab16f55b4ab2c2a745be9a0a840bf8f09a7f227d9c76eb30214d078865a5", size = 252045, upload-time = "2026-08-15T08:19:16.618Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fa/40414471acf0aa0692ca77305aa00e434fcd8288f0941c93c30e9a5f8f2f/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:cc0329df4caaceb950d2f580b5ac716a377f7059624a0bafaeaf8a218c6ed774", size = 264866, upload-time = "2026-08-15T08:19:18.101Z" }, + { url = "https://files.pythonhosted.org/packages/32/90/fcc850bae791abd2e0c041847f13e270aa08692a79f3e00de6d2dce1cb50/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:687c9ca3035544b113bea2055e180af96fb63c0c476e22a9180f51925186e7b7", size = 253932, upload-time = "2026-08-15T08:19:19.734Z" }, + { url = "https://files.pythonhosted.org/packages/af/af/53afe99068b3c10b4cbae592a52ef72a7c92c0188440e83ee3a078fd8f75/charset_normalizer-3.5.1-cp315-cp315-win32.whl", hash = "sha256:706bfd38730a5ac7a365793269a00f4e988178cec121391f4248d84ad8c972e9", size = 180320, upload-time = "2026-08-15T08:19:21.37Z" }, + { url = "https://files.pythonhosted.org/packages/c9/bc/f46a132041b29e4a8779ed712d3df1bf112e94ca8de58b66d7ec2c0cf8b9/charset_normalizer-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:92caef967d287a407085d61176fce4012b1dd62daed4eb6d5ceb26d3d2538712", size = 204174, upload-time = "2026-08-15T08:19:23.088Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5d/9ed554480eda8e447b673648628fdc29574d23dbad01fe11837adedd1cae/charset_normalizer-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:5fc45d653ea8c9a20479167e11d4a0f8cb2fa3470737ab6f9c827532313187b7", size = 184126, upload-time = "2026-08-15T08:19:24.471Z" }, + { url = "https://files.pythonhosted.org/packages/3b/32/9b8929bf384061ee1fe5d9c27c6f9776d3d824039ad4e14c88ec00c7808e/charset_normalizer-3.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:59171c6e45bf07d0d5cab3b0bf81d945035530f6873398b3b531c31184d46663", size = 381441, upload-time = "2026-08-15T08:19:26.038Z" }, + { url = "https://files.pythonhosted.org/packages/96/10/e9aa7923d3ddac652c99a1c5f7be494e737e151566a44abe018daf757f2c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dbdd9205662134957cf0c324f639bdc5031c0ca056e2369e238db75187c0f11", size = 241742, upload-time = "2026-08-15T08:19:27.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/53/a2d249ebddf47b889a100c0bdcb61a2f9dbb8bc24ef325cc062e4f476877/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e4b018dc5a0eee4676e38fe84a47a427816c590b93b55d9025274ec4d6ffc2dc", size = 235298, upload-time = "2026-08-15T08:19:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/7d/07/469f78af590f7d5cd48e20d8dbfa3d66deeff9ba37768c04d886b5afd45c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced3fdd71aaa83ce593746c2edb42b7a59cb4c19c8b5c407781c72e493aae55a", size = 262500, upload-time = "2026-08-15T08:19:30.955Z" }, + { url = "https://files.pythonhosted.org/packages/55/66/3bb56a47f7dcba014055b1a1d33c6f08bbe9c1e74dba154cfa25f90ae885/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:19a3dd5aa73cef1c99687c4fc57db016a9c17104ae1185da88ba566a5d3bebe4", size = 258888, upload-time = "2026-08-15T08:19:32.458Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c1/2adc2800903fb013210349313b710a5376856578d9e33e6b9a1d8b36714a/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc5d36d96478aa9c60654bd932525bf32964c62a7281eafdf16d85003a8d6004", size = 250243, upload-time = "2026-08-15T08:19:33.94Z" }, + { url = "https://files.pythonhosted.org/packages/95/b5/a18d0dd1157ab655cc2cb14a545f4a4784bbad70ab3502412e36097502d9/charset_normalizer-3.5.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04368edf83514385ffc3e1cfd4546e595f4f1272dd23ba437a93a9cc3741d47b", size = 249871, upload-time = "2026-08-15T08:19:35.413Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c3/525f508cd1e58d0450ac55ed40ac75bc3a97482c59def5278456a5fbf03c/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:9b5db6052055d34d41230fb78d7c439c23dc536a9896f6cb039e8dd92cfc1263", size = 243580, upload-time = "2026-08-15T08:19:36.886Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/49a91fe7e97c8140094ca5c64161ab623a70d9f636bf834eace14048acb5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:252d099029bcbea642f2a06c4ed5046bdf8b5a8150b64afa5e027e88b106e5ee", size = 239807, upload-time = "2026-08-15T08:19:38.392Z" }, + { url = "https://files.pythonhosted.org/packages/d3/58/56a48c296601274c4689b864a8e2dfb209b81dfcb39472753ce95eea662b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:6199d5606e2bbf2b096cf64d03f8b6790c91081d5ac866b8e7bb6422738cc60c", size = 264083, upload-time = "2026-08-15T08:19:39.856Z" }, + { url = "https://files.pythonhosted.org/packages/10/4c/dc48409274a1817ff349711d26c62aa0c597df865d4d69ef79160c859193/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:77efcff2b23071c349402ac1066667a3d011f62398d81408c9b88ad991747c9e", size = 250317, upload-time = "2026-08-15T08:19:41.53Z" }, + { url = "https://files.pythonhosted.org/packages/81/58/d325912115caec62d6bdd77bbab5e0b7da5d234a9f20affdffcbcb530d0b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a5cbd90ecf0fc62e64726917ad083b73001f0563657a87ec3c0b504e277dc90d", size = 258173, upload-time = "2026-08-15T08:19:43.07Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/b13b1ccae2c8ec63980d13be1890eb73f8aeabbfce02a24aabc0908788f5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4d26f14f041e83dd8edfd61f4cd4fa7285d31798b5bf1f28e70c367ba6c41d61", size = 251960, upload-time = "2026-08-15T08:19:44.587Z" }, + { url = "https://files.pythonhosted.org/packages/1e/25/ed3f9919c5aef8cc818be1f972f565f7610d7b2076b8ebb98839516ffc3c/charset_normalizer-3.5.1-cp315-cp315t-win32.whl", hash = "sha256:ac13b004224fb341e1e25a1ed5e19d32f57cdb2a403e01f003b46f051a550f6f", size = 191186, upload-time = "2026-08-15T08:19:46.293Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/43c2b3e9d8267092b913eb8b0603f0f71993c395632886bd37a7223f96cf/charset_normalizer-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:35aea775dc2bd5f54cd84a1cd2696cc3207c479cb9cf0bd346f0d343e4300ddb", size = 215947, upload-time = "2026-08-15T08:19:47.853Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/9aad3e9c8865e5e0efa9a7f6f81c37a67635a985145ecd44528a81e088ee/charset_normalizer-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:fb78f6e7fcd8ad785d28cd577168bc1aaee827b25bb8755638f694794ea98f0a", size = 193909, upload-time = "2026-08-15T08:19:49.383Z" }, + { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" }, + { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" }, + { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" }, + { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" }, + { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" }, + { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" }, + { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" }, + { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" }, + { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" }, + { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" }, + { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" }, + { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" }, + { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" }, + { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, +] + +[[package]] +name = "coverage" +version = "7.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d1/f5/deb1a27aa20746c0278ac998c4179e272004699b2d33959ce020c5ac1615/coverage-7.16.0.tar.gz", hash = "sha256:077f0964087883176ff6ab9b074694cae29f8c708273b13ca62c183c6ed716cd", size = 945620, upload-time = "2026-08-28T21:54:37.74Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/9c/8d2688694f53dc0b0f0e4783c7eb3c4bb1e79beaf1411879f6dabedf4607/coverage-7.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d1c77c3579ac42798f8b7eed6d3dd258debacca32c8753fc8a1f6eaf1db644f5", size = 223194, upload-time = "2026-08-28T21:51:27.767Z" }, + { url = "https://files.pythonhosted.org/packages/ca/11/f002163dd688aa3fa49ac6a424b7c2705c7fcf80fba18ec9f586d77827ca/coverage-7.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1f81cb1554c3712e41649ed5dc98656b50b958e4da12f0f5adb681ce3db92831", size = 223553, upload-time = "2026-08-28T21:51:29.46Z" }, + { url = "https://files.pythonhosted.org/packages/81/65/f9d469e97c4554372a710650a109004a2434dfc56f577142e5d6057fa0cc/coverage-7.16.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e701938ec9081d3e400a0c9a9a8ae0f7ca44214741daeac4454b1c6ef6dbd19", size = 255054, upload-time = "2026-08-28T21:51:31.54Z" }, + { url = "https://files.pythonhosted.org/packages/95/29/dd89fd39af1a3b6e9a9c3eddeaf03f6376ba517d43d6cbf8b519177e2a10/coverage-7.16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:719a3feb6220dd32ed932d4c3676d17fb8739e2643b29c0e7c3af400ff80ac44", size = 257790, upload-time = "2026-08-28T21:51:33.374Z" }, + { url = "https://files.pythonhosted.org/packages/0a/64/208d26cedc525d6b5db9c492cf9130784c42d9eb08d22badaa7b806005ad/coverage-7.16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:87771ecf986cff55e87413238cd5e4f54d949c2074bd6fc1657d26a56314ee24", size = 258904, upload-time = "2026-08-28T21:51:35.096Z" }, + { url = "https://files.pythonhosted.org/packages/1f/98/28e2752aa9a8baee5798edade9c95602ca200f4e7eeb503eb64df42e5921/coverage-7.16.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:47d5e1fc0b321c8308a2aacee0497c435b08acaa629b7059798fdf6fc3006352", size = 261165, upload-time = "2026-08-28T21:51:36.744Z" }, + { url = "https://files.pythonhosted.org/packages/eb/77/fa6ae699a0ea2bc12acb38a85d96b786fea0f833c12b5756056350e0e547/coverage-7.16.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01b18b8a6c9cec8d5f45550e2501426ed982cf2c35016b0acd2ba9b5d8b2fb06", size = 255416, upload-time = "2026-08-28T21:51:38.495Z" }, + { url = "https://files.pythonhosted.org/packages/89/c8/5ee46d1de7d34cb00ba08b5c50da1971114dbc09ca9898ccc32975ec74dd/coverage-7.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:32c56b5b47c50635081445ac404dd08c2d591b9c837c22570aa9e182c3b42cd4", size = 256825, upload-time = "2026-08-28T21:51:40.27Z" }, + { url = "https://files.pythonhosted.org/packages/15/f6/d59e1c0693ad48855fe20169fbf6ee5befefe5887a7fabf5f0bcb464a2dc/coverage-7.16.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6ad3bbad240ab937512156bc944fdee63ac4dd34a7558a3094548fd4c1150c02", size = 254970, upload-time = "2026-08-28T21:51:43.136Z" }, + { url = "https://files.pythonhosted.org/packages/df/7b/b51bbe05b3a7565927fccfb1be42b8b3c1f4ab15e53d91b303e9923969aa/coverage-7.16.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4c1f16d5555a195295d0dc9c902612270e3dfed6a11f3bf7bc470b7b6a79ed3c", size = 259039, upload-time = "2026-08-28T21:51:44.983Z" }, + { url = "https://files.pythonhosted.org/packages/fa/04/d513f816456a8a43c1859abe88a37d01d7d2515b6c3e24ebb3c9b1dd44ec/coverage-7.16.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:f6c9c21a8bf0d19788f3c5f3e020c90317a0a63ef60521b376003801e21250fb", size = 254539, upload-time = "2026-08-28T21:51:46.733Z" }, + { url = "https://files.pythonhosted.org/packages/dc/54/5542190ceb97e0d1333a4ce0c8f95b2ef2efe790f1ad018a4b61766f849e/coverage-7.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:06f20145a9eb5bf1fd1dde3c0bc2af2e7c22135ab07ca6284d6ada7cc3904c4e", size = 256410, upload-time = "2026-08-28T21:51:48.363Z" }, + { url = "https://files.pythonhosted.org/packages/ee/28/78643f361ff6bb5b2ade90f8bfc8395fe9ca367a18c101f8991215b4c65b/coverage-7.16.0-cp312-cp312-win32.whl", hash = "sha256:916cf8d25c1ce148f7eceb1d45afc9724841200110adc4e53250391852debd91", size = 225239, upload-time = "2026-08-28T21:51:50.22Z" }, + { url = "https://files.pythonhosted.org/packages/67/61/8e76b36c36b1a033dc933dd2480db96b04ce3be975793ce3fad122e7174d/coverage-7.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:78f8b56261d608be102c62edd3a60b66bcd0b581f3f86fdcabaf8b8d95adc950", size = 225775, upload-time = "2026-08-28T21:51:51.912Z" }, + { url = "https://files.pythonhosted.org/packages/c8/f3/bb4787a4b81c1792ca69b502f5f730dbbb609f73fed552ab074c6b92cb8b/coverage-7.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:577c2ac8c0036f6f8edd3a7783a9e67302b17771d1abf0fd2ed246e3158be51b", size = 225159, upload-time = "2026-08-28T21:51:53.667Z" }, + { url = "https://files.pythonhosted.org/packages/54/c5/e62c87f4799d1e3647d5b2ae16ea1d12205d72fde1ea8529e13fe050f678/coverage-7.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1545c52ce756b8a97007f439a220297f1cd72a2cbbcdffccdf1c1f70e74f9a42", size = 223215, upload-time = "2026-08-28T21:51:55.628Z" }, + { url = "https://files.pythonhosted.org/packages/89/e9/5e62fda9397175fb206f75368b6e85da06d831c181b6d0f67ca073cd2f89/coverage-7.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0598aadae641f30a0796b75b45c0b9c5de8619bd5cfb251bb0cc254e86e6dd13", size = 223585, upload-time = "2026-08-28T21:51:57.355Z" }, + { url = "https://files.pythonhosted.org/packages/b9/40/bede08621b1ba67e88c4d3336c22b52cb7911ff1fa4ef055344b6670e58a/coverage-7.16.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4080ad6bad9f14690e6b2104f5e8d137ccc65a4b5427a36662090637d4bd16d5", size = 254575, upload-time = "2026-08-28T21:51:59.233Z" }, + { url = "https://files.pythonhosted.org/packages/12/d8/ab0bdaa45dfd6b8cbf1a3ec548fdf827684b1997f9724375c5b3e89144fb/coverage-7.16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e9883a2f8206ce3af59117dc278e5d043fea06912bca3f199816129e5e2de354", size = 257172, upload-time = "2026-08-28T21:52:01.015Z" }, + { url = "https://files.pythonhosted.org/packages/1d/bb/135de81784bbd7dfedcab2b92b03d71d75b09b0815b42d6dabb052def5a6/coverage-7.16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:984e5430fc6f858385009e92549955157d79335b1f3e13e1031e0f89d1284261", size = 258410, upload-time = "2026-08-28T21:52:02.76Z" }, + { url = "https://files.pythonhosted.org/packages/ad/72/ce44ecc062fb2e43d9447bb76154d091c2139232f20c125297c4b58f4c6a/coverage-7.16.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b1374099dd1ad0d31fbb6c95d00a56a3c5e85fb3343dca14fc12f78323a2b42a", size = 260539, upload-time = "2026-08-28T21:52:04.821Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c4/9389c36a41e59406ca2bba493807c2294d2e5186a7e9ebcc2e63a0f2a711/coverage-7.16.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34d8686bce035c8465b318a8c2890e69ba14a00801a27f4eb6bdc97c23944d87", size = 254756, upload-time = "2026-08-28T21:52:06.68Z" }, + { url = "https://files.pythonhosted.org/packages/ad/0f/7762447b15e01fb84263608540123c4d9941f06303265ee74d801ccbec0e/coverage-7.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:857fceba6ff4b507ee0ad98798a33d544a8473df0c542bf04251ee4ed5ee6292", size = 256540, upload-time = "2026-08-28T21:52:08.529Z" }, + { url = "https://files.pythonhosted.org/packages/e6/fa/c60dc75a8346c1dbebebc7279b19971c88f70dd575f0bc10bc0cb16f92d5/coverage-7.16.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:bbf08d951abaa1ce89e28c998361d56b952413846b459cd017f116ad4c9adbfa", size = 254508, upload-time = "2026-08-28T21:52:10.323Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f0/4e0834f3a1fccaa8bf625a2a1d73bde0fa32577dc3249853c0dd0e7f2b20/coverage-7.16.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1a03e78f53e4d2ab13adac19958a89322d1829913e5623d642627bf60b35da21", size = 258659, upload-time = "2026-08-28T21:52:12.124Z" }, + { url = "https://files.pythonhosted.org/packages/b4/ec/fe712d3a11fd6e874565a5fa5497c48b8ece561d9611da040b44cdcf8386/coverage-7.16.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:dcd3dafcdd78305d27c59a1006b53a4990acb89e68d8fbe0992f4f83503c827f", size = 254326, upload-time = "2026-08-28T21:52:14.181Z" }, + { url = "https://files.pythonhosted.org/packages/e7/78/093e12072e01034c65ff380f76c74b79dd83e44fa92b689a2154389be734/coverage-7.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c1bcfe470a796fbea6234accd81d258a31574dc0b7bf569e16be757572c4de17", size = 256102, upload-time = "2026-08-28T21:52:16.003Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c0/265176117ca5d06e3f65575842884cdda96cf213350a31e9d41c80d65854/coverage-7.16.0-cp313-cp313-win32.whl", hash = "sha256:1420370276f1694b663207b8245c3628aafb9624fe3cebf313a13d860e55ee67", size = 225250, upload-time = "2026-08-28T21:52:17.82Z" }, + { url = "https://files.pythonhosted.org/packages/1f/01/8a87f2c04fde322430b45d16d8f543693e9894c5b2d2ca238a287c00beca/coverage-7.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:496277c8d7beed695e02c7be53516a0152e4caef8738a0feab6a638546cce449", size = 225790, upload-time = "2026-08-28T21:52:19.641Z" }, + { url = "https://files.pythonhosted.org/packages/23/40/c21feacd9edfe7063195bf9cc84d650e9938fc6a23063e4f027199b160e1/coverage-7.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:181c2906b9b3759955c1c33c51fbb91c754fbd0b82ea49e2c81061f5a052082c", size = 225180, upload-time = "2026-08-28T21:52:21.613Z" }, + { url = "https://files.pythonhosted.org/packages/ea/73/850675f262391b322c4c988b6cdc32cdc6629288f0fb158687b587a393a8/coverage-7.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:54b7fba6a74d010de34319a0419d5b65af8c00f539ad0b6f39fc6f342ab99697", size = 223258, upload-time = "2026-08-28T21:52:23.558Z" }, + { url = "https://files.pythonhosted.org/packages/61/c1/4f54c6d47c80d1cc58ef8fe6b74e6eb50f9e2c0f6e2de6cf38dbca2937b8/coverage-7.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fa4ff0b3dd52208d2b30903022d5087f82000507b504753dfeee83e4f32d6883", size = 223587, upload-time = "2026-08-28T21:52:25.627Z" }, + { url = "https://files.pythonhosted.org/packages/3c/be/298f2456230fb44e272a4e53a41b3f3c39f0821c242d7b7daa9787b4d6f7/coverage-7.16.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:35a9676bf86097f790113ebd9fb67681804ef54d40941d2f10ba68c02239e575", size = 254632, upload-time = "2026-08-28T21:52:27.689Z" }, + { url = "https://files.pythonhosted.org/packages/a3/9c/a1bda6439c19c4783d50df896142b67b9e7d432db36675d339a32778669d/coverage-7.16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f98d438add63546745e5e847192e3e9ab897ed6f2ca96f8281e2f5a15958ae62", size = 257139, upload-time = "2026-08-28T21:52:29.741Z" }, + { url = "https://files.pythonhosted.org/packages/f8/cd/cd735c9be757f97237c305f36897a5e5b348bdbc12ebed3b2b80060dd8a9/coverage-7.16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:151855767480be14db595cbc2040f6a4db965cdfeebd354d79b0256742b029e0", size = 258484, upload-time = "2026-08-28T21:52:31.68Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/84b2e1e8aae9db3f549782f28ce25bba5fd6a9c7bfba3782ffe8b4cd2559/coverage-7.16.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:183613f664718b340589d7f005c7e92b4b601cffd20a8a4117cfda3e983b080f", size = 260798, upload-time = "2026-08-28T21:52:33.642Z" }, + { url = "https://files.pythonhosted.org/packages/8a/4f/e04cf52483619a4dc5dd6367b30c9a8ac52243567fdfacec9b11a441565c/coverage-7.16.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:785b114356c99c0dd5b3f57b9696cfd57b7704f4c53847df8dc88c6cc0d9bcb6", size = 254612, upload-time = "2026-08-28T21:52:35.543Z" }, + { url = "https://files.pythonhosted.org/packages/da/33/627c4113f66bfffd43807f54dbf080c4632ecf12e4ef7a3bdd4ec38e46a2/coverage-7.16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:30f5aee6d1d517abcdfd4f9cad027969ff79a1440a22da263f9514e31b5b66e9", size = 256495, upload-time = "2026-08-28T21:52:37.485Z" }, + { url = "https://files.pythonhosted.org/packages/3c/38/aaca432f4e008a88f2bc4d1459aa7016d8d1bbbe801f7e4fa3cf2746557b/coverage-7.16.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:190ffa0f5af966254c249fb3aeaca2cef389785e3e287fd577d39e134d20f8a3", size = 254454, upload-time = "2026-08-28T21:52:39.425Z" }, + { url = "https://files.pythonhosted.org/packages/cc/db/8430aa87ef0a508f4c17c1b8fa7e0cf80231988d9081aa36c194036592d6/coverage-7.16.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0ccc37c00e1a5d30840902c54557e104d04aead872cedf6d2281c8725a467e06", size = 258728, upload-time = "2026-08-28T21:52:41.32Z" }, + { url = "https://files.pythonhosted.org/packages/76/88/cd8aa8c82493ffbd291d3ef5554452fffc634c6c6098a04ac848c79c98f3/coverage-7.16.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:6c60cde430c0e7e3be612973af39b4cff90ec2e2defe7b2b701daea3a0ffff04", size = 254271, upload-time = "2026-08-28T21:52:43.278Z" }, + { url = "https://files.pythonhosted.org/packages/a8/49/fe16c811ea9314a84b48f34e4bf5a3d9013091093b285a74b2272fc863d7/coverage-7.16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c5297028c8df849a61b29129cadfe682f90b5b396f528eb319a57d7678eefdad", size = 255927, upload-time = "2026-08-28T21:52:45.461Z" }, + { url = "https://files.pythonhosted.org/packages/d1/45/d0bd410e78cfbf768acc8099b335e1d5c0d5c26103c796d2bebdee001715/coverage-7.16.0-cp314-cp314-win32.whl", hash = "sha256:136988df5bc5a48795d9c42c75c4bbda5d9a78e750a080c1233010edff93a1af", size = 225424, upload-time = "2026-08-28T21:52:47.658Z" }, + { url = "https://files.pythonhosted.org/packages/17/78/1ce6ce4646822e9308dcdb1942eaf31bfd7da43247b8886338b0d6fe3767/coverage-7.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:ce2ba5e9f1842fe09165825abfb3bc6b527c71a27bc2eb3a10f2284ced64506d", size = 225918, upload-time = "2026-08-28T21:52:49.692Z" }, + { url = "https://files.pythonhosted.org/packages/f9/cd/e1323fe3a7dfcdd709451a43fe708ca1dfd36a7fc07b34eb7bd1dfdfb52d/coverage-7.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:a89d07e48d9baead9a15599923a02f62c6df6c3d85aa84ef34be3c9fd6aeb91f", size = 225344, upload-time = "2026-08-28T21:52:51.665Z" }, + { url = "https://files.pythonhosted.org/packages/39/fb/1c15460d4cf915f09ae3ad3862fef4f901838991c5641b0cec545050d810/coverage-7.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6e2854b62601c89a63814ad5def3b90d99c6724cc4cb977f75b725e5fca4b1e3", size = 223986, upload-time = "2026-08-28T21:52:53.572Z" }, + { url = "https://files.pythonhosted.org/packages/9f/73/347d2d0009ac211f79ee2a2364fd2aa19d6b9628dc22ed13a9b9386097ab/coverage-7.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f093faf23df888518d273be6da65f0ec5a25b5d8b670231e4d87de07361042e7", size = 224254, upload-time = "2026-08-28T21:52:55.59Z" }, + { url = "https://files.pythonhosted.org/packages/5a/2f/51442e6ad9d705369596f08496021647e276d5b57311818fd4312d93509b/coverage-7.16.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b7dbbbf6551eb94618e7bc76ab61cc2740a5b3d13294171bd6adb36e12346c3c", size = 265619, upload-time = "2026-08-28T21:52:57.645Z" }, + { url = "https://files.pythonhosted.org/packages/ea/8e/0f752276f6d13efbd019ab6d90792e20d6272c44cda039dc5c6d27b91e7f/coverage-7.16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:51e7d0e311d2fba3915f971236cbdd4ad821fc7a23988221c0b33c964b0eba22", size = 267734, upload-time = "2026-08-28T21:52:59.611Z" }, + { url = "https://files.pythonhosted.org/packages/fa/02/4df3baef8029881c9d1a380859f2be73f90080d430def567d182e8566a35/coverage-7.16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0bb04ee77e557d7476471969d35fbbfb5fc8a4152e9409aa5811780c36d9b23e", size = 270156, upload-time = "2026-08-28T21:53:01.658Z" }, + { url = "https://files.pythonhosted.org/packages/9f/30/ce10fdb74055ebbfb5c8a025d8845dc19c76e4b2c42bb5c755b56678990c/coverage-7.16.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c72c9b201dc0e8c2c8821d49858fd865010d08181bf877d2320971b6464ebfd5", size = 271279, upload-time = "2026-08-28T21:53:03.698Z" }, + { url = "https://files.pythonhosted.org/packages/71/19/c7e1fc9504d90da848493bad4018dd235c713a80633e48c5f0a41b63d45e/coverage-7.16.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0fca700cae4635656668ba6e2b66a85aac9f2622d7b2bcf82e844c409eaa1313", size = 264677, upload-time = "2026-08-28T21:53:05.741Z" }, + { url = "https://files.pythonhosted.org/packages/a4/f3/4021519dd41583ab396c81955387f927779641f6bac26818b6918a45aafc/coverage-7.16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:584896fb8b650e999e24ef57e9513e482c12f8e15a73ee9d4584e23c99465867", size = 267610, upload-time = "2026-08-28T21:53:07.763Z" }, + { url = "https://files.pythonhosted.org/packages/55/fc/df65aac93938d8f506434c8e96440c1d696f6be0a6a01d3c6bfe5d49403e/coverage-7.16.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:949eae7e0f562b1518355aaef4b03523e49a6d3fea12aa3542d9e36c863f8267", size = 265217, upload-time = "2026-08-28T21:53:09.786Z" }, + { url = "https://files.pythonhosted.org/packages/32/2d/dc9a5e62715165fcb4c715f965f411e324917c9daeddde16536e9d36ce3f/coverage-7.16.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:64f0611ee05364fc85cc3e5bc371804117a76fd337720e6017332fc7c534257a", size = 268948, upload-time = "2026-08-28T21:53:11.866Z" }, + { url = "https://files.pythonhosted.org/packages/8b/4e/fe73a5560f25fca52acda76fc1554f30de081793ae4de97e920f8ab161d7/coverage-7.16.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:050a291b3cfe5e0df5999ef2fa5a7aff6e2db329f069d47eb63f02bde2e7e96b", size = 264061, upload-time = "2026-08-28T21:53:13.996Z" }, + { url = "https://files.pythonhosted.org/packages/b3/f7/bb78cc4b97085ebbd77fa18cbc25abfab462814efa3e2363b4e50885c775/coverage-7.16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a336b1e2990a64f5c356a9b8380fb9c029d56c832b801255250c44d603271bfd", size = 266371, upload-time = "2026-08-28T21:53:16.233Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ec/84b4af5cd4ad498477b3bfb2217e47b048da919451053790efda66f7383c/coverage-7.16.0-cp314-cp314t-win32.whl", hash = "sha256:058631257350b31784ed43ceb808298b6f074edf4ebca4c7ce5082e6bf873a61", size = 225736, upload-time = "2026-08-28T21:53:18.632Z" }, + { url = "https://files.pythonhosted.org/packages/7e/43/50fc0e6c675c3ef14895a74bab2d6120cb5d6f4b562a3d3f5046797758dc/coverage-7.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:ed35097438dfa980c1ec75bc83edf8acbe7a374d7007e571957a257fbd0e2fb3", size = 226570, upload-time = "2026-08-28T21:53:20.754Z" }, + { url = "https://files.pythonhosted.org/packages/fc/24/9effce7bcd3c6eeb4da3561905837509e582dcdde7a7f07d6ef2c8512f76/coverage-7.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0466f4a5c0370461b7d8c7eb259d7d1db0b5756f13d66230b04d22a1d380ee11", size = 225879, upload-time = "2026-08-28T21:53:22.747Z" }, + { url = "https://files.pythonhosted.org/packages/4a/2c/318e4379106bc8047ba235e3732ddc87d1b393ac3db9776f5405ff14f322/coverage-7.16.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:80d7d5d744a041f08637df743ac086204ec5acbcd8432a42b00b49e607358024", size = 223257, upload-time = "2026-08-28T21:53:25.376Z" }, + { url = "https://files.pythonhosted.org/packages/81/4d/a5c54d9144e9db6505749758ba50a28be624148873751728a59cbb72d27a/coverage-7.16.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:c5feffce90c3d602e149de1c477578efc34dee5f069f9764cc15808ce01ee15c", size = 223596, upload-time = "2026-08-28T21:53:27.461Z" }, + { url = "https://files.pythonhosted.org/packages/bc/97/38e93a10899c9315964c0a4e729b3e5867f8f46e977808f9c6fbda52525a/coverage-7.16.0-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:acadbf2f2a18d7f9c7f119ac798c00c540d7c79c93abd71ed648c87891303633", size = 254699, upload-time = "2026-08-28T21:53:29.715Z" }, + { url = "https://files.pythonhosted.org/packages/fa/7a/acddda030b4630f68167f3daa94b41d22071847822a70d8178d43dcf678e/coverage-7.16.0-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4212cec9b42fd9929e70b462732fefd8b13406371871c82f3c14397499d6550b", size = 257614, upload-time = "2026-08-28T21:53:31.948Z" }, + { url = "https://files.pythonhosted.org/packages/15/7e/225b182497c1ce6d3f0d76a3074a4dbc9f272300e92bb100df53b03de0aa/coverage-7.16.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c5a43cc0ef101637ae920a9eed24cf0549ef815621eae68b3ad577ec5a7ad2f", size = 259236, upload-time = "2026-08-28T21:53:34.291Z" }, + { url = "https://files.pythonhosted.org/packages/2e/19/76641ddc50cb2410ebbd0ed7fe1052614d0e5612e802a2817521adb9febb/coverage-7.16.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c76a9b50a344261fe4a9bd20c322b48d3913cc48e8c37f78c21a596008296e68", size = 261433, upload-time = "2026-08-28T21:53:36.401Z" }, + { url = "https://files.pythonhosted.org/packages/12/9e/5f89de8b7c2017f36b68b4e4a25940723a748b21474820bf61e8bce0891c/coverage-7.16.0-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80cf547379ad6b1878fd03b033b51188beab4b41824c96e7839e014a4cb947be", size = 255182, upload-time = "2026-08-28T21:53:38.496Z" }, + { url = "https://files.pythonhosted.org/packages/1a/c1/ce94b2ec502e79775efb5efa22c741ebb0bd2be10bdd29650825ff57bdcb/coverage-7.16.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:4b1d09cb5d8dc2c7164450f5217e6f0717497de9c588806a0780d352abef904a", size = 257329, upload-time = "2026-08-28T21:53:40.87Z" }, + { url = "https://files.pythonhosted.org/packages/86/8d/3f5374df3a6ca19ee5f98a6bd21dbb05f1e9d399bd9978e9821d260eab5e/coverage-7.16.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:cd1e85abed2d2499c16664137ac802356316f92b4e2bf3c150bdf0c45f5dd9ae", size = 255210, upload-time = "2026-08-28T21:53:43.393Z" }, + { url = "https://files.pythonhosted.org/packages/8e/b8/1bc5751496d0be6fd9dde8ca547d9a8a9f07847856aba3f3ae5ac594cd81/coverage-7.16.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:360967a6fd77794c167529eec2d16ff8e38216110619d23acc3fd466a1648bee", size = 259442, upload-time = "2026-08-28T21:53:45.725Z" }, + { url = "https://files.pythonhosted.org/packages/7a/dc/8aca78e47e1e6fcc761cd28a20daf4a84bd847a7369e2701a93ccfc3d1fd/coverage-7.16.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:92cbc2bf4f7f67c79f1d3ca4fe8c50faddf48e852a3d07eaaf02dc014889832f", size = 254618, upload-time = "2026-08-28T21:53:48.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/fd/787842cdf6ce16ac5c1bd8a26549bab3b3f27b02500075bc540dc7853bca/coverage-7.16.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cce4dc8528453128c6fae523b15f3887fbea1d4d7c9eb9639d3d4fdcbe570c73", size = 256541, upload-time = "2026-08-28T21:53:50.805Z" }, + { url = "https://files.pythonhosted.org/packages/ef/79/8df302cbef373dd1f3401044cdb94dfc74517e5af2af27b4d0e721557e0e/coverage-7.16.0-cp315-cp315-win32.whl", hash = "sha256:5205baea687133613dced668a3d0168ea1479349615bfc255849a7944988c889", size = 225429, upload-time = "2026-08-28T21:53:53.177Z" }, + { url = "https://files.pythonhosted.org/packages/85/87/5bad7ac45f76b3728ca211028ee561c2ede3ba44da401129e28bb8737291/coverage-7.16.0-cp315-cp315-win_amd64.whl", hash = "sha256:4fcb5f07a9b7083bfb715115d27ce263ba2b5b89dddeee536b295ba0e3c2c627", size = 225903, upload-time = "2026-08-28T21:53:55.535Z" }, + { url = "https://files.pythonhosted.org/packages/cc/ea/67d84b11caf240f059ec313f616d82212df5004e8bc85802c1edfc50bb3d/coverage-7.16.0-cp315-cp315-win_arm64.whl", hash = "sha256:d568a8adcec0eda42ec23e5e65dfb8c184fc255120f9e99b484f7c869d923fb9", size = 225334, upload-time = "2026-08-28T21:53:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/65/21/a88349cce3ff720729b754916ac47e2e3646a8137552e4fa7cdd5967cc7f/coverage-7.16.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:3e8037e8213adf882e9d7eedd2c5c557933ab0b9632c42d98fe98ec9bcdb4025", size = 223980, upload-time = "2026-08-28T21:54:00.082Z" }, + { url = "https://files.pythonhosted.org/packages/fd/02/4d54abf3e6a4d8b7675921b20e91163b1064a5a9dbefebb71c05065dd136/coverage-7.16.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:289f2ed4d56eebf029b649e7dfc3c1153b111962a75e294cdd8e4a1598a04cc3", size = 224276, upload-time = "2026-08-28T21:54:02.381Z" }, + { url = "https://files.pythonhosted.org/packages/f6/39/10dbc96d95d20b9b041045d293480bd49e536180e93af62dd7662376284d/coverage-7.16.0-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9b83f6ac575530783771c8dcf05284f7c8b5b12f1e7cb226d63445aac4497a3a", size = 265135, upload-time = "2026-08-28T21:54:04.558Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3b/6b326544afd1a8aef3a495bbae109a7ab5baf23e04a2741d8d64e2df2ba2/coverage-7.16.0-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c3ff6580f2dfc5bec34717b85b2e6cf5ec993b721e7bb58a794babd525a8178", size = 268216, upload-time = "2026-08-28T21:54:06.97Z" }, + { url = "https://files.pythonhosted.org/packages/54/34/1dc8265f3ed990690e24d5f31ff79bc9fb9b25d54f9f89bebad5a6a8b7a1/coverage-7.16.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:507596cee23e9968b1934fe86d799b76166541af0a293930918b1b48a5c84bd2", size = 270772, upload-time = "2026-08-28T21:54:09.234Z" }, + { url = "https://files.pythonhosted.org/packages/66/a7/3a8463713a402b44044ec832f4a76e442ce4b3a207804303f4d1dc1a9bb4/coverage-7.16.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edc2be98e6c55ccc5ff7832bb64f023a4b03dba39dfa84b850046cf08a8249b0", size = 271752, upload-time = "2026-08-28T21:54:11.701Z" }, + { url = "https://files.pythonhosted.org/packages/25/3b/dd5e795cfbe1842f69899189089ae289a96d6a68de312960ea668542e33c/coverage-7.16.0-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9c0690994b84a15a53bdd39e0b2fdb539b22533820623eb86ba75b93760c645b", size = 265589, upload-time = "2026-08-28T21:54:14.12Z" }, + { url = "https://files.pythonhosted.org/packages/1b/b6/fd90636cbd95cb018312f6ca1ca2bbd70fbe8e4ee6f3992fc36a4230364e/coverage-7.16.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:de24c62bf798940a14674a47489a81b79915ec4134f556d5199830e065225dd0", size = 268596, upload-time = "2026-08-28T21:54:16.303Z" }, + { url = "https://files.pythonhosted.org/packages/91/10/ef2d59264f3b3b358cc5885ca375e6cdbda7c195e78304d5aae800a72d9d/coverage-7.16.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:69474d81f198774c9d2937599ca5da04c9e1c5de5032da23c607ce4960ce360e", size = 265072, upload-time = "2026-08-28T21:54:18.597Z" }, + { url = "https://files.pythonhosted.org/packages/3f/5b/400891c364c0170408d172501b340b18611800f4c42d8fbb16f9f5497c24/coverage-7.16.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:72a0795cc6d34acc2b03dfeabdc82b61b72087f2737018b56ac92c1cf5446c54", size = 269768, upload-time = "2026-08-28T21:54:20.985Z" }, + { url = "https://files.pythonhosted.org/packages/98/93/9792c80271df04d287d21ed5d662fd8fa58b1737888d817679b1ce5d2fab/coverage-7.16.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:d9a218d3f9c7d6916684ed5ba94f620661117a730e733cd6ef5e87accc5872eb", size = 265211, upload-time = "2026-08-28T21:54:23.344Z" }, + { url = "https://files.pythonhosted.org/packages/81/67/5b8f827cfa6616e6bd7ba9397acfe7e3c4fd5b9fca4125511d5089f55d5a/coverage-7.16.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:49fa72ead28c8216f8916398a4f3c4669acb30a061822810ee20a727a1be2897", size = 267170, upload-time = "2026-08-28T21:54:25.85Z" }, + { url = "https://files.pythonhosted.org/packages/5c/ee/c135d2d2cb617d744bc3e13c922f2fae66964494176ddef225dc4656bd2c/coverage-7.16.0-cp315-cp315t-win32.whl", hash = "sha256:27461af9f3ed7d2cf2411eb083784f87055ebf42211789ae3a216c48609bc743", size = 225731, upload-time = "2026-08-28T21:54:28.151Z" }, + { url = "https://files.pythonhosted.org/packages/8a/4d/dc3d53eadf155916e183bf5dfacbfc4aa5bfb7f13b7da11c01caa7a05cbc/coverage-7.16.0-cp315-cp315t-win_amd64.whl", hash = "sha256:c5612cc20ca76abc883e50269af47c1494b42958bb63dbb9aa79729a1ab5f7d3", size = 226562, upload-time = "2026-08-28T21:54:30.42Z" }, + { url = "https://files.pythonhosted.org/packages/2f/00/ac9da1a60a4e84c3ad0f7db4723fd327154a8f9add210c0dcd2db3ec5156/coverage-7.16.0-cp315-cp315t-win_arm64.whl", hash = "sha256:2ddaa9e2af4760a329d80008b7a3b4762fbb0dbcb169199360f9a5179c32f2dc", size = 225872, upload-time = "2026-08-28T21:54:32.806Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5a/234e8fadf85c3cc48cb31c247b9e8e0c7f06ece80f5b29f9b8c241f9da4c/coverage-7.16.0-py3-none-any.whl", hash = "sha256:245f7de6d023a5bba375dbec9f2e0869bfa26ac0cc639bbb7b4c814884000b73", size = 214977, upload-time = "2026-08-28T21:54:35.189Z" }, ] [[package]] name = "cycler" version = "0.12.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615 } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.21" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/aa/12037145b7a56eaa5b29b41872f7a21b538e807e13f32c4d3c46e59be084/debugpy-1.8.21.tar.gz", hash = "sha256:a3c53278e84c94e11bd87c53970ec391d1a67396c8b22609fcac576520e611a6", size = 1697577, upload-time = "2026-06-01T19:30:35.156Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/df/bf625547431a9cadc9f4cbfeda38866e2b17f6aed147b625377e87834449/debugpy-1.8.21-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:9f96713896f39c3dff0ee841f47320c3f2983d33c341e009361bb0ebc79adc4e", size = 2483609, upload-time = "2026-06-01T19:30:50.794Z" }, + { url = "https://files.pythonhosted.org/packages/bf/09/59324b903599031ff9faaec1758292409f6561a0ec2492fe4b703327705a/debugpy-1.8.21-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:c193d474f0a211191f2b4449d2d06157c689013035bd952f3b617e0ef422b176", size = 3968900, upload-time = "2026-06-01T19:30:52.341Z" }, + { url = "https://files.pythonhosted.org/packages/14/cd/27f65b805d7fe005c44e1a36b9183ecdfbcdbf9d3e721a5115d461ecc7ee/debugpy-1.8.21-cp312-cp312-win32.whl", hash = "sha256:4743373c1cac7f9e74a1b9915bf1dbe0e900eca657ffb170ae07ac8363205ae9", size = 5336340, upload-time = "2026-06-01T19:30:54.047Z" }, + { url = "https://files.pythonhosted.org/packages/77/1d/c84e30c0c674184948b66f076ab271c01d940618a2824c23cd035a27bc20/debugpy-1.8.21-cp312-cp312-win_amd64.whl", hash = "sha256:bd7ba9dd3daa7c2f942c6ca8d4695a16bf9ac16b63615261c7982bc74f7ed20c", size = 5374751, upload-time = "2026-06-01T19:30:55.891Z" }, + { url = "https://files.pythonhosted.org/packages/77/6b/d817e1f8cc77aa055d37fba092e0febfdff40fe652d8d53d4cd7a86ad98d/debugpy-1.8.21-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:13678151fc401e2d68c9880b91e28714f797d40422994572b24560ef80910a88", size = 2477398, upload-time = "2026-06-01T19:30:57.644Z" }, + { url = "https://files.pythonhosted.org/packages/48/57/412421516afc3055fa577516f00beec3d663f9b0ab330639547ae6c57720/debugpy-1.8.21-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:ecbd158386c31ffe71d46f72d44d56e66331ab9b16cad649156d514368f23ab2", size = 3962096, upload-time = "2026-06-01T19:30:59.235Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2c616337cf6ba7b07ebbc97f02c6c945a8e2f76b365e33ee809c32ee36d1/debugpy-1.8.21-cp313-cp313-win32.whl", hash = "sha256:2c2ae706dec41d99a9ca1f7ebc987a83e65578363be6f6b3ac9067504917fae1", size = 5336288, upload-time = "2026-06-01T19:31:00.79Z" }, + { url = "https://files.pythonhosted.org/packages/f8/99/9175103392f84c4b1bf7622888cdc68da07f0ff7d9e581266428f6776033/debugpy-1.8.21-cp313-cp313-win_amd64.whl", hash = "sha256:aa648733047443eb1d07682c4ef287d36a54507b643ffdf38b09a3ef002c72a0", size = 5376567, upload-time = "2026-06-01T19:31:02.56Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3d/f4bbb323a548bfab2af3d6b4ffd9bf22636e55956a1285d317a1de643aad/debugpy-1.8.21-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9bb2a685287a2ac9b181cde89edcec64845cb51de7faaa75badb9a698bc24782", size = 2477209, upload-time = "2026-06-01T19:31:04.157Z" }, + { url = "https://files.pythonhosted.org/packages/8c/2d/6e7ec524984a1702777868de49a4c53202bddac2a432a76a093469587750/debugpy-1.8.21-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:3d6922439bf33fd38a3e2c447869ebc7b97da5cd3d329ff1ef9bc06c4903437e", size = 3927115, upload-time = "2026-06-01T19:31:05.863Z" }, + { url = "https://files.pythonhosted.org/packages/97/47/d1aa6d64005a98a9144647d99306b419396f9ad7bf1d73c119e17a81fb4d/debugpy-1.8.21-cp314-cp314-win32.whl", hash = "sha256:15d4963bd5ffa48f0da0947fd06757fa7621945048a14ad7705431566d3c0e7c", size = 5336724, upload-time = "2026-06-01T19:31:07.711Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/b905b90d163af11878c1af8abafa4a25206335e112e284e413454543a6da/debugpy-1.8.21-cp314-cp314-win_amd64.whl", hash = "sha256:fe0744a12353406de0ae8ccff0d0a4a666f00801a3db8fd04e7a5f761cd520e8", size = 5373803, upload-time = "2026-06-01T19:31:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/95/51/67e7cf11a53e40694f720457d5b3a1cdaaa3d5a9a633e482f225456b93ff/debugpy-1.8.21-py2.py3-none-any.whl", hash = "sha256:b1e37d333663c8851516a47364ef473da127f9caebe4417e6df6f5825a7e9a92", size = 5352888, upload-time = "2026-06-01T19:31:25.186Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[package]] +name = "docutils" +version = "0.22.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/b6/03bb70946330e88ffec97aefd3ea75ba575cb2e762061e0e62a213befee8/docutils-0.22.4.tar.gz", hash = "sha256:4db53b1fde9abecbb74d91230d32ab626d94f6badfc575d6db9194a49df29968", size = 2291750, upload-time = "2025-12-18T19:00:26.443Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321 }, + { url = "https://files.pythonhosted.org/packages/02/10/5da547df7a391dcde17f59520a231527b8571e6f46fc8efb02ccb370ab12/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de", size = 633196, upload-time = "2025-12-18T19:00:18.077Z" }, ] [[package]] -name = "distlib" -version = "0.3.9" +name = "egosplit-sknetwork" +version = "0.0.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0d/dd/1bec4c5ddb504ca60fc29472f3d27e8d4da1257a854e1d96742f15c1d02d/distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403", size = 613923 } +dependencies = [ + { name = "numba" }, + { name = "numpy" }, + { name = "scikit-network" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/2a/4785bc85879fea7beca61f5446a630766dcbc8e9d1be784f5b1c8404c61c/egosplit_sknetwork-0.0.4.tar.gz", hash = "sha256:8074a3746a6461b9bb39a3c8b781f5827ea427770d79f2b3bc9596d0b88c428c", size = 6460, upload-time = "2026-06-27T22:20:02.588Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/91/a1/cf2472db20f7ce4a6be1253a81cfdf85ad9c7885ffbed7047fb72c24cf87/distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87", size = 468973 }, + { url = "https://files.pythonhosted.org/packages/96/d5/54b55b4b38ca966f8e4ae5f68f6fcbb628c6de1c5fe85d90cb93ddcbc6f9/egosplit_sknetwork-0.0.4-py3-none-any.whl", hash = "sha256:41b038b8517ddd601259095a7d35800c4d0bfe3fd9bbb360214e5a52e8627cec", size = 6635, upload-time = "2026-06-27T22:20:01.35Z" }, ] [[package]] -name = "exceptiongroup" -version = "1.2.2" +name = "executing" +version = "2.2.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 }, + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, ] [[package]] -name = "filelock" -version = "3.16.1" +name = "fastjsonschema" +version = "2.22.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9d/db/3ef5bb276dae18d6ec2124224403d1d67bccdbefc17af4cc8f553e341ab1/filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435", size = 18037 } +sdist = { url = "https://files.pythonhosted.org/packages/33/a4/9473c7c3b87009d9c1d74034e4a0f6a35ff0d42dd0f9866d0c3ec4e9217b/fastjsonschema-2.22.2.tar.gz", hash = "sha256:72064e12356a7d6ef02165be2946b9abadbdf238536e07eb587e3dbaa33099cf", size = 385171, upload-time = "2026-08-15T19:47:08.853Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0", size = 16163 }, + { url = "https://files.pythonhosted.org/packages/49/82/2755c7c982086f00d4dab85bc120ec35045a9fc2191893a6ce79afe94443/fastjsonschema-2.22.2-py3-none-any.whl", hash = "sha256:0fb3915616adac85ccfdd737d26be1089845d2019819505b42d39888458f74d4", size = 27413, upload-time = "2026-08-15T19:47:04.406Z" }, ] [[package]] name = "fonttools" -version = "4.55.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/76/61/a300d1574dc381393424047c0396a0e213db212e28361123af9830d71a8d/fonttools-4.55.3.tar.gz", hash = "sha256:3983313c2a04d6cc1fe9251f8fc647754cf49a61dac6cb1e7249ae67afaafc45", size = 3498155 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/f3/9ac8c6705e4a0ff3c29e524df1caeee6f2987b02fb630129f21cc99a8212/fonttools-4.55.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:1dcc07934a2165ccdc3a5a608db56fb3c24b609658a5b340aee4ecf3ba679dc0", size = 2769857 }, - { url = "https://files.pythonhosted.org/packages/d8/24/e8b8edd280bdb7d0ecc88a5d952b1dec2ee2335be71cc5a33c64871cdfe8/fonttools-4.55.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f7d66c15ba875432a2d2fb419523f5d3d347f91f48f57b8b08a2dfc3c39b8a3f", size = 2299705 }, - { url = "https://files.pythonhosted.org/packages/f8/9e/e1ba20bd3b71870207fd45ca3b90208a7edd8ae3b001081dc31c45adb017/fonttools-4.55.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27e4ae3592e62eba83cd2c4ccd9462dcfa603ff78e09110680a5444c6925d841", size = 4576104 }, - { url = "https://files.pythonhosted.org/packages/34/db/d423bc646e6703fe3e6aea0edd22a2df47b9d188c5f7f1b49070be4d2205/fonttools-4.55.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:62d65a3022c35e404d19ca14f291c89cc5890032ff04f6c17af0bd1927299674", size = 4618282 }, - { url = "https://files.pythonhosted.org/packages/75/a0/e5062ac960a385b984ba74e7b55132e7f2c65e449e8330ab0f595407a3de/fonttools-4.55.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d342e88764fb201286d185093781bf6628bbe380a913c24adf772d901baa8276", size = 4570539 }, - { url = "https://files.pythonhosted.org/packages/1f/33/0d744ff518ebe50020b63e5018b8b278efd6a930c1d2eedda7defc42153b/fonttools-4.55.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:dd68c87a2bfe37c5b33bcda0fba39b65a353876d3b9006fde3adae31f97b3ef5", size = 4742411 }, - { url = "https://files.pythonhosted.org/packages/7e/6c/2f768652dba6b801f1567fc5d1829cda369bcd6e95e315a91e628f91c702/fonttools-4.55.3-cp310-cp310-win32.whl", hash = "sha256:1bc7ad24ff98846282eef1cbeac05d013c2154f977a79886bb943015d2b1b261", size = 2175132 }, - { url = "https://files.pythonhosted.org/packages/19/d1/4dcd865360fb2c499749a913fe80e41c26e8ae18629d87dfffa3de27e831/fonttools-4.55.3-cp310-cp310-win_amd64.whl", hash = "sha256:b54baf65c52952db65df39fcd4820668d0ef4766c0ccdf32879b77f7c804d5c5", size = 2219430 }, - { url = "https://files.pythonhosted.org/packages/4b/18/14be25545600bd100e5b74a3ac39089b7c1cb403dc513b7ca348be3381bf/fonttools-4.55.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8c4491699bad88efe95772543cd49870cf756b019ad56294f6498982408ab03e", size = 2771005 }, - { url = "https://files.pythonhosted.org/packages/b2/51/2e1a5d3871cd7c2ae2054b54e92604e7d6abc3fd3656e9583c399648fe1c/fonttools-4.55.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5323a22eabddf4b24f66d26894f1229261021dacd9d29e89f7872dd8c63f0b8b", size = 2300654 }, - { url = "https://files.pythonhosted.org/packages/73/1a/50109bb2703bc6f774b52ea081db21edf2a9fa4b6d7485faadf9d1b997e9/fonttools-4.55.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5480673f599ad410695ca2ddef2dfefe9df779a9a5cda89503881e503c9c7d90", size = 4877541 }, - { url = "https://files.pythonhosted.org/packages/5d/52/c0b9857fa075da1b8806c5dc2d8342918a8cc2065fd14fbddb3303282693/fonttools-4.55.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da9da6d65cd7aa6b0f806556f4985bcbf603bf0c5c590e61b43aa3e5a0f822d0", size = 4906304 }, - { url = "https://files.pythonhosted.org/packages/0b/1b/55f85c7e962d295e456d5209581c919620ee3e877b95cd86245187a5050f/fonttools-4.55.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e894b5bd60d9f473bed7a8f506515549cc194de08064d829464088d23097331b", size = 4888087 }, - { url = "https://files.pythonhosted.org/packages/83/13/6f2809c612ea2ac51391f92468ff861c63473601530fca96458b453212bf/fonttools-4.55.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:aee3b57643827e237ff6ec6d28d9ff9766bd8b21e08cd13bff479e13d4b14765", size = 5056958 }, - { url = "https://files.pythonhosted.org/packages/c1/28/d0ea9e872fa4208b9dfca686e1dd9ca22f6c9ef33ecff2f0ebc2dbe7c29b/fonttools-4.55.3-cp311-cp311-win32.whl", hash = "sha256:eb6ca911c4c17eb51853143624d8dc87cdcdf12a711fc38bf5bd21521e79715f", size = 2173939 }, - { url = "https://files.pythonhosted.org/packages/be/36/d74ae1020bc41a1dff3e6f5a99f646563beecb97e386d27abdac3ba07650/fonttools-4.55.3-cp311-cp311-win_amd64.whl", hash = "sha256:6314bf82c54c53c71805318fcf6786d986461622dd926d92a465199ff54b1b72", size = 2220363 }, - { url = "https://files.pythonhosted.org/packages/89/58/fbcf5dff7e3ea844bb00c4d806ca1e339e1f2dce5529633bf4842c0c9a1f/fonttools-4.55.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f9e736f60f4911061235603a6119e72053073a12c6d7904011df2d8fad2c0e35", size = 2765380 }, - { url = "https://files.pythonhosted.org/packages/81/dd/da6e329e51919b4f421c8738f3497e2ab08c168e76aaef7b6d5351862bdf/fonttools-4.55.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a8aa2c5e5b8b3bcb2e4538d929f6589a5c6bdb84fd16e2ed92649fb5454f11c", size = 2297940 }, - { url = "https://files.pythonhosted.org/packages/00/44/f5ee560858425c99ef07e04919e736db09d6416408e5a8d3bbfb4a6623fd/fonttools-4.55.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07f8288aacf0a38d174445fc78377a97fb0b83cfe352a90c9d9c1400571963c7", size = 4793327 }, - { url = "https://files.pythonhosted.org/packages/24/da/0a001926d791c55e29ac3c52964957a20dbc1963615446b568b7432891c3/fonttools-4.55.3-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8d5e8916c0970fbc0f6f1bece0063363bb5857a7f170121a4493e31c3db3314", size = 4865624 }, - { url = "https://files.pythonhosted.org/packages/3d/d8/1edd8b13a427a9fb6418373437caa586c0caa57f260af8e0548f4d11e340/fonttools-4.55.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae3b6600565b2d80b7c05acb8e24d2b26ac407b27a3f2e078229721ba5698427", size = 4774166 }, - { url = "https://files.pythonhosted.org/packages/9c/ec/ade054097976c3d6debc9032e09a351505a0196aa5493edf021be376f75e/fonttools-4.55.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:54153c49913f45065c8d9e6d0c101396725c5621c8aee744719300f79771d75a", size = 5001832 }, - { url = "https://files.pythonhosted.org/packages/e2/cd/233f0e31ad799bb91fc78099c8b4e5ec43b85a131688519640d6bae46f6a/fonttools-4.55.3-cp312-cp312-win32.whl", hash = "sha256:827e95fdbbd3e51f8b459af5ea10ecb4e30af50221ca103bea68218e9615de07", size = 2162228 }, - { url = "https://files.pythonhosted.org/packages/46/45/a498b5291f6c0d91b2394b1ed7447442a57d1c9b9cf8f439aee3c316a56e/fonttools-4.55.3-cp312-cp312-win_amd64.whl", hash = "sha256:e6e8766eeeb2de759e862004aa11a9ea3d6f6d5ec710551a88b476192b64fd54", size = 2209118 }, - { url = "https://files.pythonhosted.org/packages/9c/9f/00142a19bad96eeeb1aed93f567adc19b7f2c1af6f5bc0a1c3de90b4b1ac/fonttools-4.55.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a430178ad3e650e695167cb53242dae3477b35c95bef6525b074d87493c4bf29", size = 2752812 }, - { url = "https://files.pythonhosted.org/packages/b0/20/14b8250d63ba65e162091fb0dda07730f90c303bbf5257e9ddacec7230d9/fonttools-4.55.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:529cef2ce91dc44f8e407cc567fae6e49a1786f2fefefa73a294704c415322a4", size = 2291521 }, - { url = "https://files.pythonhosted.org/packages/34/47/a681cfd10245eb74f65e491a934053ec75c4af639655446558f29818e45e/fonttools-4.55.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e75f12c82127486fac2d8bfbf5bf058202f54bf4f158d367e41647b972342ca", size = 4770980 }, - { url = "https://files.pythonhosted.org/packages/d2/6c/a7066afc19db0705a12efd812e19c32cde2b9514eb714659522f2ebd60b6/fonttools-4.55.3-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:859c358ebf41db18fb72342d3080bce67c02b39e86b9fbcf1610cca14984841b", size = 4845534 }, - { url = "https://files.pythonhosted.org/packages/0c/a2/3c204fbabbfd845d9bdcab9ae35279d41e9a4bf5c80a0a2708f9c5a195d6/fonttools-4.55.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:546565028e244a701f73df6d8dd6be489d01617863ec0c6a42fa25bf45d43048", size = 4753910 }, - { url = "https://files.pythonhosted.org/packages/6e/8c/b4cb3592880340b89e4ef6601b531780bba73862332a6451d78fe135d6cb/fonttools-4.55.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:aca318b77f23523309eec4475d1fbbb00a6b133eb766a8bdc401faba91261abe", size = 4976411 }, - { url = "https://files.pythonhosted.org/packages/fc/a8/4bf98840ff89fcc188470b59daec57322178bf36d2f4f756cd19a42a826b/fonttools-4.55.3-cp313-cp313-win32.whl", hash = "sha256:8c5ec45428edaa7022f1c949a632a6f298edc7b481312fc7dc258921e9399628", size = 2160178 }, - { url = "https://files.pythonhosted.org/packages/e6/57/4cc35004605416df3225ff362f3455cf09765db00df578ae9e46d0fefd23/fonttools-4.55.3-cp313-cp313-win_amd64.whl", hash = "sha256:11e5de1ee0d95af4ae23c1a138b184b7f06e0b6abacabf1d0db41c90b03d834b", size = 2206102 }, - { url = "https://files.pythonhosted.org/packages/7c/2e/3481bd2f8a501146ceb60fa98e54ac91d3589d22dd0b3605d26d65280f3f/fonttools-4.55.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:bdcc9f04b36c6c20978d3f060e5323a43f6222accc4e7fcbef3f428e216d96af", size = 2772598 }, - { url = "https://files.pythonhosted.org/packages/ea/29/532e428003bdd98f728aff4a48ae91d6ba44eb0b7b4f30e746ad18bf56b6/fonttools-4.55.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c3ca99e0d460eff46e033cd3992a969658c3169ffcd533e0a39c63a38beb6831", size = 2300985 }, - { url = "https://files.pythonhosted.org/packages/a4/51/738a32b3f4968b614657d945c5574897c773e5efeae48bdf965480fbd963/fonttools-4.55.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22f38464daa6cdb7b6aebd14ab06609328fe1e9705bb0fcc7d1e69de7109ee02", size = 4579674 }, - { url = "https://files.pythonhosted.org/packages/6b/77/9893aa413e7d839e292685bae0749a319eacba9470c85253529d35248075/fonttools-4.55.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed63959d00b61959b035c7d47f9313c2c1ece090ff63afea702fe86de00dbed4", size = 4627321 }, - { url = "https://files.pythonhosted.org/packages/5d/5b/1f5f813264e7b09f50fdc2ba4cd20ad7136d671c70f022be41e0ad6a3abb/fonttools-4.55.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5e8d657cd7326eeaba27de2740e847c6b39dde2f8d7cd7cc56f6aad404ddf0bd", size = 4573730 }, - { url = "https://files.pythonhosted.org/packages/a7/bf/a68606cbc37b04d604799e039614f145fbf267cb46c46353c647b6471d75/fonttools-4.55.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:fb594b5a99943042c702c550d5494bdd7577f6ef19b0bc73877c948a63184a32", size = 4742326 }, - { url = "https://files.pythonhosted.org/packages/bb/c0/2779d167e6b8def68f31cf70e077e91afba10a46e330f22cc3ee206086d1/fonttools-4.55.3-cp39-cp39-win32.whl", hash = "sha256:dc5294a3d5c84226e3dbba1b6f61d7ad813a8c0238fceea4e09aa04848c3d851", size = 2175672 }, - { url = "https://files.pythonhosted.org/packages/e3/05/b0ddd91049475035cc341d1e6fa88a04340f2ef6c38192ca45e4e2b3331f/fonttools-4.55.3-cp39-cp39-win_amd64.whl", hash = "sha256:aedbeb1db64496d098e6be92b2e63b5fac4e53b1b92032dfc6988e1ea9134a4d", size = 2219942 }, - { url = "https://files.pythonhosted.org/packages/99/3b/406d17b1f63e04a82aa621936e6e1c53a8c05458abd66300ac85ea7f9ae9/fonttools-4.55.3-py3-none-any.whl", hash = "sha256:f412604ccbeee81b091b420272841e5ec5ef68967a9790e80bffd0e30b8e2977", size = 1111638 }, -] - -[[package]] -name = "identify" -version = "2.6.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1a/5f/05f0d167be94585d502b4adf8c7af31f1dc0b1c7e14f9938a88fdbbcf4a7/identify-2.6.3.tar.gz", hash = "sha256:62f5dae9b5fef52c84cc188514e9ea4f3f636b1d8799ab5ebc475471f9e47a02", size = 99179 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c9/f5/09644a3ad803fae9eca8efa17e1f2aef380c7f0b02f7ec4e8d446e51d64a/identify-2.6.3-py2.py3-none-any.whl", hash = "sha256:9edba65473324c2ea9684b1f944fe3191db3345e50b6d04571d10ed164f8d7bd", size = 99049 }, +version = "4.64.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/41/0f072a712dc74496e03710e462a18a4cfd8a258ad055a4e22d28b43a7abd/fonttools-4.64.0.tar.gz", hash = "sha256:ecb2e59a7bc692fee64dda6010deb66222335693b30046f15cccf81233aa715f", size = 3664266, upload-time = "2026-08-31T15:44:33.685Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/23/4ea251977fef70ed14193785e1b2949355f1f5927dc0ef1dada675c0bbb2/fonttools-4.64.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9ecb2b206b5b2386f6968721a0770226b66bdd54adc4279bfff3ddf62873eed8", size = 3095501, upload-time = "2026-08-31T15:42:44.299Z" }, + { url = "https://files.pythonhosted.org/packages/c4/32/943e9034f49797e1a25dbbd60c8047ce0c38c3585c5d1b2db38ce64059c5/fonttools-4.64.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8c631303bb1fd7be3067c47536a30ff1fcb4846d6008c112bc52a03f7cd6965", size = 2583091, upload-time = "2026-08-31T15:42:46.57Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4b/332cb3105d5d550cb5728e669151601c4f7698cbedafd134154eb806ef83/fonttools-4.64.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2763e452b025ee8e990f0462e76052de9bb094ebc21d296f62c6dfe958886b4", size = 5423449, upload-time = "2026-08-31T15:42:48.615Z" }, + { url = "https://files.pythonhosted.org/packages/dc/8f/e5f2906ea833d362916c64a2f6b1922a07b19442744fd3cd89563f429bff/fonttools-4.64.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:66a83f93579fb3493e458c4449d1d566a7b2a1c7b19915cd0fa3c9b8b5a8540b", size = 5400981, upload-time = "2026-08-31T15:42:50.862Z" }, + { url = "https://files.pythonhosted.org/packages/fe/46/1b325ebb20aef8bb05f803052ea65931d73638ae3e0d02a6658e3d14e0f8/fonttools-4.64.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cf67f96dc0bfe9607f5f2b734cedfbe2f6f995231adee4ccefa12872044d452d", size = 5359588, upload-time = "2026-08-31T15:42:53.341Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d3/ac56fa880e01339aa6ad0bcb457cc30bb4d6c5ca79922e1bd650e4a3a396/fonttools-4.64.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6786bed88581e19bc4f28ea7a64ad531e8f54acf50327fddca942688824a60bd", size = 5520698, upload-time = "2026-08-31T15:42:55.919Z" }, + { url = "https://files.pythonhosted.org/packages/d7/40/1251fef04c308836a3a7db523703a7ca8ab010dc1e3b9a9bf08e0861c7a8/fonttools-4.64.0-cp312-cp312-win32.whl", hash = "sha256:da4c9bdeaf6b06c12d13d0addfc8ef15aa9695d26574a6dc10751258bef72f30", size = 2430689, upload-time = "2026-08-31T15:42:58.48Z" }, + { url = "https://files.pythonhosted.org/packages/6f/1c/ce0e89183c0235ff6cfbf0603d593023a5afa5333efb35ff569cc0be9ce2/fonttools-4.64.0-cp312-cp312-win_amd64.whl", hash = "sha256:06b6409b868494556a831ae33b2d9a090476c37516b38d70f45a9720b460d423", size = 2482071, upload-time = "2026-08-31T15:43:00.598Z" }, + { url = "https://files.pythonhosted.org/packages/44/7b/49b0054a79b9ed918c018e70e09b56eb5678ee8b44e59e126c79de4d8d73/fonttools-4.64.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9443eefff58aad558608f352092e1be6d278980e8c3b4e8621fcbfda97818500", size = 3092750, upload-time = "2026-08-31T15:43:02.705Z" }, + { url = "https://files.pythonhosted.org/packages/83/e2/08e73bd2f6e6248f071d3e9debe4c2b4cecda3a7dc057c56b44e255421c3/fonttools-4.64.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:09657817b75575822bcd6098ef0ebf0386f34430839ee53109e70fd40a7f6539", size = 2583001, upload-time = "2026-08-31T15:43:04.923Z" }, + { url = "https://files.pythonhosted.org/packages/2f/58/6dc0ff0963fc1e12f53bac59175617ec5927342ee7a4ffb871b44d56d81b/fonttools-4.64.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d7995b906666037d7114c20a5566a372902747452af7d5bd4cd6bca8f1a2550", size = 5392765, upload-time = "2026-08-31T15:43:07.096Z" }, + { url = "https://files.pythonhosted.org/packages/7a/dd/4d3911049680da7b3aecf97cb5094e3a05554f5d94829358fc7664640456/fonttools-4.64.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2c42237b7e8c6813643e57d3efed3be094d4c06339dc2166b626e2cc5c12ee93", size = 5373969, upload-time = "2026-08-31T15:43:09.617Z" }, + { url = "https://files.pythonhosted.org/packages/48/0a/a2cf94121fd3ca9166bdb4863f71d6db32a5606b223c81e2ba99832a0612/fonttools-4.64.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:498f02ea92c9ca18c0f9c581ea93184a9d56c25b0af14189b0767adaf34235d8", size = 5333854, upload-time = "2026-08-31T15:43:11.985Z" }, + { url = "https://files.pythonhosted.org/packages/44/e2/632f4a8b94e6d7eea41e6d82f0ed337f64f5fb96f9910e2ac6b1689910e2/fonttools-4.64.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8252f20108e557532f91d7d6dd9af87c16ed6fa930f65516aa480fa2cfed3363", size = 5492828, upload-time = "2026-08-31T15:43:14.288Z" }, + { url = "https://files.pythonhosted.org/packages/ff/25/7fee1978fdedc1a2d978b76dddbea88785416f5774e7222327b867712d71/fonttools-4.64.0-cp313-cp313-win32.whl", hash = "sha256:45e3ecc3888f1637094fd75cd8fc727f3a4b06d1ddf89181126c071e244fd2a5", size = 2429011, upload-time = "2026-08-31T15:43:16.463Z" }, + { url = "https://files.pythonhosted.org/packages/dd/ed/bb1c217c9e1fbfa59f42b266af57df937a703882a73e59a309773752228f/fonttools-4.64.0-cp313-cp313-win_amd64.whl", hash = "sha256:e4812f71c39d77ec5041348dafa400532adf7bf8f1fffa9aa6495fce5876d7b8", size = 2480199, upload-time = "2026-08-31T15:43:18.774Z" }, + { url = "https://files.pythonhosted.org/packages/a0/0a/59b9074b8ab165cc28d3e08bcf7a8eff8e1dc5932a5a41c87b15952fa3af/fonttools-4.64.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:6f1ce9ef9a1b13098efdc2e43a2ed96d9851bbde7b31c652a87552c4efe9b422", size = 3096790, upload-time = "2026-08-31T15:43:21.125Z" }, + { url = "https://files.pythonhosted.org/packages/17/39/af1077a36feefe79f36d67d75aee637a96673c0a74eeb2c6f24266f5a20b/fonttools-4.64.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:83cc48d1411d2ff388dab99973dca81172cc9ceae9c9799da9548d494cfb38cb", size = 2584288, upload-time = "2026-08-31T15:43:23.148Z" }, + { url = "https://files.pythonhosted.org/packages/00/c4/1ea58af0eb78264d28e5871bba0810bf0943cd93d641fdeae92553ad3410/fonttools-4.64.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e412767d1c9765cf1b82f7b00f1686c6ca5809ebb77af363b3f9f2325a465c01", size = 5378061, upload-time = "2026-08-31T15:43:25.193Z" }, + { url = "https://files.pythonhosted.org/packages/93/99/5c7e36d770407b66f7fc8378d2bb47f1530d083d8b9247ff011ec9b4dd70/fonttools-4.64.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b4a7af455ffed980925bc0ebf5b8d6239e6c3e797d9d755b6db192fb3080d614", size = 5319458, upload-time = "2026-08-31T15:43:27.696Z" }, + { url = "https://files.pythonhosted.org/packages/a8/09/89e8d600e92723309d4ddd3944c4ca565197a5df0236ae4115ccbe797375/fonttools-4.64.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:398b14f89ca950b288bd290875f07e4e10685644fa4ac668546fb107b1ada4d4", size = 5316656, upload-time = "2026-08-31T15:43:29.842Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b3/56719ab37e1592ceac89724574146622bedec036a207be80f3c7b1c14cbe/fonttools-4.64.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:dc96150f99e05a317cb1f042b92c4cf8bc93cdb1f9f85717322e202ecdf2e505", size = 5448380, upload-time = "2026-08-31T15:43:32.311Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b0/15951b7e3006073f3260da4f8983732d18903905cfe26daa5138a0bbf682/fonttools-4.64.0-cp314-cp314-win32.whl", hash = "sha256:1c3661324f3f0fa4539a32288a3e0711a5f3ccf020036e760bb558ae9811a16f", size = 2432778, upload-time = "2026-08-31T15:43:34.421Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f3/0c97402b29411f4f6d31b32f2af5b4bcd5babe5a93c64558a8fd3654f140/fonttools-4.64.0-cp314-cp314-win_amd64.whl", hash = "sha256:043f6c572bf236f2a76e762c25f841daea11e8fc03e78088d7be66e0c5b4e4c0", size = 2485394, upload-time = "2026-08-31T15:43:36.506Z" }, + { url = "https://files.pythonhosted.org/packages/00/da/82192c7bee5314f04129a068dddae11082a63295d4e3b5ce08657de96608/fonttools-4.64.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4691a122b8c1d0d82d6e7510ce59d5c42146518240274b53e912e255573924f7", size = 3170118, upload-time = "2026-08-31T15:43:38.579Z" }, + { url = "https://files.pythonhosted.org/packages/42/2d/0b4f608d754f625fecc7d94b3b26af6f65f6ab4527b386bb0c6141cdd9ea/fonttools-4.64.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:3200180abc69639483cf54a17cca2e13c31ede5f665979ea0a9c829d093f372f", size = 2617333, upload-time = "2026-08-31T15:43:40.934Z" }, + { url = "https://files.pythonhosted.org/packages/5e/df/9f7448c38dea05458acfee81c443b14ef97d6d66c636af053d41cf8a32dd/fonttools-4.64.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53eee22af5b5a305c1ee2652955ed46b148e881456fcec1e7f0eb27f642f6bb4", size = 5542345, upload-time = "2026-08-31T15:43:43.114Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e8/cbf4a81e8be322bc4bee4ba31cd33a7b6336ef8030fa13b53b3e9c09fbf9/fonttools-4.64.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08f172961e11f4eb4f80f2f20049e09b0ea8e044fa6d456fed8346eb8588f360", size = 5349981, upload-time = "2026-08-31T15:43:45.363Z" }, + { url = "https://files.pythonhosted.org/packages/d8/dc/106fd9e93e962dbb60482d30c0913af3d108f5762429dfe93265a850bdc5/fonttools-4.64.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6eae4376adb104c2acfa76fd9ea0cb12b572ca1d70eceac709871f638ff76e93", size = 5409249, upload-time = "2026-08-31T15:43:47.817Z" }, + { url = "https://files.pythonhosted.org/packages/b0/2d/c7be990abf74c9c5c5367ae3dc65953ffce49fe00f62abd129cf725a2397/fonttools-4.64.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2730946ca8f12c356bd98eb9b2b095c8e761ed05bed5afb0d5b380cebe4f6370", size = 5443781, upload-time = "2026-08-31T15:43:49.909Z" }, + { url = "https://files.pythonhosted.org/packages/9b/cc/bffec3dccb9e3f4f6097a2baedaef5a8dec2cb816522ee163e4bb7f54b44/fonttools-4.64.0-cp314-cp314t-win32.whl", hash = "sha256:d30c966bea2deffa19c738c81776f7182da5ccabd97e666bae4f3d6ba87341d9", size = 2466542, upload-time = "2026-08-31T15:43:52.088Z" }, + { url = "https://files.pythonhosted.org/packages/96/49/e31f97dfc94e0648999f04bfccb37a97062d978f87df60654f496942c89f/fonttools-4.64.0-cp314-cp314t-win_amd64.whl", hash = "sha256:917fd520bb60809d83c14d43cfe48d5ad2516abaf2c073d65a431800dade2d29", size = 2516703, upload-time = "2026-08-31T15:43:53.954Z" }, + { url = "https://files.pythonhosted.org/packages/fe/ec/e39b9e56db7dcc859983caa24cf2a36209dd71f6cc8ddbbf00d7342d7988/fonttools-4.64.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:8dd18fdff0ac9759b8d67a714730abee07b2312e3656c20ba5affb0107094762", size = 3091150, upload-time = "2026-08-31T15:43:56.309Z" }, + { url = "https://files.pythonhosted.org/packages/a8/e1/3e6a409d6f99efb66c2f6d0a71986432ff9cc9aca0df9ff4a8bed1d850f6/fonttools-4.64.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5af87d1a6d247d7467ee082ae977a5443b2c45f8cd4d59375b6daa38d523c2de", size = 2582833, upload-time = "2026-08-31T15:43:58.348Z" }, + { url = "https://files.pythonhosted.org/packages/91/7e/e8aec0e6eaf93267450535c1be9c9ae63e1d9c49659c2ffdb52c19982114/fonttools-4.64.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:769fb64412ca237547ca73f111a64252d9e32c9d938bed51ed537bc9146a8f54", size = 5375327, upload-time = "2026-08-31T15:44:00.417Z" }, + { url = "https://files.pythonhosted.org/packages/61/d1/fa9ce5c1c3c0ef858a2cbe5632e9b6b137deca010b28d5d9a677e4aa89a7/fonttools-4.64.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e662f874ab2c7da9861584db44a13573e0936df087215f63013138f6e5eba083", size = 5338647, upload-time = "2026-08-31T15:44:02.62Z" }, + { url = "https://files.pythonhosted.org/packages/0d/13/e4d4fa3c166f7f5a8f9b6403ad9dcb3887cd05f8b9d2638bd2b43d2889ef/fonttools-4.64.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:2524a26f8fdb9051b0d778d052f5d238285ca9f91a7dc004514c7d6cf38d35f4", size = 5313557, upload-time = "2026-08-31T15:44:05.037Z" }, + { url = "https://files.pythonhosted.org/packages/91/c8/5a352d69608ea7606f677080ede971090fc7340b9f143c0b4fa00cfbf63e/fonttools-4.64.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:1e4e84b47839d35be24dbf476845a34f2ccf99707b66df125c1c414d3e86d25d", size = 5462363, upload-time = "2026-08-31T15:44:07.13Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f1/b15b845f66b559a24a9c40859391bbd3048af3ac0fd04e45b57dca11c4c7/fonttools-4.64.0-cp315-cp315-win32.whl", hash = "sha256:be084d19a3ac0c8b2aba696680642d703118d3b1f18cf83f5b7dbaf0ffc62ab6", size = 2431682, upload-time = "2026-08-31T15:44:09.293Z" }, + { url = "https://files.pythonhosted.org/packages/c6/b2/909beff0d2e2e1adac896e36cff7f9d76fd154bcd57e303d8f09aee8f72b/fonttools-4.64.0-cp315-cp315-win_amd64.whl", hash = "sha256:de8acaa5f4160f537a3cf41b031171d51004b9f4aebfa6c194f18dffa9533d03", size = 2484393, upload-time = "2026-08-31T15:44:11.117Z" }, + { url = "https://files.pythonhosted.org/packages/40/47/06a51becf651cc071daa88e18ecb9f45ace9e3a570d8191ed8b3cae353fa/fonttools-4.64.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:5b90ad6637237b636d15c9ae8b7c4a7a1c194f33def378677e468c13fd4542f8", size = 3162235, upload-time = "2026-08-31T15:44:13.182Z" }, + { url = "https://files.pythonhosted.org/packages/dd/96/8b3faf58fd7ec3bb11943126658ad15b3f385068b23248deffccf2327ac1/fonttools-4.64.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:fa75c7970bc6bca340cc6e20f20f069201bfcb50094c31a536fd99724d1d01ca", size = 2613507, upload-time = "2026-08-31T15:44:15.123Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3a/223d1437e72d79f1549be7bafb3cc08f397e1d9c354a241a8ec8573b7d33/fonttools-4.64.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:236e59bc7e2a63557a4d7b013f9cb9e28d9aebc45bc09f85e545e6bf091db626", size = 5518005, upload-time = "2026-08-31T15:44:17.359Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9f/6f1a4b40ae533b9e907b7e627e397be632d0d9fd6f6be7756cf458870279/fonttools-4.64.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a515f664cad988f2295056833a59f62220bc3e46afdaffe389a29060f6712355", size = 5341654, upload-time = "2026-08-31T15:44:19.869Z" }, + { url = "https://files.pythonhosted.org/packages/52/f6/9ca30ba98730a22b527bcc1e02034f0b13b3be2ede764bb0fe8b8e0408d6/fonttools-4.64.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:5bfdaada437e7730c17d366bd7bb8c4a16639963ddbfc1b2f302a68a17a290e7", size = 5385994, upload-time = "2026-08-31T15:44:21.979Z" }, + { url = "https://files.pythonhosted.org/packages/09/27/baf1b61bff983bfec72cbb7b32162c4b68d76dc824aaaa48a1c26fa10b6b/fonttools-4.64.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:c60be0aed97a32c6ba8cee21f0d0477136e495451bd97910f589ac892db120d4", size = 5432407, upload-time = "2026-08-31T15:44:24.469Z" }, + { url = "https://files.pythonhosted.org/packages/21/ff/2eab37d43f2e2ccc0993959d8f2605d9a68470082c592684ac98611ee70a/fonttools-4.64.0-cp315-cp315t-win32.whl", hash = "sha256:f8669ce37851b597d3435b91fefa51139e58d506ca449ca0e5bb68c63b8b6d2b", size = 2463614, upload-time = "2026-08-31T15:44:27.198Z" }, + { url = "https://files.pythonhosted.org/packages/dc/8d/8bdff3ea656592197c8ef5062774221885468ffa01d8b0dc782dae23a83a/fonttools-4.64.0-cp315-cp315t-win_amd64.whl", hash = "sha256:89356c0793b474af7e49ec90d39fb2363e2341516a90460e38231df5ebe8acd5", size = 2512422, upload-time = "2026-08-31T15:44:29.478Z" }, + { url = "https://files.pythonhosted.org/packages/82/f8/7188153c4b265c899cd035de6a062677d51f67118a4ba640902bd9683e90/fonttools-4.64.0-py3-none-any.whl", hash = "sha256:4a05783ff54ce4c7a28f18e5772efdf63c219374bd9ffc55452182e1cef8be60", size = 1195327, upload-time = "2026-08-31T15:44:31.741Z" }, +] + +[[package]] +name = "idna" +version = "3.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" }, ] [[package]] name = "igraph" -version = "0.11.8" +version = "1.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "texttable" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b8/8e/8810c9ccdef97c614423ca82fca693608db9546a1a9716671035e3630499/igraph-0.11.8.tar.gz", hash = "sha256:d7dc1404567ba3b0ea1bf8b5fa6e101617915c8ad11ea5a9f925a40bf4adad7d", size = 4568774 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/24/f4/0c39bd163de47bf2e293813a9b4ae61e34575142dde2b744151c872f9da9/igraph-0.11.8-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:92c47ceb9f4c95ff7461cd94eaec55e901dbc59f6e51f4244d2dd064f31c5491", size = 1948579 }, - { url = "https://files.pythonhosted.org/packages/dd/7e/8ee4e8f03b03feca33bb9dcc730724353ac36cbe7da7b38397f8ae5cd58b/igraph-0.11.8-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:3a2afdb046b602fea71ca18aff6c72165de5002ec38d0dcf1275e34ecd0d9d02", size = 1753346 }, - { url = "https://files.pythonhosted.org/packages/ea/7d/9d23c0936070f5beb99559c1064c9057374dfa435c7e3b13504d5a2c839e/igraph-0.11.8-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7870fb72fd9e9218940262671fb79baf281ef066aa1cd35adc092ce9ad39a038", size = 2984081 }, - { url = "https://files.pythonhosted.org/packages/88/b0/210f242123b14d3ff4b36f97410f928e9bf446414c066dc8d3b8c9cad2ab/igraph-0.11.8-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c8108138ad605714761bc6d526feab54074904a99c47dcaabc269ed7b45e7650", size = 3060225 }, - { url = "https://files.pythonhosted.org/packages/90/61/ec7edb5233ec2dc3d2129d94211801fb46a1c2b9beec40989707c82271f7/igraph-0.11.8-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2e3abe641622cd9c95eb152c97caa22e68257a524cc1851a099b066f8f5c5f3", size = 3142403 }, - { url = "https://files.pythonhosted.org/packages/6b/89/09f1d251c48f239238cf75714e8cee8fcaacb3513620e0f59dbf1ef0c51d/igraph-0.11.8-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b546eaa9461473a65bb56a51672c6aeb898b737d5e86c3efa1b1bf520ee4b031", size = 3893169 }, - { url = "https://files.pythonhosted.org/packages/e2/90/3e913fd9698fb91f002fc7a96b2c81bdd77bb8f60f7cb3ec922b6e218666/igraph-0.11.8-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:178ef859135ac5075a7159e6826a546b7340cf45a01a928c2a0c24c32e3dfa63", size = 4168476 }, - { url = "https://files.pythonhosted.org/packages/4f/76/35ae678a78bd1d221af92f3ab98bedbce24968d9d096a2ddfde8580fbe5b/igraph-0.11.8-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a68ae7b6324e9c4cb1d04ce75b6e0f67974433fc7667895f1e25bf4f4c6fd530", size = 4056329 }, - { url = "https://files.pythonhosted.org/packages/b5/f5/8c79fd8cdb3708cb404a31538c11eec4283e72dfc8cb47307966f0a3af74/igraph-0.11.8-cp39-abi3-win32.whl", hash = "sha256:cc93d2f97f93bf30c2027c31e9e1aa088a3c60cdfeb6b33e0259e4b40b4c5597", size = 1597440 }, - { url = "https://files.pythonhosted.org/packages/b0/17/621d3a59430851a327421fdbec9ec8494d7fadaffc6dfdd42d4a95accbf2/igraph-0.11.8-cp39-abi3-win_amd64.whl", hash = "sha256:248831a6162130f16909c1f776cc246b48f692339ea4baca489cad4ed8dc0e13", size = 1976778 }, - { url = "https://files.pythonhosted.org/packages/54/0c/d293db1a7353632387afc00ae92a2d024bf098fd9336ab98c047c8e7f87d/igraph-0.11.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f0a8cad10406fba28c4b0199dfb491bcfdf1cdd3a56feeb52bb3b1cd724d04b4", size = 1936005 }, - { url = "https://files.pythonhosted.org/packages/c9/e6/492b224f2d4fac430ce93cfd462dcb35fd73746baefe8f5a26e09226b312/igraph-0.11.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1c11127a58ac2fc8062dac9f20ef612aff1b09f5f9d3e90800c4817229d0a0bc", size = 1741196 }, - { url = "https://files.pythonhosted.org/packages/bd/35/0f6bc83d217c853b527f01a73cdc970894374e627b8751363e3e017bbf0f/igraph-0.11.8-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:17d79bfb170b8c195fe6bacfa1c906817e8e812417c7e6a8e15f0bcf9b0775a8", size = 2595984 }, - { url = "https://files.pythonhosted.org/packages/c6/80/d94a1ff1d9502a880e175054667167f097f12bf67243bc70d22cc005bba8/igraph-0.11.8-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e9de09a26d7aae4d83338497cfd2d107d3ee3a2e9335b9db4b6c73a089e8cf47", size = 2759711 }, - { url = "https://files.pythonhosted.org/packages/1a/9e/2d51720ec198b8ee9fe8d15044c0b69673876d303b7b69587c34c1a2239a/igraph-0.11.8-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6559e2c925ed2ac608103adfd1dec9ccb9a04ddc7ad1d9d2a7db46dda6b1955", size = 2764832 }, - { url = "https://files.pythonhosted.org/packages/ba/77/af680ee6e6d81bf803dcc0ae9c116e7c160f86014bdd3a584bcac93077ad/igraph-0.11.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:6c17658b367be4f725a253678bfe799d9fe4d4e5c01ad82449cf8f2e9917937c", size = 1976705 }, - { url = "https://files.pythonhosted.org/packages/5e/90/1bf6f93e561ec7bfb69af93ecc395eb6b3e9fded57529f4bf38b3eb6e7a4/igraph-0.11.8-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e702a436935d3e127f6affff397ebbab48b522434bd8d6f15cfb1ab5d940e7d5", size = 1935989 }, - { url = "https://files.pythonhosted.org/packages/a6/6b/e4a79c2063d979f93204fdda35adea6e1b04750a3a6d439b190481a7e15f/igraph-0.11.8-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5bcad4d052785fe9b076f5aca6e870e2fae35373b09867477adc7307f2692a36", size = 1741176 }, - { url = "https://files.pythonhosted.org/packages/c3/9f/bcb7e522133ebbf9d6ba0ac7923ce01508c51fc5b9487b368c52de00d624/igraph-0.11.8-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d420cd48353e7c138bc39a118c3a01dc41aeba38486cca1524a960a755016171", size = 2596033 }, - { url = "https://files.pythonhosted.org/packages/21/22/430bbc64d3efc8937a71436c3691c5ac11f21fd5c34b1c7308388e716a72/igraph-0.11.8-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0ae9486a52da72d2ab634b92e17a969dc4e8e83303384329b903830ad67315e5", size = 2759696 }, - { url = "https://files.pythonhosted.org/packages/f4/63/91f79e74fc78853842e46fc8883587e16d275f7b3cc4349ee80b2e2bf876/igraph-0.11.8-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4e36a4f8a40bb4ffc8aa08c1cfe6fa3dfa78393cf65165bd9d59e6ac24a2468", size = 2764848 }, - { url = "https://files.pythonhosted.org/packages/e9/0c/465c20825f70c4f0c2fc774a9f291df91f81df18132e1f433f5b23fc9f75/igraph-0.11.8-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:f4048b843be54a77bc7206ce8c58825a9b1b42748c1713699034dc4f7df36f73", size = 1976704 }, -] - -[[package]] -name = "importlib-resources" -version = "6.4.5" +sdist = { url = "https://files.pythonhosted.org/packages/23/be/56bef1919005b4caf1f71522b300d359f7faeb7ae93a3b0baa9b4f146a87/igraph-1.0.0.tar.gz", hash = "sha256:2414d0be2e4d77ee5357807d100974b40f6082bb1bb71988ec46cfb6728651ee", size = 5077105, upload-time = "2025-10-23T12:22:50.127Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/03/3278ad0ceb3ea0e84d8ae3a85bdded4d0e57853aeb802a200feb43847b93/igraph-1.0.0-cp39-abi3-macosx_10_15_x86_64.whl", hash = "sha256:c2cbc415e02523e5a241eecee82319080bf928a70b1ba299f3b3e25bf029b6d4", size = 2257415, upload-time = "2025-10-23T12:22:27.246Z" }, + { url = "https://files.pythonhosted.org/packages/0d/bc/6281ec7f9baaf71ee57c3b1748da2d3148d15d253e1a03006f204aa68ca5/igraph-1.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a27753cd80680a8f676c2d5a467aaa4a95e510b30748398ec4e4aeb982130e8", size = 2048555, upload-time = "2025-10-23T12:22:29.49Z" }, + { url = "https://files.pythonhosted.org/packages/2a/38/3cd6428a4ed4c09a56df05998438e7774fd1d799ee4fb8fc481674f5f7fc/igraph-1.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a55dc3a2a4e3fc3eba42479910c1511bfc3ecb33cdf5f0406891fd85f14b5aee", size = 5314141, upload-time = "2025-10-23T12:22:31.023Z" }, + { url = "https://files.pythonhosted.org/packages/7d/da/dd2867c25adbb41563720f14b5fc895c98bf88be682a3faff4f7b3118d2a/igraph-1.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2d04c2c76f686fb1f554ee35dfd3085f5e73b7965ba6b4cf06d53e66b1955522", size = 5683134, upload-time = "2025-10-23T12:22:32.423Z" }, + { url = "https://files.pythonhosted.org/packages/e5/40/243c118d34ab80382d7009c4dcb99b887384c3d2ce84d29eeac19e2a007a/igraph-1.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f2b52dc1757fff0fed29a9f7a276d971a11db4211569ed78b9eab36288dfcc9d", size = 6211583, upload-time = "2025-10-23T12:22:34.238Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b7/88f433819c54b496cb0315fce28e658970cb20ff5dbd52a5a605ce2888de/igraph-1.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:05c79a2a8fca695b2f217a6fa7f2549f896f757d4db41be32a055400cb19cc30", size = 6594509, upload-time = "2025-10-23T12:22:35.831Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5d/8f7f6f619d374e959aa3664ebc4b24c10abc90c2e8efbed97f2623fadaf5/igraph-1.0.0-cp39-abi3-win32.whl", hash = "sha256:c2bce3cd472fec3dd9c4d8a3ea5b6b9be65fb30edf760beb4850760dd4f2d479", size = 2725406, upload-time = "2025-10-23T12:22:37.588Z" }, + { url = "https://files.pythonhosted.org/packages/af/77/a85b3745cf40a0572bae2de8cd9c2a2a8af78e5cf3e880fc0a249114e609/igraph-1.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:faeff8ede0cf15eb4ded44b0fcea6e1886740146e60504c24ad2da14e0939563", size = 3221663, upload-time = "2025-10-23T12:22:39.404Z" }, + { url = "https://files.pythonhosted.org/packages/ef/7e/5df541c37bdf6493035e89c22bd53f30d99b291bcda6c78e9a8afeecec2b/igraph-1.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:b607cafc24b10a615e713ee96e58208ef27e0764af80140c7cc45d4724a3f2df", size = 2785701, upload-time = "2025-10-23T12:22:41.03Z" }, +] + +[[package]] +name = "imagesize" +version = "2.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fb/5e/513ff06670c84e7b9887c1fdf61b2d42b4f574a831f2f1d2222023049d8a/imagesize-2.0.1.tar.gz", hash = "sha256:b2ba6a4dea487a7ebcd53248d3476aca449d30db12a2dde5e0c5ca9624fd77e5", size = 1883774, upload-time = "2026-08-24T12:35:19.13Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/f9/575c8d760eae1fc99651b7cc5efd96ad5379ca4d6b53750b0fb4fe983f34/imagesize-2.0.1-py3-none-any.whl", hash = "sha256:ea0c9a0384df69ed86a943a15cde37d0360b82491b3910dc2215e202e62b5b02", size = 14794, upload-time = "2026-08-24T12:35:12.548Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "ipykernel" +version = "7.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "zipp", marker = "python_full_version < '3.10'" }, + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio2" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/98/be/f3e8c6081b684f176b761e6a2fef02a0be939740ed6f54109a2951d806f3/importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065", size = 43372 } +sdist = { url = "https://files.pythonhosted.org/packages/3d/c4/e4a38f579de4225a561305666f7541cdabb30075def2aa1ac17bd73c1fb5/ipykernel-7.3.0.tar.gz", hash = "sha256:9acaaaf97d16355166e4085afe9d225bfbdf2b7ef520f9df3be8f2b248275e09", size = 184899, upload-time = "2026-06-10T08:41:25.481Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e1/6a/4604f9ae2fa62ef47b9de2fa5ad599589d28c9fd1d335f32759813dfa91e/importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717", size = 36115 }, + { url = "https://files.pythonhosted.org/packages/3d/02/77b271f5dc58bfbc0b577c877b2365d1ffea2afe66a80c13f2312820348c/ipykernel-7.3.0-py3-none-any.whl", hash = "sha256:897eb64da762549ef610698fca5e9675195ec6ac8ec7f19d81ce1ca20c876057", size = 120583, upload-time = "2026-06-10T08:41:23.648Z" }, ] [[package]] -name = "iniconfig" -version = "2.0.0" +name = "ipython" +version = "9.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "psutil", marker = "sys_platform != 'cygwin' and sys_platform != 'emscripten'" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/32/99451b1283ec5d92ad77073f12e1c667dc10775384d8f15c2914207149dd/ipython-9.17.1.tar.gz", hash = "sha256:8919be8c27f20a6f4423145028063f6637b42a03ce57665bb12015ee1f073529", size = 4539289, upload-time = "2026-09-01T08:29:32.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/1e/65b59cf518c106aa755e7f7da3099027738687a862ec785060702a481320/ipython-9.17.1-py3-none-any.whl", hash = "sha256:6d1645743cfd1a07eb695d85aa2b5fa66721f8cbae9431d4049f7084bbf06509", size = 639038, upload-time = "2026-09-01T08:29:30.673Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "jedi" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c5/2a/906772148a06e48885039e0250c340b770a55bbf37b08d6ee0449df369c3/jupyter_client-8.10.0.tar.gz", hash = "sha256:9f7116294dca55f1785be880057d44544db9b1567718d92cb33c58886afb9497", size = 360653, upload-time = "2026-08-28T12:17:10.854Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/88/7c548de1f6c2ade7c931a3282da73f9274fa6a1531091be682f89c85efb9/jupyter_client-8.10.0-py3-none-any.whl", hash = "sha256:5f73f24f22fa25192cfff6b23c051932a2473a797b05734aff495b392103e14e", size = 110184, upload-time = "2026-08-28T12:17:09.028Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 }, + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, ] [[package]] name = "kiwisolver" -version = "1.4.7" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/85/4d/2255e1c76304cbd60b48cee302b66d1dde4468dc5b1160e4b7cb43778f2a/kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60", size = 97286 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/97/14/fc943dd65268a96347472b4fbe5dcc2f6f55034516f80576cd0dd3a8930f/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6", size = 122440 }, - { url = "https://files.pythonhosted.org/packages/1e/46/e68fed66236b69dd02fcdb506218c05ac0e39745d696d22709498896875d/kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17", size = 65758 }, - { url = "https://files.pythonhosted.org/packages/ef/fa/65de49c85838681fc9cb05de2a68067a683717321e01ddafb5b8024286f0/kiwisolver-1.4.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa0abdf853e09aff551db11fce173e2177d00786c688203f52c87ad7fcd91ef9", size = 64311 }, - { url = "https://files.pythonhosted.org/packages/42/9c/cc8d90f6ef550f65443bad5872ffa68f3dee36de4974768628bea7c14979/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8d53103597a252fb3ab8b5845af04c7a26d5e7ea8122303dd7a021176a87e8b9", size = 1637109 }, - { url = "https://files.pythonhosted.org/packages/55/91/0a57ce324caf2ff5403edab71c508dd8f648094b18cfbb4c8cc0fde4a6ac/kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:88f17c5ffa8e9462fb79f62746428dd57b46eb931698e42e990ad63103f35e6c", size = 1617814 }, - { url = "https://files.pythonhosted.org/packages/12/5d/c36140313f2510e20207708adf36ae4919416d697ee0236b0ddfb6fd1050/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88a9ca9c710d598fd75ee5de59d5bda2684d9db36a9f50b6125eaea3969c2599", size = 1400881 }, - { url = "https://files.pythonhosted.org/packages/56/d0/786e524f9ed648324a466ca8df86298780ef2b29c25313d9a4f16992d3cf/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4d742cb7af1c28303a51b7a27aaee540e71bb8e24f68c736f6f2ffc82f2bf05", size = 1512972 }, - { url = "https://files.pythonhosted.org/packages/67/5a/77851f2f201e6141d63c10a0708e996a1363efaf9e1609ad0441b343763b/kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e28c7fea2196bf4c2f8d46a0415c77a1c480cc0724722f23d7410ffe9842c407", size = 1444787 }, - { url = "https://files.pythonhosted.org/packages/06/5f/1f5eaab84355885e224a6fc8d73089e8713dc7e91c121f00b9a1c58a2195/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e968b84db54f9d42046cf154e02911e39c0435c9801681e3fc9ce8a3c4130278", size = 2199212 }, - { url = "https://files.pythonhosted.org/packages/b5/28/9152a3bfe976a0ae21d445415defc9d1cd8614b2910b7614b30b27a47270/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0c18ec74c0472de033e1bebb2911c3c310eef5649133dd0bedf2a169a1b269e5", size = 2346399 }, - { url = "https://files.pythonhosted.org/packages/26/f6/453d1904c52ac3b400f4d5e240ac5fec25263716723e44be65f4d7149d13/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8f0ea6da6d393d8b2e187e6a5e3fb81f5862010a40c3945e2c6d12ae45cfb2ad", size = 2308688 }, - { url = "https://files.pythonhosted.org/packages/5a/9a/d4968499441b9ae187e81745e3277a8b4d7c60840a52dc9d535a7909fac3/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:f106407dda69ae456dd1227966bf445b157ccc80ba0dff3802bb63f30b74e895", size = 2445493 }, - { url = "https://files.pythonhosted.org/packages/07/c9/032267192e7828520dacb64dfdb1d74f292765f179e467c1cba97687f17d/kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:84ec80df401cfee1457063732d90022f93951944b5b58975d34ab56bb150dfb3", size = 2262191 }, - { url = "https://files.pythonhosted.org/packages/6c/ad/db0aedb638a58b2951da46ddaeecf204be8b4f5454df020d850c7fa8dca8/kiwisolver-1.4.7-cp310-cp310-win32.whl", hash = "sha256:71bb308552200fb2c195e35ef05de12f0c878c07fc91c270eb3d6e41698c3bcc", size = 46644 }, - { url = "https://files.pythonhosted.org/packages/12/ca/d0f7b7ffbb0be1e7c2258b53554efec1fd652921f10d7d85045aff93ab61/kiwisolver-1.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:44756f9fd339de0fb6ee4f8c1696cfd19b2422e0d70b4cefc1cc7f1f64045a8c", size = 55877 }, - { url = "https://files.pythonhosted.org/packages/97/6c/cfcc128672f47a3e3c0d918ecb67830600078b025bfc32d858f2e2d5c6a4/kiwisolver-1.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:78a42513018c41c2ffd262eb676442315cbfe3c44eed82385c2ed043bc63210a", size = 48347 }, - { url = "https://files.pythonhosted.org/packages/e9/44/77429fa0a58f941d6e1c58da9efe08597d2e86bf2b2cce6626834f49d07b/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d2b0e12a42fb4e72d509fc994713d099cbb15ebf1103545e8a45f14da2dfca54", size = 122442 }, - { url = "https://files.pythonhosted.org/packages/e5/20/8c75caed8f2462d63c7fd65e16c832b8f76cda331ac9e615e914ee80bac9/kiwisolver-1.4.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a8781ac3edc42ea4b90bc23e7d37b665d89423818e26eb6df90698aa2287c95", size = 65762 }, - { url = "https://files.pythonhosted.org/packages/f4/98/fe010f15dc7230f45bc4cf367b012d651367fd203caaa992fd1f5963560e/kiwisolver-1.4.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46707a10836894b559e04b0fd143e343945c97fd170d69a2d26d640b4e297935", size = 64319 }, - { url = "https://files.pythonhosted.org/packages/8b/1b/b5d618f4e58c0675654c1e5051bcf42c776703edb21c02b8c74135541f60/kiwisolver-1.4.7-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef97b8df011141c9b0f6caf23b29379f87dd13183c978a30a3c546d2c47314cb", size = 1334260 }, - { url = "https://files.pythonhosted.org/packages/b8/01/946852b13057a162a8c32c4c8d2e9ed79f0bb5d86569a40c0b5fb103e373/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab58c12a2cd0fc769089e6d38466c46d7f76aced0a1f54c77652446733d2d02", size = 1426589 }, - { url = "https://files.pythonhosted.org/packages/70/d1/c9f96df26b459e15cf8a965304e6e6f4eb291e0f7a9460b4ad97b047561e/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:803b8e1459341c1bb56d1c5c010406d5edec8a0713a0945851290a7930679b51", size = 1541080 }, - { url = "https://files.pythonhosted.org/packages/d3/73/2686990eb8b02d05f3de759d6a23a4ee7d491e659007dd4c075fede4b5d0/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9a9e8a507420fe35992ee9ecb302dab68550dedc0da9e2880dd88071c5fb052", size = 1470049 }, - { url = "https://files.pythonhosted.org/packages/a7/4b/2db7af3ed3af7c35f388d5f53c28e155cd402a55432d800c543dc6deb731/kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18077b53dc3bb490e330669a99920c5e6a496889ae8c63b58fbc57c3d7f33a18", size = 1426376 }, - { url = "https://files.pythonhosted.org/packages/05/83/2857317d04ea46dc5d115f0df7e676997bbd968ced8e2bd6f7f19cfc8d7f/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6af936f79086a89b3680a280c47ea90b4df7047b5bdf3aa5c524bbedddb9e545", size = 2222231 }, - { url = "https://files.pythonhosted.org/packages/0d/b5/866f86f5897cd4ab6d25d22e403404766a123f138bd6a02ecb2cdde52c18/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3abc5b19d24af4b77d1598a585b8a719beb8569a71568b66f4ebe1fb0449460b", size = 2368634 }, - { url = "https://files.pythonhosted.org/packages/c1/ee/73de8385403faba55f782a41260210528fe3273d0cddcf6d51648202d6d0/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:933d4de052939d90afbe6e9d5273ae05fb836cc86c15b686edd4b3560cc0ee36", size = 2329024 }, - { url = "https://files.pythonhosted.org/packages/a1/e7/cd101d8cd2cdfaa42dc06c433df17c8303d31129c9fdd16c0ea37672af91/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:65e720d2ab2b53f1f72fb5da5fb477455905ce2c88aaa671ff0a447c2c80e8e3", size = 2468484 }, - { url = "https://files.pythonhosted.org/packages/e1/72/84f09d45a10bc57a40bb58b81b99d8f22b58b2040c912b7eb97ebf625bf2/kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3bf1ed55088f214ba6427484c59553123fdd9b218a42bbc8c6496d6754b1e523", size = 2284078 }, - { url = "https://files.pythonhosted.org/packages/d2/d4/71828f32b956612dc36efd7be1788980cb1e66bfb3706e6dec9acad9b4f9/kiwisolver-1.4.7-cp311-cp311-win32.whl", hash = "sha256:4c00336b9dd5ad96d0a558fd18a8b6f711b7449acce4c157e7343ba92dd0cf3d", size = 46645 }, - { url = "https://files.pythonhosted.org/packages/a1/65/d43e9a20aabcf2e798ad1aff6c143ae3a42cf506754bcb6a7ed8259c8425/kiwisolver-1.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:929e294c1ac1e9f615c62a4e4313ca1823ba37326c164ec720a803287c4c499b", size = 56022 }, - { url = "https://files.pythonhosted.org/packages/35/b3/9f75a2e06f1b4ca00b2b192bc2b739334127d27f1d0625627ff8479302ba/kiwisolver-1.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:e33e8fbd440c917106b237ef1a2f1449dfbb9b6f6e1ce17c94cd6a1e0d438376", size = 48536 }, - { url = "https://files.pythonhosted.org/packages/97/9c/0a11c714cf8b6ef91001c8212c4ef207f772dd84540104952c45c1f0a249/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2", size = 121808 }, - { url = "https://files.pythonhosted.org/packages/f2/d8/0fe8c5f5d35878ddd135f44f2af0e4e1d379e1c7b0716f97cdcb88d4fd27/kiwisolver-1.4.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942216596dc64ddb25adb215c3c783215b23626f8d84e8eff8d6d45c3f29f75a", size = 65531 }, - { url = "https://files.pythonhosted.org/packages/80/c5/57fa58276dfdfa612241d640a64ca2f76adc6ffcebdbd135b4ef60095098/kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee", size = 63894 }, - { url = "https://files.pythonhosted.org/packages/8b/e9/26d3edd4c4ad1c5b891d8747a4f81b1b0aba9fb9721de6600a4adc09773b/kiwisolver-1.4.7-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad42ba922c67c5f219097b28fae965e10045ddf145d2928bfac2eb2e17673640", size = 1369296 }, - { url = "https://files.pythonhosted.org/packages/b6/67/3f4850b5e6cffb75ec40577ddf54f7b82b15269cc5097ff2e968ee32ea7d/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:612a10bdae23404a72941a0fc8fa2660c6ea1217c4ce0dbcab8a8f6543ea9e7f", size = 1461450 }, - { url = "https://files.pythonhosted.org/packages/52/be/86cbb9c9a315e98a8dc6b1d23c43cffd91d97d49318854f9c37b0e41cd68/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e838bba3a3bac0fe06d849d29772eb1afb9745a59710762e4ba3f4cb8424483", size = 1579168 }, - { url = "https://files.pythonhosted.org/packages/0f/00/65061acf64bd5fd34c1f4ae53f20b43b0a017a541f242a60b135b9d1e301/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22f499f6157236c19f4bbbd472fa55b063db77a16cd74d49afe28992dff8c258", size = 1507308 }, - { url = "https://files.pythonhosted.org/packages/21/e4/c0b6746fd2eb62fe702118b3ca0cb384ce95e1261cfada58ff693aeec08a/kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e", size = 1464186 }, - { url = "https://files.pythonhosted.org/packages/0a/0f/529d0a9fffb4d514f2782c829b0b4b371f7f441d61aa55f1de1c614c4ef3/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e77f2126c3e0b0d055f44513ed349038ac180371ed9b52fe96a32aa071a5107", size = 2247877 }, - { url = "https://files.pythonhosted.org/packages/d1/e1/66603ad779258843036d45adcbe1af0d1a889a07af4635f8b4ec7dccda35/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:657a05857bda581c3656bfc3b20e353c232e9193eb167766ad2dc58b56504948", size = 2404204 }, - { url = "https://files.pythonhosted.org/packages/8d/61/de5fb1ca7ad1f9ab7970e340a5b833d735df24689047de6ae71ab9d8d0e7/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4bfa75a048c056a411f9705856abfc872558e33c055d80af6a380e3658766038", size = 2352461 }, - { url = "https://files.pythonhosted.org/packages/ba/d2/0edc00a852e369827f7e05fd008275f550353f1f9bcd55db9363d779fc63/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:34ea1de54beef1c104422d210c47c7d2a4999bdecf42c7b5718fbe59a4cac383", size = 2501358 }, - { url = "https://files.pythonhosted.org/packages/84/15/adc15a483506aec6986c01fb7f237c3aec4d9ed4ac10b756e98a76835933/kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:90da3b5f694b85231cf93586dad5e90e2d71b9428f9aad96952c99055582f520", size = 2314119 }, - { url = "https://files.pythonhosted.org/packages/36/08/3a5bb2c53c89660863a5aa1ee236912269f2af8762af04a2e11df851d7b2/kiwisolver-1.4.7-cp312-cp312-win32.whl", hash = "sha256:18e0cca3e008e17fe9b164b55735a325140a5a35faad8de92dd80265cd5eb80b", size = 46367 }, - { url = "https://files.pythonhosted.org/packages/19/93/c05f0a6d825c643779fc3c70876bff1ac221f0e31e6f701f0e9578690d70/kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb", size = 55884 }, - { url = "https://files.pythonhosted.org/packages/d2/f9/3828d8f21b6de4279f0667fb50a9f5215e6fe57d5ec0d61905914f5b6099/kiwisolver-1.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:f5a8b53bdc0b3961f8b6125e198617c40aeed638b387913bf1ce78afb1b0be2a", size = 48528 }, - { url = "https://files.pythonhosted.org/packages/c4/06/7da99b04259b0f18b557a4effd1b9c901a747f7fdd84cf834ccf520cb0b2/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2e6039dcbe79a8e0f044f1c39db1986a1b8071051efba3ee4d74f5b365f5226e", size = 121913 }, - { url = "https://files.pythonhosted.org/packages/97/f5/b8a370d1aa593c17882af0a6f6755aaecd643640c0ed72dcfd2eafc388b9/kiwisolver-1.4.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a1ecf0ac1c518487d9d23b1cd7139a6a65bc460cd101ab01f1be82ecf09794b6", size = 65627 }, - { url = "https://files.pythonhosted.org/packages/2a/fc/6c0374f7503522539e2d4d1b497f5ebad3f8ed07ab51aed2af988dd0fb65/kiwisolver-1.4.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ab9ccab2b5bd5702ab0803676a580fffa2aa178c2badc5557a84cc943fcf750", size = 63888 }, - { url = "https://files.pythonhosted.org/packages/bf/3e/0b7172793d0f41cae5c923492da89a2ffcd1adf764c16159ca047463ebd3/kiwisolver-1.4.7-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f816dd2277f8d63d79f9c8473a79fe54047bc0467754962840782c575522224d", size = 1369145 }, - { url = "https://files.pythonhosted.org/packages/77/92/47d050d6f6aced2d634258123f2688fbfef8ded3c5baf2c79d94d91f1f58/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf8bcc23ceb5a1b624572a1623b9f79d2c3b337c8c455405ef231933a10da379", size = 1461448 }, - { url = "https://files.pythonhosted.org/packages/9c/1b/8f80b18e20b3b294546a1adb41701e79ae21915f4175f311a90d042301cf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dea0bf229319828467d7fca8c7c189780aa9ff679c94539eed7532ebe33ed37c", size = 1578750 }, - { url = "https://files.pythonhosted.org/packages/a4/fe/fe8e72f3be0a844f257cadd72689c0848c6d5c51bc1d60429e2d14ad776e/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c06a4c7cf15ec739ce0e5971b26c93638730090add60e183530d70848ebdd34", size = 1507175 }, - { url = "https://files.pythonhosted.org/packages/39/fa/cdc0b6105d90eadc3bee525fecc9179e2b41e1ce0293caaf49cb631a6aaf/kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:913983ad2deb14e66d83c28b632fd35ba2b825031f2fa4ca29675e665dfecbe1", size = 1463963 }, - { url = "https://files.pythonhosted.org/packages/6e/5c/0c03c4e542720c6177d4f408e56d1c8315899db72d46261a4e15b8b33a41/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5337ec7809bcd0f424c6b705ecf97941c46279cf5ed92311782c7c9c2026f07f", size = 2248220 }, - { url = "https://files.pythonhosted.org/packages/3d/ee/55ef86d5a574f4e767df7da3a3a7ff4954c996e12d4fbe9c408170cd7dcc/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4c26ed10c4f6fa6ddb329a5120ba3b6db349ca192ae211e882970bfc9d91420b", size = 2404463 }, - { url = "https://files.pythonhosted.org/packages/0f/6d/73ad36170b4bff4825dc588acf4f3e6319cb97cd1fb3eb04d9faa6b6f212/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c619b101e6de2222c1fcb0531e1b17bbffbe54294bfba43ea0d411d428618c27", size = 2352842 }, - { url = "https://files.pythonhosted.org/packages/0b/16/fa531ff9199d3b6473bb4d0f47416cdb08d556c03b8bc1cccf04e756b56d/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:073a36c8273647592ea332e816e75ef8da5c303236ec0167196793eb1e34657a", size = 2501635 }, - { url = "https://files.pythonhosted.org/packages/78/7e/aa9422e78419db0cbe75fb86d8e72b433818f2e62e2e394992d23d23a583/kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ce6b2b0231bda412463e152fc18335ba32faf4e8c23a754ad50ffa70e4091ee", size = 2314556 }, - { url = "https://files.pythonhosted.org/packages/a8/b2/15f7f556df0a6e5b3772a1e076a9d9f6c538ce5f05bd590eca8106508e06/kiwisolver-1.4.7-cp313-cp313-win32.whl", hash = "sha256:f4c9aee212bc89d4e13f58be11a56cc8036cabad119259d12ace14b34476fd07", size = 46364 }, - { url = "https://files.pythonhosted.org/packages/0b/db/32e897e43a330eee8e4770bfd2737a9584b23e33587a0812b8e20aac38f7/kiwisolver-1.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:8a3ec5aa8e38fc4c8af308917ce12c536f1c88452ce554027e55b22cbbfbff76", size = 55887 }, - { url = "https://files.pythonhosted.org/packages/c8/a4/df2bdca5270ca85fd25253049eb6708d4127be2ed0e5c2650217450b59e9/kiwisolver-1.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:76c8094ac20ec259471ac53e774623eb62e6e1f56cd8690c67ce6ce4fcb05650", size = 48530 }, - { url = "https://files.pythonhosted.org/packages/11/88/37ea0ea64512997b13d69772db8dcdc3bfca5442cda3a5e4bb943652ee3e/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9362ecfca44c863569d3d3c033dbe8ba452ff8eed6f6b5806382741a1334bd", size = 122449 }, - { url = "https://files.pythonhosted.org/packages/4e/45/5a5c46078362cb3882dcacad687c503089263c017ca1241e0483857791eb/kiwisolver-1.4.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e8df2eb9b2bac43ef8b082e06f750350fbbaf2887534a5be97f6cf07b19d9583", size = 65757 }, - { url = "https://files.pythonhosted.org/packages/8a/be/a6ae58978772f685d48dd2e84460937761c53c4bbd84e42b0336473d9775/kiwisolver-1.4.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f32d6edbc638cde7652bd690c3e728b25332acbadd7cad670cc4a02558d9c417", size = 64312 }, - { url = "https://files.pythonhosted.org/packages/f4/04/18ef6f452d311e1e1eb180c9bf5589187fa1f042db877e6fe443ef10099c/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e2e6c39bd7b9372b0be21456caab138e8e69cc0fc1190a9dfa92bd45a1e6e904", size = 1626966 }, - { url = "https://files.pythonhosted.org/packages/21/b1/40655f6c3fa11ce740e8a964fa8e4c0479c87d6a7944b95af799c7a55dfe/kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dda56c24d869b1193fcc763f1284b9126550eaf84b88bbc7256e15028f19188a", size = 1607044 }, - { url = "https://files.pythonhosted.org/packages/fd/93/af67dbcfb9b3323bbd2c2db1385a7139d8f77630e4a37bb945b57188eb2d/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79849239c39b5e1fd906556c474d9b0439ea6792b637511f3fe3a41158d89ca8", size = 1391879 }, - { url = "https://files.pythonhosted.org/packages/40/6f/d60770ef98e77b365d96061d090c0cd9e23418121c55fff188fa4bdf0b54/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5e3bc157fed2a4c02ec468de4ecd12a6e22818d4f09cde2c31ee3226ffbefab2", size = 1504751 }, - { url = "https://files.pythonhosted.org/packages/fa/3a/5f38667d313e983c432f3fcd86932177519ed8790c724e07d77d1de0188a/kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3da53da805b71e41053dc670f9a820d1157aae77b6b944e08024d17bcd51ef88", size = 1436990 }, - { url = "https://files.pythonhosted.org/packages/cb/3b/1520301a47326e6a6043b502647e42892be33b3f051e9791cc8bb43f1a32/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8705f17dfeb43139a692298cb6637ee2e59c0194538153e83e9ee0c75c2eddde", size = 2191122 }, - { url = "https://files.pythonhosted.org/packages/cf/c4/eb52da300c166239a2233f1f9c4a1b767dfab98fae27681bfb7ea4873cb6/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:82a5c2f4b87c26bb1a0ef3d16b5c4753434633b83d365cc0ddf2770c93829e3c", size = 2338126 }, - { url = "https://files.pythonhosted.org/packages/1a/cb/42b92fd5eadd708dd9107c089e817945500685f3437ce1fd387efebc6d6e/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ce8be0466f4c0d585cdb6c1e2ed07232221df101a4c6f28821d2aa754ca2d9e2", size = 2298313 }, - { url = "https://files.pythonhosted.org/packages/4f/eb/be25aa791fe5fc75a8b1e0c965e00f942496bc04635c9aae8035f6b76dcd/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:409afdfe1e2e90e6ee7fc896f3df9a7fec8e793e58bfa0d052c8a82f99c37abb", size = 2437784 }, - { url = "https://files.pythonhosted.org/packages/c5/22/30a66be7f3368d76ff95689e1c2e28d382383952964ab15330a15d8bfd03/kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5b9c3f4ee0b9a439d2415012bd1b1cc2df59e4d6a9939f4d669241d30b414327", size = 2253988 }, - { url = "https://files.pythonhosted.org/packages/35/d3/5f2ecb94b5211c8a04f218a76133cc8d6d153b0f9cd0b45fad79907f0689/kiwisolver-1.4.7-cp39-cp39-win32.whl", hash = "sha256:a79ae34384df2b615eefca647a2873842ac3b596418032bef9a7283675962644", size = 46980 }, - { url = "https://files.pythonhosted.org/packages/ef/17/cd10d020578764ea91740204edc6b3236ed8106228a46f568d716b11feb2/kiwisolver-1.4.7-cp39-cp39-win_amd64.whl", hash = "sha256:cf0438b42121a66a3a667de17e779330fc0f20b0d97d59d2f2121e182b0505e4", size = 55847 }, - { url = "https://files.pythonhosted.org/packages/91/84/32232502020bd78d1d12be7afde15811c64a95ed1f606c10456db4e4c3ac/kiwisolver-1.4.7-cp39-cp39-win_arm64.whl", hash = "sha256:764202cc7e70f767dab49e8df52c7455e8de0df5d858fa801a11aa0d882ccf3f", size = 48494 }, - { url = "https://files.pythonhosted.org/packages/ac/59/741b79775d67ab67ced9bb38552da688c0305c16e7ee24bba7a2be253fb7/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:94252291e3fe68001b1dd747b4c0b3be12582839b95ad4d1b641924d68fd4643", size = 59491 }, - { url = "https://files.pythonhosted.org/packages/58/cc/fb239294c29a5656e99e3527f7369b174dd9cc7c3ef2dea7cb3c54a8737b/kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b7dfa3b546da08a9f622bb6becdb14b3e24aaa30adba66749d38f3cc7ea9706", size = 57648 }, - { url = "https://files.pythonhosted.org/packages/3b/ef/2f009ac1f7aab9f81efb2d837301d255279d618d27b6015780115ac64bdd/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd3de6481f4ed8b734da5df134cd5a6a64fe32124fe83dde1e5b5f29fe30b1e6", size = 84257 }, - { url = "https://files.pythonhosted.org/packages/81/e1/c64f50987f85b68b1c52b464bb5bf73e71570c0f7782d626d1eb283ad620/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a91b5f9f1205845d488c928e8570dcb62b893372f63b8b6e98b863ebd2368ff2", size = 80906 }, - { url = "https://files.pythonhosted.org/packages/fd/71/1687c5c0a0be2cee39a5c9c389e546f9c6e215e46b691d00d9f646892083/kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40fa14dbd66b8b8f470d5fc79c089a66185619d31645f9b0773b88b19f7223c4", size = 79951 }, - { url = "https://files.pythonhosted.org/packages/ea/8b/d7497df4a1cae9367adf21665dd1f896c2a7aeb8769ad77b662c5e2bcce7/kiwisolver-1.4.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:eb542fe7933aa09d8d8f9d9097ef37532a7df6497819d16efe4359890a2f417a", size = 55715 }, - { url = "https://files.pythonhosted.org/packages/d5/df/ce37d9b26f07ab90880923c94d12a6ff4d27447096b4c849bfc4339ccfdf/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b01aac285f91ca889c800042c35ad3b239e704b150cfd3382adfc9dcc780e39", size = 58666 }, - { url = "https://files.pythonhosted.org/packages/b0/d3/e4b04f43bc629ac8e186b77b2b1a251cdfa5b7610fa189dc0db622672ce6/kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:48be928f59a1f5c8207154f935334d374e79f2b5d212826307d072595ad76a2e", size = 57088 }, - { url = "https://files.pythonhosted.org/packages/30/1c/752df58e2d339e670a535514d2db4fe8c842ce459776b8080fbe08ebb98e/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f37cfe618a117e50d8c240555331160d73d0411422b59b5ee217843d7b693608", size = 84321 }, - { url = "https://files.pythonhosted.org/packages/f0/f8/fe6484e847bc6e238ec9f9828089fb2c0bb53f2f5f3a79351fde5b565e4f/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:599b5c873c63a1f6ed7eead644a8a380cfbdf5db91dcb6f85707aaab213b1674", size = 80776 }, - { url = "https://files.pythonhosted.org/packages/9b/57/d7163c0379f250ef763aba85330a19feefb5ce6cb541ade853aaba881524/kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:801fa7802e5cfabe3ab0c81a34c323a319b097dfb5004be950482d882f3d7225", size = 79984 }, - { url = "https://files.pythonhosted.org/packages/8c/95/4a103776c265d13b3d2cd24fb0494d4e04ea435a8ef97e1b2c026d43250b/kiwisolver-1.4.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0c6c43471bc764fad4bc99c5c2d6d16a676b1abf844ca7c8702bdae92df01ee0", size = 55811 }, +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/07/bd78e6a8fae171ea041ef5bba3ed21a003522fa088834b069b1909981f30/kiwisolver-1.5.1.tar.gz", hash = "sha256:f1303ef2eec81262a4b708c3e858afe58d7c75ad91c1c05266eda7673369859a", size = 104395, upload-time = "2026-08-28T10:28:27.153Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/9b/65b302742389c6f96f2956bef5decf26011309feb2fc5d79613af18adea4/kiwisolver-1.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:63fb7294b768f444eb4b068965f2662f28c2fd4161e23bd60fcf3ff27b74c046", size = 123876, upload-time = "2026-08-28T10:25:27.44Z" }, + { url = "https://files.pythonhosted.org/packages/71/74/c21f339956f6f691b2ed7e31d5f3ae767304df6c460192739fc830853051/kiwisolver-1.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ebdef3eae5336568147c39a55be6a2036ffde53faa9ca2d978989ae7c2da12c", size = 66487, upload-time = "2026-08-28T10:25:28.728Z" }, + { url = "https://files.pythonhosted.org/packages/84/e5/bdb34e21523e01dceda064d63713f3bdec91388af24fba1eca7ea5e85864/kiwisolver-1.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1798e83840c3f627246104c4d8a9639c60fa068adf9ce92b61791781fa8a68c1", size = 64660, upload-time = "2026-08-28T10:25:30.071Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f4/dadfec469313c7f428efa7e84b4aba9732f813c13ea7131a24b7b008ef57/kiwisolver-1.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34633ecf50d16187ab8e5528b7a2530f2feb4e23f300db4672538b51cfc5cd38", size = 1477929, upload-time = "2026-08-28T10:25:31.495Z" }, + { url = "https://files.pythonhosted.org/packages/6f/35/09c58daac34e6f6ea5c6dee0094b422118e5a7c265586008a95fd135ac5f/kiwisolver-1.5.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d27c2123977cb9269c30a49ba45f03a4323017ef693e19db4ec9dbe1299a3002", size = 1278499, upload-time = "2026-08-28T10:25:33.375Z" }, + { url = "https://files.pythonhosted.org/packages/19/32/739765e24fbad29d13f83e546ea4abc215a78cea9d677ca09025b027724d/kiwisolver-1.5.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6a797a1cefc8b9c93170db580337e1fe3d011ad18b1299943231279406342048", size = 1296677, upload-time = "2026-08-28T10:25:35.059Z" }, + { url = "https://files.pythonhosted.org/packages/df/32/03304d1010e2cc45e5b3b52cef7e43fed3a2a5cd6c87a89b4a88e1d85b5d/kiwisolver-1.5.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2551cf9917af48ee7c4b29cc82320489508cf96fd26a51f6fc124de661cd44c7", size = 1346037, upload-time = "2026-08-28T10:25:36.705Z" }, + { url = "https://files.pythonhosted.org/packages/3e/57/4c49377bfd274450dd72ecaa13eaac32ea804a03363e4d1db0c5aa999ceb/kiwisolver-1.5.1-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:38f6e0deb4d0a4615efe0c4efc5990b06ae450ab50a0b321c0b078b6d238c083", size = 988248, upload-time = "2026-08-28T10:25:38.299Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c3/38df144a08b6c5d75ca4504e5cc3141bb3bfef64c04f4ef48204f42711b6/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bfd1de989b3330420e29de39352f5c049905c9e3ee67233a50d550e3d652c148", size = 2228722, upload-time = "2026-08-28T10:25:40.038Z" }, + { url = "https://files.pythonhosted.org/packages/e7/11/3221838a89cd64d9b386353e000cd8a296069a20fbe3584507fdfd5bebae/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1209042a623ddfda5497e4066c7b77651dde8e1d3a9dd97599dc7e97f3b9b78c", size = 2325216, upload-time = "2026-08-28T10:25:41.699Z" }, + { url = "https://files.pythonhosted.org/packages/83/d4/075c219230697bb5db910d37262b9bacf880f92b4811a02ab81ed073a253/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:26e8268480be5061d509e29669d59103c067a26377a56491630ece11762e3858", size = 1977689, upload-time = "2026-08-28T10:25:43.559Z" }, + { url = "https://files.pythonhosted.org/packages/bb/08/1d219c3c2dd960983d0d4da623d916e9de6385df2b0bab3d1af0e9b8fccc/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d79308fa689fac89cbcfbd4dbfc80b5f95c54c5a7fd4d194be221f9d33d026e6", size = 2491443, upload-time = "2026-08-28T10:25:45.242Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d3/024208ec1079d273f1047468d1bdffbf38bb75b7b268090fd3a0301b9d9a/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b03af77d77e50edba2030fd5f7c352ff209314b09030a3cba7c14edf9a09a444", size = 2295200, upload-time = "2026-08-28T10:25:46.984Z" }, + { url = "https://files.pythonhosted.org/packages/6e/7c/7b210498f9f92e1cd7855f260fa69ef056881087b199ee20c208f0e4189a/kiwisolver-1.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:06a6917674de9e0fe3f66f5430787f59a9f2ddb64af9b714eaec547e29ef5c19", size = 70748, upload-time = "2026-08-28T10:25:48.444Z" }, + { url = "https://files.pythonhosted.org/packages/94/61/ef0daa157c8bb23672f7423e0d14c39db1dc6ef8ed47e6bc54c9c1bef3bf/kiwisolver-1.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:ad8b9671348d7c8716715652ae11f85ed0eb99e265a2df2ca490577d69860b2c", size = 68324, upload-time = "2026-08-28T10:25:49.81Z" }, + { url = "https://files.pythonhosted.org/packages/08/c1/88018321d976f53c421e379c43bc6993e70ce0c8a3ec5edc4bfe102257f6/kiwisolver-1.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b6ae6a0328f0bc035741820fdeecdcd67bf4694eee03972e843663107122f450", size = 62272, upload-time = "2026-08-28T10:25:51.02Z" }, + { url = "https://files.pythonhosted.org/packages/85/d2/712bc17ea4f1d216034928069d612defbc6c95a471c55a7203a39faecb1a/kiwisolver-1.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:886fc26012f0e8b5f69d1cfe6d711f6b11f194621539bf8e6bb1c25c5dc82724", size = 64481, upload-time = "2026-08-28T10:25:52.22Z" }, + { url = "https://files.pythonhosted.org/packages/1b/e6/6c5380d676f43b6d918033962ea5e72360ca69e5a404154bc496b598ffdb/kiwisolver-1.5.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:aefe930d113798330e9462f7874542977869c0613cba3262e2de3a8d5dee8f3a", size = 66260, upload-time = "2026-08-28T10:25:53.387Z" }, + { url = "https://files.pythonhosted.org/packages/92/6a/7087f5822cc8bb272679641404b1966a42504dac9ee74e2b33840475a0aa/kiwisolver-1.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5ca5aebae78a0bc13c1943af4af615d4966c5b650b05d5aa83b50e427196fee", size = 123876, upload-time = "2026-08-28T10:25:54.644Z" }, + { url = "https://files.pythonhosted.org/packages/5c/4b/9f385087ca09ee5ab9c09c6832561a7d2f7c78d3e5661d511e669f70e439/kiwisolver-1.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1ed0f5e49d0ceff8b72190824d9e59c062fbbc02c231b853112c78474b3f5ec2", size = 66487, upload-time = "2026-08-28T10:25:55.899Z" }, + { url = "https://files.pythonhosted.org/packages/47/8b/40d33ffd2f378094ed462e9a9a0907e59d4de9845e65a59561272da350d4/kiwisolver-1.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:77a4c8187a5948d7f8795adb765a3c7b553d07d86d88e43038fc32fc1fb9a3f3", size = 64673, upload-time = "2026-08-28T10:25:57.048Z" }, + { url = "https://files.pythonhosted.org/packages/ab/43/86aacc027959108b4c66eeae8b73cedb057dfa6eb3a335d05ad65197081c/kiwisolver-1.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:74ad5c3dad54a4641b4c28cd15ded70899d04459c6c7aeacafea716be97cce6d", size = 1477992, upload-time = "2026-08-28T10:25:58.479Z" }, + { url = "https://files.pythonhosted.org/packages/ed/40/b1d0369048c79733a32c8abb0f2718532e6630641368e33a81384246e844/kiwisolver-1.5.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21e46b23a2da695c364124817bc01d970effd5483147f8d66a6a7167e3f6b851", size = 1278821, upload-time = "2026-08-28T10:26:00.121Z" }, + { url = "https://files.pythonhosted.org/packages/61/a1/fa71c1792272ff9461432715ae60ffb7e11a4d7ac3bf68961b9cab6c60cf/kiwisolver-1.5.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75d9b1cf8258462dbdc1eeda718c96ea7f079324c09067f6daabfcf37712b7fe", size = 1296805, upload-time = "2026-08-28T10:26:01.868Z" }, + { url = "https://files.pythonhosted.org/packages/a3/49/3f0bd94af8e06ecc47eb834b195a06f05d48711ceb2352c56d6835160f0e/kiwisolver-1.5.1-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fca690b00c4c48f6c2a547b0160ed511357093a4e4c9b47e0fadf3128066d89", size = 1346109, upload-time = "2026-08-28T10:26:03.59Z" }, + { url = "https://files.pythonhosted.org/packages/a4/44/3afe6ef9cf06d61220953a8963e94eca978491be1d9547cb01d82a1efa08/kiwisolver-1.5.1-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:876bbfd276473d3daffe30e8c975df4ed9429967b41a6cb362dbb5155b6f13ad", size = 988252, upload-time = "2026-08-28T10:26:05.306Z" }, + { url = "https://files.pythonhosted.org/packages/e4/30/a12bd7a7285a211e1747c3eec77b8c614dbfcc1dad942f7611a1a6921ae5/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f942903fde7363d1d879057ec5de01310efda2597161784d752fa9953a01a71a", size = 2228846, upload-time = "2026-08-28T10:26:07.312Z" }, + { url = "https://files.pythonhosted.org/packages/a1/6b/233e2958abf0dab7b18d07e52f286e02e519d7651bfbbe97af9347564109/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c90d3022d8a94778939cda8638c6c8da8fa757b8958dad7ec868ce29c87681b8", size = 2325583, upload-time = "2026-08-28T10:26:09.093Z" }, + { url = "https://files.pythonhosted.org/packages/42/8e/7673060a27b01405b580058510adef34687069d229800239f5e44682d4d0/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8a34616dc2521cc8dc1d7d081734da63539f021ac0450ce950908340c6e7aa2f", size = 1978221, upload-time = "2026-08-28T10:26:11.127Z" }, + { url = "https://files.pythonhosted.org/packages/3f/7b/1b882fc1a8b4a0bb8084e7d1d85004116d08c92c0705d31f2928dec607f2/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:8bf4df63592c2a66b4f8edc5df2544998c288aa02f96ce0acd880cd1de8c8127", size = 2491819, upload-time = "2026-08-28T10:26:13.348Z" }, + { url = "https://files.pythonhosted.org/packages/39/9c/426deb49e62c5f69464b64bbeca064d3b758a7506b8913d986ef34f4619c/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d09037ca068d784ebc4aec290ef952ca27ac15dd9c0b5801a88c6e1096b83e6b", size = 2295520, upload-time = "2026-08-28T10:26:15.042Z" }, + { url = "https://files.pythonhosted.org/packages/f5/22/deabbb3ad6d918d74b7831b2d8ae7151b09d21c87974e5ee8a456f58c94c/kiwisolver-1.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:dc23390afe9f4ef9ac3bcc72a03a56eebbde03f4c571a32cb38f859cff9a6524", size = 70758, upload-time = "2026-08-28T10:26:16.504Z" }, + { url = "https://files.pythonhosted.org/packages/b9/71/02fa5c2fd92068bb8952847e70ee6c5cb280e7febe11653d17812acc53dd/kiwisolver-1.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:186884a58486651e3c217b6acea0a53eaa9498fdd472057c46f2f0fb5c25aad5", size = 68329, upload-time = "2026-08-28T10:26:17.658Z" }, + { url = "https://files.pythonhosted.org/packages/dd/87/2d5dfad0daf17dcc18d98c48ed2332fc3f051cf599e60be6182a30dd4cf1/kiwisolver-1.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0324cd2567259b7a095f6cf18a52b0ffc6f3de9e69528ff1bc0e7a37bd43ff1a", size = 62337, upload-time = "2026-08-28T10:26:18.778Z" }, + { url = "https://files.pythonhosted.org/packages/08/c8/83e1624f15d6262b470dbcc80b09979fd4d5b2ea3ddfc6b6e3327e235726/kiwisolver-1.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:74ea337e0ec3f6f342a36a4f1b5cd94dd9affddcd28ba9aae2905af932ee8c6b", size = 64513, upload-time = "2026-08-28T10:26:19.909Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2d/827ec30eb07f528c08d8459ffb318ae91a56d793ee8acbea8b491f0ff906/kiwisolver-1.5.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ee9df1f0d77b9c6e94f4ac0fec533fbddd5ea3a327807f18d7b069ae019ded80", size = 66287, upload-time = "2026-08-28T10:26:21.078Z" }, + { url = "https://files.pythonhosted.org/packages/53/11/5c43a562529dad8def4b81e5e1877c612a7e0298105a5939b3b409d2079c/kiwisolver-1.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fc271a6f0a2126958f4090e5507b9da5848927dae331f8f763bd4aa642b3d2cd", size = 123940, upload-time = "2026-08-28T10:26:22.475Z" }, + { url = "https://files.pythonhosted.org/packages/64/db/9bd6c505c95128c258a55236bfbb3a7a3fb6023f863316b6d7d9f3c69052/kiwisolver-1.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9b3092d8992a1d69b7a59c3e39f35e1b9be327a17f68a7c35fc17329e337d6f2", size = 66493, upload-time = "2026-08-28T10:26:23.743Z" }, + { url = "https://files.pythonhosted.org/packages/e1/f4/b3007a3ed5c9be73f81161140684cf7d9bdb9c4b632f5f484d2a1c713fb9/kiwisolver-1.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c2306e8bb53601979fcb3fa09cc65e031876d9ae01eff2fcbcd7a84ef94d5bc1", size = 64720, upload-time = "2026-08-28T10:26:24.95Z" }, + { url = "https://files.pythonhosted.org/packages/a1/13/08188f0cafa3a800403e4ff62b9aad4e7a17f9c4c7e080dc8f18c64794cf/kiwisolver-1.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:18a0cfb124546a4c2e6087c5f3029c7f44b37c85b142e0ced71f73a7599ac208", size = 1475867, upload-time = "2026-08-28T10:26:26.393Z" }, + { url = "https://files.pythonhosted.org/packages/8a/3e/053bdc3c9abdb8f2606225eda398adca25c0c91ab90add8222a69db65ee0/kiwisolver-1.5.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:34ec467940442c9943016fb2d4c81d1ba84351eeca2f1a78f8bc87f1ba0d414c", size = 1282865, upload-time = "2026-08-28T10:26:28.118Z" }, + { url = "https://files.pythonhosted.org/packages/5e/64/a44c341b36b610588cc2f1e89b3cae072a3119aa8be578e90987cd640751/kiwisolver-1.5.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a83ee7107df13abe42a54a6654670eef9bb39425cf2e27f65e0007465e1286ab", size = 1300865, upload-time = "2026-08-28T10:26:30.125Z" }, + { url = "https://files.pythonhosted.org/packages/60/5e/7e7d716dca38c714478b741257a5b4a321d9932b8d851551a136dcaf3984/kiwisolver-1.5.1-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bebb89489b279b2f5661bbbb2abcc87bcd4a46607bb4a5c966f04f1db6b8df9a", size = 1348071, upload-time = "2026-08-28T10:26:31.829Z" }, + { url = "https://files.pythonhosted.org/packages/10/1a/2b98fdda8bf45b7be317e48ed12393d44334394d315c74b81f4a14c0e31b/kiwisolver-1.5.1-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:509735237ae0d849e8a843551d423d2500d2e0a9ac1611a145658b29c0fb9f85", size = 992191, upload-time = "2026-08-28T10:26:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/b6/55/d893f5ede0e50f9e3fcf01f6015f42ec7d9cd221e26772701fe4a98745f9/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:824c3d763a05ea9e9003610145186b0e9848c7584a5575c79bac5a8e7cd80bad", size = 2233854, upload-time = "2026-08-28T10:26:35.282Z" }, + { url = "https://files.pythonhosted.org/packages/b1/82/f85f6279555a6ee1639fef7bfe83adb037a03e11a6fc9eaa54b8d0380339/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:1fff05e239575b1481b6ed1a782f6fad616efbf1f0b1f44e6e85c4dfe426e483", size = 2330621, upload-time = "2026-08-28T10:26:36.9Z" }, + { url = "https://files.pythonhosted.org/packages/56/31/e11aea078f66fc2fffcc179d38ca90d9da97652a241b64519169742ba46a/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0627b9bceb9c3cdcf12b8a18655eedfed2692b038df27423383c120d0b7dc2d6", size = 1982848, upload-time = "2026-08-28T10:26:39.01Z" }, + { url = "https://files.pythonhosted.org/packages/af/ea/2956b63bf5140ca46aa2c2818e6aa03e2d5754dd2fa41db1c6b28922940c/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8a708a47ade1fe19e8371d5da076bac0dd4b0a5a7985ad6c637f7f7e361b6baa", size = 2494850, upload-time = "2026-08-28T10:26:40.837Z" }, + { url = "https://files.pythonhosted.org/packages/11/d1/3829542258d8b3fc0898d221e7ef0e2c83eca0d348709bb8dbe54f3d4005/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:007a5553dfc4f4e8d184f588a0200e2cd4b63a59cc8796df3c39909e679dc7a0", size = 2298067, upload-time = "2026-08-28T10:26:42.803Z" }, + { url = "https://files.pythonhosted.org/packages/4e/0e/49522e1ab5788cbaf63a26fbd3b851f9028616828c961b8a31b35cb96df8/kiwisolver-1.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:f4167e87b397f273dc2356fcf1eaf50a6bac51e6105f45103ef7129c8efb0255", size = 72282, upload-time = "2026-08-28T10:26:44.268Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b6/22e7ca5315d363e6f81c9f37c9472e12e7b298731e77c0428e6a911a2c39/kiwisolver-1.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:5c490db2168a508088f59140dd392556a54b8bd1048fc6383c8baff13c359673", size = 69855, upload-time = "2026-08-28T10:26:45.725Z" }, + { url = "https://files.pythonhosted.org/packages/30/8c/03a9cfbe871964c8758a816eb03ac96c806da2795a9a7cd9bf9648bfb594/kiwisolver-1.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4d4ca09bf13cff792b1884f64b98ee6c2467930d632233be25c56b442d99f10e", size = 126289, upload-time = "2026-08-28T10:26:47.023Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e3/14ce3041ca79dff9c9d884ca00c7bf32374e76028a865a9ecd99b4f5a517/kiwisolver-1.5.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:44b8faef94f1857e77fa0238f3390ff1ac51d2ea20a487e2e452a59fd2b5f5ca", size = 67709, upload-time = "2026-08-28T10:26:48.268Z" }, + { url = "https://files.pythonhosted.org/packages/af/c4/45030471a66ec8ef042e9f96ffe1d522c9ab12da180186a0898966fc1385/kiwisolver-1.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2ae70bc59790d2af72a3f76f24b272403e135070340281108b447cb77ea70819", size = 65909, upload-time = "2026-08-28T10:26:49.523Z" }, + { url = "https://files.pythonhosted.org/packages/42/73/17dce073a6ae259bb32cf9d686c4079d2e538868bc45967462bf33df914a/kiwisolver-1.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:43844c1a7ad6d723d5b5b4c4fc7f5bd399c40e288120d16257c7c9e8765c6e85", size = 1584907, upload-time = "2026-08-28T10:26:50.933Z" }, + { url = "https://files.pythonhosted.org/packages/8c/84/ae3c75909f507283cbfcc7e916c7e822579ef962020b97e6882b27b4478f/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22d5e5aaad6be121f2515765e3b1c444352cb8eb4c86510801db8f2e50757316", size = 1392474, upload-time = "2026-08-28T10:26:52.638Z" }, + { url = "https://files.pythonhosted.org/packages/34/31/8bcc83caad5bce8fa4577152389848bf6bc110e51e573a2b4e7c2aa34c89/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3fa5855898f6d3d01b72ccd48a2d65cbdee301251603fefe34e2025bddba219c", size = 1405246, upload-time = "2026-08-28T10:26:54.248Z" }, + { url = "https://files.pythonhosted.org/packages/55/72/220345537d790cf4ae54f8acfff4b5cc2468e0702a384d651cf7a771c63e/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d66a64dd5dec136040ec2ae94aa026a912ee60fdd45bc28d3db30037fd809e88", size = 1456099, upload-time = "2026-08-28T10:26:56.042Z" }, + { url = "https://files.pythonhosted.org/packages/cd/10/3725fd2398f66d18c34b4e0f81a8d03764cd4f4f089f58a527f0b4428086/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:9e51c119992ea8820706871c30a4642ec76de20ae82f9b50b9a45517d8e9f810", size = 1073695, upload-time = "2026-08-28T10:26:57.658Z" }, + { url = "https://files.pythonhosted.org/packages/86/cb/28d6e09e66b93e4588b2e6b7d84d020ccefea09e2f4de788510a07efeab7/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:70ed9a45c7484d2b30cdacf60d220f494a1763b9fec1ad03285c6553fa0889f2", size = 2335355, upload-time = "2026-08-28T10:26:59.202Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b3/a0f31d5e4e40af7dc97c36b8a74fdd3a36cf3c8bbd098da9a23466ff6a94/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:98b208a7cc42c803445ef551d6753cc42a5ea13e9cab1ee66cd8b9cb70195330", size = 2426524, upload-time = "2026-08-28T10:27:01.181Z" }, + { url = "https://files.pythonhosted.org/packages/2f/c9/728f63bd58c72cafdc79fc306abeeac7391bec03b757a48dadeb30906521/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c6834b92dd2428e2dd85ef3d85f723d3c12f20aaf43a2ddd4f944ca25d833408", size = 2063430, upload-time = "2026-08-28T10:27:03.06Z" }, + { url = "https://files.pythonhosted.org/packages/84/df/ce188b96f92f9a2c958231da140768918cba53c9713dc887b82f85462118/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:5d142e352eb13facc7dd047489aebdff6ba78576c239f1ea04931979caaf0567", size = 2597513, upload-time = "2026-08-28T10:27:05.072Z" }, + { url = "https://files.pythonhosted.org/packages/69/d6/76947c8203768968382e5bd74d9cc95654746703a61ea53015f2c74a2e06/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9b1c4900736e489a812c529100de4b8fb617d4db075e931e213c57424b83d9b", size = 2394488, upload-time = "2026-08-28T10:27:07.423Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d4/14b21e4eb203c4d15425e8b6a2c625a320b4a1f2f7557eead63ffc30ffb7/kiwisolver-1.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5978c3340f16a35c30f8ab2fa7bcf559973c55f1a5ef6970e1f621acf3c4db13", size = 75404, upload-time = "2026-08-28T10:27:08.892Z" }, + { url = "https://files.pythonhosted.org/packages/cb/f5/53157899fc7f45f76421b77b99eb1639dd0f83f26ff9d76300c96bb4a3b0/kiwisolver-1.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ca307d6c259e5c98d3cb9ade55342b47a6839762caf2536f3d7b46ee660cc82e", size = 72946, upload-time = "2026-08-28T10:27:10.944Z" }, + { url = "https://files.pythonhosted.org/packages/75/62/f786c3a27f181fa339d851a77e266d208e776b9883cabc40a5b041a31b5a/kiwisolver-1.5.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:bb7c99f0673c03017a3ee01e54a5c2617a05468b11eabe513b0080e063ed95b1", size = 62420, upload-time = "2026-08-28T10:27:12.308Z" }, + { url = "https://files.pythonhosted.org/packages/02/cd/58a91ed25fbad0facdf503297b03768efab04bdf3141e5e3b49a34be7443/kiwisolver-1.5.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:0d8924877ce22e17326a99a418c3c82037da078df3c6a260b13eca677444e6e7", size = 64577, upload-time = "2026-08-28T10:27:13.502Z" }, + { url = "https://files.pythonhosted.org/packages/f6/5c/d501ef5a0958b226eac28306d24d5e5f114be0ace50e19cabae7b6b3b197/kiwisolver-1.5.1-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:534f02c1abb31ed6dbd3515545285c330b2f12d00fdb1fdb71658b9ca5a13a6a", size = 66284, upload-time = "2026-08-28T10:27:14.813Z" }, + { url = "https://files.pythonhosted.org/packages/a3/a6/8fbecaf4fc18c02f31f05e47a84c010a80e3ec391ed2f0bdade1d62b5954/kiwisolver-1.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:cea20da04494e662b83c872683bf4ff2345206043d036315ed0e924b652e7294", size = 124031, upload-time = "2026-08-28T10:27:16.193Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c6/bf3090d2983b4204347cbdbe952116e7c3b2abf62b4e33e50167a13e75ee/kiwisolver-1.5.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:7fd82debf43c6acd0a94359d232f6bb516ee13f269a7993736a9ac9f988bb5d9", size = 66489, upload-time = "2026-08-28T10:27:17.506Z" }, + { url = "https://files.pythonhosted.org/packages/85/de/562dddef55fdd7c291da8626d6619e72b5fc0870e6ccca0e149a5731e7f3/kiwisolver-1.5.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:18170a77ddfecf40ec60d0928268dc95880c881864e015a8f34094ed18b9b9ad", size = 64806, upload-time = "2026-08-28T10:27:18.673Z" }, + { url = "https://files.pythonhosted.org/packages/89/b1/ba7b9c0164ce1cf62bf2872db63b8483289cf0f3110d6f9390eb09e409ed/kiwisolver-1.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ca7f6fe0f37ca978a1e5eb7a3a68e6413f417e78e838324947ffd420202b198b", size = 1482211, upload-time = "2026-08-28T10:27:20.039Z" }, + { url = "https://files.pythonhosted.org/packages/13/dc/34da54efb4976616d45c20aae32d70e89d6e7395ed908029154d1609ef22/kiwisolver-1.5.1-cp315-cp315-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5b973887ff782cfd6b67c9904ad8ca542e0bc5e4961503408b423b5a688b4d38", size = 1283739, upload-time = "2026-08-28T10:27:21.82Z" }, + { url = "https://files.pythonhosted.org/packages/5a/3a/30ffb62bee646e266e98a1b5cd276d9c75b6116fbfcb87c1190838c1b6df/kiwisolver-1.5.1-cp315-cp315-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f76fc85bd054c806960f917ec0f329e24e436f1712267d90588e4c39890caa63", size = 1301681, upload-time = "2026-08-28T10:27:23.876Z" }, + { url = "https://files.pythonhosted.org/packages/a9/8d/13c70be22a8506880b35fdc38dca36629613bc493405c79f4037f2cd2bb9/kiwisolver-1.5.1-cp315-cp315-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:828f75af2b0080c8a972e75f649ab46af008e92c6104a57a759157200b835b75", size = 1349159, upload-time = "2026-08-28T10:27:25.899Z" }, + { url = "https://files.pythonhosted.org/packages/82/0e/993972b8ec6767f47cd69818fb3a5ff14510557d29f7d1a839be7574fa1b/kiwisolver-1.5.1-cp315-cp315-manylinux_2_39_riscv64.whl", hash = "sha256:431dc224a1a92a5c8f582d96e505196a3b5997a7271076678da2dfde67b77e9a", size = 997613, upload-time = "2026-08-28T10:27:27.507Z" }, + { url = "https://files.pythonhosted.org/packages/36/82/ca26eddd2eda2420dfc56693449c1f821f78b485da9cbde9904c03af3f93/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:61e9a64c7635095a6bfe483e2ff055d437c59bd45f3617a228b37277f0185d62", size = 2235109, upload-time = "2026-08-28T10:27:30.113Z" }, + { url = "https://files.pythonhosted.org/packages/c7/84/97d920881e10840b8d7c7185620298e3e4c88820b05514e3a15a258b08a6/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:3c24cd69455e1b00ddf770c13b6e2c33e07d6dc3f2d34add0bf9277c5c6bbd46", size = 2331207, upload-time = "2026-08-28T10:27:32.795Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ce/34d74b8f25acc58800f4c09268371e8d6159cf0f1206f1e4dc7835629b48/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:27add358abe374ebaa3b8763ef380bc99051b5a4b18d94878366a9e4f59efef0", size = 1986696, upload-time = "2026-08-28T10:27:34.628Z" }, + { url = "https://files.pythonhosted.org/packages/0e/01/f892644014612527aef7031d3306a2ffc60b3cb044f802c1561f8e5e14f3/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:255605693a483db7bd5c79f60437f7bf658f7f520d61aa42722e32257c941951", size = 2496400, upload-time = "2026-08-28T10:27:36.818Z" }, + { url = "https://files.pythonhosted.org/packages/32/6d/d8284e66e697026536e5f418b9cfe56567bffd3c775e3ecfbae373605854/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:7d38b0c279c3032e8c9cc013b405c6df8e1668dbf15465779aa7f15f61201812", size = 2302967, upload-time = "2026-08-28T10:27:38.803Z" }, + { url = "https://files.pythonhosted.org/packages/46/0a/69a355e27f32ba50d5b6369949b6a1702e122f5277c89bc76d452b81c1c4/kiwisolver-1.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:958254518717542d02d0688d0d20cbf771da5e415e6f49543f92481c850a4540", size = 72283, upload-time = "2026-08-28T10:27:40.491Z" }, + { url = "https://files.pythonhosted.org/packages/ef/d8/7a95be90c33dcdd52204d4aa6384d731443225b887283bbd8b61e7931f6c/kiwisolver-1.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:da3275833be0edbaf4830fae08bae3dc7219f40ce0c37eaa6c25825957e06612", size = 69860, upload-time = "2026-08-28T10:27:41.835Z" }, + { url = "https://files.pythonhosted.org/packages/31/f8/9bc493e7f5707788ba7f621902c68f82dc3a7ba03c78fbd337b026cef1ed/kiwisolver-1.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:470d420f98d368d6f010633a20659b544c5fdfa5329e6b70219f2ef08fd4a7ef", size = 126336, upload-time = "2026-08-28T10:27:43.379Z" }, + { url = "https://files.pythonhosted.org/packages/d1/82/3aea86b3f99712db825e9ac5631bf99571e818a8b8961ff98cebd798413e/kiwisolver-1.5.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:83f78128fa28705fa85d01c59771c72fe81c11bd0e6155edbb9f818983a7d761", size = 67698, upload-time = "2026-08-28T10:27:44.613Z" }, + { url = "https://files.pythonhosted.org/packages/84/7d/8daafc5d2e7f9c47a4f78f8865d86d2a9cf399c2a85f86c44a993594410c/kiwisolver-1.5.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:9506e892bcc3b409831d363c6f53e5985e1c8d1f6f6b0256d00358684ff85378", size = 65945, upload-time = "2026-08-28T10:27:45.932Z" }, + { url = "https://files.pythonhosted.org/packages/3d/c9/51dc974d9130da70a8c47a96160123443d387ffe1b6b833d6f91d9429339/kiwisolver-1.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cea90547bfd93807e0013a004dc76552be44fad3bc1cc2b38610a9e889ed098f", size = 1588030, upload-time = "2026-08-28T10:27:47.678Z" }, + { url = "https://files.pythonhosted.org/packages/e6/86/f3e1a730e7a995149d8d3ff9e313b6d8a17b2cf1d98a8eff139dc30463fb/kiwisolver-1.5.1-cp315-cp315t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e8e4d953faaded9ec7ede36824e9814082d22d4c7b1eafbfa079ecba8cd0d076", size = 1390760, upload-time = "2026-08-28T10:27:49.676Z" }, + { url = "https://files.pythonhosted.org/packages/4f/3b/8ba25a2b5a0d2375e046f1b72de5179513f0be95aba6e7b094c89303929f/kiwisolver-1.5.1-cp315-cp315t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e9c01d3dd7ceba4d1d436cc021d40d592466e40b9bc7f5d83dc4e98a5c9cd8c", size = 1403279, upload-time = "2026-08-28T10:27:51.242Z" }, + { url = "https://files.pythonhosted.org/packages/18/d0/278d5cb8be812740027d5ca0a7eda0c375488a88d6dce0fa60fcc2591ad2/kiwisolver-1.5.1-cp315-cp315t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37f801b5d7cc0e5a548921308e059fd2b057bb42972b591cfa3049f95423c4ed", size = 1454429, upload-time = "2026-08-28T10:27:53.213Z" }, + { url = "https://files.pythonhosted.org/packages/94/37/bcbab41063ec284c1d200efe5087cf087798c2f8916960aa8a20dd303290/kiwisolver-1.5.1-cp315-cp315t-manylinux_2_39_riscv64.whl", hash = "sha256:e68e151428b5384f766cd25739bf77c7e4a3dc93b5ded7a12118d9fbfdf78ab6", size = 1073225, upload-time = "2026-08-28T10:27:55.089Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c5/ab79dcdf5ae28909a51210ae0a1c579e97ff997b3466414f0d04c0994583/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:8f8fddb8e323bd6eee4e54e69a39243beab22689070f4c66b472c4cc88bb89d8", size = 2334335, upload-time = "2026-08-28T10:27:56.78Z" }, + { url = "https://files.pythonhosted.org/packages/8d/8e/71d047468a189041d9c93f3b76844b924f9793b188c44bd149fa258912da/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:3cc210010fd2f438a3ed430b45f1b501fd13a8618bf984dc2c5ce5b69b78752e", size = 2424982, upload-time = "2026-08-28T10:27:58.639Z" }, + { url = "https://files.pythonhosted.org/packages/7d/37/1347461bbea6d0e1f0580b94ef603b18e72c2be5f667fa1653867361a00b/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:b5664603a253efd3a75716d793d1d3a6a82723b61dc6db767b2460bbbeec4c0f", size = 2062857, upload-time = "2026-08-28T10:28:00.407Z" }, + { url = "https://files.pythonhosted.org/packages/1f/87/c7f0976c9cd0d127643351bc0c9929e0b8899d7f49d4ec238cd909e39c42/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a7b85b2cc6ea45e5f7e8c9a30bc9fabd47cda09106cbb4b967335c3e6c43b69d", size = 2596022, upload-time = "2026-08-28T10:28:02.183Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9a/59a6f6ae6f938c15076be2c21b6cedea973d71bb1349ec84fa485fab82cf/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:ab620eb663952455271ac37f9aaad86b73c969c02f11f53cea405b38e96a4300", size = 2395634, upload-time = "2026-08-28T10:28:03.977Z" }, + { url = "https://files.pythonhosted.org/packages/e9/2d/8982c1fb7926da5bb7ed60318c3665b5c3f941447271ac982960a11b8637/kiwisolver-1.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:cb6fae641357ed2f6e533c0d3c6504a4a5703621a50c89459e46051d56b61140", size = 75379, upload-time = "2026-08-28T10:28:06.307Z" }, + { url = "https://files.pythonhosted.org/packages/07/78/ba7b6dfa1708b82b373ac056928a30c545d5c1a627df9839dcec3c6c1881/kiwisolver-1.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:b390aec180a7c054919c04898835e1c77bced23ea8383eb2c570213bf25d1a86", size = 73011, upload-time = "2026-08-28T10:28:07.578Z" }, + { url = "https://files.pythonhosted.org/packages/a9/c4/1407df7512a5b36cc79840e01710dc575733c461b13ab866cae77eaf87f3/kiwisolver-1.5.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:482676e5bd48d70ac99d9fc78863469845421e01184fa83f1f9366dc49f7e974", size = 134002, upload-time = "2026-08-28T10:28:08.881Z" }, + { url = "https://files.pythonhosted.org/packages/16/45/c37a21ad5c0ab581a93c55ad544721aaa1f0ae94edb29c6a678a23d013e6/kiwisolver-1.5.1-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:072bdb15a3c19a5b5dbc8f8fb1f4e1884bf4f3507eeb4cc6334401274d37a5c0", size = 194292, upload-time = "2026-08-28T10:28:11.06Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c1/69f00d627949580e43d57af0aa465df46868d7c29801c137a55374101294/kiwisolver-1.5.1-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:a5a00665d1a0e26763a7338d7e911d4598fbc1d50dd0d6b7919b7dc6c5d6569f", size = 73362, upload-time = "2026-08-28T10:28:12.449Z" }, +] + +[[package]] +name = "llvmlite" +version = "0.49.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/27/72ae94ea5c8f7349ec1c229d4cd058feb799cbd0833ad6d1b47c919b37b7/llvmlite-0.49.0.tar.gz", hash = "sha256:00f16db782f4a13c78c5804aedc434e46794a77e89999a168f9401106270e50a", size = 194467, upload-time = "2026-08-11T16:26:00.489Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/ae/3f699ebe3590e15e023a6372dd147526fd8ec398aacf9ceb844e854964a8/llvmlite-0.49.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:b541c8fac3450db7574d1f53cf9dff83f285bfed9d69bf81fe71fc2a7d4f97fe", size = 40479231, upload-time = "2026-08-11T16:23:56.773Z" }, + { url = "https://files.pythonhosted.org/packages/be/3c/e97f69c62a2d972066d9a2612ce1f3de313035ac897a5b9f787cad8b55f7/llvmlite-0.49.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6acba646d88abbc87d5c113a3d62c1fbf8b8fee11c6493f516803e30f21ae870", size = 59890658, upload-time = "2026-08-11T16:24:05.451Z" }, + { url = "https://files.pythonhosted.org/packages/69/e6/e942ee08605fc0526ff3854260c384d8315a5830e16c4c2a5aebc14dc9bf/llvmlite-0.49.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ec8ad805e7515cb8440a690eb3cef4d34acb29eef80b705ec4e1c1ad3c43c68", size = 58344481, upload-time = "2026-08-11T16:24:13.503Z" }, + { url = "https://files.pythonhosted.org/packages/84/49/2a44871cac6b5a2fd4aabd68cfdaf6de9a5c7edb36dee5d47b77bda4b50f/llvmlite-0.49.0-cp312-cp312-win_amd64.whl", hash = "sha256:3a9c9e3af4e214acfefa4f73ebe7bc3fb35854a62b654edb3953f5ae33c08ba3", size = 41865543, upload-time = "2026-08-11T16:24:20.41Z" }, + { url = "https://files.pythonhosted.org/packages/7d/85/0b536a3c59f2636d9dd51dda832b6c1d0ffec37608429dedf128664918f1/llvmlite-0.49.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:039fa4054a06f537fb39248d4472284ca96be311a142ec09e69f95630ab469cc", size = 40479230, upload-time = "2026-08-11T16:24:27.295Z" }, + { url = "https://files.pythonhosted.org/packages/8e/1c/ca8ba47b057b793099784475499771780ec46839f2782f753a7079d23520/llvmlite-0.49.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ddc7aecd4f56397ed6e8f120ec5dcd5a1a8f0e6032ca4af413462792d4dca2e3", size = 59890659, upload-time = "2026-08-11T16:24:35.595Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/9526dfdd33a923f33e29a18b8f9801ee7ee4b7397e88d28192c1024c4a75/llvmlite-0.49.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d3dee64784201b64c13a8df62c48a4f4218858faaa65889866bb29bdc243c038", size = 58344482, upload-time = "2026-08-11T16:24:45.79Z" }, + { url = "https://files.pythonhosted.org/packages/96/7f/9f5afcf6476b228d6b170408f377a0c4f91477fc1fc91f8141088b45bf46/llvmlite-0.49.0-cp313-cp313-win_amd64.whl", hash = "sha256:a1b414dc6b164738ec39dd8987cea73829057b7dd92fc6d91b52838385fc1dd2", size = 41865544, upload-time = "2026-08-11T16:24:53.962Z" }, + { url = "https://files.pythonhosted.org/packages/25/d1/16599b8c9f21802448059482eab48a9e74086dc56b901a677ba355565e64/llvmlite-0.49.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:80a84683d04516bb51da1bbeebddaf2c2f558809c93078a8f91807909ae331f8", size = 40479230, upload-time = "2026-08-11T16:25:01.513Z" }, + { url = "https://files.pythonhosted.org/packages/3a/61/0b23849141a4c4e7091fcd158ebb45195896974bebca3e58fee7cad4b4f4/llvmlite-0.49.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4281a0171d66d2098adce4ba706b8c550b1b10718650f682d64cde16e84e4de5", size = 59890659, upload-time = "2026-08-11T16:25:08.733Z" }, + { url = "https://files.pythonhosted.org/packages/c4/92/628692b74b31e27af9ba7e8ba651941ee4956959d5478123c453f59aad4a/llvmlite-0.49.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b095f15fb12c4d90495df5b1a3772b4732cc408398b204a787dbedd370e09c69", size = 58344479, upload-time = "2026-08-11T16:25:15.731Z" }, + { url = "https://files.pythonhosted.org/packages/96/8a/412fc273521b02cbfe0b5f8ad56cc696385f6eaeecdb9e9ae6a90111d98d/llvmlite-0.49.0-cp314-cp314-win_amd64.whl", hash = "sha256:294e2f0b70aef8f92d0ae7b203e2609f08beb39437eee73de59a21669331aae9", size = 42986588, upload-time = "2026-08-11T16:25:22.534Z" }, + { url = "https://files.pythonhosted.org/packages/fc/15/f47cf45c00c8b165ac3d268502dcb21d900e86f27fd338268a66ce922ab0/llvmlite-0.49.0-cp314-cp314-win_arm64.whl", hash = "sha256:95d1071023ed858b79f6971954fd7cc1f5dbcbab987718a4ccbe1411e47d0b81", size = 37441881, upload-time = "2026-08-11T16:25:28.324Z" }, + { url = "https://files.pythonhosted.org/packages/e8/2e/eafd488766d1c02413cba24f7b22acb9b3ccdfd8407e98d30eb16bac4e2a/llvmlite-0.49.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:f3f2ff0aeb17d34fcce9f79b99baac441cfd3efa41b83e233ca4530a72381f72", size = 40479230, upload-time = "2026-08-11T16:25:35.125Z" }, + { url = "https://files.pythonhosted.org/packages/98/07/a2c4f04e2111ccc274b4d5e3331398a9dcf6d6e5e55d6444b1ad9d6381cf/llvmlite-0.49.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d5555ea1d63928481cbf7fcb1d67452b216c7e5b393a4eb7aa1401e67f2a4fc4", size = 59890658, upload-time = "2026-08-11T16:25:43.294Z" }, + { url = "https://files.pythonhosted.org/packages/80/f9/7b7b50f80b4585bcd78675ff3110c256877b11df32a8cde284f851762f57/llvmlite-0.49.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32adb84fdaae28aeb86fdb6253084ee707ee157289a2e98fe3caf48a62bee82", size = 58344482, upload-time = "2026-08-11T16:25:51.527Z" }, + { url = "https://files.pythonhosted.org/packages/d8/c6/32d68bfbf1d0c36888530ef6fd72864861af23dc546302b41033471a8c3a/llvmlite-0.49.0-cp314-cp314t-win_amd64.whl", hash = "sha256:be637e465010bc9c50f070468f7f1cf5385e92fee364d192dd5e6cea790ecba9", size = 42986602, upload-time = "2026-08-11T16:25:57.69Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, ] [[package]] name = "matplotlib" -version = "3.9.4" +version = "3.11.1" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.10'", +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/64/f9a391af28f518b11ad45a8a712353c94a0aefce09d3703200e5c54b610a/matplotlib-3.11.1.tar.gz", hash = "sha256:69647db5746941c793d6e445a4cd349323ffb87d9cc958c2ad84a659b4832d30", size = 32612045, upload-time = "2026-07-18T03:39:46.63Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/6c/7ef7ebcb2bd9739b2b66b18b076e077f44bb46fdbe28ca0506edb3c62c79/matplotlib-3.11.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e15ef41507f3d525f46154ac9e3ae785dacde9f20e593a25de8986267892ef74", size = 9453849, upload-time = "2026-07-18T03:38:19.593Z" }, + { url = "https://files.pythonhosted.org/packages/eb/f8/6d0c312c8d9738e7d9677f09fe5c986b3239e651a7b73a2deb38b65e4a71/matplotlib-3.11.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:21a67b961a6d597bca54fae826cd20695ba4a6e4d05424a08da6e13e3176fd6b", size = 9283113, upload-time = "2026-07-18T03:38:21.95Z" }, + { url = "https://files.pythonhosted.org/packages/c9/cf/b4ad2cc81b6672ea29ea04e64e350a9f9b493b0908ccd884c67eeff8f7b2/matplotlib-3.11.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba8f811b8ddfac493734d6af0b2dff96919d0c28ca0d641858dab4262777c6ea", size = 10035615, upload-time = "2026-07-18T03:38:24.315Z" }, + { url = "https://files.pythonhosted.org/packages/88/90/4e10e033d9b66589d8ed98b84c95cdbb57033d57c1f41339d7393dbd2f2e/matplotlib-3.11.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c52f7ad20ef476806ed212380b1d54d20310c8b86bdc2c9a68b51f0024a44472", size = 10842559, upload-time = "2026-07-18T03:38:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/88/eb/799612d0f8cd3e816a10fec59329fca52cd2353264df80378dfc541ae855/matplotlib-3.11.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8b14eb22961fe865efb0e4ff167e333e428908b00115a8d800ccb65ee108e481", size = 10927532, upload-time = "2026-07-18T03:38:28.532Z" }, + { url = "https://files.pythonhosted.org/packages/88/89/56649bbaa2fd12e20f3be03dbcc135b0c8676d88bac17977599e3eb442a0/matplotlib-3.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:88a2a27dd9691ae448dfae4b26f59036be90c3c28757edd3553a29559d00859f", size = 9333886, upload-time = "2026-07-18T03:38:30.477Z" }, + { url = "https://files.pythonhosted.org/packages/c1/11/4d124efbbad677b7b7552f6f85a3bd432d4232f95400cea98fcd2ae36ef3/matplotlib-3.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:480194afceca4df2f137c2721227d3cba67121fbf4397b69cee7f83714b0a58a", size = 9007545, upload-time = "2026-07-18T03:38:32.833Z" }, + { url = "https://files.pythonhosted.org/packages/04/6c/4798363b7fb5644e309fe1fac30216e9146c9f70859d80d588c18caf5317/matplotlib-3.11.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6771b0cd7838c6a857a7209814158c0ad09bfef878db3033dd82d70ad101f191", size = 9454341, upload-time = "2026-07-18T03:38:35.001Z" }, + { url = "https://files.pythonhosted.org/packages/59/98/6acadbe7f98df19d274bc107ac58bb439fa75df82c33dc110d71a4a8501f/matplotlib-3.11.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2abdee5ffa2fe11b2d19f7a5c63b785fb7c28cc46c7bc1814156341d9d1a33e1", size = 9283627, upload-time = "2026-07-18T03:38:37.061Z" }, + { url = "https://files.pythonhosted.org/packages/24/ea/65cec46fe241390ccea1b1754207ee28eb71c5ab866bd5f22fe47e538fa4/matplotlib-3.11.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0a19dcf73406d3746d25a5ed42d713604c9a3e024d129b102852b0d941cb9f3", size = 10035860, upload-time = "2026-07-18T03:38:39.663Z" }, + { url = "https://files.pythonhosted.org/packages/c7/10/63fdccccbabe002fb0960876baabc5e3f24d9c1bb4cfb25651457f74b3a0/matplotlib-3.11.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7389b77ed2ab0552f46d9a90b81b7b8e6dfcdc42adc36c37a0865799843e0e3e", size = 10843594, upload-time = "2026-07-18T03:38:42.144Z" }, + { url = "https://files.pythonhosted.org/packages/98/51/a1155945bff7b91381875022ac1522c5dfdac0d006be8e7df389b3134eae/matplotlib-3.11.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c90be0b73568da4f662afac580956a76e308437e641b4a45aa08925eeb67d95f", size = 10927962, upload-time = "2026-07-18T03:38:44.302Z" }, + { url = "https://files.pythonhosted.org/packages/0d/3a/3d5e1f42dc761bf53401a62a83ff93389b37de9d2c093b2a3aa49ac34f1b/matplotlib-3.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:68408341f2312836fbbdf6b3c78047f65b2d8752f5fd221c3e72d348f5b34f8b", size = 9334074, upload-time = "2026-07-18T03:38:46.616Z" }, + { url = "https://files.pythonhosted.org/packages/e2/db/3f5ea5a5b64060ef5e1ff60a19170423e41ce21b8497a6fe15a36e0b43e3/matplotlib-3.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:0c1f44890d435c1b4ef52f701ad5828cb450ea97bcc83918fda6be74965d6cd2", size = 9007662, upload-time = "2026-07-18T03:38:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/98/6e/c7ae5e0531425b69c0826b00ebbc264c85cab853f1cd6e096c9983c2cdc1/matplotlib-3.11.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:5e510088c27a89d53580a752f959146893563e63c330e161d159b0fee652af6f", size = 9503790, upload-time = "2026-07-18T03:38:51.527Z" }, + { url = "https://files.pythonhosted.org/packages/92/79/15be162e0a2ed546939674e2e97d0e33ec2447d86d4d4e611fa295bb178c/matplotlib-3.11.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:1524e2bdd48a93557aa47ddcfe9c225dfdd57d5a01a5c49128c20f0632980ee1", size = 9336148, upload-time = "2026-07-18T03:38:53.564Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7f/36ffe144fc4aacfe0e3ed2318f72b6755d1e73b041d619b4d393e60f5a66/matplotlib-3.11.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:11664c551345553db92e61cae6cf1376f138f8c47cafdf13b64b18f3e3e9e464", size = 10049244, upload-time = "2026-07-18T03:38:55.911Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/55812d68c0a840d3a463638f48c00ab1fe338518ec49a640cb6473b444af/matplotlib-3.11.1-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e1f8922ba31959cf6a9dfb51be64b7f7bc582801a3957dc0c2f3afcd3537adf", size = 10860798, upload-time = "2026-07-18T03:38:58.282Z" }, + { url = "https://files.pythonhosted.org/packages/7a/64/cca444b4eb5e6c768c44fc5e1f0b5211f20ca2b282778051996e996a2bdf/matplotlib-3.11.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83235693abde86e5e0129998f80ee39fc7f58e6d56a88fafb28a9278833e9d5f", size = 10943282, upload-time = "2026-07-18T03:39:00.465Z" }, + { url = "https://files.pythonhosted.org/packages/e5/0f/a49c329d394f2e9ef38506982107e8b04ecf94dd41a9d8423ff82cc737c7/matplotlib-3.11.1-cp313-cp313t-win_amd64.whl", hash = "sha256:9a076f4fc5cdc43fdf510f5981418d25c2db4973418d9f22d8bb3dc8045ada78", size = 9383532, upload-time = "2026-07-18T03:39:02.468Z" }, + { url = "https://files.pythonhosted.org/packages/e4/50/103e86afb806d8f64d04ede14e4cfc09dbfc25f512421ff85fdd6ebd59cf/matplotlib-3.11.1-cp313-cp313t-win_arm64.whl", hash = "sha256:216fbb93a74add02ddb4cb38ef5348f59ac00b3e84567eaf16598772d40e150a", size = 9059665, upload-time = "2026-07-18T03:39:04.607Z" }, + { url = "https://files.pythonhosted.org/packages/35/04/3079499fa8cb661ea66d13d6439d5a3ae6710a7afd5c7f72e08914f275f8/matplotlib-3.11.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:30c492d4ba9448595b6fd8708c6725963f8148e25c0d8842948da5b05f0ee8d3", size = 9456022, upload-time = "2026-07-18T03:39:07.041Z" }, + { url = "https://files.pythonhosted.org/packages/53/a2/69acfe84ec1f32930e801a5782a07fc5c79c8c6599a507b806d859d5da8e/matplotlib-3.11.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ac104be2768ffdd8655db9e71b768cbb45f2b9aa7b450cf1595e8f65d3822319", size = 9285475, upload-time = "2026-07-18T03:39:09.562Z" }, + { url = "https://files.pythonhosted.org/packages/d3/b3/31b15a2ca56d4ddd6aaa1c884c2f51cf9a61cfaf5ca6f6fbd6343d38e6df/matplotlib-3.11.1-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6be943cb68bc6660ead58c55b3aa6366cba2ef7feb06460fbcce32360376f19f", size = 10847102, upload-time = "2026-07-18T03:39:11.532Z" }, + { url = "https://files.pythonhosted.org/packages/64/0d/a17e966e620545c1548125af0b29ac812dd17b197a18a7462ac12fa859ee/matplotlib-3.11.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5af0dcda57d471440a7b5b623e70e0a61003518443d9098f211a96ecfbbc25be", size = 11131087, upload-time = "2026-07-18T03:39:13.764Z" }, + { url = "https://files.pythonhosted.org/packages/97/c5/5e100efdd67abb7de20befaa333612ef9bfc63417fb71398f904f25d083c/matplotlib-3.11.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3d3fd84082b1afbd9398466c81309e20045be20d48fe0fb18c43504d164cbbb2", size = 10929036, upload-time = "2026-07-18T03:39:16.888Z" }, + { url = "https://files.pythonhosted.org/packages/ce/04/d719a0a36930ecc8dfc801ff340f9dcfc4223f8ca5d39d06b4020032fff8/matplotlib-3.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:9601a1e90be21e4884c53b4f3dc3ee0544654946f9975258d691f1c2e2f119c6", size = 9489571, upload-time = "2026-07-18T03:39:19.449Z" }, + { url = "https://files.pythonhosted.org/packages/48/65/facabdc2f1f6caba7e856db64dfedddca25f7608df07d96a1c8fd114fd3b/matplotlib-3.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:ae30c6109848ac0f9fa36c5d6270938487614c47ba31860bd5361266dabc5685", size = 9164486, upload-time = "2026-07-18T03:39:21.424Z" }, + { url = "https://files.pythonhosted.org/packages/88/dd/18da6cd01cf96354534f98c468a25380c68ce582a2c9dd0cae12b04af4f2/matplotlib-3.11.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:dadfe80797174e2984aae3be0b77594a3c72d2c0a40fbd4a0de48d2728caf3ae", size = 9504876, upload-time = "2026-07-18T03:39:23.633Z" }, + { url = "https://files.pythonhosted.org/packages/79/b0/f0b63555a18b79d038c81fd6126f35fc4dfce0eaff48d96103348c7cf935/matplotlib-3.11.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:89b193b255f4f6f7948dbcee3691f4f341ab05d9a8874a67b45ddb4182922eda", size = 9336120, upload-time = "2026-07-18T03:39:25.797Z" }, + { url = "https://files.pythonhosted.org/packages/c6/dd/f210ec7c4a6f198d5567237048a93d0811fb5a1f1691f13320e592f95b41/matplotlib-3.11.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:191163532cdefcb1571ca38a6d7e6474baccde64495783e6ba47aa07ec4b9bbb", size = 10858033, upload-time = "2026-07-18T03:39:27.999Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d2/d6d5324507c5fbb316db48e258c09c2807f3de03d9af47017e120070926f/matplotlib-3.11.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9fdf1c818ab05d0e74002091ddaf414478a3a449ec9d51c8976d45be7e3a01e2", size = 11141827, upload-time = "2026-07-18T03:39:30.092Z" }, + { url = "https://files.pythonhosted.org/packages/0f/68/3c22e9320bdce2c4d2f1320643ef706db7a24cb7420eea28b97a2d67f5a8/matplotlib-3.11.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b937b9dba5f5f6c1e31c47abe2186c865c0914fd18f2ce0dfc39c9adcef5951d", size = 10943061, upload-time = "2026-07-18T03:39:32.356Z" }, + { url = "https://files.pythonhosted.org/packages/f6/4a/907ed190ee81a9df581e0ed5456134fc0f7cb55ffcfda2f9e54ca900761c/matplotlib-3.11.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f2912f647f3fbe1ccf085f91e213936f9101bead81a5e670565b1f1b3712f4fb", size = 9540074, upload-time = "2026-07-18T03:39:34.789Z" }, + { url = "https://files.pythonhosted.org/packages/23/d4/97c19b77e0a6e3b48581185bb65088f431cd20186076cc0f650a1757ea46/matplotlib-3.11.1-cp314-cp314t-win_arm64.whl", hash = "sha256:54d47b8ae8b579633a3902ca5b4ad6c1e132a5626d64447b2e22a66394e79987", size = 9213472, upload-time = "2026-07-18T03:39:37.141Z" }, ] + +[[package]] +name = "matplotlib-inline" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "contourpy", version = "1.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "cycler", marker = "python_full_version < '3.10'" }, - { name = "fonttools", marker = "python_full_version < '3.10'" }, - { name = "importlib-resources", marker = "python_full_version < '3.10'" }, - { name = "kiwisolver", marker = "python_full_version < '3.10'" }, - { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "packaging", marker = "python_full_version < '3.10'" }, - { name = "pillow", marker = "python_full_version < '3.10'" }, - { name = "pyparsing", marker = "python_full_version < '3.10'" }, - { name = "python-dateutil", marker = "python_full_version < '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/df/17/1747b4154034befd0ed33b52538f5eb7752d05bb51c5e2a31470c3bc7d52/matplotlib-3.9.4.tar.gz", hash = "sha256:1e00e8be7393cbdc6fedfa8a6fba02cf3e83814b285db1c60b906a023ba41bc3", size = 36106529 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/94/27d2e2c30d54b56c7b764acc1874a909e34d1965a427fc7092bb6a588b63/matplotlib-3.9.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:c5fdd7abfb706dfa8d307af64a87f1a862879ec3cd8d0ec8637458f0885b9c50", size = 7885089 }, - { url = "https://files.pythonhosted.org/packages/c6/25/828273307e40a68eb8e9df832b6b2aaad075864fdc1de4b1b81e40b09e48/matplotlib-3.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d89bc4e85e40a71d1477780366c27fb7c6494d293e1617788986f74e2a03d7ff", size = 7770600 }, - { url = "https://files.pythonhosted.org/packages/f2/65/f841a422ec994da5123368d76b126acf4fc02ea7459b6e37c4891b555b83/matplotlib-3.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ddf9f3c26aae695c5daafbf6b94e4c1a30d6cd617ba594bbbded3b33a1fcfa26", size = 8200138 }, - { url = "https://files.pythonhosted.org/packages/07/06/272aca07a38804d93b6050813de41ca7ab0e29ba7a9dd098e12037c919a9/matplotlib-3.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18ebcf248030173b59a868fda1fe42397253f6698995b55e81e1f57431d85e50", size = 8312711 }, - { url = "https://files.pythonhosted.org/packages/98/37/f13e23b233c526b7e27ad61be0a771894a079e0f7494a10d8d81557e0e9a/matplotlib-3.9.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:974896ec43c672ec23f3f8c648981e8bc880ee163146e0312a9b8def2fac66f5", size = 9090622 }, - { url = "https://files.pythonhosted.org/packages/4f/8c/b1f5bd2bd70e60f93b1b54c4d5ba7a992312021d0ddddf572f9a1a6d9348/matplotlib-3.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:4598c394ae9711cec135639374e70871fa36b56afae17bdf032a345be552a88d", size = 7828211 }, - { url = "https://files.pythonhosted.org/packages/74/4b/65be7959a8fa118a3929b49a842de5b78bb55475236fcf64f3e308ff74a0/matplotlib-3.9.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d4dd29641d9fb8bc4492420c5480398dd40a09afd73aebe4eb9d0071a05fbe0c", size = 7894430 }, - { url = "https://files.pythonhosted.org/packages/e9/18/80f70d91896e0a517b4a051c3fd540daa131630fd75e02e250365353b253/matplotlib-3.9.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30e5b22e8bcfb95442bf7d48b0d7f3bdf4a450cbf68986ea45fca3d11ae9d099", size = 7780045 }, - { url = "https://files.pythonhosted.org/packages/a2/73/ccb381026e3238c5c25c3609ba4157b2d1a617ec98d65a8b4ee4e1e74d02/matplotlib-3.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bb0030d1d447fd56dcc23b4c64a26e44e898f0416276cac1ebc25522e0ac249", size = 8209906 }, - { url = "https://files.pythonhosted.org/packages/ab/33/1648da77b74741c89f5ea95cbf42a291b4b364f2660b316318811404ed97/matplotlib-3.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aca90ed222ac3565d2752b83dbb27627480d27662671e4d39da72e97f657a423", size = 8322873 }, - { url = "https://files.pythonhosted.org/packages/57/d3/8447ba78bc6593c9044c372d1609f8ea10fb1e071e7a9e0747bea74fc16c/matplotlib-3.9.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a181b2aa2906c608fcae72f977a4a2d76e385578939891b91c2550c39ecf361e", size = 9099566 }, - { url = "https://files.pythonhosted.org/packages/23/e1/4f0e237bf349c02ff9d1b6e7109f1a17f745263809b9714a8576dc17752b/matplotlib-3.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:1f6882828231eca17f501c4dcd98a05abb3f03d157fbc0769c6911fe08b6cfd3", size = 7838065 }, - { url = "https://files.pythonhosted.org/packages/1a/2b/c918bf6c19d6445d1cefe3d2e42cb740fb997e14ab19d4daeb6a7ab8a157/matplotlib-3.9.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:dfc48d67e6661378a21c2983200a654b72b5c5cdbd5d2cf6e5e1ece860f0cc70", size = 7891131 }, - { url = "https://files.pythonhosted.org/packages/c1/e5/b4e8fc601ca302afeeabf45f30e706a445c7979a180e3a978b78b2b681a4/matplotlib-3.9.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:47aef0fab8332d02d68e786eba8113ffd6f862182ea2999379dec9e237b7e483", size = 7776365 }, - { url = "https://files.pythonhosted.org/packages/99/06/b991886c506506476e5d83625c5970c656a491b9f80161458fed94597808/matplotlib-3.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fba1f52c6b7dc764097f52fd9ab627b90db452c9feb653a59945de16752e965f", size = 8200707 }, - { url = "https://files.pythonhosted.org/packages/c3/e2/556b627498cb27e61026f2d1ba86a78ad1b836fef0996bef5440e8bc9559/matplotlib-3.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:173ac3748acaac21afcc3fa1633924609ba1b87749006bc25051c52c422a5d00", size = 8313761 }, - { url = "https://files.pythonhosted.org/packages/58/ff/165af33ec766ff818306ea88e91f9f60d2a6ed543be1eb122a98acbf3b0d/matplotlib-3.9.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:320edea0cadc07007765e33f878b13b3738ffa9745c5f707705692df70ffe0e0", size = 9095284 }, - { url = "https://files.pythonhosted.org/packages/9f/8b/3d0c7a002db3b1ed702731c2a9a06d78d035f1f2fb0fb936a8e43cc1e9f4/matplotlib-3.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a4a4cfc82330b27042a7169533da7991e8789d180dd5b3daeaee57d75cd5a03b", size = 7841160 }, - { url = "https://files.pythonhosted.org/packages/49/b1/999f89a7556d101b23a2f0b54f1b6e140d73f56804da1398f2f0bc0924bc/matplotlib-3.9.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:37eeffeeca3c940985b80f5b9a7b95ea35671e0e7405001f249848d2b62351b6", size = 7891499 }, - { url = "https://files.pythonhosted.org/packages/87/7b/06a32b13a684977653396a1bfcd34d4e7539c5d55c8cbfaa8ae04d47e4a9/matplotlib-3.9.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3e7465ac859ee4abcb0d836137cd8414e7bb7ad330d905abced457217d4f0f45", size = 7776802 }, - { url = "https://files.pythonhosted.org/packages/65/87/ac498451aff739e515891bbb92e566f3c7ef31891aaa878402a71f9b0910/matplotlib-3.9.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4c12302c34afa0cf061bea23b331e747e5e554b0fa595c96e01c7b75bc3b858", size = 8200802 }, - { url = "https://files.pythonhosted.org/packages/f8/6b/9eb761c00e1cb838f6c92e5f25dcda3f56a87a52f6cb8fdfa561e6cf6a13/matplotlib-3.9.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b8c97917f21b75e72108b97707ba3d48f171541a74aa2a56df7a40626bafc64", size = 8313880 }, - { url = "https://files.pythonhosted.org/packages/d7/a2/c8eaa600e2085eec7e38cbbcc58a30fc78f8224939d31d3152bdafc01fd1/matplotlib-3.9.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0229803bd7e19271b03cb09f27db76c918c467aa4ce2ae168171bc67c3f508df", size = 9094637 }, - { url = "https://files.pythonhosted.org/packages/71/1f/c6e1daea55b7bfeb3d84c6cb1abc449f6a02b181e7e2a5e4db34c3afb793/matplotlib-3.9.4-cp313-cp313-win_amd64.whl", hash = "sha256:7c0d8ef442ebf56ff5e206f8083d08252ee738e04f3dc88ea882853a05488799", size = 7841311 }, - { url = "https://files.pythonhosted.org/packages/c0/3a/2757d3f7d388b14dd48f5a83bea65b6d69f000e86b8f28f74d86e0d375bd/matplotlib-3.9.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a04c3b00066a688834356d196136349cb32f5e1003c55ac419e91585168b88fb", size = 7919989 }, - { url = "https://files.pythonhosted.org/packages/24/28/f5077c79a4f521589a37fe1062d6a6ea3534e068213f7357e7cfffc2e17a/matplotlib-3.9.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:04c519587f6c210626741a1e9a68eefc05966ede24205db8982841826af5871a", size = 7809417 }, - { url = "https://files.pythonhosted.org/packages/36/c8/c523fd2963156692916a8eb7d4069084cf729359f7955cf09075deddfeaf/matplotlib-3.9.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:308afbf1a228b8b525fcd5cec17f246bbbb63b175a3ef6eb7b4d33287ca0cf0c", size = 8226258 }, - { url = "https://files.pythonhosted.org/packages/f6/88/499bf4b8fa9349b6f5c0cf4cead0ebe5da9d67769129f1b5651e5ac51fbc/matplotlib-3.9.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddb3b02246ddcffd3ce98e88fed5b238bc5faff10dbbaa42090ea13241d15764", size = 8335849 }, - { url = "https://files.pythonhosted.org/packages/b8/9f/20a4156b9726188646a030774ee337d5ff695a965be45ce4dbcb9312c170/matplotlib-3.9.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8a75287e9cb9eee48cb79ec1d806f75b29c0fde978cb7223a1f4c5848d696041", size = 9102152 }, - { url = "https://files.pythonhosted.org/packages/10/11/237f9c3a4e8d810b1759b67ff2da7c32c04f9c80aa475e7beb36ed43a8fb/matplotlib-3.9.4-cp313-cp313t-win_amd64.whl", hash = "sha256:488deb7af140f0ba86da003e66e10d55ff915e152c78b4b66d231638400b1965", size = 7896987 }, - { url = "https://files.pythonhosted.org/packages/56/eb/501b465c9fef28f158e414ea3a417913dc2ac748564c7ed41535f23445b4/matplotlib-3.9.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:3c3724d89a387ddf78ff88d2a30ca78ac2b4c89cf37f2db4bd453c34799e933c", size = 7885919 }, - { url = "https://files.pythonhosted.org/packages/da/36/236fbd868b6c91309a5206bd90c3f881f4f44b2d997cd1d6239ef652f878/matplotlib-3.9.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d5f0a8430ffe23d7e32cfd86445864ccad141797f7d25b7c41759a5b5d17cfd7", size = 7771486 }, - { url = "https://files.pythonhosted.org/packages/e0/4b/105caf2d54d5ed11d9f4335398f5103001a03515f2126c936a752ccf1461/matplotlib-3.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bb0141a21aef3b64b633dc4d16cbd5fc538b727e4958be82a0e1c92a234160e", size = 8201838 }, - { url = "https://files.pythonhosted.org/packages/5d/a7/bb01188fb4013d34d274caf44a2f8091255b0497438e8b6c0a7c1710c692/matplotlib-3.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:57aa235109e9eed52e2c2949db17da185383fa71083c00c6c143a60e07e0888c", size = 8314492 }, - { url = "https://files.pythonhosted.org/packages/33/19/02e1a37f7141fc605b193e927d0a9cdf9dc124a20b9e68793f4ffea19695/matplotlib-3.9.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:b18c600061477ccfdd1e6fd050c33d8be82431700f3452b297a56d9ed7037abb", size = 9092500 }, - { url = "https://files.pythonhosted.org/packages/57/68/c2feb4667adbf882ffa4b3e0ac9967f848980d9f8b5bebd86644aa67ce6a/matplotlib-3.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:ef5f2d1b67d2d2145ff75e10f8c008bfbf71d45137c4b648c87193e7dd053eac", size = 7822962 }, - { url = "https://files.pythonhosted.org/packages/0c/22/2ef6a364cd3f565442b0b055e0599744f1e4314ec7326cdaaa48a4d864d7/matplotlib-3.9.4-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:44e0ed786d769d85bc787b0606a53f2d8d2d1d3c8a2608237365e9121c1a338c", size = 7877995 }, - { url = "https://files.pythonhosted.org/packages/87/b8/2737456e566e9f4d94ae76b8aa0d953d9acb847714f9a7ad80184474f5be/matplotlib-3.9.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:09debb9ce941eb23ecdbe7eab972b1c3e0276dcf01688073faff7b0f61d6c6ca", size = 7769300 }, - { url = "https://files.pythonhosted.org/packages/b2/1f/e709c6ec7b5321e6568769baa288c7178e60a93a9da9e682b39450da0e29/matplotlib-3.9.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcc53cf157a657bfd03afab14774d54ba73aa84d42cfe2480c91bd94873952db", size = 8313423 }, - { url = "https://files.pythonhosted.org/packages/5e/b6/5a1f868782cd13f053a679984e222007ecff654a9bfbac6b27a65f4eeb05/matplotlib-3.9.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ad45da51be7ad02387801fd154ef74d942f49fe3fcd26a64c94842ba7ec0d865", size = 7854624 }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, ] [[package]] -name = "matplotlib" -version = "3.10.0" +name = "mistune" +version = "3.3.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/92/328a294a6de83bacb95bed01f04e0eaff4e3616ee359fc821a5dfc539b02/mistune-3.3.4.tar.gz", hash = "sha256:58b5c96d6fcb61190dfe5fae498d2b2065f99cf61e9649418fd54cf1ada86dfe", size = 121426, upload-time = "2026-07-22T05:22:30.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/e4/288365afae98953bc01de09f686f40d8ee84578135aa7767d5d4e60b5278/mistune-3.3.4-py3-none-any.whl", hash = "sha256:ee015381e955e370962968befe1d729ab60fafb6a715ac6751763fbce38c8d4a", size = 66862, upload-time = "2026-07-22T05:22:29.419Z" }, +] + +[[package]] +name = "nbclient" +version = "0.11.0" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.10'", +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/a5/b3bae4b590c0cbcada2c63a34f7580024e834a8ba213e949a2f906705787/nbclient-0.11.0.tar.gz", hash = "sha256:04a134a5b087f2c5887f228aca155db50169b8cd9334dee6942c8e927e56081a", size = 62535, upload-time = "2026-06-05T07:52:41.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/c9/94d73e5a01c5b926c3fa2496e97d7a8dc28ed5a77c0b2ed712f1a62e6694/nbclient-0.11.0-py3-none-any.whl", hash = "sha256:ef7fa0d59d6e1d41103933d8a445a18d5de860ca6b613b87b8574accdb3c2895", size = 25288, upload-time = "2026-06-05T07:52:40.115Z" }, ] + +[[package]] +name = "nbconvert" +version = "7.17.1" +source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "contourpy", version = "1.3.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "cycler", marker = "python_full_version >= '3.10'" }, - { name = "fonttools", marker = "python_full_version >= '3.10'" }, - { name = "kiwisolver", marker = "python_full_version >= '3.10'" }, - { name = "numpy", version = "2.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "packaging", marker = "python_full_version >= '3.10'" }, - { name = "pillow", marker = "python_full_version >= '3.10'" }, - { name = "pyparsing", marker = "python_full_version >= '3.10'" }, - { name = "python-dateutil", marker = "python_full_version >= '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/68/dd/fa2e1a45fce2d09f4aea3cee169760e672c8262325aa5796c49d543dc7e6/matplotlib-3.10.0.tar.gz", hash = "sha256:b886d02a581b96704c9d1ffe55709e49b4d2d52709ccebc4be42db856e511278", size = 36686418 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/09/ec/3cdff7b5239adaaacefcc4f77c316dfbbdf853c4ed2beec467e0fec31b9f/matplotlib-3.10.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2c5829a5a1dd5a71f0e31e6e8bb449bc0ee9dbfb05ad28fc0c6b55101b3a4be6", size = 8160551 }, - { url = "https://files.pythonhosted.org/packages/41/f2/b518f2c7f29895c9b167bf79f8529c63383ae94eaf49a247a4528e9a148d/matplotlib-3.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2a43cbefe22d653ab34bb55d42384ed30f611bcbdea1f8d7f431011a2e1c62e", size = 8034853 }, - { url = "https://files.pythonhosted.org/packages/ed/8d/45754b4affdb8f0d1a44e4e2bcd932cdf35b256b60d5eda9f455bb293ed0/matplotlib-3.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:607b16c8a73943df110f99ee2e940b8a1cbf9714b65307c040d422558397dac5", size = 8446724 }, - { url = "https://files.pythonhosted.org/packages/09/5a/a113495110ae3e3395c72d82d7bc4802902e46dc797f6b041e572f195c56/matplotlib-3.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01d2b19f13aeec2e759414d3bfe19ddfb16b13a1250add08d46d5ff6f9be83c6", size = 8583905 }, - { url = "https://files.pythonhosted.org/packages/12/b1/8b1655b4c9ed4600c817c419f7eaaf70082630efd7556a5b2e77a8a3cdaf/matplotlib-3.10.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e6c6461e1fc63df30bf6f80f0b93f5b6784299f721bc28530477acd51bfc3d1", size = 9395223 }, - { url = "https://files.pythonhosted.org/packages/5a/85/b9a54d64585a6b8737a78a61897450403c30f39e0bd3214270bb0b96f002/matplotlib-3.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:994c07b9d9fe8d25951e3202a68c17900679274dadfc1248738dcfa1bd40d7f3", size = 8025355 }, - { url = "https://files.pythonhosted.org/packages/0c/f1/e37f6c84d252867d7ddc418fff70fc661cfd363179263b08e52e8b748e30/matplotlib-3.10.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:fd44fc75522f58612ec4a33958a7e5552562b7705b42ef1b4f8c0818e304a363", size = 8171677 }, - { url = "https://files.pythonhosted.org/packages/c7/8b/92e9da1f28310a1f6572b5c55097b0c0ceb5e27486d85fb73b54f5a9b939/matplotlib-3.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c58a9622d5dbeb668f407f35f4e6bfac34bb9ecdcc81680c04d0258169747997", size = 8044945 }, - { url = "https://files.pythonhosted.org/packages/c5/cb/49e83f0fd066937a5bd3bc5c5d63093703f3637b2824df8d856e0558beef/matplotlib-3.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:845d96568ec873be63f25fa80e9e7fae4be854a66a7e2f0c8ccc99e94a8bd4ef", size = 8458269 }, - { url = "https://files.pythonhosted.org/packages/b2/7d/2d873209536b9ee17340754118a2a17988bc18981b5b56e6715ee07373ac/matplotlib-3.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5439f4c5a3e2e8eab18e2f8c3ef929772fd5641876db71f08127eed95ab64683", size = 8599369 }, - { url = "https://files.pythonhosted.org/packages/b8/03/57d6cbbe85c61fe4cbb7c94b54dce443d68c21961830833a1f34d056e5ea/matplotlib-3.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4673ff67a36152c48ddeaf1135e74ce0d4bce1bbf836ae40ed39c29edf7e2765", size = 9405992 }, - { url = "https://files.pythonhosted.org/packages/14/cf/e382598f98be11bf51dd0bc60eca44a517f6793e3dc8b9d53634a144620c/matplotlib-3.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:7e8632baebb058555ac0cde75db885c61f1212e47723d63921879806b40bec6a", size = 8034580 }, - { url = "https://files.pythonhosted.org/packages/44/c7/6b2d8cb7cc251d53c976799cacd3200add56351c175ba89ab9cbd7c1e68a/matplotlib-3.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4659665bc7c9b58f8c00317c3c2a299f7f258eeae5a5d56b4c64226fca2f7c59", size = 8172465 }, - { url = "https://files.pythonhosted.org/packages/42/2a/6d66d0fba41e13e9ca6512a0a51170f43e7e7ed3a8dfa036324100775612/matplotlib-3.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d44cb942af1693cced2604c33a9abcef6205601c445f6d0dc531d813af8a2f5a", size = 8043300 }, - { url = "https://files.pythonhosted.org/packages/90/60/2a60342b27b90a16bada939a85e29589902b41073f59668b904b15ea666c/matplotlib-3.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a994f29e968ca002b50982b27168addfd65f0105610b6be7fa515ca4b5307c95", size = 8448936 }, - { url = "https://files.pythonhosted.org/packages/a7/b2/d872fc3d753516870d520595ddd8ce4dd44fa797a240999f125f58521ad7/matplotlib-3.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b0558bae37f154fffda54d779a592bc97ca8b4701f1c710055b609a3bac44c8", size = 8594151 }, - { url = "https://files.pythonhosted.org/packages/f4/bd/b2f60cf7f57d014ab33e4f74602a2b5bdc657976db8196bbc022185f6f9c/matplotlib-3.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:503feb23bd8c8acc75541548a1d709c059b7184cde26314896e10a9f14df5f12", size = 9400347 }, - { url = "https://files.pythonhosted.org/packages/9f/6e/264673e64001b99d747aff5a288eca82826c024437a3694e19aed1decf46/matplotlib-3.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:c40ba2eb08b3f5de88152c2333c58cee7edcead0a2a0d60fcafa116b17117adc", size = 8039144 }, - { url = "https://files.pythonhosted.org/packages/72/11/1b2a094d95dcb6e6edd4a0b238177c439006c6b7a9fe8d31801237bf512f/matplotlib-3.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96f2886f5c1e466f21cc41b70c5a0cd47bfa0015eb2d5793c88ebce658600e25", size = 8173073 }, - { url = "https://files.pythonhosted.org/packages/0d/c4/87b6ad2723070511a411ea719f9c70fde64605423b184face4e94986de9d/matplotlib-3.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:12eaf48463b472c3c0f8dbacdbf906e573013df81a0ab82f0616ea4b11281908", size = 8043892 }, - { url = "https://files.pythonhosted.org/packages/57/69/cb0812a136550b21361335e9ffb7d459bf6d13e03cb7b015555d5143d2d6/matplotlib-3.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fbbabc82fde51391c4da5006f965e36d86d95f6ee83fb594b279564a4c5d0d2", size = 8450532 }, - { url = "https://files.pythonhosted.org/packages/ea/3a/bab9deb4fb199c05e9100f94d7f1c702f78d3241e6a71b784d2b88d7bebd/matplotlib-3.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad2e15300530c1a94c63cfa546e3b7864bd18ea2901317bae8bbf06a5ade6dcf", size = 8593905 }, - { url = "https://files.pythonhosted.org/packages/8b/66/742fd242f989adc1847ddf5f445815f73ad7c46aa3440690cc889cfa423c/matplotlib-3.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3547d153d70233a8496859097ef0312212e2689cdf8d7ed764441c77604095ae", size = 9399609 }, - { url = "https://files.pythonhosted.org/packages/fa/d6/54cee7142cef7d910a324a7aedf335c0c147b03658b54d49ec48166f10a6/matplotlib-3.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:c55b20591ced744aa04e8c3e4b7543ea4d650b6c3c4b208c08a05b4010e8b442", size = 8039076 }, - { url = "https://files.pythonhosted.org/packages/43/14/815d072dc36e88753433bfd0385113405efb947e6895ff7b4d2e8614a33b/matplotlib-3.10.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ade1003376731a971e398cc4ef38bb83ee8caf0aee46ac6daa4b0506db1fd06", size = 8211000 }, - { url = "https://files.pythonhosted.org/packages/9a/76/34e75f364194ec352678adcb540964be6f35ec7d3d8c75ebcb17e6839359/matplotlib-3.10.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:95b710fea129c76d30be72c3b38f330269363fbc6e570a5dd43580487380b5ff", size = 8087707 }, - { url = "https://files.pythonhosted.org/packages/c3/2b/b6bc0dff6a72d333bc7df94a66e6ce662d224e43daa8ad8ae4eaa9a77f55/matplotlib-3.10.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cdbaf909887373c3e094b0318d7ff230b2ad9dcb64da7ade654182872ab2593", size = 8477384 }, - { url = "https://files.pythonhosted.org/packages/c2/2d/b5949fb2b76e9b47ab05e25a5f5f887c70de20d8b0cbc704a4e2ee71c786/matplotlib-3.10.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d907fddb39f923d011875452ff1eca29a9e7f21722b873e90db32e5d8ddff12e", size = 8610334 }, - { url = "https://files.pythonhosted.org/packages/d6/9a/6e3c799d5134d9af44b01c787e1360bee38cf51850506ea2e743a787700b/matplotlib-3.10.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3b427392354d10975c1d0f4ee18aa5844640b512d5311ef32efd4dd7db106ede", size = 9406777 }, - { url = "https://files.pythonhosted.org/packages/0e/dd/e6ae97151e5ed648ab2ea48885bc33d39202b640eec7a2910e2c843f7ac0/matplotlib-3.10.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5fd41b0ec7ee45cd960a8e71aea7c946a28a0b8a4dcee47d2856b2af051f334c", size = 8109742 }, - { url = "https://files.pythonhosted.org/packages/32/5f/29def7ce4e815ab939b56280976ee35afffb3bbdb43f332caee74cb8c951/matplotlib-3.10.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:81713dd0d103b379de4516b861d964b1d789a144103277769238c732229d7f03", size = 8155500 }, - { url = "https://files.pythonhosted.org/packages/de/6d/d570383c9f7ca799d0a54161446f9ce7b17d6c50f2994b653514bcaa108f/matplotlib-3.10.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:359f87baedb1f836ce307f0e850d12bb5f1936f70d035561f90d41d305fdacea", size = 8032398 }, - { url = "https://files.pythonhosted.org/packages/c9/b4/680aa700d99b48e8c4393fa08e9ab8c49c0555ee6f4c9c0a5e8ea8dfde5d/matplotlib-3.10.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ae80dc3a4add4665cf2faa90138384a7ffe2a4e37c58d83e115b54287c4f06ef", size = 8587361 }, + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/01/b1/708e53fe2e429c103c6e6e159106bcf0357ac41aa4c28772bd8402339051/nbconvert-7.17.1.tar.gz", hash = "sha256:34d0d0a7e73ce3cbab6c5aae8f4f468797280b01fd8bd2ca746da8569eddd7d2", size = 865311, upload-time = "2026-04-08T00:44:14.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/f8/bb0a9d5f46819c821dc1f004aa2cc29b1d91453297dbf5ff20470f00f193/nbconvert-7.17.1-py3-none-any.whl", hash = "sha256:aa85c087b435e7bf1ffd03319f658e285f2b89eccab33bc1ba7025495ab3e7c8", size = 261927, upload-time = "2026-04-08T00:44:12.845Z" }, ] [[package]] -name = "networkx" -version = "3.2.1" +name = "nbformat" +version = "5.11.1" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.10'", +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c4/80/a84676339aaae2f1cfdf9f418701dd634aef9cc76f708ef55c36ff39c3ca/networkx-3.2.1.tar.gz", hash = "sha256:9f1bb5cf3409bf324e0a722c20bdb4c20ee39bf1c30ce8ae499c8502b0b5e0c6", size = 2073928 } +sdist = { url = "https://files.pythonhosted.org/packages/31/72/b3446efab8756e7df4b8ec587f8e611cb5a7249e4323db480802f1d3be04/nbformat-5.11.1.tar.gz", hash = "sha256:32d4521c68c6e7d5b29c76defaeed9f42ea733142b9b19f88277ce10390b9c4d", size = 147775, upload-time = "2026-08-17T08:10:51.942Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d5/f0/8fbc882ca80cf077f1b246c0e3c3465f7f415439bdea6b899f6b19f61f70/networkx-3.2.1-py3-none-any.whl", hash = "sha256:f18c69adc97877c42332c170849c96cefa91881c99a7cb3e95b7c659ebdc1ec2", size = 1647772 }, + { url = "https://files.pythonhosted.org/packages/1a/69/ee613f74085ca7103f79cd08d579c4f3177d1d26e5d3d9528d2d6536a707/nbformat-5.11.1-py3-none-any.whl", hash = "sha256:cc6698fa75f4fab8755ead786317815f13a6fee3b53311c0abb1a8b51d52f7ec", size = 79849, upload-time = "2026-08-17T08:10:50.18Z" }, ] [[package]] -name = "networkx" -version = "3.4.2" +name = "nbsphinx" +version = "0.9.8" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.10'", +dependencies = [ + { name = "docutils" }, + { name = "jinja2" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "sphinx" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e7/d1/82081750f8a78ad0399c6ed831d42623b891904e8e7b8a75878225cf1dce/nbsphinx-0.9.8.tar.gz", hash = "sha256:d0765908399a8ee2b57be7ae881cf2ea58d66db3af7bbf33e6eb48f83bea5495", size = 417469, upload-time = "2025-11-28T17:41:02.336Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/78/843bcf0cf31f88d2f8a9a063d2d80817b1901657d83d65b89b3aa835732e/nbsphinx-0.9.8-py3-none-any.whl", hash = "sha256:92d95ee91784e56bc633b60b767a6b6f23a0445f891e24641ce3c3f004759ccf", size = 31961, upload-time = "2025-11-28T17:41:00.796Z" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368 } + +[[package]] +name = "nest-asyncio2" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b4/73/731debf26e27e0a0323d7bda270dc2f634b398e38f040a09da1f4351d0aa/nest_asyncio2-1.7.2.tar.gz", hash = "sha256:1921d70b92cc4612c374928d081552efb59b83d91b2b789d935c665fa01729a8", size = 14743, upload-time = "2026-02-13T00:34:04.386Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263 }, + { url = "https://files.pythonhosted.org/packages/c5/3c/3179b85b0e1c3659f0369940200cd6d0fa900e6cefcc7ea0bc6dd0e29ffb/nest_asyncio2-1.7.2-py3-none-any.whl", hash = "sha256:f5dfa702f3f81f6a03857e9a19e2ba578c0946a4ad417b4c50a24d7ba641fe01", size = 7843, upload-time = "2026-02-13T00:34:02.691Z" }, ] [[package]] -name = "nodeenv" -version = "1.9.1" +name = "networkx" +version = "3.6.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437 } +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 }, + { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" }, ] [[package]] -name = "numpy" -version = "2.0.2" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.10'", -] -sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245 }, - { url = "https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04", size = 13738540 }, - { url = "https://files.pythonhosted.org/packages/ec/31/cc46e13bf07644efc7a4bf68df2df5fb2a1a88d0cd0da9ddc84dc0033e51/numpy-2.0.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66", size = 5300623 }, - { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774 }, - { url = "https://files.pythonhosted.org/packages/f9/a3/561c531c0e8bf082c5bef509d00d56f82e0ea7e1e3e3a7fc8fa78742a6e5/numpy-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd", size = 13907081 }, - { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451 }, - { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572 }, - { url = "https://files.pythonhosted.org/packages/3e/df/2619393b1e1b565cd2d4c4403bdd979621e2c4dea1f8532754b2598ed63b/numpy-2.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326", size = 14400722 }, - { url = "https://files.pythonhosted.org/packages/22/ad/77e921b9f256d5da36424ffb711ae79ca3f451ff8489eeca544d0701d74a/numpy-2.0.2-cp310-cp310-win32.whl", hash = "sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97", size = 6472170 }, - { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558 }, - { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137 }, - { url = "https://files.pythonhosted.org/packages/4a/d9/32de45561811a4b87fbdee23b5797394e3d1504b4a7cf40c10199848893e/numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195", size = 13703552 }, - { url = "https://files.pythonhosted.org/packages/c1/ca/2f384720020c7b244d22508cb7ab23d95f179fcfff33c31a6eeba8d6c512/numpy-2.0.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57", size = 5298957 }, - { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573 }, - { url = "https://files.pythonhosted.org/packages/a0/72/cfc3a1beb2caf4efc9d0b38a15fe34025230da27e1c08cc2eb9bfb1c7231/numpy-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669", size = 13914330 }, - { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895 }, - { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253 }, - { url = "https://files.pythonhosted.org/packages/df/87/f76450e6e1c14e5bb1eae6836478b1028e096fd02e85c1c37674606ab752/numpy-2.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15", size = 14414074 }, - { url = "https://files.pythonhosted.org/packages/5c/ca/0f0f328e1e59f73754f06e1adfb909de43726d4f24c6a3f8805f34f2b0fa/numpy-2.0.2-cp311-cp311-win32.whl", hash = "sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4", size = 6470640 }, - { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230 }, - { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803 }, - { url = "https://files.pythonhosted.org/packages/46/92/1b8b8dee833f53cef3e0a3f69b2374467789e0bb7399689582314df02651/numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e", size = 13471835 }, - { url = "https://files.pythonhosted.org/packages/7f/19/e2793bde475f1edaea6945be141aef6c8b4c669b90c90a300a8954d08f0a/numpy-2.0.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c", size = 5038499 }, - { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497 }, - { url = "https://files.pythonhosted.org/packages/72/21/67f36eac8e2d2cd652a2e69595a54128297cdcb1ff3931cfc87838874bd4/numpy-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692", size = 13621158 }, - { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173 }, - { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174 }, - { url = "https://files.pythonhosted.org/packages/71/af/a469674070c8d8408384e3012e064299f7a2de540738a8e414dcfd639996/numpy-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded", size = 14099701 }, - { url = "https://files.pythonhosted.org/packages/d0/3d/08ea9f239d0e0e939b6ca52ad403c84a2bce1bde301a8eb4888c1c1543f1/numpy-2.0.2-cp312-cp312-win32.whl", hash = "sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5", size = 6174313 }, - { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179 }, - { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942 }, - { url = "https://files.pythonhosted.org/packages/39/bc/fd298f308dcd232b56a4031fd6ddf11c43f9917fbc937e53762f7b5a3bb1/numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd", size = 13711512 }, - { url = "https://files.pythonhosted.org/packages/96/ff/06d1aa3eeb1c614eda245c1ba4fb88c483bee6520d361641331872ac4b82/numpy-2.0.2-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b", size = 5306976 }, - { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494 }, - { url = "https://files.pythonhosted.org/packages/15/31/9dffc70da6b9bbf7968f6551967fc21156207366272c2a40b4ed6008dc9b/numpy-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1", size = 13912596 }, - { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099 }, - { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823 }, - { url = "https://files.pythonhosted.org/packages/f1/46/ea25b98b13dccaebddf1a803f8c748680d972e00507cd9bc6dcdb5aa2ac1/numpy-2.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d", size = 14404424 }, - { url = "https://files.pythonhosted.org/packages/c8/a6/177dd88d95ecf07e722d21008b1b40e681a929eb9e329684d449c36586b2/numpy-2.0.2-cp39-cp39-win32.whl", hash = "sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa", size = 6476809 }, - { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314 }, - { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288 }, - { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793 }, - { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885 }, - { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784 }, +name = "numba" +version = "0.67.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "llvmlite" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/90/2544f4e3a61e501d6c9a5418fd4b905323222693d54a02cab0106a0af865/numba-0.67.0.tar.gz", hash = "sha256:cd75aa535b33fa05d9d930b1ae8af9f97a2881e96d72dfb38ec9b78284d9f851", size = 2836515, upload-time = "2026-08-11T23:04:00.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/58/915cddba90010348ed0444451132fdde9b000bcbaff1582029b5bf115d11/numba-0.67.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:6004d8d5f28d4028687fb2d972d629295b13685943bd2ed5cd8810c3b848e219", size = 2745050, upload-time = "2026-08-11T23:03:25.607Z" }, + { url = "https://files.pythonhosted.org/packages/bb/38/926757caaac18a66f057d7544a63620bf360a07d281c9f7ecadd2aa83963/numba-0.67.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f63d43db06b4756424d6d2484737c902e0ae944a0eec3e8b0b4de2c695b15caa", size = 3884596, upload-time = "2026-08-11T23:03:27.688Z" }, + { url = "https://files.pythonhosted.org/packages/4d/6d/58291dc58da39d98b32db7f044729f6d8d4920cd9622fbab3179b54ff4c4/numba-0.67.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76d3335aaeffb9dc88309420890e73497a00be08a7530441bc2b58ffe025bfa5", size = 3585290, upload-time = "2026-08-11T23:03:29.684Z" }, + { url = "https://files.pythonhosted.org/packages/6e/63/ab21828b4056afed71f9ecb40f4de26c2c19de731cc001961aca74b79464/numba-0.67.0-cp312-cp312-win_amd64.whl", hash = "sha256:50e2b72406c18cda5dd7431b0082cb85ea94e06c64c33607248fc8bef92cfb81", size = 2815645, upload-time = "2026-08-11T23:03:31.732Z" }, + { url = "https://files.pythonhosted.org/packages/49/dd/bd9fe772f6c84597b76cac229b3f2890f01a2c64fd70e48ceaae10dd65cb/numba-0.67.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:77e1c7173fee57a0d84e006c7e70346689d6cb3e7db503489bae58646b4eff7b", size = 2744872, upload-time = "2026-08-11T23:03:33.649Z" }, + { url = "https://files.pythonhosted.org/packages/a1/1c/c05609739cc41116d36e30cb2b41fb00f126bb52e1b0bac907051ad8a35d/numba-0.67.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9c4953387c77864b596d8296e2cfbdef82b0eea4166ab4864b05d226c51143e0", size = 3892004, upload-time = "2026-08-11T23:03:35.797Z" }, + { url = "https://files.pythonhosted.org/packages/4a/77/a5276ad4178250403e0e2251f3e1f8ac18feac779b0474a8bcb08558490d/numba-0.67.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88f6e0f5cb6c545e158b6ef0496c01b6d6958a7ccc6634a1576a94bbbab29ff2", size = 3591878, upload-time = "2026-08-11T23:03:37.845Z" }, + { url = "https://files.pythonhosted.org/packages/0f/80/d48f0ba7442516ceb5a1585f0c81d3aa531bc96bfcabcd9f8f925768c426/numba-0.67.0-cp313-cp313-win_amd64.whl", hash = "sha256:b68ad5125fe245339cc8dcc036081fc1ea482c5063387b9612a76ccd83dc91cd", size = 2815504, upload-time = "2026-08-11T23:03:39.736Z" }, + { url = "https://files.pythonhosted.org/packages/d7/16/345b1e4774a08247aafcfdb93d4e8d24a3646366cbe72de33053fc0de1b5/numba-0.67.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:f99f880ff25f418a67f9a1d00d0ddfbc63430f627b523e515085a592a7567f4b", size = 2745088, upload-time = "2026-08-11T23:03:41.864Z" }, + { url = "https://files.pythonhosted.org/packages/1b/36/e614ba2bc0f005ed0f37a6413f08fe705210297ddb9a37a475a8b9fdab61/numba-0.67.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5269245a675abdd3e2c35ec6bb2f250355effa9032514d8f2354f0d2d10854bd", size = 3861040, upload-time = "2026-08-11T23:03:43.842Z" }, + { url = "https://files.pythonhosted.org/packages/40/90/30c42a1dbc4176cf355e8e8be61803732c55597b1332925fe233912a43d9/numba-0.67.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f074a8e23db78490f11a3930c940be758316c10ac5985be83d2f298dc080acf7", size = 3561811, upload-time = "2026-08-11T23:03:46.037Z" }, + { url = "https://files.pythonhosted.org/packages/18/6d/21bd16f770476e394c5e5f504935817967442a71251d6b86c244a2767980/numba-0.67.0-cp314-cp314-win_amd64.whl", hash = "sha256:4d576e62bf2c9370f61312b51573c4bb1f3fe96798bbab56730847a368a316c4", size = 2817421, upload-time = "2026-08-11T23:03:47.922Z" }, + { url = "https://files.pythonhosted.org/packages/95/06/bb41b0e59b9ff52c94a2f01db24f6437df058caebb377b5f372fc343a6a2/numba-0.67.0-cp314-cp314-win_arm64.whl", hash = "sha256:7930748ce8355d2a5a28602abab056a61fdc676d17377f27d17993905428171f", size = 2788885, upload-time = "2026-08-11T23:03:49.967Z" }, + { url = "https://files.pythonhosted.org/packages/10/7c/aa07151fbd0f4283f78de437cc196f9084789be89a2b4de3fdc2f6a4b414/numba-0.67.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:4a2ed006635bbd0fe45681ed49f3b4f4bad1abf0c233bcc5842c9e3a34cabd61", size = 2748150, upload-time = "2026-08-11T23:03:51.755Z" }, + { url = "https://files.pythonhosted.org/packages/74/62/b8174ca95a4cc1a7ba1520767734e016991545590b8fbde521b681701a9f/numba-0.67.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aa5f002f665bec321b950dacaa26ee009e1d720f6ac9d9856eed5efe1caa03a6", size = 3896986, upload-time = "2026-08-11T23:03:53.752Z" }, + { url = "https://files.pythonhosted.org/packages/8c/f9/3a7b6dbf81e01a48958b45ad2239edbc64707522ab17f11f9f18c44bf6d1/numba-0.67.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83ab968b0e0fa744eba03351282dd8000796e6ec8e4518f47bd3ed86c0a20c7b", size = 3614644, upload-time = "2026-08-11T23:03:55.794Z" }, + { url = "https://files.pythonhosted.org/packages/d9/5b/248f5681c121ca853a9f4e39d342a3e01b8a0261b0275853eb3d0d56aa20/numba-0.67.0-cp314-cp314t-win_amd64.whl", hash = "sha256:00c964a5b94d3ae82d83ac162cd610755875b98dadb779fdde06e6bfcdbca47e", size = 2822870, upload-time = "2026-08-11T23:03:58.097Z" }, ] [[package]] name = "numpy" -version = "2.2.0" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.10'", -] -sdist = { url = "https://files.pythonhosted.org/packages/47/1b/1d565e0f6e156e1522ab564176b8b29d71e13d8caf003a08768df3d5cec5/numpy-2.2.0.tar.gz", hash = "sha256:140dd80ff8981a583a60980be1a655068f8adebf7a45a06a6858c873fcdcd4a0", size = 20225497 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/81/3882353e097204fe4d7a5fe026b694b0104b78f930c969faadeed1538e00/numpy-2.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1e25507d85da11ff5066269d0bd25d06e0a0f2e908415534f3e603d2a78e4ffa", size = 21212476 }, - { url = "https://files.pythonhosted.org/packages/2c/64/5577dc71240272749e07fcacb47c0f29e31ba4fbd1613fefbd1aa88efc29/numpy-2.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a62eb442011776e4036af5c8b1a00b706c5bc02dc15eb5344b0c750428c94219", size = 14351441 }, - { url = "https://files.pythonhosted.org/packages/c9/43/850c040481c19c1c2289203a606df1a202eeb3aa81440624bac891024f83/numpy-2.2.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:b606b1aaf802e6468c2608c65ff7ece53eae1a6874b3765f69b8ceb20c5fa78e", size = 5390304 }, - { url = "https://files.pythonhosted.org/packages/73/96/a4c8a86300dbafc7e4f44d8986f8b64950b7f4640a2dc5c91e036afe28c6/numpy-2.2.0-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:36b2b43146f646642b425dd2027730f99bac962618ec2052932157e213a040e9", size = 6925476 }, - { url = "https://files.pythonhosted.org/packages/0c/0a/22129c3107c4fb237f97876df4399a5c3a83f3d95f86e0353ae6fbbd202f/numpy-2.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7fe8f3583e0607ad4e43a954e35c1748b553bfe9fdac8635c02058023277d1b3", size = 14329997 }, - { url = "https://files.pythonhosted.org/packages/4c/49/c2adeccc8a47bcd9335ec000dfcb4de34a7c34aeaa23af57cd504017e8c3/numpy-2.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:122fd2fcfafdefc889c64ad99c228d5a1f9692c3a83f56c292618a59aa60ae83", size = 16378908 }, - { url = "https://files.pythonhosted.org/packages/8d/85/b65f4596748cc5468c0a978a16b3be45f6bcec78339b0fe7bce71d121d89/numpy-2.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3f2f5cddeaa4424a0a118924b988746db6ffa8565e5829b1841a8a3bd73eb59a", size = 15540949 }, - { url = "https://files.pythonhosted.org/packages/ff/b3/3b18321c94a6a6a1d972baf1b39a6de50e65c991002c014ffbcce7e09be8/numpy-2.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7fe4bb0695fe986a9e4deec3b6857003b4cfe5c5e4aac0b95f6a658c14635e31", size = 18167677 }, - { url = "https://files.pythonhosted.org/packages/41/f0/fa2a76e893a05764e4474f6011575c4e4ccf32af9c95bfcc8ef4b8a99f69/numpy-2.2.0-cp310-cp310-win32.whl", hash = "sha256:b30042fe92dbd79f1ba7f6898fada10bdaad1847c44f2dff9a16147e00a93661", size = 6570288 }, - { url = "https://files.pythonhosted.org/packages/97/4e/0b7debcd013214db224997b0d3e39bb7b3656d37d06dfc31bb57d42d143b/numpy-2.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:54dc1d6d66f8d37843ed281773c7174f03bf7ad826523f73435deb88ba60d2d4", size = 12912730 }, - { url = "https://files.pythonhosted.org/packages/80/1b/736023977a96e787c4e7653a1ac2d31d4f6ab6b4048f83c8359f7c0af2e3/numpy-2.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9874bc2ff574c40ab7a5cbb7464bf9b045d617e36754a7bc93f933d52bd9ffc6", size = 21216607 }, - { url = "https://files.pythonhosted.org/packages/85/4f/5f0be4c5c93525e663573bab9e29bd88a71f85de3a0d01413ee05bce0c2f/numpy-2.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0da8495970f6b101ddd0c38ace92edea30e7e12b9a926b57f5fabb1ecc25bb90", size = 14387756 }, - { url = "https://files.pythonhosted.org/packages/36/78/c38af7833c4f29999cdacdf12452b43b660cd25a1990ea9a7edf1fb01f17/numpy-2.2.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:0557eebc699c1c34cccdd8c3778c9294e8196df27d713706895edc6f57d29608", size = 5388483 }, - { url = "https://files.pythonhosted.org/packages/e9/b5/306ac6ee3f8f0c51abd3664ee8a9b8e264cbf179a860674827151ecc0a9c/numpy-2.2.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:3579eaeb5e07f3ded59298ce22b65f877a86ba8e9fe701f5576c99bb17c283da", size = 6929721 }, - { url = "https://files.pythonhosted.org/packages/ea/15/e33a7d86d8ce91de82c34ce94a87f2b8df891e603675e83ec7039325ff10/numpy-2.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40deb10198bbaa531509aad0cd2f9fadb26c8b94070831e2208e7df543562b74", size = 14334667 }, - { url = "https://files.pythonhosted.org/packages/52/33/10825f580f42a353f744abc450dcd2a4b1e6f1931abb0ccbd1d63bd3993c/numpy-2.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c2aed8fcf8abc3020d6a9ccb31dbc9e7d7819c56a348cc88fd44be269b37427e", size = 16390204 }, - { url = "https://files.pythonhosted.org/packages/b4/24/36cce77559572bdc6c8bcdd2f3e0db03c7079d14b9a1cd342476d7f451e8/numpy-2.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a222d764352c773aa5ebde02dd84dba3279c81c6db2e482d62a3fa54e5ece69b", size = 15556123 }, - { url = "https://files.pythonhosted.org/packages/05/51/2d706d14adee8f5c70c5de3831673d4d57051fc9ac6f3f6bff8811d2f9bd/numpy-2.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4e58666988605e251d42c2818c7d3d8991555381be26399303053b58a5bbf30d", size = 18179898 }, - { url = "https://files.pythonhosted.org/packages/8a/e7/ea8b7652564113f218e75b296e3545a256d88b233021f792fd08591e8f33/numpy-2.2.0-cp311-cp311-win32.whl", hash = "sha256:4723a50e1523e1de4fccd1b9a6dcea750c2102461e9a02b2ac55ffeae09a4410", size = 6568146 }, - { url = "https://files.pythonhosted.org/packages/d0/06/3d1ff6ed377cb0340baf90487a35f15f9dc1db8e0a07de2bf2c54a8e490f/numpy-2.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:16757cf28621e43e252c560d25b15f18a2f11da94fea344bf26c599b9cf54b73", size = 12916677 }, - { url = "https://files.pythonhosted.org/packages/7f/bc/a20dc4e1d051149052762e7647455311865d11c603170c476d1e910a353e/numpy-2.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cff210198bb4cae3f3c100444c5eaa573a823f05c253e7188e1362a5555235b3", size = 20909153 }, - { url = "https://files.pythonhosted.org/packages/60/3d/ac4fb63f36db94f4c7db05b45e3ecb3f88f778ca71850664460c78cfde41/numpy-2.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:58b92a5828bd4d9aa0952492b7de803135038de47343b2aa3cc23f3b71a3dc4e", size = 14095021 }, - { url = "https://files.pythonhosted.org/packages/41/6d/a654d519d24e4fcc7a83d4a51209cda086f26cf30722b3d8ffc1aa9b775e/numpy-2.2.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:ebe5e59545401fbb1b24da76f006ab19734ae71e703cdb4a8b347e84a0cece67", size = 5125491 }, - { url = "https://files.pythonhosted.org/packages/e6/22/fab7e1510a62e5092f4e6507a279020052b89f11d9cfe52af7f52c243b04/numpy-2.2.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e2b8cd48a9942ed3f85b95ca4105c45758438c7ed28fff1e4ce3e57c3b589d8e", size = 6658534 }, - { url = "https://files.pythonhosted.org/packages/fc/29/a3d938ddc5a534cd53df7ab79d20a68db8c67578de1df0ae0118230f5f54/numpy-2.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:57fcc997ffc0bef234b8875a54d4058afa92b0b0c4223fc1f62f24b3b5e86038", size = 14046306 }, - { url = "https://files.pythonhosted.org/packages/90/24/d0bbb56abdd8934f30384632e3c2ca1ebfeb5d17e150c6e366ba291de36b/numpy-2.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85ad7d11b309bd132d74397fcf2920933c9d1dc865487128f5c03d580f2c3d03", size = 16095819 }, - { url = "https://files.pythonhosted.org/packages/99/9c/58a673faa9e8a0e77248e782f7a17410cf7259b326265646fd50ed49c4e1/numpy-2.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cb24cca1968b21355cc6f3da1a20cd1cebd8a023e3c5b09b432444617949085a", size = 15243215 }, - { url = "https://files.pythonhosted.org/packages/9c/61/f311693f78cbf635cfb69ce9e1e857ff83937a27d93c96ac5932fd33e330/numpy-2.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0798b138c291d792f8ea40fe3768610f3c7dd2574389e37c3f26573757c8f7ef", size = 17860175 }, - { url = "https://files.pythonhosted.org/packages/11/3e/491c34262cb1fc9dd13a00beb80d755ee0517b17db20e54cac7aa524533e/numpy-2.2.0-cp312-cp312-win32.whl", hash = "sha256:afe8fb968743d40435c3827632fd36c5fbde633b0423da7692e426529b1759b1", size = 6273281 }, - { url = "https://files.pythonhosted.org/packages/89/ea/00537f599eb230771157bc509f6ea5b2dddf05d4b09f9d2f1d7096a18781/numpy-2.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:3a4199f519e57d517ebd48cb76b36c82da0360781c6a0353e64c0cac30ecaad3", size = 12613227 }, - { url = "https://files.pythonhosted.org/packages/bd/4c/0d1eef206545c994289e7a9de21b642880a11e0ed47a2b0c407c688c4f69/numpy-2.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f8c8b141ef9699ae777c6278b52c706b653bf15d135d302754f6b2e90eb30367", size = 20895707 }, - { url = "https://files.pythonhosted.org/packages/16/cb/88f6c1e6df83002c421d5f854ccf134aa088aa997af786a5dac3f32ec99b/numpy-2.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f0986e917aca18f7a567b812ef7ca9391288e2acb7a4308aa9d265bd724bdae", size = 14110592 }, - { url = "https://files.pythonhosted.org/packages/b4/54/817e6894168a43f33dca74199ba0dd0f1acd99aa6323ed6d323d63d640a2/numpy-2.2.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:1c92113619f7b272838b8d6702a7f8ebe5edea0df48166c47929611d0b4dea69", size = 5110858 }, - { url = "https://files.pythonhosted.org/packages/c7/99/00d8a1a8eb70425bba7880257ed73fed08d3e8d05da4202fb6b9a81d5ee4/numpy-2.2.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5a145e956b374e72ad1dff82779177d4a3c62bc8248f41b80cb5122e68f22d13", size = 6645143 }, - { url = "https://files.pythonhosted.org/packages/34/86/5b9c2b7c56e7a9d9297a0a4be0b8433f498eba52a8f5892d9132b0f64627/numpy-2.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18142b497d70a34b01642b9feabb70156311b326fdddd875a9981f34a369b671", size = 14042812 }, - { url = "https://files.pythonhosted.org/packages/df/54/13535f74391dbe5f479ceed96f1403267be302c840040700d4fd66688089/numpy-2.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7d41d1612c1a82b64697e894b75db6758d4f21c3ec069d841e60ebe54b5b571", size = 16093419 }, - { url = "https://files.pythonhosted.org/packages/dd/37/dfb2056842ac61315f225aa56f455da369f5223e4c5a38b91d20da1b628b/numpy-2.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a98f6f20465e7618c83252c02041517bd2f7ea29be5378f09667a8f654a5918d", size = 15238969 }, - { url = "https://files.pythonhosted.org/packages/5a/3d/d20d24ee313992f0b7e7b9d9eef642d9b545d39d5b91c4a2cc8c98776328/numpy-2.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e09d40edfdb4e260cb1567d8ae770ccf3b8b7e9f0d9b5c2a9992696b30ce2742", size = 17855705 }, - { url = "https://files.pythonhosted.org/packages/5b/40/944c9ee264f875a2db6f79380944fd2b5bb9d712bb4a134d11f45ad5b693/numpy-2.2.0-cp313-cp313-win32.whl", hash = "sha256:3905a5fffcc23e597ee4d9fb3fcd209bd658c352657548db7316e810ca80458e", size = 6270078 }, - { url = "https://files.pythonhosted.org/packages/30/04/e1ee6f8b22034302d4c5c24e15782bdedf76d90b90f3874ed0b48525def0/numpy-2.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a184288538e6ad699cbe6b24859206e38ce5fba28f3bcfa51c90d0502c1582b2", size = 12605791 }, - { url = "https://files.pythonhosted.org/packages/ef/fb/51d458625cd6134d60ac15180ae50995d7d21b0f2f92a6286ae7b0792d19/numpy-2.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7832f9e8eb00be32f15fdfb9a981d6955ea9adc8574c521d48710171b6c55e95", size = 20920160 }, - { url = "https://files.pythonhosted.org/packages/b4/34/162ae0c5d2536ea4be98c813b5161c980f0443cd5765fde16ddfe3450140/numpy-2.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f0dd071b95bbca244f4cb7f70b77d2ff3aaaba7fa16dc41f58d14854a6204e6c", size = 14119064 }, - { url = "https://files.pythonhosted.org/packages/17/6c/4195dd0e1c41c55f466d516e17e9e28510f32af76d23061ea3da67438e3c/numpy-2.2.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:b0b227dcff8cdc3efbce66d4e50891f04d0a387cce282fe1e66199146a6a8fca", size = 5152778 }, - { url = "https://files.pythonhosted.org/packages/2f/47/ea804ae525832c8d05ed85b560dfd242d34e4bb0962bc269ccaa720fb934/numpy-2.2.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:6ab153263a7c5ccaf6dfe7e53447b74f77789f28ecb278c3b5d49db7ece10d6d", size = 6667605 }, - { url = "https://files.pythonhosted.org/packages/76/99/34d20e50b3d894bb16b5374bfbee399ab8ff3a33bf1e1f0b8acfe7bbd70d/numpy-2.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e500aba968a48e9019e42c0c199b7ec0696a97fa69037bea163b55398e390529", size = 14013275 }, - { url = "https://files.pythonhosted.org/packages/69/8f/a1df7bd02d434ab82539517d1b98028985700cfc4300bc5496fb140ca648/numpy-2.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:440cfb3db4c5029775803794f8638fbdbf71ec702caf32735f53b008e1eaece3", size = 16074900 }, - { url = "https://files.pythonhosted.org/packages/04/94/b419e7a76bf21a00fcb03c613583f10e389fdc8dfe420412ff5710c8ad3d/numpy-2.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a55dc7a7f0b6198b07ec0cd445fbb98b05234e8b00c5ac4874a63372ba98d4ab", size = 15219122 }, - { url = "https://files.pythonhosted.org/packages/65/d9/dddf398b2b6c5d750892a207a469c2854a8db0f033edaf72103af8cf05aa/numpy-2.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4bddbaa30d78c86329b26bd6aaaea06b1e47444da99eddac7bf1e2fab717bd72", size = 17851668 }, - { url = "https://files.pythonhosted.org/packages/d4/dc/09a4e5819a9782a213c0eb4eecacdc1cd75ad8dac99279b04cfccb7eeb0a/numpy-2.2.0-cp313-cp313t-win32.whl", hash = "sha256:30bf971c12e4365153afb31fc73f441d4da157153f3400b82db32d04de1e4066", size = 6325288 }, - { url = "https://files.pythonhosted.org/packages/ce/e1/e0d06ec34036c92b43aef206efe99a5f5f04e12c776eab82a36e00c40afc/numpy-2.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:d35717333b39d1b6bb8433fa758a55f1081543de527171543a2b710551d40881", size = 12692303 }, - { url = "https://files.pythonhosted.org/packages/f3/18/6d4e1274f221073058b621f4df8050958b7564b24b4fa25be9f1b7639274/numpy-2.2.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e12c6c1ce84628c52d6367863773f7c8c8241be554e8b79686e91a43f1733773", size = 21043901 }, - { url = "https://files.pythonhosted.org/packages/19/3e/2b20599e7ead7ae1b89a77bb34f88c5ec12e43fbb320576ed646388d2cb7/numpy-2.2.0-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:b6207dc8fb3c8cb5668e885cef9ec7f70189bec4e276f0ff70d5aa078d32c88e", size = 6789122 }, - { url = "https://files.pythonhosted.org/packages/c9/5a/378954132c192fafa6c3d5c160092a427c7562e5bda0cc6ad9cc37008a7a/numpy-2.2.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a50aeff71d0f97b6450d33940c7181b08be1441c6c193e678211bff11aa725e7", size = 16194018 }, - { url = "https://files.pythonhosted.org/packages/67/17/209bda34fc83f3436834392f44643e66dcf3c77465f232102e7f1c7d8eae/numpy-2.2.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:df12a1f99b99f569a7c2ae59aa2d31724e8d835fc7f33e14f4792e3071d11221", size = 12819486 }, +version = "2.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/80/db0b4559e57ec36362bedbb05530a87fafbcb6067708c946967a41d449e7/numpy-2.5.2.tar.gz", hash = "sha256:d482d171c406ae88c5b19cad3b6a1c4c5209f886ab74bc44c2c865c23f52d860", size = 20773161, upload-time = "2026-08-09T13:48:27.962Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/72/dccb0aaf40972777283303919f613964227266d0c13adebb79ac124f1c3e/numpy-2.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:14e373cfc6387177e8409dac3c7159be8eb05cd77096cd7c950268b86f62831c", size = 16891693, upload-time = "2026-08-09T13:44:51.702Z" }, + { url = "https://files.pythonhosted.org/packages/60/2e/b5aee50a1f74ac815cf8331812cb8251e29024025de462e0c047641c614c/numpy-2.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4bbd96c833ecc8cc069ce518078fc8c60cb9cbfb0fea5b7a803ad65035596d03", size = 11903109, upload-time = "2026-08-09T13:44:55.501Z" }, + { url = "https://files.pythonhosted.org/packages/f3/f4/29e78102a80601cf034d4e9767022cffeca2c3b4c926e1754572ca95593d/numpy-2.5.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:6e8172ddfcf5cf74b811d372b570b83c60bd2de87a6fbfbebdadb4a9bd9c6cbb", size = 5350202, upload-time = "2026-08-09T13:44:58.401Z" }, + { url = "https://files.pythonhosted.org/packages/11/4b/dcd3b7eadaf4035d2c7a4289d232523a6964f602598ef7674e4bd7291f93/numpy-2.5.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:65f188481f1669e26f62b701e8205d19e460fa4a9b52a1414ba382330e4a3414", size = 6687736, upload-time = "2026-08-09T13:45:00.813Z" }, + { url = "https://files.pythonhosted.org/packages/e5/21/4947e0e9d6c9fc2e2ff15b8949049ee44f63adb9cacc729ab8793f97e712/numpy-2.5.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee9c4eeb8454b3660a8b53493563c3e121c2fc94fbd72b848ef814ed7b676a9", size = 15612696, upload-time = "2026-08-09T13:45:04.151Z" }, + { url = "https://files.pythonhosted.org/packages/3a/5f/62d28cf019460c7f1394105b4d49d9911a9c444cb77ab0bd95a204c5a6de/numpy-2.5.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3cdec01fa790a186d430433fdd4d4ffb70eed6f0eeb4bf05c8dbe2dce0a9bcb8", size = 16722264, upload-time = "2026-08-09T13:45:07.714Z" }, + { url = "https://files.pythonhosted.org/packages/14/25/3f0be4c1b9fdf5dd5e708a6806978564d7c46a055c000496309ff2a2f8af/numpy-2.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7999d4ddb0c4025018373fd787510d46e04c769467af22869707b3c1cfd459ab", size = 16974396, upload-time = "2026-08-09T13:45:11.316Z" }, + { url = "https://files.pythonhosted.org/packages/22/72/6262cbdeeb45da9d971e40715f579d791603ba8ec0b5e2db1ac55454421d/numpy-2.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c1f017dc0875c9209d219f97feceb7d54c2661bb243deb4114478e1295808af7", size = 18476044, upload-time = "2026-08-09T13:45:14.869Z" }, + { url = "https://files.pythonhosted.org/packages/36/33/29208b8b075bde62d26a81d14b358c42b0f69b6cabd98d4ff97f37f22b05/numpy-2.5.2-cp312-cp312-win32.whl", hash = "sha256:d6a48072864e3324e194a8fbb3c657bcc5b5c869dbc64c9537b1d5c862572c0a", size = 6072817, upload-time = "2026-08-09T13:45:17.867Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/87fea2769fe1c47c1b5b01d8310772c9d1a85d485de7cf386ef7a3332b02/numpy-2.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:28ac63476ec7651484215ee7fa15a1f78b57c14621f01e392afe17b9a1390ce4", size = 12464674, upload-time = "2026-08-09T13:45:20.734Z" }, + { url = "https://files.pythonhosted.org/packages/14/52/032b97e00461ab0809bbe4c588b035620e5a14b8cdee47ecddefc7b17d33/numpy-2.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:27650bb0e7140fa3d37b9923b4803645e0b125d190f326eecfd3f4dad8e8ade1", size = 10397131, upload-time = "2026-08-09T13:45:23.73Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/6b24738a0ef4557d189b150046cd07823c50e4273e8aebd651222e24306f/numpy-2.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8e4cb9a754c8a0c62eaa88273a5fba3391f4a610d1dee893c0755da31c083f15", size = 16886595, upload-time = "2026-08-09T13:45:27.323Z" }, + { url = "https://files.pythonhosted.org/packages/65/60/f2d208d366f263f39c6e69ed309290717aab41078b6d04c9be2a84fa2a07/numpy-2.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:52c808f96484f5571a5cc863775ce50247c17dfb3b0361f8ed6b4b0456f80080", size = 11896845, upload-time = "2026-08-09T13:45:31.638Z" }, + { url = "https://files.pythonhosted.org/packages/3c/79/81e0bf24f4d020a2b1d5cd297a9f60c3f24eeb116f9bba5870443f7b6a4a/numpy-2.5.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:29d81e97f668489cba8ebfd796b9bdd453525d35dd9e162e2daec94bf3fc7740", size = 5343880, upload-time = "2026-08-09T13:45:34.373Z" }, + { url = "https://files.pythonhosted.org/packages/ba/cc/e3141cf06d1a8a2c7e107543fe1269c1d1af760d4d683c0794a4ee1127c2/numpy-2.5.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afb3f0632d6b2e3ba04dbce8d1e48d321b369138b73830b5ca371a0e8d479d56", size = 6682264, upload-time = "2026-08-09T13:45:36.7Z" }, + { url = "https://files.pythonhosted.org/packages/29/f1/2a64a307d92c5d98f5255a4014eb43bb6103ee477087b61ecae44a3aa9b9/numpy-2.5.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0aadf13b60048d501e05fa699efaf7734e2494f3498a4c2a5521d822640324f3", size = 15609566, upload-time = "2026-08-09T13:45:39.518Z" }, + { url = "https://files.pythonhosted.org/packages/7b/44/59a1eb68e773c4098d107ef34a0dbdeca501d72ffcfbff9a7707343921ce/numpy-2.5.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29b86ff8a6cc556b47ec6b64b194815cc80e6bf5eedcc6cddfd65318cb0b4eee", size = 16709995, upload-time = "2026-08-09T13:45:43.661Z" }, + { url = "https://files.pythonhosted.org/packages/8a/4c/3e54d4ddbc359a1295f8b633e8106bcd4d7d4a206e82df051bdfb3058755/numpy-2.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6950c4b7dd562453090548ba7f5da7e59f57f85663f15d5dcc60e249192f7e59", size = 16972511, upload-time = "2026-08-09T13:45:47.094Z" }, + { url = "https://files.pythonhosted.org/packages/f2/9f/02e371638ebf19b66d46231e4be52999e87f32d1961b113bc45656608b22/numpy-2.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9727f472d2f3888053b8a75ab0cb94745a9de224bb5846dbadc0092101bc71d", size = 18465609, upload-time = "2026-08-09T13:45:50.808Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ae/ad6645abc7a3510fe48e8ea1ab4598166f500057ef4ebf38bfad4f1577de/numpy-2.5.2-cp313-cp313-win32.whl", hash = "sha256:4f9744f9fbdcea0bc552e8f19e1f141f811a3f9bc2be2cc6e86d982cab23e3f4", size = 6070204, upload-time = "2026-08-09T13:45:54.111Z" }, + { url = "https://files.pythonhosted.org/packages/15/20/f3489f86d81ea460b2bcdceaed094142ca6579f6be0ec527b781d39afe68/numpy-2.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:85aaccb24182c25df891ad0ec333585967e115269d5f1b17f2c9ae005bc96657", size = 12460532, upload-time = "2026-08-09T13:45:57.167Z" }, + { url = "https://files.pythonhosted.org/packages/d5/21/35b31dde1b283b79de828b80f876afd8c94e28fe1e9c375f89e261cc4c0d/numpy-2.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:bd68ece1553d2023c09a4226d9e41c586ad2d20594d1a456186c33513d2cb3f2", size = 10396725, upload-time = "2026-08-09T13:46:00.478Z" }, + { url = "https://files.pythonhosted.org/packages/ac/f8/c3b222bf075b50afd8e949a07a15c4b312a4a84bd8102a332bcd953cbbb4/numpy-2.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d787cf769c3baeb5f6235e778edb52c08dfa923789b5958f28e6450f96107cb1", size = 16885180, upload-time = "2026-08-09T13:46:03.939Z" }, + { url = "https://files.pythonhosted.org/packages/17/e1/2c1d4b1987795a92b5bbf7c24fe249ab96aa2573ab0d7604802c189d7b86/numpy-2.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:24b9dc2e3d84aa58523798805194e23e736f3f6ce2d1a5b92583ae734e6dbda8", size = 11907878, upload-time = "2026-08-09T13:46:07.045Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ee/d08226fc858044355983a6e5b94f08ff6f3969e0a2b160a4a89f0ddb3445/numpy-2.5.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:9e9413326d726c2545bfa65d2c0876871e8d8386e77f992c1d426e180bbd4323", size = 5354922, upload-time = "2026-08-09T13:46:10.04Z" }, + { url = "https://files.pythonhosted.org/packages/94/f0/6d3d933056440ebbc5e6bad92065fc6c26a48a84a36b1208580e94eea76c/numpy-2.5.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:60e902ac295855348a5ca2ea4c89108989a9f5fddfad3dfc0a8f36b10358567e", size = 6679168, upload-time = "2026-08-09T13:46:12.275Z" }, + { url = "https://files.pythonhosted.org/packages/c4/3b/ecd49dd90033cceb2704d88ca905d4d7d89b0e8c739608754ffd325fa820/numpy-2.5.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50e500dc868e9313530ce12ba470fe50ff3afe3d62993ed6eff652dacd555b65", size = 15624501, upload-time = "2026-08-09T13:46:15.322Z" }, + { url = "https://files.pythonhosted.org/packages/c7/99/461bd36dbdfac6c1c53efa370bd55a83227542d0d118f1677dbf1a3dacd5/numpy-2.5.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318b9a4c845dbea06708a29c84ee429cc3065048db34cdb799047643492050ee", size = 16713701, upload-time = "2026-08-09T13:46:18.949Z" }, + { url = "https://files.pythonhosted.org/packages/f9/9c/2b251df9e8a5d647b62b0cbc1b90a91850c1cf4859ecb532fd0b4eacff6c/numpy-2.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:34c319e2963be042673fb46570501b2f06c41924e17e3563d58646b4380dfb68", size = 16986065, upload-time = "2026-08-09T13:46:23.006Z" }, + { url = "https://files.pythonhosted.org/packages/8f/25/20de43f53ff1390534a124475055a19f01fe10c920a0fd11b8e18d6d6052/numpy-2.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f06571a052127dc1b4e8b83029b4d1b20daa2b64a31cdd181fc6bc774e9000eb", size = 18470031, upload-time = "2026-08-09T13:46:27.102Z" }, + { url = "https://files.pythonhosted.org/packages/56/5e/0c577ca308d6da5eb79b546ba10bbe5b60148192194e2da060913b1de4f1/numpy-2.5.2-cp314-cp314-win32.whl", hash = "sha256:2cc779226e476d1e1f08c74068c419e60f41a9e0e069c92f6671d31d5c985e98", size = 6121028, upload-time = "2026-08-09T13:46:30.046Z" }, + { url = "https://files.pythonhosted.org/packages/15/5c/7bcbd5b11f94199073320410cddcbb80cee62415bfeb540874b265c2d922/numpy-2.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:7587f53dfbd5edc0f7b87c6217b4c6d2d1f2ef9c3da70bc1315e7db5f8d7ec9d", size = 12597627, upload-time = "2026-08-09T13:46:32.886Z" }, + { url = "https://files.pythonhosted.org/packages/87/bc/4d0b06fba0da90ccc75af62823cb9dcedb6c9ea0cffa058cb2c9ee773a77/numpy-2.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:3e4c367352d3747784248a227fbec218e193b56f7e6692e3b64fc805478ecfdf", size = 10680414, upload-time = "2026-08-09T13:46:36.036Z" }, + { url = "https://files.pythonhosted.org/packages/cd/17/f429aac9dc08833a0d0f188eba38c532a751b1a1f2ca6018a37b455cb321/numpy-2.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b879fb674276e331513fb136b78dbc6bd3c848309e0d841cfd63be3896c4cfc1", size = 12026967, upload-time = "2026-08-09T13:46:39.084Z" }, + { url = "https://files.pythonhosted.org/packages/ca/9f/d0849de96a2a4ceaa16662f18ee13eaa9c0aa418269fdc8c4857c56b11da/numpy-2.5.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:fd0d703772bba096843785bd38371e31bb4a0c1151497ad5739d182114a73f7f", size = 5473874, upload-time = "2026-08-09T13:46:42.075Z" }, + { url = "https://files.pythonhosted.org/packages/89/3c/8df216d4a4a5422a3de045301cf7df8ea47286d76f5cb7160b0128ac26b7/numpy-2.5.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:3a2f061cebd9e3d23bdcfaaded5e2293a4c6a5b60fa42df85d410a725ce621bf", size = 6789276, upload-time = "2026-08-09T13:46:44.387Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3a/20d7e9891c4ddfadd6ff8d95bf4b29f353d8e1770553de2099880551dfb9/numpy-2.5.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6df895598c0edcb41030126c89e0f353b07d93238116143b7405e937359736c4", size = 15659154, upload-time = "2026-08-09T13:46:47.538Z" }, + { url = "https://files.pythonhosted.org/packages/aa/d6/f3aa3d2688bf501b858835c6bd087ae9b51a56ae6fca8e2b0990abd177af/numpy-2.5.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ab3d4a901f844ea836c3e80bf463c6a27d7f3c14e8e292fcf28d348b25b9bce", size = 16748909, upload-time = "2026-08-09T13:46:51.442Z" }, + { url = "https://files.pythonhosted.org/packages/7d/8f/1c5cae8d2baf86ab802ae97a00be55bc7e21ebc11b12bbc33376c5f05342/numpy-2.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:cebc2d6dbb605a7703d59751dea4bd6b0ab127a5a4338a6f432df1936fef8b26", size = 17027685, upload-time = "2026-08-09T13:46:55.095Z" }, + { url = "https://files.pythonhosted.org/packages/5c/27/71d3467404aedc1c24ce79610f91b52b0b0f466c43a701aa56fc75c145ab/numpy-2.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eaca7ff36f0f52e2111ec71f169d8fd3e889e7ddc0d2592e0d703fd8d3ce8fac", size = 18501181, upload-time = "2026-08-09T13:46:59.09Z" }, + { url = "https://files.pythonhosted.org/packages/14/2f/42921d27c40aea7e077f4a423ae509fd9220b028cd787bafefd8ab2b3a5f/numpy-2.5.2-cp314-cp314t-win32.whl", hash = "sha256:ddf47472af2e4280d79bac82304f5e80150211f1b9e614b760061d5fdfbb6eba", size = 6271085, upload-time = "2026-08-09T13:47:01.903Z" }, + { url = "https://files.pythonhosted.org/packages/75/e6/bad5f5d56de9b1971bac959963dda276d35c40f1854475005434bbe08692/numpy-2.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:44ef9675d908e65f9953063837c3277730f3f4437615a4cdab67b366cabaf884", size = 12787971, upload-time = "2026-08-09T13:47:04.963Z" }, + { url = "https://files.pythonhosted.org/packages/df/05/f608795cb34391acd67e38d94a3c36abd8d8576293a3a80727d7595c372c/numpy-2.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:eaa088384c46f519dacb93b7ec483a6d6b19a4a2085ae4f25ab9b1c43d387d1e", size = 10750306, upload-time = "2026-08-09T13:47:07.976Z" }, + { url = "https://files.pythonhosted.org/packages/33/c6/28de0191c5f82b7d42a0a51390ba98587048aa93a39fafb05bdbe6e8d00c/numpy-2.5.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:078f9b027b478c9379b9677babbf0f8b8f1ecfada27636d7b9a93990c638739f", size = 16885274, upload-time = "2026-08-09T13:47:11.439Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d1/973ca116000d244897e468ea1aff30b589e5022e3c8744b71706fe33bd57/numpy-2.5.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:50a68f4bacd8a2b33d8da3d2269d0d78500f86ea582e4786dc10f5ef2c2c6842", size = 11907846, upload-time = "2026-08-09T13:47:15.128Z" }, + { url = "https://files.pythonhosted.org/packages/78/d9/8c4b3937ef204cb2fd88d389ccd0f265a2ffb11f35a01d2064cf46714bd6/numpy-2.5.2-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:e79aba74ffaf5f78a050d777c184cddf8fdffabab38acf5f3ef1fecbc17895d6", size = 5354892, upload-time = "2026-08-09T13:47:18.07Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/b6ee65ea2999fdb7023935e108e6fb776ee4082aa15f159acfa857e578c8/numpy-2.5.2-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:9a0731745a72a184490a582fb4af2533512bd071ace67785b5fdffc0ae58dce8", size = 6679309, upload-time = "2026-08-09T13:47:20.456Z" }, + { url = "https://files.pythonhosted.org/packages/43/f3/acb18d8b137a393c8e7803a8c994c9e64bde3930692a69d826993113a159/numpy-2.5.2-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ec954036759bcee3aa484f8603bd9c14f3e776293b85578b8734c2d72777c69", size = 15625850, upload-time = "2026-08-09T13:47:24.365Z" }, + { url = "https://files.pythonhosted.org/packages/a9/bf/a8e9bb0db815a0e265b5744ebedd3af0bd5faad8604e5b50a1cd012f3c91/numpy-2.5.2-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc649493697006bc90614a5f0bbc8cb3cb1866715c474e473694968d7e6b99ab", size = 16713664, upload-time = "2026-08-09T13:47:27.965Z" }, + { url = "https://files.pythonhosted.org/packages/0c/c3/6e913736b3dd6582344af32418b5fb9dab34282e8a8174ae1d54ceb0fc13/numpy-2.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:cf7de32f486e4ac9e2d93b810f9e9ac72a728dd46a32a0bb403222f27f653514", size = 16986749, upload-time = "2026-08-09T13:47:31.541Z" }, + { url = "https://files.pythonhosted.org/packages/80/09/7d3b23eff5c7428ef6c01e6f7052bb60d504c4d33e317b36b8959c24ad97/numpy-2.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2ffa7bacab3e2ee1b19ed31766bb60bb380b68c23f051e199c5cc598afd68710", size = 18470495, upload-time = "2026-08-09T13:47:35.364Z" }, + { url = "https://files.pythonhosted.org/packages/a5/a4/68a321d825374f6eb677ffe8ef8c6b9a328304e6fd2e39d9530822776607/numpy-2.5.2-cp315-cp315-win32.whl", hash = "sha256:6b588cc8f902d6bff201c19fd00c43ab8545671e3554d014e12e14139e5e8617", size = 6120696, upload-time = "2026-08-09T13:47:38.561Z" }, + { url = "https://files.pythonhosted.org/packages/c8/23/deafbb1700f79fae9cd1e91220f133d124cc267de1b584da3fbf6db2f6cd/numpy-2.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:07d4e89f3a9ab0a9ba24264ccdb642b3dd951b2281e8883a5481a4aa79cc31a7", size = 12597324, upload-time = "2026-08-09T13:47:41.401Z" }, + { url = "https://files.pythonhosted.org/packages/33/cd/3272ba105e3bbbdaeb11357eda31e7a6825ffe159e8171665660299a948f/numpy-2.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:a610dc7e3c52edd39c2bc2375ff9c3fd59cb3ad00e4472d36f83bc1457145788", size = 10680466, upload-time = "2026-08-09T13:47:44.873Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0e/58370637b1bb70a5c9ce2b43f4b521ccb224e36ccb76a6596b17ae4b447c/numpy-2.5.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:40f4d451aed46a8046a1aae41c4e55fb3612273df9c502480135e1501576a34b", size = 16993947, upload-time = "2026-08-09T13:47:48.97Z" }, + { url = "https://files.pythonhosted.org/packages/10/93/2abcb807712b289d6d60fe4cf30532f98974a8396d885650f3ba5a13026e/numpy-2.5.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:c081cbe16ba1ab53078e5ff29013621e33c509eedab055775d956427712c236e", size = 12025331, upload-time = "2026-08-09T13:47:52.646Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3a/2898e003a5fbaf87e76c039b4ee1f5eb390471b4ffe74887c1f34c4e791e/numpy-2.5.2-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:0090ccdd57ec2703e9b49d0bf554767370581c1dd0a6b2bb2b2d9def317d042a", size = 5472336, upload-time = "2026-08-09T13:47:55.403Z" }, + { url = "https://files.pythonhosted.org/packages/61/a5/23f69d07c544597b29758b31b55c27dc9d541012a2c1496189fef702aec2/numpy-2.5.2-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:6a9bb119fb8dd21ba30b3f0e555b7e2b081bd9883af21ec9c1c633d161cda3a8", size = 6788387, upload-time = "2026-08-09T13:47:58.192Z" }, + { url = "https://files.pythonhosted.org/packages/15/ea/c0dbdbcf22f43782510a3e492dd3da73c6112b69cac8929d16d127536fc4/numpy-2.5.2-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a839318485284a6fb31be4f8f2c91c8f2cb22f4543c4a8903f12b0671ffe07cc", size = 15667096, upload-time = "2026-08-09T13:48:01.562Z" }, + { url = "https://files.pythonhosted.org/packages/fc/5e/29c73c31748cdb0f7566642125ba17fd5b56780cddf891b085dab27e4466/numpy-2.5.2-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba0a474801b8dc67b66bf465548abc90e82b44d2611b5770f33008dcabffe8ec", size = 16751730, upload-time = "2026-08-09T13:48:05.706Z" }, + { url = "https://files.pythonhosted.org/packages/47/95/02501e8454796bb58dadf7a99d3181e0b464bf264e1003039572f9779fac/numpy-2.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:0a4035ae1129ff8777f08bfbd44f1e5d8e9c049ce0c2dd78fc0d92c13e7251c0", size = 17038686, upload-time = "2026-08-09T13:48:09.627Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b5/53a681d91b5c82687067d8ea5035e02d917b5509d6f334cb06484a954714/numpy-2.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:77843ca236b777e67f8d6b3660ea116e499612703a0ecd7093f316201eb9d8e2", size = 18507727, upload-time = "2026-08-09T13:48:13.744Z" }, + { url = "https://files.pythonhosted.org/packages/42/06/6e11443f7b64ee376c860506091103bf68f92d2cab9e8d96d4501babf07c/numpy-2.5.2-cp315-cp315t-win32.whl", hash = "sha256:7354826bc6f8f69402e9b7fe28d15fcd34feebd74f856f111585c5b0c9fb0251", size = 6269775, upload-time = "2026-08-09T13:48:17.543Z" }, + { url = "https://files.pythonhosted.org/packages/f1/18/195d6b86cd72dbbc501edfa778005fa6b87afd34c153e46028cd3a0938f4/numpy-2.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:e5651f3f87add730ee6608d915009e19c911fba0cb000c7e3ea994b7d768eb12", size = 12782559, upload-time = "2026-08-09T13:48:21.023Z" }, + { url = "https://files.pythonhosted.org/packages/b4/07/458c344f0f0c178f4481dad5cca790626ffe4c34eabf9467069d06ee4999/numpy-2.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:5f8e00be2ec6f45f4e8a41a527f68d44a7d96fee92a650e4d8b1326f77f61e6e", size = 10748103, upload-time = "2026-08-09T13:48:24.21Z" }, +] + +[[package]] +name = "numpydoc" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/3c/dfccc9e7dee357fb2aa13c3890d952a370dd0ed071e0f7ed62ed0df567c1/numpydoc-1.10.0.tar.gz", hash = "sha256:3f7970f6eee30912260a6b31ac72bba2432830cd6722569ec17ee8d3ef5ffa01", size = 94027, upload-time = "2025-12-02T16:39:12.937Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/5e/3a6a3e90f35cea3853c45e5d5fb9b7192ce4384616f932cf7591298ab6e1/numpydoc-1.10.0-py3-none-any.whl", hash = "sha256:3149da9874af890bcc2a82ef7aae5484e5aa81cb2778f08e3c307ba6d963721b", size = 69255, upload-time = "2025-12-02T16:39:11.561Z" }, ] [[package]] name = "packaging" -version = "24.2" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[package]] +name = "parso" +version = "0.8.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, +] + +[[package]] +name = "partition-igraph" +version = "0.0.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "igraph" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/64/c7/7517c9002962d539538a64b2039ce8e344a459b4262638930e5d2ce8a3d0/partition_igraph-0.0.8.tar.gz", hash = "sha256:42c80e80ecf556a8b94aa9657c7bdf1a23ded05c8833bd0fba4c25216f98af0b", size = 5586, upload-time = "2026-04-23T17:03:17.446Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/17/fe381b000d90c9f4cf395dc4ea20f46e325a54e54dd909b319fa41ffb1c9/partition_igraph-0.0.8-py3-none-any.whl", hash = "sha256:7932aa4561c575c7a744e5b433b8358fe15e8af44a234cc458f662e6aa04a10f", size = 6238, upload-time = "2026-04-23T17:03:16.33Z" }, +] + +[[package]] +name = "partition-networkx" +version = "0.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "networkx" }, + { name = "numpy" }, + { name = "python-louvain" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/82/bc/c596b1c8dc7c04eb3b5747d5f7ee3c708ba6e7d1e6e43aa0b91eefb5f4df/partition_networkx-0.0.2.tar.gz", hash = "sha256:3dac4f3ea52e56fd8e9414fb409d5d2192cc61e1e7252000d53a485d7f0ed18c", size = 5412, upload-time = "2023-07-20T13:11:03.319Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/1e/5f808a735b5c19a38d334ae07c482268e68e02e546523813a56411334c80/partition_networkx-0.0.2-py3-none-any.whl", hash = "sha256:ff9888f267e1d40dd281fff303232d1a6bd3f70f4681c06413944b2576a98d95", size = 6087, upload-time = "2023-07-20T13:11:01.681Z" }, +] + +[[package]] +name = "partition-sknetwork" +version = "0.0.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } +dependencies = [ + { name = "numba" }, + { name = "numpy" }, + { name = "scikit-network" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4b/71/284a157ae7aaf45afd614176283e6e1087d875b12f0ddc98ff2e345f30a8/partition_sknetwork-0.0.4.tar.gz", hash = "sha256:4e3b22a934c8f1e5f2f090c949af39ab9865065acc5a29b5a1fce8ad31619c11", size = 7044, upload-time = "2026-06-27T22:17:22.788Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, + { url = "https://files.pythonhosted.org/packages/2f/f1/6ed2a6ff2d3741a885e4455f5b9388d371efa88ae8a87476aaae0dcc1129/partition_sknetwork-0.0.4-py3-none-any.whl", hash = "sha256:6133b7f20acdb498bdd0a73cb20b6db619a2175faaa19fdaad4e2e9b700231b3", size = 7090, upload-time = "2026-06-27T22:17:21.778Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, ] [[package]] name = "pillow" -version = "11.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a5/26/0d95c04c868f6bdb0c447e3ee2de5564411845e36a858cfd63766bc7b563/pillow-11.0.0.tar.gz", hash = "sha256:72bacbaf24ac003fea9bff9837d1eedb6088758d41e100c1552930151f677739", size = 46737780 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/98/fb/a6ce6836bd7fd93fbf9144bf54789e02babc27403b50a9e1583ee877d6da/pillow-11.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6619654954dc4936fcff82db8eb6401d3159ec6be81e33c6000dfd76ae189947", size = 3154708 }, - { url = "https://files.pythonhosted.org/packages/6a/1d/1f51e6e912d8ff316bb3935a8cda617c801783e0b998bf7a894e91d3bd4c/pillow-11.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b3c5ac4bed7519088103d9450a1107f76308ecf91d6dabc8a33a2fcfb18d0fba", size = 2979223 }, - { url = "https://files.pythonhosted.org/packages/90/83/e2077b0192ca8a9ef794dbb74700c7e48384706467067976c2a95a0f40a1/pillow-11.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a65149d8ada1055029fcb665452b2814fe7d7082fcb0c5bed6db851cb69b2086", size = 4183167 }, - { url = "https://files.pythonhosted.org/packages/0e/74/467af0146970a98349cdf39e9b79a6cc8a2e7558f2c01c28a7b6b85c5bda/pillow-11.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88a58d8ac0cc0e7f3a014509f0455248a76629ca9b604eca7dc5927cc593c5e9", size = 4283912 }, - { url = "https://files.pythonhosted.org/packages/85/b1/d95d4f7ca3a6c1ae120959605875a31a3c209c4e50f0029dc1a87566cf46/pillow-11.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:c26845094b1af3c91852745ae78e3ea47abf3dbcd1cf962f16b9a5fbe3ee8488", size = 4195815 }, - { url = "https://files.pythonhosted.org/packages/41/c3/94f33af0762ed76b5a237c5797e088aa57f2b7fa8ee7932d399087be66a8/pillow-11.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:1a61b54f87ab5786b8479f81c4b11f4d61702830354520837f8cc791ebba0f5f", size = 4366117 }, - { url = "https://files.pythonhosted.org/packages/ba/3c/443e7ef01f597497268899e1cca95c0de947c9bbf77a8f18b3c126681e5d/pillow-11.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:674629ff60030d144b7bca2b8330225a9b11c482ed408813924619c6f302fdbb", size = 4278607 }, - { url = "https://files.pythonhosted.org/packages/26/95/1495304448b0081e60c0c5d63f928ef48bb290acee7385804426fa395a21/pillow-11.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:598b4e238f13276e0008299bd2482003f48158e2b11826862b1eb2ad7c768b97", size = 4410685 }, - { url = "https://files.pythonhosted.org/packages/45/da/861e1df971ef0de9870720cb309ca4d553b26a9483ec9be3a7bf1de4a095/pillow-11.0.0-cp310-cp310-win32.whl", hash = "sha256:9a0f748eaa434a41fccf8e1ee7a3eed68af1b690e75328fd7a60af123c193b50", size = 2249185 }, - { url = "https://files.pythonhosted.org/packages/d5/4e/78f7c5202ea2a772a5ab05069c1b82503e6353cd79c7e474d4945f4b82c3/pillow-11.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:a5629742881bcbc1f42e840af185fd4d83a5edeb96475a575f4da50d6ede337c", size = 2566726 }, - { url = "https://files.pythonhosted.org/packages/77/e4/6e84eada35cbcc646fc1870f72ccfd4afacb0fae0c37ffbffe7f5dc24bf1/pillow-11.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:ee217c198f2e41f184f3869f3e485557296d505b5195c513b2bfe0062dc537f1", size = 2254585 }, - { url = "https://files.pythonhosted.org/packages/f0/eb/f7e21b113dd48a9c97d364e0915b3988c6a0b6207652f5a92372871b7aa4/pillow-11.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1c1d72714f429a521d8d2d018badc42414c3077eb187a59579f28e4270b4b0fc", size = 3154705 }, - { url = "https://files.pythonhosted.org/packages/25/b3/2b54a1d541accebe6bd8b1358b34ceb2c509f51cb7dcda8687362490da5b/pillow-11.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:499c3a1b0d6fc8213519e193796eb1a86a1be4b1877d678b30f83fd979811d1a", size = 2979222 }, - { url = "https://files.pythonhosted.org/packages/20/12/1a41eddad8265c5c19dda8fb6c269ce15ee25e0b9f8f26286e6202df6693/pillow-11.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8b2351c85d855293a299038e1f89db92a2f35e8d2f783489c6f0b2b5f3fe8a3", size = 4190220 }, - { url = "https://files.pythonhosted.org/packages/a9/9b/8a8c4d07d77447b7457164b861d18f5a31ae6418ef5c07f6f878fa09039a/pillow-11.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f4dba50cfa56f910241eb7f883c20f1e7b1d8f7d91c750cd0b318bad443f4d5", size = 4291399 }, - { url = "https://files.pythonhosted.org/packages/fc/e4/130c5fab4a54d3991129800dd2801feeb4b118d7630148cd67f0e6269d4c/pillow-11.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:5ddbfd761ee00c12ee1be86c9c0683ecf5bb14c9772ddbd782085779a63dd55b", size = 4202709 }, - { url = "https://files.pythonhosted.org/packages/39/63/b3fc299528d7df1f678b0666002b37affe6b8751225c3d9c12cf530e73ed/pillow-11.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:45c566eb10b8967d71bf1ab8e4a525e5a93519e29ea071459ce517f6b903d7fa", size = 4372556 }, - { url = "https://files.pythonhosted.org/packages/c6/a6/694122c55b855b586c26c694937d36bb8d3b09c735ff41b2f315c6e66a10/pillow-11.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b4fd7bd29610a83a8c9b564d457cf5bd92b4e11e79a4ee4716a63c959699b306", size = 4287187 }, - { url = "https://files.pythonhosted.org/packages/ba/a9/f9d763e2671a8acd53d29b1e284ca298bc10a595527f6be30233cdb9659d/pillow-11.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cb929ca942d0ec4fac404cbf520ee6cac37bf35be479b970c4ffadf2b6a1cad9", size = 4418468 }, - { url = "https://files.pythonhosted.org/packages/6e/0e/b5cbad2621377f11313a94aeb44ca55a9639adabcaaa073597a1925f8c26/pillow-11.0.0-cp311-cp311-win32.whl", hash = "sha256:006bcdd307cc47ba43e924099a038cbf9591062e6c50e570819743f5607404f5", size = 2249249 }, - { url = "https://files.pythonhosted.org/packages/dc/83/1470c220a4ff06cd75fc609068f6605e567ea51df70557555c2ab6516b2c/pillow-11.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:52a2d8323a465f84faaba5236567d212c3668f2ab53e1c74c15583cf507a0291", size = 2566769 }, - { url = "https://files.pythonhosted.org/packages/52/98/def78c3a23acee2bcdb2e52005fb2810ed54305602ec1bfcfab2bda6f49f/pillow-11.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:16095692a253047fe3ec028e951fa4221a1f3ed3d80c397e83541a3037ff67c9", size = 2254611 }, - { url = "https://files.pythonhosted.org/packages/1c/a3/26e606ff0b2daaf120543e537311fa3ae2eb6bf061490e4fea51771540be/pillow-11.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2c0a187a92a1cb5ef2c8ed5412dd8d4334272617f532d4ad4de31e0495bd923", size = 3147642 }, - { url = "https://files.pythonhosted.org/packages/4f/d5/1caabedd8863526a6cfa44ee7a833bd97f945dc1d56824d6d76e11731939/pillow-11.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:084a07ef0821cfe4858fe86652fffac8e187b6ae677e9906e192aafcc1b69903", size = 2978999 }, - { url = "https://files.pythonhosted.org/packages/d9/ff/5a45000826a1aa1ac6874b3ec5a856474821a1b59d838c4f6ce2ee518fe9/pillow-11.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8069c5179902dcdce0be9bfc8235347fdbac249d23bd90514b7a47a72d9fecf4", size = 4196794 }, - { url = "https://files.pythonhosted.org/packages/9d/21/84c9f287d17180f26263b5f5c8fb201de0f88b1afddf8a2597a5c9fe787f/pillow-11.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f02541ef64077f22bf4924f225c0fd1248c168f86e4b7abdedd87d6ebaceab0f", size = 4300762 }, - { url = "https://files.pythonhosted.org/packages/84/39/63fb87cd07cc541438b448b1fed467c4d687ad18aa786a7f8e67b255d1aa/pillow-11.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:fcb4621042ac4b7865c179bb972ed0da0218a076dc1820ffc48b1d74c1e37fe9", size = 4210468 }, - { url = "https://files.pythonhosted.org/packages/7f/42/6e0f2c2d5c60f499aa29be14f860dd4539de322cd8fb84ee01553493fb4d/pillow-11.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:00177a63030d612148e659b55ba99527803288cea7c75fb05766ab7981a8c1b7", size = 4381824 }, - { url = "https://files.pythonhosted.org/packages/31/69/1ef0fb9d2f8d2d114db982b78ca4eeb9db9a29f7477821e160b8c1253f67/pillow-11.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8853a3bf12afddfdf15f57c4b02d7ded92c7a75a5d7331d19f4f9572a89c17e6", size = 4296436 }, - { url = "https://files.pythonhosted.org/packages/44/ea/dad2818c675c44f6012289a7c4f46068c548768bc6c7f4e8c4ae5bbbc811/pillow-11.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3107c66e43bda25359d5ef446f59c497de2b5ed4c7fdba0894f8d6cf3822dafc", size = 4429714 }, - { url = "https://files.pythonhosted.org/packages/af/3a/da80224a6eb15bba7a0dcb2346e2b686bb9bf98378c0b4353cd88e62b171/pillow-11.0.0-cp312-cp312-win32.whl", hash = "sha256:86510e3f5eca0ab87429dd77fafc04693195eec7fd6a137c389c3eeb4cfb77c6", size = 2249631 }, - { url = "https://files.pythonhosted.org/packages/57/97/73f756c338c1d86bb802ee88c3cab015ad7ce4b838f8a24f16b676b1ac7c/pillow-11.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:8ec4a89295cd6cd4d1058a5e6aec6bf51e0eaaf9714774e1bfac7cfc9051db47", size = 2567533 }, - { url = "https://files.pythonhosted.org/packages/0b/30/2b61876e2722374558b871dfbfcbe4e406626d63f4f6ed92e9c8e24cac37/pillow-11.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:27a7860107500d813fcd203b4ea19b04babe79448268403172782754870dac25", size = 2254890 }, - { url = "https://files.pythonhosted.org/packages/63/24/e2e15e392d00fcf4215907465d8ec2a2f23bcec1481a8ebe4ae760459995/pillow-11.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bcd1fb5bb7b07f64c15618c89efcc2cfa3e95f0e3bcdbaf4642509de1942a699", size = 3147300 }, - { url = "https://files.pythonhosted.org/packages/43/72/92ad4afaa2afc233dc44184adff289c2e77e8cd916b3ddb72ac69495bda3/pillow-11.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e038b0745997c7dcaae350d35859c9715c71e92ffb7e0f4a8e8a16732150f38", size = 2978742 }, - { url = "https://files.pythonhosted.org/packages/9e/da/c8d69c5bc85d72a8523fe862f05ababdc52c0a755cfe3d362656bb86552b/pillow-11.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ae08bd8ffc41aebf578c2af2f9d8749d91f448b3bfd41d7d9ff573d74f2a6b2", size = 4194349 }, - { url = "https://files.pythonhosted.org/packages/cd/e8/686d0caeed6b998351d57796496a70185376ed9c8ec7d99e1d19ad591fc6/pillow-11.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d69bfd8ec3219ae71bcde1f942b728903cad25fafe3100ba2258b973bd2bc1b2", size = 4298714 }, - { url = "https://files.pythonhosted.org/packages/ec/da/430015cec620d622f06854be67fd2f6721f52fc17fca8ac34b32e2d60739/pillow-11.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:61b887f9ddba63ddf62fd02a3ba7add935d053b6dd7d58998c630e6dbade8527", size = 4208514 }, - { url = "https://files.pythonhosted.org/packages/44/ae/7e4f6662a9b1cb5f92b9cc9cab8321c381ffbee309210940e57432a4063a/pillow-11.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c6a660307ca9d4867caa8d9ca2c2658ab685de83792d1876274991adec7b93fa", size = 4380055 }, - { url = "https://files.pythonhosted.org/packages/74/d5/1a807779ac8a0eeed57f2b92a3c32ea1b696e6140c15bd42eaf908a261cd/pillow-11.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:73e3a0200cdda995c7e43dd47436c1548f87a30bb27fb871f352a22ab8dcf45f", size = 4296751 }, - { url = "https://files.pythonhosted.org/packages/38/8c/5fa3385163ee7080bc13026d59656267daaaaf3c728c233d530e2c2757c8/pillow-11.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fba162b8872d30fea8c52b258a542c5dfd7b235fb5cb352240c8d63b414013eb", size = 4430378 }, - { url = "https://files.pythonhosted.org/packages/ca/1d/ad9c14811133977ff87035bf426875b93097fb50af747793f013979facdb/pillow-11.0.0-cp313-cp313-win32.whl", hash = "sha256:f1b82c27e89fffc6da125d5eb0ca6e68017faf5efc078128cfaa42cf5cb38798", size = 2249588 }, - { url = "https://files.pythonhosted.org/packages/fb/01/3755ba287dac715e6afdb333cb1f6d69740a7475220b4637b5ce3d78cec2/pillow-11.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ba470552b48e5835f1d23ecb936bb7f71d206f9dfeee64245f30c3270b994de", size = 2567509 }, - { url = "https://files.pythonhosted.org/packages/c0/98/2c7d727079b6be1aba82d195767d35fcc2d32204c7a5820f822df5330152/pillow-11.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:846e193e103b41e984ac921b335df59195356ce3f71dcfd155aa79c603873b84", size = 2254791 }, - { url = "https://files.pythonhosted.org/packages/eb/38/998b04cc6f474e78b563716b20eecf42a2fa16a84589d23c8898e64b0ffd/pillow-11.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4ad70c4214f67d7466bea6a08061eba35c01b1b89eaa098040a35272a8efb22b", size = 3150854 }, - { url = "https://files.pythonhosted.org/packages/13/8e/be23a96292113c6cb26b2aa3c8b3681ec62b44ed5c2bd0b258bd59503d3c/pillow-11.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6ec0d5af64f2e3d64a165f490d96368bb5dea8b8f9ad04487f9ab60dc4bb6003", size = 2982369 }, - { url = "https://files.pythonhosted.org/packages/97/8a/3db4eaabb7a2ae8203cd3a332a005e4aba00067fc514aaaf3e9721be31f1/pillow-11.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c809a70e43c7977c4a42aefd62f0131823ebf7dd73556fa5d5950f5b354087e2", size = 4333703 }, - { url = "https://files.pythonhosted.org/packages/28/ac/629ffc84ff67b9228fe87a97272ab125bbd4dc462745f35f192d37b822f1/pillow-11.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:4b60c9520f7207aaf2e1d94de026682fc227806c6e1f55bba7606d1c94dd623a", size = 4412550 }, - { url = "https://files.pythonhosted.org/packages/d6/07/a505921d36bb2df6868806eaf56ef58699c16c388e378b0dcdb6e5b2fb36/pillow-11.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:1e2688958a840c822279fda0086fec1fdab2f95bf2b717b66871c4ad9859d7e8", size = 4461038 }, - { url = "https://files.pythonhosted.org/packages/d6/b9/fb620dd47fc7cc9678af8f8bd8c772034ca4977237049287e99dda360b66/pillow-11.0.0-cp313-cp313t-win32.whl", hash = "sha256:607bbe123c74e272e381a8d1957083a9463401f7bd01287f50521ecb05a313f8", size = 2253197 }, - { url = "https://files.pythonhosted.org/packages/df/86/25dde85c06c89d7fc5db17940f07aae0a56ac69aa9ccb5eb0f09798862a8/pillow-11.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5c39ed17edea3bc69c743a8dd3e9853b7509625c2462532e62baa0732163a904", size = 2572169 }, - { url = "https://files.pythonhosted.org/packages/51/85/9c33f2517add612e17f3381aee7c4072779130c634921a756c97bc29fb49/pillow-11.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:75acbbeb05b86bc53cbe7b7e6fe00fbcf82ad7c684b3ad82e3d711da9ba287d3", size = 2256828 }, - { url = "https://files.pythonhosted.org/packages/f3/8b/01849a820686bf309b7d79a935d57bcafbfd016f1d78fc3d37ed2ba00f96/pillow-11.0.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2e46773dc9f35a1dd28bd6981332fd7f27bec001a918a72a79b4133cf5291dba", size = 3154738 }, - { url = "https://files.pythonhosted.org/packages/35/e8/ff71a40ca8e24cfd6bb333cc4ca8cc24ebecb6942bb4ad1e5ec61f33d1b8/pillow-11.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2679d2258b7f1192b378e2893a8a0a0ca472234d4c2c0e6bdd3380e8dfa21b6a", size = 2979272 }, - { url = "https://files.pythonhosted.org/packages/09/4f/2280ad43f5639174a0227920a59664fb78c5096a0b3fd865fee5184d4526/pillow-11.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eda2616eb2313cbb3eebbe51f19362eb434b18e3bb599466a1ffa76a033fb916", size = 4179756 }, - { url = "https://files.pythonhosted.org/packages/14/b1/c8f428bae932a27ce9c87e7b21aba8ea3e820aa11413c5a795868c37e039/pillow-11.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ec184af98a121fb2da42642dea8a29ec80fc3efbaefb86d8fdd2606619045d", size = 4280488 }, - { url = "https://files.pythonhosted.org/packages/78/66/7c5e44ab2c0123710a5d4692a4ee5931ac438efd7730ac395e305902346e/pillow-11.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:8594f42df584e5b4bb9281799698403f7af489fba84c34d53d1c4bfb71b7c4e7", size = 4192772 }, - { url = "https://files.pythonhosted.org/packages/36/5d/a9a00f8251ce93144f0250c0f0aece31b83ff33ffc243cdf987a8d584818/pillow-11.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:c12b5ae868897c7338519c03049a806af85b9b8c237b7d675b8c5e089e4a618e", size = 4363533 }, - { url = "https://files.pythonhosted.org/packages/fd/21/d8182fc1f3233078eb744f9f2950992f537655174febb8b3f7bdc61847b1/pillow-11.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:70fbbdacd1d271b77b7721fe3cdd2d537bbbd75d29e6300c672ec6bb38d9672f", size = 4275415 }, - { url = "https://files.pythonhosted.org/packages/c9/ee/93e02e8c29210ba7383843405b8b39bd19a164770f14d8569096dd123781/pillow-11.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5178952973e588b3f1360868847334e9e3bf49d19e169bbbdfaf8398002419ae", size = 4407081 }, - { url = "https://files.pythonhosted.org/packages/6e/77/8cda03af2b5177a18d645ad4a7446cda6c1292d1a2fb6e772a06fa9fc86b/pillow-11.0.0-cp39-cp39-win32.whl", hash = "sha256:8c676b587da5673d3c75bd67dd2a8cdfeb282ca38a30f37950511766b26858c4", size = 2249213 }, - { url = "https://files.pythonhosted.org/packages/9f/e4/c90bf7889489f3a14803bd00d3645945dd476020ab67579985af8233ab30/pillow-11.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:94f3e1780abb45062287b4614a5bc0874519c86a777d4a7ad34978e86428b8dd", size = 2566862 }, - { url = "https://files.pythonhosted.org/packages/27/a6/77d2ed085055237581d6276ac1e85f562f1b1848614647d8427e49d83c03/pillow-11.0.0-cp39-cp39-win_arm64.whl", hash = "sha256:290f2cc809f9da7d6d622550bbf4c1e57518212da51b6a30fe8e0a270a5b78bd", size = 2254605 }, - { url = "https://files.pythonhosted.org/packages/36/57/42a4dd825eab762ba9e690d696d894ba366e06791936056e26e099398cda/pillow-11.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1187739620f2b365de756ce086fdb3604573337cc28a0d3ac4a01ab6b2d2a6d2", size = 3119239 }, - { url = "https://files.pythonhosted.org/packages/98/f7/25f9f9e368226a1d6cf3507081a1a7944eddd3ca7821023377043f5a83c8/pillow-11.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fbbcb7b57dc9c794843e3d1258c0fbf0f48656d46ffe9e09b63bbd6e8cd5d0a2", size = 2950803 }, - { url = "https://files.pythonhosted.org/packages/59/01/98ead48a6c2e31e6185d4c16c978a67fe3ccb5da5c2ff2ba8475379bb693/pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d203af30149ae339ad1b4f710d9844ed8796e97fda23ffbc4cc472968a47d0b", size = 3281098 }, - { url = "https://files.pythonhosted.org/packages/51/c0/570255b2866a0e4d500a14f950803a2ec273bac7badc43320120b9262450/pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21a0d3b115009ebb8ac3d2ebec5c2982cc693da935f4ab7bb5c8ebe2f47d36f2", size = 3323665 }, - { url = "https://files.pythonhosted.org/packages/0e/75/689b4ec0483c42bfc7d1aacd32ade7a226db4f4fac57c6fdcdf90c0731e3/pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:73853108f56df97baf2bb8b522f3578221e56f646ba345a372c78326710d3830", size = 3310533 }, - { url = "https://files.pythonhosted.org/packages/3d/30/38bd6149cf53da1db4bad304c543ade775d225961c4310f30425995cb9ec/pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e58876c91f97b0952eb766123bfef372792ab3f4e3e1f1a2267834c2ab131734", size = 3414886 }, - { url = "https://files.pythonhosted.org/packages/ec/3d/c32a51d848401bd94cabb8767a39621496491ee7cd5199856b77da9b18ad/pillow-11.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:224aaa38177597bb179f3ec87eeefcce8e4f85e608025e9cfac60de237ba6316", size = 2567508 }, - { url = "https://files.pythonhosted.org/packages/67/21/fbb4222399f72d6e9c828818ff4ef8391c1e8e71623368295c8dbc789bd1/pillow-11.0.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5bd2d3bdb846d757055910f0a59792d33b555800813c3b39ada1829c372ccb06", size = 2950706 }, - { url = "https://files.pythonhosted.org/packages/a2/b6/6aeb6e018b705ea4076db50aac078c9db8715a901f4c65698edc31375d0f/pillow-11.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:375b8dd15a1f5d2feafff536d47e22f69625c1aa92f12b339ec0b2ca40263273", size = 3323524 }, - { url = "https://files.pythonhosted.org/packages/48/26/36cc90e9932c5fe7c8876c32d6091ef5a09e8137e8e0633045bd35085fdd/pillow-11.0.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:daffdf51ee5db69a82dd127eabecce20729e21f7a3680cf7cbb23f0829189790", size = 3414787 }, - { url = "https://files.pythonhosted.org/packages/44/5c/089154029fcca7729ae142ac820057f74ca4b0b59617734276c31281af15/pillow-11.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7326a1787e3c7b0429659e0a944725e1b03eeaa10edd945a86dead1913383944", size = 2567664 }, +version = "12.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" }, + { url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" }, + { url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" }, + { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" }, + { url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" }, + { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" }, + { url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" }, + { url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" }, + { url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" }, + { url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" }, + { url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" }, + { url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" }, + { url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" }, + { url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" }, + { url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" }, + { url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" }, + { url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" }, + { url = "https://files.pythonhosted.org/packages/dc/01/001f65b68192f0228cc1dbbc8d2530ab5d58b61037ba0587f946fea607cd/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9cf95fe4d0f84c82d282745d9bb08ad9f926efa00be4697e767b814ce40d4330", size = 4161736, upload-time = "2026-07-01T11:54:51.156Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d2/0219746d0fd16fc8a84498e79452375be3797d3ce4044596ce565164b84f/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8728f216dcdb6e6d555cf971cb34076139ad74b31fc2c14da4fafc741c5f6217", size = 4255435, upload-time = "2026-07-01T11:54:53.414Z" }, + { url = "https://files.pythonhosted.org/packages/c8/02/8d0bc62ef0302318c46ff2a512822d2610e81c7aa46c9b3abe6cbaca5ad0/pillow-12.3.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a45650e8ce7fafffd731db8550230db6b0d306d181a90b67d3e6bca2f1990930", size = 3696262, upload-time = "2026-07-01T11:54:55.739Z" }, + { url = "https://files.pythonhosted.org/packages/85/e2/73c77d218410b14f5f2d565e8a998d5317b7b9c75368d29985139f7a46f0/pillow-12.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ba54cfebe86920a559a7c4d6b9050791c20513650a1952ebe3368c7dc70306f8", size = 5350344, upload-time = "2026-07-01T11:54:57.657Z" }, + { url = "https://files.pythonhosted.org/packages/c7/da/32c752228ae345f489e3a42499d817b6c3996da7e8a3bc7a04fc806b243b/pillow-12.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e158cb00350dc278f3b91551101aa7d12415a66ebf2c91d8d5ac14e56ddd3ad0", size = 4780131, upload-time = "2026-07-01T11:54:59.713Z" }, + { url = "https://files.pythonhosted.org/packages/b1/9d/8b2c807dbef61a5197c047afe99823787eb66f63daf9fb2432f91d6f0462/pillow-12.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9aeb04d6aef139de265b29683e119b638208f88cf73cdd1658aa07221165321", size = 6263757, upload-time = "2026-07-01T11:55:01.778Z" }, + { url = "https://files.pythonhosted.org/packages/5c/44/c85361f65dbe00eea8576ee467c768d25129989efb76e94f205e9ca9bb46/pillow-12.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:251bf95b67017e27b13d82f5b326234ca62d70f9cf4c2b9032de2358a3b12c7b", size = 6936962, upload-time = "2026-07-01T11:55:03.93Z" }, + { url = "https://files.pythonhosted.org/packages/18/7e/e483414b35800b86b6f08dbbc7803fb5cd52c4d6f897f47d53ea2c7e6f65/pillow-12.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fe3cca2e4e8a592be0f269a1ca4835c25199d9f3ce815c8491048f785b0a0198", size = 6339171, upload-time = "2026-07-01T11:55:05.989Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f4/68c491844841ede6bed70189546b3ee9731cf9f2cbad396faff5e1ccba45/pillow-12.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:23aceaa007d6172b02c277f0cd359c79492bbb14f7072b4ede9fbcaf20648130", size = 7048116, upload-time = "2026-07-01T11:55:08.131Z" }, + { url = "https://files.pythonhosted.org/packages/a3/34/77f3f793fed8efc7d243f21b33c5a3f0d1c97ee70346d3db855587e155ff/pillow-12.3.0-cp314-cp314-win32.whl", hash = "sha256:af8d94b0db561cf68b88a267c5c44b49e134f525d0dc2cb7ed413a66bc23559a", size = 6467209, upload-time = "2026-07-01T11:55:10.408Z" }, + { url = "https://files.pythonhosted.org/packages/f1/e0/492879f69d94f91f60fc8cd05ba03650e9520afebb2fb7aa12777d7c7f38/pillow-12.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:fdafc9cce40277e0f7a0feabce0ee50dd2fa1800f3b38015e51296b5e814048d", size = 7237707, upload-time = "2026-07-01T11:55:12.745Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ac/6b11f2875f1c2ac040d84e1bbf9cf22a88038f901ca1037898b280b38365/pillow-12.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:e91206ee562682b51b98ef4b26a6ef48fd84e15fd4c4bc5ec768eb641d206838", size = 2565995, upload-time = "2026-07-01T11:55:14.736Z" }, + { url = "https://files.pythonhosted.org/packages/52/69/c2208e56af9bfc1913afb24020297a691eb1d4ef688474c8a04913f65e04/pillow-12.3.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:164b31cd1a0490ab6efae01aa5df49da7061be0af1b30e035b6e9a1bfe34ee6e", size = 5352503, upload-time = "2026-07-01T11:55:17.076Z" }, + { url = "https://files.pythonhosted.org/packages/07/70/e5686d753e898a45d778ff1718dba8516ead6ab6b95d85fc8c4b70650cf2/pillow-12.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5afb51d599ea772b8365ae807ae557f18bccfe46ab261fd1c2a9ed700fc6eb17", size = 4782956, upload-time = "2026-07-01T11:55:19.448Z" }, + { url = "https://files.pythonhosted.org/packages/d5/37/25c6692f06927ee973ff18c8d9ee98ad0b4d84ee67a09610c2dd1447958e/pillow-12.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3edce1d53195db527e0191f84b71d02022de0540bf43a16ed734ed7537b07385", size = 6322855, upload-time = "2026-07-01T11:55:21.613Z" }, + { url = "https://files.pythonhosted.org/packages/cc/91/420637fcb8f1bc11029e403b4538e6694744428d8246118e45719f944556/pillow-12.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf16ba1b4d0b6b7c8e534936632270cf70eb00dbe09005bc345b2677b726855c", size = 6989642, upload-time = "2026-07-01T11:55:24.006Z" }, + { url = "https://files.pythonhosted.org/packages/10/08/b94d7811281ccf0d143a1cf768d1c49e1e54af63e7b708ab2ee3eb87face/pillow-12.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:24870b09b224f7ae3c39ed07d10e819d06f8720bc551847b1d623832b5b0e28d", size = 6391281, upload-time = "2026-07-01T11:55:26.252Z" }, + { url = "https://files.pythonhosted.org/packages/d2/87/24233f785f55474dc02ce3e739c5528a77e3a862e9333d1dd7a25cc31f70/pillow-12.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:30f2aa603c41533cc25c05acd0da21636e84a315768feb631c937177db558931", size = 7096716, upload-time = "2026-07-01T11:55:28.318Z" }, + { url = "https://files.pythonhosted.org/packages/23/26/fcb2f6e37175b04f53570b59937867e2b80ee1685e744023153028fc14f9/pillow-12.3.0-cp314-cp314t-win32.whl", hash = "sha256:4b0a7fe987b14c31ebda6083f74f22b561fd3739bc0ac51e019622e3d72668c7", size = 6474125, upload-time = "2026-07-01T11:55:30.956Z" }, + { url = "https://files.pythonhosted.org/packages/90/de/3634abee5f1c9e13c56787b7d5517b0ba8d6de51700b95578cf338349c9f/pillow-12.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:962864dc93511324d51ddbb5b9f8731bf71675b93ca612a07441896f4688fb8c", size = 7242939, upload-time = "2026-07-01T11:55:34.044Z" }, + { url = "https://files.pythonhosted.org/packages/ce/2a/fd13f8eb24de5714a6eb444a3d67e2842c6c576e159a43793adf23051351/pillow-12.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0740a512dc522224c77d9aa5a8d70d8b7d73fb91f2c21125d8d025d3b8990e45", size = 2567506, upload-time = "2026-07-01T11:55:35.988Z" }, + { url = "https://files.pythonhosted.org/packages/5d/dc/8fdce34ec725a33c81c6ba122b904d6b9024e50ea9ac7bede62fab54506c/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0feb2e9d6ad6c9e3c06effe9d00f3f1e618a6643273576b016f591e9315a7139", size = 4162063, upload-time = "2026-07-01T11:55:37.941Z" }, + { url = "https://files.pythonhosted.org/packages/76/66/2044b9a63d3b84ff048228dfcb7cd9bf0df983e8470971bf7d4c57b693de/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:9e881fca225083806662a5c43d627d215f258ff43c890f831966c7d7ba9c7402", size = 4255549, upload-time = "2026-07-01T11:55:40.022Z" }, + { url = "https://files.pythonhosted.org/packages/52/7e/1f67e6f4ece6b582ee4b539decbcc9f848dc245a93ed8cd7338bafef72f1/pillow-12.3.0-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:4998562bf62a445225f22e07c896bb04b35b1b1f2eb6d760584c9c51d7a5f78c", size = 3696331, upload-time = "2026-07-01T11:55:41.98Z" }, + { url = "https://files.pythonhosted.org/packages/12/40/d306fc2c8e4d45d7f175c77edca7063be7b86fe7fe6e68f4353bf71d808c/pillow-12.3.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:dc624f6bc473dacdf7ef7eb8678d0d08edf15cd94fad6ae5c7d6cc67a4e4902f", size = 5350370, upload-time = "2026-07-01T11:55:44.028Z" }, + { url = "https://files.pythonhosted.org/packages/dd/44/668fb1437e8ce420f62d6106eb66e44a5971602a4d794615bdf79315d82d/pillow-12.3.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:71d6097b330eea8fd15097780c8e89cb1a8ce7838669f48c5bacd6f663dd4701", size = 4780147, upload-time = "2026-07-01T11:55:46.073Z" }, + { url = "https://files.pythonhosted.org/packages/0c/08/93fa2e70e30a2d81547e481b6ee2bb9522117221fb1e0ce4b5df70967677/pillow-12.3.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:28ce87c5ab450a9dd970b52e5aca5fe63ed432d18a2eaddd1979a00a1ba24ace", size = 6273659, upload-time = "2026-07-01T11:55:48.264Z" }, + { url = "https://files.pythonhosted.org/packages/f8/6d/043e96ff814fc31a33077e4cba86082167db520c93632afdf2042febbb0c/pillow-12.3.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b02afb9b97f65fbca5f31db6a2a3ba21aa93030225f150fa3f249717e938fb4", size = 6947439, upload-time = "2026-07-01T11:55:50.503Z" }, + { url = "https://files.pythonhosted.org/packages/af/92/ba71d2ee2ac0edf3fa33bd9d5ee9ee080da70b1766f3ca3934f9938ddac9/pillow-12.3.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:1182d52bc2d5e5d7d0949503aa7e36d12f42205dc287e4883f407b1988820d39", size = 6353577, upload-time = "2026-07-01T11:55:52.697Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ce/e63064e2122923ff687c8ad792d0d736a7b3920a56a46982e81a7fdd25d6/pillow-12.3.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e795b7eb908249c4e43c7c99fac7c2c75dab0c43566e37db472a355f63693d71", size = 7060394, upload-time = "2026-07-01T11:55:55.149Z" }, + { url = "https://files.pythonhosted.org/packages/54/76/a09cc3ccc8d773a7283d34c38bec1708f9e3cc932093cbc4c5e71ac4060b/pillow-12.3.0-cp315-cp315-win32.whl", hash = "sha256:57b3d78c95ba9059768b10e28b813002261d3f3dfc55cc48b0c988f625175827", size = 6467375, upload-time = "2026-07-01T11:55:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/3e/03/1846c49ba3b1d5550392a4bbd06d6fb4578e1cd91a803198b5c90f5f7d53/pillow-12.3.0-cp315-cp315-win_amd64.whl", hash = "sha256:fa4ecea169a355be7a3ade2c783e2ed12f0e40d2c5621cda8b3297faf7fbb9f5", size = 7237048, upload-time = "2026-07-01T11:55:59.975Z" }, + { url = "https://files.pythonhosted.org/packages/fb/bb/89f35dcc79610423f9f195504d7def7f0d1416a711541b42867e25fe3412/pillow-12.3.0-cp315-cp315-win_arm64.whl", hash = "sha256:877c3f311ff35410f690861c4409e7ccbf0cd2f878e50628a28e5a0bb689e658", size = 2566006, upload-time = "2026-07-01T11:56:02.143Z" }, + { url = "https://files.pythonhosted.org/packages/30/88/707027ba09942dfa2c28759b5c222d769290a41c6d20ea60ec250801941f/pillow-12.3.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:e9871b1ffbfa9656b60aeee92ed5136a5742696006fa322b29ea3d8da0ecc9cf", size = 5352509, upload-time = "2026-07-01T11:56:04.2Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6d/00352fa25332c2569cd387851f568cc5a4b75a9adbfb37ac4fbce4c02eec/pillow-12.3.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:53aa02d20d10c3d814d536aa4e5ac9b84ca0ff5a88377963b085ad6822f93e64", size = 4783167, upload-time = "2026-07-01T11:56:06.631Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/9e049dfa21af7c22427275720e2490267ba8138120add5c4c574deb69782/pillow-12.3.0-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:446c34dcc4324b084a53b705127dc15717b22c5e140ae0a3c38349d4efec071e", size = 6329237, upload-time = "2026-07-01T11:56:08.868Z" }, + { url = "https://files.pythonhosted.org/packages/36/16/cf6eeaae8d0fce8dd390a33437cf68c5d5bd73834a2bc6e2f14efda0ab45/pillow-12.3.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf1845d02ad822a369a49f2bb9345b1614744267682e7a03527dc3bf6eea1777", size = 6997047, upload-time = "2026-07-01T11:56:11.379Z" }, + { url = "https://files.pythonhosted.org/packages/1e/69/dbf769bdd55f48bf5733cac28edc6364ffaa072ec9ba336266e4fe66be55/pillow-12.3.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:186941b6aef820ad110fb01fb06eb925374dc3a21b17e37ec9a53b250c6fe2d1", size = 6400440, upload-time = "2026-07-01T11:56:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e1/ffc9cfc2eea0d178da8018e18e959301ad9d6bc9f3edb7181e748a474b97/pillow-12.3.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:f13c32a3abd6079a66d9526e18dad9b6d280384d49d7c54040cd57b6424041d9", size = 7105895, upload-time = "2026-07-01T11:56:16.575Z" }, + { url = "https://files.pythonhosted.org/packages/18/f0/a5595c1e8c3ae44b9828cb2f0fa8155e5095ef04d6327b8f61cf44a3df85/pillow-12.3.0-cp315-cp315t-win32.whl", hash = "sha256:1657923d2d45afb66526e5b933e5b3052e6bdea196c90d3abb2424e18c77dae8", size = 6474384, upload-time = "2026-07-01T11:56:18.855Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/62bcd9f844984c5938d3b05264a61d797a29d3e0812341a8204af70bbdee/pillow-12.3.0-cp315-cp315t-win_amd64.whl", hash = "sha256:8cd2f7bdda092d99c9fc2fb7391354f306d01443d22785d0cbfafa2e2c8bb418", size = 7243537, upload-time = "2026-07-01T11:56:21.214Z" }, + { url = "https://files.pythonhosted.org/packages/3d/68/1f3066acedf37673694a7141381d8f811ae97f30d34413d236abe7d489f1/pillow-12.3.0-cp315-cp315t-win_arm64.whl", hash = "sha256:06ff022112bc9cbf83b60f8e028d94ad87b60621706487e65f673de61610ab59", size = 2567491, upload-time = "2026-07-01T11:56:23.506Z" }, ] [[package]] name = "platformdirs" -version = "4.3.6" +version = "4.11.7" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 } +sdist = { url = "https://files.pythonhosted.org/packages/69/b7/802a56eca9f2fac455b8bab5375a2647b0f0e14a2cd63ef077de3c4a7658/platformdirs-4.11.7.tar.gz", hash = "sha256:4f41487eeeeeb07f3a6625e61d9bc0ae6809f92d3386dbd74392fbb76108104d", size = 35127, upload-time = "2026-09-01T13:35:10.502Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 }, + { url = "https://files.pythonhosted.org/packages/27/6e/80993e10a0482f630cef528635789233224f36b1ffd11592aa15d13ff9ce/platformdirs-4.11.7-py3-none-any.whl", hash = "sha256:8a02cb259042c79d1cd0450facc2fe6dc9d303ae7901afbe33bf8ea0b188cef6", size = 23938, upload-time = "2026-09-01T13:35:09.02Z" }, ] [[package]] name = "pluggy" -version = "1.5.0" +version = "1.6.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, ] [[package]] -name = "pre-commit" -version = "4.0.1" +name = "prek" +version = "0.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b1/05/4402641f168dd862d27592cbd4c5fb171d119c15611e5dbef3df857e8932/prek-0.5.2.tar.gz", hash = "sha256:a90ea4eeba35c6081bad29775f6a49fcc33fb80372424fce64c7a9c5774e8204", size = 549442, upload-time = "2026-09-02T17:49:27.241Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6e/25/cf9c6064fea82ba6f4801dc3be650cc86eae3d9951e2a6fb28b21cbfa156/prek-0.5.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:40d488a48de3f47f48bd4911ee5dec25e615f992b4cde821e9b50d40c615b39e", size = 5982622, upload-time = "2026-09-02T17:49:10.111Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d9/9772fd4d4023c34780d957f407d9437e2a16d6bef77e3da9fa4374cd75bb/prek-0.5.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:0eb3b812fc13bc5c05cfc1a8b469f9665a02f845753c3759ad7aca50af707afb", size = 5525662, upload-time = "2026-09-02T17:49:12.336Z" }, + { url = "https://files.pythonhosted.org/packages/3b/19/be25a56ab243f2e5c9333c38bad33bddffec92ea8a25e34248eba6e00ac8/prek-0.5.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:c0219d1e694a962e3b3ae98f42f53065d2e2856719caee88578d24b35ea74cad", size = 5826109, upload-time = "2026-09-02T17:49:13.994Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bd/a4a5a3022915b8e1768df9b2d8744f3e7c4b3bb7cdbe697612cc96054169/prek-0.5.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0e22f11c1fb5df89acf5cbde78f6139edf2c30a205bea5a5d4a094366dcdbda", size = 6201473, upload-time = "2026-09-02T17:49:16.156Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fb/2e5f8adbee718f15333a113872104c4b3d25ecce423dd7117cfcd28a25fe/prek-0.5.2-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:1d52de8428d5eef7c8c0fd64efd7d31210d13924fd36a02975d462675715aeb7", size = 5829166, upload-time = "2026-09-02T17:49:17.997Z" }, + { url = "https://files.pythonhosted.org/packages/44/71/c798d54741cc8f345b211e453dda9599546fb213c3593eb711cb6c710bbf/prek-0.5.2-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:86aebcd8ab831036fc3ac9b15275412403e21041da031e6c9f1547888843e5c6", size = 6318980, upload-time = "2026-09-02T17:49:21.145Z" }, + { url = "https://files.pythonhosted.org/packages/8f/f8/4aefbf76dae091078655fbaf065c34fa900d43b39c2b88e80cbaa71b5efb/prek-0.5.2-py3-none-win_amd64.whl", hash = "sha256:b6c0e4f272f9410f8218d1db0cc7ea10cd8f62db19f820b9ace9f6c2b33bd8dd", size = 5727075, upload-time = "2026-09-02T17:49:23.656Z" }, + { url = "https://files.pythonhosted.org/packages/df/7c/409ced8866197da50e9bcb2c9bf101e3e9a35b98a851c0ccd2a44509eaa5/prek-0.5.2-py3-none-win_arm64.whl", hash = "sha256:0ebea4ef39f6446f6c414a5a506cde8942b17b5899f74cf90e352628085d4005", size = 5489643, upload-time = "2026-09-02T17:49:25.778Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.53" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cfgv" }, - { name = "identify" }, - { name = "nodeenv" }, - { name = "pyyaml" }, - { name = "virtualenv" }, + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/ea/39b988c938f75cb75d7045b5c69f8bfed47ee2152c8837fb403de29d6fb8/prompt_toolkit-3.0.53.tar.gz", hash = "sha256:9ec8a0ad96d5c56148b3f914aa79c1564c3fde5d2e6b876e7bc327e353cf8fa6", size = 435492, upload-time = "2026-07-26T20:56:14.758Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/6f/84908cad2d6aa5144abcf7b42709fe4fdb459bc640ec7ac5786e7693dabc/prompt_toolkit-3.0.53-py3-none-any.whl", hash = "sha256:01c0891d7f9237d5e339f7d3e42cdae80b7534abb1c7c0e3352efba6231492f2", size = 392288, upload-time = "2026-07-26T20:56:12.512Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" }, + { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, + { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2e/c8/e22c292035f1bac8b9f5237a2622305bc0304e776080b246f3df57c4ff9f/pre_commit-4.0.1.tar.gz", hash = "sha256:80905ac375958c0444c65e9cebebd948b3cdb518f335a091a670a89d652139d2", size = 191678 } + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/16/8f/496e10d51edd6671ebe0432e33ff800aa86775d2d147ce7d43389324a525/pre_commit-4.0.1-py2.py3-none-any.whl", hash = "sha256:efde913840816312445dc98787724647c65473daefe420785f885e8ed9a06878", size = 218713 }, + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "py-cpuinfo2" +version = "10.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/dc/97/a8b1ddada14c8280a047c0746f95cb05d94a31b1a331cea22bcdc2b2a82d/py_cpuinfo2-10.1.1.tar.gz", hash = "sha256:7861133863663f16e06eca63b12904ef100b5760415e92372dac0162799a4771", size = 100840, upload-time = "2026-03-25T21:49:40.797Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/0a/ba69d2dde1ae12ef1d389ea5a216384c5ff6ef7a1e7a48d1e9b6686f6790/py_cpuinfo2-10.1.1-py3-none-any.whl", hash = "sha256:adc53396bfb206e6498d078ec2ab407f85799ecd819584ac36a8f80a2d4d762d", size = 23791, upload-time = "2026-03-25T21:49:39.574Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, ] [[package]] name = "pyparsing" -version = "3.2.0" +version = "3.3.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8c/d5/e5aeee5387091148a19e1145f63606619cb5f20b83fccb63efae6474e7b2/pyparsing-3.2.0.tar.gz", hash = "sha256:cbf74e27246d595d9a74b186b810f6fbb86726dbf3b9532efb343f6d7294fe9c", size = 920984 } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/be/ec/2eb3cd785efd67806c46c13a17339708ddc346cbb684eade7a6e6f79536a/pyparsing-3.2.0-py3-none-any.whl", hash = "sha256:93d9577b88da0bbea8cc8334ee8b918ed014968fd2ec383e868fb8afb1ccef84", size = 106921 }, + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, ] [[package]] name = "pytest" -version = "8.3.4" +version = "9.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, - { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, { name = "iniconfig" }, { name = "packaging" }, { name = "pluggy" }, - { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" }, +] + +[[package]] +name = "pytest-benchmark" +version = "5.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "py-cpuinfo2" }, + { name = "pytest" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919 } +sdist = { url = "https://files.pythonhosted.org/packages/63/8f/83a15e40dbc34a580ee56eb56983cae5394c6e94d50cf28fe268e457be25/pytest_benchmark-5.3.0.tar.gz", hash = "sha256:358444d4e89be901ee2b6404fb043ac3d7684002ad7f3563cc153fca6339c965", size = 375410, upload-time = "2026-08-23T17:45:08.891Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 }, + { url = "https://files.pythonhosted.org/packages/eb/42/7e80f7cfa191e0a766d1de99b4661847415ad5db34f8209d81fd42175b59/pytest_benchmark-5.3.0-py3-none-any.whl", hash = "sha256:920ab1dfcffa718d49aa15ba144c7e357bda59216a0dc308016cc1c7236f719d", size = 48401, upload-time = "2026-08-23T17:45:07.094Z" }, ] [[package]] name = "pytest-cov" -version = "6.0.0" +version = "7.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "coverage", extra = ["toml"] }, + { name = "coverage" }, + { name = "pluggy" }, { name = "pytest" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/be/45/9b538de8cef30e17c7b45ef42f538a94889ed6a16f2387a6c89e73220651/pytest-cov-6.0.0.tar.gz", hash = "sha256:fde0b595ca248bb8e2d76f020b465f3b107c9632e6a1d1705f17834c89dcadc0", size = 66945 } +sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/36/3b/48e79f2cd6a61dbbd4807b4ed46cb564b4fd50a76166b1c4ea5c1d9e2371/pytest_cov-6.0.0-py3-none-any.whl", hash = "sha256:eee6f1b9e61008bd34975a4d5bab25801eb31898b032dd55addc93e96fcaaa35", size = 22949 }, + { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" }, ] [[package]] @@ -992,233 +1692,536 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "six" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 }, -] - -[[package]] -name = "pyyaml" -version = "6.0.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 }, - { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 }, - { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 }, - { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 }, - { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 }, - { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 }, - { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 }, - { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052 }, - { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774 }, - { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 }, - { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 }, - { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 }, - { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 }, - { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 }, - { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 }, - { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 }, - { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850 }, - { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980 }, - { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, - { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, - { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, - { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, - { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, - { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, - { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, - { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 }, - { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 }, - { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 }, - { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 }, - { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 }, - { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 }, - { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 }, - { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 }, - { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 }, - { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 }, - { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, - { url = "https://files.pythonhosted.org/packages/65/d8/b7a1db13636d7fb7d4ff431593c510c8b8fca920ade06ca8ef20015493c5/PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d", size = 184777 }, - { url = "https://files.pythonhosted.org/packages/0a/02/6ec546cd45143fdf9840b2c6be8d875116a64076218b61d68e12548e5839/PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f", size = 172318 }, - { url = "https://files.pythonhosted.org/packages/0e/9a/8cc68be846c972bda34f6c2a93abb644fb2476f4dcc924d52175786932c9/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290", size = 720891 }, - { url = "https://files.pythonhosted.org/packages/e9/6c/6e1b7f40181bc4805e2e07f4abc10a88ce4648e7e95ff1abe4ae4014a9b2/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12", size = 722614 }, - { url = "https://files.pythonhosted.org/packages/3d/32/e7bd8535d22ea2874cef6a81021ba019474ace0d13a4819c2a4bce79bd6a/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19", size = 737360 }, - { url = "https://files.pythonhosted.org/packages/d7/12/7322c1e30b9be969670b672573d45479edef72c9a0deac3bb2868f5d7469/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e", size = 699006 }, - { url = "https://files.pythonhosted.org/packages/82/72/04fcad41ca56491995076630c3ec1e834be241664c0c09a64c9a2589b507/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725", size = 723577 }, - { url = "https://files.pythonhosted.org/packages/ed/5e/46168b1f2757f1fcd442bc3029cd8767d88a98c9c05770d8b420948743bb/PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631", size = 144593 }, - { url = "https://files.pythonhosted.org/packages/19/87/5124b1c1f2412bb95c59ec481eaf936cd32f0fe2a7b16b97b81c4c017a6a/PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8", size = 162312 }, +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, ] [[package]] -name = "scipy" -version = "1.13.1" +name = "python-louvain" +version = "0.16" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.10'", +dependencies = [ + { name = "networkx" }, + { name = "numpy" }, ] +sdist = { url = "https://files.pythonhosted.org/packages/7c/0d/8787b021d52eb8764c0bb18ab95f720cf554902044c6a5cb1865daf45763/python-louvain-0.16.tar.gz", hash = "sha256:b7ba2df5002fd28d3ee789a49532baad11fe648e4f2117cf0798e7520a1da56b", size = 204641, upload-time = "2022-01-29T15:53:03.532Z" } + +[[package]] +name = "pyzmq" +version = "27.2.0" +source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ae/00/48c2f661e2816ccf2ecd77982f6605b2950afe60f60a52b4cbbc2504aa8f/scipy-1.13.1.tar.gz", hash = "sha256:095a87a0312b08dfd6a6155cbbd310a8c51800fc931b8c0b84003014b874ed3c", size = 57210720 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/33/59/41b2529908c002ade869623b87eecff3e11e3ce62e996d0bdcb536984187/scipy-1.13.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:20335853b85e9a49ff7572ab453794298bcf0354d8068c5f6775a0eabf350aca", size = 39328076 }, - { url = "https://files.pythonhosted.org/packages/d5/33/f1307601f492f764062ce7dd471a14750f3360e33cd0f8c614dae208492c/scipy-1.13.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d605e9c23906d1994f55ace80e0125c587f96c020037ea6aa98d01b4bd2e222f", size = 30306232 }, - { url = "https://files.pythonhosted.org/packages/c0/66/9cd4f501dd5ea03e4a4572ecd874936d0da296bd04d1c45ae1a4a75d9c3a/scipy-1.13.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cfa31f1def5c819b19ecc3a8b52d28ffdcc7ed52bb20c9a7589669dd3c250989", size = 33743202 }, - { url = "https://files.pythonhosted.org/packages/a3/ba/7255e5dc82a65adbe83771c72f384d99c43063648456796436c9a5585ec3/scipy-1.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26264b282b9da0952a024ae34710c2aff7d27480ee91a2e82b7b7073c24722f", size = 38577335 }, - { url = "https://files.pythonhosted.org/packages/49/a5/bb9ded8326e9f0cdfdc412eeda1054b914dfea952bda2097d174f8832cc0/scipy-1.13.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:eccfa1906eacc02de42d70ef4aecea45415f5be17e72b61bafcfd329bdc52e94", size = 38820728 }, - { url = "https://files.pythonhosted.org/packages/12/30/df7a8fcc08f9b4a83f5f27cfaaa7d43f9a2d2ad0b6562cced433e5b04e31/scipy-1.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:2831f0dc9c5ea9edd6e51e6e769b655f08ec6db6e2e10f86ef39bd32eb11da54", size = 46210588 }, - { url = "https://files.pythonhosted.org/packages/b4/15/4a4bb1b15bbd2cd2786c4f46e76b871b28799b67891f23f455323a0cdcfb/scipy-1.13.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:27e52b09c0d3a1d5b63e1105f24177e544a222b43611aaf5bc44d4a0979e32f9", size = 39333805 }, - { url = "https://files.pythonhosted.org/packages/ba/92/42476de1af309c27710004f5cdebc27bec62c204db42e05b23a302cb0c9a/scipy-1.13.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:54f430b00f0133e2224c3ba42b805bfd0086fe488835effa33fa291561932326", size = 30317687 }, - { url = "https://files.pythonhosted.org/packages/80/ba/8be64fe225360a4beb6840f3cbee494c107c0887f33350d0a47d55400b01/scipy-1.13.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e89369d27f9e7b0884ae559a3a956e77c02114cc60a6058b4e5011572eea9299", size = 33694638 }, - { url = "https://files.pythonhosted.org/packages/36/07/035d22ff9795129c5a847c64cb43c1fa9188826b59344fee28a3ab02e283/scipy-1.13.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a78b4b3345f1b6f68a763c6e25c0c9a23a9fd0f39f5f3d200efe8feda560a5fa", size = 38569931 }, - { url = "https://files.pythonhosted.org/packages/d9/10/f9b43de37e5ed91facc0cfff31d45ed0104f359e4f9a68416cbf4e790241/scipy-1.13.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:45484bee6d65633752c490404513b9ef02475b4284c4cfab0ef946def50b3f59", size = 38838145 }, - { url = "https://files.pythonhosted.org/packages/4a/48/4513a1a5623a23e95f94abd675ed91cfb19989c58e9f6f7d03990f6caf3d/scipy-1.13.1-cp311-cp311-win_amd64.whl", hash = "sha256:5713f62f781eebd8d597eb3f88b8bf9274e79eeabf63afb4a737abc6c84ad37b", size = 46196227 }, - { url = "https://files.pythonhosted.org/packages/f2/7b/fb6b46fbee30fc7051913068758414f2721003a89dd9a707ad49174e3843/scipy-1.13.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5d72782f39716b2b3509cd7c33cdc08c96f2f4d2b06d51e52fb45a19ca0c86a1", size = 39357301 }, - { url = "https://files.pythonhosted.org/packages/dc/5a/2043a3bde1443d94014aaa41e0b50c39d046dda8360abd3b2a1d3f79907d/scipy-1.13.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:017367484ce5498445aade74b1d5ab377acdc65e27095155e448c88497755a5d", size = 30363348 }, - { url = "https://files.pythonhosted.org/packages/e7/cb/26e4a47364bbfdb3b7fb3363be6d8a1c543bcd70a7753ab397350f5f189a/scipy-1.13.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:949ae67db5fa78a86e8fa644b9a6b07252f449dcf74247108c50e1d20d2b4627", size = 33406062 }, - { url = "https://files.pythonhosted.org/packages/88/ab/6ecdc526d509d33814835447bbbeedbebdec7cca46ef495a61b00a35b4bf/scipy-1.13.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de3ade0e53bc1f21358aa74ff4830235d716211d7d077e340c7349bc3542e884", size = 38218311 }, - { url = "https://files.pythonhosted.org/packages/0b/00/9f54554f0f8318100a71515122d8f4f503b1a2c4b4cfab3b4b68c0eb08fa/scipy-1.13.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2ac65fb503dad64218c228e2dc2d0a0193f7904747db43014645ae139c8fad16", size = 38442493 }, - { url = "https://files.pythonhosted.org/packages/3e/df/963384e90733e08eac978cd103c34df181d1fec424de383cdc443f418dd4/scipy-1.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:cdd7dacfb95fea358916410ec61bbc20440f7860333aee6d882bb8046264e949", size = 45910955 }, - { url = "https://files.pythonhosted.org/packages/7f/29/c2ea58c9731b9ecb30b6738113a95d147e83922986b34c685b8f6eefde21/scipy-1.13.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:436bbb42a94a8aeef855d755ce5a465479c721e9d684de76bf61a62e7c2b81d5", size = 39352927 }, - { url = "https://files.pythonhosted.org/packages/5c/c0/e71b94b20ccf9effb38d7147c0064c08c622309fd487b1b677771a97d18c/scipy-1.13.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:8335549ebbca860c52bf3d02f80784e91a004b71b059e3eea9678ba994796a24", size = 30324538 }, - { url = "https://files.pythonhosted.org/packages/6d/0f/aaa55b06d474817cea311e7b10aab2ea1fd5d43bc6a2861ccc9caec9f418/scipy-1.13.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d533654b7d221a6a97304ab63c41c96473ff04459e404b83275b60aa8f4b7004", size = 33732190 }, - { url = "https://files.pythonhosted.org/packages/35/f5/d0ad1a96f80962ba65e2ce1de6a1e59edecd1f0a7b55990ed208848012e0/scipy-1.13.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637e98dcf185ba7f8e663e122ebf908c4702420477ae52a04f9908707456ba4d", size = 38612244 }, - { url = "https://files.pythonhosted.org/packages/8d/02/1165905f14962174e6569076bcc3315809ae1291ed14de6448cc151eedfd/scipy-1.13.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a014c2b3697bde71724244f63de2476925596c24285c7a637364761f8710891c", size = 38845637 }, - { url = "https://files.pythonhosted.org/packages/3e/77/dab54fe647a08ee4253963bcd8f9cf17509c8ca64d6335141422fe2e2114/scipy-1.13.1-cp39-cp39-win_amd64.whl", hash = "sha256:392e4ec766654852c25ebad4f64e4e584cf19820b980bc04960bca0b0cd6eaa2", size = 46227440 }, + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e7/8d/5b3d5631c2f4b4b8862f64cd0c9eb777b5710eeb5125b4be8dd0a200a4c0/pyzmq-27.2.0.tar.gz", hash = "sha256:54d4259d1bfae24ecdb5ca79f7acc2eac6c286a02d6a0ae617797cb45f0726d3", size = 292316, upload-time = "2026-08-20T19:08:21.19Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/8a/153532fa53db30e116118164f3af269a1f3966b3e2ba32c89b12fe864bd8/pyzmq-27.2.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:591c8de5851c5ea372194469fe97587b97c3b641e9a70f31bb3474acbfde0241", size = 1431074, upload-time = "2026-08-20T19:06:40.601Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ef/c08b91248bb90a9efa81fa00ba81b69c157c74d0c5efbb2c319d91babb62/pyzmq-27.2.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:00e73942ef12cecbc7951c4a9104bb8ffaed742abb13af2da6833d90dd368cef", size = 973915, upload-time = "2026-08-20T19:06:42.037Z" }, + { url = "https://files.pythonhosted.org/packages/b4/78/a3a3a86c2b00fadb92ece1ca4f8f028d62b2ce9ac3526097239ab2d6fba9/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f8079d0521fe94bbb401fe9407578b28f3701627c8be2c9f7e0c5b77dcb0109", size = 697722, upload-time = "2026-08-20T19:06:43.325Z" }, + { url = "https://files.pythonhosted.org/packages/62/2c/d5828306f795e8d34676d266823b74e2101e0ad3760d12083de3e02abbb2/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dea74fd65f1fc5f7fe167916a473ebe6ed6174e5e5d9de11ea6583661be6cf43", size = 872258, upload-time = "2026-08-20T19:06:44.627Z" }, + { url = "https://files.pythonhosted.org/packages/09/52/51253b78fd8739293e283407eeecb14215c02c71b6519af21f6eed8e69cd/pyzmq-27.2.0-cp312-abi3-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dcc99ca132b667a4ed750afd42db4ea73288f18425a9b2e3c0af095665c491f5", size = 739591, upload-time = "2026-08-20T19:06:46.214Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3e/142c85b67a4c9678629b0cf6d5125b29663d75be69bfaa57a3cac344d780/pyzmq-27.2.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b8d5f66e4a8246cf77f7b8f7902af64f00553368fa0373c89d99b78f0ad79394", size = 1689031, upload-time = "2026-08-20T19:06:47.612Z" }, + { url = "https://files.pythonhosted.org/packages/0e/ee/0776fb0f98ed1eb74d77240087fef0ab045b6ad15cb09555c6c5134c98ad/pyzmq-27.2.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:d1526b42a2e725b84ed226f37becedc250c6347594e5ed304e4e9aff68c9aec3", size = 2059547, upload-time = "2026-08-20T19:06:49.064Z" }, + { url = "https://files.pythonhosted.org/packages/aa/0e/ec77f691a4aebe29ab6329f996fb0e0270c876a3016086e3ca6ef733bcae/pyzmq-27.2.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f707bcf2c1d007d14d70531d4dd7b41060881c73efa845580bf6faaf9ea24d42", size = 1910457, upload-time = "2026-08-20T19:06:50.783Z" }, + { url = "https://files.pythonhosted.org/packages/30/97/1f5530ff4fc271b4597048371d5af972c2baab51be132ba15874e0327a6a/pyzmq-27.2.0-cp312-abi3-win32.whl", hash = "sha256:fdaaa4ea3242f6ad298eb5177eb042aea5c73c30e76d20caee7b15af20d24ec2", size = 563450, upload-time = "2026-08-20T19:06:52.307Z" }, + { url = "https://files.pythonhosted.org/packages/02/8b/b83f7780dad22e0878e4c7bd9158ebd24ed12bc3d5e3a471cd0576f77ded/pyzmq-27.2.0-cp312-abi3-win_amd64.whl", hash = "sha256:2c218c6ab8bc447ba62054b581fd30209689d199c6ecb253f79615ca74a38e12", size = 628633, upload-time = "2026-08-20T19:06:53.809Z" }, + { url = "https://files.pythonhosted.org/packages/52/aa/3918b5ac7f9987bd9c421b065074fd7409ded88f856f2c704a24341877ec/pyzmq-27.2.0-cp312-abi3-win_arm64.whl", hash = "sha256:348d6fd3e4b81ae4580622ea8c2ea60224e84b2ac1b3be4482e6edc7de06e7a3", size = 556006, upload-time = "2026-08-20T19:06:55.242Z" }, + { url = "https://files.pythonhosted.org/packages/83/5e/d0541596b48c5a19f85dcbea83d6673d8e91681cdf853eb194c31fc9766e/pyzmq-27.2.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:c551b9e2f86dc625fcb1a032c0d68042678caf96a8dd7c28796766b673bd5b52", size = 1127193, upload-time = "2026-08-20T19:06:56.545Z" }, + { url = "https://files.pythonhosted.org/packages/50/9f/8c7411bb283982d46e6d56dca6a095678c87eb0398daead12776d9881ac2/pyzmq-27.2.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:288cc790da0e3064a14a38ddc56ba169dada8c8af4cb86518db2bcbd380eedbb", size = 1166833, upload-time = "2026-08-20T19:06:58.011Z" }, + { url = "https://files.pythonhosted.org/packages/f9/84/a849161ff88b2de9b991cc8ab332218824741122fdc4fdf222a5b822ac8c/pyzmq-27.2.0-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:3d45189c0c3c99f817b7fefff0d32eeef684cf33e1e3c0fc4281515357c54702", size = 1134452, upload-time = "2026-08-20T19:06:59.898Z" }, + { url = "https://files.pythonhosted.org/packages/3c/34/ff4aaff0cfba2a4d7ad1a16ffedc52c6deb89fcf673d455085446b23f215/pyzmq-27.2.0-cp314-cp314-android_24_x86_64.whl", hash = "sha256:d61910b52be5b2cd8b248dbcbe3a1b0275556a7d99fb613fc43323b546e273b8", size = 1167520, upload-time = "2026-08-20T19:07:01.283Z" }, + { url = "https://files.pythonhosted.org/packages/b6/07/42111e9dc1041d78b4443d6eb1b82b027f1a58178dc8a38385effbc72ad5/pyzmq-27.2.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:3ab6eb88590e510ab16715c32dbba12000da9bee989fdadd9ee19a234c492eb7", size = 1466289, upload-time = "2026-08-20T19:07:02.738Z" }, + { url = "https://files.pythonhosted.org/packages/4b/b4/def7a478458da78665840564161772e7e938600c32a89f28e8b221b54d2d/pyzmq-27.2.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1ecbdd131b9669f62d3a45afee5527c7ae9f141e4301267f21714c90bd21725f", size = 975868, upload-time = "2026-08-20T19:07:04.155Z" }, + { url = "https://files.pythonhosted.org/packages/38/d5/e3e85f7fea37153097aaff49db9e33093909cc2a7b22c1ac4ebe546600fc/pyzmq-27.2.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3146385b94a760236c5eceff468a66a296a716ca98a2e0f9217b1518118466b1", size = 706054, upload-time = "2026-08-20T19:07:05.623Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ef/3b7d9449b223183222bf517245e1e53d5f1ab8c10be8b45f6a301b2f994a/pyzmq-27.2.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9846e881620dd62566ca76a53e384c3f37490faf4b9240aebc7498810dfca853", size = 878984, upload-time = "2026-08-20T19:07:07.153Z" }, + { url = "https://files.pythonhosted.org/packages/be/a5/8b49dbd494f6dcfda69dc4cade322a4b02706ef4e3d30cc366d4e369899f/pyzmq-27.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d9527e3dbaef1edaeeb2446fa7379446814a43ade8adc7c4a5ebe69437815ddd", size = 1697489, upload-time = "2026-08-20T19:07:08.945Z" }, + { url = "https://files.pythonhosted.org/packages/da/5a/4bb8280901130c26ea25f0cbb4a6d39d94250860c6b3dbd912f1cf48fca7/pyzmq-27.2.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:56b48fa9d478a3af7254f397697a62f5ad3e1bb677e200b2701f0c290d97e5af", size = 2064236, upload-time = "2026-08-20T19:07:10.384Z" }, + { url = "https://files.pythonhosted.org/packages/de/38/f433af66922554adb2b5f79e897018c8e19a90b9eaeb49c4814f8355ebe4/pyzmq-27.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:bf0b6e4ce1bb089751c504c5493d6b0557eabd02dd21b76e9086cf964234b103", size = 1917424, upload-time = "2026-08-20T19:07:11.909Z" }, + { url = "https://files.pythonhosted.org/packages/36/81/ea1c1ae3f801d96ba2c269e056761ebcfe023476e651d3af2a7817962051/pyzmq-27.2.0-cp314-cp314t-win32.whl", hash = "sha256:fba8afcf265c6e9fbe1594cb045d4765c6c9a7d607653a8196067ef23566b843", size = 591103, upload-time = "2026-08-20T19:07:13.451Z" }, + { url = "https://files.pythonhosted.org/packages/8a/04/149a627707e780fa9f2c1ede3590c14fa6b18b5576d15744342622299a50/pyzmq-27.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d1bc1d380a91d954ed5fc9f12915dba014eed0978d2de05ee7ca688bdaac144a", size = 670215, upload-time = "2026-08-20T19:07:15.069Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/f9c3c1536c41ef3dbf765ea04218990e2056e558f98184ecd883767fc501/pyzmq-27.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:c7cfb75caa83f5153c687e9d2107f64b5ef0ef0d6edd260d3ff920baaaa69101", size = 582252, upload-time = "2026-08-20T19:07:16.582Z" }, + { url = "https://files.pythonhosted.org/packages/fa/00/78fe097a304a408275747ce43f20428789130b059c5649956277c20f30cf/pyzmq-27.2.0-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:c5129a8fe43ecc49b99eb75616603d483a3c2fcaef504988fafe8ea392aea98b", size = 1134295, upload-time = "2026-08-20T19:07:17.94Z" }, + { url = "https://files.pythonhosted.org/packages/f2/83/1c36270658d2ee56e23a3f9ef5fbcb94cbd2f9fe966a6641f2f38e697162/pyzmq-27.2.0-cp315-cp315-android_24_x86_64.whl", hash = "sha256:baa2ce3485145653194d6c8c5beedd1e9f0bf46a0919c9fa2fe2204fc35b74d9", size = 1167492, upload-time = "2026-08-20T19:07:19.476Z" }, + { url = "https://files.pythonhosted.org/packages/58/b2/f0ae223438d7faa991f6feefdc823815f11cc604f898738376b59fd96515/pyzmq-27.2.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e1ed46048d1920cabc96d952a0d5cfe4127ad8db572c335aae4e3c57b9278d7f", size = 1465992, upload-time = "2026-08-20T19:07:20.941Z" }, + { url = "https://files.pythonhosted.org/packages/59/46/fb56f3f37a6a0937b0e1d2885e808b5eedc171320bac85573cfae78fa9bc/pyzmq-27.2.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e0fa0bc6b1a184aee59b32efcd1b7f0e6d5b8f9387799e4c16a4cb66a86747d6", size = 976118, upload-time = "2026-08-20T19:07:22.577Z" }, + { url = "https://files.pythonhosted.org/packages/21/82/a2c9bfd7c4d34eea1278493cd041bc000d41acb4463c89ceaad29dc813b6/pyzmq-27.2.0-cp315-cp315t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f4bd6743e8bf854c3bfce892dd6578a514aabf128e37a4b2eafcf01856f7e44", size = 705968, upload-time = "2026-08-20T19:07:24.019Z" }, + { url = "https://files.pythonhosted.org/packages/d6/12/b906b269116b6591dc15c0acc5d04c043957c8a531d336999731f4b1d899/pyzmq-27.2.0-cp315-cp315t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95369ed6626afcfe2ac89832fb1b917c077fbeb905fbbe5d918349ce0222b89b", size = 879011, upload-time = "2026-08-20T19:07:25.428Z" }, + { url = "https://files.pythonhosted.org/packages/12/13/f96359534bfb77651c15f1fbfc4bfdd7ec3489d23f434706d39598dd0dcd/pyzmq-27.2.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:40124779c3a56ad5d91902df1ff89159cb414b6c1a0ee697abcc66cf5e6db62d", size = 1697496, upload-time = "2026-08-20T19:07:26.821Z" }, + { url = "https://files.pythonhosted.org/packages/21/b4/2c007ae5f2fe5eca86cbfbc874ed86b5135f2f7812615dfd78606d3c93f6/pyzmq-27.2.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:ec8a318dfc27c7d946651b3d9e8025d5734f30c168a822195601827207bac09b", size = 2064347, upload-time = "2026-08-20T19:07:28.315Z" }, + { url = "https://files.pythonhosted.org/packages/9b/88/767af3a6630c15215f3a66700ec79598a375edd1fdc9d75a3ad522178c01/pyzmq-27.2.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:88c0fac061bac269076edeb3a209acefc96cd6167c239daf1c2b404ac48d7012", size = 1917360, upload-time = "2026-08-20T19:07:29.693Z" }, + { url = "https://files.pythonhosted.org/packages/35/c1/80dd2d20d6e57bc68e1dce1e84bf3e76c9577c1bf728199985c8b4ea0fd1/pyzmq-27.2.0-cp315-cp315t-win32.whl", hash = "sha256:ac126d48cf18aa955daabef43bf0009ff76ad4deee437d09ecf15388214b5beb", size = 591073, upload-time = "2026-08-20T19:07:31.341Z" }, + { url = "https://files.pythonhosted.org/packages/f8/b5/33b781666f3f52ae834bc9c8e38f4f0483a826c5a91cccc993292007bf10/pyzmq-27.2.0-cp315-cp315t-win_amd64.whl", hash = "sha256:edce90a1e588ec63adbf612cc0ad582de4169cd216c7ae53c15f42a2ee902f35", size = 670701, upload-time = "2026-08-20T19:07:32.895Z" }, + { url = "https://files.pythonhosted.org/packages/6e/97/bc4f0edefb992df4fdebcf9f0cc40f631cd4ed277e1ed59ef2cd99a5c8c5/pyzmq-27.2.0-cp315-cp315t-win_arm64.whl", hash = "sha256:a843094b4d3d633bc3623e47a2ff50742d6af02bc1f7606aa2e67e971e21878d", size = 581985, upload-time = "2026-08-20T19:07:34.19Z" }, ] [[package]] -name = "scipy" -version = "1.14.1" +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "roman-numerals" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/41dc953bbeb056c17d5f7a519f50fdf010bd0553be2d630bc69d1e022703/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2", size = 9077, upload-time = "2025-12-17T18:25:34.381Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/54/6f679c435d28e0a568d8e8a7c0a93a09010818634c3c3907fc98d8983770/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7", size = 7676, upload-time = "2025-12-17T18:25:33.098Z" }, +] + +[[package]] +name = "rpds-py" +version = "2026.6.3" source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.10'", +sdist = { url = "https://files.pythonhosted.org/packages/aa/2a/9618a122aeb2a169a28b03889a2995fe297588964333d4a7d67bdf46e147/rpds_py-2026.6.3.tar.gz", hash = "sha256:1cebd1337c242e4ec2293e541f712b2da849b29f48f0c293684b71c0632625d4", size = 64051, upload-time = "2026-06-30T07:17:53.009Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/be/2e8974163072e7bab7df1a5acd54c4498e75e35d6d18b864d3a9d5dadc92/rpds_py-2026.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a0811d33247c3d6128a3001d763f2aa056bb3425204335400ac54f89eec3a0d0", size = 343691, upload-time = "2026-06-30T07:15:14.96Z" }, + { url = "https://files.pythonhosted.org/packages/a4/73/319dfa745dd668efe89309141ded489126461fcecd2b8f3a3cda185129b6/rpds_py-2026.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:538949e262e46caa31ac01bdb3c1e8f642622922cacbabbae6a8445d9dc33eaf", size = 338542, upload-time = "2026-06-30T07:15:16.267Z" }, + { url = "https://files.pythonhosted.org/packages/21/63/4239893be1c4d09b709b1a8f6be4188f0870084ff547f46606b8a75f1b03/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55927d532399c2c646100ff7feb48eaa940ad70f42cd68e1328f3ded9f81ca24", size = 368180, upload-time = "2026-06-30T07:15:17.62Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ca/9c5de382225234ceb37b1844ebdb140db12b2a278bb9efe2fcd19f6c82ce/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f56f1695bc5c0871cbc33dc0130fcf503aab0c57dcc5a6700a4f49eba4f2652e", size = 375067, upload-time = "2026-06-30T07:15:18.952Z" }, + { url = "https://files.pythonhosted.org/packages/87/dc/863f69d1bf04ade34b7fe0d59b9fdf6f0135fe2d7cbca74f1d665589559d/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:270b293dae9058fc9fcedab50f13cebf46fb8ed1d1d54e0521a9da5d6b211975", size = 490509, upload-time = "2026-06-30T07:15:20.434Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ef/eac16a12048b45ec7c7fa94f2be3438a5f26bf9cc8580b18a1cfd609b7f6/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:127565fead0a10943b282957bd5447804ff3160ad79f2ad2635e6d249e380680", size = 382754, upload-time = "2026-06-30T07:15:21.831Z" }, + { url = "https://files.pythonhosted.org/packages/04/8f/d2f3f532616be4d06c316ef119683e832bd3d41e112bf3a88f4151c95b17/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecabd69db66de867690f9797f2f8fa27ba501bbc24540cbdbdc649cd15888ba6", size = 366189, upload-time = "2026-06-30T07:15:23.371Z" }, + { url = "https://files.pythonhosted.org/packages/e3/29/41a7b0e98a4b44cd676ab7598419623373eb43b20be68c084935c1a8cf88/rpds_py-2026.6.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:58eadac9cd119677b60e1cf8ac4052f35949d71b8a9e5556efccbe82533cf22a", size = 377750, upload-time = "2026-06-30T07:15:24.659Z" }, + { url = "https://files.pythonhosted.org/packages/2e/05/ecda0bec46f9a1565090bcdc941d023f6a25aff85fda28f89f8d19878152/rpds_py-2026.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7491ee23305ac3eb59e492b6945881f5cd77a6f731061a3f25b77fd40f9e99a4", size = 395576, upload-time = "2026-06-30T07:15:25.987Z" }, + { url = "https://files.pythonhosted.org/packages/68/a8/6ed52f03ee6cb854ce78785cc9a9a672eb880e83fd7224d471f667d151f1/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c99f7e8ccb3dd6e3e4bfeac657a7b208c9bac8075f4b078c02d7404c34107fa", size = 543807, upload-time = "2026-06-30T07:15:27.356Z" }, + { url = "https://files.pythonhosted.org/packages/8f/d6/156c0d3eea27ba09b92562ba2364ba124c0a061b199e17eac637cd25a5e2/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:62698275682bf121181861295c9181e789030a2d516071f5b8f3c23c170cd0fc", size = 611187, upload-time = "2026-06-30T07:15:28.931Z" }, + { url = "https://files.pythonhosted.org/packages/f1/31/774212ed989c62f7f310220089f9b0a3fb8f40f5443d1727abd5d9f52bc9/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a214c993455f99a89aaeadc9b21241900037adc9d97203e374d75513c5911822", size = 573030, upload-time = "2026-06-30T07:15:30.553Z" }, + { url = "https://files.pythonhosted.org/packages/c9/50/22f73127a41f1ce4f87fe39aadfb9a126345801c274aa93ae88456249327/rpds_py-2026.6.3-cp312-cp312-win32.whl", hash = "sha256:501f9f04a588d6a09179368c57071301445191767c64e4b52a6aa9871f1ef5ed", size = 202185, upload-time = "2026-06-30T07:15:32.027Z" }, + { url = "https://files.pythonhosted.org/packages/04/3a/f0ee4d4dde9d3b69dedf1b5f74e7a40017046d55052d173e418c6a94f960/rpds_py-2026.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:2c958bf94822e9290a40aaf2a822d4bc5c88099093e3948ad6c571eca9272e5f", size = 220394, upload-time = "2026-06-30T07:15:33.359Z" }, + { url = "https://files.pythonhosted.org/packages/f3/83/3382fe37f809b59f02aac04dbc4e765b480b46ee0227ed516e3bdc4d3dfc/rpds_py-2026.6.3-cp312-cp312-win_arm64.whl", hash = "sha256:22bffe6042b9bcb0822bcd1955ec00e245daf17b4344e4ed8e9551b976b63e96", size = 215753, upload-time = "2026-06-30T07:15:34.778Z" }, + { url = "https://files.pythonhosted.org/packages/a4/9e/b818ee580026ec578138e961027a68820c40afeb1ec8f6819b54fb99e196/rpds_py-2026.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:3cfe765c1da0072636ca06628261e0ea05688e160d5c8a03e0217c3854037223", size = 343012, upload-time = "2026-06-30T07:15:36.005Z" }, + { url = "https://files.pythonhosted.org/packages/f3/6b/686d9dc4359a8f163cfbbf89ee0b4e586431de22fe8248edb63a8cf50d49/rpds_py-2026.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f4d78253f6996be4901669ad25319f842f740eccf4d58e3c7f3dd39e6dde1d8f", size = 338203, upload-time = "2026-06-30T07:15:37.462Z" }, + { url = "https://files.pythonhosted.org/packages/9e/9b/069aa329940f8207615e091f5eedbbd40e1e15eac68a0790fd05ccdf796c/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54f45a148e28767bf343d33a684693c70e451c6f4c0e9904709a723fafbdfc1f", size = 367984, upload-time = "2026-06-30T07:15:39.008Z" }, + { url = "https://files.pythonhosted.org/packages/14/db/34c203e4becff3703e4d3bc121842c00b8689197f398161203a880052f4e/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:842e7b070435622248c7a2c44ae53fa1440e073cc3023bc919fed570884097a7", size = 374815, upload-time = "2026-06-30T07:15:40.253Z" }, + { url = "https://files.pythonhosted.org/packages/ee/7d/8071067d2cc453d916ad836e828c943f575e8a44612537759002a1e07381/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8020133a74bd81b4572dd8e4be028a6b1ebcd70e6726edc3918008c08bee6ee6", size = 490545, upload-time = "2026-06-30T07:15:41.729Z" }, + { url = "https://files.pythonhosted.org/packages/a3/42/da06c5aa8f0484ff07f270787434204d9f4535e2f8c3b51ed402267e63c3/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdc7e35386f3847df728fbcb5e887e2d79c19e2fa1eba9e51b6621d23e3243af", size = 382828, upload-time = "2026-06-30T07:15:43.327Z" }, + { url = "https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acac386b453c2516111b50985d60ce46e7fadb5ea71ae7b25f4c946935bf27cf", size = 365678, upload-time = "2026-06-30T07:15:44.992Z" }, + { url = "https://files.pythonhosted.org/packages/69/9d/1d8922e1990b2a6eb532b6ff53d3e73d2b3bbffc84116c75826bee73dfc6/rpds_py-2026.6.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:425560c6fa0415f27261727bb20bd097568485e5eb0c121f1949417d1c516885", size = 377811, upload-time = "2026-06-30T07:15:46.523Z" }, + { url = "https://files.pythonhosted.org/packages/b1/3d/198dceafb4fb034a6a47347e1b0735d34e0bd4a50be4e898d408ee66cb14/rpds_py-2026.6.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a550fb4950a06dde3beb4721f5ad4b25bf4513784665b0a8522c792e2bd822a4", size = 395382, upload-time = "2026-06-30T07:15:47.955Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f1/13968e49655d40b6b19d8b9140296bbc6f1d86b3f0f6c346cf9f1adddf4b/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f4bca01b63096f606e095734dd56e74e175f94cfbf24ff3d63281cec61f7bb7", size = 543832, upload-time = "2026-06-30T07:15:49.33Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ab/289bcb1b90bd3e40a2900c561fa0e2087345ecbb094f0b870f2345142b7c/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ccffae9a092a00deb7efd545fe5e2c33c33b88e7c054337e9a74c179347d0b7d", size = 611011, upload-time = "2026-06-30T07:15:50.847Z" }, + { url = "https://files.pythonhosted.org/packages/1e/16/5043105e679436ccfbc8e5e0dd2d663ed18a8b8113515fd06a5e5d77c83e/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1cf01971c4f2c5553b772a542e4aaf191789cd331bc2cd4ff0e6e65ba49e1e97", size = 572431, upload-time = "2026-06-30T07:15:52.394Z" }, + { url = "https://files.pythonhosted.org/packages/85/ed/adab103321c0a6565d5ae1c2998349bc3ee175b82ccc5ae8fc04cc413075/rpds_py-2026.6.3-cp313-cp313-win32.whl", hash = "sha256:8c3d1e9c15b9d51ca0391e13da1a25a0a4df3c58a37c9dc368e0736cf7f69df0", size = 201710, upload-time = "2026-06-30T07:15:53.894Z" }, + { url = "https://files.pythonhosted.org/packages/7b/ed/a03b09668e74e5dabbf2e211f6468e1820c0552f7b0500082da31841bf7b/rpds_py-2026.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:9250a9a0a6fd4648b3f868da8d91a4c52b5811a62df58e753d50ae4454a36f80", size = 219454, upload-time = "2026-06-30T07:15:55.25Z" }, + { url = "https://files.pythonhosted.org/packages/27/17/b8642c12930b71bc2b25831f6708ccf0f75abcd11883932ec9ce54ba3a78/rpds_py-2026.6.3-cp313-cp313-win_arm64.whl", hash = "sha256:900a67df3fd1660b035a4761c4ce73c382ea6b35f90f9863c36c6fd8bf8b09bb", size = 215063, upload-time = "2026-06-30T07:15:56.573Z" }, + { url = "https://files.pythonhosted.org/packages/b6/36/7fbe9dcdaf857fb3f63c2a2284b62492d95f5e8334e947e5fb6e7f68c9be/rpds_py-2026.6.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:931908d9fc855d8f74783377822be318edb6dcb19e47169dc038f9a1bf60b06e", size = 344510, upload-time = "2026-06-30T07:15:57.921Z" }, + { url = "https://files.pythonhosted.org/packages/ba/54/f785cc3d3f60839ca57a5af4927a9f347b07b2799c373fc20f7949f87c7e/rpds_py-2026.6.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7469697dce35be237db177d42e2a2ee26e6dcc5fc052078a6fefabd288c6edd", size = 339495, upload-time = "2026-06-30T07:15:59.238Z" }, + { url = "https://files.pythonhosted.org/packages/63/ef/d4cdaf309e6b095b43597103cf8c0b951d6cca2acce68c474f75ec12e0c7/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcfbcf66006befb9fd2aeaa9e01feaf881b4dc330a02ba07d2322b1c11be7b5d", size = 369454, upload-time = "2026-06-30T07:16:01.021Z" }, + { url = "https://files.pythonhosted.org/packages/96/4a/9559a68b7ee15db09d7981212e8c2e219d2a1d6d4faa0391d813c3496a36/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:847927daf4cffbd4e90e42bc890069897101edd015f956cb8721b3473372edda", size = 374583, upload-time = "2026-06-30T07:16:02.287Z" }, + { url = "https://files.pythonhosted.org/packages/ef/75/8964aa7d2c6e8ac43eba8eb6e6b0fdda1f46d39f2fc3e6aa9f2cb17f485d/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c1ef08a82bfe327cc156da694660f599923e2e6665b6d81c9c2d0ac9ffc8", size = 492919, upload-time = "2026-06-30T07:16:03.723Z" }, + { url = "https://files.pythonhosted.org/packages/8f/97/6908094ac804115e65aedfd90f1b5fee4eebebd3f6c4cfc5419939267565/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae50181a047c871561212bb97f7932a2d45fb53e947bd9b57ebad85b529cbc53", size = 383725, upload-time = "2026-06-30T07:16:05.305Z" }, + { url = "https://files.pythonhosted.org/packages/d1/9c/0d1fdc2e7aba23e290d603bc494e97bd205bae262ce33c6b32a69768ed5e/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc319e5a1de4b6913aac94bf6a2f9e847371e0a140a43dd4991db1a09bc2d504", size = 367255, upload-time = "2026-06-30T07:16:07.086Z" }, + { url = "https://files.pythonhosted.org/packages/c4/fe/f0209ca4a9ed074bc8acb44dfd0e81c3122e94c9689f5645b7973a866719/rpds_py-2026.6.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e4316bf32babbed84e691e352faf967ce2f0f024174a8643c37c94a1080374fc", size = 379060, upload-time = "2026-06-30T07:16:08.525Z" }, + { url = "https://files.pythonhosted.org/packages/c6/8d/f1cc54c616b9d8897de8738aac148d20afca93f68187475fe194d09a71b9/rpds_py-2026.6.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8c6e5a2f750cc71c3e3b11d71661f21d6f9bc6cebc6564b1466417a1ec03ec77", size = 395960, upload-time = "2026-06-30T07:16:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/fb/04/aafff00f73aeca2945f734f1d483c64ab8f472d0864ab02377fd8e89c3b2/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4470ce197d4090875cf6affbf1f853338387428df97c4fb7b7106317b8214698", size = 545356, upload-time = "2026-06-30T07:16:11.816Z" }, + { url = "https://files.pythonhosted.org/packages/fd/cc/e229663b9e4ddac5a4acbe9085dd80a71af2a5d356b8b39d6bff233f24b0/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea964164cc9afa72d4d9b23cc28dafae93693c0a53e0b42acbff15b22c3f9ddd", size = 612319, upload-time = "2026-06-30T07:16:13.586Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7a/8a0e6d3e6cd066af108b71b43122c3fe158dd9eb86acac626593a2582eb1/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:639c8929aa0afe81be836b04de888460d6bed38b9c54cfc18da8f6bfabf5af5d", size = 573508, upload-time = "2026-06-30T07:16:15.23Z" }, + { url = "https://files.pythonhosted.org/packages/87/03/2a69ab618a789cf6cf85c86bb844c62d090e700ab1a2aa676b3741b6c516/rpds_py-2026.6.3-cp314-cp314-win32.whl", hash = "sha256:882076c00c0a608b131187055ddc5ae29f2e7eaf870d6168980420d58528a5c8", size = 202504, upload-time = "2026-06-30T07:16:16.893Z" }, + { url = "https://files.pythonhosted.org/packages/85/62/a3892ba945f4e24c78f352e5de3c7620d8479f73f211406a97263d13c7d2/rpds_py-2026.6.3-cp314-cp314-win_amd64.whl", hash = "sha256:0be972be84cfcaf46c8c6edf690ca0f154ac17babf1f6a955a51579b34ad2dc5", size = 220380, upload-time = "2026-06-30T07:16:18.108Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e7/c2bd44dc831931815ad11ebb5f430b5a0a4d3caa9de837107876c30c3432/rpds_py-2026.6.3-cp314-cp314-win_arm64.whl", hash = "sha256:2a9c6f195058cb45335e8cc3802745c603d716eb96bc9625950c1aac71c0c703", size = 215976, upload-time = "2026-06-30T07:16:19.654Z" }, + { url = "https://files.pythonhosted.org/packages/79/9c/fff7b74bce9a091ec9a012a03f9ff5f69364eaf9451060dfc4486da2ffdd/rpds_py-2026.6.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:f90938e92afda60266da758ee7d363447f7f0138c9559f9e1811629580582d90", size = 346840, upload-time = "2026-06-30T07:16:21.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/44/77bcb1168b33704908295533d27f10eb811e9e3e193e8993dc99572211d3/rpds_py-2026.6.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec829541c45bca16e61c7ae50c20501f213605beb75d1aba91a6ee37fbbb56a4", size = 340282, upload-time = "2026-06-30T07:16:22.875Z" }, + { url = "https://files.pythonhosted.org/packages/87/3c/7a9081c7c9e645b39efe19e4ffbeccd80add246327cd9b888aecffd72317/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afd70d95892096cdb26f15a00c45907b17817577aa8d1c76b2dcc2788391f9e9", size = 370403, upload-time = "2026-06-30T07:16:24.415Z" }, + { url = "https://files.pythonhosted.org/packages/f7/69/af47021eb7dad6ff3396cb001c08f0f3c4d06c20253f75be6421a59fe6b7/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29dfa0533a5d4c94d4dfa1b694fcb56c9c63aad8330ffdd816fd225d0a7a162f", size = 376055, upload-time = "2026-06-30T07:16:26.111Z" }, + { url = "https://files.pythonhosted.org/packages/81/fc/a3bcf517084396a6dd258c592567a3c011ba4557f2fde23dceaf26e74f2e/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af05d726809bff6b141be124d4c7ce998f9c9c7f30edb1f46c07aa103d540b41", size = 494419, upload-time = "2026-06-30T07:16:27.596Z" }, + { url = "https://files.pythonhosted.org/packages/c9/eb/13d529d1788135425c7bf207f8463458ca5d92e43f3f701365b83e9dffc1/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9826217f048f620d9a712672818bf231442c1b35d96b227a07eabd11b4bb6945", size = 384848, upload-time = "2026-06-30T07:16:29.183Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f4/b7ac49f30013aba8f7b9566b1dd07e81de95e708c1374b7bacc5b9bc5c9c/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:536bceea4fa4acf7e1c61da2b5786304367c816c8895be71b8f537c480b0ea1f", size = 371369, upload-time = "2026-06-30T07:16:30.912Z" }, + { url = "https://files.pythonhosted.org/packages/31/86/6260bafa622f788b07ddec0e52d810305c8b9b0b8c27f58a2ab04bf62b4f/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:bc0011654b91cc4fb2ae701bec0a0ba1e552c0714247fa7af6c59e0ccfa3a4e1", size = 379673, upload-time = "2026-06-30T07:16:32.486Z" }, + { url = "https://files.pythonhosted.org/packages/19/c3/03f1ee79a047b48daeca157c89a18509cde22b6b951d642b9b0af1be660a/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:539d75de9e0d536c84ff18dfeb805398e58227001ce09231a26a08b9aed1ee0e", size = 397500, upload-time = "2026-06-30T07:16:34.471Z" }, + { url = "https://files.pythonhosted.org/packages/f0/95/8ed0cd8c377dca12aea498f119fe639fc474d1461545c39d2b5872eb1c0f/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:166cf54d9f44fc6ceb53c7860258dde44a81406646de79f8ed3234fca3b6e538", size = 545978, upload-time = "2026-06-30T07:16:36.45Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f2/0eb57f0eaa83f8fc152a7e03de968ab77e1f00732bebc892b190c6eebde7/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:d34c20167764fbcf927194d532dd7e0c56772f0a5f943fa5ef9e9afbba8fb9db", size = 613350, upload-time = "2026-06-30T07:16:38.213Z" }, + { url = "https://files.pythonhosted.org/packages/5b/de/e0674bdbc3ef7634989b3f854c3f34bc1f587d36e5bfdc5c378d57034619/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea7bb13b7c9a29791f87a0387ba7d3ad3a6d783d827e4d3f27b40a0ff44495e2", size = 576486, upload-time = "2026-06-30T07:16:39.797Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f6/21101359743cd136ada781e8210a85769578422ba460672eea0e29739200/rpds_py-2026.6.3-cp314-cp314t-win32.whl", hash = "sha256:6de4744d05bd1aa1be4ed7ea1189e3979196808008113bbbf899a460966b925e", size = 201068, upload-time = "2026-06-30T07:16:41.316Z" }, + { url = "https://files.pythonhosted.org/packages/a6/b2/9574d4d44f7760c2aa32d92a0a4f41698e33f5b204a0bf5c9758f52c79d5/rpds_py-2026.6.3-cp314-cp314t-win_amd64.whl", hash = "sha256:c7b9a2f8f4d8e90af72571d3d495deebdd7e3c75451f5b41719aee166e940fc2", size = 220600, upload-time = "2026-06-30T07:16:43.091Z" }, + { url = "https://files.pythonhosted.org/packages/08/ae/f23a2697e6ee6340a578b0f136be6483657bef0c6f9497b752bb5c0964bb/rpds_py-2026.6.3-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:e059c5dde6452b44424bd1834557556c226b57781dee1227af23518459722b13", size = 344726, upload-time = "2026-06-30T07:16:44.5Z" }, + { url = "https://files.pythonhosted.org/packages/c3/63/e7b3a1a5358dd32c930a1062d8e15b67fd6e8922e81df9e91706d66ee5c8/rpds_py-2026.6.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2f7c26fbc5acd2522b95d4177fe4710ffd8e9b20529e703ffbf8db4d93903f05", size = 339587, upload-time = "2026-06-30T07:16:46.255Z" }, + { url = "https://files.pythonhosted.org/packages/ec/64/10a85681916ca55fffb91b0a211f84e34297c109243484dd6394660a8a7c/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3086b538543802f84c843911242db20447de00d8752dd0efc936dbcf02218ba", size = 369585, upload-time = "2026-06-30T07:16:48.101Z" }, + { url = "https://files.pythonhosted.org/packages/76/c2/baf95c7c38823e12ba34407c5f5767a89e5cf2233895e56f608167ae9493/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2e5c5ee828d42cb11760761c0af6507927bec42d0ad5458f97c9203b054617", size = 375479, upload-time = "2026-06-30T07:16:49.93Z" }, + { url = "https://files.pythonhosted.org/packages/6a/94/0aad06c72d65101e11d33528d438cda99a39ce0da99466e156158f2541d3/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed0c1e5d10cdc7135537988c74a0188da68e2f3c30813ba3744ab1e42e0480f9", size = 492418, upload-time = "2026-06-30T07:16:51.641Z" }, + { url = "https://files.pythonhosted.org/packages/b5/17/de3f5a479a1f056535d7489819639d8cd591ea6281d700390b43b1abd745/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c2642a7603ec0b16ed77da4555db3b4b472341904873788327c0b0d7b95f1bb", size = 384123, upload-time = "2026-06-30T07:16:53.622Z" }, + { url = "https://files.pythonhosted.org/packages/46/7d/bf09bd1b145bb2671c03e1e6d1ab8651858d90d8c7dfeadd85a37a934fd8/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4320744c1ffdd95a603def63344bfab2d33edeab301c5007e7de9f9f5b3885", size = 367351, upload-time = "2026-06-30T07:16:55.241Z" }, + { url = "https://files.pythonhosted.org/packages/a3/ea/1bb734f314b8be319149ddee80b18bd41372bdcfbdf88d28131c0cd37719/rpds_py-2026.6.3-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:a9f4645593036b81bbdb36b9c8e0ea0d1c3fee968c4d59db0344c14087ef143a", size = 378827, upload-time = "2026-06-30T07:16:56.841Z" }, + { url = "https://files.pythonhosted.org/packages/4b/93/d9611e5b25e26df9a3649813ed66193ace9347a7c7fc4ab7cf70e94851c0/rpds_py-2026.6.3-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e55d236be29255554da47abe5c577637db7c24a02b8b46f0ca9524c855801868", size = 395966, upload-time = "2026-06-30T07:16:58.557Z" }, + { url = "https://files.pythonhosted.org/packages/c3/cb/99d77e16e5534ae1d90629bbe419ba6ee170833a6a85e3aa1cc41726fbbc/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:24e9c5386e16669b674a69c156c8eeefcb578f3b3397b713b08e6d60f3c7b187", size = 545680, upload-time = "2026-06-30T07:17:00.164Z" }, + { url = "https://files.pythonhosted.org/packages/59/15/11a29755f790cef7a2f755e8e14f4f0c33f39489e1893a632a2eee59672b/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:c60924535c75f1566b6eb75b5c31a48a43fef04fa2d0d201acbad8a9969c6107", size = 611853, upload-time = "2026-06-30T07:17:01.962Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/0c27547e21644da938fb530f7e1a8148dd24d02db07e7a5f2567a17ce710/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:38a2fea2787428f811719ceb9114cb78964a3138838320c29ac39526c79c16ba", size = 573715, upload-time = "2026-06-30T07:17:03.693Z" }, + { url = "https://files.pythonhosted.org/packages/29/71/4d8fcf700931815594bce892255bbd973b94efaf0fc1932b0590df18d886/rpds_py-2026.6.3-cp315-cp315-win32.whl", hash = "sha256:d483fe17f01ad64b7bf7cc38fcefff1ca9fb83f8c2b2542b68f97ffe0611b369", size = 202864, upload-time = "2026-06-30T07:17:05.746Z" }, + { url = "https://files.pythonhosted.org/packages/eb/62/b577562de0edbb55b2be85ce5fd09c33e386b9b13eee09833af4240fd5c4/rpds_py-2026.6.3-cp315-cp315-win_amd64.whl", hash = "sha256:67e3a721ffc5d8d2210d3671872298c4a84e4b8035cfe42ffd7cde35d772b146", size = 220430, upload-time = "2026-06-30T07:17:07.471Z" }, + { url = "https://files.pythonhosted.org/packages/c8/95/d6d0b2509825141eef60669a5739eec88dbc6a48053d6c92993a5704defe/rpds_py-2026.6.3-cp315-cp315-win_arm64.whl", hash = "sha256:6e84adbcf4bf841aed8116a8264b9f50b4cb3e7bd89b516122e616ac56ca269e", size = 215877, upload-time = "2026-06-30T07:17:09.008Z" }, + { url = "https://files.pythonhosted.org/packages/b7/bf/f3ea278f0afd615c1d0f19cb69043a41526e2bb600c2b536eb192218eb27/rpds_py-2026.6.3-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ae6dd8f10bd17aad820876d24caec9efdafd80a318d16c0a48edb5e136902c6b", size = 346933, upload-time = "2026-06-30T07:17:10.762Z" }, + { url = "https://files.pythonhosted.org/packages/9d/29/9907bdf1c5346763cf10b7f6852aad86652168c259def904cbe0082c5864/rpds_py-2026.6.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bdbd97738551fca3917c1bd7188bec1920bb520104f28e7e1007f9ceb17b7690", size = 340274, upload-time = "2026-06-30T07:17:12.266Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2c/8e03767b5778ef25cebf74a7a91a2c3806f8eced4c92cb7406bbe060756d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b95977e7211527ab0ba576e286d023389fbeeb32a6b7b771665d333c60e5342", size = 370763, upload-time = "2026-06-30T07:17:14.107Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e1/df2a7e1ba2efd796af26194250b8d42c821b46592311595162af9ef0528d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15fde0e6fb0d88a60d221204873743e5d9f0b7d29165e62cd86d0413ad74ba6", size = 376467, upload-time = "2026-06-30T07:17:15.76Z" }, + { url = "https://files.pythonhosted.org/packages/6b/de/8a0814d1946af29cb068fb259aa8622f856df1d0bab58429448726b537f5/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a136d453475ac0fcbda502ef1e6504bd28d6d904700915d278deeab0d00fe140", size = 496689, upload-time = "2026-06-30T07:17:17.308Z" }, + { url = "https://files.pythonhosted.org/packages/df/f3/f19e0c852ba13694f5a79f3b719331051573cb5693feacf8a88ffffc3a71/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f826877d462181e5eb1c26a0026b8d0cab05d99844ecb6d8bf3627a2ca0c0442", size = 385340, upload-time = "2026-06-30T07:17:18.928Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ae/7ec3a9d2d4351f99e37bcb06b6b6f954512646bfdbf9742e1de727865daf/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79486287de1730dbaff3dbd124d0ca4d2ef7f9d29bf2544f1f93c09b5bcbbd12", size = 372179, upload-time = "2026-06-30T07:17:20.539Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ac/9cee911dff2aaa9a5a8354f6610bf2e6a616de9197c5fff4f54f82585f1e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:808345f53cb952433ca2816f1604ff3515608a81784954f38d4452acfe8e61d5", size = 379993, upload-time = "2026-06-30T07:17:22.212Z" }, + { url = "https://files.pythonhosted.org/packages/83/6b/7c2a07ba88d1e9a936612f7a5d067467ed03d971d5a06f7d309dff044a7e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1967debc37f64f2c4dc90a7f563aec558b471966e12adcac4e1c4240496b6ebf", size = 398909, upload-time = "2026-06-30T07:17:23.66Z" }, + { url = "https://files.pythonhosted.org/packages/97/0b/776ffcb66783637b0031f6d58d6fb55913c8b5abf00aeecd46bf933fb477/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:f0840b5b17057f7fd918b76183a4b5a0635f43e14eb2ce60dce1d4ee4707ea00", size = 546584, upload-time = "2026-06-30T07:17:25.264Z" }, + { url = "https://files.pythonhosted.org/packages/55/33/ba3bc04d7092bd553c9b2b195624992d2cc4f3de1f380b7b93cbee67bd79/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:faa679d19a6696fd54259ad321251ad77a13e70e03dd834daa762a44fb6196ef", size = 614357, upload-time = "2026-06-30T07:17:26.888Z" }, + { url = "https://files.pythonhosted.org/packages/8b/71/14edf065f04630b1a8472f7653cad03f6c478bcf95ea0e6aed55451e33ea/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:23a439f31ccbeff1574e24889128821d1f7917470e830cf6544dced1c662262a", size = 576533, upload-time = "2026-06-30T07:17:28.546Z" }, + { url = "https://files.pythonhosted.org/packages/ba/76/65002b08596c389105720a8c0d22298b8dc25a4baf89b2ce431343c8b1de/rpds_py-2026.6.3-cp315-cp315t-win32.whl", hash = "sha256:913ca42ccad3f8cc6e292b587ae8ae49c8c823e5dce51a736252fc7c7cdfa577", size = 201204, upload-time = "2026-06-30T07:17:30.193Z" }, + { url = "https://files.pythonhosted.org/packages/8c/97/d855d6b3c322d1f27e26f5241c42016b56cf01377ea8ed348285f54652f0/rpds_py-2026.6.3-cp315-cp315t-win_amd64.whl", hash = "sha256:ae3d4fe8c0b9213624fdce7279d70e3b148b682ca20719ebd193a23ebfa47324", size = 220719, upload-time = "2026-06-30T07:17:31.788Z" }, ] + +[[package]] +name = "scikit-network" +version = "0.33.5" +source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", version = "2.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/62/11/4d44a1f274e002784e4dbdb81e0ea96d2de2d1045b2132d5af62cc31fd28/scipy-1.14.1.tar.gz", hash = "sha256:5a275584e726026a5699459aa72f828a610821006228e841b94275c4a7c08417", size = 58620554 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/64/68/3bc0cfaf64ff507d82b1e5d5b64521df4c8bf7e22bc0b897827cbee9872c/scipy-1.14.1-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:b28d2ca4add7ac16ae8bb6632a3c86e4b9e4d52d3e34267f6e1b0c1f8d87e389", size = 39069598 }, - { url = "https://files.pythonhosted.org/packages/43/a5/8d02f9c372790326ad405d94f04d4339482ec082455b9e6e288f7100513b/scipy-1.14.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:d0d2821003174de06b69e58cef2316a6622b60ee613121199cb2852a873f8cf3", size = 29879676 }, - { url = "https://files.pythonhosted.org/packages/07/42/0e0bea9666fcbf2cb6ea0205db42c81b1f34d7b729ba251010edf9c80ebd/scipy-1.14.1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8bddf15838ba768bb5f5083c1ea012d64c9a444e16192762bd858f1e126196d0", size = 23088696 }, - { url = "https://files.pythonhosted.org/packages/15/47/298ab6fef5ebf31b426560e978b8b8548421d4ed0bf99263e1eb44532306/scipy-1.14.1-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:97c5dddd5932bd2a1a31c927ba5e1463a53b87ca96b5c9bdf5dfd6096e27efc3", size = 25470699 }, - { url = "https://files.pythonhosted.org/packages/d8/df/cdb6be5274bc694c4c22862ac3438cb04f360ed9df0aecee02ce0b798380/scipy-1.14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ff0a7e01e422c15739ecd64432743cf7aae2b03f3084288f399affcefe5222d", size = 35606631 }, - { url = "https://files.pythonhosted.org/packages/47/78/b0c2c23880dd1e99e938ad49ccfb011ae353758a2dc5ed7ee59baff684c3/scipy-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e32dced201274bf96899e6491d9ba3e9a5f6b336708656466ad0522d8528f69", size = 41178528 }, - { url = "https://files.pythonhosted.org/packages/5d/aa/994b45c34b897637b853ec04334afa55a85650a0d11dacfa67232260fb0a/scipy-1.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8426251ad1e4ad903a4514712d2fa8fdd5382c978010d1c6f5f37ef286a713ad", size = 42784535 }, - { url = "https://files.pythonhosted.org/packages/e7/1c/8daa6df17a945cb1a2a1e3bae3c49643f7b3b94017ff01a4787064f03f84/scipy-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:a49f6ed96f83966f576b33a44257d869756df6cf1ef4934f59dd58b25e0327e5", size = 44772117 }, - { url = "https://files.pythonhosted.org/packages/b2/ab/070ccfabe870d9f105b04aee1e2860520460ef7ca0213172abfe871463b9/scipy-1.14.1-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:2da0469a4ef0ecd3693761acbdc20f2fdeafb69e6819cc081308cc978153c675", size = 39076999 }, - { url = "https://files.pythonhosted.org/packages/a7/c5/02ac82f9bb8f70818099df7e86c3ad28dae64e1347b421d8e3adf26acab6/scipy-1.14.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:c0ee987efa6737242745f347835da2cc5bb9f1b42996a4d97d5c7ff7928cb6f2", size = 29894570 }, - { url = "https://files.pythonhosted.org/packages/ed/05/7f03e680cc5249c4f96c9e4e845acde08eb1aee5bc216eff8a089baa4ddb/scipy-1.14.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3a1b111fac6baec1c1d92f27e76511c9e7218f1695d61b59e05e0fe04dc59617", size = 23103567 }, - { url = "https://files.pythonhosted.org/packages/5e/fc/9f1413bef53171f379d786aabc104d4abeea48ee84c553a3e3d8c9f96a9c/scipy-1.14.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8475230e55549ab3f207bff11ebfc91c805dc3463ef62eda3ccf593254524ce8", size = 25499102 }, - { url = "https://files.pythonhosted.org/packages/c2/4b/b44bee3c2ddc316b0159b3d87a3d467ef8d7edfd525e6f7364a62cd87d90/scipy-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:278266012eb69f4a720827bdd2dc54b2271c97d84255b2faaa8f161a158c3b37", size = 35586346 }, - { url = "https://files.pythonhosted.org/packages/93/6b/701776d4bd6bdd9b629c387b5140f006185bd8ddea16788a44434376b98f/scipy-1.14.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fef8c87f8abfb884dac04e97824b61299880c43f4ce675dd2cbeadd3c9b466d2", size = 41165244 }, - { url = "https://files.pythonhosted.org/packages/06/57/e6aa6f55729a8f245d8a6984f2855696c5992113a5dc789065020f8be753/scipy-1.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b05d43735bb2f07d689f56f7b474788a13ed8adc484a85aa65c0fd931cf9ccd2", size = 42817917 }, - { url = "https://files.pythonhosted.org/packages/ea/c2/5ecadc5fcccefaece775feadcd795060adf5c3b29a883bff0e678cfe89af/scipy-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:716e389b694c4bb564b4fc0c51bc84d381735e0d39d3f26ec1af2556ec6aad94", size = 44781033 }, - { url = "https://files.pythonhosted.org/packages/c0/04/2bdacc8ac6387b15db6faa40295f8bd25eccf33f1f13e68a72dc3c60a99e/scipy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:631f07b3734d34aced009aaf6fedfd0eb3498a97e581c3b1e5f14a04164a456d", size = 39128781 }, - { url = "https://files.pythonhosted.org/packages/c8/53/35b4d41f5fd42f5781dbd0dd6c05d35ba8aa75c84ecddc7d44756cd8da2e/scipy-1.14.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:af29a935803cc707ab2ed7791c44288a682f9c8107bc00f0eccc4f92c08d6e07", size = 29939542 }, - { url = "https://files.pythonhosted.org/packages/66/67/6ef192e0e4d77b20cc33a01e743b00bc9e68fb83b88e06e636d2619a8767/scipy-1.14.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2843f2d527d9eebec9a43e6b406fb7266f3af25a751aa91d62ff416f54170bc5", size = 23148375 }, - { url = "https://files.pythonhosted.org/packages/f6/32/3a6dedd51d68eb7b8e7dc7947d5d841bcb699f1bf4463639554986f4d782/scipy-1.14.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:eb58ca0abd96911932f688528977858681a59d61a7ce908ffd355957f7025cfc", size = 25578573 }, - { url = "https://files.pythonhosted.org/packages/f0/5a/efa92a58dc3a2898705f1dc9dbaf390ca7d4fba26d6ab8cfffb0c72f656f/scipy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30ac8812c1d2aab7131a79ba62933a2a76f582d5dbbc695192453dae67ad6310", size = 35319299 }, - { url = "https://files.pythonhosted.org/packages/8e/ee/8a26858ca517e9c64f84b4c7734b89bda8e63bec85c3d2f432d225bb1886/scipy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f9ea80f2e65bdaa0b7627fb00cbeb2daf163caa015e59b7516395fe3bd1e066", size = 40849331 }, - { url = "https://files.pythonhosted.org/packages/a5/cd/06f72bc9187840f1c99e1a8750aad4216fc7dfdd7df46e6280add14b4822/scipy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:edaf02b82cd7639db00dbff629995ef185c8df4c3ffa71a5562a595765a06ce1", size = 42544049 }, - { url = "https://files.pythonhosted.org/packages/aa/7d/43ab67228ef98c6b5dd42ab386eae2d7877036970a0d7e3dd3eb47a0d530/scipy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:2ff38e22128e6c03ff73b6bb0f85f897d2362f8c052e3b8ad00532198fbdae3f", size = 44521212 }, - { url = "https://files.pythonhosted.org/packages/50/ef/ac98346db016ff18a6ad7626a35808f37074d25796fd0234c2bb0ed1e054/scipy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1729560c906963fc8389f6aac023739ff3983e727b1a4d87696b7bf108316a79", size = 39091068 }, - { url = "https://files.pythonhosted.org/packages/b9/cc/70948fe9f393b911b4251e96b55bbdeaa8cca41f37c26fd1df0232933b9e/scipy-1.14.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:4079b90df244709e675cdc8b93bfd8a395d59af40b72e339c2287c91860deb8e", size = 29875417 }, - { url = "https://files.pythonhosted.org/packages/3b/2e/35f549b7d231c1c9f9639f9ef49b815d816bf54dd050da5da1c11517a218/scipy-1.14.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e0cf28db0f24a38b2a0ca33a85a54852586e43cf6fd876365c86e0657cfe7d73", size = 23084508 }, - { url = "https://files.pythonhosted.org/packages/3f/d6/b028e3f3e59fae61fb8c0f450db732c43dd1d836223a589a8be9f6377203/scipy-1.14.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:0c2f95de3b04e26f5f3ad5bb05e74ba7f68b837133a4492414b3afd79dfe540e", size = 25503364 }, - { url = "https://files.pythonhosted.org/packages/a7/2f/6c142b352ac15967744d62b165537a965e95d557085db4beab2a11f7943b/scipy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b99722ea48b7ea25e8e015e8341ae74624f72e5f21fc2abd45f3a93266de4c5d", size = 35292639 }, - { url = "https://files.pythonhosted.org/packages/56/46/2449e6e51e0d7c3575f289f6acb7f828938eaab8874dbccfeb0cd2b71a27/scipy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5149e3fd2d686e42144a093b206aef01932a0059c2a33ddfa67f5f035bdfe13e", size = 40798288 }, - { url = "https://files.pythonhosted.org/packages/32/cd/9d86f7ed7f4497c9fd3e39f8918dd93d9f647ba80d7e34e4946c0c2d1a7c/scipy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e4f5a7c49323533f9103d4dacf4e4f07078f360743dec7f7596949149efeec06", size = 42524647 }, - { url = "https://files.pythonhosted.org/packages/f5/1b/6ee032251bf4cdb0cc50059374e86a9f076308c1512b61c4e003e241efb7/scipy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:baff393942b550823bfce952bb62270ee17504d02a1801d7fd0719534dfb9c84", size = 44469524 }, + { name = "numpy" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/6d/28b00fbef9ff7d8ba31861bf16705a1a74a1696fb65aab2a7c584f966bec/scikit_network-0.33.5.tar.gz", hash = "sha256:ae2149d9a280fdc4bbadd5f8a7b17c8af61c054bc3f834792bc61483e6783c12", size = 1784205, upload-time = "2025-11-19T09:45:14.402Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/32/f092fca9a3ae256e0608ec6a4d8830023ea4ae478c2e27e94cf5802824f0/scikit_network-0.33.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ced625228be1632595d11adaf22d61d1d4c788909cd4d8c364e720b2814aac7f", size = 2874698, upload-time = "2025-11-19T09:44:52.765Z" }, + { url = "https://files.pythonhosted.org/packages/4b/c7/5b2ce72f93b422af48a2b755fbcbab271bf980a6b46484f754d63978f1ff/scikit_network-0.33.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:808b625d28005c24b47cbdf65f780a3a355aa4080992e6b78f03434e873d06e6", size = 2854224, upload-time = "2025-11-19T09:44:55.574Z" }, + { url = "https://files.pythonhosted.org/packages/86/02/974ae67f493ccf988108894e8a9dedfd00ca5113d2848e0b9fc2a4d18824/scikit_network-0.33.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f9f2d98059cd79bdb935ff6a638f1c3a12b0b1cb7ace9e1d3fb35476eeeaabaa", size = 7924650, upload-time = "2025-11-19T09:44:57.704Z" }, + { url = "https://files.pythonhosted.org/packages/8d/34/b67e48e111916a6f09fe29a971a9716c14f78525e0ab7c46e6a6538cf2f6/scikit_network-0.33.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aac2d3bc14214f02dac300624f5ec2650af9a98b52f304d300f0ec2813a0e544", size = 8012322, upload-time = "2025-11-19T09:45:00.079Z" }, + { url = "https://files.pythonhosted.org/packages/c3/a2/49293b53b837b3248d19fffd41a9fd73dcb2eeabbab890cc4c8aa237b545/scikit_network-0.33.5-cp312-cp312-win_amd64.whl", hash = "sha256:2866b16aed9ef25ba42cb2f2e44ef2ad079337f336ce48d0604b55fa4af87688", size = 2746491, upload-time = "2025-11-19T09:45:01.997Z" }, + { url = "https://files.pythonhosted.org/packages/d6/cd/0069244e970d27fa0ab0512394295a106605f00c271e85618182460d2c92/scikit_network-0.33.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:aa8b490a777e081dd6f69627a26b50cc4012f27fff683a1e4828819a88a5dcf2", size = 2862564, upload-time = "2025-11-19T09:45:03.93Z" }, + { url = "https://files.pythonhosted.org/packages/51/37/85454864e50a65e528fe3b15eb3b41eb68b0c7f6d5c51c220b3198622ede/scikit_network-0.33.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3615d073ba9ae1ae30dda2de747474cd23c86cededa82b317471ee9f9bebd1b2", size = 2842521, upload-time = "2025-11-19T09:45:06.31Z" }, + { url = "https://files.pythonhosted.org/packages/c4/b9/4023f35e430b51020f17b0f1d8933768cf1ed7cd1623cc089f5543048983/scikit_network-0.33.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2408d3f4c81256a3193d536aad4a6ffcfbb05d096abe6a9cc0b6b5e275df876d", size = 7871695, upload-time = "2025-11-19T09:45:08.101Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ec/e50755f7459130ba745c42c37665c5ae9a7c7e357f43400b5b8b966f902e/scikit_network-0.33.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:526490a1e0e8e49ad0f4cca193f581d60082a2fa8c9a825eb0b6936050b0d02b", size = 7968762, upload-time = "2025-11-19T09:45:10.347Z" }, + { url = "https://files.pythonhosted.org/packages/45/2a/616974a0adb9d04a791570e9371caaef14c54f8806b04dd59c80a7b60289/scikit_network-0.33.5-cp313-cp313-win_amd64.whl", hash = "sha256:722c15fcede5e07ac008354bbd6ef375e0f5bf1fd52bd40271775997be2fb715", size = 2742482, upload-time = "2025-11-19T09:45:12.843Z" }, +] + +[[package]] +name = "scipy" +version = "1.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7e/74/66de6258867beb2ef08f35f9f2ac017a52cacd5081714d239ff1a442d458/scipy-1.18.1.tar.gz", hash = "sha256:52c4b7422442aba924d03ad4019852b08a92e64ea187b933135687bfe2747307", size = 30781235, upload-time = "2026-08-21T23:28:50.599Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/f7/240c110c08693826b4513a52f5717d62ec7c7af72f2920821247c03b17b3/scipy-1.18.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:457fd7a2a8edeb044ab6ffbc0aa03ff6cd18491356e5e0c834d76ce621b916d1", size = 31111061, upload-time = "2026-08-21T23:23:44.522Z" }, + { url = "https://files.pythonhosted.org/packages/05/4a/78c6285577c375e7cf27277ea8ee6961224327f1e1a0c44af5f17f23635c/scipy-1.18.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:e708533e8b2ae2497d65346538a7dcc92814410b25b81432eac66de0f2af8265", size = 28733332, upload-time = "2026-08-21T23:23:50.015Z" }, + { url = "https://files.pythonhosted.org/packages/a5/f6/a5b82f8abbe14d134691b8b903696f701d25a081353a29dc655c364d9e62/scipy-1.18.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:7bbf207c4453ce1ad2e00b17313852b33310b83090c2311bdaf97f93c0380d12", size = 20475078, upload-time = "2026-08-21T23:23:54.138Z" }, + { url = "https://files.pythonhosted.org/packages/23/22/0858a0bbd6b3e825ceb8cd9baf9eaf3b2f2b1d77727eb6be40500bcdc92f/scipy-1.18.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:78c0665edead396b1abb4897c41a5c1d9bf090c8a637a4c20a61678e0a264e66", size = 23108904, upload-time = "2026-08-21T23:23:57.824Z" }, + { url = "https://files.pythonhosted.org/packages/75/9a/2e71719f31eaefe0e3a1706c4a1ded94e664bfd95ffca2b219a671faee01/scipy-1.18.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c085faa2cfa879c5141df483f836f4d691045a078224a670fa570fa01612d89", size = 34025113, upload-time = "2026-08-21T23:24:02.209Z" }, + { url = "https://files.pythonhosted.org/packages/df/64/ff35eb9e54894cf471ff4716abd3c81eb0a0626869217ce3e6ba4ccf17d7/scipy-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f55fa87b6c612ecd6b058f167c53231b1d14e412efe361d3d6e38b3631c73218", size = 35344199, upload-time = "2026-08-21T23:24:07.844Z" }, + { url = "https://files.pythonhosted.org/packages/d3/af/c5538be1792f7034c12c7db6ee67cace58253c7b87b122d68253eaf5de89/scipy-1.18.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c35d74ce0e193ff740c2f2be2ac913ddc232fe6c1ff40b26cfecb9c670c63314", size = 35639587, upload-time = "2026-08-21T23:24:13.05Z" }, + { url = "https://files.pythonhosted.org/packages/91/4c/075e4f66471bac101141ac739e9e135549be1bae584571bd03a530c056e1/scipy-1.18.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d2924a03db38dc2e848bca2fe9f077dafb891480b91a00a0963a8cf86dfc31c1", size = 37480330, upload-time = "2026-08-21T23:24:19.608Z" }, + { url = "https://files.pythonhosted.org/packages/39/e7/979fd14e75008623df31ba70d6bb144700f68feadcea042021c06a05bf82/scipy-1.18.1-cp312-cp312-win_amd64.whl", hash = "sha256:5e4d44984abc0020154ea81b247adeddcc3ac5527b975ff798bd1ba0adc513c2", size = 36658278, upload-time = "2026-08-21T23:24:25.463Z" }, + { url = "https://files.pythonhosted.org/packages/c7/0b/e1525354ff9d7d5feb6d1b31af6d14072e5c91e9607b421fa1ec889660b3/scipy-1.18.1-cp312-cp312-win_arm64.whl", hash = "sha256:d65d448389b8436493abcf629cc94ad0cf32aecaf06e1acca1de53cc795f2f12", size = 24400588, upload-time = "2026-08-21T23:24:30.579Z" }, + { url = "https://files.pythonhosted.org/packages/b6/55/4540ee0f9c42a9ad7109d0d1a8cc70de54c3572b01c6693a2b1c70e90ceb/scipy-1.18.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:3ab3523da44749156e1f68b464dc56af11ae4cbc5c739a49d05f32b982eca9f3", size = 31089958, upload-time = "2026-08-21T23:24:35.8Z" }, + { url = "https://files.pythonhosted.org/packages/2a/f5/769f36d14922b8071a43e95d24d18b6bdafad10d7f5cf647867e1ac052bc/scipy-1.18.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6fb6a55cc0ba97b59a1f288fb86dc6fce8bdfc0fffcbfd015e3a954bf2a2d93", size = 28715106, upload-time = "2026-08-21T23:24:40.775Z" }, + { url = "https://files.pythonhosted.org/packages/9a/d7/21d890274f75ea37a8209d5519e72da3da90302e3b9fb8397a0918386a62/scipy-1.18.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ea324d9dd34c38bfb9bec8ca4d1b407db97dbb74029f566b8e322b1b6fe56fe6", size = 20456846, upload-time = "2026-08-21T23:24:45.066Z" }, + { url = "https://files.pythonhosted.org/packages/ec/01/798430ecea2e78ec7c02663d5f71c007bb6abeca931080debd40d7fa55ea/scipy-1.18.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:75b00eb8fb802090aa903f4ea1c7f5a584779f967361e68b7e98e531cc2d7174", size = 23087986, upload-time = "2026-08-21T23:24:49.539Z" }, + { url = "https://files.pythonhosted.org/packages/e6/5f/4634e9d35c68496e4e34cb6946eafab044458e6cedab42b40b6588e475b6/scipy-1.18.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d416b16cccfd70fbf62400e84d0bb2f4e6af519a45557f1692c749b37f14b315", size = 33998146, upload-time = "2026-08-21T23:24:54.714Z" }, + { url = "https://files.pythonhosted.org/packages/41/48/6450ed9243315322bbc19ac57b9b70d66a20bf1d38d124c96bc4bf6af9ea/scipy-1.18.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fdaf5ea890a6183d0565f51a61799d67081bd5b1cf03c5f4b3fd3732108625c9", size = 35312578, upload-time = "2026-08-21T23:25:00.44Z" }, + { url = "https://files.pythonhosted.org/packages/00/bd/bf5a4be6a3525676499f6dff307991739ff6fdcad1481b1aeb6745339f58/scipy-1.18.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c825cef2f49e46753726a7181a8e199804a912b29519ada542c6ebc654951899", size = 35612621, upload-time = "2026-08-21T23:25:06.144Z" }, + { url = "https://files.pythonhosted.org/packages/bd/4e/3c45c33e00a77996c4b1cb707929f833ba7b1d522ee29f882512c330676d/scipy-1.18.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e3b417bf8c2c7c16e8f58ad91db17783ec911ac16e7b50eb6eab6e809b4f5b07", size = 37457323, upload-time = "2026-08-21T23:25:12.483Z" }, + { url = "https://files.pythonhosted.org/packages/93/0e/e0348fbc0dbab65c114cf78957e7dfeb49f8e8b556b4d930cc12ff195e18/scipy-1.18.1-cp313-cp313-win_amd64.whl", hash = "sha256:559ed65f60c1af5a03f3912605a1b5114f522c7c32fb23c3376ae8f03219fe28", size = 36622841, upload-time = "2026-08-21T23:25:18.722Z" }, + { url = "https://files.pythonhosted.org/packages/50/a8/6a77f5f267c555108f0a864b6db714363dab567a8266422a79a385f9232b/scipy-1.18.1-cp313-cp313-win_arm64.whl", hash = "sha256:cd479fc04dd9401e3b4f49e76518768ef99c4f517a98c284eb091fd725719adf", size = 24399315, upload-time = "2026-08-21T23:25:23.458Z" }, + { url = "https://files.pythonhosted.org/packages/06/d5/d8eb4e280ddb56a4ab2c6f02ee49b56b23f6e977cf0802fd6d68dbef14f5/scipy-1.18.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:83de5453a7799afc9048b4616bd085cef126e36412f0ea2f6370c36a2a3a51e7", size = 31090936, upload-time = "2026-08-21T23:25:28.686Z" }, + { url = "https://files.pythonhosted.org/packages/2a/49/59ea385dc3a62ff498ddf3cfff7c2b41b0f9f9d3c4122b3f1dcb6d6327fe/scipy-1.18.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9554bcc6d715ee87a633a3cc8e7703c6628b100dd29cb8a2efc4c0533c7ff729", size = 28725221, upload-time = "2026-08-21T23:25:33.244Z" }, + { url = "https://files.pythonhosted.org/packages/70/e8/6b0c288c50942d78193696c9f15f9a0874f5178aa0ddf40f83d9924b3e8d/scipy-1.18.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:011413b7426b75012840e35649e00fe0a2c3bae89fed433876e3a99251572efc", size = 20466839, upload-time = "2026-08-21T23:25:37.516Z" }, + { url = "https://files.pythonhosted.org/packages/4b/e0/54fd3793c729e3b936782f181b59cbb1205bf250ab605a16cb1ba61cdd5e/scipy-1.18.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:88f0e784020649f88ea48c9f5ddfa403bf9205820667c0914740b392035afb82", size = 23089121, upload-time = "2026-08-21T23:25:42.019Z" }, + { url = "https://files.pythonhosted.org/packages/0b/56/030af62bea3cf878e0028515dff78c123b01633606a879b63f42d2db99cc/scipy-1.18.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d3ab0e8c69a17dd3559eab8cbb88f258e285c94d572c2719033f90f83290c89", size = 34053851, upload-time = "2026-08-21T23:25:47.998Z" }, + { url = "https://files.pythonhosted.org/packages/6b/89/2a844506d49651e9aa1af6ef95b6bd8031cb1d5a4375edec6155037e04cf/scipy-1.18.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ac0333bdf38309aa3dcbe7e3fa7ea29e7a2c37c6ea306a757b700ded8e4596ad", size = 35329183, upload-time = "2026-08-21T23:25:53.522Z" }, + { url = "https://files.pythonhosted.org/packages/eb/56/c7370c3640e92ac9613cbf26cb3f729f9b12ddf1727b55b94b53b24d6f48/scipy-1.18.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:911de823097db8b63f034299d12662db93344e6ffa0b881cbb57748974b70168", size = 35672551, upload-time = "2026-08-21T23:25:59.387Z" }, + { url = "https://files.pythonhosted.org/packages/24/16/ec8536f351421f8bf60a1120930638f83790f4710b8230446aca3d6159d4/scipy-1.18.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:95298364e251be3e60249facbeeca03631d3bb7584f85879516ec55ac717b81f", size = 37469416, upload-time = "2026-08-21T23:26:05.432Z" }, + { url = "https://files.pythonhosted.org/packages/52/94/d73da0d28f16c45bb9b0a5691b91610b0275c5ef0eb5e43c87cf2dc1bf31/scipy-1.18.1-cp314-cp314-win_amd64.whl", hash = "sha256:78a0d7c918e74a232394117160e7e3db503377572a45bcef8826e4ab8a35feba", size = 37362755, upload-time = "2026-08-21T23:26:11.366Z" }, + { url = "https://files.pythonhosted.org/packages/89/25/e996e4dc74e10e227b1e14db5eaf6608bb6dd33884a64851c38f18dd4249/scipy-1.18.1-cp314-cp314-win_arm64.whl", hash = "sha256:cbf38d043c1aa4ab306e1ada6ab6eddacc3322a20b7af1b30bc93254b366fe09", size = 25036090, upload-time = "2026-08-21T23:26:15.887Z" }, + { url = "https://files.pythonhosted.org/packages/fa/c9/c00213f92309d753b48903e6a451b87eb52ff5b7a16e789d1568bbf221c4/scipy-1.18.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0fcb3c93519f27bb4f0c4b0f7802cdcaca7fcf93267b75edda2e9f4e8a55cbd7", size = 31485550, upload-time = "2026-08-21T23:26:20.776Z" }, + { url = "https://files.pythonhosted.org/packages/74/b2/e3067c487982d4eeab2938928529410370c06fea84a4d3f4925e7d96647d/scipy-1.18.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:ddef79fb382df40104a19bb7151b3b23e57c1778fcf857c71ceecd9bd264513f", size = 29174642, upload-time = "2026-08-21T23:26:25.395Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ab/374c9fe2d1ec014e576c781a4b5d8e1ba340e8f6b4638c16f711d2b194f0/scipy-1.18.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:0e82073ecc7acc6436fac4b31674109c7e1d3e596789767eda01258a8c9e8123", size = 20916357, upload-time = "2026-08-21T23:26:30.112Z" }, + { url = "https://files.pythonhosted.org/packages/90/38/223915c88a17317cafbf8ca2a42b11c265a9fb1e804aa665544132b5fe8a/scipy-1.18.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:8bcf3c1ba5d6456e2effd30fcbd3459b044d683fcdac79a2e6830f0bdf7de487", size = 23482611, upload-time = "2026-08-21T23:26:34.846Z" }, + { url = "https://files.pythonhosted.org/packages/c4/d1/db0948da8ca57a80b36520ef0a768b967d99f3af65f4b6f1bf6362ad4dd4/scipy-1.18.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cfbf154f2ba187f2ed6cce2639efff7d105f1140573642c0161615b6d91d6a87", size = 34143202, upload-time = "2026-08-21T23:26:40.4Z" }, + { url = "https://files.pythonhosted.org/packages/87/53/39d046cc7574ed6acacb6bd5723e220107ece80bff12faaf3efc4ddeede4/scipy-1.18.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a1d33a7836f7ddc1993427966a0823468ec41bcbdb1a9f9942d1d7e57f803ba3", size = 35380876, upload-time = "2026-08-21T23:26:46.1Z" }, + { url = "https://files.pythonhosted.org/packages/f9/da/32e0e799d875a85ca57d9bde6c78148afcc0e38276df683d95854eadc8c3/scipy-1.18.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7f4b8bc363b6d65ee2152bec57568e3c52639bb34c46057b09857a307ed5e21d", size = 35770885, upload-time = "2026-08-21T23:26:51.533Z" }, + { url = "https://files.pythonhosted.org/packages/88/2e/f97a666d362fee68b18f41c9c30ed502ca5c98b549749bfcb52a8b74d1eb/scipy-1.18.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:11c423f1049c5755ad4409af52a9ada1cff96fe9b50795d4af3619f292901239", size = 37525424, upload-time = "2026-08-21T23:26:56.751Z" }, + { url = "https://files.pythonhosted.org/packages/ca/d5/a9e765a84654ebba8479a1fd1b059ced1af72b168a3b2a3a46540ea38d20/scipy-1.18.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c24acac1e18912761c4700239bbc1fd32f615af690f1584d49b35859be51324d", size = 37416961, upload-time = "2026-08-21T23:27:01.546Z" }, + { url = "https://files.pythonhosted.org/packages/ee/16/e79e0d1c63ef698879d85439d37e9fb434e3b804e506a6991038d086ebd9/scipy-1.18.1-cp314-cp314t-win_arm64.whl", hash = "sha256:9f2897bf7737392ad0d5213ea7b6add72a4edf5679b3153106aeb88b6507b3b9", size = 25331848, upload-time = "2026-08-21T23:27:05.884Z" }, + { url = "https://files.pythonhosted.org/packages/be/4f/1bd37c883b67163e2ca1f60977a399500e6879c15defecac62831c8d078d/scipy-1.18.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:eb0dfcf4e28a99c12c999744a2ff67c9b06200e20401c7c88186e33552a46331", size = 31091484, upload-time = "2026-08-21T23:27:11.051Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c5/ba929d7feb9b2332f96827c12e0e924b61973b59b4dea383b603372c65ce/scipy-1.18.1-cp315-cp315-macosx_12_0_arm64.whl", hash = "sha256:30f464bee641fa8e282577c7dce027308403213c6ca8270bba73285c91024bc5", size = 28725057, upload-time = "2026-08-21T23:27:15.9Z" }, + { url = "https://files.pythonhosted.org/packages/a4/19/68f1c50f609d955d230e66d25d02bd3e1e167ec540232135354fb9a4b9e3/scipy-1.18.1-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:1bca3b943fc2567ea49cd02c99abde49da4d5178ec46f624bd8255cda8755beb", size = 20466734, upload-time = "2026-08-21T23:27:20.044Z" }, + { url = "https://files.pythonhosted.org/packages/ef/6d/319fa29b73d1802fa80b32a6eaf3f5be456ef81526da2716a9493bcb5501/scipy-1.18.1-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:c9d18a33309122074ea483dd92dd444189166b8b2ec429fe9ed5ac73c7a0aa23", size = 23089664, upload-time = "2026-08-21T23:27:24.345Z" }, + { url = "https://files.pythonhosted.org/packages/b7/db/30992f9b51a63de671daf3888ffd18378b6cb9ec9f2c972264238ffa7fd6/scipy-1.18.1-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:82f201b4c878551d48558337aab270d3c6cca5507b8737c8d8a608d234cccde0", size = 34054035, upload-time = "2026-08-21T23:27:29.409Z" }, + { url = "https://files.pythonhosted.org/packages/91/d4/bf3e735dc0b9d5a8ff45079d2540e17d3aff7a2f0048dd8f552ffd031d2b/scipy-1.18.1-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0ac49ea97594532dd44b7136094d35f5440fa06e6d9c6384a74c01764df388c5", size = 35333883, upload-time = "2026-08-21T23:27:34.293Z" }, + { url = "https://files.pythonhosted.org/packages/19/93/12d78ce9f871fe945fca588d32644e6e63f553c2a35c564d73f3b22a3313/scipy-1.18.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:ceb30a00ce7c92d459819443d29ca486d882b83fb6738bdcbb2a1cce94ac5daa", size = 35673124, upload-time = "2026-08-21T23:27:39.059Z" }, + { url = "https://files.pythonhosted.org/packages/70/cd/886219313a1012a48e6ae0ec4f302c837151beb92e1ff0d709ef8fdfc488/scipy-1.18.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f29633129f9fa7e88a3f0fca835de2d030bfc9643f7799e1a0c46cee24d38fc7", size = 37470753, upload-time = "2026-08-21T23:27:44.435Z" }, + { url = "https://files.pythonhosted.org/packages/17/6c/a776888ce618bee54fbde26172f0f46ac1da70d27b63861797fe78e1904b/scipy-1.18.1-cp315-cp315-win_amd64.whl", hash = "sha256:92c14f5bdbfb6216315ce33e78080474082de8b3830122ba97809bfbe65f75c0", size = 37361483, upload-time = "2026-08-21T23:27:49.334Z" }, + { url = "https://files.pythonhosted.org/packages/ab/09/97b651691322ebee97999b017ffc18a15a0b815103844c97e8da9d469731/scipy-1.18.1-cp315-cp315-win_arm64.whl", hash = "sha256:e402cf31eb68f453dbb2d36fc6d722b33f24a55d68b2ae1d92fa6305ca71c298", size = 25035883, upload-time = "2026-08-21T23:27:53.596Z" }, + { url = "https://files.pythonhosted.org/packages/ed/0f/9ec20467bbabd0d44e2a77d0fd3d124f884b4d67df92af82c91d2d6a486f/scipy-1.18.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:2a0b02f9fc46f8520330c23d45e6560db7e3a0d927232139427637f98943e11d", size = 31474926, upload-time = "2026-08-21T23:27:57.993Z" }, + { url = "https://files.pythonhosted.org/packages/8a/58/dcb79161e56efbedc50079fcd2f5fe427a0ebb53022eb476aa73c015ad8f/scipy-1.18.1-cp315-cp315t-macosx_12_0_arm64.whl", hash = "sha256:1d73131e358976663dd969e1fb4ed1404b815cd977eaaedc3b3a133ba2d81c35", size = 29164940, upload-time = "2026-08-21T23:28:03.062Z" }, + { url = "https://files.pythonhosted.org/packages/71/d3/1eeea80c817fcb8ef7bd4a05a58824977a0e57a375cfc3d7ea7c911c01ad/scipy-1.18.1-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:bff0b729edd992766136b34e39cc76bc2fad905aa58897ee72a9cd000a6d8443", size = 20906742, upload-time = "2026-08-21T23:28:07.642Z" }, + { url = "https://files.pythonhosted.org/packages/54/46/e59350428b6099301a20128108c995e2eb175a43f383af9a346e38824f9b/scipy-1.18.1-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:10ac20c69d880f77f375db44c22e3e6a644f9fefa291d4cd2fb9790a89fc99fd", size = 23472183, upload-time = "2026-08-21T23:28:12.109Z" }, + { url = "https://files.pythonhosted.org/packages/89/31/cc91623fa98f0621766a0f0aaaadb2c66de74a7ea7e3837164f6e4354260/scipy-1.18.1-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33a834464fdabc0f26a45508df31b3cc5d028e04dbf6c5ed398541418e0a12fe", size = 34130796, upload-time = "2026-08-21T23:28:17.906Z" }, + { url = "https://files.pythonhosted.org/packages/fc/3e/8572ef536957ddb8aa81bb4090d9e25f257e3b4e05d97deb54319deb8a3a/scipy-1.18.1-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49023963c193dacee096301452f223ee24d86ec5807f8df93c0f7221d119e305", size = 35374253, upload-time = "2026-08-21T23:28:23.732Z" }, + { url = "https://files.pythonhosted.org/packages/b5/c6/59fdeffb4f1435299f93d9dc8140b43ad2916e6cfc944be6c3041fcec86d/scipy-1.18.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:d84a09d0dad90ba6525d8ac1c2334b33e64bf3ccfe9e841f02feb867a22681e4", size = 35758543, upload-time = "2026-08-21T23:28:29.431Z" }, + { url = "https://files.pythonhosted.org/packages/cf/d9/135be205d9de8783193aff9cc3bf483a03a38e4b29432c954e8cb66ac14e/scipy-1.18.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:179ce34a8d0fe273d8883ba59e17e052247d08973dfcb743ca52bb1cce2d60b0", size = 37521946, upload-time = "2026-08-21T23:28:35.245Z" }, + { url = "https://files.pythonhosted.org/packages/5c/a2/5b7d5270621ab7cfa3f7766067bf95dc360b5efb6394694e8143b4156e2b/scipy-1.18.1-cp315-cp315t-win_amd64.whl", hash = "sha256:5632e3ae3d09197c446310cd5187de63e28448ce22f0f67b2b93d97503c0c230", size = 37408295, upload-time = "2026-08-21T23:28:40.724Z" }, + { url = "https://files.pythonhosted.org/packages/63/ad/741c19fcb66755ff953daf9243af8480e4bf3d7fbe57583c178c7d2b6b51/scipy-1.18.1-cp315-cp315t-win_arm64.whl", hash = "sha256:eda632a7981f69730d6281f451db9c1c370993a2c0d7ddb43e2a809a2862b83a", size = 25319710, upload-time = "2026-08-21T23:28:45.713Z" }, ] [[package]] name = "six" version = "1.17.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "snowballstemmer" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/f8/0a71edf031f03c40db17503cb8ca78a69a171254e568e7db241b0ab57ea1/snowballstemmer-3.1.1.tar.gz", hash = "sha256:e07bbc54a0d798fe6010a12398422e62a8bfbba95c394fd0956ef58cb4d3e260", size = 123314, upload-time = "2026-06-03T00:56:40.194Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/07/2ebca9b11fb9be7340a818d8d6f63feaebb146be2c4afbd6061701d6df6e/snowballstemmer-3.1.1-py3-none-any.whl", hash = "sha256:7e207fa178741da09cdee59d3ecec3827ad5f92b1fc5c9ff3755b639f71f5752", size = 104164, upload-time = "2026-06-03T00:56:38.614Z" }, +] + +[[package]] +name = "soupsieve" +version = "2.9.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/69/99/a6ca3beb3ccacb41fb3321d8a60e5566f9e6467601ef8eba6a17e1b89778/soupsieve-2.9.2.tar.gz", hash = "sha256:4a55d8cf158a9c2e587fa4922f1bbb91d68ac829e2d6f25403a85747c71daf74", size = 122445, upload-time = "2026-08-07T00:57:24.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/dc/ad025c1ee131eba60c69f4dd5779b18fcf1e6b21a343e2162a84d5d133c7/soupsieve-2.9.2-py3-none-any.whl", hash = "sha256:8089a26fd974ca7a1f30276d3d8492ab266ab15af581642dfe8aa162e0c1c823", size = 37370, upload-time = "2026-08-07T00:57:23.524Z" }, +] + +[[package]] +name = "sphinx" +version = "9.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "alabaster" }, + { name = "babel" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "docutils" }, + { name = "imagesize" }, + { name = "jinja2" }, + { name = "packaging" }, + { name = "pygments" }, + { name = "requests" }, + { name = "roman-numerals" }, + { name = "snowballstemmer" }, + { name = "sphinxcontrib-applehelp" }, + { name = "sphinxcontrib-devhelp" }, + { name = "sphinxcontrib-htmlhelp" }, + { name = "sphinxcontrib-jsmath" }, + { name = "sphinxcontrib-qthelp" }, + { name = "sphinxcontrib-serializinghtml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/bd/f08eb0f4eed5c83f1ba2a3bd18f7745a2b1525fad70660a1c00224ec468a/sphinx-9.1.0.tar.gz", hash = "sha256:7741722357dd75f8190766926071fed3bdc211c74dd2d7d4df5404da95930ddb", size = 8718324, upload-time = "2025-12-31T15:09:27.646Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/f7/b1884cb3188ab181fc81fa00c266699dab600f927a964df02ec3d5d1916a/sphinx-9.1.0-py3-none-any.whl", hash = "sha256:c84fdd4e782504495fe4f2c0b3413d6c2bf388589bb352d439b2a3bb99991978", size = 3921742, upload-time = "2025-12-31T15:09:25.561Z" }, +] + +[[package]] +name = "sphinx-rtd-theme" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "sphinx" }, + { name = "sphinxcontrib-jquery" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/84/68/a1bfbf38c0f7bccc9b10bbf76b94606f64acb1552ae394f0b8285bfaea25/sphinx_rtd_theme-3.1.0.tar.gz", hash = "sha256:b44276f2c276e909239a4f6c955aa667aaafeb78597923b1c60babc76db78e4c", size = 7620915, upload-time = "2026-01-12T16:03:31.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/c7/b5c8015d823bfda1a346adb2c634a2101d50bb75d421eb6dcb31acd25ebc/sphinx_rtd_theme-3.1.0-py2.py3-none-any.whl", hash = "sha256:1785824ae8e6632060490f67cf3a72d404a85d2d9fc26bce3619944de5682b89", size = 7655617, upload-time = "2026-01-12T16:03:28.101Z" }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, +] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/de/f3/aa67467e051df70a6330fe7770894b3e4f09436dea6881ae0b4f3d87cad8/sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a", size = 122331, upload-time = "2023-03-14T15:01:01.944Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", size = 121104, upload-time = "2023-03-14T15:01:00.356Z" }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, ] [[package]] name = "texttable" version = "1.7.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1c/dc/0aff23d6036a4d3bf4f1d8c8204c5c79c4437e25e0ae94ffe4bbb55ee3c2/texttable-1.7.0.tar.gz", hash = "sha256:2d2068fb55115807d3ac77a4ca68fa48803e84ebb0ee2340f858107a36522638", size = 12831 } +sdist = { url = "https://files.pythonhosted.org/packages/1c/dc/0aff23d6036a4d3bf4f1d8c8204c5c79c4437e25e0ae94ffe4bbb55ee3c2/texttable-1.7.0.tar.gz", hash = "sha256:2d2068fb55115807d3ac77a4ca68fa48803e84ebb0ee2340f858107a36522638", size = 12831, upload-time = "2023-10-03T09:48:12.272Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/24/99/4772b8e00a136f3e01236de33b0efda31ee7077203ba5967fcc76da94d65/texttable-1.7.0-py2.py3-none-any.whl", hash = "sha256:72227d592c82b3d7f672731ae73e4d1f88cd8e2ef5b075a7a7f01a23a3743917", size = 10768 }, + { url = "https://files.pythonhosted.org/packages/24/99/4772b8e00a136f3e01236de33b0efda31ee7077203ba5967fcc76da94d65/texttable-1.7.0-py2.py3-none-any.whl", hash = "sha256:72227d592c82b3d7f672731ae73e4d1f88cd8e2ef5b075a7a7f01a23a3743917", size = 10768, upload-time = "2023-10-03T09:48:10.434Z" }, ] [[package]] -name = "tomli" -version = "2.2.1" +name = "tinycss2" +version = "1.5.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 }, - { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 }, - { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 }, - { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 }, - { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 }, - { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 }, - { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 }, - { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 }, - { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 }, - { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 }, - { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 }, - { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 }, - { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 }, - { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 }, - { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 }, - { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 }, - { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 }, - { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 }, - { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 }, - { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 }, - { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 }, - { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 }, - { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 }, - { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 }, - { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 }, - { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 }, - { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 }, - { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 }, - { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 }, - { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 }, - { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/ae/2ca4913e5c0f09781d75482874c3a95db9105462a92ddd303c7d285d3df2/tinycss2-1.5.1.tar.gz", hash = "sha256:d339d2b616ba90ccce58da8495a78f46e55d4d25f9fd71dfd526f07e7d53f957", size = 88195, upload-time = "2025-11-23T10:29:10.082Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/45/c7b5c3168458db837e8ceab06dc77824e18202679d0463f0e8f002143a97/tinycss2-1.5.1-py3-none-any.whl", hash = "sha256:3415ba0f5839c062696996998176c4a3751d18b7edaaeeb658c9ce21ec150661", size = 28404, upload-time = "2025-11-23T10:29:08.676Z" }, ] [[package]] -name = "typing-extensions" -version = "4.12.2" +name = "tornado" +version = "6.5.8" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } +sdist = { url = "https://files.pythonhosted.org/packages/10/d3/343e5bb989d6515b1646cf3d40135d73f3d5e45339bded401b56cdac24dd/tornado-6.5.8.tar.gz", hash = "sha256:9452e1b208a8bd771e2cb1f2ff564985b9b214bdebbe622793e1799e0a6bd23f", size = 520493, upload-time = "2026-08-07T02:12:42.971Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, + { url = "https://files.pythonhosted.org/packages/f2/d5/007086fd8df5489338e204f65adce33fd4f21a4999dbb2b9cff2f897b5f4/tornado-6.5.8-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:cc6aa787d7cfab7c3d35189dc7a56fbd2399a569624c730c6b55b3d6531d0403", size = 449487, upload-time = "2026-08-07T02:12:28.682Z" }, + { url = "https://files.pythonhosted.org/packages/70/c8/5a24a99495903f594f6a199dd7beead1cbc0a13e2cb9102727bcaaf2a997/tornado-6.5.8-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9715b5eb79735b2bcd454ce216a9275b7c0470e64ea1bf5742f78b2f72b26eeb", size = 447649, upload-time = "2026-08-07T02:12:30.306Z" }, + { url = "https://files.pythonhosted.org/packages/6e/de/f2e733f386b85962d1b1dc82cd63d169b5b4580062b35397eac9244a41fe/tornado-6.5.8-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:547d63f450d570c14fe0e8db2cfb14c9bbd1c2503b4a6612586267955aa47b58", size = 450707, upload-time = "2026-08-07T02:12:31.95Z" }, + { url = "https://files.pythonhosted.org/packages/0b/94/20efeee9a01c141e9ac47c397f81679dfda24b32768fc4fff24e76d36c2c/tornado-6.5.8-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e2360a0ffbe145eca8af0b19cb7203d79b1a98dd4cccdd6b368f6f49c2e3808", size = 451677, upload-time = "2026-08-07T02:12:33.512Z" }, + { url = "https://files.pythonhosted.org/packages/42/ec/a96ccb8ccf0de2b7bc2c5fa1608a4803735018242e90c4882365a9fd418f/tornado-6.5.8-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:5d242290bdf7ab3151bc1065fdd75c0dcc21cbc7b49f22a4c56329c2d6566d22", size = 451510, upload-time = "2026-08-07T02:12:35.346Z" }, + { url = "https://files.pythonhosted.org/packages/29/b5/93185859245ad3f00e62175f29607346788b696369347f0146e0421286bb/tornado-6.5.8-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7b94ff0e128fe0542f3bd331fb44d06260fc4ac16881545159f34ef08aad4195", size = 450917, upload-time = "2026-08-07T02:12:36.963Z" }, + { url = "https://files.pythonhosted.org/packages/97/cf/fe33cf062834487d34d1559746a4a12521033c22645b6d74d4bca702e018/tornado-6.5.8-cp39-abi3-win32.whl", hash = "sha256:67832909c4779c64942380cb5f044a5c6163d00831472d80e25e115de9917836", size = 451952, upload-time = "2026-08-07T02:12:38.512Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e1/468ad54333e92ccb62627e62cb88e5fc14a2171daa67ed47b1b8542d5b86/tornado-6.5.8-cp39-abi3-win_amd64.whl", hash = "sha256:11881db6b7c168494be2c2d12e65931451bdf7ee718535418ae1d8855dd5a0ee", size = 452391, upload-time = "2026-08-07T02:12:39.971Z" }, + { url = "https://files.pythonhosted.org/packages/ad/3e/cd5e4f06e34cde33b8ef66cf36aa2b5ad46354cc1af7d2136bbe365fee1d/tornado-6.5.8-cp39-abi3-win_arm64.whl", hash = "sha256:68a7468c7e289f8514d7d664101753903217eff1bb6822c6b5994a0b5f5bcb26", size = 451411, upload-time = "2026-08-07T02:12:41.469Z" }, ] [[package]] -name = "virtualenv" -version = "20.28.0" +name = "tqdm" +version = "4.70.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "distlib" }, - { name = "filelock" }, - { name = "platformdirs" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/21/3b/6c24bec5be5e743ffd99576daa5cc077722fc7d5bbc00bd133fa0c698dc6/tqdm-4.70.0.tar.gz", hash = "sha256:55b0b0dbd97462d06ebee91e4dac24ed4d4702be82b24f07e6c1d27e08cea220", size = 795438, upload-time = "2026-07-27T11:33:15.271Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl", hash = "sha256:7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953", size = 80184, upload-time = "2026-07-27T11:33:13.167Z" }, +] + +[[package]] +name = "traitlets" +version = "5.16.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/2e/a7fbfe268c8a3b32546930c0297c101d65a4a14c304ad5790a9f478f0e4e/traitlets-5.16.1.tar.gz", hash = "sha256:ed900c2b631aa3a112811139fa97b8d2c3bad5e989656bba4b7e52c7852c18c1", size = 166137, upload-time = "2026-08-03T08:32:36.848Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/66/0d785f0bc5e4315a96c989bb476d0fc07ea4f85132550c7b156ca2035d52/traitlets-5.16.1-py3-none-any.whl", hash = "sha256:f775618166caa0396c8e337099240f2bd3e5e917d203b2e6fbe21a58d3cb1f6b", size = 86211, upload-time = "2026-08-03T08:32:34.48Z" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/bf/75/53316a5a8050069228a2f6d11f32046cfa94fbb6cc3f08703f59b873de2e/virtualenv-20.28.0.tar.gz", hash = "sha256:2c9c3262bb8e7b87ea801d715fae4495e6032450c71d2309be9550e7364049aa", size = 7650368 } + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.8.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/57/ed58088fafdf4c55a0ad6bde846502567645424d7ebf325230b9237f4085/wcwidth-0.8.3.tar.gz", hash = "sha256:d128512515fbf4612e0ff21fd6380399210318b7b54a9af59dff8454cf9730eb", size = 1458450, upload-time = "2026-08-28T18:10:06.875Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/10/f9/0919cf6f1432a8c4baa62511f8f8da8225432d22e83e3476f5be1a1edc6e/virtualenv-20.28.0-py3-none-any.whl", hash = "sha256:23eae1b4516ecd610481eda647f3a7c09aea295055337331bb4e6892ecce47b0", size = 4276702 }, + { url = "https://files.pythonhosted.org/packages/c4/0e/57f6bb3024a597b2e8ec4aee710ffe62ddc95af2e2bb1ee7a7abdc22c68c/wcwidth-0.8.3-py3-none-any.whl", hash = "sha256:d5b73dba6158a595ec9370350e7f2637bcac8d6c5e4fde34f30fcffb6103a5e4", size = 331669, upload-time = "2026-08-28T18:10:04.909Z" }, ] [[package]] -name = "zipp" -version = "3.21.0" +name = "webencodings" +version = "0.6.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 } +sdist = { url = "https://files.pythonhosted.org/packages/d5/a0/8fd707bcb776a7be556bad06a2ea5fb9bd519df78ef8e26f70ccf0f38bff/webencodings-0.6.1.tar.gz", hash = "sha256:565f9ad031c702dae404e27a099e3e09186a3ab1b9520f06d215502b651fd910", size = 15001, upload-time = "2026-08-15T14:22:57.549Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 }, + { url = "https://files.pythonhosted.org/packages/77/c6/040cbc72480d789a5f40d63fb484d3106554c4dfa2d2b70ad5022057750f/webencodings-0.6.1-py3-none-any.whl", hash = "sha256:7fab6269c8bf237c657876b52058ccb182e861518d1c695c1a9aaa8c1c105d5b", size = 8745, upload-time = "2026-08-15T14:22:56.31Z" }, ] From 1d04e445003cb48a6846dc16d2bd82470ad1d94d Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Wed, 2 Sep 2026 17:34:27 -0400 Subject: [PATCH 66/85] Fix degree exponent validation message --- abcd_graph/abcd.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index 1855b0a..fb07e0e 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -294,7 +294,7 @@ def _validate_params(self): not isinstance(self.degree_exponent, (float, np.floating)) or self.degree_exponent < 0 ): - raise ValueError("rho must be positive") + raise ValueError("degree exponent must be positive") elif self.degree_exponent < 2 or self.degree_exponent > 3: warn( f"Typical degree exponents are between 2 and 3, got {self.degree_exponent}", From f1942dca7ddcc20718dbbc374fc52d2da3724b58 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Wed, 2 Sep 2026 17:45:16 -0400 Subject: [PATCH 67/85] Fix range in powerlaw fit --- abcd_graph/abcd_sample.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/abcd_graph/abcd_sample.py b/abcd_graph/abcd_sample.py index 08a05eb..7a9a682 100644 --- a/abcd_graph/abcd_sample.py +++ b/abcd_graph/abcd_sample.py @@ -73,7 +73,7 @@ def objective(exponent): weights = domain ** (-exponent) return len(samples) * np.log(np.sum(weights)) + exponent * observed_constant - sol = minimize_scalar(objective, bounds=[1.0, 5.0], method="Bounded") + sol = minimize_scalar(objective, bounds=[0.0, 5.0], method="Bounded") return sol.x From 0322890a3dd3f32c63505c235a28466a4b6e59e0 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Wed, 2 Sep 2026 18:17:37 -0400 Subject: [PATCH 68/85] Wrtie progress bars through logger --- abcd_graph/abcd.py | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index fb07e0e..8dcfddc 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -19,6 +19,21 @@ MAX_N = np.iinfo(np.uint32).max +class TqdmToLogger: + def __init__(self, logger, level=logging.INFO): + self.logger = logger + self.level = level + self.buf = "" + + def write(self, buf): + self.buf = buf.strip("\r\n") + if self.buf: + self.logger.log(self.level, self.buf) + + def flush(self): + pass + + def format_duration(seconds: float): if seconds >= 1.0: return f"{seconds:.3f}s" @@ -82,8 +97,8 @@ def generate_graph( logger.info("Building Community Graphs") start = perf_counter() # TODO Parallel this loop - # TODO logging for this progess bar - for i in trange(n_coms, disable=logger.getEffectiveLevel() > 20): + tqdm_out = TqdmToLogger(logger, level=logging.INFO) + for i in trange(n_coms, file=tqdm_out): generate_community_graph_task( i, graph, From 4b348daa8b01f9b544da5a81f8bf2e1e0289dc00 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Wed, 2 Sep 2026 19:10:41 -0400 Subject: [PATCH 69/85] Feature/better fit checks (#10) * Fix doc typos in ABCD * Add controls for fitting groups of parasm * Add tests --- abcd_graph/abcd.py | 23 ++++++++++++++++++++--- tests/test_abcd.py | 33 +++++++++++++++++++++++++++++++-- 2 files changed, 51 insertions(+), 5 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index 8dcfddc..017ddda 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -190,13 +190,13 @@ class ABCD: of vertices minus the number of outliers. rho_tol: float, default=0.05 - Tolerance for rho optmiziation. Only used if rho is not 0. + Tolerance for rho optimiziation. Only used if rho is not 0. alpha_min: float, default=-60.0 Minimum bound in rho optimization. Only used if rho is not 0. alpha_max: float, default=60.0 - Maximum bound in rho optmization. Only used if rho is not 0. + Maximum bound in rho optimization. Only used if rho is not 0. alpha_iters: int, default=10 Number of alphas to try in rho optimization. Only used if rho is not 0. @@ -552,7 +552,7 @@ def fit( do_not_set: Container | None = {"degree_sequence", "community_size_sequence"}, ): """Set parameters of this ABCD class to the empirical values from another graph. - Measureable parameters are: + Measurable parameters are: * n * xi @@ -578,6 +578,23 @@ def fit( sequence or community size sequence take priority and force samples to have exactly the same sequence. """ + # Some combination of parameter must or must not be set together + if do_not_set is not None: + if "degree_sequence" not in do_not_set and "n" in do_not_set: + raise ValueError( + """Can not fit degree sequence but not n. Either add 'degree_sequence' or remove 'n' + from do_not_set.""" + ) + + if "community_size_sequence" not in do_not_set and ( + "n" in do_not_set or "outliers" in do_not_set or "eta" in do_not_set + ): + warn( + """Fitting community_size_sequence but not 'n', 'outliers', or 'eta' is not well + tested, consider fitting all.""", + stacklevel=2, + ) + parameters = [ "n", "xi", diff --git a/tests/test_abcd.py b/tests/test_abcd.py index 18bb471..2b5d744 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -64,8 +64,6 @@ def test_seed(n): npt.assert_array_equal(sample2.to_dense(), sample2.to_dense()) -@pytest.mark.filterwarnings("ignore::UserWarning:powerlaw*") -@pytest.mark.filterwarnings("ignore::RuntimeWarning:powerlaw*") def test_fit(): edges = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 0], [1, 3]], dtype=np.uint32) coms = sp.csr_array([[1, 1, 1, 0, 0], [0, 0, 1, 1, 0]]) @@ -85,3 +83,34 @@ def test_fit(): assert abcd.community_size_exponent != 1.5 assert abcd.degree_sequence is None assert abcd.community_size_sequence is None + + +def test_fit_with_sequences(): + edges = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 0], [1, 3]], dtype=np.uint32) + coms = sp.csr_array([[1, 1, 1, 0, 0], [0, 0, 1, 1, 0]]) + sample = ABCDSample(edges, coms) + abcd = ABCD(100) + + abcd.fit(sample, do_not_set=None) + + assert abcd.n == 5 + assert abcd.xi == 0.5 + assert abcd.eta == 1.25 + assert abcd.min_degree == 2 + assert abcd.max_degree == 3 + assert abcd.degree_exponent != 2.5 + assert abcd.min_community_size == 2 + assert abcd.max_community_size == 3 + assert abcd.community_size_exponent != 1.5 + npt.assert_array_equal(abcd.degree_sequence, np.array([2, 3, 2, 3, 2])) + npt.assert_array_equal(abcd.community_size_sequence, np.array([3, 2])) + + +def test_fit_degree_sequence_but_not_n_raises(): + edges = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 0], [1, 3]], dtype=np.uint32) + coms = sp.csr_array([[1, 1, 1, 0, 0], [0, 0, 1, 1, 0]]) + sample = ABCDSample(edges, coms) + abcd = ABCD(100) + + with pytest.raises(ValueError): + abcd.fit(sample, do_not_set=["n"]) From 3ae52a0a16f74a705a003c757c5e2695af025a8a Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Wed, 2 Sep 2026 19:11:19 -0400 Subject: [PATCH 70/85] Add ABCDe and clean up references in README --- README.md | 71 ++++++++++++++++++++++++++++++++----------------------- 1 file changed, 42 insertions(+), 29 deletions(-) diff --git a/README.md b/README.md index d31d73c..4301a2d 100644 --- a/README.md +++ b/README.md @@ -188,41 +188,55 @@ If you use the ABCD model in an academic work, please consider citing the follow ### ABCD (communities form a partition) ```bibtex @article{abcd, - title={Artificial Benchmark for Community Detection ({ABCD})—Fast random graph model with community structure}, - author={Bogumił Kamiński and Paweł Prałat and François Théberge}, - journal={Network Science}, + title = {Artificial Benchmark for Community Detection ({ABCD})—Fast random graph model with community structure}, + author = {Bogumił Kamiński and Paweł Prałat and François Théberge}, + journal = {Network Science}, volume = {9}, number = {2}, - pages={153--178}, - year={2021}, + pages = {153--178}, + year = {2021}, doi = {10.1017/nws.2020.45}, } ``` +### ABCDe (algorithm similarities) +```bibtex +@article{abcde, + title = {Properties and Performance of the ABCDe Random Graph Model with Community Structure}, + author = {Bogumił Kamiński and Tomasz Olczak and Bartosz Pankratz and Paweł Prałat and François Théberge}, + journal = {Big Data Research}, + year = {2022}, + volume = {30}, + pages = {100348}, + doi = {https://doi.org/10.1016/j.bdr.2022.100348}, +} +``` + + + ### ABCD+o (allows outliers) ```bibtex @article{abcdo, - title={Artificial benchmark for community detection with outliers (ABCD+o)}, - volume={8}, - doi={10.1007/s41109-023-00552-9}, - journal={Applied Network Science}, - author={Bogumił Kamiński and Paweł Prałat and François Théberge}, - year={2023}, - articleno={25}, + title = {Artificial benchmark for community detection with outliers (ABCD+o)}, + volume = {8}, + doi = {10.1007/s41109-023-00552-9}, + journal = {Applied Network Science}, + author = {Bogumił Kamiński and Paweł Prałat and François Théberge}, + year = {2023}, + pages = {25}, } ``` ### ABCD+o2 (allows overlaps and outliers) ```bibtex @article{abcdoo, - title={The artificial benchmark for community detection with outliers and overlapping communities (abcd+ o2)}, - author={Jordan Barrett and Ryan DeWolfe and Bogumił Kamiński and Paweł Prałat and Aaron Smith and François Théberge}, - journal={Journal of Complex Networks}, - volume={14}, - number={4}, - pages={cnag023}, - year={2026}, - publisher={Oxford University Press} + title = {The artificial benchmark for community detection with outliers and overlapping communities (abcd+ o2)}, + author = {Jordan Barrett and Ryan DeWolfe and Bogumił Kamiński and Paweł Prałat and Aaron Smith and François Théberge}, + journal = {Journal of Complex Networks}, + volume = {14}, + number = {4}, + pages = {cnag023}, + year = {2026}, } ``` @@ -232,15 +246,14 @@ There are other extensions of ABCD that are not yet covered by this package but Hypergraphs ([available implementation in julia](https://github.com/bkamins/ABCDHypergraphGenerator.jl)) ```bibtex @article{habcd, - title={Hypergraph Artificial Benchmark for Community Detection (h--{ABCD})}, - author={Bogumił Kamiński and Paweł Prałat and François Théberge}, - journal={Journal of Complex Networks}, - volume={11}, - number={4}, - pages={cnad028}, - year={2023}, - publisher={Oxford University Press}, - doi={10.1093/comnet/cnad028} + title = {Hypergraph Artificial Benchmark for Community Detection (h--{ABCD})}, + author = {Bogumił Kamiński and Paweł Prałat and François Théberge}, + journal = {Journal of Complex Networks}, + volume = {11}, + number = {4}, + pages = {cnad028}, + year = {2023}, + doi = {10.1093/comnet/cnad028} } ``` From 707aa0bab62942b1b508705f5207aef9604c8cd6 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Wed, 2 Sep 2026 19:17:31 -0400 Subject: [PATCH 71/85] Update changelog --- CHANGELOG.md | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b763409..e32028b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,7 +1,17 @@ -## Unreleased +## abcd-graph 0.5.0-beta (unreleased) ### Features -- Added top level ABCD object, an alternative interface that effectively adds a .sample() method to the ABCDParams. ([#67](https://github.com/AleksanderWWW/abcd-graph/pull/67)) +- Complete rewrite and file restructure to simplify and increase speed. +- Main class ABCD stores parameters, sample and ABCD graph with the .sample() method +- ABCD.sample() returns and ABCDSample object that store the graph and community data +- ABCD has a .fit(ABCDSample) method to fit the ABCD parameters to the empirical parameters observed in the sample. +- readthedocs style documentation + +### Enhancements +- More comprehensive testing +- Run benchmarks in CI +- Migrate all workflows to uv + ## abcd-graph 0.4.1 From 133d7d24f68af02b492af13f7e0a9ab2b17b5464 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Wed, 2 Sep 2026 19:22:05 -0400 Subject: [PATCH 72/85] Disable numba for coverage report --- .github/workflows/coverage.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 0064200..3a143f8 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -18,7 +18,7 @@ jobs: run: uv sync --frozen - name: Run tests - run: uv run pytest --junitxml=pytest.xml + run: NUMBA_DISABLE_JIT=1 uv run pytest --junitxml=pytest.xml --cov-report=term-missing:skip-covered --cov=abcd_graph tests | tee pytest-coverage.txt From b05a6fe00561b8c458648e5dfa03abc8a491ce34 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 4 Sep 2026 09:08:11 -0400 Subject: [PATCH 73/85] Rewire hashes edges as tuple (#11) Hash edges as tuples instead of uint64 in rewire. Set up for general changes to make node dtype dynamic instead of uint32. --- abcd_graph/abcd.py | 19 +++++- abcd_graph/models.py | 134 ++++++++++++++++++++----------------------- tests/test_abcd.py | 4 +- tests/test_models.py | 12 ++-- 4 files changed, 86 insertions(+), 83 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index 017ddda..6710f0e 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -13,7 +13,13 @@ from abcd_graph.abcd_sample import ABCDSample, icdf from abcd_graph.degrees import assign_degrees, split_degrees from abcd_graph.membership import build_membership_matrix -from abcd_graph.models import Model, chunglu_model, configuration_model, rewire +from abcd_graph.models import ( + Model, + chunglu_model, + configuration_model, + get_edge_type, + rewire, +) from abcd_graph.samplers import sample_community_sizes, sample_degrees MAX_N = np.iinfo(np.uint32).max @@ -67,7 +73,12 @@ def generate_community_graph_task( com_data, rng, ) - rewire(community_graph, rng, max_swap_attempts_per_bad_edge) + rewire( + community_graph, + get_edge_type(community_graph), + rng, + max_swap_attempts_per_bad_edge, + ) graph[community_edges_indptr[i] : community_edges_indptr[i + 1]] = community_graph @@ -114,7 +125,9 @@ def generate_graph( logger.info(f"Finished in {format_duration(end - start)}.") logger.info("Global Rewiring") start = perf_counter() - n_good_edges = rewire(graph, rng, max_swap_attempts_per_bad_edge) + n_good_edges = rewire( + graph, get_edge_type(graph), rng, max_swap_attempts_per_bad_edge + ) end = perf_counter() logger.info(f"Finished in {format_duration(end - start)}.") if graph.shape[0] - n_good_edges: diff --git a/abcd_graph/models.py b/abcd_graph/models.py index 1008651..35b8d2f 100644 --- a/abcd_graph/models.py +++ b/abcd_graph/models.py @@ -1,9 +1,9 @@ from typing import Any, Protocol import numpy as np -from numba import njit +from numba import from_dtype, njit from numba.typed import List, Set -from numba.types import uint64 +from numba.types import UniTuple from numpy.random import Generator from numpy.typing import NDArray @@ -62,60 +62,47 @@ def configuration_model( @njit(inline="always") -def make_edge_id( - edge: NDArray[np.uint32], -) -> uint64: +def make_edge_tuple(edge: NDArray[np.integer[Any]]) -> UniTuple(np.integer[Any], 2): high, low = edge[0], edge[1] if high < low: high, low = low, high - return (uint64(high) << 32) | uint64(low) - - -@njit(inline="always") -def edge_from_id( - edge_id: uint64, -) -> NDArray[np.uint32]: - edge = np.empty(2, dtype=np.uint32) - edge[0] = np.uint32(edge_id >> 32) - edge[1] = np.uint32(edge_id & 0xFFFFFFFF) - return edge + return (low, high) @njit(inline="always") def swap( - edge1: NDArray[np.uint32], - edge2: NDArray[np.uint32], + edge1: UniTuple(np.integer[Any], 2), + edge2: UniTuple(np.integer[Any], 2), rng: Generator, -): - edge1 = edge1.copy() - edge2 = edge2.copy() +) -> (UniTuple(np.integer[Any], 2), UniTuple(np.integer[Any], 2)): if rng.uniform() > 0.5: - edge1[0], edge2[0] = edge2[0], edge1[0] - else: - edge1[0], edge2[1] = edge2[1], edge1[0] - return edge1, edge2 + return (edge1[0], edge2[0]), (edge2[0], edge1[0]) + return (edge1[0], edge2[1]), (edge2[1], edge1[0]) @njit(inline="always") def is_bad_swap( - edge1: NDArray[np.uint32], - edge2: NDArray[np.uint32], - good_edges: Set[uint64], + edge1: NDArray[np.integer[Any]], + edge2: NDArray[np.integer[Any]], + good_edges: Set[UniTuple(np.integer[Any], 2)], ) -> bool: if edge1[0] == edge1[1] or edge2[0] == edge2[1]: return True - edge1_id = make_edge_id(edge1) - edge2_id = make_edge_id(edge2) - if edge1_id == edge2_id: + if edge1 == edge2: return True - if edge1_id in good_edges or edge2_id in good_edges: + if edge1 in good_edges or edge2 in good_edges: return True return False +def get_edge_type(edges: NDArray[np.integer[Any]]) -> UniTuple(np.integer[Any], 2): + return UniTuple(from_dtype(edges.dtype), 2) + + @njit(nogil=True) def rewire( - edges: NDArray[np.uint32], + edges: NDArray[np.integer[Any]], + edge_type: UniTuple(np.integer[Any], 2), rng: Generator, max_swap_attempts_per_bad_edge: int = 5, ) -> int: @@ -124,9 +111,14 @@ def rewire( Parameters ---------- - edges: NDArray[np.uint32] + edges: NDArray[np.integer[Any]] Edge list with shape (n_edges, 2) to be rewired. Will be altered in place. + node_dtype: np.integer[Any] + dtype of nodes stored in the edges list. Required for numba pre-compilation + and is assumed to be correct. Consistency checks should be made before + calling this function. + rng: Generator numpy.random.Generator object to use for randomness. @@ -136,69 +128,67 @@ def rewire( """ # Move good edges to the front, add their hashes to a set, and # make a List-backed-queue of bad edges - good_edges = Set.empty(uint64) - bad_queue = List.empty_list(uint64) + good_edges = Set.empty(edge_type) + bad_queue = List.empty_list(edge_type) n_good_edges = 0 for i in range(edges.shape[0]): - edge = edges[i] - edge_id = make_edge_id(edge) - if edge[0] != edge[1] and edge_id not in good_edges: - good_edges.add(edge_id) + edge = make_edge_tuple(edges[i]) + if edge[0] != edge[1] and edge not in good_edges: + good_edges.add(edge) edges[n_good_edges] = edge n_good_edges += 1 else: - bad_queue.append(edge_id) + bad_queue.append(edge) # Try to resolve the bad edge at the head of bad_queue by trying a swap # with a random edge (good or bad, but not the one we are trying to resolve) # If the swap would cause a collision, move bad edge to the back of the # queue. Repeat until the Queue is empty or we give up. - next_index = len(bad_queue) + + # Store bad edges in the indices 0:queue_len and keep at the front + # of the list + next_index = len(bad_queue) - 1 + queue_len = len(bad_queue) + for _ in range(len(bad_queue) * max_swap_attempts_per_bad_edge): - if len(bad_queue) == 0: + if queue_len == 0: break - else: - next_index = (next_index + 1) % len(bad_queue) - bad_edge_id = bad_queue[next_index] - bad_edge = edge_from_id(bad_edge_id) + + next_index = (next_index + 1) % queue_len + bad_edge = bad_queue[next_index] choose_from_good_edges = rng.uniform() < n_good_edges / ( - n_good_edges + len(bad_queue) - 1 - ) + n_good_edges + queue_len - 1 + ) # Always True if queue_len == 1 if choose_from_good_edges: swap_index = rng.integers(0, n_good_edges) - swap_candidate_edge = edges[swap_index] + swap_candidate_edge = make_edge_tuple(edges[swap_index]) new_edge1, new_edge2 = swap(bad_edge, swap_candidate_edge, rng) if not is_bad_swap(new_edge1, new_edge2, good_edges): edges[swap_index] = new_edge1 edges[n_good_edges] = new_edge2 n_good_edges += 1 - good_edges.add(make_edge_id(new_edge1)) - good_edges.add(make_edge_id(new_edge2)) - good_edges.discard(make_edge_id(swap_candidate_edge)) - bad_queue.pop(next_index) + good_edges.add(new_edge1) + good_edges.add(new_edge2) + good_edges.discard(swap_candidate_edge) + bad_queue[next_index] = bad_queue[queue_len - 1] + queue_len -= 1 else: - swap_offset = rng.integers(1, len(bad_queue)) # don't choose current head - swap_index = (next_index + swap_offset) % len(bad_queue) - swap_candidate_edge_id = bad_queue[swap_index] - swap_candidate_edge = edge_from_id(swap_candidate_edge_id) + swap_offset = rng.integers(1, queue_len) # don't choose current head + swap_index = (next_index + swap_offset) % queue_len + swap_candidate_edge = bad_queue[swap_index] new_edge1, new_edge2 = swap(bad_edge, swap_candidate_edge, rng) if not is_bad_swap(new_edge1, new_edge2, good_edges): edges[n_good_edges] = new_edge1 - n_good_edges += 1 - edges[n_good_edges] = new_edge2 - good_edges.add(make_edge_id(new_edge1)) - good_edges.add(make_edge_id(new_edge2)) - n_good_edges += 1 - if swap_index < next_index: # Pop larger index first - bad_queue.pop(next_index) - bad_queue.pop(swap_index) - else: - bad_queue.pop(swap_index) - bad_queue.pop(next_index) + edges[n_good_edges + 1] = new_edge2 + n_good_edges += 2 + good_edges.add(new_edge1) + good_edges.add(new_edge2) + bad_queue[next_index] = bad_queue[queue_len - 1] + bad_queue[swap_index] = bad_queue[queue_len - 2] + queue_len -= 2 # Write bad edges that failed to swap back into the edge list - for i in range(len(bad_queue)): - bad_edge = edge_from_id(bad_queue[i]) - edges[n_good_edges + i] = bad_edge + for i in range(queue_len): + edges[n_good_edges + i] = bad_queue[i] return n_good_edges diff --git a/tests/test_abcd.py b/tests/test_abcd.py index 2b5d744..5c8ed43 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -8,10 +8,10 @@ from abcd_graph.abcd_sample import ABCDSample -@pytest.mark.parametrize("n", [500, 1000]) +@pytest.mark.parametrize("n", [500, 1000, 2000]) @pytest.mark.parametrize("xi", [0.2, 0.5, 0.7]) def test_abcd(n, xi): - rng = np.random.default_rng(seed=1) + rng = np.random.default_rng(seed=2) abcd = ABCD(n, xi=xi, rng=rng) sample = abcd.sample() diff --git a/tests/test_models.py b/tests/test_models.py index 871989b..83bf69c 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -2,7 +2,7 @@ import pytest from utils import assert_no_bad_edges -from abcd_graph.models import chunglu_model, configuration_model, rewire +from abcd_graph.models import chunglu_model, configuration_model, get_edge_type, rewire def test_chunglu_model(): @@ -45,7 +45,7 @@ def test_rewire_loops(): dtype=np.uint32, ) - n_good_edges = rewire(edges, rng) + n_good_edges = rewire(edges, get_edge_type(edges), rng) assert edges.shape == (5, 2) assert edges.dtype == np.uint32 @@ -65,7 +65,7 @@ def test_rewire_multiedges(): dtype=np.uint32, ) - n_good_edges = rewire(edges, rng) + n_good_edges = rewire(edges, get_edge_type(edges), rng) assert edges.shape == (4, 2) assert edges.dtype == np.uint32 @@ -77,7 +77,7 @@ def test_rewire_swap_two_bad_edges(): rng = np.random.default_rng(seed=1) edges = np.array([[0, 0], [1, 2], [1, 2]], dtype=np.uint32) - n_good_edges = rewire(edges, rng) + n_good_edges = rewire(edges, get_edge_type(edges), rng) assert edges.shape == (3, 2) assert edges.dtype == np.uint32 @@ -92,7 +92,7 @@ def test_rewire_many(): dtype=np.uint32, ) - n_good_edges = rewire(edges, rng) + n_good_edges = rewire(edges, get_edge_type(edges), rng) assert edges.shape == (8, 2) assert edges.dtype == np.uint32 @@ -104,7 +104,7 @@ def test_rewire_failure(): rng = np.random.default_rng(seed=1) edges = np.array([[0, 0], [0, 1]], dtype=np.uint32) - n_good_edges = rewire(edges, rng) + n_good_edges = rewire(edges, get_edge_type(edges), rng) assert edges.shape == (2, 2) assert edges.dtype == np.uint32 From 1da9288c6e41c4b3e38fafc011cae8763f9d135b Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 4 Sep 2026 14:21:12 -0400 Subject: [PATCH 74/85] Refactor, models generate inplace (#12) * Configuration model inplace option * Add chung-lu model and update protocol * Make abcd generate inplace --- abcd_graph/abcd.py | 8 ++---- abcd_graph/models.py | 64 +++++++++++++++++++++++++++++++++++++------- pyproject.toml | 1 + tests/test_models.py | 29 ++++++++++++++++++++ 4 files changed, 86 insertions(+), 16 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index 6710f0e..4d1fdf1 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -68,18 +68,14 @@ def generate_community_graph_task( com_data = community_degrees_data[ community_degrees_indptr[i] : community_degrees_indptr[i + 1] ] - community_graph = model( - com_indices, - com_data, - rng, - ) + community_graph = graph[community_edges_indptr[i] : community_edges_indptr[i + 1]] + model(com_indices, com_data, rng, out=community_graph) rewire( community_graph, get_edge_type(community_graph), rng, max_swap_attempts_per_bad_edge, ) - graph[community_edges_indptr[i] : community_edges_indptr[i + 1]] = community_graph def generate_graph( diff --git a/abcd_graph/models.py b/abcd_graph/models.py index 35b8d2f..43d171d 100644 --- a/abcd_graph/models.py +++ b/abcd_graph/models.py @@ -8,15 +8,21 @@ from numpy.typing import NDArray -# Define the function interface contract structurally class Model(Protocol): def __call__( - self, node_ids: NDArray[np.uint32], degrees: NDArray[np.uint32], rng: Generator + self, + node_ids: NDArray[np.uint32], + degrees: NDArray[np.uint32], + rng: Generator, + out: NDArray[np.uint32] | None = None, ) -> NDArray[np.uint32]: ... def chunglu_model( - node_ids: NDArray[np.uint32], degrees: NDArray[np.integer[Any]], rng: Generator + node_ids: NDArray[np.uint32], + degrees: NDArray[np.integer[Any]], + rng: Generator, + out: NDArray[np.uint32] | None = None, ) -> NDArray[np.uint32]: """Sample a random graph with, on expectation, the given degree sequence. @@ -31,15 +37,24 @@ def chunglu_model( rng: Generator numpy.random.Generator object used for randomness. + + out: NDArray[np.uint32] | None (default=None) + If passed, write output into this array inplace. Can be passed as a view of a larger array. """ - node_probs = degrees / degrees.sum() - edges = rng.choice(node_ids, size=np.sum(degrees), p=node_probs).reshape(-1, 2) + sum_degrees = np.sum(degrees) + node_probs = degrees / sum_degrees + edges = rng.choice(node_ids, size=(sum_degrees // 2, 2), p=node_probs) + if out is not None: + out[:] = edges return edges @njit(nogil=True) def configuration_model( - node_ids: NDArray[np.uint32], degrees: NDArray[np.uint32], rng: Generator + node_ids: NDArray[np.uint32], + degrees: NDArray[np.uint32], + rng: Generator, + out: NDArray[np.uint32] | None = None, ) -> NDArray[np.uint32]: """Sample a random graph with the given degree sequence. @@ -54,11 +69,40 @@ def configuration_model( rng: Generator numpy.random.Generator object used for randomness. + + out: NDArray[np.uint32] | None (default=None) + If passed, write output into this array inplace. Can be passed as a view of a larger array. """ - stubs = np.repeat(node_ids, degrees) - rng.shuffle(stubs) - edges = stubs.reshape(-1, 2) - return edges + n_stubs = np.sum(degrees) + if out is None: + out = np.empty((n_stubs // 2, 2), dtype=np.uint32) + else: + assert out.shape == (n_stubs // 2, 2) + + next_index = 0 + for node, degree in zip(node_ids, degrees): + for i in range(next_index, next_index + degree): + r_i = i if i < out.shape[0] else i - out.shape[0] + c_i = 0 if i < out.shape[0] else 1 + out[r_i, c_i] = node + next_index += degree + + # Inplace Fisher-Yates shuffle all elements of 2d array + n_stubs = out.shape[0] * out.shape[1] + for i in range(n_stubs): + i = n_stubs - i - 1 + j = rng.integers(0, i + 1) + # Map to 2d (row, col) coordinates + r_i = i if i < out.shape[0] else i - out.shape[0] + c_i = 0 if i < out.shape[0] else 1 + r_j = j if j < out.shape[0] else j - out.shape[0] + c_j = 0 if j < out.shape[0] else 1 + # Swap the elements + temp = out[r_i, c_i] + out[r_i, c_i] = out[r_j, c_j] + out[r_j, c_j] = temp + + return out @njit(inline="always") diff --git a/pyproject.toml b/pyproject.toml index 708a0cb..e650914 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -105,6 +105,7 @@ select = [ ignore = [ "E501", # line too long (handled by black) "B008", # Do not perform function call in defaults + "B905", # Do not require strict in zip, not compatible with numba ] [tool.ruff.lint.per-file-ignores] diff --git a/tests/test_models.py b/tests/test_models.py index 83bf69c..6942d8d 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -18,6 +18,20 @@ def test_chunglu_model(): assert edges.shape == (64, 2) +def test_chunglu_model_inplace(): + rng = np.random.default_rng(seed=1) + node_ids = np.arange(32, dtype=np.uint32) + degrees = np.full(32, 4, dtype=np.int64) + edges = np.empty((64, 2), dtype=np.uint32) + + chunglu_model(node_ids, degrees, rng) + + ids, counts = np.unique(edges, return_counts=True) + assert set(ids).issubset(set(node_ids)) + assert edges.dtype == np.uint32 + assert edges.shape == (64, 2) + + def test_configuration_model(): rng = np.random.default_rng(seed=1) node_ids = np.arange(32, dtype=np.uint32) @@ -32,6 +46,21 @@ def test_configuration_model(): assert edges.shape == (64, 2) +def test_configuration_model_inplace(): + rng = np.random.default_rng(seed=1) + node_ids = np.arange(32, dtype=np.uint32) + degrees = np.full(32, 4, dtype=np.int64) + edges = np.empty((64, 2), dtype=np.uint32) + + configuration_model(node_ids, degrees, rng, out=edges) + + ids, counts = np.unique(edges, return_counts=True) + assert set(ids) == set(node_ids) + assert np.all(counts == 4) + assert edges.dtype == np.uint32 + assert edges.shape == (64, 2) + + def test_rewire_loops(): rng = np.random.default_rng(seed=1) edges = np.array( From 83c7f0d6d5c323e1ae05dc01cd29d9af35743fe5 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Fri, 4 Sep 2026 20:23:51 -0400 Subject: [PATCH 75/85] Refactor/degree assignment speed (#13) * Use argpartiton in outlier degree assignment * Special path for alpha=0 --- abcd_graph/degrees.py | 58 +++++++++++++++++++++++++++++-------------- 1 file changed, 39 insertions(+), 19 deletions(-) diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index 89fd351..6948344 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -123,7 +123,7 @@ def _assign_outlier_degrees( if len(available_indices) > n_outliers: chosen_indices = rng.choice(available_indices, size=n_outliers, replace=False) else: - chosen_indices = np.argsort(degrees)[:n_outliers] + chosen_indices = np.argpartition(degrees, n_outliers)[:n_outliers] outlier_degrees = degrees[chosen_indices] remaining_mask = np.ones_like(degrees, dtype=np.bool) @@ -143,12 +143,14 @@ def _assign_degrees( assigned_degrees = np.empty_like(degrees) is_open_mask = np.ones_like(assigned_degrees, dtype=np.bool) n_coms_exp_alpha = n_coms.astype(np.float64) ** alpha + + # Group decisions since there are relatively few unique degrees degree, counts = np.unique_counts(degrees) # Sort by degree descending degree_argsort = np.argsort(degree)[::-1] degree = degree[degree_argsort] counts = counts[degree_argsort] - # Group decisions since there are relatively few unique degrees + for d, count in zip(degree, counts, strict=True): allowed_indices = np.where(is_open_mask & (d <= thresholds))[0] if len(allowed_indices) <= count: @@ -174,14 +176,21 @@ def _assign_degrees( all_indices_with_max_needed_threshold = np.where( is_open_mask & (thresholds == min_needed_threshold) )[0] - probs = n_coms_exp_alpha[all_indices_with_max_needed_threshold] - probs /= np.sum(probs) - chosen_max_indices = rng.choice( - all_indices_with_max_needed_threshold, - size=n_of_max_threshold, - replace=False, - p=probs, - ) + if alpha != 0: + probs = n_coms_exp_alpha[all_indices_with_max_needed_threshold] + probs /= np.sum(probs) + chosen_max_indices = rng.choice( + all_indices_with_max_needed_threshold, + size=n_of_max_threshold, + replace=False, + p=probs if alpha > 0 else None, + ) + else: # Specialized path is alpha == 0 is much faster + chosen_max_indices = rng.choice( + all_indices_with_max_needed_threshold, + size=n_of_max_threshold, + replace=False, + ) # Assign degrees and update masks assigned_degrees[next_best_indices_without_max] = d is_open_mask[next_best_indices_without_max] = False @@ -189,11 +198,18 @@ def _assign_degrees( is_open_mask[chosen_max_indices] = False else: # Choose `count` indices from allowed_indices proportional to n_coms ** alpha - probs = n_coms_exp_alpha[allowed_indices] - probs /= np.sum(probs) - chosen_indices = chosen_max_indices = rng.choice( - allowed_indices, size=count, replace=False, p=probs - ) + if alpha != 0: + probs = n_coms_exp_alpha[allowed_indices] + probs /= np.sum(probs) + chosen_indices = chosen_max_indices = rng.choice( + allowed_indices, size=count, replace=False, p=probs + ) + else: # Specialized path is alpha == 0 is much faster + chosen_indices = chosen_max_indices = rng.choice( + allowed_indices, + size=count, + replace=False, + ) assigned_degrees[chosen_indices] = d is_open_mask[chosen_indices] = False @@ -321,18 +337,22 @@ def assign_degrees( Array of degrees that is aligned with the membership matrix. """ - degrees = np.sort(degrees)[::-1] # sort degrees descending + n_coms = membership_matrix.sum(axis=0) # number of communities per node + # can't have a correlation if all non-outliers have the same number of coms + unique_n_coms = np.unique(n_coms) + if len(unique_n_coms) == 1 or (len(unique_n_coms) == 2 and 0 in unique_n_coms): + rho = 0.0 + community_sizes = membership_matrix.sum(axis=1).astype( np.uint32 ) # size of each community - n_coms = membership_matrix.sum(axis=0) # number of communities per node - if np.max(n_coms) == 1: - rho = 0.0 + community_size_matrix = ( sp.diags_array(community_sizes, format="csr", dtype=np.uint32) @ membership_matrix ) min_com_sizes = community_size_matrix.min(axis=0, explicit=True).todense() + # minimum community size for each node n = membership_matrix.shape[1] n_outliers = np.sum(n_coms == 0) From f2e71fd8b6e5612bc789d2bcb1e91eb1d4c46da9 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sun, 6 Sep 2026 09:42:02 -0400 Subject: [PATCH 76/85] Dynamically assign node dtype at sample time (#14) Instead of fixed uint32 (and thus maximum allowable node count), instead pick a dtype dynamically based on the number of nodes. Scipy requires int32/int64 for their pointer arrays, so there's not as much savings as anticipated --- abcd_graph/abcd.py | 82 ++++++++++++++------------------------- abcd_graph/abcd_sample.py | 24 ++++++------ abcd_graph/degrees.py | 59 ++++++++++++++-------------- abcd_graph/membership.py | 18 ++++----- abcd_graph/models.py | 32 +++++++-------- abcd_graph/samplers.py | 31 ++++++++------- tests/test_abcd.py | 23 +++++++---- tests/test_degrees.py | 50 ++++++++++++------------ 8 files changed, 151 insertions(+), 168 deletions(-) diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index 4d1fdf1..86f8cd9 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -2,12 +2,13 @@ import sys from collections.abc import Callable, Container from time import perf_counter +from typing import Any from warnings import warn import numpy as np import scipy.sparse as sp from numpy.random import Generator -from numpy.typing import ArrayLike, NDArray +from numpy.typing import ArrayLike, DTypeLike, NDArray from tqdm import trange from abcd_graph.abcd_sample import ABCDSample, icdf @@ -22,8 +23,6 @@ ) from abcd_graph.samplers import sample_community_sizes, sample_degrees -MAX_N = np.iinfo(np.uint32).max - class TqdmToLogger: def __init__(self, logger, level=logging.INFO): @@ -51,71 +50,45 @@ def format_duration(seconds: float): return f"{seconds * 1e9:.3f}ns" -def generate_community_graph_task( - i, - graph, - community_edges_indptr, - community_degrees_indptr, - community_degrees_indices, - community_degrees_data, - model, - max_swap_attempts_per_bad_edge, - rng: Generator, -) -> None: - com_indices = community_degrees_indices[ - community_degrees_indptr[i] : community_degrees_indptr[i + 1] - ] - com_data = community_degrees_data[ - community_degrees_indptr[i] : community_degrees_indptr[i + 1] - ] - community_graph = graph[community_edges_indptr[i] : community_edges_indptr[i + 1]] - model(com_indices, com_data, rng, out=community_graph) - rewire( - community_graph, - get_edge_type(community_graph), - rng, - max_swap_attempts_per_bad_edge, - ) - - def generate_graph( community_degrees: sp.csr_array, - background_degrees: NDArray[np.uint32], + background_degrees: NDArray[np.integer[Any]], model: Model, max_swap_attempts_per_bad_edge: int, rng: Generator, logger: logging.Logger, + dtype: DTypeLike, ): # Add background degrees as the last community community_degrees = sp.vstack( (community_degrees, sp.csr_array(background_degrees)), format="csr" ) - # Sort communities by volume decreasing + # Make indptr for edges in each community community_m = community_degrees.sum(axis=1) // 2 - argsort_community_m = np.argsort(community_m)[::-1] - community_degrees = community_degrees[argsort_community_m] - - community_edges_indptr = np.cumsum(community_m[argsort_community_m]) + community_edges_indptr = np.cumsum(community_m) community_edges_indptr = np.insert(community_edges_indptr, 0, 0) - graph = np.empty((community_edges_indptr[-1], 2), dtype=np.uint32) - n_coms = community_degrees.shape[0] - rngs = rng.spawn(n_coms) + graph = np.empty((community_edges_indptr[-1], 2), dtype=dtype) + indices_as_node_ids = community_degrees.indices.astype(dtype) + logger.info("Building Community Graphs") start = perf_counter() # TODO Parallel this loop tqdm_out = TqdmToLogger(logger, level=logging.INFO) - for i in trange(n_coms, file=tqdm_out): - generate_community_graph_task( - i, - graph, - community_edges_indptr, - community_degrees.indptr, - community_degrees.indices, - community_degrees.data, - model, + for i in trange(community_degrees.shape[0], file=tqdm_out): + com_nodes = indices_as_node_ids[ + community_degrees.indptr[i] : community_degrees.indptr[i + 1] + ] + com_degrees = community_degrees.data[ + community_degrees.indptr[i] : community_degrees.indptr[i + 1] + ] + com_graph = graph[community_edges_indptr[i] : community_edges_indptr[i + 1]] + model(com_nodes, com_degrees, rng, out=com_graph) + rewire( + com_graph, + get_edge_type(com_graph), + rng, max_swap_attempts_per_bad_edge, - rngs[i], ) end = perf_counter() logger.info(f"Finished in {format_duration(end - start)}.") @@ -283,8 +256,6 @@ def __init__( def _validate_params(self): if not isinstance(self.n, (int, np.integer)) or self.n < 1: raise ValueError("n must be a positive integer") - if self.n > MAX_N: - raise ValueError(f"n must at most {MAX_N} so it can be stored as a uint32") if not isinstance(self.xi, (float, np.floating)) or self.xi < 0 or self.xi > 1: raise ValueError("xi must be a float between 0 and 1") @@ -451,8 +422,10 @@ def sample(self) -> ABCDSample: else: n_outliers = self.outliers + self.dtype_ = np.min_scalar_type(self.n) + if self.degree_sequence is not None: - degree_sequence = np.asarray(self.degree_sequence, dtype=np.uint32) + degree_sequence = np.asarray(self.degree_sequence, dtype=self.dtype_) else: self.logger_.info("Generating Degree Sequence") start = perf_counter() @@ -467,13 +440,14 @@ def sample(self) -> ABCDSample: self.min_degree, max_degree, self.rng, + self.dtype_, ) end = perf_counter() self.logger_.info(f"Finished in {format_duration(end - start)}.") if self.community_size_sequence is not None: community_size_sequence = np.asarray( - self.community_size_sequence, dtype=np.uint32 + self.community_size_sequence, dtype=self.dtype_ ) else: self.logger_.info("Generating Degree Sequence") @@ -490,6 +464,7 @@ def sample(self) -> ABCDSample: max_community_size, self.eta, self.rng, + self.dtype_, ) end = perf_counter() self.logger_.info(f"Finished in {format_duration(end - start)}.") @@ -547,6 +522,7 @@ def sample(self) -> ABCDSample: self.max_swap_attempts_per_bad_edge, self.rng, self.logger_, + self.dtype_, ) sample_end = perf_counter() self.logger_.info( diff --git a/abcd_graph/abcd_sample.py b/abcd_graph/abcd_sample.py index 7a9a682..915ec97 100644 --- a/abcd_graph/abcd_sample.py +++ b/abcd_graph/abcd_sample.py @@ -1,3 +1,5 @@ +from typing import Any + import numpy as np import scipy.sparse as sp from numba import njit @@ -7,9 +9,9 @@ @njit def count_intra_community_edges( - edges: NDArray[np.uint32], - indptr: NDArray[np.uint64], - indices: NDArray[np.uint32], + edges: NDArray[np.integer[Any]], + indptr: NDArray[np.int32] | NDArray[np.int64], + indices: NDArray[np.int32] | NDArray[np.int64], ): m_intra_community = 0 for i in range(edges.shape[0]): @@ -31,7 +33,7 @@ def icdf(points: ArrayLike, sequence: ArrayLike, weights=None) -> NDArray[np.flo def fit_powerlaw_exponent( - samples: NDArray[np.uint32], + samples: NDArray[np.integer[Any]], ): """Find the parameters of a discrete truncated power-law distribution for the given samples via maximum-likelihood. @@ -103,17 +105,18 @@ def __init__( edges = np.asarray(edges) if not np.issubdtype(edges.dtype, np.integer): _, edges = np.unique(edges, return_inverse=True) + edges = edges.astype(np.min_scaler_type(np.max(edges))) self.edges = edges + if sp.issparse(communities): - self.membership_matrix = sp.csr_array(communities) + self.membership_matrix = sp.csr_array(communities, dtype=np.bool) else: communities = np.asarray(communities) if communities.ndim == 2: self.membership_matrix = sp.csr_array(communities, dtype=np.bool) elif communities.ndim == 1 and np.issubdtype(communities.dtype, np.integer): - communities = communities.astype(np.int64) n = len(communities) - node_ids = np.arange(n, dtype=np.int64) + node_ids = np.arange(n, dtype=communities.dtype) membership = np.vstack([communities, node_ids]) membership = membership[:, membership[0] >= 0] # Drop outliers membership_matrix = sp.coo_array( @@ -123,7 +126,8 @@ def __init__( self.membership_matrix = membership_matrix.tocsr() else: raise ValueError( - "Got an unknown format for communities. Must be a sparse or dense membership matrix or a 1-d array of community ids." + """Got an unknown format for communities. Must be a sparse or dense + membership matrix or a 1-d array of community ids.""" ) @property @@ -207,10 +211,8 @@ def degree_sequence(self) -> NDArray: ------- Array[int] """ - degrees = np.zeros(self.n, dtype=np.uint32) node, degree = np.unique_counts(self.edges) - degrees[node] = degree - return degrees + return degree[node] @property def min_degree(self) -> int: diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index 6948344..8156aaa 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -1,3 +1,5 @@ +from typing import Any + import numpy as np import scipy.sparse as sp from numba import njit @@ -7,10 +9,10 @@ @njit(cache=True) def _split_community_degree( - degrees: NDArray[np.uint32], - background_degrees: NDArray[np.uint32], - indptr: NDArray[np.uint64], - data: NDArray[np.uint32], + degrees: NDArray[np.integer[Any]], + background_degrees: NDArray[np.integer[Any]], + indptr: NDArray[np.int32] | NDArray[np.int64], + data: NDArray[np.integer[Any]], rng: Generator, ) -> None: for i in range(len(degrees)): @@ -31,12 +33,12 @@ def _split_community_degree( @njit(cache=True) def make_community_degree_sums_even( - community_degrees_indptr: NDArray, - community_degrees_indices: NDArray, - community_degrees_data: NDArray, - background_degrees: NDArray[np.uint32], + community_degrees_indptr: NDArray[np.int32] | NDArray[np.int64], + community_degrees_indices: NDArray[np.int32] | NDArray[np.int64], + community_degrees_data: NDArray[np.integer[Any]], + background_degrees: NDArray[np.integer[Any]], rng: Generator, -): +) -> None: for com in range(len(community_degrees_indptr) - 1): com_members = community_degrees_indices[ community_degrees_indptr[com] : community_degrees_indptr[com + 1] @@ -44,7 +46,7 @@ def make_community_degree_sums_even( com_degrees = community_degrees_data[ community_degrees_indptr[com] : community_degrees_indptr[com + 1] ] - if np.sum(com_degrees.astype(np.uint64)) % 2 == 0: + if np.sum(com_degrees) % 2 == 0: continue indices_of_max_degree = np.where(com_degrees == np.max(com_degrees))[0] decrease_index = indices_of_max_degree[ @@ -55,18 +57,18 @@ def make_community_degree_sums_even( def split_degrees( - degrees: NDArray[np.uint32], + degrees: NDArray[np.integer[Any]], membership_matrix: sp.csr_array, xi: float, rng: Generator, -) -> (sp.csr_array, NDArray[np.uint32]): +) -> (sp.csr_array, NDArray[np.integer[Any]]): """Split degrees into community degrees and background degrees. The fraction of degree in the background is, on expectation, xi. Community degrees will be split evenly among communities if the nodes belongs to more than one. Parameters ---------- - degrees: NDArray + degrees: NDArray[np.integer[Any]] Array of degrees. membership_matrix: sp.csr_array @@ -86,14 +88,14 @@ def split_degrees( is the degree of node j in community i. Has the same non-zero entries as the membership_matrix. - background_degrees: NDArray[np.uint32] + background_degrees: NDArray[np.integer[Any]] Array for the degree of each node in the background graph. """ background_degrees = degrees * xi background_degrees += rng.uniform(size=len(degrees)) - background_degrees = background_degrees.astype(np.uint32) + background_degrees = background_degrees.astype(degrees.dtype) - community_degrees = membership_matrix.copy().astype(np.uint32) + community_degrees = membership_matrix.copy().astype(degrees.dtype) community_degrees = community_degrees.tocsc() _split_community_degree( degrees, @@ -114,11 +116,11 @@ def split_degrees( def _assign_outlier_degrees( - degrees: NDArray[np.uint32], + degrees: NDArray[np.integer[Any]], outlier_threshold: float, n_outliers: int, rng: Generator, -) -> (NDArray[np.uint32], NDArray[np.uint32]): +) -> (NDArray[np.integer[Any]], NDArray[np.integer[Any]]): available_indices = np.where(degrees < outlier_threshold)[0] if len(available_indices) > n_outliers: chosen_indices = rng.choice(available_indices, size=n_outliers, replace=False) @@ -134,12 +136,12 @@ def _assign_outlier_degrees( def _assign_degrees( - degrees: NDArray[np.uint32], - n_coms: NDArray, + degrees: NDArray[np.integer[Any]], + n_coms: NDArray[np.integer[Any]], thresholds: NDArray[np.floating], rng: Generator, alpha: float = 0.0, -) -> NDArray[np.uint32]: +) -> NDArray[np.integer[Any]]: assigned_degrees = np.empty_like(degrees) is_open_mask = np.ones_like(assigned_degrees, dtype=np.bool) n_coms_exp_alpha = n_coms.astype(np.float64) ** alpha @@ -217,8 +219,8 @@ def _assign_degrees( def _assign_degrees_with_alpha_search( - degrees: NDArray[np.uint32], - n_coms: NDArray[np.uint32], + degrees: NDArray[np.integer[Any]], + n_coms: NDArray[np.integer[Any]], thresholds: NDArray[np.floating], rng: Generator, rho: float, @@ -286,7 +288,7 @@ def _assign_degrees_with_alpha_search( def assign_degrees( - degrees: NDArray[np.uint32], + degrees: NDArray[np.integer[Any]], membership_matrix: sp.csr_array, xi: float, rng: Generator, @@ -295,7 +297,7 @@ def assign_degrees( alpha_min: float = -60, alpha_max: float = 60, alpha_iters: int = 10, -) -> NDArray[np.uint32]: +) -> NDArray[np.integer[Any]]: """Assign degrees to nodes. Parameters @@ -343,13 +345,10 @@ def assign_degrees( if len(unique_n_coms) == 1 or (len(unique_n_coms) == 2 and 0 in unique_n_coms): rho = 0.0 - community_sizes = membership_matrix.sum(axis=1).astype( - np.uint32 - ) # size of each community + community_sizes = membership_matrix.sum(axis=1) # size of each community community_size_matrix = ( - sp.diags_array(community_sizes, format="csr", dtype=np.uint32) - @ membership_matrix + sp.diags_array(community_sizes, format="csr", dtype=None) @ membership_matrix ) min_com_sizes = community_size_matrix.min(axis=0, explicit=True).todense() # minimum community size for each node diff --git a/abcd_graph/membership.py b/abcd_graph/membership.py index 9f5e18c..6f2b14c 100644 --- a/abcd_graph/membership.py +++ b/abcd_graph/membership.py @@ -39,7 +39,7 @@ def make_primary_community_sizes( def make_overlapping_communities( n: int, - community_sizes: NDArray[np.uint32], + community_sizes: NDArray[np.integer[Any]], dimension: int, rng: Generator, ) -> sp.csr_array: @@ -51,13 +51,11 @@ def make_overlapping_communities( radii = rng.random(size=(n, 1), dtype=np.float32) ** (1.0 / dimension) points = radii * direction - # TODO pynndescent with masked query - # for now brute force primary_communities = [] has_primary = np.zeros(n, dtype=np.bool) norms = np.linalg.norm(points, axis=1) for size in primary_community_sizes: - available_ids = np.where(~has_primary)[0].astype(np.uint32) + available_ids = np.where(~has_primary)[0] seed = np.argmax(norms[available_ids]) dist_from_seed = np.linalg.norm(points[available_ids] - seed, axis=1) community_ids = available_ids[np.argsort(dist_from_seed)[:size]] @@ -66,18 +64,16 @@ def make_overlapping_communities( # Expand primary communities to full size communities = [] - for primary_members, final_size in zip( - primary_communities, community_sizes, strict=True - ): + for primary_members, final_size in zip(primary_communities, community_sizes): n_new = final_size - len(primary_members) - non_members = np.setdiff1d(np.arange(n), primary_members).astype(np.uint32) + non_members = np.setdiff1d(np.arange(n), primary_members) community_mean = np.mean(points[primary_members], axis=0) dist_to_mean = np.linalg.norm(points[non_members] - community_mean, axis=1) new_members = non_members[np.argsort(dist_to_mean)[:n_new]] communities.append(np.concatenate((primary_members, new_members))) - indptr = np.arange(len(community_sizes) + 1, dtype=np.uint64) - indices = np.empty(np.sum(community_sizes), dtype=np.uint32) + indptr = np.arange(len(community_sizes) + 1) + indices = np.empty(np.sum(community_sizes), dtype=indptr.dtype) next_indptr = 0 for i, members in enumerate(communities): indptr[i] = next_indptr @@ -86,7 +82,7 @@ def make_overlapping_communities( indptr[-1] = next_indptr data = np.ones_like(indices, dtype=np.bool) membership_array = sp.csr_array( - (data, indices, indptr), shape=(len(community_sizes), n) + (data, indices, indptr), shape=(len(community_sizes), n), dtype=np.bool ) return membership_array diff --git a/abcd_graph/models.py b/abcd_graph/models.py index 43d171d..f8dfda6 100644 --- a/abcd_graph/models.py +++ b/abcd_graph/models.py @@ -11,24 +11,24 @@ class Model(Protocol): def __call__( self, - node_ids: NDArray[np.uint32], - degrees: NDArray[np.uint32], + node_ids: NDArray[np.integer[Any]], + degrees: NDArray[np.integer[Any]], rng: Generator, - out: NDArray[np.uint32] | None = None, - ) -> NDArray[np.uint32]: ... + out: NDArray[np.integer[Any]] | None = None, + ) -> NDArray[np.integer[Any]]: ... def chunglu_model( - node_ids: NDArray[np.uint32], + node_ids: NDArray[np.integer[Any]], degrees: NDArray[np.integer[Any]], rng: Generator, - out: NDArray[np.uint32] | None = None, -) -> NDArray[np.uint32]: + out: NDArray[np.integer[Any]] | None = None, +) -> NDArray[np.integer[Any]]: """Sample a random graph with, on expectation, the given degree sequence. Parameters ---------- - node_ids: NDArray[np.uint32] + node_ids: NDArray[np.integer[Any]] List of node_ids for the graph. The returned edge list will contain each node_id equal to it's degree @@ -38,7 +38,7 @@ def chunglu_model( rng: Generator numpy.random.Generator object used for randomness. - out: NDArray[np.uint32] | None (default=None) + out: NDArray[np.integer[Any]] | None (default=None) If passed, write output into this array inplace. Can be passed as a view of a larger array. """ sum_degrees = np.sum(degrees) @@ -51,16 +51,16 @@ def chunglu_model( @njit(nogil=True) def configuration_model( - node_ids: NDArray[np.uint32], - degrees: NDArray[np.uint32], + node_ids: NDArray[np.integer[Any]], + degrees: NDArray[np.integer[Any]], rng: Generator, - out: NDArray[np.uint32] | None = None, -) -> NDArray[np.uint32]: + out: NDArray[np.integer[Any]] | None = None, +) -> NDArray[np.integer[Any]]: """Sample a random graph with the given degree sequence. Parameters ---------- - node_ids: NDArray[np.uint32] + node_ids: NDArray[np.integer[Any]] List of node_ids for the graph. The returned edge list will contain each node_id equal to it's degree @@ -70,12 +70,12 @@ def configuration_model( rng: Generator numpy.random.Generator object used for randomness. - out: NDArray[np.uint32] | None (default=None) + out: NDArray[np.integer[Any]] | None (default=None) If passed, write output into this array inplace. Can be passed as a view of a larger array. """ n_stubs = np.sum(degrees) if out is None: - out = np.empty((n_stubs // 2, 2), dtype=np.uint32) + out = np.empty((n_stubs // 2, 2), dtype=node_ids.dtype) else: assert out.shape == (n_stubs // 2, 2) diff --git a/abcd_graph/samplers.py b/abcd_graph/samplers.py index a19c95c..8e8ad77 100644 --- a/abcd_graph/samplers.py +++ b/abcd_graph/samplers.py @@ -1,7 +1,9 @@ +from typing import Any + import numpy as np from numba import njit from numpy.random import Generator -from numpy.typing import NDArray +from numpy.typing import DTypeLike, NDArray def sample_degrees( @@ -10,8 +12,10 @@ def sample_degrees( min_degree: int, max_degree: int, rng: Generator, -): - options = np.arange(min_degree, max_degree + 1, dtype=np.uint32) + dtype: DTypeLike | None = None, +) -> NDArray[np.integer[Any]]: + dtype = dtype if dtype is not None else np.min_scalar_type(n) + options = np.arange(min_degree, max_degree + 1, dtype=dtype) probs = options.astype(np.float32) ** -degree_exponent probs /= np.sum(probs) degrees = rng.choice(options, p=probs, size=n) @@ -24,14 +28,14 @@ def sample_degrees( @njit def _sample_community_sizes( - available_sizes: NDArray[np.uint32], - prob_cumsum: NDArray[np.float32], + available_sizes: NDArray[np.integer[Any]], + probs: NDArray[np.float32], target_sum: float, rng: Generator, ): max_n_communities = int(np.ceil(target_sum / available_sizes[0])) - community_sizes = np.empty(max_n_communities, dtype=np.uint32) - + community_sizes = np.empty(max_n_communities, dtype=available_sizes.dtype) + prob_cumsum = np.cumsum(probs) next_id = 0 sizes_sum = 0 for i in range(len(community_sizes)): @@ -44,11 +48,11 @@ def _sample_community_sizes( if sizes_sum > target_sum - 1: break - return community_sizes[:next_id] + return community_sizes[:next_id].copy() # Copy to free memory def fix_community_sizes( - community_sizes: NDArray[np.uint32], + community_sizes: NDArray[np.integer[Any]], target_sum: float, min_community_size: int, max_community_size: int, @@ -87,16 +91,17 @@ def sample_community_sizes( max_community_size: int, eta: float, rng: Generator, -): + dtype: DTypeLike | None = None, +) -> NDArray[np.integer[Any]]: + dtype = dtype if dtype is not None else np.min_scalar_type(n) target_sum = n * eta - options = np.arange(min_community_size, max_community_size + 1, dtype=np.uint32) + options = np.arange(min_community_size, max_community_size + 1, dtype=dtype) probs = options.astype(np.float32) ** -community_size_exponent probs /= np.sum(probs) - prob_cumsum = np.cumsum(probs) community_sizes = _sample_community_sizes( options, - prob_cumsum, + probs, target_sum, rng, ) diff --git a/tests/test_abcd.py b/tests/test_abcd.py index 5c8ed43..411a803 100644 --- a/tests/test_abcd.py +++ b/tests/test_abcd.py @@ -8,21 +8,21 @@ from abcd_graph.abcd_sample import ABCDSample -@pytest.mark.parametrize("n", [500, 1000, 2000]) +@pytest.mark.parametrize("n", [1000, 2000]) @pytest.mark.parametrize("xi", [0.2, 0.5, 0.7]) def test_abcd(n, xi): - rng = np.random.default_rng(seed=2) + rng = np.random.default_rng(seed=1) abcd = ABCD(n, xi=xi, rng=rng) sample = abcd.sample() assert_no_bad_edges(sample.edges) assert np.max(sample.edges) == n - 1 assert sample.n == n - assert np.abs(sample.xi - xi) < 0.1 # xi is noisy + assert np.abs(sample.xi - xi) < 0.15 # xi is noisy @pytest.mark.benchmark -@pytest.mark.parametrize("n", [500, 1000]) +@pytest.mark.parametrize("n", [1000, 2000]) @pytest.mark.parametrize("xi", [0.2, 0.5, 0.7]) @pytest.mark.parametrize("eta", [1.5, 2.0]) @pytest.mark.parametrize("rho", [0.0, -0.3, 0.3]) @@ -40,10 +40,17 @@ def test_abcdoo(n, xi, eta, rho): assert np.sign(sample.rho) == np.sign(rho) -def test_abcd_raises_large_n(): - abcd = ABCD(np.iinfo(np.uint32).max + 1) - with pytest.raises(ValueError): - abcd.sample() +@pytest.mark.parametrize( + "n, dtype", + [ + (255, np.uint8), + (256, np.uint16), + ], +) +def test_abcd_sets_dtype(n, dtype): + abcd = ABCD(n) + sample = abcd.sample() + assert sample.edges.dtype == dtype @pytest.mark.parametrize("n", [100, 200]) diff --git a/tests/test_degrees.py b/tests/test_degrees.py index 017afa5..ba8875d 100644 --- a/tests/test_degrees.py +++ b/tests/test_degrees.py @@ -9,9 +9,10 @@ @pytest.mark.parametrize("xi", [0.2, 0.4]) -def test_split_degrees(xi): - degrees = np.array([10, 5, 3]) - membership_matrix = sp.csr_array([[1, 0, 0], [1, 1, 0]]) +@pytest.mark.parametrize("dtype", [np.uint8, np.uint32, np.int32]) +def test_split_degrees(xi, dtype): + degrees = np.array([10, 5, 3], dtype=dtype) + membership_matrix = sp.csr_array([[1, 0, 0], [1, 1, 0]], dtype=dtype) rng = np.random.default_rng(seed=1) community_degrees, background_degrees = split_degrees( @@ -21,23 +22,22 @@ def test_split_degrees(xi): rng, ) - assert community_degrees.dtype == np.uint32 + assert community_degrees.dtype == dtype assert community_degrees.shape == membership_matrix.shape assert len(background_degrees) == len(degrees) - assert background_degrees.dtype == np.uint32 + assert background_degrees.dtype == dtype assert np.all(community_degrees.sum(axis=0) + background_degrees == degrees) is_outlier = membership_matrix.sum(axis=0) == 0 assert np.all(background_degrees[is_outlier] == degrees[is_outlier]) assert np.all(community_degrees.sum(axis=1) % 2 == 0) -def test_assign_degrees_no_overlap(): - degrees = np.concatenate( - (np.full(16, 4, dtype=np.uint32), np.full(16, 3, dtype=np.uint32)) - ) +@pytest.mark.parametrize("dtype", [np.uint8, np.uint32, np.int32]) +def test_assign_degrees_no_overlap(dtype): + degrees = np.concatenate((np.full(16, 4), np.full(16, 3))).astype(dtype) # Membership matrix with 4 communities size 7 and 4 outliers - indptr = np.arange(5, dtype=np.uint32) * 7 - indices = np.arange(28, dtype=np.uint32) + indptr = np.arange(5) * 7 + indices = np.arange(28) data = np.ones(28, dtype=np.bool) membership_matrix = sp.csr_array((data, indices, indptr), shape=(4, 32)) xi = 0.2 @@ -51,18 +51,17 @@ def test_assign_degrees_no_overlap(): ) assert assigned_degrees.shape == degrees.shape - assert assigned_degrees.dtype == np.uint32 + assert assigned_degrees.dtype == dtype assert np.sum(assigned_degrees == 4) == 16 assert np.sum(assigned_degrees == 3) == 16 -def test_assign_degrees_overlap(): - degrees = np.concatenate( - (np.full(16, 4, dtype=np.uint32), np.full(16, 3, dtype=np.uint32)) - ) +@pytest.mark.parametrize("dtype", [np.uint8, np.uint32, np.int32]) +def test_assign_degrees_overlap(dtype): + degrees = np.concatenate((np.full(16, 4), np.full(16, 3))).astype(dtype) # Membership matrix with 4 communities size 7 and 4 outliers - indptr = np.arange(6, dtype=np.uint32) * 7 - indices = np.concatenate((np.arange(28, dtype=np.uint32), np.arange(7) * 4)) + indptr = np.arange(6) * 7 + indices = np.concatenate((np.arange(28), np.arange(7) * 4)) data = np.ones(35, dtype=np.bool) membership_matrix = sp.csr_array((data, indices, indptr), shape=(5, 32)) xi = 0.2 @@ -76,20 +75,19 @@ def test_assign_degrees_overlap(): ) assert assigned_degrees.shape == degrees.shape - assert assigned_degrees.dtype == np.uint32 + assert assigned_degrees.dtype == dtype assert np.sum(assigned_degrees == 4) == 16 assert np.sum(assigned_degrees == 3) == 16 @pytest.mark.parametrize("xi", [0.2, 0.4]) @pytest.mark.parametrize("rho", [-0.7, -0.2, 0.2, 0.7]) -def test_assign_degrees_overlap_with_rho(xi, rho): - degrees = np.concatenate( - (np.full(16, 4, dtype=np.uint32), np.full(16, 3, dtype=np.uint32)) - ) +@pytest.mark.parametrize("dtype", [np.uint8, np.uint32, np.int32]) +def test_assign_degrees_overlap_with_rho(xi, rho, dtype): + degrees = np.concatenate((np.full(16, 4), np.full(16, 3))).astype(dtype) # Membership matrix with 4 communities size 7 and 4 outliers - indptr = np.arange(6, dtype=np.uint32) * 7 - indices = np.concatenate((np.arange(28, dtype=np.uint32), np.arange(7) * 4)) + indptr = np.arange(6) * 7 + indices = np.concatenate((np.arange(28), np.arange(7) * 4)) data = np.ones(35, dtype=np.bool) membership_matrix = sp.csr_array((data, indices, indptr), shape=(5, 32)) rng = np.random.default_rng(seed=1) @@ -103,7 +101,7 @@ def test_assign_degrees_overlap_with_rho(xi, rho): ) assert assigned_degrees.shape == degrees.shape - assert assigned_degrees.dtype == np.uint32 + assert assigned_degrees.dtype == dtype assert np.sum(assigned_degrees == 4) == 16 assert np.sum(assigned_degrees == 3) == 16 n_coms = membership_matrix.sum(axis=0) From 9630c665e55a4b7e41590381a101356cf23d5154 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 12 Sep 2026 17:16:49 -0400 Subject: [PATCH 77/85] Change job name from prek to pre-commit (#16) --- .github/workflows/pre-commit.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml index 0b5ddb6..a7a9cec 100644 --- a/.github/workflows/pre-commit.yml +++ b/.github/workflows/pre-commit.yml @@ -11,7 +11,7 @@ on: - 'release/**' jobs: - prek: + pre-commit: runs-on: ubuntu-latest steps: - uses: actions/checkout@v7 From b82a9bb40285cd2f1e75437cf502837ef6990999 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Tue, 15 Sep 2026 10:00:05 -0400 Subject: [PATCH 78/85] Refactor/clean up deps (#17) * Add fstar to docs deps * Add igraph and networkx to extra dependency group all * Upgrade minimum numpy version to 2.1.0 --- .github/workflows/ci.yml | 2 +- .github/workflows/coverage.yml | 2 +- pyproject.toml | 20 +++++++++++++++----- uv.lock | 28 ++++++++++++++++++++++++---- 4 files changed, 41 insertions(+), 11 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 27e8b1f..d82e0bb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -26,7 +26,7 @@ jobs: enable-cache: true - name: Install package - run: uv sync --frozen + run: uv sync --frozen --extra all - name: Run Tests run: uv run pytest tests diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml index 3a143f8..262bdb7 100644 --- a/.github/workflows/coverage.yml +++ b/.github/workflows/coverage.yml @@ -15,7 +15,7 @@ jobs: enable-cache: true - name: Install package - run: uv sync --frozen + run: uv sync --frozen --extra all - name: Run tests run: NUMBA_DISABLE_JIT=1 uv run pytest --junitxml=pytest.xml diff --git a/pyproject.toml b/pyproject.toml index e650914..36ccab8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,12 +28,18 @@ classifiers = [ requires-python = ">=3.12" dependencies = [ "numba>=0.66.0", - "numpy>=2.0.0", + "numpy>=2.1.0", "scipy>=1.18.0", "typing-extensions>=4.10.0", "tqdm>=4.0.0", ] +[project.optional-dependencies] +all = [ + "igraph>=1.0.0", + "networkx>=3.6.1", +] + [dependency-groups] dev = [ "prek", @@ -49,13 +55,14 @@ docs = [ "numpydoc", "pandocfilters", "sphinx-rtd-theme", - "networkx", + "networkx>=3.6.1", "partition-networkx", - "igraph", + "igraph>=1.0.0", "partition-igraph", "scikit-network>=0.33.5", - "partition-sknetwork", - "egosplit-sknetwork", + "partition-sknetwork>=0.0.4", + "egosplit-sknetwork>=0.0.4", + "fstar", ] [project.urls] @@ -65,6 +72,9 @@ Repository = "https://github.com/AleksanderWWW/abcd-graph" [tool.hatch.build.targets.wheel] packages = ["abcd_graph"] +[tool.uv.sources] +fstar = { git = "https://github.com/ryandewolfe33/fstar" } + [tool.pytest.ini_options] pythonpath = [ "." diff --git a/uv.lock b/uv.lock index 37a9035..5a9148a 100644 --- a/uv.lock +++ b/uv.lock @@ -14,6 +14,12 @@ dependencies = [ { name = "typing-extensions" }, ] +[package.optional-dependencies] +all = [ + { name = "igraph" }, + { name = "networkx" }, +] + [package.dev-dependencies] dev = [ { name = "prek" }, @@ -23,6 +29,7 @@ dev = [ ] docs = [ { name = "egosplit-sknetwork" }, + { name = "fstar" }, { name = "igraph" }, { name = "ipykernel" }, { name = "jupyterlab-pygments" }, @@ -40,12 +47,15 @@ docs = [ [package.metadata] requires-dist = [ + { name = "igraph", marker = "extra == 'all'", specifier = ">=1.0.0" }, + { name = "networkx", marker = "extra == 'all'", specifier = ">=3.6.1" }, { name = "numba", specifier = ">=0.66.0" }, { name = "numpy", specifier = ">=2.0.0" }, { name = "scipy", specifier = ">=1.18.0" }, { name = "tqdm", specifier = ">=4.0.0" }, { name = "typing-extensions", specifier = ">=4.10.0" }, ] +provides-extras = ["all"] [package.metadata.requires-dev] dev = [ @@ -55,18 +65,19 @@ dev = [ { name = "pytest-cov", specifier = ">=6.0.0" }, ] docs = [ - { name = "egosplit-sknetwork" }, - { name = "igraph" }, + { name = "egosplit-sknetwork", specifier = ">=0.0.4" }, + { name = "fstar", git = "https://github.com/ryandewolfe33/fstar" }, + { name = "igraph", specifier = ">=1.0.0" }, { name = "ipykernel" }, { name = "jupyterlab-pygments", specifier = ">=0.1.1" }, { name = "matplotlib" }, { name = "nbsphinx" }, - { name = "networkx" }, + { name = "networkx", specifier = ">=3.6.1" }, { name = "numpydoc" }, { name = "pandocfilters" }, { name = "partition-igraph" }, { name = "partition-networkx" }, - { name = "partition-sknetwork" }, + { name = "partition-sknetwork", specifier = ">=0.0.4" }, { name = "scikit-network", specifier = ">=0.33.5" }, { name = "sphinx-rtd-theme" }, ] @@ -691,6 +702,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/82/f8/7188153c4b265c899cd035de6a062677d51f67118a4ba640902bd9683e90/fonttools-4.64.0-py3-none-any.whl", hash = "sha256:4a05783ff54ce4c7a28f18e5772efdf63c219374bd9ffc55452182e1cef8be60", size = 1195327, upload-time = "2026-08-31T15:44:31.741Z" }, ] +[[package]] +name = "fstar" +version = "0.0.2" +source = { git = "https://github.com/ryandewolfe33/fstar#2eb354bf44bd6ff013d17bae6d5792236a44d007" } +dependencies = [ + { name = "numpy" }, + { name = "scipy" }, +] + [[package]] name = "idna" version = "3.19" From 643efa52643f99b2d8125fc9059a6d1820c18ee1 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Tue, 15 Sep 2026 10:21:39 -0400 Subject: [PATCH 79/85] Update Changelog --- CHANGELOG.md | 30 +++++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index e32028b..9ff5d78 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,16 +1,32 @@ ## abcd-graph 0.5.0-beta (unreleased) +- Complete rewrite and file restructure to simplify and increase speed. + +### Breaking Changes +- Main class ABCD stores parameters, and has a .sample() method +- ABCD.sample() returns an ABCDSample object that stores the graph and community data +- ABCD parameter name changes (gamma -> degree_exponent, beta -> community_size_exponent) +- Raise warning instead of error when powerlaw exponents are outside the expected ranges +- Removed callbacks +- Removed visualizer +- removed mypy from ci (not compatible with numba) +- removed [igraph], [networkx], [scipy], [matplotlib] optional dependencies +- moved dev and docs dependencies to uv's dependency-groups +- minimum python version bumped to 3.12 +- minimum numpy version bumped to 2.1 ### Features -- Complete rewrite and file restructure to simplify and increase speed. -- Main class ABCD stores parameters, sample and ABCD graph with the .sample() method -- ABCD.sample() returns and ABCDSample object that store the graph and community data -- ABCD has a .fit(ABCDSample) method to fit the ABCD parameters to the empirical parameters observed in the sample. -- readthedocs style documentation +- Added overlap capabilities via parameters eta and rho +- ABCD has a .fit(ABCDSample) method to fit the ABCD parameters to the empirical parameters observed in the sample ([fork/#5](https://github.com/ryandewolfe33/abcd-graph/pull/5)) ### Enhancements +- Much faster sampling - More comprehensive testing -- Run benchmarks in CI -- Migrate all workflows to uv +- readthedocs style documentation ([fork/#7](https://github.com/ryandewolfe33/abcd-graph/pull/7)) +- Run benchmarks in CI ([fork/#8](https://github.com/ryandewolfe33/abcd-graph/pull/8)) +- Migrate all workflows to uv ([fork/#8](https://github.com/ryandewolfe33/abcd-graph/pull/8)) +- Run pre-commit workflow with prek +- Replaced flake8 with ruff for linting +- Default max_degree and max_community_size grows with n ## abcd-graph 0.4.1 From a37350cacd4d8bca0d96ec57be01474aecdd3771 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Wed, 16 Sep 2026 17:41:22 -0400 Subject: [PATCH 80/85] Bug fixes in rewire (#18) --- abcd_graph/models.py | 42 +++++++++++++++++++++++++++++++++++++----- tests/test_models.py | 16 ++++++++++++++++ 2 files changed, 53 insertions(+), 5 deletions(-) diff --git a/abcd_graph/models.py b/abcd_graph/models.py index f8dfda6..73841e4 100644 --- a/abcd_graph/models.py +++ b/abcd_graph/models.py @@ -106,7 +106,7 @@ def configuration_model( @njit(inline="always") -def make_edge_tuple(edge: NDArray[np.integer[Any]]) -> UniTuple(np.integer[Any], 2): +def make_edge_tuple(edge) -> UniTuple(np.integer[Any], 2): high, low = edge[0], edge[1] if high < low: high, low = low, high @@ -120,14 +120,16 @@ def swap( rng: Generator, ) -> (UniTuple(np.integer[Any], 2), UniTuple(np.integer[Any], 2)): if rng.uniform() > 0.5: - return (edge1[0], edge2[0]), (edge2[0], edge1[0]) - return (edge1[0], edge2[1]), (edge2[1], edge1[0]) + return make_edge_tuple((edge1[0], edge2[0])), make_edge_tuple( + (edge2[0], edge1[0]) + ) + return make_edge_tuple((edge1[0], edge2[1])), make_edge_tuple((edge1[1], edge2[0])) @njit(inline="always") def is_bad_swap( - edge1: NDArray[np.integer[Any]], - edge2: NDArray[np.integer[Any]], + edge1: UniTuple(np.integer[Any], 2), + edge2: UniTuple(np.integer[Any], 2), good_edges: Set[UniTuple(np.integer[Any], 2)], ) -> bool: if edge1[0] == edge1[1] or edge2[0] == edge2[1]: @@ -149,6 +151,7 @@ def rewire( edge_type: UniTuple(np.integer[Any], 2), rng: Generator, max_swap_attempts_per_bad_edge: int = 5, + print_info: bool = False, ) -> int: """Perform inplace edge swaps to resolve loops and multi-edges. @@ -189,6 +192,11 @@ def rewire( # If the swap would cause a collision, move bad edge to the back of the # queue. Repeat until the Queue is empty or we give up. + if print_info: + print(len(bad_queue), "bad edges") + # print(good_edges) + # print(bad_queue) + # Store bad edges in the indices 0:queue_len and keep at the front # of the list next_index = len(bad_queue) - 1 @@ -200,6 +208,16 @@ def rewire( next_index = (next_index + 1) % queue_len bad_edge = bad_queue[next_index] + + # Check if edge is still bad. Conflicting edge may have been switched. + if bad_edge[0] != bad_edge[1] and bad_edge not in good_edges: + edges[n_good_edges] = bad_edge + good_edges.add(bad_edge) + n_good_edges += 1 + bad_queue[next_index] = bad_queue[queue_len - 1] + queue_len -= 1 + continue + choose_from_good_edges = rng.uniform() < n_good_edges / ( n_good_edges + queue_len - 1 ) # Always True if queue_len == 1 @@ -207,7 +225,11 @@ def rewire( swap_index = rng.integers(0, n_good_edges) swap_candidate_edge = make_edge_tuple(edges[swap_index]) new_edge1, new_edge2 = swap(bad_edge, swap_candidate_edge, rng) + # if print_info: + # print("Try swapping", bad_edge, swap_candidate_edge, "to", new_edge1, new_edge2) if not is_bad_swap(new_edge1, new_edge2, good_edges): + # if print_info: + # print("Okay") edges[swap_index] = new_edge1 edges[n_good_edges] = new_edge2 n_good_edges += 1 @@ -221,7 +243,11 @@ def rewire( swap_index = (next_index + swap_offset) % queue_len swap_candidate_edge = bad_queue[swap_index] new_edge1, new_edge2 = swap(bad_edge, swap_candidate_edge, rng) + # if print_info: + # print("Try swapping", bad_edge, swap_candidate_edge, "to", new_edge1, new_edge2) if not is_bad_swap(new_edge1, new_edge2, good_edges): + # if print_info: + # print("Okay") edges[n_good_edges] = new_edge1 edges[n_good_edges + 1] = new_edge2 n_good_edges += 2 @@ -231,6 +257,12 @@ def rewire( bad_queue[swap_index] = bad_queue[queue_len - 2] queue_len -= 2 + # if print_info: + # print(edges) + # print() + # print() + # print() + # Write bad edges that failed to swap back into the edge list for i in range(queue_len): edges[n_good_edges + i] = bad_queue[i] diff --git a/tests/test_models.py b/tests/test_models.py index 6942d8d..d5caa58 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -129,6 +129,22 @@ def test_rewire_many(): assert n_good_edges == edges.shape[0] +def test_rewire_is_idempotent(): + # idempotent: applying more than once is the same as applying once + # i.e. further rewires do nothing. + rng = np.random.default_rng(seed=1) + edges = np.array( + [[0, 0], [0, 1], [0, 1], [2, 3], [2, 3], [3, 3], [4, 5], [5, 6]], + dtype=np.uint32, + ) + + rewire(edges, get_edge_type(edges), rng) + first_rewire = edges.copy() + rewire(edges, get_edge_type(edges), rng) + + np.testing.assert_equal(first_rewire, edges) + + def test_rewire_failure(): rng = np.random.default_rng(seed=1) edges = np.array([[0, 0], [0, 1]], dtype=np.uint32) From b751770382f90c19215191d875f3b2813a290719 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 26 Sep 2026 13:36:18 -0400 Subject: [PATCH 81/85] Try moving dockerfile to us astral images (#19) Move docker to astral's uv:python3.12-trixie-slim base images since we need numba and trixie (debain) comes with gclib and can download binaries directly instead of building every time. --- .github/workflows/docker-in-ci.yml | 22 ++++----- Dockerfile | 71 +++++++++++++++--------------- uv.lock | 2 +- 3 files changed, 49 insertions(+), 46 deletions(-) diff --git a/.github/workflows/docker-in-ci.yml b/.github/workflows/docker-in-ci.yml index 7354206..5affc70 100644 --- a/.github/workflows/docker-in-ci.yml +++ b/.github/workflows/docker-in-ci.yml @@ -1,19 +1,21 @@ name: docker on: - pull_request: - branches: - - main push: branches: - - main + - 'main' + - 'release/**' + pull_request: + branches: + - 'main' + - 'release/**' jobs: docker-basic: runs-on: ubuntu-latest steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@v7 - name: Build docker basic image run: | @@ -24,7 +26,7 @@ jobs: docker image inspect abcd-graph - name: Run Trivy vulnerability scanner - uses: aquasecurity/trivy-action@0.31.0 + uses: aquasecurity/trivy-action@v0.36.0 with: image-ref: 'abcd-graph' format: 'table' @@ -35,7 +37,7 @@ jobs: - name: Run basic docker image run: | - docker run --rm abcd-graph -c "from abcd_graph import ABCDGraph, ABCDParams" + docker run --rm abcd-graph -c "from abcd_graph import ABCD, ABCDSample" docker-full: needs: @@ -43,7 +45,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout repository - uses: actions/checkout@v4 + uses: actions/checkout@v7 - name: Build docker full image run: | @@ -54,7 +56,7 @@ jobs: docker image inspect abcd-graph-full - name: Run Trivy vulnerability scanner - uses: aquasecurity/trivy-action@0.31.0 + uses: aquasecurity/trivy-action@v0.36.0 with: image-ref: 'abcd-graph-full' format: 'table' @@ -65,4 +67,4 @@ jobs: - name: Run full docker image run: | - docker run --rm abcd-graph-full -c "import abcd_graph, igraph, networkx, scipy" + docker run --rm abcd-graph-full -c "from abcd_graph import ABCD, ABCDSample; import igraph; import networkx" diff --git a/Dockerfile b/Dockerfile index 566f62c..414a62f 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,59 +1,60 @@ -FROM python:3.12-alpine AS build +FROM ghcr.io/astral-sh/uv:python3.12-trixie-slim AS build -# Install build tools + curl -RUN apk add --no-cache \ - bash \ - curl \ +# Install build tools +RUN apt-get update && apt-get install -y --no-install-recommends \ libffi-dev \ - build-base \ - linux-headers - -# Install uv and upgrade pip/setuptools -RUN pip install --upgrade pip setuptools && pip install uv + build-essential \ + && rm -rf /var/lib/apt/lists/* # Choose the type of installation (default - just the base package) ARG INSTALL_TYPE=normal WORKDIR /build -RUN pip install uv +# Keeps Python from buffering stdout and stderr +ENV PYTHONUNBUFFERED=1 +ENV UV_COMPILE_BYTECODE=1 +ENV UV_LINK_MODE=copy +ENV UV_NO_DEV=1 +ENV UV_TOOL_BIN_DIR=/usr/local/bin -COPY pyproject.toml README.md ./ +COPY pyproject.toml uv.lock README.md ./ -# Install dependencies into a virtual environment in a temporary location -RUN if [ "$INSTALL_TYPE" = "normal" ]; then \ - uv venv /venv && \ - . /venv/bin/activate && \ - uv pip install --no-cache-dir -r pyproject.toml ; \ +# Install the project's dependencies using the lockfile and settings +RUN --mount=type=cache,target=/root/.cache/uv \ + if [ "$INSTALL_TYPE" = "normal" ]; then \ + \ + uv sync --locked --no-install-project ; \ else \ - uv venv /venv && \ - . /venv/bin/activate && \ - uv pip install --no-cache-dir -r pyproject.toml --extra $INSTALL_TYPE ; \ + uv sync --locked --no-install-project --extra $INSTALL_TYPE ; \ fi -COPY src src +# Add the rest of the project source code and install it +# Installing separately from its dependencies allows layer caching +COPY abcd_graph abcd_graph +RUN --mount=type=cache,target=/root/.cache/uv \ + if [ "$INSTALL_TYPE" = "normal" ]; then \ + uv sync --frozen --no-editable ; \ + else \ + uv sync --frozen --no-editable --extra $INSTALL_TYPE ; \ + fi -# Install the actual package into the virtual environment -RUN . /venv/bin/activate && uv pip install --no-cache-dir . -FROM python:3.12-alpine AS runtime +FROM ghcr.io/astral-sh/uv:python3.12-trixie-slim AS runtime -# Add a non-root user -RUN addgroup -S abcd && adduser -S abcd -G abcd +# Add a non-root user (Debian syntax) +RUN useradd -m -s /bin/bash abcd -WORKDIR /home/abcd-graph +WORKDIR /home/abcd # Copy the installed virtual environment from the build stage -COPY --from=build /venv /venv - -# Add a default shell -SHELL ["/bin/sh", "-c"] +COPY --from=build /build/.venv /home/abcd/.venv -# Set environment to use venv -ENV PATH="/venv/bin:$PATH" +# Update paths to search the virtual environment binary directories +ENV PATH="/home/abcd/.venv/bin:$PATH" +ENV PYTHONPATH="/home/abcd" -# Use non-root user +RUN chown -R abcd:abcd /home/abcd USER abcd -# Default to python REPL ENTRYPOINT ["python"] diff --git a/uv.lock b/uv.lock index 5a9148a..101a297 100644 --- a/uv.lock +++ b/uv.lock @@ -50,7 +50,7 @@ requires-dist = [ { name = "igraph", marker = "extra == 'all'", specifier = ">=1.0.0" }, { name = "networkx", marker = "extra == 'all'", specifier = ">=3.6.1" }, { name = "numba", specifier = ">=0.66.0" }, - { name = "numpy", specifier = ">=2.0.0" }, + { name = "numpy", specifier = ">=2.1.0" }, { name = "scipy", specifier = ">=1.18.0" }, { name = "tqdm", specifier = ">=4.0.0" }, { name = "typing-extensions", specifier = ">=4.10.0" }, From c5c3842ba0f1ae4916bd79c8a9d0745a2f2a4c40 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 26 Sep 2026 13:44:05 -0400 Subject: [PATCH 82/85] Don't add latest packages --- pyproject.toml | 3 + uv.lock | 479 ++++++++++++++++++++++++++----------------------- 2 files changed, 255 insertions(+), 227 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 36ccab8..aaa9071 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -72,6 +72,9 @@ Repository = "https://github.com/AleksanderWWW/abcd-graph" [tool.hatch.build.targets.wheel] packages = ["abcd_graph"] +[tool.uv] +exclude-newer = "14 days" + [tool.uv.sources] fstar = { git = "https://github.com/ryandewolfe33/fstar" } diff --git a/uv.lock b/uv.lock index 101a297..7e74f1f 100644 --- a/uv.lock +++ b/uv.lock @@ -2,6 +2,10 @@ version = 1 revision = 3 requires-python = ">=3.12" +[options] +exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values. +exclude-newer-span = "P14D" + [[package]] name = "abcd-graph" version = "0.5.0b0" @@ -402,68 +406,82 @@ wheels = [ [[package]] name = "contourpy" -version = "1.3.3" +version = "1.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "numpy" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, - { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, - { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, - { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, - { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, - { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, - { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, - { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, - { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, - { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, - { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, - { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, - { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, - { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, - { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, - { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, - { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, - { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, - { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, - { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, - { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, - { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, - { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, - { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, - { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, - { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, - { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, - { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, - { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, - { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, - { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, - { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, - { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, - { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, - { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, - { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, - { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, - { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, - { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, - { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, - { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, - { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, - { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, - { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, - { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, - { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, - { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, - { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, - { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, - { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, - { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, - { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, - { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, - { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, - { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, +sdist = { url = "https://files.pythonhosted.org/packages/83/5a/a55177dd22553a277388e8a1b3220e92de91bacb28356cdc73caa240121d/contourpy-1.4.0.tar.gz", hash = "sha256:20156f5a1ac4f8ce02656e39a61e82164a3d359796dc8026f75b062783d500e1", size = 13323726, upload-time = "2026-09-11T19:05:05.808Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/ba/01bde9753bdbba04a6da9d2bff3881f021bc708f654655e95fae26d3b3a3/contourpy-1.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:186ba929df36d61b6127da2e89cd1357e4cb79aca647381ab1a6feb0b152877b", size = 297302, upload-time = "2026-09-11T19:02:45.103Z" }, + { url = "https://files.pythonhosted.org/packages/dd/f5/c5bf67522d49a2222f3154fe46879451d26f0e35ece41770758a64ea78cb/contourpy-1.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c76f3a5318164db7d9401132fc1b5364b784c613c93fa506e3b5e6d1bf353ec8", size = 284921, upload-time = "2026-09-11T19:02:48.049Z" }, + { url = "https://files.pythonhosted.org/packages/0f/cc/cb989599eec12fda312e127eb8e04a8b21a7a6c94bf7ff1bc68273334a42/contourpy-1.4.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:43c3ccbb32c6294b183dcc8e8c46dacf5ecef809497e3d48a5be298eef185ad0", size = 356332, upload-time = "2026-09-11T19:02:51.408Z" }, + { url = "https://files.pythonhosted.org/packages/47/fb/6f620d7602507817b0b4c21dd790ed68688f1f4ae9c29aacf21f08db5cf1/contourpy-1.4.0-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:86d05cec773c9507a3950122e0e40ce77c23c75ceeb2fc189514e71893cbb34b", size = 405878, upload-time = "2026-09-11T19:02:54.093Z" }, + { url = "https://files.pythonhosted.org/packages/32/4e/693c6d6bdece679f0953775eef3a1b66d56be55478d936e7deb1f3004422/contourpy-1.4.0-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2deb580178ca19437a84bd77e4bc2cd91a8ccad212413a83c273900868b5978c", size = 408296, upload-time = "2026-09-11T19:02:56.528Z" }, + { url = "https://files.pythonhosted.org/packages/78/f9/b6831508960d559581c448532ba4df312217072975486dbf2b24fcc5b76f/contourpy-1.4.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:875f42444c9cf48d56f724f2637e60d0f73b3b12c9041e1484580a233edf9591", size = 383243, upload-time = "2026-09-11T19:02:58.638Z" }, + { url = "https://files.pythonhosted.org/packages/f2/21/52903825a0ae7bb625e8bd30a09816d4c3c5d6174a469c10a616166cf780/contourpy-1.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f863c6100bf926cf47d13f3cd75f9bb8ebd98aaab230eeb4468b91f98f39a6b3", size = 1357306, upload-time = "2026-09-11T19:03:01.036Z" }, + { url = "https://files.pythonhosted.org/packages/d8/79/d68b1ce8539e4071518fed9523f558398f34dcd078b8927b109c72dad2ef/contourpy-1.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3863ef2e2b13fe93f8c0ebb08ee400cb07153b8b0e91c5acb26e4537f283634f", size = 1427243, upload-time = "2026-09-11T19:03:03.866Z" }, + { url = "https://files.pythonhosted.org/packages/ac/f0/b75a10e9d0616b97a30de277b6dfe83f1879880854c7330337309530eb48/contourpy-1.4.0-cp312-cp312-win32.whl", hash = "sha256:5450f091ac1be0be3ad3a2a3b3f23b5e443e78c670ced4fd347d626f92a28fd2", size = 347345, upload-time = "2026-09-11T19:03:06.192Z" }, + { url = "https://files.pythonhosted.org/packages/50/a9/dab08786bb4d77ef9a046b3c1be923be4e73c5d07d91f5a54e8ea9b09e41/contourpy-1.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:6e697d94e69f499ff6bebb899cae97a58d5d14f0e1fe9568b43a0248d2f9af8c", size = 234083, upload-time = "2026-09-11T19:03:08.122Z" }, + { url = "https://files.pythonhosted.org/packages/47/b9/3ba509755a970dbde5948e7142ac21f266be72f38017cc4087a05fdceee1/contourpy-1.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:0c7a4c2716a4e98342221954416a836cca77c996c14ddbf22b5f01d5d93ca09c", size = 559521, upload-time = "2026-09-11T19:03:10.047Z" }, + { url = "https://files.pythonhosted.org/packages/b7/8b/62a6eacea08ea0b6ab0159a7783df7ed421ff9c1ff58fef7c31f58fa5e52/contourpy-1.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e21d1d4a9db5b3a793649c7ab0ddb4697f2818929eec871a7b9c45fce7b2a1ea", size = 297330, upload-time = "2026-09-11T19:03:11.809Z" }, + { url = "https://files.pythonhosted.org/packages/3f/2f/103cdc5b7077cd569989d3ddb99ee3d4e96ee31bde8df2a6e426b2dc6195/contourpy-1.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:196759a3e4db60e1546167e361090ebb6d199aa3aafc9e34ea17a5ac3b23e814", size = 285037, upload-time = "2026-09-11T19:03:13.781Z" }, + { url = "https://files.pythonhosted.org/packages/bf/25/97001d1fdf940e6f5adfc592d4f5899fff95daf7dceead3988fe09987d2d/contourpy-1.4.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c0e07c691f3b3321913ed9b8161c50ea5f77fadd006f52f5e755359b0dcbfc5", size = 356675, upload-time = "2026-09-11T19:03:15.374Z" }, + { url = "https://files.pythonhosted.org/packages/a6/5e/9a7241a89e2f74402aefa2569e1349ad2750ff77823c04c788eaaedb7fdd/contourpy-1.4.0-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7f861af508fca2384eef392bc1d8377cfa349b2b854cb11b45d89c75780e2561", size = 406990, upload-time = "2026-09-11T19:03:17.44Z" }, + { url = "https://files.pythonhosted.org/packages/36/81/3a4fbbf6a806eada5453a6d16f6c7d96b9f4b3e57a3127368fb545986b8a/contourpy-1.4.0-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a03b32c2e7eda8b17757c022162c13c86f5c3d6f937dddf9ba3c3ff7b513953b", size = 407271, upload-time = "2026-09-11T19:03:19.523Z" }, + { url = "https://files.pythonhosted.org/packages/68/77/8f93ecbde1a4d11dfd460cd19a0c159f5487352e751fa87f5d78cc9db08e/contourpy-1.4.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f1219a8898523cba821085f2da8a1b962cc696325763f09d7f93538ba43b2d70", size = 384707, upload-time = "2026-09-11T19:03:21.208Z" }, + { url = "https://files.pythonhosted.org/packages/05/07/e5cdf94d68961ee464de6b4fedd3d2f666584f59ccd124bb1290597122ab/contourpy-1.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:20da2f86bfaed60dbba729fe738c8241b1dd22b6cf7e8cbbf30df290bd04ba28", size = 1356741, upload-time = "2026-09-11T19:03:23.621Z" }, + { url = "https://files.pythonhosted.org/packages/fd/8a/2301d07accb257ac08daeb631875fada06fedd019c20ff7b00ee07e9d211/contourpy-1.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6ced1670fafee703b8277ab1645072a226e74f167166eae146fb743916119b67", size = 1426793, upload-time = "2026-09-11T19:03:25.955Z" }, + { url = "https://files.pythonhosted.org/packages/7d/5d/a62648f06259d15c139b14eb8cf3c58fe53cb970a55f2bb77d1070e80a41/contourpy-1.4.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:abd0f7e51ecc52bf8c95713bd80b1c17c516a71fa391c54475308a4377903c2b", size = 117961, upload-time = "2026-09-11T19:03:27.713Z" }, + { url = "https://files.pythonhosted.org/packages/71/31/c5b7771ba6982f319ec90c0cf5c425b36891adfeee2d9f667f90b2d0c166/contourpy-1.4.0-cp313-cp313-win32.whl", hash = "sha256:510f7d93d94cf6ebf4e2cd0640bea16ab8affac7547230175b6745b596ce0599", size = 347438, upload-time = "2026-09-11T19:03:29.829Z" }, + { url = "https://files.pythonhosted.org/packages/68/c1/a59df0754bf83a6f3e153cc19d550a5b01f607e389b1c4d57f436f9139e0/contourpy-1.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:6507a016976a75a15aee47809a34605de6244ccc056e6164bf9fb14b27eecad4", size = 234084, upload-time = "2026-09-11T19:03:31.657Z" }, + { url = "https://files.pythonhosted.org/packages/41/48/97224f5decb1efa5a610f912195deb45321f73ec9b9dac485cd6fe2d5a6a/contourpy-1.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:423bd5f4b3f11d54a8c597234e513382e3454bb106b8ec7ae32ba4ed63f8d99b", size = 559559, upload-time = "2026-09-11T19:03:33.528Z" }, + { url = "https://files.pythonhosted.org/packages/75/b0/b548628c8dddf6e5e0a981b7fa8e4c008024df09c7d17c6a9e271edfa0b3/contourpy-1.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a3e67bc1a6a4618a1dac7c3053a9ffece5ddfa2046b2670b342cf430bb0b87d1", size = 297354, upload-time = "2026-09-11T19:03:35.017Z" }, + { url = "https://files.pythonhosted.org/packages/04/5a/513484208742f65af2648c519f0b7ab034616e183c4403538024c136a1ab/contourpy-1.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:072a702e2e178f4fcf96f04775d0c059e4c917925abf0d3208ebb6865df3c23d", size = 283729, upload-time = "2026-09-11T19:03:36.818Z" }, + { url = "https://files.pythonhosted.org/packages/35/da/5a6562febc994b2c4bf9d01e57a50458ef8a2051bb3e7b35a00333e0fc26/contourpy-1.4.0-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:404dbcd9233513dfd1323b66ea593fef90e899f658f6b8a9ed8e93bd0ca669db", size = 357819, upload-time = "2026-09-11T19:03:39.058Z" }, + { url = "https://files.pythonhosted.org/packages/6d/99/7b358ce888aaa426f755daa096c99c59d17c352037344e836f20e5d3b957/contourpy-1.4.0-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:61624f6722480aa7e168fd746164e7bfdf48f8ccb6542f1613741200dc37e2b1", size = 407795, upload-time = "2026-09-11T19:03:41.293Z" }, + { url = "https://files.pythonhosted.org/packages/be/02/34d7548adf08c60967435d79d7a90882eacc84f5093435287974c7e99943/contourpy-1.4.0-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2e741a39dfc96babe1722561e81351aeec104526c57dbe91c167c1db606c2d55", size = 408552, upload-time = "2026-09-11T19:03:42.728Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8c/9677dad226e5aaac5b823d5b09d881ebc32ff1648af417597649841e516c/contourpy-1.4.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e439ab450c93455feb0218532ded3e946ec7a9b5f459069f122cfa44b89229f6", size = 384850, upload-time = "2026-09-11T19:03:44.402Z" }, + { url = "https://files.pythonhosted.org/packages/08/f5/e3fbeaa489c223629fbb434737cb3de4ecaca9cae4825e77b92490f640f8/contourpy-1.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:417be048f7e122cefbe2a34c51a1f2b0410f8eb35796f794d45475ddb7872d9d", size = 1357601, upload-time = "2026-09-11T19:03:46.746Z" }, + { url = "https://files.pythonhosted.org/packages/88/be/55fec293d342c222ed58a5d4056df4362e192af2e59527a3d5d822de8828/contourpy-1.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:43d80072a32299bf945de0a6dd4e034ea0162e832261de2e07a274a5adbba9c9", size = 1427340, upload-time = "2026-09-11T19:03:48.745Z" }, + { url = "https://files.pythonhosted.org/packages/86/40/0faabf453edf59b0e3633381d7ca72c3414fb9b72b5cbb08b06ed792d3e5/contourpy-1.4.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:fa1b787362a3856e63dd2b89449f6c384d55ee1beb8f94f4bcc871b40f02462c", size = 118355, upload-time = "2026-09-11T19:03:50.047Z" }, + { url = "https://files.pythonhosted.org/packages/38/0c/7ea75aa3559ae8a6805015e15a19c92b6480752ecc92526361e5776e88c5/contourpy-1.4.0-cp314-cp314-win32.whl", hash = "sha256:738c44fa71735a617f36da58e32810512407d283d5d1bb5b1cecb00d7eeba7cf", size = 356977, upload-time = "2026-09-11T19:04:11.401Z" }, + { url = "https://files.pythonhosted.org/packages/15/41/3df8cc14bb572c8b447f9dfbc876703f0f2f2896058285b5c87a1d4a638d/contourpy-1.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:181bea01bc742734ae672fa00c717d855dd35e1f029536406538c52e7b0cd73d", size = 240101, upload-time = "2026-09-11T19:04:12.772Z" }, + { url = "https://files.pythonhosted.org/packages/66/01/ee6830a5aa4565662a345172f6f35eeeed625d20f1c9d4ecd35318fe4ade/contourpy-1.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:64039341e2d8804f1a13bda8c69083eab935167bbd7e856cf096241f17d5bd45", size = 576359, upload-time = "2026-09-11T19:04:14.983Z" }, + { url = "https://files.pythonhosted.org/packages/51/af/49ee9c9cf012699e505c1b63c531cc99f19df50f205173092c4d541e3ec7/contourpy-1.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ef47fef9a912c77e3d84b014f701e5a9340f25703e9ed3bcebe37f91fb69dc49", size = 313601, upload-time = "2026-09-11T19:03:51.452Z" }, + { url = "https://files.pythonhosted.org/packages/ad/59/ce411ab2be0f805038626d8f4ca9ce563487ff51ff6c363e7512271564ed/contourpy-1.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:96019f059bcb3774acc0104be3360a57b36d33eaaa2e1d7f77c800ca8e07618b", size = 302812, upload-time = "2026-09-11T19:03:53.022Z" }, + { url = "https://files.pythonhosted.org/packages/95/b0/390915f9af14c1e2d3b2a9ad99d85b98df4352346a51e368cbb825f813c3/contourpy-1.4.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ddf5a2596d716fd3793434844caf31abc7a40b1e8718431420c89858268fb909", size = 348996, upload-time = "2026-09-11T19:03:54.594Z" }, + { url = "https://files.pythonhosted.org/packages/c7/85/e0952576d54322f3e9983b1e049a7a31f42ce82c5c29d01821e6dd3780d7/contourpy-1.4.0-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dd59df9e2fb0aff8bd7fd1adb9f349b7c835245a9d0f18c2f2deeb537190f2b1", size = 400272, upload-time = "2026-09-11T19:03:56.822Z" }, + { url = "https://files.pythonhosted.org/packages/d6/7d/f13543a5e1598e4a4ad01d9d5e2d65f9c09c37660616429913d606c5977d/contourpy-1.4.0-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b7794ea07cab575633daad8d6e963b662053391022294d3aacc1d9ba9ef54114", size = 412895, upload-time = "2026-09-11T19:03:58.487Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a8/6e5eaff53507dfd2dfc428240eecda32453067277d4b3e7ca71210b2d611/contourpy-1.4.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a1c8a74744fa746eeaa12f0f9ed7f8b4add9d8f1b14d95e3b5e133675eac888f", size = 377060, upload-time = "2026-09-11T19:04:00.122Z" }, + { url = "https://files.pythonhosted.org/packages/16/a3/d00e44d35511b3cead5bd794ee672d4eecf30d9de4ceac57a49d6204064f/contourpy-1.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:107ec46f7aa1664266d69b1181aadc953d58d39f7d8d648fa5b795d4a060b0de", size = 1345688, upload-time = "2026-09-11T19:04:02.705Z" }, + { url = "https://files.pythonhosted.org/packages/1e/01/1e533b0cae32c8edd63fe40435ec3b29345dab87321afcd28722d7f957d1/contourpy-1.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5a4c89c7f38a0d7a94356d74e3391073c4325c4d47ad2fd065c3fe7dbae16c0c", size = 1416140, upload-time = "2026-09-11T19:04:04.77Z" }, + { url = "https://files.pythonhosted.org/packages/6d/0c/4ee66759f00d6a5d6909782f14f441d639fa18a4a43142e334351efc47f8/contourpy-1.4.0-cp314-cp314t-win32.whl", hash = "sha256:912c6afaa106e2f74ba22b30416b77ef7eb94e3bdc5a4df51ab147845dba9b6d", size = 371982, upload-time = "2026-09-11T19:04:06.233Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ac/b3e5324138c3e3741f526663f4f265f4f69dfdf26415a39428940864a5f6/contourpy-1.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:ef9440f6f8506246269a82734f5ff9e2e4c5e775b3996fc883cc491c5257eca6", size = 262907, upload-time = "2026-09-11T19:04:07.882Z" }, + { url = "https://files.pythonhosted.org/packages/19/37/c9aa45e47819dc15a38fc5c81a2fb987fde55e9d3b991fbde514e3b6b5f5/contourpy-1.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:fc9feef8f1f001c5b87decadc67c4a5d1eebb62ca39c4763d1237ff62cf2b707", size = 587071, upload-time = "2026-09-11T19:04:09.898Z" }, + { url = "https://files.pythonhosted.org/packages/cc/74/66d4e6fbea3bcb3fd4e5ae21c039ba31b8fc408b35884b4bc09b88016dce/contourpy-1.4.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:79b06c60d5e569ce12c5da8f0c51217cdc484386e2349fa717c30fafb56d2871", size = 297358, upload-time = "2026-09-11T19:04:16.718Z" }, + { url = "https://files.pythonhosted.org/packages/2e/8d/8f7f25e71d73f15d7859943189900d2d348e740388c9ef52a0180d284762/contourpy-1.4.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:6f963ea9f0d68d2b6a02d861e3c0aae09ae25ba21f243fcf281e9fed468b078d", size = 283732, upload-time = "2026-09-11T19:04:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/f0/90/957549e3b03c407c670e3e191db63f4aef60dab6605bc967af3a806b543e/contourpy-1.4.0-cp315-cp315-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5545ff38229c15d11d822fc6f7415b932da9f4975f53e305b7b96ebfb01f889c", size = 357820, upload-time = "2026-09-11T19:04:20.077Z" }, + { url = "https://files.pythonhosted.org/packages/56/4c/fa8de87d907b41b05d03f4945a51675cd67319650d01b4c927d209ffa6ee/contourpy-1.4.0-cp315-cp315-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:630d32f06cedf37b7f1dd2b6a12e4492826bd477a4c9c7b2e2fee6ce3a2cea76", size = 407804, upload-time = "2026-09-11T19:04:21.781Z" }, + { url = "https://files.pythonhosted.org/packages/04/e7/96bd4f4a4ae285727befbdb4b332d53a2654cc5da4585d2525b47a063e1f/contourpy-1.4.0-cp315-cp315-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:be85d160e7c795113c2a93254dde2fc7e86b375322570eee78b420969426973c", size = 408559, upload-time = "2026-09-11T19:04:23.432Z" }, + { url = "https://files.pythonhosted.org/packages/ae/94/39660e8dc309f96bf7971eb4ec5659f272f84e42b34c9990a96ecce8442c/contourpy-1.4.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:018227e134b73090b06f911e773a526c77c9af426be29065500ce096a5accd4c", size = 384861, upload-time = "2026-09-11T19:04:25.198Z" }, + { url = "https://files.pythonhosted.org/packages/ab/7b/411dccbf73d5d19da49bf7735786b3baf4ddb1456412d48ae4d4ab1fc761/contourpy-1.4.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:4bffcb2e8cc5c0e837631acab59dd04265fdac376550e7c3e310523877c68cb7", size = 1357612, upload-time = "2026-09-11T19:04:27.614Z" }, + { url = "https://files.pythonhosted.org/packages/a0/39/bf2442130e7d5aae75a4de4504f0c8aca3ef3da3feac3940ee27ca985d83/contourpy-1.4.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc87f2ffa84a49a77d76cb792f28a48ff3b05a222aa0b2bddbd839ba78e1d5ca", size = 1427345, upload-time = "2026-09-11T19:04:29.646Z" }, + { url = "https://files.pythonhosted.org/packages/96/60/e5d9196dd83ccd7dd103762982b10ef19a4f72e8ef67ae7157699b9be0bb/contourpy-1.4.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:c8be3392b84cf43373a488874dc1ebf46f60784a70977f92586e18019d71c7ed", size = 118157, upload-time = "2026-09-11T19:04:31.091Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b2/ae3d90f08ba2ed82189d93b55ffbd41e559760e89af4f9ef54d51869f41d/contourpy-1.4.0-cp315-cp315-win32.whl", hash = "sha256:618137ec5778fb76d494c9ec854b104a377fddba0d128bef7136cce2c3bf0df8", size = 356982, upload-time = "2026-09-11T19:04:52.913Z" }, + { url = "https://files.pythonhosted.org/packages/02/a0/36648fff407dcf8b8482985d33367ffc0fe90be72383869312cd0bd00a1b/contourpy-1.4.0-cp315-cp315-win_amd64.whl", hash = "sha256:ea09dc704029930cbd097f75cb0cc1db9852adbcf1a151fac7e9559f7bcbfd19", size = 240101, upload-time = "2026-09-11T19:04:54.587Z" }, + { url = "https://files.pythonhosted.org/packages/07/09/49e987a96706b8f877596cee00d558d7880793a833addc6b33f80805e5dc/contourpy-1.4.0-cp315-cp315-win_arm64.whl", hash = "sha256:a5e2bb871b90cd7a52bdee63bf80ef7acb46398d27efc66d7679240016efc5aa", size = 576375, upload-time = "2026-09-11T19:04:56.515Z" }, + { url = "https://files.pythonhosted.org/packages/e3/18/820ba24a070fe2a834af73e52245c501960746f5c1777ebc64ec0c0dec12/contourpy-1.4.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:432e89f835cf01f8d2123a130a3126b17ee6e0348e4d62c0973872b30aa873bf", size = 313543, upload-time = "2026-09-11T19:04:32.582Z" }, + { url = "https://files.pythonhosted.org/packages/d3/4c/f61a63d8107e0c1c3fa47d30ce45abad90b2ad48a1a9a4510332db7e0176/contourpy-1.4.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3e0a2392533e5e2abdf277c951047516acc8d2f3c42b2dd9dc34c907c9ebabf2", size = 302702, upload-time = "2026-09-11T19:04:34.257Z" }, + { url = "https://files.pythonhosted.org/packages/9d/93/5af95cb5113ecc6e780ca0c6c79756a2cea8833f971bbae112dd4ad73ded/contourpy-1.4.0-cp315-cp315t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:758e7496cec3195fc28a28945eab3ceef348c47fb95c7afc2eca2f3901209c8c", size = 354370, upload-time = "2026-09-11T19:04:36.158Z" }, + { url = "https://files.pythonhosted.org/packages/47/75/5a9942446647202beb7b4d150891bfcb78fb112c73862484bbe4cc031092/contourpy-1.4.0-cp315-cp315t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bee6ff96653e0807cd0f8eaef00174a031e3a2effa5c20f49a5a8d574b05af23", size = 402340, upload-time = "2026-09-11T19:04:37.914Z" }, + { url = "https://files.pythonhosted.org/packages/c3/4f/bfdb0c67775a584f957211936661289789c4d0ec3e988bca2c8c02f8090e/contourpy-1.4.0-cp315-cp315t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a58b5f130afec61a093d743cdda435cc4047748b6791627e34a68f41ec3a9b07", size = 410721, upload-time = "2026-09-11T19:04:39.925Z" }, + { url = "https://files.pythonhosted.org/packages/65/d3/dddf13d6bb26e145c99debd1f2695018b5f3e24452dd9bfc9904c9d2ec89/contourpy-1.4.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9dc493e7924e5aa32d89d0b8e50986280f3d4b284968a792787bd7bcffd3cad", size = 382604, upload-time = "2026-09-11T19:04:41.793Z" }, + { url = "https://files.pythonhosted.org/packages/37/b4/89f0a5f6c6ccd322eae2704c7e933c82a4e594a61773933b4b0a18646866/contourpy-1.4.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:c927ec747633e68c9920bcaad48b0bcefe648812b822f18c34e2d0e2270a3d2a", size = 1354996, upload-time = "2026-09-11T19:04:43.856Z" }, + { url = "https://files.pythonhosted.org/packages/5d/29/fc91cc1ac6f3b591a269f4357b656d6ed0c39eb17c148f41f6da2f9729b9/contourpy-1.4.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:80c7fc8e7ac217777ce7ba2db3cf8478652b5a4b335283111012ff9eaac9d842", size = 1425030, upload-time = "2026-09-11T19:04:45.981Z" }, + { url = "https://files.pythonhosted.org/packages/d8/b8/bb129f524210c5d3eb8616876e02af280fba8b5554e0ac1afad80b51e06b/contourpy-1.4.0-cp315-cp315t-win32.whl", hash = "sha256:90feb8da006803a95ba573fddc9536357d0c3faddc3a4c9e22816ca49af52878", size = 371854, upload-time = "2026-09-11T19:04:48.106Z" }, + { url = "https://files.pythonhosted.org/packages/d8/b1/bc774d9d200cfc4f073bba78b1bb1cb3b55bf1c8c345eae41fc2db510459/contourpy-1.4.0-cp315-cp315t-win_amd64.whl", hash = "sha256:de503609fdb71f597634ca64fb4bd2f13d27c97f140e912b1e8ed93544840df0", size = 262450, upload-time = "2026-09-11T19:04:49.502Z" }, + { url = "https://files.pythonhosted.org/packages/54/bf/eb4ff492e1c3d027617b5a20e4e6d63a035b41b8cf77a95950159556a3a5/contourpy-1.4.0-cp315-cp315t-win_arm64.whl", hash = "sha256:78ed5c5f962b3e156109f0531b174a65ba80d13cc681a70227b12524c162e184", size = 587064, upload-time = "2026-09-11T19:04:51.148Z" }, ] [[package]] @@ -647,59 +665,59 @@ wheels = [ [[package]] name = "fonttools" -version = "4.64.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d4/41/0f072a712dc74496e03710e462a18a4cfd8a258ad055a4e22d28b43a7abd/fonttools-4.64.0.tar.gz", hash = "sha256:ecb2e59a7bc692fee64dda6010deb66222335693b30046f15cccf81233aa715f", size = 3664266, upload-time = "2026-08-31T15:44:33.685Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/82/23/4ea251977fef70ed14193785e1b2949355f1f5927dc0ef1dada675c0bbb2/fonttools-4.64.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9ecb2b206b5b2386f6968721a0770226b66bdd54adc4279bfff3ddf62873eed8", size = 3095501, upload-time = "2026-08-31T15:42:44.299Z" }, - { url = "https://files.pythonhosted.org/packages/c4/32/943e9034f49797e1a25dbbd60c8047ce0c38c3585c5d1b2db38ce64059c5/fonttools-4.64.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a8c631303bb1fd7be3067c47536a30ff1fcb4846d6008c112bc52a03f7cd6965", size = 2583091, upload-time = "2026-08-31T15:42:46.57Z" }, - { url = "https://files.pythonhosted.org/packages/0a/4b/332cb3105d5d550cb5728e669151601c4f7698cbedafd134154eb806ef83/fonttools-4.64.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2763e452b025ee8e990f0462e76052de9bb094ebc21d296f62c6dfe958886b4", size = 5423449, upload-time = "2026-08-31T15:42:48.615Z" }, - { url = "https://files.pythonhosted.org/packages/dc/8f/e5f2906ea833d362916c64a2f6b1922a07b19442744fd3cd89563f429bff/fonttools-4.64.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:66a83f93579fb3493e458c4449d1d566a7b2a1c7b19915cd0fa3c9b8b5a8540b", size = 5400981, upload-time = "2026-08-31T15:42:50.862Z" }, - { url = "https://files.pythonhosted.org/packages/fe/46/1b325ebb20aef8bb05f803052ea65931d73638ae3e0d02a6658e3d14e0f8/fonttools-4.64.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cf67f96dc0bfe9607f5f2b734cedfbe2f6f995231adee4ccefa12872044d452d", size = 5359588, upload-time = "2026-08-31T15:42:53.341Z" }, - { url = "https://files.pythonhosted.org/packages/8c/d3/ac56fa880e01339aa6ad0bcb457cc30bb4d6c5ca79922e1bd650e4a3a396/fonttools-4.64.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6786bed88581e19bc4f28ea7a64ad531e8f54acf50327fddca942688824a60bd", size = 5520698, upload-time = "2026-08-31T15:42:55.919Z" }, - { url = "https://files.pythonhosted.org/packages/d7/40/1251fef04c308836a3a7db523703a7ca8ab010dc1e3b9a9bf08e0861c7a8/fonttools-4.64.0-cp312-cp312-win32.whl", hash = "sha256:da4c9bdeaf6b06c12d13d0addfc8ef15aa9695d26574a6dc10751258bef72f30", size = 2430689, upload-time = "2026-08-31T15:42:58.48Z" }, - { url = "https://files.pythonhosted.org/packages/6f/1c/ce0e89183c0235ff6cfbf0603d593023a5afa5333efb35ff569cc0be9ce2/fonttools-4.64.0-cp312-cp312-win_amd64.whl", hash = "sha256:06b6409b868494556a831ae33b2d9a090476c37516b38d70f45a9720b460d423", size = 2482071, upload-time = "2026-08-31T15:43:00.598Z" }, - { url = "https://files.pythonhosted.org/packages/44/7b/49b0054a79b9ed918c018e70e09b56eb5678ee8b44e59e126c79de4d8d73/fonttools-4.64.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9443eefff58aad558608f352092e1be6d278980e8c3b4e8621fcbfda97818500", size = 3092750, upload-time = "2026-08-31T15:43:02.705Z" }, - { url = "https://files.pythonhosted.org/packages/83/e2/08e73bd2f6e6248f071d3e9debe4c2b4cecda3a7dc057c56b44e255421c3/fonttools-4.64.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:09657817b75575822bcd6098ef0ebf0386f34430839ee53109e70fd40a7f6539", size = 2583001, upload-time = "2026-08-31T15:43:04.923Z" }, - { url = "https://files.pythonhosted.org/packages/2f/58/6dc0ff0963fc1e12f53bac59175617ec5927342ee7a4ffb871b44d56d81b/fonttools-4.64.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d7995b906666037d7114c20a5566a372902747452af7d5bd4cd6bca8f1a2550", size = 5392765, upload-time = "2026-08-31T15:43:07.096Z" }, - { url = "https://files.pythonhosted.org/packages/7a/dd/4d3911049680da7b3aecf97cb5094e3a05554f5d94829358fc7664640456/fonttools-4.64.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2c42237b7e8c6813643e57d3efed3be094d4c06339dc2166b626e2cc5c12ee93", size = 5373969, upload-time = "2026-08-31T15:43:09.617Z" }, - { url = "https://files.pythonhosted.org/packages/48/0a/a2cf94121fd3ca9166bdb4863f71d6db32a5606b223c81e2ba99832a0612/fonttools-4.64.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:498f02ea92c9ca18c0f9c581ea93184a9d56c25b0af14189b0767adaf34235d8", size = 5333854, upload-time = "2026-08-31T15:43:11.985Z" }, - { url = "https://files.pythonhosted.org/packages/44/e2/632f4a8b94e6d7eea41e6d82f0ed337f64f5fb96f9910e2ac6b1689910e2/fonttools-4.64.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8252f20108e557532f91d7d6dd9af87c16ed6fa930f65516aa480fa2cfed3363", size = 5492828, upload-time = "2026-08-31T15:43:14.288Z" }, - { url = "https://files.pythonhosted.org/packages/ff/25/7fee1978fdedc1a2d978b76dddbea88785416f5774e7222327b867712d71/fonttools-4.64.0-cp313-cp313-win32.whl", hash = "sha256:45e3ecc3888f1637094fd75cd8fc727f3a4b06d1ddf89181126c071e244fd2a5", size = 2429011, upload-time = "2026-08-31T15:43:16.463Z" }, - { url = "https://files.pythonhosted.org/packages/dd/ed/bb1c217c9e1fbfa59f42b266af57df937a703882a73e59a309773752228f/fonttools-4.64.0-cp313-cp313-win_amd64.whl", hash = "sha256:e4812f71c39d77ec5041348dafa400532adf7bf8f1fffa9aa6495fce5876d7b8", size = 2480199, upload-time = "2026-08-31T15:43:18.774Z" }, - { url = "https://files.pythonhosted.org/packages/a0/0a/59b9074b8ab165cc28d3e08bcf7a8eff8e1dc5932a5a41c87b15952fa3af/fonttools-4.64.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:6f1ce9ef9a1b13098efdc2e43a2ed96d9851bbde7b31c652a87552c4efe9b422", size = 3096790, upload-time = "2026-08-31T15:43:21.125Z" }, - { url = "https://files.pythonhosted.org/packages/17/39/af1077a36feefe79f36d67d75aee637a96673c0a74eeb2c6f24266f5a20b/fonttools-4.64.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:83cc48d1411d2ff388dab99973dca81172cc9ceae9c9799da9548d494cfb38cb", size = 2584288, upload-time = "2026-08-31T15:43:23.148Z" }, - { url = "https://files.pythonhosted.org/packages/00/c4/1ea58af0eb78264d28e5871bba0810bf0943cd93d641fdeae92553ad3410/fonttools-4.64.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e412767d1c9765cf1b82f7b00f1686c6ca5809ebb77af363b3f9f2325a465c01", size = 5378061, upload-time = "2026-08-31T15:43:25.193Z" }, - { url = "https://files.pythonhosted.org/packages/93/99/5c7e36d770407b66f7fc8378d2bb47f1530d083d8b9247ff011ec9b4dd70/fonttools-4.64.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b4a7af455ffed980925bc0ebf5b8d6239e6c3e797d9d755b6db192fb3080d614", size = 5319458, upload-time = "2026-08-31T15:43:27.696Z" }, - { url = "https://files.pythonhosted.org/packages/a8/09/89e8d600e92723309d4ddd3944c4ca565197a5df0236ae4115ccbe797375/fonttools-4.64.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:398b14f89ca950b288bd290875f07e4e10685644fa4ac668546fb107b1ada4d4", size = 5316656, upload-time = "2026-08-31T15:43:29.842Z" }, - { url = "https://files.pythonhosted.org/packages/0e/b3/56719ab37e1592ceac89724574146622bedec036a207be80f3c7b1c14cbe/fonttools-4.64.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:dc96150f99e05a317cb1f042b92c4cf8bc93cdb1f9f85717322e202ecdf2e505", size = 5448380, upload-time = "2026-08-31T15:43:32.311Z" }, - { url = "https://files.pythonhosted.org/packages/3b/b0/15951b7e3006073f3260da4f8983732d18903905cfe26daa5138a0bbf682/fonttools-4.64.0-cp314-cp314-win32.whl", hash = "sha256:1c3661324f3f0fa4539a32288a3e0711a5f3ccf020036e760bb558ae9811a16f", size = 2432778, upload-time = "2026-08-31T15:43:34.421Z" }, - { url = "https://files.pythonhosted.org/packages/8e/f3/0c97402b29411f4f6d31b32f2af5b4bcd5babe5a93c64558a8fd3654f140/fonttools-4.64.0-cp314-cp314-win_amd64.whl", hash = "sha256:043f6c572bf236f2a76e762c25f841daea11e8fc03e78088d7be66e0c5b4e4c0", size = 2485394, upload-time = "2026-08-31T15:43:36.506Z" }, - { url = "https://files.pythonhosted.org/packages/00/da/82192c7bee5314f04129a068dddae11082a63295d4e3b5ce08657de96608/fonttools-4.64.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4691a122b8c1d0d82d6e7510ce59d5c42146518240274b53e912e255573924f7", size = 3170118, upload-time = "2026-08-31T15:43:38.579Z" }, - { url = "https://files.pythonhosted.org/packages/42/2d/0b4f608d754f625fecc7d94b3b26af6f65f6ab4527b386bb0c6141cdd9ea/fonttools-4.64.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:3200180abc69639483cf54a17cca2e13c31ede5f665979ea0a9c829d093f372f", size = 2617333, upload-time = "2026-08-31T15:43:40.934Z" }, - { url = "https://files.pythonhosted.org/packages/5e/df/9f7448c38dea05458acfee81c443b14ef97d6d66c636af053d41cf8a32dd/fonttools-4.64.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53eee22af5b5a305c1ee2652955ed46b148e881456fcec1e7f0eb27f642f6bb4", size = 5542345, upload-time = "2026-08-31T15:43:43.114Z" }, - { url = "https://files.pythonhosted.org/packages/b1/e8/cbf4a81e8be322bc4bee4ba31cd33a7b6336ef8030fa13b53b3e9c09fbf9/fonttools-4.64.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08f172961e11f4eb4f80f2f20049e09b0ea8e044fa6d456fed8346eb8588f360", size = 5349981, upload-time = "2026-08-31T15:43:45.363Z" }, - { url = "https://files.pythonhosted.org/packages/d8/dc/106fd9e93e962dbb60482d30c0913af3d108f5762429dfe93265a850bdc5/fonttools-4.64.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6eae4376adb104c2acfa76fd9ea0cb12b572ca1d70eceac709871f638ff76e93", size = 5409249, upload-time = "2026-08-31T15:43:47.817Z" }, - { url = "https://files.pythonhosted.org/packages/b0/2d/c7be990abf74c9c5c5367ae3dc65953ffce49fe00f62abd129cf725a2397/fonttools-4.64.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2730946ca8f12c356bd98eb9b2b095c8e761ed05bed5afb0d5b380cebe4f6370", size = 5443781, upload-time = "2026-08-31T15:43:49.909Z" }, - { url = "https://files.pythonhosted.org/packages/9b/cc/bffec3dccb9e3f4f6097a2baedaef5a8dec2cb816522ee163e4bb7f54b44/fonttools-4.64.0-cp314-cp314t-win32.whl", hash = "sha256:d30c966bea2deffa19c738c81776f7182da5ccabd97e666bae4f3d6ba87341d9", size = 2466542, upload-time = "2026-08-31T15:43:52.088Z" }, - { url = "https://files.pythonhosted.org/packages/96/49/e31f97dfc94e0648999f04bfccb37a97062d978f87df60654f496942c89f/fonttools-4.64.0-cp314-cp314t-win_amd64.whl", hash = "sha256:917fd520bb60809d83c14d43cfe48d5ad2516abaf2c073d65a431800dade2d29", size = 2516703, upload-time = "2026-08-31T15:43:53.954Z" }, - { url = "https://files.pythonhosted.org/packages/fe/ec/e39b9e56db7dcc859983caa24cf2a36209dd71f6cc8ddbbf00d7342d7988/fonttools-4.64.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:8dd18fdff0ac9759b8d67a714730abee07b2312e3656c20ba5affb0107094762", size = 3091150, upload-time = "2026-08-31T15:43:56.309Z" }, - { url = "https://files.pythonhosted.org/packages/a8/e1/3e6a409d6f99efb66c2f6d0a71986432ff9cc9aca0df9ff4a8bed1d850f6/fonttools-4.64.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:5af87d1a6d247d7467ee082ae977a5443b2c45f8cd4d59375b6daa38d523c2de", size = 2582833, upload-time = "2026-08-31T15:43:58.348Z" }, - { url = "https://files.pythonhosted.org/packages/91/7e/e8aec0e6eaf93267450535c1be9c9ae63e1d9c49659c2ffdb52c19982114/fonttools-4.64.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:769fb64412ca237547ca73f111a64252d9e32c9d938bed51ed537bc9146a8f54", size = 5375327, upload-time = "2026-08-31T15:44:00.417Z" }, - { url = "https://files.pythonhosted.org/packages/61/d1/fa9ce5c1c3c0ef858a2cbe5632e9b6b137deca010b28d5d9a677e4aa89a7/fonttools-4.64.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e662f874ab2c7da9861584db44a13573e0936df087215f63013138f6e5eba083", size = 5338647, upload-time = "2026-08-31T15:44:02.62Z" }, - { url = "https://files.pythonhosted.org/packages/0d/13/e4d4fa3c166f7f5a8f9b6403ad9dcb3887cd05f8b9d2638bd2b43d2889ef/fonttools-4.64.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:2524a26f8fdb9051b0d778d052f5d238285ca9f91a7dc004514c7d6cf38d35f4", size = 5313557, upload-time = "2026-08-31T15:44:05.037Z" }, - { url = "https://files.pythonhosted.org/packages/91/c8/5a352d69608ea7606f677080ede971090fc7340b9f143c0b4fa00cfbf63e/fonttools-4.64.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:1e4e84b47839d35be24dbf476845a34f2ccf99707b66df125c1c414d3e86d25d", size = 5462363, upload-time = "2026-08-31T15:44:07.13Z" }, - { url = "https://files.pythonhosted.org/packages/4b/f1/b15b845f66b559a24a9c40859391bbd3048af3ac0fd04e45b57dca11c4c7/fonttools-4.64.0-cp315-cp315-win32.whl", hash = "sha256:be084d19a3ac0c8b2aba696680642d703118d3b1f18cf83f5b7dbaf0ffc62ab6", size = 2431682, upload-time = "2026-08-31T15:44:09.293Z" }, - { url = "https://files.pythonhosted.org/packages/c6/b2/909beff0d2e2e1adac896e36cff7f9d76fd154bcd57e303d8f09aee8f72b/fonttools-4.64.0-cp315-cp315-win_amd64.whl", hash = "sha256:de8acaa5f4160f537a3cf41b031171d51004b9f4aebfa6c194f18dffa9533d03", size = 2484393, upload-time = "2026-08-31T15:44:11.117Z" }, - { url = "https://files.pythonhosted.org/packages/40/47/06a51becf651cc071daa88e18ecb9f45ace9e3a570d8191ed8b3cae353fa/fonttools-4.64.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:5b90ad6637237b636d15c9ae8b7c4a7a1c194f33def378677e468c13fd4542f8", size = 3162235, upload-time = "2026-08-31T15:44:13.182Z" }, - { url = "https://files.pythonhosted.org/packages/dd/96/8b3faf58fd7ec3bb11943126658ad15b3f385068b23248deffccf2327ac1/fonttools-4.64.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:fa75c7970bc6bca340cc6e20f20f069201bfcb50094c31a536fd99724d1d01ca", size = 2613507, upload-time = "2026-08-31T15:44:15.123Z" }, - { url = "https://files.pythonhosted.org/packages/bb/3a/223d1437e72d79f1549be7bafb3cc08f397e1d9c354a241a8ec8573b7d33/fonttools-4.64.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:236e59bc7e2a63557a4d7b013f9cb9e28d9aebc45bc09f85e545e6bf091db626", size = 5518005, upload-time = "2026-08-31T15:44:17.359Z" }, - { url = "https://files.pythonhosted.org/packages/9d/9f/6f1a4b40ae533b9e907b7e627e397be632d0d9fd6f6be7756cf458870279/fonttools-4.64.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a515f664cad988f2295056833a59f62220bc3e46afdaffe389a29060f6712355", size = 5341654, upload-time = "2026-08-31T15:44:19.869Z" }, - { url = "https://files.pythonhosted.org/packages/52/f6/9ca30ba98730a22b527bcc1e02034f0b13b3be2ede764bb0fe8b8e0408d6/fonttools-4.64.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:5bfdaada437e7730c17d366bd7bb8c4a16639963ddbfc1b2f302a68a17a290e7", size = 5385994, upload-time = "2026-08-31T15:44:21.979Z" }, - { url = "https://files.pythonhosted.org/packages/09/27/baf1b61bff983bfec72cbb7b32162c4b68d76dc824aaaa48a1c26fa10b6b/fonttools-4.64.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:c60be0aed97a32c6ba8cee21f0d0477136e495451bd97910f589ac892db120d4", size = 5432407, upload-time = "2026-08-31T15:44:24.469Z" }, - { url = "https://files.pythonhosted.org/packages/21/ff/2eab37d43f2e2ccc0993959d8f2605d9a68470082c592684ac98611ee70a/fonttools-4.64.0-cp315-cp315t-win32.whl", hash = "sha256:f8669ce37851b597d3435b91fefa51139e58d506ca449ca0e5bb68c63b8b6d2b", size = 2463614, upload-time = "2026-08-31T15:44:27.198Z" }, - { url = "https://files.pythonhosted.org/packages/dc/8d/8bdff3ea656592197c8ef5062774221885468ffa01d8b0dc782dae23a83a/fonttools-4.64.0-cp315-cp315t-win_amd64.whl", hash = "sha256:89356c0793b474af7e49ec90d39fb2363e2341516a90460e38231df5ebe8acd5", size = 2512422, upload-time = "2026-08-31T15:44:29.478Z" }, - { url = "https://files.pythonhosted.org/packages/82/f8/7188153c4b265c899cd035de6a062677d51f67118a4ba640902bd9683e90/fonttools-4.64.0-py3-none-any.whl", hash = "sha256:4a05783ff54ce4c7a28f18e5772efdf63c219374bd9ffc55452182e1cef8be60", size = 1195327, upload-time = "2026-08-31T15:44:31.741Z" }, +version = "4.65.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/77/51/d63c7e52163ac14393a35bd14bd7c0da95f8f74be5d7cc988092f9965129/fonttools-4.65.0.tar.gz", hash = "sha256:762ba5431358d0dbd4a01982484a1d494fb267e91f974cdcf20b80eab8560f6f", size = 3674467, upload-time = "2026-09-10T15:35:54.955Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/db/242fa4fce7f632c5f7ab15585343393b25792510c0c32bd218ad24d59f1c/fonttools-4.65.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e844a45c9e5ced6536f184cf1a65b5d65e8f7e711993b413e10500a8223622e5", size = 3097120, upload-time = "2026-09-10T15:33:46Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b6/42fa4d373416675f74446421cf0b2badb82a4245c60745f05f424f75c649/fonttools-4.65.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b30e953de049bf43fc0a63c7d0c44d205c923e4bbf24716aae1518c0e65f977c", size = 2584658, upload-time = "2026-09-10T15:33:48.473Z" }, + { url = "https://files.pythonhosted.org/packages/75/6f/d589b9d62280a846c77a2c383d852c6dcb79ae8aa02bf0fa46c8577af145/fonttools-4.65.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09c34bdeed8915bfb53bee0c8ed2254dbd8ec69c0014b7f3702f347c049bf358", size = 5425737, upload-time = "2026-09-10T15:33:51.473Z" }, + { url = "https://files.pythonhosted.org/packages/b5/09/de2c0c20a42c18e565a2617932beb08c06697bbdd0d3f62b108262e11583/fonttools-4.65.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:05595385ae99f4b9626cebb973bf171b8fe38a8f40708e6e42abba0ed7537778", size = 5402463, upload-time = "2026-09-10T15:33:54.907Z" }, + { url = "https://files.pythonhosted.org/packages/79/2e/bc0f5c9dce21821454bb5812d3b23410bca33c8bbd5468386d0327aa0cff/fonttools-4.65.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d95b34dd68fbfc0e4a1740c421597656117f979ed8dc85de66e08f9f9981806e", size = 5362168, upload-time = "2026-09-10T15:33:57.481Z" }, + { url = "https://files.pythonhosted.org/packages/1f/0d/2116763ade7e71e0e5d421babe1785d745be9b3d605bf914792ce1c97f79/fonttools-4.65.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:924d06e6130429168318db71c40174a765ad016fc4b56ca811287e3d7373b3a6", size = 5524117, upload-time = "2026-09-10T15:34:00.021Z" }, + { url = "https://files.pythonhosted.org/packages/e2/5e/f9600553b9f645e3068553831685ff1dab6259536a23b38d2e048de38f17/fonttools-4.65.0-cp312-cp312-win32.whl", hash = "sha256:04f73dd01005752a6e75cf4a8dc6b70dc724d1d4bc34cc89522153f4a2f07680", size = 2432089, upload-time = "2026-09-10T15:34:02.803Z" }, + { url = "https://files.pythonhosted.org/packages/3a/02/e436a6a1863b9862bab9f82d6da33055dd7aa3738017edd902a163525dc2/fonttools-4.65.0-cp312-cp312-win_amd64.whl", hash = "sha256:3b5d9ba89edf778b376e669b879ae33a198bf45cf5a23c3f6514f935cf9d0d9d", size = 2483475, upload-time = "2026-09-10T15:34:05.09Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5c/343a4225e83eb06f82c1d8bf41fc5e5f71eab2f62bc7ca215c764722c0a9/fonttools-4.65.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8b7bb52817a24731d2e4f4df0e71fdde05e6c806c8f8f1517b015d142fdacfa5", size = 3094663, upload-time = "2026-09-10T15:34:07.235Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c9/49b2401be932741d9218181c08948c96db32eab21ecaaf79283b752e13e7/fonttools-4.65.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e2c21772fcf70325189707b19f346812690bb1b0bd7e207e6ac205244806b303", size = 2584521, upload-time = "2026-09-10T15:34:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/51/c9/48b07e6c5cf44fa56f758a04c3772a66c0e9ba82bbe22077e4076746a62b/fonttools-4.65.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:64c9b26816415b5e3d899e9077109d327b22140fe3c4066644d8cdbad5bb1569", size = 5395399, upload-time = "2026-09-10T15:34:12.38Z" }, + { url = "https://files.pythonhosted.org/packages/fa/2d/5cc5a10c8ed56079d6c2e9e3e5920622529a2ae045c9f47a6055ccb1a319/fonttools-4.65.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6dd6243f60e2d6160c2966e1e14020dc261ffd741b69a2e4ca8bfd051592e4b7", size = 5376659, upload-time = "2026-09-10T15:34:15.239Z" }, + { url = "https://files.pythonhosted.org/packages/ab/6f/ccf33739d936bb3afa1655a225be7ee5d63d6d3c8b7d0e570bc5a2a7b899/fonttools-4.65.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:834962fd7cf21c58e81ac50a59e6ed2306f9df5e3dd481dad1cd7d2c4c60b773", size = 5336795, upload-time = "2026-09-10T15:34:17.817Z" }, + { url = "https://files.pythonhosted.org/packages/7e/c1/ffd17483f2094f0f4118974295b514b5b82afd4f6e3c80c23f01684e97a6/fonttools-4.65.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:580eb68ff7bd6954a7a76afddd864bfc66eaaf5f5c20dd6ead9186d0055a4ffe", size = 5496530, upload-time = "2026-09-10T15:34:20.241Z" }, + { url = "https://files.pythonhosted.org/packages/b1/19/9aca7712d0676ba5f8d1530ce20478a9bb09cccd0153d56693337379cdcf/fonttools-4.65.0-cp313-cp313-win32.whl", hash = "sha256:7a18b2ffd44249fe84289253197aa65ad4f2de554c0d381f18b1f5939bc6bc60", size = 2430392, upload-time = "2026-09-10T15:34:22.906Z" }, + { url = "https://files.pythonhosted.org/packages/1f/6f/f015dea0f4354e0798751b657cea2dee482914737f88bf1a078349ce92cf/fonttools-4.65.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ae1846b0f192fd485d26a455af19b8f5cf05aff08f9836f533913d8fcea133c", size = 2481620, upload-time = "2026-09-10T15:34:25.816Z" }, + { url = "https://files.pythonhosted.org/packages/64/29/606365ef601668bfebed14cfe3dc72bb7fcd1e23011bbb2833f17fea3065/fonttools-4.65.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:dc87a9f846bec83c3795804f62b4632716d46e3522869a3dd9cd44a5d245b006", size = 3098393, upload-time = "2026-09-10T15:34:28.472Z" }, + { url = "https://files.pythonhosted.org/packages/c7/61/11412939d6b7abf5ac7ce0d61d7f94a0a4fbabc9f1ab0a04fa622e0fc11c/fonttools-4.65.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:aa50dd7b9baf75e2bbd43401fc0d237f7a94a8ad2e0c57ea97160fc631af5eb0", size = 2585766, upload-time = "2026-09-10T15:34:31.207Z" }, + { url = "https://files.pythonhosted.org/packages/db/17/734921d8aee8309801da42590375d32d4d46f771b73373ec9520d5d4220b/fonttools-4.65.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0d2a9892fdb3b7e2d0f4174e3b907d226ff83698249762eeefce08ec5b2de1dd", size = 5380679, upload-time = "2026-09-10T15:34:33.933Z" }, + { url = "https://files.pythonhosted.org/packages/cf/eb/2a4d78d60d978e694cfa04c98e4d8ddbf7f028fd768ddef470bb9da5d69e/fonttools-4.65.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6d815734e7fede0ad1f233f23f0f191cbe8fc64762ff041e589bc0f78e0b2397", size = 5321833, upload-time = "2026-09-10T15:34:36.295Z" }, + { url = "https://files.pythonhosted.org/packages/d9/ca/1cd48b5c11ef9658732787bf2362e1bf3871dad5945d2f6cc8f675ca769c/fonttools-4.65.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:71e4c67b6196a2f447f46476fd2302604721617f5e0a21b0988bdd87b6bb9687", size = 5320938, upload-time = "2026-09-10T15:34:38.992Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0d/90e6051bded926cccabe9dd0bce3b6ca012f4d5779d61167afbf4989ceb6/fonttools-4.65.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b11d8a4a0c3ca74bbd4c105b7ef82501945c939e6096d9934ec7d288cdf5aaa9", size = 5451747, upload-time = "2026-09-10T15:34:41.387Z" }, + { url = "https://files.pythonhosted.org/packages/18/74/23e0268e48029ff0752083f69312c49b738163d5af919add9dc4ac81e907/fonttools-4.65.0-cp314-cp314-win32.whl", hash = "sha256:8e44a34d91b3c793879767eb115867ced74d2eb94974e64e72fe9e2eea71cf1a", size = 2434246, upload-time = "2026-09-10T15:34:44.385Z" }, + { url = "https://files.pythonhosted.org/packages/a1/2d/ee69affecd4bc81cb932a213438d4199fb48bf8ca6d664438ccc7f623c2a/fonttools-4.65.0-cp314-cp314-win_amd64.whl", hash = "sha256:0aa8901db22875c831d6a91796549590d7e747da37438f38b69d771b668be445", size = 2486706, upload-time = "2026-09-10T15:34:46.842Z" }, + { url = "https://files.pythonhosted.org/packages/8e/9c/edee5f785198ce3327e1ddeace91c773122d47f086a67e0a84b800f4a940/fonttools-4.65.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:2e4a380ca40d3a5372e31b340f0da0d53b4583aadbb8e41f6a516afa69c509a4", size = 3172027, upload-time = "2026-09-10T15:34:49.269Z" }, + { url = "https://files.pythonhosted.org/packages/9c/c6/252ec9884381089bc30da75978b072593920249de60219817f16cbc9145f/fonttools-4.65.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:661bd91c4be13721408b2d4b67a9b3fa7736713adc9a6c9780c9c60fc7959f90", size = 2619020, upload-time = "2026-09-10T15:34:51.453Z" }, + { url = "https://files.pythonhosted.org/packages/42/79/f71b0d202b8473bb45b07876c08a474de9fe560ed2c0cde642812a81e22a/fonttools-4.65.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:62c5e42c79449def957adf8a9a65a43018efa7e2a6bc6baa3afe955e0d5fb2ab", size = 5545942, upload-time = "2026-09-10T15:34:54.804Z" }, + { url = "https://files.pythonhosted.org/packages/4a/bd/52e1bf33e0aebfe22ecc9a85c634db707c1dd9f6b1b438efeed98c55b959/fonttools-4.65.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:36fca8efc46b5adfca327c666e739fc05b7a7a6ef17840230f81b22f53230f61", size = 5351477, upload-time = "2026-09-10T15:34:57.514Z" }, + { url = "https://files.pythonhosted.org/packages/5c/76/8c6b2ad20beec95cd446f3a8bdc753c7e4a4fd69ef3e66704c0f7c8cb0b5/fonttools-4.65.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8aa1291e4c767abf1b0b79ca2d6895f7c0b661d9d95d03b5791c883a9d1e1f08", size = 5412271, upload-time = "2026-09-10T15:35:00.895Z" }, + { url = "https://files.pythonhosted.org/packages/79/49/fadbf11bbbd2d699d88a5498a0634280206e01e3bd5da9a4e0c504953ce9/fonttools-4.65.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fcf39949f56911348514b466714efa9118bec3d2be249e1c487263f7cda6edab", size = 5446450, upload-time = "2026-09-10T15:35:03.369Z" }, + { url = "https://files.pythonhosted.org/packages/df/77/5fda646d3a6d5ee26465865c00319cc0925cf484a3b42dd8232d5b39f973/fonttools-4.65.0-cp314-cp314t-win32.whl", hash = "sha256:ffc918702661f1d74d2fbb2f5551036b64f6d2d743139e105289b694bcd16f54", size = 2467858, upload-time = "2026-09-10T15:35:05.744Z" }, + { url = "https://files.pythonhosted.org/packages/ae/0f/afa0f3de70ebe02bba46b32cccb30b1de52624472b14ac2e7cd403d08db9/fonttools-4.65.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5a977e3645dbffaee924209828aa702a215f7ff68bc08010740c10c723787e62", size = 2518248, upload-time = "2026-09-10T15:35:07.846Z" }, + { url = "https://files.pythonhosted.org/packages/86/54/b273cf5712b36a381c13284fbf244e811e1e1d7081aed20f200f0a191ffa/fonttools-4.65.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:7aa0518b45ff5286ad56f063938db3add3816e899aab58d782b3f9a252523caa", size = 3092770, upload-time = "2026-09-10T15:35:10.868Z" }, + { url = "https://files.pythonhosted.org/packages/36/1d/d3e4511475954d4ec4f3c254e81f0fcc1ade504cb7381eeca48b8c44b8a6/fonttools-4.65.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:673e2b3ac4ac8e4f3607d390ecc5a606e5db5c4e88fb4cb2999593efb65afea2", size = 2584364, upload-time = "2026-09-10T15:35:13.54Z" }, + { url = "https://files.pythonhosted.org/packages/e5/3f/7cfaba467bdd1d3d04be21ba7b5bd75c6ca58ba280e0519707ca96a43c4d/fonttools-4.65.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a03cff943b204a90bf3d1c04c97b9509a8aa0ee99e2e544084ca43ad995975b", size = 5377819, upload-time = "2026-09-10T15:35:15.839Z" }, + { url = "https://files.pythonhosted.org/packages/25/17/a68d9b19a97bb2ee37e8098fea50657073df97c7e5392afbe1b9d7c0c581/fonttools-4.65.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:41f684ee6212e411196ab054f8308faf6605f154950e6f4686fb8f2103d624b0", size = 5341296, upload-time = "2026-09-10T15:35:18.527Z" }, + { url = "https://files.pythonhosted.org/packages/ad/8d/d744653ed607a241339015d4af6743ca3d85a74a2045a02cc06ea0383c71/fonttools-4.65.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:52ea9d2a8385075770db74d5e5718fa80b2222bb4fc62856a377dd2865ca8848", size = 5315310, upload-time = "2026-09-10T15:35:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c8/1ca6dc69cbaa0e394ff70d9e266777124d3ce3c6433026a6b4de50b890ae/fonttools-4.65.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:d0d25027ade65ec46b13c0436e51bcb7c5171a4ea255a5e7a8d0d1d3ab4cffd7", size = 5463840, upload-time = "2026-09-10T15:35:24.022Z" }, + { url = "https://files.pythonhosted.org/packages/07/97/d374df38a14f2ac04ba9ed96bca89d4988e7d63aa5ed85c54fd8f2badd7d/fonttools-4.65.0-cp315-cp315-win32.whl", hash = "sha256:22cb846d35d278235ef3b7e947c6040b2057d72e8305a314f21d5342eca49040", size = 2433149, upload-time = "2026-09-10T15:35:26.59Z" }, + { url = "https://files.pythonhosted.org/packages/62/c5/eb8f7506faf6a70c5a8f2eccbeea3cd826c748a6fd78c7b4b3effb5a3a11/fonttools-4.65.0-cp315-cp315-win_amd64.whl", hash = "sha256:aecc899fdbf9ecbf728f8977977e2e1043ee4d70c257124c8fa4cbcf796fcd83", size = 2485725, upload-time = "2026-09-10T15:35:28.945Z" }, + { url = "https://files.pythonhosted.org/packages/f1/a4/2df0d97514feb8d857d5de854cd8d660d9a7ee1fd081bc98497124f515a8/fonttools-4.65.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:6275863dad195ee34b6e0ca3fc61c74096bc37e5d6fb8e049f4d68d65865a2b7", size = 3164065, upload-time = "2026-09-10T15:35:31.197Z" }, + { url = "https://files.pythonhosted.org/packages/15/33/e09661c09e6c8a3b0bd50da0e72918df7576dede31f39c948cc245011434/fonttools-4.65.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:d8ffd2f62b402180b0edae8f86a071f583970e2177143117db5cf4c52da60079", size = 2615195, upload-time = "2026-09-10T15:35:33.569Z" }, + { url = "https://files.pythonhosted.org/packages/64/d7/114b05f4193679d0935272220083ec43de7f918b5a777018c5ac5c1ae39e/fonttools-4.65.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:830f91327ca83bfc1278e7060068a498938f84d05dc4869675486f84f55d4fe1", size = 5521239, upload-time = "2026-09-10T15:35:36.291Z" }, + { url = "https://files.pythonhosted.org/packages/ba/10/67d615939f859ffe75663a67bca3593966febbcd0109ec72f20f73cbb4cc/fonttools-4.65.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9db2cb95847c18eef74a4ef0fe257a893ae3f4b0395f4866e2f426ab07f3d804", size = 5343802, upload-time = "2026-09-10T15:35:38.82Z" }, + { url = "https://files.pythonhosted.org/packages/d1/06/faa793a806da03acce862fbed353f76026b28103d43860d69be9a6a1f0fd/fonttools-4.65.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:be9b9a95ed0af03375e99020e921c4bc6b41fad10e053dea7acad370521a3c46", size = 5388482, upload-time = "2026-09-10T15:35:41.616Z" }, + { url = "https://files.pythonhosted.org/packages/53/d2/eb7258df60e634db60c9a8cd72bc9eaf8dea409d1b1ceec3b9fb49531ad2/fonttools-4.65.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:bbd9faf777a9deb6790df4f2b0be611857c45fe86605e840d7154a028d828af7", size = 5435088, upload-time = "2026-09-10T15:35:44.639Z" }, + { url = "https://files.pythonhosted.org/packages/00/6a/58597f16e1265fe9205de3069e338a339e3eef0b1daf049ee08269458091/fonttools-4.65.0-cp315-cp315t-win32.whl", hash = "sha256:c779d838815b91889c95ed64c9be5950ad5a683279f91aeb23384cb757ddc6a3", size = 2464925, upload-time = "2026-09-10T15:35:47.224Z" }, + { url = "https://files.pythonhosted.org/packages/4b/95/122fc172006db747f4968e08c710f52a94f55eb007173b859b3f80b5b810/fonttools-4.65.0-cp315-cp315t-win_amd64.whl", hash = "sha256:d9484b7ee1b49b6b8a0231c849f3983723dec29e3a7366d9b1b02f4036f71944", size = 2513945, upload-time = "2026-09-10T15:35:49.895Z" }, + { url = "https://files.pythonhosted.org/packages/e6/35/f894ceb867118c0261d0f69a9bd516b045a3754238f76c88a49513ac7a83/fonttools-4.65.0-py3-none-any.whl", hash = "sha256:3060b8c1fc2329fa20265b7c138614143ea7c1624e26c5c180c76aeb74deae6f", size = 1196441, upload-time = "2026-09-10T15:35:52.347Z" }, ] [[package]] @@ -1105,7 +1123,7 @@ wheels = [ [[package]] name = "matplotlib" -version = "3.11.1" +version = "3.11.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "contourpy" }, @@ -1118,43 +1136,50 @@ dependencies = [ { name = "pyparsing" }, { name = "python-dateutil" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/49/64/f9a391af28f518b11ad45a8a712353c94a0aefce09d3703200e5c54b610a/matplotlib-3.11.1.tar.gz", hash = "sha256:69647db5746941c793d6e445a4cd349323ffb87d9cc958c2ad84a659b4832d30", size = 32612045, upload-time = "2026-07-18T03:39:46.63Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f2/6c/7ef7ebcb2bd9739b2b66b18b076e077f44bb46fdbe28ca0506edb3c62c79/matplotlib-3.11.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e15ef41507f3d525f46154ac9e3ae785dacde9f20e593a25de8986267892ef74", size = 9453849, upload-time = "2026-07-18T03:38:19.593Z" }, - { url = "https://files.pythonhosted.org/packages/eb/f8/6d0c312c8d9738e7d9677f09fe5c986b3239e651a7b73a2deb38b65e4a71/matplotlib-3.11.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:21a67b961a6d597bca54fae826cd20695ba4a6e4d05424a08da6e13e3176fd6b", size = 9283113, upload-time = "2026-07-18T03:38:21.95Z" }, - { url = "https://files.pythonhosted.org/packages/c9/cf/b4ad2cc81b6672ea29ea04e64e350a9f9b493b0908ccd884c67eeff8f7b2/matplotlib-3.11.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba8f811b8ddfac493734d6af0b2dff96919d0c28ca0d641858dab4262777c6ea", size = 10035615, upload-time = "2026-07-18T03:38:24.315Z" }, - { url = "https://files.pythonhosted.org/packages/88/90/4e10e033d9b66589d8ed98b84c95cdbb57033d57c1f41339d7393dbd2f2e/matplotlib-3.11.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c52f7ad20ef476806ed212380b1d54d20310c8b86bdc2c9a68b51f0024a44472", size = 10842559, upload-time = "2026-07-18T03:38:26.285Z" }, - { url = "https://files.pythonhosted.org/packages/88/eb/799612d0f8cd3e816a10fec59329fca52cd2353264df80378dfc541ae855/matplotlib-3.11.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8b14eb22961fe865efb0e4ff167e333e428908b00115a8d800ccb65ee108e481", size = 10927532, upload-time = "2026-07-18T03:38:28.532Z" }, - { url = "https://files.pythonhosted.org/packages/88/89/56649bbaa2fd12e20f3be03dbcc135b0c8676d88bac17977599e3eb442a0/matplotlib-3.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:88a2a27dd9691ae448dfae4b26f59036be90c3c28757edd3553a29559d00859f", size = 9333886, upload-time = "2026-07-18T03:38:30.477Z" }, - { url = "https://files.pythonhosted.org/packages/c1/11/4d124efbbad677b7b7552f6f85a3bd432d4232f95400cea98fcd2ae36ef3/matplotlib-3.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:480194afceca4df2f137c2721227d3cba67121fbf4397b69cee7f83714b0a58a", size = 9007545, upload-time = "2026-07-18T03:38:32.833Z" }, - { url = "https://files.pythonhosted.org/packages/04/6c/4798363b7fb5644e309fe1fac30216e9146c9f70859d80d588c18caf5317/matplotlib-3.11.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6771b0cd7838c6a857a7209814158c0ad09bfef878db3033dd82d70ad101f191", size = 9454341, upload-time = "2026-07-18T03:38:35.001Z" }, - { url = "https://files.pythonhosted.org/packages/59/98/6acadbe7f98df19d274bc107ac58bb439fa75df82c33dc110d71a4a8501f/matplotlib-3.11.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2abdee5ffa2fe11b2d19f7a5c63b785fb7c28cc46c7bc1814156341d9d1a33e1", size = 9283627, upload-time = "2026-07-18T03:38:37.061Z" }, - { url = "https://files.pythonhosted.org/packages/24/ea/65cec46fe241390ccea1b1754207ee28eb71c5ab866bd5f22fe47e538fa4/matplotlib-3.11.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0a19dcf73406d3746d25a5ed42d713604c9a3e024d129b102852b0d941cb9f3", size = 10035860, upload-time = "2026-07-18T03:38:39.663Z" }, - { url = "https://files.pythonhosted.org/packages/c7/10/63fdccccbabe002fb0960876baabc5e3f24d9c1bb4cfb25651457f74b3a0/matplotlib-3.11.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7389b77ed2ab0552f46d9a90b81b7b8e6dfcdc42adc36c37a0865799843e0e3e", size = 10843594, upload-time = "2026-07-18T03:38:42.144Z" }, - { url = "https://files.pythonhosted.org/packages/98/51/a1155945bff7b91381875022ac1522c5dfdac0d006be8e7df389b3134eae/matplotlib-3.11.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c90be0b73568da4f662afac580956a76e308437e641b4a45aa08925eeb67d95f", size = 10927962, upload-time = "2026-07-18T03:38:44.302Z" }, - { url = "https://files.pythonhosted.org/packages/0d/3a/3d5e1f42dc761bf53401a62a83ff93389b37de9d2c093b2a3aa49ac34f1b/matplotlib-3.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:68408341f2312836fbbdf6b3c78047f65b2d8752f5fd221c3e72d348f5b34f8b", size = 9334074, upload-time = "2026-07-18T03:38:46.616Z" }, - { url = "https://files.pythonhosted.org/packages/e2/db/3f5ea5a5b64060ef5e1ff60a19170423e41ce21b8497a6fe15a36e0b43e3/matplotlib-3.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:0c1f44890d435c1b4ef52f701ad5828cb450ea97bcc83918fda6be74965d6cd2", size = 9007662, upload-time = "2026-07-18T03:38:49.112Z" }, - { url = "https://files.pythonhosted.org/packages/98/6e/c7ae5e0531425b69c0826b00ebbc264c85cab853f1cd6e096c9983c2cdc1/matplotlib-3.11.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:5e510088c27a89d53580a752f959146893563e63c330e161d159b0fee652af6f", size = 9503790, upload-time = "2026-07-18T03:38:51.527Z" }, - { url = "https://files.pythonhosted.org/packages/92/79/15be162e0a2ed546939674e2e97d0e33ec2447d86d4d4e611fa295bb178c/matplotlib-3.11.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:1524e2bdd48a93557aa47ddcfe9c225dfdd57d5a01a5c49128c20f0632980ee1", size = 9336148, upload-time = "2026-07-18T03:38:53.564Z" }, - { url = "https://files.pythonhosted.org/packages/6a/7f/36ffe144fc4aacfe0e3ed2318f72b6755d1e73b041d619b4d393e60f5a66/matplotlib-3.11.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:11664c551345553db92e61cae6cf1376f138f8c47cafdf13b64b18f3e3e9e464", size = 10049244, upload-time = "2026-07-18T03:38:55.911Z" }, - { url = "https://files.pythonhosted.org/packages/ab/5f/55812d68c0a840d3a463638f48c00ab1fe338518ec49a640cb6473b444af/matplotlib-3.11.1-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e1f8922ba31959cf6a9dfb51be64b7f7bc582801a3957dc0c2f3afcd3537adf", size = 10860798, upload-time = "2026-07-18T03:38:58.282Z" }, - { url = "https://files.pythonhosted.org/packages/7a/64/cca444b4eb5e6c768c44fc5e1f0b5211f20ca2b282778051996e996a2bdf/matplotlib-3.11.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83235693abde86e5e0129998f80ee39fc7f58e6d56a88fafb28a9278833e9d5f", size = 10943282, upload-time = "2026-07-18T03:39:00.465Z" }, - { url = "https://files.pythonhosted.org/packages/e5/0f/a49c329d394f2e9ef38506982107e8b04ecf94dd41a9d8423ff82cc737c7/matplotlib-3.11.1-cp313-cp313t-win_amd64.whl", hash = "sha256:9a076f4fc5cdc43fdf510f5981418d25c2db4973418d9f22d8bb3dc8045ada78", size = 9383532, upload-time = "2026-07-18T03:39:02.468Z" }, - { url = "https://files.pythonhosted.org/packages/e4/50/103e86afb806d8f64d04ede14e4cfc09dbfc25f512421ff85fdd6ebd59cf/matplotlib-3.11.1-cp313-cp313t-win_arm64.whl", hash = "sha256:216fbb93a74add02ddb4cb38ef5348f59ac00b3e84567eaf16598772d40e150a", size = 9059665, upload-time = "2026-07-18T03:39:04.607Z" }, - { url = "https://files.pythonhosted.org/packages/35/04/3079499fa8cb661ea66d13d6439d5a3ae6710a7afd5c7f72e08914f275f8/matplotlib-3.11.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:30c492d4ba9448595b6fd8708c6725963f8148e25c0d8842948da5b05f0ee8d3", size = 9456022, upload-time = "2026-07-18T03:39:07.041Z" }, - { url = "https://files.pythonhosted.org/packages/53/a2/69acfe84ec1f32930e801a5782a07fc5c79c8c6599a507b806d859d5da8e/matplotlib-3.11.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ac104be2768ffdd8655db9e71b768cbb45f2b9aa7b450cf1595e8f65d3822319", size = 9285475, upload-time = "2026-07-18T03:39:09.562Z" }, - { url = "https://files.pythonhosted.org/packages/d3/b3/31b15a2ca56d4ddd6aaa1c884c2f51cf9a61cfaf5ca6f6fbd6343d38e6df/matplotlib-3.11.1-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6be943cb68bc6660ead58c55b3aa6366cba2ef7feb06460fbcce32360376f19f", size = 10847102, upload-time = "2026-07-18T03:39:11.532Z" }, - { url = "https://files.pythonhosted.org/packages/64/0d/a17e966e620545c1548125af0b29ac812dd17b197a18a7462ac12fa859ee/matplotlib-3.11.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5af0dcda57d471440a7b5b623e70e0a61003518443d9098f211a96ecfbbc25be", size = 11131087, upload-time = "2026-07-18T03:39:13.764Z" }, - { url = "https://files.pythonhosted.org/packages/97/c5/5e100efdd67abb7de20befaa333612ef9bfc63417fb71398f904f25d083c/matplotlib-3.11.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3d3fd84082b1afbd9398466c81309e20045be20d48fe0fb18c43504d164cbbb2", size = 10929036, upload-time = "2026-07-18T03:39:16.888Z" }, - { url = "https://files.pythonhosted.org/packages/ce/04/d719a0a36930ecc8dfc801ff340f9dcfc4223f8ca5d39d06b4020032fff8/matplotlib-3.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:9601a1e90be21e4884c53b4f3dc3ee0544654946f9975258d691f1c2e2f119c6", size = 9489571, upload-time = "2026-07-18T03:39:19.449Z" }, - { url = "https://files.pythonhosted.org/packages/48/65/facabdc2f1f6caba7e856db64dfedddca25f7608df07d96a1c8fd114fd3b/matplotlib-3.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:ae30c6109848ac0f9fa36c5d6270938487614c47ba31860bd5361266dabc5685", size = 9164486, upload-time = "2026-07-18T03:39:21.424Z" }, - { url = "https://files.pythonhosted.org/packages/88/dd/18da6cd01cf96354534f98c468a25380c68ce582a2c9dd0cae12b04af4f2/matplotlib-3.11.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:dadfe80797174e2984aae3be0b77594a3c72d2c0a40fbd4a0de48d2728caf3ae", size = 9504876, upload-time = "2026-07-18T03:39:23.633Z" }, - { url = "https://files.pythonhosted.org/packages/79/b0/f0b63555a18b79d038c81fd6126f35fc4dfce0eaff48d96103348c7cf935/matplotlib-3.11.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:89b193b255f4f6f7948dbcee3691f4f341ab05d9a8874a67b45ddb4182922eda", size = 9336120, upload-time = "2026-07-18T03:39:25.797Z" }, - { url = "https://files.pythonhosted.org/packages/c6/dd/f210ec7c4a6f198d5567237048a93d0811fb5a1f1691f13320e592f95b41/matplotlib-3.11.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:191163532cdefcb1571ca38a6d7e6474baccde64495783e6ba47aa07ec4b9bbb", size = 10858033, upload-time = "2026-07-18T03:39:27.999Z" }, - { url = "https://files.pythonhosted.org/packages/ec/d2/d6d5324507c5fbb316db48e258c09c2807f3de03d9af47017e120070926f/matplotlib-3.11.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9fdf1c818ab05d0e74002091ddaf414478a3a449ec9d51c8976d45be7e3a01e2", size = 11141827, upload-time = "2026-07-18T03:39:30.092Z" }, - { url = "https://files.pythonhosted.org/packages/0f/68/3c22e9320bdce2c4d2f1320643ef706db7a24cb7420eea28b97a2d67f5a8/matplotlib-3.11.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b937b9dba5f5f6c1e31c47abe2186c865c0914fd18f2ce0dfc39c9adcef5951d", size = 10943061, upload-time = "2026-07-18T03:39:32.356Z" }, - { url = "https://files.pythonhosted.org/packages/f6/4a/907ed190ee81a9df581e0ed5456134fc0f7cb55ffcfda2f9e54ca900761c/matplotlib-3.11.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f2912f647f3fbe1ccf085f91e213936f9101bead81a5e670565b1f1b3712f4fb", size = 9540074, upload-time = "2026-07-18T03:39:34.789Z" }, - { url = "https://files.pythonhosted.org/packages/23/d4/97c19b77e0a6e3b48581185bb65088f431cd20186076cc0f650a1757ea46/matplotlib-3.11.1-cp314-cp314t-win_arm64.whl", hash = "sha256:54d47b8ae8b579633a3902ca5b4ad6c1e132a5626d64447b2e22a66394e79987", size = 9213472, upload-time = "2026-07-18T03:39:37.141Z" }, +sdist = { url = "https://files.pythonhosted.org/packages/e7/c8/9aa712a0afb882649424dd8de8ad9aa6235e796e84c6052e8f6dc1598d0d/matplotlib-3.11.2.tar.gz", hash = "sha256:cec596316640f2b394b8f0daa0ea61a8eae82d017b620b9f202befb972a59ea4", size = 32660610, upload-time = "2026-09-11T19:05:31.214Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/ce/1bfcc4873b121597791ad74032943b123218c0613af0b97e8dd05e916fb1/matplotlib-3.11.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ef752769cd962f39ea0b6ffc82d1ea43a0012c5a6157c7a075212fa509cfcff2", size = 9476466, upload-time = "2026-09-11T19:03:19.45Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c4/7f5f3601ee69baf072c0c7d3ce60c03e0618621c5a56c34a62a460e29d11/matplotlib-3.11.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ef31985c4dedb5f1424e1aec6849a47dd37689cb7fa3c20b1b82187f26806261", size = 9305583, upload-time = "2026-09-11T19:03:22.39Z" }, + { url = "https://files.pythonhosted.org/packages/b8/90/2b3fd67ee273163faeda6d514be70b5596eaa0fd77b60ffc294ad0b34f5f/matplotlib-3.11.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:df4f7784aca81a94f254c0a2767d592ee25f407e488f5fa7203e51093fb6ca27", size = 9860353, upload-time = "2026-09-11T19:03:25.049Z" }, + { url = "https://files.pythonhosted.org/packages/f4/84/32549e7a462dc311aed2ab62e5d2538028840b5c53a8be0195c789937c3d/matplotlib-3.11.2-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b9a7ad579856284135e401ecc918c5f8a017ee30539298862a109f51b971710", size = 10670348, upload-time = "2026-09-11T19:03:28.108Z" }, + { url = "https://files.pythonhosted.org/packages/84/39/02e21b74f7439bd643d717ea846006d46e309e6d29b632b57751265311d6/matplotlib-3.11.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3aa4b8516fd26659e4363abbf317c703d9116496c5db2e9d0609a2866dd39dd2", size = 10810580, upload-time = "2026-09-11T19:03:31.402Z" }, + { url = "https://files.pythonhosted.org/packages/04/93/0d239bde12b308262265c2d98909b2f0ecad2b5deeae96241642e822e9c7/matplotlib-3.11.2-cp312-cp312-win_amd64.whl", hash = "sha256:c5c1c68ee401fc98271263410f0e5ce88285abacf7627132914e8adf3d70ff43", size = 9349409, upload-time = "2026-09-11T19:03:34.195Z" }, + { url = "https://files.pythonhosted.org/packages/49/a8/06baf901c02246c8a222b655cc4540ef9c15e1549a04e07927f9cde716c3/matplotlib-3.11.2-cp312-cp312-win_arm64.whl", hash = "sha256:643ff850d8e0f5b8319337f87ed3cb59506afb3df3cc48de777d85871233be7b", size = 9028084, upload-time = "2026-09-11T19:03:37.032Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ce/fc58855a3d17f6cb8a87b6f9ccd100f65432a3a7ffed57309cbf14c78987/matplotlib-3.11.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7d43ff8cebb50840648cb6429b2228621dbd709010f3117b3740abb20abf21c0", size = 9476987, upload-time = "2026-09-11T19:03:40.17Z" }, + { url = "https://files.pythonhosted.org/packages/a9/29/2a47b700545aca050e0ed73c89ba21e08407e11f5f42a567421b220de6c1/matplotlib-3.11.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2a8285cea8ef4d92aa041d1c33788bcae82248503300f93f1ca2136b9049452f", size = 9306050, upload-time = "2026-09-11T19:03:43.103Z" }, + { url = "https://files.pythonhosted.org/packages/a9/df/e7c10292f348cf55178a5b3c0092a38ea68891a3945f199ae8b7b8ac9dc1/matplotlib-3.11.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1944895967f87c84c9b4bad29a707b31f5b36df4a3a2339ea1f8ea3ce5105539", size = 9861060, upload-time = "2026-09-11T19:03:46.044Z" }, + { url = "https://files.pythonhosted.org/packages/e4/b9/b978de6d43d47f1d4d8e653fac32c16d8d2e5f46bbbb822e26d7cb1adece/matplotlib-3.11.2-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af2661f6ac6bbd1d081996f54fdd9385715c625ace8cec0869055c0cfbf38981", size = 10670885, upload-time = "2026-09-11T19:03:48.942Z" }, + { url = "https://files.pythonhosted.org/packages/a3/80/d72f61bb2631ac15d17fada1f17e0f99fecba69d8376d34f17cf93b7eddd/matplotlib-3.11.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7e5a90f8a707ebb6004a713b1cff091a40cc5df4c7c1cb165e5a505ebc11c292", size = 10811222, upload-time = "2026-09-11T19:03:51.665Z" }, + { url = "https://files.pythonhosted.org/packages/94/2e/6d1d33f242c705b5c6c6fb3f0fc141add51cb1abb62912e59de0835d28c4/matplotlib-3.11.2-cp313-cp313-win_amd64.whl", hash = "sha256:bc067c462a86f0e57bf52fc6e058d90171a5420007dac00c46e90153050c69a7", size = 9349539, upload-time = "2026-09-11T19:03:54.534Z" }, + { url = "https://files.pythonhosted.org/packages/bb/bb/c0aa86a7f4c0e62f1c3c0711e361f6f23f87eb9018732a5e11994bd1b7ec/matplotlib-3.11.2-cp313-cp313-win_arm64.whl", hash = "sha256:3e8576f7c47e02fd4f21f44171302d2d1d58d4471d46da3d71fe8899d19539d9", size = 9028295, upload-time = "2026-09-11T19:03:57.261Z" }, + { url = "https://files.pythonhosted.org/packages/54/b4/4facdb700bc236e4c676495ca3798d8134ab8668cbfe0f6b2e9ebf962a38/matplotlib-3.11.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c9721f81275499da1feeb36a2cf8192ea086283b3bd16b7dc4c9d7aedb7396d6", size = 9478976, upload-time = "2026-09-11T19:04:00.12Z" }, + { url = "https://files.pythonhosted.org/packages/4c/a0/bba05f0a25bfeb0475c2f2a87958b31103aa6b7a5386017afb1a96212825/matplotlib-3.11.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1a3040b209f3968b4e84161df7b174f07a9fad33b0f2d7e48ea3bbd3075e2863", size = 9307932, upload-time = "2026-09-11T19:04:02.976Z" }, + { url = "https://files.pythonhosted.org/packages/d4/42/81d5cba4bb39b41b0998efc880e129f2d7cdb94256ca49678fdcd9c21be5/matplotlib-3.11.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf3fe71fbfb8ec0e310e0bc8537c3405a01f38f25f9394ed2135e6202fed542b", size = 10674370, upload-time = "2026-09-11T19:04:06.912Z" }, + { url = "https://files.pythonhosted.org/packages/29/5e/52f56f93d5b20815ee0ae352f7a38eff25580edb180b4fa7df87cfeba68f/matplotlib-3.11.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8c8255de28f986d935a64c9ca71c0ec2d2f41d355691f5ea684725dc91413f71", size = 10954597, upload-time = "2026-09-11T19:04:09.948Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ae/f8918a1b564db49c53cd603eb3c8748c5767e4ce0fb2cf1d7c38653e4c5d/matplotlib-3.11.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a8756cc73d9af9a7fe0deb54ea2e75ef73b01d9e575877e72acad5458e660943", size = 10812583, upload-time = "2026-09-11T19:04:12.887Z" }, + { url = "https://files.pythonhosted.org/packages/ea/61/4315ef0d63937fe56f451887b4a0be3b8e8b22cf1d92a8d157caac54570d/matplotlib-3.11.2-cp314-cp314-win_amd64.whl", hash = "sha256:ecea603dd2fbf8242fd31a305a8b12a4ece2de28096870c65fdd0d1e35b8d9a6", size = 9505972, upload-time = "2026-09-11T19:04:15.788Z" }, + { url = "https://files.pythonhosted.org/packages/d5/00/02398b0a1a62ef73d9af0a957fe1773363eec9a6ca7e433c72ae2790fbce/matplotlib-3.11.2-cp314-cp314-win_arm64.whl", hash = "sha256:01dc8eaaab5a9fce9ff615eca82345728f289e4715b186ee10c6d85272fc26bb", size = 9184534, upload-time = "2026-09-11T19:04:18.691Z" }, + { url = "https://files.pythonhosted.org/packages/ec/c5/1e6ca10baa7e04f113c37856aadb4adc3dbb1c55fc7da6dc830bba1292d7/matplotlib-3.11.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:79a258f58253dfa025af80a9e9bb228d75fced007f0e93ae7423fefbde81a74d", size = 9526415, upload-time = "2026-09-11T19:04:21.39Z" }, + { url = "https://files.pythonhosted.org/packages/e0/93/7561727af07ccc84747953c6a33eee3981cc436d04f465032e707ca0e429/matplotlib-3.11.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c0b83f044ce10a98027b105b3931548719a6e8c7ef986b4362651e0b5367c8dc", size = 9361064, upload-time = "2026-09-11T19:04:24.107Z" }, + { url = "https://files.pythonhosted.org/packages/c1/40/ce270ef2a6794d94a409fe28b8dabedffc07c07f9e5dbb89e0f605bd157d/matplotlib-3.11.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e43b188f0a5b75447bcc197728258166aa64365770ed1caa36595a5e1ca4bbba", size = 10684626, upload-time = "2026-09-11T19:04:27.201Z" }, + { url = "https://files.pythonhosted.org/packages/45/46/396e0307dbf1c1f2d0a3654caa6dbc780dd5379f5f11257369cf8d21d9fe/matplotlib-3.11.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3304eb5a59442a8867f6920d484591c0fa09ffc29e9260be2feec3351e25869", size = 10960602, upload-time = "2026-09-11T19:04:30.254Z" }, + { url = "https://files.pythonhosted.org/packages/1c/97/4defb84695477340aa88b27c9482cc1ca4de11f36f66b6c8c0ddd685def1/matplotlib-3.11.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:02329432ae5c6af87cf208ee575b701d698bdf0b1a3bb28cc6d53c36e967e575", size = 10822603, upload-time = "2026-09-11T19:04:32.964Z" }, + { url = "https://files.pythonhosted.org/packages/7d/e7/eab54551c1ec6b72dcd678a078b6c6da8d4c85ec1ff0016e81fe52866304/matplotlib-3.11.2-cp314-cp314t-win_amd64.whl", hash = "sha256:f2ac30cf5eb5dff1b584627ae0b0e1186551a4f69ae3c75073911da497a29170", size = 9551206, upload-time = "2026-09-11T19:04:35.811Z" }, + { url = "https://files.pythonhosted.org/packages/4e/0e/04698032cb4d8fb1e30d8ffec5ded20f6f582b03c8c58b2385c95245f158/matplotlib-3.11.2-cp314-cp314t-win_arm64.whl", hash = "sha256:cf41ecd1b0c0b6f7177ed965a54c2afbe888715c7cf6054dc12d53bc1494002c", size = 9234977, upload-time = "2026-09-11T19:04:38.972Z" }, + { url = "https://files.pythonhosted.org/packages/44/a9/ca827c184b87364378964e36e7c0ae23651d146fdbc4000635205490cf82/matplotlib-3.11.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:894a9cbbecbe30ae6787d464df2e8fc7a8d475cfc68f87c3029f7c11152899b3", size = 9478997, upload-time = "2026-09-11T19:04:41.914Z" }, + { url = "https://files.pythonhosted.org/packages/48/60/01aaafc9c3159f3fae9a65bbcddaa4a6d4d72b0aeffdd636d7f6d00a5c8d/matplotlib-3.11.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:bbf1062991d826ed27e2144f3afa4461afbb8ff56e8f703043e191a8163b1ee9", size = 9307947, upload-time = "2026-09-11T19:04:44.834Z" }, + { url = "https://files.pythonhosted.org/packages/1e/a0/6aa72c7cd7cf4dfac652744d7a3310007cec3ce8e5ab9be607bec7096471/matplotlib-3.11.2-cp315-cp315-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:399fef672f7046ef7d6a57572b2a6f9845f3f5afcff04e7b2df7a363a9f42190", size = 10674370, upload-time = "2026-09-11T19:04:47.745Z" }, + { url = "https://files.pythonhosted.org/packages/a1/97/d7e90225ac145046787a2ee0fa4cdc7e4d5cb6772ea232130b10f8a4095a/matplotlib-3.11.2-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc82dde2a0d3e3ad472edce04897ad7146b8d8bfd1df8a32992eebb81af18fdc", size = 10954581, upload-time = "2026-09-11T19:04:50.712Z" }, + { url = "https://files.pythonhosted.org/packages/58/18/89cf056a9d2cae01f4b8baf01c7e809d613244fcdfa2a2acf28c1e0d79fa/matplotlib-3.11.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:930efb28f59fda124e39265d177bab302625297bb147d2910de725a2fc2aef54", size = 10812605, upload-time = "2026-09-11T19:04:53.552Z" }, + { url = "https://files.pythonhosted.org/packages/9d/4d/c61b9f4c34af802d4d84e58803e009013d626b5f468bafe1416131863b5b/matplotlib-3.11.2-cp315-cp315-win_amd64.whl", hash = "sha256:3da3bc0cbf7245e7db72cc6d29d12c5abef72cb73059c73b945f14e3545f3eb2", size = 9506068, upload-time = "2026-09-11T19:04:56.519Z" }, + { url = "https://files.pythonhosted.org/packages/03/7b/047f2fa8708d47430d8e7fa45e9fffb0aee5d4e300f978e087be2ee11fbc/matplotlib-3.11.2-cp315-cp315-win_arm64.whl", hash = "sha256:f25446b2981717dca9786bac841cb3fd7efb568e3e3c755dd980481c5cb9228d", size = 9184576, upload-time = "2026-09-11T19:04:59.318Z" }, + { url = "https://files.pythonhosted.org/packages/03/6e/ad9c5989950785a98642667df265a47c6637e924cb69b5dcf68c3299ae7c/matplotlib-3.11.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:fea03cf56568cc1cba08b470be6a0559e71c3a5b688d54b7179bb35ba23d0821", size = 9525988, upload-time = "2026-09-11T19:05:02.304Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c3/25c61701fb655dd412428b15eee2591ce554cdd593e39a045a153373f428/matplotlib-3.11.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:254d4ddb2fa8df3b4c689c0c306063aee10521df82cfb438185e499c75fe37c1", size = 9360774, upload-time = "2026-09-11T19:05:05.092Z" }, + { url = "https://files.pythonhosted.org/packages/58/5a/4552878fce8f9d249a5e264c16f5c267c27eac08fb039fa3e207a06feff5/matplotlib-3.11.2-cp315-cp315t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e60cf3047a51edecdc4535a9196bbd6a732936b8e9f8184aabf4d16165884aaf", size = 10685892, upload-time = "2026-09-11T19:05:07.686Z" }, + { url = "https://files.pythonhosted.org/packages/af/dd/b3b19ec0124fc4aafd8a4b3bae859c562a7ff0fd8ae3b2099947f78bde19/matplotlib-3.11.2-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eb3712dc9b464793de0a4e42a7313d50293c751f94bddaf7332a1bc71bccdda9", size = 10964946, upload-time = "2026-09-11T19:05:10.943Z" }, + { url = "https://files.pythonhosted.org/packages/7b/30/687ccce22f66a57fed85942450e88062773bcbf1a42914e70c7148ec71dc/matplotlib-3.11.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:75b6d88402770e181b5d06a67dda4129c31da7d05004d63a21c310ec78d1b83c", size = 10824960, upload-time = "2026-09-11T19:05:13.9Z" }, + { url = "https://files.pythonhosted.org/packages/d3/34/117fe35a8d05054b4b34d2d29287099927c24c3841d36e06d9fa2f20c1cf/matplotlib-3.11.2-cp315-cp315t-win_amd64.whl", hash = "sha256:a6939df7567114b6bac7f4c5e06c84a67f197c1b2f2e4b234d4eecb3bfec9482", size = 9551204, upload-time = "2026-09-11T19:05:16.48Z" }, + { url = "https://files.pythonhosted.org/packages/63/5a/9f440e7bec8b80d0af2a65d1165b2f4e718982dad785531f62255d9ff19b/matplotlib-3.11.2-cp315-cp315t-win_arm64.whl", hash = "sha256:d480038c83691532ed52ff3147db51fa902fc78cb2d8349993a1cdb684435bff", size = 9233946, upload-time = "2026-09-11T19:05:19.063Z" }, ] [[package]] @@ -1299,75 +1324,75 @@ wheels = [ [[package]] name = "numpy" -version = "2.5.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9a/80/db0b4559e57ec36362bedbb05530a87fafbcb6067708c946967a41d449e7/numpy-2.5.2.tar.gz", hash = "sha256:d482d171c406ae88c5b19cad3b6a1c4c5209f886ab74bc44c2c865c23f52d860", size = 20773161, upload-time = "2026-08-09T13:48:27.962Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/69/72/dccb0aaf40972777283303919f613964227266d0c13adebb79ac124f1c3e/numpy-2.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:14e373cfc6387177e8409dac3c7159be8eb05cd77096cd7c950268b86f62831c", size = 16891693, upload-time = "2026-08-09T13:44:51.702Z" }, - { url = "https://files.pythonhosted.org/packages/60/2e/b5aee50a1f74ac815cf8331812cb8251e29024025de462e0c047641c614c/numpy-2.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4bbd96c833ecc8cc069ce518078fc8c60cb9cbfb0fea5b7a803ad65035596d03", size = 11903109, upload-time = "2026-08-09T13:44:55.501Z" }, - { url = "https://files.pythonhosted.org/packages/f3/f4/29e78102a80601cf034d4e9767022cffeca2c3b4c926e1754572ca95593d/numpy-2.5.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:6e8172ddfcf5cf74b811d372b570b83c60bd2de87a6fbfbebdadb4a9bd9c6cbb", size = 5350202, upload-time = "2026-08-09T13:44:58.401Z" }, - { url = "https://files.pythonhosted.org/packages/11/4b/dcd3b7eadaf4035d2c7a4289d232523a6964f602598ef7674e4bd7291f93/numpy-2.5.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:65f188481f1669e26f62b701e8205d19e460fa4a9b52a1414ba382330e4a3414", size = 6687736, upload-time = "2026-08-09T13:45:00.813Z" }, - { url = "https://files.pythonhosted.org/packages/e5/21/4947e0e9d6c9fc2e2ff15b8949049ee44f63adb9cacc729ab8793f97e712/numpy-2.5.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee9c4eeb8454b3660a8b53493563c3e121c2fc94fbd72b848ef814ed7b676a9", size = 15612696, upload-time = "2026-08-09T13:45:04.151Z" }, - { url = "https://files.pythonhosted.org/packages/3a/5f/62d28cf019460c7f1394105b4d49d9911a9c444cb77ab0bd95a204c5a6de/numpy-2.5.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3cdec01fa790a186d430433fdd4d4ffb70eed6f0eeb4bf05c8dbe2dce0a9bcb8", size = 16722264, upload-time = "2026-08-09T13:45:07.714Z" }, - { url = "https://files.pythonhosted.org/packages/14/25/3f0be4c1b9fdf5dd5e708a6806978564d7c46a055c000496309ff2a2f8af/numpy-2.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7999d4ddb0c4025018373fd787510d46e04c769467af22869707b3c1cfd459ab", size = 16974396, upload-time = "2026-08-09T13:45:11.316Z" }, - { url = "https://files.pythonhosted.org/packages/22/72/6262cbdeeb45da9d971e40715f579d791603ba8ec0b5e2db1ac55454421d/numpy-2.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c1f017dc0875c9209d219f97feceb7d54c2661bb243deb4114478e1295808af7", size = 18476044, upload-time = "2026-08-09T13:45:14.869Z" }, - { url = "https://files.pythonhosted.org/packages/36/33/29208b8b075bde62d26a81d14b358c42b0f69b6cabd98d4ff97f37f22b05/numpy-2.5.2-cp312-cp312-win32.whl", hash = "sha256:d6a48072864e3324e194a8fbb3c657bcc5b5c869dbc64c9537b1d5c862572c0a", size = 6072817, upload-time = "2026-08-09T13:45:17.867Z" }, - { url = "https://files.pythonhosted.org/packages/7f/b9/87fea2769fe1c47c1b5b01d8310772c9d1a85d485de7cf386ef7a3332b02/numpy-2.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:28ac63476ec7651484215ee7fa15a1f78b57c14621f01e392afe17b9a1390ce4", size = 12464674, upload-time = "2026-08-09T13:45:20.734Z" }, - { url = "https://files.pythonhosted.org/packages/14/52/032b97e00461ab0809bbe4c588b035620e5a14b8cdee47ecddefc7b17d33/numpy-2.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:27650bb0e7140fa3d37b9923b4803645e0b125d190f326eecfd3f4dad8e8ade1", size = 10397131, upload-time = "2026-08-09T13:45:23.73Z" }, - { url = "https://files.pythonhosted.org/packages/f5/d2/6b24738a0ef4557d189b150046cd07823c50e4273e8aebd651222e24306f/numpy-2.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8e4cb9a754c8a0c62eaa88273a5fba3391f4a610d1dee893c0755da31c083f15", size = 16886595, upload-time = "2026-08-09T13:45:27.323Z" }, - { url = "https://files.pythonhosted.org/packages/65/60/f2d208d366f263f39c6e69ed309290717aab41078b6d04c9be2a84fa2a07/numpy-2.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:52c808f96484f5571a5cc863775ce50247c17dfb3b0361f8ed6b4b0456f80080", size = 11896845, upload-time = "2026-08-09T13:45:31.638Z" }, - { url = "https://files.pythonhosted.org/packages/3c/79/81e0bf24f4d020a2b1d5cd297a9f60c3f24eeb116f9bba5870443f7b6a4a/numpy-2.5.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:29d81e97f668489cba8ebfd796b9bdd453525d35dd9e162e2daec94bf3fc7740", size = 5343880, upload-time = "2026-08-09T13:45:34.373Z" }, - { url = "https://files.pythonhosted.org/packages/ba/cc/e3141cf06d1a8a2c7e107543fe1269c1d1af760d4d683c0794a4ee1127c2/numpy-2.5.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afb3f0632d6b2e3ba04dbce8d1e48d321b369138b73830b5ca371a0e8d479d56", size = 6682264, upload-time = "2026-08-09T13:45:36.7Z" }, - { url = "https://files.pythonhosted.org/packages/29/f1/2a64a307d92c5d98f5255a4014eb43bb6103ee477087b61ecae44a3aa9b9/numpy-2.5.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0aadf13b60048d501e05fa699efaf7734e2494f3498a4c2a5521d822640324f3", size = 15609566, upload-time = "2026-08-09T13:45:39.518Z" }, - { url = "https://files.pythonhosted.org/packages/7b/44/59a1eb68e773c4098d107ef34a0dbdeca501d72ffcfbff9a7707343921ce/numpy-2.5.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29b86ff8a6cc556b47ec6b64b194815cc80e6bf5eedcc6cddfd65318cb0b4eee", size = 16709995, upload-time = "2026-08-09T13:45:43.661Z" }, - { url = "https://files.pythonhosted.org/packages/8a/4c/3e54d4ddbc359a1295f8b633e8106bcd4d7d4a206e82df051bdfb3058755/numpy-2.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6950c4b7dd562453090548ba7f5da7e59f57f85663f15d5dcc60e249192f7e59", size = 16972511, upload-time = "2026-08-09T13:45:47.094Z" }, - { url = "https://files.pythonhosted.org/packages/f2/9f/02e371638ebf19b66d46231e4be52999e87f32d1961b113bc45656608b22/numpy-2.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9727f472d2f3888053b8a75ab0cb94745a9de224bb5846dbadc0092101bc71d", size = 18465609, upload-time = "2026-08-09T13:45:50.808Z" }, - { url = "https://files.pythonhosted.org/packages/eb/ae/ad6645abc7a3510fe48e8ea1ab4598166f500057ef4ebf38bfad4f1577de/numpy-2.5.2-cp313-cp313-win32.whl", hash = "sha256:4f9744f9fbdcea0bc552e8f19e1f141f811a3f9bc2be2cc6e86d982cab23e3f4", size = 6070204, upload-time = "2026-08-09T13:45:54.111Z" }, - { url = "https://files.pythonhosted.org/packages/15/20/f3489f86d81ea460b2bcdceaed094142ca6579f6be0ec527b781d39afe68/numpy-2.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:85aaccb24182c25df891ad0ec333585967e115269d5f1b17f2c9ae005bc96657", size = 12460532, upload-time = "2026-08-09T13:45:57.167Z" }, - { url = "https://files.pythonhosted.org/packages/d5/21/35b31dde1b283b79de828b80f876afd8c94e28fe1e9c375f89e261cc4c0d/numpy-2.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:bd68ece1553d2023c09a4226d9e41c586ad2d20594d1a456186c33513d2cb3f2", size = 10396725, upload-time = "2026-08-09T13:46:00.478Z" }, - { url = "https://files.pythonhosted.org/packages/ac/f8/c3b222bf075b50afd8e949a07a15c4b312a4a84bd8102a332bcd953cbbb4/numpy-2.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d787cf769c3baeb5f6235e778edb52c08dfa923789b5958f28e6450f96107cb1", size = 16885180, upload-time = "2026-08-09T13:46:03.939Z" }, - { url = "https://files.pythonhosted.org/packages/17/e1/2c1d4b1987795a92b5bbf7c24fe249ab96aa2573ab0d7604802c189d7b86/numpy-2.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:24b9dc2e3d84aa58523798805194e23e736f3f6ce2d1a5b92583ae734e6dbda8", size = 11907878, upload-time = "2026-08-09T13:46:07.045Z" }, - { url = "https://files.pythonhosted.org/packages/b9/ee/d08226fc858044355983a6e5b94f08ff6f3969e0a2b160a4a89f0ddb3445/numpy-2.5.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:9e9413326d726c2545bfa65d2c0876871e8d8386e77f992c1d426e180bbd4323", size = 5354922, upload-time = "2026-08-09T13:46:10.04Z" }, - { url = "https://files.pythonhosted.org/packages/94/f0/6d3d933056440ebbc5e6bad92065fc6c26a48a84a36b1208580e94eea76c/numpy-2.5.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:60e902ac295855348a5ca2ea4c89108989a9f5fddfad3dfc0a8f36b10358567e", size = 6679168, upload-time = "2026-08-09T13:46:12.275Z" }, - { url = "https://files.pythonhosted.org/packages/c4/3b/ecd49dd90033cceb2704d88ca905d4d7d89b0e8c739608754ffd325fa820/numpy-2.5.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50e500dc868e9313530ce12ba470fe50ff3afe3d62993ed6eff652dacd555b65", size = 15624501, upload-time = "2026-08-09T13:46:15.322Z" }, - { url = "https://files.pythonhosted.org/packages/c7/99/461bd36dbdfac6c1c53efa370bd55a83227542d0d118f1677dbf1a3dacd5/numpy-2.5.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318b9a4c845dbea06708a29c84ee429cc3065048db34cdb799047643492050ee", size = 16713701, upload-time = "2026-08-09T13:46:18.949Z" }, - { url = "https://files.pythonhosted.org/packages/f9/9c/2b251df9e8a5d647b62b0cbc1b90a91850c1cf4859ecb532fd0b4eacff6c/numpy-2.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:34c319e2963be042673fb46570501b2f06c41924e17e3563d58646b4380dfb68", size = 16986065, upload-time = "2026-08-09T13:46:23.006Z" }, - { url = "https://files.pythonhosted.org/packages/8f/25/20de43f53ff1390534a124475055a19f01fe10c920a0fd11b8e18d6d6052/numpy-2.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f06571a052127dc1b4e8b83029b4d1b20daa2b64a31cdd181fc6bc774e9000eb", size = 18470031, upload-time = "2026-08-09T13:46:27.102Z" }, - { url = "https://files.pythonhosted.org/packages/56/5e/0c577ca308d6da5eb79b546ba10bbe5b60148192194e2da060913b1de4f1/numpy-2.5.2-cp314-cp314-win32.whl", hash = "sha256:2cc779226e476d1e1f08c74068c419e60f41a9e0e069c92f6671d31d5c985e98", size = 6121028, upload-time = "2026-08-09T13:46:30.046Z" }, - { url = "https://files.pythonhosted.org/packages/15/5c/7bcbd5b11f94199073320410cddcbb80cee62415bfeb540874b265c2d922/numpy-2.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:7587f53dfbd5edc0f7b87c6217b4c6d2d1f2ef9c3da70bc1315e7db5f8d7ec9d", size = 12597627, upload-time = "2026-08-09T13:46:32.886Z" }, - { url = "https://files.pythonhosted.org/packages/87/bc/4d0b06fba0da90ccc75af62823cb9dcedb6c9ea0cffa058cb2c9ee773a77/numpy-2.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:3e4c367352d3747784248a227fbec218e193b56f7e6692e3b64fc805478ecfdf", size = 10680414, upload-time = "2026-08-09T13:46:36.036Z" }, - { url = "https://files.pythonhosted.org/packages/cd/17/f429aac9dc08833a0d0f188eba38c532a751b1a1f2ca6018a37b455cb321/numpy-2.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b879fb674276e331513fb136b78dbc6bd3c848309e0d841cfd63be3896c4cfc1", size = 12026967, upload-time = "2026-08-09T13:46:39.084Z" }, - { url = "https://files.pythonhosted.org/packages/ca/9f/d0849de96a2a4ceaa16662f18ee13eaa9c0aa418269fdc8c4857c56b11da/numpy-2.5.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:fd0d703772bba096843785bd38371e31bb4a0c1151497ad5739d182114a73f7f", size = 5473874, upload-time = "2026-08-09T13:46:42.075Z" }, - { url = "https://files.pythonhosted.org/packages/89/3c/8df216d4a4a5422a3de045301cf7df8ea47286d76f5cb7160b0128ac26b7/numpy-2.5.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:3a2f061cebd9e3d23bdcfaaded5e2293a4c6a5b60fa42df85d410a725ce621bf", size = 6789276, upload-time = "2026-08-09T13:46:44.387Z" }, - { url = "https://files.pythonhosted.org/packages/e6/3a/20d7e9891c4ddfadd6ff8d95bf4b29f353d8e1770553de2099880551dfb9/numpy-2.5.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6df895598c0edcb41030126c89e0f353b07d93238116143b7405e937359736c4", size = 15659154, upload-time = "2026-08-09T13:46:47.538Z" }, - { url = "https://files.pythonhosted.org/packages/aa/d6/f3aa3d2688bf501b858835c6bd087ae9b51a56ae6fca8e2b0990abd177af/numpy-2.5.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ab3d4a901f844ea836c3e80bf463c6a27d7f3c14e8e292fcf28d348b25b9bce", size = 16748909, upload-time = "2026-08-09T13:46:51.442Z" }, - { url = "https://files.pythonhosted.org/packages/7d/8f/1c5cae8d2baf86ab802ae97a00be55bc7e21ebc11b12bbc33376c5f05342/numpy-2.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:cebc2d6dbb605a7703d59751dea4bd6b0ab127a5a4338a6f432df1936fef8b26", size = 17027685, upload-time = "2026-08-09T13:46:55.095Z" }, - { url = "https://files.pythonhosted.org/packages/5c/27/71d3467404aedc1c24ce79610f91b52b0b0f466c43a701aa56fc75c145ab/numpy-2.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eaca7ff36f0f52e2111ec71f169d8fd3e889e7ddc0d2592e0d703fd8d3ce8fac", size = 18501181, upload-time = "2026-08-09T13:46:59.09Z" }, - { url = "https://files.pythonhosted.org/packages/14/2f/42921d27c40aea7e077f4a423ae509fd9220b028cd787bafefd8ab2b3a5f/numpy-2.5.2-cp314-cp314t-win32.whl", hash = "sha256:ddf47472af2e4280d79bac82304f5e80150211f1b9e614b760061d5fdfbb6eba", size = 6271085, upload-time = "2026-08-09T13:47:01.903Z" }, - { url = "https://files.pythonhosted.org/packages/75/e6/bad5f5d56de9b1971bac959963dda276d35c40f1854475005434bbe08692/numpy-2.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:44ef9675d908e65f9953063837c3277730f3f4437615a4cdab67b366cabaf884", size = 12787971, upload-time = "2026-08-09T13:47:04.963Z" }, - { url = "https://files.pythonhosted.org/packages/df/05/f608795cb34391acd67e38d94a3c36abd8d8576293a3a80727d7595c372c/numpy-2.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:eaa088384c46f519dacb93b7ec483a6d6b19a4a2085ae4f25ab9b1c43d387d1e", size = 10750306, upload-time = "2026-08-09T13:47:07.976Z" }, - { url = "https://files.pythonhosted.org/packages/33/c6/28de0191c5f82b7d42a0a51390ba98587048aa93a39fafb05bdbe6e8d00c/numpy-2.5.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:078f9b027b478c9379b9677babbf0f8b8f1ecfada27636d7b9a93990c638739f", size = 16885274, upload-time = "2026-08-09T13:47:11.439Z" }, - { url = "https://files.pythonhosted.org/packages/dd/d1/973ca116000d244897e468ea1aff30b589e5022e3c8744b71706fe33bd57/numpy-2.5.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:50a68f4bacd8a2b33d8da3d2269d0d78500f86ea582e4786dc10f5ef2c2c6842", size = 11907846, upload-time = "2026-08-09T13:47:15.128Z" }, - { url = "https://files.pythonhosted.org/packages/78/d9/8c4b3937ef204cb2fd88d389ccd0f265a2ffb11f35a01d2064cf46714bd6/numpy-2.5.2-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:e79aba74ffaf5f78a050d777c184cddf8fdffabab38acf5f3ef1fecbc17895d6", size = 5354892, upload-time = "2026-08-09T13:47:18.07Z" }, - { url = "https://files.pythonhosted.org/packages/74/9b/b6ee65ea2999fdb7023935e108e6fb776ee4082aa15f159acfa857e578c8/numpy-2.5.2-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:9a0731745a72a184490a582fb4af2533512bd071ace67785b5fdffc0ae58dce8", size = 6679309, upload-time = "2026-08-09T13:47:20.456Z" }, - { url = "https://files.pythonhosted.org/packages/43/f3/acb18d8b137a393c8e7803a8c994c9e64bde3930692a69d826993113a159/numpy-2.5.2-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ec954036759bcee3aa484f8603bd9c14f3e776293b85578b8734c2d72777c69", size = 15625850, upload-time = "2026-08-09T13:47:24.365Z" }, - { url = "https://files.pythonhosted.org/packages/a9/bf/a8e9bb0db815a0e265b5744ebedd3af0bd5faad8604e5b50a1cd012f3c91/numpy-2.5.2-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc649493697006bc90614a5f0bbc8cb3cb1866715c474e473694968d7e6b99ab", size = 16713664, upload-time = "2026-08-09T13:47:27.965Z" }, - { url = "https://files.pythonhosted.org/packages/0c/c3/6e913736b3dd6582344af32418b5fb9dab34282e8a8174ae1d54ceb0fc13/numpy-2.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:cf7de32f486e4ac9e2d93b810f9e9ac72a728dd46a32a0bb403222f27f653514", size = 16986749, upload-time = "2026-08-09T13:47:31.541Z" }, - { url = "https://files.pythonhosted.org/packages/80/09/7d3b23eff5c7428ef6c01e6f7052bb60d504c4d33e317b36b8959c24ad97/numpy-2.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2ffa7bacab3e2ee1b19ed31766bb60bb380b68c23f051e199c5cc598afd68710", size = 18470495, upload-time = "2026-08-09T13:47:35.364Z" }, - { url = "https://files.pythonhosted.org/packages/a5/a4/68a321d825374f6eb677ffe8ef8c6b9a328304e6fd2e39d9530822776607/numpy-2.5.2-cp315-cp315-win32.whl", hash = "sha256:6b588cc8f902d6bff201c19fd00c43ab8545671e3554d014e12e14139e5e8617", size = 6120696, upload-time = "2026-08-09T13:47:38.561Z" }, - { url = "https://files.pythonhosted.org/packages/c8/23/deafbb1700f79fae9cd1e91220f133d124cc267de1b584da3fbf6db2f6cd/numpy-2.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:07d4e89f3a9ab0a9ba24264ccdb642b3dd951b2281e8883a5481a4aa79cc31a7", size = 12597324, upload-time = "2026-08-09T13:47:41.401Z" }, - { url = "https://files.pythonhosted.org/packages/33/cd/3272ba105e3bbbdaeb11357eda31e7a6825ffe159e8171665660299a948f/numpy-2.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:a610dc7e3c52edd39c2bc2375ff9c3fd59cb3ad00e4472d36f83bc1457145788", size = 10680466, upload-time = "2026-08-09T13:47:44.873Z" }, - { url = "https://files.pythonhosted.org/packages/0e/0e/58370637b1bb70a5c9ce2b43f4b521ccb224e36ccb76a6596b17ae4b447c/numpy-2.5.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:40f4d451aed46a8046a1aae41c4e55fb3612273df9c502480135e1501576a34b", size = 16993947, upload-time = "2026-08-09T13:47:48.97Z" }, - { url = "https://files.pythonhosted.org/packages/10/93/2abcb807712b289d6d60fe4cf30532f98974a8396d885650f3ba5a13026e/numpy-2.5.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:c081cbe16ba1ab53078e5ff29013621e33c509eedab055775d956427712c236e", size = 12025331, upload-time = "2026-08-09T13:47:52.646Z" }, - { url = "https://files.pythonhosted.org/packages/8b/3a/2898e003a5fbaf87e76c039b4ee1f5eb390471b4ffe74887c1f34c4e791e/numpy-2.5.2-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:0090ccdd57ec2703e9b49d0bf554767370581c1dd0a6b2bb2b2d9def317d042a", size = 5472336, upload-time = "2026-08-09T13:47:55.403Z" }, - { url = "https://files.pythonhosted.org/packages/61/a5/23f69d07c544597b29758b31b55c27dc9d541012a2c1496189fef702aec2/numpy-2.5.2-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:6a9bb119fb8dd21ba30b3f0e555b7e2b081bd9883af21ec9c1c633d161cda3a8", size = 6788387, upload-time = "2026-08-09T13:47:58.192Z" }, - { url = "https://files.pythonhosted.org/packages/15/ea/c0dbdbcf22f43782510a3e492dd3da73c6112b69cac8929d16d127536fc4/numpy-2.5.2-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a839318485284a6fb31be4f8f2c91c8f2cb22f4543c4a8903f12b0671ffe07cc", size = 15667096, upload-time = "2026-08-09T13:48:01.562Z" }, - { url = "https://files.pythonhosted.org/packages/fc/5e/29c73c31748cdb0f7566642125ba17fd5b56780cddf891b085dab27e4466/numpy-2.5.2-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba0a474801b8dc67b66bf465548abc90e82b44d2611b5770f33008dcabffe8ec", size = 16751730, upload-time = "2026-08-09T13:48:05.706Z" }, - { url = "https://files.pythonhosted.org/packages/47/95/02501e8454796bb58dadf7a99d3181e0b464bf264e1003039572f9779fac/numpy-2.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:0a4035ae1129ff8777f08bfbd44f1e5d8e9c049ce0c2dd78fc0d92c13e7251c0", size = 17038686, upload-time = "2026-08-09T13:48:09.627Z" }, - { url = "https://files.pythonhosted.org/packages/0e/b5/53a681d91b5c82687067d8ea5035e02d917b5509d6f334cb06484a954714/numpy-2.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:77843ca236b777e67f8d6b3660ea116e499612703a0ecd7093f316201eb9d8e2", size = 18507727, upload-time = "2026-08-09T13:48:13.744Z" }, - { url = "https://files.pythonhosted.org/packages/42/06/6e11443f7b64ee376c860506091103bf68f92d2cab9e8d96d4501babf07c/numpy-2.5.2-cp315-cp315t-win32.whl", hash = "sha256:7354826bc6f8f69402e9b7fe28d15fcd34feebd74f856f111585c5b0c9fb0251", size = 6269775, upload-time = "2026-08-09T13:48:17.543Z" }, - { url = "https://files.pythonhosted.org/packages/f1/18/195d6b86cd72dbbc501edfa778005fa6b87afd34c153e46028cd3a0938f4/numpy-2.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:e5651f3f87add730ee6608d915009e19c911fba0cb000c7e3ea994b7d768eb12", size = 12782559, upload-time = "2026-08-09T13:48:21.023Z" }, - { url = "https://files.pythonhosted.org/packages/b4/07/458c344f0f0c178f4481dad5cca790626ffe4c34eabf9467069d06ee4999/numpy-2.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:5f8e00be2ec6f45f4e8a41a527f68d44a7d96fee92a650e4d8b1326f77f61e6e", size = 10748103, upload-time = "2026-08-09T13:48:24.21Z" }, +version = "2.5.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/01/11703282db468b85f6f7b8c7f22d058de5970d5c7e60a3a8aaa313c3de36/numpy-2.5.3.tar.gz", hash = "sha256:df2d5874ff183595a4ba404edd04f6bd9b5505c1d7708573f6a6c17489a67563", size = 20791231, upload-time = "2026-09-06T16:27:47.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/50/8fdbb16af64895706a45f06a4068e29db732ec180f3c1375f14123359138/numpy-2.5.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cb189f09db39283b26bfd061ec16189e14f71c6755207f72a0f7540867afe5b9", size = 16994982, upload-time = "2026-09-06T16:24:29.244Z" }, + { url = "https://files.pythonhosted.org/packages/60/39/789131c1188c078dcb3a1692e72e1e050c68b88ffe72c9ccaac9bcd7a9cd/numpy-2.5.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f59a878c33d6b88122d80d239bb3b845d58708750b0cb06a09aebb9b18ec696c", size = 12009327, upload-time = "2026-09-06T16:24:32.491Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/a312e95696e5f601914dd8b6dd844692ba61670807417e24b68e337b5c70/numpy-2.5.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a72f874bc9e10e4b8f80426fb49716d5141f64442a0c8418065093ec8017fbb0", size = 5445405, upload-time = "2026-09-06T16:24:35.071Z" }, + { url = "https://files.pythonhosted.org/packages/30/d0/5623a1707ed4fe16e3909fe3cf5ee3da004ae677ad23d83bbf3adf1a6faf/numpy-2.5.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:fc36dc566135b5eceec4cf89758fcb719266a019ef07dae1754ae7c9f617ef3e", size = 6783213, upload-time = "2026-09-06T16:24:37.253Z" }, + { url = "https://files.pythonhosted.org/packages/f1/32/84146fc020ad3c25f805f70ab60da46fe3c540a21369754a7e4369754b6f/numpy-2.5.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76c2c1e6bfa5c84adc6434dfbf013aa92096a7985221762c8f11fedfd20fff58", size = 15687872, upload-time = "2026-09-06T16:24:39.751Z" }, + { url = "https://files.pythonhosted.org/packages/65/af/aa78d1a88805456e212b65461354cd943197fb9acecc4c90fd12295123a3/numpy-2.5.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7e18c623bb5c95acb3b3328861272816ba199fb531921c5d6d0b675f1fde9e3", size = 16717410, upload-time = "2026-09-06T16:24:42.745Z" }, + { url = "https://files.pythonhosted.org/packages/3b/24/faa79d865e69a97ba17473b23a1b74094b2259c03e820c70297293b9ea49/numpy-2.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4f8929ee6c96bfbd7b4ed2032e0c03af86fe1826740ab61ddabf9072d06e57ff", size = 17040975, upload-time = "2026-09-06T16:24:45.961Z" }, + { url = "https://files.pythonhosted.org/packages/62/4a/8877e629445a7176297dffcaf9c485faa96a95d81728a62521ad55bd4c0f/numpy-2.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b5d93cf48f687479941d12b69c873ad2cc76bbd487f0091c2200636497f34034", size = 18476479, upload-time = "2026-09-06T16:24:49.35Z" }, + { url = "https://files.pythonhosted.org/packages/c8/db/35e1c2d38b04cbd5b731f9d71495e055e813197669d22b612f11748d2ff9/numpy-2.5.3-cp312-cp312-win32.whl", hash = "sha256:bf63afbe037eb5d2fe87fbcc7778e61da53ebaf21d938a4515aa73b62532a5d4", size = 6133378, upload-time = "2026-09-06T16:24:51.915Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a1/accf6d4f0c80c5d9ba9735d6b1550e444180599f34dec69ca01360f717ad/numpy-2.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:0a59a421a32580a009e8a1751345bf829631b990dc1794b80514ab722b435def", size = 12567828, upload-time = "2026-09-06T16:24:54.255Z" }, + { url = "https://files.pythonhosted.org/packages/22/43/1764aff32e4652526ae2f71fa8b3efd8d25c8a3d6926914454e47138ed1e/numpy-2.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:ccb32e0525d29e8b0572eb84c9a57af0e7a4e615726927506f55063c62414034", size = 10485432, upload-time = "2026-09-06T16:24:57.278Z" }, + { url = "https://files.pythonhosted.org/packages/79/e5/8fb89cd46d14e35699d13bf943a5f5f441ecee8667120a1f6105ab89e349/numpy-2.5.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:66a78fe4556c60aceda5916f9eacd638b18e9e681016ec302dcb4682d6d4d034", size = 16991061, upload-time = "2026-09-06T16:25:00.411Z" }, + { url = "https://files.pythonhosted.org/packages/2f/06/9dc9e48b5e5e941c8b10350c5ff2d721da42a20517d911d15544246775ff/numpy-2.5.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92f30e89b8ee0ecf363033576c422b2f58fed6a80bed0aa48dff6d14c654663e", size = 12003676, upload-time = "2026-09-06T16:25:03.475Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2a/98282aa5b8f58b1157d440bb6282eed47e3632a5de53a714fbab17e659fe/numpy-2.5.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f9a2353b37a1a9e78fd82b27ad7e2a32a2d036604d18f02b05e3136c62ca3b09", size = 5439695, upload-time = "2026-09-06T16:25:05.978Z" }, + { url = "https://files.pythonhosted.org/packages/a1/f9/b6533d777be9d6ffd29dc1be0867e563e6e8cc9a220ff1b716adc317f060/numpy-2.5.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:ccbc4665079665c3cf3bab4db9f6b095370cd6437d66be549b6c2a1fd19e1958", size = 6779395, upload-time = "2026-09-06T16:25:08.599Z" }, + { url = "https://files.pythonhosted.org/packages/73/85/735720d04ec197c5dcfacdfc9922667c7f1f5f496a279b7ba4d7c74c4cc7/numpy-2.5.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c76d5dde9f445058f83d0c02af00557a4db91de9a9a57c0df87d1535001d654b", size = 15681750, upload-time = "2026-09-06T16:25:11.173Z" }, + { url = "https://files.pythonhosted.org/packages/3a/1b/3b16a9bc514a440a7a0883684111dcb1ef1aee960af2ca95da8fc775f124/numpy-2.5.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5fa86b80fd24bcd1aff83ad23be44ea323de3f787be8f8b15d4a65621e25321", size = 16708577, upload-time = "2026-09-06T16:25:14.171Z" }, + { url = "https://files.pythonhosted.org/packages/69/c4/386f397831b07328b639c96c5b62719346cf4baf07c68d927239752b1534/numpy-2.5.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd4cb9ad3c7889b9b3fe0a9a9fb5d2ed26f9879bff2608d9f01aed147a20d231", size = 17042047, upload-time = "2026-09-06T16:25:17.582Z" }, + { url = "https://files.pythonhosted.org/packages/5f/3e/a700ecbf36e85ae8328fd3b0e12eeddc22ed6358a64cb2bd913e0d195d65/numpy-2.5.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1302b90c0e52281681b2975adfe8a860cb7b12216a27b4b0b4207c44bf7bccf0", size = 18465724, upload-time = "2026-09-06T16:25:20.949Z" }, + { url = "https://files.pythonhosted.org/packages/41/ee/38e785e88a4045f6ad1d1f2808dcdfafdca48c760260c0587bf171e29fc9/numpy-2.5.3-cp313-cp313-win32.whl", hash = "sha256:1c80eabb4035ecf4ca9cd49cde8a9fdd69a729e63e6474887d1523ade7aa277f", size = 6129003, upload-time = "2026-09-06T16:25:23.664Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ec/100f2b1794ede74a9b3d7ec6b9736927f56713414c1dfe19ab6c383494bf/numpy-2.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:71cad2b2a7451ab79d8f5e71b453485b6775963d5cf794179144a7463fe6e8ec", size = 12560965, upload-time = "2026-09-06T16:25:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/80/b1/7dc825ca94c12acebbce4c37caa5e198695eb31424bc579679f32b1bb49d/numpy-2.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:8e4dd766076855b5ff7ea52fa5f07ce26286726e0f8bff446b7739d02e6ea204", size = 10482343, upload-time = "2026-09-06T16:25:29.772Z" }, + { url = "https://files.pythonhosted.org/packages/70/78/cf416f15dc29375a229d9dfebf8db6e313f291580b39fa1a568b6052bb07/numpy-2.5.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:350ba9783ce969cf9f7ce6e6a9a58e1a6e2a19ca025b7ee448c4db727706212a", size = 16998686, upload-time = "2026-09-06T16:25:33.171Z" }, + { url = "https://files.pythonhosted.org/packages/9e/59/abcc2d8def4fd60eec7d87f92d27c13448ffd9ab14339bcc63a0d7a2fdea/numpy-2.5.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:012e66aca395d795496446e52aeeb5866312a5d4d3f27da270e5a0b43f70dc5c", size = 12013862, upload-time = "2026-09-06T16:25:36.748Z" }, + { url = "https://files.pythonhosted.org/packages/94/75/4640d2d6e4b64a049e48425a82728a41ef4adb61332d2cba68055774878b/numpy-2.5.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:adc1ada2662f8a5f960b8a10d9986897e7499ef07e06d4cfe7197f8cce923c07", size = 5449793, upload-time = "2026-09-06T16:25:39.476Z" }, + { url = "https://files.pythonhosted.org/packages/96/cd/625b57ae33d4ca560f32cc0b47b4a5922146d9beb998ddf773900d440a73/numpy-2.5.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:54a115e5a73b8fc44f0cebef486365a1894b5c9760685d4558b72b7c3eb846e0", size = 6785176, upload-time = "2026-09-06T16:25:42.069Z" }, + { url = "https://files.pythonhosted.org/packages/9c/72/12918652e7912ef9751e8694c88820fcd1908e0618cb23f5f3caa6004b7b/numpy-2.5.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be5a8381859b6da607c84f4f7d6847725f1cf1853ef8a2c9e115b7d58bef47dc", size = 15703377, upload-time = "2026-09-06T16:25:45.135Z" }, + { url = "https://files.pythonhosted.org/packages/45/8f/9beacf79ca7c650688ad0baa80931adb988fe6e6e5d5903c23cc3dbd70eb/numpy-2.5.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b0521d0f4aebb6e06189451025fa17a913287b13c03d5fe05c017333b654ea5b", size = 16711928, upload-time = "2026-09-06T16:25:48.461Z" }, + { url = "https://files.pythonhosted.org/packages/09/8d/41d0a56e1ac4c87495c897a211b1368691b7237aadabec8b3b8f3a74d48f/numpy-2.5.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9deb49575e5b0b94ed72c8a64ec4d033381adc27e9060ae842971f697ba96104", size = 17059507, upload-time = "2026-09-06T16:25:51.873Z" }, + { url = "https://files.pythonhosted.org/packages/08/1e/0dfbc5cc251d54e2af790f254d24ec38637fa97ec7d5d11de7ffed787098/numpy-2.5.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b00eefbcf0f292945c4b4dec2ae845389ef5bcdcd596e6e4328051db5b5ba694", size = 18471002, upload-time = "2026-09-06T16:25:55.233Z" }, + { url = "https://files.pythonhosted.org/packages/b5/2c/dfa40f6991f8185c8c30ffd023dfcbb11888e823cfab9557b920f3bb7bed/numpy-2.5.3-cp314-cp314-win32.whl", hash = "sha256:c2381f82999704f818e2c987a865050e285ec3621262c66d40f5a96c8f899f8e", size = 6180485, upload-time = "2026-09-06T16:25:58.157Z" }, + { url = "https://files.pythonhosted.org/packages/a4/73/d2c08231e4fde7e415501fd02c715d96e98599b2d8384445933944152984/numpy-2.5.3-cp314-cp314-win_amd64.whl", hash = "sha256:2c25dfa72943e4336ddb6b0ee4277b47a0c85bede0807530ec68103bf58e2c10", size = 12698179, upload-time = "2026-09-06T16:26:00.789Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e9/dcdcc9b95cf5f49815055573aee1b11cfbf5299f38a180e437ded050810f/numpy-2.5.3-cp314-cp314-win_arm64.whl", hash = "sha256:15aa985ac73a8db02db7663381aa109510449d3819d37206caed27b33a65a8a6", size = 10769383, upload-time = "2026-09-06T16:26:04.011Z" }, + { url = "https://files.pythonhosted.org/packages/49/c4/af8bc08a7ef4e1529a7c0cf24969accce316b783999802089a581ec99272/numpy-2.5.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ac7bb1c52d445bd4f8f7f97fefe6abc3a084dc4d63df50d79b17fa2b78e89297", size = 12132668, upload-time = "2026-09-06T16:26:07.138Z" }, + { url = "https://files.pythonhosted.org/packages/c5/ae/0f15eb56d4ec5e13c1f7ff04ff407f997d1acbadb45d3e1f2e2645a8f43c/numpy-2.5.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e6ab667ba76450084eb64013762c438ea76d9d29cc676dcd6c2e9892ba37f841", size = 5568580, upload-time = "2026-09-06T16:26:09.828Z" }, + { url = "https://files.pythonhosted.org/packages/23/fb/c72a8f25d4b6e96c354e7ab45ace3b27dc11e5d6a13b6c7d0cd6b08bf112/numpy-2.5.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f7fabeb6cea87d65f3b926de33d03fb016cfdc29314c90974383b5582ae72891", size = 6882634, upload-time = "2026-09-06T16:26:12.524Z" }, + { url = "https://files.pythonhosted.org/packages/07/a9/968c90ed2ab15060c338e8137f1215b5a60756ae07328e0a60d1c6734df4/numpy-2.5.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fb6f8fb9ff0b3a69f52c66ce397b0246583e9f28616231b0e32ca49259a5fa6", size = 15748923, upload-time = "2026-09-06T16:26:15.092Z" }, + { url = "https://files.pythonhosted.org/packages/59/08/9df04103947b95e3b6b1f2ed1a70521f325647a31b82da6a2aae3a485508/numpy-2.5.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93e1f5447e2b1e479d7bd74701e84746b86450cff1fc368b132d195e2b8f8211", size = 16746748, upload-time = "2026-09-06T16:26:18.43Z" }, + { url = "https://files.pythonhosted.org/packages/41/a0/14c8d5fe5b53a334aabb653deb391c0fef49558f491880ea300ed6785224/numpy-2.5.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c00abe94c1a69d75d827dcf1c025b25c8a45d230b3bcd77a9020883a1b047653", size = 17111561, upload-time = "2026-09-06T16:26:22.113Z" }, + { url = "https://files.pythonhosted.org/packages/c4/a6/d7e96e42f01522e154c32489640f16dfc4f6181d165d05fc3bec8c2c4999/numpy-2.5.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:536f963710a4e63934d80ac0dc4f478804a83e9a84b6828018f25d09953ada33", size = 18513945, upload-time = "2026-09-06T16:26:25.401Z" }, + { url = "https://files.pythonhosted.org/packages/25/39/3453afb7119d0449ef11c886874120ff180e2c337760e0e2d88f70f1a945/numpy-2.5.3-cp314-cp314t-win32.whl", hash = "sha256:4c8a6d2ebce6305fd82fbefca827775437147052a976ee7c94b36a0c1b52ac6c", size = 6335421, upload-time = "2026-09-06T16:26:28.175Z" }, + { url = "https://files.pythonhosted.org/packages/99/01/22815d2b19a1a746b1d45205cffebb3fe511a18acb75fba6c88491fc9894/numpy-2.5.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9a37475425b431b4d060f23b4f52cd2f3aef6bc7c654bd760adf0040eec9d435", size = 12896420, upload-time = "2026-09-06T16:26:31.265Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ee/a7cbba67eeaff038dc29ca8b98a88396c8b0cc9c89d4924f4a27a5c9150b/numpy-2.5.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2d8240cb4c16fd831074aa2b2cf9fc54664d826341d61c372245b96a74a49a9a", size = 10857177, upload-time = "2026-09-06T16:26:34.167Z" }, + { url = "https://files.pythonhosted.org/packages/45/56/78194492883ff5eec90423fe56a3a44b154da047d88a6307f629713c584f/numpy-2.5.3-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a6391fafaba97500887132cd582abc6e19452b1ac775a47caa7b24490e152058", size = 16996531, upload-time = "2026-09-06T16:26:37.287Z" }, + { url = "https://files.pythonhosted.org/packages/11/39/dd55c0af90bbab564b09ae3b0aa60ec5c02b900fa4f1ba23440525c8b32d/numpy-2.5.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:09d5a423c71ad5feb5625844ad58050e35df43871004b52ac9c0ad44a56775be", size = 12012569, upload-time = "2026-09-06T16:26:40.707Z" }, + { url = "https://files.pythonhosted.org/packages/b6/51/04f67d32e4862b281b1cb84ceeaed3421189a84fb6fb51a391cd6d5009f7/numpy-2.5.3-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:f9579f383d1bf9df80081e72760e84960a7fd4f88cf0c9e535a8597c9bb646f5", size = 5448498, upload-time = "2026-09-06T16:26:43.435Z" }, + { url = "https://files.pythonhosted.org/packages/a3/c9/25b4dc0dd1344ec26c7319e84fd4e9809d2b5628f4e12decd618036e5178/numpy-2.5.3-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:86bff898a431c0fb71f7610b75726e75a54d47b37edc9d537f48de63bb3c0b90", size = 6783026, upload-time = "2026-09-06T16:26:46.374Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c7/29285be1e5232a6e7ee3268a33c85843f5a8ee93350c6465cddd66ebbf76/numpy-2.5.3-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f3ed25271581281f2fccb1adcedfcde4c07362eec69189b50baf6f90e3ae159", size = 15697322, upload-time = "2026-09-06T16:26:49.415Z" }, + { url = "https://files.pythonhosted.org/packages/55/49/bbad5335fb4996a16881f853ff3e0ba582f01720e55c89b1c06b8fc42a90/numpy-2.5.3-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ffdc76bfcae6b255dff75202c5e7feaf95b40246bc0a17944facc1fecf9f79ab", size = 16708995, upload-time = "2026-09-06T16:26:53.127Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e9/1df35483760b04a65ea44669f89dc64f30e5aca098b48ceb8b1310b0e0fe/numpy-2.5.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:116f96cadd935c6122e9228d676fe7ede19e741f5c8bb1c3cddbe0c51ccebea2", size = 17052508, upload-time = "2026-09-06T16:26:56.464Z" }, + { url = "https://files.pythonhosted.org/packages/b8/99/66e54da8265cc8be8a7382bf96edce17aaa2837d6f484432025932a3caa5/numpy-2.5.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:09ffa5d903faeaa5c4dd05009cf81c8bab9f2cb37c548b8d39b65b4cfa7c97f7", size = 18468224, upload-time = "2026-09-06T16:26:59.966Z" }, + { url = "https://files.pythonhosted.org/packages/01/bc/b5e90a91c115168d793dfd2ad9c69c438c2fe7a13a437e770bc5b078e732/numpy-2.5.3-cp315-cp315-win32.whl", hash = "sha256:e01c918ac3d48e18a927cf7b14a26a3e29ff2bdf2eacb976da0aecd6a43ed034", size = 6179919, upload-time = "2026-09-06T16:27:03.166Z" }, + { url = "https://files.pythonhosted.org/packages/37/ea/780748fd3985109075514ef8fc64cd25f943e40dde13a6d59141eb268fc8/numpy-2.5.3-cp315-cp315-win_amd64.whl", hash = "sha256:e931e4f499e0dc7ef29d269a8e5b35dd722e5d14be07df6240166ea7c6532fae", size = 12697656, upload-time = "2026-09-06T16:27:06.153Z" }, + { url = "https://files.pythonhosted.org/packages/b3/16/407be69a2a87c8cab64d95975a8977a426a29e138f07e276ec258f0fe4e5/numpy-2.5.3-cp315-cp315-win_arm64.whl", hash = "sha256:26e15e4aecd8617dfbaecb37d223e365d7b39411fba20454be2670a96aa74cb5", size = 10767601, upload-time = "2026-09-06T16:27:09.297Z" }, + { url = "https://files.pythonhosted.org/packages/44/bf/a97ffb01e41d50a32a9177aef942a4d0e389a3daf451d04e5f38ef6afb87/numpy-2.5.3-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:6cef4bb1706dfec49243c05d921eefb4e190d41e2528b30d8035ea1f36b4c24a", size = 17090092, upload-time = "2026-09-06T16:27:12.907Z" }, + { url = "https://files.pythonhosted.org/packages/d1/24/136c02f2c2af9a067a84d0c3aa10c99012c0476fa5066732fa4a4202557d/numpy-2.5.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:d1c89973648c85069c5046ad460f7b8a00218b29a2e42359ac8cc63e9ab94832", size = 12129429, upload-time = "2026-09-06T16:27:16.089Z" }, + { url = "https://files.pythonhosted.org/packages/fe/6c/b47582d6597789bf946d5efbeb6b9e56fd8bcbd5efc6fbf51dbe1ea31eb3/numpy-2.5.3-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:214045a5bf00113a146ab9ee9730c44501af6723cdf1f6830932f7b5ef2e7af0", size = 5565452, upload-time = "2026-09-06T16:27:19.868Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/ef3cc6da73774202d4deae16bb321fd8298a4e0561e3539f8c4be237d916/numpy-2.5.3-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:8617bbfae4486cf99c9f899966699428d19da931d06ca94ad3da986c76e15997", size = 6876736, upload-time = "2026-09-06T16:27:22.232Z" }, + { url = "https://files.pythonhosted.org/packages/9e/24/e3813329498596cb842703dcacac1741612ed9fb9c4e6a3e0c7e2ebbc597/numpy-2.5.3-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:595d020938c84e320bcf40ad71089e108eac0d377cd018e14a8c094f39e98d85", size = 15745777, upload-time = "2026-09-06T16:27:25.181Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9e/4e7a07fd0776dc2210cdacf2010be8665194d094defc10c419d7dea794cc/numpy-2.5.3-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f24021b9f22bc6301c37b196974a92c1c18dccedb6fef3dd252e95f2d6adbe4", size = 16746949, upload-time = "2026-09-06T16:27:28.576Z" }, + { url = "https://files.pythonhosted.org/packages/91/db/01674c0e20335057813a00c2ebd546ed25bff9ed7914f9bced00f8c55d94/numpy-2.5.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:71b39d9f935b6ec0f8753e3e2afb51e3efba6f2e05b68b32a40754d24bcd4a3c", size = 17108994, upload-time = "2026-09-06T16:27:31.946Z" }, + { url = "https://files.pythonhosted.org/packages/45/7a/584c5e71f8d378e57cac0b033891ed65c683ef90573ba4854e8c28203db0/numpy-2.5.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:6b05c171afb3aa07adbd20abc00aea86fe375beb0fdb9ef780ec5b7f63bab1c0", size = 18512266, upload-time = "2026-09-06T16:27:35.196Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d2/4e1014173aa3c55e6a756e0e567290743a6ab33a288460374d7ef6bcd239/numpy-2.5.3-cp315-cp315t-win32.whl", hash = "sha256:f54660b0eb6b0b9f36e7fe1cdfdff472028dd0d14acd9b9b65098efbad059469", size = 6330292, upload-time = "2026-09-06T16:27:38.149Z" }, + { url = "https://files.pythonhosted.org/packages/6c/b0/ff5658a58199b7bcaad87bf260eef6713d9d42cca4e028f935b4fc5fbac6/numpy-2.5.3-cp315-cp315t-win_amd64.whl", hash = "sha256:1aad64d99730d013cfc6debafed22783b4fc5a7f4b8bc744d2d8cf7dcc880551", size = 12884918, upload-time = "2026-09-06T16:27:40.965Z" }, + { url = "https://files.pythonhosted.org/packages/fb/0b/b12a2df5d1b774bd9007a6fdff9381145b6223d37f11afc9c37ab0efd9a1/numpy-2.5.3-cp315-cp315t-win_arm64.whl", hash = "sha256:befa1ae5bd6030b3f512b43ff3fa5290bbed6b84411a44244b14adf835f5b89d", size = 10850807, upload-time = "2026-09-06T16:27:43.868Z" }, ] [[package]] @@ -1536,11 +1561,11 @@ wheels = [ [[package]] name = "platformdirs" -version = "4.11.7" +version = "4.11.8" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/69/b7/802a56eca9f2fac455b8bab5375a2647b0f0e14a2cd63ef077de3c4a7658/platformdirs-4.11.7.tar.gz", hash = "sha256:4f41487eeeeeb07f3a6625e61d9bc0ae6809f92d3386dbd74392fbb76108104d", size = 35127, upload-time = "2026-09-01T13:35:10.502Z" } +sdist = { url = "https://files.pythonhosted.org/packages/53/18/f3bb8ef0d3b930692343da8aa4d3cbcd6749477c053959395ac81965a6e9/platformdirs-4.11.8.tar.gz", hash = "sha256:f23abafea7dd4276d1f29104b83598d7dcc567cafd07c9c951e66665645437fc", size = 37182, upload-time = "2026-09-08T22:20:42.866Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/27/6e/80993e10a0482f630cef528635789233224f36b1ffd11592aa15d13ff9ce/platformdirs-4.11.7-py3-none-any.whl", hash = "sha256:8a02cb259042c79d1cd0450facc2fe6dc9d303ae7901afbe33bf8ea0b188cef6", size = 23938, upload-time = "2026-09-01T13:35:09.02Z" }, + { url = "https://files.pythonhosted.org/packages/f4/e1/5b7b8bbb55084d1425bcb9bc823ff519e1b2be05f6ebb0089e2eacc38413/platformdirs-4.11.8-py3-none-any.whl", hash = "sha256:52f2f181bbfde907966932cc8312d967d02976422d66d537ea16092b8e291081", size = 24027, upload-time = "2026-09-08T22:20:41.537Z" }, ] [[package]] @@ -1619,11 +1644,11 @@ wheels = [ [[package]] name = "pure-eval" -version = "0.2.3" +version = "0.2.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +sdist = { url = "https://files.pythonhosted.org/packages/da/9f/abfd2959e9261dd5217ca8551d4de211ca6ab26fe9b72cf44731ff6c4442/pure_eval-0.2.4.tar.gz", hash = "sha256:260c2774686e651b79f8b8e7fc9d80b3599ea6a66334b47d5f4abb69fc2c0ea1", size = 20563, upload-time = "2026-09-10T21:41:22.836Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, + { url = "https://files.pythonhosted.org/packages/6d/18/83376915176eb058cb86470eb7396388a13350b09a8f233a79303bbcbc5b/pure_eval-0.2.4-py3-none-any.whl", hash = "sha256:96cae060a313cfaad51bb761278bfb0e62dc0248d9315a81173752dc546cd37a", size = 11893, upload-time = "2026-09-10T21:41:21.532Z" }, ] [[package]] @@ -2191,14 +2216,14 @@ wheels = [ [[package]] name = "tqdm" -version = "4.70.0" +version = "4.70.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/21/3b/6c24bec5be5e743ffd99576daa5cc077722fc7d5bbc00bd133fa0c698dc6/tqdm-4.70.0.tar.gz", hash = "sha256:55b0b0dbd97462d06ebee91e4dac24ed4d4702be82b24f07e6c1d27e08cea220", size = 795438, upload-time = "2026-07-27T11:33:15.271Z" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/ea/b2a5bd54b28a324dae8211928b2d730b6547500342c7e6c6dea08bd0a485/tqdm-4.70.1.tar.gz", hash = "sha256:cefd0eca11b2a37a3aee776544d4f4ae913f02688135b5556b8788dfa474afc4", size = 171846, upload-time = "2026-09-11T07:25:16.601Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl", hash = "sha256:7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953", size = 80184, upload-time = "2026-07-27T11:33:13.167Z" }, + { url = "https://files.pythonhosted.org/packages/a7/03/921a3d3c75785aca9ebfbfcabfbc3a1be12e2ab5265deb026d55a5a3f83e/tqdm-4.70.1-py3-none-any.whl", hash = "sha256:c293e525e6fef9c20e8728fd4612df02a0aa31bb5fe91ecd93e123b1b7bffa73", size = 80199, upload-time = "2026-09-11T07:25:14.599Z" }, ] [[package]] From 0824833ef4be8f7ef026301878877f54874d5f18 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 26 Sep 2026 13:44:56 -0400 Subject: [PATCH 83/85] Add trivy version --- .github/workflows/docker-in-ci.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/docker-in-ci.yml b/.github/workflows/docker-in-ci.yml index 5affc70..1a30b33 100644 --- a/.github/workflows/docker-in-ci.yml +++ b/.github/workflows/docker-in-ci.yml @@ -34,6 +34,7 @@ jobs: ignore-unfixed: true vuln-type: 'os,library' severity: 'CRITICAL,HIGH' + version: 'v0.74.0' - name: Run basic docker image run: | @@ -64,6 +65,7 @@ jobs: ignore-unfixed: true vuln-type: 'os,library' severity: 'CRITICAL,HIGH' + version: 'v0.74.0' - name: Run full docker image run: | From 5d6e7141789a5c776149dc248aa5f6df26b7e0af Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 26 Sep 2026 13:51:18 -0400 Subject: [PATCH 84/85] Add to gitignore --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index b3f32e8..4e93c6a 100644 --- a/.gitignore +++ b/.gitignore @@ -6,3 +6,7 @@ dist/ .python-version .DS_store docs/_build +.venv +.ruff_cache +.pytest_cache +.benchmarks From 229508f857eeb71237af50a71621b553d40b90e1 Mon Sep 17 00:00:00 2001 From: Ryan DeWolfe Date: Sat, 26 Sep 2026 20:32:44 -0400 Subject: [PATCH 85/85] Add ty type checker to pre-commit workflow (#20) * Add ty type checker to pre-commit workflow * Run via official hook and only on src and tests * Also run on benchmarks * Update changelog --- .pre-commit-config.yaml | 5 +++++ CHANGELOG.md | 2 ++ abcd_graph/abcd.py | 33 +++++++++++++++++---------------- abcd_graph/abcd_sample.py | 12 +++++++----- abcd_graph/degrees.py | 6 +++--- abcd_graph/models.py | 20 ++++++++++---------- pyproject.toml | 8 ++++++++ uv.lock | 27 +++++++++++++++++++++++++++ 8 files changed, 79 insertions(+), 34 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 16ca408..5dd0bee 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -26,6 +26,11 @@ repos: args: [ --fix ] # Run the formatter. - id: ruff-format + - repo: https://github.com/astral-sh/ty-pre-commit + # ty version. + rev: v0.0.84 + hooks: + - id: ty default_language_version: python: python3.12 diff --git a/CHANGELOG.md b/CHANGELOG.md index 9ff5d78..4a23640 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,7 +26,9 @@ - Migrate all workflows to uv ([fork/#8](https://github.com/ryandewolfe33/abcd-graph/pull/8)) - Run pre-commit workflow with prek - Replaced flake8 with ruff for linting +- Replaced mypy with ty for faster static type checking ([fork/#20](https://github.com/ryandewolfe33/abcd-graph/pull/20)) - Default max_degree and max_community_size grows with n +- Docker uses uv:python3.12-trixie-slim as base image for easier install ([fork/#19](https://github.com/ryandewolfe33/abcd-graph/pull/19)) ## abcd-graph 0.4.1 diff --git a/abcd_graph/abcd.py b/abcd_graph/abcd.py index 86f8cd9..01a6dfb 100644 --- a/abcd_graph/abcd.py +++ b/abcd_graph/abcd.py @@ -103,7 +103,8 @@ def generate_graph( logger.info( f"Failed to rewire {graph.shape[0] - n_good_edges}, they will be removed." ) - graph.resize((n_good_edges, 2), refcheck=False) + graph = np.resize(graph[:n_good_edges, :], (n_good_edges, graph.shape[1])) + return graph @@ -411,6 +412,16 @@ def _get_logger(self): logger.addHandler(handler) return logger + def _get_max_degree(self) -> int: + if isinstance(self.max_degree, (int, np.integer)): + return int(self.max_degree) + return self.max_degree(self.n) + + def _get_max_community_size(self) -> int: + if isinstance(self.max_community_size, (int, np.integer)): + return int(self.max_community_size) + return self.max_community_size(self.n) + def sample(self) -> ABCDSample: sample_start = perf_counter() @@ -420,7 +431,7 @@ def sample(self) -> ABCDSample: if self.outliers < 1: n_outliers = int(self.n * self.outliers) else: - n_outliers = self.outliers + n_outliers = int(self.outliers) self.dtype_ = np.min_scalar_type(self.n) @@ -429,16 +440,11 @@ def sample(self) -> ABCDSample: else: self.logger_.info("Generating Degree Sequence") start = perf_counter() - max_degree = ( - self.max_degree(self.n) - if callable(self.max_degree) - else self.max_degree - ) degree_sequence = sample_degrees( self.n, self.degree_exponent, self.min_degree, - max_degree, + self._get_max_degree(), self.rng, self.dtype_, ) @@ -452,16 +458,11 @@ def sample(self) -> ABCDSample: else: self.logger_.info("Generating Degree Sequence") start = perf_counter() - max_community_size = ( - self.max_community_size(self.n) - if callable(self.max_community_size) - else self.max_community_size - ) community_size_sequence = sample_community_sizes( self.n - n_outliers, self.community_size_exponent, self.min_community_size, - max_community_size, + self._get_max_community_size(), self.eta, self.rng, self.dtype_, @@ -619,7 +620,7 @@ def expected_degree_icdf(self, points: ArrayLike): self._validate_params() if self.degree_sequence is not None: return icdf(points, self.degree_sequence) - values = np.arange(self.min_degree, self.max_degree + 1) + values = np.arange(self.min_degree, self._get_max_degree() + 1) weights = values**-self.degree_exponent return icdf(points, values, weights=weights) @@ -641,6 +642,6 @@ def expected_community_size_icdf(self, points: ArrayLike): self._validate_params() if self.community_size_sequence is not None: return icdf(points, self.community_size_sequence) - values = np.arange(self.min_community_size, self.max_community_size + 1) + values = np.arange(self.min_community_size, self._get_max_community_size() + 1) weights = values**-self.community_size_exponent return icdf(points, values, weights=weights) diff --git a/abcd_graph/abcd_sample.py b/abcd_graph/abcd_sample.py index 915ec97..8867e42 100644 --- a/abcd_graph/abcd_sample.py +++ b/abcd_graph/abcd_sample.py @@ -22,10 +22,12 @@ def count_intra_community_edges( return m_intra_community -def icdf(points: ArrayLike, sequence: ArrayLike, weights=None) -> NDArray[np.floating]: +def icdf( + points: ArrayLike, sequence: ArrayLike, weights: ArrayLike | None = None +) -> NDArray[np.floating]: points = np.asarray(points) points = np.insert(points, 0, 0) - hist, bin_edges = np.histogram(sequence, bins=points, weights=weights) + hist, bin_edges = np.histogram(sequence, bins=points, weights=weights) # type: ignore cdf = np.cumsum(hist).astype(np.float64) cdf /= cdf[-1] icdf = 1 - cdf @@ -105,7 +107,7 @@ def __init__( edges = np.asarray(edges) if not np.issubdtype(edges.dtype, np.integer): _, edges = np.unique(edges, return_inverse=True) - edges = edges.astype(np.min_scaler_type(np.max(edges))) + edges = edges.astype(np.min_scalar_type(np.max(edges))) self.edges = edges if sp.issparse(communities): @@ -328,7 +330,7 @@ def to_networkx(self): networkx.Graph """ try: - import networkx as nx + import networkx as nx # type: ignore g = nx.from_edgelist(self.edges) return g @@ -346,7 +348,7 @@ def to_igraph(self): igraph.Graph """ try: - import igraph as ig + import igraph as ig # type: ignore g = ig.Graph(n=self.n, edges=self.edges, directed=False) return g diff --git a/abcd_graph/degrees.py b/abcd_graph/degrees.py index 8156aaa..a305fd3 100644 --- a/abcd_graph/degrees.py +++ b/abcd_graph/degrees.py @@ -61,7 +61,7 @@ def split_degrees( membership_matrix: sp.csr_array, xi: float, rng: Generator, -) -> (sp.csr_array, NDArray[np.integer[Any]]): +) -> tuple[sp.csr_array, NDArray[np.integer[Any]]]: """Split degrees into community degrees and background degrees. The fraction of degree in the background is, on expectation, xi. Community degrees will be split evenly among communities if the nodes belongs to more than one. @@ -91,7 +91,7 @@ def split_degrees( background_degrees: NDArray[np.integer[Any]] Array for the degree of each node in the background graph. """ - background_degrees = degrees * xi + background_degrees = degrees.astype(np.float64) * xi background_degrees += rng.uniform(size=len(degrees)) background_degrees = background_degrees.astype(degrees.dtype) @@ -120,7 +120,7 @@ def _assign_outlier_degrees( outlier_threshold: float, n_outliers: int, rng: Generator, -) -> (NDArray[np.integer[Any]], NDArray[np.integer[Any]]): +) -> tuple[NDArray[np.integer[Any]], NDArray[np.integer[Any]]]: available_indices = np.where(degrees < outlier_threshold)[0] if len(available_indices) > n_outliers: chosen_indices = rng.choice(available_indices, size=n_outliers, replace=False) diff --git a/abcd_graph/models.py b/abcd_graph/models.py index 73841e4..ccaef39 100644 --- a/abcd_graph/models.py +++ b/abcd_graph/models.py @@ -3,7 +3,7 @@ import numpy as np from numba import from_dtype, njit from numba.typed import List, Set -from numba.types import UniTuple +from numba.types import UniTuple # type: ignore from numpy.random import Generator from numpy.typing import NDArray @@ -106,7 +106,7 @@ def configuration_model( @njit(inline="always") -def make_edge_tuple(edge) -> UniTuple(np.integer[Any], 2): +def make_edge_tuple(edge) -> tuple[int, int]: high, low = edge[0], edge[1] if high < low: high, low = low, high @@ -115,10 +115,10 @@ def make_edge_tuple(edge) -> UniTuple(np.integer[Any], 2): @njit(inline="always") def swap( - edge1: UniTuple(np.integer[Any], 2), - edge2: UniTuple(np.integer[Any], 2), + edge1: tuple[int, int], + edge2: tuple[int, int], rng: Generator, -) -> (UniTuple(np.integer[Any], 2), UniTuple(np.integer[Any], 2)): +) -> tuple[tuple[int, int], tuple[int, int]]: if rng.uniform() > 0.5: return make_edge_tuple((edge1[0], edge2[0])), make_edge_tuple( (edge2[0], edge1[0]) @@ -128,9 +128,9 @@ def swap( @njit(inline="always") def is_bad_swap( - edge1: UniTuple(np.integer[Any], 2), - edge2: UniTuple(np.integer[Any], 2), - good_edges: Set[UniTuple(np.integer[Any], 2)], + edge1: tuple[int, int], + edge2: tuple[int, int], + good_edges: Set[tuple[int, int]], ) -> bool: if edge1[0] == edge1[1] or edge2[0] == edge2[1]: return True @@ -141,14 +141,14 @@ def is_bad_swap( return False -def get_edge_type(edges: NDArray[np.integer[Any]]) -> UniTuple(np.integer[Any], 2): +def get_edge_type(edges: NDArray[np.integer[Any]]) -> tuple[int, int]: return UniTuple(from_dtype(edges.dtype), 2) @njit(nogil=True) def rewire( edges: NDArray[np.integer[Any]], - edge_type: UniTuple(np.integer[Any], 2), + edge_type: tuple[int, int], rng: Generator, max_swap_attempts_per_bad_edge: int = 5, print_info: bool = False, diff --git a/pyproject.toml b/pyproject.toml index aaa9071..ae3e637 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -46,6 +46,7 @@ dev = [ "pytest>=8.3.4", "pytest-cov>=6.0.0", "pytest-benchmark>=5.3.0", + "ty>=0.0.80", ] docs = [ "matplotlib", @@ -124,6 +125,13 @@ ignore = [ [tool.ruff.lint.per-file-ignores] "__init__.py" = ["F401"] +[tool.ty.src] +include = [ + "abcd_graph", + "tests", + "benchmarks", +] + [tool.coverage.run] source = ["abcd_graph"] diff --git a/uv.lock b/uv.lock index 7e74f1f..246f82d 100644 --- a/uv.lock +++ b/uv.lock @@ -30,6 +30,7 @@ dev = [ { name = "pytest" }, { name = "pytest-benchmark" }, { name = "pytest-cov" }, + { name = "ty" }, ] docs = [ { name = "egosplit-sknetwork" }, @@ -67,6 +68,7 @@ dev = [ { name = "pytest", specifier = ">=8.3.4" }, { name = "pytest-benchmark", specifier = ">=5.3.0" }, { name = "pytest-cov", specifier = ">=6.0.0" }, + { name = "ty", specifier = ">=0.0.80" }, ] docs = [ { name = "egosplit-sknetwork", specifier = ">=0.0.4" }, @@ -2235,6 +2237,31 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ad/66/0d785f0bc5e4315a96c989bb476d0fc07ea4f85132550c7b156ca2035d52/traitlets-5.16.1-py3-none-any.whl", hash = "sha256:f775618166caa0396c8e337099240f2bd3e5e917d203b2e6fbe21a58d3cb1f6b", size = 86211, upload-time = "2026-08-03T08:32:34.48Z" }, ] +[[package]] +name = "ty" +version = "0.0.80" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/b0/6d1b10e0d422736a3c439e487c950ae785f401d71ff879d5be68bccb6d90/ty-0.0.80.tar.gz", hash = "sha256:fe86bc91327e45ff5e3593b7e306e7f57a44bc0608f38d647b8d97bd99c96013", size = 7183998, upload-time = "2026-09-09T21:18:47.547Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/29/c8/3c93195eca282936ebb574d0ba98843e4b147ee324006f88464777012a92/ty-0.0.80-py3-none-linux_armv6l.whl", hash = "sha256:738d1cfca466c577aea24547c348629c00c63548cf7da2c46b497b3840f85dee", size = 13606509, upload-time = "2026-09-09T21:18:10.476Z" }, + { url = "https://files.pythonhosted.org/packages/e7/48/bbb47f7001c97262a5109bcd92a45bcc8a2fbb21e994c214a9897630bfb7/ty-0.0.80-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:56060164bb8ee43770fa367524fbdba2611fc90f8923a02cc91f80eb37d5a1b0", size = 13203812, upload-time = "2026-09-09T21:18:12.796Z" }, + { url = "https://files.pythonhosted.org/packages/db/8d/fd141160567047b742e466be8ed09a4c4ed80fa045d37f946eb4f4532fee/ty-0.0.80-py3-none-macosx_11_0_arm64.whl", hash = "sha256:da4062e0fbf3923d9b71688157c5753394f243348f00732e9edbb27498397169", size = 13021896, upload-time = "2026-09-09T21:18:15.186Z" }, + { url = "https://files.pythonhosted.org/packages/1e/10/b4177faf9e71bc37bc4d08f512042269660a1ce0ec457c48f96e51fc91d7/ty-0.0.80-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9eb94b2659f506a3a07a9ea1415d5c18aaa1e554adc1612614d617a0ed320e1", size = 13083881, upload-time = "2026-09-09T21:18:17.616Z" }, + { url = "https://files.pythonhosted.org/packages/7f/c2/192d48b9a9acbbe030fc9a4bd73af75671a5566e731949f77e912a68ce68/ty-0.0.80-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e2f5e39a87da48c1af1a3b3135f02be7a83a93da30b0d6a5f5d27806e7c747ce", size = 13354874, upload-time = "2026-09-09T21:18:19.744Z" }, + { url = "https://files.pythonhosted.org/packages/0a/5b/736dfd31efd98bed9dbe018ff91676e5ea83485b1e24afb635fd0247728f/ty-0.0.80-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4e00149e7779c6b98f3ba12e10a631a861bd7ca1a42bbf064e2677ada7d2c0c2", size = 14204805, upload-time = "2026-09-09T21:18:21.999Z" }, + { url = "https://files.pythonhosted.org/packages/fd/6f/557c726cb53401998e3589bb632c963a6887a70240e0a4386024f3731c81/ty-0.0.80-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a377268f359fb6e7a2cc9026a09223c764f58d020dec8e6baeaba9caba6ff829", size = 14630014, upload-time = "2026-09-09T21:18:24Z" }, + { url = "https://files.pythonhosted.org/packages/e9/19/7a4b18fe27f6b6bd4ffa56b67c8b09ecb76bb4312d1c64b73f65417b4dbd/ty-0.0.80-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4511dbf1b266b9ce5b73e9b28d94468096c2b6da00e2fe205168c32d3b352ca7", size = 14326946, upload-time = "2026-09-09T21:18:26.679Z" }, + { url = "https://files.pythonhosted.org/packages/f8/95/16dd90805fc7e53ec54ae9fdb1a8b74753fb159a55a170f60f49b9417824/ty-0.0.80-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fe95feffa7156800c6f804195acb9fb5846a39671c7192c30fff23351aaf7c31", size = 13705988, upload-time = "2026-09-09T21:18:28.681Z" }, + { url = "https://files.pythonhosted.org/packages/b1/09/4e87992c23ab8a742c7d4914ac5fe66fb9301c8464a69fd2ecbc0be3fbcd/ty-0.0.80-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:ba26b39f06bc8c3c2c5acd3a147239482b36620cdbca1b9d02e915294854f2cc", size = 14233729, upload-time = "2026-09-09T21:18:30.961Z" }, + { url = "https://files.pythonhosted.org/packages/36/e9/b8c11fda8e66a1d1cc1a7160ed719a33f4dc0107b1cef6a14e2673965763/ty-0.0.80-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:2e6167320888c115a6fbe69893b63fd1c848f9121a454e75e5f612674528e3f3", size = 13173523, upload-time = "2026-09-09T21:18:33.266Z" }, + { url = "https://files.pythonhosted.org/packages/73/a7/512083fa540c5be1ac8642658f03bfb5bfa6fd168ea4f55e3c0aabe04166/ty-0.0.80-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:7aecb62b4de70b479eab07d1779ea66da26dd8b068f50a9330867157312f103c", size = 13373014, upload-time = "2026-09-09T21:18:35.339Z" }, + { url = "https://files.pythonhosted.org/packages/5e/63/cd2f0ca81fd9b8cafef93bbcf022bf636bc4de8ee7465c6aafeec1d4d52b/ty-0.0.80-py3-none-musllinux_1_2_i686.whl", hash = "sha256:4fed06adacd16b7e2d722f37449021b1419598d0440769701c0f4827faddde63", size = 13667827, upload-time = "2026-09-09T21:18:37.241Z" }, + { url = "https://files.pythonhosted.org/packages/0d/5d/ebdfdcb2dc099ae74dc4b75511eef0dd398b2fa27006c543543974b4567f/ty-0.0.80-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:09329af6303ce611ec2cfffc995dc1ddf76c9f47194fc1a4d64a984759c25f5b", size = 13963866, upload-time = "2026-09-09T21:18:39.386Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f6/c286d5e1b560cfd16d6e91fdab683718aacf09fc88938ca06dcc9d1c8502/ty-0.0.80-py3-none-win32.whl", hash = "sha256:a81b3b512f7b4c68e42fbd1835633de658809666e9aafd5defa52bbc5197698d", size = 12881806, upload-time = "2026-09-09T21:18:41.507Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c8/3b3a8ac16d47a23ff34bf57c0d99a491860748aea96e0e886b4bfed54f9b/ty-0.0.80-py3-none-win_amd64.whl", hash = "sha256:8043f99878a2ae434781cb881c8a3840dff70c4a5b60bdc5ae84251f35ee063f", size = 13528883, upload-time = "2026-09-09T21:18:43.687Z" }, + { url = "https://files.pythonhosted.org/packages/2e/71/a6c697930fca76596d7d17f8853120f41a298fd9ea632c901cfca8ca869b/ty-0.0.80-py3-none-win_arm64.whl", hash = "sha256:e277ef034331da5319efc839c064968d24f35715b71c70369cf97d36fe4dcbdb", size = 13370135, upload-time = "2026-09-09T21:18:45.758Z" }, +] + [[package]] name = "typing-extensions" version = "4.16.0"