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": "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\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": "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\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": "iVBORw0KGgoAAAANSUhEUgAAArgAAAHICAYAAAClCplzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xl4TGcfN/DvZN/FSGQhhCC1L2ntEZJQtStaipIuiocWrRblQalQTVH70lKq2trf6lPe2ktRpVQlqkVSkSAaQhaJZM77h3dmcieTmElmck5mvp/rynUlZ07O3Jn85sxvztzne1SSJEkgIiIiIrISdnIPgIiIiIjInNjgEhEREZFVYYNLRERERFaFDS4RERERWRU2uERERERkVdjgEhEREZFVYYNLRERERFaFDS4RERERWRU2uERERERkVdjgWlhwcDA6d+4s9zCoHBITE6FSqTBr1qwyb6Mi6kClUmHkyJEWvQ8qXefOnREcHCz3MMrkgw8+gK+vLx48eGDU+ocPH4ZKpcKGDRssOzCqcFFRUejevbvcwyAqF5tqcFUqVYlff/zxR7H18/PzsWDBAoSGhsLZ2RmBgYEYM2YM/v33XxlGbxmzZs3Crl27KvQ+s7OzMWXKFAQHB8PZ2RnBwcGYOnUqsrOzjd7GX3/9hVmzZqFDhw7w9/eHu7s7GjVqhDfffBOpqakWHL18EhMTMWvWLJw7d07uoZjVmjVrMHz4cDRu3BgODg5QqVRITk6We1g2JTk5GQsWLMDUqVPh6empW3748GHMmjUL9+7dk3F08rHkcy41NRXTp09Hjx49EBAQAJVKhejo6DJt67vvvkNUVBT8/f3h5uaG+vXrY+zYsUhMTCzT9j788EPs27cP33//fZl+n0gRJBsCQAoPD5c2bdpU7OvevXvF1h82bJgEQOrVq5e0Zs0aaerUqZKrq6vUpEkTKTMz06j7fPjwoZSbm2vuP8VsAEgjRoyosPvLz8+XIiIiJADS8OHDpbVr10rjxo2T7O3tpcjISKmgoMCo7bz33nuSu7u7NHjwYGnx4sXS6tWrpZiYGMne3l6qWrWqlJCQYLYxazQaKScnR3r06FGZt1G7dm0pIiKiXOM4dOiQBEBav369wdtzcnKkvLy8ct2HHGrXri25u7tLHTp0kEJCQiQA0vXr1+UeVplERERItWvXlnsYJhs/frzk4eFRbL82c+ZMCYB07dq1Yr9TUFAg5eTkSPn5+RU0yor3pOecObZdo0YNqU+fPhIAKSoqyuTtLF68WAIgtWrVSoqLi5PWrFkjjR07VnJ2dpZ8fHyk1NTUMo2vffv2UlhYWJl+l0gJbK7BNbaZO3DggARA6tOnj7B827ZtEgBp9uzZFhhhxavoBvezzz6TAEjjx48Xln/88ccSAOmLL74wajunT5+W7t69W2z56tWrJQDSoEGDzDJec6mIBreyunr1qu6NzYgRIypdg6vRaKQHDx5IklSxDW5GRoZZtvPgwQPJy8tLiomJKXZbaQ2uLbDkc+7+/fvSrVu3dD+XtcGtUaOGVKNGDSknJ0dYHhcXJwGQli1bVqbxafelp06dKtPvE8nNpqYoaD169OiJ88w2btwIAJg0aZKwfMCAAQgODtbd/iSG5l5ql12+fBl9+/ZFlSpV4OHhgR49euDvv/8W1i08z23lypVo2LAhXFxcEBwcjFmzZiE/P19Yv7Q5gIXnaGq3CwBffPGFMF1D6+TJk+jduzcCAwPh7OyMgIAAdOnSpVxTGrSP29tvvy0sHzt2LFxdXY1+XJ9++ml4e3sXWz548GAAwO+//y4sT05OxqhRo1CnTh24uLjAx8cHYWFhmDdv3hPvq6Q5uBqNBp9++imaN28OV1dXeHl5ITIyEj/++GOJ2zp//jy6desGT09PVKlSBc8//zyuXLnyxDHMmjULXbp0AQDExMTo/leFa8vQHFztsqNHj6Jjx45wd3eHn58f3nvvPRQUFCA3NxdTpkxBUFAQXFxc8Mwzz+DkyZMGx7B9+3ZERETAy8sLrq6uaNmyJdatW/fEsT9JnTp1YGdX9l3RV199BZVKhe+++05Y3qhRI6hUKmzatElY3r59e9StW1dYdunSJQwePBh+fn5wdnZG3bp18c477+D+/fvCehs2bIBKpcL+/fsRGxuLBg0awNnZGR9//HGJ43vw4AG6d+8OZ2dnfPnll8Jtxj6m2n3G77//jp49e6Jq1aqoUqUKAECSJCxduhQtW7bU7UtCQkLw0ksvGTVdZ+/evbh//z569uwpLO/cuTNmz54N4PH/SFtz2ueBoTm4hZetWbMGjRo1gouLCxo0aKB7bt+4cQODBw9GtWrV4O7ujn79+uHmzZvFxpWXl4ePPvoIzZo10z2/oqOjcfTo0WLrmvJcLGmuetG/x5jnXHl4enqievXq5d5ORkYG1Go1XFxchOU1atQAALi5uemW5ebmYs6cOWjUqBHc3d3h5eWF0NBQvPLKK8jJyRF+X1sP33zzTbnHSCQHB7kHUNG2bduGL7/8EgUFBahSpQp69eqFuXPnFmsKT506BTs7O7Rt27bYNtq1a4ctW7YgPT0darW6TOO4ceMGOnXqhD59+mDBggX466+/sHTpUvTt2xcXLlwo9oK/bNkyJCcnY/To0VCr1di9ezdmz56NK1euFHsBN0bDhg2xadMmDB8+HOHh4Rg1apRw++XLlxEVFYXq1atj7NixCAwMxJ07d3DmzBmcOHEC/fr1M/k+JUnC6dOnERgYiNq1awu3ubq6okWLFjh9+rTJ2y3sxo0bAAA/Pz/dsvz8fHTt2hXXr1/HmDFj8NRTTyEzMxOXLl3CwYMHMW3atDLd18iRI7Fp0yZ06NAB8+bNQ2ZmJtatW4dnn30WGzduxLBhw4T1k5OT0aVLF/Tp0wcfffQREhISsGrVKvz88884c+aM7gXJkOeffx6PHj3CvHnzMGrUKISHhxf7O0vy22+/oV+/fnj11VcxbNgw/O9//8NHH30Ee3t7XLhwAffv38c777yDrKwsxMXFoVevXrh27ZowF3PmzJn44IMP0KVLF8ycOROurq7Yt28fXn/9dfz999+YP39+mR5Dc4iKigIA7N+/H7179wYApKSkICEhAXZ2dti/fz+GDx8OALh//z5Onz6NmJgY3e+fO3cOnTp1Qn5+PsaOHYu6devi2LFjiIuLw4EDB3D8+HGhSQCAyZMnIzs7GyNGjICvry+CgoIMji0lJQU9evRAYmIi9u7dq2uYANMf0+vXryMiIgL9+/dHbGysrimcN2+ebi7na6+9BicnJ/zzzz/Yu3cvUlJSEBAQUOrjd+jQIQAotq97//33oVarsXPnTixatAg+Pj4AgGbNmpW6PQBYsWIF0tLS8Nprr8HLywtr167FiBEj4OjoiKlTpyI8PBxz587FpUuXsHz5cowYMQL79u3T/X5+fj569OiBI0eOYMiQIRg9ejSys7Px5ZdfIjIyErt27UKvXr1065v6XDSGMc+5jIwMPHr0yKjtOTo66t6UmNOzzz6L7du34+2338arr74KLy8v/Pbbb5gyZQqaNWuGF198UbfuuHHjsG7dOgwdOhRvvvkmAODatWvYs2cPsrKy4Orqqlu3Ro0aqFWrlq4+iCoduQ8hV6Snn35aio2NlbZv3y599dVX0tixYyVHR0dJrVYXm7Pp4eEhVa9e3eB2Jk+eLAGQzp8//8T7NPTRdO3atSUA0ldffSUsj42NlQBI+/bt0y3TfkTm5uYmJSYm6pYXFBRI/fr1kwBIhw4d0i0v7SNSGJiOYGiZJEnSkiVLJADSyZMnn/g3GuvOnTsSAKl169YGbx80aJAEoFwfvQ4YMKDYR4rnz5+XAEjz588v0zavXbsmAZBmzpypW6adwvLcc88JcxBv374tVa9eXfL29tZ9bC1J+v/5woULhW3v2LHD6GkiT/q4tKT/r0qlkn7++WdheYsWLSSVSiX17NlT0mg0uuU7d+6UAEirV6/WLTt79qykUqmkN998s9h9jhs3TrKzs5OuXLnyxPEbo6xTFJo0aSI1atRI9/MXX3whqVQqafjw4VKNGjV0y3fv3i0BkL7++mvdsvDwcEmlUknHjh0Ttjl79mwJgDRnzhzdsvXr10sApJCQEOH/q1X4+XfhwgUpKChICgoKki5cuCCsZ+pjqq2flStXFlu/ZcuWUsOGDUt6aJ4oIiJCcnFxMXhbaVMUDNWjdpm/v7+Unp6uW37z5k3J2dlZUqlU0oIFC4TtvPXWWxIA6c8//9Qt084r3bFjh7BuXl6e1LJlS6lOnTq6ZaY+F0t6vpX295T0nNOeT2DM15OmKKGMUxTu3Lkj9e/fX7K3txfu7/nnny9Wo1WrVpW6d+9u9LajoqIkR0dHk8dEpAQ2NUXh9OnTmDJlCp5//nkMGTIEy5cvx+7du5Geno4JEyYI62ZnZ8PZ2dngdrQfBZly1n9RgYGBGDJkiLCsa9euAB4fPS1q2LBhwlFPOzs7TJ06FcDjjznNTfvx/65du4p9dFVW2sfLUo/rvHnzsH37dvTr1w8jRozQLdceNTl06JDBj0LLQvuYz5gxA/b29rrlvr6++M9//oN79+7hwIEDwu94enpi/PjxwrL+/fujYcOG2LlzJzQajVnGVlS7du3Qrl07YVmnTp0gSRLeeustYVpKREQEALEGN2/eDEmS8Oqrr+LOnTvCV58+faDRaLB//36LjN1YUVFRiI+P130kf+DAATRr1gxDhgzBjRs3cOnSJd1ylUqFyMhIAEBaWhp++ukndO3aFR06dBC2+c4778Dd3d3g82vcuHHw8PAocTwHDx5Ex44dUa1aNZw8eRJNmjQRbi/LY6pWq/H6668Xuy9vb2/cuHEDR44cMeKRKi4tLQ3VqlUr0++W5JVXXkHVqlV1P/v5+SE0NBQqlUp35FDLUM1t2rQJwcHBCA8PFx6bjIwM9OnTB9euXdOtX5bnornExcXhxx9/NOorLi7OImNwdnZGnTp1EBERgXXr1mHHjh14++23sWfPHrzwwgvIy8vTrevt7Y2LFy/i/PnzRm27WrVqePToEe7evWuRsRNZks1NUSjqueeeQ5s2bXDgwAE8fPhQ12S5ubkhNzfX4O88fPhQt05ZFZ0DCED3ImMohqxRo0YlLis6b9ccBg8ejC1btmD+/PlYtGgRWrdujU6dOmHw4MHFXqyNpX28jH1c09PThZ0z8PhFq/CLmNaSJUvw/vvvo3Pnzti8ebPQtNWuXRszZ87EnDlzEBgYiKZNm6Jjx47o16+f7k2Fqa5evQoAaNq0abHbtMuKzq0NCQkx2Nw3atQICQkJSEtLM2rKgakM1Zq2+Sh6m3Z54RpMSEgAADRv3rzE+7h161a5x1ke0dHRWLJkCQ4cOIBhw4bhwIEDGDx4MDp16gQnJyfs378fTz31FPbv34+mTZvC19cXQOn/Rzc3N4SEhBicI92gQYMSx3Lr1i10794dISEhOHr0qDDVQ6ssj2lISIjB2o+NjUX//v3RuXNn+Pn5ITw8HFFRURgyZIjRH4lLkmTUesYqqeYCAwOLzRUtqeays7N1/ydDbt26hQYNGpTpuWguYWFhFtmusTQaDZ599lmkpqbi4sWLuikG/fv3R7169TBmzBisW7cOY8eOBfB4Pzl8+HC0aNECtWrVQnh4OJ599lkMGjSo2P8F0NdF4f0pUWVh8w0u8PgEilOnTiE9PR2BgYEAgJo1a+Ly5cvIzc0t1pRoMzpr1qxZ5vs09EKlVZ4Xm5J2REVPRnsSJycn/PDDDzh79iz27duHY8eOYdGiRZg3bx4WLlxY7CQxY6jVari5uZWYcZqcnAwvLy94eXkBeDwHruhRqWvXrhWbL/3JJ5/g7bffRlRUFP7P//k/Bt94zJo1CzExMfjhhx/w008/Yfv27VixYgX69u2LnTt3WvUOvLRaK+m2wjWoPbK8Z8+eEo++G2poKlJERAQcHBywf/9+hIWF4caNG4iOjoa7uzvatm2L/fv3Y8CAAYiPj8fEiRPLfX+lvblVq9V45plnsHv3bnz22WfFPh0CyvaYlnSfbdq0wd9//439+/fj0KFDOHLkCLZt24b//ve/OHr0KJ566qlS/xZfX19dk2guJdWVsfs9jUaD0NBQLFu2rMT1y/pGuySm7iMBw2/CS+Lk5FTmczZKcuzYMfz8888YN26cMH8WAAYNGoQxY8bg0KFDuga3d+/eSExMxL59+3D48GEcPnwYmzdvxuzZs3HixIlibyj+/fdfODk5GTyhl0jp2ODi8Udjjo6Owsd0rVu3xqVLl3Dq1Cl06tRJWP/EiRMICQkx+86qNPHx8SUuq1evnm6ZWq3GmTNniq1b1hewVq1aoVWrVgCAu3fvon379pg2bRrGjx8PJycnk7alUqnw9NNP4+jRo0hKShKmXOTk5ODcuXNo3769bllcXFyxj8b8/f2FnxcsWIApU6age/fu2Llzp8GjEFq1a9fG6NGjMXr0aOTn52PkyJHYvHkzjhw5YvKZ0SEhIQCAixcvok2bNsJt2ouGaNfRunLlisE3TPHx8fDy8ir1aBUg31GUBg0aYO/evQgICNDVgtJ4enqidevWOHDgAMLCwuDk5KQ7KSgqKgqffPKJ7iSmwmH62iby4sWLxbaZk5ODq1evCs8vYzg6OmLbtm0YPnw4Jk6ciKysLLz//vvCOuZ+TN3c3NCnTx/06dMHwONkhOeeew7z589/4pXGmjRpgiNHjuD69evFTpaTs+auX7+Ozp07w8Gh9JcpU5+LarUa6enpxbZjaB/5pL/f0JvwkkRERODw4cNGrWss7Um1BQUFxW7TNuxFG3dvb2+8+OKLupPPVq1ahTFjxmD58uXFkmL++usvs7+RIKooNjMHt6Srj23ZsgVnz57Vxfhoac+6LjpvaseOHUhMTNTdXlG+/PJLJCUl6X7WaDSIjY0F8HgnqxUaGooHDx7gl19+EX5/4cKFBrfr4eFhcGd/586dYsuqVq2KunXrIi8vz+jLeRZV0uO6cuVK5OTkCI9rWFgYoqOjha/CDey8efMwZcoU9OrVC7t27SqxuTV0prODg4Pu4+GyXJlO+5jPmzdPmDt7584dLF++HN7e3rqz+7UePHiApUuXCst27tyJhIQE9OvX74lRWdo5n4b+X5ak/Z9MnTrV4BnjGRkZJU47qUjR0dFITk7GqlWr0LZtW7i7u+uWZ2RkYOHChXB0dBTesPr6+iI8PBz79u0r9pyJi4tDZmYmBgwYYPJYHBwcsHnzZsTExGD69OnFkjrM+ZimpaUVW6b96NyY2ta+ufv555+L3SZXzb388su4e/cuPvzwQ4O3F56+YepzMTQ0FCdOnBDm+j98+LDYcxN48t9fkXNw79y5g0uXLiEjI0O3rHHjxgAenytR9Gpz2jc22qa/oKDA4Fzakmrlxo0buH79upD8ATw+R+LSpUtWe8VIsh42cwR37ty5OH78OCIjI1GrVi3k5eXh+PHj2L59OwICArB48WJh/ejoaAwZMgRbtmxB79690bdvX1y7dg2LFi1Co0aNyvQRfXk0bNgQbdq0wZgxY6BWq7Fr1y4cPHgQgwcPFnZAb7zxBuLi4tCvXz+89dZbcHNzw/fffy/sFAvTfny7YMEC1KpVCyqVCoMHD8bcuXOxd+9e9OrVC3Xq1IGDgwOOHDmC//3vf+jVq5dwtDs4OBhJSUlGTa2IiYnBxo0bsXTpUmRkZKBTp044f/48VqxYgc6dOxsd57N8+XK8//778PPzw/PPP4+tW7cKt3t4eOiizA4dOoTXX38d/fv3R2hoKLy9vREfH49Vq1ahRo0aZbo8ZmRkJIYPH45NmzahS5cu6N+/vy6a6Pbt29i4cWOxk5BCQkIwb9483ZGmhIQErFy5Er6+vpg7d+4T77NRo0bw9PTEihUr4ObmBm9vb1SvXl13wpSlPP3005g7dy6mT5+OJk2aYMiQIahZsyZu376NCxcuYPfu3YiPj9dNHdmwYQNiYmIwc+bMYkeEDPnuu+90J71o84s//fRT3VSV8ePHGzWXNCoqCh988AHi4+PxwQcf6Ja3bt0aXl5eiI+PR4cOHYr9Xz799FN06tQJkZGRGDNmjC4m7KuvvkLz5s2LZWEby87ODp999hnc3NwQGxuLrKwsLF68WPdJhimPaWm0+4bWrVujZs2aSE9PxxdffAEAwsmWJenevTu8vLywZ88eIVIK0EeHvffeexg6dChcXFzQpEkTix/Ve+utt3DgwAHMmjULR48eRbdu3aBWq3H9+nX8/PPPuHr1qu6Iq6nPxTfffBNDhgxB586d8fLLLyMzMxMbN240WGNPes6Vdw5u0ed9YmKiblnt2rWFN/zLli3D7NmzsX79el2Ob7NmzTBo0CBs3boVLVu2xOuvvw61Wo3jx49j8+bNCAkJwejRowE8foMdEBCA3r17o0WLFggICEBKSgrWrl0LBwcHDB06VBjLnj17AAAvvPCCsPyXX35Bly5dMGLEiCd+OkAkK9nyGyrY7t27pe7du0s1a9aUXFxcJGdnZyk0NFSaNGmScDWZwvLy8qR58+ZJ9evXl5ycnCR/f39p1KhRUlpamtH3W1JMmKHIGENxVIVjapYvXy6FhoZKTk5OUlBQkDRjxgyDl2bdt2+fFBYWJjk5OUm+vr7S6NGjpXv37hmMx7l8+bLUtWtXydPTUxcvo73fF198UQoODpZcXV0lLy8vqVmzZtKCBQuk7OxsYRvVqlWTAgMDjX5MHjx4IE2ePFmqVauW5OjoKNWqVUt69913jb78sSTp46RK+ioclXb16lVp9OjRUqNGjSQvLy/J1dVVqlevnjR+/Hij4qgM/V8k6XFU2+LFi6WmTZtKzs7OkoeHh9SlSxch5k1L+z8/d+6c1LVrV8nDw0Py9PSU+vbtK/31119G/93ff/+91LJlS8nZ2blY9JCh/6+hZZJUevxTSb+zd+9eqUePHlK1atUkR0dHKTAwUOrSpYsUFxcnXEXp008/lQBIa9asMepvetL/0tiraOXl5Unu7u4SgGKxaL1795YASP/9738N/m58fLz0wgsvSD4+PpKjo6NUu3ZtadKkScUu4a2NCSsczVdYSTF97777rgRAeu2114TLURv7mJZ2JbzY2FgpIiJCql69uuTo6Cj5+/tL3bt3l/7v//2/Btc3ZPz48ZKbm5t0//79YrctWLBAqlOnjuTg4CA8D0yN1SrpsSnpd/Lz86UVK1ZIbdq0kTw8PCQXFxcpODhYev7556VvvvlGWNeU56IkSdKiRYukOnXqSI6OjlJISIi0cOFCXdxY0XGU9pwrr9Lqvuj9aJ+zRceXl5cnxcXFSS1btpRcXV0lR0dHKTg4WBo3bpzwWpWbmytNnTpVatOmjeTj4yM5OTlJNWvWlAYOHGjwamUlXapX+/+qyCtgEpWFSpLMfPosmdXhw4fRpUsX4V27kpw7dw4tW7bE559/LoTnW5O///4b9evXx5w5czB9+nS5h6N4/fr1w8WLFxEfHw9HR0e5h0NGSE5ORmhoKGbNmoXJkyfLPRyS2cmTJ9GuXTvs2bOn2BXuiCoLm5mDS5axd+9eNG/e3KiPQiurlJQUADDLZTWt3aNHj3Dw4EHMnz+fzW0lUrNmTbz33nv46KOPyjy/nqzH+++/j27durG5pUqNR3AVTulHcK3Z3bt3sW3bNqxduxa//fYbLl++jDp16sg9LCIiInoCHsElKkFSUhLGjRuHnJwcbN26lc0tERFRJcEjuERERERkVXgEl4iIiIisChtcIiIiIrIqbHCJiIiIyKqwwSUiIiIiq8IGl4iIiIisioPcA7CE7OxsXLp0CU899RTc3NzkHg4REREZ6d69e8jOzjbLttzc3ODt7W2WbVHlYpUN7qVLlxAWFoYzZ86gVatWZtuuJEl48OABPD09oVKpzLbdykqSJGg0GtjZ2fHxAOujKNaHiPUhYn2IWB+P3bt3D8uWLUN+fr5Ztufg4IBx48axybVBVtngWookScjMzISHh4dN74AK075AEevDENaHHuujONaHHuvjsezsbOTn56Nly5bw8PAo17YyMzPx22+/ITs7mw2uDWKDS0RERIri4eHBppTKhW+diYiIiMiqsMElIiIiIqvCBpeIiIiIrAobXCIiIiKyKmxwiYiIiMiqsMElIiIiIqvCBpeIiIiIrAobXCIiIiKyKmxwiYiIiMiqsMElIiIiIqsi+6V6Fy9ejKNHj8LBQT+U5cuXw9fXFwCQlpaGpUuXIiEhAVWqVMHLL7+MTp06yTVcIiIiIlI42RtcAOjbty9GjBhh8LaPP/4YwcHBeP/993H58mXMnTsXtWvXRu3atSt4lERERERUGSiiwS1JSkoKLl++jBkzZsDZ2RlNmzZF69atcfDgQcTExMgypkePHiEvLw92dpzdIUkS8vPzodFooFKp5B6O7DQaDeujENaHiPUhUnJ9nD7tZLFtP/NMHgDAycly90FECmlw9+3bh3379sHHxwe9e/dG165dAQBJSUnw9fWFh4eHbt06derg999/L7aN1NRUpKamAgASEhIsNtZ79+7BwcFBcTtkOUiShIKCAtjb2/PxwOPHg/Whx/oQsT5ESq6Pjh0DLbbtGzfuAAACAy13H0SkgAa3d+/eeOWVV+Du7o6LFy9iwYIFcHd3R/v27fHw4UOhuQUAd3d35OTkFNvO6tWrMXv27IoaNhEREREplOwNbkhIiO77Zs2aoWfPnjh+/Djat28PFxcXZGVlCetnZ2fD1dW12HbeeOMN9OnTB8DjI7jDhg2zyHi9vb1RrVo1fsQI/UeMPCL1mEajQX5+Puvj/2N9iFgfIiXXx7Fjltu2j4+P5TZORDqyN7hFqVQqSJIEAKhduzbS0tKQmZmpO5J79epVgyeYBQQEICAgwOLjc3R0hJOTE1+g8PgFys7OTpEvUHLQaDSsj0JYHyLWh0jJ9dGhgyW3zrm3RBVB9r3ssWPHkJ2dDY1Gg/j4eHz//fdo27YtgMdzlOrVq4cvv/wSubm5+OOPP/DLL78gMjJS5lETERERkVLJfgR3z549WL58OTQaDXx8fDBs2DAh53by5Mn49NNPMXToUHh7e2Ps2LEshPapAAAgAElEQVSMCCMiIiKiEsne4M6fP7/U2319fTFnzpwKGs2TMeZHT8kxP3JgDJSI9SFifYiUWh+WjAgrjUYDpKc7Qa0GylIe2vixkjCWjGyN7A1uZcOYHz0lx/zIgTFQItaHiPUhUmp9WDIirHR2AMp+Apo2fqwkjCUjW8PDCERERERkVXgE10SMCdNTcsyPHBgDJWJ9iFgfIqXWhyUjwkqj0WiQnp4OtVpdpvpg/BiRiA2uiRjzo6fkmB85MAZKxPoQsT5ESq0Py0aElUyjAW7ezIO/f9nm4DJ+jEjEvSwRERERWRU2uERERERkVThFwUSM+dFTasyPXBgDJWJ9iFgfIqXWR2WNCasIhaPIGDtGSscG10SM+dFTasyPXBgDJWJ9iFgfIqXWR2WNCasIhaPIGDtGSqfQ94lERERERGXDI7gmYkyYnlJjfuTCGCgR60PE+hAptT4qa0xYRWAUGVUmbHBNxJgfPaXG/MiFMVAi1oeI9SFSan1U3piwisB5t1R5KPZpRERERERUFmxwiYiIiMiqcIqCiRjzo6fUmB+5MAZKxPoQsT5E5qiPskZ6FY67KozRV0TWgw2uiRjzo6fUmB+5MAZKxPoQsT5E5qiPskZ6FY67KozRV0TWg4cRiIiIiMiq8AiuiRgTpqfUmB+5MAZKxPoQsT5E5qiPskZ6Me6KyPqxwTURY370lBrzIxfGQIlYHyLWh8gc9VH2SC/OtSWydtzLEhEREZFVYYNLRERERFaFUxRMxJgfPcZAiRgDJWJ9iFgfYqyXJAEFBSrY2wMsj8dXMktPd4JaXbFXMispMg1gbBpVbmxwTcSYHz3GQIkYAyVifYhYH0VjvVTgS1BhdgAq/uS3kiLTAMamUeVmm4cRiIiIiMhq8e2ziRgTpscYKBFjoESsDxHrQ4z14hF+kUajQXp6OtRqdYXWByPTyFqxwTURY370GAMlYgyUiPUhYn2IsV6SBOTnS3Bw4Bxc4PEc3Js38+DvX7FzcBmZRtbKNveyRERERGS1eATXRLZ+FnRhPEtexLPkRawPEeuDKQqlKU+KgjYJgakHRHpscE1k62dBF8Y5dCKeJS9ifYhYH0xRKF3ZUxS0SQhMPSDSs83DCERERERktfj22URMUdDjWfIiniUvYn2IWB9MUShNeVIUmIRAVBwbXBPZ+lnQhfEseRHPkhexPkSsD6YolKZ8KQqce0tUlG3uZYmIiIjIarHBJSIiIiKrwikKJrL1mJ/CGAMlYgyUiPUhspX6KBwFVhrGhInKExNmKdr4MUMYSUZKxwbXRLYe81MYTxIRMQZKxPoQ2Up9iFFgpWFMmKjsMWGWoo0fM4SRZKR0CnmfSERERERkHnz7bCLGhOkxBkrEGCgR60NkK/VROAqsNDzCLypPTJilMH6MKjM2uCay9ZifwhgDJWIMlIj1IbKV+igcBVYaxoSJyhcTZimcZ0uVl2KeRkRERERE5sAGl4iIiIisCqcomMgWYn6MxRgoka3EQBmL9SGqbPVhbNxXWckdE2YoAovRV0TWgw2uiWwh5sdYPElEZCsxUMZifYgqW30YH/dVVvLGhBmKwGL0FZH1UP5hBCIiIiIiE/AIrokYE6bHGCiRrcRAGYv1Iaps9WFs3FdZyX2EnxFYRNaNDa6JbCHmx1iMgRLZSgyUsVgfospWH8bGfZWV/DFhnG9LZM2Uv5clIiIiIjIBG1wiIiIisiqcomCiyhTzY2mMgRJVthgoS2N9iJRYH06nT8t355IEVUEBZMsJUxqNBk7p6YBabZlLmVl6zgmRwrDBNVFlivmxNLlPElGayhYDZWmsD5ES6yOwY0fZ7lvekDDlsQNg0dPeJMmSWydSHGUcRiAiIiIiMhO+gTYRY8L0GAMlqmwxUJbG+hApsj4snQVWCh7hF2k0GqSnp0OtViunPogqMTa4JqpMMT+WxhgoUWWLgbI01odIkfUh57xMSYKUnw8Zc8KURaNB3s2bgL+/ZebgEtkYPouIiIiIyKqwwSUiIiIiq8IpCiZSWsyPnBgDJVJiDJScWB8iOevj9GnlXbVLkoCCApVNp4Q980ye7vvC9eHi4iLjqIisAxtcEykt5kdOPElEpMQYKDmxPkRy1kfHjoEVen/GYVDYjRt3dN8Xro8aNWrIOCoi68DDTERERERkVWz77XMZMCZMjzFQIkXGQMmI9SGSsz5kTAMrEY/wAz4++ks7FK4PIio/RTW49+/fx5gxYxAQEICPP/4YAJCUlISlS5ciMTERfn5+GDVqFJo3by7bGBUX8yMjxkCJFBkDJSPWh0jO+lDiVVolCcjPl2w8JUw/N7pwfRBR+SnqVXj9+vUICgrS/Zyfn485c+agdevW2LJlCwYPHozY2Fjcu3dPxlESERERkZIppsH9448/kJKSgujoaN2yCxcuIDc3FwMHDoSjoyPCw8NRq1YtHD9+XMaREhEREZGSKWKKwqNHj7B69WpMmjQJV69e1S3/559/EBwcLHycV7duXSQlJckxTACMCSuMMVAixoSJWB8iY+tDiZFelmDNMWHa+C9ONyCSjyIa3O3bt6N58+aoU6eO0ODm5OTA3d1dWNfd3R23b98uto3U1FSkpqYCABISEiw2VsZA6fEkERFjwkSsD5Gx9aHMSC9LsN6YMG38V2CgrfwviZRH9r1LSkoKDhw4gCVLlhS7zdXVFVlZWcKyrKwsuLq6Flt39erVmD17tsXGSURERESVg+wNbkJCAu7evYvRo0cDAPLy8pCXl4eXX34ZY8eORVJSEjQaje4jvWvXrqFTp07FtvPGG2+gT58+um0OGzbMIuNlTJgeY6BEjAkTsT5ExtaHEiO9LMGaj/AXjv8iInnI3uB27NgRrVq10v38008/4dChQ/jvf/8LT09PODk5YceOHejbty9OnTqFpKQkdDCQeRMQEICAgACLj5cxUHqMgRIxJkzE+hAZWx9KjPSyBOuOCePcWyK5yd7gOjs7w9nZWfezu7s77O3tUbVqVQDA9OnTsWzZMnz99deoXr06pk6dCm9vb7mGS0REREQKJ3uDW1RUVBSioqJ0PwcHB+su+kBERERE9CSKa3CVjjFQeoyBEjEmTMT6EBmqD1uJBDNE7pgwbZRXYYz1IrIebHBNxBgoPWs+SaQsGBMmYn2IDNWH7USCGSJvTJg2yqswxnoRWQ8eZiIiIiIiq8IjuCZiTJgeY6BEjAkTsT5EhurDViLBDJH7CD+jvIisGxtcEzEGSo8xUCLGhIlYHyJD9WErkWCGyB8Txvm2RNaMr8JEREREZFV4BNdEPEtej2fJi5iiIGJ9iJiiIJI7RaE8iiYwMH2BSHnY4JqIZ8nryT2HTmmYoiBifYiYolCUvCkK5VE0gYHpC0TKw8NMRERERGRVKufbZxkxRUGPZ8mLmKIgYn2ImKIgqsxH+JnAQKR8bHBNxLPk9XiWvIgpCiLWh4gpCiL5UxTKg3NuiZSOr8JEREREZFXY4BIRERGRVeEUBRMxBkqPMVAixoSJWB+iovVhyxFhQPliwrQxXYznIqKSsME1EWOg9CrzSSKWwJgwEetDVLQ+bDsiDChPTJg2povxXERUEh5mIiIiIiKrwiO4JmJMmB5joESMCROxPkRF68OWI8KA8h3hZ0wXET0JG1wTMQZKjzFQIsaEiVgfoqL1YcsRYUB5Y8I495aISsdXYSIiIiKyKmxwiYiIiMiqcIqCiRgDpccYKBFjwkSsj8e0cWAaDZCe7gS1GjB3eWhjswxhlBYR2SI2uCZiDJQeY6BEjAkTsT4e08eB2QGwzMlR2tgsQxilRUS2iIeZiIiIiMiq8AiuiRgTpscYKBFjwkSsj8e0cWAajQbp6elQq9Vmrw/GZhERidjgmogxUHqMgRIxJkzE+nhMGwem0QA3b+bB39/8c3AZm0VEJOKrMBERERFZFTa4RERERGRVOEXBRIyB0mMMlIgxYSLWhz4iDLBsTJiptLFijBAjImvFBtdEjIHSYwyUiDFhItZH4YgwwJIxYabSxooxQoyIrBUPMxERERGRVeERXBMxJkyPMVAixoSJWB/6iDDAsjFhpmKsGBFZOza4JmIMlB5joESMCROxPvQRYYClY8JMxbm3RGTdZN/NEhERERGZExtcIiIiIrIqnKJgIsZA6TEGSsSYMJGt10fhiDCg9JgwbWwXwOguIiJzYINrIsZA6TEGSsSYMJGt14cYEQaUFhOmje0CGN1FRGQOPMxERERERFaFR3BNxJgwPcZAiRgTJrL1+igcEQaUHhPG2C4iIvNig2sixkDpMQZKxJgwka3XR+GIMOBJMWGcd0tEZE58FSYiIiIiq8IGl4iIiIisCqcomIgxUHq2HgNVFGPCRLZSH0XjwEpSWkyYtWL8GRHJhQ2uiRgDpWfrMVBFMSZMZCv1UTwOrCQlx4RZK8afEZFcbOQ4AhERERHZCh7BNRFjwvRsPQaqKMaEiWylPorGgZWktJgwa8X4MyKSCxtcEzEGSs/WY6CKYkyYyFbqo2gcWElKjwmzVpx3S0TysJndLBERERHZBja4RERERGRVOEXBRIyB0rOVGChjMSZMZE31YWwUWGmsOSZMGwfGKDAiUgo2uCZiDJSercRAGYsxYSJrqg/jo8BKY70xYdo4MEaBEZFSWNlxBCIiIiKydTyCayLGhOnZSgyUsRgTJrKm+jA2Cqw01hwTxjgwIlIaNrgmYgyUnq3EQBmLMWEia6oPY6PASmPdMWGce0sVp6CgAJcuXdK9YXzqqadgb28v97BIYdjgEhERUaVw7do1fPjhh8jLy0O1atXw77//wtnZGdOmTUOdOnXkHh4pCBtcE/EseT1rOkveHJiiIFJifZgjDaEwbXqAIUwUIDK/pUuX4rnnnsOAAQN0y7Zv345ly5YhLi5OxpGR0rDBNRHPktezprPkzYEpCiIl1od50hD0tOkBhjBRgMj8bty4gX79+gnL+vXrh61bt8o0IlIqHmYiIiKiSqFJkya4cOGCsOz3339H48aNZRoRKRWP4JqIKQp61nSWvDkwRUGkxPowRxpCYUwPILK8L774Qvd9tWrV8OGHH6JVq1bw9fXF7du38dtvv6FLly4yjpCUiA2uiXiWvJ41nSVvDkxRECmxPsyRhiDiPFsiS7t3757wc8eOHQEAWVlZcHd3R8eOHfHo0SM5hkYKpogGd9myZfj111+Rk5MDT09PdOvWDS+88AIAICkpCUuXLkViYiL8/PwwatQoNG/eXOYRExERUUV466235B4CVUKKaHD79OmD119/Hc7OzkhLS8OsWbMQGBiItm3bYs6cOejWrRtiY2Nx8uRJxMbGYtWqVfD29pZ72ERERFSBbt++XeJt1atXBwCkpaXB19e3ooZECqWIBrdWrVrCzyqVCikpKbhw4QJyc3MxcOBA2NnZITw8HN999x2OHz+Onj17yjJWxkDpKTEGSk6MCRPJVR/mjgLTMhQJxigwooo1atQoSJJUbJ8iSRJ2794NABg3bhy++eYbOYZHCqKIBhd4PIl8z549yM3NRfXq1dGlSxf8/PPPCA4OFpqFunXrIikpqdjvp6amIjU1FQCQkJBgsXEyBkpPiTFQcmJMmEiu+jB3FJiWoUgwRoERVSxj4sA2b95cASMhpVPMYaYRI0bg22+/RVxcHCIiIuDu7o6cnBy4u7sL62mXF7V69WqEhYUhLCwMw4YNq6hhExERUQVxdHSEo6Mj7t27h6tXr+LevXu6ZVoODoo5dlcpJCYmQqVSYdu2bbplwcHBGDdunFm2P2HCBAQHB5tlW6ZQVBWoVCrUr18fZ86cwZYtW+Dj44OsrCxhnaysLLi6uhb73TfeeAN9+vQB8PgIrqWaXMaE6SkxBkpOjAkTyVUf5o4C02IkGJH80tLS8PHHH+PPP/+Eu7s7srKyEBoainfeeYfzbkmgqAZXS6PRIDU1Fa1atcL27duh0Wh0DcO1a9fQqVOnYr8TEBCAgIAAi4+NMVB6SoyBkhNjwkRy1Yf5o8C0ON+WSG6LFy9GSEgIZs2aBVdXV+Tk5GDjxo349NNPMWfOHLmHRwoi+6twZmYmDh06hOzsbGg0GsTHx+OHH35AixYt0LRpUzg5OWHHjh149OgRjh07hqSkJHSw3CsYERERKdSVK1cQExOj+yTX1dUVr776Kv766y+ZRyY6ceIEunXrBi8vL3h6eqJNmzb48ccfAQBTpkxB06ZN4eHhgRo1amDIkCG6c4i0OnfujF69emHbtm0IDQ2Fh4cHIiMjceXKFWG93NxcTJ8+HXXr1oWzszNq1qyJkSNHFhtLZGQk3N3dUaVKFbz00kulplGU9jc9aTspKSno06cP3NzcUKNGDXz00Ucm34+5KOII7v79+7FmzRpoNBqo1Wr069cPPXv2hEqlwvTp07Fs2TJ8/fXXqF69OqZOncqIMCIiIhsUHByMf/75ByEhIbplSUlJsszxLMnx48cRGRmJtm3bYt26dfD29savv/6Kf/75B8DjqLNp06YhMDAQaWlpunOP4uPjhfnD586dw8KFCzF//nwUFBRg0qRJGDZsGE6cOKFbZ8CAATh48CCmTZuGtm3bIi0tDTt27NDdfuLECXTu3Bk9evTAN998g6ysLEyfPh19+/YVtvMkxm6nb9++SE5OxsqVK+Ht7Y358+fj+vXrssyLlr3B9fDwwIcfflji7cHBwfj4448rcESlYwyUHmPCRIwJE1m6PiwVB2YpGg2Qnu4EtRpQUnkYij8DGIFGytS4cWPMnj0bERER8PX1RVpaGg4fPoyuXbti7969uvW6d+8u2xjfffdd1KtXDwcPHoS9vT0AoFu3brrbP//8c933BQUFaNeuHWrWrImDBw8K6927dw+//fabbm5xZmYmYmJikJycjJo1a+LHH3/E999/j6+++gpDhgzR/V7h76dMmYKnn34aO3bs0O2HmzZtiiZNmuB///sfevToYdTfZMx29u7di19//RUHDhxAZGQkgMdHooOCgqBWq016DM1B9ga3smEMlB5jwkSMCRNZuj4sFQdmOXYAlHeimqH4M4ARaKRMly5dQlBQEK5evYqrV68CeJyl/+eff+LPP//UrSdXg5udna27KJW2uS3qhx9+wJw5c3Dx4kXcv39ft/zy5ctCg9uiRQvhxLlGjRoBgK7BPXDgANzc3DB48OASx3L8+HF8/PHHKCgo0C1v0KABgoKCcPr0aaMaXGO3c+rUKVSpUkXX3AJAlSpVEB0djbNnzz7xfsyNDS4RERFVCqV94qsEd+/ehUajKfEN4unTp9GnTx/07dsXU6ZMQfXq1aFSqdC2bVs8fPhQWLfodEztpyra9f79918EBASUeADh7t27KCgowMSJEzFx4sRit1+/ft3ov8mY7aSmphpMsvDz8zPqfsyNDa6JGBOmx5gwEWPCRJauD0vFgVmKRqNBeno61Gq1ouqD8WdE5uPt7Q07OzukpKQYvH3nzp2oUqUKvv32W91+wNDFq4xRrVo1pKamGryym3YsKpUK06ZNQ79+/Yrdbuxz39jtBAQEIC0trdjtt27dMup+zI0NrokYA6XHmDARY8JElq6PyhamotEAN2/mwd9fWXNwGX9Glcns2bMxc+ZMYdmcOXMwY8YMmUYkcnd3R7t27bBx40a8/fbbxaYp5OTkwNHRUdgnlvXKa9HR0ViwYAG+/fZbvPjiiyWOJSEhAXPnzi3TfZiyndatWyMjIwMHDx7UTVPIyMjA/v37OQeXiIiIqCSNGzcutkw7N1Up5s+fj8jISERHR2Ps2LGoWrUqzp49Cx8fH3Tt2hWLFy/G+PHj0b9/f5w4cQKbNm0q0/1ER0ejR48eeOWVV3DlyhW0adMG6enp2LZtG7755hsAwMKFCxEZGYkXX3wRgwcPRtWqVZGcnIwff/wRMTEx6Ny5s1H3Zcx2unfvjlatWmHo0KFYsGABvL29ERsbCy8vrzL9feVlVINbp04dk47AaCd+ExEREZnLwIEDiy0bMGCADCMpWceOHXH48GFMnz4dI0eOhL29PRo3boy5c+ciKioKCxYswNKlS7F+/Xp06NABe/bsQYMGDcp0X9u3b8fs2bOxevVqzJo1C35+fsKJau3bt8exY8cwc+ZMxMTEIC8vDzVr1kRUVBTq1atn9P0Ysx2VSoXdu3dj9OjReOONN1C1alWMHz8et27dwq5du8r095WHSpIk6UkrTZgwQWhwt23bhvv37yM6Ohp+fn64desW9u/fjypVqmDgwIH45JNPLDroJzl79izCwsJw5swZtGrVymzb1Wg0uH79Ovz8/PgRNDgHtyiNRoNbt26xPv4/c9RHZYsCK41S5+Cam7GxY9x/iDQaDW7evAl/f3+rro8nSUlJwZo1axAeHl7uzPt79+7hp59+wqhRo5gKYoOMOoK7ePFi3fcLFy5EUFAQ9u7dKxx2zsjIwHPPPSfb2XIVhTFQeowJEzEmTGSO+qh8UWClUWZMmLkxdoyIlMDkt4mffvoppk6dWmxORZUqVTBlyhQsXbrUbIMjIiIiIjKVySeZpaenIyMjw+BtGRkZuHv3brkHpWSMCdPjR4wixoSJzFEflS0KrDS2MkWBsWNkq4yY8VlmfI01nckNblRUFN577z0EBQUhIiJCt/zw4cOYMmUKoqKizDpApWEMlB5jwkSMCROZoz4qWxRYaZQbE2Zu1jNvmpTpzp07OHLkCNLS0uDr64vOnTujWrVqcg8L165ds8hBvsDAQAQEBJh9u9bO5N3s6tWrERgYiMjISKjVaoSGhkKtViMqKgoBAQFYtWqVJcZJRERENu7SpUsYP3484uPj4ejoiISEBIwbNw6XL1+We2ikMCYfwQ0ICMDp06exd+9e/PLLL0hNTUVAQABat24t27WfiYiIyPqtX78eb7zxhpDfeujQIaxfvx6xsbHyDayQskZ+GcLGvezKfKGH7t2722RD++jRI+Tl5fEjaOjnWGo0Gk5RwOMpCqwPvaL1YU2RX1olRWIBxWOxiKj8/vnnH4SHhwvLOnXqhLVr18o0IlIqoxrc9PR03fWV09PTn7i+HJdkqyiMgdJjTJiIMWGiovVhXZFfj5UUiQUwFovIEpydnZGbmws3Nzfdsry8PL6hpGKMOszk6+uLX3/9FcDjM2R9fX1L/SIiIiIytz59+iA5OVlYlpycjN69e8s0ospl3bp16Nixo9zDqBBGHcH9/PPPERISovvelo9OMSZMjzFhIsaEiYrWhzVFfmkxEouoYj3//PPFltWvXx/169eXYTTy6ty5M06ePAkHB30r9+WXX6Jfv34yjko5jGpwR4wYoft+5MiRlhpLpcAYKD3GhIkYEyYqWh/WFPmlx49FiSra/fv3MWnSJLRo0QIjR46Eh4eH3EOSzeLFizF69Gi5h6FIfBUmIiKiSkOj0SAvLw81a9bEpEmTcPDgQbmHpCjz589HSEgIPD090ahRI+zcudPgehqNBpMmTYKfnx+8vLzQsGFD/PTTT7rbFi5ciPr160OtVqNXr164ceNGRf4Z5VbmFAUiIiIiOahUKvTr1w8RERFYu3YtDh48iLFjx8p6cufMmdXw5Zd1zbzVMKSkpJr0GyEhIfjpp5/g7++PrVu3YujQobhy5Uqxi0X88MMP2L59O86fPw8/Pz8kJibqPo1dsmQJtm7div379yMwMBAzZszASy+9hCNHjpjtL7M0NrgmYgyUHmPCRIwJExWuj19/dS7XtorGcfGMaSICgKpVq+Ldd9/Fb7/9htjYWLRr1w4vvfSS3MOqMJMmTcKUKVMAAB4eHkhOTsagQYN0t7/44ouYO3cufvnlF/Tt21f4XScnJzx8+BAXL16Ej48P6tSpo7tt5cqVWL58OWrXrg0A+OCDD+Du7o6UlJRKkxDDBtdEjIHSY0yYiDFhosL10bFjjXJtq2gcV2XZwRKReb3++usoKChARkYGXnvtNeG2goICfPPNNzbV4H7yySfF5uBu2LABixYtQlJSEgAgMzMTd+4UjzTs2rUrpk+fjilTpuCvv/7Cc889h0WLFsHf3x9JSUkYMGCAcLDGwcEB169frzT7Xza4REREVCmMHTsWWVlZWLlyJf7zn//IPRzFuXr1Kt544w0cPHgQbdu2hb29PZo2bQpJkgyuP378eIwfPx7p6el49dVXMXXqVKxfvx5BQUHYsGFDpY4UK3ODe/nyZeFSvc888wxCQ0PNOTZFYkyYHmPCRIwJExWuj/JGhDGOi4gAoGXLlnj48CF69uyJli1byj0cwezZ/2LChL8tcKle44+YZmZmQqVS6faZ69evR0JCgsF1T506BUmSEBYWBjc3N7i6usLe3h4AMGbMGEybNg0bNmxA3bp1kZ6ejgMHDgjTH5TO5AY3MzMTo0aNwrfffguNRgMXFxc8fPgQdnZ2GDRoENauXWvVkR2MgdJjTJiIMWGiwvVR/ogwzrklosdcXFxsahqCKZo1a4a33noLbdu2hYODA0aMGIE2bdoYXDcjIwPvvPMOrl69CicnJ0RERGDx4sUAgIkTJ8Le3h49evTAjRs3oFar0a1bN+tucMePH489e/Zg7dq1GDhwIDw9PfHgwQNs3boVEyZMwPjx47F+/XpLjJWIiIhs2IoVK9CgQQNER0cXu+327ds4e/YsunfvLsPIKt7hw4cNLl+wYAEWLFhg8LbXXntNN3e5W7du+P333w2uZ2dnhwkTJmDChAlmGascTD7MtH37dixYsAAxMTHw9PQEAHh6euKVV17B/PnzsWPHDrMPkoiIiOiXX35BWFiYsOzXX38FALi5uZWY+Uq2x+QjuC4uLkKURGF169aFo6NjuQelZIyB0mNMmEiJMWGnT8v30b4kAQUFKtjbA7ZaHoXjzYrWB6POiEyXk5ODqlWrCsvi4uKwZcsWeHh44P79+zKNjJTG5AY3JiYGK1euxLPPPis0NZIkYcWKFYiJiTHrAJWGMS4I/6kAACAASURBVFB6jAkTKTEmrGNHOeNcVLD1oJbC8WZF66OyRO0QKYmnpydu3rwJf39/AMCdO3eQnZ2N7OxsvnEkgVGvPp988onu+2rVquHMmTOoX78+evfujerVq+P27dv47rvvkJubi/DwcIsNloiIiGzX008/jUWLFmHo0KFwcHDA2bNn4eLiglWrVkGSJLRq1UruIZJCGNXgvvPOOwaXL1mypNiyKVOmYPLkyeUblYIxJkyPMWEiJcaElTeeqzx4hF+MN1NifRBVNsOHD8eyZcsQGxsLf39/TJ48GY0bN8auXbsQEBCAl19+We4hkkIY1eBqNBpLj6PSYAyUHmPCREqMCSt/PFfZSRKQny/BwcF25+AWjjdTYn0QVTbu7u547733hGWBgYGKyMTVvg4+zq4ludn2BDkiIiKqNLKysiBJkiLz9uvUqVPiSfhU8crU4GZlZWHDhg04duwY0tPToVarER4ejhEjRsDd3d3cY1QUpZ0lLyemKIjkSlGQMymhNLaSolA4KaEwnuxCZH6xsbGIiopCly5dit2WnJyM3bt38xK+BKAMDe7169fRuXNnJCYmonnz5vDz88Off/6JrVu34pNPPsGhQ4cQFBRkibEqgtLOkpcT51iK5EpRkDcpoTS2kaJQOCmhMKYkEJnftWvXil2Za+PGjXj55Zfh5+eny8SVw8OHD/Ho0SOzb9fZ2ZlvmMvA5FefSZMmAQDi4+MRGhqqW/7nn3+iV69eePvtt/Htt9+ab4REREREAAoKCuDq6ios27NnD15++WU4OjoiJydHppEBKSkpuHv3rtm3GxgYiICAALNv19qZ3OD++OOPWL16tdDcAkBoaCjmzJmD0aNHm21wSsQUBT2mKIjkOktezqSE0tjKEf7CSQlEZFnVqlVDQkICGjVqBAD4+++/kZubi7S0NNjZ2emusEpkcoObn59f7N2TlqurKwoKCso9KCXjWdB6TFEQyXWWvJxJCaWxnRQFfnRIVFGio6MRGxuL5557Dvb29nj06BH8/PzwwQcfQKPR4Nlnn5V7iGjQoIHZtsVEhrIzucHt0KED5s6di4iICFSpUkW3PCMjAx9++CE6KPXVloiIiCq1/v37w9nZGefOnYO/vz9eeukldO/eHYcPH0ZAQAB7ENIxucGNi4tDp06dEBQUhMjISPj5+eH27ds4cOAAHB0d8fnnn1tinERERETo0aMHevToofvZxcUFAwcOlHFEpEQmN7hNmjTB+fPnsWjRIhw7dgwXL16EWq3G66+/jokTJ6JmzZqWGKdiMCZMjzFhInPEhDmdPm3mUclIkqAqKIDV54QZS6OBU3o6oFYDdnbKnVtCpHDJyclCTGnHjh2tvvcg05UpwycoKAiffPKJucdSKTAmTM9WTiIyljliwgI7djTzqORjGyFhxrMDIJyOJkkyjYSo8jp69CiWLVuGVq1awdfXF4mJidi+fTvGjx+PTp06yT28ClP4Qhc5OTlwdHSEg8PjPe60adMwbdo0uYamGEa9/jRr1gxfffUVmjRpgqZNm5b64q1SqaBWq9G6dWu89957UKvVZhssERER2a5NmzZhxowZaNq0qW7Z77//jmXLltlUg5uZman7vm3bthg9ejRGjhxZ4vraxCNbYtRfGxYWprtCWVhY2BOPTj148ACfffYZ/vzzT+zatav8o1QQxoTpMSZMZJaYMKVmfpUBj/CLNBqN7iNV7j+IyiY7O1sXEabVuHFjZGVlyTQiZVq3bh3Wr1+Pdu3a4YsvvsALL7yAli1b6q5Cq+Xj44Ndu3ahY8eO0Gg0iIuLw5o1a/Dvv/+iffv2WL16NWrUqCHjX1J2RjW469ev132/YcMGoza8e/duDB8+vEyDUjLGhOkxJkxklpgwa5qXKUmQ8vNhAzlhxtFokHfzJuDv/3gOLhGZLDo6Gtu3b8fAgQNhZ2cHjUaD7du3Izo6Wu6hodrMmaj75Zdm3WYYgNSUlDL97qlTpzBw4ECkpqbi0aNH2Lx5c6nrL1myBFu3bsX+/fsRGBiIGTNm4KWXXsKRI0fKdP9ys9jx6oiICGzatMlSmyciIiIbk5CQgL///hvfffcd1Go10tPTkZmZiXr16mHy5Mm69RYuXCjjKJUhICAAEydOBACjpiesXLkSy5cvR+3atQEAH3zwAdzd3ZGSklIpLz1usQbX29sbffv2tdTmiYiIyMZ0795d7iFUGrVq1TJp/aSkJAwYMED4BNLBwQHXr19ng2sLGBOmx5gwkbExYVYVBVYaxoSJCsWE5bVpAycnXgGNyFSRkZFyD6HSKPq67OHhgezsbN3Pubm5uHfvnu7noKAgbNiwAR2tJM2HDa6JGBOmx5OIRMbGhFlTFFhpGBMmKhwTdufGjUp5RIRICTIzM3Hy5EkkJiYiNzcXPj4+CA0NRYsWLWQd17+zZ+PvCRPMfqlec+0pmjdvjj/++ANnzpxBkyZNMGPGDOH2MWPGYNq0adiwYQPq1q2L9PR0HDhwAIMGDTLTCCoWX3+IiIioUrh06RLmzp0LFxcXSJKEf//9F82bN8ePP/4IPz8/TJ06VciIJb2GDRti1qxZePbZZ+Hk5ISZM2fC29tbd/vEiRNhb2+PHj164MaNG1Cr1ejWrVulbXBVkmR9aeNnz55FWFgYzpw5g1atWpltuxqNBtevX4efnx+nKIAxYUVpNBrcunXrifVhK1MUeIRfVDgmLJ9TFLj/KEKj0eDmzZvw9/e36deXlJQUrFmzBuHh4ULzpTVhwgT07NkTXbt2BQDs27cP8fHxmDBhAj777DNkZmZiwoQJAB5/4vrTTz9h1KhRFfKJydWrV3H37l3zH8ENDERAQIDZtmkreATXRIwJ02NMmMjomDBrigIrDWPCRIViwpy4/yAqk9TUVERFRel+jo6OxsaNG6FSqfDSSy/htddek3F0pCTcyxIREVGl4Ofnh/Pnz+t+PnfuHHx9fQFAN22BCOARXCIiIqokRowYgfnz5yM0NBTA41zcd999FwBw7do11KtXT87hkYKwwTURY8L0GBMmMjYm7PRp6517+cwzebrvC9eHs7OzjKMiImsRFhaGJUuW4OzZswAen/mvnZ8aEhKCOXPmyDk8UhA2uCZiTJgeTyISGRsT1rGj9cZD3bhxR/d94fqorNcyJyLl8ff3R48ePeQeBikcG1wiIiKqFFasWIEGDRogOjq62G23b9/G2bNnZbvamYuLC1xdXXH9+nWzbdPV1RWOjo5m254tYYNrIm9vb1SrVo1TFMCYn6I0Gg3y8/OfWB/HjlXgoCqYj4+P7vvC9UFEZA6//PILhgwZIiz79ddf8fTTT8PNzQ07d+6UrcENDAzkBVwURPZXnkePHmHVqlU4f/48Hjx4AB8fH7zwwguIiIgA8PjayEuXLkViYiL8/PwwatQoNG/eXLbxMiZMjzFhImNjwqw7JUw/v7hwfRARmUNOTg6qVq0qLIuLi8OWLVvg4eGB+/fvyzQyUhrZu7SCggKo1WrMnTsXX3/9Nf7zn/9g5cqVuHTpEvLz8zFnzhy0bt0aW7ZsweDBgxEbGytcO5mIiIhsg6enJ27evKn7+c6dO8jOzkZ2djYePnxo8xdQIT3ZD624uLhg6NChup8bNWqEhg0bIiEhATk5OcjNzcXAgQNhZ2eH/9fe/cdWVZ9xHP/c3tLfKJTaWihtYXMRNkNAwB+UH85RNgkgszACpUFGwA0XddFsZmKoMMgSNnEU1kaTGjGIcaBDNAMmEhGJdpAJLg1KKGUtlQKFAaWlvfee/cHay6EFetrbe8499/36y37v4fSxfEOffu/Tzxk/frzef/997du3T1OnTrWxagAAEG6jR4/Wyy+/rHnz5ik2NlYHDx5UQkKCSktLZRhGSJ9eishme4N7vebmZh09elTTpk3TiRMnlJuba3q7d+jQoaqurratPmLCgogJM+ssJixUkWDXxm9djxMLANFi/vz5Kikp0erVq3XnnXfqueee0/e//3299957yszMVFFRkd0lwiEc1eAGAgGtXbtWd911l0aOHKmvv/5aycnJpmuSk5NVX1/f4c/W1dWprq5O0tXg595CTFgQMWFmncWEhSoS7Nr4revxSw0AokVycrJ+85vfmNYGDhyokSNH2lQRnMoxDa5hGNqwYYMaGhpUXFwsj8ejxMRENTY2mq5rbGxUYmJihz9fVlam4uLicJULAADCrLGxUYZhKCUlxe5S4HCOaHANw1Bpaamqqqq0YsWK9gY2OztbW7ZsUSAQaH/Lt6qqShMmTOhwjyVLlmj69OmSrp7gFhYW9kqtxIQFERNm1llMWKgiwa6N3wKAaLV69Wo9/PDDeuihhzq8VlNTo7/97W9aunSpDZXBaRzR4JaVlenIkSNauXKlkpKS2tfvuecexcXFaevWrZoxY4Y+//xzVVdXa1wnOUuZmZntj+vrTcSEBRETZtZZTFjoIsGYswWAqqoq3Xfffaa1N954Q0VFRcrIyNA///lPmyqD09je4NbX1+vDDz9Unz59tHDhwvb1goICzZ49Wy+88IJKSkq0efNmpaen6/nnn1e/fv1srBgAANjB7/d3GFPcvn27ioqK1KdPHzU1NdlUGZzG9gY3PT1d27Ztu+Hrubm5WrNmTRgrAgAATjRgwABVVlZq+PDhkqSjR4/qypUrOn36tGJiYtS3b1+bK4RT2N7gRhpiwoKICTO7PiYsVBFhkcowJL/fI69XCuf2IFINcK8f/ehHWr16tX7yk5/I6/WqtbVVGRkZeumllxQIBDRlyhS7S4RD0OBaRExYEDFhZtfHhIUqIixyeWTHPzFEqgHuNXPmTMXHx+tf//qXMjIyNG/ePP34xz/Wnj17lJmZ2env6CA60eACAICI8cgjj+iRRx5p/zghIUEFBQU2VgQnosG1iJiwIGLCzK6PCQtVRFiksuuEn0g1AAANrkXEhAURE2Z2fUxYtL9TZhiSz2coNja8M7hEqgEA6NIAAADgKjS4AAAAcBVGFCwiJiyImDAzYsLMuhITRqQXAKA30OBaRExYEDFhZsSEXe/WMWFEegEAegPHkAAAAHAVTnAtIiYsiJgwM2LCzLpywk+kFwCgN9DgWkRMWBAxYWbEhJl1LSaMOVsAQOjRpQEAAMBVOMG1iBSFoGhPUYirqDAvBAKKa2iQUlMl9odkGPL4/bppjEKkiPbjeACIMDS4FpGiEBTtKQoD8/JMH8dIYqI06NYZChHEMOyuAABgAcdMAAAAcBXXHLCECykKQVGfonBdTEIgEFBDQ4NSU1PZH+KEHwBgHxpci0hRCIr6FIXr5zIDAbV8+610553M4EqSYcjw+XSLGAUAAEKO78IAAABwFRpcAAAAuAojChYRExbklpiwiorQPGwgEJAaGuJICfs/w5D8fk+vpoSNGdPSYS0ujodHAEC0o8G1iJiwILf8ElFe3sAQ3YmgMLPeDwqrrT3TYW3gwFD9fQIAIhXnTAAAAHAVTnAtIiYsyC0xYdelfXUbMWFm4TjhT0vjxBwA0BENrkXEhAW5JSYsVE9hDQSkb79tISXs/wxD8vmMXk4JY94WANAR34YBAADgKjS4AAAAcBVGFCwiJiyImDCznsSEjRnTQrwVAAAhQoNrETFhQcSEXa/7MWG1tWeItwIAIEQ4hgQAAICrcIJrETFhQcSEmfUkJoy4KwAAQocG1yJiwoKICTPrWUwY87cAAIQKXRoAAABchQYXAAAArsKIgkXEhAXZERMWqkiv3tCTmDA3GTOmRZJ5f8THx9tcFQAgmtDgWkRMWJAdMWGhi/TqDd2PCXOT2tozksz7Y9CgQTZXBQCIJlF8zgQAAAA34gTXImLCguyICQtVpFdv6ElMmJu0RZ5duz8AAAgnvvNYRExYkB0xYaGK9OoNPYsJc5Orc9LX7g8AAMIpqr8NAwAAwH1ocAEAAOAqvHdoETFhQV2JCXNyrFeoOSEmrC2iS5Li4qLnaw8AwLVocC0iJiyoKzFhzo71CjX7Y8LaIrokaeDAaPraAwAQxDEkAAAAXIUTXIuICQvqSkyYk2O9Qs0JMWFtEV0AAEQzGlyLiAkL6kpMmJNjvULNGTFhzN0CAECXBgAAAFehwQUAAICrMKJgETFhQW0zuJ9/HitCJW4eE9YW30V0FwAAvY8G1yJiwoLaYsLGj0+2uxSHuHFMWFt8F9FdAAD0Po4hAQAA4Cqc4FpETFhQ24jC3r0GJ9q6eUwY8V0AAIQPDa5FxIQFtcWEjRsnZnB1q5gwZm8BAAgXujQAAAC4Cg0uAAAAXIURBYvCHRNWUeHct7YNQ/L7PfJ6GVGQbhwT1hYRJhETBgBAONDgWhTumLC8PCfHSnnEFrpW5zFhbRFhEjFhAACEAyMKAAAAcBWO3ywKd0zYp5+G5dN0S9uDHrxeLzFhunFMGBFhAACElyMa3O3bt2v37t06fvy4HnjgAT333HPtr1VXV2vdunU6fvy4MjIytHjxYo0YMcK2WsMdEzZuXFg+TbcYhuTzGYqNZQZXullMGHO3AACEkyNGFFJTUzV79mzl5+eb1n0+n1asWKGxY8fqrbfe0pw5c7R69WqdP3/epkoBAADgdI44wX3wwQclSceOHdPFixfb1w8fPqwrV66ooKBAMTExGj9+vN5//33t27dPU6dOtaXW7qQoxFVU9GJFNjIMefx+EaPwf4GA4hoapNRUafx4u6sBACBqOaLBvZETJ04oNzfX1EwOHTpU1dXVHa6tq6tTXV2dJKmysrLXaupOisLAvLxeq8dOZCiYmTIUDMPGSgAAiG6O7k+ampqUnJxsWktOTlZ9fX2Ha8vKylRcXByu0gAAAOBQjm5wExMT1djYaFprbGxUYmJih2uXLFmi6dOnS7p6gltYWNgrNXUrRcHJUQg9QIqCmSlFwe5iAACIYo5ucLOzs7VlyxYFAoH2hrKqqkoTJkzocG1mZqYyMzN7vaZupSg4OQqhJwxDhs8nYhT+LxBQy7ffSnfeaXclAABENUccNPn9frW0tCgQCCgQCKilpUU+n0/33HOP4uLitHXrVrW2turTTz9VdXW1xrm1YQQAAECPOeIE9+2339bmzZvbP963b59++MMf6umnn9YLL7ygkpISbd68Wenp6Xr++efVr18/G6sFAACAkzmiwZ07d67mzp3b6Wu5ublas2ZNmCu6MasxYa6NCJOICbseMWEAADiCIxrcSGI1JsytEWESMWHXIyYMAABncMQMLgAAABAqHMBZZDkmzKURYRIxYdcjJgwAAGegwbXIckyYmxMfiAkzIyYMAABH4KAJAAAArkKDCwAAAFdhRMEiqzFhFRVxvVyRfQxD8vs9jk8JGzOm5YavxcW59+8HAIBoRYNrkdWYsLy8gb1ckZ0iIyistvbMDV8bONDNfz8AAEQnRhQAAADgKs4/fnMYqzFhLk4Ji5iYsLS0tFtfBAAAXIMG1yKrMWEuTwmTz2dEQEoYc7YAAEQTRhQAAADgKjS4AAAAcBVGFCyyEhPm5ogw6eqIwsiRLQoEAp3O4BLBBQAA7ECDa5GVmDB3R4RJkkfV1Wdv+EtmRHABAAA7MKIAAAAAV+EE1yIrMWFujgiTrsaEDRgwwNKDLwAAAHobDa5FVmLC3BwRJrXFhMXR4AIAAEdhRAEAAACuQoMLAAAAV2FEwaKuxoS5PSJMujqi4Pd75PX2zpPMxoxp6bBG9BgAALgVGlyLuhoT5v6IMEnyqDe3UG3tmQ5rRI8BAIBbYUQBAAAArsIJrkVdjQlze0SYdDUmzO/33/BBDz2VlpYW8nsCAAD3o8G1qKsxYW6PCJPaYsIMxcb2zgyuxLwtAACwjhEFAAAAuAoNLgAAAFyFEQWLwhUT1haRRSwWAACANTS4FoUrJqwtIotYLAAAAGsYUQAAAICrcIJrUbhiwojIAgAA6B4aXIvCFxPG7C0AAEB3MKIAAAAAV6HBBQAAgKswomBRV2LCehoRFikMQ/L7PfJ6e+tJZqHVFr12LWLYAABwHxpci7oSE9bTiLDI4VEkbaG26LVrEcMGAID7MKIAAAAAV4mc4zeH6EpMWE8jwiKFYRjy+/3yer23fPCFExC9BgBAdKDBtagrMWE9jwiLDIYh+XyGYmMjYwaX6DUAAKIDIwoAAABwFU5wLepKikJcRUUYK7KRYcjj9ytiYhR6WyCguIYGtUyZooSEBLurAQAgatHgWtSVFIWBeXlhrMg+kZWh0PtiJKVJqq2p0aBBg+wuBwCAqMWIAgAAAFyFAziLupKiEC0xCpGWotDbAoGAGhoaNGDAALtLAQAgqtHgWtSVFIVoilEwfD5FUIxC7woE1PLttzwdDQAAmzGiAAAAAFehwQUAAICrMKJg0a1iwioqouft6dGjbx6XBgAAYAcaXItuFROWlzcwzBXZp6bmjNLT0+0uAwAAwITjNwAAALgKJ7gW3SomLEoSwiRJaWlpdpcAAADQAQ2uRbeKCYuWhDBJMow4+Xw+u8sAAAAwYUQBAAAArkKDCwAAAFdhRMGim8WExVVU2FCRjQxDHr9f8nqj70lm0TSLAgBAhKHBtehmMWED8/JsqMg+HkXxBjIMuysAAAA3wIgCAAAAXCVqD+C666YxYdGUESbJMAz5/X55vd4bPvgCAAAg3GhwLbppTFi0zWUahgyfT4qNjb4ZXAAA4FgR0eBeunRJ69ev18GDB5WYmKiZM2dqxowZdpcFAAAAB4qIBresrEytra0qLy9XfX29li1bpqysLN177712lwYAAACHcfwvmTU3N2vfvn2aP3++kpKSlJubq/z8fO3atcvu0gAAAOBAjj/Bra2tlWEYysnJaV8bMmSI9u/fb7qurq5OdXV1kqTKysqw1ggAAADncHyD29zcrKSkJNNacnKympqaTGtlZWUqLi4OZ2kAAABwIMePKCQkJHRoZi9fvqzExETT2pIlS3TgwAEdOHBAb775ZjhLBAAAgIM4/gR30KBBkqQTJ04oOztbklRVVdX+320yMzOVmZkZ9voAAADgLBFxgjtu3Dht3LhRly9fVnV1tXbu3KnJkyfbXRoAAAAcyPEnuNLV8YOSkhItWLBAiYmJeuyxx4gIAwAAQKciosFNSUnRb3/7W7vLAAAAQARw/IgCAAAAYAUNLgAAAFyFBhcAAACuEhEzuFa15eaG+olmgUBAZ8+e1cmTJxUTw88GhmHI7/fL6/XK4/HYXY7t2B9m7A8z9ocZ+8OM/XHV6dOnVVdXp7Nnz/b4XpcuXQpBRYhUrmxwjx8/LkkqLCy0txAAANAtoci2j42N7fA0VEQHj2EYht1FhNqZM2e0Y8cO5ebmdnjiWU9UVlaqsLBQb775poYNGxay+8Id2B+4GfYHbob9EXTx4kVlZWWF5Pt3UlKS+vXrF4KqEGlceYKblpamefPm9dr9hw0bplGjRvXa/RHZ2B+4GfYHbob9AYRG9A76AAAAwJW8y5cvX253EZEkJSVFkyZNUt++fe0uBQ7E/sDNsD9wM+wPIHRcOYMLAACA6MWIAgAAAFyFBhcAAACuQoMLAAAAV3FlTFhvuHTpktavX6+DBw8qMTFRM2fO1IwZM+wuCzZpbW1VaWmpvvzyS128eFFpaWmaPXu2Jk6caHdpcJALFy7oF7/4hTIzM7VmzRq7y4GDfPbZZ9q0aZNOnTql2267TT//+c/14IMP2l0W4Bo0uF1UVlam1tZWlZeXq76+XsuWLVNWVpbuvfdeu0uDDfx+v1JTU7Vy5UplZGSosrJSL730kjIyMnT33XfbXR4cory8XIMHD5bP57O7FDjIl19+qddee03PPvus7r77bl24cEHNzc12lwW4Cg1uFzQ3N2vfvn16+eWXlZSUpNzcXOXn52vXrl00uFEqISHB9DCR4cOHa9iwYaqsrNTQoUO1YcMGVVRUyO/3Kz09Xc8++6yys7NtrBjh9tVXX+nkyZOaPHmy/v73v0uSWlpa2BvQpk2b9LOf/UzDhw+XpPYnbbE/gNChwe2C2tpaGYahnJyc9rUhQ4Zo//79NlYFJ2lubtbRo0c1bdo07d69W9XV1SorK1NycrJqamqUkpJid4kIo9bWVpWVlenXv/61jh071r7O3oDf79c333yjsWPH6oknnlBzc7NGjhypRYsWae/evewPIET4JbMuaG5uVlJSkmktOTlZTU1NNlUEJwkEAlq7dq3uuusujRw5UrGxsWpqalJNTY0Mw9DgwYPVv39/u8tEGG3ZskUjRozQkCFDTOvsDZw/f14+n0+ffPKJVq5cqZKSEp0/f16vvfYa+wMIIU5wuyAhIaFDM3v58mUlJibaVBGcwjAMbdiwQQ0NDSouLpbH49FDDz2khoYGrV+/Xg0NDXrggQe0cOHCDj8kwZ1Onjypjz76SK+88kqH19gbiI+PlyRNnTpVaWlpkqRZs2Zp1apVevLJJ9kfQIhwgtsFgwYNkiSdOHGifa2qqoq5qChnGIZKS0tVVVWl5cuXt//A4/V6NXv2bK1bt07r1q3Tf/7zH23dutXmahEulZWVOnfunJ544gkVFRXp1Vdf1bFjx1RUVKQrV66wN6JcSkqK0tLS5PF4OrzGvx1A6HCC2wUJCQkaN26cNm7cqGeeeUanT5/Wzp079dRTT9ldGmxUVlamI0eOaOXKlaYTlkOHDqlv377Kzs5WQkKC+vTpo5gYfpaMFnl5eRo1alT7x3v37tXHH3+sF198UUePHmVvQPn5+frggw80evRoxcfHa8uWLRo7diz/dgAhRIPbRUuWLFFJSYkWLFigxMREPfbYYyQoRLH6+np9+OGH6tOnjxYuXNi+XlBQoIyMDP3lL3/R2bNnFR8fr1GjRumnP/2pjdUinOLj49vfhpauzut7vV71799fhw4dYm9As2bN0oULF7R06VJ5vV6NHj1aixYtUkVFBfsDCBGPYRiG3UUAAAAAocJ7HwAAAHAVGlwAAAC4Cg0uAAAAtATdtwAABTZJREFUXIUGFwAAAK5CgwsAAABXocEFAACAq9DgAgAAwFVocAEAAOAqNLgAuuz8+fPyeDx6/fXXw/Y59+zZo1WrVnVYX758uVJSUsJWBwAgctDgAnC0GzW4ixYt0scff2xDRQAAp4u1uwAA0aepqUmJiYk9ukdWVpaysrJCVBEAwE04wQVwQ6+++qpyc3OVlJSkhx9+WEePHjW97vF4tGbNGtPa2rVr5fF42j/es2ePPB6PPvjgAxUUFOi2227TrFmzJElvvPGG8vLylJqaqv79+2vSpEn64osv2v/s8uXLVVxcrMbGRnk8Hnk8Hk2aNKn9tetHFKqrq1VQUKDbb79dycnJmjJlig4fPmy6Jjc3V08++aTWr1+vnJwc3X777Xr00Ud1+vTpHn+9AADOwAkugE5t375dixcv1oIFCzRnzhwdOHCgvTHtjsWLF6uwsFDvvvuuvF6vJOn48eMqKirSd77zHbW0tOitt97ShAkTdOjQIX3ve9/TokWLVFNTo02bNmn37t2SpNtuu63T+1+8eFGTJk1STEyMSktLlZCQoN///vft9xs8eHD7tdu2bdM333yj9evX68yZM3rmmWf0q1/9Sps3b+72/x8AwDlocAF0auXKlRo/frzKy8slSVOmTFFzc7NWrFjRrftNnz5df/jDH0xrL774Yvt/BwIBTZ48WV988YVef/11rVq1qn0MISYmRvfff/9N719eXq7q6mr9+9//1rBhwyRJEydOVHZ2ttauXas//vGP7dcahqFt27YpPj5e0tVGe9WqVQoEAoqJ4Y0tAIh0/EsOoAO/368DBw5o5syZpvWCgoJu33Pq1Kkd1iorKzVz5kxlZGTI6/WqT58+OnLkiL7++mvL99+7d69+8IMftDe3kpSamqrJkyfr008/NV07ceLE9uZWkoYPH67W1lbV19db/rwAAOfhBBdAB6dPn5bP51N6erppPSMjo9v3vP7PXrx4Ufn5+brjjjv0pz/9STk5OUpISNCiRYvU3Nxs+f7nzp3rtL6MjAx99dVXprV+/fqZPo6Li5Okbn1eAIDz0OAC6OCOO+5QbGxshxPNU6dOmT6Oj49XS0uLae3cuXOd3vPaXzyTpP3796umpkbbt2/XiBEj2tf/+9//disdITU1VUeOHOmwfurUKaWmplq+HwAgcjGiAKADr9erUaNG6d133zWt//WvfzV9nJWVpcrKStParl27uvQ5mpqaJAVPTyXps88+0/Hjx03XxcXF6cqVK7e8X15eng4fPmxqcs+dO6d//OMfysvL61JNAAB3oMEF0Knf/e532rt3rx5//HHt2LFDq1at0saNG03XFBQU6J133tGf//xn7dixQ/Pnz1dtbW2X7n///fcrJSVFS5cu1c6dO1VeXq45c+Zo0KBBpuuGDRsmn8+nV155RRUVFZ2e0krS448/rpycHE2dOlWbN2/We++9p/z8fMXGxurpp5/u3hcBABCRaHABdGr69OkqLS3VRx99pEcffVQ7d+7U22+/bbpm2bJlmjt3roqLi1VYWKicnBw99dRTXbp/RkaG3nnnHdXX12vGjBlau3atysrK9N3vftd03bRp0/TLX/5Sq1ev1n333aclS5Z0er++fftqz549GjFihBYvXqx58+apf//++uSTT0wRYQAA9/MYhmHYXQQAAAAQKpzgAgAAwFVocAEAAOAqNLgAAABwFRpcAAAAuAoNLgAAAFyFBhcAAACuQoMLAAAAV6HBBQAAgKvQ4AIAAMBVaHABAADgKjS4AAAAcJX/ARC2NHRo7QpqAAAAAElFTkSuQmCC\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": "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\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": "iVBORw0KGgoAAAANSUhEUgAAApEAAAGxCAYAAAA6b+1gAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl0VOXh//HPZAjZIIExIQQhCSLrF6TITwRZAiKL9SBVI/UgLUsxtYJ1peJaEBA3aJBFUCuoqCBIRWM1LmgRKoogFpW1QBANJDGQELKRmfn9QR2ICZgHZubOZN6vczwnc+fmuZ/AI/nMfe7MtbndbrcAAAAAA2FWBwAAAEDwoUQCAADAGCUSAAAAxiiRAAAAMEaJBAAAgDFKJAAAAIxRIgEAAGCMEgkAAABjlEgAAAAYo0QCAADAWL0skaWlpdq8ebNKS0utjgIAAFAvNbA6gC9s375d3bt3V0ZGhpKSkrw6dllZmaKiorw6ZrByOp2SJLvdbnGSwMH8OIn5URPz4yTmR03MjxOysrK8NtYXX3zhtbFQU708E+lLZWVlVkdAAGN+4EyYHzgT5geCDSUSAAAAxiiRAAAAMEaJBAAAgDFKJAAAAIxRIgEAAGCMEgkAAABjlEgAAAAYo0QCAADAGCUSAAAAxiiRAAAAMGb5vbOPHz+uhQsX6quvvtLRo0cVHx+vESNGKC0tTZKUk5OjuXPnat++fUpMTFRGRoa6du1qcWoAAIDQZvmZSKfTKYfDoenTp2vZsmWaMGGCnn76aW3fvl1VVVWaNm2aevTooVdffVU33HCDZs6cqSNHjlgdGwAAIKRZXiIjIyN14403qnnz5rLZbOrUqZM6duyobdu2aevWraqoqFB6errCw8PVt29fJScna/369VbHBgAACGmWL2f/XHl5uXbv3q1hw4Zp//79Sk1NVVjYya57wQUXKCcnx7J8NpvNsmMj8DE/vKs0oZHVEbyqMsKl0tj69TOdLZfTKUkKs9sVnV9icRoAZyOgSqTL5VJmZqbatm2rbt26aefOnYqJiam2T0xMjPLy8mp8b1FRkYqKiiRJubm5Pstot9t9NnawoTDVxPw4yRvzY/+Qjl5IEli4GKemDks3Wh0BwFkImBLpdru1YMECFRYWaurUqbLZbIqKitKxY8eq7Xfs2DFFRUXV+P61a9cqKytLklRQUOCXzAAAAKEqIEqk2+3WwoULtXfvXk2bNs1TEpOTk/X666/L5XJ5lrT37t2rfv361RijX79+nndtb926VatWrfJJVuf/lmBw4u8N1TE/TvLG/EjO3uaFJIGjuLhYsbGxVscICKcuZwMITgFRIhctWqQdO3Zo+vTpio6O9mzv0qWLGjZsqFWrVmn48OH67LPPlJOTo969e9cYIy4uTnFxcZJ8eyaS4oQzYX54V327Vq688IiiKyx/P2NA+OkFF5eAAMHL8hKZl5enf/7znwoPD9e4ceM829PT0zVixAg98MADmjdvnpYtW6ZmzZrp3nvvVZMmTSxMDAAAAMtLZLNmzfTmm2+e9vnU1FQ9+eSTfkwEAACAX8K6CgAAAIxRIgEAAGCMEgkAAABjlEgAAAAYo0QCAADAGCUSAAAAxiiRAAAAMEaJBAAAgDFKJAAAAIxRIgEAAGCMEgkAAABjlt87O9jYbDarIyCAMT9wJswP72qYUGp1BK+KjqhUw1j//kyV+dF+PR7qF0qkIbvdbnWEgMEvxJqYHycxP2pifpzkjfkRP2S/F5IEjnhJ0hG/HvOHpR38ejzULyxnAwAAwBhnIg05nU6rIwQMt9ttdYSAw/w4iflRE/PjJG/Mj4LsZC8kCRzFxcWKjY21OgZQZ5RIQ/xixJkwP3AmzA/vqm/X85UWliuyon79TKjfWM4GAACAMUokAAAAjFEiAQAAYIwSCQAAAGOUSAAAABijRAIAAMAYJRIAAADGKJEAAAAwRokEAACAMUokAAAAjFEiAQAAYIwSCQAAAGOUSAAAABhrYHWAYGOz2ayOgADG/MCZnDo/EtylFibxnXxbtNURAPgJJdKQ3W63OkLAoDDVxPw4iflR06nzY4j2W5jEd5aqQ532Y34AwY/lbAAAABjjTKQhp9NpdYSA4Xa7rY4QcJgfJzE/ajp1fmQr2cIk1mN+AMGPEmmIf/hwJswPnMmp84NrBwEEO5azAQAAYIwSCQAAAGOUSAAAABijRAIAAMAYJRIAAADGKJEAAAAwRokEAACAMUokAAAAjFEiAQAAYIwSCQAAAGOUSAAAABijRAIAAMBYA6sDBBubzWZ1BAQw5kfwSih1+PwYEZUNFFsa6/Pj5EcX+vwYAECJNGS3262OEDAoTDUxP04KtvkxZH9f/xzoiO8PsbTDat8fBEDIYzkbAAAAxjgTacjpdFodIWC43W6rIwQc5sdJwTY/spM/8fkxiouLFRvr++VsAPAHSqShYPvFCP9ifgQvf1xHWFheqIroKp8fBwD8geVsAAAAGKNEAgAAwBglEgAAAMYokQAAADBGiQQAAIAxSiQAAACMUSIBAABgjBIJAAAAY5RIAAAAGKNEAgAAwBglEgAAAMYokQAAADBGiQQAAICxBlYHCDY2m83qCAhgzI/gVlqR4NPxK50RKq2I9ekx/CU6It/qCAAsRok0ZLfbrY4QMChMNTE/TgrG+bG/YIjPj3GkwOeH8IsO5y+1OgIAi7GcDQAAAGOciTTkdDqtjhAw3G631RECDvPjpGCcH8nx2T4dv7i4WLGx9WM5GwAokYaC8Rcj/If5Edx8fZ1fub1Q0REVPj0GAPgLy9kAAAAwRokEAACAMUokAAAAjFEiAQAAYIwSCQAAAGOUSAAAABijRAIAAMAYJRIAAADGKJEAAAAwZvkda7KysrRmzRrt27dPvXr10qRJkzzPjR8/XkeOHFFY2Imum5CQoPnz51sVFQAAAP9jeYl0OBwaMWKEtmzZoqNHj9Z4/t5771X37t0tSAYAAIDTsbxEXnbZZZKkPXv21FoiAQAAEHgsL5G/JDMzU263W8nJyRo1apQ6depkdSQAAICQF9Al8s4771SbNm0kSR9++KGmTp2quXPnqlmzZpZlstlslh0b1ilNaFSn/SojXCqNrdu+9Z3L6ZQkhdntdf6e6PwSX8UBAHhZQJfIU886/vrXv9Ynn3yiTZs26corr6yxb1FRkYqKiiRJubm5PstkN/iFWN+FUqHeP6Rjnfc94sMc9V2HpRutjgAAqKOALpE/FxYWJrfbXetza9euVVZWliSpoKDAn7EAAABCjuUl0ul0yul0yuVyyeVyqbKyUmFhYTp8+LDy8vLUrl07SdKaNWu0a9cuTZw4sdZx+vXrp65du0qStm7dqlWrVvksL044XaGvj5Kzt9Vpv+LiYsXGxvo4TXA4m+VsAEDwsLxELl++XMuWLfM8Xr9+vS6//HJde+21euaZZ5Sbm6sGDRqoVatWevDBB5WUlFTrOHFxcYqLi5Pk2zORoVSccFJdr9UrLzyi6Ao+w186+YKLS0AAoH6yvESOHDlSI0eOrPW5OXPm+DkNAAAA6oJTJgAAADBGiQQAAIAxSiQAAACMUSIBAABgjBIJAAAAY5RIAAAAGKNEAgAAwBglEgAAwEvGjBmjzp07Wx3DLyiRAAAAMEaJBAAAgDFKJAAAgA/k5uZq3LhxuuCCCxQVFaW2bdvqvvvuU0VFRbX9bDabHn/8cU2ZMkWJiYmKj4/X2LFjdezYsWr7HThwQKNGjVJ8fLyioqLUr18/bdq0yZ8/UjWW3zs72NhsNqsjIIAxP86sYUKp1REsFR1RqYaxof1n8BOn0yVJstvDVJkfbXEawDcKCgrkcDg0e/ZsNW3aVDt37tSUKVOUm5urxYsXV9t33rx56tu3r1544QXt3LlTkyZNUmJioh599FFJ0uHDh9WnTx81atRIc+fOVVxcnObOnavLL79cu3btUrNmzfz+81EiDdntdqsjBAwKU03Mj5Nqmx/xQ/ZbkCRwxEuSjlicIvD8sLSD1REAn+jSpYuefPJJz+PevXsrJiZGo0eP1vz58xUdffIFVFJSkl5++WVJ0tChQ7V582atXLnSUyIzMzN15MgRff75557COHDgQLVr105PPvmkHn/8cT/+ZCewnA0AAOADbrdbmZmZ6tSpk6KiohQeHq4bb7xRVVVV2rNnT7V9Bw0aVO1xp06ddODAAc/j9957TwMGDJDD4VBVVZWqqqpkt9uVlpamjRs3+uXn+TnORBpyOp1WRwgYbrfb6ggBh/lxUm3zoyA72YIkgaO4uFixsbFWxwgIpy5nA/VVZmam7r77bv3lL3/RgAED1LRpU23cuFETJkxQeXl5tX2bNGlS7XHDhg2rXTtZUFCgDRs2KDw8vMZx2rRp45sf4BdQIg1RnHAmzI8zC/Vr30oLyxVZEdp/Bj/56QUXl4CgPluxYoWuvvpqzZw507Pt22+/PauxHA6Hhg4dqmnTptV4LiIi4qwzngtKJAAAgA+UlZWpYcOG1bb9dN2jqSuuuEJLly5Vx44dFRMT441454wSCQAA4AODBg3SnDlzNG/ePLVr105Lly7V7t27z2qsO++8Uy+//LLS0tJ02223KTk5Wfn5+frss8/UokUL3XHHHV5O/8sokQAAAD7w0EMPKT8/Xw899JAkKT09XU899ZSGDRtmPNZ5552nDRs26IEHHtA999yjH3/8Uc2aNVPPnj11zTXXeDt6ndjc9fAirs2bN6t79+7KyMhQUlKSV8cuLCyUw+Hw6pjBimuaamJ+nMT8qIn5cRLzoybmxwlZWVleG+uLL77w2lioibfFAQAAwBglEgAAAMYokQAAADDGG2sAAADO0cyZM7Vv3z6vj9urVy+NGTPG6+N6AyUSAADAC7z9Zt5Ax3I2AAAAjFEiAQAAYIwSCQAAAGOUSAAAABjjjTWGbDab1REQwOr7/Ehwl9Z5X6dckiS7O7Rfq+bboj1f1/f5AcB/jhw5ooyMDL3zzjtq3Lix/vKXv+j222/3awZKpCFu0XUSvxBrqu/zY4j2133n0O6OHkvVwfN1fZ8fAPxn4sSJqqio0Pfff6+cnBwNHDhQ7du315VXXum3DPwzDwAAEESOHTumFStWaMaMGYqNjVWXLl1000036fnnn/drDs5EGnI6nVZHCBhut9vqCAGnvs+PbCXXeV+n63/L2WG8Vv1JfZ8fgD/Y7XZ16dJFCQkJys/P19atWwPi/60DBd30Y/GFXh83NXVdjW07d+6Uy+VS586dPdt+9atfadWqVV4//plQIg1RnHAm9X1+nHp93y9x6sQ/6nYbS7g/qe/zA/C1Cy+8ULNmzVJERITy8/OVkJCg8vJy3X333dq9e7fV8fympKREcXFx1bY1adJER48e9WsOSiQAAAgKDz74oF5//XW9+OKLnm2jR4/Wgw8+qNGjR1uYzL8aNWqk4uLiatuKiorUuHFjv+ZgnQkAAASFlJQUvfzyy9W2vfTSS0pJSbEokTXatWsnm82mb775xrNty5Yt1Za3/YEzkQAAIChs3rxZ3bt31+eff+7Zdskll2jz5s0WpjqhZfyXSmi8wQcjp9bYEhMTo/T0dN1///166aWXlJOTo+eee06LFy/2wfFPjxIJAAAC1oQJEzxf5+XladasWfr000918OBBNW/eXL169dI///lPCxNaY/78+brpppuUlJSkxo0ba/LkyX79eB+JEgkAAALYeeedV+3x+++/L+nEdYElJSV6//33FR4ebkU0SzVp0kQrVqywNAMlEgAABKyHH37Y6gg4DUokAAAICs2bNz/tcwcPHpQkJSYm6tChQ/6KFNIokQAAICisXr1aNputxmeu2mw29ejRQ5K0fPly9e/f34J0oYcSCQAAgkLv3r1/cZ+BAwf6IQkkSiQAAAgSVVVVkk4sWcfHx6ugoKDG0nUg3AIxVFAiAQBAUEhMTNSMGTPUuXNnlZSUqFGjRvr66691//33W34dZFxcnGw2m9fHjY2N9fqY3kKJBAAAQWHKlCnavn27br31VpWVlSkqKkoTJ07UQw89VO3zJK1wyy23WHp8K3DbQwAAEBQ6duyozMxMlZWVSZLKyso0e/Zs/d///Z/FyUITZyIN+eJUNeoP5kftEkodfjtWfnSh344FwL927dqlNm3aaMeOHZ5tF154oXbt2mVhqtBFiTRkt9utjhAwKEw1MT9OOnV+DNnf12/HXdphtd+OBcC/vvzyS82ZM0fvvvuuDh48qKSkJA0dOlSrV6/Wtdde69lv1apVfs82c+ZM7du3z+vj9urVS2PGjPH6uN5AiQQAAEGhS5cu2rt3r9q3b6/27dtLkvbs2aMuXbqoS5cukk68gLWiREpSUlKSJce1CiXSEB8dcNLPP+wVzI9TnTo/spM/sTAJgPriT3/6k9URcApKpCGKE86E+VE7rlMEgPqHd2cDAICgMGfOnBrbZs+ebUESSJRIAAAQJDZv3lxj25YtWyxIYr158+bp//2//6eIiAjdcMMNlmSo03J269atjd6Ju2fPnrMOBAAAUJsXXnihxrYXX3zRgiTWa9GihR544AF98MEHKigosCRDnUrk8OHDq5XIlStXqri4WFdccYUSExN16NAhffDBB4qLi1N6errPwgIAAECejzTasmVLYJfIzMxMz9dPPPGEWrVqpXfffbfa/RyLiop05ZVXKjEx0fspAQAAEFCM35391FNPacGCBTVuCB4XF6fJkyfrlltu0T333OO1gAAAAIGu24GOuvDHFK+Puy71K6+P6S3Gb6wpLCxUUVFRrc8VFRXp8OHD5xwKAAAAgc24RA4cOFD33HOP/vWvf1Xb/vHHH2vy5MkaOHCg18IBAAD8JDU1lcvmAohxiVy0aJFatGihyy+/XA6HQ+3bt5fD4dDAgQOVlJSkhQsX+iInAAAIcTNmzFDz5s09jy+66CKtXr3a89+bb75pYTr/qqqqUnl5uaqqquRyuVReXq7jx4/7NYPxNZFJSUnauHGj3n33XX3++efKzc1VUlKSevTooaFDh/oiIwAAgM4//3x9/fXXnsfbtm1TRESE/vrXv0qSZs2aZVU0fdlymzYkeP8zK1OVWuv26dOna+rUqZ7HK1as0OjRo7VkyRKvZzids77t4dChQymNAADAb6qqqmpss9ls+uyzz077fH01ZcoUTZkyxdIMdSqRhYWFatKkicLCwlRY+Mv3wHU4HOccDAAA4FR79uzRsGHD9MYbb0iSrr766mo3ODG5MQrOXZ1KZEJCgj799FP16NFD8fHxv/iX5HQ6vRIuEDFBcSbMj9MrrUjw6/GiI/L9ejwAvrdgwQJlZmZqyJAhCgsLU/v27fXnP//Z83xubq6F6UJPnUrk888/rzZt2ni+DuVflHa73eoIASOU58HpMD9O+vn82F8wxK/H73D+Ur8eD4DvbdmyRSNHjlTPnj3ldrv10EMP6dChQ57nrbqHdKiqU4kcPXq05+sxY8b4KgsAAMAZ/fDDD1q1apXVMaBzeGNNqKrPS/Wm3G631RECDvPjpJ/Pj+T4bIuSAAgFP60E8e+w/1AiDVGccCbMj9PjGkUA52r16tW67rrran0Xdnp6urp166bJkydbkCw0USIBAEBQaN68ucLCar9Pyvbt2zVy5Eg/JzqpXbt2ioiI8Pq4jRo18vqY3kKJBAAAQWPlypW1rvqEhYVZekvE6667zrJjW4USCQAAgsbjjz/u99v7oXZnXSJ37txZ7baHl1xyidq3b+/NbAAAANV89tlnAVkily9fru3bt3t93D59+mjgwIFeH9cbjEtkSUmJMjIy9Nprr8nlcikyMlLl5eUKCwvT9ddfr2effTag1+8BAEBwuvnmmwOyQEon7qbjizdXfvfdd14f01tqvzr1DG699VZlZWXp2WefVVFRkUpLS1VUVKRnnnlGb7/9tm699VZf5AQAACHuyy+/tDoCTmF8JvL111/XY489prFjx3q2NW7cWOPGjVN5ebnuvfdeLV682KshAQAAGjZsqPHjx2vw4MGKj49XQUGB3nvvPT377LMBe4ayPjMukZGRkWrdunWtz11wwQUKDw8/51AAAAA/d8899yg1NVVPPPGEDh48qObNm+sPf/iDHA6Hpk+fbnW8kGO8nD127Fg9/fTTNdb93W63FixYUO0MJQAAgLf0799fd955p9avX6///ve/Wr9+ve644w7179/f6mghqU5nImfPnu35+rzzztOmTZvUtm1bDRs2TM2aNVNeXp7eeustVVRUqG/fvj4LCwAAQteRI0dks9lqbC8qKrIgjXUqKio0YcIEffjhhyooKFBycrLuv/9+v3/Yep1K5N13313r9jlz5tTYNnnyZE2aNMkoRFZWltasWaN9+/apV69e1b4/JydHc+fO1b59+5SYmKiMjAx17drVaHwAABD8Xn31VT355JN68cUXPR8xOHr0aC1btkwpKSme/XJycixM6XtVVVVq0aKFPvzwQ7Vu3Vrr16/XVVddpdatW6tXr15+y1GnEulyuXwawuFwaMSIEdqyZYuOHj3q2V5VVaVp06Zp8ODBmjlzpjZs2KCZM2dq4cKFatKkiU8zAQCAwPLTSaYnnnii2vbOnTt7vrbZbOrRo4dfc/lbTEyMHn74Yc/jPn36qHfv3vr3v/8deCXS1y677DJJJz5j6dQSuXXrVlVUVCg9PV1hYWHq27ev3nrrLU/jBgAAoePSSy+1OsJpdTt+QBe6f/T6uOuU+ov7HDt2TF988YVuu+02rx//TM6qRB47dkxLlizRunXrVFhYKIfDob59+2r06NGKiYnxWrj9+/crNTW12s3WL7jgAktPU9d2LUYgKk3w/Qe+u5xOSVKY3e7zY/lLdH6J1REAAL/A4XCoefPmys3N1eHDh62OYymXy6UxY8bokksu0eDBg/16bOMS+d1336l///7at2+funbtqsTERO3YsUMrVqzQ7Nmz9dFHH6lVq1ZeCVdWVlajlMbExCgvL6/GvkVFRZ4La3Nzc71y/NrYg6Qw7R/S0eoIQanD0o1WRwAAnEZUVJSmTp2q3r17q0GDBnK5XPrkk080ZcoUlZaWWh3P79xut26++Wb98MMPys7O9vuJLuOP+LnzzjslSd9++602b96sd955R5s3b9Y333wjm82mu+66y2vhoqKidOzYsWrbjh07pqioqBr7rl27VjNmzNCMGTP0/PPPey0DAAAIDLfccot+/PFH9e3bVyUlJRowYICOHj3q92XcQOB2uzVhwgRt2bJF77zzjiW3nDY+E/n+++9r0aJFat++fbXt7du317Rp03TzzTd7LVxycrJef/11uVwuz5L23r171a9fvxr79uvXz/Ou7a1bt2rVqlVey3Eq5/+WcANdcvY2nx+jPi5nAwACV1pamkaOHOl5w295ebmeeOIJrVy50uJk0pfhLbXBleD1cVNPs33ixInasGGDPvzwQ8XGxnr9uHVhXCKrqqpqPRMonThzeDYly+l0yul0yuVyyeVyqbKyUmFhYerSpYsaNmyoVatWafjw4frss8+Uk5Oj3r171xgjLi5OcXFxkqSCggLjDHXli5ur+4I/ru376e86WJb4AQDBrXHjxiopqf77zW63h9zvoZycHC1YsEARERHVLiG87777dN999/kth3GJ7N27t6ZPn660tDRPaZNOXJM4Y8aMWgveL1m+fLmWLVvmebx+/Xpdfvnluv322/XAAw9o3rx5WrZsmZo1a6Z7772Xj/cBACAE5eXlKTExUYcOHVJYWJi6du2qcePGac2aNVZH86uUlJSAOKllXCJnzZqlfv36qVWrVrr88suVmJiovLw8ffjhhwoPDz+r6xFHjhx52k9ZT01N1ZNPPmk8JgAAqF9ef/11tW7dWocOHZLNZtPUqVP17rvv6rnnnrM6WkgyLpGdO3fWV199pb/97W9at26dvvnmGzkcDt10002644471LJlS1/kBAAAIe61117zfM39sq13Vp8T2apVq2r30wYAALDST9dFBssbYOuDOpXIiy66SK+88oo6d+6sLl26nPFziGw2mxwOh3r06KF77rlHDofDa2EBAEDoWr16ta677jpVVVXVeC49PV3dunXT5MmTLUgWmupUIrt37+750O/u3bv/4odZHj16VH//+9+1Y8cOvfHGG+eeEgAAhLzmzZtXu4vdqbZv337a91fAN+pUIhcvXuz5esmSJXUaePXq1frd7353VqEAAABqs3LlylrfmRwWFqbExEQLEoWus7omsi7S0tL00ksv+Wp4AAAQgh5//HEdP37c6hg19O/fXzk5OV4f96KLLvL6mN7isxLZpEkTDR8+3FfDAwCAEPTZZ58FZIns1auXevXqZXUMvzK+dzYAAIAVbr755oAskKHKZ2ciAQAAvOnLL7+0OsJpzZ07Vzt37vT6uH379tWIESO8Pq43UCIBAEBQaN68uQ4ePFjrc8nJyWrQoIH27Nnj51QnlJSU6LzzzvP6uKWlpV4f01tYzgYAAEHhzTffVHh4eK3Pde3aVbfffrufE4U2zkQa+qXPyET90zCh7q8CoyMq1TA2cF81+pPT6VJlfpTVMQDUI263Wy1atFBFRUWN5woLC9WxY0cLUoUuSqShn26rhNAp1PFD9td9X0nSEV9FCToHXmxndQQA9cyKFStq/ZxIKXR+LwUKSiQAAAgKNptNAwYMqPVMJPyPEmmIG7ufdLpXgvVNQXZynfctLi5WbGysD9MED6fTFTJzBIB/uN1uVVZW1nrv7FCTkZGht99+W0ePHpXD4VBGRobuu+8+v2agRBril2LoqcyPrvO+pYXliqyo+/71GS+4AHjbpZdeanWEgHH77bdrzpw5ioqK0nfffachQ4bowgsv9OvHAVEiAQAAgkynTp2qPQ4LC9Pu3bv9moESCQAAgsavf/1rDR8+XG3btlVkZKQOHTqkrVu36u9//7tP7l1dVzHdDui8C3/0/sDrUk/71L333qunnnpKpaWlSk1N1ahRo7x//DPgcyIBAEBQGDt2rP74xz9q06ZNWrZsmQoKCvTOO+/ohx9+0DPPPKOLL77Y6oh+NXPmTJWUlOjzzz/XyJEj1bRpU78enxIJAACCwm9/+1vdcssteuaZZ/R3JG1fAAAULUlEQVTMM89o4sSJSktL08KFCzV16lT9+c9/tjqi39lsNl1yySWKjIzUX//6V78emxIJAACCQoMGDZSXl+d5fPDgQc+tBjds2KDWrVtbFc1yVVVV+u9//+vXY3JNJAAACAqbN2/WpEmT9Oyzz8rtduvmm2/WV199JUmKjIzUsWPHLMt27MuWKtyQ4PVxU1Nrbjt8+LCysrI0fPhwNWrUSJ9++qmefvppPfjgg14//plwJhIAAASFxx57TC1atNBbb72lrKwsnX/++XriiSckSQkJCXr++ectTugfNptNixcvVkpKiuLi4vSHP/xBd911lyZOnOjXHJyJBAAAQeHHH3/UxIkTFRERIUnV7lyTk5Nj6buz/alJkyZas2aN1TE4EwkAAIJHRESEfv/736tjx45WRwl5nIkEAABBIzo6WjfeeKPS0tK0Y8cOPfXUUyoqKrI6VkjiTCQAAAgq5eXlGjVqlHbs2KHFixfrqquusjpSSKJEAgCAoPTaa69p/Pjx6tmzpxYsWKCUlBSrI4UUlrMN2Ww2qyOEvAR3qdURTivCXqnYAM4nSfm2aKsjAMBZuemmmxQVFaWoqCjddNNNnu05OTlq1qyZXn75ZfXp08fChKGFEmnIbrdbHSFgWFWoh2i/Jcetk1hJOmJ1ijNaqg5WRwCAs5KSkqKGDRvKbrfXOOuYn5+vjz/+2JpgIYoSCQAAgsIDDzyguLg4Pffcc3rggQesjlPNmDFjfPIGn4QE73+AubdQIg05nU6rIwQMt9ttyXGzlWzJceuiuLhYsbGxVscAgHqrqKhI119/vdUxakhKSlJSUpLVMfyKEmnIquKEkwL5mr5CZ7kqAjgfAADeQokEAAA4RzNnztS+ffu8Pm6vXr00ZswYr4/rDZRIAAAALwi15Ww+JxIAAADGKJEAAAAwRokEAACAMUokAAAAjFEiAQAAglRBQYHi4+PVs2dPvx+bEgkAABCkJk2apE6dOllybEokAABAEPrXv/6lXbt2aezYsZYcn8+JBAAAOEcHurXQjxfGe33c1HX5tW6vrKzUxIkTtXTpUn355ZdeP25dcCYSAAAgyDz66KO64oor1LVrV8sycCYSAAAgiOzevVtLlizRli1bLM1BiQQAAAgi69at08GDB9WuXTtJUllZmcrKytS8eXPt3LlTsbGxfslBiTRks9msjlBvJJQ6rI7gdRGVDRRb6p//ef0tP7rQ6ggAELBafvmDEjbs9f7Aqak1Nv32t7/V0KFDPY+XL1+uF198UW+//bYaN27s/QynQYk0ZLfbrY4QMM61UA/Z39dLSQLMEasD+MbSDquN9ucFFwD4RlRUlKKiojyP4+LiFB4erubNm/s1B2+sAQAACGJjxozRhg0b/H5czkQacjqdVkcIGG63+5y+Pzv5Ey8lCRzFxcV+uxYl0J3r/AAABDZKpCF+MXpPfbzGrrC8UBXRVVbHAADA51jOBgAAgDFKJAAAAIxRIgEAAGCMayIBAADOUcOGDRUW5v1zc+Hh4V4f01sokQAAAOforrvusjqC37GcDQAAAGOUSAAAABijRAIAAMAYJRIAAADGKJEAAAAwRokEAACAMUokAAAAjFEiAQAAYIwPGzdks9msjgA/Kq1IMNq/0hmh0opYH6UJfNER+VZHAAD4CSXSkN1utzpCwAiFQr2/YIjx9xwp8EGQINHh/KWer0NhfgBAKGM5GwAAAMY4E2nI6XRaHSFguN1uqyP4XHJ8ttH+xcXFio0N3eXsU4XC/ACAUEaJNMQvxtBieo1fub1Q0REVPkoDAEDgYDkbAAAAxiiRAAAAMEaJBAAAgDFKJAAAAIxRIgEAAGCMEgkAAABjlEgAAAAYo0QCAADAGCUSAAAAxgL+jjWZmZlau3atGjQ4GXX+/PlKSEiwMBUAAEBoC/gSKUnDhw/X6NGjrY4BAACA/2E5GwAAAMaC4kxkdna2srOzFR8fr2HDhmnQoEGWZbHZbF4bqzShkdH+0fklXjs2AADAuQj4Ejls2DCNGzdOMTEx+uabb/TYY48pJiZGl112WbX9ioqKVFRUJEnKzc31WR673e61sfYP6Wi0f4elG712bAAAgHMR8CWyTZs2nq8vuugiXXXVVVq/fn2NErl27VplZWVJkgoKCvyaEQAAINQEfIn8OZvNJrfbXWN7v3791LVrV0nS1q1btWrVKp8c3+l0em2s5OxtXhsLAADAnwK+RK5bt04XX3yxIiMjtX37dr399tvKyMiosV9cXJzi4uIk+fZMZG0F9mxxjSMAAAhWAV8is7KyNH/+fLlcLsXHx2vUqFHq16+f1bEAAABCWsCXyEcffdTqCAAAAPgZPicSAAAAxiiRAAAAMEaJBAAAgDFKJAAAAIxRIgEAAGCMEgkAAABjlEgAAAAYo0QCAADAGCUSAAAAxiiRAAAAMEaJBAAAgLGAv3d2oLHZbF4Zp2FCqVfGsZLT6ZIk2e3187VIZX601REAAAhYlEhDdrvdK+PED9nvlXHgOz8s7WB1BAAAAlb9PIUEAAAAn+JMpCGn0+mVcQqyk70yjpXq+3I2AAA4PUqkIbfb7ZVx6sP1dj8Vam8t8QMAgODBKSQAAAAYo0QCAADAGCUSAAAAxiiRAAAAMEaJBAAAgDFKJAAAAIxRIgEAAGCMEgkAAABjlEgAAAAYo0QCAADAGCUSAAAAxiiRAAAAMEaJBAAAgLEGVgcINjab7ZzHSHCXeiGJ9ZxySZLs7nN7LZJvi/ZGHAAA4EeUSEN2u/2cxxii/V5IEgC8dB57qTp4ZyAAAOA3LGcDAADAGGciDTmdznMeI1vJXkhiPafrf8vZYbwWAQAg1FAiDbnd7nMeo75cA+jUiUJtt537Ej8AAAgunEICAACAMUokAAAAjFEiAQAAYIwSCQAAAGOUSAAAABijRAIAAMAYJRIAAADGKJEAAAAwRokEAACAMUokAAAAjFEiAQAAYIwSCQAAAGOUSAAAABhrYHWAYGOz2c7p+xNKHV5KYj2nyylJsofZPdvyowutigMAAPyIEmnIbrf/8k5nMGR/Xy8lCUxLO6y2OgIAAPADlrMBAABgjDORhpxO5zl9f3byJ15KYr3alrMBAEBooEQacrvd5/T99emawZ8K9bku8QMAgODDcjYAAACMUSIBAABgjBIJAAAAY5RIAAAAGKNEAgAAwBglEgAAAMYokQAAADBGiQQAAIAxSiQAAACMUSIBAABgjBIJAAAAY5RIAAAAGGtgdYBgY7PZzvp7SysSvJjEei6XU5IUFma3OImZ6Ih8qyMAABD0KJGG7PazL0z7C4Z4MQnOVofzl1odAQCAoMdyNgAAAIxxJtKQ0+k86+9Njs/2YhLrBetyNgAAOHeUSENut/usv7e+XYv3U6E+lyV+AAAQnFjOBgAAgDFKJAAAAIxRIgEAAGCMEgkAAABjlEgAAAAYo0QCAADAGCUSAAAAxiiRAAAAMEaJBAAAgDFKJAAAAIxRIgEAAGCMEgkAAABjlEgAAAAYa2B1AF8oKyuTJBUUFHh97KKiIlVUVHh93GDkdDolSXa73eIkgYP5cRLzoybmx0nMj5qYHyeUlpYqMjJSYWGc5wp09bJE7tu3T5K0atUqa4MAAABjmzZt0sUXX2x1DPwCm9vtdlsdwtsKCgqUnZ2t1NRURUVFeW3c3NxcPf/88xo3bpySkpK8Ni7qB+YHzoT5gTNhflTXoUMHRUdHWx0Dv6BenomMj4/XjTfe6PVx9+/fr/j4eHXp0kXJycleHx/BjfmBM2F+4EyYHwhGXHAAAAAAY/YpU6ZMsTpEMImIiFD79u0VGRlpdRQEIOYHzoT5gTNhfiDY1MtrIgEAAOBbLGcDAADAGCUSAAAAxurlu7N9oaSkRPPnz9fmzZsVFRWla665RsOHD7c6FiySlZWlNWvWaN++ferVq5cmTZpkdSQEkOPHj2vhwoX66quvdPToUcXHx2vEiBFKS0uzOhoCxLx58/TFF1+orKxMjRs31uDBgzVixAirYwFGKJF1tGjRIh0/flyLFy9WXl6eHnzwQbVs2VLdu3e3Ohos4HA4NGLECG3ZskVHjx61Og4CjNPplMPh0PTp05WYmKht27bp4YcfVmJiojp06GB1PASAq6++WjfddJMiIiKUn5+vKVOmqEWLFurTp4/V0YA6o0TWQXl5udavX6+//e1vio6OVmpqqgYPHqz333+fEhmiLrvsMknSnj17qpXIyspKLViwQBs3bpTT6VSzZs10991387lvISYyMrLaZ9V26tRJHTt21LZt23TBBRcwR1Dj79tms+mHH37g3xAEFUpkHXz//fdyu91KSUnxbGvdurU+/fRTC1MhEK1Zs0Y5OTlatGiRYmJidODAATVq1MjqWLBYeXm5du/erWHDhjFH4PHCCy8oKytLFRUVatasmQYMGMD8QFDhjTV1UF5eXuP2SzExMSorK7MoEQJVgwYNVFZWpgMHDsjtdqtVq1Zq2rSp1bFgIZfLpczMTLVt21bdunVjjsBj9OjReu211zRr1iylpaUpJiaG+YGgwpnIOoiMjKxRGEtLS716X27UDwMGDFBhYaHmz5+vwsJC9erVS+PGjeMesCHK7XZrwYIFKiws1NSpU2Wz2ZgjqMZms6lt27batGmTXn31VY0ZM4b5gaDBmcg6OP/88yWduLfpT/bu3cs1KqjBbrdrxIgRmjt3rubOnavvvvtOq1atsjoWLOB2u7Vw4ULt3btXU6ZM8bzoZI6gNi6XS7m5ucwPBBVKZB1ERkaqd+/eeumll1RaWqqcnBy99957GjRokNXRYBGn06nKykq5XC65XC5VVlaqqqpK//nPf7R37145nU5FRkYqPDxcYWH8bxaKFi1apB07dmjq1KnVziIxR1BSUqKPPvpIpaWlcrlc+vbbb/XOO+/oV7/6FfMDQYXbHtZRSUmJ5s2b5/mcyGuvvZbPiQxhr7zyipYtW1Zt2+WXX65u3bpp2bJl+vHHHxUREaGLL75Yf/rTn7gXbojJy8vT+PHjFR4eLrvd7tmenp6uxMRE5kiIKykp0cyZM7Vnzx65XC45HA5dccUVuvbaa7V27VrmB4IGJRIAAADGOEcOAAAAY5RIAAAAGKNEAgAAwBglEgAAAMYokQAAADBGiQQAAIAxSiQAAACMUSIBAABgjBIJoM6OHDkim82mJUuW+O2YH3/8sR555JEa26dMmaJGjRr5LQcAoDpKJICAdroSOX78eH300UcWJAIASFIDqwMACD1lZWWKioo6pzFatmypli1beikRAMAUZyIBnNazzz6r1NRURUdHa+DAgdq9e3e15202m5588slq2zIzM2Wz2TyPP/74Y9lsNr399ttKT09XbGysrr/+eknSiy++qD59+sjhcKhp06bq37+/Pv/8c8/3TpkyRVOnTtWxY8dks9lks9nUv39/z3M/X87OyclRenq64uLiFBMToyFDhmjr1q3V9klNTdXEiRM1f/58paSkKC4uTr/5zW+Un59/zn9eABBKOBMJoFZZWVnKyMjQmDFjdMMNN2jTpk2e8nc2MjIyNGrUKP3jH/+Q3W6XJO3bt0+///3v1aZNG1VWVurVV19Vv3799J///Eft2rXT+PHjdeDAAb3yyitas2aNJCk2NrbW8Y8ePar+/fsrLCxMCxcuVGRkpGbMmOEZr1WrVp5933zzTe3atUvz589XQUGB7rjjDt16661atmzZWf98ABBqKJEAajV9+nT17dtXixcvliQNGTJE5eXlmjZt2lmNd/XVV+uxxx6rtu2hhx7yfO1yuTRo0CB9/vnnWrJkiR555BHPknVYWJh69ux5xvEXL16snJwcffPNN+rYsaMkKS0tTcnJycrMzNSsWbM8+7rdbr355puKiIiQdKLMPvLII3K5XAoLY4EGAOqCfy0B1OB0OrVp0yZdc8011banp6ef9ZhXXXVVjW3btm3TNddco8TERNntdoWHh2vHjh3auXOn8fiffPKJOnfu7CmQkuRwODRo0CCtW7eu2r5paWmeAilJnTp10vHjx5WXl2d8XAAIVZyJBFBDfn6+qqqq1KxZs2rbExMTz3rMn3/v0aNHNXjwYCUkJGj27NlKSUlRZGSkxo8fr/LycuPxDx8+XGu+xMREff3119W2NWnSpNrjhg0bStJZHRcAQhUlEkANCQkJatCgQY0zc4cOHar2OCIiQpWVldW2HT58uNYxT32zjSR9+umnOnDggLKystS1a1fP9qKiorN617XD4dCOHTtqbD906JAcDofxeACAM2M5G0ANdrtdF198sf7xj39U275y5cpqj1u2bKlt27ZV2/b+++/X6RhlZWWSTp4FlKR///vf2rdvX7X9GjZsqIqKil8cr0+fPtq6dWu1Inn48GF98MEH6tOnT50yAQDqjhIJoFb333+/PvnkE40dO1bZ2dl65JFH9NJLL1XbJz09XStWrNBTTz2l7Oxs/e53v9P3339fp/F79uypRo0aacKECXrvvfe0ePFi3XDDDTr//POr7dexY0dVVVVpzpw52rhxY61nGyVp7NixSklJ0VVXXaVly5bpjTfe0ODBg9WgQQPdfvvtZ/eHAAA4LUokgFpdffXVWrhwoT788EP95je/0Xvvvafly5dX2+fBBx/UyJEjNXXqVI0aNUopKSm67bbb6jR+YmKiVqxYoby8PA0fPlyZmZlatGiRLrzwwmr7DRs2TLfccotmzpypSy+9VH/84x9rHa9x48b6+OOP1bVrV2VkZOjGG29U06ZNtXbt2mof7wMA8A6b2+12Wx0CAAAAwYUzkQAAADBGiQQAAIAxSiQAAACMUSIBAABgjBIJAAAAY5RIAAAAGKNEAgAAwBglEgAAAMYokQAAADBGiQQAAIAxSiQAAACMUSIBAABg7P8DKe+UUm0S18wAAAAASUVORK5CYII=\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 0000000..ee61425 Binary files /dev/null and b/docs/imgs/lane_error.png differ diff --git a/docs/imgs/lanes2.png b/docs/imgs/lanes2.png index 10f71f1..134f2ba 100644 Binary files a/docs/imgs/lanes2.png and b/docs/imgs/lanes2.png differ diff --git a/docs/imgs/quickstart.png b/docs/imgs/quickstart.png index 3d46aa0..bd4a485 100644 Binary files a/docs/imgs/quickstart.png and b/docs/imgs/quickstart.png differ diff --git a/docs/imgs/submit.png b/docs/imgs/submit.png index 8c06609..edb6cab 100644 Binary files a/docs/imgs/submit.png and b/docs/imgs/submit.png differ 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):