From fa77c2e7066244fd59ec0113698e6c89aa513e2e Mon Sep 17 00:00:00 2001 From: Donald M Date: Mon, 18 Feb 2019 20:43:39 -0600 Subject: [PATCH] v0.2.1; bugfixes and features. --- CHANGELOG.md | 18 + README.Rmd | 42 +- README.md | 73 ++- README.rst | 78 ++- docs/examples.ipynb | 635 +++++++++++-------------- docs/imgs/lane_error.png | Bin 0 -> 27591 bytes docs/imgs/lanes2.png | Bin 24068 -> 24162 bytes docs/imgs/quickstart.png | Bin 15966 -> 15931 bytes docs/imgs/submit.png | Bin 19168 -> 19385 bytes ezpq/Job.py | 14 +- ezpq/Plot.py | 5 +- ezpq/Queue.py | 382 +++++++++------ ezpq/__init__.py | 2 +- publish.ps1 | 10 +- setup.py | 2 +- test/test_processes.py | 91 ++++ test/{test_ezpq.py => test_threads.py} | 29 +- 17 files changed, 817 insertions(+), 564 deletions(-) create mode 100644 docs/imgs/lane_error.png create mode 100644 test/test_processes.py rename test/{test_ezpq.py => test_threads.py} (61%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9fcceac..72e342e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,24 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). +## v0.2.1 + +### Added + +- `clear_waiting()` function to clear the waiting queue. +- Added `stop_on_lane_error` parameter to `ezpq.Job` to allow for short-circuiting a synchronous lane if a job in the lane fails. When set to `True` and the preceding job has a non-zero exit code, this job will not be run. Note that this is to be set per-job for flexibility. +- Additional unit tests. + +### Changed + +- `stop_all()` function now clears the waiting queue and terminate running jobs. This addresses a bug where a queue would fail to close when disposing with jobs still in the waiting queue. +- The default `poll` for the queue itself is still `0.1`. Now, the default `poll` for `get` and `wait` is equal to the `poll` for the queue itself, as it makes no sense to check for changes more freqeuntly than changes could arise. + +### Removed + +- Removed functions `has_waiting`, `has_work`, and `has_completed`. Use `size(...)` for this. +- Renamed `Queue.is_started` to `Queue.is_running`. + ## v0.2.0 ### Added diff --git a/README.Rmd b/README.Rmd index 0b0630e..dcd3c7c 100644 --- a/README.Rmd +++ b/README.Rmd @@ -90,7 +90,7 @@ def random_sleep(x): return n ``` -```{python, echo=TRUE} +```{python, echo=TRUE, eval=FALSE} start = time.time() output = [random_sleep(x) for x in range(60)] @@ -100,9 +100,17 @@ end = time.time() print('> Runtime: ' + str(end - start)) ``` +``` +## '> Runtime: 58.932034969329834' +``` + Here is the function ran in parallel with an `ezpq` Queue of 6 workers. Thus, the runtime of the above operation will be reduced from ~60s to ~10s. ```{python, eval=FALSE, echo=TRUE} +import time +import random +import ezpq + start = time.time() with ezpq.Queue(6) as Q: @@ -244,7 +252,7 @@ with ezpq.Queue(6) as Q: Q.put(random_sleep, x) # repeatedly print sizes until complete. - while Q.has_work(): + while Q.size(waiting=True, working=True): print_sizes(Q) time.sleep(1) @@ -253,7 +261,7 @@ with ezpq.Queue(6) as Q: ### wait -The `wait()` method will block execution until all jobs complete. It also accepts a `timeout` parameter, given in seconds. The return value is the count of jobs that did not complete. Thus, a return value greater than 0 indicates the timeout was exceeded. The parameter `poll` can be used to adjust how frequently (in seconds) the operation checks for completed jobs (default=0.1). +The `wait()` method will block execution until all jobs complete. It also accepts a `timeout` parameter, given in seconds. The return value is the count of jobs that did not complete. Thus, a return value greater than 0 indicates the timeout was exceeded. The parameter `poll` can be used to adjust how frequently (in seconds) the operation checks for completed jobs. New in v0.2.0, include `show_progress=True` to show a progress bar while waiting. This is equivalent to a call to `waitpb()`. @@ -262,7 +270,7 @@ New in v0.2.0, include `show_progress=True` to show a progress bar while waiting ### get -`get()` retrieves and deletes ("pop") the highest priority job from the completed queue, if one is available. If the completed queue is empty, `get()` returns `None`. However, `get()` will wait for a completed job if the `poll` frequency is greater than 0. If the timeout is exceeded, `None` is returned. +`get()` retrieves and deletes ("pop") the highest priority job from the completed queue, if one is available. If the completed queue is empty, `get()` returns `None`. However, `get()` will wait for a completed job if `wait`, `poll`, or `timeout` are specified. If the timeout is exceeded, `None` is returned. ```{python, echo=TRUE} with ezpq.Queue(6) as Q: @@ -274,7 +282,7 @@ with ezpq.Queue(6) as Q: # repeatedly `get()` until queue is empty. for i in range(n_inputs): - output[i] = Q.get(poll=0.1) + output[i] = Q.get(wait=True) ``` ### collect @@ -326,6 +334,30 @@ When you have jobs that are dependent upon another, you can use "lanes" to execu In the above graphic, notice how same-colored bars never overlap. These bars represent jobs that are in the same lane, which executed synchronously. +### Lane Error Handling + +You may want to short-circuit a synchronous lane if a job in the lane fails. You can do this by specifying `skip_on_lane_error=True` when putting a job in the queue. If specified and the preceding job has a non-zero exit code, this job will not be run. + +```{python, echo=TRUE} +def reciprocal(x): + time.sleep(0.1) # slow things down + return 1/x # will throw DivideByZero exception +``` + +```{python, echo=TRUE} +import random +with ezpq.Queue(6) as Q: + for i in range(100): + Q.put(reciprocal, random.randint(0, 10), lane=i%5, suppress_errors=True, stop_on_lane_error=True) + Q.wait() + output = Q.collect() + +plt = ezpq.Plot(output).build(facet_by='lane', color_by='exitcode', color_pal=['red', 'blue']) +plt.save('docs/imgs/lane_error.png') +``` + +![](docs/imgs/lane_error.png) + ## ezpq.Plot The `Plot` class is used to visualize the wait, start, and end times for each job that entered the queueing system. The class is initialized with a list of dicts; exactly what is returned from a call to `collect()` or `map()`. diff --git a/README.md b/README.md index 3be0e2e..620c409 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,5 @@ # `ezpq`: an easy parallel queueing system. -Read this on [GitHub](https://github.com/dm3ll3n/ezpq) or [my site](https://www.donaldmellenbruch.com/project/ezpq/). - * [`ezpq`: an easy parallel queueing system.](#ezpq-an-easy-parallel-queueing-system) * [Overview](#overview) * [Features](#features) @@ -17,9 +15,13 @@ Read this on [GitHub](https://github.com/dm3ll3n/ezpq) or [my site](https://www. * [map](#map) * [dispose](#dispose) * [Synchronous Lanes](#synchronous-lanes) + * [Lane Error Handling](#lane-error-handling) * [ezpq.Plot](#ezpqplot) * [More Examples](#more-examples) +Read this on [GitHub](https://github.com/dm3ll3n/ezpq) or [my +site](https://www.donaldmellenbruch.com/project/ezpq/). + ## Overview `ezpq` implements a parallel queueing system consisting of: @@ -97,6 +99,9 @@ Thus, the runtime of the above operation will be reduced from ~60s to ~10s. ``` python +import time +import random +import ezpq start = time.time() with ezpq.Queue(6) as Q: output = Q.map(random_sleep, range(60)) @@ -138,7 +143,7 @@ print( output[0] ) ## {'args': [0], ## 'callback': None, ## 'cancelled': False, - ## 'ended': datetime.datetime(2019, 1, 28, 17, 45, 29, 943860), + ## 'ended': datetime.datetime(2019, 2, 18, 20, 21, 0, 902915), ## 'exception': None, ## 'exitcode': 0, ## 'function': 'random_sleep', @@ -148,11 +153,11 @@ print( output[0] ) ## 'name': 1, ## 'output': 1.3444218515250481, ## 'priority': 100, - ## 'processed': datetime.datetime(2019, 1, 28, 17, 45, 29, 998175), - ## 'qid': 'd6eaaf93', - ## 'runtime': 1.3502492904663086, - ## 'started': datetime.datetime(2019, 1, 28, 17, 45, 28, 593611), - ## 'submitted': datetime.datetime(2019, 1, 28, 17, 45, 28, 489300), + ## 'processed': datetime.datetime(2019, 2, 18, 20, 21, 0, 955396), + ## 'qid': 'f4717edb', + ## 'runtime': 1.3515939712524414, + ## 'started': datetime.datetime(2019, 2, 18, 20, 20, 59, 551321), + ## 'submitted': datetime.datetime(2019, 2, 18, 20, 20, 59, 446199), ## 'timeout': 0} Easily convert output to a `pandas` dataframe: @@ -164,11 +169,11 @@ print( df.head()[['id', 'output', 'runtime', 'exitcode']] ) ``` ## id output runtime exitcode - ## 0 1 1.344422 1.350249 0 - ## 1 2 0.634364 0.638975 0 - ## 2 3 1.456034 1.460431 0 - ## 3 4 0.737965 0.742028 0 - ## 4 5 0.736048 0.740672 0 + ## 0 1 1.344422 1.351594 0 + ## 1 2 0.634364 0.640723 0 + ## 2 3 1.456034 1.461620 0 + ## 3 4 0.737965 0.743645 0 + ## 4 5 0.736048 0.742260 0 Use `ezpq.Plot` to generate a Gannt chart of the job timings. @@ -236,7 +241,7 @@ queue with a call to `submit()`. ## Help on function __init__ in module ezpq.Job: ## - ## __init__(self, function, args=None, kwargs=None, name=None, priority=100, lane=None, timeout=0, suppress_errors=False) + ## __init__(self, function, args=None, kwargs=None, name=None, priority=100, lane=None, timeout=0, suppress_errors=False, stop_on_lane_error=False) ## Defines what to run within a `ezpq.Queue`, and how to run it. ## ## Args: @@ -316,7 +321,7 @@ with ezpq.Queue(6) as Q: for x in range(60): Q.put(random_sleep, x) # repeatedly print sizes until complete. - while Q.has_work(): + while Q.size(waiting=True, working=True): print_sizes(Q) time.sleep(1) print_sizes(Q) @@ -330,9 +335,9 @@ with ezpq.Queue(6) as Q: ## 'Total: 60; Waiting: 31; Working: 6; Completed: 23' ## 'Total: 60; Waiting: 24; Working: 6; Completed: 30' ## 'Total: 60; Waiting: 17; Working: 6; Completed: 37' - ## 'Total: 60; Waiting: 11; Working: 6; Completed: 43' + ## 'Total: 60; Waiting: 12; Working: 6; Completed: 42' ## 'Total: 60; Waiting: 6; Working: 6; Completed: 48' - ## 'Total: 60; Waiting: 0; Working: 5; Completed: 55' + ## 'Total: 60; Waiting: 1; Working: 6; Completed: 53' ## 'Total: 60; Waiting: 0; Working: 1; Completed: 59' ## 'Total: 60; Waiting: 0; Working: 0; Completed: 60' @@ -343,7 +348,7 @@ also accepts a `timeout` parameter, given in seconds. The return value is the count of jobs that did not complete. Thus, a return value greater than 0 indicates the timeout was exceeded. The parameter `poll` can be used to adjust how frequently (in seconds) the operation checks for -completed jobs (default=0.1). +completed jobs. New in v0.2.0, include `show_progress=True` to show a progress bar while waiting. This is equivalent to a call to `waitpb()`. @@ -355,8 +360,8 @@ waiting. This is equivalent to a call to `waitpb()`. `get()` retrieves and deletes (“pop”) the highest priority job from the completed queue, if one is available. If the completed queue is empty, `get()` returns `None`. However, `get()` will wait for a completed job -if the `poll` frequency is greater than 0. If the timeout is exceeded, -`None` is returned. +if `wait`, `poll`, or `timeout` are specified. If the timeout is +exceeded, `None` is returned. ``` python with ezpq.Queue(6) as Q: @@ -368,7 +373,7 @@ with ezpq.Queue(6) as Q: # repeatedly `get()` until queue is empty. for i in range(n_inputs): - output[i] = Q.get(poll=0.1) + output[i] = Q.get(wait=True) ``` ### collect @@ -427,6 +432,32 @@ In the above graphic, notice how same-colored bars never overlap. These bars represent jobs that are in the same lane, which executed synchronously. +### Lane Error Handling + +You may want to short-circuit a synchronous lane if a job in the lane +fails. You can do this by specifying `skip_on_lane_error=True` when +putting a job in the queue. If specified and the preceding job has a +non-zero exit code, this job will not be run. + +``` python +def reciprocal(x): + time.sleep(0.1) # slow things down + return 1/x # will throw DivideByZero exception +``` + +``` python +import random +with ezpq.Queue(6) as Q: + for i in range(100): + Q.put(reciprocal, random.randint(0, 10), lane=i%5, suppress_errors=True, stop_on_lane_error=True) + Q.wait() + output = Q.collect() +plt = ezpq.Plot(output).build(facet_by='lane', color_by='exitcode', color_pal=['red', 'blue']) +plt.save('docs/imgs/lane_error.png') +``` + +![](docs/imgs/lane_error.png) + ## ezpq.Plot The `Plot` class is used to visualize the wait, start, and end times for diff --git a/README.rst b/README.rst index c1430fe..b80439e 100644 --- a/README.rst +++ b/README.rst @@ -1,9 +1,6 @@ ``ezpq``: an easy parallel queueing system. =========================================== -Read this on `GitHub `__ or `my -site `__. - - ```ezpq``: an easy parallel queueing system. <#ezpq-an-easy-parallel-queueing-system>`__ - `Overview <#overview>`__ @@ -22,9 +19,15 @@ site `__. - `dispose <#dispose>`__ - `Synchronous Lanes <#synchronous-lanes>`__ + + - `Lane Error Handling <#lane-error-handling>`__ + - `ezpq.Plot <#ezpqplot>`__ - `More Examples <#more-examples>`__ +Read this on `GitHub `__ or `my +site `__. + Overview -------- @@ -110,6 +113,9 @@ workers. Thus, the runtime of the above operation will be reduced from .. code:: python + import time + import random + import ezpq start = time.time() with ezpq.Queue(6) as Q: output = Q.map(random_sleep, range(60)) @@ -152,7 +158,7 @@ job, along with its output, and exit code. ## {'args': [0], ## 'callback': None, ## 'cancelled': False, - ## 'ended': datetime.datetime(2019, 1, 28, 17, 45, 29, 943860), + ## 'ended': datetime.datetime(2019, 2, 18, 20, 21, 0, 902915), ## 'exception': None, ## 'exitcode': 0, ## 'function': 'random_sleep', @@ -162,11 +168,11 @@ job, along with its output, and exit code. ## 'name': 1, ## 'output': 1.3444218515250481, ## 'priority': 100, - ## 'processed': datetime.datetime(2019, 1, 28, 17, 45, 29, 998175), - ## 'qid': 'd6eaaf93', - ## 'runtime': 1.3502492904663086, - ## 'started': datetime.datetime(2019, 1, 28, 17, 45, 28, 593611), - ## 'submitted': datetime.datetime(2019, 1, 28, 17, 45, 28, 489300), + ## 'processed': datetime.datetime(2019, 2, 18, 20, 21, 0, 955396), + ## 'qid': 'f4717edb', + ## 'runtime': 1.3515939712524414, + ## 'started': datetime.datetime(2019, 2, 18, 20, 20, 59, 551321), + ## 'submitted': datetime.datetime(2019, 2, 18, 20, 20, 59, 446199), ## 'timeout': 0} Easily convert output to a ``pandas`` dataframe: @@ -180,11 +186,11 @@ Easily convert output to a ``pandas`` dataframe: :: ## id output runtime exitcode - ## 0 1 1.344422 1.350249 0 - ## 1 2 0.634364 0.638975 0 - ## 2 3 1.456034 1.460431 0 - ## 3 4 0.737965 0.742028 0 - ## 4 5 0.736048 0.740672 0 + ## 0 1 1.344422 1.351594 0 + ## 1 2 0.634364 0.640723 0 + ## 2 3 1.456034 1.461620 0 + ## 3 4 0.737965 0.743645 0 + ## 4 5 0.736048 0.742260 0 Use ``ezpq.Plot`` to generate a Gannt chart of the job timings. @@ -260,7 +266,7 @@ queue with a call to ``submit()``. ## Help on function __init__ in module ezpq.Job: ## - ## __init__(self, function, args=None, kwargs=None, name=None, priority=100, lane=None, timeout=0, suppress_errors=False) + ## __init__(self, function, args=None, kwargs=None, name=None, priority=100, lane=None, timeout=0, suppress_errors=False, stop_on_lane_error=False) ## Defines what to run within a `ezpq.Queue`, and how to run it. ## ## Args: @@ -344,7 +350,7 @@ corresponding queue(s) will be counted. For example: for x in range(60): Q.put(random_sleep, x) # repeatedly print sizes until complete. - while Q.has_work(): + while Q.size(waiting=True, working=True): print_sizes(Q) time.sleep(1) print_sizes(Q) @@ -359,9 +365,9 @@ corresponding queue(s) will be counted. For example: ## 'Total: 60; Waiting: 31; Working: 6; Completed: 23' ## 'Total: 60; Waiting: 24; Working: 6; Completed: 30' ## 'Total: 60; Waiting: 17; Working: 6; Completed: 37' - ## 'Total: 60; Waiting: 11; Working: 6; Completed: 43' + ## 'Total: 60; Waiting: 12; Working: 6; Completed: 42' ## 'Total: 60; Waiting: 6; Working: 6; Completed: 48' - ## 'Total: 60; Waiting: 0; Working: 5; Completed: 55' + ## 'Total: 60; Waiting: 1; Working: 6; Completed: 53' ## 'Total: 60; Waiting: 0; Working: 1; Completed: 59' ## 'Total: 60; Waiting: 0; Working: 0; Completed: 60' @@ -373,7 +379,7 @@ also accepts a ``timeout`` parameter, given in seconds. The return value is the count of jobs that did not complete. Thus, a return value greater than 0 indicates the timeout was exceeded. The parameter ``poll`` can be used to adjust how frequently (in seconds) the operation checks for -completed jobs (default=0.1). +completed jobs. New in v0.2.0, include ``show_progress=True`` to show a progress bar while waiting. This is equivalent to a call to ``waitpb()``. @@ -387,8 +393,8 @@ get ``get()`` retrieves and deletes (“pop”) the highest priority job from the completed queue, if one is available. If the completed queue is empty, ``get()`` returns ``None``. However, ``get()`` will wait for a -completed job if the ``poll`` frequency is greater than 0. If the -timeout is exceeded, ``None`` is returned. +completed job if ``wait``, ``poll``, or ``timeout`` are specified. If +the timeout is exceeded, ``None`` is returned. .. code:: python @@ -401,7 +407,7 @@ timeout is exceeded, ``None`` is returned. # repeatedly `get()` until queue is empty. for i in range(n_inputs): - output[i] = Q.get(poll=0.1) + output[i] = Q.get(wait=True) collect ~~~~~~~ @@ -468,6 +474,34 @@ In the above graphic, notice how same-colored bars never overlap. These bars represent jobs that are in the same lane, which executed synchronously. +Lane Error Handling +~~~~~~~~~~~~~~~~~~~ + +You may want to short-circuit a synchronous lane if a job in the lane +fails. You can do this by specifying ``skip_on_lane_error=True`` when +putting a job in the queue. If specified and the preceding job has a +non-zero exit code, this job will not be run. + +.. code:: python + + def reciprocal(x): + time.sleep(0.1) # slow things down + return 1/x # will throw DivideByZero exception + +.. code:: python + + import random + with ezpq.Queue(6) as Q: + for i in range(100): + Q.put(reciprocal, random.randint(0, 10), lane=i%5, suppress_errors=True, stop_on_lane_error=True) + Q.wait() + output = Q.collect() + plt = ezpq.Plot(output).build(facet_by='lane', color_by='exitcode', color_pal=['red', 'blue']) + plt.save('docs/imgs/lane_error.png') + +.. figure:: docs/imgs/lane_error.png + :alt: + ezpq.Plot --------- diff --git a/docs/examples.ipynb b/docs/examples.ipynb index aad5c93..79d1613 100644 --- a/docs/examples.ipynb +++ b/docs/examples.ipynb @@ -199,7 +199,7 @@ "source": [ "`get()` is used to pop the highest priority job from the *completed* queue. The result must be stored or it will be lost.\n", "\n", - "When `poll` > 0 and no output is available, the operation will wait for the next job to finish." + "When no output is available and `wait` is true, the operation will wait for the next job to finish." ] }, { @@ -208,7 +208,7 @@ "metadata": {}, "outputs": [], "source": [ - "done = Q.get(poll=0.05) # get() returns a dict\n", + "done = Q.get(wait=True) # get() returns a dict\n", "\n", "results.append(done) # append dictionary to results list." ] @@ -246,7 +246,7 @@ "source": [ "`collect()` is used to repeatedly `get()` all completed jobs.\n", "\n", - "`collect()` does not support the `poll` parameter;\n", + "`collect()` does not support the `wait` parameter;\n", "\n", "Instead, wait for all running and queued jobs to complete with `wait()` before calling `collect()`." ] @@ -322,22 +322,22 @@ { "data": { "text/plain": [ - "{'qid': '66b81c35',\n", + "{'qid': '50630fdf',\n", " 'id': 1,\n", " 'name': 1,\n", " 'priority': 100,\n", " 'lane': None,\n", " 'timeout': 0,\n", " 'function': 'sleep',\n", - " 'args': 1,\n", + " 'args': [1],\n", " 'kwargs': None,\n", - " 'submitted': datetime.datetime(2019, 1, 24, 4, 15, 36, 829309),\n", - " 'started': datetime.datetime(2019, 1, 24, 4, 15, 36, 922387),\n", - " 'ended': datetime.datetime(2019, 1, 24, 4, 15, 37, 926731),\n", - " 'processed': datetime.datetime(2019, 1, 24, 4, 15, 38, 25013),\n", + " 'submitted': datetime.datetime(2019, 2, 18, 20, 20, 17, 663244),\n", + " 'started': datetime.datetime(2019, 2, 18, 20, 20, 17, 758352),\n", + " 'ended': datetime.datetime(2019, 2, 18, 20, 20, 18, 763252),\n", + " 'processed': datetime.datetime(2019, 2, 18, 20, 20, 18, 860747),\n", " 'exitcode': 0,\n", " 'cancelled': False,\n", - " 'runtime': 1.0043442249298096,\n", + " 'runtime': 1.0048999786376953,\n", " 'output': None,\n", " 'exception': None,\n", " 'callback': None}" @@ -409,10 +409,10 @@ " \n", " \n", " 0\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:37.926731\n", + " 2019-02-18 20:20:18.763252\n", " None\n", " 0\n", " sleep\n", @@ -422,19 +422,19 @@ " 1\n", " None\n", " 100\n", - " 2019-01-24 04:15:38.025013\n", - " 66b81c35\n", - " 1.004344\n", - " 2019-01-24 04:15:36.922387\n", - " 2019-01-24 04:15:36.829309\n", + " 2019-02-18 20:20:18.860747\n", + " 50630fdf\n", + " 1.004900\n", + " 2019-02-18 20:20:17.758352\n", + " 2019-02-18 20:20:17.663244\n", " 0\n", " \n", " \n", " 1\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:37.933360\n", + " 2019-02-18 20:20:18.767614\n", " None\n", " 0\n", " sleep\n", @@ -444,19 +444,19 @@ " 2\n", " None\n", " 100\n", - " 2019-01-24 04:15:38.025349\n", - " 66b81c35\n", - " 1.005953\n", - " 2019-01-24 04:15:36.927407\n", - " 2019-01-24 04:15:36.829347\n", + " 2019-02-18 20:20:18.861133\n", + " 50630fdf\n", + " 1.004243\n", + " 2019-02-18 20:20:17.763371\n", + " 2019-02-18 20:20:17.663274\n", " 0\n", " \n", " \n", " 2\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:37.938149\n", + " 2019-02-18 20:20:18.773731\n", " None\n", " 0\n", " sleep\n", @@ -466,19 +466,19 @@ " 3\n", " None\n", " 100\n", - " 2019-01-24 04:15:38.025572\n", - " 66b81c35\n", - " 1.003882\n", - " 2019-01-24 04:15:36.934268\n", - " 2019-01-24 04:15:36.829362\n", + " 2019-02-18 20:20:18.861372\n", + " 50630fdf\n", + " 1.004808\n", + " 2019-02-18 20:20:17.768923\n", + " 2019-02-18 20:20:17.663301\n", " 0\n", " \n", " \n", " 3\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:37.944128\n", + " 2019-02-18 20:20:18.778162\n", " None\n", " 0\n", " sleep\n", @@ -488,19 +488,19 @@ " 4\n", " None\n", " 100\n", - " 2019-01-24 04:15:38.025856\n", - " 66b81c35\n", - " 1.004658\n", - " 2019-01-24 04:15:36.939469\n", - " 2019-01-24 04:15:36.829374\n", + " 2019-02-18 20:20:18.861594\n", + " 50630fdf\n", + " 1.004613\n", + " 2019-02-18 20:20:17.773550\n", + " 2019-02-18 20:20:17.663330\n", " 0\n", " \n", " \n", " 4\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:37.970571\n", + " 2019-02-18 20:20:18.801069\n", " None\n", " 0\n", " sleep\n", @@ -510,11 +510,11 @@ " 5\n", " None\n", " 100\n", - " 2019-01-24 04:15:38.026084\n", - " 66b81c35\n", - " 1.004730\n", - " 2019-01-24 04:15:36.965841\n", - " 2019-01-24 04:15:36.829386\n", + " 2019-02-18 20:20:18.861894\n", + " 50630fdf\n", + " 1.006149\n", + " 2019-02-18 20:20:17.794920\n", + " 2019-02-18 20:20:17.663351\n", " 0\n", " \n", " \n", @@ -522,26 +522,26 @@ "" ], "text/plain": [ - " args callback cancelled ended exception exitcode \\\n", - "0 1 None False 2019-01-24 04:15:37.926731 None 0 \n", - "1 1 None False 2019-01-24 04:15:37.933360 None 0 \n", - "2 1 None False 2019-01-24 04:15:37.938149 None 0 \n", - "3 1 None False 2019-01-24 04:15:37.944128 None 0 \n", - "4 1 None False 2019-01-24 04:15:37.970571 None 0 \n", + " args callback cancelled ended exception exitcode \\\n", + "0 [1] None False 2019-02-18 20:20:18.763252 None 0 \n", + "1 [1] None False 2019-02-18 20:20:18.767614 None 0 \n", + "2 [1] None False 2019-02-18 20:20:18.773731 None 0 \n", + "3 [1] None False 2019-02-18 20:20:18.778162 None 0 \n", + "4 [1] None False 2019-02-18 20:20:18.801069 None 0 \n", "\n", " function id kwargs lane name output priority processed \\\n", - "0 sleep 1 None None 1 None 100 2019-01-24 04:15:38.025013 \n", - "1 sleep 2 None None 2 None 100 2019-01-24 04:15:38.025349 \n", - "2 sleep 3 None None 3 None 100 2019-01-24 04:15:38.025572 \n", - "3 sleep 4 None None 4 None 100 2019-01-24 04:15:38.025856 \n", - "4 sleep 5 None None 5 None 100 2019-01-24 04:15:38.026084 \n", + "0 sleep 1 None None 1 None 100 2019-02-18 20:20:18.860747 \n", + "1 sleep 2 None None 2 None 100 2019-02-18 20:20:18.861133 \n", + "2 sleep 3 None None 3 None 100 2019-02-18 20:20:18.861372 \n", + "3 sleep 4 None None 4 None 100 2019-02-18 20:20:18.861594 \n", + "4 sleep 5 None None 5 None 100 2019-02-18 20:20:18.861894 \n", "\n", " qid runtime started submitted \\\n", - "0 66b81c35 1.004344 2019-01-24 04:15:36.922387 2019-01-24 04:15:36.829309 \n", - "1 66b81c35 1.005953 2019-01-24 04:15:36.927407 2019-01-24 04:15:36.829347 \n", - "2 66b81c35 1.003882 2019-01-24 04:15:36.934268 2019-01-24 04:15:36.829362 \n", - "3 66b81c35 1.004658 2019-01-24 04:15:36.939469 2019-01-24 04:15:36.829374 \n", - "4 66b81c35 1.004730 2019-01-24 04:15:36.965841 2019-01-24 04:15:36.829386 \n", + "0 50630fdf 1.004900 2019-02-18 20:20:17.758352 2019-02-18 20:20:17.663244 \n", + "1 50630fdf 1.004243 2019-02-18 20:20:17.763371 2019-02-18 20:20:17.663274 \n", + "2 50630fdf 1.004808 2019-02-18 20:20:17.768923 2019-02-18 20:20:17.663301 \n", + "3 50630fdf 1.004613 2019-02-18 20:20:17.773550 2019-02-18 20:20:17.663330 \n", + "4 50630fdf 1.006149 2019-02-18 20:20:17.794920 2019-02-18 20:20:17.663351 \n", "\n", " timeout \n", "0 0 \n", @@ -576,7 +576,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -587,7 +587,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 18, @@ -652,7 +652,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f89580b4d93c48b9b0044ff5c3666fd5", + "model_id": "f3ad832275004ee0bb2d0388a5992673", "version_major": 2, "version_minor": 0 }, @@ -715,10 +715,10 @@ " \n", " \n", " 0\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:42.429427\n", + " 2019-02-18 20:20:22.972163\n", " None\n", " 0\n", " sleep\n", @@ -728,19 +728,19 @@ " 1\n", " None\n", " 100\n", - " 2019-01-24 04:15:42.526040\n", - " 36420732\n", - " 1.004340\n", - " 2019-01-24 04:15:41.425087\n", - " 2019-01-24 04:15:41.319883\n", + " 2019-02-18 20:20:23.069554\n", + " 3bd621c4\n", + " 1.004521\n", + " 2019-02-18 20:20:21.967642\n", + " 2019-02-18 20:20:21.862432\n", " 0\n", " \n", " \n", " 1\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:42.434688\n", + " 2019-02-18 20:20:22.978533\n", " None\n", " 0\n", " sleep\n", @@ -750,19 +750,19 @@ " 2\n", " None\n", " 100\n", - " 2019-01-24 04:15:42.526500\n", - " 36420732\n", - " 1.003568\n", - " 2019-01-24 04:15:41.431120\n", - " 2019-01-24 04:15:41.319906\n", + " 2019-02-18 20:20:23.069994\n", + " 3bd621c4\n", + " 1.004548\n", + " 2019-02-18 20:20:21.973985\n", + " 2019-02-18 20:20:21.862470\n", " 0\n", " \n", " \n", " 2\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:42.441526\n", + " 2019-02-18 20:20:22.986742\n", " None\n", " 0\n", " sleep\n", @@ -772,19 +772,19 @@ " 3\n", " None\n", " 100\n", - " 2019-01-24 04:15:42.526796\n", - " 36420732\n", - " 1.004652\n", - " 2019-01-24 04:15:41.436874\n", - " 2019-01-24 04:15:41.319914\n", + " 2019-02-18 20:20:23.070316\n", + " 3bd621c4\n", + " 1.005369\n", + " 2019-02-18 20:20:21.981373\n", + " 2019-02-18 20:20:21.862491\n", " 0\n", " \n", " \n", " 3\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:42.447323\n", + " 2019-02-18 20:20:22.994291\n", " None\n", " 0\n", " sleep\n", @@ -794,19 +794,19 @@ " 4\n", " None\n", " 100\n", - " 2019-01-24 04:15:42.527056\n", - " 36420732\n", - " 1.004292\n", - " 2019-01-24 04:15:41.443031\n", - " 2019-01-24 04:15:41.319930\n", + " 2019-02-18 20:20:23.070578\n", + " 3bd621c4\n", + " 1.005236\n", + " 2019-02-18 20:20:21.989055\n", + " 2019-02-18 20:20:21.862505\n", " 0\n", " \n", " \n", " 4\n", - " 1\n", + " [1]\n", " None\n", " False\n", - " 2019-01-24 04:15:42.453564\n", + " 2019-02-18 20:20:22.999577\n", " None\n", " 0\n", " sleep\n", @@ -816,11 +816,11 @@ " 5\n", " None\n", " 100\n", - " 2019-01-24 04:15:42.527323\n", - " 36420732\n", - " 1.004038\n", - " 2019-01-24 04:15:41.449526\n", - " 2019-01-24 04:15:41.319941\n", + " 2019-02-18 20:20:23.070843\n", + " 3bd621c4\n", + " 1.003640\n", + " 2019-02-18 20:20:21.995937\n", + " 2019-02-18 20:20:21.862532\n", " 0\n", " \n", " \n", @@ -828,26 +828,26 @@ "" ], "text/plain": [ - " args callback cancelled ended exception exitcode \\\n", - "0 1 None False 2019-01-24 04:15:42.429427 None 0 \n", - "1 1 None False 2019-01-24 04:15:42.434688 None 0 \n", - "2 1 None False 2019-01-24 04:15:42.441526 None 0 \n", - "3 1 None False 2019-01-24 04:15:42.447323 None 0 \n", - "4 1 None False 2019-01-24 04:15:42.453564 None 0 \n", + " args callback cancelled ended exception exitcode \\\n", + "0 [1] None False 2019-02-18 20:20:22.972163 None 0 \n", + "1 [1] None False 2019-02-18 20:20:22.978533 None 0 \n", + "2 [1] None False 2019-02-18 20:20:22.986742 None 0 \n", + "3 [1] None False 2019-02-18 20:20:22.994291 None 0 \n", + "4 [1] None False 2019-02-18 20:20:22.999577 None 0 \n", "\n", " function id kwargs lane name output priority processed \\\n", - "0 sleep 1 None None 1 None 100 2019-01-24 04:15:42.526040 \n", - "1 sleep 2 None None 2 None 100 2019-01-24 04:15:42.526500 \n", - "2 sleep 3 None None 3 None 100 2019-01-24 04:15:42.526796 \n", - "3 sleep 4 None None 4 None 100 2019-01-24 04:15:42.527056 \n", - "4 sleep 5 None None 5 None 100 2019-01-24 04:15:42.527323 \n", + "0 sleep 1 None None 1 None 100 2019-02-18 20:20:23.069554 \n", + "1 sleep 2 None None 2 None 100 2019-02-18 20:20:23.069994 \n", + "2 sleep 3 None None 3 None 100 2019-02-18 20:20:23.070316 \n", + "3 sleep 4 None None 4 None 100 2019-02-18 20:20:23.070578 \n", + "4 sleep 5 None None 5 None 100 2019-02-18 20:20:23.070843 \n", "\n", " qid runtime started submitted \\\n", - "0 36420732 1.004340 2019-01-24 04:15:41.425087 2019-01-24 04:15:41.319883 \n", - "1 36420732 1.003568 2019-01-24 04:15:41.431120 2019-01-24 04:15:41.319906 \n", - "2 36420732 1.004652 2019-01-24 04:15:41.436874 2019-01-24 04:15:41.319914 \n", - "3 36420732 1.004292 2019-01-24 04:15:41.443031 2019-01-24 04:15:41.319930 \n", - "4 36420732 1.004038 2019-01-24 04:15:41.449526 2019-01-24 04:15:41.319941 \n", + "0 3bd621c4 1.004521 2019-02-18 20:20:21.967642 2019-02-18 20:20:21.862432 \n", + "1 3bd621c4 1.004548 2019-02-18 20:20:21.973985 2019-02-18 20:20:21.862470 \n", + "2 3bd621c4 1.005369 2019-02-18 20:20:21.981373 2019-02-18 20:20:21.862491 \n", + "3 3bd621c4 1.005236 2019-02-18 20:20:21.989055 2019-02-18 20:20:21.862505 \n", + "4 3bd621c4 1.003640 2019-02-18 20:20:21.995937 2019-02-18 20:20:21.862532 \n", "\n", " timeout \n", "0 0 \n", @@ -896,7 +896,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAscAAAHICAYAAACiSEdmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xl4TGf/BvB7ssdkjySNJSKWVNHY26rYonbiLVV7UGLtr0ptpSW1pNYuKKmqFi2tpbRqaaO0ttJSbUoEFeEllRAJsiCZ8/tDMq8xCZlzZuacM3N/rst1yTlnznwznpn5Os8z92gEQRBARERERERwkLsAIiIiIiKlYHNMRERERFSMzTERERERUTE2x0RERERExdgcExEREREVY3NMRERERFSMzTERERERUTE2x0RERERExdgcExEREREVY3Ns40JDQ9G6dWu5y7BLM2fOhEajwYULF0Tdft++fdBoNPjss8/MWteDPvvsM2g0Guzbt89i90HmpeZ/s3PnzsHV1RUbNmyQuxSTlfa4m+M5WtprdFRUFDp27Cj6nEQkDZtjK9JoNGX++fvvv42OLywsxLx58xAeHg5XV1dUqlQJo0aNwvXr12Wo3jJmzpyJrVu3Wu3+UlJSMHHiRLRr1w7+/v7QaDQYNmyY1e5fDlu3bsXMmTPlLsOs0tPTMX36dHTu3BnBwcHQaDRo167dI29z/fp1jBo1CpUqVYKrqyvCw8Mxf/58FBYWWqlqmjBhAurUqYOXX35Z7lIUbc6cOdi9eze+//57uUshsktsjq0sMjISa9euNfpTtWpVo2OHDBmCKVOmoHbt2li6dCkGDx6Mzz//HK1bt0Zubm657i8lJQU//PCDuX8Ns4mLi7Nqc3z48GEsXLgQ58+fR9OmTS16X9OnT0d+fj6qVatm0ft5nK1btyIuLq7UfQMHDkR+fj5atmxp5aqkSUlJwZw5c/DXX3+hWbNmjz3+1q1baNmyJVauXIlevXph2bJleOaZZzB58mQMHz7cChXT8ePH8e2332L8+PHQaDRyl6Nozz77LJo3b44ZM2bIXQqRXXKSuwB7ExYWhgEDBjz2uJ9++gnr1q1D9+7dsW3bNv32xo0bo1evXli0aBHefvvtx57H1dVVUr22plu3bsjKyoKvry8uXLiA6tWrW+y+nJyc4OSk7KeYo6MjHB0d5S7DZI0bN8bVq1cRGBgIAI9tthYsWIBTp05h0aJFGD9+PABg2LBh8Pb2xtKlSzFkyBDF/wfh5s2b8PLysup9FhUV4c6dO6hQoYLkcy1btgweHh7o2bOnGSoTTxAE5ObmwsPDQ9Y6HicmJgYjRozA0aNHy/UfQCIyH145lsG9e/dw69atRx6zZs0aANC/kZfo2bMnQkND9fsfp7T1bCXbzpw5g+joaHh7e8PDwwOdO3fGuXPnDI59cE3d8uXLUadOHbi5uSE0NBQzZ840mpJu3bo1QkNDS61Fo9Fg8ODBBucFgM8//9xgiUmJX3/9Fd26ddNPgwcHB6NNmzaSrjT7+/vD19e33Mfv2rULbdu2RWBgINzc3FClShV06tQJ+/fvf+xty1pzfPnyZQwbNgyVK1eGi4sLqlSpgtjYWKSnp5d5rvI89qUJDQ3F559/DsBwWU/JGsnS1lGWbNuzZw/mzp2LsLAwuLm5ISIiAjt37gQAnDp1Cl27doW3tzd8fHwwePBg3L592+j+b926hWnTpumXBvn5+aFHjx7466+/Hlv7o3h6euob4/JYs2YNKlSogFGjRhlsnzBhgn7/o9y7d6/Uxm7+/PnQaDSIiooy2P7xxx9Do9Hgl19+0W8rKChAXFwcnnzySbi5ucHPzw/dunXD77//bnR/Jc+Vffv2oXXr1vDy8kJERMQja1y+fDmcnJzQs2dP5Ofn67f/888/GDx4MCpVqqQfb6NHj8a1a9cMbl8yXk+dOoVJkyahWrVqcHV1xddffw1A2vOxqKgImzZtQuvWraHVag32mfoac/r0aYwZMwb16tWDt7c33N3dUb9+fSxcuBBFRUUGx5aM5cTERMTHx6N27dpwdXXFwoULAQBHjx7F0KFDER4eDq1WC61Wi6ZNm2L16tWP/Z0eRRAErFy5Es2aNdOft3nz5ia9dnXp0gUA8NVXX0mqhYhMp+zLWjZo06ZNWLduHYqKiuDt7Y2uXbti9uzZRg3lkSNH4ODggGeffdboHM899xzWr1+PrKws+Pn5iarj8uXLaNmyJbp374558+bh7NmzWLJkCaKjo5GUlAQHB8P/Ny1duhT//e9/MXLkSPj5+WHbtm2Ii4vDP//8g7Vr15p8/3Xq1MHatWsxcOBAREZGIjY21mD/mTNnEBUVhcDAQIwePRqVKlXCtWvXcOzYMRw+fBg9evQQ9Xub4pdffkHXrl3x1FNPYeLEifD398e///6LQ4cO4Y8//kBkZKTJ57x8+TKaNm2KjIwMDBs2DBEREfjzzz+xcuVK7Nq1C7/99huCgoIMbiPlsX///fexePFi7N+/3+DY5s2bP7bWqVOn4s6dOxg1ahQcHR3xwQcfIDo6Gps2bcIrr7yC3r17o1u3bjh8+DA+//xzuLq6IiEhQX/7mzdvokWLFjh37hxiYmIQERGBGzduYOXKlXjuueewf/9+NGrUyMRH0HRXr15FWloamjdvDnd3d4N9oaGhCA4OxtGjRx95DmdnZ0RGRmLv3r3Q6XT650diYiIcHBxw6NAhFBQUwM3NTb9dq9XiueeeA3C/OezcuTP27t2Lzp07Y+zYsfj333+xfPlytGjRAjt37kSbNm0M7vP333/Hpk2bMHToUPTr16/M/1ALgoApU6Zg/vz5eO2117B48WJ9fSdOnEDr1q1RoUIFDB06FNWqVcPZs2exfPly7NmzB0ePHoW3t7fB+fr37w8nJyeMGTMGHh4eCA8Pl/x8PH78OG7evFnq61mJ8o7zffv2Ye/evejatSuqV6+OgoIC7NixAxMnTsT58+fx0UcfGZ174sSJyMvLQ0xMDAICAvTL2L755hv8/fff6NWrF6pVq4acnBx8/fXXGDp0KDIzMzFp0qRH/l5lGTJkCNasWYPo6Gj0798fALBlyxb85z//wfLlyzFy5MjHnqNy5coICQnB3r17RdVARBIIZDVNmjQR4uPjhc2bNwtffvmlMHr0aMHZ2Vnw8/MTkpOTDY718PAQAgMDSz3PxIkTBQDCn3/++dj7rFatmtCqVSujbQCEL7/80mB7fHy8AEDYvXu3ftvevXsFAEKFChWECxcu6LcXFRUJPXr0EAAIe/fu1W9v1aqVUK1atVJrASDExMQ8dpsgCMIHH3wgABB+/fXXx/6OYqWmpgoAhFdeeaXU/a+//roAQPj3339FnX/GjBkCACE1NVW/beDAgQIA4YsvvjA49vPPPzeqxdTHviwxMTFCWU/11atXG52nZFtERIRQUFCg3/7HH38IAASNRiN89dVXBueJjo4WnJ2dhVu3bum3jRs3TnB2djb6N7xx44ZQpUoVoXXr1o+tvbwACFFRUaXu+/333wUAQu/evUvd37RpU8HX1/ex97Fw4UIBgHD06FFBEAShoKBAcHd3FwYNGiQAEH744QdBEARBp9MJ/v7+QseOHfW3XbVqlQBAGD58uME5U1JSBFdXV6FWrVpCUVGRwe8DQNi5c6dRHQ/+mxUUFAh9+vQRHBwchPfee8/o2AYNGgjVq1cXrl+/brD9yJEjgqOjozBz5kz9tpLx2qJFC+Hu3bsGx0t9PpbUvGHDBqN9po7z27dvl3of/fr1ExwdHYX09HSj+61Ro4bB2HzUuYqKioTIyEjB29vb4HEo7blSUvvq1av127Zu3SoAEBYvXmx07m7dugleXl7CzZs39dtKe40uERUVJTg7O5e6j4gsh8sqrOi3337DlClT8OKLL6Jv375YtmwZtm3bhqysLIwbN87g2Ly8vDLXC5dcncrLyxNdS6VKldC3b1+DbS+88AKA+1dtHzZgwACDD5Y5ODhg6tSpAIDNmzeLrqMsPj4+AO5/mOzBKWJrKqlh48aNuHfvnuTz6XQ6bN26FeHh4ejXr5/BvoEDB6JGjRrYsmULBEEw2Gftx77EmDFjDMZggwYN4OXlheDgYPTu3dvg2FatWuHevXv6JSSCIGDdunV47rnnUKNGDVy7dk3/p7CwEO3bt8f+/fut8m9b8jx51POpPM+lkqUTe/bsAQAcOnQI+fn5eP311xEUFKTffuLECVy/ft1gqUXJv9PDH4ysXbs2+vXrh7NnzyIpKclgX0RExCPjvG7cuIH27dtj69at2Lhxo9FryN9//40TJ06gT58+0Ol0Bv8GYWFhqFmzJnbv3m103gkTJsDZ2dlgm9TnY2ZmJoD7y5rKUt5x/uCyjDt37iArKwvXrl1Dx44dUVRUVOoylbFjx5a6xvjBc+Xn5+P69evIyspCx44dkZOTg5SUFBN+y/vWrl0Ld3d3vPzyywaP+bVr19CjRw/cvHkThw8fLte5/P39ce/ePdy4ccPkOohIPDbHMuvUqROeeeYZ7NmzBwUFBfrtFSpUwJ07d0q9TclxUj4kExYWZrSt5I2rtKi4p556qsxtD69TNoc+ffqgY8eOePfdd+Hr64uWLVti+vTppUbeWcrYsWPRpEkTvPrqq/D19cULL7yAOXPmIDU1VdT5MjMzcevWLdSrV89on0ajQd26dXHjxg2jN0JrP/YlShsjvr6+ZW4H/jd2SpqBX375BQEBAUZ/Pv30UxQVFRmte7WEkufJo55P5XkuRUREICAgAImJiQDuL50ICAhAREQEoqKiDLYDMGiOz58/D39/fwQHBxudt379+gDurw1+UO3atR9Zz+DBg/HLL7/gu+++w4svvmi0Pzk5GQAQHx9f6r9BSkoKrl69anS70u7XXM/Hh//j96DyjvO8vDxMnToV1atXh5ubG/z9/REQEIBBgwYBALKyssr1OwH3x2nJMpEKFSqgYsWKCAgIwLRp08o81+MkJycjPz8flStXNnrMX3nlFQAo9XEvTcnjxXQPIuvimmMFqF69Oo4cOYKsrCxUqlQJAFClShWcOXMGd+7cMbri9d///ld/jFiPSih41BvY45T1Im5qlqyLiwt27tyJ48ePY/fu3Thw4ADee+89zJ07FwsWLNB/kMqS/Pz8cOTIERw6dAiJiYnYv38/4uLiEBcXh7Vr19p8VmtZY6Q8Y0en0wEAWrZsibfeeqvM4wMCAiRUWD4lz5OS583D/vvf/5bruaTRaNC2bVts27YNBQUFSExMRNu2bfUZyxs2bEBWVhYSExPh7++PBg0aSKr7cQ37yy+/jE8//RTvvPMOnnnmGXh6ehrsL/k3ePXVV9G9e/dSz/HwGuyy7lfq87Hk39kcGe39+/fHtm3bMGzYMLRs2RIVK1aEk5MTjh07hilTpuh/78f9ToIgoEOHDkhKSsKrr76Kpk2bwtfXF46OjtixYwfee++9Us/1ODqdDt7e3ti0aVOZx9StW7dc57p+/TpcXFz0V+6JyDrYHCvAmTNn4OzsbDDl2KxZM5w+fRpHjhwxipg6fPgwatSoIfrDeGKcOnWqzG01a9bUb/Pz88OxY8eMjj1//ryo+23UqJH+Q1s3btxA8+bN8eabb+LVV1+Fi4uLqHOawsHBAS1atECLFi0AAJcuXUKjRo0wefJkk5vjgIAAeHp64uTJk0b7BEHAyZMn4evra5SmUd7HvixyXHUKCAiAj48Pbty48dgv57C0oKAghISE4MSJE8jPzzdoCNPS0pCeno7OnTuX61xRUVH46quvsH37dhw7dkz/BTJRUVHQ6XTYuXMnDhw4gC5duhg87jVq1MDp06dx9epVow9cllx9rVGjhkm/V79+/dCxY0f07dsX7dq1w65duwzGzoNXS831byD2+VgyW3L27NkyjynPOM/JycG2bdswYMAAfPzxxwbHPurcpUlKSsLx48fx1ltv4Z133jHY9+OPP5p0rgfVrl0bp0+fRsOGDR+5jKQ8zp49W+pMExFZFpdVWElZV0zWr1+P48ePo2PHjgZXiAcOHAgAWLRokcHxW7ZswYULF/T7rWXdunVIS0vT/6zT6RAfHw8ABlO64eHhuHXrltGn/xcsWFDqeT08PEqduixtur1kSv/u3buPjcIzh5J1kg+qWrUqgoKCRF0Bc3BwQI8ePXD69Gmjq0pffPEF/vnnH7z44otGzWx5H/uylKy1FDNFLJaDgwMGDBiApKQkfZTcw8o7tWwOAwcORF5eHpYvX26wveT5Vd7nU0mTOWPGDBQVFel/DgkJQa1atTB37lzk5eUZRbuV/DvNmjXLYPu5c+fw5ZdfolatWnj66adN/r1efPFFfPPNN/jrr7/QunVrZGRk6Pc1aNAA9evXx6pVq/RLLB4kCEKpY7w0Up+PDRs2hJeXFw4dOlTmMeUZ5yUpHA/Pbt26dQuLFy8u1+9SomQG5OFzXblyBZ988olJ53pQyfKOSZMmlToLV95xf/nyZVy6dMkoxSQvLw+nT59+ZPQjEUnDK8dWMnv2bBw8eBBt27ZFSEgI7t69i4MHD2Lz5s0IDg7G+++/b3B8u3bt0LdvX6xfvx7dunVDdHQ0UlNT8d577+Gpp56yyrKCB9WpUwfPPPMMRo0aBT8/P2zduhU//fQT+vTpY/DiPWLECCxatAg9evTAa6+9hgoVKuD7779HTk5Oqed99tlnkZiYiHnz5iEkJAQajQZ9+vTB7NmzsWvXLn1ck5OTE37++Wfs2LEDXbt2NbgiExoairS0tHItB8nJycGSJUsAANnZ2QDuf4Bq9uzZAO6vK+3WrRsAIDY2FhcvXkT79u0RGhqKwsJCbN++HSdPnsTYsWNFPY5z585FYmIi+vbti71796J+/fr6KLeqVatizpw5Rrcp72NflmeffRZLly7F6NGj0aVLFzg7O+OZZ56x6BegAPe/AvfQoUMYPHgwtm7disjISGi1Wly8eBF79uyBu7u7QUxV69at8fPPPyM1NbXMrOwHlfyblbhw4YJ+W7Vq1Qwa3kmTJmHTpk2YNGkSLly4gIiICPz888/6OMFWrVqV63eqXr06qlevjlOnTiEsLMzgMWzXrp2++X64OR40aBDWrVuHZcuW4eLFi+jQoYM+yk0QBCQkJIi+wt+5c2fs2LED3bp1Q6tWrbBnzx5UqlQJGo0G69atQ9u2bdGoUSMMHjwY9evX139wcuvWrYiJiSnXV4ub8nwsjaOjI3r16oUNGzbg1q1bRktAgPKNc09PT3Ts2BFffPEFXF1d8cwzzyA9PR2rVq0yuiL/OE8++STq1auH+fPn4/bt26hbty5SU1ORkJCAGjVqiP7PZM+ePTF8+HCsXLkSf/75J3r06IEnnngCV65cwbFjx7Bjx45yfcB3+/btAGD04dejR4+iTZs2iImJ0eeVE5GZyRGRYY+2bdsmdOzYUahSpYrg5uYmuLq6CuHh4cL48eOFq1evlnqbu3fvCnPnzhVq1aoluLi4CE888YQQGxsrZGZmlvt+y4pyKy06qCTabMaMGfptD0YVLVu2TAgPDxdcXFyEqlWrCm+99ZZR5JMgCMLu3buFxo0bCy4uLkJAQIAwcuRIITs7u9TYtjNnzggvvPCC4OnpqY+vKrnfl19+WQgNDRXc3d0FLy8v4emnnxbmzZsn5OXlGZzD399fqFSpUrkej5Lfsaw/D9a3efNmITo6Wqhatarg6uoq+Pr6Cs2aNRNWrFhhELtVltKi3ARBEC5duiS88sorQnBwsODk5CRUqlRJGD58uHDlyhWD48Q89qUpKioSJkyYIFSuXFlwcHAwiJ56VJRbaTFxZY2dsm6Tl5cnzJ07V4iIiBDc3d0FrVYr1KxZU+jfv79BZKAgCEKjRo2EChUqCDdu3CjX7/Wof8fSaszIyBBiY2OFJ554QnBxcRFq1aolxMfHC/fu3SvX/ZUYPny4AECIjY012L5582YBgBASElLq7fLz84UZM2YItWvXFlxcXAQfHx+ha9eu+mi4h3+30iIOBaHsx/rgwYOCt7e3EBYWZjDmLl26JIwZM0YICwvT32/9+vWF1157TTh58qT+uLLGqyCY9nwsy7FjxwQAwqpVq4zObco4v379ujBixAihcuXK+tfR+fPnC4mJiUaxao8ay4IgCGlpaUKfPn2EwMBAwc3NTYiIiBBWrVpV7udFaVFuJb788kuhdevWgre3t/736dSpk7B8+XKD48p6TjVv3lxo3Lix0faS+yxrfBCRdGyO6ZEe9eKvBCXZu59++qncpRiZNm2aAEC4dOmS3KUo3vXr1wUHBwfh7bfflrsUsqDu3bsL9evXF3Q6nX6b0l9j5HD48GEBgLB9+3a5SyGyS1xzTKq2a9cuREREICYmRu5SjFy5cgUODg6SP5RjD3744QcEBgaK/kYyUodFixYhJSUFGzZskLsURZs2bRrat2+v/wppIrIurjkmVZsyZQqmTJkidxkGfv/9d/z444/YuHEjWrduXWpcFhnq06cP+vTpI3cZZGE1a9YsM2+a/qfkC2WISB5sjonMbN26dVizZg3atGmDZcuWyV0OERERmUAjCBK+8YGIiIiIyIZwzTERERERUTE2x0RERERExdgcExEREREVY3NMRERERFSMzTERERERUTGbjHLLy8vD6dOn8eSTT6JChQpyl0NERETllJ2djby8PLOcq0KFCvDx8THLuch+2GRzfPr0aTRu3BjHjh1Do0aNzHZeQRBw69YteHp6QqPRmO289kIQBOh0Ojg4OPDxE4HjTzqOQWk4BqXh+Hu87OxsLF26FIWFhWY5n5OTE8aOHcsGmUxik82xpQiCgNu3b8PDw4MvbCKVvDGQ6Tj+zINjUDyOQek4/h4tLy8PhYWFaNiwITw8PCSd6/bt2/jjjz+Ql5fH5phMwuaYiIiIFMXDw4MNLcmG/30lIiIiIirG5piIiIiIqBibYyIiIiKiYmyOiYiIiIiKsTkmIiIiIirG5piIiIiIqBibYyIiIiKiYmyOiYiIiIiKsTkmIiIiIirG5piIiIiIqJjsXx/9/vvv45dffoGT0/9KWbZsGQICAgAAmZmZWLJkCZKTk+Ht7Y1BgwahZcuWcpVLRERERDZM9uYYAKKjoxETE1PqvoULFyI0NBTTpk3DmTNnMHv2bFSrVg3VqlWzcpVEREREZOsU0RyX5cqVKzhz5gzeeustuLq6on79+mjWrBl++uknDBkyRJaa7t69i4KCAjg4cEWKqQRBQGFhIZycnKDRaOQuR3V0Oh3Hn0Qcg9KofQym/VeQ9f4FQUBRUREcHR1VOf6qVflfzW5ubjJWQmRZimiOd+/ejd27d6NixYro1q0bXnjhBQBAWloaAgIC4OHhoT+2evXq+Ouvv4zOkZ6ejvT0dABAcnKyxWq9du0adDqdKt8Y5Kb2Nwa56XQ6ZGVlcfxJwDEojdrH4Ix5hXKXoGrvTvtfyxAaGipfIUQWJntz3K1bNwwdOhRarRYnT57EvHnzoNVq0bx5cxQUFBg0xgCg1WqRn59vdJ6EhATExcVZq2wiIiIiskGyN8c1atTQ//3pp59Gly5dcPDgQTRv3hxubm7Izc01OD4vLw/u7u5G5xkxYgS6d+8O4P6V4wEDBlik3ooVKyIwMFCVV03kxiltaUqu1nH8iccxKI3ax2DcZC6rkOKJJ9RXM5EYsjfHD9NoNBCE+y9g1apVQ2ZmJm7fvq2/gnz+/PlSP4wXHByM4OBgi9fn4uICNzc3Vb4xyI2NiTQ6nY7jTyKOQWnUPgbDa8p7/xx/ROog+6vbgQMHkJeXB51Oh1OnTuH777/Hs88+CwCoVKkSatasiXXr1uHOnTv4+++/cfToUbRt21bmqomIiIjIFsl+5Xj79u1YtmwZdDodKlasiAEDBhjkGE+cOBEffvgh+vfvDx8fH4wePZoxbkRERERkEbI3x+++++4j9wcEBGDWrFlWqubx1BxjJDdOKUqj9hgtJeAYlEbNY1DuGDdA3WuOH4xxAxjlRrZN9uZYbRjlJp6a3xiUQO0xWkrAMSiNmscgY9ykeTDGDWCUG9k2db26ERERERFZEK8cm4hRbuJxSlsatcdoKQHHoDRqHoNyx7gB6p65YIwb2RM2xyZSc4yR3NiYSKP2GC0l4BiURs1jUO4YN4Djj0gt1PXqRkRERERkQWyOiYiIiIiKcVmFidQaY6QEnFKURs0xWkrBMSiNmscgo9ykYZQb2RM2xyZilJt4an5jUAI1x2gpBcegNGoeg4xyk4ZRbmRP1PXqRkRERERkQbxybCJGuYnHKW1p1ByjpRQcg9KoeQwyyk0aRrmRPWFzbCK1xhgpARsTadQco6UUHIPSqHkMMsqNiMpLXa9uREREREQWxOaYiIiIiKgYl1WYSK0xRkrAKUVp1ByjpRQcg9KodQwqIcYNUPeaY0a5kT1hc2wiRrmJp+Y3BiVQc4yWUnAMSqPWMcgYN+kY5Ub2RD2vbkREREREFsYrxyZilJt4nNKWRs0xWkrBMSiNWsegEmLcAHXPXDDKjewJm2MTqTXGSAnYmEij5hgtpeAYlEatY1AJMW4Axx+RWqjn1Y2IiIiIyMLYHBMRERERFeOyChOpMcZIKTilKI1aY7SUhGNQGrWOQUa5SfNwjBvAKDeybWyOTcQoN/HU+sagFGqN0VISjkFp1DoGGeUmzcMxbgCj3Mi2qefVjYiIiIjIwnjl2ESMchOPU9rSqDVGS0k4BqVR6xhklJs0jHEje8Pm2ERqjDFSCjYm0qg1RktJOAalUesYZJQbEZlCPa9uREREREQWxivHJlLjJ7WVgldNpFFrUoCScAxKo8YxqJSkCkC9yyqYVkH2hs2xiZhWIZ5a3xiUQq1JAUrCMSiNGscgkyqkY1oF2Rt1vLoREREREVkBrxybiGkV4nFKWxq1JgUoCcegNGocg0pJqgDUO3PBtAqyN2yOTaTGT2orBRsTadSaFKAkHIPSqHEMKiWpAuD4I1ILdby6ERERERFZAZtjIiIiIqJiXFZhIrXFGCkJpxSlUWOMltJwDEqjxjHIKDdpSotxAxjlRraNzbGJGOUmnhrfGJREjTFaSsMxKI0axyCj3KQpLcYNYJQb2Tax/hfjAAAgAElEQVR1vLoREREREVkBrxybiFFu4nFKWxo1xmgpDcegNGocg4xyk4YxbmSP2BybSG0xRkrCxkQaNcZoKQ3HoDRqHIOMciMiU6nj1Y2IiIiIyArYHBMRERERFeOyChOpLcZISTilKI0aY7SUhmNQGrWNQSXFuAHqXHPMKDeyR2yOTcQoN/HU+MagJGqM0VIajkFp1DYGGeMmHaPcyB4p/9WNiIiIiMhKeOXYRIxyE49T2tKoMUZLaTgGpVHbGFRSjBugzpkLRrmRPWJzbCK1xRgpCRsTadQYo6U0HIPSqG0MKinGDeD4I1IL5b+6ERERERFZCZtjIiIiIqJiXFZhIjXFGCkNpxSlUVuMlhJxDEqjpjGotBg3QH1rjsuKcQMY5Ua2jc2xiRjlJp7a3hiURm0xWkrEMSiNmsYgY9ykKyvGDWCUG9k2Zb+6ERERERFZEa8cm4hRbuJxSlsatcVoKRHHoDRqGoNKi3ED1DdzwRg3sldsjk2kphgjpWFjIo3aYrSUiGNQGjWNQaXFuAEcf0RqoexXNyIiIiIiK2JzTERERERUjMsqTKSWGCMl4pSiNGqK0VIqjkFp1DQGGeUmzaNi3ABGuZFtY3NsIka5iaemNwYlUlOMllJxDEqjpjHIKDdpHhXjBjDKjWybsl/diIiIiIisiFeOTcQoN/E4pS2NmmK0lIpjUBo1jUFGuUnDGDeyZ4pqjm/evIlRo0YhODgYCxcuBACkpaVhyZIluHDhAoKCghAbG4uIiAjZalRLjJESsTGRRk0xWkrFMSiNmsYgo9yISCxFvbqtXr0aVatW1f9cWFiIWbNmoVmzZli/fj369OmD+Ph4ZGdny1glEREREdkqxTTHf//9N65cuYJ27drptyUlJeHOnTvo1asXnJ2dERkZiZCQEBw8eFDGSomIiIjIViliWcW9e/eQkJCA8ePH4/z58/rtFy9eRGhoqMH0XVhYGNLS0uQoEwCj3KTglKI0aorRUiolj0ElRo89TKcTkJVVhJzbBXBwUNbjB/wvfowxY0QkhSKa482bNyMiIgLVq1c3aI7z8/Oh1WoNjtVqtcjIyDA6R3p6OtLT0wEAycnJFquVUW7iqenDKEqkphgtpVLyGFRX9NgVuQsoVUn8GGPGiEgK2ZvjK1euYM+ePfjggw+M9rm7uyM3N9dgW25uLtzd3Y2OTUhIQFxcnMXqJCIiIiLbJ3tznJycjBs3bmDkyJEA7i9buHv3LgYNGoTRo0cjLS3N4EpZamoqWrZsaXSeESNGoHv37vpzDhgwwCL1MspNPCVPaauBmmK0lErJY1CJ0WMPu7+s4jr8/PwVuayC8WNEZA6yN8ctWrRAo0aN9D/v378fe/fuxdtvvw1PT0+4uLhgy5YtiI6OxpEjR5CWlobnn3/e6DzBwcEIDg62eL1qiTFSIiU3JmqgphgtpVLyGFRi9NjDdDod/v3XEU88wTFIRLZL9ubY1dUVrq6u+p+1Wi0cHR3h6+sLAJg+fTqWLl2KDRs2IDAwEFOnToWPj49c5RIRERGRDZO9OX5YVFQUoqKi9D+HhobqvxCEiIiIiMiSFNccKx2jtMRT8pS2GjDKTTolj0FGuUlTEuMGMMqNiKRhc2wiRrmJp+QYLTVglJt0Sh6DjHKTpiTGDWCUGxFJw3dYIiIiIqJivHJsIka5iafkKW01YJSbdEoeg4xyk4YxbkRkLmyOTcQoLfGU3JioAaPcpFPyGGSUGxGRMvDVjYiIiIioGK8cm4hpAeIp+aqdGjCtQjqljkE1JFUATKsgIvvA5thETKsQT8lJAWrAtArplDoG1ZVUATCtgohsGd9hiYiIiIiK8cqxiZhWIZ5Sp7TVgmkV0il1DKohqQJgWgUR2Qc2xyZiWoB4Sm1M1IJpFdIpdQyqIakCYFoFEdkHvroRERERERVjc0xEREREVIzLKkzEKC3xlDqlrRaMcpNOiWNQLTFugHKj3B6McQMY5UZE0rA5NhGj3MRTaoyWWjDKTToljkH1xbgBSotyezDGDWCUGxFJw3dYIiIiIqJivHJsIka5iafEKW01YZSbdEocg2qJcQOUG+XGGDciMic2xyZilJZ4SmxM1IRRbtIpcQyqJcYNYJQbEdkHvroRERERERVjc0xEREREVIzLKkzEKC3xlDilrSaMcpNOiWOQUW7SPBzjBjDKjYikYXNsIka5iafEGC01YZSbdEocg4xyk+bhGDeAUW5EJA3fYYmIiIiIivHKsYkY5SaeEqe01YRRbtIpcQwyyk0axrgRkbmxOTYRo7TEU2JjoiaMcpNOiWOQUW5ERMrCVzciIiIiomJsjomIiIiIinFZhYkYpSWeEqe01YRRbtIpbQyqKcYNYJQbEdkHNscmYpSbeEqM0VITRrlJp7QxqM4YN4BRbkRky/gOS0RERERUjFeOTcQoN/GUNqWtNoxyk05pY1BNMW4Ao9yIyD6wOTYRo7TEU1pjojaMcpNOaWNQTTFuAKPciMg+8NWNiIiIiKgYm2MiIiIiomJcVmEiRmmJp7QpbbVhlJt0ShuDjHKTprQYN4BRbkQkDZtjEzHKTTylxWipDaPcpFPaGGSUmzSlxbgBjHIjImn4DktEREREVIxXjk3EKDfxlDalrTaMcpNOaWOQUW7SMMaNiCyBzbGJGKUlntIaE7VhlJt0ShuDjHIjIlIevroRERERERVjc0xEREREVIzLKkzEKC3xlDalrTaMcpNOSWNQbTFuAKPciMg+sDk2EaPcxFNajJbaMMpNOiWNQfXGuAGMciMiW8Z3WCIiIiKiYrxybCJGuYmnpCltNWKUm3RKGoNqi3EDGOVGRPaBzbGJGKUlnpIaEzVilJt0ShqDaotxAxjlRkT2ga9uRERERETF2BwTERERERXjsgoTMUpLPCVNaasRo9ykU9IYZJSbNGXFuAGMciMiadgcm4hRbuIpKUZLjRjlJp2SxiCj3KQpK8YNYJQbEUnDd1giIiIiomK8cmwiRrmJp6QpbTVilJt0ShqDjHKThjFuRGQpbI5NxCgt8ZTUmKgRo9ykU9IYZJQbkThFRUU4ffo0srKy4OfnhyeffBKOjo5yl0U2hM0xERERqUJqairmzJmDu3fvwt/fH9evX4erqyvefPNNVK9eXe7yyEawOTYR0wLEU9JVOzViWoV0ShmDakyqAJhWQfJbsmQJOnXqhJ49e+q3bd68GUuXLsWiRYtkrIxsCZtjEzGtQjwlJQWoEdMqpFPKGFR3UgXAtAqSy+XLl9GjRw+DbT169MDGjRtlqohsEd9hiYiISBXq1auHpKQkg21//fUX6tatK1NFZIt45dhETKsQTylT2mrFtArplDIG1ZhUATCtguTx+eef6//u7++POXPmoFGjRggICEBGRgb++OMPtGnTRsYKydawOTYR0wLEU0pjolZMq5BOKWNQjUkVANMqSB7Z2dkGP7do0QIAkJubC61WixYtWuDevXtylEY2ShHN8dKlS/H7778jPz8fnp6eaN++PXr37g0ASEtLw5IlS3DhwgUEBQUhNjYWERERMldMRERE1vDaa6/JXQLZGUU0x927d8fw4cPh6uqKzMxMzJw5E5UqVcKzzz6LWbNmoX379oiPj8evv/6K+Ph4rFixAj4+PnKXTURERFaUkZFR5r7AwEAAQGZmJgICAqxVEtkgRTTHISEhBj9rNBpcuXIFSUlJuHPnDnr16gUHBwdERkbiu+++w8GDB9GlSxdZamWUlnhKmdJWK7mj3NQaP/YgudMqSuLHGDVGJE5sbCwEQTB6/gqCgG3btgEAxo4di6+++kqO8shGKKI5Bu4vuN++fTvu3LmDwMBAtGnTBocOHUJoaKhBIxAWFoa0tDSj26enpyM9PR0AkJycbLE6GeUmntyNidrJHeWm/vgx+ZXEjzFqjEic8kS2ffHFF1aohGyZYprjmJgYDBo0COfOncOvv/4KrVaL/Px8aLVag+O0Wm2p0yoJCQmIi4uzVrlERERkZc7OzgDuL50o+froh5dQODkpprUhlVLUCNJoNKhVqxaOHTuG9evXo2LFisjNzTU4Jjc3F+7u7ka3HTFiBLp37w7g/pXjAQMGWKRGRrmJx2UV0sgd5abW+LEHyT17wfgxImkyMzOxcOFCpKSkQKvVIjc3F+Hh4XjjjTe4zpjMRlHNcQmdTof09HQ0atQImzdvNphGTk1NRcuWLY1uExwcjODgYIvXxigt8dgcSyN3lJta48cexDFIpG7vv/8+atSogZkzZ8Ld3R35+flYs2YNPvzwQ8yaNUvu8shGyN7h3b59G3v37kVeXh50Oh1OnTqFnTt3okGDBqhfvz5cXFywZcsW3Lt3DwcOHEBaWhqef/55ucsmIiIiK/vnn38wZMgQ/Qyyu7s7XnnlFZw9e1bmysiWKOLKcWJiIj7++GPodDr4+fmhR48e6NKlCzQaDaZPn46lS5diw4YNCAwMxNSpUxnjRkREZIdCQ0Nx8eJF1KhRQ78tLS2NH3Ils5K9Ofbw8MCcOXPK3B8aGoqFCxdasaJHY5SbeJzSloZRbtLJuea4JMYNYJQbkVh169ZFXFwcWrVqhYCAAGRmZmLfvn144YUXsGvXLv1xHTt2lLFKUjvZm2O1YZSbeHJ/GErtGOWmbiUxbgCj3IjEOn36NKpWrYrz58/j/PnzAO5/V0JKSgpSUlL0x7E5JinYHBMREZEqPGqmmchc2BybiFFu4nFZhTSMcpNOztkLxrgREakDm2MTMcpNPDbH0jDKTTqOQSJ1i4uLw4wZMwy2zZo1C2+99ZZMFZEtYodHREREqlC3bl2jbU899ZQMlZAtK9eV4+rVq5t0laVkkTwRERGRufTq1ctoW8+ePWWohGxZuZrj6Ohog+Z406ZNuHnzJtq1a4egoCBcvXoViYmJ8Pb2LnXg2hJGuYnHKW1p5Ixys4UYN4BRbkRE9Hjlao7ff/99/d8XLFiAqlWrYteuXfDy8tJvz8nJQadOnRAUFGT+KhWEUW7iMcpNGjmj3BjjJh2j3IioRGhoKLp27YqlS5eWeUx2djZ8fX2xevVqDB482HrFkelrjj/88ENMnTrVoDEGAG9vb0yZMgVLliwxW3FEREREtuabb77BG2+8IXcZVAaT0yqysrKQk5NT6r6cnBzcuHFDclFKxig38bisQho5o9xsIcYNYJQbESlDw4YN5S6BHsHk5jgqKgqTJ09G1apV0apVK/32ffv2YcqUKYiKijJrgUrDKDfx2BxLI2eUmy3EuAEcg0Rqd/r0aTg5OaFmTeMXpaKiIty7d08Ra/pXrlyJOXPmICMjA8899xzmzZuHpk2b6pdIlLasorTbkDxMfodNSEhApUqV0LZtW/j5+SE8PBx+fn6IiopCcHAwVqxYYYk6iYiIyM4lJCQgPz+/1H3p6emIi4uzckXGtm/fjtjYWLRp0wbffPMNoqKi8NJLL5n9NmQ5Jl85Dg4Oxm+//YZdu3bh6NGjSE9PR3BwMJo1a8bvMiciIiKLSU9Px5NPPmmwbcqUKXj33XdRuXJlXLp0SabK/mf27NmIjIzE6tWrAQAdOnRAQUEBZs2aZdbbkOWI/oa8jh072mUzzCg38TilLY1cUW62EuMGyLfm+MEYN4BRbkRiPfzcLSoqwtmzZwEAGo0GRUVFcpWmr+fYsWOYP3++wfZevXqV2eiKuQ1ZVrma46ysLPj4+MDBwQFZWVmPPd7Pz09yYUrFKDfxGOUmjVxRboxxk+7BGDeAUW5EYlWuXBk//fQT2rdvDwA4duwYCgsLcfr0aQCQPU42MzMThYWFCAwMNNj+qLrE3IYsq1zNcUBAAA4fPoxmzZqhYsWKj21s5P6fGxEREdmel156Ce+++y727dsHR0dHNGnSBA0aNMD06dPh6OiI8ePHy1pfQEAAnJyckJGRYbD96tWrZr0NWVa5muNPP/0UNWrU0P/dnq/6McpNPC6rkEauKDdbiXED5Ju9YIwbkXk0bdoUCxcuRFJSEoKDg9G0aVN0794dKSkpCAwMlH3m2tHREY0aNcI333yD119/Xb9906ZNZr0NWVa5muOYmBj93+39W1oY5SYem2Np5Ipys5UYN4BjkMgWVK9eHdWrV9f/rNFojD6kJ6dp06YhOjoaQ4YMQZ8+fXDs2DGsXbvW7Lchy2GHR0RERKpx+/ZtJCYm4pNPPsGyZcvw1Vdf4cSJE3KXpde9e3esWLECe/bsQY8ePfDDDz/gq6++MvttyHJEp1UQERERWdPp06cxe/ZsuLm5QRAEXL9+HREREfjxxx8RFBSEqVOnwsPDQ+4yMWLECIwYMUL/c3Z2tsH+CxcuPPY2wP3ZLrI+NscmYpSbeJzSlkaOKDdbinED5Flz/HCMG8AoNyKxVqxYgZiYGLzwwgsAgN27d+PUqVOYOXMmVq1ahU8++QTjxo2TuUpSOzbHJmKUm3iMcpNGjig3xrhJ93CMG8AoNyKx0tPTERUVpf+5Xbt2WLNmDTQaDfr164dhw4bJWB3ZCjbHREREpApBQUH4888/0bBhQwDAiRMnEBAQAAD6pRZyycjIwM2bN8vcX/JlJefOnTPpvP7+/vD19ZVUG5lGdHN85swZg6+Pbtq0KcLDw81ZmyIxyk08LquQRo4oN1uKcQPkmb1gjBuR+cTExODdd9/V9xvJycmYNGkSACA1NRU1a8oXr3P79m3k5OSY/bxardbs56RHM7k5vn37NmJjY/H1119Dp9PBzc1NvwbypZdewsqVKxWxGN5SGOUmHptjaeSIcrOlGDeAY5BI7Ro3bowPPvgAx48fBwCMGjUKwcHBAIAaNWoo4uuWa9eubbZznTlzxmznovIz+R321Vdfxfbt27Fy5Urk5OQgLy8POTk5+Pjjj/H999/j1VdftUSdRERERAgKCkKTJk3QoUMHfWNMZE4mN8ebN2/GvHnzMGTIEHh6egIAPD09MXToULz77rvYsmWL2YskIiIiAoCcnByMHDkS48aNw99//y13OWSDTF5W4ebmZvDNNA8KCwuDs7Oz5KKUjFFu4nFKWxpGuUln7TXHpcW4AYxyI5LKy8sL//d//4eEhASEhIRg8ODB8PLykrssshEmN8dDhgzB8uXL0aFDB4M3F0EQ8NFHH2HIkCFmLVBpGOUmHqPcpGGUm/qUFuMGMMqNSCpBEFCrVi0sXLgQO3fuxOTJk9GrVy+DmDciscr1Drt48WL9H39/fxw7dgy1atXC66+/jvj4eLz++uuoVasW/vjjDwQGBlq6ZiIiIrJDGRkZyMzMhE6nw9WrV5GRkYHGjRtj/PjxSExMxLRp0+Qu0WpiY2NRuXJleHl5ITQ0FHPnztXv0+l0iIuLQ9WqVeHh4YG6devin3/+MTrHzJkzodFosGvXLv22BQsWoH79+vD09ERISAimTZuGoqIi/f7s7Gz07t0bnp6eqFSpEt5//339vv3798PDw8Pgj0ajweLFiwEAv/76Kxo0aABfX1/4+vrihRdewMmTJ8t939ZSrivHb7zxRqnbP/jgA6NtU6ZMwcSJE6VVpWCMchOPyyqkYZSbdNaevWCMG5F5xcbG6rOMH/6qZcC+vm553Lhx+OCDD+Du7o5Lly6hQ4cOqFmzJnr37o133nkHe/fuxS+//ILQ0FCcPXsWfn5+Brc/c+YMNm3aZPShRp1Oh9WrVyMiIgJXrlxB9+7d4eXlhcmTJwMAxo4dizt37uDy5ctIS0tDVFQUwsPD0alTJ0RGRuL27dv6cyUnJ6NevXro1asXAKBmzZr47rvvUKVKFRQVFWHZsmV46aWXcOrUqXLdt7WUqznW6XSWrkM1GOUmHptjaRjlJh3HIJG6bdy4ETk5OXjjjTewcuVKucsxsG23DkeOewO4asazeuO9d0rf89RTTxn87ODggHPnziE7OxsLFy7EH3/8of+MWGnxciNHjsSiRYuM/pPxYCNarVo19O/fH/v378fkyZORm5uLjRs34tixY/Dy8kL9+vUxfPhwfPrpp+jUqZPRfXz66aeIiopCSEgIgPsXGEsIggAHBwf8888/EAQBGo3mkfdtTezwiIiISBWcnZ3h4+OD1157Dc7OzqX+sSdTp06FVqtFSEgIcnNzMWDAACQlJcHJyQlbt25FcHAwatSogblz5xpcVV+zZg38/f3RoUOHx97Hzz//jHr16gG4f7VZp9PpfwaABg0alJoaUlhYiLVr1xp9Fi0nJwc+Pj5wc3PDa6+9hjfffLPMixUP3rc1ifqGvNzcXHz22Wc4cOAAsrKy4Ofnh8jISMTExNj8N7kwrUI8XrWTxtppFbaWVAEwrYJI7TIzMxEQEKD/+ugH3blzBw4ODnbVIMfHx2Pu3Ln4/fffsXXrVvj6+uLAgQPIycnB33//jXPnzuHy5cto3749KleujJiYGGRlZWHmzJnYv3//Y8+/ZMkSJCUlYc2aNQDufxGct7e3wTE+Pj64deuW0W137NiBu3fv4j//+Y/Bdm9vb2RnZ+PWrVtYtWoVatWqVa77tiaTm+NLly6hdevWuHDhAiIiIhAUFISUlBRs3LgRixcvxt69e1G1alVL1KoITKsQj2kV0lg7rYJJFdIxrYLIvIYNG4ZOnTph5MiRRvs2b96MrKwsjB07VobK5KPRaNC0aVPs2rULM2bMQMuWLQEAb7/9NrRaLWrXro3hw4dj+/btiImJwaRJkzB69GhUrlz5keddu3Yt5s6di71798Lf3x8A4OHhgZs3bxocl5OTo//eiwetXr0affv2LfNigKenJ8aOHYuKFSvizJkzBoEOpd23NZncHI8fPx4AcOrUKf13mwNASkoKunbtigkTJuDrr782X4VEREREuL+s4syZM1i+fDlGjRplsK9du3ayplVEd3BAy2Y3LPD10eWbkS8sLMQ///yj/89BWRehEhMT8e2332LhwoUA7l+N79evH8aOHYt33rm/wPmLL77AxIkTkZiYiCeffFJ/29q1a0Oj0eDkyZOoW7cuAODEiRNGSx8yMjLw/fff49ChQ4+sWafTIS8vD5cvX9Y3x2XdtzWZ3Bz/+OOPSEhIMGiMASA8PByzZs0q9X9ztoRpFeJxWYU01k6rsLWkCoBpFURq5+joiFmzZmHmzJlYunQpxowZo38uBwYGljq9b4tu3LiB7du3Izo6Gh4eHjh8+DCWL1+Ot956C2FhYWjTpg1mz56Njz76CFeuXMEnn3yib3x/++03g3i0pk2bYv78+ejatSsAYP369Rg3bhx++OEHo6ZXq9WiV69emDZtGtauXYu0tDR88sknWL16tcFx69atQ506ddCkSROD7du2bUOtWrXw5JNP4ubNm5gyZQoCAgJQp06dx963NZncHBcWFsLd3b3Ufe7u7rLk0VkT0yrEY3MsjbXTKmwtqQLgGCSyBVqtVt8gz5s3D+PGjYObmxtOnTqFgIAAucuzCo1Gg9WrV+P//u//UFhYiMqVK2PChAn6q8ZffPEFhg8fjooVK8LPzw+jR4/GwIEDAcDoMXJ0dISvr69+acSbb76J7OxsREZG6o+JjIzEzp07AQDLli3D8OHDERwcDE9PT0yZMsUoqWL16tV45ZVXjOq+evUqJkyYgPT0dGi1WjzzzDPYvXu3funF4+7bWkxujp9//nnMnj0brVq1MliUnZOTgzlz5uD55583a4FERERED3Jzc0NcXBwWLFiA4cOHo1atWkhOTrb52esSPj4++Omnn8rcHxwcjO3bt5frXBcuXDD4OTU19bH3vXHjxkcek5SUVOr22NhYxMbGlnm7x923tZjcHC9atAgtW7ZE1apV0bZtWwQFBSEjIwN79uyBs7MzPv30U0vUSURERHbupZde0v/d1dUV06dPx4kTJ5CWloaXX37ZaMknkRgmN8f16tXDn3/+iffeew8HDhzAyZMn4efnh+HDh+P1119HlSpVLFGnYjDKTTxOaUvDKDfprLnmuKwYN4BRbkRilXzT2oMaNGiABg0ayFAN2SpROcdVq1bVf0+2vWGUm3iMcpOGUW7qUlaMG8AoNyIpioqKkJSUhLS0NBQUFMDNzQ0hISF4+umn4ejoKHd5ZAPK1Rw//fTT+PLLL1GvXj3Ur1//kY2NRqOBn58fmjVrhsmTJxt9lzcRERGRGBcvXsTs2bNx9+5dVKtWDRUqVEBubi62bNkCFxcXTJ8+HdWqVZO7TFK5cjXHjRs31n/zXePGjR971a/kW09SUlKwdetW6VUqCKPcxOOyCmkY5SadNWcvGONGZH4ffvghOnTogJ49exrt27x5M5YuXYoFCxbIUNn/3M8mJjUrV3P8YH7dZ599Vq4Tb9u2TR8bYksY5SYem2NpGOUmHccgkbqlpaUhPj6+1H3R0dHYsGGDlSv6n4oVK+ovJJqTh4eH2c9JjyZqzXF5tGrVCmvXrrXU6YmIiMjOBAYG4siRI2jRooXRvl9//RVBQUEyVHWfl5cXvLy8ZLt/Mh+LNcc+Pj6Ijo621OmJiIjIzowcORJz587F9u3bUb16dWi1Wty+fRupqam4ePEipk6dKneJZAMs1hzbKka5iccpbWmsGeVmizFuAKPciNSufv36SEhIwIEDB3Dx4kVkZmbC3d0drVq1QosWLXjllsyCzbGJGOUmHqPcpLFmlBtj3KRjlBuRZXh5eaFz585yl0E2jB0eERER2YTHfa0xUXnwyrGJGOUmHpdVSGPNKDdbjHEDGOVGpHbZ2dnw8fEpc/+mTZsMvmKaSAw2xyZilJt4bI6lsWaUmy3GuAEcg0RqN3ToUDRq1AhRUVFo1qwZvxGPLIIdHhEREanC4sWLERQUhGXLlmHw4MFYtWoV0tLS5C6LbAyvHBMREZEqhIaGYvjw4RgyZAiOHj2KxMREjBs3DmFhYWjXrh10Op3cJZINYHNsIka5iccpbWkY5SadtdYcPyrGDWCUG5FUTk5OaN68OZo3b47r169j3759+Pbbb3H37l25S/0pSYUAABiLSURBVCMbwObYRIxyE49RbtIwyk09HhXjBjDKjcic/P390bNnT/Ts2RPnz5+XuxyyAezwiIiIyCaEhYXJXQLZAF45NhGj3MTjsgppGOUmnbVmLxjjRmQZH330EWrXro127doZ7cvIyMDx48fRsWNHGSojWyJ7c3zv3j2sWLECf/75J27duoWKFSuid+/eaNWqFQAgLS0NS5YswYULFxAUFITY2FhERETIVi+j3MRjcywNo9yk4xgkUrejR4+ib9++Btt+//13NGnSBBUqVMA333zD5pgkk73DKyoqgp+fH2bPno0NGzZgzJgxWL58OU6fPo3CwkLMmjULzZo1w/r169GnTx/Ex8cjOztb7rKJiIjIyvLz8+Hr62uwbdGiRQAADw8P3Lx5U46yyMbI3hy7ubmhf//+eOKJJ6DRaPDUU0+hTp06SE5ORlJSEu7cuYNevXrB2dkZkZGRCAkJwcGDB+Uum4iIiKzM09MT//77r/7na9euIS8vD3l5eSgoKICLi4uM1ZGtkH1ZxcMKCgpw7tw5dOvWDRcvXkRoaKjBFHJYWJisgd+MchPP0lPatho/VkKnE5CVVYSc2wVwcDD/41cSP8aYMSJSqiZNmuC9995D//794eTkhOPHj8PNzQ0rVqyAIAho1KiR3CWSDVBUc6zT6fD++++jVq1aaNiwIc6cOQOtVmtwjFarRUZGhtFt09PTkZ6eDgBITk62WI2MchPP0h+Gsp/4sSsWOWtJ/BhjxohIqQYOHIilS5ciPj4eTzzxBCZOnIi6deti69atCA4OxqBBg+QukWyAYppjQRDw0UcfISsrC3FxcdBoNHB3d0dubq7Bcbm5uXB3dze6fUJCAuLi4qxVLhEREVmZVqvF5MmTDbZVqlQJDRs2lKkiskWKaI4FQcCKFSuQmpqKWbNm6ZvfkJAQbN682eBKbWpqKlq2bGl0jhEjRqB79+4A7l85HjBggEVqZZSbeJZeVmGr8WMl7i+ruA4/P3+LLKtg/BgRKV1mZiYCAgJK3Xfnzh04ODjA2dnZylWRrVFEc5yQkICUlBTMnj0bFSpU0G+vX78+XFxcsGXLFkRHR+PIkSNIS0vD888/b3SO4OBgBAcHW7xWRrmJZ+nm2Fbjx0rodDr8+68jnniC44+I7NOwYcPQqVMnjBw50mjf5s2bkZWVhbFjx8pQGdkS2d9hMzIysGPHDly6dAlDhw5F79690bt3b3z99ddwcnLC9OnT8euvv6Jv37748ssvMXXqVPj4+MhdNhEREVmZs7Mzzpw5g+XLlxvta9euHf78808ZqiJbI/uV48DAQHz77bdl7g8NDcXChQutWBEREREpkaOjI2bNmoWZM2di6dKlGDNmjH4mMjAwELdu3ZK5QrIFsjfHasMoN/EsuazC1mPcAEa5EREB9z+UV9Igz5s3D+PGjYObmxtOnTpV5npkIlOwOTYRo9zEs2SUm/3EuAGMciMie+fm5oa4uDgsWLAAw4cPR61atZCcnFzqWmQiU7E5JiIiIlV46aWX9H93dXXF9OnT8ccff+DixYt4+eWXER4eLmN1ZCvYHJuIUW7iWXJZha3HuAGMciMi6tWrl9G2hg0bMueYzIrNsYkY5SaeJZtjW49xAxjlRkREZA18hyUiIiIiKsbmmIiIiIioGJdVmIhRbuIxyk0aS0a5lcS4AYxyIyIi+8bm2ESMchOPUW7mYv4ot5IYN4BRbkREZN/Y4RERERERFeOVYxMxyk08RrlJY8koN8a4ERER3cfm2ESMchOPUW7SMMqNiIjI8vgOS0RERERUjFeOTcS0CvEsdeXYHpIqAKZVEBERWQObYxMxrUI8S6VV2FdSBcC0CiIiIsthh0dEREREVIxXjk3EtArxLLWswh6SKgCmVRAREVkDm2MTMa1CPEs1x/aQVAEwrYKIiMga+A5LRERERFSMzTERERERUTEuqzARo9zEs8SyCnuJcQMsF+X2YIwbwCg3IiKyb2yOTcQoN/EsEeVmfzFugLmj3B6McQMY5UZERPaNHR4RERERUTFeOTYRo9zEs8SyCnuJcQMsF+XGGDciIqL/YXNsIka5iWeJ5theYtwARrkRERFZA99hiYiIiIiKsTkmIiIiIirGZRUmYpSbeIxyk8YSUW4Px7gBjHIjIiL7xubYRIxyE49RbuZivii3h2PcAEa5ERGRfWOHR0RERERUjFeOTcQoN/EY5SaNJaLcGONGRERkiM2xiRjlJh6j3KRhlBsREZHl8R2WiIiIiKgYm2MiIiIiomJcVmEiRrmJZ+5lFfYU4wYwyo2IiMga2BybiFFu4pk7ys0+Y9wARrkRERFZDjs8IiIiIqJivHJsIka5iWfuZRX2FOMGMMqNiIjIGtgcm4hRbuKZuzm2pxg3gFFuRERE1sB3WCIiIiKiYmyOiYiIiIiKcVmFiRjlJh6j3KQxd5RbaTFuAKPciIjIvrE5NhGj3MRjlJu5mCfKrbQYN4BRbkREZN/Y4RERERERFeOVYxMxyk08RrlJY+4oN8a4ERERGWNzbCJGuYnHKDdpGOVGRERkeXyHJSIiIiIqxuaYiIiIiKgYl1WYiFFu4plzWYW9xbgBjHIjIiKyBjbHJmKUm3jmjHKz3xg3gFFuRERElsMOj4iIiIioGK8cm4hRbuKZc1mFvcW4AYxyIyIisgY2xyZilJt45myO7S3GDWCUGxERkTXwHZaIiIiIqBibYyIiIiKiYlxWYSJGuYlnrmUV9hjjBpg3yq2sGDeAUW5ERGTf2BybiFFu4pkrys2+Y9wAc0S5lRXjBjDKjYiI7Bs7PCIiIiKiYrxybCJGuYlnrmUV9hjjBpg3yo0xbkRERKVTRHO8fft2/PTTT7hw4QKee+45TJw4Ub8vLS0NS5YswYULFxAUFITY2FhERETIViuj3MQzV3NsjzFuAKPciIiIrEER77B+fn7o3bs32rdvb7C9sLAQs2bNQrNmzbB+/Xr06dMH8fHxyM7OlqlSIiIiIrJlirhy3Lx5cwDA+fPncevWLf32pKQk3LlzB7169YKDgwMiIyPx3Xff4eDBg+jSpYsstYpJq7DXdIWHSflA3oPpCkxTICIiIktRRHNclosXLyI0NNSgEQ0LC0NaWprRsenp6UhPTwcAJCcnW6wmMWkVTFeQ7sF0BaYpEBERkaUoujnOz8+HVqs12KbVapGRkWF0bEJCAuLi4qxVGhERERHZIEU3x+7u7sjNzTXYlpubC3d3d6NjR4wYge7duwO4f+V4wIABFqlJTFqFvaYrPEzKsgqmKxAREZE1KLo5DgkJwebNmw2WMaSmpqJly5ZGxwYHByM4ONjiNYlJq7DXdIWHmSutgoj+v727jamy/uM4/jmAcg7gDUw9cyJgdwuXc+GDbFJSDXzgvCGpOcSmjum6m9p6YCsdpNHcrLCBctYDXLrCWdmctcRUlpqbDrfQxixW0hAnKFYYnA435/+g63/qBNq5DnCu48X79cjz4/LHV/bb+PLzy+cAAEZKVKRV9PX1yefzqb+/X/39/fL5fOrt7dWsWbM0duxYffbZZ+rp6dGpU6fU3NysefPmWV0yAAAAbCgqbo7379+vmpqawOvTp0/rySef1IYNG/TGG2+ooqJCNTU1mjJlil577TVNnDjRwmoBAABgV1HRHBcWFqqwsHDQj2VkZGjHjh0Rruj2iHILX7gzx/+McZOIcgMAACMnKprjuwlRbpH3zxg3iSg3AAAwcqJi5hgAAACIBtwcm0SUW/jCHasgxg0AAEQKzbFJRLmFjyg3AAAQ7RirAAAAAAw0xwAAAICBsQqTzEa5EeP2N6LcAABAtKM5NslslBsxbkNHlBsAAIgUxioAAAAAAzfHJpmNciPG7W9EuQEAgGhHc2yS2Sg3Ytz+RpQbAACIdoxVAAAAAAaaYwAAAMDAWIVJRLmFL5yZ43/HuElEuQEAgJFDc2wSUW6R9e8YN4koNwAAMHIYqwAAAAAM3BybRJRb+MIZqyDGDQAARBLNsUlEuYWPKDcAABDtGKsAAAAADDTHAAAAgIGxCpPMRLkR4xaMKDcAABDtaI5NMhPlRozb0BHlBgAAIomxCgAAAMDAzbFJZqLciHELRpQbAACIdjTHJpmJciPGLRhRbgAAINoxVgEAAAAYaI4BAAAAA2MVJhHlFj6zM8eDxbhJRLkBAICRQ3NsElFukTNYjJtElBsAABg5jFUAAAAABm6OTSLKLXxmxyqIcQMAAJFGc2wSUW7hI8oNAABEO8YqAAAAAAPNMQAAAGBgrMKkUKPciHEbyMzM8e1i3CSi3AAAwMihOTYp1Cg3YtyG5nYxbhJRbgAAYOQwVgEAAAAYuDk2KdQoN2LcBjIzVkGMGwAAsALNsUmhRrkR4zYQUW4AACDaMVYBAAAAGLg5Nom0ivCRVgEAAKIdzbFJpFVEBmkVAADACoxVAAAAAAZujk0irSJ8pFUAAIBoR3NsEmkV4SOtAgAARDvGKgAAAAADzTEAAABgYKzCpFCi3IhxG1yoM8d3inGTiHIDAAAjh+bYpFCi3IhxG5o7xbhJRLkBAICRw1gFAAAAYODm2KRQotyIcRtcqGMVxLgBAACr0BybFEqUGzFugyPKDQAARDvGKgAAAAADzTEAAABgYKzCJKLcwkeUGwAAiHY0xyYR5TbyiHIDAABWYawCAAAAMHBzbBJRbuEjyg0AAEQ7mmOTiHILH1FuAAAg2t0VzfGtW7dUWVmp8+fPy+VyKT8/X0uWLLG6LAAAANjMXdEcezwe9fT0qLq6Wm1tbdq8ebNSU1M1Z84cq0sDAACAjUT9L+R5vV6dPn1aK1euVEJCgjIyMpSXl6ejR49aXRoAAABsJupvjq9cuSK/36/09PTA2owZM3TmzJmg565evaqrV69KkhobGyNaIwAAAOwh6ptjr9erhISEoLXExER1d3cHrXk8HpWWlkayNAAAANhM1I9VOJ3OAY1wV1eXXC5X0Nq6detUX1+v+vp67du3L5IlAgAAwCai/uZ42rRpkqRffvlFaWlpkqSff/458Of/mzp1qqZOnRrx+gAAAGAfd8XN8bx587R37151dXWpublZtbW1ys3Ntbo0AAAA2EzU3xxLf41MVFRUaNWqVXK5XFq2bBkxbgAAABh2d0VznJSUpE2bNlldBgAAAGwu6scqAAAAgEihOQYAAAAMNMcAAACA4a6YOTbr/7nIw/1Oef39/bpx44ZaW1sVE8PPFWb5/X719fUpNjZWDofD6nLuOpy/oeMMDg1ncGg4f/+tvb1dV69e1Y0bN4a8161bt4ahIoxGtmyOL1++LEkqKiqythAAABCW4Xjvgri4uAHvsgv8F4ff7/dbXcRwu379uo4cOaKMjIwB76Q3FI2NjSoqKtK+ffuUmZk5bPsCoeD8wWqcQURCZ2enUlNTh+X7d0JCgiZOnDgMVWE0seXN8aRJk7RixYoR2z8zM1NZWVkjtj9wJ5w/WI0zCMDOGBoDAAAADLElJSUlVhdxN0lKSlJOTo7GjRtndSkYhTh/sBpnEIDd2XLmGAAAAAgHYxUAAACAgeYYAAAAMNAcAwAAAAZbRrmNhFu3bqmyslLnz5+Xy+VSfn6+lixZYnVZsKmenh5VVVXpu+++U2dnpyZNmqRnn31W8+fPt7o0jDK///67nn/+eU2dOlU7duywuhwAGHE0xyHyeDzq6elRdXW12tratHnzZqWmpmrOnDlWlwYb6uvrU0pKirZt2ya3263Gxka9+eabcrvdevDBB60uD6NIdXW1pk+frt7eXqtLAYCIoDkOgdfr1enTp/Xee+8pISFBGRkZysvL09GjR2mOMSKcTmfQG9nMnDlTmZmZamxs1D333KNdu3bp3Llz6uvr05QpU/Tqq68qLS3NwophRxcvXlRra6tyc3P11VdfSZJ8Ph/nD4Ct0RyH4MqVK/L7/UpPTw+szZgxQ2fOnLGwKowmXq9XTU1NWrRokY4fP67m5mZ5PB4lJiaqpaVFSUlJVpcIm+np6ZHH49Err7yin376KbDO+QNgd/xCXgi8Xq8SEhKC1hITE9Xd3W1RRRhN+vv7VV5ervvvv18PP/yw4uLi1N3drZaWFvn9fk2fPl3JyclWlwmb+fTTTzV79mzNmDEjaJ3zB8DuuDkOgdPpHNAId3V1yeVyWVQRRgu/369du3apo6NDpaWlcjgceuKJJ9TR0aHKykp1dHTo0Ucf1Zo1awb8AAeEq7W1VceOHdPOnTsHfIzzB8DueIe8EHi9XhUWFqq8vDwwV7dv3z61tLRo06ZNFlcHu/L7/aqqqlJTU5O2bt06aPPR0dGh7du3a9asWSoqKrKgStjRsWPHtHv37sCZ8/l88vl8SkpKUlVVVWCd8wfAjrg5DoHT6dS8efO0d+9ebdy4Ue3t7aqtrdX69eutLg025vF4dOnSJW3bti2oMW5oaNC4ceOUlpYmp9OpMWPGKCaGCSkMn+zsbGVlZQVenzx5UidOnNCWLVvU1NTE+QNgazTHIVq3bp0qKiq0atUquVwuLVu2jKQKjJi2tjZ9+eWXGjNmjNasWRNYLygokNvt1u7du3Xjxg3Fx8crKytLTz/9tIXVwm7i4+MVHx8feJ2YmKjY2FglJyeroaGB8wfA1hirAAAAAAz8XxgAAABgoDkGAAAADDTHAAAAgIHmGAAAADDQHAMAAAAGmmMAAADAQHMMAAAAGGiOAQAAAAPNMYCQ/frrr3I4HNqzZ0/EPmddXZ3KysoGrJeUlCgpKSlidQAARgeaYwBR7XbNcXFxsU6cOGFBRQAAO4uzugAAo093d7dcLteQ9khNTVVqauowVQQAwF+4OQZwWx988IEyMjKUkJCgp556Sk1NTUEfdzgc2rFjR9BaeXm5HA5H4HVdXZ0cDoe++OILFRQUaPz48XrmmWckSR9++KGys7OVkpKi5ORk5eTk6OzZs4G/W1JSotLSUv3xxx9yOBxyOBzKyckJfOzfYxXNzc0qKCjQhAkTlJiYqAULFujChQtBz2RkZOill15SZWWl0tPTNWHCBC1dulTt7e1D/noBAO5+3BwDGNThw4e1du1arVq1SsuXL1d9fX2gqQ3H2rVrVVRUpIMHDyo2NlaSdPnyZT333HO699575fP59PHHH+vxxx9XQ0ODHnjgARUXF6ulpUUfffSRjh8/LkkaP378oPt3dnYqJydHMTExqqqqktPp1FtvvRXYb/r06YFnDx06pB9//FGVlZW6fv26Nm7cqJdfflk1NTVh//sAAPZAcwxgUNu2bdNjjz2m6upqSdKCBQvk9Xq1devWsPZbvHixtm/fHrS2ZcuWwJ/7+/uVm5urs2fPas+ePSorKwuMTsTExGju3Ll33L+6ulrNzc36/vvvlZmZKUmaP3++0tLSVF5ernfeeSfwrN/v16FDhxQfHy/prya9rKxM/f39ionhP9QAYDTjuwCAAfr6+lRfX6/8/Pyg9YKCgrD3XLhw4YC1xsZG5efny+12KzY2VmPGjNGlS5f0ww8/mN7/5MmTeuihhwKNsSSlpKQoNzdXp06dCnp2/vz5gcZYkmbOnKmenh61tbWZ/rwAAHvh5hjAAO3t7ert7dWUKVOC1t1ud9h7/vvvdnZ2Ki8vT5MnT9a7776r9PR0OZ1OFRcXy+v1mt7/5s2bg9bndrt18eLFoLWJEycGvR47dqwkhfV5AQD2QnMMYIDJkycrLi5uwE3qtWvXgl7Hx8fL5/MFrd28eXPQPf/5S3qSdObMGbW0tOjw4cOaPXt2YP23334LK4UiJSVFly5dGrB+7do1paSkmN4PADA6MVYBYIDY2FhlZWXp4MGDQeuffPJJ0OvU1FQ1NjYGrR09ejSkz9Hd3S3p71tbSfr22291+fLloOfGjh2rP//88z/3y87O1oULF4Ia5Js3b+rrr79WdnZ2SDUBAEBzDGBQr7/+uk6ePKnVq1fryJEjKisr0969e4OeKSgo0IEDB/T+++/ryJEjWrlypa5cuRLS/nPnzlVSUpJefPFF1dbWqrq6WsuXL9e0adOCnsvMzFRvb6927typc+fODXo7LEmrV69Wenq6Fi5cqJqaGn3++efKy8tTXFycNmzYEN4XAQAw6tAcAxjU4sWLVVVVpWPHjmnp0qWqra3V/v37g57ZvHmzCgsLVVpaqqKiIqWnp2v9+vUh7e92u3XgwAG1tbVpyZIlKi8vl8fj0X333Rf03KJFi/TCCy/o7bff1iOPPKJ169YNut+4ceNUV1en2bNna+3atVqxYoWSk5P1zTffBMW4AQBwJw6/3++3uggAAAAgGnBzDAAAABhojgEAAAADzTEAAABgoDkGAAAADDTHAAAAgIHmGAAAADDQHAMAAAAGmmMAAADAQHMMAAAAGGiOAQAAAAPNMQAAAGD4H5HI0niWBYDVAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -907,7 +907,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 21, @@ -951,7 +951,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "37f219e7ebcb48fa840daa4e4c61527f", + "model_id": "6d9dfdca9a5948b996aa7ff469e7703a", "version_major": 2, "version_minor": 0 }, @@ -981,7 +981,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -992,7 +992,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 22, @@ -1045,7 +1045,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5a99744f03e644eda63ced46c6d9b81d", + "model_id": "ecb60e878f194caf8f1e9a9d1aa2dfd5", "version_major": 2, "version_minor": 0 }, @@ -1075,7 +1075,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsQAAAHICAYAAABJf/xlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XlYVGX/P/D3gOwgyCooyKKR5o6apeCCmrmAqZl+c81CK61H08c9QU00w0zRXDI11yc1oqw0cUszrdzSQE0FzC1QFGVxgTm/P/jNxHjOAIMzc2Z5v67L65IzZ858ONwMn7nnnvdRCIIggIiIiIjIStnIXQARERERkZzYEBMRERGRVWNDTERERERWjQ0xEREREVk1NsREREREZNXYEBMRERGRVWNDTERERERWjQ0xEREREVk1NsREREREZNXYEFuY4OBgdOzYUe4y6AlkZWVBoVAgPj6+2scwxjhQKBQYPny4QR+DKtaxY0cEBwfLXUa1zJo1Cz4+Prh3716V9l+7di0UCgX2799v2MIMqLq/l+vXr4ejoyOysrL0XhMRlWFDbEAKhULrvzNnzoj2Lykpwfz58xEeHg4HBwcEBATgzTffxK1bt2So3jDi4+Px9ddfG/Uxi4qKMHnyZAQHB8PBwQHBwcGYMmUKioqKqnyMv/76C/Hx8WjXrh1q164NFxcXNGrUCO+88w6uX79uwOrlk5WVhfj4eJw8eVLuUvRq5cqVGDJkCJ555hnUqFEDCoUCV65ckbssq3LlyhXMnz8fU6ZMgZubm3r7/v37ER8fjzt37shYnel59dVXERYWhokTJ8pdCpHFqiF3AZYuMjIScXFxou2BgYGibSNGjMCGDRvQq1cvTJgwAZmZmVi0aBEOHTqEI0eOwMXFpdLHO3fuHBQKhV5qN4SEhAQMGzYMffr0McrjlZaWokePHjhw4ACGDBmCqKgonDp1CgsWLMCvv/6K3bt3w8am8teFq1evRnJyMnr37o0BAwbAyckJR44cwbJly7BhwwYcPnwYTz/9tF5qrlevHoqLi1Gjhry/nllZWUhISEBwcDCaN28uur24uBi2trYyVPZk5s6di5s3b6J58+YIDg7GxYsX5S7J6nz44YewsbHBqFGjNLbv378fCQkJGD58ODw8PGSqzvTY2NjgP//5D+Li4nDmzBk0btxY7pKILA4bYgMLDQ3F4MGDK91v79692LBhA2JiYpCamqreHhERgf79+yMpKQnvv/9+pcdxcHB4onotzbp163DgwAGMHTsWixcvVm8PDg7GhAkTsGHDBgwdOrTS4/Tv3x+TJ0/W+CMdFxeHtm3bYtSoUXj//ffx5Zdf6qVmhUIBR0dHvRzLkMyhRin79u1DvXr1YGNjg+HDh5tdQywIAgoLC+Hq6mrUx7179y5q1qz5xMcpKCjAunXr8PLLL1fpRb4+FRcXw87OTvYXm9UxYMAAvPPOO1i2bBmWLVsmdzlEFodLJozg0aNHla6T++KLLwAA48eP19jer18/BAcHq2+vjNQaNdW28+fPIzY2Fu7u7nB1dUWPHj1w4cIFjX33798PhUKBtWvX4tNPP0XDhg3h6OiI4OBgxMfHo6SkRGP/itYwll9jqjouUNakll8+onLkyBH07t0bAQEBcHBwgL+/Pzp16vRESyxU5+29997T2P7WW2/Bycmpyue1VatWkjNWAwcOBAD88ccfGtuvXLmCuLg4hISEwNHREd7e3oiIiMDcuXMrfSxta4iVSiUWL16MZs2awcnJCTVr1kTnzp2xe/durcc6deoUunXrBjc3N7i7u6Nv375VagDj4+PRqVMnAGXvXKh+VuXHltQaYtW2n376Ce3bt4eLiwv8/PwwadIklJaW4sGDB5g8eTICAwPh6OiI1q1b48iRI5I1bN++HR06dEDNmjXh5OSEFi1a4LPPPqu09sqEhIRU6V0BbTZt2gSFQoFvv/1WY3ujRo2gUCiwfv16je3PP/88QkNDNbadPXsWAwcOhJ+fHxwcHBAaGooJEybg7t27Gvup1s2mpaUhMTERTz31FBwcHPDRRx9pre/evXvo3r07HBwcsGHDBo3bqnpOVc8Zf/zxB3r27IlatWrB3d0dQFlDvmTJErRo0UL9XBIWFob/+7//q9LyoZ07d+Lu3bvo2bOnxvaOHTsiISEBQNnPSDXmHv89EAQBixYtUp+LkJAQLFy4UPQ4quem7OxsDBw4EN7e3nB2dtZYHlPV8/Hjjz9i0KBBCAsLU//uRUVFicaAyrFjx9ClSxe4uLigVq1a6Nevn9b1vzt37kTnzp3h6+sLR0dH1K1bFy+++CIOHjyosZ+7uzvat2+PrVu3QhAEyWMRUfWZ38tkM7Nt2zZs2LABpaWlcHd3R69evTBnzhxRE3n06FHY2Nigbdu2omM899xz2Lx5M/Ly8uDp6VmtOq5evYqoqCjExMRg/vz5+Ouvv7BkyRLExsbi9OnTogYhOTkZV65cwejRo+Hp6YnU1FQkJCTg4sWLoj/4VdGwYUOsX78eQ4YMkVxGcv78eURHR8PX1xdvvfUWAgICcPPmTRw7dgy//PJLtZZYCIKA3377DQEBAahXr57GbU5OTmjevDl+++03nY9b3tWrVwEAfn5+6m0lJSXo2rUr/v77b7z55pt4+umnUVBQgLNnz2Lv3r2YOnVqtR5r+PDhWL9+Pdq1a4e5c+eioKAAn332GV544QV88cUXoncirly5gk6dOiEmJgYffvghMjIysHz5chw+fBjHjh1DnTp1tD5W37598ejRI8ydOxdxcXGIjIwUfZ/anDhxAn369MHIkSMxePBgfP/99/jwww9ha2uL06dP4+7du5gwYQIKCwuRlJSEXr16ITMzU2Mt6cyZMzFr1ix06tQJM2fOhJOTE3bt2oU33ngDFy5cwLx586p1DvUhOjoaAJCWlobevXsDAK5du4aMjAzY2NggLS0NQ4YMAVA2q/rbb79hxIgR6vufPHkSUVFRKCkpwVtvvYXQ0FAcOnQISUlJ2LNnD37++Wc4OztrPObEiRNRVFSEYcOGwcfHR3LJlaqOHj16ICsrCzt37lS/qAF0P6d///03OnTogJdeegmJiYm4ceMGgLIlJ9OnT0ePHj3w+uuvw97eHpcvX8bOnTtx7do1+Pv7V3j+9u3bBwCi57pp06bB09MTKSkp+Pjjj+Ht7Q0AaNq0qcZ+U6dOxd27dzFixAi4urriiy++wHvvvYeAgAD1C1SVgoICREZGonXr1khISMC9e/fUM+u6nI+1a9fin3/+weDBg1G3bl3k5uZi3bp1iImJwZYtW/DKK6+o9z1+/DiioqJga2uLsWPHIjAwED/++CM6duyIwsJCjfp++ukn9OrVC40aNcLEiRPh5eWFGzdu4PDhwzhx4oT6907l+eefR1paGk6fPi06L0T0hAQymFatWgmJiYnC9u3bhU2bNglvvfWWYGdnJ3h6egoZGRka+7q6ugq+vr6Sx5k4caIAQDh16lSlj1mvXj2hQ4cOom0AhE2bNmlsT0xMFAAIu3btUm/bt2+fAEBwdnYWsrKy1NtLS0uFPn36CACEffv2qbd36NBBqFevnmQtAIRhw4ZVuk0QBOGTTz4RAAhHjhyp9Husqps3bwoAhDZt2kje/vLLLwsAhPz8/Go/Rr9+/QQAwpo1a9TbTp06JQAQ5s2bV61jZmZmCgCEmTNnqrft2bNHACC8+OKLQklJiXp7Tk6O4OvrK3h4eAj37t1Tb1f9zBcsWKBx7K+++krrz+BxqrFQ/nsrT9vPV6FQCIcPH9bY3rx5c0GhUAg9e/YUlEqlentKSooAQFixYoV62/HjxwWFQiG88847osccM2aMYGNjI1y8eLHS+qti2LBhAgDh77//1ul+jRs3Fho1aqT+et26dYJCoRCGDBki1KlTR709NTVVACBs2bJFvS0yMlJQKBTCoUOHNI6ZkJAgABBmz56t3rZmzRoBgBAWFqbx81Up//t3+vRpITAwUAgMDBROnz6tsZ+u51Q1fj799FPR/i1atBAaNmyo7dRUqkOHDoKjo6PkbTNnzhQACJmZmaLbVOeiadOmwv3799XbCwoKBC8vL+G5554TPQ4AYdKkSaJj6Xo+CgoKRPsVFhYKDRo00BgHglD287WxsRF+//13je2jRo0SAGg8P48bN04AINy4cUN0fCnr168XAAgbNmyo0v5EVHVcMmFAv/32GyZPnoy+ffti0KBBWLp0KVJTU5GXl4f//Oc/GvsWFRVpXf+rWqupSyrC4wICAjBo0CCNbV27dgVQNjv7uMGDB2vMqtrY2GDKlCkAyt5m1DfVcoSvv/4axcXFejmm6nwZ6rzOnTsX27dvR58+fTBs2DD1dtVby/v27VPPqj0p1TmfMWOGxgfZfHx88Pbbb+POnTvYs2ePxn3c3NwwduxYjW0vvfQSGjZsiJSUFCiVSr3U9rjnnnsOzz33nMa2qKgoCIKAd999V2OZTIcOHQBojsGNGzdCEASMHDkSN2/e1PgXExMDpVKJtLQ0g9ReVdHR0UhPT1cvEdizZw+aNm2KQYMG4erVqzh79qx6u0KhQOfOnQEAubm5OHjwILp27Yp27dppHHPChAlwcXGR/P0aM2ZMhWuG9+7di/bt28PLywtHjhwRfeiqOufU09MTb7zxhuixPDw8cPXqVRw4cKAKZ0osNzcXXl5e1bovUHYuyv9Ou7i44LnnnpN8HgOASZMmibbpej7Kr3UuLCzErVu3UFRUhM6dOyM9PV29JE718+3evTsiIiI0HnPGjBmiOlTPe1u3bsWjR48q/d5V5y0nJ6fSfYlIN2yIjezFF1/Es88+iz179uD+/fvq7c7Oznjw4IHkfVT7Pf42qi4eX8MI/PvkKhXr1qhRI63bHl93rA8DBw5E9+7dMW/ePNSqVQtRUVGYPn26ZDxdVanOV1XPa15eHm7cuKHxr7S0VPK+n3zyCaZNm4aOHTti48aNGk1evXr1MHPmTOzevRsBAQFo1qwZ3n777QrX+lbm0qVLAIAmTZqIblNte3xtcFhYmOSLgUaNGuHu3bvIzc2tdj0VkRprtWrVkrxNtb38GMzIyAAANGvWDD4+Phr/unXrBgD4559/DFJ7VXXp0gUA1C9C9uzZgy5duiAqKgr29vbqZiotLQ1NmjSBj48PgIp/js7OzggLC5Nc4/3UU09preWff/5B9+7d4e/vj59++gkBAQGifapzTsPCwiRTRBITE+Hi4oKOHTuidu3aePnll7F8+XLk5+drrfFxwhOsgdX2XCb1PObj46MeY+Xpej6ysrIwZMgQeHl5wdXVFd7e3vDx8cGKFSsAALdv3wbw7++g1PNnnTp11C+WVcaMGYNWrVph7NixqFWrFrp27YoPPvgAmZmZkt+76ryZcpIQkbniGmIZhISE4OjRo8jLy1P/8apbty7Onz+PBw8eiJoY1YdA6tatW+3HrCge60n+OGl7Yn78w3eVsbe3xw8//IDjx49j165dOHToED7++GPMnTsXCxYsEH0orio8PT1FH6Ip78qVK6hZs6b6k/N9+/YVzXplZmaK1nsvXLgQ7733HqKjo/HNN99IvlCJj4/HiBEj8MMPP+DgwYPYvn07li1bhtjYWKSkpFj0H7SKxpq228qPQdXM9Y4dO7TO7ks1RcbUoUMH1KhRA2lpaYiIiMDVq1fVH6Jq27Yt0tLS0K9fP6Snp2PcuHFP/HgVvRj29PRE69atkZqaitWrV4vefQKqd061Peazzz6LCxcuIC0tDfv27cOBAwewbds2vP/++/jpp58qjR/08fFRvzCoDl2i/rR9D7qcj4KCAkRFRSE/Px/vvvsumjZtipo1a8LGxgaff/45Nm/eXO13Wzw9PXH06FEcPnwYaWlpOHjwIBISEpCQkID169drrE0G/n3h6OvrW63HIyLt2BDL4Pz587Czs9N427BNmzY4e/Ysjh49iqioKI39f/nlF4SFhVX7A3XVkZ6ernVb/fr11ds8PT1x7Ngx0b7V/YPXsmVLtGzZEkDZrMvzzz+PqVOnYuzYsbC3t9fpWAqFAq1atcJPP/2E7OxsjSUgxcXFOHnyJJ5//nn1tqSkJPVMj0rt2rU1vp4/fz4mT56M7t27IyUlpcLosXr16mH06NEYPXo0SkpKMHz4cGzcuBEHDhzQ+WpVYWFhAIA///wTzz77rMZtqll01T4qFy9elHyBlZ6ejpo1a6pnLbWRq2l/6qmnsHPnTvj7+6vHgqlxc3NDmzZtsGfPHkRERMDe3l79Aajo6GgsXLgQu3btAvDvbDLwb5P1559/io5ZXFyMS5cuafx+VYWdnR22bduGIUOGYNy4cSgsLMS0adM09tH3OXV2dkZMTAxiYmIAlCUlvPjii5g3bx7Wrl1b4X0bN26MAwcO4O+//xZ9ONBYY06X87F37178/fffWL16NV577TWN21atWqXxtep3UOr58+rVq5Kz6DY2Nmjfvj3at28PoOzDjC1btsSkSZNEDfFff/0FQPodBiJ6MlwyYSDari63efNmHD9+XB2LpKL6VHpSUpLG/l999ZX67Tpj2rBhA7Kzs9VfK5VKJCYmAiibSVUJDw/HvXv38Ouvv2rcf8GCBZLHdXV1RV5enmj7zZs3Rdtq1aqF0NBQPHz4sMqXd32ctvP66aefori4WOO8RkREoEuXLhr/yje8c+fOxeTJk9GrVy98/fXXWpvh/Px80XrAGjVqoFmzZgC0j42KqM753LlzNWajbt68iaVLl8LDw0OdfqBy7949LFmyRGNbSkoKMjIy0KdPn0qjx1RrVqV+Xoak+plMmTJFcl1lfn6+1mUwxtSlSxdcuXIFy5cvR9u2bdXrTLt06YL8/HwsWLAAdnZ2Gi9wfXx8EBkZiV27dol+Z5KSklBQUIB+/frpXEuNGjWwceNGjBgxAtOnTxclmejznEottVGtl63K2Fa9GDx8+LDoNmONOV3Oh2pG+vF30v744w9RJKSPjw/at2+PnTt34vjx4xq3zZkzR/Q4UucyMDAQfn5+kufyl19+gbe3t2iN+MWLF9Xr1omoejhDbCBz5szBzz//jM6dOyMoKAgPHz7Ezz//jO3bt8Pf3x+LFi3S2L9Lly4YNGgQNm/ejN69eyM2NhaZmZn4+OOP0ahRo2otGXgSDRs2xLPPPos333wTnp6e+Prrr7F3714MHDhQI8pp1KhRSEpKQp8+ffDuu+/C2dkZ3333ndb1hKq3k+fPn4+goCAoFAoMHDgQc+bMwc6dO9GrVy+EhISgRo0aOHDgAL7//nv06tVLYzZdlS1alaUeI0aMwBdffIElS5YgPz9ffaW6ZcuWoWPHjlW6aAoALF26FNOmTYOfnx/69u2LrVu3atzu6uqqjobbt28f3njjDbz00ksIDw+Hh4cH0tPTsXz5ctSpU0djxrCqOnfujCFDhmD9+vXo1KkTXnrpJXXsWk5ODr744gvRh67CwsIwd+5c9axyRkYGPv30U/j4+Ej+cX5co0aN4ObmhmXLlsHZ2RkeHh7w9fVVf0DMUFq1aoU5c+Zg+vTpaNy4MQYNGoS6desiJycHp0+fRmpqKtLT09VLWdauXYsRI0Zg5syZosxaKd9++y1OnToF4N/86MWLF6uXzowdO1a01lNKdHQ0Zs2ahfT0dMyaNUu9vU2bNqhZsybS09PRrl070c9l8eLFiIqKQufOnfHmm2+qY9c2bdqEZs2aibLIq8rGxgarV6+Gs7MzEhMTUVhYiEWLFqnfKdHlnFZE9dzQpk0b1K1bF3l5eVi3bh0AaHy4VJvu3bujZs2a2LFjh2gGVBXFNmnSJLz66qtwdHRE48aN9X5lNl3OR7t27eDv74/33nsPly5dQnBwMDIyMrBq1So0adJE9A7Zxx9/jKioKHTs2BFvv/22OnbtxIkT6ig5lbi4OFy+fBndunVDcHAwSkpKsGPHDvz5558YM2aMxr75+fk4dOiQOhe8vOjo6Co/JxKRFjKlW1i81NRUoXv37kLdunUFR0dHwcHBQQgPDxfGjx8v/PPPP5L3efjwoTB37lyhQYMGgr29vVC7dm0hLi5OyM3NrfLjaotde3ybIEjHe5WP2lq6dKkQHh4u2NvbC4GBgcKMGTOEhw8fio6za9cuISIiQrC3txd8fHyE0aNHC3fu3JGM5Tp//rzQtWtXwc3NTQAgqIbgvn37hFdeeUUIDg4WnJychJo1awpNmzYV5s+fLxQVFWkcw8vLSwgICKjyObl3754wceJEISgoSLCzsxOCgoKE//73v5JRStqo4rm0/SsfPXfp0iVh9OjRQqNGjYSaNWsKTk5OQv369YWxY8dWKd5L6uciCGXRd4sWLRKaNGkiODg4CK6urkKnTp00YvNUVD/zkydPCl27dhVcXV0FNzc3ITY2Vvjrr7+q/H1/9913QosWLQQHBwdRZJTUz1dqmyBUHKel7T47d+4UevToIXh5eQl2dnZCQECA0KlTJyEpKUkoLi5W77d48WIBgLBy5coqfU+V/SylapTy8OFDwcXFRQAgipnr3bu3AEB4//33Je+bnp4uDBgwQPD29hbs7OyEevXqCePHjxfu3LmjsZ8qaqx81GF52mIP//vf/woAhNdff10oLS1Vb6/qOdX2nCEIZXGNHTp0EHx9fQU7Ozuhdu3aQvfu3YUff/xRcn8pY8eOFZydnYW7d++Kbps/f74QEhIi1KhRQ+P3oKJzofqZlldRJKRKVc/H6dOnhR49egi1atUSnJ2dhbZt2wqpqalax/Wvv/4qdOrUSXB2dhbc3d2Fvn37CpmZmaLzun37diE2NlYIDAwUHBwchFq1aglt2rQRli9frvFzEwRBWLlypQBAFKknCP/G5BFR9SkEgS8p6V/79+9Hp06dsGbNGtFVyEzByZMn0aJFC3z++ecaFzuwJBcuXECDBg0we/ZsTJ8+Xe5yTF6fPn3w559/Ij09HXZ2dnKXQ1Vw5coVhIeHIz4+HhMnTpS7HJOnVCrRpEkTNGrUSPTuFBHpB9cQk1nZuXMnmjVrVqW3Zs3VtWvXAPCT5FXx6NEj7N27F/PmzWMzbEbq1q2LSZMm4cMPP6z25wOsycaNG3Hx4kWtn80goifHGWLSYOozxJbs9u3b2LZtG1atWoUTJ07g/PnzCAkJkbssIiIii8cZYiITkZ2djTFjxqC4uBhbt25lM0xERGQknCEmIiIiIqvGGWIiIiIismpsiImIiIjIqrEhJiIiIiKrxoaYiIiIiKwaG2IiIiIismo15C7AEIqKinD27Fk8/fTTcHZ2lrscIiIiqqI7d+6gqKhIL8dydnaGh4eHXo5Fls0iG+KzZ88iIiICx44dQ8uWLfV2XEEQcO/ePbi5uUGhUOjtuOZOEAQolUrY2NjwvDyGY0Yax4w0jhdpHC/SLHG83LlzB8nJySgpKdHL8WrUqIExY8awKaZKWWRDbCiCIKCgoACurq4W8+SjL6o/VqSJY0Y7jhkxjhftOF7ELHG8FBUVoaSkBC1atICrq+sTHaugoAAnTpxAUVERG2KqFBtiIiIiMimurq5sYsmo+HKbiIiIiKwaG2IiIiIismpsiImIiIjIqrEhJiIiIiKrxoaYiIiIiKwaG2IiIiIismpsiImIiIjIqrEhJiIiIiKrxoaYiIiIiKwaG2IiIiIismqyX7p50aJF+Omnn1Cjxr+lLF26FD4+PgCA3NxcLFmyBBkZGXB3d8fQoUMRFRUlV7lEREREZGFkb4gBIDY2FsOGDZO87aOPPkJwcDCmTZuG8+fPY86cOahXrx7q1atn5CqJiIiIyBKZREOszbVr13D+/HnMmDEDDg4OaNKkCdq0aYO9e/dixIgRstT06NEjPHz4EDY2XG2iIggCSkpKoFQqoVAo5C7HpCiVSo4ZCRwz0sxtvGReLjXK4wiCgNLSUtja2prseAkJstX42t7eXqZKiKg6TKIh3rVrF3bt2gVvb2/07t0bXbt2BQBkZ2fDx8cHrq6u6n1DQkLwxx9/iI5x/fp1XL9+HQCQkZFhsFrv3LmDGjVqmOyTshzM4Y+VXARB4JiRwDEjzdzGy8z5RXKXYDIWJjhrfB0QECBTJURUHbI3xL1798Zrr70GFxcX/Pnnn5g/fz5cXFzw/PPP4/79+xrNMAC4uLiguLhYdJwVK1YgISHBWGUTERERkYWQvSEOCwtT/79p06bo2bMnfv75Zzz//PNwdHREYWGhxv5FRUVwcnISHWfUqFGIiYkBUDZDPHjwYIPU6+HhAS8vL7N4O9NYVG9/m8usljEplUqUlJRwzDyGY0aauY2XhElcMqHi7W1b+U5EZLJkb4gfp1AoIAgCAKBevXrIzc1FQUGBeqb40qVLkh+o8/f3h7+/v8Hrs7Ozg729vVn8sTIWQRBgY2PD5kaCUqnkmJHAMSPN3MZLeH3jPA5fQBGRocn+jHvo0CEUFRVBqVQiPT0d3333Hdq2bQugbA1W/fr1sWHDBjx48ABnzpzBr7/+is6dO8tcNRERERFZCtlniHfs2IGlS5dCqVTC29sbgwcP1sgZnjhxIhYvXoxXX30VHh4eeOuttxi5RkRERER6I3tDPG/evApv9/HxwezZs41UTeXMKRLJWBihpZ25xWgZC8eMNLnGi7Hi06rLHNYQy0GpFJCXV4r8gvuwsdH/eXk8Sq48xsqRpZG9ITY35hSJZCz8Y6WducVoGQvHjDS5xgvj08zdNYMc9fEoufIYK0eWhlNWRERERGTVOEOsI8auifET4NqZW4yWsXDMSJNrvBgrPq26+I6CtLIlE7fg6ellkCUTjJIja8KGWEfmFIlkLIzQ0s7cYrSMhWNGmlzjxVjxadXFF1DSlEolbtywRe3ajnx+IXpC/A0iIiIiIqvGhpiIiIiIrBqXTOiIEVpijNDSjrFr0jhmpBlyvJSPVns8TosRWkRk7dgQ64gRWmL8wIt2jF2TxjEjzZDjpXy02uNxWozQIiJrxykrIiIiIrJqnCHWEWPXxPgJcO0YuyaNY0aaIcdL+Wg1xmkREWliQ6wjRmiJMUJLO8auSeOYkWbI8WLq0WpERHLiX2giIiIismpsiImIiIjIqnHJhI4YoSXGCC3tGLsmjWNGmrFi18weSD22AAAgAElEQVSNKaeSPB5hp8IoOyLzwoZYR4zQEjPlP1ZyY+yaNI4ZacaKXSP9eTzCToVRdkTmhVNWRERERGTVOEOsI8auiTFCSzvGrknjmJFmrNg1c2PK7ygwwo7IMrAh1hEjtMQYoaUdY9ekccxIY+yaNL6AIiJD419oIiIiIrJqbIiJiIiIyKpxyYSOGKElxggt7Ri7Jo1jRlpVxos5x6dVl77WEDMijYi0YUOsI0ZoiZnyB17kxtg1aRwz0qoyXhifVn2MSCMibThlRURERERWjTPEOmLsmhg/Aa4dY9ekccxIq8p4Mef4tOrS1zsKjEgjIm3YEOuIEVpijNDSjrFr0jhmpFVlvJhzfFp18QUUERka/0ITERERkVXjDLGOmBggxsQA7ZgyIY1jRhpTJqTxQ5jSlEoBeXmlyC+4DxsbzfNSPlGDKRpElWNDrCMmBojxj5V2TJmQxjEjjSkTVD3XRFvKJ2owRYOocpyyIiIiIiKrxhliHTFlQowfeNGOKRPSOGakMWVCGt9RkFa2ZOIWPD29REsmmKhBpBs2xDpiYoAYEwO0Y8qENI4ZaUyZkMYXUNKUSiVu3LBF7dqOfH4hekL8DSIiIiIiq8aGmIiIiIisGpdM6IgRWmKM0NKOsWvSOGakqcbLuQviGC1rplpD3CjcVe5SiMhCsSHWESO0xPiBF+0YuyaNY0aaarwkJj+SuxSTtHklG2IiMgxOWRERERGRVeMMsY4YuybGT4Brx9g1aRwz0lTjZeZEHy6ZKEf1jgIRkaGwIdYRI7TEGKGlHWPXpHHMSFONl/BAxmiVp3oBRURkKHzGJSIiIiKrxoaYiIiIiKwal0zoiBFaYozQ0o6xa9I4ZoDMy+I1sWWX4i1FfgFj18rTZypJSJD4ksb29vZPdEwiMn9siHXECC0xRmhpx9g1aRwzwMz5RRXces1odVibhQnOom0BAQEyVEJEpoRTVkRERERk1ThDrCPGrokxQks7xq5J45gBEiZpWzJxC56eXlwyUY4+31Hw9hYvmSAiYkOsI0ZoiTFCSzvGrknjmAHC64u3KZVK3Lhhi9q1GbtWHl9AEZGh8RmXiIiIiKwaG2IiIiIismpcMqEjRmiJMUJLO8auSbOWMSMVrVYRfceulY8YY7QYEZF2bIh1xAgtMUZoacfYNWnWMmYqjlariH5i18pHjDFajIhIO05ZEREREZFV4wyxjhi7JsZPgGvH2DVp1jJmpKLVKqLv2DVGjBERVQ0bYh0xQkuMEVraMXZNmrWMGalotYowdo2ISB58xiUiIiIiq8aGmIiIiIisGpdM6IgRWmLWEqFVHYxdk2ZuY0bX+LTq0nfsmj6Vj3BTYZQbEVkKNsQ6YoSWmLVEaFUHY9ekmduYqX58WnXpJ3ZNn8pHuKkwyo2ILAWnrIiIiIjIqnGGWEeMXROzlgit6mDsmjRzGzO6xqdVl75j1/SJEW5EZMlMqiG+e/cu3nzzTfj7++Ojjz4CAGRnZ2PJkiXIysqCn58f4uLi0KxZM9lqZISWmLVEaFUHY9ekmduY0TU+rboYu0ZEJA+TesZds2YNAgMD1V+XlJRg9uzZaNOmDTZv3oyBAwciMTERd+7ckbFKIiIiIrIkJtMQnzlzBteuXUOXLl3U206fPo0HDx6gf//+sLOzQ2RkJIKCgvDzzz/LWCkRERERWRKTWDLx6NEjrFixAuPHj8elS5fU2y9fvozg4GCNtw5DQ0ORnZ0tR5kAGLsmxdwitIyJsWvSTHHMGCtarSKmHLsmp+BAG/WacyIiQzCJZ5ft27ejWbNmCAkJ0WiIi4uL4eLiorGvi4sLcnJyRMe4fv06rl+/DgDIyMgwWK2M0BIztwgtY2LsmjRTHDPGj1ariOnFrskpKd4JpaWlcHYWR78REemD7A3xtWvXsGfPHnzyySei25ycnFBYWKixrbCwEE5OTqJ9V6xYgYSEBIPVSURERESWSfaGOCMjA7dv38bo0aMBAA8fPsTDhw8xdOhQvPXWW8jOzoZSqVS/3ZyZmYmoqCjRcUaNGoWYmBj1MQcPHmyQehm7JmZuEVrGxNg1aaY4ZowVrVYRU45dk5O3d9mSCSIiQ5G9IW7fvj1atmyp/vrgwYPYt28f3n//fbi5ucHe3h5fffUVYmNjcfToUWRnZ6Ndu3ai4/j7+8Pf39/g9TJCS8zcIrSMibFr0kxxzBgrWq0ijF2TphovRESGIntD7ODgAAcHB/XXLi4usLW1Ra1atQAA06dPR3JyMrZs2QJfX19MmTIFHh4ecpVLRERERBZG9ob4cdHR0YiOjlZ/HRwcrL5IBxERERGRvplcQ2zqGKElZooRWqaCsWvSTHHMmHrsWkhQ2aWT7e3t5SiNiMiisSHWESO0xEwxQstUMHZNmimOGVOPXVuYUBY5FhAQYOxiiIgsHqesiIiIiMiqcYZYR4xdEzPFCC1Twdg1aaY4Zkw9ds3b21amqoiILB8bYh0xQkvMFCO0TAVj16SZ4phh7BoRkfXiMy4RERERWTXOEOuIiQFippgYYCqYMiHNkGPG2GkRqvQHKUyEICIyD2yIdcTEADFTTAwwFUyZkGbIMWPstAhV+oMUJkIQEZkHTlkRERERkVXjDLGOmDIhZoqJAaaCKRPSDDlmjJ0WwfQHIiLzx4ZYR0wMEDPFxABTwZQJaYYcM6aQFkFEROaFf6GJiIiIyKqxISYiIiIiq8YlEzpihJYYY9e0Y+yatCcdM8aOVjOWsivVlSK/4L7oSnXVUT4SjhFwRETasSHWESO0xBi7ph1j16Q96ZgxdrSa8V3Ty1HKR8IxAo6ISDtOWRERERGRVeMMsY4YuybG2DXtGLsm7UnHjLGj1YylbMnELXh6eullyQQj4YiIqoYNsY4YoSXG2DXtGLsm7UnHjKVGqymVSty4YYvatR05XoiIjIjPuERERERk1dgQExEREZFV45IJHTFCS4yxa9oxdk1aVcaMpUarVUTfsWuGFBJkyyg3IrIYbIh1xAgtMcauacfYNWlVGTOWH61WEf3ErhnSwgRnRrkRkcXglBURERERWTXOEOuIsWtijF3TjrFr0qoyZiw1Wq0i+o5dMyRGuhGRJWFDrCNGaIkxdk07xq5Jq8qYsdRotYowdo2ISB58xiUiIiIiq8aGmIiIiIisGpdM6IgRWmKMXdOOsWvSTD12LSRIc30s48WIiCwbG2IdMUJLjLFr2jF2TZqpx64tTHDW+JrxYkRElo1TVkRERERk1ThDrCPGrokxdk07xq5JM/XYNUaKERFZFzbEOmKElhhj17Rj7Jo0xq4REZEp4V9oIiIiIrJqbIiJiIiIyKpxyYSOGKElxtg17Ri7Jk01Zi5mPeKYKafs0s2lyC+4b9KXblbF0jGOjogsBRtiHTFCS4yxa9oxdk2aaszEf/hQ7lJM1DW5C6iQKpaOcXREZCk4ZUVEREREVo0zxDpi7JoYY9e0Y+yaNNWYif+vgmOmnLIlE7fg6ell0ksmGEtHRJaGDbGOGKElxtg17Ri7Jk01ZsLrc8yUp1QqceOGLWrXduR4ISIyIj7jEhEREZFVY0NMRERERFaNSyZ0xAgtMcauacfYNSDzsvgSzEwmkSYVu6aKOFNh1BkRkf6xIdYRI7TE2Nxox9g1YOb8IrlLMEP/xq6pIs5UGHVGRKR/1jllRURERET0/3GGWEeMXRNj7Jp2jF0DEiZxyURVScWuMeKMiMjw2BDriBFaYoxd046xa0B4ffE2voiSxtg1IiJ58BmXiIiIiKwaG2IiIiIismpcMqEja4/QksLYNe0sJXZNKjrtSXANsSZVtJpqvBARkXGxIdaRtUdoSWFzo52lxK4xOs2wVNFqqvESGBgoc0VERNbFfKesiIiIiIj0gDPEOmLsmhgTA7SzlNg1qei0J8F3FTSpotVU44WIiIyLDbGOrD1CSwpj17SzlNg1qei0J8EXUdJU44WIiIyLDTERERGZjdLSUpw9exZ5eXnw9PTE008/DVtbXsCGngwbYh1ZQmKAvjFlQjumTEiz1iUTqjQJALC3t5exEiLzlJmZiQ8++AAPHz6El5cXbt26BQcHB0ydOhUhISFyl0dmjA2xjiwhMUDfrLW5qQqmTFB5qjQJAAgICJCxEiLztGTJErz44ovo16+fetv27duRnJyMpKQkGSsjc2e+U1ZERERkVa5evYo+ffpobOvTpw+uXr0qU0VkKThDrCOmTIjxA1LaMWVCmrW+q6BKkyCi6mncuDFOnz6N5s2bq7f98ccfeOaZZ2SsiiwBG2IdWUJigL4xZUI7pkxI44soIqqqdevWqf/v5eWFDz74AC1btoSPjw9ycnJw4sQJdOrUScYKyRKYREOcnJyM33//HcXFxXBzc0O3bt0wYMAAAEB2djaWLFmCrKws+Pn5IS4uDs2aNZO5YiIiIjKGO3fuaHzdvn17AEBhYSFcXFzQvn17XvKcnphJNMQxMTF444034ODggNzcXMTHxyMgIABt27bF7Nmz0a1bNyQmJuLIkSNITEzE8uXL4eHhIXfZREREZGDvvvuu3CWQFTCJhjgoKEjja4VCgWvXruH06dN48OAB+vfvDxsbG0RGRuLbb7/Fzz//jJ49e8pSqyVEaOkbY9e0M7XYNV3j01QxYYwIIyJTkJOTo/U2X19fAEBubi58fHyMVRJZCJNoiIGyNUI7duzAgwcP4Ovri06dOuHw4cMIDg7WaCRCQ0ORnZ0tuv/169dx/fp1AEBGRobB6rSECC19s9YPSFWFqcWu6RqfpooJY0QYEZmCuLg4CIIgej4VBAGpqakAgDFjxuB///ufHOWRGTOZhnjYsGEYOnQoLly4gCNHjsDFxQXFxcVwcXHR2M/FxUXyFeKKFSuQkJBgrHKJiIjIyLZu3VrpPhs3bjRCJWRpTKYhBsqWSjRo0ADHjh3D5s2b4e3tjcLCQo19CgsL4eTkJLrvqFGjEBMTA6Bshnjw4MEGqZGxa2JMDNDO1GLXdI1PY0wYEZkSOzs7AGXLIlSXbn58eUSNGibV2pCZMMlRo1Qqcf36dbRs2RLbt2+HUqlUNxOZmZmIiooS3cff3x/+/v4Gr80SIrT0jbFr2pla7Jq+49OIiIwpNzcXH330Ec6dOwcXFxcUFhYiPDwcEyZM4LpheiKy/4UuKCjAvn37UFRUBKVSifT0dPzwww9o3rw5mjRpAnt7e3z11Vd49OgRDh06hOzsbLRr107usomIiMjIFi1ahLCwMGzevBkbN27E5s2bERoaisWLF8tdGpk5k5ghTktLw8qVK6FUKuHp6Yk+ffqgZ8+eUCgUmD59OpKTk7Flyxb4+vpiypQpjFwjIiKyQhcvXkR8fLx66YSTkxNGjhxpsGWSZD1kb4hdXV3xwQcfaL09ODgYH330kRErqpgpRWiZCsauaSdH7Jqu0WpyqCyZJCTIllFvRCQSHByMy5cvIywsTL0tOzsbwcHB8hVFFkH2htjcmFKElqlg7Jp2csSu6RqtZooWJjgz6o2IRJ555hkkJCSgQ4cO8PHxQW5uLvbv34+uXbti586d6v26d+8uY5VkjtgQExERkVk4e/YsAgMDcenSJVy6dAlA2cW9zp07h3Pnzqn3Y0NMumJDrCPGrokxdk07OWLXdI1Wk0Nl7yow7o2IpFS0xJLoSbAh1pEpRWiZCsauaSdH7Jo5RKvxRRQREZkSdnVERERkFqSuSDt79mwZKiFLU6UZ4pCQEJ1mcVTreoiIiIj05ZlnnhFta9SokQyVkKWpUkMcGxur0RBv27YNd+/eRZcuXeDn54d//vkHaWlpcHd3R//+/Q1WrClg7JoYY9e0qyx2zdQi0kKCpNfuMgKNiEyBVI/Rr18/GSohS1OlhnjRokXq/y9YsACBgYHYuXMnatasqd6en5+PF198EX5+fvqv0oQwdk2MsWvaVRa7ZmoRaQsTnCW3MwKNiEh/goOD0atXLyQnJ2vd586dO6hVqxbWrFmD4cOHG684K6XzNOfixYsxZcoUjWYYANzd3TF58mQsWbJEb8URERERWZqUlBRMmDBB7jKoHJ1TJvLy8pCfny95W35+Pm7fvv3ERZkyxq6JMTFAu8pi10wtIo1xZ0REhteiRQu5S6DH6NwQR0dHY9KkSQgMDESHDh3U2/fv34/JkycjOjparwWaGsauiTF2TbvKYtfMISKNiIh0s2rVKnzwwQfIycnBc889h/nz56N169bq5Q9SSyak7kPGo3NXt2LFCgQEBKBz587w9PREeHg4PD09ER0dDX9/fyxfvtwQdRIRERFpuHr1Kr777jt8//33uHHjhtzlAAB27NiBuLg4dOrUCSkpKYiOjsbLL7+s9/uQfuk8Q+zv74/ffvsNO3fuxK+//orr16/D398fbdq04aUSiYiIyGCmTZuGESNGoH79+jh69CiSkpLQsGFDAMC6devw3//+FxEREbLWOGfOHERGRmLNmjUAgBdeeAH379+vMC+5Ovch/ar2leq6d+9ulQ0wY9fEGLumnVKpROblUuQX3IeNjfWdm5AgW0a2EZHeXLhwAaGhoQCATZs2YfLkyWjZsiUA4NSpU/j8889lbYhLS0tx7NgxfPjhhxrb+/fvr7W5rc59SP+q1BDn5eXBw8MDNjY2yMvLq3R/T0/PJy7MVDF2TYyxa9oJgoAlqx8AuCZ3KbJYmODMyDYi0htbW1sUFRXB1dUVN2/eRLNmzdS3NW3aVPZlE7m5uSgpKYGvr6/G9ooiaatzH9K/Kk1z+vj44PfffwcAeHt7w8fHp8J/RERERPrWunVrbNiwAaWlpWjdujV2796tvi0tLU32F+A+Pj6oUaMGcnJyNLb/888/er0P6V+VZog///xzhIWFqf9vzbOAjF0TY+yadkqlEmNH5sLT08sql0wwxo2I9On1119HYmIi3njjDQQGBmL58uXYtm0bFAoFioqKMGPGDFnrs7W1RcuWLZGSkoJx48apt2/btk2v9yH9q1JDPGzYMPX/rf1qKYxdE2PsmnZKpRIhQbaoXduRY4aI6Am5ublh7ty5OHXqFM6dOwc/Pz84ODggODgYzz33HJydpa+2aUzTpk1DbGwsRowYgYEDB+LYsWNYv3693u9D+lXtD9URERERyaFZs2Ya64dNSUxMDJYvX44PPvgAW7ZswbPPPov//e9/ePbZZ/V6H9IvNsRERERkFpRKJX788UccOnQIeXl58PT0RGRkJLp162ZS71COGjUKo0aNUn99584djduzsrIqvQ9Q9g4sGQcbYh0xdk2MsWvaWXvsmjYVJZOEBJWtO2ZcGxE9bv369Thy5Ah69eoFHx8f5ObmIiUlBTdu3NBY3kmkKzbEOmLsmhhj17Sz9ti16liYULYGUO5PixOR6UlLS8NHH32kEUnWunVrvPfee2yI6YmwISYiIiKzYG9vDzc3N41tNWvWhIODg0wV/SsnJwd3797Vevtff/0FoOziIrrw8vJCrVq1nqg2qly1G+Lz589rXLq5devWCA8P12dtJomxa2KMXdPO2mPXtKnoXQVGtRGRNoMGDcInn3yCgQMHwtfXFzk5Odi8eTNeeeUVPHr0SL2fnZ2d0WsrKChAfn6+3o/r4uKi92OSmM4NcUFBAeLi4vDll19CqVTC0dER9+/fh42NDV5++WWsWrUKrq6uhqjVJDB2TYyxa9oxdk0aX0QRUXUkJycDAI4ePQpBENTPH7/++iuSk5OhUCggCAJSU1Nlq/Gpp57S27HOnz+vt2NRxXRuiMeOHYsdO3Zg1apV6N+/P9zc3HDv3j1s3boV//nPfzB27FisWbPGELUSERGRFVu1apXcJZCF0rkh3r59O+bPn48RI0aot7m5ueG1117D/fv3MWXKFDbEREREpHc+Pj5yl0AWSueG2NHRESEhIZK3hYaGyrJux5gYuyZmSbFrmZdL9Xo8pVJAXh5j1x4nZzKJKtbtcYx5IzIPP/74I/bs2YPLly+juLgYTk5OCAoKQnR0NLp16yZ3eWSmdG6IR4wYgU8//RQvvPCCxh8yQRCwbNkyjZljS8TYNTFLil2bOb/IQEdm7JqpUMW6PY4xb0Smb+PGjTh48CBiYmIQGhoKZ2dnFBYWIjMzE9u2bUNOTg4GDx4sd5kmp23bthg9ejSGDx9u8Mc6cuQIhg8fjitXrmDp0qWiOLzly5djy5Yt2L9/v+T9Bw4ciKeffhrx8fEGr7W8Kk1zLly4UP3Py8sLx44dQ4MGDTBu3DgkJiZi3LhxaNCgAU6cOAFfX19D10xERERW6IcffkBCQgJ69OiBp59+GkFBQWjYsCF69OiBOXPmYNeuXXKXaDR//fUXunXrBg8PD9SrVw+rV6+u8n23bduGsLAwODs7Izo6GtnZ2Rq3z5gxAz4+PnB3d8frr7+OBw8eqG9LTk5Gq1at4ODggIEDB4qOPWPGDIwcORIFBQVmlQ1dpRniCRMmSG7/5JNPRNsmT56MiRMnPllVJoyxa2KWlBiQMMkQSyZuMXbtMXK+q8BYNyLzVVpaCmdn6Xd5nJ2dUVJSYuSK5FFSUoKYmBj83//9H77//nucOnUK0dHRqF+/Pjp06FDhfTMyMjB8+HB89dVXiIyMxNSpUzFgwAAcPXoUAPDZZ59h48aNOHr0KNzd3REbG4v3338f8+fPB1D2btr06dORlpaGmzdvio6fmZmJJk2a6P+bNrAqNcRKpdLQdZgNxq6JWVLsWnh9/R5PqVTixg3Grj3Okl5EEZHxtGvXDnPnzsUrr7yC0NBQuLi4oLCwEJcuXcKWLVvQrl072WpL3aXE0ePuAP7R41Hd8fEs8dZz584hKysLU6dOha2tLSIiIvDSSy/h888/R4cOHbBlyxZMnToVt2/fxsiRIzXuu2HDBnTv3l293nrWrFnw8fHBn3/+iWeeeQZr1qzB+PHjERoaCgCYOXMmXn31VXVD3LdvXwDAyZMnRQ1xcHAwLl++jJdeegm2tra4dOkS7t+/jxEjRuDXX39F06ZNERUVpXGfffv2YcyYMer7PXz4UC9nTlf8C01ERERmYfTo0WjYsCEWLlyIoUOHom/fvhg6dCiSkpLQsGFDjB49Wu4SjUIQBAiCINr2xx9/4OzZs3jttdewcuVK5OTkwMPDA7///rt6vzNnzqB58+bqr93c3BAWFoYzZ85I3t68eXPk5ubin38qb/SzsrIQFBSElJQUFBQUwNfXF4MGDUJ4eDhyc3OxePFijaUdeXl5iI2NxeTJk3H79m1ER0fjm2++qfZ5eRLVulJdYWEh1q5di0OHDiEvLw+enp6IjIzEsGHDLP6KKkyZEGPKhHZMmZDGlAkiqo4aNWpg6NChGDp0KPLz89UpE+7u7nKXZlTh4eGoW7cuZs2ahWnTpuHEiRNISUlB7dq18eWXX+LFF19Ely5dAABTpkzRWOJaUFAADw8PjeN5eHjg3r17krer/n/v3j34+fnpVOfly5fxyy+/4Pvvv4ejoyMiIiLw6quv4sSJEwCAHTt2oEGDBhgyZAgAYNiwYVi0aJGOZ0M/dG6I//77b3Ts2BFZWVlo1qwZ/Pz8cO7cOWzduhULFy7Evn37EBgYaIhaTQJTJsSYMlEVTJkwFUyZIDJ/Dx48wK1bt3D//n04OjrC0dERDg4OcpdlNHZ2dkhNTcU777yDgIAAhIeHY/jw4Thz5gyuXbuGoKAg9b62traoU6eO+mtXV1fRJabz8/Ph5uYmebvq/6rbdXHt2jW4u7trvGCpV6+euiF+vFbV7XLQuSEeP348ACA9PR3h4eHq7efOnUOvXr3w3nvv4csvv9RfhUREREQoe4d6xYoVOHz4MARBUMeuKRQKPP/88xg9erRs71THvmCDqDa3DXDpZunv55lnnsGePXvUXw8cOBBt27aFg4MDTp06pd5eWlqKq1evqr9u3LgxTp48qf66oKAAFy9eROPGjTVuV63HPnnyJHx8fHSeHQbKJhry8/Nx9+5d1KxZE0DZrHH528t/rbq9/JINY9G5Id69ezdWrFih0QwDZdP3s2fPtvj1O0yZELOkD0gxZcI4mDJBRNWRnJyM0tJSfPzxxxrvRv/9999Yv349kpOTMWnSJBkrNJ4//vgD9evXh62tLTZv3ow9e/Zg6dKlyMnJwbx587B3715ERkZiwYIFuH37tvp+gwcPRuvWrZGWlob27dtj5syZaNq0KZ555hkAwPDhwzF//nz06NED7u7umDVrlsY1JkpKStT/lEol7t+/D1tbW8kLswUFBaFt27aYOnUqkpKSkJ6ejo0bN6Jhw4YAgJ49e+Ltt9/Gpk2bMGDAAGzevBmnT59GTEyMgc+emM4NcUlJCZycnCRvc3JyQmmpfhsKU8OUCTGmTGjHlAlplvQiioiM5/jx41i7dq2oDwkMDMT48ePNKvf2SW3evBkrVqzAw4cP0apVK+zevRteXl7w8vLCZ599hpEjR+LOnTt47bXX0KpVK/X9GjZsiDVr1iAuLg43btxA27ZtNd7Zf/3115GdnY3WrVvj0aNH6N+/P2bN+jfqYs6cOUhISFB/vXXrVgwbNgxr166VrHPTpk0YMWIEvL290bRpU7z22mv45ZdfAABeXl5ISUnBO++8g1GjRuGll15C79699XymqkYhPP4xxUq88MILuH37Nnbv3q2xJiQ/Px9du3aFp6cndu7cqfdCdXH8+HFERETg2LFjaNmypd6OW9bc3EDt2rXZ3JTD5kY7jhlpHDPSOF6kcbxIs8Txcu3aNaxcuRKRkZGiD34BZbOXCQkJkutMs7OzER8fjzVr1gAo+8zPwYMHERcXZ5TPCFy6dAm3b+t/yURAQAD8/f31dkySpvMMcVJSEqKiohAYGIjOnTvDz88POTk52LNnD+zs7PD5558bok4iIiKycv3798f777+Prl27ii7dvGvXLrz88styl0hmSueGuHHjxjh16hQ+/vhjHDp0CH/++Sc8PT3xxkeUq9EAABy2SURBVBtvYNy4cahbt64h6jQZjF0TY+yadqYWuxZeX3q5ExGROejVqxfq1KmD3bt345dfflHHrtWrVw/jxo3T67vCZF2qlUMcGBiIhQsX6rsWs8DYNTHGrlWFacSubVml50XSRERG1qJFC7Ro0ULuMsjCVKkhbtq0KTZt2oTGjRujSZMmFTY9CoUCnp6eaNOmDSZNmgRPT0+9FUtEREREpG9VaogjIiLUuX4RERGVzgLeu3cPq1evxrlz5/D1118/eZUmhLFrYpb0gRfGrhERma5p06YhISEBNWqI25fvv/8emZmZePvtt2Wo7F9l2cFkbqrUEKs+sQlAa6zG41JTU9WX4rMkjF0TY+yadoxdIyLSnzNnzkCpVEreVrduXXz77bdGruhf3t7eBrkoiKurq96PSWLVWkNcFR06dMD69esNdXgiIiKyMgqFAjNnzpScYHj06BGuX78uQ1Vlatasqb4aG5kfgzXEHh4eiI2NNdThiYiIyAq1b98etrbSV5zs3LmzkashS2GwhthSMXZNzBRj1/Qdn1Zdpha7Zir0nUwSEvTvH0d7e/snPh4Rma5u3bpJXiaY6EmwIdYRY9fETDF2zXDxadVlGrFrlmphgrP6/8a4IhURyeOdd97ROjtM9CQ4zUlERERmoXPnzpLv0F65ckWGasiScIZYR4xdEzPF2DV9x6dVF2PXpOn7XQVvb84YEVmDnJwcye3jx4/HsmXLUKtWLc4gU7WwIdYRY9fETDF2Td/xadXF2DVppvgiiohMX1xcHARBkHzeeP3112FnZ4eRI0eie/fuMlRH5owNMREREZmFrVu3irYpFAq8+uqr2LBhAy5fvozZs2ezISadsSEmIiIis6AtXaJOnTqws7NDWFgYiouLjVwVWQI2xDpi7JqYXLFrphKtVhHGrkkTBAGBAYLk5VeJiCpy7949/P7778jLy4Onpydat26NhQsXqm9fvHixjNWRueJfIx0xdk1Mrtg104tWqwhj1x734Qx7ODs7V74jEdH/d+rUKSQmJiIgIAA+Pj7Izc3FihUrMHXqVDRt2hQA4OfnJ3OVZI7YEBMREZFZWLlyJd566y1ERUWptx04cAArV65EcnKyjJWRuWNDrCPGronJlRhgKtFqFWHsmjRBEODlJchdBhGZmVu3bqFdu3Ya2yIjI/Hpp5/KVBFZCtkb4kePHmH58uU4deoU7t27B29vbwwYMAAdOnQAAGRnZ2PJkiXIysqCn58f4uLi0KxZM9nqZeyamFyxa6YSrVYRxq5JU72IIiLSRdu2bfHTTz+hU6dO6m379+/Hs88+K2NVZAlkb4hLS0vh6emJOXPmwM/PDxkZGZg1axb8/PxQv359zJ49G926dUNiYiKOHDmCxMRELF++HB4eHnKXTkREREZ0//59LFmyBN988w18fHyQk5OD7OxstGnTBgsWLFDvN3HiRBmrJHMke0Ps6OiIV199Vf11o0aN0LBhQ2RkZKC4uBgPHjxA//79YWNjg8jISHz77bf4+eef0bNnTxmrJiIiImMLDg5GcHCw+uvQ0FC0bdtWvoLIYsjeED/u/v37uHDhAnr37o3Lly8jODhY463m0NBQZGdny1YfY9fEGLumHWPXpFUnmSQk6N/Lsdrb2xuqNCIyYQMHDpS7BLJQJtUQK5VKLFq0CA0aNECLFi1w/vx5uLi4aOzj4uIieS3z69ev4/r16wCAjIwMg9XI2DUxxq5VBWPXntTChH8j2gICAmSshIjkdOLECRw8eFCdQxwZGYkWLVrIXRaZOZOZ5hQEAcuWLUNeXh4mTpwIhUIBJycnFBYWauxXWFgIJycn0f1XrFiBiIgIREREYPDgwcYqm4iIiIwkNTUVCxcuhJubG1q1agU3NzckJSUhNTVV7tLIzJnEDLEgCFi+fDkyMzMxe/ZsdcMbFBSE7du3Q6lUqpcoZGZmauQPqowaNQoxMTEAymaIDdUUM3ZNjLFr2jF2TVp13lXw9ratfCcismhff/01Zs2ahZCQEPW2jh07YtasWYiNjZWxMjJ3JtEQr1ixAufOncOcOXM0rlzVpEkT2Nvb46uvvkJsbCyOHj2K7OxsUQYhAPj7+8Pf39/gtTJ2TYyxa9oxdk2aXC+iiMi8lZaWok6dOhrb6tati9JS058gIdMme0Ock5OD77//HnZ2dnjttdfU2/v3748BAwZg+vTpSE5OxpYtW+Dr64spU6Ywco2IiMgK9evXD6tXr8aQIUPg6uqKwsJCrFu3Dn379pW7NDJzsjfEvr6++Oabb7TeHhwcjI8++siIFREREZEpSklJwd27d7Fr1y44OTmhuLgYNjY2cHNzQ0pKinq/devWyVglmSPZG2Jzw9g1Mbli1xi9RURkXSZMmCB3CWSh2BDriLFrYnLFrjF6i4jIujRu3FjuEshCcZqTiIiIiKwaZ4h1xNg1MSYGEBERkTljQ6wjxq6JyRW7RkRERKQP7OqIiIiIyKqxISYiIiIiq8YlEzpi7JqYIWPXMi8b7+pDIUG2jHIjIiKyQmyIdcTYNTFDxq7NnF+k1+NVZGGCM6PciIiIrBCnOYmIiIjIqnGGWEeMXRMzZOxawiTjLZnw9rY12mMRERGR6WBDrCPGrokZMnYtvL5eD0dEREQkwq6OiIiIiKwaZ4h1xJQJsaqkTBgzLUIXIUGayySYMkFERGR92BDriCkTYlVJmTBmWoQuFiY4a3zNlAkiIiLrw2lOIiIiIrJqnCHWEVMmxKqSMmHMtAhdMFmCiIiI2BDriCkTYlVJmWBaBBEREZkqdnVEREREZNXYEBMRERGRVeOSCR0xdk3MnGPXDE2pFJCXV4r8gvuwsdFfMsnjcXHlMTqOiIhIN2yIdcTYNTFzjl0znmt6PdrjcXHlMTqOiIhIN5zmJCIiIiKrxhliHTF2TcycY9cMrWzJxC14enrpdckE4+KIiIj0hw2xjhi7JsbYNe2USiVu3LBF7dqOHDNEREQmin+hiYiIiMiqsSEmIiIiIqvGJRM6YuyamGoN8cWsR0zfKCckyBZKpVLuMoiIiKgSbIh1xNg1MVXsWvyHD+UuxaQsTHCGIAgcK0RERCaO05xEREREZNU4Q6wjxq6JqZZMxP9XwdnQcry9y5ZM5OXlyV0KERERVYANsY4Yuyamil0Lr8+lJI/jGmIiIiLTx66OiIiIiKwaG2IiIiIismpcMqEjc4ldy7xsvEslq1ImbG1tjb5kIiRI+hLG9vb2Rq2DiIiIzBcbYh2ZS+zazPlFcpdgFAsTnCW3BwQEGLkSIvp/7d1rbFRlu8bxazql7bTl1F3oWyltwcO2RENEgwdAUEP5QDhpQYKVIDaggvEQzdYophWsMUFFoUqjSY0QDkHQKBoBRSIiCQQSAdMgBFoE+lKkIAU6tDOz9gcyI8MM2FXaWWtm/X+fmGcWqzfNk3L36d1rAUC8svcxJwAAANDFOCE2KV5i1yr+zxkjE9nZ0UcmAAAA2ouG2KR4iV3735ti97GCOcTxMEoCAABwJXt3dQAAAEAXoyEGAACAozEyYZKdYtdiGa12LVbOEHeWYHwbcW0AADgPDbFJdopdc0q0WiwE49uIawMAwHmsP+YEAAAALMQJsUl2il2LZbTatSTCyATxbQAAOBcNsUl2il2LZbTatRC7BgAA4pn1XR0AAABgIRpiAAAAOBojEybFOnYtGK0WjAW7HBFhAAAA14+G2KRYx64Fo9WCsWCXIyIMAADg+jEyAQAAAEfjhNikWMeuBaPViAUDAADoGjTEJsU6ds0u0WoAAACJipEJAAAAOBoNMQAAAByNkQmTOhq7FoxPS0SJ8OjmrhIIGGpq8uvvc14lJf3zuQnG6BGdBwCA9WiITepo7FowPg1OdTzsVTBGj+g8AACsx8gEAAAAHI0TYpM6GrsWjE9LRIxMXN2lkYlTysr6n7CRCWL0AACwD1s0xOvXr9fmzZtVV1ene++9Vy+//HLovfr6ei1evFh1dXXKycnRrFmzNHjwYMtq7WjsWiLHpxmGIZ/PF9Mn+MWLQCCg//7Xrf/8Jy1mUX0AAMAcW/wPnZWVpSlTpqi4uDhs3efzaf78+Ro6dKhWrlypqVOn6u2339aZM2csqhQAAACJxhYnxPfdd58k6dChQ2pubg6t7927VxcvXlRJSYmSkpI0YsQIffPNN9q2bZvGjh1rSa3XSpmwKkkimFhwOdILAAAA2scWDfHVHDlyRIWFhWHN58CBA1VfXx9xbUNDgxoaGiRJtbW1XVbTtVImrEqSCCYWXI70AgAAgPaxdUPc0tKijIyMsLWMjAw1NjZGXFtdXa2KiopYlQYAAIAEYeuG2OPx6Pz582Fr58+fl8fjibh29uzZGj9+vKRLJ8SlpaVdUtO1UiasSpIgsQAAAKDjbN0Q5+fna+3atQoEAqEG9PDhw7r//vsjrs3NzVVubm6X13StlIlETpIAAABIVLZImfD7/WptbVUgEFAgEFBra6t8Pp9uv/12paSkaN26dWpra9Mvv/yi+vp6DRs2zOqSAQAAkCBscUK8evVqrVq1KvR627ZtevDBB/X888/r9ddf15IlS7Rq1Sr17dtXr776qnr16mVhtQAAAEgktmiIp02bpmnTpkV9r7CwUAsXLoxxRVdnx9g1q3X2k+ouj5EjPg4AAHQ1WzTE8cSOsWuJ5vIYOeLjAABAV7PFDDEAAABgFU6ITbJj7JrVOntkghg5AAAQSzTEJhG7FskwDPl8vquOkgAAANgZIxMAAABwNBpiAAAAOBojEyYRuxYp2gzx5dFpEvFpAADAvmiITSJ2rX0uj06TiE8DAAD2xcgEAAAAHI0TYpOIXYsUbWSC6DQAABAvaIhNInYtErFrAAAgnjEyAQAAAEejIQYAAICjMTJhErFrkQr7J4VGJgAAAOINHYxJxK5FerfcI7/fr/T09H+/GAAAwGYYmQAAAICjcUJsErFrkbKzL41MAAAAxCMaYpOIXYtkGEbUzwcAAEA8oIsBAACAo9EQAwAAwNEYmTApFrFrA/L/eexxSkpKp9wTAAAA0dEQmxSL2LX3Kv6JL7vhhhs65Z4AAACIjpEJAAAAOBonxCbFInYtO9v97xcBAACgU9AQm0TsGgAAQGJhZAIAAACORkMMAAAAR2NkwqRYxK7FG8Mw5Pf75Xa7o6ZvdIbLo+iCiKQDAACdgYbYpFjEriHS5VF0QUTSAQCAzsDIBAAAAByNE2KTYhG7Fm9iMTJBFB0AAOgqNMQmEbsWyTAM+Xy+q46SAAAA2BkjEwAAAHA0GmIAAAA4GiMTJhG7FikWM8TxIFo0XCAQsKASAABgBg2xScSu4WqiRcMZhuHobxIAAIgHjEwAAADA0TghNonYtUiMTFwSLRouEAioqanJgmoAAEB70RCbROxaJGLXro4ZYgAA7I+RCQAAADgaJ8QmmU2ZCCYPpKSkdHltAAAAMI+G2CSzKRPB5IEbbrihy2sDAACAeYxMAAAAwNE4ITbJbMpEtOQBAAAA2AcNsUmkTAAAACQWRiYAAADgaDTEAAAAcDRGJkwyG7vmBJ39pLpgVJ1EXB0AAOh6NMQmmY1dg3nBqDqJuDoAAND1GJkAAACAo3FCbJLZ2DUn6OyRCaLqAABALNEQm0TsWiTDMOTz+a46SgIAAGBnjEwAAADA0WiIAQAA4GiMTJhE7Fqka80QByPUiE8DAAB2RUNsErFr5gQj1IhPAwAAdsXIBAAAAByNE2KTiF2LdK2RCSLUAACA3dEQm0TsWiRi1wAAQDyLi4b43Llzqqqq0u7du+XxeDRp0iRNmDDB6rIAAACQAOKiIa6urlZbW5tqamrU2NioefPmKS8vT3feeafVpQEAACDO2f6X6rxer7Zt26bHH39c6enpKiwsVHFxsTZt2mR1aQAAAEgAtj8hPnbsmAzDUEFBQWhtwIAB2r59e9h1DQ0NamhokCTV1tbGtEYAAADEL9s3xF6vV+np6WFrGRkZamlpCVurrq5WRUVFLEsDAABAArD9yERaWlpE83vhwgV5PJ6wtdmzZ2vXrl3atWuXli9fHssSAQAAEMdsf0Lcr18/SdKRI0eUn58vSTp8+HDoz0G5ubnKzc2NeX0AAACIb3FxQjxs2DAtW7ZMFy5cUH19vTZu3KjRo0dbXRoAAAASgO1PiKVL4xBLlizRjBkz5PF49MgjjxC5BgAAgE4RFw1xZmamXnnlFavLAAAAQAKy/cgEAAAA0JVoiAEAAOBoNMQAAABwtLiYITYrmFvc2U+sCwQCOnXqlI4fP66kJL6XCDIMQ36/X263Wy6Xy+pybIU9Ex17Jjr2S3Tsl+gScb+cPHlSDQ0NOnXq1HXf69y5c51QEZwiIRviuro6SVJpaam1hQAAgA7pjGcLJCcnRzztFojGZRiGYXURne2vv/7Shg0bVFhYGPFEu+tRW1ur0tJSLV++XEVFRZ12XyQu9gzMYL/AjETdL83NzcrLy+uU/7/T09PVq1evTqgKiS4hT4izs7P12GOPddn9i4qKNGTIkC67PxIPewZmsF9gBvsFuH6JMXQEAAAAdJC7vLy83Ooi4klmZqZGjRql7t27W10K4gR7BmawX2AG+wXoHAk5QwwAAAC0FyMTAAAAcDQaYgAAADgaDTEAAAAcLSFj17rCuXPnVFVVpd27d8vj8WjSpEmaMGGC1WXBJtra2rR06VL99ttvam5uVnZ2tqZMmaKRI0daXRriwNmzZ/X0008rNzdXCxcutLoc2Nivv/6qFStW6MSJE+rRo4eefPJJ3XfffVaXBcQ9GuJ2qq6uVltbm2pqatTY2Kh58+YpLy9Pd955p9WlwQb8fr+ysrK0YMEC5eTkqLa2Vm+++aZycnJ06623Wl0ebK6mpkb9+/eXz+ezuhTY2G+//aZPP/1UL730km699VadPXtWXq/X6rKAhEBD3A5er1fbtm3T+++/r/T0dBUWFqq4uFibNm2iIYYkKS0tLexhMIMGDVJRUZFqa2s1cOBAffTRR9q5c6f8fr/69u2rl156Sfn5+RZWDLvYt2+fjh8/rtGjR+v777+XJLW2trJnEGHFihV69NFHNWjQIEkKPYGN/QJcPxridjh27JgMw1BBQUFobcCAAdq+fbuFVcHOvF6vDh48qHHjxmnz5s2qr69XdXW1MjIydPToUWVmZlpdImygra1N1dXVevHFF3Xo0KHQOnsGV/L7/Tpw4ICGDh2qp556Sl6vV3fccYfKysq0detW9gtwnfilunbwer1KT08PW8vIyFBLS4tFFcHOAoGAFi1apJtvvll33HGHkpOT1dLSoqNHj8owDPXv31+9e/e2ukzYwNq1azV48GANGDAgbJ09gyudOXNGPp9PP//8sxYsWKAlS5bozJkz+vTTT9kvQCfghLgd0tLSIprfCxcuyOPxWFQR7MowDH300UdqampSRUWFXC6XHnjgATU1NamqqkpNTU269957NXPmzIhvsuAsx48f148//qgPPvgg4j32DK6UmpoqSRo7dqyys7MlSZMnT1ZlZaXmzp3LfgGuEyfE7dCvXz9J0pEjR0Jrhw8fZj4LYQzD0NKlS3X48GGVl5eHvmFyu92aMmWKFi9erMWLF+vPP//UunXrLK4WVqutrdXp06f11FNPafr06frkk0906NAhTZ8+XRcvXmTPIExmZqays7Plcrki3uNrDHD9OCFuh7S0NA0bNkzLli3TCy+8oJMnT2rjxo167rnnrC4NNlJdXa39+/drwYIFYScze/bsUffu3ZWfn6+0tDR169ZNSUl8L+p0w4cP15AhQ0Kvt27dqp9++klvvPGGDh48yJ5BhOLiYn377be66667lJqaqrVr12ro0KF8jQE6AQ1xO82ePVtLlizRjBkz5PF49Mgjj5AwgZDGxkZ999136tatm2bOnBlaLykpUU5Ojj7++GOdOnVKqampGjJkiB5++GELq4UdpKamhn4MLl36vQS3263evXtrz5497BlEmDx5ss6ePas5c+bI7XbrrrvuUllZmXbu3Ml+Aa6TyzAMw+oiAAAAAKvwMxUAAAA4Gg0xAAAAHI2GGAAAAI5GQwwAAABHoyEGAACAo9EQAwAAwNFoiAEAAOBoNMQAAABwNBpiAO125swZuVwuffbZZzH7mFu2bFFlZWXEenl5uTIzM2NWBwAgcdEQA7C1qzXEZWVl+umnnyyoCACQaJKtLgCA87S0tMjj8VzXPfLy8pSXl9dJFQEAnIwTYgBX9cknn6iwsFDp6el66KGHdPDgwbD3XS6XFi5cGLa2aNEiuVyu0OstW7bI5XLp22+/VUlJiXr06KHJkydLkj7//HMNHz5cWVlZ6t27t0aNGqUdO3aE/m55ebkqKip0/vx5uVwuuVwujRo1KvTelSMT9fX1KikpUc+ePZWRkaExY8Zo7969YdcUFhZq7ty5qqqqUkFBgXr27KmJEyfq5MmT1/35AgDEJ06IAUS1fv16zZo1SzNmzNDUqVO1a9euUCPbEbNmzVJpaam+/PJLud1uSVJdXZ2mT5+uG2+8Ua2trVq5cqXuv/9+7dmzR7fccovKysp09OhRrVixQps3b5Yk9ejRI+r9m5ubNWrUKCUlJWnp0qVKS0vTW2+9Fbpf//79Q9d+/fXXOnDggKqqqvTXX3/phRde0LPPPqtVq1Z1+N8HAIhfNMQAolqwYIFGjBihmpoaSdKYMWPk9Xo1f/78Dt1v/Pjxeuedd8LW3njjjdCfA4GARo8erR07duizzz5TZWVlaCwiKSlJ99xzzzXvX1NTo/r6ev3+++8qKiqSJI0cOVL5+flatGiR3n333dC1hmHo66+/VmpqqqRLjXllZaUCgYCSkvjBGQA4DV/5AUTw+/3atWuXJk2aFLZeUlLS4XuOHTs2Yq22tlaTJk1STk6O3G63unXrpv379+uPP/4wff+tW7fqtttuCzXDkpSVlaXRo0frl19+Cbt25MiRoWZYkgYNGqS2tjY1Njaa/rgAgPjHCTGACCdPnpTP51Pfvn3D1nNycjp8zyv/bnNzs4qLi9WnTx+99957KigoUFpamsrKyuT1ek3f//Tp01Hry8nJ0b59+8LWevXqFfY6JSVFkjr0cQEA8Y+GGECEPn36KDk5OeLE9MSJE2GvU1NT1draGrZ2+vTpqPe8/BftJGn79u06evSo1q9fr8GDB4fW//777w6lR2RlZWn//v0R6ydOnFBWVpbp+wEAnIORCQAR3G63hgwZoi+//DJs/Ysvvgh7nZeXp9ra2rC1TZs2tetjtLS0SPrndFaSfv31V9XV1YVdl5KSoosXL/7r/YYPH669e/eGNcWnT5/WDz/8oOHDh7erJgCAM9EQA4jqtdde09atW/XEE09ow4YNqqys1LJly8KuKSkp0Zo1a/Thhx9qw4YNevzxx3Xs2LF23f+ee+5RZmam5syZo40bN6qmpkZTp05Vv379wq4rKiqSz+fTBx98oJ07d0Y9BZakJ554QgUFBRo7dqxWrVqlr776SsXFxUpOTtbzzz/fsU8CAMARaIgBRDV+/HgtXbpUP/74oyZOnKiNGzdq9erVYdfMmzdP06ZNU0VFhUpLS1VQUKDnnnuuXffPycnRmjVr1NjYqAkTJmjRokWqrq7WTTfdFHbduHHj9Mwzz+jtt9/W3XffrdmzZ0e9X/fu3bVlyxYNHjxYs2bN0mOPPabevXvr559/DotcAwDgSi7DMAyriwAAAACswgkxAAAAHI2GGAAAAI5GQwwAAABHoyEGAACAo9EQAwAAwNFoiAEAAOBoNMQAAABwNBpiAAAAOBoNMQAAAByNhhgAAACORkMMAAAAR/t/VCSXFWgc7qsAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1086,7 +1086,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 23, @@ -1148,7 +1148,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "50c764dcf01c49c79207ae537d0e3d0d", + "model_id": "4361a5fe28944ba784565f1febad695f", "version_major": 2, "version_minor": 0 }, @@ -1159,13 +1159,6 @@ "metadata": {}, "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:Pulse already running.\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -1185,7 +1178,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1196,7 +1189,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 25, @@ -1305,7 +1298,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6cae6927e7c0496197af1659dd61faca", + "model_id": "bbd4261aefaf473ebef5582808ccf030", "version_major": 2, "version_minor": 0 }, @@ -1316,6 +1309,27 @@ "metadata": {}, "output_type": "display_data" }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Process 3:\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.6/multiprocessing/process.py\", line 93, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"../ezpq/Queue.py\", line 587, in _job_wrap\n", + " raise ex_obj\n", + " File \"../ezpq/Queue.py\", line 578, in _job_wrap\n", + " out = _job.function(*args, **kwargs)\n", + " File \"\", line 9, in enum_files\n", + " size += os.path.getsize( os.path.join(root, name) )\n", + " File \"/usr/lib/python3.6/genericpath.py\", line 50, in getsize\n", + " return os.stat(filename).st_size\n", + "FileNotFoundError: [Errno 2] No such file or directory: '/home/donald/Documents/Dropbox/pwsh/pskafka/kafkacat-1.4.0RC1/tmp-bootstrap/usr/local/lib/librdkafka++.so'\n" + ] + }, { "name": "stdout", "output_type": "stream", @@ -1393,7 +1407,7 @@ " \n", " \n", " 0\n", - " d91454f7\n", + " 141e2d04\n", " 1\n", " /home/donald/bin\n", " 100\n", @@ -1402,20 +1416,20 @@ " enum_files\n", " NaN\n", " {'path': '/home/donald/bin', 'pattern': '*'}\n", - " 2019-01-24 04:16:31.168725\n", - " 2019-01-24 04:16:31.274264\n", - " 2019-01-24 04:16:31.278330\n", - " 2019-01-24 04:16:31.370645\n", + " 2019-02-18 20:21:14.791565\n", + " 2019-02-18 20:21:14.897535\n", + " 2019-02-18 20:21:14.901591\n", + " 2019-02-18 20:21:14.993735\n", " 0\n", " False\n", - " 0.004066\n", - " (3, 83860495)\n", + " 0.004056\n", + " (3, 83860646)\n", " NaN\n", " NaN\n", " \n", " \n", " 1\n", - " d91454f7\n", + " 141e2d04\n", " 2\n", " /home/donald/Desktop\n", " 100\n", @@ -1424,20 +1438,20 @@ " enum_files\n", " NaN\n", " {'path': '/home/donald/Desktop', 'pattern': '*'}\n", - " 2019-01-24 04:16:31.168761\n", - " 2019-01-24 04:16:31.281023\n", - " 2019-01-24 04:16:31.286515\n", - " 2019-01-24 04:16:31.371730\n", + " 2019-02-18 20:21:14.791587\n", + " 2019-02-18 20:21:14.903832\n", + " 2019-02-18 20:21:14.908947\n", + " 2019-02-18 20:21:14.994798\n", " 0\n", " False\n", - " 0.005492\n", - " (9, 418216)\n", + " 0.005115\n", + " (17, 1162796)\n", " NaN\n", " NaN\n", " \n", " \n", " 2\n", - " d91454f7\n", + " 141e2d04\n", " 5\n", " /home/donald/Music\n", " 100\n", @@ -1446,58 +1460,58 @@ " enum_files\n", " NaN\n", " {'path': '/home/donald/Music', 'pattern': '*'}\n", - " 2019-01-24 04:16:31.168798\n", - " 2019-01-24 04:16:31.302599\n", - " 2019-01-24 04:16:31.306935\n", - " 2019-01-24 04:16:31.372170\n", + " 2019-02-18 20:21:14.791620\n", + " 2019-02-18 20:21:14.926363\n", + " 2019-02-18 20:21:14.930386\n", + " 2019-02-18 20:21:14.995248\n", " 0\n", " False\n", - " 0.004336\n", + " 0.004023\n", " (0, 0)\n", " NaN\n", " NaN\n", " \n", " \n", " 3\n", - " d91454f7\n", - " 4\n", - " /home/donald/Downloads\n", + " 141e2d04\n", + " 3\n", + " /home/donald/Documents\n", " 100\n", " NaN\n", " 0\n", " enum_files\n", " NaN\n", - " {'path': '/home/donald/Downloads', 'pattern': ...\n", - " 2019-01-24 04:16:31.168782\n", - " 2019-01-24 04:16:31.296372\n", - " 2019-01-24 04:16:31.393124\n", - " 2019-01-24 04:16:31.470766\n", - " 0\n", + " {'path': '/home/donald/Documents', 'pattern': ...\n", + " 2019-02-18 20:21:14.791596\n", + " 2019-02-18 20:21:14.910665\n", + " 2019-02-18 20:21:15.001843\n", + " 2019-02-18 20:21:15.093378\n", + " 1\n", " False\n", - " 0.096751\n", - " (3930, 6021598980)\n", + " 0.091178\n", " NaN\n", + " Traceback (most recent call last):\\n File \".....\n", " NaN\n", " \n", " \n", " 4\n", - " d91454f7\n", - " 3\n", - " /home/donald/Documents\n", + " 141e2d04\n", + " 4\n", + " /home/donald/Downloads\n", " 100\n", " NaN\n", " 0\n", " enum_files\n", " NaN\n", - " {'path': '/home/donald/Documents', 'pattern': ...\n", - " 2019-01-24 04:16:31.168770\n", - " 2019-01-24 04:16:31.289080\n", - " 2019-01-24 04:16:31.476378\n", - " 2019-01-24 04:16:31.571118\n", + " {'path': '/home/donald/Downloads', 'pattern': ...\n", + " 2019-02-18 20:21:14.791607\n", + " 2019-02-18 20:21:14.917641\n", + " 2019-02-18 20:21:15.071268\n", + " 2019-02-18 20:21:15.093854\n", " 0\n", " False\n", - " 0.187298\n", - " (7152, 11065039815)\n", + " 0.153627\n", + " (4523, 6313058280)\n", " NaN\n", " NaN\n", " \n", @@ -1507,39 +1521,46 @@ ], "text/plain": [ " qid id name priority lane timeout function \\\n", - "0 d91454f7 1 /home/donald/bin 100 NaN 0 enum_files \n", - "1 d91454f7 2 /home/donald/Desktop 100 NaN 0 enum_files \n", - "2 d91454f7 5 /home/donald/Music 100 NaN 0 enum_files \n", - "3 d91454f7 4 /home/donald/Downloads 100 NaN 0 enum_files \n", - "4 d91454f7 3 /home/donald/Documents 100 NaN 0 enum_files \n", + "0 141e2d04 1 /home/donald/bin 100 NaN 0 enum_files \n", + "1 141e2d04 2 /home/donald/Desktop 100 NaN 0 enum_files \n", + "2 141e2d04 5 /home/donald/Music 100 NaN 0 enum_files \n", + "3 141e2d04 3 /home/donald/Documents 100 NaN 0 enum_files \n", + "4 141e2d04 4 /home/donald/Downloads 100 NaN 0 enum_files \n", "\n", " args kwargs \\\n", "0 NaN {'path': '/home/donald/bin', 'pattern': '*'} \n", "1 NaN {'path': '/home/donald/Desktop', 'pattern': '*'} \n", "2 NaN {'path': '/home/donald/Music', 'pattern': '*'} \n", - "3 NaN {'path': '/home/donald/Downloads', 'pattern': ... \n", - "4 NaN {'path': '/home/donald/Documents', 'pattern': ... \n", + "3 NaN {'path': '/home/donald/Documents', 'pattern': ... \n", + "4 NaN {'path': '/home/donald/Downloads', 'pattern': ... \n", "\n", " submitted started \\\n", - "0 2019-01-24 04:16:31.168725 2019-01-24 04:16:31.274264 \n", - "1 2019-01-24 04:16:31.168761 2019-01-24 04:16:31.281023 \n", - "2 2019-01-24 04:16:31.168798 2019-01-24 04:16:31.302599 \n", - "3 2019-01-24 04:16:31.168782 2019-01-24 04:16:31.296372 \n", - "4 2019-01-24 04:16:31.168770 2019-01-24 04:16:31.289080 \n", + "0 2019-02-18 20:21:14.791565 2019-02-18 20:21:14.897535 \n", + "1 2019-02-18 20:21:14.791587 2019-02-18 20:21:14.903832 \n", + "2 2019-02-18 20:21:14.791620 2019-02-18 20:21:14.926363 \n", + "3 2019-02-18 20:21:14.791596 2019-02-18 20:21:14.910665 \n", + "4 2019-02-18 20:21:14.791607 2019-02-18 20:21:14.917641 \n", "\n", " ended processed exitcode cancelled \\\n", - "0 2019-01-24 04:16:31.278330 2019-01-24 04:16:31.370645 0 False \n", - "1 2019-01-24 04:16:31.286515 2019-01-24 04:16:31.371730 0 False \n", - "2 2019-01-24 04:16:31.306935 2019-01-24 04:16:31.372170 0 False \n", - "3 2019-01-24 04:16:31.393124 2019-01-24 04:16:31.470766 0 False \n", - "4 2019-01-24 04:16:31.476378 2019-01-24 04:16:31.571118 0 False \n", + "0 2019-02-18 20:21:14.901591 2019-02-18 20:21:14.993735 0 False \n", + "1 2019-02-18 20:21:14.908947 2019-02-18 20:21:14.994798 0 False \n", + "2 2019-02-18 20:21:14.930386 2019-02-18 20:21:14.995248 0 False \n", + "3 2019-02-18 20:21:15.001843 2019-02-18 20:21:15.093378 1 False \n", + "4 2019-02-18 20:21:15.071268 2019-02-18 20:21:15.093854 0 False \n", + "\n", + " runtime output \\\n", + "0 0.004056 (3, 83860646) \n", + "1 0.005115 (17, 1162796) \n", + "2 0.004023 (0, 0) \n", + "3 0.091178 NaN \n", + "4 0.153627 (4523, 6313058280) \n", "\n", - " runtime output exception callback \n", - "0 0.004066 (3, 83860495) NaN NaN \n", - "1 0.005492 (9, 418216) NaN NaN \n", - "2 0.004336 (0, 0) NaN NaN \n", - "3 0.096751 (3930, 6021598980) NaN NaN \n", - "4 0.187298 (7152, 11065039815) NaN NaN " + " exception callback \n", + "0 NaN NaN \n", + "1 NaN NaN \n", + "2 NaN NaN \n", + "3 Traceback (most recent call last):\\n File \"..... NaN \n", + "4 NaN NaN " ] }, "execution_count": 29, @@ -1566,7 +1587,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyEAAAGxCAYAAAB1F7mZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XdUVGf+BvCHKSjg0JGmglGxIgpRbETsBRWMBTSCHVusiRE1rhiN2WgU29piDIuKscVVQcWwa9soFozGElajQXQQlKqABoaZ3x8e7s8RCKDTkOdzDufM3PvOe7/zjpncZ95bjFQqlQpEREREREQ6ItJ3AUREREREVLMwhBARERERkU4xhBARERERkU4xhBARERERkU4xhBARERERkU4xhBARERERkU4xhBARERERkU4xhBARERERkU4xhBARERERkU4xhBARERERkU5J9F3AmygoKEBSUhKaNWsGU1NTfZdDRERElZSTk4OCggKN9GVqagpLS0uN9EVEulUtQ0hSUhK8vLyQmJgIT09PjfWrUqnw7NkzyGQyGBkZaaxfbVKpVFAqlRCJRNWqZo6z9nGctY9jrBscZ93QxTjn5ORgw4YNUCgUGulPIpHg448/ZhAhqoaqZQjRFpVKhby8PNSpU6fa/E8DgPA/uuqC46wbHGft4xjrBsdZN3QxzgUFBVAoFGjbti3q1KnzVn3l5eXhl19+QUFBAUMIUTXEEEJEREQ6VadOHQYHohqu+vxEQ0RERERE7wSGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0ineJ+Q1CoUCCoWi2txgSqVSCXeerS438VIqlQY/zk+U6WrPVSoViouLIVaKq804q5RKPFFmAIXFMDLQcX5ddRtnjrFucJwBO5G9Bqr6a69+NxsbG2t9e0RUszGEvCY7OxticTX6n3PJ/+iqWc2GPs6LCz7Rdwma81DfBdQAHGPdqMHjvMR0tda38ep3s7Ozs9a3R0Q1m8GEkHPnziE6Ohrp6ekwNzfH+PHj0alTJ32XRUREREREGmYQIeTatWvYtm0bPv30UzRr1gxPnz7Fixcv9F0WERERERFpgUGEkOjoaAQGBqJFixYAAEtLSz1XRERERERE2qL3EFJcXIw7d+6gffv2mDx5Ml68eIG2bdtiwoQJMDMz03d5RERERESkYXq/zEhOTg4UCgXOnDmDZcuWYcOGDcjJycG2bdvU2j169AhXrlzBlStX8Ntvv+mpWiIiIiIielt6nwmpVasWAMDPzw+2trYAgGHDhmH58uVq7bZs2YIlS5bovD4iIiIiItIsvc+E1KlTB7a2thVeqnXSpElITExEYmIidu7cqaPqiIiIiIhI0/Q+EwIAvXv3RmxsLN5//33UqlULBw4cQPv27dXaODo6wtHRUU8VEhERERGRphhECBk2bBiePn2KadOmQSwW4/3338eECRP0XRYREREREWmBQYQQsViM0NBQhIaG6rsUIiIiIiLSMr2fE0JERERERDWLQcyEGBIrKyvY2dlBJKoe+UylUkGhUEAikVR4cr+hUCqVKC4uNuhx/kK5Su25SqVCcXExxGJxtRlnlVKJJxkZsLO1hZGBjvPrqts4c4x1g+MM2InqaqCqv/bqdzMRkbYxhLxGIpFAIpEY7M7x61QqFQBUuxBi6OPsCGe159U17EEkhoOxg8GO8+uq2zhzjHWD46wbr343ExFpW/X4NiciIiIioncGQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREekUQwgREREREemURN8FGBqFQgGFQgGRqHrkM5VKBYVCAQAwMjLSczWVo1Qq9TrOSkW62nORxL7C17wL4yyR8D93IiIiMgzcK3lNdnY2xGJxtdnRVKlUKC4urnY163OcC9I/UXtuar+6wte8C+Ps5OSk75KIiIiIAPBwLCIiIiIi0jGGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imGECIiIiIi0imJvgswNFZWVrCzs4NIVD3ymUqlgkKhgEQigZGRkb7LqRSlUoni4mK9jbPSepXac5GkboWv4TgTERERaQ5DyGskEgkkEkm12WlTqVQAUO12jvU6zhLnKr+E40xERESkOdwzISIiIiIinWIIISIiIiIinWIIISIiIiIinWIIISIiIiIinWIIISIiIiIinWIIISIiIiIinWIIISIiIiIinWIIISIiIiIinWIIISIiIiIinWIIISIiIiIinWIIISIiIiIinWIIISIiIqqkMWPGoFWrVjh16hTatm0LMzMztG/fHomJiUKbVatWoV27drCwsEDdunUxYMAA3L59u8x+4uPj0bp1a5iYmKBr165ITk5GVlYWhg8fDnNzczRq1Ah79uwpVUdsbCy8vb1hYmICOzs7TJkyBfn5+Vp//0SawhBCREREVAVpaWmYMWMG5s6di7179+LFixcYPHgwioqKAAAPHz7Exx9/jEOHDmHbtm1QKpXo1KkTsrKySvXzySefYOHChdi1axfu3r2Ljz76CIGBgXB3d8eBAwfg5eWFUaNG4f79+8Lr9u/fj0GDBsHd3R0HDx7EihUr8OOPP2L8+PE6HQeityHRdwFERERE1UlWVhZOnz6Nli1bAgDMzMzQrVs3XLhwAV26dEFERITQtri4GL169ULdunWxf/9+hIaGlttPamoqpk+fjnnz5mHRokUAgHbt2uHHH3/Ev/71L8ycORMqlQqffvopAgMDsW3bNqEvR0dH9O/fH4sWLRL6IzJknAkhIiIiqgInJye1Hf0WLVoAeDkDAgAJCQno1asXbGxsIJFIYGpqiry8vFKHZL3ej5ubGwCgZ8+ewjJLS0vUrVsXDx48AADcvn0b9+/fx/Dhw6FQKIS/rl27QiQS4fLly9p500QaxpkQIiIioiqwtLRUe25sbAwAePHiBVJSUtC7d2+8//772LJlC5ycnGBsbAw/Pz+8ePGiUv2UtbzktRkZGQCAwYMHl1lbSVghMnQMIUREREQacvz4ceTl5eHHH38UwoRCoSh1Psibsra2BgBs2LAB3t7epdY7OTlpZDtE2sYQQkRERKQhz58/h5GREaRSqbBs7969UCgUGum/WbNmqFevHu7du4dp06ZppE8ifWAIISIiItKQ7t27AwDGjh2LSZMm4ebNm1i1alWpQ6zelJGREVavXo2RI0ciPz8ffn5+MDMzw/379xEbG4vly5cL55YQGTKemE5ERESkIe7u7oiMjERiYiIGDBiA3bt3Y//+/bCwsNDYNoYNG4ajR48iKSkJI0aMwKBBg7Bq1Sq4urrC3t5eY9sh0ibOhBARERFVUmRkZKlllpaWUKlUwvPg4GAEBwertUlOTq6wH19fX7V+ynstAPTq1Qu9evWqVM1EhogzIUREREREpFMMIUREREREpFMMIUREREREpFM8J4SIiIioAnl5eRq718frJBIJ7+9BNQ5DCBEREVEF8vLy8OTJE630LZVKGUKoxmEIISIiIqoCTd+H448//tBof0TVAc8JISIiIiIinWIIISIiIiIineLhWERERESVsHJzyV3P0zXar7VlbWxcqdEuiQweZ0KIiIiIqgFfX19s3rxZ32VUSlhYGMaMGaP17URGRqJDhw7lrg8KCkJ4eLjW6yjLmDFjEBYWppdtVwcMIUREREQGKjc3F9bW1igsLNR3KaXcunVL4yfp68LGjRsRGhoKADAyMoKZmRlkMhlsbGzg4+ODbdu2QaVSabWG8PBwBAUFaXUbho4hhIiIiMhAxcXFwdfXF8bGxvoupZSYmBgMGDBA32VU2et1JyYm4tmzZ0hNTcXChQvx1VdfYeLEiXqssGZgCCEiIiIyUK/vMMvlcnTr1g0ymQydO3fG/fv3hXUXL15Ex44dYWFhAXd3d8TExAjrwsPDMWTIEIwbNw7m5uZo0qQJLl68iKioKLi4uMDW1hYRERFCe5VKhdWrV8PNzQ3W1tbo378/Hj58WG5tv/76K9q1aweZTAY/Pz9kZ2ertT127Bg8PDxgYWEBb29vnD9/Xlg3ZswYTJ06FR9++CFkMhlat26Nq1evCutXrlyJxo0bQyaToXnz5jhw4EC543Xy5Em0bNkSMpkMISEhpWaQCgoKkJCQgJ49e5Z6ba1atdC3b1/s2rUL27dvx82bNwEAhYWFWLBgARo2bAhbW1uMHDlSeH8vXrzAmDFjYGNjAwsLC3h4eODWrVul+n7x4gUGDx6MESNG4MiRI1i+fDkOHDiAOnXqwNXVFQDw9OlTjB8/Hg4ODqhXrx7mzJmDP//8EwCQnJwMIyMjbNu2DfXr14ednR0WLFgApVJZ7lgYOoYQIiIiIgOkVCoRFxcHPz8/YVlUVBTWr1+PzMxMODo6YtGiRQCA7Oxs9O3bF+PGjUNmZiZWrVqFwMBA/Pbbb8JrY2JiEBAQgOzsbAQEBGDYsGE4d+4ckpKSEBsbi3nz5uHBgwcAgA0bNmDXrl04ceIE0tPT4enpqXb4UHZ2Nm7evAkfHx8UFRXB398fgwcPRlZWFmbOnIkdO3YIbe/cuYMhQ4Zg+fLlyMzMxLRp09CvXz9kZGQIbaKjozFnzhzk5OSge/fumDFjhrCuYcOGOH36NHJzc7F06VIEBweXCkQAkJWVBX9/f4SFhSE7Oxs9evTA4cOH1drEx8ejQ4cOMDU1LXfcO3ToAGdnZ5w5cwYAMH/+fFy5cgUXLlzAgwcPYGxsjI8//hgA8M9//hPXr1/H3bt3kZOTgx9++AHW1tZq/eXm5qJv375wdHTErl27MHDgQCxYsABDhgxBXl4ekpOTAQAzZsyAXC5HUlISLl++jJ9//hlffPGFWl/Hjh3DrVu3kJCQgB9++AGRkZHlvg9DxxBCREREZIASEhLg4uICe3t7YdnYsWPRqlUrGBsbY+TIkbhy5QoAIDY2Fi4uLpg4cSIkEgl69+6NgQMHIjo6Wnhtx44dMWjQIIjFYowYMQIpKSkIDw+HiYkJvL294erqimvXrgEANm3ahGXLlsHV1RVSqRTh4eG4dOkSUlJSALzcGe7RowekUinOnz+P/Px8hIWFQSqVonfv3ujTp4+w3T179qBPnz7w8/ODRCJBSEgImjVrhkOHDgltAgIC0KVLF4jFYoSEhAjvCwCGDh0KZ2dniEQiDB06FE2bNsWFCxdKjVdMTAyaNGmC4OBgSCQSjB49Gu7u7qXaVOYQMicnJ2RlZUGlUmHz5s2IiIhA3bp1YWJigqVLl2Lfvn0oLi6GsbExnj17hqSkJKhUKjRv3hwODg5CP2lpafD19YWPjw82btwIkajsXe/i4mLs3r0bX3/9NSwtLeHg4IAlS5YgKipKrV14eDhkMhkaNWqEmTNnqn2+1Q1DCBEREZEBio2NLbXD/OoOrqmpKfLy8gC8PEyr5LCeEq6urpDL5eW+9q/6S05ORmBgICwtLWFpaQlbW1uIRCJhBuLV2lJTU4WQUMLFxUV4/Ca15efnC8+joqLQpk0boZbr16+rzaKUSE1NRYMGDdSWvVoHABw9erRSISQ1NRXW1tZ48uQJCgoK0LFjR2H77u7uEIlESEtLQ3BwMEaPHo3Q0FDUrVsXoaGhePr0qdDPsWPH8PjxY8yaNesvt5eRkYHCwkK1cXJ1dcWjR4/UTpJ/9f25uLiojWF1wxBCREREZIBiYmLUDsX6K87OzsJhPSWSk5Ph7Oz8Rttu0KABDh8+jJycHOHv+fPn6NSpE4qLi3HixAn069cPwMtZA7lcrnZ+QsmMydvWdv/+fUyYMAHr1q1DZmYmcnJy4O7uXubVq5ycnNS2+3odv/zyC6ysrEoFlddduHABcrkcPj4+sLW1hYmJCa5evao2Fi9evICzszMkEgkWLlyIX3/9FdevX8etW7ewcuX/3/Rl7NixCAoKQs+ePZGVlSUsNzIyUtumra0tjI2N1cYpOTkZjo6Oam1ffT8pKSlv/PkaAoYQIiIiIgPz4MEDZGRkwNPTs1Lt+/fvj+TkZGzfvh0KhQLx8fE4cuQIRo4c+UbbnzJlChYuXIi7d+8CeHkOyN69ewEA586dQ+PGjWFnZwfg5WFeJiYmWLFiBYqKihAfH4/jx48LfQ0fPhxxcXE4duwYFAoFdu7ciaSkJPj7+1dYR8mMSMm2oqKicOPGjTLb+vn54fbt24iOjoZCocCOHTtw/fp1YX1Fh2IVFhbixIkTGDVqFEaPHo1WrVpBJBJh0qRJmD17Nh49egQAePz4sXAo2cmTJ3Ht2jUUFxejTp06qFWrFsRisVq/q1atQrdu3dSCiL29PZKTk4XgJhaLERQUhPnz5yMnJwfp6elYsmQJgoOD1fpasmQJnj17hnv37mHt2rUYMWJEhWNoqBhCiIiIiAxMTEwM+vfvX+oX8/JYW1vj6NGj2LJlC2xsbDBr1ixER0ejefPmb7T96dOnIygoCAMGDIC5uTk8PDwQFxcn1PbqzrxUKsWhQ4ewf/9+WFlZISIiQm3n2c3NDXv37sW8efNgY2ODtWvXIjY2Fra2thXW0aJFC8ydOxedO3eGvb09rl69ik6dOpXZ1sbGBgcPHsSyZctgZWWFn376CQMHDhTWlxdCvLy8IJPJ4ODggC+++AKffvopvvvuO2H93//+d3h4eMDHxwcymQydOnXCxYsXAbw85yMwMBAWFhZo1KgRnJ2dMXfu3FLbWL16Nbp27SoEkWHDhkEqlcLGxgaNGjUCAKxbtw729vZo2rQp2rZti/bt2+Nvf/ubWj99+/ZFixYt4O3tjWHDhmHs2LEVjqGhMlJp+24sWnDlyhV4eXkhMTGx0r8QVIZSqURaWhocHBzKPXHI0KhUKigUCkgkkkp/Uekbx1k3OM7axzHWDY6zbuhinFNTU7F161b4+PjA0tLyrfrKycnB2bNnERoaCicnJw1VWL60tDTMWpSnlb6tLZXYuFL9pn9+fn4IDQ2t1GyBrrVs2RLR0dHw8PDQdymV9vjxY7Rq1QppaWnV5nvkVcnJyWjYsCGeP3+O2rVr67scjah+nwIRERHRO67kV3NDU1hYiI8++qhaBRDgZWiNiIiolgHkXSXRdwFEREREpO6zzz7TdwllMjY2xoIFC/RdRpW5ubnBzc2t4oakMwwhRERERJUwd3IuAGh8Z/aPP/7QaH/07nF1dS3zimDVGeekiIiIiIhIpxhCiIiIiIhIpxhCiIiIiIhIp3hOCBEREVEFpFIpatWqBeDlXbw1qaRfopqEIYSIiIioAjY2NrCxsdF3GUTvDB6ORUREREREOsWZECIiIjIYxcXFSEpKQlZWFqytrdGsWTOIxWJ9lwXg5V23tUEsFnOWhWochhAiIiIyCH/88Qe+/PJLFBYWwsbGBpmZmahVqxYWLFiAhg0b6rW2tLQ0yOVyrfQtlUoZQqjGYQghIiIig7B+/Xr069cPQ4YMEZYdOHAAGzZswKpVq/RYGRFpGkPIaxQKBRQKBUSi6nG6jEqlgkKhAAAYGRnpuZrKUSqVWh1nZfoTjfepUqlQXFwMpVhcjcZZBWXGExQWAyJR9ahZl+Mssrd76z5e/bdsbGysgaqIaja5XI6AgAC1ZQEBAdi3b5+eKiob75hO9PYMKoQ8ffoUU6ZMgaOjI7755hu91JCdnQ1xNdrRLNlpq241a3OcCz5ZrPE+q7OH+i7AQJmuXvLWfbz6b9nZ2VkDVRHVbK1atcL169fRpk0bYdmvv/6Kli1b6rEqItIGgwoh33//PerXry/8sk9ERETvtn/+85/CYxsbG3z55Zfw9PSEnZ0dHj9+jF9++QXdunXTY4X/T7TSAgDwO9I127F1bWCjZrskMnQGc8zRjRs3kJqaip49e+q7FCIiItKRnJwc4a+oqAhdunSBqakp8vPzYWZmhi5duqCoqEjfZRKRhhnETEhRURG2bNmCOXPm4N69e/ouh4iIiHRk5syZ+i6h2vD19UVQUBAmT56s71IqFBYWhrS0NERGRmp1O5GRkdi8eTMSEhLKXB8UFIRmzZohPDxcq3VQ1RnETMiBAwfg4eGh98vvERERkf48fvy43L8ST55o/uIjhiw3NxfW1tYoLCzUdyml3Lp1S+Mn6evCxo0bERoaCuDlRX3MzMwgk8lgY2MDHx8fbNu2DSqVSs9ValZkZCQ6dOig7zLU6H0mJDU1Ff/+97+xdu3av2z36NEjPHr0CADw22+/6aI0IiIi0qHQ0FCoVKpSFy1RqVQ4dOgQAODjjz/Gnj179FGeXsTFxcHX19cgr8AXExODAQMG6LuMKouJiVGbTUpMTESzZs3w559/4uTJk5g2bRoSEhKwbds2PVb57tP7TMhvv/2G7OxsTJ48GSEhIfj2229x7949hISEoKCgQGi3ZcsWeHl5wcvLC6NGjdJjxURERKQN+/btw/79+7Fv3z61v/379wttdu3apccKde/1HX25XI5u3bpBJpOhc+fOuH//vrDu4sWL6NixIywsLODu7o6YmBhhXXh4OIYMGYJx48bB3NwcTZo0wcWLFxEVFQUXFxfY2toiIiJCaK9SqbB69Wq4ubnB2toa/fv3x8OH6tdbfLW2X3/9Fe3atYNMJoOfnx+ys7PV2h47dgweHh6wsLCAt7c3zp8/L6wbM2YMpk6dig8//BAymQytW7fG1atXhfUrV65E48aNIZPJ0Lx5cxw4cKDc8Tp58iRatmwJmUyGkJCQUjNIBQUFSEhIKPMc5Fq1aqFv377YtWsXtm/fjps3bwJ4efXW8ePHw8HBAfXq1cOcOXPw559/qo37Bx98ACsrKzg4OOCrr74SxjwoKEho9+LFCxgZGSE5OVl431OmTEFAQADq1KmDtm3b4u7du1ixYgUcHBzg6OioFrgLCwuFG3fa2tpi5MiRwjgnJyfDyMgIO3bsQMOGDWFlZYXZs2cDAK5fv47Jkyfj0qVLqFOnDurUqYP8/HxcvnwZ3t7eMDc3h52dHT766KNyx1Ub9B5CunTpgm+//RZr167F2rVrMXLkSLi4uGDt2rUwMTER2k2aNAmJiYlITEzEzp079VgxERERaYNUKoVUKkVOTg7u3buHnJwcYVkJiUTvB3HojFKpRFxcHPz8/IRlUVFRWL9+PTIzM+Ho6IhFixYBeHmLgb59+2LcuHHIzMzEqlWrEBgYqHb0SExMDAICApCdnY2AgAAMGzYM586dQ1JSEmJjYzFv3jw8ePAAALBhwwbs2rULJ06cQHp6Ojw9PdV2qLOzs3Hz5k34+PigqKgI/v7+GDx4MLKysjBz5kzs2LFDaHvnzh0MGTIEy5cvR2ZmJqZNm4Z+/fohIyNDaBMdHY05c+YgJycH3bt3x4wZM4R1DRs2xOnTp5Gbm4ulS5ciODi4VCACgKysLPj7+yMsLAzZ2dno0aMHDh8+rNYmPj4eHTp0gKmpabnj3qFDBzg7O+PMmTMAgBkzZkAulyMpKQmXL1/Gzz//jC+++AIA8PDhQ/Tq1Qvjxo1Deno6bt++je7du//Fp6ruhx9+EOp1c3NDr1698Pz5czx48ADr1q3DpEmT8Pz5cwDA/PnzceXKFVy4cAEPHjyAsbExPv7441Lv78aNG0hMTMT333+P//znP3B3d8fmzZvRrl075OXlIS8vD2ZmZpg+fToGDRqEnJwcPHjwAFOnTq103Zqg9xBSq1YtWFlZCX9mZmYQi8WwsrJSm451dHSEp6cnPD090bx5cz1WTERERNrw5MkTzJs3DxMnTsQXX3yBiRMnYt68eTXuPJASCQkJcHFxgb29vbBs7NixaNWqFYyNjTFy5EhcuXIFABAbGwsXFxdMnDgREokEvXv3xsCBAxEdHS28tmPHjhg0aBDEYjFGjBiBlJQUhIeHw8TEBN7e3nB1dcW1a9cAAJs2bcKyZcvg6uoKqVSK8PBwXLp0CSkpKQBezmz06NEDUqkU58+fR35+PsLCwiCVStG7d2/06dNH2O6ePXvQp08f+Pn5QSKRICQkBM2aNRMOsQNe3pSyS5cuEIvFCAkJEd4XAAwdOhTOzs4QiUQYOnQomjZtigsXLpQar5iYGDRp0gTBwcGQSCQYPXo03N3dS7WpzCFkTk5OyMrKQnFxMXbv3o2vv/4alpaWcHBwwJIlSxAVFQUA2LlzJ3x8fDBmzBgYGxvD3Nwc3t7eFfZfwt/fHx06dIBUKkVgYCAeP36Mzz//HFKpFMOGDcPz589x9+5dqFQqbN68GREREahbty5MTEywdOlS7Nu3D8XFxUJ/S5YsgZmZGd577z188MEHauP4OmNjY9y/fx+pqamoXbs2OnfuXOm6NUHvIeR1PXr00NuNComIiEh/1qxZg0aNGmH37t3YtWsXdu/ejffeew/r1q3Td2l6ERsbW2qH2cHBQXhsamqKvLw8AC8P03J1dVVr6+rqCrlcXu5r/6q/5ORkBAYGwtLSEpaWlrC1tYVIJBJmIF6tLTU1VQgJJVxcXITHb1Jbfn6+8DyKgCd3AAAgAElEQVQqKgpt2rQRarl+/braLEqJ1NRUNGjQQG3Zq3UAwNGjRysVQlJTU2FtbY2MjAwUFhaq1e/q6opHjx5BpVIhJSUFjRs3rrC/8rz+vm1tbSEWi4VlJiYmyMvLw5MnT1BQUICOHTsK4+Du7g6RSIS0tLRy+yv5PMuyfft2FBQUwNPTEy1btsT27dvf+H28CYMLIURERFQz3b17F2PHjhUOxzYxMcH48eNx584dPVemHzExMWqHYv0VZ2dn4VyDEsnJyXB2dn6jbTdo0ACHDx9Wu4/L8+fP0alTJxQXF+PEiRPo168fgJezBnK5HEqlUnh9yYzJ29Z2//59TJgwAevWrUNmZiZycnLg7u5e5tWrnJyc1Lb7eh2//PILrKysSgWV1124cAFyuRw+Pj6wtbWFsbGxWv3JyclwdHSEkZERGjRogN9//73MfurUqaN2fvOrYaGqbG1tYWJigqtXr6p9Ji9evKjUOL5+sQcAaNSoEXbu3In09HT84x//wOTJk8t9L9rAEEJEREQGwdXVtdRO5P3790v9il4TPHjwABkZGfD09KxU+/79+yM5ORnbt2+HQqFAfHw8jhw5gpEjR77R9qdMmYKFCxfi7t27AF6eA7J3714AwLlz59C4cWPY2dkBeHmYl4mJCVasWIGioiLEx8fj+PHjQl/Dhw9HXFwcjh07BoVCgZ07dyIpKQn+/v4V1lEyI1KyraioKNy4caPMtn5+frh9+zaio6OhUCiwY8cOXL9+XVhf0aFYhYWFOHHiBEaNGoXRo0ejVatWEIvFCAoKwvz585GTk4P09HQsWbIEwcHBAICPPvoIZ86cwY4dO1BUVISnT58Kh4q1bdsWZ8+exb1795Cfn48lS5ZU+H7LIxKJMGnSJMyePVu4Wuzjx4/VDmn7K/b29pDL5Won1EdFReHx48cwMjKCpaUljIyM1GZhtK3mnN1VSVZWVrCzs1ObUjRkKpUKCoUCEomkzJRriJRKJYqLi7U2zspVX2i8T5VKheLiYojF4mo0zipkZDyBra0dRKLqUbMux1lU1+6t+3j13zIRvb2WLVtiyZIl6Nq1K+zs7PDkyROcOnUKvXr1Utup7du3rx6r1I2YmBj079+/0t+F1tbWOHr0KGbNmoXZs2ejfv36iI6OfuPzaKdPnw6RSIQBAwZALpfD0tISvXr1wvDhw0vtzEulUhw6dAgTJkzAsmXL0LVrVwQHBws7vG5ubti7dy/mzZuHoKAguLm5ITY2Fra2thXW0aJFC8ydOxedO3eGSCRCSEgIOnXqVGZbGxsbHDx4EDNmzMCkSZMwePBgDBw4UFgfExOD1atXl3qdl5cXRCIRpFIpWrRogU8//RQTJ04U1q9btw6zZs1C06ZNIRaLMWzYMPztb38DANSvXx/Hjx/H3LlzMX36dJiYmGDWrFnw9vZGjx49EBISAi8vL1haWmLZsmVvdfPGv//97/jqq6/g4+OD9PR02NvbIzAwsFJhrnv37mjTpg0cHR2hVCohl8vx008/Ye7cucjPz4ejoyM2btyo03v2Gamq4d1Yrly5Ai8vLyQmJlb6F4LKUCqVSEtLg4ODA0OIFnGcdYPjrH0cY93gOOuGLsY5NTUVW7duhY+PDywtLUutX7hwYaX6+fLLL5GTk4OzZ88iNDQUTk5Omi61lLS0NDyaVf7x9W/FWom2G9Vv+ufn54fQ0NBK7WDqWsuWLREdHQ0PDw99l1Jpjx8/RqtWrZCWllZtvkfedZwJISIiIoPw5Zdf6rsEg9G1a9cy72Whb4WFhfjoo4+qVQABgJycHERERDCAGBCGECIiIqJKUM7NBfDy8CJN+uOPP0ot++yzzzS6DU0xNjbGggUL9F1Glbm5uWn8c6O3wzhIREREBqGsE3eXLl2qh0qISNsYQoiIiMggtGzZstSyFi1a6KESItK2Sh2O1bBhwyqdWHfv3r03LoiIiIhqpqFDh5ZaNmTIED1UQkTaVqkQ4u/vrxZC9u/fj6dPn6Jnz56wt7dHeno64uPjYWFhUeYXCBEREVF1JhaLIZG83G3S9I+tUqlUo/0RVQeVCiFr1qwRHq9cuVK4JrK5ubmwPDc3F/369YO9vb3mqyQiIiLSIzs7O94TiEiDqnxOyLp16zB//ny1AAIAFhYWCAsLw/r16zVWHBERERERvXuqfInerKws5ObmlrkuNzcX2dnZb10UERERkaHR1j6OSCSChYWFVvomMlRVDiE9evTAvHnzUL9+fXTt2lVYfurUKYSFhaFHjx4aLZCIiIhI39LS0iCXy7XSt1QqRevWrbXSN5GhqvLhWFu2bIGTkxO6d+8Oa2trNG3aFNbW1ujRowccHR2xefNmbdRJRERE77iFCxdCoVCUue7o0aP4xz/+oeOKiEhbqjwT4ujoiEuXLuH48eO4ePEiHj16BEdHR7Rv3x59+/bVRo1ERERUA9y4cQNKpbLMdfXq1cORI0d0XFHZdHHHdKJ3XZVDSIm+ffsydBAREZHGGBkZYfHixRCJSh+oUVRUhEePHumhKiLShkqFkKysLFhaWkIkEiErK6vC9tbW1m9dGBEREdU8Xbp0gVgsLnNd9+7ddVyNOouVLw85T9dwv7WtLYGNKzXcK5Fhq1QIsbOzw/nz59G+fXvY2tpWePf04uJijRRHRERENUvv3r158z6iGqBSIWT79u1o1KiR8LiiEEJERERUVTNmzCh3FoQAX19fBAUFYfLkyfoupUJhYWFIS0tDZGSkVrcTGRmJzZs3IyEhocz1QUFBaNasGcLDw7Vax9uq6H28DUMdg0qFkNGjRwuPx4wZo61aiIiIqAbT9+FWhig3NxcNGzZEWlqavksp5datWwgICMDt27f1XUqVbNy4EVevXsXWrVthZGQEU1NTiEQiGBsbo0WLFhg9ejTGjx/PH921rMqX6CUiIiLSlqdPn2LChAnYsGED8vLy9F2O3sXFxcHX1xfGxsb6LqWUmJgYDBgwQN9lVNnrdScmJuLZs2dITU3FwoUL8dVXX2HixIl6rLBmYAghIiIig6FUKlFYWIh69ephzpw5+M9//qPvkvTq9R1muVyObt26QSaToXPnzrh//76w7uLFi+jYsSMsLCzg7u6OmJgYYV14eDiGDBmCcePGwdzcHE2aNMHFixcRFRUFFxcX2NraIiIiQmivUqmwevVquLm5wdraGv3798fDhw/Lre3XX39Fu3btIJPJ4OfnV+ru8seOHYOHhwcsLCzg7e2N8+fPC+vGjBmDqVOn4sMPP4RMJkPr1q1x9epVYf3KlSvRuHFjyGQyNG/eHAcOHCh3vE6ePImWLVtCJpMhJCQEhYWFausLCgqQkJCAnj17lnptrVq10LdvX+zatQvbt2/HzZs3AbwMxuPHj4eDg4Pw7/LPP/8EAEyYMAHLli0T+q5VqxbCwsIAAAqFAjKZDMnJyUhOToaRkRF27NiBhg0bwsrKCrNnzy73ffzVZ3n58mV06tQJlpaWcHBwwNSpU4V6KhqDzMxM+Pv7w8rKClZWVvD29kZGRka5dWgTQwgREREZFCMjIwQEBODrr7/G5cuX8fnnnyM1NVXfZemcUqlEXFwc/Pz8hGVRUVFYv349MjMz4ejoiEWLFgEAsrOz0bdvX4wbNw6ZmZlYtWoVAgMD8dtvvwmvjYmJQUBAALKzsxEQEIBhw4bh3LlzSEpKQmxsLObNm4cHDx4AADZs2IBdu3bhxIkTSE9Ph6enJ4KCgoS+srOzcfPmTfj4+KCoqAj+/v4YPHgwsrKyMHPmTOzYsUNoe+fOHQwZMgTLly9HZmYmpk2bhn79+qnt/EZHR2POnDnIyclB9+7dMWPGDGFdw4YNcfr0aeTm5mLp0qUIDg4uFYiAl1dz9ff3R1hYGLKzs9GjRw8cPnxYrU18fDw6dOgAU1PTcse9Q4cOcHZ2xpkzZwC8PFdJLpcjKSkJly9fxs8//4wvvvgCwMvzdE6dOgUA+Pnnn1GvXj3h+aVLl2BjYwNXV1e17d+4cQOJiYn4/vvvywzZFX2WYrEY33zzDTIyMnDhwgWcPn0a69evr9QYfPPNN1AqlZDL5cjIyMDGjRtRu3btcsdCmxhCiIiIyCBZWVnhs88+w5AhQ/DVV18hOjpa3yXpVEJCAlxcXGBvby8sGzt2LFq1agVjY2OMHDkSV65cAQDExsbCxcUFEydOhEQiQe/evTFw4EC1MevYsSMGDRoEsViMESNGICUlBeHh4TAxMYG3tzdcXV1x7do1AMCmTZuwbNkyuLq6QiqVIjw8HJcuXUJKSgqAlzMbPXr0gFQqxfnz55Gfn4+wsDBIpVL07t0bffr0Eba7Z88e9OnTB35+fpBIJAgJCUGzZs1w6NAhoU1AQIBweeaQkBDhfQHA0KFD4ezsDJFIhKFDh6Jp06a4cOFCqfGKiYlBkyZNEBwcDIlEgtGjR8Pd3b1Um8ocQubk5ISsrCwUFxdj9+7d+Prrr4WZhyVLliAqKgrAyxBy/vx5FBYW4tSpU5gyZQru37+PvLw8nDp1Cr6+vmr9LlmyBGZmZnjvvffwwQcfqL3PEhV9lm3btkWnTp0gkUjg4uKC0NBQnD59ulJjYGxsjMzMTPz+++8Qi8Xw8vJCnTp1KhwPbXjjmxUSERERadLEiRNRXFyM3NxcTJgwQW1dcXEx9uzZg5EjR+qpOt2LjY0ttcPs4OAgPDY1NRXOm5HL5Wq/uAOAq6sr5HJ5ua/9q/6Sk5MRGBioduNIkUiEhw8fokGDBmq1paamCiGhhIuLC3Jyct64tvz8fOF5VFQUVq9ejeTkZABAXl5emYcQpaamokGDBmrLXFxc1J4fPXoUn3/+eanXltWXtbU1MjIyUFhYqFa/q6srHj16BJVKhXr16sHR0REXLlzAyZMnsWHDBpw/fx5nz57FyZMnS/17LW+8X1XReN2+fRtz5szB5cuXUVBQAIVCAQ8Pj0qNwdy5c/H8+XMMGTIE+fn5GDVqFL788ku9XBb7jUPI7du3cfHiRTx69AiOjo5o164dmjZtqsnaiIiIqAaZOnUq8vPzsWnTJkybNk3f5ehdTEwMtm/fXqm2zs7Owk56ieTkZDRp0uSNtt2gQQNs3ry51C/5wMtAeOLECaxZswbAy1kDuVwOpVIpBJGUlBSYm5sLtSUmJpaqrVevXhXWcf/+fUyYMAHx8fHo3LkzxGIx2rZtC5VKVaqtk5OTMFNTIiUlBW3atAEA/PLLL7Cysiq1k/66CxcuQC6Xw8fHB7a2tjA2NkZycrKwo5+cnAxHR0fh6lm+vr6IjY3F3bt30aZNG/j6+uKnn37CuXPnsHXr1grf4+sq+iynTJkCd3d3REdHw9zcHGvXrsXu3bsrNQZ16tTBihUrsGLFCty9exf9+vVD06ZNMX78+CrX+baqfDhWXl4eRo4ciRYtWiAkJASLFy9GSEgIWrZsiREjRvBKFkRERPRG2rZti/fffx9+fn5o27ZtmX81xYMHD5CRkQFPT89Kte/fvz+Sk5Oxfft2KBQKxMfH48iRI288czRlyhQsXLgQd+/eBfDyPIW9e/cCAM6dO4fGjRvDzs4OwMvDvExMTLBixQoUFRUhPj4ex48fF/oaPnw44uLicOzYMSgUCuzcuRNJSUnw9/evsI6SGZGSbUVFReHGjRtltvXz88Pt27cRHR0NhUKBHTt24Pr168L6ig7FKiwsxIkTJzBq1CiMHj0arVq1glgsRlBQEObPn4+cnBykp6djyZIlCA4OFl7n6+uLTZs2oWPHjhCJRPD19cV3330HW1vbUjMalVHRZ/ns2TOYm5tDJpPh9u3b2Lx5c5XG4Pbt21AqlTA3N4dUKtXbvXmqHEKmT5+OmJgYfPvtt8jNzUVBQQFyc3OxdetWxMbGYvr06dqok4iIiGqA2rVr16hDrsoTExOD/v37V/peFdbW1jh69Ci2bNkCGxsbzJo1C9HR0WjevPkbbX/69OkICgrCgAEDYG5uDg8PD8TFxQm1vbozL5VKcejQIezfvx9WVlaIiIhQ20l3c3PD3r17MW/ePNjY2GDt2rWIjY2Fra1thXW0aNECc+fORefOnWFvb4+rV6+iU6dOZba1sbHBwYMHsWzZMlhZWeGnn37CwIEDhfXlhRAvLy/IZDI4ODjgiy++wKefforvvvtOWL9u3TrY29ujadOmaNu2Ldq3b4+//e1vwnpfX188ffpUmDUqOWenrFmkyqjos/zmm2+wd+9eyGQyjB8/HsOGDav0GPz+++/o27evcBWy3r17q31WumSkKms+6y+Ym5vj66+/xpQpU0qt27hxI+bPn4/c3FyNFViWK1euwMvLC4mJiZX+haAylEol0tLS4ODgoHZcoyFTqVRQKBSQSCTV5qY6HGfd4DhrH8dYNzjOuqGLcU5NTcXWrVvh4+MDS0vLUutv3LiBli1bljlmd+7cwYsXL4STbHNycnD27FmEhobCyclJK/W+Ki0tDXmzFmmlb6W1Jdw2rlRb5ufnh9DQ0ErNFuhay5YtER0dLRyeVB08fvwYrVq1QlpaWrX5HnnXVflTqF27Nho2bFjmuvfee08vJ7YQERFR9bdw4UIoFIoy18nlcvzwww86rkh/unbtWua9LPStsLAQH330UbUKIMDL0BoREcEAYkCqfGL62LFjsWnTJvTp00ftlwqVSoWNGzdi7NixGi2QiIiIagYjIyPcuHGjzB80FQoF7t27p4eq/l/u3MkAXh5epEl//PFHqWWfffaZRrehKcbGxliwYIG+y6gyNzc3jX9u9HYqFUJWr14tPLaxsUFiYiKaNGmCgQMHom7dunj8+DGOHDmCP//8Ez4+PlorloiIiN5ta9asKfcQtlq1aum4GiLSlkqFkE8//bTM5WvXri21LCwsDHPnzn27qoiIiKjGUalU2LZtGw/tJqoBKhVClEqltusgIiKiGq5u3br6LoGIdIR3TCciIiKD8O233+q7hHK9eojY7du3Ndq3sbGxRvsjqg7eKITk5+cjMjIS//3vf5GVlQVra2v4+Phg9OjRMDMz03SNREREVEMolUrcuXMHT548gb29PRo3bmwQlzm2t7eHvb29vssgemdUOYQ8ePAAvr6+wu3r7e3t8b///Q/79u3D6tWrcfLkSdSvX18btRIREdE7LCcnB8uWLUNubi4yMjJgYWEBW1tbLFy4EFZWVvouj4g0qMohZM6cOQCAW7duoWnTpsLy//3vfxgwYAA++eQT7N27V3MVEhERUY3w/fffo127dggMDMTIkSMRGRmJXbt2Ydu2bQZx0Ztnz55ppV+RSMQjSajGqXII+emnn7Blyxa1AAIATZs2xdKlSzF58mSNFUdEREQ1x7Vr1zB16lS1ZYGBgRg3bpyeKvp/aWlpkMvlWulbKpWidevWWumbyFBV+baRCoUCJiYmZa4zMTFBcXHxWxdFRERENc+ff/4pnKStUqkAvJx94CV7id49VZ4J6dy5M5YtW4auXbvCwsJCWJ6bm4svv/wSnTt31miBREREVDM4ODjg0aNHcHJyAgCcPHkShw8fRs+ePfVcmTpd3DGd6F1X5RCyatUqfPDBB6hfvz66d+8Oe3t7PH78GP/+978hlUqxfft2bdRJRERE77ghQ4YgKysLTk5OsLW1xb///W/069cPvXv31ndpRKRhVQ4hrVq1wrVr1xAREYH//ve/uHnzJqytrTFx4kTMnj0b9erV00adRERE9I7r0qWL8Hj9+vV6rKRsFqKVAID03zXbb21YA9io2U6JDNwb3Sekfv36WL16taZrISIiohps7dq1GDx4MBo0aFBq3ZkzZ2Bqaor3339fD5URkaZV6sT01q1b48aNGwAAd3d3tG7dutw/Dw8PdOvWDfPmzUNWVpZWiyciIqJ3x8mTJ7Fo0SIkJyeXWmdmZob9+/frvigD4uvri82bN+u7jEoJCwvDmDFjtL6dyMhIdOjQodz1QUFBCA8P13od5Tl79iwaNWqkt+0bskqFEC8vL+H61V5eXn/55+npCRsbG3z33XcGcUk9IiIiqh5q1aqFkJAQLF68uNTJ2q1atcL9+/f1VJn+5ObmwtraGoWFhfoupZRbt25p/CR9Xdi4cSNCQ0MBAEZGRrCwsMDz58/V2rRp0wZGRkZISkp6q235+Pjg7t27b9XHu6pSh2N9//33wuPIyMhKdXzo0CEEBwe/UVFERERUM/Xo0QNSqRSLFy/G559/rraTWxMv1RsXFwdfX1/h0sWGJCYmBgMGDNB3GVUWExOjdl87BwcHHDx4ECNHjgQAXL16FS9evNBXeTVGle8TUlldu3bFjh07tNU9ERERvaM++OADTJ48GYsXL8aPP/6IO3fu4B//+Ac8PDz0XZrOvb6jL5fL0a1bN8hkMnTu3FltdujixYvo2LEjLCws4O7ujpiYGGFdeHg4hgwZgnHjxsHc3BxNmjTBxYsXERUVBRcXF9ja2iIiIkJor1KpsHr1ari5ucHa2hr9+/fHw4cPy63t119/Rbt27SCTyeDn54fs7Gy1tseOHYOHhwcsLCzg7e2N8+fPC+vGjBmDqVOn4sMPP4RMJkPr1q1x9epVYf3KlSvRuHFjyGQyNG/eHAcOHCh3vE6ePImWLVtCJpMhJCSk1AxSQUEBEhIS1C77PHr0aLUf2SMjIzF69Gi1140ZMwZhYWHC86SkJBgZGQnPd+zYIdRYv359YSxPnToFBwcHoV1qaiqCgoJgb28PKysrBAQElPte3nVaCyGWlpbw9/fXVvdERET0DuvUqRMWL16MhIQELFq0CM+ePcP48eP1XZZOKZVKxMXFwc/PT1gWFRWF9evXIzMzE46Ojli0aBEAIDs7G3379sW4ceOQmZmJVatWITAwEL/99pvw2piYGAQEBCA7OxsBAQEYNmwYzp07h6SkJMTGxmLevHl48OABAGDDhg3YtWsXTpw4gfT0dHh6eiIoKEjoKzs7Gzdv3oSPjw+Kiorg7++PwYMHIysrCzNnzlT7IfrOnTsYMmQIli9fjszMTEybNg39+vVDRkaG0CY6Ohpz5sxBTk4OunfvjhkzZgjrGjZsiNOnTyM3NxdLly5FcHBwqUAEAFlZWfD390dYWBiys7PRo0cPHD58WK1NfHw8OnToAFNTU2HZgAEDcO3aNcjlchQVFWHPnj0ICQmp9OeUn5+PcePG4fvvv8ezZ89w7do1+Pr6lmpXXFyMgQMHwtraGnfu3MHjx48xe/bsSm/nXaO1EEJERERUFXv27FF73qxZM6xYsQI//PADFi9eDEtLSz1Vph8JCQlwcXGBvb29sGzs2LFo1aoVjI2NMXLkSFy5cgUAEBsbCxcXF0ycOBESiQS9e/fGwIEDER0dLby2Y8eOGDRoEMRiMUaMGIGUlBSEh4fDxMQE3t7ecHV1xbVr1wAAmzZtwrJly+Dq6gqpVIrw8HBcunQJKSkpAF7ObJQcOnf+/Hnk5+cjLCwMUqkUvXv3Rp8+fYTt7tmzB3369IGfnx8kEglCQkLQrFkzHDp0SGgTEBCALl26QCwWIyQkRHhfADB06FA4OztDJBJh6NChaNq0KS5cuFBqvGJiYtCkSRMEBwdDIpFg9OjRcHd3L9Xm9UPIjI2NERgYiB07diA2NhatW7eGs7NzlT4rqVSKW7du4enTp7C2tkbbtm1Ltbl06RL++OMPrFmzBubm5pBKpejatWuVtvMuYQghIiIig6JUKpGdnQ2lUqnvUvQqNja21A7zq4f2mJqaIi8vD8DLw7RcXV3V2rq6ukIul5f72r/qLzk5GYGBgbC0tISlpSVsbW0hEomEGYhXa0tNTRVCQgkXFxfh8ZvUlp+fLzyPiopCmzZthFquX7+uNotSIjU1tdTlnV+tAwCOHj1a5nksY8aMwT//+U9ERkZW+apeZmZmOHz4MA4ePIj69euja9euaoeblUhJSUGDBg0M8vwefWAIISIiIoPw7NkzrFq1CsOGDcPYsWMxdOhQrFq1StgxrmliYmLUDsX6K87OzqUubZycnFzlX/RLNGjQAIcPH0ZOTo7w9/z5c3Tq1AnFxcU4ceIE+vXrBwBwcnKCXC5XC40lMyZvW9v9+/cxYcIErFu3DpmZmcjJyYG7uztUKlWptk5OTmrbfb2OX375BVZWVmXeh8bT0xNSqRRnzpzB4MGDS62vU6cOCgoKhOdpaWlq63v27Injx4/jyZMn8PPzw/Dhw0v10aBBA6SkpKCoqKjC910TMIQQERGRQVi/fj0KCwsRERGB6OhorFmzBn/++SfWrVun79J07sGDB8jIyICnp2el2vfv3x/JycnYvn07FAoF4uPjceTIEeGKT1U1ZcoULFy4ULi8bHZ2Nvbu3QsAOHfuHBo3bgw7OzsALw/zMjExwYoVK1BUVIT4+HgcP35c6Gv48OGIi4vDsWPHoFAosHPnTiQlJVXq3OGSGZGSbUVFRQn3rnudn58fbt++jejoaCgUCuzYsQPXr18X1ld0Na99+/YhPj4etWvXLrWubdu2OHr0KJ48eYKsrCx8/fXXwrr09HT861//Ql5eHqRSKWQyGcRicak+2rVrBxcXF8yZMwfPnj1DUVERTp8+XeEYvKsYQoiIiMggXL9+HbNmzUKDBg1gamqKBg0a4JNPPlHbkawpYmJi0L9/f7UrMP0Va2trHD16FFu2bIGNjQ1mzZqF6OhoNG/e/I22P336dAQFBWHAgAEwNzeHh4cH4uLihNpe3ZmXSqU4dOgQ9u/fDysrK0RERKjdpsHNzQ179+7FvHnzYGNjg7Vr1yI2Nha2trYV1tGiRQvMnTsXnTt3hr29Pa5evYpOnTqV2dbGxgYHDx7EsmXLYGVlhZ9++gkDBw4U1lcUQpo2bVpu6Bs1ahS8vb3RuHFjdO7cGR9++KGwTqlUYs2aNahXrx4sLS0RGRmpdi5OCbFYjCNHjuDRo0d47733YG9vXyMDdgkjVVnzWQbuypUr8MxZdS4AACAASURBVPLyQmJiYqV/IagMpVKJtLQ0ODg4qB3XaMhUKhUUCgUkEkmlv6j0jeOsGxxn7eMY6wbHWTd0Mc6pqanYunUrfHx8yjzJfObMmZg/f77a+QFpaWn46quvsHbtWrW2OTk5OHv2LEJDQ+Hk5KSVel+VlpaGvEeztNK3EtZwa7tRbZmfnx/+r707j4u63vc4/h4YUFAUUERFGTqpqbmk3XJfK03JtMQlF1IzMjtZ2XW5thw8mueeyq1cUO8tU6P01OloqKGmlbmk6bG0MO0ooCKuaIogDPO7f3Cd44jmNvxmRl/Px6PHw/n+fvOdz3xmgt+b35aQkOCVVxq9++67lZyc7FOXTD569KgaNGig7Oxsn/k5cqu7ppsV3k7sdrvsdrvPfEEv/KKT5FO/6NzRZ/sR805YNAxDRUVFsvs7fKvPxx3KLyr43T5bI73nu+5r3+eLv8ucaAjcvLZt22r8+PHq2rWrIiIidOzYMa1YsUIPPvigy9WS3PkHSG/Vrl07l3tZeIuCggL179/fpwKIVBxap06d6jPbd7cDQsglcnJy5O/v7xMbQNK/N459rWZ39PnIy+euvhJ0QiWvpX6xyCnBv7vcTL72fb74u3yjJ38C+LcL5xFcem+Hi88vMAxD//M//2NqXRecdoySJJe7uLvD/v37S4yNHj3ara/hLoGBgRo3bpyny7huderUcfvnhptDCAEAAF5h3rx5ni4BgEkIIQAAwKucP39ehw4dUn5+vsqUKaMaNWqoTJkyni4LgBsRQgAAgFfIzc3VnDlztHHjRhmG4bxpncViUcuWLTVs2DCVK1fO02UCcANCCAAA8AozZsxQUVGRpk6dqpo1azrHDxw4oIULF2rGjBkaM2aMBysstmfPHrfOFxAQ4Nb5AF9ACAEAAF5h+/btmj9/voKCglzGa9asqZEjR+rJJ5/0UGVSlSpVVKlSpVKZ2xcuxAG4GyEEAAB4haCgIB09elQ2m63EsiNHjig42HNX8/Pz8+PyroAbEUIAAIBXiIuL0+uvv66HHnpIf/jDH5znhOzfv1+pqanq1auXR+vLz88vlXktFgsn3uO2QwgBAABe4ZFHHlFUVJRWr16tTZs2KS8vT0FBQbLZbHrppZc8epPC7OxsHTp0qFTmDggIUKNGjUplbsBbEUIAAIDXaNKkiZo0aeLpMgCUMkIIAADwGufOndO8efPUqFEjdejQwdPlXJYZd0wHbnWEEAAA4DUKCgr03Xff6cyZM1q7dq2GDRumqKgoT5cFwM0IIZcICwtTRESEz1wBwzAM2e12Wa1Wn7nEn8PhUFFR0U33OXyyw41V/T7DMFRUVCR/f3+f6vPx48dVuXLl3+2ztYr3fNd97ft88XcZgPsEBATo1Vdf1datW/XGG2+obdu2iouLk9Xq2c2WpIpvFf/jiHvnDS0brrc0y72TAl6OEHIJq9Uqq9XqUyFEks9stEnFG27u6LPVxD+M+drGsfT/ffb3U9mqgXyfS8nF32UA7nffffepcePGWrx4sUaOHKmnn35aDRs29HRZANzAN7ZMAADALW/69OmaN2+ecnNzNX36dE2fPl2zZ8/WyZMnVbZsWb366queLtGj2rdvr6SkJE+XcU3Gjh2rQYMGlfrrzJ8/X82bN7/i8r59+yoxMfGG5u7SpYv+93//9wYrw9UQQgAAgFcICwtTaGio/P39FRYW5vJfgwYN1LNnT0+XaLrTp08rPDxcBQUFni6lhJ9//tntJ+mbYdasWUpISJBUfI+WcuXKqXz58qpWrZqeeuop5ebmSpJWrlypp5566qrzDRo0SGPHji3Vmm9FHEMAAAC8Qnx8vM6ePasDBw4oPj7e0+V4hdTUVLVv316BgYGeLqWElJQUPfLII54u47qlpKRo2LBhzsfbtm1T3bp1lZmZqYcfflgTJ07UX/7yF9PquXC49+2GPSEAAMBrlC9fXn/+8589XYbXuHRD/9ChQ+rQoYNCQkLUqlUrZWRkOJdt2bJFLVq0UMWKFdWwYUOlpKQ4lyUmJqpnz54aMmSIKlSooNq1a2vLli1asGCBbDabKleurKlTpzrXNwxDU6ZMUZ06dRQeHq6uXbvq4MGDV6ztxx9/1H333aeQkBDFxsYqJyfHZd2VK1eqcePGqlixopo1a6ZNmzY5lw0aNEjDhw/X448/rpCQEDVq1Eg7duxwLn/rrbdUq1YthYSEqF69evr000+v2K9169bp7rvvVkhIiOLj40vsQTp37pw2b96sBx98sMRzo6OjFRsbq507d0oqefjbggUL1KBBA4WEhKhWrVr64osvNGvWLH344YeaMmWKypcvr7Zt20qSYmJi9MUXXzifm5SUpPbt2zsfWywWzZo1S3Xr1lVoaKik4hti9unTR5GRkapZs6YSExPlcBRfhGffvn3q2LGjKlasqEqVKjlfx5cRQgAAALyQw+FQamqqYmNjnWMLFizQu+++qxMnTqhatWp67bXXJEk5OTl6+OGHNWTIEJ04cUKTJ09Wnz59lJaW5nxuSkqKevTooZycHPXo0UO9evXSxo0btXv3bi1fvlxjxozRgQMHJEkzZszQhx9+qFWrVunIkSNq2rSp+vbt65wrJydHP/30k9q0aaPCwkJ1795djz32mE6ePKkXXnhBCxcudK67d+9e9ezZU5MmTdKJEyf03HPPqUuXLjp+/LhzneTkZI0cOVKnTp1Sx44dNWLECOeyO+64Q19//bVOnz6tCRMmaODAgSUCkSSdPHlS3bt319ixY5WTk6MHHnhAy5Ytc1lnzZo1at68uYKDg0s8Pz09XcuXL1fTpk1LLPvHP/6h0aNHa+7cufrtt9+0bt062Ww2DR8+XP3799fIkSN19uxZffPNN1f+QC+xZMkSffPNNzp27JgcDoceffRR1apVSxkZGfruu++0dOlS5zkpr7zyiurUqaPjx48rOztbb7zxxjW/jrcihAAAAHihzZs3y2azKTIy0jk2ePBgNWjQQIGBgerXr5+2b98uSVq+fLlsNpuefvppWa1WderUSd26dVNycrLzuS1atNCjjz4qf39/PfHEE8rMzFRiYqKCgoLUrFkzxcTE6IcffpAkzZ49WxMnTlRMTIwCAgKUmJiorVu3KjMzU1Lxno0HHnhAAQEB2rRpk3JzczV27FgFBASoU6dO6ty5s/N1Fy9erM6dOys2NlZWq1Xx8fGqW7euli5d6lynR48eat26tfz9/RUfH+98X5IUFxenqKgo+fn5KS4uTnfddZe+++67Ev1KSUlR7dq1NXDgQFmtVj355JMlrqZ2uUPI7r//foWGhqp9+/Z68MEHNW7cuBJzJyUl6T//8z/VsmVLWSwW1axZU/Xq1bv6h/g7xo4dqypVqigoKEjff/+9Dhw4oIkTJ6ps2bKqXr26Ro4cqY8++kiSFBgYqMOHDysjI0MBAQFq06bNTb22N7j9DkADAADwAcuXLy+xwVy1alXnv4ODg3X27FlJxYdpxcTEuKwbExOjQ4cOXfG5vzdfenq6+vTp43KJdz8/Px08eFDR0dEutWVlZTlDwgU2m02nTp264dounBwuFe/9mTJlitLT0yVJZ8+eddmLckFWVpaio6Ndxmw2m8vjFStWlLjK2pYtW1S3bt0S810sMzNTtWrV+t11rtfFtaWnp+vYsWMKCwtzjjkcDtWsWVNS8SFpf/rTn9ShQwcFBAQoISHB50+GZ08IAACAF0pJSXE5FOv3REVFOTfSL0hPT7/hu81HR0dr2bJlOnXqlPO/vLw8tWzZUkVFRVq1apW6dOkiSapevboOHTrkPH9BknOPyc3WlpGRoaFDh+qdd97RiRMndOrUKTVs2NB5X6mLVa9e3eV1L63jn//8p8LCwkoElWsRHR2tX3/99bLLLndfq/Lly+vcuXPOx9nZ2b/7vOjoaNWoUcOl37/99pt++uknSVKVKlU0e/ZsHThwQH//+9/11ltv6csvv7zu9+FNCCEAAABe5sCBAzp+/Phlz0+4nK5duyo9PV3vvfee7Ha71qxZo88//1z9+vW7odd/9tln9corr+hf//qXpOJzQJYsWSJJ2rhxo2rVqqWIiAhJxYd5BQUF6c0331RhYaHWrFnjclJ27969lZqaqpUrV8put2vRokXavXu3unfvftU6LuwRufBaCxYs0K5duy67bmxsrPbs2aPk5GTZ7XYtXLjQeZK5dHNX80pISNDkyZO1efNmGYahgwcPavfu3ZKkyMhI7du3z2X9Jk2aKDk5WQUFBfr55581f/78353/vvvuU0REhCZMmKDc3Fw5HA7t3btXX3/9taTi80cunK9z4TLW/v7+N/RevAUhBAAAwMukpKSoa9eul/0r++WEh4drxYoVmjNnjipVqqQXX3xRycnJN3zewvPPP6++ffvqkUceUYUKFdS4cWOlpqY6a7t4Yz4gIEBLly7VJ598orCwME2dOlUDBw50Lq9Tp46WLFmiMWPGqFKlSpo+fbqWL1+uypUrX7WO+vXra9SoUWrVqpUiIyO1Y8cOtWzZ8rLrVqpUSZ999pkmTpyosLAwrV69Wt26dXMuv5kQ8vjjj2vixInOq4t16NDBeWWyp556Snv37lVYWJg6dOggSZowYYKysrIUHh6uP/7xj1e95LS/v78+//xz7d27V7Vr11ZYWJh69+6tw4cPSyq+jHCLFi1Urlw5tW3bVi+++KLL1bZ8kcW43P4sL7d9+3bde++92rZt2zX/heBaOBwOZWdnq2rVqi7HNXozwzCc15e+1h9UnkafzUGfSx89Ngd9NocZfc7KytLcuXPVpk0b52VJb9SpU6e0fv16JSQkqHr16m6q8Mqys7P12tkXS2XuUEe43qozy2UsNjZWCQkJ17S3wGx33323kpOT1bhxY0+Xcs2OHj2qBg0aKDs722d+jtzq+BQAAAC8TLt27S57LwtPKygoUP/+/X0qgEjFoXXq1KkEEC/C1bEAAACuwbDToyQVH17kTvv37y8xNnr0aLe+hrsEBgZe9hK23q5OnTpu/9xwc4iDAAAAAExFCAEAAABgKkIIAAAAAFNxTggAAMB12LNnj1vnCwgIcOt8gC8ghAAAAFxF5cqVVaFChVKZ21cu4wy4EyEEAADgKqxWq6xWNpsAd+H/JgAAgGtgt9tLbW4CDm43fOMBAACuIjs7W4cOHSqVuQMCAtSoUaNSmRvwVlwdCwAAAICp2BMCAABwHcy4Yzpwq2NPCAAAAABTEUIAAAAAmIrDsQAAAK7BWxX//2+3R35167zhZaVZbp0R8H7sCQEAAPAB7du3V1JSkqfLuCZjx47VoEGDSv115s+fr+bNm19xed++fZWYmHjZZenp6bJYLMrPz7/s8g8//FAdO3Z0R5m4DEIIAACAlzp9+rTCw8NVUFDg6VJK+Pnnn91+kr4ZZs2apYSEhKuu179/f61du9aEim5PhBAAAAAvlZqaqvbt2yswMNDTpZSQkpKiRx55xNNlXDdfrftWQwgBAADwUpduMB86dEgdOnRQSEiIWrVqpYyMDOeyLVu2qEWLFqpYsaIaNmyolJQU57LExET17NlTQ4YMUYUKFVS7dm1t2bJFCxYskM1mU+XKlTV16lTn+oZhaMqUKapTp47Cw8PVtWtXHTx48Iq1/fjjj7rvvvsUEhKi2NhY5eTkuKy7cuVKNW7cWBUrVlSzZs20adMm57JBgwZp+PDhevzxxxUSEqJGjRppx44dzuVvvfWWatWqpZCQENWrV0+ffvrpFfu1bt063X333QoJCVF8fHyJPUjnzp3T5s2b9eCDDzrHFi1apJo1ayoiIkLjxo2Tw+GQVPJQL4vForlz56pu3bqqWLGiBgwY4JV7qHwFIQQAAMALORwOpaamKjY21jm2YMECvfvuuzpx4oSqVaum1157TZKUk5Ojhx9+WEOGDNGJEyc0efJk9enTR2lpac7npqSkqEePHsrJyVGPHj3Uq1cvbdy4Ubt379by5cs1ZswYHThwQJI0Y8YMffjhh1q1apWOHDmipk2bqm/fvs65cnJy9NNPP6lNmzYqLCxU9+7d9dhjj+nkyZN64YUXtHDhQue6e/fuVc+ePTVp0iSdOHFCzz33nLp06aLjx48710lOTtbIkSN16tQpdezYUSNGjHAuu+OOO/T111/r9OnTmjBhggYOHFgiEEnSyZMn1b17d40dO1Y5OTl64IEHtGzZMpd11qxZo+bNmys4ONg5tnLlSv3888/avHmzPv74Y82fP/+Kn8knn3yiDRs2aO/evdq0aZMWLVp0xXXx+wghAAAAXmjz5s2y2WyKjIx0jg0ePFgNGjRQYGCg+vXrp+3bt0uSli9fLpvNpqefflpWq1WdOnVSt27dlJyc7HxuixYt9Oijj8rf319PPPGEMjMzlZiYqKCgIDVr1kwxMTH64YcfJEmzZ8/WxIkTFRMTo4CAACUmJmrr1q3KzMyUVLzh/sADDyggIECbNm1Sbm6uxo4dq4CAAHXq1EmdO3d2vu7ixYvVuXNnxcbGymq1Kj4+XnXr1tXSpUud6/To0UOtW7eWv7+/4uPjne9LkuLi4hQVFSU/Pz/FxcXprrvu0nfffVeiXykpKapdu7YGDhwoq9WqJ598Ug0bNiyxzqWHYiUmJiokJER33nmnXnjhBZeeXWrcuHGqVKmSqlSpotjYWJc6cX0IIQAAAF5o+fLlJTaYq1at6vx3cHCwzp49K6n4MK2YmBiXdWNiYnTo0KErPvf35ktPT1efPn0UGhqq0NBQVa5cWX5+fs49EBfXlpWV5QwJF9hsNue/b6S23Nxc5+MFCxbonnvucdayc+dOl70oF2RlZSk6Otpl7OI6JGnFihUlenrxc2w2m0tdl7pSv3D9CCEAAABeKCUlxeVQrN8TFRWl9PR0l7H09HRFRUXd0GtHR0dr2bJlOnXqlPO/vLw8tWzZUkVFRVq1apW6dOkiSapevboOHTrkPJdCknOPyc3WlpGRoaFDh+qdd97RiRMndOrUKTVs2FCGYZRYt3r16i6ve2kd//znPxUWFlYiqFy8TmZm5g33DNeHEAIAAOBlDhw4oOPHj6tp06bXtH7Xrl2Vnp6u9957T3a7XWvWrNHnn3+ufv363dDrP/vss3rllVf0r3/9S1LxOSBLliyRJG3cuFG1atVSRESEpOLDvIKCgvTmm2+qsLBQa9as0RdffOGcq3fv3kpNTdXKlStlt9u1aNEi7d69W927d79qHRf2iFx4rQULFmjXrl2XXTc2NlZ79uxRcnKy7Ha7Fi5cqJ07dzqXX+mqWOPHj9eZM2e0b98+TZ8+XU888cS1tAg3iRACAADgZVJSUtS1a1dZLJZrWj88PFwrVqzQnDlzVKlSJb344otKTk5WvXr1buj1n3/+efXt21ePPPKIKlSooMaNGys1NdVZ28Ub8wEBAVq6dKk++eQThYWFaerUqRo4cKBzeZ06dbRkyRKNGTNGlSpV0vTp07V8+XJVrlz5qnXUr19fo0aNUqtWrRQZGakdO3aoZcuWl123UqVK+uyzzzRx4kSFhYVp9erV6tatm3P5lULIww8/rPr166tZs2bq1auXBg8efM19wo2zGJfbn+Xltm/frnvvvVfbtm275r8QXAuHw6Hs7GxVrVrV5bhGb2YYhux2u6xW6zX/oPI0+mwO+lz66LE56LM5zOhzVlaW5s6dqzZt2ig0NPSm5jp16pTWr1+vhIQEVa9e3U0VXll2drZePHu4VOYOd0iz6jRxGYuNjVVCQsI17S0w2913363k5GQ1btzY06Vcs6NHj6pBgwbKzs72mZ8jtzo+BQAAAC/Trl07l3tZeIuCggL179/fpwKIVBxap06dSgDxIlZPFwAAAABXo0eP9nQJlxUYGKhx48Z5uozrVqdOHdWpU8fTZeAihBAAAIBrMOp08dWf3L0xu3//frfOB/gC9kkBAAAAMBUhBAAAAICpOBwLAADgOuzZs8et8wUEBLh1PsAXEEIAAACuIjw8XGXLli2Vuf39/UtlXsCbEUIAAACuIjAwUIGBgZ4uA7hlcE4IAAAAAFMRQgAAAACYihACAAAAwFSEEAAAAACmIoQAAAAAMBUhBAAAAICpCCEAAAAATMV9Qi5ht9tlt9vl5+cb+cwwDNntdkmSxWLxcDXXxuFwXFefjxxzlBiLjDD387kV+my18r87AADwDmyVXCInJ0f+/v4+s6FpGIaKiop8rubr6fPLfzpXYmzK+ODSKO2KboU+V69e3dMlAQAASPKCEFJYWKikpCT98MMPOnPmjCpXrqzevXurXbt2ni4NAAAAQCnweAgpKipSeHi4Jk6cqMjISKWlpenPf/6zIiMjVbduXU+XBwAAAMDNPH7iQ9myZdW/f39VrVpVFotF9evXV7169ZSWlubp0gAAAACUAo+HkEvl5+fr119/lc1m83QpAAAAAEqBxw/HupjD4dC0adNUu3ZtNWnSxGXZ4cOHdfjwYUliLwkAAADgw7wmhBiGoVmzZunkyZMaP358iSsQzZkzR+PHj/dQdQAAAADcxSsOxzIMQ0lJSdq/f78SExMVFBRUYp1nnnlG27Zt07Zt27Ro0SIPVAkAAADAHbxiT8icOXP0yy+/aOLEiQoOvvz9H6pVq6Zq1aqZXBkAAAAAd/N4CDl69KhWrFihgIAADRkyxDkeFxen3r17e7AyAAAAAKXB4yGkSpUqWrZsmafLAAAAAGASrzgnBAAAAMDtw+N7QrxNWFiYIiIi5OfnG/nMMAzZ7XZZrdYSVxTzVg6HQ0VFRdfc58l/dpQYqxJh7udzO/QZAADALISQS1itVlmtVp/ZaDMMQ5J8buP4evoc5QXXI7gd+gwAAGAWtkwAAAAAmIoQAgAAAMBUhBAAAAAApiKEAAAAADAVIQQAAACAqQghAAAAAExFCAEAAABgKkIIAAAAAFMRQgAAAACYihACAAAAwFSEEAAAAACmIoQAAAAAMBUhBAAAAICpCCEAAAAATEUIAQAAAGAqQggAAAAAUxFCAAAAAJiKEAIAAADAVIQQAAAAAKYihAAAAAAwFSEEAAAAgKkIIQAAAABMRQgBAAAAYCpCCAAAAABTEUIAAAAAmIoQAgAAAMBUhBAAAAAApiKEAAAAADAVIQQAAACAqQghAAAAAExFCAEAAABgKkIIAAAAAFMRQgAAAACYihACAAAAwFSEEAAAAACmIoQAAAAAMBUhBAAAAICpCCEAAAAATEUIAQAAAGAqQggAAAAAUxFCAAAAAJiKEAIAAADAVIQQAAAAAKYihAAAAAAwFSEEAAAAgKkIIQAAAABMRQgBAAAAYCpCCAAAAABTEUIAAAAAmIoQAgAAAMBUhBAAAAAApiKEAAAAADCV1dMFeBu73S673S4/P9/IZ4ZhyG63S5IsFouHq7k2Dofjsn0+4rC7rBfp5z1fT1/vc2BgoKfLAQAAcPKerTwvkZOTI39/f5/Z0DQMQ0VFRT5X8+X6/PK5Iy7rTQmONLu0K/L1PkdFRXm6HAAAACff+HM/AAAAgFsGIQQAAACAqQghAAAAAExFCAEAAABgKkIIAAAAAFMRQgAAAACYihACAAAAwFSEEAAAAACmIoQAAAAAMBUhBAAAAICpCCEAAAAATGX1dAHeJiwsTBEREfLz8418ZhiG7Ha7rFarLBaLp8u5Jg6HQ0VFRSX6PNkR7rJeFT/v+Xr6ep8BAAC8ifds5XkJq9Uqq9XqUyFEks9tHF+uz1Fe/HX09T4DAAB4E9/Y0gYAAABwyyCEAAAAADAVIQQAAACAqQghAAAAAExFCAEAAABgKkIIAAAAAFMRQgAAAACYihACAAAAwFQ+eRezvLw8SVJaWppb53U4HDpx4oSysrJ86maFRUVF8vf396mb6NHn0kefSx89Ngd9NocZfT527JgOHz6sEydO3PRcZ8+edUNFADzFJ0NIenq6JGnAgAGeLQQAANyQatWq3fQcVqtVwcHBbqgGgNkshmEYni7ieh0/flypqamKiYlRUFCQ2+ZNS0vTgAEDtGjRItWrV89t88IVfTYHfS599Ngc9NkcZvX5zJkzqlGjhlt+fwcHBys0NNQNVQEwm0/uCalcubL69+9favPXq1dPTZs2LbX5UYw+m4M+lz56bA76bA76DMAMvnFwLQAAAIBbhn9iYmKip4vwJuXLl1f79u0VEhLi6VJuafTZHPS59NFjc9Bnc9BnAGbxyXNCAAAAAPguDscCAAAAYCpCCAAAAABT+eTVsUrD2bNnNXPmTG3fvl1BQUF67LHH1L17d0+X5TVSUlK0du1apaenq0WLFho1apRzWUZGht59912lp6crMjJSCQkJaty4sXP5hg0b9MEHH+jkyZOqW7euRowYoSpVqnjibXi9wsJCJSUl6YcfftCZM2dUuXJl9e7dW+3atZNEr91lxowZ+v7775WXl6eQkBB16tRJvXv3lkSPS8Nvv/2mZ599VtWqVdPbb78tiT67y7Rp0/TNN9/Iav33r/OZM2cqIiJCUvHNAd99912lpaWpYsWKio+PV9u2bZ3r7tq1S0lJScrOzlZ0dLSef/553XHHHaa/DwC3IQOGYRjG22+/bUyYMMHIzc019u/fbwwYMMD4/vvvPV2W19iwYYOxadMmY/bs2cabb77pHC8sLDSeeuopY/HixUZBQYHxzTffGH369DFycnIMwzCMzMxMo1evXsb27duN/Px8Y968ecbLL7/sqbfh9fLy8oxFixYZhw8fNhwOh/HTTz8Zffr0MdLS0ui1G2VkZBj5+fmGYRjG0aNHjeHDhxvr16+nx6Vk2rRpxpgxY5y9os/uM3XqVGP+/PlXXD569Ghj1qxZRn5+vvHjjz8avXv3NtLT0w3DMIzTp08bffv2Nb788kujoKDA+Oyzz4whQ4YYBQUFZpUP4DbGnhBJ+fn52rBhg6ZOnarg4GDFxMSoU6dOWr16te69915Pl+cVpOvImAAADLBJREFUWrZsKUnat2+fzpw54xzfuXOnzp8/r7i4OPn5+alNmzb6/PPPtWHDBsXGxuqrr75S06ZN1aRJE0lSv379NHDgQGVmZio6OlrTpk1TYGCgcnJy9MMPP6hatWoaO3asNm7cqKVLl8pisWjo0KFq06aNJGnbtm2aP3++jh49qjJlyqhDhw4aPHiw+Q0pJWXLlnW5B079+vVVr149paWlKS8vj167SXR0tMtji8WirKwsvs+lYNeuXcrKytJDDz2kL774QhI/N8ySlZWlPXv26LXXXlOZMmXUsGFD3X///Vq7dq0GDx6sTZs2qVq1aurYsaMkqXv37lq2bJl27Nih++67T8nJycrIyFBwcLA2btyo0NBQvfzyyzp48KA+/PBD5efnq3fv3s6jBvbu3as5c+bowIEDCggIUJMmTfTyyy97sgUAvBjnhEg6dOiQDMOQzWZzjt1xxx3KzMz0YFW+ITMzUzExMfLz+/dX6Q9/+IMyMjIkFR9ycfGu/eDgYFWtWtW5XJLWr1+vnj17Kjk5WVFRUXr99ddVUFCg9957T08//bRmzZql8+fPS5LeeecdPf7441q8eLHmzJnjDEe3qvz8fP3666+y2Wz02s0++OAD9erVS0899ZTy8/PVoUMHeuxmhYWFmjNnjoYNGyaLxeIcp8/ulZqaqn79+mnEiBFavXq1czwjI0MREREqX768c+yOO+5w9jEzM9OlzxaLRTExMS6/+7Zu3armzZsrOTlZzZs311//+lft3r1bs2bN0uuvv64PPvhAx44dkyTNnTtX999/vz766CO999576tKlS2m/dQA+jBCi4g294OBgl7Fy5copLy/PQxX5jry8PJUrV85l7OLe5efn/+5ySWrWrJnq1q0rq9Wq1q1b6/Tp0+rdu7fz8fnz55WdnS1JslqtOnz4sH777TcFBQXprrvuKuV36DkOh0PTpk1T7dq11aRJE3rtZk8++aSWLFmiyZMnq127ds5e0WP3+fTTT9W4ceMS5xjQZ/fp1q2bkpKStHDhQg0dOlTz58/Xxo0bJRX38eIAIrn28WqfgyTVrVtXzZo1k7+/v9q2batjx47piSeeUJkyZXTXXXepSpUqSk9Pl1Tc56NHj+rkyZMKDAxU/fr1S/GdA/B1hBAVHwJzaeA4d+6cgoKCPFSR7wgKClJubq7LWG5urrN3ZcuW1blz51yWX9rbsLAw57/LlCmjChUqyN/f32Xswuczbtw4paen65lnntHIkSO1detWt78nb2AYhmbNmqWTJ09q1KhRslgs9LoUWCwW1a5dWwEBAfroo4/osRtlZWXpyy+/VL9+/Uoso8/uc+eddzrfe6NGjRQbG6sNGzZIKu7jpX2+uI9BQUEl+nzx5yCV7PPlxi70ecSIETp//rxeeuklPffccy57ZQDgUoQQSVFRUZLksgt6//79JY4bR0nR0dHKyMiQw+Fwju3fv995aJvNZtO+ffucy/Ly8pSdne1y6Nv1uPPOOzVu3DgtWrRI3bt313//938rPz//5t6ElzEMQ0lJSdq/f78SExOdGwT0uvQ4HA4dPnyYHrtRWlqacnJyNGzYMMXHx2vevHnat2+f4uPjFRkZSZ9LicVikfH/9yC22Ww6duyYzp4961y+b98+Zx+jo6Nd+mwYhtLT02/4d1+1atX08ssva8GCBRo2bJhmz56trKysm3g3AG5lhBAV/7WoVatWWrhwoc6dO6eMjAytWrVKDz30kKdL8xpFRUUqKCiQw+GQw+FQQUGB7Ha7GjZsqMDAQP39739XYWGhvv32W2VkZKhVq1aSpPbt22v79u3asWOHCgoKlJycrJiYmBv6JVdYWKh169bp7Nmz8vf3V7ly5WSxWFyOK78VzJkzR7/88ovGjx/vcpggvXaPs2fPat26dTp37pwcDod+/vlnrVy5Uvfccw89dqPWrVtr3rx5mj59uqZPn65+/frJZrNp+vTp+o//+A/67Cbffvuty3d5+fLlat68uSSpevXqqlWrlhYtWqTz589r165d2rJli/NE9BYtWujw4cNat26dCgsLtWzZMknSPffcc0O1rF27VqdOnZLFYnEe5nWr9BmA+3F1rP/3zDPPaMaMGRo0aJCCgoLUs2dProx1kcWLF+vjjz92Pt6wYYM6duyoF198Ua+++qpmzJihjz/+WFWqVNF//dd/KTQ0VJJUs2ZNjRgxQjNnzlROTo7uuusujR49+obr+PrrrzVv3jwVFRWpSpUqGj16tAIDA2/6/XmLo0ePasWKFQoICNCQIUOc43Fxcerduze9dpM1a9Zo7ty5cjgcCg8PV48ePRQbGyuLxUKP3aRMmTLOw3ek4nMN/P39nYfy0Gf3SElJ0cyZM+VwOFS5cmUNGDDA5T4go0aN0jvvvKP+/fsrNDRUw4cPd+4JqVChgsaNG6c5c+Zo5syZio6O1quvvqqAgIAbqmXHjh16//33df78eYWFhWnYsGGqWrWqW94ngFuPxbiw3xYAAAAATMB+UgAAAACmIoQAAAAAMBUhBAAAAICpCCEAAAAATEUIAQAAAGAqQggAAAAAUxFCAAAAAJiKEAIAAADAVIQQAE6nTp2SxWLR/PnzTXvNr776SpMmTSoxnpiYqPLly5tWBwAAMA8hBIBHXSmEDB06VOvWrfNARQAAoLRZPV0AgFtPXl6egoKCbmqOGjVqqEaNGm6qCAAAeBP2hAC3sXnz5ikmJkbBwcF64IEH9Ouvv7ost1gsevvtt13Gpk2bJovF4nz81VdfyWKxaPny5YqLi1OFChXUq1cvSdKCBQvUunVrhYeHKywsTO3bt9eWLVucz01MTNT48eOVm5sri8Uii8Wi9u3bO5ddejhWRkaG4uLiVLFiRZUrV06dO3fWzp07XdaJiYnRH//4R82cOVM2m00VK1ZUjx49dOzYsZvuFwAAcA/2hAC3qZSUFCUkJGjQoEHq27evtm3b5gwPNyIhIUEDBgzQZ599Jn9/f0lSenq64uPjdeedd6qgoEAfffSR2rZtqx9//FF16tTR0KFDdfDgQSUnJ2vt2rWSpAoVKlx2/jNnzqh9+/by8/NTUlKSypYtqzfeeMM5X82aNZ3rLlu2THv37tXMmTN1/PhxvfTSS3r++ef18ccf3/D7AwAA7kMIAW5TEydOVJs2bfT+++9Lkjp37qz8/HxNmDDhhuZ79NFH9de//tVl7PXXX3f+2+Fw6KGHHtKWLVs0f/58TZo0yXnIlZ+fn5o3b/6787///vvKyMjQTz/9pHr16kmS2rVrp+joaE2bNk2TJ092rmsYhpYtW6YyZcpIKg5DkyZNksPhkJ8fO4ABAPA0fhsDt6GioiJt27ZNjz32mMt4XFzcDc8ZGxtbYiwtLU2PPfaYIiMj5e/vr4CAAP3yyy/as2fPdc+/fv16NWjQwBlAJCk8PFwPPfSQvv32W5d127Vr5wwgklS/fn0VFhbq6NGj1/26AADA/dgTAtyGjh07JrvdripVqriMR0ZG3vCclz73zJkz6tSpkyIiIjRlyhTZbDaVLVtWQ4cOVX5+/nXPn5OTc9n6IiMjtWvXLpex0NBQl8eBgYGSdEOvCwAA3I8QAtyGIiIiZLVaS+wZOHLkiMvjMmXKqKCgwGUsJyfnsnNefLK6JG3atEkHDx5USkqKGjdu7Bw/ffr0DV31Kjw8XL/88kuJ8SNHjig8PPy65wMAAJ7D4VjAbcjf319NmzbVZ5995jL+ySefuDyuUaOG0tLSXMZWr159Ta+Rl5cn6d97ISRp48aNSk9Pd1kvMDBQ58+fv+p8rVu31s6dO12CSE5OjtasWaPWrVtfU00AAMA7EEKA29Qrr7yi9evXa/DgwUpNTdWkSZO0cOFCl3Xi4uL0t7/9Te+8845SU1M1cOBAHTp06Jrmb968ucqXL6/nnntOq1at0vvvv6++ffsqKirKZb169erJbrdr+vTp2rp162X3dkjS4MGDZbPZFBsbq48//lj/+Mc/1KlTJ1mtVr344os31gQAAOARhBDgNvXoo48qKSlJX375pXr06KFVq1Zp8eLFLuu89tpr6tevn8aPH68BAwbIZrPphRdeuKb5IyMj9be//U1Hjx5V9+7dNW3aNM2ZM0e1atVyWa9bt24aPny4/vKXv6hZs2Z65plnLjtfSEiIvvrqKzVu3FgJCQnq37+/wsLC9M0337hcnhcAAHg/i2EYhqeLAAAAAHD7YE8IAAAAAFMRQgAAAACYihACAAAAwFSEEAAAAACmIoQAAAAAMBUhBAAAAICpCCEAAAAATEUIAQAAAGAqQggAAAAAUxFCAAAAAJiKEAIAAADAVIQQAAAAAKb6P7MjY39XYcltAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1577,7 +1598,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 30, @@ -1628,7 +1649,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9515de9e066c4f4a9fe7bacbb8b8efac", + "model_id": "7302cd202fc24d008dc238022747528e", "version_major": 2, "version_minor": 0 }, @@ -1639,62 +1660,6 @@ "metadata": {}, "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n", - "WARNING:root:Pulse already running.\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -1704,7 +1669,7 @@ } ], "source": [ - "with ezpq.Queue(n_workers=n_workers, callback=slow_callback, poll=0.5) as Q:\n", + "with ezpq.Queue(n_workers=n_workers, callback=slow_callback, poll=1) as Q:\n", " for _ in range(n_inputs):\n", " Q.put(time.sleep, 1)\n", " Q.waitpb()\n", @@ -1721,7 +1686,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1732,7 +1697,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 33, @@ -1776,119 +1741,81 @@ { "data": { "text/plain": [ - "[{'qid': '24c0fae2',\n", - " 'id': 4,\n", - " 'name': 4,\n", - " 'priority': 100,\n", - " 'lane': None,\n", - " 'timeout': 0,\n", - " 'function': 'reciprocal',\n", - " 'args': 0,\n", - " 'kwargs': None,\n", - " 'submitted': datetime.datetime(2019, 1, 24, 4, 17, 8, 957057),\n", - " 'started': datetime.datetime(2019, 1, 24, 4, 17, 9, 58476),\n", - " 'ended': datetime.datetime(2019, 1, 24, 4, 17, 10, 58702),\n", - " 'processed': datetime.datetime(2019, 1, 24, 4, 17, 10, 61465),\n", - " 'exitcode': -1,\n", - " 'cancelled': False,\n", - " 'runtime': 1.0002264976501465,\n", - " 'output': None,\n", - " 'exception': ZeroDivisionError('division by zero'),\n", - " 'callback': None},\n", - " {'qid': '24c0fae2',\n", + "[{'qid': '873bf141',\n", " 'id': 5,\n", " 'name': 5,\n", " 'priority': 100,\n", " 'lane': None,\n", " 'timeout': 0,\n", " 'function': 'reciprocal',\n", - " 'args': 0,\n", + " 'args': [0],\n", " 'kwargs': None,\n", - " 'submitted': datetime.datetime(2019, 1, 24, 4, 17, 8, 957073),\n", - " 'started': datetime.datetime(2019, 1, 24, 4, 17, 9, 58759),\n", - " 'ended': datetime.datetime(2019, 1, 24, 4, 17, 10, 59183),\n", - " 'processed': datetime.datetime(2019, 1, 24, 4, 17, 10, 61486),\n", + " 'submitted': datetime.datetime(2019, 2, 18, 20, 21, 55, 726351),\n", + " 'started': datetime.datetime(2019, 2, 18, 20, 21, 55, 827401),\n", + " 'ended': datetime.datetime(2019, 2, 18, 20, 21, 56, 828921),\n", + " 'processed': datetime.datetime(2019, 2, 18, 20, 21, 56, 830606),\n", " 'exitcode': -1,\n", " 'cancelled': False,\n", - " 'runtime': 1.0004241466522217,\n", + " 'runtime': 1.0015199184417725,\n", " 'output': None,\n", - " 'exception': ZeroDivisionError('division by zero'),\n", + " 'exception': 'Traceback (most recent call last):\\n File \"../ezpq/Queue.py\", line 578, in _job_wrap\\n out = _job.function(*args, **kwargs)\\n File \"\", line 3, in reciprocal\\n return 1/x\\nZeroDivisionError: division by zero\\n',\n", " 'callback': None},\n", - " {'qid': '24c0fae2',\n", - " 'id': 12,\n", - " 'name': 12,\n", + " {'qid': '873bf141',\n", + " 'id': 6,\n", + " 'name': 6,\n", " 'priority': 100,\n", " 'lane': None,\n", " 'timeout': 0,\n", " 'function': 'reciprocal',\n", - " 'args': 0,\n", + " 'args': [0],\n", " 'kwargs': None,\n", - " 'submitted': datetime.datetime(2019, 1, 24, 4, 17, 8, 957135),\n", - " 'started': datetime.datetime(2019, 1, 24, 4, 17, 11, 65773),\n", - " 'ended': datetime.datetime(2019, 1, 24, 4, 17, 12, 66879),\n", - " 'processed': datetime.datetime(2019, 1, 24, 4, 17, 12, 69206),\n", + " 'submitted': datetime.datetime(2019, 2, 18, 20, 21, 55, 726363),\n", + " 'started': datetime.datetime(2019, 2, 18, 20, 21, 56, 830782),\n", + " 'ended': datetime.datetime(2019, 2, 18, 20, 21, 57, 832082),\n", + " 'processed': datetime.datetime(2019, 2, 18, 20, 21, 57, 834327),\n", " 'exitcode': -1,\n", " 'cancelled': False,\n", - " 'runtime': 1.0011060237884521,\n", + " 'runtime': 1.0012998580932617,\n", " 'output': None,\n", - " 'exception': ZeroDivisionError('division by zero'),\n", + " 'exception': 'Traceback (most recent call last):\\n File \"../ezpq/Queue.py\", line 578, in _job_wrap\\n out = _job.function(*args, **kwargs)\\n File \"\", line 3, in reciprocal\\n return 1/x\\nZeroDivisionError: division by zero\\n',\n", " 'callback': None},\n", - " {'qid': '24c0fae2',\n", + " {'qid': '873bf141',\n", " 'id': 15,\n", " 'name': 15,\n", " 'priority': 100,\n", " 'lane': None,\n", " 'timeout': 0,\n", " 'function': 'reciprocal',\n", - " 'args': 0,\n", - " 'kwargs': None,\n", - " 'submitted': datetime.datetime(2019, 1, 24, 4, 17, 8, 957160),\n", - " 'started': datetime.datetime(2019, 1, 24, 4, 17, 11, 66490),\n", - " 'ended': datetime.datetime(2019, 1, 24, 4, 17, 12, 67481),\n", - " 'processed': datetime.datetime(2019, 1, 24, 4, 17, 12, 69297),\n", - " 'exitcode': -1,\n", - " 'cancelled': False,\n", - " 'runtime': 1.0009911060333252,\n", - " 'output': None,\n", - " 'exception': ZeroDivisionError('division by zero'),\n", - " 'callback': None},\n", - " {'qid': '24c0fae2',\n", - " 'id': 17,\n", - " 'name': 17,\n", - " 'priority': 100,\n", - " 'lane': None,\n", - " 'timeout': 0,\n", - " 'function': 'reciprocal',\n", - " 'args': 0,\n", + " 'args': [0],\n", " 'kwargs': None,\n", - " 'submitted': datetime.datetime(2019, 1, 24, 4, 17, 8, 957176),\n", - " 'started': datetime.datetime(2019, 1, 24, 4, 17, 12, 69687),\n", - " 'ended': datetime.datetime(2019, 1, 24, 4, 17, 13, 70713),\n", - " 'processed': datetime.datetime(2019, 1, 24, 4, 17, 13, 73362),\n", + " 'submitted': datetime.datetime(2019, 2, 18, 20, 21, 55, 726513),\n", + " 'started': datetime.datetime(2019, 2, 18, 20, 21, 57, 835738),\n", + " 'ended': datetime.datetime(2019, 2, 18, 20, 21, 58, 836210),\n", + " 'processed': datetime.datetime(2019, 2, 18, 20, 21, 58, 838107),\n", " 'exitcode': -1,\n", " 'cancelled': False,\n", - " 'runtime': 1.001025676727295,\n", + " 'runtime': 1.000471830368042,\n", " 'output': None,\n", - " 'exception': ZeroDivisionError('division by zero'),\n", + " 'exception': 'Traceback (most recent call last):\\n File \"../ezpq/Queue.py\", line 578, in _job_wrap\\n out = _job.function(*args, **kwargs)\\n File \"\", line 3, in reciprocal\\n return 1/x\\nZeroDivisionError: division by zero\\n',\n", " 'callback': None},\n", - " {'qid': '24c0fae2',\n", - " 'id': 18,\n", - " 'name': 18,\n", + " {'qid': '873bf141',\n", + " 'id': 16,\n", + " 'name': 16,\n", " 'priority': 100,\n", " 'lane': None,\n", " 'timeout': 0,\n", " 'function': 'reciprocal',\n", - " 'args': 0,\n", + " 'args': [0],\n", " 'kwargs': None,\n", - " 'submitted': datetime.datetime(2019, 1, 24, 4, 17, 8, 957185),\n", - " 'started': datetime.datetime(2019, 1, 24, 4, 17, 12, 69941),\n", - " 'ended': datetime.datetime(2019, 1, 24, 4, 17, 13, 71073),\n", - " 'processed': datetime.datetime(2019, 1, 24, 4, 17, 13, 73388),\n", + " 'submitted': datetime.datetime(2019, 2, 18, 20, 21, 55, 726524),\n", + " 'started': datetime.datetime(2019, 2, 18, 20, 21, 58, 838259),\n", + " 'ended': datetime.datetime(2019, 2, 18, 20, 21, 59, 839682),\n", + " 'processed': datetime.datetime(2019, 2, 18, 20, 21, 59, 841945),\n", " 'exitcode': -1,\n", " 'cancelled': False,\n", - " 'runtime': 1.001131534576416,\n", + " 'runtime': 1.0014238357543945,\n", " 'output': None,\n", - " 'exception': ZeroDivisionError('division by zero'),\n", + " 'exception': 'Traceback (most recent call last):\\n File \"../ezpq/Queue.py\", line 578, in _job_wrap\\n out = _job.function(*args, **kwargs)\\n File \"\", line 3, in reciprocal\\n return 1/x\\nZeroDivisionError: division by zero\\n',\n", " 'callback': None}]" ] }, @@ -1921,7 +1848,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1932,7 +1859,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 37, @@ -2054,7 +1981,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fa11ab6649f340879aaa614d5ec08bb3", + "model_id": "f21ab39826574cd0b41bd14d4fdbb18e", "version_major": 2, "version_minor": 0 }, @@ -2096,7 +2023,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c99dc95836e84a8d9377fa99b729bccb", + "model_id": "cc51eb73e523441f836b1840dc76551c", "version_major": 2, "version_minor": 0 }, @@ -2135,7 +2062,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ae8e3942dadc4f589611b3db64c71490", + "model_id": "beaf4092a03d406dac81d506653c5e39", "version_major": 2, "version_minor": 0 }, @@ -2186,7 +2113,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "391c219eb6384259ab92a36cdd262477", + "model_id": "f27ed6344a8f4d03b692affa5817615b", "version_major": 2, "version_minor": 0 }, @@ -2244,7 +2171,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "90412e9147ff43c1ad55d67a1de22429", + "model_id": "3422853d24e74e37ac7c31e3a1c638b9", "version_major": 2, "version_minor": 0 }, @@ -2379,7 +2306,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9d233721e32a40dca08ab75b50293efc", + "model_id": "b1a67e1276c14d6986ef0f00225bb8ec", "version_major": 2, "version_minor": 0 }, @@ -2415,7 +2342,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2426,7 +2353,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 49, @@ -2553,7 +2480,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ea80efacfb0947e186eff204b246e45e", + "model_id": "1e19f7d5676243a4a50b31e872bbe0b7", "version_major": 2, "version_minor": 0 }, @@ -2573,7 +2500,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2584,7 +2511,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 50, @@ -2773,7 +2700,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "249cf053a37c4bcaafc63930161f26b5", + "model_id": "821725d7a29e487a874721c49a446d6b", "version_major": 2, "version_minor": 0 }, @@ -2794,7 +2721,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a9a6346b3f5444ef84ecac03411c065f", + "model_id": "6bb1082eb6bf4205848e512f9d7244f2", "version_major": 2, "version_minor": 0 }, @@ -2815,7 +2742,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c70d94e64a67484ca3b3c217f6d3e77b", + "model_id": "c3077386a89d4e6a856dd06a19ab70c6", "version_major": 2, "version_minor": 0 }, @@ -2854,7 +2781,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2865,7 +2792,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 52, @@ -2894,7 +2821,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApEAAAGxCAYAAAA6b+1gAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3X90lNW97/HPBIIJCQxGkhBPM0RBUK6RU1PpBQ7Bg0opXIwHkNsiLQkp8VThKlGsKJBI7ImcqxTkh7GcFNDqAbnEgkFFhHsaiUIrIa7oEYEr+XHaQAg/hl8JmEzuH9TRkCBMMpn9TJ73a62uNfPM4zMf1prql733d29HU1NTkwAAAAAfhJgOAAAAgOBDEQkAAACfUUQCAADAZxSRAAAA8BlFJAAAAHxGEQkAAACfUUQCAADAZxSRAAAA8BlFJAAAAHxGEQkAAACfdcoi8ty5cyopKdG5c+dMRwEAAOiUupoO0BH27dunpKQkZWRkKC4uzq/PrqurU3h4uF+faTeNjY2SpC5duhhO0jnwm2w/fpP+w++x/ez+eywsLPTbsz7++GO/PQstGS8iv/rqK+Xl5emTTz7R6dOn1bt3b02ePFkjR46UJFVUVGjZsmUqLy9XbGysMjIyNHjwYGN5+RckrIbfJKyE3yNgH8ansxsbGxUVFaVnn31W69at08MPP6yXXnpJ+/btU0NDg3JycjRkyBD9+7//u37yk58oNzdXJ0+eNB0bAADA1owXkWFhYXrggQfUp08fORwODRo0SLfccos+//xzlZWV6fz585o0aZJCQ0M1YsQIuVwuFRcXm44NAABga8ansy9VX1+vgwcPavz48aqsrFRCQoJCQr6pdW+88UZVVFQYy+dwOIx9N/wnPr7SdARVVblMRwAAoM0sVUR6PB4tWbJEN910k77//e9r//79ioiIaHZPRESEampqWvyzbrdbbrdbklRdXd1hGe260NmfrFCIp6evNh1B2dlZpiMAANBmlikim5qatHLlSh0/flzPPPOMHA6HwsPDdfbs2Wb3nT17ttVF20VFRd6Ortra2oBkBgAAsCtLFJFNTU3Ky8vToUOHlJOT4y0SXS6XNm7cKI/H453SPnTokJKTk1s8Izk52du1XVZWpoKCgg7J+vXWC2i7pqYm0xGUn59mOgIAAEHNEkXkyy+/rC+++ELPPvusunfv7r2emJiobt26qaCgQCkpKdq9e7cqKio0fPjwFs9wOp1yOp2SOnYk0goFENqP9YgAALSP8SKypqZGb7/9tkJDQzV9+nTv9UmTJmny5MmaN2+eli9frnXr1ikmJkZz585Vr169jOW1wno+tF98pQUaa1wUsgCA4GW8iIyJidHmzZsv+3lCQoKef/75ACb6bjTWtJ8VCvH01RZorMmisQYAELyM7xMJAACA4GN8JDLY0FjTflZYV5qfRmMNAADtQRHpIysUQGg/1iMCANA+TGcDAADAZ4xE+sgKTSFon0oLHHnoYoshAECQo4j0Ed3Z7We6EF9tgSMPszjyEAAQ5JjOBgAAgM8YifQR3dntZ7o5KY0jDwEAaDeKSB+ZLoDQfqxHBACg/ZjOBgAAgM8YifSR6aYQtF98mPnu7Kp6RkMBAMGNItJHdGe3n+lCPN1lvjs7ez/d2QDQFl26dFFiYqKio6N19OhRlZWV0a9gCEUkAAAICv3799cLL7yga665RkePHlV0dLTq6+v1+OOP6+DBg6bj2Q5FpI/42077mW5Oyq+kOxsAgtH8+fO1ceNGvfLKK95r06ZN0/z58zVt2jSDyeyJItJHpgsgtB/rEQEgOPXt21evvfZas2uvvvqq0tIYHDCBItJHptfzof0q4+NNR5Crqsp0BAAIOiUlJUpKStKf/vQn77U77rhDJSUlBlPZF0Wkj2isaT/Thfjq9HSj3y9JWdnZpiMAQFB4+OGHva9ramr0wgsv6KOPPtLhw4fVp08fDR06VG+//bbBhPZFEQkAACzruuuua/Z+27ZtkqTIyEidOXNG27ZtU2hoqIlotme8iCwsLNSOHTtUXl6uoUOHas6cOd7PfvGLX+jkyZMKCbm4J3p0dLRWrFhhKqokGmv8wfS60rT8fKPfDwC4egsXLjQdAZdhvIiMiorS5MmTVVpaqtOnT7f4fO7cuUpKSjKQrHWmCyC0H+sRASA49enT57KfHT58WJIUGxurI0eOBCqSrRkvIocNGyZJ+vLLL1stIgEAACRp06ZNcjgcLQZ0HA6HhgwZIklav3697rzzTgPp7Md4EXklS5YsUVNTk1wul6ZOnapBgwYZzWO6KSRYxcd/c9Sgx+ORJO8yhUCpqmJrHwAIZsOHD7/iPXfddVcAkkCyeBGZmZmpfv36SZK2b9+uZ555RsuWLVNMTEyLe91ut9xutySpurq6wzLRnd026ekWOGowm6MGASCYNTQ0SLo4Zd27d2/V1ta2mLqmdyFwLF1EfnvUcezYsfrggw+0Z88e/fjHP25xb1FRkQoLCyVJtbW1AcsIAAACIzY2Vr/+9a9166236syZM4qMjNSnn36qp59+mnWQBli6iLxUSEjIZRtbkpOTNXjwYElSWVmZCgoKOiQDf8Npm/z8b04TMDWdDQAIbtnZ2dq3b59mzZqluro6hYeHa+bMmVqwYEGz/SQRGMaLyMbGRjU2Nsrj8cjj8ejChQsKCQnRiRMnVFNTowEDBkiSduzYoQMHDmjmzJmtPsfpdMrpdErq2JFIurPb5tvrEb8uxFkaAADwxS233KJZs2Z5p7Xr6uq0ePFibd++3XAyezJeRK5fv17r1q3zvi8uLtaoUaM0YcIE/fa3v1V1dbW6du2q+Ph4zZ8/X3FxcQbTAgAAUw4cOKB+/frpiy++8F7r37+/Dhw4YDCVfRkvIqdMmaIpU6a0+tnSpUsDnObK6M72XXxlZbP3Jqazq1x0ZgNAsNu7d6+WLl2qd999V4cPH1ZcXJzGjBmjTZs2acKECd77OmpJG5ozXkQGG6ZgfZe+2gKd2Vl0ZgNAsEtMTNShQ4c0cOBADRw4UNLFfaYTExOVmJgo6eJgD0VkYFBEAgCAoPDLX/7SdAR8C0Wkj+jO9l1+Wlqz93RnAwAQ/CgifUR3tu8uXY9IdzYAoC2WLl2qRx55pNm1xYsXKzMz01Aie2MoCAAABIWSkpIW10pLSw0kgcRIpM/ozvZdZbz57mwX52YDQNBbu3Zti2uvvPKKgSSQKCJ9xhSs71Zb4NzsLM7NBgDAr5jOBgAAgM8YifQR3dm+S8unOxsAgM6GItJHdGf77tL1iHRnAwAQ/CgifURjje/iw8w31lTV01gDAJ1B3759dffddys6OlpHjx7V+++/r4qKCtOxbIki0keMnvku3WW+sSZ7P401ABDsRo8erXnz5unDDz/U4cOHddNNNyk1NVU5OTl67733TMezHYpIAAAQFB566CHNnj1be/bs8V5LSkrS/PnzKSINoIj0EY01vsuvpLEGANB+kZGRLTYX37t3ryIjIw0lsjeKSB/RWOO7S9cj0lgDAGiLzZs36+c//7nWrFmjpqYmORwOpaamavPmzaaj2RJFJAAAsKz8/HxvU2tTU5MGDRqkn/70pzp69Kiio6PVo0cPff7554ZT2hNFpI/ozvZNZXx8i2tmjj2sCth3AQD8p6Cg4DvfwxyKSB8xBeub1enppiNIkrKys01HAAC0wZYtW0xHwGVYoogsLCzUjh07VF5erqFDh2rOnDnezyoqKrRs2TKVl5crNjZWGRkZGjx4sMG0AADAlB/84AcaOHCgunfv3uz6qlWrDCWyL0sUkVFRUZo8ebJKS0t1+vRp7/WGhgbl5ORo9OjRys3N1a5du5Sbm6u8vDz16tXLSFa6s32Tlp/f4hrd2QCAtsjMzNTYsWNVWlqq+vp673WWmplhiSJy2LBhkqQvv/yyWRFZVlam8+fPa9KkSQoJCdGIESP01ltvqbi4WOPGjTOSle5s37S2FpHubABAW4wbN04/+9nP9Ne//tV0FEiy9FBQZWWlEhISmo1Y3XjjjRxvBACADZ0+fVrHjx83HQN/Y4mRyMupq6tTREREs2sRERGqqakxlCg4hszj4yuvfFMHq6rirGoAgH+99NJLeuKJJ7Rq1SrV1tY2++yrr74ylMq+LF1EhoeH6+zZs82unT17VuHh4S3udbvdcrvdkqTq6uoOyxQMU7Dp6RY4qzqbs6oBAP61cOFCSRentb+9d6TD4dCQIUNMRrMlSxeRLpdLGzdulMfj8U5pHzp0SMnJyS3uLSoqUmFhoSS1+NsJAAAIfvfee6/pCPgWSxSRjY2NamxslMfjkcfj0YULFxQSEqLExER169ZNBQUFSklJ0e7du1VRUaHhw4e3eEZycrJ365+ysrIO24w0GLqz8/PTrnwTAABB5siRI97XvXr10smTJw2mgSWKyPXr12vdunXe98XFxRo1apQeffRRzZs3T8uXL9e6desUExOjuXPntrq9j9PplNPplNSxI5HB0J3NekQAQGfUpUsXzZo1SxMmTFBYWJjq6+tVUFCgZcuWBcUgT2djiSJyypQpmjJlSqufJSQk6Pnnnw9wossLisaaSgs01rgoZAEA/pWWlqbrr79e999/v15//XVNnz5dmZmZevDBB7Vy5UrT8WzHEkVkMAmKxprVFmisyaKxBgDgX2PHjtWMGTN07NgxSRdPtVuwYIHWrl1LEWmApfeJBAAA+FpUVJS3gPzauXPnWhyBiMBgJNJHwbDmIj+NxhoAQOdz7NgxXXvttTpx4oQcDodiY2P14IMPateuXaaj2RJFpI+CorGG9YgAgE5o27ZtSkxMVFFRkUJDQ/Xmm2/q/fff16JFi0xHsyWKSAAAEBTy8vK8r++7774WU9sILIpIHwVDd3alBY49dLHNEACgA3Tv3l0ul0vdu3dX3759vddLSkoMprInikgfBUN39moLHHuYxbGHAAA/GzNmjObOnSuPx6P6+nrvdYfDoTFjxhhMZk8UkQAAICjMmjVLCxYs0B//+EfTUSCKSJ8FQ3d2GsceAgA6oW7duumDDz4wHQN/QxHpo2DozmY9IgCgM9qwYYMmTpyoDRs2mI4CUUQCAIAg8cMf/lCDBg3S1KlTW3RmT58+3VAq+6KI9JHVu7Pjw8x3ZlfVMxIKAPC/goICFRQUmI6Bv6GI9JHVu7PTXeY7s7P305kNAPC/LVu2mI6Ab6GIBAAAQSM5OVkTJ05Unz59VF1drY0bN9JsYwhFpI+s3p2dX0lnNgCgc7rnnns0Y8YMrV27VnPmzNH69ev12GOPKTIyUu+8847peLZDEekjq3dnsx4RANBZpaam6qmnntLBgweVmZmpgoIC7d27V7m5uRSRBlBE+sjqjTWV8fGmI8hVVWU6AgCgE4qLi9PBgwebXTt06JBiYmIMJbI3ikgfWb2xZnV6uukIysrONh0BANAJ1dfXKzw8XHV1dd5Bnfvuu08HDhwwnMyeKCIBAEBQKC0tVVJSknbu3KmuXbvqzTfflMPh0OzZs01HsyXLF5FLlixRUVGRunb9JuqKFSsUHR1tJI/VG2vS8vNNRwAAwG9iY2N15MgRSdLChQu913NyclRTU6NPP/3U8v9t7qwsX0RKUkpKiqZNm2Y6hiTrN9awHhEA0Jm88cYbGjlypKSL09lf27Ztm6lI+JsQ0wEAAAAux+qDN3YWFCORW7du1datW9W7d2+NHz9e99xzj7EsrXVnx8db4KjBKrb2AQAAgWP5InL8+PGaPn26IiIi9Nlnn2nRokWKiIjQsGHDmt3ndrvldrslSdXV1R2Wp7Xu7PR0Cxw1mM1RgwAAIHAsX0T269fP+/q2227TuHHjVFxc3KKILCoqUmFhoSSptrY2oBkBAEDHsPr+zHZm+SLyUg6Ho9X1EcnJyRo8eLAkqaysTAUFBR3y/a11gOXnc9QgAAAdgTWR1mX5InLnzp26/fbbFRYWpn379mnLli3KyMhocZ/T6ZTT6ZTUsSORrf2YWY8IAEDHeOSRR0xHwGVYvogsLCzUihUr5PF41Lt3b02dOlXJycmmYwEAgAD45JNPvK/HjRunt99+u9UBnR/84AdyOp3avn17IOPZmuWLyOeee850hGYuXZsRX2m+M1uSqlyMhgIAOresrCy99957+uqrr1p85nQ6NWXKFIrIALJ8EWk1l3Znp68235ktSdlZdGcDADq3pqYmjRs3rtUiMjo6WgMGDDCQyr4oIgEAQNBISUmRx+Np9bP9+/cHOI29UUT66NLu7Pw0OrMBAAiUjIyMVkciEXgUkT66dDEvaxEBAAiMkpKSy45CIvAoIn10aWNNpQWOPHSxxRAAwAZ++ctfmo6Ab6GI9NGljTWrLXDkYRZHHgIAgAALMR0AAAAAwYeRSB9d2liTxpGHAADAhigifXRpYw3rEQEAgB0xnQ0AAACfMRLpoxbHHoaZ786uqmc0FAAABBZFpI9aHHvoMt+dnb2f7mwAABBYTGcDAADAZ4xE+qjFsYeVdGcDAAD7oYj0UYtjD1mPCAAAbIjpbAAAAPiMkUgftTw7O95Qkm+4qqpMRwAAADZDEemjlmdnpxtK8o2s7GzTEQAAgM0wnQ0AAACfMRLpo5ZnZ+cbSgIAAGAORaSPWp6dzXpEAABgP0xnAwAA+ElqaqpuvfVW0zEColOORNbV1UmSamtr/f5st9ut8+fP+/25dvL1koBLm5TQNvwm24/fpP/we2w/u/8ez507p7CwMIWEMM5ldZ2yiCwvL5ckFRQUmA0CAAB8tmfPHt1+++2mY+AKOmUR+aMf/Ui///3vlZCQoPDwcNNxAACAD26++WbTEfyiurpaTz/9tP7jP/5D1dXV+t73vqf7779fWVlZuuaaa7z3ORwOLVq0SOfOndNLL72kxsZGjR8/XsuXL1dERIT3vv/6r//Sk08+qXfffVdnz57VHXfcod/85jdKSkoy8cfrnEVk79699cADD5iOAQAAbKy2tlZRUVFavHixrr32Wu3fv1/Z2dmqrq7W6tWrm927fPlyjRgxQmvXrtX+/fs1Z84cxcbG6rnnnpMknThxQv/wD/+gyMhILVu2TE6nU8uWLdOoUaN04MABxcTEBPzP52i6tN0YAAAAbZKamqqPP/5Yn376aYvPGhoa9MYbb2jatGlyu93q3r27pIsjkUOGDNHu3bubPWfnzp06ePCgJCkrK0tLly7V/v37vQXj+fPnNWDAAP3P//k/9a//+q8B+NM1x6pVAACADtDU1KQlS5Zo0KBBCg8PV2hoqB544AE1NDToyy+/bHbvPffc0+z9oEGD9F//9V/e9++9957+8R//UVFRUWpoaFBDQ4O6dOmikSNH6s9//nNA/jyX6pTT2QAAAKYtWbJEjz/+uJ544gn94z/+o6699lr9+c9/1sMPP6z6+vpm9/bq1avZ+27dujXb6aC2tla7du1SaGhoi+/p169fx/wBrqBTFpHnzp3Tvn37dPPNN3uHigEAAAJpw4YNuvfee5Wbm+u99p//+Z9telZUVJTGjBmjnJycFp99u0knkIwXkV999ZXy8vL0ySef6PTp0+rdu7cmT56skSNHSpIqKiq0bNkylZeXKzY2VhkZGRo8ePB3PnPfvn1KSkpSRkaG4uLi/JrX7XbL6XT69Zl2Y/c90PyN32T78Zv0H36P7Wf332NhYaHfnvXxxx/77VltUVdXp27dujW79tprr7XpWXfffbd+//vf65ZbbmnWsW2S8SKysbFRUVFRevbZZxUbG6vPP/9cCxcuVGxsrPr376+cnByNHj1aubm52rVrl3Jzc5WXl9di2DeQeQEr4TcJK+H3CHzjnnvu0dKlS7V8+XINGDBAv//9772NMr7KzMzUa6+9ppEjR+qRRx6Ry+XS0aNHtXv3bl1//fWaPXu2n9NfmfHGmrCwMD3wwAPq06ePHA6HBg0apFtuuUWff/65ysrKdP78eU2aNEmhoaEaMWKEXC6XiouLTccGAAD4TgsWLNCUKVO0YMEC/eQnP1FYWJhefPHFNj3ruuuu065du/T3f//3+tWvfqXRo0dr9uzZKi8v1w9/+EM/J786xkciL1VfX6+DBw9q/PjxqqysVEJCQrOjj2688UZVVFQYTAhYi8PhMB0B3xIfX2k6gqqqXKYjALa1Zs0a7+vIyMgW+0FKF7u2v+u9JD366KN69NFHm13r06eP/u3f/s0/Qf3AUkWkx+PRkiVLdNNNN+n73/++9u/f32LePyIiQjU1NS3+WbfbLbfbLeniDvGAXdh13ZQ/+bMQT09v+R+MQMvOzjIdAYANWKaIbGpq0sqVK3X8+HE988wzcjgcCg8P19mzZ5vdd/bs2VaPMiwqKvIuxq2trQ1IZgAAALuyRBHZ1NSkvLw8HTp0SDk5Od4i0eVyaePGjfJ4PN4p7UOHDik5ObnFM5KTk71d22VlZSooKAjcHwAwiEaG9vPnwV35+Wl+exYAWJklisiXX35ZX3zxhZ599tlm+zomJiaqW7duKigoUEpKinbv3q2KigoNHz68xTOcTqd3WwlGImEnnFxqLaxHBOwpNzdX5eXlfn/u0KFDlZqa6vfn+oPxIrKmpkZvv/22QkNDNX36dO/1SZMmafLkyZo3b56WL1+udevWKSYmRnPnzjW2vQ8AAMDl+HtvaqszXkTGxMRo8+bNl/08ISFBzz//fAATAcGF7mxria+0QHe2i9FQAB3PeBEJoH3ozm4/v3Znt7KdR6BlZ9GdDaDjGd9sHAAAAMGHkUggyNGd3X5+7c5OozsbgD1QRAJBju5sa2E9IoBAOHnypDIyMvTOO++oR48eeuKJJ1qccNPRKCIBAACCzMyZM3X+/Hn95S9/UUVFhe666y4NHDhQP/7xjwOWgSISCHJ0Z1tLpQXOznaxVyXQqZ09e1YbNmzQnj171LNnTyUmJmrGjBn63e9+RxEJ4OrRnd1+/izEV1vg7Owszs4GAm7T6NHanZTk9+euXrOmxbX9+/fL4/Ho1ltv9V77+7//+4Cf1kd3NgAAQBA5c+aM95S+r/Xq1UunT58OaA5GIoEgR3d2+/mzOSmNs7MBdLDIyEidOnWq2TW3260ePXoENAdFJBDk6M62FtYjAuhoAwYMkMPh0Geffab/9t/+mySptLS02fR2IFBEAkGOxhrriA8z31RTVU8RC5iQ8t57GvPWW/5/cEJCi0sRERGaNGmSnn76ab366quqqKjQv/3bv2l1gE/MoogEghyNNe3nr0I83WW+qSZ7P0016Ny6dOmixMRERUdH6+jRoyorK7Plsp4VK1ZoxowZiouLU48ePfTkk08GtDNboogEAABBon///nrhhRd0zTXX6OjRo4qOjlZ9fb0ef/xxHTx40HS8gOrVq5c2bNhgNANFJBDk7Pg3cH/z17rS/EqaaoCONH/+fG3cuFGvvPKK99q0adM0f/58TZs2zWAye6KIBIIcjTXWwXpEoGP17dtXr732WrNrr776qtI4s94I9okEAABBoaSkREmXbOh9xx13qKSkxFAie2MkEghydGdbR2V8vOkIclVVmY4A+NXDDz/sfV1TU6MXXnhBH330kQ4fPqw+ffpo6NChevvttw0mtC+KSCDI0Z3dfv4qxFenp/vlOe2RlZ1tOgLgV9ddd12z99u2bZN0ccPtM2fOaNu2bQoNDTURzfYoIgEAgGUtXLjQdISr4nQ6O2RmqGfPnn5/pr8YLyILCwu1Y8cOlZeXa+jQoZozZ473s1/84hc6efKkQkIuLt2Mjo7WihUrTEUFLInu7PbzV3NSWn6+X54DoHV9+vS57GeHDx+WJMXGxurIkSOBiuT10EMPBfw7TTNeREZFRWny5MkqLS1t9eDwuXPntlhEC+AbdGdbB+sRgY61adMmORyOFv/eczgcGjJkiCRp/fr1uvPOOw2ksx/jReSwYcMkSV9++WWrRSQAAIAkDR8+/Ir33HXXXQFIAskCReSVLFmyRE1NTXK5XJo6daoGDRpkOhJgKXbvzo6Pb/951R6PR5K8S2d8VVXF/pBAIDQ0NEi6OGXdu3dv1dbWtpi6NrXEJzc3V+Xl5X5/7tChQ5Wamur35/qDpYvIzMxM9evXT5K0fft2PfPMM1q2bJliYmJa3Ot2u+V2uyVJ1dXVAc0JmGT37uz0dAucV53NedVAIMTGxurXv/61br31Vp05c0aRkZH69NNP9fTTTxtZB3mpuLg40xECytJF5LdHHceOHasPPvhAe/bsafWA8aKiIhUWFkqSamtrA5YRAAAERnZ2tvbt26dZs2aprq5O4eHhmjlzphYsWNBsP0kEhqWLyEuFhIRctokgOTlZgwcPliSVlZWpoKAgkNEAY+zenZ2f3/7jzto7nQ0gMG655RbNmjXLO61dV1enxYsXa/v27YaT2ZPxIrKxsVGNjY3yeDzyeDy6cOGCQkJCdOLECdXU1GjAgAGSpB07dujAgQOaOXNmq89xOp1yOp2SGImEvdi9O9sf6xG/LsTtvjQAsLoDBw6oX79++uKLL7zX+vfvrwMHDhhMZV/Gi8j169dr3bp13vfFxcUaNWqUJkyYoN/+9reqrq5W165dFR8fr/nz59tuvQFwJXZurImvbH9TjdS+kcgqF001QKDs3btXS5cu1bvvvqvDhw8rLi5OY8aM0aZNmzRhwgTvfXaYjVy+fLnWrFmjsrIy/dM//VOzWipQrqqIvOGGG3z6D9WXX3551fdOmTJFU6ZMafWzpUuXXvVzALuy8+hZ+moLNNVk0VQDBEpiYqIOHTqkgQMHauDAgZIu1hyJiYlKTEyUdPEv1nYoIq+//nrNmzdP77//vrEZ2KsqIlNSUpoVkf/n//wfnTp1Snfffbd3Z/j3339fTqdTkyZN6rCwAADAvn75y1+ajmAZX4+8lpaWWruIXLJkiff1//7f/1vx8fF69913m53n6Ha79eMf/1ixsbH+TwngsuzcWJOf1v6mGonGGgBoC5/XRL744otauXJliwPBnU6nnnzyST300EP61a9+5beAAL6bnRtr/LUekcYaIDgsXbpUjzzySLNrixcvVmZmpqFE3xgdtUlJPXb7/blrLphftnM5Pv+1+/jx495NvS/ldrt14sSJdocCAAC4VEna8Fl0AAAgAElEQVRJSYtrpaWlBpJAasNI5F133aVf/epXio+P18iRI73X/+M//kNPPvkkZ1YCAWbn7uxKPxx5KLVvOtvFkYdAwKxdu7bFtVdeecVAEkhtKCJffvll3XvvvRo1apScTqeio6N19OhRud1uff/731deXl5H5ARwGXaegl1tgSMPszjyEIABDQ0N3v95PB7V19erS5cuCg0NDVgGn4vIuLg4/fnPf9a7776rP/3pT6qurlZcXJyGDBmiMWPGdERGAAAAS3vveIreqvZ/HZSQ0Pr1Z599Vs8884z3/YYNGzRt2jStWbPG7xkup82bjY8ZM4aiEbAAO3dnp/nhyEOJ7mwAwSc7O1vZ2dlGM1xVEXn8+HH16tVLISEhOn78+BXvj4qKancwAFfHzt3Z/lqPSHc2APjuqorI6OhoffTRRxoyZIh69+59xYX8dh4ZAQAAHadv3766++67vT0Z77//vioqKkzHsqWrKiJ/97vfqV+/ft7Xdu4GBazGzv9/jA8z351dVU93NhAoo0eP1rx58/Thhx/q8OHDuummm5SamqqcnBy99957puPZzlUVkdOmTfO+Tk1N7agsANrAzlOw6S7z3dnZ++nOBgLloYce0uzZs7Vnzx7vtaSkJM2fP58i0gBWkQMAgKAQGRnZYnPxvXv3KjIy0lAie2tzdzYAa7DzGuT8SrqzATvZvHmzfv7zn2vNmjVqamqSw+FQamqqNm/ebDqaLVFEAkHOzt3Z/lqPSHc2YF35+fnetd9NTU0aNGiQfvrTn+ro0aOKjo5Wjx499PnnnxtOKQ0YMEDXXHON359r5VFWikggyNm5saYyPt4vz2nfsYdVfskAoHUFBQXf+d4qJk6caDpCwFFEAkHOzqNnq9PTTUdQluHNfoHObsuWLaYj4DLaXETu37+/2bGHd9xxhwYOHOjPbAAAAM384Ac/0MCBA9W9e/dm11etWmUo0UXr16/Xvn37/P7cf/iHf9Bdd93l9+f6g89F5JkzZ5SRkaE33nhDHo9HYWFhqq+vV0hIiO6//36tWrXK5/n7wsJC7dixQ+Xl5Ro6dKjmzJnj/ayiokLLli1TeXm5YmNjlZGRocGDB/saG+i07NxYk5af75fn0FgDBIfMzEyNHTtWpaWlqq+v9163wrKeL7/8skPWqFdZeMmMz0XkrFmzVFhYqFWrVmnSpEnq0aOHTp8+rQ0bNujRRx/VrFmztHq1b3u3RUVFafLkySotLdXp06e91xsaGpSTk6PRo0crNzdXu3btUm5urvLy8tSrVy9fowOdkp0ba/y1HpHGGiA4jBs3Tj/72c/017/+1XQUqA37RG7cuFGLFi1SWlqaevToIUnq0aOHpk+frueee65NC16HDRum//7f/7t69uzZ7HpZWZnOnz+vSZMmKTQ0VCNGjJDL5VJxcbHP3wEAAILb6dOndfz4cdMx8Dc+j0SGhYXphhtuaPWzG2+8UaGhoe0O9bXKykolJCQ0m2K68cYbOSMT+JZAT+PEx/vnqMH2qKriqEHAjl566SU98cQTWrVqlWpra5t99tVXXxlKZV8+F5FpaWl66aWX9KMf/ajZf7yampq0cuVKpaX5Z/NfSaqrq1NERESzaxEREaqpqWlxr9vtltvtliRVV1f7LQNgdYGegk1Pt8BRg9kcNQjY0cKFCyVdnNb+9t6RDodDQ4YMMRnNlq6qiFy8eLH39XXXXac9e/bopptu0vjx4xUTE6Oamhq99dZbOn/+vEaMGOG3cOHh4Tp79myza2fPnlV4eHiLe4uKilRYWChJLf52AgAAgt+9995rOoIlnD9/Xg8//LC2b9+u2tpauVwuPf3005oyZUpAc1xVEfn444+3en3p0qUtrj355JPNuqvbw+VyaePGjfJ4PN4p7UOHDik5ObnFvcnJyd6u7bKyMstuRgr4W6C7s/Pz/TfbAAC+OHLkiPd1r169dPLkSYNpzGloaND111+v7du364YbblBxcbHGjRunG264QUOHDg1YjqsqIr/e/qKjNDY2qrGxUR6PRx6PRxcuXFBISIgSExPVrVs3FRQUKCUlRbt371ZFRYWGDx/e4hlOp1NOp1MSI5Gwl0B3Z7MeEYApXbp00axZszRhwgTvFoMFBQVatmyZrbY7i4iI8E7tSxf3khw+fLg+/PBD6xWRHW39+vVat26d931xcbFGjRqlRx99VPPmzdPy5cu1bt06xcTEaO7cuWzvAwCADaWlpen666/X/fffr9dff13Tp09XZmamHnzwQa1cudJotk2jN2l30m6/P3f1miuvQz979qw+/vhjPfLII37//u/SpiLy7NmzWrNmjXbu3Knjx48rKipKI0aM0LRp01o0wlyNKVOmXHYePyEhQc8//3xbYgK2EMju7PhKC3RmuxgJBexq7NixmjFjho4dOybp4oEkCxYs0Nq1a40XkaZ4PB6lpqbqjjvu0OjRowP63T4XkVVVVbrzzjtVXl6uwYMHKzY2Vl988YU2bNigxYsX6//+3/+r+Pj4jsgKoBWB7M5O9/EggY6QnUVnNmBXUVFR3gLya+fOnWtxBKJdNDU16Z//+Z/117/+VVu3bg34lm8+bzaemZkpSfrP//xPlZSU6J133lFJSYk+++wzORwOPfbYY34PCQAAcOzYMV177bWSLs7CxMbGau7cudq1a5fhZIHX1NSkhx9+WKWlpXrnnXd8PnLaH3weidy2bZtefvllDRw4sNn1gQMHKicnR//8z//st3AAriyQi8nz/bgPLAD4atu2bUpMTFRRUZFCQ0P15ptv6v3339eiRYtMR1PKeyka89YY/z84ofXLM2fO1K5du7R9+/YWJ/4Fis9FZENDQ6v7NEoX93W0U3cUYAWB7M5mPSIAk/Ly8ryv77vvvhZT23ZRUVGhlStX6pprrmm2hPCpp57SU089FbAcPheRw4cP17PPPquRI0d6t9SRLp4Y8+tf/7rV7XcAdJxAroGptMCRhy62GAJsrXv37nK5XOrevbv69u3rvV5SUmIwVWD17ds34Nu7tcbnIvKFF15QcnKy4uPjNWrUKMXGxqqmpkbbt29XaGiofve733VETgCXEcjGmtUWOPIwiyMPAdsaM2aM5s6dK4/Ho/r6eu91h8OhMWM6YCoZ38nnIvLWW2/VJ598ot/85jfauXOnPvvsM0VFRWnGjBmaPXu2vve973VETgAAYHOzZs3SggUL9Mc//tF0FKiN+0TGx8c3O08bgDmBXIecxpGHAAzq1q2bPvjgA9Mx8DdXVUTedtttev3113XrrbcqMTHxO9dgORwORUVFaciQIfrVr36lqKgov4UF0FIg18WwHhGASRs2bNDEiRO1YcMG01Ggqywik5KSvCfRJCUlXXEh/+nTp5Wfn68vvvhCf/jDH9qfEgAA2N4Pf/hDDRo0SFOnTm3RmT19+nRDqezrqorI1d86pWLNmjVX9eBNmzbpZz/7WZtCAbh6AT32MMx8d3ZVPaOhgF0VFBSooKDAdAz8TZvWRF6NkSNH6tVXX+2oxwP4m4Aee+gy352dvZ/ubMCutmzZYjrCZd15552qqKjw+3Nvu+02vz/TXzqsiOzVq5dSUlI66vEAAMCGkpOTNXHiRPXp00fV1dXauHGjJZpthg4dqqFDh5qOEVAdVkQCCIyAHntYSXc2AHPuuecezZgxQ2vXrtWcOXO0fv16PfbYY4qMjNQ777xjOp7tUEQCQS6gxx6yHhGAQampqXrqqad08OBBZWZmqqCgQHv37lVubq7xInLZsmXav3+/3587YsQITZ482e/P9QeKSAAAEBTi4uJ08ODBZtcOHTqkmJgYQ4m+cebMGV133XV+f+65c+f8/kx/oYgEglygurMr4+MD8j3fxVVVZToCAIPq6+sVHh6uuro677/77rvvPh04cMBwMnuiiASCXKC6s1enpwfke75LVna26QgADCotLVVSUpJ27typrl276s0335TD4dDs2bNNR7MlyxeRS5YsUVFRkbp2/SbqihUrFB0dbTAVAAAIhNjYWB05ckSStHDhQu/1nJwc1dTU6NNPPw1ogyG+YfkiUpJSUlI0bdo00zEASwrUvzzT8vMD8j0A8G1vvPGGRo4cKenidPbXtm3bZioS/iYoikgAlxeo7mzWIwIwIZA7UASTjIwMbdmyRadPn1ZUVJQyMjL01FNPBTRDUBSRW7du1datW9W7d2+NHz9e99xzj+lIQEDEx1/5mEGn85R69jzTYRmqqtjWBwCs5tFHH9XSpUsVHh6uqqoq/ehHP1L//v0Duh2Q5YvI8ePHa/r06YqIiNBnn32mRYsWKSIiQsOGDWt2n9vtltvtliRVV1ebiAr4XXq6BY4ZzOaYQQCwmkGDBjV7HxIS0mL7o45m+SKyX79+3te33Xabxo0bp+Li4hZFZFFRkQoLCyVJtbW1Ac0IAAA6RqC2MWuv0Zs2KWn3br8/d83qyw8mzJ07Vy+++KLOnTunhIQETZ061e/f/10sX0ReyuFwtLo+Ijk5WYMHD5YklZWVqaCgINDRAL/Lz7/yMYOnTp1Sz549A5AGAAKPNZGXl5ubq3/5l3/Rxx9/rD/84Q+69tprA/r9li8id+7cqdtvv11hYWHat2+ftmzZooyMjBb3OZ1OOZ1OSYxEovO4mvWIx48fV1RUVADSAEDgPfLII6YjWJrD4dAdd9yhd999V1lZWVq8eHHAvtvyRWRhYaFWrFghj8ej3r17a+rUqUpOTjYdCwAABMAnn3ziff2nP/1Jy5cv1yuvvNLivoyMDIWFhenFF18MZDzLaGho0P/7f/8voN9p+SLyueeeMx0BMCa+8iq6s0+dUs8zHdid7aI7G4A1XLhwQRMnTpTD4dDatWubfbZ161YtXrzYWBH5XkqK3hozxu/PTWjl2okTJ1RYWKiUlBRFRkbqo48+0ksvvaT58+f7/fu/i+WLSMDO0r9jQXWgZGfRnQ3AGhoaGpSRkaGVK1eqa9euyv/WIQgVFRW67rrrDKYLHIfDodWrV+t//a//pYaGBv3d3/2dHnvsMc2cOTOgOSgiAQBAUHA4HDpy5IgyMjKUl5enHj16aMmSJZKkG264QceOHTOcMDB69eqlHTt2mI5BEQlYWX4a3dkA8LWvO7WPHTumGTNm6MUXX9S///u/a+/evUpOTtZrr71mOKG9UEQCFnY16xHpzgZgF++884739cmTJ5WWlqbx48erX79++s1vfqPt27cbTGc/FJEAACAoLFq0qNn7xsZG/eEPfzCUBhSRgEVVXsW52ZJ0ynlKZzrw7GwXZ2cDAFpBEQlY1GoLnJstSVmcnQ0AaEWI6QAAAAAIPoxEAhaVdhXnZkt0ZwOAFaSmpsrtdvv9udHR0X5/pr9QRAIWdbVrEenOBgDz4uLiFBcXZzpGQFFEAhYVH3Z1jTXOyFPqGdYxjTVV9TTVAABaRxEJWFS6y3xjTfZ+mmoA4Grk5uaqvLzc788dOnSoUlNT/f5cf6CIBAAA8AOmswFYQn4ljTUAAOuiiAQs6mrXIx4/c1xR3WisAQAEFvtEAgAAwGeMRAIWVRkff1X3nXI6daaDprNdVVUd8lwAQPCjiAQsanV6uukIysrONh0BAPAdamtrdfPNN6t///7atWtXQL+b6WwAAIAgNWfOHA0aNMjIdzMSCVhUWn7+Vd1HdzYA2NMf//hHHThwQOnp6Xr55ZcD/v0UkYBFXe16RI49BADzRo/epKSk3X5/7po1rR88ceHCBc2cOVO///3vtXfvXr9/79VgOhsAACDIPPfcc7r77rs1ePBgYxk65UhkXV2dpIuLTf3N7Xbr/Pnzfn+unTQ2NkqSunTpYjhJ58Bvsv34TfoPv8f2s/vv8dy5cwoLC1NICONcl3Pw4EGtWbNGpaWlRnN0yiLy67MrCwoKzAYBAAA+27Nnj26//XbTMSxr586dOnz4sAYMGCDp4uBZXV2d+vTpo/379wdsnbyjqampKSDfFEC1tbXaunWrEhISFB4ebjoOAADwwc0336zu3bubjuGT3NzcDhmFT0hIUGpqarNrdXV1crvd3vfr16/XK6+8oi1btig2NlYOh8PvOVrTKUcie/furQceeMB0DAAAAL8LDw9vNkjmdDoVGhqqPn36BDQHCw4AAACCWGpqasA3GpcoIgEAANAGFJEAAADwWacsIs+dO6eSkhKdO3fOdBQAAIBOqVM21uzbt09JSUnKyMhQXFycX5/tdrvldDr9+ky7sfseaP7Gb7L9+E36D7/H9rP777GwsNBvz/r444/99iy0ZLyI/Oqrr5SXl6dPPvlEp0+fVu/evTV58mSNHDlSklRRUaFly5apvLxcsbGxysjIMLo7+9f/5wasgt8krITfI2AfxovIxsZGRUVF6dlnn1VsbKw+//xzLVy4ULGxserfv79ycnI0evRo5ebmateuXcrNzVVeXp569eplOjoAAIAkqVu3bh1yyk5oaKjfn+kvxovIsLCwZns6Dho0SLfccos+//xz1dXV6fz585o0aZJCQkI0YsQIvfXWWyouLta4ceMMpgYAAPjGY489ZjpCwBkvIi9VX1+vgwcPavz48aqsrFRCQkKzyv7GG29URUWFwYQAgMsJ1EkZdhQfX2k6gqqqXKYjwEIsVUR6PB4tWbJEN910k77//e9r//79ioiIaHZPRESEampqWvyzbrfbewRQdXV1QPICAJqzazOIP12uEE9PXx3gJC1lZ2eZjgALsUwR2dTUpJUrV+r48eN65pln5HA4FB4errNnzza77+zZs62eh11UVOTt6KqtrQ1IZgAAALuyRBHZ1NSkvLw8HTp0SDk5Od4i0eVyaePGjfJ4PN4p7UOHDik5ObnFM5KTk71d22VlZSooKAjcHwAAIInubH9oampq9Xp+flqAkwDfzRJF5Msvv6wvvvhCzz77rLp37+69npiYqG7duqmgoEApKSnavXu3KioqNHz48BbPcDqd3r3JGIkEADMuVwCh/ViPCKsxXkTW1NTo7bffVmhoqKZPn+69PmnSJE2ePFnz5s3T8uXLtW7dOsXExGju3Lls7wMAAGCY8SIyJiZGmzdvvuznCQkJev755wOYCADQVnRnd5z4Sgt0Z7sYDcU3jBeRAIDOg+7s9rtsd/ZqC3RnZ9GdjW/4f2t1AAAAdHqMRAIA/Ibu7Pa7bHd2Gt3ZsBaKSACA39Cd3XFYjwiroYgEAPgNjTUdo9ICRx5KkotthvAtFJEAAL+hsab9WivEV1vgyENJyuLYQ3wLjTUAAADwGSORAAC/obGm/VpbV5rGkYewIIpIAIDf0FjTMViLCCtiOhsAAAA+YyQSAOA3dGd3jPgw893ZVfWMhqI5ikgAgN/Qnd1+rRXi6S7z3dnZ+63Rmd2lSxclJiYqOjpaR48eVVlZGWtxDaGIBAAAQaF///564YUXdM011+jo0aOKjo5WfX29Hn/8cR08eNB0PNuhiAQA+A0jQu3XWnNSfiXd2ZI0f/58bdy4Ua+88or32rRp0zR//nxNmzbNYDJ7oogEAPgN3dkdg/WIF/Xt21evvfZas2uvvvqq0jhX3Ai6swEAQFAoKSlRUlJSs2t33HGHSkpKDCWyN0YiAQB+Q3d2x6iMjzcdQa6qKiPf+/DDD3tf19TU6IUXXtBHH32kw4cPq0+fPho6dKjefvttI9nsjiISAOA3dGe3X+tnZ6cbSNJcVna2ke+97rrrmr3ftm2bJCkyMlJnzpzRtm3bFBoaaiKa7RkvIgsLC7Vjxw6Vl5dr6NChmjNnjvezX/ziFzp58qRCQi7OukdHR2vFihWmogIAgABbuHCh6Qi4DONFZFRUlCZPnqzS0lKdPn26xedz585tsf4BAGBNdGe3X+tnZ+cbSGI9ffr0uexnhw8fliTFxsbqyJEjgYpka8aLyGHDhkmSvvzyy1aLSABA8KA7u2OYWo9oNZs2bZLD4WjxO3M4HBoyZIgkaf369brzzjsNpLMf40XklSxZskRNTU1yuVyaOnWqBg0aZDoSAOAyOlNjTXy8maMGPR6PJCkkJERVVWzt823Dhw+/4j133XVXAJJAsngRmZmZqX79+kmStm/frmeeeUbLli1TTExMi3vdbrfcbrckqbq6OqA5AQAXdabGmvR0Cxw1mG2NowatoqGhQdLFKevevXurtra2xdQ1SyoCx9JF5LdHHceOHasPPvhAe/bs0Y9//OMW9xYVFamwsFCSVFtbG7CMAAAgMGJjY/XrX/9at956q86cOaPIyEh9+umnevrpp1kHaYCli8hLhYSEXHa9TXJysgYPHixJKisrU0FBQSCjAQDUuUaB8vPNnILy7elsNJedna19+/Zp1qxZqqurU3h4uGbOnKkFCxY0208SgWG8iGxsbFRjY6M8Ho88Ho8uXLigkJAQnThxQjU1NRowYIAkaceOHTpw4IBmzpzZ6nOcTqecTqckRiIBwJTO1Fhjaj3i14V4Z1oa4C+33HKLZs2a5Z3Wrqur0+LFi7V9+3bDyezJeBG5fv16rVu3zvu+uLhYo0aN0oQJE/Tb3/5W1dXV6tq1q+Lj4zV//nzFxcUZTAsAAEw5cOCA+vXrpy+++MJ7rX///jpw4IDBVPZlvIicMmWKpkyZ0upnS5cuDXAaAEB7dJbu7PhKM53Z0jfT2X9JSDCWwar27t2rpUuX6t1339Xhw4cVFxenMWPGaNOmTZowYYL3Ppa0BYbxIhIA0Hl0linY9NUW6MzOojP7UomJiTp06JAGDhyogQMHSrq4z3RiYqISExMlXfyLDEVkYFBEAgCAoPDLX/7SdAR8C0UkAMBvOkt3dn6amc5s6ZvpbMDqKCIBAH7TWbqzq1zmTorxdmcbS2BdS5cu1SOPPNLs2uLFi5WZmWkokb2xCRUAAAgKJSUlLa6VlpYaSAKJkUgAgB91lu7sSkPnZkvfTGcn/CXBWAarWrt2bYtrr7zyioEkkCgiAQB+1Fm6s1db4NzsLM7NhsUxnQ0AAACfMRIJAPCbztKdnWbo3GyJ7mwED4pIAIDfdJbubJehc7OlbxXinWNlADoxikgAgN90lsaa+DDzjTV/uZBgLIOV9e3bV3fffbeio6N19OhRvf/++6qoqDAdy5YoIgEAftNZGmvSXeYba7L301hzqdGjR2vevHn68MMPdfjwYd10001KTU1VTk6O3nvvPdPxbIciEgAABIWHHnpIs2fP1p49e7zXkpKSNH/+fIpIAygiAQB+01kaa/IraayxosjIyBabi+/du1eRkZGGEtkbRSQAwG86S2NNVb35xppOsjLArzZv3qyf//znWrNmjZqamuRwOJSamqrNmzebjmZLFJEAAMCy8vPzvQ1bTU1NGjRokH7605/q6NGjio6OVo8ePfT5558bTmlPFJEAAL/pLN3ZlfHxxr77m2MP/2Isg5UUFBR853uYQxEJAPCbztKdvTo93XQEZWVnm45gCVu2bDEdAZdhiSKysLBQO3bsUHl5uYYOHao5c+Z4P6uoqNCyZctUXl6u2NhYZWRkaPDgwQbTAgAAU37wgx9o4MCB6t69e7Prq1atMpTIvixRREZFRWny5MkqLS3V6dOnvdcbGhqUk5Oj0aNHKzc3V7t27VJubq7y8vLUq1cvg4kBAK3pLN3Zafn5xr6b7uzLy8zM1NixY1VaWqr6+nrv9c6yjCLYWKKIHDZsmCTpyy+/bFZElpWV6fz585o0aZJCQkI0YsQIvfXWWyouLta4ceNMxQUAXEZn6c52VVUZ++5vjj3sHEsD/GncuHH62c9+pr/+9a+mo0BSiOkA36WyslIJCQkKCfkm5o033sjxRgAA2NDp06d1/Phx0zHwN5YYibycuro6RURENLsWERGhmpoaQ4kAAN+lPdOK8fHmzqv+WlWVuf0hcWUvvfSSnnjiCa1atUq1tbXNPvvqq68MpbIvSxeR4eHhOnv2bLNrZ8+eVXh4eIt73W633G63JKm6ujog+QAAzbWnOzs93QLnVWdzXrWVLVy4UNLFae1v7x3pcDg0ZMgQk9FsydJFpMvl0saNG+XxeLxT2ocOHVJycnKLe4uKilRYWChJLf52AgAAgt+9995rOgK+xRJFZGNjoxobG+XxeOTxeHThwgWFhIQoMTFR3bp1U0FBgVJSUrR7925VVFRo+PDhLZ6RnJzs3fqnrKyMzUgBwID2dGfn55s7rxrB4ciRI97XvXr10smTJw2mgSWKyPXr12vdunXe98XFxRo1apQeffRRzZs3T8uXL9e6desUExOjuXPntrq9j9PplNPplMRIJACY0p7ubNYj4kq6dOmiWbNmacKECQoLC1N9fb0KCgq0bNmyTrO9VDCxRBE5ZcoUTZkypdXPEhIS9Pzzzwc4EQCgLdraWBNfaYGmGhdFrNWlpaXp+uuv1/3336/XX39d06dPV2Zmph588EGtXLnSdDzbsUQRCQDoHNraWJO+2gJNNVk01Vjd2LFjNWPGDB07dkzSxVPtFixYoLVr11JEGmDpfSIBAAC+FhUV5S0gv3bu3LkWRyAiMBiJBAD4TVvXpeWn0VSDKzt27JiuvfZanThxQg6HQ7GxsXrwwQe1a9cu09FsiSISAOA3bW2sYT0irsa2bduUmJiooqIihYaG6s0339T777+vRYsWmY5mSxSRAAAgKOTl5Xlf33fffS2mthFYFJEAAL9pa3d2pQWOPHSxxVBQ6N69u1wul7p3766+fft6r5eUlBhMZU8UkQAAv2lrd/ZqCxx5mMWRh5Y3ZswYzZ07Vx6PR/X19d7rDodDY8aMMZjMnigiAQBAUJg1a5YWLFigP/7xj6ajQBSRAAA/amt3dhpHHuIqdOvWTR988IHpGPgbikgAgN+0tTub9Yi4Ghs2bNDEiRO1YcMG01EgikgAABAkfvjDH2rQoEGaOnVqi87s6dOnG0plXxSRAAC/afPZ2WHmu7Or6hkNtbqCggIVFBSYjoG/oYgEAFAlWk0AAA9ASURBVPhNm8/Odpnvzs7eT3e21W3ZssV0BHwLRSQAAAgaycnJmjhxovr06aPq6mpt3LiRZhtDKCIBAH7T5rOzK+nOxpXdc889mjFjhtauXas5c+Zo/fr1euyxxxQZGal33nnHdDzboYgEAPhNm8/OZj0irkJqaqqeeuopHTx4UJmZmSooKNDevXuVm5tLEWkARSQAwG/a0lhTGR/fAUl846qqMh0BVyEuLk4HDx5sdu3QoUOKiYkxlMjeKCIBAH7Tlsaa1enpHZDEN1nZ2aYj4CrU19crPDxcdXV13r+w3HfffTpw4IDhZPZEEQkAAIJCaWmpkpKStHPnTnXt2lVvvvmmHA6HZs+ebTqaLVm+iFyyZImKiorUtes3UVesWKHo6GiDqQAArWlLY01afn4HJEFnERsbqyNHjkiSFi5c6L2ek5Ojmpoaffrpp21u6EL7WL6IlKSUlBRNmzbNdAwAwBW0pbGG9Yj4Lm+88YZGjhwp6eJ09te2bdtmKhL+JsR0AAAAgMtpa8c/Ol5QjERu3bpVW7duVe/evTV+/Hjdc889piMBQFCLj++YYwadzlPq2fPMVd1bVcW2PkAws3wROX78eE2fPl0RERH67LPPtGjRIkVERGjYsGHN7nO73XK73ZKk6upqE1EBIGikp1vgmMFsjhkEgpnli8h+/fp5X992220aN26ciouLWxSRRUVFKiwslCTV1tYGNCMAAOgYbdl7FIFh+SLyUg6Ho9X1EcnJyRo8eLAkqaysTAUFBYGOBgBBIz+/Y44ZPHXqlHr27Nkhz4Y9sSbSuixfRO7cuVO33367wsLCtG/fPm3ZskUZGRkt7nM6nXI6nZIYiQSAK+mo9YjHjx9XVFRUhzwb9vTII4+YjoDLsHwRWVhYqBUrVsjj8ah3796aOnWqkpOTTccCAAAB8Mknn3hfv/DCC/rwww+1cePGFvf93d/9ncaOHatVq1YFMp6tWb6IfO6550xHAIBOJ76yg7qzT51SzzNX2Z3tojsbvrn11lv1zDPPNLs2ceJEbdy4UceOHdP48eMpIgPI8kUkAMD/0ldboDs7i+5s+Oaaa67RqVOnml2bNWuWNm7cqPr6etbjBhibjQMAgKBw4sQJ9e/f3/u+b9++6t69u5xOp3r27KkzVzkKDv9gJBIAbCg/je5sBJ9t27bpueee09q1a9XQ0KAbbrhBJ0+e1L/8y78oJCSEoxADjCISAGyoo9Yj0p2NjvTyyy+ra9eu+slPfqK//OUvys3N1bZt2zRp0iRVVVXp9ddfNx3RVigiAcBmKjvoyENJOuU8pTNXceyhiyMP0QaNjY168cUXm107ceKEcnNzDSWyN4pIALCZ1RY48jCLIw+BoEdjDQAAAHzGSCQA2ExaBx15KNFYA9gJRSQA2ExHrkeksQawD6azAQAA4DNGIgHAZuLDOq472xl5Sj3DrtydXVVPdzYQ7CgiAcBm0l3mu7Oz99OdDQQ7prMBAADgM0YiAcBm8ivpzgbQfhSRAGAzHbke8fiZ44rqRnc2YAdMZwMAAMBnjEQCgM1Uxsd32LNPOZ06cxXT2a6qqg7LACAwKCIBwGZWp6ebjqCs7GzTEQC0E9PZAAAA8BkjkQBgM2n5+R32bLqzAfugiAQAm+nI9YicnQ3YB9PZAAAA8FmnHImsq6uTJNXW1vr92W63W+fPn/f7c+2ksbFRktSlSxfDSToHfpPtx2/Sf/g9tp/df4/nzp1TWFiYQkIY57K6TllElpeXS5IKCgrMBgEAAD7bs2ePbr/9dtMxcAWOpqamJtMh/K22tlZbt25VQkKCwsPD/fbc6upq/e53v9P06dMVFxfnt+cCbcVvElbC7xH+cvPNN6t79+6mY+AKOuVIZO/evfXAAw/4/bmVlZXq3bu3EhMT5XJ13LFhwNXiNwkr4fcI2AsLDgAAAOAzikgfOJ1O/Y//8T/kdDpNRwEk8ZuEtfB7BOylU66JBAAAQMdiJBIAAAA+o4gEAACAzzpld3ZHOHPmjFasWKGSkhKFh4frn/7pn5SSkmI6FmxiyZIlKioqUteu3/xfdsWKFYqOjjaYCnZSWFioHTt2qLy8XEOHDtWcOXO8n1VUVGjZsmUqLy9XbGysMjIyNHjwYINpAQQCReRVevnll/XVV19p9erVqqmp0fz58/W9731PSUlJpqPBJlJSUjRt2jTTMWBTUVFRmjx5skpLS3X69Gnv9YaGBuXk5Gj06NHKzc3Vrl27lJubq7y8PPXq1ctgYgAdjSLyKtTX16u4uFi/+c1v1P3/t3evMU3dfxzH370IaBWlUTEDLV5igvOS+ESiqEQDmhG8pS7GW2RBTFCjPptRF8mUadQFb4mL2UBJHEYjxssDcDomqInGGGTMMd2kRhMBJxrlYoF2D8z63xnov4cx+//L5/Wo59tff+fbpmk++Z2ec/r0IS4ujpSUFC5cuKAQKSHn9/vJz8/n0qVLeL1enE4nWVlZjBs3LtStyXtk8uTJAPz222+GEFlZWcmrV69wu91YrVamTp3K2bNnuXLlCqmpqTx+/Jj9+/fz66+/YrPZGDp0KDt27AjV2xCRbqQQGYRHjx7h9/txuVyB2vDhw7l27VoIu5Kepri4mOLiYgYOHEhaWhrJyckA3Lp1i7KyMvbu3YvT6eTx48ch7lR6kgcPHhAXF2e4z/GIESPweDwAFBQUEBMTQ3Z2NgDV1dUh6VNEup9CZBBaWlo63H7J4XDQ3Nwcoo6kp0lLS+OTTz7B4XBQVVXFzp07cTgcTJ48Gbvdjtfr5cGDB0RGRjJkyJBQtys9SHNzMw6Hw1BzOBzU1dUBYLfbefr0KXV1dXzwwQd8+OGHoWhTRP4FOjs7CBERER0CY1NTU7fel1vkbUaOHElkZCQ2m43x48eTmprKlStXABg/fjyLFy+moKCAZcuWsWvXLn7//fcQdyw9Re/evWlsbDTUGhsbA7+P6enpOJ1ONm/ezMqVKzl58mQo2hSRf4FCZBBiYmKA14dt/nT//n3dG1ZCxmKx8Nf7BHz00Ufs2bOHw4cP097ezpEjR0LYnfQkw4YNw+Px4PP5ArX79+8H/v4zYMAAsrKy+Oabb9i4cSNFRUVUVFSEql0R6UYKkUGIiIhgypQpFBQU0NTUhMfjoaSkJPCfNJF/W3l5OU1NTfh8Pn766SfOnz9PQkICAHfv3uXnn3+mtbWV8PBwwsPDDf9PE+kO7e3teL1efD4fPp8Pr9dLW1sb48aNIywsjFOnTtHa2kp5eTkej4cpU6YAr7+79fX1wOvD3FarVd9PkfeEbnsYpJcvX3LgwIHAdSIXLFig60TKO/Ppp58GVnv+PLFm9uzZAFRUVPD1119TW1uL3W4nPj6e1atXExUVFeKu5X1y7NgxCgsLDbUZM2awfv16ampqOHDgADU1NQwePJhVq1YFrhOZn5/PDz/8wMuXL+nXrx+zZ8/m448/DsVbEJFuphApIiIiIqbpmIKIiIiImKYQKSIiIiKmKUSKiIiIiGkKkSIiIiJimkKkiIiIiJimECkiIiIipilEioiIiIhpCpEiIiIiYppCpIgE7dmzZ1gsFvLz89/ZPktLS8nJyelQ37p1K3379n1nfYiIiJFCpIj8T3tTiMzIyOD7778PQUciIgJgD3UDItLzNDc307t37380R2xsLLGxsd3UkYiImKWVSBF5o8OHDxMXF0efPn2YOXMm9+7dMzxvsVjYvXu3oZabm4vFYglsl5aWYrFYOH/+PG63m8jISBYuXAjA0aNHSUxMxOl0EhUVRVJSEtevXw+8duvWrWRnZ9PY2IjFYsFisZCUlBR47u+Hsz0eD263m/79++NwOJg1axaVlZWGMXFxcaxZs4aDBw/icrno378/8+bNo76+/h9/XiIiPYlWIkWkU+fOnSMzM5MVK1awaNEibt68GQh/XZGZmcnSpUspKirCZrMBUFNTw/Llyxk5ciRer5dvv/2WadOmcfv2bUaPHk1GRgYPHz7k2LFjXLp0CYDIyMhO53/x4gVJSUlYrVYOHTpEREQE27dvD8w3dOjQwNgzZ85w9+5dDh48yJMnT9iwYQNr166lsLCwy+9PRKSnUYgUkU5t27aNqVOnkpeXB8CsWbNoaWnh888/79J8c+bMYefOnYbaZ599Fnjs8/lITk7m+vXr5Ofnk5OTEzhkbbVaSUhIeOv8eXl5eDweqqqqiI+PB2D69OkMGzaM3Nxc9uzZExjr9/s5c+YM4eHhwOswm5OTg8/nw2rVARoRkWDo11JEOmhvb+fmzZvMnz/fUHe73V2eMzU1tUPtzp07zJ8/n+joaGw2G7169aK6uppffvnF9PxlZWWMHTs2ECABnE4nycnJlJeXG8ZOnz49ECABxowZQ2trK3V1dab3KyLSU2klUkQ6qK+vp62tjcGDBxvq0dHRXZ7z76998eIFKSkpDBo0iC+//BKXy0VERAQZGRm0tLSYnr+hoaHT/qKjo/nxxx8NtQEDBhi2w8LCALq0XxGRnkohUkQ6GDRoEHa7vcPKXG1trWE7PDwcr9drqDU0NHQ6519PtgG4du0aDx8+5Ny5c0yYMCFQf/78eZfOunY6nVRXV3eo19bW4nQ6Tc8nIiJvp8PZItKBzWZj4sSJFBUVGeonT540bMfGxnLnzh1D7cKFC0Hto7m5GfjPKiDA1atXqampMYwLCwvj1atX/3W+xMREKisrDUGyoaGB7777jsTExKB6EhGR4ClEikinNm3aRFlZGenp6RQXF5OTk0NBQYFhjNvt5sSJE+zbt4/i4mKWLVvGo0ePgpo/ISGBvn37snr1akpKSsjLy2PRokXExMQYxsXHx9PW1sbevXu5ceNGp6uNAOnp6bhcLlJTUyksLOT06dOkpKRgt9tZv3591z4EERF5I4VIEenUnDlzOHToEBcvXmTevHmUlJRw/Phxw5gtW7awePFisrOzWbp0KS6Xi3Xr1gU1f3R0NCdOnKCuro65c+eSm5vLV199xahRowzj0tLSyMrK4osvvmDSpEmsWrWq0/n69etHaWkpEyZMIDMzkyVLlhAVFcXly5cNl/cREZHuYfH7/f5QNyEiIiIi/1+0EikiIiIipilEioiIiIhpCpEiIiIiYppCpIiIiIiYphApIiIiIqYpRIqIiIiIaQqRIiIiImKaQqSIiIiImKYQKSIiIiKmKUSKiIiIiGkKkSIiIiJimkKkiIiIiJj2B+KD3+Aw66BoAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2905,7 +2832,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 53, diff --git a/docs/imgs/lane_error.png b/docs/imgs/lane_error.png new file mode 100644 index 0000000000000000000000000000000000000000..ee614253fe7c8182eb2841ad67ca013bdefebd38 GIT binary patch literal 27591 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 J(yiRW{|$xX!`1)* literal 0 HcmV?d00001 diff --git a/docs/imgs/lanes2.png b/docs/imgs/lanes2.png index 10f71f1c5261ea1b382502b0d1958f21afe4daaf..134f2baae5e51ea28fcaac3383212373f5aab253 100644 GIT binary patch literal 24162 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

!kJa29BLsBMJOPL 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 Z%JqwEbe!j`0z9#u!PC{xWt~$(698*KEoT4# diff --git a/docs/imgs/quickstart.png b/docs/imgs/quickstart.png index 3d46aa075ba6e3c99e71c173e2d898f2f9ca7130..bd4a485d12cc884115b5b3ca77f99048acbbdf5e 100644 GIT binary patch literal 15931 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�H&iG^a?woA?Mp=7rgKhH9sq0{7e%dOax$ q@S@})IP(ANx#s`NN$7&D!#S^Anf%{pdu{{ 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 LUe396{oelr`)?0% literal 19168 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 CR*xhA diff --git a/ezpq/Job.py b/ezpq/Job.py index 1226915..8e6a147 100644 --- a/ezpq/Job.py +++ b/ezpq/Job.py @@ -4,7 +4,7 @@ class Job(): - def __init__(self, function, args=None, kwargs=None, name=None, priority=100, lane=None, timeout=0, suppress_errors=False): + def __init__(self, function, args=None, kwargs=None, name=None, priority=100, lane=None, timeout=0, suppress_errors=False, stop_on_lane_error=False): """Defines what to run within a `ezpq.Queue`, and how to run it. Args: @@ -54,6 +54,7 @@ def __init__(self, function, args=None, kwargs=None, name=None, priority=100, la self.priority = priority self._suppress_errors = suppress_errors + self._stop_on_lane_error = stop_on_lane_error self._inner_job = None self._cancelled = False self._submitted = None @@ -87,12 +88,15 @@ def _join(self): self._inner_job.join() def get_exitcode(self): - '''Returns the exit code of the inner job. Only works for processes, not threads.''' - if self._inner_job is not None and hasattr(self._inner_job, 'exitcode'): - return self._inner_job.exitcode + '''Returns the exit code of the inner job.''' + + if self._inner_job is not None and \ + hasattr(self._inner_job, 'exitcode') and \ + self._inner_job.exitcode is not None and \ + not self._suppress_errors: + return self._inner_job.exitcode else: return self._exitcode - return None def _terminate(self): if self._inner_job is not None: diff --git a/ezpq/Plot.py b/ezpq/Plot.py index 93273ed..a05fdb0 100644 --- a/ezpq/Plot.py +++ b/ezpq/Plot.py @@ -111,6 +111,7 @@ def build(self, color_by='qid', facet_by='qid', facet_scale='fixed', show_legend import plotnine as gg df2 = self.jobs_df.loc[:, set(['qid', 'id', color_by, facet_by, 'submitted_offset', 'started_offset', 'ended_offset', 'processed_offset'])].melt(id_vars=set(['qid', 'id', color_by, facet_by])) + df2 = df2[df2['value'].notnull()] df_submit_start = df2[(df2['variable'] == 'submitted_offset') | (df2['variable'] == 'started_offset')] df_start_end = df2[(df2['variable'] == 'started_offset') | (df2['variable'] == 'ended_offset')] @@ -121,11 +122,11 @@ def build(self, color_by='qid', facet_by='qid', facet_scale='fixed', show_legend labs['title'] = title gg_obj = gg.ggplot(gg.aes(x='value', y='id', group='factor(id)')) + \ - gg.geom_line(df_submit_start, color='gray', size=bar_width, alpha=0.25) + \ + gg.geom_line(df_submit_start, color='gray', size=bar_width, alpha=0.2) + \ gg.geom_line(df_start_end, gg.aes(color='factor({})'.format(color_by)), size=bar_width, show_legend=bool(show_legend)) + \ - gg.geom_line(df_end_processed, color='gray', size=bar_width, alpha=0.25) + \ + gg.geom_line(df_end_processed, color='gray', size=bar_width, alpha=0.2) + \ gg.labs(**labs) + \ gg.labs(color=color_by) + \ Plot._plot_theme(grid_axis='x', theme=theme) + \ diff --git a/ezpq/Queue.py b/ezpq/Queue.py index 8d59cd3..7d60796 100644 --- a/ezpq/Queue.py +++ b/ezpq/Queue.py @@ -38,9 +38,9 @@ def start(self): self.is_running = True def stop(self): - if self.is_running: - self._timer.cancel() - self.is_running = False + self.is_running = False + self._timer.cancel() + # self._timer.join() def __init__(self, @@ -113,8 +113,8 @@ def __init__(self, self._q_working = dict() self._q_completed = list() self._n_q_waiting = 0 - self._n_q_working = 0 - self._n_q_completed = 0 + # self._n_q_working = 0 + # self._n_q_completed = 0 self._auto_remove = auto_remove self._mpmanager = None @@ -129,6 +129,7 @@ def __init__(self, self._poll = poll self._ticker = Queue.RepeatedTimer(interval=self._poll, function=self._pulse) + self.is_running = False if auto_start is True: self.start() self._auto_stop = auto_stop @@ -137,8 +138,7 @@ def __init__(self, def __call__(self, fun, *args, **kwargs): '''Decorator guided by http://scottlobdell.me/2015/04/decorators-arguments-python/''' - if not self.is_started(): - self.start() + self.start() def wrapped_f(iterable, *args, **kwargs): for x in iterable: @@ -181,55 +181,105 @@ def log_csv(job, path='ezpq_log.csv', append=True): return -1 def __del__(self): - self.dispose() + if self.is_running: + self.dispose() def start(self): '''Starts the queue system pulse.''' + log.debug('Starting pulse.') self._ticker.start() + self.is_running = True def _stop(self): '''Stops the queue system pulse.''' - if self._ticker is not None: - self._ticker.stop() - log.debug('Stopped pulse.') + log.debug('Stopping pulse.') + self._ticker.stop() + self.is_running = False def dispose(self): '''Clears all output and stops the queue system pulse.''' - with self._lock: - self.clear() - self._stop() - if self._mpmanager is not None: - self._mpmanager.shutdown() - - def stop_all(self, wait=False): - '''Stops all jobs in the working dictionary.''' - keys = list(self._q_working.keys()) - for k in keys: - job = self._q_working.get(k) - if job is not None: job._stop() + log.debug('Disposing') - if wait: self.wait() - - def clear(self): - '''Clears the queue system components: waiting, working, completed. - Also resets the counters. - ''' self.stop_all(wait=True) - self._q_working.clear() + self._stop() + + # self._q_working.clear() log.debug('Removed jobs.') self._output = None log.debug('Removed output.') - self._q_completed[:] = [] + self._q_completed.clear() # [:] = [] log.debug('Removed completed.') + # self._n_q_working = 0 self._n_submitted = 0 self._n_completed = 0 log.debug('Reset counters.') + + if self._mpmanager is not None: + self._mpmanager.shutdown() + + def clear_waiting(self): + log.debug('Clearing waiting queue') + with self._lock: + for _ in range(len(self._q_waiting)): + _, _, job = heappop(self._q_waiting) + job._cancelled = True + job._processed = time.time() + if not self._auto_remove: + heappush(self._q_completed, (int(job.priority), job._submitted, job.to_dict())) + self._n_q_waiting -= 1 + + keys = list(self._q_waiting_lanes.keys()) + for k in keys: + lane_jobs = self._q_waiting_lanes.get(k) + for _ in range(len(lane_jobs)): + _, _, job = heappop(lane_jobs) + job._cancelled = True + job._processed = time.time() + if not self._auto_remove: + heappush(self._q_completed, (int(job.priority), job._submitted, job.to_dict())) + self._n_q_waiting -= 1 + del(self._q_waiting_lanes[k]) + + def stop_all(self, wait=True): + '''Stops working jobs and clears waiting jobs.''' + + self.clear_waiting() + + keys = list(self._q_working.keys()) + for k in keys: + job = self._q_working.get(k) + if job is not None: + job._stop() + + if wait: + self.wait() + + # def clear(self): + # '''Clears the queue system components: waiting, working, completed. + # Also resets the counters. + # ''' + # self.clear_waiting() + # self.stop_all(wait=True) + + # with self._lock: + # # self._q_working.clear() + # log.debug('Removed jobs.') + # self._output = None + # log.debug('Removed output.') + # self._q_completed.clear() # [:] = [] + # log.debug('Removed completed.') + # # self._n_q_working = 0 + # self._n_submitted = 0 + # self._n_completed = 0 + # log.debug('Reset counters.') def __enter__(self): + log.debug('Entered context manager') return self def __exit__(self, *args): + log.debug('Exiting context manager') self.dispose() def n_submitted(self): @@ -247,74 +297,100 @@ def n_workers(self): def _pulse(self): '''Used internally; manages the queue system operations.''' - start = time.time() + # locked = self._lock.acquire(blocking=False) - if self._lock.locked(): - log.warning('Pulse already running.') #' If you see this repeatedly, consider increasing the value of "poll", or removing a slow callback.') - elif self._auto_stop and not self.has_work(): - self._stop() - else: - with self._lock: - - for job_id, job in self._q_working.items(): - if job.is_expired(): - job._stop() - - for job_id in list(self._q_working.keys()): - job = self._q_working[job_id] - - if not job.is_running() and not job.is_processed(): - job._join() - if not job._cancelled: - try: - job_data = self._output.pop(job._id) - job._ended = job_data['_ended'] - job._output = job_data['_output'] - job._exception = job_data['_exception'] - job._exitcode = job_data['_exitcode'] - except KeyError as ex: - job._ended = time.time() - job._output = None - job._exception = Exception('No data for job; it may have exited unexpectedly.') - job._exitcode = 1 - - if self._callback is not None: - try: - job._callback = self._callback(job.to_dict()) - except Exception as ex: - job._callback = str(ex) - - job._processed = time.time() - - log.debug("Completed job: '{}'".format(job._id)) - if not self._auto_remove: - heappush(self._q_completed, (int(job.priority), job._submitted, job.to_dict())) - self._n_q_completed += 1 - - if self._log_file is not None: - Queue.log_csv(job=job.to_dict(), path=self._log_file) - - del(self._q_working[job_id]) - self._n_completed += 1 - self._n_q_working -= 1 - - if job.lane is not None: - lane = self._q_waiting_lanes.get(job.lane) - if lane is not None: - _, _, job = heappop(lane) - if len(lane) == 0: - del(self._q_waiting_lanes[job.lane]) - self._q_working[job._id] = job - self._n_q_working += 1 - self._n_q_waiting -= 1 - self._start_job(job=job) - - while self.has_waiting() and self.n_workers_free() > 0: - _, _, job = heappop(self._q_waiting) - self._q_working[job._id] = job - self._n_q_working += 1 - self._n_q_waiting -= 1 - self._start_job(job=job) + with self._lock: + try: + # if not locked: # self._lock.locked(): + # log.debug('Thread already locked.') #' If you see this repeatedly, consider increasing the value of "poll", or removing a slow callback.') + # else: + if self._auto_stop and len(self._q_working) == 0 and self._n_q_waiting == 0: # self.size(waiting=True, working=True) == 0: + self._stop() + else: + for job_id, job in self._q_working.items(): + if job.is_expired(): + job._stop() + + for job_id in list(self._q_working.keys()): + job = self._q_working[job_id] + + if not job.is_running() and not job.is_processed(): + job._join() + if not job._cancelled: + try: + job_data = self._output.pop(job._id) + job._ended = job_data['_ended'] + job._output = job_data['_output'] + job._exitcode = job_data['_exitcode'] + job._exception = job_data['_exception'] + except KeyError as ex: + job._ended = time.time() + job._output = None + job._exitcode = 1 + job._exception = Exception('{}\n\nNo data for job; it may have exited unexpectedly.'.format(str(ex))) + + if self._callback is not None: + try: + job._callback = self._callback(job.to_dict()) + except Exception as ex: + job._callback = str(ex) + + job._processed = time.time() + + log.debug("Completed job: '{}'".format(job._id)) + if not self._auto_remove: + heappush(self._q_completed, (int(job.priority), job._submitted, job.to_dict())) + # self._n_q_completed += 1 + + if self._log_file is not None: + Queue.log_csv(job=job.to_dict(), path=self._log_file) + + del(self._q_working[job_id]) + self._n_completed += 1 + # self._n_q_working -= 1 + + if job.lane is not None: + lane = self._q_waiting_lanes.get(job.lane) + if lane is not None: + next_job = None + parent_exitcode = job.get_exitcode() + while len(lane) > 0: + _, _, next_job = heappop(lane) + + if parent_exitcode == 0 or not next_job._stop_on_lane_error: + break + else: + next_job._cancelled = True + next_job._exitcode = parent_exitcode + next_job._exception = 'stop_on_lane_error = True and preceding job ({}) exit code is {}'.format(job._id, parent_exitcode) + next_job._processed = time.time() + if not self._auto_remove: + heappush(self._q_completed, (int(next_job.priority), next_job._submitted, next_job.to_dict())) + next_job = None + self._n_q_waiting -= 1 # decrement after completed. + continue + + if len(lane) == 0: + del(self._q_waiting_lanes[job.lane]) + + if next_job is not None: + self._q_working[next_job._id] = next_job + self._start_job(job=next_job) + self._n_q_waiting -= 1 # decrement after started. + + while len(self._q_waiting) > 0 and self.n_workers_free() > 0: + _, _, job = heappop(self._q_waiting) + # self._n_q_working += 1 + self._q_working[job._id] = job + self._start_job(job=job) + self._n_q_waiting -= 1 + + except Exception as ex: + log.error(traceback.format_exc()) + finally: + log.debug('Waiting={}; Working={}; Completed={}.'.format(self._n_q_waiting, len(self._q_working), len(self._q_completed))) + # if locked: + # self._lock.release() def size(self, waiting=False, working=False, completed=False): """Returns the number of jobs in the corresponding queue(s). @@ -337,48 +413,46 @@ def size(self, waiting=False, working=False, completed=False): """ size = 0 + locked = False - if not any([waiting, working, completed]) or all([waiting, working, completed]): - size = self._n_q_waiting + self._n_q_working + self._n_q_completed - else: - if waiting: size += self._n_q_waiting - if working: size += self._n_q_working - if completed: size += self._n_q_completed + try: + to_tally = sum([waiting, working, completed]) + if to_tally != 1: + if to_tally == 0: + waiting, working, completed = True, True, True + locked = self._lock.acquire() # must lock when more than 1 component included. + + if waiting: + size += self._n_q_waiting + if working: + size += len(self._q_working) + if completed: + size += len(self._q_completed) + finally: + if locked: + self._lock.release() return size - - def has_waiting(self): - '''True if there are jobs in the waiting queue; otherwise False.''' - return len(self._q_waiting) > 0 # self.size(waiting=True) > 0 - - def has_completed(self): - '''True if there are jobs in the completed queue; otherwise False.''' - return len(self._q_completed) > 0 # self.size(completed=True) > 0 - - def has_work(self): - '''True if there are jobs either waiting or being worked; otherwise False.''' - return self.size(waiting=True, working=True) > 0 - def n_workers_free(self): '''Returns the number of available processes.''' - return self._n_workers - self.size(working=True) + return self._n_workers - len(self._q_working) def is_working(self): '''True if there are running jobs.''' - return self.size(working=True) > 0 + return len(self._q_working) > 0 def is_busy(self): '''True if max concurrent limit (n_workers) is reached or if there are waiting jobs.''' - return self.n_workers_free() <= 0 or self.has_waiting() + return self.n_workers_free() == 0 or self._n_q_waiting > 0 - def is_started(self): - '''True if the queue system pulse is running.''' - return self._ticker.is_running + # def is_running(self): + # '''True if the queue system pulse is running.''' + # return self.is_running def is_empty(self): '''True if there are no jobs in the queue system.''' - return self.size() <= 0 + return self.size() == 0 def is_full(self): '''True if the number of jobs in the queue system is equal to max_size.''' @@ -388,13 +462,13 @@ def remaining_jobs(self): '''The difference between the number of jobs submitted and the number completed.''' return self._n_submitted - self._n_completed - def wait_worker(self, poll=0.1, timeout=0): + def wait_worker(self, poll=0, timeout=0): """Waits for the number of running jobs to fall below the max concurrent limit (n_workers) Args: poll: the time, in seconds, between checks. - Accepts: float - - Default: 0.1 + - Default: ezpq.Queue.poll timeout: when > 0, the maximum time to wait, in seconds. Otherwise, no limit. - Accepts: float - Default: 0 (unlimited) @@ -402,19 +476,24 @@ def wait_worker(self, poll=0.1, timeout=0): Returns: True if a worker is available; False otherwise. """ + if poll is None or poll <= 0: + poll = self._poll + else: + assert poll >= self._poll + start = time.time() while self.is_busy() and (timeout==0 or time.time() - start < timeout): time.sleep(poll) return not self.is_busy() - def wait(self, poll=0.1, timeout=0, show_progress=False): + def wait(self, poll=0, timeout=0, show_progress=False): """Waits for jobs to be completed by the queue system. Args: poll: the time, in seconds, between checks. - Accepts: float - - Default: 0.1 + - Default: ezpq.Queue.poll timeout: when > 0, the maximum time to wait, in seconds. Otherwise, no limit. - Accepts: float - Default: 0 (unlimited) @@ -426,6 +505,11 @@ def wait(self, poll=0.1, timeout=0, show_progress=False): 0 if the expected number of jobs completed. > 0 otherwise. """ + if poll is None or poll <= 0: + poll = self._poll + else: + assert poll >= self._poll + n_pending = 0 if show_progress: @@ -442,13 +526,13 @@ def wait(self, poll=0.1, timeout=0, show_progress=False): return n_pending - def waitpb(self, poll=0.1, timeout=0): + def waitpb(self, poll=0, timeout=0): """Waits for jobs to be completed by the queue system. Args: poll: the time, in seconds, between checks. - Accepts: float - - Default: 0.1 + - Default: ezpq.Queue.poll timeout: when > 0, the maximum time to wait, in seconds. Otherwise, no limit. - Accepts: float - Default: 0 (unlimited) @@ -457,6 +541,11 @@ def waitpb(self, poll=0.1, timeout=0): 0 if the expected number of jobs completed. > 0 otherwise. """ + if poll is None or poll <= 0: + poll = self._poll + else: + assert poll >= self._poll + n_pending = self.size(waiting=True, working=True) if n_pending > 0: @@ -491,10 +580,10 @@ def _job_wrap(_job, _output, *args, **kwargs): ex_obj = ex ex_msg = traceback.format_exc() code = -1 + finally: + _output.update({ _job._id: {'_ended':time.time(), '_output':out, '_exception': ex_msg, '_exitcode': code} }) - _output.update({ _job._id: {'_ended':time.time(), '_output':out, '_exception': ex_msg, '_exitcode': code} }) - - if ex_obj is not None and not _job._suppress_errors: + if not _job._suppress_errors and ex_obj is not None: raise ex_obj def _start_job(self, job): @@ -596,13 +685,13 @@ def map(self, function, iterable, args=None, kwargs=None, timeout=0, show_progre return self.collect() - def get(self, poll=0, timeout=0): + def get(self, wait=False, poll=0, timeout=0): """Pops the highest priority item from the completed queue. Args: poll: when > 0, time between checks - Accepts: float - - Default: 0 (no wait); 0.1 if timeout > 0. + - Default: 0 (no wait) timeout: the maximum time, in seconds, to wait for a job to complete. - Accepts: float - Default: 0 (no wait/unlimited wait) @@ -615,21 +704,26 @@ def get(self, poll=0, timeout=0): Dictionary of the most recently completed, highest priority job. """ - assert(not self._auto_remove) + assert (not self._auto_remove) - job = None + if (wait or timeout > 0) and (poll is None or poll <= 0): + poll = self._poll + wait = True + else: + assert poll <= 0 or poll >= self._poll + if not wait and (timeout > 0 or poll > 0): + wait = True - if timeout > 0 and poll <= 0: - poll = 0.1 + job = None start = time.time() while True: - if self.has_completed(): + if len(self._q_completed) > 0: _,_,job = heappop(self._q_completed) - self._n_q_completed -= 1 + # self._n_q_completed -= 1 # job = x.to_dict() - elif (timeout > 0 or poll > 0) and (timeout <= 0 or time.time() - start < timeout): + elif wait and self.size() > 0 and (timeout <= 0 or time.time() - start < timeout): time.sleep(poll) continue @@ -650,9 +744,9 @@ def collect(self, n=0): """ if n <= 0: - n = self.size(completed=True) + n = len(self._q_completed) else: - n = min(n, self.size(completed=True)) + n = min(n, len(self._q_completed)) return [self.get() for _ in range(n)] diff --git a/ezpq/__init__.py b/ezpq/__init__.py index f65e02e..9accef2 100644 --- a/ezpq/__init__.py +++ b/ezpq/__init__.py @@ -1,4 +1,4 @@ -__version__ = "0.2.0" +__version__ = "0.2.1" from .Job import Job from .Queue import Queue diff --git a/publish.ps1 b/publish.ps1 index 0d8e8bc..5583639 100644 --- a/publish.ps1 +++ b/publish.ps1 @@ -5,8 +5,8 @@ Remove-Item 'build', 'dist', 'ezpq.egg-info' -Recurse -Force -ea 0 -pandoc --from=markdown --to=commonmark -o README.md README.md -pandoc --from=commonmark --to=rst --output=README.rst README.md +# pandoc --from=markdown --to=commonmark -o README.md README.md +pandoc --from=markdown --to=rst --output=README.rst README.md # fix 'Warning: "raw" directive disabled.' $rst = Get-Content 'README.rst' | Where-Object { $_ -ne '.. raw:: html' } @@ -16,10 +16,8 @@ python setup.py sdist bdist_wheel twine check dist/* -twine upload --repository-url https://test.pypi.org/legacy/ dist/* +# twine upload --repository-url https://test.pypi.org/legacy/ dist/* -python3 -m pip install --index-url https://test.pypi.org/simple/ ezpq +# python3 -m pip install --index-url https://test.pypi.org/simple/ ezpq # twine upload dist/* - - diff --git a/setup.py b/setup.py index 675f09c..2bfa21c 100644 --- a/setup.py +++ b/setup.py @@ -10,7 +10,7 @@ setup( name="ezpq", - version="0.2.0", + version="0.2.1", #download_url = 'https://github.com/dm3ll3n/ezpq/releases/download/0.2.0/ezpq-0.2.0.tar.gz', description="an easy parallel queueing system", long_description=README, diff --git a/test/test_processes.py b/test/test_processes.py new file mode 100644 index 0000000..87f35fb --- /dev/null +++ b/test/test_processes.py @@ -0,0 +1,91 @@ + +import unittest +from multiprocessing import Process +from threading import Thread +import random + +from _context import ezpq + +def return_me(x): + return x + +def reciprocal(x): + return 1/x + +class TestEZPQ(unittest.TestCase): + + def setUp(self): + self.Q = ezpq.Queue(job_runner=Process, auto_start=True, n_workers=5) + in_list = list(range(1000)) + random.shuffle(in_list) + self.input = tuple(in_list) + + def test_priority(self): + self.Q._stop() + + for i,x in enumerate(self.input): + self.Q.put(function=return_me, args=x, + priority=-i) # should result in reversed inputs. + + self.Q.start() + self.Q.wait() + + out_list = tuple(job['output'] for job in self.Q.collect()) + + self.assertEqual(tuple(reversed(self.input)), out_list) + + def test_map(self): + job_data = self.Q.map(function=return_me, iterable=self.input) + + out_list = tuple(job['output'] for job in job_data) + + self.assertEqual(self.input, out_list) + + def test_lanes(self): + for i, x in enumerate(self.input): + self.Q.put(function=return_me, args=x, + lane = i % self.Q.n_workers()) # returns in order + + self.Q.wait() + out_list = tuple(x['output'] for x in self.Q.collect()) + + self.assertEqual(self.input, out_list) + + def test_lane_error(self): + for i in range(100): + self.Q.put(reciprocal, random.randint(0, 5), lane=i%5, suppress_errors=True, stop_on_lane_error=True) + self.Q.wait() + output = self.Q.collect() + + self.assertGreater(len(self.input), len([x for x in output if x['started'] is not None])) + + + def test_size(self): + for x in self.input: + self.Q.put(function=return_me, args=x) + + sizes = [self.Q.size() + for i in range(len(self.input)) + for _ in [self.Q.get(wait=True)]] + + # numbers in `sizes` should decrement by 1 until reaching 0. + self.assertEqual(sizes, list(reversed(range(len(self.input))))) + + def test_terminate(self): + for x in self.input: + self.Q.put(function=return_me, args=x, priority=x) + self.Q.stop_all() + output = self.Q.collect() + + self.assertEqual(list(sorted([x['id'] for x in output])), + list(range(1, len(self.input)+1))) + + def test_empty(self): + self.assertEqual(self.Q.size(), 0) + + def tearDown(self): + self.Q.dispose() + del(self.Q) + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_ezpq.py b/test/test_threads.py similarity index 61% rename from test/test_ezpq.py rename to test/test_threads.py index 9eba33d..a0839ed 100644 --- a/test/test_ezpq.py +++ b/test/test_threads.py @@ -6,14 +6,17 @@ from _context import ezpq -def return_me(x=1): +def return_me(x): return x +def reciprocal(x): + return 1/x + class TestEZPQ(unittest.TestCase): def setUp(self): - self.Q = ezpq.Queue(job_runner=Process, auto_start=True, n_workers=5) - in_list = list(range(100)) + self.Q = ezpq.Queue(job_runner=Thread, auto_start=True, n_workers=5) + in_list = list(range(1000)) random.shuffle(in_list) self.input = tuple(in_list) @@ -48,7 +51,27 @@ def test_lanes(self): self.assertEqual(self.input, out_list) + def test_lane_error(self): + for i in range(100): + self.Q.put(reciprocal, random.randint(0, 5), lane=i%5, suppress_errors=True, stop_on_lane_error=True) + self.Q.wait() + output = self.Q.collect() + + self.assertGreater(len(self.input), len([x for x in output if x['started'] is not None])) + + def test_size(self): + for x in self.input: + self.Q.put(function=return_me, args=x) + + sizes = [self.Q.size() + for i in range(len(self.input)) + for _ in [self.Q.get(wait=True)]] + + # numbers in `sizes` should decrement by 1 until reaching 0. + self.assertEqual(sizes, list(reversed(range(len(self.input))))) + + def test_empty(self): self.assertEqual(self.Q.size(), 0) def tearDown(self):