From b903fbc888974fc6118b228efa3b28189899764d Mon Sep 17 00:00:00 2001 From: scaleoutSean Date: Sat, 27 Apr 2024 15:33:32 +0800 Subject: [PATCH] Migrate repo to sfc --- .gitignore | 167 ++ CHANGELOG.md | 97 + CODE_OF_CONDUCT.md | 6 + LICENSE | 202 ++ README.md | 161 ++ docs/FAQ.md | 288 +++ grafana/Dockerfile | 17 + .../h-series-compute-h410c-ipmi.json | 668 ++++++ .../h-series-compute-h615c-ipmi.json | 900 ++++++++ grafana/dashboards/solidfire-cluster.json | 1910 +++++++++++++++++ grafana/dashboards/solidfire-histograms.json | 662 ++++++ .../dashboards/solidfire-multicluster.json | 712 ++++++ grafana/dashboards/solidfire-node.json | 830 +++++++ .../solidfire-storage-optimization.json | 1135 ++++++++++ grafana/dashboards/solidfire-volume-topn.json | 840 ++++++++ grafana/dashboards/solidfire-volume.json | 1017 +++++++++ grafana/dashboards/vsphere-esxi-metrics.json | 858 ++++++++ grafana/dashboards/vsphere-vm-stats.json | 987 +++++++++ .../provisioning/dashboards/dashboards.yml | 11 + .../provisioning/datasources/datasource.yml | 11 + graphite/Dockerfile | 35 + graphite/carbon.conf | 161 ++ graphite/graphite-api.yaml | 17 + graphite/statsd_config.js | 8 + graphite/storage-aggregation.conf | 17 + graphite/storage-schemas.conf | 43 + ...ries-compute-hardware-monitoring-h410c.png | Bin 0 -> 164871 bytes ...ries-compute-hardware-monitoring-h615c.png | Bin 0 -> 215257 bytes images/dashboard-solidfire-cluster.png | Bin 0 -> 156810 bytes ...-solidfire-volume-min-to-max-histogram.png | Bin 0 -> 96371 bytes images/hcicollector_architecture_overview.jpg | Bin 0 -> 79025 bytes install_hcicollector.sh | 328 +++ .../hci-compute-ipmi-collectd.md | 106 + sfcollector/Dockerfile | 18 + sfcollector/README.md | 23 + sfcollector/graphite-sfc.yml | 66 + sfcollector/solidfire_graphite_collector.py | 478 +++++ vmwcollector/Dockerfile | 5 + 38 files changed, 12784 insertions(+) create mode 100644 .gitignore create mode 100644 CHANGELOG.md create mode 100644 CODE_OF_CONDUCT.md create mode 100644 LICENSE create mode 100644 README.md create mode 100644 docs/FAQ.md create mode 100644 grafana/Dockerfile create mode 100644 grafana/dashboards/h-series-compute-h410c-ipmi.json create mode 100644 grafana/dashboards/h-series-compute-h615c-ipmi.json create mode 100644 grafana/dashboards/solidfire-cluster.json create mode 100644 grafana/dashboards/solidfire-histograms.json create mode 100644 grafana/dashboards/solidfire-multicluster.json create mode 100644 grafana/dashboards/solidfire-node.json create mode 100644 grafana/dashboards/solidfire-storage-optimization.json create mode 100644 grafana/dashboards/solidfire-volume-topn.json create mode 100644 grafana/dashboards/solidfire-volume.json create mode 100644 grafana/dashboards/vsphere-esxi-metrics.json create mode 100644 grafana/dashboards/vsphere-vm-stats.json create mode 100644 grafana/provisioning/dashboards/dashboards.yml create mode 100644 grafana/provisioning/datasources/datasource.yml create mode 100644 graphite/Dockerfile create mode 100644 graphite/carbon.conf create mode 100644 graphite/graphite-api.yaml create mode 100644 graphite/statsd_config.js create mode 100644 graphite/storage-aggregation.conf create mode 100644 graphite/storage-schemas.conf create mode 100644 images/dashboard-h-series-compute-hardware-monitoring-h410c.png create mode 100644 images/dashboard-h-series-compute-hardware-monitoring-h615c.png create mode 100644 images/dashboard-solidfire-cluster.png create mode 100644 images/dashboard-solidfire-volume-min-to-max-histogram.png create mode 100644 images/hcicollector_architecture_overview.jpg create mode 100755 install_hcicollector.sh create mode 100644 netapp-hci-compute/hci-compute-ipmi-collectd.md create mode 100644 sfcollector/Dockerfile create mode 100644 sfcollector/README.md create mode 100644 sfcollector/graphite-sfc.yml create mode 100644 sfcollector/solidfire_graphite_collector.py create mode 100644 vmwcollector/Dockerfile diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..13ec293 --- /dev/null +++ b/.gitignore @@ -0,0 +1,167 @@ +cleanup.sh +vmwcollector/vsphere-graphite.json +*/__pycache__/ + +### GH for Python + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..ceaffdb --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,97 @@ +# Change Log + +- [Change Log](#change-log) + - [Changes in v0.7.1](#changes-in-v071) + - [Changes in v0.7](#changes-in-v07) + - [Changes in v0.6.1](#changes-in-v061) + - [Changes in .v6](#changes-in-v6) + - [Changes in .5](#changes-in-5) + - [Changes in .4](#changes-in-4) + - [Changes in .3](#changes-in-3) + - [Changes in .v2](#changes-in-v2) + - [Changes in .v1](#changes-in-v1) + +## Changes in v0.7.1 + +- Create SolidFire container based on v0.7 for easy deployment and stand-alone SolidFire monitoring with Kubernetes (see ./sfcollector-kubernetes/ directory) +- Update README.md and add an example Deployment YAML file for SolidFire Collector and Graphite/statsd +- SolidFire Collector container published on Docker Hub can be deployed without any configuration wizard + +## Changes in v0.7 + +- Fork upstream hcicollector by jedimt (this release builds upon upstream branch .v7, here renamed to v0.7) +- Remove NetApp Trident-related steps from install script (see the FAQs). HCICollector now by default uses two local Docker volumes: one for GraphiteDB and another for Grafana settings +- Remove the NetApp Technical Report PDF and video demo files from the repo for faster repository cloning. Add video links to YouTube demo videos +- Changes and improvements to documentation as well as online help (links to the SolidFire UI and basic descriptions in various panels) +- Introduce potentially breaking changes in metrics paths and details gathered from SolidFire (see Release Notes v0.7 and FAQs) +- Change storage schemas for GraphiteDB to use less disk space +- Fixes: + - SFCollector: wrapper script can contain special characters (issue #2). Change Docker base OS to Python 3.8.6 (slim Buster) + - SFCollector: gather more SolidFire metrics relevant to administrators and operations staff + - SFCollector: deduplication efficiency formula changed to account for space used for snapshots (issue #3) + - SFCollector: set SolidFire API call timeout to a lower value than default (issue #6) + - SFCollector: add the option to validate TLS certificate of SolidFire API endpoint(s) + - SFCollector: add variable for API response timeout for larger environments (issue #12) + - SFCollector: upgrade SolidFire SDK for Python v1.7.0.152, upgrade base image to Python 3.9.2-buster-slim + - Grafana: configure Legend and Axis Y values in most panels to display 0 decimals (enforce integer values where apppropriate (e.g. byte count) and lower the level of unnecessary detail elsewhere), adjust precision and make other usability improvements + - Grafana: change deprecated gauge caunters to new gauge counters + - Grafana: replace deprecated Grafana renderer with new renderer container + - Grafana: add new panels to existing dashboards, including iSCSI connections, disk wear level, QoS histograms and more + - Grafana: change some dashboards to make it easier to see key panels without scrolling + - Update third party container images: + - graphite-statsd v1.1.7-11: considerably smaller Docker image, and (by upstream) update internal components (`GRAPHITE_LOG_ROTATION: 1` added to container environment variables to retain previous behavior after changes in upstream v1.1.7-9) + - grafana v6.7.5: v6.7.4 and v6.7.5 fix two security issues (neither of them impacts HCICollector with default settings because they aren't enabled) + - vsphere-graphite v0.8b: support for vSphere 7.0 (and 7.0U1) API via govmomi 0.23.0 (v7.0 API should work fine on vCenter 7.0U1) +- Known issues: + - Built-in dashboard links to SolidFire UI work for configurations with single SolidFire storage cluster. HCICollector environments that monitor multiple SolidFire clusters can add a MVIP variable to dashboard and reference it in URLs to modify URLs on the fly + - Install script configures only one vCenter cluster and only one SolidFire cluster. See the FAQs for workarounds + - Some visualizations use Beta-release plugins from Grafana which may have issues related to visualization or configuration (editing of panel settings). There are bugs in browsers and Grafana too + - SolidFire disk drive Wear Level / Life Remaining visualization uses the title like `drive.${disk-id}` although `${disk-id}` would be better. The reason is the Grafana plugin cannot accept numeric titles. If that bothers you try some other Grafana visualization plugin + - Dashboards and panels may contain hard-coded URLs (e.g. 192.168.1.30) or SolidFire cluster name (e.g. PROD): search-and-replace this link with your own before you import them. HCICollector install script does this for you, but direct import bypasses that step. The proper solution would be to add the MVIP variable to all dashboards and use it in URLs + - By the nature of how vSphere and SolidFire plugins gather metrics, an object deleted and created with the same name (e.g. a VM, or datastore, or SolidFire volume) may appear in the same long term graph as its ancient namesake. Such objects generally have UUIDs, but VMware and SolidFire don't keep UUID-to-Name mappings for deleted objects. If UUIDs were to be used (which is partially done in Some SolidFire dashboards, that would be correct but present problems for humans who hardly recognize current, let alone historic, UUIDs). This isn't an unsolvable problem but it'd require a fair amount of work to fix. Essentially a DB would have to be built, and another back-end added to Graphite, as far as I can tell. Or cross reference SolidFire API logs against UUIDs. +- Experimental features: + - Two sample dashboards for hardware monitoring of NetApp H-Series Compute nodes: metrics are not gathered by by default - it requires read-only access to the compute node IPMI interface, manual deployment of collectd VM or container (see the config-examples directory and FAQs) and potentially modifications to the dashboards to make them usable) + +## Changes in v0.6.1 + +- Fix for the bad dedupe factor formula (issue #3) in .v6 +- Prior to v0.7, sfcollector used latest version of base OS, so there's a risk to rebuilding containers as base OS updates may break sfcollector +- If you want to try, download branch [v0.6.1](https://github.com/scaleoutsean/hcicollector/tree/v0.6.1) and rebuild, or just apply the [change](https://github.com/jedimt/hcicollector/compare/master...scaleoutsean:v0.6.1) to existing sfcollector/solidfire_graphite_collector.py and rebuild only that container (sfcollector) + +## Changes in .v6 + +- Changed file layout to be more consistent with container names and roles +- Retooled for Grafana 5.0.0 +- Dashboards and datasources are now automatically added through the new provisioning functionality in Grafana 5 +- Removed the external volume for the Grafana container, only Graphite uses an (optional) external iSCSI volume for persistent data +- Added the ability to poll for active alerts in the "SolidFire Cluster" dashboard. +- Added support for email alerting based on SolidFire events. Note: alerting queries do not support templating variables so if you have multiple clusters you will need to use `*` for the cluster instance instead of the `$Cluster` variable. The net effect of this is that the alert pane will show alerts from ALL clusters instead of an individually selected cluster. +- New detailed install document +- Added a very basic installation script + +## Changes in .5 + +- Extensive dashboard updates. Dashboards now available on [grafana.com](https://grafana.com/dashboards?search=HCI) +- Added additional metrics to collection +- Updated to Trident from NDVP for persistent storage + +## Changes in .4 + +- Added a vSphere collectored based heavily on the work of cblomart's vsphere-graphite collector +- Dashboard updates +- New dashboards for vSphere components + +## Changes in .3 + +- Changed the collector container to Alpine which dramatically cut down container size and build time. +- Other minor changes + +## Changes in .v2 + +- Added "&" in wrapper.sh script to make the collector calls async. Previously the script was waiting for the collector script to finish before continuing the loop. This caused the time between collections to stack which caused holes in the dataset. Now stats should be returned every minute +- Changed graphs to use the summerize function for better accuracy + +## Changes in .v1 + +- Initial release + diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..b6bd688 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,6 @@ +# Contributor Code of Conduct + +This project adheres to No Code of Conduct. We accept anyone's contributions. Nothing else matters. + +For more information please visit the [No Code of Conduct](https://nocodeofconduct.com) homepage. + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md new file mode 100644 index 0000000..b969838 --- /dev/null +++ b/README.md @@ -0,0 +1,161 @@ +# SolidFire Collector (formerly HCI Collector) + +HCI Collector is a container-based metrics collection and graphing solution for NetApp HCI and SolidFire systems running Element OS v11.0 or newer. + +- HCI Collector >= v0.7 deployed based on this repo can monitor SolidFire and vSphere 6, 7 (i.e. NetApp HCI) +- Stand-alone SolidFire Collector >= v0.7.1 can be deployed to Docker, Docker Compose, Kubernetes and Nomad. It gathers only (SolidFire) storage metrics + +| If you install... | it runs on | and gathers metrics for | +| :--- | :---: | :--- | +| SolidFire Collector v1.0.5 | VM, Docker, Kubernetes,Nomad | SolidFire (NetApp HCI storage, NetApp eSDS)| +| HCI Collector v0.7.2| VM, Docker, Docker compose | SolidFire, vSphere | + +Note: sfc is in `sfcollector-kubernetes/solidfire_graphite_collector.py` + +## Alternatives + +- [SolidFire Exporter](https://github.com/mjavier2k/solidfire-exporter/) - Prometheus exporter + - [Getting started with SolidFire Exporter](https://scaleoutsean.github.io/2021/03/09/get-started-with-solidfire-exporter.html) +- SolidFire syslog forwarding to Elasticsearch or similar platform (detailed [steps](https://scaleoutsean.github.io/2021/10/18/solidfire-syslog-filebeat-logstash-elk-stack.html)) + +## Changes + +See [CHANGELOG.md](CHANGELOG.md). Also: + +- In this repo only SolidFire Collector will be refreshed and updated. VMware-related stuff will be removed in next release (if we get there) +- NetApp HCI users please use vmwcollector or other upstream project or tool to gather vSphere metrics + +## FAQs + +See the [FAQs](/docs/FAQ.md). + +## Description + +HCI Collector is a fully packaged metrics collection and graphing project for Element OS 11+ and vSphere 6+ clusters. It is based on the following components packaged as individual containers: + +- sfcollector: container with SolidFire Python SDK and a metrics collecting script. Runs a Python script that collects SolidFire storage cluster data and feeds it to GraphiteDB via statsd +- vmwcollector: vSphere stats collector. Collects vSphere data and feeds it to GraphiteDB +- graphite: database that stores received time series data +- grafana and grafana-renderer: graphing engine and a renderer with a Web UI that visualizes Graphite data through SolidFire and vSphere dashboards + +The HCI Collector uses internal VM disk space, but advanced users can use [NetApp Trident](https://docs.netapp.com/us-en/trident/index.html) or other storage to store Graphite DB on a NetApp block or file storage system. + +### Architecture and Demos + +![HCI Collector architecture overview](images/hcicollector_architecture_overview.jpg) + +- [HCI Collector walk-through for v0.7b](https://youtu.be/9vW-PozlIUk) +- [Demo of sfcollector using Element v11+ Volume Histograms](https://youtu.be/VHjgdtOr8Ws) + +## Prerequisites and requirements + +### SolidFire Collector (SFC) + +See README file in folder sfcollector or use [this](https://hub.docker.com/repository/docker/scaleoutsean/sfc) container (or build your own). + +You can build the container from sfcollector/Dockerfile. + +### HCI Collector + +HCI Collector was tested with the following configuration (newer components might work): + +- Docker +- NetApp HCI (SolidFire, Element OS) v11.3 - v12.7 +- VMware vSphere 6.7U3b or newer (other 6.x releases should work and so should vSphere 7 - see vsphere-graphite documentation) +- NetApp HCI storage and vCenter management accounts with read access to Element storage and vCenter API + +Newer or older releases of each component may work. Element OS users with a pre-v11.0 software should check the FAQs. + +HCI Collector has the following minimum requirements: + +- A recent Linux VM with Docker CE + - Disk capacity: approximately 10GB for OS, 3MB/hour for GraphiteDB in a small environment (see the FAQs or Graphite docs on how to use less storage) +- Read-only access to management API of SolidFire/Element v11 (Management IP or "MVIP") and vCenter. HCI Collector can work with Element v10 and v11, but with v10 histogram metrics do not get collected and histogram panels won't work + +## Installation and configuration + +### SFC + +- SFC takes less than one minute to deploy +- Docker: refer to [the Docker Hub page for SFC](https://hub.docker.com/repository/docker/scaleoutsean/sfc) +- Kubernetes: use the example Deployment file from `sfcollector` folder to deploy +- SFC takes less than one minute to deploy +- You may load Grafana dashboard files or build your own + +### HCI Collector + +- Read the Security section below and make a plan based on your security requirements +- Deploy a VM with a sufficiently large disk (say, 1,000 GB) or adjust GraphiteDB settings to retain less data by pruning it sooner +- Install Docker CE and docker-compose. Enable and restart Docker service +- Clone `sfc` repository (`git clone https://github.com/scaleoutsean/sfc`) or download the source code from Releases +- Execute the install script and provide requested inputs (`cd sfc; sudo ./install_hcicollector.sh`) +- Examine the config files and run `sudo docker-compose up` (recommended the first time as you can visually inspect everything works; stop it with CTRL+C) or `sudo docker-compose up -d` (background mode) +- Access Grafana at the VM port 80 (see under Security) and login with the temporary password from install wizard. Default Grafana username is `admin` + +#### Example of install script questions & answers + +**NOTE:** you can deploy SFC (SolidFire Collector only) without any wizard based on improved Docker container posted on [Docker Hub](https://hub.docker.com/repository/docker/scaleoutsean/sfc) + +- SolidFire management virtual IP (MVIP): 192.168.1.30 +- SolidFire username (case sensitive): monitor (dedicated SolidFire cluster admin account created on SolidFire cluster) +- Password to use for the Grafana admin account: admin (temporary password until first log on) +- vCenter domain: local (IP-based VMware cluster) +- ESXi hostnames do not resolve in DNS: yes (no DNS - IPv4-based VMware cluster) +- IP address of this Docker host: "public" IP for Grafana access (the VM could have another network connected to Management LAN) +- Shell view: + +```sh + Enter the SolidFire management virtual IP (MVIP): +192.168.1.30 + Enter the SolidFire username (e.g. 'monitor'): +monitor + Enter the Solidfire password: ******** + Enter the initial password to use for the Grafana admin account: ********* + Deploy read-only Grafana dashboards (no user customization) - 'true' or 'false'): +false + Enter the vCenter hostname or IP (e.g. 'vcsa' or '10.10.10.10'): +192.168.1.7 + Enter the vCenter username: +administrator@vsphere.local + Enter the vCenter password: ******** + Enter the vCenter DNS domain (e.g. 'company.com' or 'local' if none) +local + ESXi hostnames do not resolve in DNS - true or false? (e.g. 'true') +true +``` + +## Accounts and Security + +- Accounts + - If you want proper security use a dedicated SolidFire cluster admin account with a Reporting-only (or Read-only) role. Even Reporting-only role has access to sensitive information (initiator and target passwords of your storage accounts), but at least it cannot make modifications to SolidFire cluster (it only can `Get` and `List`)- + - It is recommended to create a dedicated vCenter "read-only" account for limited, read-only access by vpshere-graphite + - Do not use SolidFire cluster or VMware vCenter passwords for Grafana Web UI authentication +- Configuration files + - Configuration files contain plain text passwords to SolidFire storage and vSphere + - Stand-alone SolidFire container on Kubernetes or Nomad can use platform features to store credentials in the platform so that they're not stored as plain text +- HCI Collector VM + - Ensure that only administrator-level staff has access to your HCICollector VM (set a complex password on the VM, access Grafana Web UI over HTTPS, etc.) + - By default, Grafana's Web service runs at port 80 (not 443). See the FAQs on how to configure HTTPS. Use a unique username and password for Grafana +- Network + - HCI Collector container is configured to not validate TLS certificate of SolidFire Management IP (edit sfcollector to change that if your certificates are valid) + - Grafana access in HCICollector defaults to HTTP. This can be changed (see in [FAQs](FAQ.md)), but at the very least do not use SolidFire cluster or vCenter cluster passwords for Grafana admin authentication + - If Grafana will be accessed by non-admin users you should create a multi-homed VM (one public (Grafana) and one private (Management LAN) interface. NetApp HCI has two Management VLANs (vCenter and Storage). + - Anyone can send data (or junk) to Graphite's receiver ports on HCICollectore using VM's interfaces. You may modify Carbon configuration file ([FAQs](FAQ.md) to make Graphite listen on a different interface (say, loopback) from Grafana, or run HCICollector on a Management Network, or use ufw/iptables to restrict access, etc. + - On Kubernetes, access to SolidFire collector is limited because it only needs outgoing access to your Graphite/Statsd container, which is easy to protect +- 3rd party containers + - Upstream containers are not audited or regularly checked for vulnerabilities. Feel free to inspect them on your own + +## Acknowledgments + +- This would not have been possible without the prior work of Aaron Patten, cblomart, cbiebers, jmreicha and other authors and contributors +- [solidfire-graphite-collector](https://github.com/cbiebers/solidfire-graphite-collector) - original SolidFire collector script +- Main 3rd party applications + - [docker-graphite-statsd](https://github.com/graphite-project/docker-graphite-statsd) - GraphiteDB and StatsD container by [Graphite](https://graphiteapp.org/). Documentation can be found [here](https://graphite.readthedocs.io/en/latest/releases.html) + - [vsphere-graphite](https://github.com/cblomart/vsphere-graphite) - VMware vSphere collector for GraphiteDB + - [Grafana](https://grafana.com) + +## License and Trademarks + +- `solidfire_graphite_collector.py`, SolidFire-related dashboards and scripts are licensed under the Apache License, Version 2.0 +- External, third party containers, scripts and applications may be licensed under their respective licenses +- NetApp, SolidFire, and the marks listed at www.netapp.com/TM are trademarks of NetApp, Inc. Other marks belong to their respective owners diff --git a/docs/FAQ.md b/docs/FAQ.md new file mode 100644 index 0000000..49b9790 --- /dev/null +++ b/docs/FAQ.md @@ -0,0 +1,288 @@ +# FAQs + +- [FAQs](#faqs) + - [HLEP!! It doesn't wokr and I needed it to work yesterday](#hlep-it-doesnt-wokr-and-i-needed-it-to-work-yesterday) + - [Where are the configuration files and what's in them](#where-are-the-configuration-files-and-whats-in-them) + - [Do passwords really have to be stored unencrypted](#do-passwords-really-have-to-be-stored-unencrypted) + - [What does the comment about multiple interfaces on HCICollector VM mean?](#what-does-the-comment-about-multiple-interfaces-on-hcicollector-vm-mean) + - [Where is the SolidFire collector log?](#where-is-the-solidfire-collector-log) + - [How to recover from a failed run of install script](#how-to-recover-from-a-failed-run-of-install-script) + - [How to add multiple vCenter and SolidFire clusters?](#how-to-add-multiple-vcenter-and-solidfire-clusters) + - [How to integrate HCICollector with persistent container storage](#how-to-integrate-hcicollector-with-persistent-container-storage) + - [How to update HCICollector from an older version](#how-to-update-hcicollector-from-an-older-version) + - [How to update individual HCICollector container to a newer version](#how-to-update-individual-hcicollector-container-to-a-newer-version) + - [Add own data feeds and dashboards](#add-own-data-feeds-and-dashboards) + - [Install a plugin from the Grafana Web site](#install-a-plugin-from-the-grafana-web-site) + - [Can SolidFire Connector a newer version Grafana](#can-solidfire-connector-a-newer-version-grafana) + - [How to create SolidFire histograms and other dashboards](#how-to-create-solidfire-histograms-and-other-dashboards) + - [I imported a sample dashboard and it's not showing anything](#i-imported-a-sample-dashboard-and-its-not-showing-anything) + - [How to monitor container volumes](#how-to-monitor-container-volumes) + - [How much disks capacity do I need for HCICollector's Graphite volume?](#how-much-disks-capacity-do-i-need-for-hcicollectors-graphite-volume) + - [How can I delete old Graphite DB files?](#how-can-i-delete-old-graphite-db-files) + - [How to add 3rd party feeds and dashboards to HCICollector's Grafana instance](#how-to-add-3rd-party-feeds-and-dashboards-to-hcicollectors-grafana-instance) + - [How to gather and send SolidFire storage cluster metrics to existing GraphiteDB with a Python script (without running all HCICollector containers) such as NAbox or other?](#how-to-gather-and-send-solidfire-storage-cluster-metrics-to-existing-graphitedb-with-a-python-script-without-running-all-hcicollector-containers-such-as-nabox-or-other) + - [Use HCICollector without vCenter](#use-hcicollector-without-vcenter) + - [Use HCICollector with a pre-11.7 version of SolidFire/Element](#use-hcicollector-with-a-pre-117-version-of-solidfireelement) + - [Reset Grafana password](#reset-grafana-password) + - [Alternative approaches to telemetry gathering](#alternative-approaches-to-telemetry-gathering) + - [How to export data from Graphite](#how-to-export-data-from-graphite) + - [It seems there are dashboard for NetApp HCI Compute node hardware monitoring (IPMI via BMC), but they aren't deployed. What's up with that](#it-seems-there-are-dashboard-for-netapp-hci-compute-node-hardware-monitoring-ipmi-via-bmc-but-they-arent-deployed-whats-up-with-that) + - [How to gather *hardware* metrics from NetApp HCI Series nodes](#how-to-gather-hardware-metrics-from-netapp-hci-series-nodes) + - [Can these hardware monitoring dahasboards be used to monitor SolidFire or NetApp HCI storage nodes](#can-these-hardware-monitoring-dahasboards-be-used-to-monitor-solidfire-or-netapp-hci-storage-nodes) + - [What about H300E, H500E, H700 compute nodes](#what-about-h300e-h500e-h700-compute-nodes) + - [Why do the two hardware monitoring dashboards for H410C and H615C have different metrics and dashboards](#why-do-the-two-hardware-monitoring-dashboards-for-h410c-and-h615c-have-different-metrics-and-dashboards) + - [What's the roadmap, Kenneth](#whats-the-roadmap-kenneth) + - [What is the reason Trident was removed from HCICollector](#what-is-the-reason-trident-was-removed-from-hcicollector) + - [Can HCICollector collect Trident metrics](#can-hcicollector-collect-trident-metrics) + - [Is this repo associated with or sponsored by NetApp](#is-this-repo-associated-with-or-sponsored-by-netapp) + +## HLEP!! It doesn't wokr and I needed it to work yesterday + +If you must have a working solution ASAP, please consider one of the alternatives (see other FAQs for alternatives) while you figure out how to make this thing work. For NetApp Cloud Insights you just need to register at cloud.netapp.com, download and deploy acquisition VM and you'll have something that works well. + +But if you still want to try HCICollector, since v0.7 there's really not much that can go wrong so first get familiar with Docker and the HCICollector docs. You may also try the netapp-hci channel in the NetApp Community Slack (join [here](https://netapp.io)) to see if you can find someone who has experience with HCICollector. For help with 3rd party projects, please refer to their documentation & community resources. + +## Where are the configuration files and what's in them + +Most of these files are created by the installation script. If you change them, you may need to rebuild the containers. + +- `docker-compose.yml` - Initial Grafana password (you'll be prompted to change it the first time you log in) +- `grafana/provisioning/*/*.yml` and `grafana/Dockerfile` - Grafana configuration +- `graphite/carbon.conf` and `graphite/*.conf` - GraphiteDB (service user identity) and StatsD configuration files (including IP address) +- `sfcollector/wrapper.sh` - SolidFire cluster admin account and password. It is created by install script. wrapper.sh periodically executes `solidfire/solidfire_graphite_collector.py` which gathers metrics and events and sends them to Graphite +- `vmwcollector/vsphere-graphite.json` and `vmwcollector/Dockerfile` - VMware vCenter monitoring account and password and container details + +## Do passwords really have to be stored unencrypted + +For now yes, but your pull request that fixes that would be welcome. The VM is your last line of defense. Protect it. + +The entire VM (apart from the Grafana Web UI, of course) should be made off limits to non-administrators. Suggested configuration: + +- VM with two interfaces (Management & User Network) +- Management Network: connection to vCenter, SolidFire/Element + - Graphite (carbon.conf) listening on this network +- User Network: expose Grafana via HTTPS + - Firewall that permits access only to port 443 of this interface (or 80, if you don't want to create TLS certificates and register this interface in DNS) + +Another thing that should be considered by users of Element OS v12 or newer is to set up a dedicated cluster admin account on SolidFire or NetApp HCI limited to Read & Reporting role (refer to Access Control in the SolidFire User Guide or SolidFire API Reference Guide). Older Element releases require full-featured cluster admin account for Read & Reporting. + +The same goes for VMware - vSphere administrator account with limited permissions (read-only) should be used for VMware cluster monitoring. If you don't manage the SolidFire or VMware cluster(s) you want to monitor, you may ask the admin(s) to create a reporting-only admin account for you (for Element v11, if you do not use QoS histograms; for VMware vCenter please refer to the vsphere-graphite and VMware documentation.) + +## What does the comment about multiple interfaces on HCICollector VM mean? + +Generally - and considering the nature of this container (passwords in config files, etc.) - it is expected that there be two interfaces: + +- Internal, for IT team to access the VM, and for containers to access Managements IPs of vCenter and SolidFire (incoming port 22 (optional), outgoing destination port 443 (required, directly or via trusted proxy)) +- External, for users (from IT or elsewhere), to access Graphana Web UI (incoming port 80) + +When install script creates config files for you, it sets all services to "external" IP, including but not limited, Graphite (incoming port 8080). To prevent outside users from accessing this VM, either change config files to not expose services on this interface (hard) or add firewall rules to only allow access to port 80 on External IP. Yes, 443 (HTTPS) would be even better, but you'd have to supply TLS certificates Grafana (see `grafana/Dockerfile` and Grafana documentation) and rebuild that container, or add another container, a reverse proxy that would terminate HTTPS and redirect to HTTP (Graphana service port). + +Another point should be made about Grafana accounts. If you don't access Grafana over HTTPS, it may not be a great idea to have any accounts on it because with HTTP passwords are transmitted in clear. You should definitively NOT use your "default" admin password for Grafana! Best practice: read the Grafana manual and rebuild the container to work with HTTPS, and then create appropriate Grafana accounts. + +## Where is the SolidFire collector log? + +For the container engine and 3rd party containers please see their respective documentation. + +For the container running solidfire_graphite_collector.py (SFCollector) see `sfcollector/solidfire_graphite_collector.py --help`. You can edit wrapper.sh (example below), (re)build the container, start and enter the container to run `tail -f /log.txt` + +```shell +/usr/bin/python /solidfire_graphite_collector.py -s 10.10.10.10 -u monitor -p "monitor1234" -g graphite -l log.txt & +``` + +## How to recover from a failed run of install script + +It's just Docker, so use regular Docker (including `docker-compose`) commands to delete the containers, networks, etc. To remove Docker data, look into removing the Docker Graphite and Grafana volumes, too. + +## How to add multiple vCenter and SolidFire clusters? + +- For vCenter, edit `vmwcollector/vsphere-graphite.json` and rebuild. See upstream documentation. +- For SolidFire, edit `sfcollector/wrapper.sh` to run against additional MVIP's and rebuild. Note that dashboard panel links may need to be modified to use variables, as the way they're currently created is hardcoded based on single storage cluster use case. + +## How to integrate HCICollector with persistent container storage + +Deploy Docker CE or Kubernetes, deploy a NetApp Trident container (there are two versions - one for Docker and one for Kubernetes) and make sure it works with your backend (ONTAP or SolidFire or whatever you use to store these metrics). Then, instead of creating a local volume for GraphiteDB or any other data you want to persist to external storage, create a Trident volume on external storage (Element OS, ONTAP, etc.) and edit your Docker compose file to make HCICollector store GraphiteDB data on it (in `docker-compose.yaml` generated by installation script find `graphite` (volumes section) and set `external: true`. Then rebuild the Graphite container). You may need to refer to install script from a previous releases of HCICollector and reference various configuration files (mostly for Grafana and Graphite). + +If you want to migrate data from a local to an external volume, you could create a new external volume and use a custom container (that mounts the both) and then copy data from old to new volume. Obviously you'd have to do this while GraphiteDB isn't being used, so maybe temporarily modify its Dockerfile and roll back the modification after data has been copied over. Next time the container is started it should be mounting only one (new) Graphite volume on external storage. Create a snapshot before this if you want to protect your data. You'd also have to rebuild the graphite container. + +## How to update HCICollector from an older version + +I would advise against that because that hasn't been tested and changes may break it (see CHANGELOG for v0.7). + +## How to update individual HCICollector container to a newer version + +Edit Dockerfile and rebuild the container. You may want to do this if there's a security bug that affects you or you want to add functionality unavailable in current release. + +Using container and config files from newer releases may not work because there are several moving parts. + +## Add own data feeds and dashboards + +Feel free to do it by yourself. Metrics can be sent to StatsD or directly to Graphite (see `graphite/Dockerfile`). Additional ports may be `EXPOSE`'d if necessary. Dashboards can be imported from the Graphana Web interface. Since v0.7, it is possible to edit (or remove) built-in sample dashboards and import or create your own. + +## Install a plugin from the Grafana Web site + +Modify the Grafana Dockerfile and rebuild the container. + +## Can SolidFire Connector a newer version Grafana + +SolidFire Collector seems to work fine with Grafana 11 Preview (and Grafana and SolidFire work with latest Graphite), so it's likely Grafana 8, 9, 10 and 11 all work. + +## How to create SolidFire histograms and other dashboards + +See the samples included in HCICollector. + +A separate but related problem is what Grafana function should be used to visualize histogram metrics. Derivative seems to provide better results than perSecond (both of these can be found under panel Transform functions.) + +## I imported a sample dashboard and it's not showing anything + +First, give it time before you start reinstalling or making changes. I've seen SSDs and ESXi take 70 minutes for all panels to get populated. Other data may start appearing in 5 minutes. As long as one panel works, that's valuable info for troubleshooting, so wait at least 10-15 minutes. + +Things that can go wrong: + +- Grafana's source DB (instance of GraphiteDB): is Source working? Make sure of the type and name of your Grafana data source (in Grafana settings, make Graphite or Default or whatever is functional) +- Dashboard's source: edit imported Dashboard and in Source pick the correct (Default or Graphite or whatever) Source that contains GraphiteDB data to be visualized +- Dashboard attempts to use wrong MVIP or cluster: delete pre-installed Dashboard, check source code for the dashboard (e.g. by browsing the HCICollector source code on Github) and look for SolidFire MVIP or cluster name. Replace those with your own MVIP or cluster name, copy the file to where other Dashboards are lcoated (`./grafana/...`) and rebuild Grafana container +- Panels: due to changes in metric paths, a dashboard or panel from v0.7 may not work in (say) v0.7.5. Download the file from the right repo branch +- Metric path, URL or cluster name in Dashboard imported using the Grafana UI: things get correctly set up by the HCICollector install script, which uses the SolidFire MVIP you provide to spare you from doing that manually for every Dashboard or Panel. You can correct these details in text editor or Grafana and run a file-wide Search-and-Replace before you Import the dashboard (see other hints on how). +- Pilot error: typos in passwords, accounts, IPs... + +## How to monitor container volumes + +One way would be to duplicate existing dashboards and edit their queries to show only volumes owned by the Kubernetes storage provisioning account. NetApp Trident is often deployed to use the storage account name `trident`, but those who use several clusters could use dashboards with Account ID variables and manually added aliases that translate to the Account Name or even the Kubernetes cluster Name. + +The hard way would be to send native NetApp Trident performance metrics to Prometheus, add Prometheus to Grafana sources, and create a new dashboard for that source. HCICollector v0.7 and earlier does not use InfluxDB, so you'd have to have InfluxDB for that. + +## How much disks capacity do I need for HCICollector's Graphite volume? + +As always, "it depends." + +Example settings for SolidFire and VMware: +- 1 minute frequency (retain 2 days) +- 5 minute (8 days) +- 15 minute (30 days) +- 1 hour (1 year) + +For standard VM infra environments Graphite probably needs less than 1 GB/day/VM using default settings. Static environments with few VMs may want to keep fine-grained metrics longer. Dynamic DevTest or Kubernetes environments may want the opposite. If you hold Graphite on NetApp E-Series or similar array, you can keep fine-grained metrics and application logs for years. Run your environment for an hour or day, stop HCICollector, and compare Before vs After. + +I tried to use various approaches to optimize but the settings can never be good for everyone. Some users may vant faily verbose stats but keep them only for 8 days, others may want coarse stats for months. And the worst of all is that deleted VMs and other objects are retained according to Graphite settings, so even if the VM is created and deleted after 7 days, its data will still be kept for 1 year (with a schema similar to the example above). + +Feel free to modify Graphite settings (`graphite/storage-schemas.conf`) to suit your requirements. Check the official Graphite documentation for the details. + +## How can I delete old Graphite DB files? + +Get into the Graphite container, find and wipe files that haven't been touched for a while. Modify this for your circumstances (source: StackOverflow.com): + +`find /opt/graphite/storage/whisper/ -type f -mtime +120 -name \*.wsp -delete; find /opt/graphite/storage/whisper -depth -type d -empty -delete` + +## How to add 3rd party feeds and dashboards to HCICollector's Grafana instance + +Import them from the Grafana Web UI. + +Also see "Add own data fees and dashboards" above. + +## How to gather and send SolidFire storage cluster metrics to existing GraphiteDB with a Python script (without running all HCICollector containers) such as NAbox or other? + +Use the `sfcollector` container. Create a `solidfire/wrapper.sh` to run `solidfire/solidfire_graphite_collector.py` and send it to existing StatsD or Graphite. + +- Use `solidfire_graphite_collector.py`. Provide your own Graphite server destination with the `--graphite` argument. You may also need to provide a custom `--metricroot` suitable for your environment. +- Alternatively, modify HCICollector to send data to StatsD first. StatsD can send data to built-in GraphiteDB and also to another Graphite (such as your own). Mind the `metricroot` of secondary destination. You may also modify the script to send data to Telegram or other destnation(s). +- Metrics retention periods are set externally in your existing instance of Graphite (see the answer for GraphiteDB disk capacity estimate, above) +- If your existing Grafana setup doesn't use Graphite, you can also deploy the Graphite container from HCICollector and even reuse dashboards included in HCICollector. Then you'd add this Graphite instance as a new data source in Grafana + +## Use HCICollector without vCenter + +If you don't have a vCenter (you use Hyper-V, for example) or VMware in your environment, you may still use the installation script and then remove the vmwcollector (vsphere-graphite) section (before you run docker-compose). + +## Use HCICollector with a pre-11.7 version of SolidFire/Element + +Change the Element API version string in sfcollector/solidfire_graphite_collector.py (min `7.0`). Note that SolidFire Python SDK must support that version. + +Some sample panels may not be able to work with data gathered from older API (and they can be deleted from affected sample dashboards, if you want to use those that do work.) + +## Reset Grafana password + +If your username is admin: enter the container, run `apk add sqlite; cd /var/lib/grafana; sqlite3 grafana.db` and set admin password to admin. + +```sql +sqlite> update user set password = '59acf18b94d7eb0694c61e60ce44c110c7a683ac6a8f09580d626f90f4a242000746579358d77dd9e570e83fa24faa88a8a6', salt = 'F3FAxVm33R' where login = 'admin'; +sqlite> .exit +``` + +## Alternative approaches to telemetry gathering + +Several of the many options: + +- Enterprise: please consider either the gratis or paid version of [NetApp Cloud Insights](https://cloud.netapp.com/cloud-insights), a proven, comprehensive, cloud-hosted service for cloud and on-premises environments. The free/lite version can monitor most NetApp storage products including NetApp HCI +- Enterprise: if you own a NetApp HCI or SolidFire ("storage-only") cluster, you can choose to allow NetApp ActiveIQ to gather metrics and send them to ActiveIQ service, but with better trending and alerting. ActiveIQ also has an API and a mobile application which is superior for support-related monitoring (as opposed to gathering and visualization of performance-related metrics.) +- Gratis: [NABox](https://nabox.org) (at some point it may be able to monitor Element storage clusters; until then you may try to integrate the SolidFire Graphite collector script on your own.) +- Gratis: [solidfire-exporter](https://github.com/mjavier2k/solidfire-exporter) - permissively licensed SolidFire metrics exporter to Prometheus +- Gratis: enable and use SNMP v2/v3 on Element software cluster (as well as other monitored components). This can work with any tool which can receive SNMP traps (Zabbix, [Nagios/Icinga](https://github.com/scaleoutsean/nagfire), etc.) + +## How to export data from Graphite + +- Manual: click at the top of a panel and in drop-down menu select `More` > `Export to CSV`. You can also get the URL for your query or panel and poll it periodically to export/download data. +- Automated: see the [Graphite API docs](https://graphite.readthedocs.io/en/latest/render_api.html). Of course, because we control data as it's being gathered, we can store it in both Graphite and another location and eliminate the need to export it to begin with, but if you want to store just one copy and export a subset later, Graphite API is a convenient way to do that. + +## It seems there are dashboard for NetApp HCI Compute node hardware monitoring (IPMI via BMC), but they aren't deployed. What's up with that + +Those are a very late addition (in v0.7 beta 2) and not tested nearly enough, but considering the quirky nature of IPMI some users may find them useful. YMMV. + +## How to gather *hardware* metrics from NetApp HCI Series nodes + +- For storage nodes, it's included in the API (see the repo Awesome SolidFire) and indirectly used by integrated SolidFire platform software (Element OS) +- For compute nodes, HCI Collector v0.7 uses a OS-independent approach, IPMI + +**WARNING**: as mentioned elsewhere, Grafana in HCICollector has the ability to configure alerts, but they are not enabled by default. Related to that, some gauges in the hardware monitoring dashboards have visual clues about the status of certain indicators (e.g. hot for overheated System Board). While care has been taken to use conservative values, these do not represent manufacturers' (NetApp, Intel, NVIDIA) recommendations and do not activate alerts or notifications in the Grafana UI. Independently of Grafana, BMC itself can create alerts (`SELEnabled` and `SELSensor` in collectd documentation), but that is not enabled in the example configuration file in this repo. + +Please refer to the official sites for information on operating environment and safety, starting with the official NetApp HCI documentation. + +IPMI polling may also fail, resulting in one or more dashboards showing outdated information. Please review the thresholds and do not rely on HCICollector for decision making in environments where the malfunctioning of these components could increase the risk of fire hazard, injury, etc. + +One way to do it is: + +- Use ipmitool to create a new USER type of user for read-only access to IPMI IP's +- Deploy a VM or container with collectd (see a mini how-to in the config-examples directory). This VM or container needs to access IPMI IPs and Graphite (to submit gathered data). Go easy on the IPMI information gathering interval - BMC isn't a Web appliance... Set collectd to gather info every 3-5 minutes +- Metric root for the BMC metrics is `netapp.hci.compute` and depending on how you configure collectd, your metrics can be found under `netapp.hci.compute.h615.$hostname.ipmi.` or similar +- Deploy one or both hardware-monitoring dashboards (for the H410C or H615C), in each dashboard pick the right platform (e.g. H615C) and hostname (e.g. H615T4). If you have multiple systems, you can select All, although in that case you may need to make adjustments to panels. These dashboards were tested with one system per platform, so they probably need to be significantly modified to nicely display multiple systems in a single dashboard + +## Can these hardware monitoring dahasboards be used to monitor SolidFire or NetApp HCI storage nodes + +Yes, but those nodes already expose system-level warnings, so while gathering BMC metrics from those systems will work, it creates more workload on the storage nodes' BMC without significantly increasing their manageability. + +## What about H300E, H500E, H700 compute nodes + +Use the instructions for the H410 platform + +## Why do the two hardware monitoring dashboards for H410C and H615C have different metrics and dashboards + +Because they use different BMCs and different hardware platforms. The collectd IPMI plugin by default gathers "basic" IPMI metrics, so if one wanted to find a non-trivial common set of metrics that would be possible, but it'd also require extra time (get all metrics, figure out which are equivalent, and so on). + +Up to four nodes in the H400 Series chassis share (two) chassis fans, so if one were to to show only sensor info common to both platforms, neither H615C fans nor H410 shared chassis fans would be shown. + +## What's the roadmap, Kenneth + +Don't have it! + +At this time my primary goal is to keep the components up to date and ensure this thing installs and runs. + +I've been thinking about changing the back-end to InfluxDB v1 and removing VMware-related code from this repo. + +## What is the reason Trident was removed from HCICollector + +Because it was confusing to people unfamiliar with Trident, the installation script couldn't handle Trident updates and various other concerns (such as, for example, the fact that more and more NetApp customers use Trident in production so there's a growing risk of unintentional conflict with other users and workloads). Additionally, my primary goal is to make it easier to install and use SolidFire collector in existing monitoring infrastructure rather than create new instances of Grafana and Graphite or introduce additional dependencies. + +## Can HCICollector collect Trident metrics + +Up to v0.7 it cannot. It could, but that feature would have to be added. It should be relatively simple (scrape Prometheus metrics from Trident container (port 8001), store them in another back-end (not Graphite), and add a dashboard or two). + +Prometheus users probably want to use existing Prometheus instances (built into Kubernetes or stand-alone) so I think it should be easier to do this: + +- Add a Graphite container to and send sfcollector data to it, and use existing Grafana or other front-end, or +- Use `solidfire-exporter` (not sfcollector) with existing Prometheus, and do not use HCICollector/sfcollector. It may collect slightly different metrics, of course. + +Trident's SolidFire metrics are relatively basic as of v21.01, so I'd recommend `solidfire-exporter` to folks who use Kubernetes. The value of Trident metrics isn't in the breadth or depth of SolidFire metrics, but that it makes it possible to monitor only Trident-related SolidFire metrics. + +`sfcollector` can't tell for sure what volumes were created by Trident, although I was able to use regexp in Grafana to create a "poor man's" filter to show only Trident volumes. Those generally have at least two underscores in Volume name. Trident-managed SolidFire volumes have specific metadata tags and are owned by known accounts (those specified in the SolidFire back-end JSON used by Trident), so it is not hard to identify them them in either Grafana (regexp for volume name, or storage account) or sfcollector (pre-process Trident volume metrics before sendign them to Graphite, based on account information and volume metadata). + +## Is this repo associated with or sponsored by NetApp + +No, it is not. diff --git a/grafana/Dockerfile b/grafana/Dockerfile new file mode 100644 index 0000000..47e57aa --- /dev/null +++ b/grafana/Dockerfile @@ -0,0 +1,17 @@ +# Dockerfile for Grafana container +# +# https://hub.docker.com/r/grafana/grafana/tags +FROM grafana/grafana:8.3.5 +ENV GF_SECURITY_DISABLE_GRAVATAR=true +ENV GF_SERVER_PROTOCOL=http +ENV GF_SERVER_HTTP_PORT=3000 + +ENV GF_INSTALL_PLUGINS="yesoreyeram-boomtable-panel, btplc-trend-box-panel, grafana-clock-panel, farski-blendstat-panel, vonage-status-panel, grafana-piechart-panel" + +# For HTTPS, change server protocol to HTTPS and ensure required certs are available +# COPY certs/ /etc/ssl/certs/ +# ENV GF_SERVER_CERT_FILE = +# ENV GF_SERVER_CERT_KEY = + +RUN mkdir -p /var/lib/grafana/dashboards +COPY dashboards /var/lib/grafana/dashboards/ diff --git a/grafana/dashboards/h-series-compute-h410c-ipmi.json b/grafana/dashboards/h-series-compute-h410c-ipmi.json new file mode 100644 index 0000000..f357c8d --- /dev/null +++ b/grafana/dashboards/h-series-compute-h410c-ipmi.json @@ -0,0 +1,668 @@ +{ + "annotations": { + "list": [ + { + "$$hashKey": "object:8757", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "Hardware Metrics for NetApp H-Series 410C, 300E, 500E, 700E (IPMI)", + "editable": true, + "gnetId": null, + "graphTooltip": 0, + "id": 13, + "iteration": 1591862303003, + "links": [], + "panels": [ + { + "bgColor": "#3274D9", + "cacheTimeout": null, + "clockType": "24 hour", + "countdownSettings": { + "customFormat": null, + "endCountdownTime": "2020-06-11T12:06:00.000Z", + "endText": "00:00:00" + }, + "datasource": null, + "dateSettings": { + "dateFormat": "YYYY-MM-DD", + "fontSize": "20px", + "fontWeight": "normal", + "showDate": false + }, + "gridPos": { + "h": 4, + "w": 5, + "x": 0, + "y": 0 + }, + "id": 7, + "links": [], + "mode": "time", + "refreshSettings": { + "syncWithDashboard": false + }, + "targets": [ + { + "refId": "A", + "target": "" + } + ], + "timeFrom": null, + "timeSettings": { + "customFormat": "HH:mm:ss", + "fontSize": "50px", + "fontWeight": "normal" + }, + "timeShift": null, + "timezone": null, + "timezoneSettings": { + "fontSize": "12px", + "fontWeight": "normal", + "showTimezone": false, + "zoneFormat": "offsetAbbv" + }, + "title": "Time", + "type": "grafana-clock-panel" + }, + { + "datasource": null, + "description": "Different CPUs have different operating temperatures, so gauge thresholds should probably be customized for the CPU with lowest operating temperatures in your environment.\n\nExample: Intel Xeon Gold 6240Y - Max 74C, so we may want to set orange (warning) at 55C and red (critical) at 65C\n\nNote that Grafana alerts need to be separately configured.", + "gridPos": { + "h": 8, + "w": 12, + "x": 5, + "y": 0 + }, + "id": 2, + "options": { + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 1, + "mappings": [], + "max": 100, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "#EAB839", + "value": 50 + }, + { + "color": "semi-dark-red", + "value": 60 + } + ] + } + }, + "overrides": [], + "values": false + }, + "orientation": "auto", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.temperature-CPU1_Temp_processor__3_1_, 'CPU0 Temperature')", + "textEditor": true + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.temperature-CPU2_Temp_processor__3_2_, 'CPU1 Temperature')", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "CPU Temperature - $hostname", + "type": "gauge" + }, + { + "datasource": null, + "description": "Different systems have different operating ranges and different data centers run at different temperatures. Feel free to examine the details of sensor that's measured and adjust Warning and Critical level for your environment. \n\nNote that Grafana alerts need to be separately configured.", + "gridPos": { + "h": 8, + "w": 7, + "x": 17, + "y": 0 + }, + "id": 8, + "options": { + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 1, + "mappings": [], + "max": 60, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "#EAB839", + "value": 35 + }, + { + "color": "semi-dark-red", + "value": 40 + } + ] + }, + "unit": "celsius" + }, + "overrides": [], + "values": false + }, + "orientation": "auto", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.temperature-System_Temp_system_board__7_2_, 'Mainboard Temperature')", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "System Board Temperature - $hostname", + "type": "gauge" + }, + { + "datasource": null, + "gridPos": { + "h": 4, + "w": 5, + "x": 0, + "y": 4 + }, + "id": 4, + "options": { + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + } + ] + } + }, + "overrides": [], + "values": false + }, + "orientation": "auto", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.power-PW_Consumption_power_management_board__21_0_, 'BMC Power Consumption')", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "BMC Power Consumption - $hostname", + "type": "gauge" + }, + { + "datasource": null, + "description": "Several H400 Systems (up to 4) may share the same H400 chassis, so chassis fan metrics aren't host-specific\n\nThis also applies to chassis hosting H-Series 300E, 500E, 700E compute nodes (which may be intermixed between them and also with H410C and even H401S nodes)", + "gridPos": { + "h": 4, + "w": 24, + "x": 0, + "y": 8 + }, + "id": 3, + "options": { + "displayMode": "basic", + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 0, + "mappings": [], + "max": 22000, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "#EAB839", + "value": 11000 + }, + { + "color": "red", + "value": 12000 + } + ] + }, + "unit": "rpm" + }, + "overrides": [], + "values": false + }, + "orientation": "auto", + "showUnfilled": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.fanspeed-FAN1_fan_cooling__29_1_, 'FAN1')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.fanspeed-FAN2_fan_cooling__29_2_, 'FAN2')", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Chassis Fan Speed", + "type": "bargauge" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": null, + "decimals": 0, + "description": "This panel serves to help you spot temperature trends in over days or weeks.", + "fill": 0, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 12, + "x": 0, + "y": 12 + }, + "hiddenSeries": false, + "id": 5, + "legend": { + "alignAsTable": false, + "avg": false, + "current": true, + "max": true, + "min": true, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pluginVersion": "6.7.4", + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.temperature-CPU1_Temp_processor__3_1_, 'CPU0 Temp')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.temperature-CPU2_Temp_processor__3_2_, 'CPU1 Temp')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "C", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.temperature-AOC_NIC_Temp____system_board__7_1_, 'NIC Temp')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "D", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.temperature-Inlet_Temp_system_board__7_3_, 'Inlet Temp')", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Temperature Indicators - $hostname", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:10044", + "decimals": 1, + "format": "short", + "label": "", + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "$$hashKey": "object:10045", + "decimals": 1, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": null, + "description": "Single chassis may be shared among up to 4 compute and/or storage nodes from Gen 1 (H300/H500/H700) and Gen 2 (H410) H-Series systems", + "fill": 0, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 12, + "x": 12, + "y": 12 + }, + "hiddenSeries": false, + "id": 9, + "legend": { + "alignAsTable": true, + "avg": false, + "current": true, + "max": true, + "min": true, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pluginVersion": "6.7.4", + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.fanspeed-FAN1_fan_cooling__29_1_, 'Fan1 Speed')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.$platform.$hostname.ipmi.fanspeed-FAN2_fan_cooling__29_2_, 'Fan2 Speed')", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Chassis Fan Speed", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:10044", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": "20000", + "min": "0", + "show": true + }, + { + "$$hashKey": "object:10045", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "NetApp HCI", + "Compute", + "IPMI" + ], + "templating": { + "list": [ + { + "allValue": null, + "current": { + "isNone": true, + "selected": false, + "tags": [], + "text": "h400", + "value": "h400" + }, + "datasource": "graphite", + "definition": "netapp.hci.compute.*", + "hide": 0, + "includeAll": false, + "index": -1, + "label": "NetApp HCI Compute Platform", + "multi": false, + "name": "platform", + "options": [ + { + "$$hashKey": "object:2093", + "selected": true, + "text": "h400", + "value": "h400" + }, + { + "$$hashKey": "object:2094", + "selected": false, + "text": "h410c22", + "value": "h410c22" + } + ], + "query": "netapp.hci.compute.*", + "refresh": 0, + "regex": "", + "skipUrlSync": false, + "sort": 1, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": null, + "current": { + "tags": [], + "text": "All", + "value": [ + "$__all" + ] + }, + "datasource": "graphite", + "definition": "netapp.hci.compute.$platform.*", + "hide": 0, + "includeAll": true, + "index": -1, + "label": "NetApp HCI Compute Host", + "multi": true, + "name": "hostname", + "options": [ + { + "$$hashKey": "object:14557", + "selected": true, + "text": "All", + "value": "$__all" + }, + { + "$$hashKey": "object:14558", + "selected": false, + "text": "h410c21", + "value": "h410c21" + }, + { + "$$hashKey": "object:14559", + "selected": false, + "text": "h410c22", + "value": "h410c22" + }, + { + "$$hashKey": "object:14560", + "selected": false, + "text": "h615t4", + "value": "h615t4" + }, + { + "$$hashKey": "object:14561", + "selected": false, + "text": "h615t4bmc", + "value": "h615t4bmc" + } + ], + "query": "netapp.hci.compute.$platform.*", + "refresh": 0, + "regex": "", + "skipUrlSync": false, + "sort": 1, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-6h", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ] + }, + "timezone": "", + "title": "NetApp HCI - H400 Series Chasis and Server Systems", + "uid": "BvHeQJmGz", + "variables": { + "list": [] + }, + "version": 14 +} \ No newline at end of file diff --git a/grafana/dashboards/h-series-compute-h615c-ipmi.json b/grafana/dashboards/h-series-compute-h615c-ipmi.json new file mode 100644 index 0000000..204ae9d --- /dev/null +++ b/grafana/dashboards/h-series-compute-h615c-ipmi.json @@ -0,0 +1,900 @@ +{ + "annotations": { + "list": [ + { + "$$hashKey": "object:2019", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "limit": 100, + "name": "Annotations & Alerts", + "showIn": 0, + "type": "dashboard" + } + ] + }, + "description": "Hardware Metrics for NetApp H-Series 615C (IPMI)", + "editable": true, + "gnetId": 24, + "graphTooltip": 1, + "id": 12, + "iteration": 1591852292413, + "links": [], + "panels": [ + { + "bgColor": "#8AB8FF", + "clockType": "24 hour", + "countdownSettings": { + "customFormat": null, + "endCountdownTime": "2020-06-11T11:32:00.000Z", + "endText": "00:00:00" + }, + "datasource": null, + "dateSettings": { + "dateFormat": "YYYY-MM-DD", + "fontSize": "20px", + "fontWeight": "normal", + "showDate": false + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 0, + "y": 0 + }, + "id": 26, + "mode": "time", + "refreshSettings": { + "syncWithDashboard": false + }, + "targets": [ + { + "refId": "A", + "target": "" + } + ], + "timeFrom": null, + "timeSettings": { + "customFormat": "HH:mm:ss", + "fontSize": "60px", + "fontWeight": "normal" + }, + "timeShift": null, + "timezone": "Asia/Taipei", + "timezoneSettings": { + "fontSize": "12px", + "fontWeight": "normal", + "showTimezone": false, + "zoneFormat": "nameOffset" + }, + "title": "Time", + "type": "grafana-clock-panel" + }, + { + "datasource": null, + "description": "Different systems have different operating ranges and different data centers run at different temperatures. Feel free to examine the details of sensor that's measured and adjust Warning and Critical level for your environment. \n\nNote that Grafana alerts need to be separately configured.", + "gridPos": { + "h": 8, + "w": 6, + "x": 6, + "y": 0 + }, + "id": 28, + "options": { + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 1, + "mappings": [], + "max": 50, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "semi-dark-orange", + "value": 35 + }, + { + "color": "semi-dark-red", + "value": 40 + } + ] + }, + "title": "", + "unit": "celsius" + }, + "overrides": [], + "values": false + }, + "orientation": "auto", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_PCH_system_board__7_1_, 'System Board Temperature')" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "System Board Temperature - $hostname", + "type": "gauge" + }, + { + "datasource": null, + "description": "Different CPUs have different operating temperatures, so gauge thresholds should probably be customized for the CPU with lowest operating temperatures in your environment.\n\nExample: Intel Xeon Gold 6240Y - Max 74C, so we may want to see a warning at 55C and critical at 65C", + "gridPos": { + "h": 8, + "w": 12, + "x": 12, + "y": 0 + }, + "id": 27, + "options": { + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 1, + "mappings": [], + "max": 90, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "semi-dark-orange", + "value": 50 + }, + { + "color": "semi-dark-red", + "value": 60 + } + ] + }, + "title": "", + "unit": "celsius" + }, + "overrides": [], + "values": false + }, + "orientation": "auto", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_CPU0_invalid__65_1_, 'CPU0')" + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_CPU1_invalid__65_1_, 'CPU1')" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "CPU Temperature - $hostname", + "type": "gauge" + }, + { + "cacheTimeout": null, + "colorBackground": false, + "colorPrefix": false, + "colorValue": true, + "colors": [ + "#299c46", + "rgba(237, 129, 40, 0.89)", + "#d44a3a" + ], + "datasource": null, + "decimals": 1, + "description": "", + "format": "volt", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 0, + "y": 4 + }, + "id": 24, + "interval": null, + "links": [], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:6424", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:6425", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "nullPointMode": "connected", + "nullText": null, + "pluginVersion": "6.7.4", + "postfix": "", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "rgb(31, 120, 193)", + "show": true, + "ymax": null, + "ymin": 10 + }, + "tableColumn": "", + "targets": [ + { + "hide": false, + "refCount": 0, + "refId": "B", + "target": "aliasByNode(netapp.hci.compute.h615.$hostname.ipmi.voltage-Volt_P12V_system_board__7_1_, 3)", + "textEditor": false + } + ], + "thresholds": "", + "timeFrom": null, + "timeShift": null, + "title": "System Board Voltage", + "type": "singlestat", + "valueFontSize": "150%", + "valueMaps": [ + { + "$$hashKey": "object:6427", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": null, + "description": "This panel serves to help you spot temperature trends in over days or weeks.", + "fill": 0, + "fillGradient": 0, + "gridPos": { + "h": 6, + "w": 12, + "x": 0, + "y": 8 + }, + "hiddenSeries": false, + "id": 30, + "legend": { + "alignAsTable": false, + "avg": false, + "current": false, + "max": true, + "min": false, + "rightSide": true, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_Inlet_processor__3_0_, 'Inlet Processor')" + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_Outlet_system_board__7_1_, 'Outlet System Board')" + }, + { + "refCount": 0, + "refId": "C", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_CPU0_invalid__65_1_, 'CPU0')" + }, + { + "refCount": 0, + "refId": "D", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_CPU1_invalid__65_1_, 'CPU1')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "E", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_GPU1_system_board__7_0_, 'GPU1')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "F", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_GPU2_system_board__7_0_, 'GPU2')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "G", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_GPU3_system_board__7_0_, 'GPU3')", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Temperature Indicators - $hostname", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:9067", + "decimals": null, + "format": "celsius", + "label": null, + "logBase": 1, + "max": "90", + "min": "20", + "show": true + }, + { + "$$hashKey": "object:9068", + "decimals": null, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": null, + "decimals": 0, + "description": "Average fan speeds are expected to be consistent if system workload and environment temperature remain stable.\n\nIf BIOS settings that impact Power Consumption are changed, Fan Speeds are likely to change as well.", + "fill": 6, + "fillGradient": 6, + "gridPos": { + "h": 6, + "w": 12, + "x": 12, + "y": 8 + }, + "hiddenSeries": false, + "id": 31, + "legend": { + "alignAsTable": false, + "avg": false, + "current": false, + "max": true, + "min": true, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(consolidateBy(netapp.hci.compute.h615.$hostname.ipmi.fanspeed-Fan_SYS1_1_system_board__7_0_, 'average'), 'Avg Fan RPM')" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Fan Speeds - $hostname", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:9177", + "decimals": 0, + "format": "rpm", + "label": "", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:9178", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "cacheTimeout": "", + "datasource": null, + "gridPos": { + "h": 4, + "w": 24, + "x": 0, + "y": 14 + }, + "id": 20, + "maxPerRow": 12, + "options": { + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 0, + "mappings": [], + "max": 22000, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "semi-dark-green", + "value": null + }, + { + "color": "light-orange", + "value": 15000 + }, + { + "color": "semi-dark-red", + "value": 18000 + } + ] + }, + "unit": "rpm" + }, + "overrides": [], + "values": false + }, + "orientation": "auto", + "showThresholdLabels": false, + "showThresholdMarkers": false + }, + "pluginVersion": "6.7.4", + "repeat": null, + "repeatDirection": "h", + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.*Fan_SYS0_0*, 'Fan1')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.*Fan_SYS1_0*, 'Fan2')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "C", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.*Fan_SYS2_0*, 'Fan3')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "D", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.*Fan_SYS3_0*, 'Fan4')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "E", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.*Fan_SYS4_0*, 'Fan5')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "F", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.*Fan_SYS5_0*, 'Fan6')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "G", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.*Fan_SYS6_0*, 'Fan7')", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Chassis Fan Speed", + "type": "gauge" + }, + { + "cacheTimeout": "", + "datasource": null, + "description": "Power Consumption does not have \"critical level\" per se, as PSU on the H615C are redundant so should one PSU fail, the other can consume \"twice as much\" power.\n\nHowever, users who care about energy consumption may want to examine system activity in the case it regularly consumes more power than expected.", + "gridPos": { + "h": 6, + "w": 12, + "x": 0, + "y": 18 + }, + "id": 23, + "options": { + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 0, + "mappings": [], + "max": 1100, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "light-orange", + "value": 500 + }, + { + "color": "light-red", + "value": 750 + } + ] + }, + "unit": "watt" + }, + "overrides": [], + "values": false + }, + "orientation": "auto", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.h615.h615t4.ipmi.power-PSU0_Input_power_supply__10_1_, 'PSU1')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.h615.h615t4.ipmi.power-PSU1_Input_power_supply__10_1_, 'PSU2')", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Power Consumption - $hostname", + "type": "gauge" + }, + { + "datasource": null, + "description": "If you don't have a H615C-A4321 in your environment, you may delete this panel. \n\nMaximum NVIDIA Tesla T4 operating temperature is 86C. \n\nNote that Grafana alerts need to be separately configured.", + "gridPos": { + "h": 6, + "w": 12, + "x": 12, + "y": 18 + }, + "id": 22, + "options": { + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 1, + "mappings": [], + "max": 90, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "semi-dark-orange", + "value": 70 + }, + { + "color": "semi-dark-red", + "value": 80 + } + ] + }, + "title": "", + "unit": "celsius" + }, + "overrides": [], + "values": false + }, + "orientation": "auto", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_GPU1_system_board__7_0_, 'GPU0')" + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_GPU2_system_board__7_0_, 'GPU1')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "C", + "target": "alias(netapp.hci.compute.h615.$hostname.ipmi.temperature-Temp_GPU2_system_board__7_0_, 'GPU2')", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "GPU Temperature", + "type": "gauge" + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "NetApp HCI", + "Compute", + "IPMI" + ], + "templating": { + "list": [ + { + "allValue": null, + "current": { + "tags": [], + "text": "h400", + "value": "h400" + }, + "datasource": "graphite", + "definition": "netapp.hci.compute.*", + "hide": 0, + "includeAll": false, + "index": -1, + "label": "NetApp HCI System Series", + "multi": false, + "name": "platform", + "options": [ + { + "$$hashKey": "object:6347", + "selected": true, + "text": "h400", + "value": "h400" + }, + { + "$$hashKey": "object:6348", + "selected": false, + "text": "h410c22", + "value": "h410c22" + }, + { + "$$hashKey": "object:6349", + "selected": false, + "text": "h600", + "value": "h600" + }, + { + "$$hashKey": "object:6350", + "selected": false, + "text": "h615", + "value": "h615" + } + ], + "query": "netapp.hci.compute.*", + "refresh": 0, + "regex": "", + "skipUrlSync": false, + "sort": 1, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": null, + "current": { + "tags": [], + "text": "h615t4", + "value": "h615t4" + }, + "datasource": "graphite", + "definition": "netapp.hci.compute.h615.*", + "hide": 0, + "includeAll": false, + "index": -1, + "label": "NetApp HCI System System", + "multi": false, + "name": "hostname", + "options": [ + { + "$$hashKey": "object:6397", + "selected": true, + "text": "h615t4", + "value": "h615t4" + }, + { + "$$hashKey": "object:6398", + "selected": false, + "text": "h615t4bmc", + "value": "h615t4bmc" + }, + { + "$$hashKey": "object:6399", + "selected": false, + "text": "ubuntu", + "value": "ubuntu" + } + ], + "query": "netapp.hci.compute.h615.*", + "refresh": 0, + "regex": "", + "skipUrlSync": false, + "sort": 1, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-1h", + "to": "now" + }, + "timepicker": { + "now": true, + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "browser", + "title": "NetApp HCI - H615C Server Systems", + "uid": "8xpgKJiGz", + "variables": { + "list": [] + }, + "version": 16 +} \ No newline at end of file diff --git a/grafana/dashboards/solidfire-cluster.json b/grafana/dashboards/solidfire-cluster.json new file mode 100644 index 0000000..44afd55 --- /dev/null +++ b/grafana/dashboards/solidfire-cluster.json @@ -0,0 +1,1910 @@ +{ + "__inputs": [ + { + "name": "DS_GRAPHITE", + "label": "graphite", + "description": "", + "type": "datasource", + "pluginId": "graphite", + "pluginName": "Graphite" + } + ], + "__requires": [ + { + "type": "panel", + "id": "gauge", + "name": "Gauge", + "version": "" + }, + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "6.7.4" + }, + { + "type": "panel", + "id": "grafana-clock-panel", + "name": "Clock", + "version": "1.0.3" + }, + { + "type": "panel", + "id": "graph", + "name": "Graph", + "version": "" + }, + { + "type": "datasource", + "id": "graphite", + "name": "Graphite", + "version": "1.0.0" + }, + { + "type": "panel", + "id": "singlestat", + "name": "Singlestat", + "version": "" + } + ], + "annotations": { + "list": [ + { + "$$hashKey": "object:1530", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "Metrics for Element cluster", + "editable": true, + "gnetId": null, + "graphTooltip": 1, + "id": null, + "iteration": 1597136723392, + "links": [ + { + "$$hashKey": "object:4901", + "icon": "external link", + "tags": [], + "targetBlank": true, + "title": "SolidFire UI - Cluster $Cluster", + "type": "link", + "url": "https://192.168.1.30/" + } + ], + "panels": [ + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 37, + "panels": [], + "repeat": null, + "title": "Element Cluster Alerts", + "type": "row" + }, + { + "bgColor": "#8F3BB8", + "clockType": "12 hour", + "countdownSettings": { + "customFormat": null, + "endCountdownTime": "2020-06-06T17:28:00.000Z", + "endText": "00:00:00" + }, + "datasource": "${DS_GRAPHITE}", + "dateSettings": { + "dateFormat": "YYYY-MM-DD", + "fontSize": "20px", + "fontWeight": "normal", + "showDate": true + }, + "description": "", + "gridPos": { + "h": 4, + "w": 6, + "x": 0, + "y": 1 + }, + "id": 43, + "mode": "time", + "refreshSettings": { + "syncWithDashboard": false + }, + "targets": [ + { + "refId": "A", + "target": "" + } + ], + "timeFrom": null, + "timeSettings": { + "customFormat": "HH:mm:ss", + "fontSize": "50px", + "fontWeight": "normal" + }, + "timeShift": null, + "timezone": "Asia/Taipei", + "timezoneSettings": { + "fontSize": "12px", + "fontWeight": "normal", + "showTimezone": true, + "zoneFormat": "nameOffset" + }, + "title": "", + "type": "grafana-clock-panel" + }, + { + "cacheTimeout": null, + "colorBackground": true, + "colorValue": false, + "colors": [ + "#299c46", + "rgba(237, 129, 40, 0.89)", + "#d44a3a" + ], + "datasource": "${DS_GRAPHITE}", + "format": "none", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 4, + "w": 2, + "x": 6, + "y": 1 + }, + "height": "", + "id": 34, + "interval": null, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Active Alerts (Warnings)", + "url": "https://192.168.1.30/cluster/#/reporting/alerts?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D,%22severity%22:%7B%22func%22:%22contains%22,%22params%22:%7B%22value%22:%22warning%22%7D%7D%7D" + } + ], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:3503", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:3504", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "nullPointMode": "connected", + "nullText": null, + "postfix": "", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "rgb(31, 120, 193)", + "show": false + }, + "tableColumn": "", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.fault.warning", + "textEditor": false + } + ], + "thresholds": "1", + "title": "Warnings", + "type": "singlestat", + "valueFontSize": "80%", + "valueMaps": [ + { + "$$hashKey": "object:3506", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "cacheTimeout": null, + "colorBackground": true, + "colorValue": false, + "colors": [ + "#299c46", + "rgba(237, 129, 40, 0.89)", + "#d44a3a" + ], + "datasource": "${DS_GRAPHITE}", + "format": "none", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 4, + "w": 2, + "x": 8, + "y": 1 + }, + "id": 35, + "interval": null, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Active Alerts (Errors)", + "url": "https://192.168.1.30/cluster/#/reporting/alerts?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D,%22severity%22:%7B%22func%22:%22contains%22,%22params%22:%7B%22value%22:%22error%22%7D%7D%7D" + } + ], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:3722", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:3723", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "nullPointMode": "connected", + "nullText": null, + "postfix": "", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "rgb(31, 120, 193)", + "show": false + }, + "tableColumn": "", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.fault.error", + "textEditor": false + } + ], + "thresholds": "1,1", + "title": "Errors", + "type": "singlestat", + "valueFontSize": "80%", + "valueMaps": [ + { + "$$hashKey": "object:3725", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "cacheTimeout": null, + "colorBackground": true, + "colorValue": false, + "colors": [ + "#299c46", + "rgba(237, 129, 40, 0.89)", + "#d44a3a" + ], + "datasource": "${DS_GRAPHITE}", + "format": "none", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 4, + "w": 2, + "x": 10, + "y": 1 + }, + "id": 36, + "interval": null, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Active Alerts (Critical Events)", + "url": "https://192.168.1.30/cluster/#/reporting/alerts?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D,%22severity%22:%7B%22func%22:%22contains%22,%22params%22:%7B%22value%22:%22critical%22%7D%7D%7D" + } + ], + "mappingType": 1, + "mappingTypes": [ + { + "name": "value to text", + "value": 1 + }, + { + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "nullPointMode": "connected", + "nullText": null, + "postfix": "", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "rgb(31, 120, 193)", + "show": false + }, + "tableColumn": "", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.fault.critical", + "textEditor": false + } + ], + "thresholds": "1,1", + "title": "Critical", + "type": "singlestat", + "valueFontSize": "80%", + "valueMaps": [ + { + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "aliasColors": { + "Cluster Critical Faults": "dark-red", + "Cluster Errors": "dark-orange", + "Cluster Warnigs": "light-yellow" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 0, + "fillGradient": 0, + "gridPos": { + "h": 4, + "w": 12, + "x": 12, + "y": 1 + }, + "hiddenSeries": false, + "id": 33, + "legend": { + "alignAsTable": true, + "avg": false, + "current": true, + "hideEmpty": false, + "hideZero": false, + "max": false, + "min": false, + "rightSide": true, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Resolved Alerts (History)", + "url": "https://192.168.1.30/cluster/#/reporting/alerts?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22resolved%22%7D%7D%7D" + } + ], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 0.5, + "points": true, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": true, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(sumSeries(netapp.solidfire.cluster.$Cluster.fault.critical), 'Cluster Critical Faults')" + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(sumSeries(netapp.solidfire.cluster.$Cluster.fault.error), 'Cluster Errors')" + }, + { + "hide": false, + "refCount": 0, + "refId": "C", + "target": "alias(sumSeries(netapp.solidfire.cluster.$Cluster.fault.warning), 'Cluster Warnigs')" + } + ], + "thresholds": [ + { + "$$hashKey": "object:659", + "colorMode": "warning", + "fill": true, + "line": true, + "op": "gt", + "value": 0, + "yaxis": "left" + } + ], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Fault History", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:629", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": "5", + "min": "0", + "show": true + }, + { + "$$hashKey": "object:630", + "decimals": 0, + "format": "short", + "label": "", + "logBase": 1, + "max": null, + "min": "0", + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 5 + }, + "id": 38, + "panels": [], + "repeat": null, + "title": "Storage Efficiencies", + "type": "row" + }, + { + "cacheTimeout": null, + "colorBackground": true, + "colorValue": false, + "colors": [ + "rgba(245, 54, 54, 0.9)", + "rgba(237, 129, 40, 0.89)", + "rgba(50, 172, 45, 0.97)" + ], + "datasource": "${DS_GRAPHITE}", + "decimals": 2, + "description": "Changes in compression factor are not instantly obvservable. \n\nIt may take up to an hour for changes to reflect in values obtained from the cluster API.\n", + "editable": true, + "error": false, + "format": "none", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 3, + "w": 6, + "x": 0, + "y": 6 + }, + "id": 22, + "interval": null, + "links": [], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:20721", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:20722", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "nullPointMode": "connected", + "nullText": null, + "postfix": ":1", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "rgb(31, 120, 193)", + "show": false + }, + "tableColumn": "", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.compression_factor", + "textEditor": false + } + ], + "thresholds": ".9,1.5", + "title": "Compression Factor", + "type": "singlestat", + "valueFontSize": "80%", + "valueMaps": [ + { + "$$hashKey": "object:20724", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "cacheTimeout": null, + "colorBackground": true, + "colorValue": false, + "colors": [ + "rgba(245, 54, 54, 0.9)", + "rgba(237, 129, 40, 0.89)", + "rgba(50, 172, 45, 0.97)" + ], + "datasource": "${DS_GRAPHITE}", + "decimals": 2, + "description": "Changes in deduplication factor are not instantly obvservable. \n\nIt may take up to an hour for changes to reflect in values obtained from the cluster API.", + "editable": true, + "error": false, + "format": "none", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 3, + "w": 6, + "x": 6, + "y": 6 + }, + "height": "", + "id": 21, + "interval": null, + "links": [], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:2350", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:2351", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "nullPointMode": "connected", + "nullText": null, + "postfix": ":1", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "rgb(31, 120, 193)", + "show": false + }, + "tableColumn": "", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.dedupe_factor", + "textEditor": false + } + ], + "thresholds": "1.5,2", + "title": "Deduplication Factor", + "type": "singlestat", + "valueFontSize": "80%", + "valueMaps": [ + { + "$$hashKey": "object:2353", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "cacheTimeout": null, + "colorBackground": true, + "colorValue": false, + "colors": [ + "rgba(245, 54, 54, 0.9)", + "rgba(237, 129, 40, 0.89)", + "rgba(50, 172, 45, 0.97)" + ], + "datasource": "${DS_GRAPHITE}", + "description": "Efficiency factor shown here is product of Compression and Deduplication. \n\nIt can easily be modified to also consider Thin Provisioning.", + "editable": true, + "error": false, + "format": "none", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 3, + "w": 6, + "x": 12, + "y": 6 + }, + "id": 23, + "interval": null, + "links": [], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:3415", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:3416", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": "200", + "nullPointMode": "connected", + "nullText": null, + "postfix": ":1", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "rgb(31, 120, 193)", + "show": false + }, + "tableColumn": "", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.efficiency_cxd_factor", + "textEditor": false + } + ], + "thresholds": "2, 2.5, 3", + "title": "Efficiency Factor", + "type": "singlestat", + "valueFontSize": "80%", + "valueMaps": [ + { + "$$hashKey": "object:3418", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "cacheTimeout": null, + "colorBackground": false, + "colorPostfix": false, + "colorPrefix": false, + "colorValue": true, + "colors": [ + "rgba(245, 54, 54, 0.9)", + "rgba(237, 129, 40, 0.89)", + "rgba(50, 172, 45, 0.97)" + ], + "datasource": "${DS_GRAPHITE}", + "decimals": null, + "description": "Ratio of all (zero and non-zero) blocks vs. non-zero blocks.\n\nIt may take up to an hour for changes to reflect in values obtained from the cluster API.", + "editable": true, + "error": false, + "format": "none", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 3, + "w": 6, + "x": 18, + "y": 6 + }, + "id": 20, + "interval": null, + "links": [], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:21346", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:21347", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "nullPointMode": "connected", + "nullText": null, + "postfix": ":1", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "rgb(31, 120, 193)", + "show": false + }, + "tableColumn": "", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.thin_factor", + "textEditor": false + } + ], + "thresholds": "1.5,3", + "title": "Thin Provisioning Factor", + "type": "singlestat", + "valueFontSize": "80%", + "valueMaps": [ + { + "$$hashKey": "object:21349", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 9 + }, + "id": 39, + "panels": [], + "repeat": null, + "title": "Cluster Performance", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 8, + "x": 0, + "y": 10 + }, + "hiddenSeries": false, + "id": 30, + "legend": { + "alignAsTable": false, + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refId": "A", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.readOps), 5), 'Read IOPS')" + }, + { + "hide": false, + "refId": "B", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.writeOps), 5), 'Write IOPS')", + "textEditor": false + }, + { + "hide": false, + "refId": "C", + "target": "alias(keepLastValue(perSecond(sumSeries(netapp.solidfire.cluster.$Cluster.{readOps,writeOps})), 5), 'Total IOPS')", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster IOPS", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:1840", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:1841", + "decimals": 0, + "format": "short", + "label": "", + "logBase": 1, + "max": null, + "min": null, + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 7, + "w": 8, + "x": 8, + "y": 10 + }, + "hiddenSeries": false, + "hideTimeOverride": false, + "id": 8, + "legend": { + "alignAsTable": false, + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": true, + "refId": "B", + "target": "alias(keepLastValue(netapp.solidfire.cluster.$Cluster.readBytesLastSample, 5), '$Cluster Read Bytes/s')" + }, + { + "hide": true, + "refId": "A", + "target": "alias(keepLastValue(netapp.solidfire.cluster.$Cluster.writeBytesLastSample, 5), '$Cluster Write Bytes/s')" + }, + { + "refId": "C", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.readBytes), 5), 'Read Bytes/s')" + }, + { + "refId": "D", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.writeBytes), 5), 'Write Bytes/s')" + }, + { + "refId": "E", + "target": "alias(keepLastValue(sumSeries(perSecond(netapp.solidfire.cluster.$Cluster.{readBytes,writeBytes})), 5), 'Total Bytes/s')" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster Read/Write Bytes / s", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2063", + "decimals": 0, + "format": "Bps", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:2064", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "cacheTimeout": "", + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 8, + "x": 16, + "y": 10 + }, + "hiddenSeries": false, + "id": 31, + "legend": { + "avg": true, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "alias(keepLastValue(netapp.solidfire.cluster.$Cluster.clusterRecentIOSize, 5), 'I/O Size')" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster Cluster Recent I/O Size", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2160", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:2161", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 17 + }, + "id": 40, + "panels": [], + "repeat": null, + "title": "Cluster Utilization", + "type": "row" + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 7, + "w": 8, + "x": 0, + "y": 18 + }, + "id": 29, + "links": [], + "options": { + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 1, + "mappings": [ + { + "$$hashKey": "object:2452", + "id": 0, + "op": "=", + "text": "N/A", + "type": 1, + "value": "null" + } + ], + "max": 100, + "min": 0, + "nullValueMode": "connected", + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#299c46", + "value": null + }, + { + "color": "rgba(237, 129, 40, 0.89)", + "value": 60 + }, + { + "color": "#d44a3a", + "value": 80 + } + ] + }, + "unit": "percentunit" + }, + "overrides": [], + "values": false + }, + "orientation": "horizontal", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.clusterUtilization" + } + ], + "title": "$Cluster Current Cluster Utilization", + "type": "gauge" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "CPU utilization of all SolidFire nodes in the selected cluster over time", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 8, + "x": 8, + "y": 18 + }, + "hiddenSeries": false, + "id": 28, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByNode(scale(keepLastValue(netapp.solidfire.cluster.$Cluster.clusterUtilizationScaled, 5), 100), 3)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster Utilization Over Time", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2553", + "decimals": 0, + "format": "percent", + "label": null, + "logBase": 1, + "max": "100", + "min": "0", + "show": true + }, + { + "$$hashKey": "object:2554", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": "100", + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 8, + "x": 16, + "y": 18 + }, + "hiddenSeries": false, + "id": 32, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Active Storage Nodes", + "url": "https://192.168.1.30/cluster/#/system/nodes?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D%7D" + } + ], + "nullPointMode": "null as zero", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.node.*.cpu, 5), 5)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster Node CPU Usage per Node", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2268", + "decimals": 0, + "format": "short", + "label": "", + "logBase": 1, + "max": "100", + "min": "0", + "show": true + }, + { + "$$hashKey": "object:2269", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": "100", + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Active iSCSI sessions may be up to several hundred per storage node (see Element documentation) and depending on other factors (multipathing, number of clients connecting to each volume) it can be 2X or more of the number of active volumes.\n\nClusters with lots of volumes (Kubernetes, for example) may need to pay attention to this number.\n\nWhen the number of sessions goes up and down by the same number, there may be iSCSI clients out there trying to connect to non-existing targets.\n\n", + "editable": true, + "error": false, + "fill": 1, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 7, + "w": 8, + "x": 0, + "y": 25 + }, + "hiddenSeries": false, + "id": 19, + "legend": { + "alignAsTable": false, + "avg": false, + "current": true, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 2, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - iSCSI Sessions", + "url": "" + } + ], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [ + { + "$$hashKey": "object:2980", + "alias": "peakActiveSessions", + "bars": false, + "fill": 0, + "lines": true, + "linewidth": 1 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": true, + "targets": [ + { + "refId": "B", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.activeSessions, 5), 3)", + "textEditor": false + }, + { + "hide": true, + "refId": "A", + "target": "aliasByMetric(netapp.solidfire.cluster.$Cluster.peakActiveSessions)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster Active iSCSI Sessions", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2999", + "decimals": 0, + "format": "none", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:3000", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "cacheTimeout": "", + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "It is expected to see one Block (used for volume metadata) and several Data (used for client data) disks per each SolidFire storage node.\n\nUnexpected changes should be examined.\n\n", + "editable": true, + "error": false, + "fill": 1, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 7, + "w": 8, + "x": 8, + "y": 25 + }, + "height": "", + "hiddenSeries": false, + "id": 27, + "legend": { + "alignAsTable": false, + "avg": false, + "current": true, + "hideEmpty": false, + "hideZero": false, + "max": false, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Disk Drives", + "url": "https://192.168.1.30/cluster/#/system/drives?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D%7D" + } + ], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "C", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.drives.*.volume, 5), 6)", + "textEditor": false + }, + { + "refCount": 0, + "refId": "A", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.drives.*.block, 5), 6)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster Drive Count", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:3429", + "decimals": 0, + "format": "none", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:3430", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 1, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 7, + "w": 8, + "x": 16, + "y": 25 + }, + "hiddenSeries": false, + "id": 4, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 2, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Volume Performance", + "url": "https://192.168.1.30/cluster/#/reporting/volume-performance?page=1" + } + ], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 1, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.clientQueueDepth, 5), 3)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster Client Queue Depth", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:3096", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:3097", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "SolidFire", + "NetApp HCI" + ], + "templating": { + "list": [ + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": true, + "index": -1, + "label": "Cluster Name", + "multi": true, + "name": "Cluster", + "options": [], + "query": "netapp.solidfire.cluster.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-30m", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "browser", + "title": "NetApp HCI - SolidFire Cluster", + "uid": "T6iPgf6kz", + "variables": { + "list": [] + }, + "version": 4 +} diff --git a/grafana/dashboards/solidfire-histograms.json b/grafana/dashboards/solidfire-histograms.json new file mode 100644 index 0000000..0efc627 --- /dev/null +++ b/grafana/dashboards/solidfire-histograms.json @@ -0,0 +1,662 @@ +{ + "__inputs": [ + { + "name": "DS_GRAPHITE", + "label": "graphite", + "description": "", + "type": "datasource", + "pluginId": "graphite", + "pluginName": "Graphite" + } + ], + "__requires": [ + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "6.7.4" + }, + { + "type": "panel", + "id": "graph", + "name": "Graph", + "version": "" + }, + { + "type": "datasource", + "id": "graphite", + "name": "Graphite", + "version": "1.0.0" + }, + { + "type": "panel", + "id": "heatmap", + "name": "Heatmap", + "version": "" + }, + { + "type": "panel", + "id": "stat", + "name": "Stat", + "version": "" + } + ], + "annotations": { + "list": [ + { + "$$hashKey": "object:5384", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "editable": true, + "gnetId": null, + "graphTooltip": 0, + "id": null, + "iteration": 1597139506431, + "links": [ + { + "$$hashKey": "object:5840", + "icon": "external link", + "includeVars": true, + "tags": [], + "targetBlank": true, + "title": "SolidFire UI - Volume Performance Details", + "tooltip": "Volume performance details in SolidFire Web UI", + "type": "link", + "url": "https://192.168.1.30/cluster/#/management/volumes/volume-details?page=1&volumeID=$volumeID" + } + ], + "panels": [ + { + "aliasColors": { + "averageIOPSize": "red" + }, + "bars": true, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "fill": 0, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 24, + "x": 0, + "y": 0 + }, + "hiddenSeries": false, + "id": 11, + "legend": { + "alignAsTable": false, + "avg": false, + "current": false, + "max": false, + "min": false, + "rightSide": true, + "show": true, + "total": false, + "values": false + }, + "lines": false, + "linewidth": 2, + "nullPointMode": "null as zero", + "options": { + "dataLinks": [] + }, + "percentage": true, + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": true, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "aliasByMetric(derivative(netapp.solidfire.cluster.$cluster.volumeID.$volumeID.readBlockSizes.*))", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Histogram of Read Requests for Volume $volumeID", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "transparent": true, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:6472", + "decimals": 0, + "format": "short", + "label": "Number of requests per Bucket", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:6473", + "format": "short", + "label": "Bucket size of added IO requests", + "logBase": 1, + "max": null, + "min": "0", + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": { + "averageIOPSize": "red" + }, + "bars": true, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "fill": 0, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 24, + "x": 0, + "y": 7 + }, + "hiddenSeries": false, + "id": 12, + "legend": { + "alignAsTable": false, + "avg": false, + "current": false, + "hideEmpty": false, + "hideZero": false, + "max": false, + "min": false, + "rightSide": true, + "show": true, + "total": false, + "values": false + }, + "lines": false, + "linewidth": 2, + "nullPointMode": "null as zero", + "options": { + "dataLinks": [] + }, + "percentage": true, + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": true, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "aliasByMetric(derivative(netapp.solidfire.cluster.$cluster.volumeID.$volumeID.writeBlockSizes.*))", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Histogram of Write Requests for Volume $volumeID", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "transparent": true, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:6472", + "decimals": 0, + "format": "short", + "label": "Number of requests per Bucket", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:6473", + "format": "short", + "label": "Bucket size of added IO requests", + "logBase": 1, + "max": null, + "min": "0", + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": true, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Actual IOPS may be useful for comparison vs. by-bucket IO request size breakdown obtained from QoS histograms", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 22, + "x": 0, + "y": 14 + }, + "hiddenSeries": false, + "id": 2, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": false, + "linewidth": 1, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pluginVersion": "6.7.3", + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "substr(netapp.solidfire.cluster.$cluster.volumeID.$volumeID.actualIOPS, 5, 6)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Actual IOPS for Volume $volumeID", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "transparent": true, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2106", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:2107", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "description": "How much the client is using the volume (0% - it's not, 120% - it's using Burst IOPS)", + "gridPos": { + "h": 7, + "w": 2, + "x": 22, + "y": 14 + }, + "id": 17, + "links": [], + "options": { + "colorMode": "background", + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 0, + "mappings": [], + "max": 150, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "dark-yellow", + "value": null + }, + { + "color": "semi-dark-orange", + "value": 50 + }, + { + "color": "semi-dark-red", + "value": 75 + } + ] + }, + "title": "Busy", + "unit": "percent" + }, + "overrides": [], + "values": false + }, + "graphMode": "area", + "justifyMode": "center", + "orientation": "auto" + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "$$hashKey": "object:2473", + "aggregation": "Last", + "decimals": 2, + "displayAliasType": "Warning / Critical", + "displayType": "Regular", + "displayValueWithAlias": "Never", + "hide": false, + "refCount": 0, + "refId": "B", + "target": "netapp.solidfire.cluster.$cluster.volumeID.$volumeID.volumeUtilization", + "units": "none", + "valueHandler": "Number Threshold" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Utilization", + "transparent": true, + "type": "stat" + }, + { + "cards": { + "cardPadding": null, + "cardRound": null + }, + "color": { + "cardColor": "#1F60C4", + "colorScale": "sqrt", + "colorScheme": "interpolateOranges", + "exponent": 0.9, + "min": null, + "mode": "opacity" + }, + "dataFormat": "tsbuckets", + "datasource": "${DS_GRAPHITE}", + "description": "This charts loses meaning if QoS policies have been changed during observed period", + "gridPos": { + "h": 7, + "w": 22, + "x": 0, + "y": 21 + }, + "heatmap": {}, + "hideZeroBuckets": true, + "highlightCards": true, + "id": 14, + "legend": { + "show": false + }, + "pluginVersion": "6.5.1", + "reverseYBuckets": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "aliasByMetric(derivative(netapp.solidfire.cluster.$cluster.volumeID.$volumeID.belowMinIopsPercentages.*))", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Volume Heatmap (Time Spent Below Min IOPS) Volume $volumeID", + "tooltip": { + "show": true, + "showHistogram": false + }, + "transparent": true, + "type": "heatmap", + "xAxis": { + "show": true + }, + "xBucketNumber": null, + "xBucketSize": null, + "yAxis": { + "decimals": 0, + "format": "short", + "logBase": 1, + "max": null, + "min": null, + "show": true, + "splitFactor": null + }, + "yBucketBound": "middle", + "yBucketNumber": null, + "yBucketSize": null + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "description": "How much time the system is throttling this volume (0% - no throttling)", + "gridPos": { + "h": 7, + "w": 2, + "x": 22, + "y": 21 + }, + "id": 16, + "links": [], + "options": { + "colorMode": "background", + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 0, + "mappings": [], + "max": 100, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "light-blue", + "value": null + }, + { + "color": "#EAB839", + "value": 50 + }, + { + "color": "semi-dark-red", + "value": 75 + } + ] + }, + "title": "Throttle", + "unit": "percentunit" + }, + "overrides": [], + "values": false + }, + "graphMode": "none", + "justifyMode": "center", + "orientation": "auto" + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "$$hashKey": "object:2473", + "aggregation": "Last", + "decimals": 2, + "displayAliasType": "Warning / Critical", + "displayType": "Regular", + "displayValueWithAlias": "Never", + "hide": false, + "refCount": 0, + "refId": "B", + "target": "netapp.solidfire.cluster.$cluster.volumeID.$volumeID.throttle", + "units": "none", + "valueHandler": "Number Threshold" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Throttle", + "transparent": true, + "type": "stat" + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "SolidFire", + "NetApp HCI" + ], + "templating": { + "list": [ + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "netapp.solidfire.cluster.*", + "hide": 0, + "includeAll": false, + "index": -1, + "label": "Element Cluster Name", + "multi": true, + "name": "cluster", + "options": [], + "query": "netapp.solidfire.cluster.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "netapp.solidfire.cluster.*.volumeID.*", + "hide": 0, + "includeAll": false, + "index": -1, + "label": "Volume ID", + "multi": true, + "name": "volumeID", + "options": [], + "query": "netapp.solidfire.cluster.*.volumeID.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 3, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-15m", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ] + }, + "timezone": "", + "title": "NetApp HCI - SolidFire Volume Histograms", + "uid": "43IlzYaWz", + "variables": { + "list": [] + }, + "version": 2 +} \ No newline at end of file diff --git a/grafana/dashboards/solidfire-multicluster.json b/grafana/dashboards/solidfire-multicluster.json new file mode 100644 index 0000000..236ee7d --- /dev/null +++ b/grafana/dashboards/solidfire-multicluster.json @@ -0,0 +1,712 @@ +{ + "__inputs": [ + { + "name": "DS_GRAPHITE", + "label": "graphite", + "description": "", + "type": "datasource", + "pluginId": "graphite", + "pluginName": "Graphite" + } + ], + "__requires": [ + { + "type": "panel", + "id": "bargauge", + "name": "Bar Gauge", + "version": "" + }, + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "6.7.4" + }, + { + "type": "panel", + "id": "graph", + "name": "Graph", + "version": "" + }, + { + "type": "datasource", + "id": "graphite", + "name": "Graphite", + "version": "1.0.0" + }, + { + "type": "panel", + "id": "singlestat", + "name": "Singlestat", + "version": "" + } + ], + "annotations": { + "list": [ + { + "$$hashKey": "object:928", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "editable": true, + "gnetId": null, + "graphTooltip": 1, + "id": null, + "iteration": 1608386563492, + "links": [], + "panels": [ + { + "cacheTimeout": null, + "colorBackground": false, + "colorPostfix": true, + "colorPrefix": false, + "colorValue": true, + "colors": [ + "#56A64B", + "#FF780A", + "#E02F44" + ], + "datasource": "${DS_GRAPHITE}", + "decimals": 2, + "description": "Cluster utilization is expected to hit close to 100% at maximum rated performance (or above) while spikes in utilization may also happen during Garbage Collection and other system jobs", + "format": "percentunit", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 4, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 2, + "interval": null, + "links": [], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:6370", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:6371", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "maxPerRow": 2, + "nullPointMode": "connected", + "nullText": null, + "postfix": "", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "repeat": "Cluster", + "repeatDirection": "h", + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "#1F60C4", + "show": true + }, + "tableColumn": "", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.clusterUtilization" + } + ], + "thresholds": "40,75", + "title": "$Cluster cluster Utilization %", + "type": "singlestat", + "valueFontSize": "120%", + "valueMaps": [ + { + "$$hashKey": "object:6373", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "aliasColors": { + "Read IOPS": "semi-dark-green", + "Total IOPS": "dark-blue", + "Write IOPS": "semi-dark-red" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Cluster IOPS", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 9, + "w": 24, + "x": 0, + "y": 8 + }, + "hiddenSeries": false, + "id": 30, + "legend": { + "alignAsTable": false, + "avg": false, + "current": true, + "max": false, + "min": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "maxPerRow": 2, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "repeat": "Cluster", + "repeatDirection": "h", + "seriesOverrides": [ + { + "$$hashKey": "object:19062", + "alias": "Total IOPS", + "yaxis": 1 + } + ], + "spaceLength": 10, + "stack": true, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refCount": 0, + "refId": "A", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.readOps), 5), 'Read IOPS')" + }, + { + "hide": false, + "refCount": 0, + "refId": "B", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.writeOps), 5), 'Write IOPS')", + "textEditor": false + }, + { + "hide": false, + "refCount": 0, + "refId": "C", + "target": "alias(keepLastValue(perSecond(sumSeries(netapp.solidfire.cluster.$Cluster.{readOps,writeOps})), 5), 'Total IOPS')", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster IOPS", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:3580", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:3581", + "decimals": 0, + "format": "short", + "label": "", + "logBase": 1, + "max": null, + "min": "0", + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": { + "Read Bytes/s": "semi-dark-green", + "Total Bytes/s": "dark-blue", + "Write Bytes/s": "semi-dark-red" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 8, + "w": 24, + "x": 0, + "y": 26 + }, + "hiddenSeries": false, + "hideTimeOverride": false, + "id": 40, + "legend": { + "alignAsTable": false, + "avg": false, + "current": true, + "max": false, + "min": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "maxPerRow": 2, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "repeat": "Cluster", + "repeatDirection": "h", + "seriesOverrides": [], + "spaceLength": 10, + "stack": true, + "steppedLine": false, + "targets": [ + { + "hide": true, + "refId": "B", + "target": "alias(keepLastValue(netapp.solidfire.cluster.$Cluster.readBytesLastSample, 5), '$Cluster Read Bytes/s')" + }, + { + "hide": true, + "refId": "A", + "target": "alias(keepLastValue(netapp.solidfire.cluster.$Cluster.writeBytesLastSample, 5), '$Cluster Write Bytes/s')" + }, + { + "refId": "C", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.readBytes), 5), 'Read Bytes/s')" + }, + { + "refId": "D", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.writeBytes), 5), 'Write Bytes/s')" + }, + { + "refId": "E", + "target": "alias(keepLastValue(sumSeries(perSecond(netapp.solidfire.cluster.$Cluster.{readBytes,writeBytes})), 5), 'Total Bytes/s')" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster Read/Write Bytes / s", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:4255", + "decimals": 0, + "format": "Bps", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:4256", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": { + "active": "dark-green", + "available": "super-light-green", + "failed": "dark-red", + "removing": "semi-dark-yellow" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "All drives except those that have failed or are being added or removed should be Active. \n\nIf you see unexpected changes in the Active Drives curve, examine your cluster.", + "editable": true, + "error": false, + "fill": 1, + "fillGradient": 2, + "grid": {}, + "gridPos": { + "h": 7, + "w": 24, + "x": 0, + "y": 42 + }, + "height": "", + "hiddenSeries": false, + "id": 20, + "legend": { + "alignAsTable": false, + "avg": false, + "current": true, + "hideEmpty": true, + "hideZero": false, + "max": false, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Active Cluster Drives", + "url": "https://192.168.1.30/cluster/#/system/drives?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D%7D" + } + ], + "maxPerRow": 2, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 1, + "points": true, + "renderer": "flot", + "repeat": "Cluster", + "repeatDirection": "h", + "seriesOverrides": [ + { + "$$hashKey": "object:18254", + "alias": "available", + "yaxis": 2 + }, + { + "$$hashKey": "object:18255", + "alias": "unknown", + "yaxis": 2 + }, + { + "$$hashKey": "object:18256", + "alias": "removing", + "yaxis": 2 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": true, + "targets": [ + { + "refCount": 0, + "refId": "B", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.drives.*.active, 5), 6)", + "textEditor": false + }, + { + "refCount": 0, + "refId": "A", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.drives.*.available, 5), 6)", + "textEditor": false + }, + { + "refCount": 0, + "refId": "C", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.drives.*.unknown, 5), 6)", + "textEditor": false + }, + { + "refCount": 0, + "refId": "D", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.drives.*.removing, 5), 6)", + "textEditor": false + }, + { + "refCount": 0, + "refId": "E", + "target": "aliasByNode(keepLastValue(netapp.solidfire.cluster.$Cluster.drives.*.failed, 5), 6)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Cluster Drive Activeness Status", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:1001", + "decimals": 0, + "format": "short", + "label": "Active or Failed Disks", + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "$$hashKey": "object:1002", + "decimals": 0, + "format": "short", + "label": "Other", + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": true, + "alignLevel": null + } + }, + { + "cacheTimeout": "200", + "datasource": "${DS_GRAPHITE}", + "description": "Wear is expected to gradually grow (and Drive Life Remaining decline), but below 50% should be rare. \nIn the case of accelerated or sudden decline in Life Remaining (say, 1%/week), it may be a good idea to contact Support.\n\nClick on the SolidFire UI link to see individual drives sorted by Wear Remaining", + "gridPos": { + "h": 5, + "w": 24, + "x": 0, + "y": 56 + }, + "id": 41, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Drive Wear Level Remaining (%, Ascending)", + "url": "https://192.168.1.30/cluster/#/system/drives?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D%7D" + } + ], + "options": { + "displayMode": "gradient", + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 0, + "mappings": [], + "max": 100, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "dark-yellow", + "value": 30 + }, + { + "color": "dark-orange", + "value": 50 + }, + { + "color": "dark-red", + "value": 80 + } + ] + }, + "unit": "percent" + }, + "overrides": [], + "values": false + }, + "orientation": "horizontal", + "showUnfilled": true + }, + "pluginVersion": "6.7.4", + "repeat": "Cluster", + "repeatDirection": "h", + "targets": [ + { + "$$hashKey": "object:2864", + "aggregation": "Last", + "alias": "Wear Level", + "decimals": 0, + "displayAliasType": "Warning / Critical", + "displayType": "Regular", + "displayValueWithAlias": "When Alias Displayed", + "hide": false, + "refCount": 0, + "refId": "A", + "target": "substr(netapp.solidfire.cluster.$Cluster.drives.*.lifeRemainingPercent, -3, -1)", + "textEditor": false, + "units": "percent", + "valueHandler": "Number Threshold" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "$Cluster Drive Wear Level", + "transparent": true, + "type": "bargauge" + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "SolidFire", + "NetApp HCI" + ], + "templating": { + "list": [ + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": true, + "index": -1, + "label": null, + "multi": true, + "name": "Cluster", + "options": [], + "query": "netapp.solidfire.cluster.*", + "refresh": 2, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-1h", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "", + "title": "NetApp HCI - SolidFire Multi-Cluster NOC View", + "uid": "AWltdqzmz", + "variables": { + "list": [] + }, + "version": 5 +} \ No newline at end of file diff --git a/grafana/dashboards/solidfire-node.json b/grafana/dashboards/solidfire-node.json new file mode 100644 index 0000000..e43fe96 --- /dev/null +++ b/grafana/dashboards/solidfire-node.json @@ -0,0 +1,830 @@ +{ + "__inputs": [ + { + "name": "DS_GRAPHITE", + "label": "graphite", + "description": "", + "type": "datasource", + "pluginId": "graphite", + "pluginName": "Graphite" + } + ], + "__requires": [ + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "6.7.4" + }, + { + "type": "panel", + "id": "graph", + "name": "Graph", + "version": "" + }, + { + "type": "datasource", + "id": "graphite", + "name": "Graphite", + "version": "1.0.0" + }, + { + "type": "panel", + "id": "stat", + "name": "Stat", + "version": "" + } + ], + "annotations": { + "list": [ + { + "$$hashKey": "object:1276", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "Per node statistics for a SolidFire cluster", + "editable": true, + "gnetId": null, + "graphTooltip": 1, + "id": null, + "iteration": 1597051499109, + "links": [ + { + "$$hashKey": "object:6817", + "icon": "external link", + "tags": [], + "targetBlank": true, + "title": "SolidFire UI - Storage Nodes", + "tooltip": "Performance details for storage nodes", + "type": "link", + "url": "https://192.168.1.30/cluster/#/system/nodes?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D%7D" + } + ], + "panels": [ + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 90, + "panels": [], + "repeat": null, + "title": "Current Processor, Memory and Network Utilization", + "type": "row" + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "description": "This value is generally not important as storage node performance is determined by QoS settings and activity of the volumes active on the node.\n\nHowever in the case of extended periods of high CPU utilization, you may want to take a look at the sum of Burst or Maximum settings and check client-side workloads.", + "gridPos": { + "h": 7, + "w": 24, + "x": 0, + "y": 1 + }, + "id": 18, + "links": [], + "options": { + "colorMode": "value", + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 0, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "dark-green", + "value": null + }, + { + "color": "light-green", + "value": 60 + }, + { + "color": "#EAB839", + "value": 75 + }, + { + "color": "semi-dark-red", + "value": 90 + } + ] + }, + "unit": "percent" + }, + "overrides": [], + "values": false + }, + "graphMode": "none", + "justifyMode": "center", + "orientation": "auto" + }, + "pluginVersion": "6.7.4", + "repeat": "Cluster", + "repeatDirection": "h", + "repeatIteration": 1480760272097, + "targets": [ + { + "refId": "B", + "target": "aliasByNode(netapp.solidfire.cluster.$Cluster.node.$Node.cpu, 5)", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "$Node CPU Utilization", + "transparent": true, + "type": "stat" + }, + { + "datasource": "${DS_GRAPHITE}", + "description": "This value is generally not important as storage node performance is much smaller than network bandwidth available on SolidFire nodes.\n\nIt can be of interest in parallel backup or during distributed recovery from failed nodes or disk drives.", + "gridPos": { + "h": 4, + "w": 6, + "x": 0, + "y": 8 + }, + "id": 72, + "links": [], + "maxPerRow": 12, + "options": { + "colorMode": "value", + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 0, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "#EAB839", + "value": 60 + }, + { + "color": "semi-dark-red", + "value": 80 + } + ] + }, + "unit": "percent" + }, + "overrides": [], + "values": false + }, + "graphMode": "area", + "justifyMode": "auto", + "orientation": "auto" + }, + "pluginVersion": "6.7.4", + "repeat": "Node", + "repeatDirection": "h", + "targets": [ + { + "refId": "A", + "target": "aliasByNode(netapp.solidfire.cluster.$Cluster.node.$Node.networkUtilizationCluster, 5)" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "$Node Node Network Utilization", + "type": "stat" + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "description": "Generally not important, as RAM is appropriately sized for the node to deliver rated IOPS with compression and deduplication enabled", + "gridPos": { + "h": 4, + "w": 6, + "x": 0, + "y": 12 + }, + "id": 96, + "links": [], + "maxPerRow": 12, + "options": { + "colorMode": "value", + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 1, + "mappings": [ + { + "$$hashKey": "object:306", + "id": 0, + "op": "=", + "text": "N/A", + "type": 1, + "value": "null" + } + ], + "nullValueMode": "connected", + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "semi-dark-blue", + "value": null + } + ] + }, + "unit": "bytes" + }, + "overrides": [], + "values": false + }, + "graphMode": "area", + "justifyMode": "auto", + "orientation": "horizontal" + }, + "pluginVersion": "6.7.4", + "repeat": "Node", + "repeatDirection": "h", + "targets": [ + { + "refId": "A", + "target": "aliasByMetric(netapp.solidfire.cluster.$Cluster.node.$Node.usedMemory)" + } + ], + "title": "$Node RAM Utilization", + "type": "stat" + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 16 + }, + "id": 113, + "panels": [], + "repeat": null, + "title": "Node iSCSI Connections", + "type": "row" + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "description": "Nodes in this panel are NOT ordered (limitation of Grafana and visualization type chosen that's needs a work around). \n\nPlease use the SolidFire UI to identify connections per node (Reporting > iSCSI Connections).\n\nMaximum number of connections can be found in the SolidFire documentation (few hundred per node)", + "gridPos": { + "h": 7, + "w": 24, + "x": 0, + "y": 17 + }, + "id": 130, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - iSCSI Connections ", + "url": "https://192.168.1.30/cluster/#/reporting/sessions?page=1" + } + ], + "options": { + "colorMode": "value", + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 0, + "mappings": [], + "max": 500, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "dark-green", + "value": null + }, + { + "color": "light-green", + "value": 100 + }, + { + "color": "#EAB839", + "value": 200 + }, + { + "color": "dark-orange", + "value": 300 + } + ] + }, + "unit": "short" + }, + "overrides": [], + "values": false + }, + "graphMode": "area", + "justifyMode": "center", + "orientation": "vertical" + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refId": "A", + "target": "substr(netapp.solidfire.cluster.$Cluster.drives.*.sessions, 4, 6)" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Distribution of iSCSI Connections", + "transparent": true, + "type": "stat" + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 24 + }, + "id": 92, + "panels": [], + "repeat": null, + "title": "Node Performance", + "type": "row" + }, + { + "aliasColors": { + "Read IOPS": "semi-dark-green", + "Total IOPS": "dark-blue", + "Write IOPS": "semi-dark-orange" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Nodes are not expected to be equally busy, but with many more active volumes than storage nodes, eventually they tend to be similarly busy.\n\nOutliers may appear during storage-offloaded operations (Storage vMotion, for example).", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 6, + "x": 0, + "y": 25 + }, + "hiddenSeries": false, + "id": 89, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "maxPerRow": 4, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "repeat": "Node", + "repeatDirection": "h", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.node.$Node.readOps), 5), 'Read IOPS')" + }, + { + "refId": "B", + "target": "alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.node.$Node.writeOps), 5), 'Write IOPS')" + }, + { + "refId": "C", + "target": "alias(sumSeries(#A,#B),'Total IOPS')", + "targetFull": "alias(sumSeries(alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.node.$Node.readOps), 5), 'Read IOPS'),alias(keepLastValue(perSecond(netapp.solidfire.cluster.$Cluster.node.$Node.writeOps), 5), 'Write IOPS')),'Total IOPS')", + "textEditor": true + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Node Node IOPS", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:580", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:581", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 32 + }, + "id": 93, + "panels": [], + "repeat": null, + "title": "Storage Interfaces", + "type": "row" + }, + { + "aliasColors": { + "Out": "light-yellow" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "iSCSI Network Traffic in bytes per second. \n\nWe can use this chart to check if parallel backup is keeping all storage nodes equally busy, or how much additional bandwidth is used after volume replication traffic is enabled ", + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 7, + "w": 6, + "x": 0, + "y": 33 + }, + "hiddenSeries": false, + "id": 40, + "legend": { + "alignAsTable": true, + "avg": true, + "current": true, + "max": true, + "min": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "maxPerRow": 4, + "nullPointMode": "connected", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "repeat": "Node", + "repeatDirection": "h", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refId": "A", + "target": "alias(perSecond(netapp.solidfire.cluster.$Cluster.node.$Node.sBytesIn), 'In')", + "textEditor": false + }, + { + "hide": false, + "refId": "B", + "target": "alias(perSecond(netapp.solidfire.cluster.$Cluster.node.$Node.sBytesOut), 'Out')", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Node Node iSCSI Network Traffic", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:724", + "decimals": 0, + "format": "Bps", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:725", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 40 + }, + "id": 94, + "panels": [], + "repeat": null, + "title": "Management Interfaces", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Network traffic on management interface", + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 7, + "w": 6, + "x": 0, + "y": 41 + }, + "hiddenSeries": false, + "id": 39, + "legend": { + "alignAsTable": true, + "avg": true, + "current": true, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "maxPerRow": 4, + "nullPointMode": "connected", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "repeat": "Node", + "repeatDirection": "h", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "alias(perSecond(netapp.solidfire.cluster.$Cluster.node.$Node.mBytesIn), 'In')", + "textEditor": false + }, + { + "refId": "B", + "target": "alias(perSecond(netapp.solidfire.cluster.$Cluster.node.$Node.mBytesOut), 'Out')", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Node Node Management Network Traffic", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:865", + "decimals": 0, + "format": "Bps", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "$$hashKey": "object:866", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "SolidFire", + "NetApp HCI" + ], + "templating": { + "list": [ + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": false, + "index": -1, + "label": "SolidFire Cluster Name", + "multi": false, + "name": "Cluster", + "options": [], + "query": "netapp.solidfire.cluster.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": true, + "index": -1, + "label": "SolidFire Node", + "multi": true, + "name": "Node", + "options": [], + "query": "netapp.solidfire.cluster.$Cluster.node.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-1h", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "browser", + "title": "NetApp HCI - SolidFire Node", + "uid": "MPWsgfezz", + "variables": { + "list": [] + }, + "version": 17 +} diff --git a/grafana/dashboards/solidfire-storage-optimization.json b/grafana/dashboards/solidfire-storage-optimization.json new file mode 100644 index 0000000..3241b99 --- /dev/null +++ b/grafana/dashboards/solidfire-storage-optimization.json @@ -0,0 +1,1135 @@ +{ + "__inputs": [ + { + "name": "DS_GRAPHITE", + "label": "graphite", + "description": "", + "type": "datasource", + "pluginId": "graphite", + "pluginName": "Graphite" + } + ], + "__requires": [ + { + "type": "panel", + "id": "btplc-trend-box-panel", + "name": "Trend Box", + "version": "0.1.9" + }, + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "6.7.4" + }, + { + "type": "panel", + "id": "grafana-piechart-panel", + "name": "Pie Chart", + "version": "1.6.0" + }, + { + "type": "panel", + "id": "graph", + "name": "Graph", + "version": "" + }, + { + "type": "datasource", + "id": "graphite", + "name": "Graphite", + "version": "1.0.0" + }, + { + "type": "panel", + "id": "singlestat", + "name": "Singlestat", + "version": "" + } + ], + "annotations": { + "list": [ + { + "$$hashKey": "object:9318", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "Dashboard with storage optimization-focused panels", + "editable": true, + "gnetId": null, + "graphTooltip": 0, + "id": null, + "iteration": 1597149326354, + "links": [ + { + "$$hashKey": "object:5588", + "icon": "external link", + "tags": [], + "targetBlank": true, + "title": "SolidFire UI - Volume Management", + "type": "link", + "url": "https://192.168.1.30/cluster/#/management/volumes?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D%7D" + }, + { + "$$hashKey": "object:1419", + "icon": "external link", + "includeVars": false, + "tags": [], + "targetBlank": true, + "title": "SolidFire UI - Map selected Account ID Num to Name", + "tooltip": "Resolve selected Account ID to Account Name", + "type": "link", + "url": "https://192.168.1.30/cluster/#/management/accounts?page=1&filter=%7B%22accountID%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:$accountIdNum%7D%7D%7D" + } + ], + "panels": [ + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 14, + "panels": [], + "title": "Cluster Level Information", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "When maxUsedSpace is hit, cluster has no space to write new data.\n\nMost users don't wait until nonZeroBlocks get close to maxUsedSpace (especially if they desire to tolerate the loss of one node)", + "fill": 1, + "fillGradient": 6, + "gridPos": { + "h": 8, + "w": 9, + "x": 0, + "y": 1 + }, + "hiddenSeries": false, + "id": 11, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 2, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pluginVersion": "6.7.3", + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "aliasByMetric(netapp.solidfire.cluster.$clusterID.maxUsedSpace)" + }, + { + "refCount": 0, + "refId": "C", + "target": "aliasByMetric(netapp.solidfire.cluster.$clusterID.usedSpace)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Data Space Used & Maximum", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:11848", + "decimals": 0, + "format": "bytes", + "label": "", + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "$$hashKey": "object:11849", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "maxUsedMetadata space is the maximum amount of space available for volume metadata. \n\nIf usedMetadata space is growing quickly, make sure users or automation aren't leaving behind unnecessary clones or snapshots", + "fill": 1, + "fillGradient": 6, + "gridPos": { + "h": 8, + "w": 9, + "x": 9, + "y": 1 + }, + "hiddenSeries": false, + "id": 12, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 2, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pluginVersion": "6.7.3", + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "aliasByMetric(netapp.solidfire.cluster.$clusterID.maxUsedMetadataSpace)" + }, + { + "refCount": 0, + "refId": "C", + "target": "aliasByMetric(netapp.solidfire.cluster.$clusterID.usedMetadataSpace)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Metadata Space Used & Maximum", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:11848", + "decimals": 0, + "format": "bytes", + "label": "", + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "$$hashKey": "object:11849", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "datasource": "${DS_GRAPHITE}", + "decimals": "2", + "defaultColor": "#96D98D", + "description": "Data capacity utilization trend shows change (% delta) over selected time period and (below) the current utiilzation (% full)", + "displayValue": "value", + "format": "percent", + "gridPos": { + "h": 4, + "w": 6, + "x": 18, + "y": 1 + }, + "id": 22, + "linkIndex": "0", + "numberSize": "14px", + "percentSize": "30px", + "pluginVersion": "6.7.3", + "targets": [ + { + "hide": true, + "refCount": -1, + "refId": "A", + "target": "aliasByMetric(netapp.solidfire.cluster.$clusterID.maxUsedSpace)" + }, + { + "hide": true, + "refCount": -1, + "refId": "C", + "target": "aliasByMetric(netapp.solidfire.cluster.$clusterID.usedSpace)" + }, + { + "hide": false, + "refCount": 0, + "refId": "B", + "target": "asPercent(#C, #A)", + "targetFull": "asPercent(aliasByMetric(netapp.solidfire.cluster.$clusterID.usedSpace), aliasByMetric(netapp.solidfire.cluster.$clusterID.maxUsedSpace))" + } + ], + "thresholds": [ + { + "$$hashKey": "object:7866", + "color": "#FA6400", + "value": "50" + }, + { + "$$hashKey": "object:7869", + "color": "#E02F44", + "value": "70" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Data Space Utilization Trend", + "titleSize": "20px", + "type": "btplc-trend-box-panel" + }, + { + "datasource": "${DS_GRAPHITE}", + "decimals": "2", + "defaultColor": "#96D98D", + "description": "Metadata capacity utilization trend shows change (% delta) over selected time period and (below) the current utiilzation (% full)", + "displayValue": "value", + "format": "percent", + "gridPos": { + "h": 4, + "w": 6, + "x": 18, + "y": 5 + }, + "id": 23, + "linkIndex": "0", + "numberSize": "14px", + "percentSize": "30px", + "pluginVersion": "6.7.3", + "targets": [ + { + "hide": true, + "refCount": -1, + "refId": "A", + "target": "aliasByMetric(netapp.solidfire.cluster.$clusterID.maxUsedMetadataSpace)" + }, + { + "hide": true, + "refCount": -1, + "refId": "C", + "target": "aliasByMetric(netapp.solidfire.cluster.$clusterID.usedMetadataSpace)" + }, + { + "refCount": 0, + "refId": "B", + "target": "asPercent(#C, #A)", + "targetFull": "asPercent(aliasByMetric(netapp.solidfire.cluster.$clusterID.usedMetadataSpace), aliasByMetric(netapp.solidfire.cluster.$clusterID.maxUsedMetadataSpace))" + } + ], + "thresholds": [ + { + "$$hashKey": "object:7866", + "color": "#FA6400", + "value": "50" + }, + { + "$$hashKey": "object:7869", + "color": "#E02F44", + "value": "70" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Metadata Space Utilization Trend", + "titleSize": "20px", + "type": "btplc-trend-box-panel" + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 9 + }, + "id": 2, + "panels": [], + "repeat": null, + "title": "Volume Level Information", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "cacheTimeout": "", + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "description": "Volume sizes over time (Top 10). \n\nMinimum volume size on SolidFire is 1GiB.", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 8, + "w": 24, + "x": 0, + "y": 10 + }, + "hiddenSeries": false, + "id": 25, + "legend": { + "avg": false, + "current": false, + "hideEmpty": true, + "hideZero": true, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 2, + "points": false, + "renderer": "flot", + "repeat": "clusterID", + "repeatDirection": "v", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": true, + "targets": [ + { + "refId": "A", + "target": "highestCurrent(aliasByNode(removeBelowValue(netapp.solidfire.cluster.$clusterID.volumeID.*.volumeSize, 1073741824), 5), 10)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$clusterID Volume Sizes over TIme", + "tooltip": { + "shared": true, + "sort": 2, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:9797", + "format": "bytes", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "$$hashKey": "object:9798", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "cacheTimeout": "", + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 1, + "description": "These volumes may be candidates for efficiency improvements.\n\nThis panel uses new metric paths (HCICollector v0.7) based on Volume IDs and in order to map IDs to Names click on the SolidFire UI link in top right corner of this dashboard and look it up in the SolidFire Web UI.", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 18 + }, + "hiddenSeries": false, + "id": 6, + "legend": { + "avg": false, + "current": false, + "hideEmpty": false, + "hideZero": true, + "max": false, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Volume Details", + "url": "https://192.168.1.30/cluster/#/management/volumes?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D,%22volumeID%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:${volumeID}%7D%7D%7D" + } + ], + "nullPointMode": "null", + "options": { + "dataLinks": [ + { + "title": "", + "url": "https://${__data.fields[1]}" + } + ] + }, + "percentage": false, + "pluginVersion": "6.7.3", + "pointradius": 2, + "points": false, + "renderer": "flot", + "repeat": null, + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": true, + "targets": [ + { + "$$hashKey": "object:9689", + "aggregation": "Last", + "decimals": 2, + "displayAliasType": "Warning / Critical", + "displayType": "Regular", + "displayValueWithAlias": "Never", + "refId": "A", + "target": "substr(removeAboveValue(netapp.solidfire.cluster.$clusterID.volumeID.*.volumeEfficiency, 2), 5, 6)", + "units": "none", + "valueHandler": "Number Threshold" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Volume IDs with Efficiency not Higher than 2X ", + "tooltip": { + "shared": true, + "sort": 1, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:9412", + "decimals": 0, + "format": "short", + "label": "Compr x Dedupe", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:9413", + "decimals": 0, + "format": "short", + "label": "", + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Candidates for lower Burst IO Setting.\n\nYou may want to adjust values and create several similar indicators.\n\nThis panel uses new metric paths (HCICollector v0.7) based on Volume IDs and in order to map IDs to Names click on the SolidFire UI link in top right corner of this dashboard and look it up in the SolidFire Web UI", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 8, + "w": 12, + "x": 12, + "y": 18 + }, + "hiddenSeries": false, + "id": 9, + "legend": { + "avg": false, + "current": false, + "hideZero": true, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [ + { + "targetBlank": true, + "title": "SolidFire UI - Volume Details", + "url": "https://192.168.1.30/cluster/#/management/volumes?page=1&filter=%7B%22status%22:%7B%22func%22:%22equalTo%22,%22params%22:%7B%22value%22:%22active%22%7D%7D%7D" + } + ], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [ + { + "$$hashKey": "object:13381", + "alias": "1", + "yaxis": 1 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": true, + "targets": [ + { + "refId": "A", + "target": "substr(removeBelowValue(netapp.solidfire.cluster.$clusterID.volumeID.*.burstIOPSCredit, 600000), 5, 6)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Volume IDs with Burst IOPS Credit > 600K", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:10123", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:10124", + "decimals": 0, + "format": "short", + "label": "", + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 26 + }, + "id": 16, + "panels": [], + "repeat": null, + "title": "Account Level Information", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 1, + "description": "Data Efficiency for Account ID (Numeric)", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 27 + }, + "hiddenSeries": false, + "id": 21, + "legend": { + "avg": false, + "current": false, + "hideEmpty": false, + "hideZero": true, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 2, + "points": false, + "renderer": "flot", + "repeat": null, + "repeatDirection": "h", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": true, + "targets": [ + { + "refId": "A", + "target": "substr(netapp.solidfire.cluster.$clusterID.accountID.$accountIdNum.accountEfficiency, 4, 6)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Account Data Efficiency for Account ID (Num): $accountIdNum", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:6680", + "decimals": 1, + "format": "short", + "label": "", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:6681", + "decimals": 2, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "breakPoint": "50%", + "cacheTimeout": "", + "combine": { + "label": "Others", + "threshold": "0.05" + }, + "datasource": "${DS_GRAPHITE}", + "decimals": 1, + "description": "Size of all volumes belonging to an account (selected in Name drop-down list at the top)\n\nThis includes thin-provisioned capacity (which is unused capacity) and does not consider data efficiencies", + "fontSize": "80%", + "format": "bytes", + "gridPos": { + "h": 17, + "w": 12, + "x": 12, + "y": 27 + }, + "id": 18, + "interval": null, + "legend": { + "header": "", + "percentage": true, + "percentageDecimals": 0, + "show": true, + "values": true + }, + "legendType": "Right side", + "links": [], + "maxDataPoints": 1, + "nullPointMode": "connected", + "pieType": "pie", + "repeat": null, + "repeatDirection": "v", + "strokeWidth": 1, + "targets": [ + { + "hide": false, + "refCount": 0, + "refId": "A", + "target": "aliasByNode(netapp.solidfire.cluster.$clusterID.accountID.$accountID.volume.*.volumeSize, 7)", + "textEditor": false + } + ], + "timeFrom": null, + "timeShift": null, + "title": "Volume Sizes by Account ID (Name): $accountID", + "type": "grafana-piechart-panel", + "valueName": "current" + }, + { + "cacheTimeout": "", + "colorBackground": false, + "colorPostfix": false, + "colorPrefix": true, + "colorValue": true, + "colors": [ + "#E02F44", + "rgba(237, 129, 40, 0.89)", + "#299c46" + ], + "datasource": "${DS_GRAPHITE}", + "decimals": 2, + "description": "Efficiency of data stored on volumes owned by an account (selected from Account ID (Numeric) drop-down list at the top; this is an inconvenience of storing this data in a location different - see Release Notes for v0.7)", + "format": "short", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 9, + "w": 12, + "x": 0, + "y": 35 + }, + "id": 19, + "interval": null, + "links": [], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:5202", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:5203", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "nullPointMode": "connected", + "nullText": null, + "postfix": "x", + "postfixFontSize": "80%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "repeat": null, + "repeatDirection": "v", + "sparkline": { + "fillColor": "#1F60C4", + "full": false, + "lineColor": "rgb(0, 0, 0)", + "show": true, + "ymax": null, + "ymin": 0 + }, + "tableColumn": "", + "targets": [ + { + "hide": false, + "refCount": 0, + "refId": "A", + "target": "alias(netapp.solidfire.cluster.$clusterID.accountID.$accountIdNum.accountEfficiency, '$accountIdNum')" + } + ], + "thresholds": "2,3", + "timeFrom": null, + "timeShift": null, + "title": "Volume Efficiency for Account ID (Num): $accountIdNum", + "type": "singlestat", + "valueFontSize": "150%", + "valueMaps": [ + { + "$$hashKey": "object:5205", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + } + ], + "refresh": "5m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "SolidFire", + "NetApp HCI" + ], + "templating": { + "list": [ + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "netapp.solidfire.cluster.*", + "hide": 0, + "includeAll": true, + "index": -1, + "label": "Cluster Name", + "multi": false, + "name": "clusterID", + "options": [], + "query": "netapp.solidfire.cluster.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "netapp.solidfire.cluster.*.volumeID.*", + "hide": 0, + "includeAll": true, + "index": -1, + "label": "Volume ID", + "multi": false, + "name": "volumeID", + "options": [], + "query": "netapp.solidfire.cluster.*.volumeID.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 4, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "netapp.solidfire.cluster.$clusterID.accountID.*", + "hide": 0, + "includeAll": false, + "index": -1, + "label": "Account ID (Name)", + "multi": false, + "name": "accountID", + "options": [], + "query": "netapp.solidfire.cluster.$clusterID.accountID.*", + "refresh": 1, + "regex": "[a-zA-Z]|[a-zA-Z0-9].*[A-Za-z].*", + "skipUrlSync": false, + "sort": 1, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "netapp.solidfire.cluster.*.accountID.*", + "hide": 0, + "includeAll": false, + "index": -1, + "label": "Account ID (Numeric)", + "multi": false, + "name": "accountIdNum", + "options": [], + "query": "netapp.solidfire.cluster.*.accountID.*", + "refresh": 1, + "regex": "[0-9].*?", + "skipUrlSync": false, + "sort": 3, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-30m", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ] + }, + "timezone": "", + "title": "NetApp HCI - SolidFire Storage Optimization", + "uid": "0wbZ3ozMk", + "variables": { + "list": [] + }, + "version": 7 +} \ No newline at end of file diff --git a/grafana/dashboards/solidfire-volume-topn.json b/grafana/dashboards/solidfire-volume-topn.json new file mode 100644 index 0000000..bbcc767 --- /dev/null +++ b/grafana/dashboards/solidfire-volume-topn.json @@ -0,0 +1,840 @@ +{ + "__inputs": [ + { + "name": "DS_GRAPHITE", + "label": "graphite", + "description": "", + "type": "datasource", + "pluginId": "graphite", + "pluginName": "Graphite" + } + ], + "__requires": [ + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "6.7.4" + }, + { + "type": "panel", + "id": "graph", + "name": "Graph", + "version": "" + }, + { + "type": "datasource", + "id": "graphite", + "name": "Graphite", + "version": "1.0.0" + } + ], + "annotations": { + "list": [ + { + "$$hashKey": "object:1738", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "TopN Solidfire volumes by Average IOPS", + "editable": true, + "gnetId": null, + "graphTooltip": 1, + "id": null, + "iteration": 1597057670082, + "links": [ + { + "$$hashKey": "object:5573", + "icon": "external link", + "tags": [], + "targetBlank": true, + "title": "SolidFire UI - Volume Perfomance", + "tooltip": "View volume performance by Name & ID", + "type": "link", + "url": "https://192.168.1.30/cluster/#/reporting/volume-performance?page=1" + } + ], + "panels": [ + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 20, + "panels": [], + "repeat": null, + "title": "Volume Statistics", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 1 + }, + "hiddenSeries": false, + "id": 14, + "legend": { + "alignAsTable": true, + "avg": true, + "current": true, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refId": "B", + "target": "aliasByNode(perSecond(highestAverage(keepLastValue(netapp.solidfire.cluster.$Cluster.accountID.*.volume.*.writeOps, 5), $TopN)), 7)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Top $TopN WriteOps/s", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 1, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:3896", + "decimals": 0, + "format": "iops", + "label": "", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:3897", + "format": "bytes", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 8, + "w": 12, + "x": 12, + "y": 1 + }, + "hiddenSeries": false, + "id": 15, + "legend": { + "alignAsTable": true, + "avg": true, + "current": true, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [ + { + "$$hashKey": "object:4015", + "alias": "Avg IOP Size", + "bars": false, + "color": "#890F02", + "lines": false, + "pointradius": 1, + "points": true, + "yaxis": 2 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "B", + "target": "aliasByNode(perSecond(keepLastValue(highestAverage(netapp.solidfire.cluster.$Cluster.accountID.*.volume.*.readOps, $TopN), 5)), 7)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Top $TopN Read Ops/s", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:4038", + "decimals": 0, + "format": "iops", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:4039", + "decimals": 0, + "format": "bytes", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 9 + }, + "hiddenSeries": false, + "id": 16, + "legend": { + "alignAsTable": true, + "avg": true, + "current": true, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [ + { + "$$hashKey": "object:4160", + "alias": "Avg IOP Size", + "bars": false, + "color": "#890F02", + "lines": false, + "pointradius": 1, + "points": true, + "yaxis": 2 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refId": "C", + "target": "aliasByNode(highestAverage(perSecond(keepLastValue(netapp.solidfire.cluster.$Cluster.accountID.*.volume.*.writeBytes, 5)), $TopN), 7)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Top $TopN Write Bytes/s", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:4183", + "decimals": 0, + "format": "Bps", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:4184", + "decimals": 0, + "format": "bytes", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 8, + "w": 12, + "x": 12, + "y": 9 + }, + "hiddenSeries": false, + "id": 17, + "legend": { + "alignAsTable": true, + "avg": true, + "current": true, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [ + { + "$$hashKey": "object:4469", + "alias": "Avg IOP Size", + "bars": false, + "color": "#890F02", + "lines": false, + "pointradius": 1, + "points": true, + "yaxis": 2 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": true, + "refId": "A", + "target": "aliasByNode(scale(highestAverage(netapp.solidfire.cluster.$Cluster.accountID.*.volume.*.readBytesLastSample, $TopN), 2), 7)", + "textEditor": false + }, + { + "hide": false, + "refId": "B", + "target": "aliasByNode(perSecond(keepLastValue(highestAverage(netapp.solidfire.cluster.$Cluster.accountID.*.volume.*.readBytes, $TopN), 5)), 7)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Top $TopN Read Bytes/s", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:4492", + "decimals": 0, + "format": "Bps", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:4493", + "decimals": 0, + "format": "bytes", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 17 + }, + "hiddenSeries": false, + "id": 18, + "legend": { + "alignAsTable": true, + "avg": true, + "current": true, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refId": "B", + "target": "aliasByNode(highestAverage(netapp.solidfire.cluster.$Cluster.accountID.*.volume.*.writeLatencyUSec, $TopN), 7)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Top $TopN Write Latency", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 1, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:4607", + "decimals": 0, + "format": "µs", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:4608", + "decimals": 0, + "format": "bytes", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 8, + "w": 12, + "x": 12, + "y": 17 + }, + "hiddenSeries": false, + "id": 19, + "legend": { + "alignAsTable": true, + "avg": true, + "current": true, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [ + { + "$$hashKey": "object:4716", + "alias": "Avg IOP Size", + "bars": false, + "color": "#890F02", + "lines": false, + "pointradius": 1, + "points": true, + "yaxis": 2 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "B", + "target": "aliasByNode(highestAverage(netapp.solidfire.cluster.$Cluster.accountID.*.volume.*.readLatencyUSec, $TopN), 7)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Top $TopN Read Latency", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:4739", + "decimals": 0, + "format": "µs", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:4740", + "decimals": 0, + "format": "bytes", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "SolidFire", + "NetApp HCI" + ], + "templating": { + "list": [ + { + "allValue": "*", + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": false, + "index": -1, + "label": null, + "multi": false, + "name": "Cluster", + "options": [], + "query": "netapp.solidfire.cluster.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "auto": false, + "auto_count": 30, + "auto_min": "10s", + "current": { + "selected": false, + "text": "5", + "value": "5" + }, + "datasource": null, + "hide": 0, + "includeAll": false, + "label": "", + "multi": false, + "name": "TopN", + "options": [ + { + "selected": false, + "text": "1", + "value": "1" + }, + { + "selected": true, + "text": "5", + "value": "5" + }, + { + "selected": false, + "text": "10", + "value": "10" + }, + { + "selected": false, + "text": "20", + "value": "20" + } + ], + "query": "1,5,10,20", + "refresh": 2, + "skipUrlSync": false, + "type": "interval" + } + ] + }, + "time": { + "from": "now-1h", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "browser", + "title": "NetApp HCI - SolidFire Volume TopN", + "uid": "7D04zBezz", + "variables": { + "list": [] + }, + "version": 3 +} \ No newline at end of file diff --git a/grafana/dashboards/solidfire-volume.json b/grafana/dashboards/solidfire-volume.json new file mode 100644 index 0000000..12a249d --- /dev/null +++ b/grafana/dashboards/solidfire-volume.json @@ -0,0 +1,1017 @@ +{ + "__inputs": [ + { + "name": "DS_GRAPHITE", + "label": "graphite", + "description": "", + "type": "datasource", + "pluginId": "graphite", + "pluginName": "Graphite" + } + ], + "__requires": [ + { + "type": "panel", + "id": "gauge", + "name": "Gauge", + "version": "" + }, + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "6.7.4" + }, + { + "type": "panel", + "id": "graph", + "name": "Graph", + "version": "" + }, + { + "type": "datasource", + "id": "graphite", + "name": "Graphite", + "version": "1.0.0" + }, + { + "type": "panel", + "id": "singlestat", + "name": "Singlestat", + "version": "" + } + ], + "annotations": { + "list": [ + { + "$$hashKey": "object:1524", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "Volume performance metrics", + "editable": true, + "gnetId": null, + "graphTooltip": 1, + "id": null, + "iteration": 1597057240895, + "links": [], + "panels": [ + { + "cacheTimeout": null, + "colorBackground": true, + "colorValue": false, + "colors": [ + "#56A64B", + "#FA6400", + "#E02F44" + ], + "datasource": "${DS_GRAPHITE}", + "decimals": 1, + "description": "Larger volumes take longer to backup, snapshot, replicate.... \n\nIt is a best practice to keep volumes smaller than the current Element maximum of 16T. ", + "editable": true, + "error": false, + "format": "bytes", + "gauge": { + "maxValue": 100, + "minValue": 0, + "show": false, + "thresholdLabels": false, + "thresholdMarkers": true + }, + "gridPos": { + "h": 5, + "w": 4, + "x": 0, + "y": 0 + }, + "id": 25, + "interval": null, + "links": [], + "mappingType": 1, + "mappingTypes": [ + { + "$$hashKey": "object:2941", + "name": "value to text", + "value": 1 + }, + { + "$$hashKey": "object:2942", + "name": "range to text", + "value": 2 + } + ], + "maxDataPoints": 100, + "nullPointMode": "connected", + "nullText": null, + "postfix": "", + "postfixFontSize": "50%", + "prefix": "", + "prefixFontSize": "50%", + "rangeMaps": [ + { + "from": "null", + "text": "N/A", + "to": "null" + } + ], + "sparkline": { + "fillColor": "rgba(31, 118, 189, 0.18)", + "full": false, + "lineColor": "rgb(31, 120, 193)", + "show": false + }, + "tableColumn": "", + "targets": [ + { + "hide": false, + "refId": "C", + "target": "netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.volumeSize", + "textEditor": false + } + ], + "thresholds": "8589934592000,12884901888000", + "title": "Volume Size", + "type": "singlestat", + "valueFontSize": "100%", + "valueMaps": [ + { + "$$hashKey": "object:2944", + "op": "=", + "text": "N/A", + "value": "null" + } + ], + "valueName": "current" + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 5, + "w": 4, + "x": 4, + "y": 0 + }, + "id": 32, + "links": [], + "options": { + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 1, + "links": [], + "mappings": [ + { + "$$hashKey": "object:1538", + "id": 0, + "op": "=", + "text": "N/A", + "type": 1, + "value": "null" + } + ], + "max": 100, + "min": 0, + "nullValueMode": "connected", + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#299c46", + "value": null + }, + { + "color": "rgba(237, 129, 40, 0.89)", + "value": 70 + }, + { + "color": "#d44a3a", + "value": 85 + } + ] + }, + "unit": "percentunit" + }, + "overrides": [], + "values": false + }, + "orientation": "horizontal", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "hide": true, + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.nonZeroBlocks", + "textEditor": true + }, + { + "hide": true, + "refId": "B", + "target": "netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.zeroBlocks" + }, + { + "hide": true, + "refId": "C", + "target": "netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.volumeSize", + "textEditor": false + }, + { + "refId": "D", + "target": "divideSeries(scale(#A, 4096), #C)", + "targetFull": "divideSeries(scale(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.nonZeroBlocks, 4096), netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.volumeSize)", + "textEditor": true + } + ], + "title": "Capacity Utilization", + "type": "gauge" + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 5, + "w": 4, + "x": 8, + "y": 0 + }, + "id": 33, + "links": [], + "options": { + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 0, + "mappings": [ + { + "$$hashKey": "object:1636", + "id": 0, + "op": "=", + "text": "N/A", + "type": 1, + "value": "null" + } + ], + "max": 100, + "min": 0, + "nullValueMode": "connected", + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#299c46", + "value": null + }, + { + "color": "rgba(237, 129, 40, 0.89)", + "value": 65 + }, + { + "color": "#d44a3a", + "value": 85 + } + ] + }, + "unit": "percentunit" + }, + "overrides": [], + "values": false + }, + "orientation": "horizontal", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "refId": "A", + "target": "netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.volumeUtilization", + "textEditor": false + } + ], + "title": "Performance Utilization", + "type": "gauge" + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "description": "Percentage of time being throttled. \n\nThere's no recommended value, but over 60% could mean some workload(s) could benefit from QoS adjustments.", + "gridPos": { + "h": 5, + "w": 4, + "x": 12, + "y": 0 + }, + "id": 31, + "links": [], + "options": { + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "mappings": [ + { + "$$hashKey": "object:1692", + "id": 0, + "op": "=", + "text": "N/A", + "type": 1, + "value": "null" + } + ], + "max": 100, + "min": 0, + "nullValueMode": "connected", + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "rgba(50, 172, 45, 0.97)", + "value": null + }, + { + "color": "light-red", + "value": 60 + } + ] + }, + "unit": "percentunit" + }, + "overrides": [], + "values": false + }, + "orientation": "horizontal", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "hide": false, + "refId": "A", + "target": "aliasByMetric(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.throttle)", + "textEditor": false + } + ], + "title": "Throttle", + "type": "gauge" + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "description": "Over a short period (say, 5 min), Read + Write % may not equal 100.\n\nUsers may want to increase QoS for volumes that have lower read percentage and hit Max IOPS sooner than expected", + "gridPos": { + "h": 5, + "w": 4, + "x": 16, + "y": 0 + }, + "id": 28, + "links": [], + "options": { + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 0, + "mappings": [ + { + "$$hashKey": "object:1818", + "id": 0, + "op": "=", + "text": "N/A", + "type": 1, + "value": "null" + } + ], + "max": 1, + "min": 0, + "nullValueMode": "connected", + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "light-purple", + "value": null + } + ] + }, + "unit": "percentunit" + }, + "overrides": [], + "values": false + }, + "orientation": "horizontal", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "hide": true, + "refId": "A", + "target": "aliasByMetric(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.readOps)", + "textEditor": true + }, + { + "hide": true, + "refId": "B", + "target": "aliasByMetric(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.writeOps)", + "textEditor": true + }, + { + "hide": true, + "refId": "C", + "target": "alias(sumSeries(#A, #B), 'TotalOps')", + "targetFull": "alias(sumSeries(aliasByMetric(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.readOps), aliasByMetric(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.writeOps)), 'TotalOps')", + "textEditor": true + }, + { + "refId": "D", + "target": "alias(divideSeries(#A, #C), 'Pct Read')", + "targetFull": "alias(divideSeries(aliasByMetric(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.readOps), alias(sumSeries(#A, aliasByMetric(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.writeOps)), 'TotalOps')), 'Pct Read')", + "textEditor": true + } + ], + "title": "%Read", + "type": "gauge" + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 5, + "w": 4, + "x": 20, + "y": 0 + }, + "id": 29, + "links": [], + "options": { + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 0, + "mappings": [ + { + "$$hashKey": "object:1897", + "id": 0, + "op": "=", + "text": "N/A", + "type": 1, + "value": "null" + } + ], + "max": 1, + "min": 0, + "nullValueMode": "connected", + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "semi-dark-blue", + "value": null + } + ] + }, + "unit": "percentunit" + }, + "overrides": [], + "values": false + }, + "orientation": "horizontal", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "targets": [ + { + "hide": true, + "refId": "A", + "target": "aliasByMetric(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.readOps)", + "textEditor": true + }, + { + "hide": true, + "refId": "B", + "target": "aliasByMetric(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.writeOps)", + "textEditor": true + }, + { + "hide": true, + "refId": "C", + "target": "alias(sumSeries(#A, #B), 'TotalOps')", + "textEditor": true + }, + { + "refId": "D", + "target": "alias(divideSeries(#B, #C), 'Pct Write')", + "textEditor": true + } + ], + "title": "%Write", + "type": "gauge" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 6, + "w": 24, + "x": 0, + "y": 5 + }, + "hiddenSeries": false, + "id": 15, + "legend": { + "alignAsTable": true, + "avg": true, + "current": false, + "max": true, + "min": false, + "rightSide": true, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 2, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "repeat": null, + "seriesOverrides": [ + { + "$$hashKey": "object:2025", + "alias": "Utilization", + "color": "#890F02", + "lines": false, + "pointradius": 1, + "points": true, + "yaxis": 2 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refId": "A", + "target": "alias(perSecond(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.readBytes), 'Read')", + "textEditor": false + }, + { + "hide": false, + "refId": "B", + "target": "alias(perSecond(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.writeBytes), 'Write')", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Volume Throughput", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2046", + "decimals": 0, + "format": "Bps", + "label": "", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:2047", + "format": "none", + "label": "", + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": { + "Avg IO Size": "dark-red" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 6, + "w": 24, + "x": 0, + "y": 11 + }, + "hiddenSeries": false, + "id": 14, + "legend": { + "alignAsTable": true, + "avg": true, + "current": false, + "max": true, + "min": false, + "rightSide": true, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [ + { + "$$hashKey": "object:2379", + "alias": "Avg IO Size", + "bars": false, + "lines": false, + "pointradius": 1, + "points": true, + "yaxis": 2 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "A", + "target": "alias(perSecond(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.readOps), 'Read')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "B", + "target": "alias(perSecond(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.writeOps), 'Write')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "D", + "target": "alias(perSecond(sumSeries(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.*Ops)), 'Total')", + "textEditor": false + }, + { + "refCount": 0, + "refId": "C", + "target": "alias(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.averageIOPSize, 'Avg IO Size')", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Volume IOPS and Average IO Size", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2400", + "decimals": 0, + "format": "iops", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:2401", + "decimals": 0, + "format": "bytes", + "label": "Avg IOP Size", + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Volume latency is time taken to respond to received I/O requests. \n\nIt does not include RTT on the network and other overheads (hypervisor, container, etc.). Latency of non-cached I/O requests that application sees is always slightly higher\n\nVery low (e.g. 1) Queue Depth may indicate single-threaded application (if container or physical host is the iSCSI client). Persistently high 32 QD may indicate a very busy application that could benefit from having its data spread over several volumes.", + "editable": true, + "error": false, + "fill": 0, + "fillGradient": 0, + "grid": {}, + "gridPos": { + "h": 6, + "w": 24, + "x": 0, + "y": 17 + }, + "hiddenSeries": false, + "id": 18, + "legend": { + "alignAsTable": true, + "avg": true, + "current": false, + "hideEmpty": false, + "hideZero": false, + "max": true, + "min": false, + "rightSide": true, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 2, + "points": false, + "renderer": "flot", + "seriesOverrides": [ + { + "$$hashKey": "object:2595", + "alias": "Queue Depth", + "bars": false, + "color": "#890F02", + "lines": false, + "pointradius": 1, + "points": true, + "yaxis": 2 + } + ], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "alias(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.readLatencyUSec, 'Read Latency')" + }, + { + "hide": false, + "refId": "B", + "target": "alias(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.writeLatencyUSec, 'Write Latency')" + }, + { + "hide": false, + "refId": "D", + "target": "alias(netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.$Volume.clientQueueDepth, 'Queue Depth')" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Latency & Queue Depth", + "tooltip": { + "msResolution": false, + "shared": true, + "sort": 0, + "value_type": "cumulative" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2618", + "decimals": 0, + "format": "µs", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:2619", + "decimals": 0, + "format": "short", + "label": "Queue Depth", + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "SolidFire", + "NetApp HCI" + ], + "templating": { + "list": [ + { + "allValue": "*", + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": false, + "index": -1, + "label": null, + "multi": false, + "name": "Cluster", + "options": [], + "query": "netapp.solidfire.cluster.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": "*", + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": true, + "index": -1, + "label": null, + "multi": false, + "name": "AccountID", + "options": [], + "query": "netapp.solidfire.cluster.$Cluster.accountID.*", + "refresh": 1, + "regex": "[a-zA-Z][a-zA-Z0-9].*", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": "*", + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": false, + "index": -1, + "label": null, + "multi": false, + "name": "Volume", + "options": [], + "query": "netapp.solidfire.cluster.$Cluster.accountID.$AccountID.volume.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 1, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-30m", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "browser", + "title": "NetApp HCI - SolidFire Volume", + "uid": "a9aNkB6kz", + "variables": { + "list": [] + }, + "version": 8 +} \ No newline at end of file diff --git a/grafana/dashboards/vsphere-esxi-metrics.json b/grafana/dashboards/vsphere-esxi-metrics.json new file mode 100644 index 0000000..1e4c86c --- /dev/null +++ b/grafana/dashboards/vsphere-esxi-metrics.json @@ -0,0 +1,858 @@ +{ + "__inputs": [ + { + "name": "DS_GRAPHITE", + "label": "graphite", + "description": "", + "type": "datasource", + "pluginId": "graphite", + "pluginName": "Graphite" + } + ], + "__requires": [ + { + "type": "panel", + "id": "bargauge", + "name": "Bar Gauge", + "version": "" + }, + { + "type": "panel", + "id": "gauge", + "name": "Gauge", + "version": "" + }, + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "6.7.4" + }, + { + "type": "panel", + "id": "graph", + "name": "Graph", + "version": "" + }, + { + "type": "datasource", + "id": "graphite", + "name": "Graphite", + "version": "1.0.0" + } + ], + "annotations": { + "list": [ + { + "$$hashKey": "object:2289", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "TopN (Current IOPS) VMs", + "editable": true, + "gnetId": null, + "graphTooltip": 0, + "id": null, + "iteration": 1597058026827, + "links": [], + "panels": [ + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 6, + "panels": [], + "repeat": null, + "title": "ESXi CPU Stats", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Average CPU utilization (MHz) of ESXi hosts", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 12, + "x": 0, + "y": 1 + }, + "hiddenSeries": false, + "id": 1, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refId": "B", + "target": "aliasByNode(highestAverage(vsphere.$vcenter.hostsystem.$Host.cpu.usagemhz.average, $TopN), 3)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Host ESXi Average CPU Utilization (MHz)", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:8874", + "decimals": 0, + "format": "short", + "label": "CPU Mhz", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:8875", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 12, + "x": 12, + "y": 1 + }, + "hiddenSeries": false, + "id": 3, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "repeat": null, + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByNode(highestAverage(scale(vsphere.$vcenter.hostsystem.$Host.cpu.usage.average, 0.01), $TopN), 3)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Host ESXi CPU Usage (%)", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:3420", + "decimals": 0, + "format": "percent", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:3421", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "cacheTimeout": null, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 7, + "w": 8, + "x": 0, + "y": 8 + }, + "id": 5, + "links": [], + "maxPerRow": 12, + "options": { + "fieldOptions": { + "calcs": [ + "lastNotNull" + ], + "defaults": { + "decimals": 0, + "mappings": [ + { + "$$hashKey": "object:9300", + "id": 0, + "op": "=", + "text": "N/A", + "type": 1, + "value": "null" + } + ], + "max": 100, + "min": 0, + "nullValueMode": "connected", + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "rgba(50, 172, 45, 0.97)", + "value": null + }, + { + "color": "rgba(237, 129, 40, 0.89)", + "value": 70 + }, + { + "color": "rgba(245, 54, 54, 0.9)", + "value": 90 + } + ] + }, + "unit": "percent" + }, + "overrides": [], + "values": false + }, + "orientation": "horizontal", + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "6.7.4", + "repeat": "Host", + "repeatDirection": "h", + "targets": [ + { + "refId": "A", + "target": "scale(vsphere.$vcenter.hostsystem.$Host.cpu.usage.maximum, 0.01)", + "textEditor": false + } + ], + "title": "$Host CPU Usage %", + "type": "gauge" + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 15 + }, + "id": 7, + "panels": [], + "repeat": null, + "title": "ESXi Memory Stats", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Active memory per ESXi host", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 12, + "x": 0, + "y": 16 + }, + "hiddenSeries": false, + "id": 2, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refId": "B", + "target": "aliasByNode(highestAverage(vsphere.$vcenter.hostsystem.$Host.mem.active.maximum, $TopN), 3)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Host ESXi Active Memory", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:457", + "decimals": 0, + "format": "deckbytes", + "label": "Active Memory", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:458", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Percentage of ESXi host memory that has been consumed", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 12, + "x": 12, + "y": 16 + }, + "hiddenSeries": false, + "id": 4, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByNode(highestAverage(scale(vsphere.$vcenter.hostsystem.$Host.mem.usage.maximum, 0.01), $TopN), 3)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Host Memory Usage (%)", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:3310", + "decimals": 0, + "format": "percent", + "label": "", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:3311", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 23 + }, + "id": 12, + "panels": [], + "repeat": null, + "title": "ESXi Datastore Stats", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "description": "Average Datastore IOPS for datastores attached to ESXi host. You may want to create own aliases to see datastore names.", + "fill": 0, + "fillGradient": 0, + "gridPos": { + "h": 8, + "w": 8, + "x": 0, + "y": 24 + }, + "hiddenSeries": false, + "id": 9, + "legend": { + "avg": false, + "current": false, + "hideEmpty": true, + "hideZero": true, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "maxPerRow": 3, + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 2, + "points": false, + "renderer": "flot", + "repeat": "Host", + "repeatDirection": "h", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByMetric(vsphere.$vcenter.hostsystem.$Host.datastore.datastoreiops.average.*)" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$Host - ESXi Average Datastore IOPS", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:2787", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:2788", + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": false + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "datasource": "${DS_GRAPHITE}", + "description": "Average Datastore I/O latency for naa_ * datastores attached to a ESXi host. You may want to create own aliases to use recognizable datastore names for key volumes.\n\nThresholds can of course be edited, but are created for an environment that also has NetApp hybrid or NL-SAS storage (say, FAS 8000 Series).\n\nSolidFire volume naa_....011 is Volume ID 17 in the SolidFire Web management UI", + "gridPos": { + "h": 8, + "w": 8, + "x": 0, + "y": 32 + }, + "id": 10, + "maxPerRow": 3, + "options": { + "displayMode": "gradient", + "fieldOptions": { + "calcs": [ + "mean" + ], + "defaults": { + "decimals": 1, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "super-light-green", + "value": 4 + }, + { + "color": "#EAB839", + "value": 8 + }, + { + "color": "dark-red", + "value": 20 + } + ] + }, + "unit": "ms" + }, + "overrides": [], + "values": false + }, + "orientation": "horizontal", + "showUnfilled": true + }, + "pluginVersion": "6.7.4", + "repeat": "Host", + "repeatDirection": "h", + "targets": [ + { + "$$hashKey": "object:2563", + "aggregation": "Last", + "decimals": 2, + "displayAliasType": "Warning / Critical", + "displayType": "Regular", + "displayValueWithAlias": "Never", + "refId": "A", + "target": "highestCurrent(aliasByMetric(vsphere.$vcenter.hostsystem.$Host.disk.devicelatency.average.naa_6f47acc*), $TopN)", + "units": "none", + "valueHandler": "Number Threshold" + } + ], + "timeFrom": null, + "timeShift": null, + "title": "$Host ESXi Average I/O Latency", + "type": "bargauge" + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "ESXi", + "NetApp HCI" + ], + "templating": { + "list": [ + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": true, + "index": -1, + "label": null, + "multi": false, + "name": "vcenter", + "options": [], + "query": "vsphere.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": true, + "index": -1, + "label": "", + "multi": false, + "name": "Host", + "options": [], + "query": "vsphere.$vcenter.hostsystem.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "auto": false, + "auto_count": 30, + "auto_min": "10s", + "current": { + "selected": false, + "text": "3", + "value": "3" + }, + "hide": 0, + "label": null, + "name": "TopN", + "options": [ + { + "selected": false, + "text": "1", + "value": "1" + }, + { + "selected": true, + "text": "3", + "value": "3" + }, + { + "selected": false, + "text": "6", + "value": "6" + }, + { + "selected": false, + "text": "8", + "value": "8" + } + ], + "query": "1,3,6,8", + "refresh": 2, + "skipUrlSync": false, + "type": "interval" + } + ] + }, + "time": { + "from": "now-1h", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "", + "title": "NetApp HCI - vSphere ESXi Metrics", + "uid": "Eg3vkf6zk", + "variables": { + "list": [] + }, + "version": 6 +} \ No newline at end of file diff --git a/grafana/dashboards/vsphere-vm-stats.json b/grafana/dashboards/vsphere-vm-stats.json new file mode 100644 index 0000000..7dcc107 --- /dev/null +++ b/grafana/dashboards/vsphere-vm-stats.json @@ -0,0 +1,987 @@ +{ + "__inputs": [ + { + "name": "DS_GRAPHITE", + "label": "graphite", + "description": "", + "type": "datasource", + "pluginId": "graphite", + "pluginName": "Graphite" + } + ], + "__requires": [ + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "6.7.4" + }, + { + "type": "panel", + "id": "graph", + "name": "Graph", + "version": "" + }, + { + "type": "datasource", + "id": "graphite", + "name": "Graphite", + "version": "1.0.0" + } + ], + "annotations": { + "list": [ + { + "$$hashKey": "object:2571", + "builtIn": 1, + "datasource": "-- Grafana --", + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "Top VMs by Highest Average CPU Usage", + "editable": true, + "gnetId": null, + "graphTooltip": 0, + "id": null, + "iteration": 1597058557481, + "links": [], + "panels": [ + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 7, + "panels": [], + "repeat": null, + "title": "VM CPU Stats", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 12, + "x": 0, + "y": 1 + }, + "hiddenSeries": false, + "id": 1, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refId": "A", + "target": "aliasByNode(highestAverage(scale(vsphere.$vcenter.virtualmachine.$VM.cpu.usage.maximum, 0.01), $TopN), 3)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$VM CPU Usage", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "format": "percent", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 12, + "x": 12, + "y": 1 + }, + "hiddenSeries": false, + "id": 2, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByNode(highestAverage(scale(scale(vsphere.$vcenter.virtualmachine.$VM.cpu.ready.summation, 0.0000166), 100), $TopN), 3)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$VM VM CPU Ready (per minute)", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "format": "percent", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 8 + }, + "id": 8, + "panels": [], + "repeat": null, + "title": "VM Memory Stats", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 24, + "x": 0, + "y": 9 + }, + "hiddenSeries": false, + "id": 3, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByNode(highestAverage(vsphere.$vcenter.virtualmachine.$VM.mem.active.maximum, $TopN), 3)", + "textEditor": true + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "VM - Active Memory", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "format": "kbytes", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + }, + { + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": null, + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "collapsed": false, + "datasource": "${DS_GRAPHITE}", + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 16 + }, + "id": 9, + "panels": [], + "repeat": null, + "title": "VM Disk Stats", + "type": "row" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 8, + "x": 0, + "y": 17 + }, + "height": "250", + "hiddenSeries": false, + "id": 6, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": false, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": true, + "refCount": -1, + "refId": "A", + "target": "vsphere.$vcenter.virtualmachine.$VM.virtualdisk.numberwriteaveraged.average.*", + "textEditor": false + }, + { + "hide": true, + "refCount": -1, + "refId": "B", + "target": "vsphere.$vcenter.virtualmachine.$VM.virtualdisk.numberreadaveraged.average.*", + "textEditor": false + }, + { + "hide": false, + "refCount": 0, + "refId": "C", + "target": "alias(sumSeries(#A, #B), 'Total IOPS')", + "targetFull": "alias(sumSeries(vsphere.$vcenter.virtualmachine.$VM.virtualdisk.numberwriteaveraged.average.*, vsphere.$vcenter.virtualmachine.$VM.virtualdisk.numberreadaveraged.average.*), 'Total IOPS')", + "textEditor": true + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$VM VM Total IOPS", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:6696", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:6697", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 8, + "x": 8, + "y": 17 + }, + "hiddenSeries": false, + "id": 5, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByNode(highestAverage(vsphere.$vcenter.virtualmachine.$VM.virtualdisk.numberwriteaveraged.average.*, $TopN), 3)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$VM VM Write IOPS", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:6542", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:6543", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 7, + "w": 8, + "x": 16, + "y": 17 + }, + "hiddenSeries": false, + "id": 4, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refId": "A", + "target": "aliasByNode(highestAverage(vsphere.$vcenter.virtualmachine.$VM.virtualdisk.numberreadaveraged.average.*, $TopN), 3)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "$VM VM Read IOPS", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:6430", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:6431", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 9, + "w": 12, + "x": 0, + "y": 24 + }, + "hiddenSeries": false, + "id": 11, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "refCount": 0, + "refId": "C", + "target": "groupByNode(highestAverage(vsphere.$vcenter.virtualmachine.$VM.virtualdisk.totalwritelatency.average.*, $TopN), 3, 'sum')" + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Top $TopN VMDK by Write Latency", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:6318", + "decimals": 0, + "format": "ms", + "label": "", + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:6319", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": "${DS_GRAPHITE}", + "decimals": 0, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 9, + "w": 12, + "x": 12, + "y": 24 + }, + "hiddenSeries": false, + "id": 13, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "dataLinks": [] + }, + "percentage": false, + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "hide": false, + "refCount": 0, + "refId": "A", + "target": "aliasByNode(highestAverage(vsphere.$vcenter.virtualmachine.$VM.virtualdisk.totalreadlatency.average.*, $TopN), 3)", + "textEditor": false + } + ], + "thresholds": [], + "timeFrom": null, + "timeRegions": [], + "timeShift": null, + "title": "Top $TopN VMDK by Read Latency", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "buckets": null, + "mode": "time", + "name": null, + "show": true, + "values": [] + }, + "yaxes": [ + { + "$$hashKey": "object:6167", + "decimals": 0, + "format": "ms", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + }, + { + "$$hashKey": "object:6168", + "decimals": 0, + "format": "short", + "label": null, + "logBase": 1, + "max": null, + "min": "0", + "show": true + } + ], + "yaxis": { + "align": false, + "alignLevel": null + } + } + ], + "refresh": "1m", + "schemaVersion": 22, + "style": "dark", + "tags": [ + "ESXi", + "NetApp HCI" + ], + "templating": { + "list": [ + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": true, + "index": -1, + "label": null, + "multi": false, + "name": "vcenter", + "options": [], + "query": "vsphere.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": null, + "current": {}, + "datasource": "${DS_GRAPHITE}", + "definition": "", + "hide": 0, + "includeAll": true, + "index": -1, + "label": null, + "multi": false, + "name": "VM", + "options": [], + "query": "vsphere.$vcenter.virtualmachine.*", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tags": [], + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "auto": false, + "auto_count": 30, + "auto_min": "10s", + "current": { + "selected": false, + "text": "3", + "value": "3" + }, + "hide": 0, + "label": "Top N VMs", + "name": "TopN", + "options": [ + { + "selected": false, + "text": "1", + "value": "1" + }, + { + "selected": true, + "text": "3", + "value": "3" + }, + { + "selected": false, + "text": "5", + "value": "5" + }, + { + "selected": false, + "text": "10", + "value": "10" + }, + { + "selected": false, + "text": "15", + "value": "15" + } + ], + "query": "1,3,5,10.,15", + "refresh": 2, + "skipUrlSync": false, + "type": "interval" + } + ] + }, + "time": { + "from": "now-1h", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "", + "title": "NetApp HCI - vSphere VM Stats", + "uid": "I15dkBekz", + "variables": { + "list": [] + }, + "version": 5 +} \ No newline at end of file diff --git a/grafana/provisioning/dashboards/dashboards.yml b/grafana/provisioning/dashboards/dashboards.yml new file mode 100644 index 0000000..6c6cee0 --- /dev/null +++ b/grafana/provisioning/dashboards/dashboards.yml @@ -0,0 +1,11 @@ +apiVersion: 1 +providers: + - name: 'default' + orgId: 1 + folder: '' + type: file + disableDeletion: false + editable: true + allowUiUpdates: true + options: + path: /var/lib/grafana/dashboards diff --git a/grafana/provisioning/datasources/datasource.yml b/grafana/provisioning/datasources/datasource.yml new file mode 100644 index 0000000..72c042d --- /dev/null +++ b/grafana/provisioning/datasources/datasource.yml @@ -0,0 +1,11 @@ +apiVersion: 1 +datasources: + - name: 'graphite' + type: graphite + access: direct + orgId: 1 + url: http://DOCKERIP:8080 + isDefault: true + version: 1 + editable: true + basicAuth: false diff --git a/graphite/Dockerfile b/graphite/Dockerfile new file mode 100644 index 0000000..92a78d4 --- /dev/null +++ b/graphite/Dockerfile @@ -0,0 +1,35 @@ +# Dockerfile for Graphite stack +# +FROM graphiteapp/graphite-statsd:1.1.10-5 + +# Graphite +COPY carbon.conf /opt/graphite/conf/carbon.conf +# https://github.com/graphite-project/docker-graphite-statsd/pull/66/commits/9092b00ed236c4b9d4864fa2f0731486987078eb#diff-3254677a7917c6c01f55212f86c57fbfR121 +COPY storage-schemas.conf /opt/graphite/conf/storage-schemas.conf +COPY storage-aggregation.conf /opt/graphite/conf/storage-aggregation.conf +# StatsD +COPY statsd_config.js /etc/statsd/config.js +# Graphite API +COPY graphite-api.yaml /etc/graphite-api.yaml + +# nginx +# Ports +##Graphite API 8080; Carbon line receiver 2003; Cabon pickle receiver 2004; +##Carbon cache query 7002; StatsD UDP 8125; StatsD Admin 8126 +EXPOSE 80 \ +# graphite-api +8080 \ +# Carbon line receiver +2003 \ +# Carbon pickle receiver +2004 \ +# Carbon cache query +7002 \ +# StatsD UDP +8125 \ +# StatsD Admin +8126 + +# Launch stack +# https://github.com/graphite-project/docker-graphite-statsd/pull/66/commits/9092b00ed236c4b9d4864fa2f0731486987078eb +ENTRYPOINT ["/entrypoint"] diff --git a/graphite/carbon.conf b/graphite/carbon.conf new file mode 100644 index 0000000..0554946 --- /dev/null +++ b/graphite/carbon.conf @@ -0,0 +1,161 @@ +[cache] + +LOCAL_DATA_DIR = /opt/graphite/storage/whisper/ + +# Specify the user to drop privileges to +# If this is blank carbon runs as the user that invokes it +# This user must have write access to the local data directory +USER = + +# Limit the size of the cache to avoid swapping or becoming CPU bound. +# Sorts and serving cache queries gets more expensive as the cache grows. +# Use the value "inf" (infinity) for an unlimited cache size. +MAX_CACHE_SIZE = inf + +# Limits the number of whisper update_many() calls per second, which effectively +# means the number of write requests sent to the disk. This is intended to +# prevent over-utilizing the disk and thus starving the rest of the system. +# When the rate of required updates exceeds this, then carbon's caching will +# take effect and increase the overall throughput accordingly. +MAX_UPDATES_PER_SECOND = 1000 + +# Softly limits the number of whisper files that get created each minute. +# Setting this value low (like at 50) is a good way to ensure your graphite +# system will not be adversely impacted when a bunch of new metrics are +# sent to it. The trade off is that it will take much longer for those metrics' +# database files to all get created and thus longer until the data becomes usable. +# Setting this value high (like "inf" for infinity) will cause graphite to create +# the files quickly but at the risk of slowing I/O down considerably for a while. +MAX_CREATES_PER_MINUTE = 60 + +LINE_RECEIVER_INTERFACE = 0.0.0.0 +LINE_RECEIVER_PORT = 2003 + +# Set this to True to enable the UDP listener. By default this is off +# because it is very common to run multiple carbon daemons and managing +# another (rarely used) port for every carbon instance is not fun. +ENABLE_UDP_LISTENER = False +UDP_RECEIVER_INTERFACE = 0.0.0.0 +UDP_RECEIVER_PORT = 2003 + +PICKLE_RECEIVER_INTERFACE = 0.0.0.0 +PICKLE_RECEIVER_PORT = 2004 + +# Per security concerns outlined in Bug #817247 the pickle receiver +# will use a more secure and slightly less efficient unpickler. +# Set this to True to revert to the old-fashioned insecure unpickler. +USE_INSECURE_UNPICKLER = False + +CACHE_QUERY_INTERFACE = 0.0.0.0 +CACHE_QUERY_PORT = 7002 + +# Set this to False to drop datapoints received after the cache +# reaches MAX_CACHE_SIZE. If this is True (the default) then sockets +# over which metrics are received will temporarily stop accepting +# data until the cache size falls below 95% MAX_CACHE_SIZE. +USE_FLOW_CONTROL = True + +# By default, carbon-cache will log every whisper update. This can be excessive and +# degrade performance if logging on the same volume as the whisper data is stored. +LOG_UPDATES = False + +# On some systems it is desirable for whisper to write synchronously. +# Set this option to True if you'd like to try this. Basically it will +# shift the onus of buffering writes from the kernel into carbon's cache. +WHISPER_AUTOFLUSH = False + +[relay] +LINE_RECEIVER_INTERFACE = 0.0.0.0 +LINE_RECEIVER_PORT = 2013 +PICKLE_RECEIVER_INTERFACE = 0.0.0.0 +PICKLE_RECEIVER_PORT = 2014 +UDP_RECEIVER_INTERFACE = 0.0.0.0 +UDP_RECEIVER_PORT = 2013 + +# To use consistent hashing instead of the user defined relay-rules.conf, +# change this to: +# RELAY_METHOD = consistent-hashing +RELAY_METHOD = rules + +# If you use consistent-hashing you may want to add redundancy +# of your data by replicating every datapoint to more than +# one machine. +REPLICATION_FACTOR = 1 + +# If using RELAY_METHOD = rules, all destinations used in relay-rules.conf +# must be defined in this list +DESTINATIONS = 127.0.0.1:2004 + +# This defines the maximum "message size" between carbon daemons. +# You shouldn't need to tune this unless you really know what you're doing. +MAX_DATAPOINTS_PER_MESSAGE = 500 +MAX_QUEUE_SIZE = 10000 + +# Set this to False to drop datapoints when any send queue (sending datapoints +# to a downstream carbon daemon) hits MAX_QUEUE_SIZE. If this is True (the +# default) then sockets over which metrics are received will temporarily stop accepting +# data until the send queues fall below 80% MAX_QUEUE_SIZE. +USE_FLOW_CONTROL = True + +# Set this to True to enable whitelisting and blacklisting of metrics in +# CONF_DIR/whitelist and CONF_DIR/blacklist. If the whitelist is missing or +# empty, all metrics will pass through +# USE_WHITELIST = False + +# By default, carbon itself will log statistics (such as a count, +# metricsReceived) with the top level prefix of 'carbon' at an interval of 60 +# seconds. Set CARBON_METRIC_INTERVAL to 0 to disable instrumentation +# CARBON_METRIC_PREFIX = carbon +# CARBON_METRIC_INTERVAL = 60 + +# Introduce delayed tag updates to mitigate errors in logs +# https://github.com/graphite-project/carbon/issues/816#issuecomment-453463723 +TAG_UPDATE_INTERVAL = 2000 +# ENABLE_TAGS = False + +[aggregator] +LINE_RECEIVER_INTERFACE = 0.0.0.0 +LINE_RECEIVER_PORT = 2023 + +PICKLE_RECEIVER_INTERFACE = 0.0.0.0 +PICKLE_RECEIVER_PORT = 2024 + +# This is a list of carbon daemons we will send any relayed or +# generated metrics to. The default provided would send to a single +# carbon-cache instance on the default port. However if you +# use multiple carbon-cache instances then it would look like this: +# +# DESTINATIONS = 127.0.0.1:2004:a, 127.0.0.1:2104:b +# +# The format is comma-delimited IP:PORT:INSTANCE where the :INSTANCE part is +# optional and refers to the "None" instance if omitted. +# +# Note that if the destinations are all carbon-caches then this should +# exactly match the webapp's CARBONLINK_HOSTS setting in terms of +# instances listed (order matters!). +DESTINATIONS = 127.0.0.1:2004 + +# If you want to add redundancy to your data by replicating every +# datapoint to more than one machine, increase this. +REPLICATION_FACTOR = 1 + +# This is the maximum number of datapoints that can be queued up +# for a single destination. Once this limit is hit, we will +# stop accepting new data if USE_FLOW_CONTROL is True, otherwise +# we will drop any subsequently received datapoints. +MAX_QUEUE_SIZE = 10000 + +# Set this to False to drop datapoints when any send queue (sending datapoints +# to a downstream carbon daemon) hits MAX_QUEUE_SIZE. If this is True (the +# default) then sockets over which metrics are received will temporarily stop accepting +# data until the send queues fall below 80% MAX_QUEUE_SIZE. +USE_FLOW_CONTROL = True + +# This defines the maximum "message size" between carbon daemons. +# You shouldn't need to tune this unless you really know what you're doing. +MAX_DATAPOINTS_PER_MESSAGE = 500 + +# This defines how many datapoints the aggregator remembers for +# each metric. Aggregation only happens for datapoints that fall in +# the past MAX_AGGREGATION_INTERVALS * intervalSize seconds. +MAX_AGGREGATION_INTERVALS = 5 diff --git a/graphite/graphite-api.yaml b/graphite/graphite-api.yaml new file mode 100644 index 0000000..43a4df1 --- /dev/null +++ b/graphite/graphite-api.yaml @@ -0,0 +1,17 @@ +search_index: /opt/graphite/index +finders: + - graphite_api.finders.whisper.WhisperFinder +functions: + - graphite_api.functions.SeriesFunctions + - graphite_api.functions.PieFunctions +whisper: + directories: + - /opt/graphite/storage/whisper +carbon: + hosts: + - 127.0.0.1:7002 + timeout: 1 + retry_delay: 15 + carbon_prefix: carbon + replication_factor: 1 +time_zone: UTC diff --git a/graphite/statsd_config.js b/graphite/statsd_config.js new file mode 100644 index 0000000..1004144 --- /dev/null +++ b/graphite/statsd_config.js @@ -0,0 +1,8 @@ +{ + graphitePort: 2003, + graphiteHost: '127.0.0.1", + port: 8125, + backends: [ "./backends/graphite" ], + flushInterval: 5000, + deleteIdleStats: true +} diff --git a/graphite/storage-aggregation.conf b/graphite/storage-aggregation.conf new file mode 100644 index 0000000..2c4dc12 --- /dev/null +++ b/graphite/storage-aggregation.conf @@ -0,0 +1,17 @@ +# Aggregation methods for whisper files. Entries are scanned in order, +# and first match wins. This file is scanned for changes every 60 seconds +# +# [name] +# pattern = +# xFilesFactor = +# aggregationMethod = +# +# name: Arbitrary unique name for the rule +# pattern: Regex pattern to match against the metric name +# xFilesFactor: Ratio of valid data points required for aggregation to the next retention to occur +# aggregationMethod: function to apply to data points for aggregation +# +[stats_counts] +pattern = ^stats_counts\..*$ +xFilesFactor = 0 +aggregationMethod = sum diff --git a/graphite/storage-schemas.conf b/graphite/storage-schemas.conf new file mode 100644 index 0000000..f4b3653 --- /dev/null +++ b/graphite/storage-schemas.conf @@ -0,0 +1,43 @@ +[stats] +pattern = ^stats\.*$ +retentions = 5s:1d,1m:7d + +[netapp] +pattern = ^netapp\.* +retentions = 1m:2d,5m:8d,30m:30d;360m:365d + +[netapp-drives] +pattern = ^netapp\.*\cluster\.*\node\.*\drives\*\.*$ +retentions = 1m:1h,10m:1d,120m:30d;720m:365d + +[vsphere] +pattern = ^vsphere\.* +retentions = 1m:2d,5m:8d,30m:30d,360m:365d + +[carbon] +pattern = ^carbon\.*$ +retentions = 5s:1d,1m:7d + +[statsd_internal_counts] +pattern = ^stats_counts\.statsd.*$ +retentions = 5s:1d,1m:7d + +[statsd_internal] +pattern = ^statsd\..*$ +retentions = 5s:1d,1m:7d + +[statsd] +pattern = ^stats_counts\..*$ +retentions = 5s:1d,1m:28d,1h:2y + +[statsd_gauges_internal] +pattern = ^stats\.gauges\.statsd\..*$ +retentions = 5s:1d,1m:7d + +[statsd_gauges] +pattern = ^stats\.gauges\..*$ +retentions = 5s:1d,1m:28d,1h:2y + +[catchall] +pattern = ^.* +retentions = 1m:2d,15m:28d diff --git a/images/dashboard-h-series-compute-hardware-monitoring-h410c.png b/images/dashboard-h-series-compute-hardware-monitoring-h410c.png new file mode 100644 index 0000000000000000000000000000000000000000..78327cac3f8f46b894f47b2f58948e549cde2f3d GIT binary patch literal 164871 zcmY&<1ymi)vNaMQ!3pk3aCbdO2=4Cg?iTdm5-d2u-QC^Yor4_Q-R&TMzI)%h|9!RA zteKuQ)2pjxSNE=}a0NMW6hs0BSK4Z~2phgr+kT6l&i;7xa*Qu?ZB^dx4~gkjhWJQ!s)7 z=H3RvrF|TyEiVm&f(4Dj{rZ=WFr#Wh-?2on20FTf-@sm*>pQM~Va?yao6yxhWSXi_ zw_&xWaoWy4c$_oZ&KBD89zFVQTApVTwzRFifp607zWzq}_TQ3g^_@y73ej&74JlNv zNI5>;r$E!K=3qo@&t9%`rQDa-DN$VHza=?F4^qx!(yX3u^T&zMi8WE|tm;+xD`bpp zRg?tdzeQJogAs~WI6c~59=}&*b-^rnG23@{_w#>$qe!6+EA2NbQN)i-8<%Uhys%(-FDgOKaQg$nYPYQST>p-3@*{fL0*?O*BlmFWe zQ#CSazx{Stb|!e<@UZ`q()v_fC{+s#1+Opc@?}yCxTTyt28m7o-ESg^Y7=EJ>U7Yw zeJS^)_Rhi?ajD5^d!Px9PK1R2sw%A5X*ygbXQoa28?2*kGbstk1vMO}EJ@q($MJly zToI-uT85r4&hOn^#ne3otIQSh_u`4@Q}BPQysiMNFT7&g>?4Oc`62=E_ zhtywc_{p(k>T?H`qpYM0h9t$Fn*ueSW9VbEO1(Z&*S}lHT`F77rY6EaiH}T;ss8@~hkonym5`SgcWaa#D_Pt1 z5w^FtCod|r;3*yBAx$sLRUI_lEzUl2RyR$FIc7#v;djV7B#9qEFmp~_RC7&m( zl#nt0f9pkU!{4fNqG6g|SXxS-luX~K@%3vLQ)O|?Rjj|3c4gE3prO1s@8VEu;{Dc^ zuf^_3c$ZuOb%Ds3*4ZZd;holqJh8Ojf97do6Oj9y3lUu7Pu5FB45p zd4_g})oIu2c}-PwKaY1DRuyfH3P)B>UKPAARaX@|TK~Z!dnP;Kv_Ae!z6q@-oG`5o z*;lF-BCj57JQXHEG4j1+9FirmN5Qpyq5w0`vgcs+^}nZNu2khbw1Q^C*=bqtZwF~Q zis=?N4dVh$-%-CpWV6xl7K$c<(XVg>V>NE;HX)q<>79S3Qz@CIy>*GPKkMdEWqipW z5Mfr1ikJ0LQzlwv`AJ?wiOF4)PcqTc%4qc8E-qP7D}z^ON;^~C;w8Tle{(NJRY$E5 zUTw5xF}eI66dX+RIr1`2ZCbrylUdrd;;n7w;cSl^;_3H8w&4#z^g9L?U;<>i& z3C+Y_?(b@QLyWDo!SyhB6aov|NfU+Jq^q5T{i_{2wH4jiC(Qb{|FkHq__|cRiZKL* zFqeE;Mnohri+)Mt_;a?GIH#zvzI?@mrc$Bor=OL8tinAkS+z8}co*;n%K$+mH4nvi z)7cZ6w!Sabedh<*n9{;vXVuKiWP-Wl|p^Qs2wWS(_R%c$Y|qx zEbWd!&Hr>FE3f)7)FE!i4;BGd1#4$F@Mt^*qQUyN!G{(+dl@TA-tm}4Cuyc)w`zi0 z7eu4diEa5zze1hw_ijA(sB=YKsxDA2$HtGBeGiFdUYT^tg?yzP7z-k24hIPG#>E$E z?e0_Jpz=L6RDR~Op=4&Lvdh_u3zg~mKg@@JrX1W?>mJXp%&%5?7}{nDVjhxYMABgE zm`|^GwEhP(Vy&Uyp#K6?ePiuHy`{4E)l-oc;pJ|9QMK0tNkzr(Uj!qkpt7_rot+S8 zxFrI>+s3Kwgqn&QE;vQxvCr*l7SZrFS%$1oHt=5!TiNg>9TfgN$!Ttr_c2Ld32Tu? zZNdJ)aK!Gxbs8dI8@QFz&}Jrf+L;0Jpr4`F?3F0-DRH}?Ic|L7sFa{>*~IkB($d#=H_h%1W|B~f~l^HrO@DjI*!;P^ZjH)Ts!h<18{(3$D zW~wfPTp*2&6gcvvS&M$t2}HsK?1Pim&Zgj$5oEmY=*Baf6#l@wf*x4*R?LjbO^1fM zaJ*k-OnE1Bn>z$_;3+r0KO#K#YFk&4d}DSQg*?8wLp+;5BJFzztJ_~7F2zi!P%L*X1lR@j)BYdc(B!rSnqezJc@ z7pb?3a67BVqD?L!(c9`^Hq)R>IEb^I?Ia_B_x!R-g@-~IVqL-rgX~05w}tsR`nlmG z5ByuPxl!2`uYPM(`(QF-bL*(&17}r>ncu7(+FuZF5s$HxYBHNhEj{UE89TcQ&ga5D zqv8jy+7X6l8dh2hFsQ==*;}0QAKzH;W}9HOs3C)t7IO_~A(0)}P2g!l*%y>cTTXOL zN;Dy9TjtR!8JKJqnm-!el=!^z+H$;!hCSMCj8;C}5dEbU5TFvn$S$UT`=sypPj|M0 z*EhF@gzRE4F2Z(=03-I2Xwq4Z+92zhq?1h&QQLv+Ikg;cK$10k!S2QQH;cj&SoZ)o z({odj!GXHZrt;a+aVOD&5}5Q1W+^W^@umH?+;VItA7|X=elc{pjDTij!6u)+(MsgJ zKi)%XEgyzC0sZqZkLl9HK3@6VE!u-ZHm=OuD^6!`Y?uF1Qsywu%V=-jw%Yr*bwV$!tkaLq8ovkIl+9J^KiAC zKvEe>=e80mf8L7PXYYYjrsKv0QHi_jsp;^J$4AN}4$N7SA3!_Majo(mnN;QC5H(oy zA~hJDHoN5OQq@H}pdUJ~UpZtwH}$@`*BIvFZzE}}EgECC=g;bok)99zrsHOA^#7%_ zzl5D~ofrB-2Btli6wZk=m#K9#et^70>4M z5JQWKh6Cfv0N`ukq0^p0WXm3>49U9GiNO+LU*eO4TptpVAxjDjy2Z74MR)BdJzSou zM49j4v2bY?OJ2d*ebZ?yI)xXb6FbDAIsQO&#nrwN;PTs|YLAAyvv57y zNJZYu+rojPZQXX2foPnwKK7p#!`1_^nvH+5wkN*C} z_7S~PG3$W{dJsG|U`lXRp8ArGW^E87HS;qu$?> z%$jb-i?B?aWGsSgU7o}b9d!h_cd>YUGjEXQRej%_oxz+gZt<|U9mln&dBCF-{yniw z$KBT#k_z$Ho~CWoCAe6+meN)M6~k95BNal-I8NWlHWF`LT{Pe$-jsYN3aO2ZzkVo7 za~bWK5|QeG2id>25wukI>Jr#ouBRZyd{ikb0{lN!ZQiztY#d#p#PTk-#f9yC&GCra zr5m|%;&pZwm<~7q_w=3|+fYM0a%un8^QLMQboEzW%Df^3RyO)+ub*FEO4FEI-Gv{$ zuw1P*(5m1orfH||xX((yR6e^()lzjpdr%2qY(b;N-qs?_5Fae=a4~%J)D8WzwBsZJ z=eST+hK1>@MA+-2s2HjnJ*G;_puXcGlZ%%8bWZ6W!t}2a$z7Y_ZBXptYM}rOf9-s> ziYE>q%t`hDHW`bd3)lRE0}FkvGYsidYa(k&e~PY4e91aCm%*B=dXDj&XYt-i$p^jk z=Mv11z}RGOZ$eHRP)huLrsH8z{?WMB`13R2I5=~+)r%#*bkn0k=3fn$6FL+q$L%#4 z2PFmdjU8;RUifxL;(zmbC+^H@LosKwF(M_u|D%2@Oc-D0*ev&t9?sX_U)KYtJ2H{4 zR)2dsVeXGw#?Fz?K5UHlPXS5A0wMzmI_9BDcAa!uB+n@9JK?7E)BF(HQf36E5%mLW z7n%<*t_x>r{1Cob5oX_vPfA9-jp+-&q@M`S4#s)*krKs{ozNpKiF>Q_Ts>3CT>9EdCB|b zWjP)XC&w**p`KCq`g0{J4nq&@W$mH4+xoE@B&I*{&X&9N3AS9oLg;&p5MGJvCHG?{T`>6V+FFH5;uLS&(c3;U$rv|KG!69&PXj6eKm|-!mXLA3 zEU$5ytdoVa9n-#W8V!_x%Gl^~$I^Q>6u=oXE3h-L^%+*Sb&TD?Ooz;r5;Is4({4R0 zcol0!Ri~d90N)~~3Q>Z0v=|EECn|kDkghbR1aO!hKfOO3S2*aYIQ={* zjn8N_G+nze{x#>e_X{wWZ`UNffjOtJdvBri{Ks^o@xX`bxkUX|Ir+|7Sisopcvy;? z$&pR1eA(Z5gqPhSgV2d_xfSadKmcQ|VN*78vTj(sQ$YXro#uS>69^%9^(^}4SvhlK zu2W7RI2_IAm;QUg#8cUVS~HJ5CCh{pZ*sKZ$B^5WQf9&{tn*c=BpJC2?(HVmfJa&Ng5?w!|2Jx`D^E)*g7+E;0w&gyPMc>3{E_d_yPe&m%l%& z%$%-%)}!D8|qxFDbg)hWff)~A=3#DDs*ip$m zxoDS;>&8UpDlKryAA)ew^&Y6yGMI&n_`Sa>-xug=Jf3j&j~e8O!@8U*-5312iG>{C z9KQ{D|K#!2YDY`1buJp|BO~POsM-8HJz&($R0iWXw)Wi{{cJmIn)*|j_<*6=lFB$9 zNfCP$UV0<|hV4qLOZri}zKQ@N2CZ)o#;E{5gnCsI`e;(fqVi5NbCeuvg?bv6`4|3z zl9C&aQCw|(Woai$$4pVU;?bh{B+XjW3yc}5#NYt{Gtul%6W3Q=e1U1wM@tpmg8pLi zz>-mS6&UNKiltPY)pn1v>lV{7&b_)X@0EIa9N6LnjlQ=Cx%AM7t`G5eD*YpAB@gkB zyL)K^zv@ZpOzt9)n!c61LCHK_x<+F4F}__Y%49s#aE|u2UZq`*%!^<3Ms^%`r@pB- ziu*Ajo&ckJ+7ki4jcg+H@^pYT>P3#tRl)#AMF&2f5 z{4~(O+g5+~v){dlQ%?>lrsIrA=y%o%0n4Q)U2s0!`ztB^#UdSU$FF)szXE5@LI|%v zJo`D<6&jw(?p$rdFpwGX>1Dlrd0y)DyF)U?&Zcu5ZzHB`zhWU7RZgf~2m?$*7gYl< z^oS+^nr`QjQ|vHP5x$j`SwR(2f=D$SG#|hNytkI?Os)#KcRlZjYtBG~e7n>L{eAj@ zMQ(X^Vh7T~=qUymLY6m<_M2&gprVWJEGgHXG{>*iu$1kOtahVE6G5?49Z{k1^Ww8f z!A7YE20cmSK`w1@_P*B!Jq2>B{9z9RoNJSilvWhFu{^jC*(WIbNa~*mo9pbBsgb=m zPmM!VSJlD}ve6d>+Pq(=JxG(nu3j6Tv5un&bX;Dq&6$Kcb6Xb{Vz}WvvESu}^3&`F zVf8J##KV^goF6@ev1|qx4>=`HgjmoswD1NNF68Ky7P&Az;^XjDn(ad$$4zFdLyPWgYre9~&fi6PT6U52dX;(OAUMElLd5= zgC>KmwE~dyNKi;e$mVD@*`wDa6R31epEtB3_vxaqc3D%*o9J_$%jG4tLEsfzI8Akq zU5sS&NoHF@_AUzlai8kNaxHVF0N$Nx$(8KtrT#CHH`!;SepOeDE_=2{v4OsQros+) zlSwG2-|5#?*L_tOsU9N6V})RDOU_)oqV+@itbO-m^#bp#xE)VD6j{hltDfN{cN6a4 z-CJMmyq1OY1iDK+(qtQdWlJH4Ra)NV!jgB>;iBIbiB11=4r(#lAfn z3+zv%Rq=&i&!zK70qcOzpV-VNd)HckyV9gSx8aBHXa!wH5ljS}82(9ko>WM%oyL>0f;wIHP(-m-V>xzkC`bPifUbtC4m=4+UI z&{t-6h!z*N8QLBj<{X!lk6(bdFM*@(U$Sw^t(}v{#HR!UyK2X!y=T~y zSs`v1g3z1BF~;USNwhnbeALC!74G_%zYhN;`T{(u(J$Y5&gLyHN(3~SWtr}Y;*w(Nza|alqFv1 z{ycTL&bQEw5LL*Ih}f4O#|IZnHN?DW5gr^lK5b&mg`|B1rrvEeo?u1tlR)%k+7GSY z1s}sQq((D(A?NEzdozdY!v<@stty2sx4~;Wv()eUu zR(iu{gq!hY6m};ZSQGl!J7sG8JeA{P`CrmETH6n3+b5rz2z!N6>9z zJ@5sqF<#eQ3)760EJ*g{^27L3L5xpmoXM+U7)v`n2p2;rT#?Oao=vqYTBYd&Vx*QU7apDS4+SP6PJl` zpnQK&6Eiv04%UqBG9Tw9LLV}z5@X0HMSZnjC1TnC(G2KB3LkA#6i(HRGP@6FVH!X( z4mCbJyD)A`Ql;E}h`=NcCEZyQ>JL*@t!he^*a)2>ZO1phc>0*uKs4gLAIBQy-*9GX z!SqEa!$Kz>Fr#t3EsMu%^Lc$W$8^u}St*Wt;ZjtjsB#-i6!QlAoS2iSFY85iY=vIjS3~&0`ov}C49@xFM@X!7(uIv6Abmqs1aczXG4Ek7_Kow8C`U@FZxzDTR z!)%AY8MsVXww}mX2+|IX6hf!!hn2=yvkTp5RXRN?V$d~N!EHPtU^aaB4SxKGwP`Vr ztPFOM{p_vqyn>#!ZfJl=?k=sFPF+;7Hj4pXQ`{Y}I1aC7IooRnXx<(=# z_3#7w&_&O$C#1w5_R*FDnLj_kspyz?@|KB$A2e;?KAhiHYhIsHA)PkafD9BCzqU-$ zjKi0!FVY3p{*u%(oO$W5QBc#*#Qd-jkcF*O=U3Q2R%nmO(|FgL9Gm- zv!s-BtKi9odlApcp9BjmU#8n4ft~64!rs63ZI<;6M$e|+mLEpx7XJDqh*rGr55Ef3 z&E$D;6}_~VysN5*%g=1uDS=kyH`At)H|rVj)WKeYp0pnKdiB1k^UCYkxNc_%JVIO? z;7~>>SyCKY!6naD1&b| za;k=hs$>~)`TYD*?bYvMDMQ#G2I1=H;^yjRiFEVH3n53=&!-)Z9H0)qrl`;#p%IkU zqZ*b8ZHIDcd&Pd)uz|E;h|aDrq_n-LZ-rhgZP^&0@!gKtj{>9xz0XOIlN77duZA-V z*6y91JA2yu{#bawmObuGwWM4v)1|oGU>Bd9F-MN=PO^`{j|fC2&DLh~?NR{7?!$P0 zA8;QSa{?Zy;=jr3btZ)5MF{lHhm*1FHx^yKz1(qU5(TLVllF+~gUimlq&gT23`h0@ zhcB%|*I`Y)v~^}^@fr__HJsGW#2KK8LQVu+h`J;mBF-4i(`$ux*xv%;2yZCo0%So< zlZj*i{W2Q>Lt6uS*MR1!R*O1eOxj84W0hQ*jF#RXo6zlTt}#_#JFk%?QOf@khQzP> z`b%8-rXw?5sG!RU%Cfl0G={(DQR` zWH&(%u_$q`TYErhE%-23XT4#WTzKvD5xx)%22^uj#wShS_(RMuSvT&WgSrM=} z$Bn6Q26l7l`$RQpMNJ`&8PaFG0+Q_bf{>P>EoLhP?V4?|T9XtT=6UfgZZ7?VkfaFW zloER3NJs`slG?Zx^J;%FdvptjSbRp?W*UkM{r1}On){fF1iFUUjK6y^HTFUbEwAum<; z;R~xyMZtWM%O@i{uzG;ywdEq+RHr=@Z}5J_fg%IGrIly!$_2Kp!b~CxuJy#|r+~_V z)F%pL-+kSr0STuChS;jXaE1+PvF&dhrRLwWM?B`OjacXHgevLw>sOsQ=PY%Idq*49 z+*uaA0is@+#!c-W_q);Cw+D7k`MYNjtP3U_uftaLot_~t-n$*{@#P8U1S^l50#mQ_ z=lIhzDMaFs%Ghl#L|eatmP2c(07LD$L%4whRbYSZ zb6;3}`qf{~#i4d&Bm*HtFf0Zs4Sh^H|F_D5SxxADb$*fLWTx^wpZjs*T>JK_7ou*jOg z8SJ=b9jT>&t>Z#IF0=6>Zu8U@mxJ87e0+v+CcmJ4+ir@whOZC}gBx0s&lACUmIK|o zju%E@*oouKPi47>*>Y)1Y0jPO0W@3BdvUk1Hw*oZki#?SgyhKs)FOd|&0|2)uPB}- z!2`#(c*Lxx;74;W#OY?Tkl@Dt>`6l-B{$=}&b2MDrXZrUX$SHC7}HGaVG8^Xh2xJj zXZo30(kfK<879pCh_b6pT!&O!Zd_jbnbMo@yu2ovwphm3lsdAH?@fc42jiO6>i%@A zXCqf_h|)@y`@&S#zegKk8bx$k4|Bb|KPw^s8J3u7QC%pPQ3@}VywA(e19^?p+vl{M z%Topl$;9B*mDw@Isgzn;&BLD&!qX-qwl)K!Y?PU`-0fn}XX<9V${cyfC6U!mk6IkQ z%2n*&JG>d0lVoN}VK=e$!3 zM(rMP{{*s0#+5nJO44_U;3Jjk;u_ZSyYc%zKfhl#$T)Lu26S{)w-z&a)=>=Z?bArg zbtI)`y{Z-#Q)R?ZPt@XSg&^_0+ae0r52zkI_$_BzwM_>md+ftz z>V0Jyrs!&Cl+ppK0PEMX3M~jvKSdbMyTN=-A&qL(SV9HY7dAFRe+GyVXqpb)$r7N( z^oYW?ZzG<*jue&3H9@TJFNp?gRO4IOL0+tN?R@^MQE*#&VwfJUQtm1v{U`Lj&*Lfa znfH)8pY8|$Lbr?E^$(3Ke~Y5_FN*;w#d*VSEF|iZv?J^sR_mi4X*LRklvmcf7fp<< zF7|nLbw(MJ!%JWu>{qZ9)1*g>wUC_Nx|^4pofotu3DOj4&(_a}QdM^urFB!ybd_AF zVq`mbxG?;idhC=+`>KSJk*mM{C35YG$Kxcer+~cZXHGWWCaovYWyFIO%nfDI{?narS(_)1pwm*MES~uGn4xY5pQgQM9vqE-1;c z$EXWC=7v!}H~C~#jI}(~FQRDvzP6g@_ya3?P!f36k|$aQ?;ZqsJnVbl+7Gb8AGUtK z<{NY5xwp)aGN-pYW=e_|Kwj!-`!JSdb+iXP8j&bm=_^_P9#&++pR{U>{+DcDalMgq zF%R1j_?=0al)GsMd_o>{uJawZ&=*K}*G=8eOQ|_3w)iMk?CpOTF8v!D|7T%Vca_|j zsC1XT%0|Z_Bi9fvsG8z0EBY~AC*p~;BZS61W@sYjC6Zd3xe|{pr`z2x>FGJU8CBQ| z0UE)#kF08<|N2ak+eMSB~X3^O#l6$Owm(Q2aiYXX7(qYW4~@VQZ}S@^DLHdv%#{;uGR zaga#~qphFs7mIx=HsSp@QPS{AE>uxM{P(px_w%YDg!-_c=vnb)nY+W1aMA=<$!vIR&NZ=PPgIO&PTuHd)>Pw|mN?;p zY&P*!%v_P(IQYzL-UL3NP#2^B3 z8)vY${=o>@438m!IEhfyOrtGf=sfaW`-DVOShTBFp8f&n;rxS^OMFv4hhqtEP>B2Y z3;zlXJpfUKR!}!}C)ry-JDZt4BlO3Md3X#dg>vrCj+?`9p!T%vso!=+p1isCU24T} zY;SPGM7wFSKSeDd~{t1c|P*5G>9IQ zRSq2zR*An$kbPz{%~AX5e0#bC8+EcE9FK}J@ca90!Odv%FUrQV(;F#tm$Q}Nl(sj% z+6Y~d>JRjg8aH>o-E_~zb3el!yKcX8hG}MUtXSJN!)Z_&OLIY2>qgBW8E56o!*?h3 zl(B%F_cwo(gX{H~JE1&Z^_&9aeKNRE_t&CbH9UQ~${B(PQIF8lMIC>s+cJt&TfFOK z(bK3z`(d1}UlF(C4Zd>zauDXIx6Ldu=@ewTxEaU735`JaN^qG13`;2-PpRxc>X5ic;v>49j;2i=(+Y8WFEE zoQK*j0~VpCwgl|x83W%UBUVZ~l&Amt_g4ZBk@PO@z2V>wyt>Li1!@IFOkt6a62MGW z3}oUFw)5&lcmV(pge=c)YY8`u!dxvpoo^5FL*k^JkpQCYl>NN1YIXQ2lfV=n<)Jm^u}YEPGNZW)xqb^*4tbHqz}pG?G5%(1F-y zPqyeVY_bRb{C}3j}!6nilPM2_DoTA^_;&nApXyi z{?m8h3UXAEO_r8m0D|J!(5Fwd)>sX>Jwu+miYmhelfuWnzGk>X9xf> z1SZ;YbtRx+WDjaizJG&(fzioVa5&;^ngfk~xJN2S5yt?9BA?JpdP9Q#H zJ;OuaK5CbWywJT{v+|h9#a8Z{$_-S0uX_iH40L=4n0H2Su!c1Q`^78@@efSLLqW|? zwon1bF!%`S+f%YdewTF2r-M0%*ysMu;IW$Hl-Awob3VUEdQ$e!eU0>PL`n!ZnFAWN zuSB)S4H$EC__D8a=pCM47c(azV^}i!I2hz$M;i^oD01D8E4Nr$Lf?ZnRM3L;7?*Sv)iiift6UVkfxq&j3r}*)h{V|OJN?e^Mm`S z93Kg=vGrMc0ukM}9uUM!=cyz)B*numBEvRHjtp_Z>y z!6GAg=)zdKxAT8qd28`C;X-ab64RMefj6_2;Jswx98$eRRm#$>K^snpdl}GEB8)ij zjzj4>VnXIQwN%hB^AiEuj*Fr)~5vQZ_7qvxEzUieDGPk6y7 zFDh2J!apq@8e@N_9?}p)#V!$(BCU2BEAN{CZ68ll^k`!!`7-l2rK2S)5CLWO+Btp& zypH@grXIO31XVTl%%k$}vx+sX7UXMFu5tzv=yk{Gbm2O`JRX3)>hR^6Bk684?P{az zrdqG0?d4 zCMXo)+Um9~l%F;lACx#J`iG8((+kpt0@t~+rLBSa6Z+wSnrAGxi_yh9b9nsEO+PFQ zgzMY4dDq^%4MaTkx=W|lds+7$ki@fCUT69RKb$?U6qN|t`P|~TAdPnWXBF*?`M{mw zHC!}T6ACgqtDY+nazz_2wBIQdJ+r%|BlRu3w&g5c8Xn^4A>5@lh*o`#zXZXmf2D^I zsrkMT?5{3W+zT_;C==^|_z4-ia`6zKJ5GD6h@zlnvtRXa9c&)#PAAi90S5VpG}cow zKeukMxl6DNq{!IEa62pao6zdy%Gbf33p<9v%)UWz zZ+1Dc5`R_q{0)l>6*!zD|JWnDlB@i#eYx3Cu^C?r+vQ!XrhMGKt|JoZPKA872n{~% zGAyEF-hNA)DXT`)?_Pp)H>GR^kh9nP;@*!tjLQy_M_#FhRKHf%|a{p0Xah1f} z3q|F+6T&1VL}m1ai@4_@;)*5;>>T^zABo zzBzX?3B#oKa47}ZimPxR{N2oOLQtS}vcX6zKd8%`RIU&q$8sq;>~f)pjUN?a6sL=P zL7QlkN^c%RR^tZHnaRUku`JkLskc1)CYq~uY*_x}j<#KKt}3KCYl&#L_$dcp+@V{C zG((upVYeGUzvWOKcTMHY7sg_(m+-({bSJLt%}MFVm#f9b1UqHGkoAwl^)5~F&REv9 zd{*19^qBIWA{XF5u-Cm&j4*FHu|MjT5kNsaPa;YyU^#-5=dQ_o!!Vs~EKZAY@GN1} zk)+&_+f6MrjMDI<-L#6$iS10QETG8I}uzH^XYIy%J`O<{8+Gq*xm$!@N59t6b7`mOVg!Y+FOdl;c zlHIZ2pZx~AedATUy?E@9qd^TFV7CFdeS&A1P4{MbOQ;if8tig@5F(0cq7{-o*m7-l z_?ebcY1~Y{flGVCNYt}vyIOPM(yA70K_GXI@p=k~a?w;R=iIP*-~$td2)ap57NIUa zzE`WKCF>%{Z$Exz=~#8{V%li`Wys1%)YqwdZ|V#sK2_LVDC=dmEos~G>m1;|(|z?p zgZKbEv1_G?l_6Er5pf|6aE5}&<@ey>g+aw*kbFaHq|YD78uY)Du6fBuNM%RzPYxCA z)t(RDd;HX|`HR4PK!f&yx{N|+^>nGu?8Q5uZ zTLv>mw(KR>*O@YBqdRg9!{S!JuNaDu!-VvPws7~~}3axUfDE&nR z;+YbVQFbr1QHaFbU>D&=Opqrh#_kJr#%`~)4E;D}Ij&o)UA|OQZCG+xrRn8zI7nJ~$=2fxbGVxg3b z_x|_IG$INt>%en0)CJ!IKBu)~-QREqH^s{nW*qPdanE)#u3^=jRc2Vn80WT;1XBGm z2p{~{6%X0Z8Rq-y3t3tpv==v-f_pt@#4=t#jn+=vYW0nZtv;9b?x3N1p=oaN{j&GF zS>r64@oY6$d1&#H{|Zx$=r8iqS?K5Q7bQ9A(tr1)RYF>Z`?p)}Zujgg%I4tt715;+ zh0KtBbm->-RB=@nDM3gX#i@w_8!s<`Zrgq*lSxl+FrI)-$|8LE3&cKM@Zu*}m31^~ z$>qQ+Zr~4EHyX;fz}RZrPdHV}G0G!q1qpedEy4lOuwJ5iVz%te17x&?)c}GPDPCFL z4D72JuNvV`@YqRiMi*Oi5{=7cgbZ4eMI%jy+VxiJh#6!r(8k2|hijiQbSbbzaOgHpR{Se2ngOi9CCKt3P~pO0>t1 zCcz)^3X%IVffuIL@Ulf!W_thIzY&SM(Hah?>J6>LNvq+jQ`nJ{Zk$FM)0KFY`b~ld zHce65tR^F@EnW*B5pKv%^;0J(_D~*Q04N{5qn^~X^GJM{;7hbGk6h$i#V=lTZ>$f$ z;#~&5afx>dnX+|HjrQJ12I?Vcb54SHxd+%Sz@uqpt~K1NZA2vd5!@a>1>MfpO3o47 zPkYw`-?z#^=42f3p_8fTmS_Q-XhJJn7CQ91W*U-3Gz*2Hd)-|i@f`|8{erQzymdXnRY3$o{ZNPaKO@jf#FoR z5m=8wp(1<5C?}j$n!M#Qp}S!1OQIXY$Uxj2W9aCs_g!LgVqj{AehW((c!8Xs)s$A? z?NGR2IWswV*=Df5D06Y8wDs!IVEN3#*?=;Hk5_!mxqvD&^_8`9Q1GW=uZzv1Q+SwF zz%)Q`;DHNbw7lcKDZCVH_V0|{(h4pA27|hmPA(125yIzB;gc7E^y}UxeP-CNqki9^ zA3oL%G?y=X{%qEqvOX#*IZbp)tra!T>q6seaB~N-&iA{>*v$HCUbZ}smQ`1eBUd2Bzs3{$vRtU7?}Plj81}6c)NoK#qYC^{Pyb3!D+u7 zK<9Zc(&ekZ$Ct5xIDa&k0cjclwsa&1 zL!WWH0L)I-ztZqk=03nJ{%~uAT(p)U?{@S(@^R@gJ$S3MS&mLJu1{Ecbp1ch-ZCt% zW$PBk3Be_}C%8j!XhMQ(aCi6M)>sH`!JP(zySoIp;O_434quaf_C9-`^WJ;k=UYEu zJxx))YL?7ebIdVH*@9lomHr2h<43y!t)&Vhx~S+y;G0lHFifUJ0YWWLIcGHGj588s z9OgsYRMETdw4|%x2d)&>l6FNMer9EDtpHKhKh7B_c2WIBWwwiqHG@!;0O4e@$Nq{a zq_5k@yoFk;P?>|sJ5#ah%W$$ADpbRTpdhy^X7FEFf=_Kk{_u>gJ@b6{=<+aaug>`g z3n1wSEgV1XLAM*r|3u@@n>o}1l#%@q^(zd$@B9~kv|dI03ybFD5;#-bPp$o8SKhuJ zRscNSXqD-Zn#{0D!Y9^SDM;4dz`cCL1Yg*^@kWD**>(?g>XgL0;@JZfcb&XrFdc$9Q>tH2zNsn^FNOxKt zv)umLP{PkK)RWhG9@o;XaaqTaH^iXXE*%+X13eabWxk5 zz^_#xs&&U5r)@>*Dc)VYBdyUHaozCF|QHsKYFC$Ko#o$X@A}S>Z04Te*8O>5vZug zW{^Z>`g=O$vj~OC)Pwkc^aP_o9C!)&+m&hV3;EY%`2BeS$IB}7w=2{9Q%h5YNGr5r z%fxuO)~(5KJT&#Kgzv-pgk|o9?B6Z?KiP*YgmJ0}BOTI5B1qajN|=XeKK30>$QXS< z@1x>V0fUU@=I`$Q^M_oQ!M|tczaGeNR5%V|FgchS(wsF>cZ9bm+z5cKBs06FBjN_f zT3I2{T--4C6qI*HH}DAYXGQ2r)@LZB(CMxUWZ+D|hmn29vbhN-UL#E*rI=j7fN_%{ zQ>)2{1%L%CT(Ff&1bv~>00W@@alls1N*zuPw(w})+?BTQ@AZKR3W`z{8#ulsLQ0ZO zP8=8*n5&zI*_$y)wO*M8g+*7;f7wFumgU92d`0r4&Tb6K>t6Hp{<9zQjF|&3qUKcD zaGRTq_+7Zg^UsteulPGh=Jtd{6T1f};>8ZE( z*Th^flk+`Q1D|<+je43yBMIrB9hKQ1LGka^;^oWo=JISQJ~THq#f~L$_pO5HC-WaB zU)#?OI26>=#zAE773mbhp=+@h$(Xl7Pb4RAUypWn;aUseb#X+e5h>(zh%{8tyO*X zw>|CK(K_hw?vU?1$e@;!;fDRqsX8WR$)7!NCzVb7kes<`#x)m=xUW1M0d`~L6L)J$ zxNoH;Ox6j=OM7j%o;@6=TZ4asa6(QWUxQlIjg2O*mFQ=mh>ph8^GWBf*zS>C3JU!* zM-Dp$1^07$qV0H-kQF!?euUO(+Qd38t~Ns5wcQu1JtH#*PRr?QG&> z7;9{OJJ3i6)NvssR-az8Kqw_!%xJwpjRHN9{F<*iC}2Er0#-T^)Oc~K4SXkO*{cSf z3{yt7dLVKXf$5b5D?c2ggZH$%5*mJ*^ph56SKW2YC?7$5)gv6y87yE%KXKcoNx-Kh ze>^vdyy@pGQ`KnO_8R7eb0PwSt-712c;+D#d1v{d%OC+MHeR4sr4?G_48& zm!poI@A$5VWL4|j_*?o2#KQ>vrakWnl50X%Yf5^8L23T;$px~U3)hz)iyUW$Km-_B zj#$BW)_+bLa&k^)2=z2e&lCJ>?|lrPobVGjVLG|X{nC@x+}hq43LkBMXRFf=&C3df zeDVl7UO_Kw9Qt^u6<1+v2q7AVtMl3uFIhSx?sGPm>zFp!YD4*ASpom&U&0dk#Xql! zzh=PL!Y?L7p1kG?xrj*fGwL9l;rR8Te~da^&;&Qxg1`Rr#TQE4qgyFDBFfxhZ63ws ztLtSy5bI%x+`ezX3iqB8%oFX_>9yZ07ga_kLAv}c8>ZB&bNU-?k_?A_jkO`|u|W+W zoaP&(i57gwt0UxqHbWhMl=a?W|AP>HZIr_E=!UCzXd^Jhu5rF4!&o<7t)Gc>$XZKJ z!y620MB!I0QKAEOKn}B-t#+z+L#tSxUw=<7C*(Q*o|F zF?OFV1FWWjS%Y&B$@xT~&{dwAd#K~yVur`5ej7}29d0hXtjo{XaWI&Cji}0Z-?Kr` zo?|tqrS_7s1>;ZL4@(m{9#ior#5~w7%chT>S9LW^<263lRq{C%F}LkjzFNc-U(PiWq|o%w5fMqAS& z*BewTh<(s7U3Nd~<6VbMKM}W$%H-s^NL`kF?H0GCJf`FZ`No;8@Xg1{~dGFqZ8?-8OsyHEb|fo zS^KgI@-@Z?TzA|hIv5|UIJXQNTWqHX)%pLOAfM=EjFAaZs22qlf*XJ4$WJZe=JB?EQHtW** zYJ4G8&rPe`TL6kWc_*Y-EsqBDOJ%V0wKkmsj1r!=n%A^P)+BzZ0o6#t(4mKmuW1Op z+UE(@e5xu{FXqSzFU$g#rt8O>U-LXLjWPNEbdL(b7>3SiJI>jfYk1}@%FuuG%xhI8 zIV(w~9WHG6=)6lhrb7IUAzdNurvcf%7uh{rt=}Yi$Ge|S@*>;p$;%(tcF@JNimDs+ z&0l$Vt4^=WnBtAWWi4`JAuusP%<;iI&o@HNcV6&6QjSF@b!;O9j7@akjSxkSKe4f1 zhUqozyBQ9zUCYJ5!=^%|fLGPG+Lnt$A(fwJxG*dl^=@U4MvX z@uRY=d}omsmcT?dpdtUsZyKBEo9sPZWM%#q4Ozp@zWb>3?UCTl_$Wc6mlvVE(|`}^ z>h-nCTAs?=D(u3qiaXAje+}^Z{BGC}mDRGmv({ks7x$$mecp4}v6}3kUoICBp~L10hjaHJ<8^ZQnEs-HVzaR7M&EEd1td=(_42OvHSTRDioXhpNQl^+O;jMd}7=TJs$!mf#xHvEa8Ufs$`B#0Z`gum-k#zMvS?t)Fo*fknV^jliu(Jxd4{fxRk2k84bN1W0CWD=*N2u;DK^ z|dBBmI#h`RGbAYZ+XWe|3Bo_Z(;l`Fxi zoMm6$08^$EAPH-a*K*dl5zdE`^(>fi0qZG}YhaByfL>+I(eQ`6C9IufM~3vO8&g~j z0=x@>T=0#`dY_k5|ayF&Mch_ui*gRVezrD9Gqu>$;2CHI2nq9!8#) z+ckxUt~>V**o&xSkBH@r17^?C^o8EUC-^0o-`Nh?bR$_NzIpWC+@o1~m44gANIyrX z3+-+}Hhf$r(bqBmW-<>@$GOJZzNWU+QJVlrtI)x~d6kEGUcScw-9p5@V{ZkcoN+W2Vr$~?$%-b^8kCoBX~@H6LRi_7i$bB4~H<^r8$pv(gVJb_gAJQFhdqVZbE z5&xHIq-@bx))tt~ph*SVi^lUh&3nkd?(XQ(%8Q=v#o;%~!pK_JbAY z2zfJ)>V{WotCD`h-x;titzKQJv+xSFK1Q=;W_*<>U3NL_TQVi-4mUZ*LO$VI#^jC!-b4NecMf8cTCY&{0B?V3`+b+ghgMOR5kAy$ zu%Z;6tDzA$9A|~@045PrLE~cNHK;8hnQ0ToM=6o3d54?tv~o%vuP7^YG-Hp(*Xn$tR)S!`_J)&ufMFGgX7-x@)`S-WcS)D^_G9XY+dp2{az+V zW1CWmsv4t_HS5MG^MLG=5j}TQ^Jo%lr9rZH*M^cBQG2swUpA+5>AT%|Z1!zP#eymF zouNi&9dvLdH1*Q4+)PWwiibMZSZhj{l$Onn#~I?+7T_Cz*2DKysuR^3iP~c9q1W5e zlS#b8(~I7Pdn8>8+X4aVz30w+&yyrvaattdt13$GasbRQp2;{X`{U}$EQ*PLfAOeG z!h>*p4ILtI8#NVOXx(L`?Oi4C!#liVHC92l@3m`>az32n#YoCV#oecION!ty%nNXf%R8B3hZQ!9y0DG*@Le#%g!!mTiP}!Q zey(Iuy31H(%lZ7f*$$M#F)4#=Sx~-mLH(fC^4f7y8i7#1-q&&!_;Q*1wtYQzuI*{L z1Bg(f701*Nq7Pty*LDxrX6!WcBrM@XJr2D4s@h$hZnJaZ!4DEyY3e#5$Obz;0D?x8 zs=!BlGdy{l8z9xzdUf)Iw`K9jg0oc(%A5IC*x7t__aGQ*)ObUxHzx3;b&u|Wwm21~ z^e!OmSE)vH@*rHF8*#9kk04ItRf znQ(F&kGtK9#Kd0HMF6 zy)UaYU#*@r$#`CSoY;kSh;@I!Re%4@dYV(Dy$0=y1NsXfkKB$ZzuBY)O)I}4 zbUQiuLf^Ls>5=x)3G7XBURiOYgJa40pk_E?BKULARCt}Em zYZVD{x`Tb=X4@0C)+EsW%a$oAyxY_02CpOylsv5JdZ%99`x9Otgqcw6>*5*G3I1g zGzP~6=dllYVo6pL-zeI)VCF5GJ znw~{)d4-|kYsfqzKjr@rekNrTM~#r_s3N#98*z4h?ZdPH|6^M)%j4GS$T{&*7kHrs zvoH%Am=rLfc3*|krK{~dvEAy|HHF~G6u9eQ`5p=9S+IW|#Pcf}Q5d=QM(G_BKlJ0u zbC6jpVj9ge`KGT;Fj0E!d4zv0`AV3Hp7|F@Jhm30oFa9*(PL)NNQX=A&5`^3+k0T} zT%)d5?HlFek`oVu*L<7D=T}r>vSx)c+Y^OdvNbSq2I|9IH4tW%wd9SXrYzD-?YYVo z7=fd7**rvEI=3=SO&e9f=*nLY@bKjO)6s-Av+vYA!_MipP!B(bM>nUYrW)oXu#{dd%%##34uff25%(J z`=B_JtrS1E@vgiYTS^Tt!YJCCO$=K-@4r7G!9bbsE{&w@X+1Q_It&cxDVs*Wxxn3F z;t}ywX{%s@CHC!lA7-Jjb1X*>do+&y_HtdgjJ*NYhs{%PI>1U2f`%|&k)}i5g5>$S&wJddB`d)cz08_{1T$k)+SfKm$ zr<?d0a?0*j{+8RC--JIso{u&ne@T=+uEW@n{b!B`j``+}h!iGY$PhsBM+Z)1g zc7t5u{2<0w3(h~k68+1hYgV`?5;lYEBxa5cIG%AJ)hWOxI#B4}-4c<0dinjS8z!OF z%vI4c4UR|#6xkJnI0_C`-7+KDH!cO)R24P0%=_P;!Zs}37RN=?+0>Q=cy&IUx;;E~ z`ntHQ@Gso#@wya@3-WmlzVH3|P1unMQ4blPl!Zpzg0AI5`J;(C-6&(_?=8V6M^<9b zbL#-T!H|+dv{HXseT_kOyk)CalABC|qpFBk$R{TUx45OxM6!I$M2&lkfhx{J0+b5M90W1D>CvIwT!ST0dd{gW}85 z%J5Ww1(j%_D`v6z7oQs(+ z^2YDv@?6FG>(;wlSzxfhS?id!jq+TT>}KiI!SOb{F9xjKIfW6SkRnYVh7Rjaq+Yox zH^sL3Jym9ZDgEEW!S#K-H%Q+7E7@a=IAYe7V>uqQUPMWUxHtdMhA-e#O?>;;E9}dS z5<$g{K5RV1rASDjwa~NmWNDE7ZBUj z>2y0rZ&6p8jnpl;{{vaeyDPY%{eldKTO|@p%(IR3*Z6t4$;4RY{m+2@f5Sfih0Kiv z#T0YIvD;MD?TK6*E2DayJoP?HG&ZZ5jRRs^Q3jp*%l?{3FE@%by*paBFdya@!l#Lk{B(<}Z!EcZ zo*|oRr7RfU{>KPW(qVN|0YHviIj;@EyQRlXsblm!HK86ePO0~cslj}>Tw|l7Qy5Ta zL`NUpTwh&9NKO`I>+#_F!}vxgO#Nau{(wPM$V{r)xM9#K~$?%t{j6}H49l$$jKWlqoOg>IbF=H zN@j}^U!mF*RmYNOll~DLiADOOCcEvFbmmQ!7ql-AZVi_8cgy7_dn|atyA zrE$|4Cz;k9e-qYR)ujJtu~DP$mty1?zrnhwCW{}Qs?cEh^&i^aaVkh>YY8~Le{@|u z-XCA~d+3NYIKa%;9Q~XM(d~wNlyw9h?p7 zEN=mBegi$!$Xc+B=@cmzGX8{cdO+MEoO0M7|EQ?;hglWhkU)fK_@ffLL%fLICK0=# z2pml|pv$o&Fz?JBGv8Obk17n1WkwYQh)5f~5hrIi5Bu<-6VNER$YuQGQy zD3N@X|L}%{!vg!^(SqhMJjNC+Hp8qE$KXTRRMfEG1M>xu3-E#6+N=%{6zT>UQq3sD zu4HEibpZ#~a%WFw$6Q?vtFGbObLdIX8(a-h6k<^G9>l47fa(n~cxft3LegSj4+uZ( zNUvIVVqRCAEBsQxGf)HR8^ z<s)Z-i(2Lm6XzxEl)$B5|d2lMGCr-;QDe$)V#*}&tI!93$9a4h>orU z=fgd66B|N-X3w9c8v9P2*(Qa@t(%$4RG1tNCkQWxAH(-kJ;z@mrE(xUYrYABK(!)D z;wBo8?=)RR{DI=`4(iS`n&CpY$dLj`Cvxgyaa+^*;4SKr16l&S(XPG@eWn9Yiv_(?ob zK>&A7|7%OIGPiUuIEK|2kk-?o!YOihbh~z~5#C`M3W+M;aC^Pg*wB6q>uOoK6$Bk6FPXBOi31;8l<2#5 zzM$Oqh@_l;-|l_x;6JPyibo%=rOTIaX$d=JTG^i_>FRt+MbnbSo521&o zm9(KfwDZ~EptG9GJyUtfl2PI-Ruua3lq&|qhyad1q#FKfNn7_i$T3e6AQ_;vv^PU_0dl{x~lVl5%HUi#^jNM1Dyn(TQ&#V z%lG!3%{OQJk)~MuIL>@!IJIvoVe;Ny0;!)Bc5=dN*Rn-LGoR7i4cM*XgE~JQ1s{kGmf~atY4pCX4KeB#J%&{r9pLC3P)l>VAA5qB^!Ii+Ua<%LNakYFyl-xlb>&sa-G!-nFc7A@ zov2&-ia2kwR=@o`vZWLJvoiwF%|O;yhf8>H(dg&Y1m!q<)SWg%aI!QOWV(KlT+{h! z+0)y?LwSAj)W*Q~7yc~|_QEn=u4gMIs;9jSoe}V@8wZkifHd&BW%+a|L_ojRl~nuY zk>#TQi>kAmfFDSE2R>OjD&ypsl036NaN0?c^zdQCV*MWX{!D_Qk~1ysobb-ox}8cO z@yjtkQDlljCJUCc#}iSvkch!iR=`P^Ep-k*JAy}Y!8R7cb8*kF+GW9qI=*ZcrnzB; zV4fa}pq;QnpBfKzymXvJXWed5f{_Q5OWun(#2J=#S3Uuz=i7L7C@h)nvYa3i-KB4F zDBD2S76F@l{_OV$E}DxUQ$Tx_x`0|ldu?~jRw9NK!i!=B+`9$Dx>jfCOQ6%R8jPb^ zqWzNM_cf4>MMqU|cehv9nk|>tgUctj1>1m*Gq)?)2QoP7J7D8?dkw4R5z#{-eO1x- zfJZhF*~AcR%;y03(&KObki=zb7+)TaOHY1@7P4q2k{D&tx_aJ7y0nay?Ex*OSs3HD zhs^C;7-Z^Lu7ap+4P+1R-kE5%R`i}*RUHPmh>MnA8A?vG-=oDsfj7vJ(JOJ%kyX}= zp11eZtkC2v2l+TGnyp0kUTVP}G@gM?M<`O(`B#O2M+Fjb4eSEhXP24|1}6RhbXStM z|b#((18-( zW%bLpet7?xwLifOCe3{pyXqX^A8Ws*`;-GS(RxSLbn?Ap{i2Ow^u1X#m*^e5C>t~y z_k(zoOEK~M_S4twd-;{=3-tvv0kf#k!O@l>J^Cjjz*Op~(8lDoUcbv_q?z+jKE9)A zSm+P;^5@o&o#z|2x@`AX`YJ&0ZS7}dQLs`tk7Lr<^BO8~*MvYgZ3p4)r}thf)>&e8SXS6WFbJq|6Dz7v3@bRjA}}c$aV}eY%e6Dl4WlYcUKcCs!LS&@D%VjgLwqz2F}35x zyj|<{h4Nkd=G7{;^HA+&*l5F%-UG!DNo|j7;CWAsYN%B=={sbjA0n*ob44;0DV z@8?#|Lsq`(H341+o(Ew(u=dYAC%?W~zY5X{LQV6)Y$cw2Yd7;Yfn!WD_}prHQ_X6q zRmW297>s5 zXx4V3DiH5PxGw^obfBu=nIVT;XdP^Hl>+MC`tW4*9mckvw%ZXvQxk7Lyrp~#Ym#)i0{d7$hey&JZfBxLx{#Zr|Aw6dX zxds*kHg_=Se7t7|%&s(XU=2dwwUPEGc4Ha`4Rpu)CrGG|GDb4%C6e`vhX`LP@= zIrfz)qC(rG-`r!X||xiFh++Vn}SL>6A2(8pdJ@U5172*Wc5fx&Ea zsK>Klb}KvE@kLZvjt4s{Q6+DQ>`Nqo{uWqu`f{C zb#-gAe*9zYzJq*Jd$*vUA0F2FU>wP9!1|Zl+2X?ar{dN%yM3TWiU6bXk+^5rc3iJL z8~;%0qattaJ*39Qn%RUrvNGLko@J-w1rDQu?YeuPT;{`bFLXkFR3<48EQPd3+=1HC zu3tJeF9L&d16SEx%TAhUL6h4+0$=72+^bVlj^#%!H}QO{)_%nNt}W6^8X1M)v_5_g zjku{S@s@93b(;@c^Z|Cb3>xI^vOtmWw(Bz?$t>5}T5Mj}(+J0EOzu_iOOu>gb+^^r zZFf|*{mI^CuMvK=4Vh)o4H;v8E8N7VZ41Po8Ua8ia z#9=eRw-IhZ=ENLMs9eP5ExK<7^VqBny7S%IdcpA!xz*?-LnYK5Tiq*3jqBe^2_d5UEltWt{pv5R|jx9SS_{vzPUwVcO8X0pND zZdi~Yvxd)+*Aa_gVCCCj@wrvcxu`U-$iuo~W7mZkHpQmV)jB!Sj%Hi)LjM=uH=1qCzWoQ zo8JKrty}P!<`FMDSXgc!#ELZLX5yh?8NbZwFihL|Zx$n(1CT@d=PBF?KeF&{R%YF8 z_lZgk%w&Gb^m3*}owN2QqmZ;4=I2{w9 z@VIIr)&7jr)|!xJlBAuIF_|A{fEu^?z+r#V!_!03h0M9=uczm>vyaj#*)N?M^!cc{ zI*~dF{JNT*+g{gjtEB0(bA3TqrvyCpnU!6w=k7{@2QLxm;3XpLopsOfIH;Q+EF!^R zQzB9Xz=Eb)M#wH&_&O-TUKhqIEpm+Q`E%D-wGh^v!|R5Wvi0FjoQ<@DnGP!tkV|VWFuLWnABMd{ix`tGOz~_`0-6nZgCR|^< z3&q}!5g;6CXpDgip}$B-Ts=#z>r%?tp6}wRRq_k>0%IVSkdIrkw!?!REC*dm6pV*^ z_`|h91yJCCl6k?QsI5c_nwvkTkcVq#b{6htAG`9rOjZ<5&r39fwik}@Mm9wXrn*CE z4)gl;IK+a>wo7PhLu^Nv2vnx=P&=x`-J5}0kVD-mhOcA=MIOuCfXaxeRJF${1%N4y zH^&&OBW>NJYZ>hur^LjNt&l`zyPJrziL$(#%Zv$I6+b>Kbj^8gS?#jziecUkh)C zZKY4BFU;CQ#L#~TN7vw*>j2@@(y9$oj_jX~Y( zDCEwA`zrC$lw*sisaR^d@@DN3^>hmHEn@y1?JGxovoJ>Xo)Z<4HmllYUlSd?a50vy zM&)4~uMl^c*uX5ss6*UfE_%? zhhxCE7FRf1Y`^9BAfo~s|Iy>-Z2EC`&^_U?*8^o5iP{MUb>!oKz4cZe&FeGbcWXa{ z&g~9V+-Rk+o)%s4Ia-MmZWtF!cQ%7b`)PD99F7zkj7as*vt% z7}PE}%P;8x`_*gxsqU~_`xV2kN9FfBl;fZD!8rIAQ$t#vt`|MgUALuNjSt5wGNV=$ zaaLH%I$q3a9x7?RfUnMJ1fh2|s+Q^v@(!{>NueLvcXLzTF5WM|<7PKAj zc3&l&Tw&@1uUBFlOR-FTQYciMTa~-uW7Rl-JwM}9y%m@M#RWq7xLrP1;ht4`-n7NP zJoVLEkiTaY!RW!7et6HWCG3rAcFGsjo`K=MBU#-$=nk;93Or*MIGR_$0bXnhc$*=w zOybYx9+nVqHb`8dW)L|;Ng{m0#>*^*dTyp157C9#{hPS9z^*=$K;Kw*u2MixBL$TQ znIPiy#~s-iny(TF;D_Vs_}sT;-`Wyr1}bT{t@^2JE5qukC_5p(;0w}mfdXwcUF6{o zJ^JHl-yyhnI#frFvsdr}Wf^)nb?B+H_UJs&j|BySFt~+RuzQum zUA(!$?eV1^Ayzn(W(4lps2s%tv}eAbndIF!9*1vlwyR(TQ>}l_Sf~dJwsbg$WJbz2 z7UDjuUT_e~OY&fSWE_t-ITlQjB|v&J{ysB+Nrv$rTZfT)f6qzMW;wT%c3`-19T``^ zvrH8+++f$eR5x7H?-$+a5ZkhzhbDt2i^N0RWBd2IOI|)+4~k!=5oFLwf{g429dzJv z#mjB>iig^OiaawZblPcB3al-2y@CWOto8#^;m}0a&mQeAiwI;P)in;__1$y+@yx;#Z`_giS3re;bxRFAeqa&C zBB#9@ys_NFh+Ux55&6&$g4OpmgPwS$o7_D@A#Ir?mxN}MR7@-Uo6Vsir`^0>WIUCS zccBe<9U9&Gi%zazRdJ9vd4;rI)ZX=hEFUThSv(IWUjgc%sj95Ilrzt*>RnzpNYcCk zwrDNb&*w2M{p8dD1I~k=SxTE%D{XzxN~Y6Ca{B8HTF$NLJ5|_fR=<*AOoxKyUi!oj z81z>alh3Vem7DGE>~E|+2+g&~8g;U*35J_|V~x{n6ee>pX*8^g@PLmG8RNTl(GOIB z7eKuM0T+-`WqutnhjlMUyb?j_p?SgQiv~GmkQ;we-=590(Mfb*9_4R*NKAK9?2pj85*TtYuYlX(|5yxg z94=CkyrP8#?;L%@417C#_a$^7h0CgG902HG3uds+QTLjj1kPI3%ib-1Hl9CE{VL?Ho zb`m|)!z4VZjGTR5YYGpM&#_MKf8c^$0fR}fUeD?hjc>uwqL9NZ_=wLBHYXEvnw4s7 zT1Op!v_H>o<+r`WUwTupp@(JAAl|T8^7cKWMutsNLy6$HFK&Q zEzeKx#raA=ga|H(ORM>83&v01e41jUDdePiz z!Q+g8Hc3>}ACPc8G0{{F7NFu!K4K(@7{f`CU;3abDG0WZNEsF>0hN)IQ4fkyJ8_BG z9^fG*$GvtMnr8k7~jKLW+*{F8~8xwE=`898;`Q{Rg|`SdK%5TROmR z+ophRtLTF%f zf)OO(=8K}`5dS6nk}p&(u}pn3S|+*fN%3yd=o8Z&+fJ8XsWv>SZ<0-4zlex2#~52h zYj&8%Q((`tk+QlIBY~7}%y0%X`L%#KA+nViTojr80gxm5 z;J2v2JhwGr)=2jaX`Sag&%DWA5=gz4eq=om8fFu8bEjXnOnpKO4#>?mgBnz$#7Hce zr=U!Dr#jq*lTG(JnkGkl=|fyoC{MQG;B3g5NJY|yw4tkknkQw}Nqa1Kp;`g=<{cQL zliQ?U#4z(=Bf9zt8Hhgd4y`&FE>roNKofLme|}i=UF+Ba z8l!~TA~R#?qj3da#^u!n*}&_Rh}yN@UHSvQD8I!XR&;wn$Rs)jx{@AW+Np~OJ0f^h zq(yZd=KW0QZ1j_@PK^OZ7_MDl0zPq9?QE!CoxPX~MTN75J{hCaPY_<#2K60CvZJfx zG*BQd3q}ajAS!n5ZD1ZysR1G{A_5f-l{i$nSlx_!h*7i78+_1&eor`&gnK-r)=0g* z$wa<_sM+xTNX94C79jW7*jQD{nBJe=Ht8TDAPe*U1QRCE@?hR|z9U~1 zdW~Ta)!7o%W0YB;NCTbj3x`b041te>v&{;DkAaa{wM_w?PN!V-dtrXv6=GOmb^*r^ z)&B6g^wX=4^Y9(5EvOFUvP)QTlZZ+egL*2A*U0NlV{Da?i4=uGFyU!K?KOE)*+PS> z3d-+J`7ObY7dFDAt7jcg$r+6O7vQ##E#=K~z_bloWH^mOWYf+UITW6yNvl;<=D_nV z#$sY!UVShx!p91GWtzdRKaDb7pEGW|4YAEiYG*L6GNs7# z;wzP8o5XVV!~l+Tg``mw`XA>5e%6MIbK6GCuJy~aY>EReEh^_W9!)oMs`yC8-1D}j zr=*h4hT?xsNEv1ukx5n!IA_gt=CY5!E)@2h8=<8}9K4|UppU=NY^7sE1e7Ls-POhD zo6iGtuWCeOiTIFtjFt@FcqxOkcAC9&afcLuHp0Ca=azjKIQe+9Tv*Y5MjB(W^6X8n z;MVi}o+OHd;J%^dJ@ZJdh%r&EZIBR`RclvJrqWsJ(GfkHp^eBrbD@rCb3;|Dc(1`d zWNZ|;UYd|YZ%;{|uWb0vB+#>qIZ>?_yGQO+r>a*SRmhhs&p10|y=pK=sx>zvSBzMq z5}43GKA+AfWyBoJXM2?4fa7|mmD+#njT-F+39ldMsfXN}#hcX>ygTiZpO{b|!( zI4JK6k~cQy%YJ4OlPM~{fjKawoQJ^|&DIEd!t70!c1jf@yseLD7oMBaGl&qcJ_*ccGEZXB|x z3`uu2@yGPXh1}uB7=!puX_jfst5vHr20-+ydv8diTIImmi^ti({*^Bu5}2CI6Ll|G z@&wgwzbKpMP>b5R&Q?^!ZaRq25#cvJXWl&uZG8K?S5R{FL4HJE`a#_8?oW$j?B)w( zt+7n&S4wk=<@ASj9amd=kmimrXo?rg!Lk*kwLuy{loP!=r)bs&jUUkV*;CwRaPWd~ zXk_PUO_IYw=JInXXEF4G9EGx1{kaZ@j}qDZn1pVuhE+xm7-rtDFIUEZpz@GqvyNuRXWETvPGB(b#;NK*BT3~D_Kz^*HthU zmYQU~r;^F{wvh^kU20z^4qH+=VvhbQGVZC+4Ys~D+!T6%!gruD9M5^{xjg?+0m!YH zELV+iw~FslHFrFJ8}Vwr^eS?kk(*fZ@Ib91c`ye~*(l9TY6!cd5VUuy%1^mXK{9ey zybj&kKuG}`c#d})ZU;h(mJe2hvot~&I@1-e`8hru_)}qfgpVEN*u#}LUey9R^6Nj0 zD!f$Pgf^Ftf`3_p`h3^Y@0SJCudSjmu#;@x`R+CvD%pd9Mw0riGkUH4!qR*wOwaX> zoQZW4S?^w2&%Ls_nYB!(NWEBjQ(vh$(b8s!KlbuWQF8V@GF!SR-P?xh3!!FGTOWp! zA4aj?{8{Us8Eps$qTc6kSz2-%wpA44&3L@WG{ZA;laLlt%sz41A_kASg_ngY)76Cl zZK{|!3F(z+u|H(5#4zo+e406paPkc?YF2krBwF;hb9W}%p5+bue2Lf+r#)L0Wb1-9 zDO+Mv6y?2gwZ?00gueCC$s~&KwhA>k!bu3TI6g6+@2C#292W`&=cv}$f$5Y!Cny*4 zUo+2~sp(WSWHO>J$&q+$Edi!&AcC=SJ9q!7*gRu>aPHq<8(<~Bq4ZB;=jx_Fr8;?v z^xV>1Rp%~lQ5tIuI?g~NM{a$>t&rWokl>!%M;vr#F75my*{EFFv#%4npB0Q6X*A`- zWzYJJT@}=t%ZmUk1UrSIg|AQ@%vOVribDhQEWAgd!6(-}B5(XEvfPBTGk4>tIUedP z7{o4$=<^odz(iMa=1YrZ09(lpya&(IW!;(G>4(dkCWBGiqTeJ+FcS3O%#+EFQ<^G3 zbAAVj(`C!`EcEA@R=J&*FUF%SoPkk?EEFvT_SSZ_5%-c5vI!;3l%6Y}Kpl&k}RJMw9}Q{SC|B7XqPN zNeO<-Y*A$_bjW?Pd(L3rL&cY-L{B`NNBNR^RmoHAJG#?Zg@+c~W8}(LGh31JHM7N0 z>XjM#JI~U&ym?Ah1ey6F4wr^gnbEshGu(JvERocGgA$+^jdWJM#V^$scIaF%AuS(6 zN#!4_IVD})83~(U&MDL= zWNPf}RT+>CS_OaE|9_0VRaBd85H8vlE5!;F*Ftf34^}Adt}VgcU5mTBI}~?!65QS0 zHMn!~Z#!q-ots={t=DEAnQsR3*VQN04mWziJ-9N}(&NFE6488jct^|QP`YLODPd3d z(36?%b_WJNvEcH^tic!cQ~&yf@k|VyzHs`X2QE6S12HyqMOE;Q=3dVZ-W)76`+Y*z zgJ(Y{2r61&515*uj%sUFf)m(d;npVPt7R<@;mh!4TbZEaU`W}SqgC7Mu)@2XJrUSE zIw~dfaqC(UIQExfwKekx#g)$Pk`B4l(SDrbY?#VXCfd7??<%8%p*NWXoP3fA$`j>C z8nyhHIokWz=}4nS0Olx(73JcqD(!zT;{P|zObpc*AYt#MMcxt+O)M7JgMJw+Qq)|& zy{#g}ofKNejnN(Qj3B5)Vykch|x zKvxW{KO%3NiSeW(sx!ZK`S+zZsAd@JS8LXMABpHN=^OEto(koz+xawp-tL=lT`I-p#-yEeoS?eI zx~bW?3r&V>%AUjK4tsp!bN=QP;%_Aj09cf&5;PyXD5J4q?5=2cJtzGqZ`fn|vM#4z z(A-N&et9p4v|q^yT$tKMkypV|X@w5j{u!Y3Z)RaZePrkYindb(eLAN-`%t)YRLj() z>gY;KOQp=FQc`dkivM43p6I8qi-~`ar2dcc3YDFfD>Pi2S6t2P$HchOc;VLUyhF&6 zD|RW)=&)Nz#}^?F4qp}L(+ll*oPT%Wvrvq1xYC2<--?%bUy0Wry=gRh?Xm1zewI}| zilv?fm!TS7^L@y;PtSsPUn{P^_$h${UC{`%qd5nHB3}fkn3PtcnEhnRN&N}%9WZRC z4scY#NUE1{b#sPJ0JORv>Y-KG|BE5&%5_4gCN|r^1h`Zo zTxcCXPlh?HWaG>GlA2i&|eS`9ydfa(j*{5JSmu!JmSM>rq*6vcSLx-r21LpynXHT~- zEw4ohcmX3bd141DFZy_8>^;W#b zvS?&rZfs|A86NrkJg{f2eUiHeNfW6(CUf`gg3$)UBm|Ptq{+g>h6wE(5|dH^K$Q9E z$OFCluh6TniU_^>t=APmk?ZfQmw51HprUr|w&q>YU%dXP2X}h?khx-8<6q@*Oc#m- zk+sJTcKkR4_Um<(tEZ}a%Ns<;I~AA%MmDSL-2_`s$YN^x`Z2RNmWIYgz7m=Lx`nU_D3;H%MZKf*6a z$^KFEXU)k#xsMUFI{9DaCxWN^#~ATpKGM1h&ckrcv5Im<;d5KeiGs~tu*0zEue)O_ zBSd+5c_w&)GUnUw6mFi4)IF2px3dU|U>&2sO^OKd>JT4wO|sd;+`ftT62D0#M1Fws zT<-@{mj62Es0cvFQfdFTE3RrJ#k7#AbSTo>oVL2J*ZGrhN{&5r{yM?yoE?S#$@2b;^Gqgx_A;e=6~Mo2-h(XtSLtt1 zNC`jmkevTpPd{`$)_>C%ls;wOF2m7rrG!6wPslhV*}n+X+(jsXtge<+_B7~7*spHb zuNJjY_9`fwETrX;FODi^mr3>O7-8~26wy;Y<&pz7Wn&?L_(Ee0Rr~)deesuag%ME8 zAG>4Si`UErC0v_vckUz0SpkA?`d6n}?p$&e=O}H6O$;>>(g(b^+iQx05y=H!r{?># z`NAEe%cYn(_y`o|kw=Fm`T=wsOCmpw!Ux!Bk)uuiNA2~$@J-`}NoN^0Sn-E&CoKg3 zsaIfOxt89!CzBY})?yf@lq^zQaIi3;gFvFWwVPn8am;{m+2X+vLgKF3N{+Q2?#f2M zd?f#OwP1sh!BH@jm3!7vqaeubb_OSuu>N15ZLf!}J7my%E97t{M}xv}SJuESh$4IR z^D%cYZSA||x5Ek;K}+2!;LM~@(G?-kRZu{qxGv*= zs~G+U6~Y{hIIdYWR5SiTKRBrvlxQS%pQEumjr8M~DdIQXJv%_jRGsjc*!>A8Nk~o2 zEjRJ&5Ml7o={$IjgeJgXWbrm{vf}X9;l1TI|lYIZp zm{ze8>s-et{{emfo=mUGZGEE<0WM|PpByI6-P*9GrDc(j7Q82?-O z=oO42ypdHgRjX(9@Pr@h;GSwEZm&c*PPiJaO6LQaGL7zu<>lr2hacDw2Z5eWirKZ+?lf^zh60of(7KC?yB9k!jZAw3gzT$)^mcg+x zATD;_m!ij}yYlDP_Chl$JG9DOb!W>+s4ObNQqA99^UU?ZAKTP!ah5|Ikyo_@bkhG{as6Iy-Mxup2y|)=C^Kd#l(l-l^gI& zP5usT+NT%&+p&$e<>Mfkq3){xhM+4ZTT`N8Xv*YiYw+bmfw$@D!8p!xjJqdCr_a6e zi&K3s`5p%bR05%AKc4x(5X2QEUoBZKzs;W$qQrV7UgLR8#z_0|S5l_XYOZv(k@2-S z%O0>nEAcptm5nVi9R$PgWmhqUw&gD0^beyxO!+RslHg98?Gh+Xh8iXhb^f83d@pc- z?ceABE_uP8Q>-aXREs?hHB9b#t+5vRyFLagLxlLLpY(8tk>;3{Ym)*y5k5SW$KbZ# zR2LZjS(D~#$PLj^wy=!pQD|s={Jz$~?AFZm7v}bo4a>{3k?pi42d;Cv5z zhc)+Jlw>pXgzTp>B+>hcPY}s zq9Xv|IiMAX(8W-?JIW>tTz73yk4(!1Rph2Wn-k`==NCH92)RDF({hC)<*!m>k6(oM z#Tv0RJJJge#b1c-L>kaWl*>(e?{NP#>HaM5qhoU8UnPeof0j|leC1`1W2sjD?sInz z!yI*NPH@@QQFd?LGH7qJ2u?IM|N9*g}N_JUj+;dDG3o$xK9B>-3baZ z&^8uzk&$*6VvQ6d$GR&kf+o&}Wv9bsfI42Zau?%zTDr6GRF8>{gD1jmck{%L**EB5 z+#OdiJlX&oXH2uzKmutgGqG|~R3OJ1as^B4IvK5nwC*5>2SJSoNO+dS^xJd7tvk$> z+?dc756^b%n$}F{!->md&1(xx$=Vz>(I0x&EQkYGa1Z@ZK%&3N2iE(I$P5_;rVfaCJdm1Zt=kCN^ z%|<-#aet8nS2){yWPH>1SA%@k-FT;aUnPj%^m=XjfBR9KP7n*-Qgsc;6NgbE;=gW? zZr>v<)|@R7*gezf)Ebi7k*D4Usa5rau-PkAlM*DUTubtWAvz&1Afn6(*d*sTXHR}c zvHitz!gI{++_q*gU{|RXT!xHjK+|(hevat)(dWk|sP0_cbH5=Nl@%Ps5M^RnV#^PN z@mq10Ij7VEz>`l5VvVes2jCJ$`ZD?cBXTm>u7gN~f3=tsS)Bv+_gY41B*1m3hIFAD z$IPFZ_3!(fC*I+PqgG%ZI|mOhMKMioFJCio84mLWx58p#@OGqqn$vK)xQ7f%>Twl;?so#;)0dBIHbvJO7cQFwJExCqCdcj_&b!&( zn~vFkcRdMv`2enS% zbD)KEns7e0RuU$MIQ`TBFb@1d_uE2}ig-2S;lP0&g5D*2E(>YB93HR_75V~ZxwC5C zz*c;e>UicZ-qeBm`fz7pbW) z#Fz@z=Lvp3LAp)g_tW@T^XrWaB+@p+fh())k&?fr6I)k}+-|{OBF&|GToA=XRuUB2 zl=UTP)e%tf|u}!ObU+^`2ZtAAjr4Y(^9}yJv{Ija~^oZT(@J)S6fR_i3IC z6eh5%0NBgqN7y)>FT)7!c-j$T)C@A-R-yk@r0U|!skMq#l|OF@w!XA`2eG-+0~;lf zN|cGu{dE%GLpTwC55P6=MpW|UDW-I~hs=|H8Vg-<<~I1!4afm6GnJx1d}EI&3=Tq% zGLd2Y-#3CQ;WWd2jQg9e0%^ZK3_De6f;jcL`>CGg;{~y$b|+evG1@36W*8G;sF@(W z_;iZvVTD#ngQ91Jkb=zL`3sArC}wN{sn%e7GIN!A56HY0PL#?MbEObMrW)LtByF(i zZ0>*z_3WQ5Ll|e`yWGw|6aU&C^f3-$m*&8}Z#@e-K~~u>2=}^Pc;4?u{*LukGTbi4 zEH~475^VFYuX6N)k`;^7doJ72+4GVf7+&c68Oh(zZZePZu9@lNmeJu9ULhNH8_!fs zh9~@&`utDUp_h1Phg1gZVq3>ASvuXy{&5_1mj~LF{o8xbh57!Lz0tN)^>WwNWr98W z-ml;x>1W=B?OZe$;sr7DMD!NR9t!Ih}jewZ~EAZmv zU}~b@SuwaK@ z9T;t8Anbp)FsF6gkDn0v;tFHXYd_Hze0eULo$D!zWl6&+)9Fb#?*5>%J3iq%o_AI~ zelVmE$L^x{e#=w46>3mFXO4*wUB15E19F)QxA5c@n8NzpfUAltC=&j@9veb8!7BX= zFP=-zm-X?ABj0kx{N-T%VrN>qYTyj5W3^$|B6}3nuShhLP5u6fsVZXMgS+N#NnVlc zEU-k8+q<)V&1EA^Zx(`rzZj18M(h>3HjOj?TRs@M1m6v~FSVlh*;PTg7T)IVNKMCX zi{oL*CcFDr8!vVWk&IZe?9TxmLpn~z_g^hfj zi&tASQx%1@o?R}TN9;}P*6c;{$&GkGe<_=(KUaxBmZRFK>Y{WIykS$FVE}wt+minp zoz&$VP+OrcAC)(fSUlg4FKo#-cZn?_qFRIAbg~3eQ1+2)k?yi(fiVf^6jhha@SoE| z=l75I=`)Jd?Rt2?n&2Hgb5f}3PnrP$V=k4sKj^>A>Q;ghmv07y!^W`dL(KYLAxHr{HmIfj>iF0xp zP371VUWYk*oB1NiS%U4|5ydu8ox6O!BMXm!KI4NC>yDVilDOw(^t0_4Me@$T2r*dt zC1)q+K7NRw20T+nMe`fc2HV!EOdgO&8GSxX9~)%}=E#Ng@89e+ELh)h`4HR(TI z*`x+aBS)=~S~fv`4v%X0$85WkxNzHB`HKNe-T67fFO;K%nb1Gba@h>O_qZE=aD1(l z+q1rvkci~}%P2^rw`}h4*#i*AnO|*wzZF$y8~ZmRcA64sIoW@(#C-iuN#DgR&2lea+VY$6x{@hblAy3_aD|Nj)aj`cPK~hplrS{> z6kG{15`01-)`eg_In|nQ*V)G~S~c3$JJVXMRLF9x(OET4nJ!l#Evv4(ocB4{bok#3 zx}w>1U2!L6CR2G8u#pflFqoS8l-URs-b@`@3TYp1qRwwI*I4_Z|XyNRvNyQGJncnz7Jt~pZ z_=6ZB&HbvCU&%j;$CTqqp*DkM9*L*80JtAbMOML$rv<#X$X6`QE2_mVe}Cq*e7a}k z4iK7EBaY#{#3hiqQ7UYhJ>)3C*7M(hU48JcgRg2%-vkWZ;JGIrlr%gDiegx^6p?Cz zdV*OBPb~Q9bW*4&<*9UdzRc5~7Z~_Mp9N4xl6uQ+-m8w~Y1Pv%+t|{1-~crw5u5YX zgbUE|Zoy7uExf(bYL1)ygOX^Yy8}jDhbl!>G0GbJ@ zsur~_fqKY{%?pM1SLe%lO8&R_5!)k*Gi#SlMlX6TylULSF-~v6_UZjeK9a7^vrpf^ zfq(P0vcn|R-|(A$wn-FS>O7JE($lWdT|WL-RH}@qU4aU37SBTI101Ilf`IaWOL7If zPm+Cp^8XC`ckz7+z5MwETg9@{4_+%}47;YUG96$Hh9{)pF}-6M%QC~jFP>;iza%i> zxO-e%t1K)+*Si@qN9inV+WsibYi!D=|BV@(kjDg}XY32o6ilV}^!_+XBfeNWCV`jy zL3DL!ff-mXXvYtX7+Nc!5HlFkmQH&t*t1@le_Va<`P2R!KFOPHT!yGzg&&>DB_F^r zFnyxbw3aKZ(1PTKO?~2Xwt($tI2Ufx22eu(Js5WSDEN? zT*+9-MUPXFnG81X_;)LzF?8t8a{eBb6d!%qf{g%Bk<7DW&ZZ4^fV^|JwDhL~n22BC z+cxO^s^*xSNAZw#h+~G3#zZ(%BPMYpAC@nA1;+6`56#4w!bo*RL7L z;{t1^7hE~7>OC{A;t?e>6Mj_ciWgqb@^aYk7xkr$QHU)~Zn}bT4JW715 z06CF+S>?*@lxhF@6iVXa!;Ks}q2*s;o3A5vX6!n8kwcgid!^saYcv$-+GVnBxi-J6 z6Ai<3TANHv!ubSgg;PAaz6|$Mz~U+Y?d-2B$bcPf_a*}~qK-WkjIZ8hS8-UxaFD|# zITGhi1i=rmfm3uMxETnLth0$#OSPmtdCfB(wzp&-on7TlZ3kMD+uUv#3C8|%g-bb2Keq07_!t<# zi(fZksR_WekZG!wKzKDiyW;IQ5^+6DsB}%=;{2Ug<^u|0ciQ_|qI0jtBfZ|n96$iy z*K5GT)vTj_C0oY9c4s;@B;HwUjG%hE@Z)gfo%mk3>sGw^R+H`Ds%^~nJ7b@3jVK4~ z865e*&D&Fr=%#|RYJjd^1J-n-M5N-uE3S#yl)7P>0}NwYLGqnQ8dv%0+cOLJso=La zXOS)&Dxw>w=?xK|$4WkYe({|D8PgdkD*3)=<ZZ;Da ztMU!)jMQ@%F|#6{J-EqHrP%5!>DKaBIXlk8b4ER4X9@|%OIWHZW5M8n6=?*ll4 z5jp@W)8`M7Z~5bLcG-+Y@|NKq(;W|0wm8V}{aTBecELxRL#fY18JxZJXXyVgJ=wH?1+Sk_3`tHyYJKAelMbId`?&W zy+@7)^lGRlP~&L)L&(TafjJN!j%&~C6ol@fW+Sc|kUhtKO#5=4g`_ySC0|XzB>3>d z`KP;P4dB{UN2IUtSzNlnfm@mLn2=GAAA?+O#E&9S3RawWgCglO|7?U!)>7bbMT5k! z{5NaF&#s@gBUuV_EaW4_=_-}AFYXQM77%g%;+C-pEsQypYJ~)(nln(Ep>Pvk=Fu_> z`6aW=1EJ?`XJ(h;`iQ$bE*Z=sjMkv$+T`NEn1hD5b88AP4=&5?i%|f>V-2ujqc)u_ z3e^_ivRup`NifL$WejToyy|t~+T3?~NXUGS)JcKn1eu?nog6Agx#<|UFqF6f`SWld zTqC?J^ZF%HNqSYmE12C>=^4~j5TIHOvAgcWLZ?L{YUdfgsi*m_nIpHXNsn3=l5DSA zdQDc?ep(LS4XuFNa3{&6yOwgX9H`!GCMG#KI3eL1#MR1*K}uS>#$+ z{ZlH)9FwU!dgD;AwFLYA2*=()do}(X|7i<73m7X62y$r2(ui6D_cG25?WNYd% zYfl6ZcINfyhj>h{Dtq;byFQ7XVZ@EgzV|0~dDDe$gd#d5y~4O;#LjQo5St1_G}v_c zp#heBZHB4K%tV$4@wkCQM$N9y-?x|FQ9ea3KJ+s*TLeZJZ-R4@lEg~_k;=|tU)HM+ zY>RXnWsoTKc=094G5ZypVvUDF0xZtREu#KR@KM;#wJ9=lA>@ybVJ^roJ@yLEo|$2c zd}b|T_Y?YH-Gm@qg@efs|FW185{sWJOsm@$Bq}?hw3YE-BTo*vUlv8c1Bw>OLoB@+ z#WUlPlxu}g10ox(q%vEL^i^`9Q@fk-c@T$#hzHo_gI1g^a|~tVdPYg)1Ek8Za z*P7=FjD(7^0NN7qsg}pVtVC4hIAP@L$Y8A+9}qfwvfTila#7A?&dsBz2yiy?TZvr@ z02K$Z>AX^*R91`la$D7fZT+q>04jOH>)Pz3suhEp!^O#fQnlPE#VZA7uz+NJLRgi$ z{68^4;%xH*Q1WQI5`_|A7mmd8)Q)Zd3N$@^*zi8}xL}3?j<7BP{Cvhi^pS}&`8aMO zdT;p;`tL?mTG4hQp(u=9f*+DczOOT-{po&h>xB=e`BqAVmbPi3B1~|I-=f>|A;}}{ zG9!Itr{?gM<0Eelg{@iA!CBKrlxCfA=uCm6rY0Vz<)Uv5a3JjYYzlbDJ%&*@;M$>g zME)8qy-BO@lhkdsQ??v|w!Z%HHUJMd+c@EEn`*19uTh=2+selk=NEj#^7zjThdINH z^1rPP@6Qj{0xnx5Wy5VWBP&R+YM)$~Cr`&Vc9w_coqc9LNa;OucsI3D^)wxSy4YXmkB$iD$eeLT#TaNUJ_; zTaB2WwH_MA&=4|F4W;#BgBh`3{4b5M`O@ZSaV>daJ$s)UhiRPQ*^1b2h;ycYs)$r` zZ1!PSVH$lz3*&%KQQhJ*JJc0DDT$muM6a6uUAKYt^Z`m%Z#c6k3-nTv|HFaV(fb`2PyhspK(}70dHZPvNV`pCqq{Dku%YQ$Qab8}io{!sTpZOD zS}Z#Qm@zy8aQOb>FIu(e$YB=A^OiO-sLY()v%O9x)C-vXovdhj@4bOHKRN8@Q?}?Z z4VndCo`2HyKaf>?#AFvQhwyCeOu5j1@nZ1f`z@+w8gw9Vze=9ec6OQ{4LEL`W$+sB zxL@~Zmth3LFcGscwtYH?kPUg0&6Vw6WMk?PW7{r-xiY}_LiM)0Uu*XMvv9v@8{4$& z@?cav-7v1pwApi5>`iQf@AQ#TpC6NlNQ%Pc7mD<_W5#9ABqwC2`q$rJb1c^&A<8n9rrSn}Ka12Q`Ltv(&J{!wK z&6;yWh-3bRhXLI2T=JyN=TF?1 zb~I{hEovF6saygCNatC833iB+n!7mUW*rwdM>MsmvBN2iAn86$zdDUp%oCh{WkB;Q3lW@)MJLCM_Q+@IUyIa6zEY!mm!+<+1} z7qYL4(D{4*-cLux&@k1*CX`sUVFI;OHiNnZLrxC%yH}6WdJZhn<+h1k`5mu?3ukuv ze=}jRCppS+pYe}M(+^M)3_rOP8U3We<>5iiIyP6Cspx^p6h_e(f)Nc4&zhXza(-*! zF3b6tE-2{hO~afMgO}qbP28KE6cyaErp>0%fseNS0_%KpiI#Yu`3!j=!pY;VnK@W>tAj#!A#xO~`irH+l|e!p~^Ub0n8BvihtFBs*0F)B`eIA9@> zc&CdG9<;&0{n)xH%JA7$yTg=muTW=kGG{4=SJ#yDFnJEO{F;vi`c--c?UhFqJj0Yw z;kA>R3fwCF0?@=i`3*_FW&EApQ7N!S2D; z-iY0r(?aOLipBfGTepQTt$tVKNAom)BPjeRE^d$~gr97_Aa8$}c;6h;&16%9;JQpj z+wG`AQQ)5r1rl0yfNwUSw()&_`4mnW+H|LG_xWKxuSVjWnVZ4)Sl&B2n|~HfF#FT| z2ad58l=t>)N5_XcUYDJgbZgKRvE17zX4Zv%z`@ENjN&>B0(Jh-0ll{`bD7?`MfFR~ zH_3v1_mmVa8cghytuXIUTR6H)Fr2sw6Z2U-D>1lt#^JXt+plx_JA^HB$3G`N_j&H> z0;3ShZ~8hR^@u~0n!Mvr$W(_&dG-!Os9q|lzfh9pfy2K}N?LRn4TT~LgJ3gq8-zB- zoai`^Q9q+h{>pS(JUaOK83>ch1sOHv%z4NYDUeT^e~!3x>ky-OAMW}Gj+Lj~EZ?~Y z#FIps^dU8!Y3R#pvBJY$*X43J3p&gk+~wPQRA?Av&Cf>2NB7NI4D_ZMsmU0@;V5}$c5N8D=3QXTe1X9r9Xo&yVG>DgFukkjtBUDb~82`P9d z;Yn1_JK9st_wRb|wW#DKnSXVpS5B1RMnb%w9t{C7v;Tn+$AQN|E1xf4RDicIP1~Ww z@~`b*?$^EHS(i~*5mkHwyBOQx-k(mXPycjgOn86OR{v5p&>EYVv^C=O4f;m6{ z*=tLGHlbuZ`TGlTpmFM87wT^6XiS?$)?czD^M;?z$<;u#>WV*_0ppnW(rP4Vqk#CK%Z^y)Wia_G^y~!ceUnX4n2qvN+3J(D;x~fV066u%E5FOZq&h7DK7x}|KN8_F z>*4L#&!;|AAr5Nz9Lw@c4F;BCmjx@HEXC3YC>K2MI-Uh0^QHKM(XK2vtc}G3xkuZp`ud%P1a%t}xL((=R) zxU_{=n31ey=PS*)aVyv3#$T73ne|LzeWe>+AL|M_zNPFt?s@Pf zbgJWc6L2wv9(8>H!sH!lllM=xC9wl{#|?5JT0Yh21aB=UC=_GV8R_AY>e$}_8($jq z*7E(NW)U-*m@)0#<`pjRfM0$Qfhpq=W$`)mY`JzcU6lJdWZ>XCO>C-s-{`_hqL| z)_a;%-Nc_Dd$mcJ-c4G%R<^}}kdmGVu0k@unS+A^9>pHVRv$ASA@Xa!nXW=wz@5Ge z`MJwnCVQ!wVkwIxuzO=Pbx?s0xX+;+jAi=+kd}5b&pqByJb!f zvER{)P5Hp0V2z1e%B)Bp57@9S?a$J!Gzl++zNy(~ikfQyA_Q>*U{RYhuT&Z^JO)%m z(cqTM$Ee;^FAg!XXp{b}lo+`Gg%8l_!Jsv)9h(pz0@s!0ce-S@R*6aLG9(6JrXYZl zqM)oP)32D&St^7Nu^og6ufz{>N(KS*k3~OBb9p_D6v6KK8<;sN(~WGr&d+B};THZ% z_H`Z0%UUcv%Wrp!!04?ipI18Pi}lFe-Q8;a_?k|dUK%kX6QAu%wRU|Pt6!y8g(!2x9_HmxZ^i|7V&A`9dW`oCCW?GL>E$d{%XU>d4T`Tz(eRXL?jB6sxSCMEured+> zP1%f3E8F0{n{Y)XvV!T{uMA9{giX&) zj(E%P3on^8iD8u88d(xBV@xx{*3GRuxK%Gk=a0f>p{->^N2_#XKL#` zLNX<955pniR?TL6sre$JKZLFBnQ+2AY+D~{Z!OxpHWJ1&{b!ZkDTT*Z|6X#0^%pk1 ziH%PIs8i2-+fS%pF27P|WQW7K$oeyk(2u{Uu)3dX*6}f_gBBGm(ox)Hu)5LC1};Ot z*6C8EqNEkfZ?Z_kQ<`$?)xAw!AWlM62eT7cDSIWvRRm(!O;^0tx(R@`Oh}NZk>f?j zy&hzT-JgAR!LZyW?$6n3kqggc-wV~|YA}#!c=MCl5|N28S}8flVTyMh8DM{1&P~Jq zy@H#r&MP$F!#_c{|DhP%u(|WGfKsPe_O^n``Ygu}%LS&7R13%ZKWolP8q0K+C|e9e z`2!afW{|5_f7FIAQ^+(&;^O17uq(bNuE(G6_6J722?pQzY@fr74|f>`znb)#-n@Db z^)JTc+$YNw2hSV!i+3U2x0+XvF!eY8ez>(h%48R*=#vflk&8Z@Ka6)0st2kQC!y2@ zz_%0^^~HRBbbyaje9)XJrVJla2k(YK0dquwycDQiyExRU>D<`%Y1KQyQ!5CHvM4K+ zU56VmS>CP`w=ES56WdXOvwY6^E4jeC!ATm-=?vS?=V;?v{5xj8_dnQ#p`P2D!B97S z48Iln5kW_ z>cMNV8_@~>q~B>46~W7OQ8V}!K*hht{u7DaebqopJl1vsm#;++#Afm#z6w7);;3{| z(@8Y$<;S;YR(VO`y!vxf`fXQi0`4pp&UPbN`M!*F%4~MM>8Itkb?y+Ns?*>e)9zL6 zA|yLTEUo-n6EA0Re`gx+5u!1*+h-Vq3}n!suuMjXGa2zpq3f#q%RCS93}Efhj>>># zZFM^m`b)h&!$7LzP?IYRNsG&I??A0;O}7iq$G`gwle9e9c70#Oo>8>Zi965rx}KK1 zlof!H)wJfEt}&g250}}H*hZ0n+yMa-)EExMRYM)3PDg!r~y)6E?1be72GALM-~AhJvPjIdbJzOiiH>D$^^|8H=Nx1FFucd zF9{eiIQ~7Jk;M8t6SV)0yw;?!CjTL1d>p zrJV%gnfV?9bCoX#T!L$#41$@w7|d6vD`d5S$;9&6znUf&5INje@Y`>^mOJ&ei&+Jt zI=!E(2A;&r=E4@Xu>O(0?OAu@S6w!pRnBNs3{-%>MeK5D;-08gZEFfKjAIwN7B!g# z(?7apT-F(l$ta#`EfP)y;Xp$aiXfDwFke%}_xDS=lnnPib=mawBo>Cqhxh%}m;dGI z$3aQ=GWntCWrnS=BX;E7OO1ux};;FtW5< zeclC?S;rSN3&|sHb-J?8O8Xfo=*{4%DA=Lg#`C4obc*a77M4@$nxv#WZS3==KN>Mp z?22A9FyeO1S;bKfHVQY|!6WUXt_nSSR)LiyXv=C^jl|R8!!Lp9#vfL@DmV2hAWfis zVFl+LccbpIN^?6!S0B^FVZsZ&7miPR{>6~|RP3?bo=&V>l+=?KLJwE=T$amDDWGOG-xyn-eM_FgW3QbO3UN4{->RME!WPL{XL|k%^Am zi{KreqYR%O6ka`Rgeuhf3|aG}K9@{16V$BJy}a^Okgf-<{~_mae^D|G*e?ydrvcKJ zXMx!|grkR~2gtna_e&TDYZx9a{ zTaFgU(kp>NM+d4IxiZWB9ZhvXx`FjR)R+F@pR!3LlOTjVw(A%cI@YL}b{3y;18MxR zuaKYp{ad`Kq|y^lABDJC4CaZCc)oD?ssi5SmdV|h(`%#!vo&O`Y0=1ZXz@<}S1O`E z652+mqQ;|#S zAB}yI8>~-DQFC9!n$WHJ3#6#)kCp!MdSjC_7pjw#h)Gr>EY97g{O>de z6gj#C=O2F4uZyHsY+yO+*59zKRK-Fzp{tsw4bRm_8*K`$ji2m}IAz)zafieZCvj(C z)-`2@=2qeGLX>T3bdE`j#`TXq3oRJhGI{kx_x_4xRu1DmE_agi%r42IShg(=$&&jP z3ir@U&6-&<<0|A{?a;W8b3W?Wiak&$?fj_+`>x2)3@Qzb`+fjFNz3n~@~j8Ys7H$( zKm0U}xRUU0R6J1`1aPQ2*9q}t)kr`?F!uA8i9ygVU0BZCFF6CHp_O@BC}ex4V<)i^ zyDLB*?Q|l$QPUkwa<&m2T5Au4;X+C<)>kr!!AMhaZ)BLlOB=#VlP#V7f{=-s?-(f@ zs_33|^TPdo*{8&_17skE^!K5(Lqw-aXA5UbjlcuMEA!jS*E zrC^_6?4Z;eAD3@cqJl`2|AVIDeaYKP;YllV0nMmf@bq;9-*J@XU#!;~6D0k*HR;be zEisah6A2^JF*|;%0fU++tyM5q^y*`{-7QD*_Nk=VTEeQ+_Si(DvsND~YVq5Riv}-k z7;=Ugs&(_Vf#VB=f3e}1W6*-z578_hdu!Sv$pG@Av(@BaU&Pb2)g;YFCD_#qbOEgT zKwq)8MoX^da#Bjs_A{D(@X*u?qPTA0##&>wGNJ)mqt6wq0V%?mMi+h!Gl5&Nad(Dg z7IbSPp976PYquleN8hin3jzZEz zzDPX2%3{c9k^v~85E#o(>8${NeG@cZE(X3a)L?aI{$l&VmVd_;8(Kje0jjLoApWkV zIf+k3CFsRSLfbgEy|dv7m%SE@?r_Dt1BPtp6llnMH%ewN`y_@hV`Q<@#bIQswD=m> zQGe&=A8whsMyBwDhTulcJRRO98+LpSQ(cA6_g&TM1|18b^Vail9Eb};(l?NY(3%-7 z$B0Z=u?P>5^jCjzsl!`$J9twQXv-Cv%FZWqmZc@NyQE2ApFmbSRFPfm?07eKR?0Lp z*C6hi@|m6dc27f`wTOLR-~rL!Vx(?IM+vI5@ExkD!7sDl_eLm=0ztNp0 zhsi7d&k5<64f{`zMEDI3b_xAprWYmlw-SY>V%T4S;e}B$5`4F951`Dh-aTauzDQD2 za4VIMzq&M8RnIpWnG9~YV#e05#U@1HV2k0e=WL!HXhH&KGBR>j>T$o4 z!$J?T{An7E6E2v9Bei+Gb@;)$jsoYc*Uu@L>nuD3)bAhAHoEZVroF3V`4QA*B@>-R z%o{s>qn#!A6i2!#&|Z=5bs9d*P|Ed3z-@rxW(g+dLNNrO>?FP@XCv_Nt8IGh;K`w;ldxbOgj`E z$U!ak=g%Ap{@bTtJFStTy}4%XRyXf|XHWPWRD2xjbyIzal#J%~iz@s~lJ7LzkH@(d zv1nw;eJIPH?&*ZSjby2Cvge_fmpzhZ7E}kdPz#lHq^+v|yQK5lgcAwTE6(M0b~w?! zgJN!zsbo}lFV=#nUUtaoSxYpO>R@`>{^k+!5WAK(`<5EYO|;&Nn|z2uxMP6{^|->Q z8J#Xcm_WO;6G7O>&GV(Z=t;y300o@4Ksd0MrC6rAZKj~&GrbN?O#;YE^(7J`X2 zN4li@UvaiW-BRoVHR9*UDrohn z?L(b?O5pv%t_7GZD=wS&yZEmZUAD!f!t7hh?)<`7q|aBn417>@~WADivmS!Zef z&3%ca&CM0d%rB>NN0}Pj_xzrxXx2T|+oDRRi{`SAo`%7$b&pnw&;95$5L5~UGIq=p ziTQuV>H}!;kQMn)Lg(!f?mF#YQ4n}lC5}u8C-Md$r@P!)G&oRQ)&rA~C=wm1Hka*} zx9lY8+?ow>f9E|K(t$V%rJhp2>LVUY$GV9NKZBm9_X4Ha#V+-m()0{ddzGs(@S=g@ zX4X8?bs}$}F`)+~$WSMzsk`LM0y@F=7x?O7ivjXV-lNaqMpHVNj#O84rP0J5rz|X6 zOM1_{R6Hl;b^Z2DXVUA9xf5QOJqS?E7hZ}cX~T{$YiTybc1zcywkIheJg=rjqIL;7 z(gDW#^m!w5jY=?dX_4kpGJ@H~rQ=*DJlNV3mn0$Rc{stc?mJD>XG|ov0HpWJA$ffe zKL4`*(8OE9Z|p2D6L;LUEL4#zq!>I(d8;wv;80AeJBV7u-_Je>2g|{bYXm`|ML|C; zwD3!=LF$Zbc_T&XhLpGb)9=JRGR!ka0PBF8feIJVtI;~WEOwhEyMF3l8NKo{VeWI}M|I*+-} zPOe1tqc>%-v|mzi({-MYa6&E$%HE+;y%+Wt}A|Hv%!k?Dn(v=>G z1VRC28<0~wC3SeOFNF||pJW}E8Mes}>~OJ+|A(rt42!Z0y9H4?q+uwLZjgqNR5~T3 zQ@VR-kd&0}Zpon=X_4**X8`H$^gO)Zcdm1tKm2CTv+r8>T5CTpdKNSKV$+G1A@(f< zxKREq@9Mg z1X09Ctj3O81ive!v?nYQvbUfPWPA=XB;C-W%3l)1^-?;EOLF9T+UOc$(Wfaf5^$M} zh3}CUfys6ikK;q?-9S{KI5=(A zsxX{?ZFx-vik1OmGa#sz0|vzx+teK^@U(S3iT|Rd);l&NwNNXB$yTehx=+UYgKjl~ z*_XhQBM#tLDzp?Es70-4lTPT;0KJC2sC#=WRhS4%m_c>#L5`C6-R6@nl3JPNca5=j zOsnIU5p{{VHoD^p3E4;`haQSUW;*lB8>ezq#&IOk$k6&*mm_)rTG`=4v&MUS?SXaL ztU$#9XvM%F^yzAwfJSMW*H){_%sBG0V~%QFfcYTP+BB<*_02?j&cBCkQ54qOq5n2j zm557$IG6Wx@Q%;xeZPaEId^S2wXi0vT_>7!83N?se43O4V-9QmbzT0b{yt80?iwE# zo5Ah4gLq2an_nR$A=SG!?A;dsya<$!W6VFw@Wc=lEUF}%x|$_bzKa9nfcVN-6Rm676D>Y$?GtiH!sA^7f6gB>zfb)^(t zri4xDtk>$o_O;QEIaHg}PaiIHYk%)934#5K>sj(>V9X1#BAk^ceA?c=sS2Cn71rlX~zaL@l zr1oL$sIfp~XOJ~Z5RNJGV~tbQ^yREu;mw#yg6%xQVH95G`QK4VRn@puOgok^dG3!^ z1KWQ`GoV(}#fb7gjWAv@Qd3sGQz5S3D(w*3v%g<@GHo$+uVUxy%U0E50cba*Z4Cej ziKtz?q+ENC0@p%+)waYr@d70U0}MOI$%ZT?X`Axhex+$x6lmX| z1V3R0dBt8%{D+Wp$rN=S%rmwQxd@RGHe#Zyys=m~Jox53QGJK)EXraM{TaMlQ%$U{ z44udIbq?QHoPa^xUkq|@{b^i1;WIIgX+A0uK;U~3QRltR)ScagLoG5Iy2!5_%Cv~k zkendLgHYZu^-Yp0X=7(V4z{w5i|?plzykth76choqf}D-7RnEF<}tF*8~eJB%B8zH z`l_B-{9#QyQn|w&C{A>~`bdceg1vi~ztB_$NFo(iWRkn$EH?8`M)b6%M@&c;$6h=k zfN+|Orn@}44Yq#v$wz+ol>=Qkwbo<}JBv|tU*4xX{#h-sWZLhFJZy|HVaAf7=(pXO z;HC5+4-<;kP$E{s2jz-#({>ZUmgZ^NAzfF3PSxee21<@KB(u{HKKoO~FXKvKOha#$ zfh->bBEIT$Cvo#uGT08@Nb_+7W56KAm@AEBo$u(2Os=pJS{1)cEiK)Pvi4W;WB*jftX{vkJ`w-gaXMgDOs21I>zwlpCpuEEU_m~)}pxkdv1!G1y{en=~r=bGx;LN$Er@ZqeeG^Ha&J|T`F0{ znbuwU{@QBBY#%l9&O^u37{eV2G4`A8qk*J4)>8 z026A;x3ZBGKDSYrQ6b=$SUm_)`yZ=00%`Ql{F9ON}qjJIu2 zg1fpXU4jR7xfOf)ZWkK~gSDh}Xm(m%*F7I)KKH)JNDxaoRWd+OdR-iC9 zl+0T9yFB_;%SSD$@km+H=(VZ%lq}}2-{_TMo$ZSzUo^aAXAs*J_1Xx(ca0E)vK`4@ z!@GJY7=X}G$Zn2fHAK60O7;231+T3%PDq>4KCr$r+E5doRA2hawN3EWLkU?y_V*5J z@%ESD#-9dTUnQF-D<-nxF(ziYi}Ev^MWQ%KtRSU%{|h~!^`9wHy zO~}UuvWF;|4nwIrG{RmD7fTk*i?L;<^qjUl2%MP-Hg?r3AFRK>Bu>ChvB4F!XwI|2 zj_7i0%c!|r>{vKI66g8c;Mnjgq+p+3DcHSmcCYXJkzLu6b4n{(JZcqY8N9yuB8$+* z2b%{ir`H6DLCiZGKNrxGWdJ{hngk@Xww~m)MYGiH)5u}49Eob$&(_E2U)k}2agn8U z3x%a)CU>%B^?4mrh@U0Lg??GqGj#Zs6{I$%wW}7)9G6J#p6m+{RcD1{ND8DR--3Us z?SIdkb59eL^wvxQ3HA&Qzc5gLSzyTUoof-#VB!5Y3vK*quDh>3TJM4(^c!->9UsSK zY-Yld{8tq7ng>r6v<0%AzzN*;%UGi4DWk9Dho$Ar?=nRa9exY|OTtLswvq=+FrHNZ ze~A|=qu_(SUHwDRZQ*nUETRW0vKw!h z+!p_~9;7X?F;%=LB$u<+ecB_~qGFk8e<3)@oas-hR-4^dxB2yhLbFf(+YRmd9SvGr*2=_Kj44(`suHi0Qd6`Y&Mc!T`v zQQQgnH}sNM;9*gfN29?J9Etc}sGtF%68kMBR(x)TXNOg2S4J9<`tQs^)!=9UW%Le% zux}}Z)TY+xu5+-2heCAxXu8UqzsGHk5IeyG#mpOW`z4bLN9Eu>S1&HKyOt6{{01p5 zG&wVeUMSi;SN+)a{hH=3sv7hENXwt=trLy5!37^hv9CWl-kBXtIMP?VUVQ=jnDpq# z58-<9F8D47^x`~`pS-@mn7j-SoDENQ7S3$2-?c<-P%Z23+0XB%XTDx&{2QYqK-_;< zMC}%X5_0XHG*34cnpVLjf&W*wJj9g8gD z+|6i4`}S9Q9J;B*P3>2?0xrwG21{}cC5Vn?FufZ+di3XNX$7CNR!eAkrMMi{yL3VP z;W~?*sg!K0%7@SFJd9X9?s-x;b|w7a!(9z)TJ-I0A{el}QhbL)R ztHqV%M}w5Ye|JaVe+nI4CB9RY%@qJ@`am(uQLkd~|Cc^|HphN{cxq=&#S2L#vu})= z$X&i&LIlLwl7E}k3D|!J(ybD31H-1GkrH3eF(3L~#vX#Tuf=}_0&=X53POREuYvf)lKE{5#EG3kt z@kow#ch(slBSJqEm}SV|*lZefZTo}WcN9EERYUw-sBly)*8quW&{(on_X37=_;s96 zWUPJZhg<&Hnj$S#S5-vY#lNY0tV9+=6Kt=82M=-O*UrLMVPQg%Wn9)x%l(@k75Uhv z1(N}CH>VsP@Ar`64EO7$hCfNR*AJ$)U(#l$ZH$n(7>n3yLy5;NL-(Q8HZ{Au`i%Fj zFDQw}y~ykZvfTjwE_AKnhiIKcCTo4lTbwtj$m%zHP_`cA@1iVZ_*Eom(ISm)HB5g$ zUFIH+9}X^w+DVPVgl^hyDF7lWync9#0Pb48fWoDxf;VH^m`jPca#SJV!XFgBv-iNR z#*B#@U&z{cY6y^gNK7BiSKx7+1N;4vCu4nXQ_K_#*H6YT^~Iw)ATJe$q+rk~Boi?e zOULF6@WSO3;(>t^!sslU-kE!9L6<09_o}^zLdV>40WUm?9$yYg1iWkip^)9w+Hq>h z8pG9m7uEEP&<=dwaHHyK3@8Mlycpl`aw>aV02!9=!X2EFhujVh;Tv%R3kL#_LWjqm zqFP?lUT)shnX$^l?cFy!%S!jR-p)eBkIe#bg-I*fE8 z8*bn=M**rOJ$kF1XptraQZ+T>D2%RThRTiF-9>#%X1o62<7la+KH41x9i};EDz|Wc za?61$;_EygdERz=`{r8wQn2cqKVedm)wc_6_J!L7ukA-gaN;#UfCL+!&T=@Jt$3pa zsNgs{+?z|A!njEHWWi)EN2q|LA(T3F?y-;=`4Z@Z&XbTzS5%Rz!-kKc_|I993~0S0 z6}kNc5Sa?_X_9L%TOI{Yx^cR?FT1=|I%0nl zy76Cq$NF3!8aurkKGfh-3X|Qh;jx^B46FuZt@1FdY3S&g$s}HpB%}bTZv@Q>kSHLl zIp6R~B>gav#CoRo@}lemd$AgU>=3{qfYr;>rS7{RFQJaVnV$1mhZR#HH#4^BNMavz7K#?dya&YbSnh=(a!I z!qb@nPclD^UdxApC6#x9a;O6)RxDos_Ak9=(Ac61DxR*lWD1 zW)TCxN9E18bP};mgW`|3yHjU(IH4{Z;KCQVVk|1WpA#7u5u5xEwCO5#qVj(q;MR_& ztERenlcijTC>ur!@5Cx2JM3-be7q?9Y<;ao8@pPS6;zzs&5%NV!#=%r6-d0US0!jYu~)LRQBVp(R5>`RC`x zN<43fm_t;hA!=n5897VQk1RO7iz8<0TCPiTss*|gZV;7Q>gcrqBtM+wwv0dM?i8a+ zSl`JTu;sB%YaCsIhh&uDiwlubKQm3@MSj@wl+PL*_Rak}=zYQofy@EM4j%y-H9$zq z7e^aC8hh>fr1dY>u1A(GoGTJNj*m%DosDteX4Q`;x&BY&Jse+O%rfzuW$D}=25z`zPQRuE|1 z@V|$ZI=yvp=L49Dl4M9l4otV&ZRNPjh6`c8^?6Tjn?JnSC*9jQg@8>=6X!lf((#Zy-};|pAEg4KpY6w0uGmYjvmMJDcnMRKza9cg!seb8olk)H6{6~ z`p~{_EhXT&1f=960uJ^MJ~3G7sC9x&OftjaJd{@AfUkE{M`vLshr`_JELzULZ+qG+4{Ockj~v+S-c+KR_Aqikwq+5zymm zhyn3}ttgUpG!QsiGhSB-XO6u%WyVsPP2!E zOv$YO%Qh@9$iN*STL3<&<*ShP`UUU10XCn0d(R8yYm)V>JMKYu2#)mhr%?YQDyaP4s!cHK64^T}{SNpVKo)4APtNsV7`cJ`U;59Rx_<5>zEYQdGkFvmz-} z4Q=T)cVm}~>zYiNG^Q*q!-?O_1Ev%vw3G(+FNK^Cru|o<7mgy^>w_FGV+~W|zgJ_6 z$^`WzKTlmGrWJ#(^lVaDSvWSubPu+qh6vv4!Y@7tq0kWhePgArSDF|Xe;*utwFgs< zF`myrnSewkDqvk4GQ zP6o0@+j6Zt&0WD5NtR(i@`YsiV{?;X-|)YbB2~=J7P@8AT=#{*y}Va!g45_(u?L|JSeFwZ^is;5sQZ%jkMv2deJ1 zYxxNs8)Azw&bf7y%4w~lPrXK*xkP^LJ64G??jI~(F;fT_TJ+GeQ~U}Qt3Mt2!fo7_ z5AbG_D8|1AzQJzSjqs(Sl(5MP+8`x+{d^`UjLk*|`2)9P=L$pivYS{Z~ zs-D2u*q@UmZ8WrLU=`py;aosW3TSb8!Flth8ROBP%Us`Ny%EZrmI2h}@)u5dNKshv zK$TP7-t2i@vI3E^LhD04$QpEB)h$M4NgO;S zl(XBCdP{8W`*7C0cYa%VswN`3I5=EmscYAO-@>qa%ik4oE!$9nSWTl3s(P40QM%`L;1CE{eY+!n7rs|*xalcJiFJcPI)g748 zeOjpZ7@|`%u>U>Ay@&|@z@Z2EqTK_{~PmNbIhSDprP-R1JKh%Bc2Fg$t@LqV_|H(vHt6Ncm*)qb(3)(P_rVLU|>Db8TOk9`EOMgU5)J{A#;xHNxgN3CWkDH1?fv2ai*^X;saK;^_eI9(Xih{1e4hj9D-~6vn$s-iV(n)p6u` z{aP>DJ_<~Og3Rn&t^x;H9Vfv~mYkb)JpVF~fuM6%b9g`eN}0RA`wPBHCP)i&|T%NmD%fIem`1FVTyull#NxNd*Hg}$^GP``6OcWLW8 zjKgq_<7FY#QM*aYmy;MTx7K|>2X04GLaD4A9a1i~70D5$PspWDAZ3#n@te^=@eZbC zOzP>FOr;%gBoapEMU<<1|4drm+}e_req%q)m5uhB1aSS(UCUI^`qVoffOdl8&}P zg-@)hj{Q3m@0ie~$FCP!LAE|7ZI1RE5#p@weI|H`@Fu`kg1MT4%qMQXr=;1hj!Ce- z*Q6(xPHcNLBMf+%s6+Cs4vV57cG46$2N%7lPytcF*jN~EFJ5Qw0$JZvY|PJPxFn2p zk&|wRFzvqZ>|>Z_a>3^GI{}c@%jyfDqj>EG0{DRt@b4q7JZ)~FAVfk$Dou#aA8c+L zDY}Q0s!15QLqn)X>)-Pz;A_vWAd9?9^BeCX1iqNZ5!WN9;hf)qdAIy`qfe{B8nyES;`5|YR!<}f^CR2tg zC!()Mz;aZlpVt;p;Kfu`_H--D8CTc2Sa2mIiM>Ino@e3t;5&tDmanv-nKyacS@Nor z)8U za+^R*`ml@BM~SMjs}{!~jOw<|<@-B!Tm(@VBf4EJHh_c`bYVgv1f8`H( z$(BSuo(g^rG~#r!ZcIRj){>5^o2g10^CWx_ZP;3SJkZIZ+?m= z_lp1yob=+RX1==V-;}lsV%sYh{zU7cr_7yqF8(TVH0=&x5G$*w?8kcq*f(12AB@MZSg`^Eb;>SoaDFJWGcWP-XgApqK&IkG1JL5nP_!m}{Ei825Te9JkK z+cGi2d~_jXnK_oCvb!p4-6RYu7unw`&{vlDUNT@vzW$WeUx^6Q$qTrQ;-?jPg{1du zqEQ0{qrkB$p4ZH`Qv(b%4Fb3zz;1z`;@{u2Rgxo^D0izS01$}V`ukR= z5}4RF=gtc!^+qSz$QMi^L`$(H_qe&AXAW3l-teW=er`wXdXXXQQB_aavF3yQ+yUQF zRmLT&ry^v1B;M=aExgq#Us#m0VIs)PekC7TYd#EYm&b&Nul%(lLZ|4DSj{8;T;Kn3 zZXvk$dM{#wjQB9VOzwWjBZOC?8Cirxx{otCz#V;Jcm&=WeJX^^>A-$w6Nahym&O4; zXfFYJ9@8?g4ivLMH+(yFd}?}4hGJap{>D@fRBK*>&ZX6|Mf+$kdex;L5wAQ95HUiF zv@+1-iX8WYL>^}KQKUH^yqEGnZFouIVHz_Ja&D1KyktzO9UUG{xXPE#={0i%k~%am zMU(;mPT;+|u~%f7s`tspyJlT5iKjVb)G3dyls0j%pCQ8in&8*gpv#Etz@MQxjY_6P z`P$q{(a1U86s2gc`Y17D0^gXih<4dz)L7coK?z}&8`@9pwj}VLal9mMK$802fn4Iy z53oK2Rt{Xn3P9WWGu7z(Rcn6V_ED33?({C#QLV&o>AT61amn(SZ^K0=={dFn1-0Xe zFQY@m5qOXik-2>TSoQNi{hFt)kGa;kgIL8fO$N}5c_%#BPN$6jH#x8GRtkN|iN~f% zLd4|$GitE$VYO3A3yH%fMz7^4gt`Nb~CN z10MSf-sx}zU^ef?HK*mGfc}`dVINO7_9d_b=nbyF(ozsze)P;e5v;L3XVN1hq{Q~( zw`AGRCjzVgc7O1Y7FX6F?8$8q<$vEKt!GmWamv%uG${CNPHGACf>YxxKw}(~`S3+S zOm;$xDa?kGr2l-zP~Xi_8X_W;cj{O~ji_zCHD*M0gzSU--@KK`1bDs8=(sIl=;kZ~ ztK&6oQFoaT_u0(vjJUx~nk9&44JVmb9baOcDyq(PosS)1jGr3XXO=cvlLy@0ewWM0k!Z$Qdgs&vBaLRm(Z zSX^~vKUp~jj)8=JYH@tPAFuDR;j+*K0mfeaBTt2Hq8Y;njJF4jz+oWIhe5V!B?U@j ztN_BC>9xu7S;xe#D~bQE4AiFr54dnk`q2w_J@!g|?}(6-x}!sA8MDfFuCkkW58lvA zL|Tr_rE`j#CdP2mshU3`KIdwz(#$l{iS!;rdVm#~=!2)j!gf3}qOwc#>awL3fFJ+a zGwsFlI9YH-q5(Tk_cp>?uVQU(%4lR@bGopPBYHjv#H4y9V8W0MxW4dZ6SDpaovR@1 zNpoJ4u0PuDY{JQVQlSA1XaIl>a7M#tC#4xX!yG)mG97mD?h{9(A=>8&hN{8saHBT& zDC!?J2Mn+=DATo%HZzjQ($f=b&SkQXJ7_52K--Fwj>(eE1{SS)HmN!jvG3;$HiZJy zlId9zp9or6|F?-?S?ei<@gMq^0*x)8OY-J#=O6%Ez=V(Z(vo{nk%!Mx|LJ*8WC`z5`jkh6-LqJP$KSFUm6n-Vveq+uk_g3j~F7^fa{b{ zEt?XJyX+5}@b;LlYwP>a(>E*)%niQ+@|EgG2XQl$}>Hy#KKI>|v7*5fy1uIq_ zeR>!#an&GD*a&%R+uzC&!lTw$C@ zKDnOzX`!8|dKeAjnDRqCB+WHecVF z<%YW|Th{pl#ue1m)Z*>OhjxIUPHAcB_fC_46Z?|;t>gd~y{F>@=aJ*6$?pG|b{TQH zQk>HIJs(|iV8cng=%_P~aF={ciRAuJf;Kvw*rHDcb}SG(9dK19kKX zNy16{9E9R^`W!H`_e2V1>%T*9JUFol{;kNEJ)7(L$km(PAvQqZs z0kNg8uyY9!+h9(F4Bw)LF(x~lo!Xvuzkaq6-r*3a2yM`+;5+?#@$6+rT-&VN^&Nj1 zp6$x<#Io`#m>)U|;;;>iY1nNC+(d0pRJLVoYycC&6Pi!UFCPpRY|*AD_eU~q`&M*I zfWgZi!*}piuoNsXRvvo%*!znl<13VyxF_B|-ZzXZsk32T0D9TtTe@gCSZB6SlQ(H; z^e(M0jZsc~+qrr<`fV4;zwwK!2-dggMsBRN5UY=35I>X)5xS`9kXb@F&y?y*3hm#WTmHp>QhvfJ@)mD_j} z&!qb6#Gm{*bOw=skNhVPh$F7)qj>r3PuoTr@828FE&b=+`;B_EKYAF}zV`TkZb;nF zQdzXgVHW3^f4NF}!Saixs`&-*EVFkQ8HE~pr6x+#GLyjsfXODSAbFBs57(%(Do|N-R&R1fML9 z%twEouaH~m>jc94$YJE#gmAuWvvIl43g7~_A?#`*_@XMi@9_U9@hbB%q~83&pz`nm z_?I1iVm_nWVD&~Eja_QX#{q&||KymC6&2Oap9 zyc|uc1Vg@I3G?Uzf^_t4nXQU>`EL|mz27`R_xVHFGRpcKL$ZLG{ARu z2fnj;2HLbg*dVj)?KM3GooIOzpV2(o{iN1f&uJ7EzzGhe%0^_y0W_0ix4rG*!`VFK z_C0&|eBnc1r;pN@8gY|?&He5Dtf}PqDYq7WFCf%tRYWkGu4fN!gbZ)>sU@>U%>+}e z;JzLsOKD0j2(<{rF6|scC_?4ivABt3Z$)+49wTg;uh0(SU-wa4p~QTQL$Hf|-h333 zugJu(nmRMn>j~+w5-$iscdu`tr)62CO9o*>DbXLt4tOl1I;y)wwZN4kwqDM}%pS8R zwt%CQss(_+s{iI?aTDF|tLbyxo4bPKTHT%f8n7JyZv=RsX3Y)EnQs>P{lY`^^v8nr@w8& zT?Td^*LTQXrLI^vU#1X_wVVYrLSr;QY&^!L5{E9QoQeG={x=WeiW{t z%I8S%`9+FK&w1mrJ-$Ow+QS#1h-pCtxu=X|u?>+YOt16HDqaZ%Q3AsL2pPXA%eC5Z zmIK=2ctAXu&SAOgd8R(WjL4>X0(r>J*m2;Ld2R@(QpHI_56woWJnO zY9`vT$)(EX5+>l6?@zcX>v%fOcr+ZfI*W_7jw>)a)eo5j-Czz_jN zlrgB_V@ur>i5e(nn9iVp1$Xqt>W)j^yVrhM%9XFXQb^#1@9Cxg@4tLNYQ-tdNGy|8 zb)~~#yQ``7NkPSGb5&4sXgm~&t#nNdCpJj>;++(u6a4)4&vh78KL-2YO4FkZI?B!%%9YDfJ{e&q2P7rycW_Ma~WJJ?mbwa@&g~k8h|Nn7& zyLTJ?pGbimz<_4PHCzuV*^(&utTgW|7G5dcRWZ;#D-AKiH4O@1b722`6Da09&xdhg zrp%pbGIR8svG3HSB|XUYKaLIw*#NLs!IKW=AeM<zW`)t_DW~RRVNB8iXs&0Z0_%MXkhE_ zDe5C)hM8}~nmlnocBrXI7{v@|5B z!EC?}|4UJn#Q^Z^L8Ut1 z#D0LV!i!&}pG@OJg`>1(cup}92|q>PZ&Hmvh|e5beR#~1x>*6=CqT!5@rBP(ighG( zoy@ONIQ_9@J4+INRa$qJm+a}5d-ZUH;NInfN{LflHoBnV)TS?iiR14V#|=6WuM;!8 z;OQkaW}EnugzQppZWTL(_Dm~{f*P~hcnOWDFKITX?pJtyrU1Khd>W*W;I{d~ftpxd zEg{c4o@~rYUR0SSl{H`x4bpvN-w8e(+tIHg#8#ehTofbH2g{RX&~`e$t;A&}z99cS zhjv==?D7BumixAUq5ygYa)!au{;%o1kGJz0z^up!=Ksu9Cu+4ie%GPMxUALflmw;z z>$+6Lwv{VTHMjO zlv|1aB{h~Q9$tHg0=by791zx24*!uTVo@!_>x^qvS zu1q5a!oRo;=A^NYmVGaigpBa}S?mCh&H&f!dFR){D1LQXVXjLfH=ooyxdRX^26|u+ zqBbxkv3i!Da+cF_)xV->Wr?SiiW;Y9MKGepQ6}1rOAJ(7xIQXwbcnw+uNPCsN!#;vp+JW+k8EmFtpaf z@`Y;I!9Sh>KM%tS#=nVwaKGioW`@4xXx5Kn+O;%l_&pqP=suIvDt>xHC zNdG(z8BKn32whnuW$d)1Wi>V*fl!E4JRN$y%tRcy_n$UaOz~vGfjM+-rM+i-Y<(eu zV`%$sj>6hDee^fuxTG02uM#o)2uP9$`0N0CK#@kh^IIlE*&wVBNy()D&t1{R1e`uGwz>-`^D;LSVWzo}VsW z%sGB|P_yK*&OD#+A;Iqjpf55Vl!u>fMGKE>;?VH`E_xizaz$2_a$5DC`JGc3mW_R% z-UO%`$wR2T==~hkf8L%cKM$#M#+T`Chk&E+)MLrzopbM}RqO%-HmJ>&NbOs$X-0WJ zuL0n+8Qx_o$WLU|sIa<5&y&pCd%V>kN-9jsOi`NHFb&uS`sjdU_rEfaY-Z02At3y_ zko_R8ZWTUeKyS$@R~e-wz{i>Y&7!PdR>f+jHr7HTV_))gWDrO=2|(MR^$%J|62~VZ zXnU3bw;EzFgS*ddVgkF_oNwHzFV+xrSjYux&QO6~F@Y4Y%(P=d(IB!zM?Q&Z(h!=O zWz8aOu{ImEk9Gr?d#?awWgxZv#It2P>eQ=mdm(o+w1of_fiT0mZ?bk5Ki*gYH7PcQ zTPL!(XrLQQcOYNv7{3S;go|QiSzn3@nG8Nbqb}D8DbryOZCSvJ_AT%+_oXUL*CatX;Z`D&z2B`n1~zsS#JT!!UQ zc;OZQKH`thi1Wrr!t?6(Bsf56*6a-hW%;i}s?2|CsRLPZ&L5rVi=+*vs7;x*G=-j` zy_Q-9U{IeM-XQvzjezavNN`ycJ%u}vx}qYhT{LO!#)t)h&XM^k8h5;&B;Kut8(=Q5nB{k7=6>T6IVc527V8JtIJUNysmmF-KLhcv9_^-Y>2Q z5E&tUKjvr;p?L$(S`whqn#^zuAFdax-1Q>;bA6-QP^WYduE;JIOs%xG^&+c*eI|*g zd*e^7RMh2%Qrlc*u5Uy+6TiSa*FR|vJkj1wcAMvf1^-kkq+;K41*#h+DIY;%dp&&P_zs z!0T8G&+;Sw@dzvbo)*kEcq^1qKNt%7-?~E&pcw(8uNwY22TV2Va3xhIX5PQM&ApIjVDCv6EBoCI zTwsknyS!&yy$uAL!}HI2U9oGvP|G%DAT8p75GKlkZ`ih|Hk~^+a{|L(zWX4NMHn#Klqfk4SVEEFDLgaM8IDBH@1mpBU;XP0+QG7o3lk5}Y zS3TkzK(6fd81;m48tMGKaE|>?P?Kfu0X9=nl+x>jj4YIbS3Za{M`hAKH>7J%NLo_( ztpz49Eehmuv-G2e2uIWNluTO+q>2s82b6Ni(m83Yc3F*H$G9y1gwdq~7lc}tb)UG? z#$;y_bFQ^Rv1Wd;|C+|M!s9vmglUM(C2bDU7cRV!7BjNU8{CDrH)sl} zLM!E#Orw~9`R{vUV&LyTb107suZ#1MfM{-MJ*nGY`~y%oFjx{*to^+)szvV^9=;ea zzZ%B_zx6#x%b=GTToOFQZfEs-@MO)PqX1UtzBnFF`yVSHu_9O4n(Y??$-XuOJqAnT ztyurwKRp&L3s=L|{aYvp{V}zj;oKO}eiOwhSwDGm)W&mG-#z!9D%1}dcGdltzAsik$}D#EZ5yrXTKqaJZ~yPx=`Iv1 zG|~NxoaCQ5{zCSU8w0&}FYDf-ESLB<;}K{6!+&t8b`^^O?9SQbBid+JELLw&DZ4hL z1^nkMztE@ksR|t`HpAEf+6|(f?m7XmOE#uLcf5=4>ch#uX&Y<36ghQ)9@D^F*87&^ zSm^aV`H%Ei9|`3Bf*6jwNad9?zGebF{aLo-poy4?c;-SX*8I?qSu3CxX*Y+f(Xh|I zXi(}*K{F_!x(v$*_P&k1uuwSK@p*IIhcTLpJFh7D+VGzIB>2{|>|uhW!C=W0$_~ud z0EQ;VC03c_a5cTUBR)MzbhF|I41pC*&ym3ma9#7zxxa@4sNoESC7wwcwszg8ygcW# zck`djrDv;jtYW!}dF-2N=UxA zBWXU4e#nrCy%l|O#~X6*BO(QSsWO+N}`22+*ou7m^G2Bb8g4aJp+W&?H%=}QH40grv1EdBo74RL$u9vd) z?-v8I%<<&74gPtrkDo4YOV-J(`)xU`aBhESWj}6TK56>A7H^K%8Q#Sv{P`y0YvZ^+ zpPCQ(E~jMO;Reo1D9W<`VaPP}BJW>t_PH{&h@U(BP7dw@(E9VT^#}! zZG!AL@(z!b5juM+3=~!_o4sAIt8$KR`0*3YeW57>0j$1kQH9?pkl_gO2}1Ei*u=Ju z9_vM5?j!#@AYBR;-r%=^8xB(q*83dIWdymx*F}sC(xqz z#`G~jC^G32A7}3DAEVq2UUM=zr^OlTRL|9VV`?B-f2U%2i3Q_j--a|ckzxZV&n3q5 zABC|IOsA~zu~IgzD~+P&EN&VK<^~@WyoS8^4(~N^VJYdCC}@l&g$mv1pSfKLHA~I= z1Guk6J?dbSE1y*?7GY<)i7Ho7*0*T}`WIuL4i@Pt2vUb}OxhT*6aHrX3P>Nz_-5kE z&1WmXNI~twX&+2!xe%qnvOGIb^?<-3Qb#^4x+v+3uj-heH_Nt?VT|ubp32^rb*&dD zd&+yW7rg~JF9-E0x4!ULccWHV2vEG&39Q$PD$z^abtNE1yL+g;Y5wq35{TkQZz>aP71lT|!f0 zhLzpCfdlbtLwRMf60n?~7Ro5g4*K?&Bc%HA6cMt4?zDF3vEg&c4>{bzsVSI^=y7;N zm~R;VV4*}3ImcTaYL395+(S5Q|C6;ntm^@8-rkZ!>4e~bzU=R*>;plW1b>DNnKUw; zT_2Oej`g$xl?{CH_n8A`)YyBc+`rwnQ?d7M6_7#i9H{cotzReUcJ(ywo$xLP%KjQB zIAWFyng3Q;i_6xd?}JyQr6^#tcLxY=jMIYN6fvUR33M!+PEl5hYj)I8ilit*6kcE&Q_>J$ zm}&rTHx{UB7a)-)u+Sx8Vg8sc#kzx`bB`s*OxP8M4r5}W0IN*7_=tV&VV-Q&Odvy>u#diNx+gpkb@j@e5KHh-7WK=lbgyjD?1j|vt;t3^Fn{?g6=i4=Vw+_bd) z?P0mbJq*Q(dpu5V!~D+~H@$@6HP+l`P+wT^CQTAvvP4kf#+C-%+~ct)__}BC^|=*; zF<>`8mXpcqlZAJ1r*~ujIXl{l9;Z>npZmxk?g>6^%Q$@?!cmwW8%QGk`Gf5qCe9}{ zf-iD=fJX9)$|vvzK@R&v&9pSNG!FSv2cFgi1?z}r!RD%WU-kJ)fyYMWd&Jb@k=`bW zbsfi-4y$L95AeqIjifO%gY)UvUS3&J8JbnSHvc>+IjZt4Jcv47bogcnsbGFie18m` zmXAdwLWIaLy1X@aPQQkZ1G+XI$*W0G*hX(p;D}Fng8jK#9Amrbeq%=@f7k5`j>jYA zoBOjAXcg;S94*#<4#xYguz!)&d%^et4h#k@EEjbTfA#N3L)JAcTPsRo!~VhM`y#EF z%GD09;u(x#74(URi;?C~{oRjsHLJY-#H%hJdx;?mcQ-WUeGHKgLwPutD}EKtw|?N$ z90sR#UEz=}Z{SU>@3m!~^RTO9g50ZVhSP}29;3Cj$3Q(UDSN|eO*ur~i|+H7yQ z-wN;s`fGk7?xOYCwMN75R@ljGS!m@hC?XFznKrNLw1{#{L+Dq$tk&LGhaj6y5PyLG zx>2F|T>RJ%_#6nd4Iaas1EVg9fqPfz9EkFuZ!tQ-6gj8J@_%@G$FR!3?|(Q=m^9gT zlWp6cJYlkJyG}LPwrx$en`}&zZT;W#`QG>M$+>z`*JQdC(v7L@IEQ1nXP0Ts=SdC8fr_`D3urteVC0$XXMYfi=S?lljdo0Buqmu8}Qk4+(d(^93 zh6JUz!WKKU^%aac7zCk-ivvIT_g(Ol`P3}g-*N4nMwUNDx`(I4zIR#cWw>Vb8|7;T=(cahw5(a$inv2^T45V_1<6zT3NSQ9Q4}DL^f&R(^y=u@fU$7kE9ZV*K|L8 z414huHmN7c>k!jeM&yDDcp%??KCJTr=k(5+GI3t4|BN^hp?%I2;{xO#b)io>q0-GK zS}jREE*x$Dq97LdaCKChCU~1ohS(&E|>= z_A|4pz3~-n?hY8oSy6c*+wo+S-nb~-7FtUWv7F0Nb&ML>?JZBzr%^79tu9lVYOb$y z4GGvFE{}G1NW!-xWQQ$5fxabrQ_y#N?&P;S?pN2V2-2>|FTb5^?C=DvUtZu_IJ-{` zF`wru9Q2!Uj~g58V^hWSK07?kImm|CSVS+_K2a;KNnU9_R=n6JT}Hcg+4G+3Zl=ib z7q(T2M_t~W`$R1PhdBAs+m|GJ{EoDnEbKnlU?&;G$m!;53;^^!lcpdAi-sQ0cghtp~6QUY2?I z9&!#vTQI(F8+0_`awg7LPve7l-r423T-3}p{*pM{Z|I-W*nE=6j8siHsl7PqDt$HL z9IIkw@{8Bk{y_>!|Z@bvfbwmZx!g{~LJ zIK-^Qjq$H!9VV#%%7lpuBnm#6NQcp#<4hf&KkgeHcK$-*`0$F+^K#VmIHmY)JA5_J z;zkkuh(FGsU3d+7sq_r3-7Grq!G@q*M&xDVc+cs~oJzp*UkEHM-rFDVPpP}N=|Q+W zT_cv}?qT2spCQlMO0U5-@4)(qY??P>T(Fx^1w>-8{Z4^6dDsoVY*A!Lb@w){u$V=3 z|GV>jPsO1!46vu-k2EP+vA@ldv_HIodG^DkHCC3PQ3&i^Y(giFzOGtTh6e!2ltSza zBWJI~X_t-9GukJ?TjK{1I45>&zl7jeXT2>kkYGBQ%KN_a;|A}Q>B-8}Vx!9QMNLNq zNic3L1q`3V0|$NFuNc=@rXMJW&rPPK!jcz9kP6BgKTUaJSzBOYC+rKtx3w+AJohW# ztuqgyi%DArsNk#@i10C@*zU}%Bm)!ZEO1$W6$q!5dXrR6H-_`JLqg^<>6Wz+`&xaXY+p*epuZbRZD0kdk-|7W-zJJ3M_3`c+ zR)4hDV~0pH+lvu=*L@{K-typJf&Be=9HgGdI3L{=)-{sOg`BeW=#IrX*6n;~7JO7G+h#bQmXz#NLGSW~tYyVrqr$k}fr)i2 z#cIiZ+6#6Jp$8)}Q#MYW`Rns z_7iJ^g1yhdkbJZm1{5&nsET31WuN`!p7{HwU#^({wRaJ&0k~z_r}BB_4ABrb{wjO% z*5;f%bReXdY-*?2MJ*YpRv+`2qT;a+BK@lntDUYdy$ zJ=gpZJ2FCEW}b6M@GeKPVvX-e80-J&lJgxlC~YqXro2DjMzGT<=HG6$>`h^Do;9e~u+sOG)4i}?I}WAN5C4I$ z8yCaEZ0FC5UsMK`Nx{*H+2sq>5tTQ*B3}mzd%8$w+dfOCU_QcHY_LF;j?GDw#Eg=5 zSS2eX%KQ7CLG@a=*~jI?)z&a?jbEUnB5AR%H{2BdR|4x2#c6d@SH5?ht2S(^c`LG8 zT>VoB>i5(ZdCqRwlGT9h(>alp=2F65&V2Z20qG5O31Z zd2|7I&v%xMKL8tgjhY9u~FtY0QbmlF8ScoLh0oA=rX4N^rF&tXycz#si zE6^=!ITVoypAy?ne`T}d01B$6Al?BZWwxsc1Ge4791vDQt|Q0{=&XGgWEg1Za{0G3 z#DFkq^qMQA+1Q-X{`7btrf3#@Od26Pg$ z+#~-0HP;fXvsnsM?^cr%uBq&uG{qllzrzm*8CEt_|7k&*{R+KSf=F0gJE;OpUGBZE z6aJ0ttK&cK=C#0LAsDXKP99VlIWh}SIUCX}LI1c>=H=6UPp$(OzhLb7zG-!;BDxGH zNex^Gx56Q4?}(+$+Y&fo>Hx#O2w*B8rnx4Eq#es0?EVLs^DTn`S{|D2TB`GXl!DR# zgYrti$B3oVwQV{dI>uXnsxGk(TjIiwHlzZI%_+O`if769Xuj%8KB? zRwZwQ{=@4$Z{wuaWWDG8LZuF+Azb99+@e*6e{q?zfA|f6d0tmN7m0Q>Npj{=h^ZgN?u8rNoQn&{2_1CA zH2*rh-kT{mHX4-%aBROpcsG8O(7b@H=%&Ol=Ghpma?Krem ze0c4?c3-9_Q|uWpR7^pG5SBmY?axzzhK_Oa{Y==Mrt_U{VtS0LPs?$7t z_`27wRl*wnfakL_zCG9Z{E0`_JPa}2_u@d;c~OfhtLu=Y)e5bR4}fw z?_1q->qjYe()sGmr!xt#vE|vWK&G{SD|uF2H+fDrF8>u#9N7OVDPW9l7~!f z9>qxIu9~OL+ZYh+HjlpcnVbbH>CZ`yva$r&xiIav_nt{C@M=-fz9nCJ`g00O`E2vj zzw#m!`zrcZ>o$EZGBKIccVE);s^XGOv~AoVc-FpU{|_(EyU51+Pb4EogNj}qsZMk; zH8*T17gMrgQ~}Jq%K6vH?sW?Y5!%uKx-6y?G}}g7ssYIGVDX0W7D&WYePr-hhXb#S z2_pzKF5+RRf-ggWh2bx&L!4aTmw*;+)=w4=lyX=`if;ul_qZir%&KN|4mOy-x3s|B zKVKeD01P=<8Wa29mh|Ni0t=F@?=zqCe4(cy2-MzuG46Jw7W#K+eaM9%Q+i$QUQ?+J?z zR%O;9u}iYX)=ElYbz6)d;4lk?)(Fpo%8fhbYP6c9cel*q|8h+NkZafy)qe`m5?N;9 z0x9*92N)gy7b~tJL;GqD^k??vt|8BM^OThEA7gH&MOy?yD~Cx&+;T(9m%DeK7|b^r zrvC9w`X%mLID^k2JPnP*(Ea{;!n4oWR^6{Et0!$qL_Sbq0Dg@L7(1lI+!8@NI<2My7eV_)r#LnB@R)KcHh9E;`&S=jb(s~ zDBUDrGe61r9j%%Y+1r-E4>$)v>c$?3Z-(>Gu&5!+8ILu_s~ETwWG$f*HU4>F6}?&k z97rd86YJD`azM1j1je$a@@CC2mI=O5)7W1>rUBUq9hv0cf*NJ^QtE1l95EG78Gb8> z@(eWy$096H*$# zri<+(-@j||AAbl^B@%VV1~G>#x2dVZZL!~Ak<2hyo`+Tu5hf$#fi)%0%)0e6RH6ex z70@S*p8f>MuF_{u513+HogG{UwmLM?fg{AP?599&8^|e*ePJnQD zGSY(mSby*EzNB6QoF?jIi$+T=%*1?`ar`ERNB(PHfXNN$kTF9S#>m62Efy?mb(cwa zBU0`Uk2dgA&;I>gx~}mRxCKMMQY7{k;p95&Z~SrV#VbA&Iq_GRPb=i-n1QAPZ+AQx z+p}_?dz)7jjK=t?k=xABSnKNLTzR%=BtA&L7c@Y> zHwxQ}O+=@nuJIFYG;}jxl(U*I_0Tt)>Y!<=Ez~YhU9Yf7ZITjn%2dV68zHs@`VVZ= z9e0S779w=WRh~j}Y6|u>Di$j%E8Yo+jSe@vu-N(gD8}xQQN@38P82>WFWfpV8r#oE z$uBQ0VUBQIn>8jnd2!!=aTUSp1qgqARpU^ay5PqMv}8XftxS^$QA+sDXH2O9M9!@# zKeZ%rk2&Q4t0I_w3KqEFzpMMdFP_XqigXNHWK$LxxU>_}YZ<&ryTvlTfXUZfCh_OO zcxc%`Sp-K{8>W#PTgW(=7F`Y34fGG;9!i2k*a6t9SimngS|l_AUedr5TH*k#j2Vxi z<;c=LqR3AE3feqcTk9U%i$DMnx zW{!25yv8mKJlxhs-fhea-h$Ye#b9Xn`T%xvIHmNRry#2u3_GGKU7G(rg#6~yg2&65 z$b13(B;Wl^DYsKPoMjasuexqD;p2wxad=%G=>w9njO(nY#ZLOKM5qECmJ~z~9MFix zoe(`q36YIQVwbGK6G&lMq%)$!1Om5T{ra!FMMVMd$ZdbS+dZ9mp zD7aoqbW)VnG5 zDHojb#aq9XOg9*$<^+7L|G|Ny3~dg;IzC4pm{{;*M9(lK8@oCD!t?JM`;-%92Apy9 zQbQbsu?|BTS8RAeGnZf%DYkkJ;X&ZFC9HNeA=DsvfHg~>2D z4%n6hM}RI=Je^sz(}q>(E{-QDEW2ZL(yEx5BY2-rCz>bfNJ22LA|u8oP2!jdZy=7K6FOH zh`KG>fzpN>=G{hofU6@iHR1e2L0TLbb6=6BG8cQ}W@(=)9f4vzvIMRIWvdDlu#O;E zLLS(jMve_T_6@*E_`;ZMo>I}?H5r+DG>DC-E0YE;)Zw*hsF!l~3XA=||?f?p+vy+>panQH7{P0FpLdy;mbR-qmWhih{u3{ah<}sT~D*OrrU;Vr;)aGIAwOo z*uD(WPaMXokI|D9W{w~Km{-&SOO!S)=$D_AI%G7VlK|*;SV{lqE>ciW11(Bjw~(!iw@T-#B*JRv$`i?m z8&S3d5}lfmtE;TyJ{mZQ)9*ccTKpKjpS6O!kfw<&G9%UAi2Fg+zoR1*&!_%%$(B3?fG_#h6qP z6i&l_Zs;mQ2}wT+DIb<+1MJ4E6DCeRu%-M5aJlxFX5UnhL!F*IS>Cojf=zLh1%(^Rn?5njsi^ z)OmU?FZ!pj-*!tzO%bDGo0LM3zC_l|P!2u(0O%|r-baS#Gvvwfw?qP#V8oh3_^9@W2N?Lh~e(C^UDS%j-T4vxFJhF9dvltV0$*;CFS|cySYQ-6_00*69pDjgRc0WL!d(=MzOi6;4R2@ z4eQK72EJG zlV?hQi~;=+`1YXG7Hix}96cg3m=nU4$np)~>QazF)N_E2oE{T?HfNnMB`6f(Xk12H zr&nORs1P4LlvJu)`&ylb-NhyMyhjI;iFfrXLdvM#2=1TL@8R;o?RN60Z=C0iVO-n` z@(WwMG2Q_j1Tbya?g-QoGrVrp{s!Nen=QEAOv&evFtZW@Zua2O`q^+Z0Mq~RS`n|~ zRuSk|fw1-ei& zKYtR11wLtwWM$FBELwe)+;w`&owZPEsz4g%&?q<;BGaZl-5vhRE+s85V~@LsSWBK} z5YE|`Sc-KYqEioEOb&?v=lPeOXQv6DHURGuYWv}7(B=M>VP_K${oKc%(`#16RuaJ9 z?U<&-=L#wzNU9D|k{l*F1N`Bzr86{198|ZcZ*q%-@2}W00`zF(6+lq5#;qrD zuY|X?C}8n|c*AHsr)%1+=pm+vF<(8Q>5htZ)#$CqY9}5kYr()f_T7Mm>}A(TPV*;hl)x)|I$AD2kl9RGvqbkjs$>tL zqx&N+PSEU?Q;`5+9pNWCH!}SPdn2Jy;1<)~!F6AprW$7fmswgrd9O!g$DeL5BFKtT z^<{xhi_6D z+fcptPC2=@`quv3I}Ul1s>jE3mywLP5NX+AA;x}7A-3(0?H9?qx9Bba9FKi6X4yoL zb4w=47PMh&Hz-J_g^gF-7sQJ_;4_6=dBh)N zFNBvNU>sTn5V@Xs?TNr{qE?inR@qHJ1#1kYn!H@U(SYlIUvf>XuKL2L`KBP)sLeko zQ3A+1QbzW$qM|Y2MFTnLpJzj%qO{0$sylgfgs5({x}5*Q5V>B( zx$ismNZ;jnqL3EZ@(gMCh@J(2*A<|ngGM7Bu}dxLb@x*N&WIT_PVOQeL~w0t7JdN6 zJ4|y7;=eso2Kv3{WqHF=I|>};@-6i><=drz96pmKHVsbd-5L%y=MZ(WLPX>xC+DGA zzCruvrtciTJnDV-dLIdWibFjVm=#|9_LRBCpnNz5OMN8a#*k!qPYYLNpvUgCQ>GAU zYmm{{pg}0OiCIgMH>BbGzMReQoW;7p6FNyI=rrxfh^l&BzgnP$=-?#8U1R!+j*mT_ zAtQpdJ15#*wb73cW5E=j<SUN@D+k z{%M<@emH>MI~yS3{4c*pj8kHSlG1Fb#(Izvh)OWLVUH_YPi zoJdz~91fTi?Ec5H>9tR78}2V9IosoczCi_e<+<~Je`;lhUTxvhCqwXFFan0|(R)hn z3P|x1Ve!R@?uB9{?hWQ%KFqRkD$ky5@V_%{#fE5Tu*&v>jYl>Q*zvJ|Zlp?_1<_&l~vrlcR~Q!Dc`k%(&3#~sCwwd6DSr=pD;mM}y?6? z<R)WzL@fSsxay!{OqdUawRFfKMVFx zXYZ2mr~9NwhdVPI4bQGQ;eYArhd_R;Mce5M1_xEd=9TxstEXc)EGjtdsqy4hf#bgw zf^Sr3CniNQJMHq4Yx^`Imhvn_F5*fiwos~7SqXh$(4g%u_lf*))r43G8p^sehkbeL z-%7vND7gNq`0S1O|DV3-u3Dwa+?llR=Eg~I%n`|aw0wG8AEv1QQ3Rg8qVc1v-{?sS zFpMdz>I=&B=py`4+L&6--uvYb&j2t%OWK@4b*rrSN1We!6uOldUHmY+5CAJEy%zNM zYoW{_L>2iQjET?%4?!wl>1M<)KIrRtxWYgCvC@&hJbtvIJbR-ss4AxHc@d0@3ISL6 zbCYxBIfs)MFMg78g}lQs!CSC)C2fUcWn&`a!S~{g@DPl`kND3NKEGWp{w;a|nYfa& zcNh!jKJi^iLFrgcGOZadlsNQg@9d_k=V+NFJC9`TJP~%3W$pXX##p*nQxoM8@ppJ; zLmwq)V(6@SEJ)M)IKS`0Af!n_rNFMO!aSB(7*9*0DYSV_b6uvX)_!K9bSrLkRnxw5 zvle2Zn&BfqycmNgfw5@cK3$XEKb)#cKQ-t$KP&U^M5Hz|;V3hR2XU|UR%SamTB=il4N`sglb z83mZORANzXv0^r43qrn4%L^&V8EmX)z2}ox9e7|vK-^ycSjf+}pk+6HNGW@~%X8tX z=h4YtQ^PA2e@)F!eLE#b=%5>AJj^0Ko>;&&lgu7s;~BQ$h}y985-A&aA14q?L{yU$ zM&I4|F>)NfWS(-#1?riQzns^MS>RmUZE1;N zeq51XK6TYBw99%yilA-jvMzJFDg>}}bZ0SqZN8G5ZbyAJ`4!Z+1e@**h3Qo^@=$`G zzJ3;5kDZWUmPPc8vBq9^#=ytPrOQ%F`c_7lMH|4>Iz%W_-YfQL18to38gq8B&?4VQ z{I;JN6YtWrVK-7u`w(W7p>a%hsG-B3*IL$7H)iESy_CHH%b;a_HIxpt!cUnM9UF6fnFTa9t~x!abVLbLG3l?rM1e+hNC^);V-^qH z^ayXDCzQ~<*qVw>+n%?Uvk+E*k{{6KIhO7U3YRMX8t&;&H) zXjPL}B_~j5Da$dzXMN^g>Ro$X6Mtxo2*-~28m8Xu<6tv2#5&rMTGA`$B^}NbfsKEAR$|K+9ZJJ7L_oE?&@9bM*p z<##WLM>6cCZQ^rF{~Cu_2D*`S@yt#%a~u!o@m-h`;DKn`r=NYpbxUl-QsZECD@JOU zfE1c6y>kf5!u(`~SH#Y)Ue6j^Q_ELyF48EVu~NpxEha?(>dJOe(K(v&dY%QGjcLCN}_&blA>*2oxI2ONjOI}$~T0* z%W)W*2g>}#+VpfnM6y5XD8ob!>E>8T#(sR?6OnRp>G7hwXzV>1*&^kWvB;>@weBId zdL-C9DQTlz#^M?z8jY;J_?n^)32@+Gb+f{!__FDA>t0VEaa|nEVsrE2^L%6;kJ!0{ z##!yk(W(`N3TK1WlVmvCf3?alp$B3s#msm0k>nk;4sBOvrzVLD(kntH$N9{hk9z)!%^v$p zAa7OMzePL+6{+LJhC}OOx2`nfg^{Qbq@pOCF4(4>j+mzF%V@%<3wzA}TYffvGRLPY znbM+bYGM(_mX=2{AS0HtS89Bm6O$h^?>hFG2Gm91%H|Kbs6bs~KA35UEm($zgJs^$ z9EIbeljMj+dSGbqcVI|rn2`|^gQ3~tMRd>a?uTYfC7v&;o7gr@|B3h#BCPaNZ5A1J zAWnU_?$49W^}vI65M~`&0rOrR94rE|(z(1CJxUf+x-9}`!B@aI-dV1GrLf1s51*av zEFRW>EP8W6!t$>X+04TtTi*n zQPyqV>Yu{Mo~mh5xuP*Z$z1REuP+yh`0Zkk#M&FJ;EMRa%g;E}mQzKl8g3f-5}d?1 ze1=sePJ0-{sFEz`rdKC&B_EI8m@IbGd&won`&jM$GJ`w4e%Qqt#k*C)#S;^m?q z9k=M-7!=lBwqHmcIn71kZ*wpfD+cShhamnmTE*^(KB636g1sr&uvdpAV}a~|yP6;U z%2NJAnnMi>M_4+sLs=2cyeCBxy zca3azENXt2eXvsMX|9^4us){igXaT~vxgV1>6?qvUJOIC_7BF@$V4Cd*DNZiwj;jz z&&R~KZ#P^B7Kwpf{32g)i|Cr;sy{4J?_03%tslUEH-LheDU{p5mT*!$1SeCUA1|cF zAznsie`5GZ(nvlr!@FG7V(z-FMLn;^&#jyiXMF)dMNHx8HmAd}-YKdacZhGY(&Rx7Garmjl_Pbbdd`9vwmZl39vy2@V|04 zNm+#x|CsGnF_~-`fST>?C8=H1th+BF7?Gv%Z(AjeZOr2F!|!_urhXvL{}Ya~CeIEN zHT!orxfnM|kv$Haj+k#I4mzcC*hpm7Zte2MI81qc-8}97a>uGw7Rx;zv1!GF>v2}& z_4+T*>-9R)skRP6*`v7}LClVyJk)Ri$Mgpts3=xtb#R-qJU+jyHJ)an9ZGSGwPBWa zWA@`STb&lOP$=b;+{W&+(+ALk9wr)4!CZAM9tPsUP`ojDsiT8oQb;4tmf$- zW%KwhwxuMO<;UX;eWWPO6K+yH-rJ1)AdR8L9{N2QB^V?G~D|%Fo%ttcg!hB|dx%2CZ zlLTELDI{KzDjHQ7)jeiDZ4K_#o>%XejYol!bo0N}0?I*sx2W8DXdVUz_@M}Po>N3r z9lt?iw<>BH&3W-NC^fU7>;`C(sf`hNS&W!>E3`$rF>zrH#0d<{)Tn6cm82+86{VQM zdBm3#S3>nd@cXP`rR|q}=&X3I9tD!F}v(m>@zoVg;764XyRF=RfnXa^Ev)XtKu zab6-TGYn1C>-zqE5UkcJZA>;hqDoLspr{bErG#7e#{UgloF;?@)cu!H+f`$vrs-X=Z$I{xTO+p?xBxfEizoy3rx z4I|*cc7Y}R9*d4%R_?livJATy)>Z4jXr#Hyg%SL<0)@5i06HE$iKVLVHGKJR*kBZPGtidIcL7(|>&_xmF=)$Iqu@_Mynj{=!*iBZ zvkyxOBG5ZYTWS7amD8~1-P(V0Y{uMvd`25dq#dvjG~4;rBKfnK4L&Tzgw#hX*<1SM zDb-u&{*O0$A$kE<6aK+)xdH1+9=mz&Z21AP-BdC}VqwzPn#DS?VOV9FiR8@_|4Xo7 zieO@5wb>EB$R@9E;YzFOveG? z3}`Hcc7T1|gJv#Qq%wX`^H=_)hRzgT zq{t~z_AW1aYIsn)$+=QzBD+y9km^87QGYEq*n&}ApJl^#x<9PPl${$UGuW|)7i6vg|I1f8x`7x1-o&P%p%{WF ztLiprMgBWW) zW>ZsfdsHWb4dW!e=+wLS59^7(O(G=2{tVt)?|0~2A_X^F z37S1*67fIq@bvHZ_hyFI>Q2vXr1;Ny_#~qAouJ7!DF(kc04YR!R84!s=vj0&H#=#! z7)=rA$Rvp$dy8EW<*W2>{9<&FsyL%0Giiqe9vwjSmMyqRB8+wp7Y|V7omdLt- z!FA=u)BJ9X===04Rv=VD+m1Y>yXxq9zgS0dn41w=y38a-6ICLn0sdJw@qh<67#Tr1 zxs25aXp@l^Bh;_0=io&7mxz}?96=PlJRW_MX>^EaCM3;YwEw1f$;mz^V3`5y8+qgG310_^ZPQa}bcry92f{OCU_pt87>~gH;vGJsN=!EhV<-mz7sVP#cD@wzs2BNy7&O(X$9A!j60l^)b$Y)MiDB0FIGbc z@#*s^nn+W`*b0R9of<7HU?13&$N()#e5j49QD5{TUdwlqy57{wrMPPr6n1hR$?&+H z^HsS(uSm5(OAoe4_3|Ijdq?>UnlM$VvT0_4XJ&N0-63K2eJ+=AB+x-qH!9BcKr50! zZn$E`{8U{EtaIbXrg}IE^?N3Rl4%2prY)em0fnXm%E~2`%f2e*LjzZ0E(#*@J#YU) zz(zOS`787ogJ!vPv$T@8?2AAd(Yid!24OQuhRrhW=W#%ZE50F)%*KQaX+2n+7f_|} zqNI%ttk0i^AH@z}$>0&!dp{kz$z&HtY`Kvh8)dE#q^J7}?~i}}0lPru?HKA!_f@uA zK|vw8Mn|-;4J*JZQL5yOO9WkdzSvriK z*=T5ECH(KAAv*VKnJn;JLL>0B&UaWsj%e(R0Z{;pns=L`%Z8hQgBj5pFvg$O?i1DBLP3H8k8^z;0>(5_DMAf zCmjqiR6jF#Id1d(L4Khvjkah{46Vxxvj5Hzw=lh4+hcgdEb&VicGX|6kS4xjGpkNaG3Ybsi~UP>w8mL9fB zCC}61&gD>{Fb1d5q6hkGq<4$Se#L;8VUU2aF|+l#(Ep?9n*-zgp08uuW*f7yZ8vt4 zG`6kA+B8izNn_h~8ndx&+uXd{&-eE}|1a*n^UR$&=gbV>(*a{%Z2?^)%4ybm6!V9C z!r_e|Zazyo^@B_-()qAxNl8BuN)MQN8!T$}7^A(ksYC+97Qs1IAug;`SjQ0Q{Frla zHn|>fq5~y3B7%!pL+e4`Iy>8s*C*~DFaq}N3DyWDa1el0TA z==X9aRvO|-8hwAqb3S1%S&!%>90`~i*_s7FjQ0!zZ2}?7aZy#(XN!Op;FQRTs*d>K13Y^p2N;jrKD>}T= zf`@e~jv2uwWS^&zWF%wjbmFPg;amG|V%xB%wRTwae|)Rw?~-w`BoSd^goP7{Dq-dy z%k7)%2SnSU2N!$&3ac8mygUJ93hbY<=gW*OW??|8nvAEi-!$IxMJhKs^PmMwmnR>t z3pU&#+7d|SrExrb%HZcp8HT}^+j-9N{{A)&u%|5IH45x%EG4?|~i6I8<-_|yCLcmsGs`_(c6*s!+l}o>Ev6(-A@(l>{ zd?=4`j!nJ3L`s!Spy{$^XF%n2Kr_y}t{z1;LApT)W8_#dY7CQaHL#LNmXx((U%d|w zZ!tV_qFog7U1)M-C`huuBlk918Bh_bC6qEPn9*}e?7#4bm|<+1CeVzc@@y}4xZu#o z*lRP-ryD%bf5LIz6-)*4*V5)u1NZs0l1QsGl1qibFxq9gExzPlo?D($B}1$ z06W|XJ(rt=DcfBWV(R;#+xYW0ZkBi1)(#P9d=^3IM2E8wqs~>A3(713GU`j5Ng-%_ zfo$!ze>iQ+RTyIG)WM;{AfK5E2yLUKBO?}JzjRf8T?EaHJUv>Z>(Xl?X7hI}NA*Qi z4)@<52XEtpCJVjR?%)_eI5kS7gPm~pQgJY7w$N32A9Jp8j?*=07eRINYFT$n`Ex2E zDd{>zp}jg1GIFiQxn2gJIZ|GJ-k$x$Aq77WZbDwNAELA+2_OawALG0gfdT__#QswB zy_BkOZDdR`=f3~Kw8F=ZvF`C;wA4ZX8}kiE41D^I;L+jWDa3ci9BN4iR=sEn2-05; zp+EnM0zl#=z7Bqyp6;a}ikW#R*adJUSwXqQgR#+;EKyVgh32A?^-G2m$110v4oHnJya256o>HZw?l zj$zI@l|=Kwz}2d4Qh-V!w&1zls2(b65RNq2WhU-)h>mVuFTM`;|yz=~a}5ydNLMS|Ubf=H7kHW_k&q zcA@)za!Ly}H;F-r6)sXz(2#VlUae&+Z8aqDK5lOxEvoQGs8jtq`SYzmLx|{5SOBHA zGBr#=pd|jLD|)g5zL)wQYz*qQIp~Pe@$69q?~C+LyXn|$E?mcDz4y;1da)(gPtv}_$kJjZ6A^QF zCsM`plQ^4yK@o!5OO$r}b@d+0%A z_u-X&$ETY+ZOe9cBZd%%taTwa*BLdvx3jb(U#U&4%AXu%v_F`q*Ij8xl!rP+d^dxb zTbH|9PiYzWdyQg26ung3U8TZpW(~%W4Niy?<~nZ0H*R=&D-EWJ+Ne)1E@wn8^=j#R zYs$^ss$P{SK8pb0%VKqTgQNPz>3J8egBueKs8D5>GrS0j#Apys%2N_nG5>lq!G;RK zqERmw_`tDYIH4d{>6UGfE~T4a^(XPBqNxFoo9FQwK3FZ7Y4SwjuS`IGo>+*H>!9gy zP0^`tFm{B=&G_Kq^Fssnu#2ZG&mom-w(W~5uFu=GTP)dfzw-n})U@ZFj9318NpJ0D zI^85nE7{^czA*jNMrBjdg)MpdM6-Z`AWan!Hpb*FYMjp&DMurrS`QwPN zLnUN?dH2>Tkl7!c`lT8lWum#)RLs7xkj1Ys8ZZ)Z)~! z)(rOXA{1C!CA;uS9RuI4WxOvYT`eY)o0*NfNWcNkzPaPfDKrT!^u#}G&fuoa?Q=Am zxvr6V)qeI2@W~7b!OCwbAv>fkgZ?o#j765Q7;(Ar2x2r|o66ZwP`RCM`t+D!z?J~n zw&u7Ihh#N@QTs<5lv*xF`rnz&$dzJTl}fFMlR6s>T!Lv^FU~nVu3p~=3Ri!C3;M~4 zVi8ek-r}2QMX8yW_M(|60T_NA4aC2Xx|79S)})hX6#JKk7Q9+_tkw20YIxvWuu2U? z*-SVV){vEoZzaJOxmlY@4#eI4r>fkY9ex-aeDZg?Gy$cC2cW+oBmHI&Zt&tHEL{Rn#$--aermb5q)py$a z;sovzd>Y{2Kyf{RWD4YjeGTM~mPl8M%vi&wnq-+0Ujj@mVt za2Gr%34A0rh^e^8{idB-6txuFo$^SNh&b!sbCmC}HmlSiZ&yp;+&}n$sQn+#n4$OF zAnAQvn6j7Dq&YvIDiRp5UZT1Uu6G13UUq*3c>DMKfJHz<`Xv)6eDw$VhT9Pt4H5W3 zal*2b&D)o>I6&;;^8eqDzcyf9((az)jjL+PjH3;dv;m*2u=TizPAqEmg`|@XhJ~OI zMR6 z)P|I?PQ)Pi?_U~dM2Q>qUA79(RsK)E)gR5CW0ud$b3D~{I<$&sM+x!XfP$t)MR;a8 z10qoQn0po_Aq32>?)%Q>acxj4qxCJhoor7tATWH^%`_SCYqTE7G^sq3zZs&=#@#BE zsc>Fm(2m>fZ?ItJMR%1^o9eHbl-?>KWL7=eckuc^F=Xg&zw|95Fp!*+-{#=^R*DQ7 zPv#eGd_clv7NFp$DL~hr&ae%W5j0Epn@tX^A2R~$#|*PMOu?5P7?b4*_)tD$9DE5| zWxpElBH;FKCkoM ztv*{t=yLx(!`0&*1yfVj-xT`6oW8sg3owmL`z?;+vo;B!E^~G2}xeXGx>CBeq9|DE8KlAjQ#HIFQRtTNn+&M!CqJX|IE8s=&vr> z^Hm@EzAffb$MZq@zBw)Co8NXA{+_LKdQ1G4AIfwol}`eCw<(4j)#FbM>y_sbNWOuS zBkvI-5iy*eNulgQ>izO6(l?y`jGQjTD8>UQT-c2bFnoP$6v>w?ZJ3GDd6Xu{i{7`5*K&)G0WyYiG zyNqb(>!Y36qtf$Oog2JxPN~Q2zcFf>IGXTshgOhj<-Z&G>;<>b-MeL}F4-;YF5si% zfis;kt6v#5s3arFzS1(c!BuBHB?lHkaDnu*U~2_kO?s!bxlIoP>eE%`vGI~XO{9!^ z2mwf3-50$lp9@{kUl;1MaZL{s!J4@+(YOqwa?DPR3Hlg^-(x@PzTtmCUcFgeRjsul z)&i^WK7o@3(x``uqNAjnA@Uem+V%mK_jB%d0XNGN>-XtywJUWu?)6yGF%>vEspoIP zK2Y>3j#4&&(}+s3@zm5o$Y8bisZFjYYlcCGV?H8bumSCx5Bq_6q6*K;>t1OZxocTW%0LkSB-Tg4bZzJbGZ`Eu2hub^~*#@zhpc~lzXO4>Ho!AS>_H%@Yq zA6%Z*18wo~+mdaVn#&Uk^mX``J&uo+eG?jsNG)(eA8Z8Ib{lrTjI&-Bch|aeXaJ5o zg30UD{(Xm#Qz7u^rq7PuBmdabo&nc`;jteG0Tvb(qpSV)KU%82z*fO|cJt|34+i?d zKON0X4%H_@ z?zxnUAvVJ|&4p3zQN!?4W*W~m5B?g5tZ)_ZP-6tRf50$a99^Os`hX}cS_1%@;3p?( zyn&Wj3dp${m#*}OETl(P44=#ckm_#q0+Jk!`(oELN)=TXPGo`S8Rw%euH)uQw@W^D z2KsQNvi83_j0I}nYWwIe$OasUOLMedJJP0Db_B)E>T~1e;~{wZ-YRCA%YtqT-TA^g(Z&}rokg{kx&pNpW0Eogx zL6CX6plz%xM29`lvYs^j=hq;pMUQWC_rZbR=-kd&INR(~g zhj|rN*zGz3KZ71;gbOa2B%}%n?>WHuPTa2TqshJyW3AmbdlJ{8Dt+p0?R_Ta9)7eF zP;zB4n$)-Uz;$t9jE2s9Io`8s=!Lvq?WbYLO4>_zC+fi{QBt9~*=GCcb+g}DT3 z`iR~iFrGx6;LusRU}PAy3pb5t_NZo2^?>zS=#q$(CXR`@>vN&{W4w?#^vMH1Z}^^t z64J?@GA7n_-Be1-0+|qQR9^Lr2-5v_tqVUYm!p?B9C%abY}H)1Ml<6rT6Qy7+Q)td z%9TB09>qo#FGB0v`#mvTq&d8Lbnr+nK+QSK z+xwc{xIQxsr*jbA(7qmdLt^67Si*+!P@bcdjLhx`ZIY z%_j0gh{9yWr!j>7xTxU2rhN;K4_jb82Z}H&q8$E1I7`Vgj5HZ`&*Zpf>(b+9g9H9s z#iaK0vQ#eR*YiQZag;L;YKU~X^uq)8(hJCFpKK1-IV<(xua_HGK_hRTGZsmJdA0U# z&H!+n=!+avmgwCxntCy@5mrmsd^P9)(!BS_?yPG_iOLxJup!f=i_;l2*Y~~0x91wc z+4>VUFx{^m_Hr@lTUhJJ@5hovuu`5lV1(i>3k%skCotLawTnM?TxprDR*?FJFxfJb z_|(H5pLRvef#kr0fx^rgH30OgcPEn16K>3b(Dv=J!P#4Vd0M{0-$Xwpo2u*{i)}wY z_o%R9B)Yz4=dzSeQ)?Z$Z#adPsx+dGfw32m?y*%;x8QMqFydB+Yr4uTFnusyZ=WM# z$u!Zh`IAnMgG#8V<6J|!|3hC#UVeT$i_PRK=yTR%Wgh@vOMc4IQ4!U z;@Gfi$PFqT^y>$SIZzo(eGwLxOEKh3g$XZ)F20j%=J5egWrWo}T)h4ESiQYOQXyVKRrhE>;E)P3T ziXTAQSi4=pc+((Q4+bxr1yAu$8rxtoTZh2!2xIvO!#gA$BTI%lzZ|&b;%9!=sBU8y zAXsTr)yI0z%4(UjF9_X(;CxQ2s)K0hvFIUp7IpN}qe5A(voZ_72^E_?g%|m}&$qO= zu~n>^8W(r@J*Odx3FBawQ0K#E7kq&Wu~kfG=U$6u9fChq3d8@oy0s-E2)PEzJeu-^=A0q_oNZ)r+>U}7LFZjL>Td_ z@;`sQm{K;~vkZ_&^a%7;MFS-qL7LsmVQ5q@j%05Je0ZV3k-T2HTrFwSMTe_7dXL$*Mset>t8seJHUyngcFqK+Cp*S2jbOk%5mjz z0m3la)W?;S1&(kury>~&F~d!>RDN(B!!l2*tYaBcz!@b*vYF5K{5ac;Z#3KZyP&Qj z*Bhi`E~VDBPuIcKKiYK3ruF8J-Bb&#VN@!aU=e-UQF?l=?NchK=b~W9y?$(Y z)3M#W_p<|yx%m02zmNHx@l~uTW=7YiF7g0(^xHBaRX2~Wrdkl(gh5ZcOSP`Wewbq@ z0l!2r;xPPaheq;6%5Tb@O;sqx^TdC8X)$pc$->k7l%*7;m<`Fmx4jRmXm=t1fXkz+ zlq934P`>k3iIkFM{ZNV!-BZAA)vTF|-m=)mF8kR+!Kc~qq>pK72wEW{CL#|F!Vn^k zjq;Pd%ea4ho{_xNjr$wEVZ+Sn0Dw1z>%#U(X@xEwyDAYJt4eZwT->3eTL}6y1<`Hq zM{|Po4~R79&`oDDmZT-=u}kVQ3|N_}n)dWkcgM#I-CGtS1^_}4z0+5PLF%M|o$FAevHN;6qW6Yn_yBs-qIkRJ$h*K>xexQD#6 zCc}yM>bpNpLz>?(V`3Ae7ca^)#98mA9}dj?+r|KR%2`P?S`*?T_oOG zc>>(Jpa?KI!@j&%6hhlbu7E=o#d~=w(%CGy7*yM!mG!D#yqN!(WHcqax}s39wemV( zq5;%=v1b(sR8?2sy?-3y!!IeFsThYn`9&O3lFpVq*K6UCD|i-SiF1$1jEAFlcZ z9S4$)9gHU-2oF-_Ccu9F!HZY&*3l!ELAzw9Rk~9mo>z2TD@w9kkWYZ7x4d0Ze$yg2 zR{F4dqnMEx-EaY^cq_Aq{g2+nK3ADp92GjA6puyYBK~`mu?&)R!!q@+exK|6<-9=N zM?BbT50ur6R*oqYKS;u zs*W?qBqPFT%t8!-T?{}&`bmcO4#Ajj-qL#<|1DS- zBTYV-@e6gNa$%m|-6EgMfbhw(Sc!igHrw%oWGE-^Ku!Kr;HvYV)%qzy@#(`iv7^gh zXp4tfuT=D{+qNt5Br-&n%hV#DS32%hdln>r&NA3rKF#vztWy2D%OpbgFCio9gd5^M z5HFw4`>?Z4$5(D+n#Vf>*Y>Wg05ae@Zn3PLn3Ib*j+>K9-l8>H2+IK@u5yu+Et|U6 zqm`2D3f5Y%6-u$;h$<*RnSxW zG{}juR~u|_0V`e`^FVKntV|5ouxP@&w?wNT3-Gf2!OL#PrgzemFVojH)uX61qE3mw zT7{s)z$nvRD4EYQW53>}Jlg*PU&wb4!Od*_e%-HUFK)j-64R>Yn&~zkcM+xb0j^*E zi+GVE8bWlP@*tL4ckoSoVPWEJ_sTGYy* zro#{HLdT_%ed13)!;h{gz+lb<4Bxzz3|388aWW`u@ z!glwTvMwy4=V(>pA|+zf)M@~8INGv-ET$G*9|Esf)F)Do2UGputU}(vJiMAE6#&^( z_+n*6Pp5L@_s1H3e}IiW_b1ys2gcUCSLv*ID0OTh+frLFi_Q3#E@krLt(HA>pD^L_ zA7?$m@Wq&Ztg4^HI}KtQ$L@BO^O`DMLKFcy$372vX!yA=0b}Ee_#5kZ?+f?Dr1#n1 z`KRNm#FUTqHWCrR8r*hIjoj@gH|D$p#XraD{1kH-8^j^u?HMBb=G5-(fdR#(W>3CD zv}zadvh8%5&}(%y9gl=?qNS@b{8iF7duxLMNNz6=huuL&X&3NBogLCVuSTeg0e;in0tiK(v{G( zUqpPLQ@|HkKX(i%(0iV@Ziir@qXyOYBM~XTAzpINkUL$;fvu{nOx)bO(3qPn#vkP; zno2%bFoN4`2Q5)F`Vz0Pp7x=fw?!3Kewir4WWkqy@)|+v6W;%9=$y=9*?#JX6GKUZ zO0!A?YhOTpt0|a;ggT2TzThZ)2-_Dd1!a+ys>QFj){mBVeyT*(0con`Q&{zeL1TbH zDET|!JLWt^p2@%R9t{TDVx!Mx@<~!BY#`ys<|+Mx4o8E%F-0m~G2tEvI(OfwMAQAG zXwy6|b|{Vf`P{=2+5Lqk?9K}`=8@2mem;Q}@dA{GgN#yB94kRD8D&K0 z-FyTtCQF3lL7 zidse2IXZ42=)3tczFVy<(W%QC=K;0-Z;{5%G}TqQT0;tPtR$%$#1C>vhWDQywWZ@| znp7V=&tQ)_R~gn1NBxOL)@Wkmgs#yyKK@$XOj0uov$g$pe-yPbZe*{MtlE@JmC|<= z@mY^G^G-mW9NV2XEJA+m;X%_@LsCUPz;O1Zya8xKq2Z;a@%m!#i8d3HK+&}}1kdq&} zx$0mP0XrUSDW;JOr*!Sz`@XLK@A`L3aL4J5(~wT;)LgIel@rrtKV^ zB6Bbc1;n%jb&~$7@}0Cu6W64D2udRWY+?-}L~&@a@Ctj)hfLgDYtnLhVYrUA+cGxDAMdAb5t@5|oc}1_Ft1hua02C*?U9 z_DbnH;`RyE7JI;18j+cE{#&}cxLL^FWo~WB!nE8ldK5&7biUdGxUYfFnisz^`LPQQ zd$Q@|Si2tI4F|!-LRA-&eeht+sau)uLXCYG#h(P)e71RZd@DDX0zs@K zuttwM$9B|aKY^jj4UX9~{2@r*R>s<=)y#;1_3b%I?IAC>g-)p~);}}4Fwi&#IO!n$ za>Jy7zu2;lPjzA-DUr5p(0#phbU$du&f}G%VM0=BEods;z?!sFxn#cYXT1&{NUj@2 zH(92Wg_&Rpj*PWc^&M=!v>az3$rg;<58kPCVc?L`y))NU7Fkn0@gdF@!L`DOj5%** zp34f%tW3_MxaLbJ!!;&DMV*J>rSSh{GA0Y!Zb2=tv zO~Yc2c^5@&jT&WVZRDu4wk2j84ZRJ&JmMg5k0Ayk(|bccFLmN%xJkEhK%c}to_E~Sma?K%w1-c$%ti|S@! zx*LNp!TK_Ko{{|&fp9XwAKy6g;y<{hJ_81YdjKLaFvE|txK&(9bbM(y5bSS{2v3yY zyW~Ds1Lus7CXW7iO{BZU*XOK9Zay%g@dKNF)PVMnQ@v1USq7!oQiYv#hkeUAmvL)Ax-q4ie z&q7!=>fsbdJ)_#s@P)x)R%V4}l-!PO8t)Ns?G{~2lNU*R`wkIX*jU2M;VqaZb;pK> z+Mnkt2I`_ZdpUyuak&7Qo#OLY+-+b|n808ekL zVZ6nc&wd(B#~GO&wRKodoG=5XJ0y-j09^9RWzow04X|cE{d`nIo<--uOq=g1OvXEH z%KJ|ZN8um47im{++XUBdZU$bLbg^B2I7OYDr1jOvk8Et1|MFzRgHMfAo`0Re61>g| z>ZR7MHZ^U0!yAl@*U?WI!aQ(lh{02Gj(Pk{7(IxXvZ(@4mfbEEyWWO{mh>QRR=|r% zn{nXQvFL9k(Dk=dXHh<5{zV)Y z6`4jo(JWc~sZozw^Tqvd@^zkbYtup~T?}qD>=2c-;+al-$#~LArH+AqxTE4eAZ|{` zOD`*v5olTe&z(Hh3f`hFoUhOpXoIUt8u6v(dsGB-@>*hu&qZ56Zd`|lG=1G<|7s8{k?r2ehM zER5)SFC&K!q&B6}^w^h<`fC$1Zx>cN8oR5n{Oz`# z{^=RSwRE@O@ZE9D(u^I`yPxk@QBxC~rY6wEM+`inWex|*CLOibhPgNWh)bVdXpjER%6dC4 zB>M+gjE3RQ$jX0Y&_z|4ZQr}nsHrqjT8d^z^Q7wmrH|i&9)M(mcmY-JLtqLVpgI2O zrsmhTRqO_()4*Pj4Q>{K4d|-FT>WaZPoaIfY@)c_w`Iv8xiy;&{%+aeRrSKK(g5>< zEF^(b(yo4R*sieiU1fZp9*5imrq>4r1%I7qf4`}Wo;&v||MaKJ`sEIFg2;{5FUR?K z)|w5$Gf}1`8?|vI#F(YsO28txxE^I8IB8Mroa93#Y+4(S)`X?-v@h6o+PLc5CyWrPiua08-Rk!4AY|{Y^HdGhY1%i*hx? zGJ=eg(IzQfD*r-MFeH@FjbXhh747AzVZ+{CB*wz??oBrJ(@Vk--s6N$3n!ohu{+>r z*e?c88G28-HJmbKWCOvgXG}hY*iYPRb zDzOFI(<_DY4ejI1N;;_*_?ca!F|(_BLYu}9a$3oDJ=R9)7hBf6<<Lr|^8Oxm;m4R_4=n%uO(iIArHa?qqS=>>a@>gl$lNazd*@3sHM50zOUtK8{%3TIV z6jd$w=CPitU4Ho_5Je4g%4%g%TE^Z);yzrXqQmubfIkna%q)Ydp|v#|!o*Ot!T8}BP#vFTlQc+TeXwW{sAqhIXsQVnQ1lWv?rs|f>> z3y;7m$Y}H7nNmR9+ndh;DYCx!5#;O8({n^u3W76733^FtK7iCL9luIaUw8b8KRe`TPQ+cA-^ z^*9JlqxgxFE%$7xV5;%0Cu|JKaU4}*c}j>q-Y+&QzAD0?oMLBFIOEbo-eBm_HX*o6Dh4M}Vu zSL6>H{R9A!XL8$DB2YaeKmk|5z1^_tbnqsj#^cA3GgS}4u0zV(9h zZ}oh%Uezov&^cY7W}v)6TwzK|N1gMkQLjFr5+ncj41=3p z=<06=pxHG_#|?Mo*61;pjB_#QzsCz}z)OUhH85Z%luuwl;D&g^S>Lg7v0E_=9e{Y1 zHv0bE6AW?GPzM?4VukAYowZyFToL7-Fo%278{fG2pmHWIq5p4H;55arK~dL6wjuaV zHX586GXON{!9QVD8b!F$S1T^LCtiMk2~k2YOubT@IOjuw zCFpB2HI(7RvoNzJz~sOb%z_sDXKy*(l1eMir=YMP9tL_pMzAFK$QWj};Ic4noe7H=)B#}ZRLL{M%2d(e#i z@&C`fQ40(gGtoRkPEEC_KDT|UA7`JNQMu=3Ub~d>##9?RMHzxk0BI5AOph#H6gb0_ zOx6x$w~=BVxjg)F%0eh}r-E1kh`^?T=p>W*y zzF_30hd$M>$u0X^oJ&CY4;n!nf0oS1!{)Y+P7J-BJt*q%F(6*;Ugp4b_%3ZK;!%+ye`8 z0tKqp9i%e!kTtP86;Wm$Bo@FO2K>SxRZl!l;M*j(6k=iKj#eIvDYAxaYyxc-7Ucf) zrzj7#lnP;zt=xdhi%|w6zfTJc0!Ay_YtEYXpB@}fYrSn78>C?S`nL&$MxBjm?`yt~ zcQ9h+&h(vW0(l>H(cVDunoppA)cM7%Zqzt5cm4eItlGSac zyA|9V4%~5|HPPF=N)3E1N)j1NK+8*3ai&dxfy(g@UDQWiYF9fvFUM4LE-CAmOW_|9 z;`>3`>r!vn2^ijn9h9^w`&|2aAbP{)3cS#8Zeg&YkhTdLC8=n)CBFflPYvwE^2ksau?o4oNWqkxt~d2mlV%we)H}W|5t`!81Cu1fM!0Bi|D1*HWV)*?WFk2GkHF zq;w&Q_`l(S>f1qbAeixw9mH{rc_i%_vuM}H?ZrpDomqQY1>#3@O(A9y5ma`|Zxg72 zy{(BfWlD0?enu5(ZHi5Do@fCzf%U zV__?j3L$b5mrXS7Ax6 zs<(AX(bJl{7?BmK9$#U!)NgcfyOa^O6N`@Lk=d4$JD5-n3lngAgqeN1(H~fBpq+@T zmDj+&?;$RSK8nxQqyCvG`E*(`W>?RFeW#Z~TMz7&n6JgOwOfE&Hr_TO-Bm5q<>*dc zleod*@~nR1TiX2A;z@<-ZsVDK)nK=zlq7Q77Q?oJ!x3~!syt<8%tIj%i&4rLDx)%q z3(2m!>)%K+L1-S456Y}gPPJA?|9#$ruPg-z3sj#>1gm@wsF^ZOFW4);MfME4I`qwc zydZsm&e#n^T-i)f$++#3EOvs%x=0!Ec~XB?zXiCby#LM=c0~oF3P~2D@UqQ$a8kqe z)P*u*ChRYc>9Tu&RFCf5D>WtO{Uh-)yrjeYx6PJ=}JT?+9JQ7Yx;}4umX^nTz}#fLj%UnaR;`VIH%FvHGq|LR)Vz^;QFA^FV$zR*={kT(|Xd3i3@3oy)?sO^yFnbdU>_S=; z?k0MU{IlfUyqzcAX<1i0Q)tj~IH|o`W~oKBY4K;uJ8&rOZxRo4+ml#_*Ct79JhV$Q zOAmjcM3Kzbk2p)i2m5_zX9?H`|7oY!H_MMW!1%O;=BlGSBA3Lz1a9-p_+S!IV( zjfLR4yE@#kqC^0=G5sDDJT=6^V~!9BzJiJEq{7?YCX$KNVfYU9`q^|QKYyB4uS+K4 zM*2-1rUKT#BtNBf-KKg~TJlrBkvndYwA|3RVfJo<)Ug#C!bU1Us`@=z@tBigyMphE zDdTt8z-6UqQv;62icYM%on5E1nX?|jH-Q#1fG)u*S^ z>mAyUfscZ75!P48&43%I11>MD1P`?~`|FU@`5pgEEaHxhNf8h}dAA4tM7ao?T!B1J zbEk_?(fT`H7f4Ods0~7!j)z#<5b#{>AL=;Z;ho*xGlX0<^yIXUmKqbbb3Ne}BXP)Q zbP8;}sie&|)~%K)Abj&)rW(&Kv9mHU7JTuKj1=T1y#=MB2)SIJ{=lzY`7GnJe8N-X zrC-R4Vd~-9X?eo#;Dz|HZvJaD9g@H&xvrM^rfK_Co2>U<+aOGz+#j7#bJT-eUhspZ zVq%pe;6XMc?g z)5sF!I|zDdaTdqJpIDoIi}73IlxnnxvxVMk;1%Xe{so2Tcu!tFJv3?RJe$$)u@{8X z#kP!k7Xv7f_#88?_{}mWCcA}t9H~yyiqMEDNI{BA?bq$$Ju1Z&l}o-2P`G8P{l1)t zzdtoDv5OQ-hj33CIq5-}7L@<$=!<(`yw~Z`A%-1I18y})?$tY z7{xb;lY&c@h$cHd$qiOz^DWmy1d79Rncg8D&PGI|_@SUJHiCZx+MuBAbzN3^ z=gj7(1_1r@DuPjr2CHk-#XDWaED|F1E}I#8Fp;mquMD7>Z-4Bm4!Uj_E`&u8+t$`~ zo^R#t#>%Acwr-ssPmzg49A`eaT)qV$Q~-sW%k&~?$olr+uO<&2dt*P5y6~{}?F@|7 zTzjGB$rwe^Zn}X2=%385O_@NSae<~>o-uABwOLe~D>M!dh4bC$m}&}1${fQR!REfC z=|o>lmoGHH4<(&VPFq0-DEk53MZ3cG>?~?`n8>q@*$~XJG5iLxFPoyi!Aj)wh=*|2ZN}8F-5B z1BeV#KKu|vr@CRrd^uBo3=iN%n`)ai-3xyL>{LS3|2-gqJhN&n zE&UcxOjYIx^)eKtUI4X6=4NMY2fy($27H>uMc*EyGFL}NIiwYk_D{mi|7#!jcZ3l* zyBsd<#rW0Y&+_eMZ)_@7h3_@qn%`u-*ZaMt^Q6+^_Ohmw>d<(9Bg-@T{Ab(ivkrZy z_za&bG=tZvFMIOE>Fj+G67>gsre4n?$7Y=5%BU6fzDR0q7k9(l4v(vSI%l71` z|G;VGaD-BNFCWsEN1B69}YaQGz8z$$oG3Mw@m|o62 zFnCzqlQGtR_&^6@wC6uut7X&JH~D+oyyK|S9Xu)Q4?VdSz__vTmHs`zayyT2C;0X1 zv^eH!Ih@3L^3&(infHQwgBnmv1jrwxDhRV2s4mIRQ3O5t=8sl z_=K4cADtxvq+@imyY`LZ+3oR`$dP*oPfT@zCo{Z)!xN+esx=2jX(U4Sv34(iP7i^# zju|)yaJJ=OumRMGb%z3@hzA;u{1#b{0Nl269wRd=zifM}sF4fOe< zW9Q4W>+5N{KoBPW&bTn12FVlpMf))&lb0jrhW-_XL)T^C%yanNYo;&ZuR@sv`=@Gy zfWqX+!&0dUxKgIqyY8i>1HSI{GllX%a;g&qaH%-3FkDhV2Q2O6qt-I9A*_(s|1E-q zut-h!Yj-%RO#mozc&Zg?R+b9wRzL&MqjcuTAQR|8@Q;Q6qRoHM!+GZfBN{irHG`>P zWXIv3ibixOnI2FKg**COC2SyPe_Hw_->hGOl*0v`p07+C>f`|B9AU#JFcVwt^am-m zsIB}yjXf0={yyE!XuruefzO1Y&i`ZYEraT6x`jaqmJr;X1VTt~LU2uRcXuafumcAt zxI=*895lGQyIXK~3+`^S33={)-mj*nzFRdlHB&YH!GkeFriwqn366X*SV{3EXAcAwwfkPDgU>BnKe6*A zdMZN9vsq2Y{TERJyqibrM%$S2mt@V&!a*ud4XiObVG6vzP>JdHqQirO-XeR{+90^y zX6Od4 z!*a_bAV8A)?o292-=7^unfnHdZkxIQ%c6t6k9hV@^H|VW$DWH#6n z@O|f%*-Fz|($P2f53I?cwi6M16S~lAGr7lVH*-Wyvi@8^v}!#IZSyUVNS(K*Vzp<0~NyMZfxj@P9S-6PtwGkHnByK}ELdP?3d(ud8r|nd>w75KO|(H1}_I*f#L{4)axpC$FTfHfEO0Dp;P= zaQK8Z$tA;_^7ay00I@1x_ZIMsm}t)&-k_mhjiG65+HhT;mvw!;tHzrOtXxj-T5L61 zPrkR@g}QY5203QbS*V^DPA2@Vb!4A~3A5*1l_eE~s1xL_f2Q!`07 zT%-y$T7Nk+v^;A_rMkDUJPncu26#Ul zY*hM~)Q!;V#``tf+IIpSoH%(Wz0u%q^X?&;PS;N1bcb^N;ZJ_mqfzh&D^yV&KRCRr zAghbAW0^pIi(ZI7uA$4~cF$WVBv8F2h^5>oMllp2_ zgn*WYna6EicFuOFp?Z^(@y%~6lg$G_vXJulBmq04w$7&1L^E4POx>g&?9Ss%SlF<^ z=rXD^rEMJUXYl~CHIJs>i$f@j&S$A<%v74B@6U}mPpG@I(NLo^#bmsg#$|k18Ghco z=uL{-$a3K&p&%QCM&F&%lvrgH1BsLOoc--#DH$$vWxUJPAn z%LI;dR~#gudJ4d47gL6$pY&XQhP`I8P$Ot>gZbw zUIRnKxzN_fZ5(hIKNgK;u1a7LlizA9 z;1xRTI2_sj4^RI{gwF&KWy=O(8@Yz6Y_Ca!+8FHa8QMF<{9Y!ZM8t%4hTn%SmN;o! z`T?umAMw>?IyZO8lqZ2T`n*8(?s@Y=(^0vkWg{^jQ6NzM$-)PuF+3DvsXP8ip^4iH% zq)K&s#v>#kY?AO7CH8wtfxVPt&L;XosF&9DA z)K;+rutGN0?+C9(6h(>}M`X)i#BkF_8)~n%HA%~|uo>zb-j(ip3a{5t#N=~N2ndrf zkKJ<+`b+o)x>|-79A|Q$=v2zZLX%yEiY$WU(E6wM&-<*eDl*eRgBI1M*}x?}i_MS& z@QVZ2T39ndRZuY+bCv-|6X>2tU=4F%0EU2;Wr=74K zpmoj+Or&BzD-iJ_m}V8=8OG#Z5pW7Q_b0)CPAa@V6yq)BM0UOipjoBzPUIojY+xmf zX=KHYltTSpIVD>ILOq{=>=e=v&Nk6{i#mxb3?Idw&e3e$k20>JjvTz3H|LB9poLV? z!zq}VR1jphXP|1mdbXf@lv*tA^IfdqyD%&!`gj#c8{YhROSNiDHL6r+XiKhlWa zS6y)*>MK}CeTa-D@t`J+jQz?OMUqL%kU9n<-izsj6k5Lk@5{n1lCe=`hOJ zh~8V}^)vTk=2Z#vRg*xc63?4#zh^4NDeMTeI+0N_Qk43#SNub9X{surWM%aO#oeAL zaEiFS6c=?xrBXrW9qWu~ZurA2-RAl%TFsDN}O)u(TI{B_aaD>6=a1V#~ikP`TnI?6H_fUIqv+#VZ**@p*pKrVbdHm389t-No?ErqfM=~P4TBuXR~Sx) zCdqT|E%Cm8z3V$zT0Ys~_2Z0thn54K4zJ%E8!4?LQj3GC!N#X*+h*Th$P~Uu@J=c* z=;$tb9S6MnxWFqAgWRx*omRdM-Xbs-w0LS@5u@rX2;`(N?spy+&G5k5bk(||2^T}- z@_4}eS-n2uy0!OZ`}sqEa(j_zmSf7Qud??BmvzTTWAP9wD1#7ZXPcm1q) z`>TZWZ#Dn0$%amH5V5EEBwvXFyfh)aa7c~e!X-fPS=+f%Y~Gf?J;g)wJx&x;$=wN) zxga^JPaB}s&h6j5JcV+rc7>a0EJs!)v{~!d5D;iwLh@BoRP4o#_%IpMB9kx>m>Tc# zw(dJ@?%0%(;a}oVko#HKD(H|WG*I=6Qe5J7x@Lx-Fa#910exqW(Ae;$#!l5Q>YALL zuoyTw%6)mafPE>|cwnVsbMV&uuHbZ?RA8_qFHgW-`HHkfIye=E{BZV7H3ozl&*JbbCYYvGT@G339`E&3J8Vvaj_SN7U;8|G5R36-SgMycO@ zgVyD~!z=a&p6Bo9?0&T|a5{%vTg(e!JO^!eToUl6>+NDcUUmq=;W+2wc!=fn?MB@t z?c_7p<7me-ud2h-TXpM;^rDqE!J_5d<%VD6YKsgq)7>~U^RcuD@J76Mj0^6PP6vxu zSlSKN%u=K5VjWtpZ@VW;2XeZxh({0xTGUq>tE3&wyTVlJ#Am4Q-p#$)^Si}wJSS;% zGbYI>3h0`702n^zA7?GkT#C~bs7!t?r_$prTVy7J_q4TF@`MEl4qftHw(xI%C4*uI ztd^73!NqvKOSKM-Hbl}pp*{|}pQGTweT&W176*)DJcDBkI(7ItE`qPatMH2G7lNqN zu?AfZVO%cb70&0+p_1K<(Rm)4zK8_-3yBLB9NmnE2c@F3E-_tctSHt$90)r8&L=4j zIB&>S89SILBPUnC#t(S!j(Ks1a37U#{$NO5nt9WebW>eU8agDC7{*1@tJ9^aw&4Si zYM1nnWn2BqWc+IV#qYptaxEkWl6D4+YPw9b5mj|)v%Cvo6z*5VJ2?BzKrGVY__;74 z;36Ar^vnDL<{nQOMh*p7{v>jihEGV<=tHbh)I*D_6V`e7>w3?*>>q`}St>ExjLl*A zTy(Ub!iJxi`=c$wwgWIZt#1(tm!9WGIE;_sHOMhc?X5{VJ;CbTWt%M-Rjgrci&Fb4z z#E8`36=-eJk>z;1aiy|*Oa^{P4s+Jh_Vx1lB$8-DLYK@A-vIM6;&^PEAs<^m`2FQ^fG|NL zZYQ#e*II~p`0kUD zw(|G~k690|5g9kS`GGs;{rw60S{)v$@g15nqX=!-nVxw$ZOOQp#JSLD7pFD|8QkFMc-%3r{giczG?Lvz z?MQbudg2|927eH|Nd`wKD1`~+Hxl7fFSMr98QM>*TvcC{6qV4<2LB%Yxl}K1q+^$e zs7k%iIbYS_j}xS}it2c|&su!^l^uP^#-YE@>Bi%?b+RZzkEsESj^nu%pP6 z#B5qTjZTN+yUP130iXwfM`HpG1^3GFlR?EZ zEHI*)><>PR&6}BEF=Cos`&g$(GCW6oHFd0o*x0nkYVPPtSy}}#0l`wC%L-$h*ahmC z*xNHxQPpE2VTa*%4Kr1=JO?p7WW~l>dilUubHwBAPZWqj0G~}TNy}rH`3>ynLv^> zpGTvl#h_l{FjN`bqR**sr)0iJ|HGBe*^Aw>2`cq&%*TjFe&mm9mQCfEYcUE{MQ&l1 zdP^gQidlkG+w$&!QDNmP;Dm{}lQZs*+cO7q7c*8b2(gHZ(x4W{`uaM_#Rz&1iU2A^ zt1Ug{<;W-Mq*Gj?r2zJSJXI{f&WM2VE$PwCy~jXk*^N=wZPXkm0SLvHTfX#rh6wDv z`LM4NQ1CF*w?v6f<+1Q@I_z^WCRWQ*Gj%8PvLqU7t5GvrKcjfUOUDlXlCNV@v zUo)ZX_nVba+g}6tYA~(i`}~%(17he-9Vh9Jw;v!K zNDg*5L*nnhmM8e9WKF~CThorjkhX1aR_SiJniV@+Qw5H&r_!U_)2D@~!hV{sVCO`b zm-q$WGg(Nr$CAH!3(4{p5$b2>6O=Og4;KV$lwXCJUCm!58jX?cJk@ru-Xi(e7-ueA)0l0wmu!*%k2+b-C<&j<7Iix zA5`VFlH!0#`JpA$j5;ixua>j|1-Mwz)NiHD@E3l0Hr2=86VE^e(i?Y?E+C)~5NxNz zzr1?o1pCWW2t~#5ToIDnKVBLRvT@3A@`i0#p?Vov)e7s%ej@Jg+o5dg#V;8T9Cwe+TQr7WM#fw{Rn8Q!!AP zjcNL8g{`zhYEjNH-jY40?OT2%Anr~xZMc;fxTa!(j5Lvzsr#WeN1hDmH`|j z|2pA3eQ5#*F8<@em?2j?U-G6h16~!fqA`~CKhcOV5TnKHkIC*uCr40^ zw6z@Q`pkMOZsk>##3ylrRHrwpL;U@vh-L9+xM&8pN!tScpmDc*v86E3{%5nn7x83i z4oDt>uYUf^l|R2~7jSg`yF~wdMLg&rYCK}Yf2HjYkD&NhN~80FmigCz0CWCt%AzpR zv9GdA0yr6^%H>FDwexPNUBABX+Zi+jOV<2wr|L7^n$csVo+YaKcbCy+Z%isUre^RP zu!cF|`2^AAwQ#Mvd!EXODVuHy7ik^!*6PkD zG%v`1Af81VR5q&*N^?fsD1+Gq+v!W0$_kACHBT3i2kw+l<1^RFD&{Y0iRlSMvcn!= zv-nq%odsh3OHzE9svH6A;gu7xxx7Eg(^|#L zp|$G1=<2Qfz#%!~`~-w;Bs?f?L4l=6+b04UA^m2sgNc6L`@OXi(XAmPj(ZgW{)9k( z^{OD(S(eJWRMuw_oOyfn!KO7v8pXRUA@klwuzt>IlxPFU=mQvR`0n;JJ&+8WqmjLa81OZSBw6do10yuxOmv~mNW^_+suBza-0jR9^<)v-3j#KIJrJxC1EF=* zrX(_fbJ$Gv)jDyv^<-!J_WY(b=5IpGXb_t!o-fAVu?SLh;L3ybC3-_6f zdT{q_4c-vX1*!jhw6^V6Dy4_Cw%BP)x5?|bJRU=kL{E>9qNPAecX<}6PW~X$mXGsq zY3g0@JKc_8jbcIiuJ-N{M0oHOIZ)0`swx*Z;?7y8A(`g7bWrN zER)?x@2v+!U^CpkHc8yDn+*N**O(ugT~|sFc$tjrxP2Ut#1XHFRx9{`HJVK7I*GKdt)yu5 z-~oY-5aZj*-s0-cgQc)e6VEZ|X{{X-!K7%};x)N9;sxQnkLfV`s!-D*3d_U3`9zYg zl(bK=8W=5DREP<&z*CnH!OPvC#fYEgp5^6h3&uwaSqG~*q~|T(45y^YG>fI@cQ@8U zNhe3UKxoOk8{8x3S_MxDJP-7h&T5hoZb`P%{Y8~JS9UG!Lk=FTTg-DsK~efe%m_Kj zvUls0E={hqjZPcb^<|f4=3F>byjCy;HAOUtOv&bK2)|ov^lmtAcN(3oCl?`Y%4Suo zH@Hf#G;{agB86WlMFbw~gKi6l+{y@}f2BK&sH|5y9rLt^2c4%;y?TMmdjbbgCK9bg zcZzMjR4Iy`qrqF&!|5!mB~R2Uks(~4h*5#SIlu+(6gHdb$I6lMLX4HWxhR#nuWanK z@T>E9TZRdlfC19Mt{n(ntMibHx1``mqf~h1Dp`Lr8vNRQUl}Kk#sp9!mJ%PF{tv}}j9F6KJPI9B|$K1&W1nqm!hh4QS=8I@%zz7(F z^~F|;C0AG@6k$;%7_!#-Q)6c2NtOmVeBwA>-dwG@0?8rrf=R(${R*zmP1=n|| zouJy{bvn2&%;qUStMcKC7)x zG>O_p{C3x8OlcXC1ju$J-0M*_(ZUz{Mdg1t$r)ehUntFgcQpG%39Kj)WmD#lp~!(M z616TQg>^^~R4snXTDZejr~byUo1e$<5HfUln&{Nh#sOf7Oi&^+;1ZEVN#C>| z$s%13BR$6jH_X1c{7_hjvmkw@1#K2#*s$bnYKs-J+4 z0mUdD0)9}g-b{8T)X-8#g#9h}i77uzK404Tnp!l(&%Yy+4Lf2p%FH2TPHZ_ z8ex5yvSOogfB@|!*rCcTFv=zUw9ZuHTT`-leKTbr;AT>EeaXEF*GW)LPXRsa-kby7r{aYjfTAzBbhUZ zW}&A%gnhCUJhf{_p*2br@U(e*PdHuB5g&yb(42*LC;G$@M7UjUUWil)=+3}ct!~wA zF4xYIH0P1_cgR$rJG)=et0gOzB8`)2nm>GTysQLQ??otEi#DW&A&8ZWkXXOAbUYW6 zAm+lh9o+SM6&von1|=63kIuUyp<%zN$!0vqmT23<&@K|jZoTWV+HzJ7jGZd)TYVi9 zNvFl+VxXUPQ^tBkyrjsTF5EfcIG)qMjidd2LG}JMxZ1fTDV6{Z4|T57Q5=+gH&m=4Tt50!>#;om}C8^h834Dr;y0d14O$-+37x`PpdWP z*!YBD!F8Rv{&0#&Kr~FVF_XxjlkkFhjQCF&O)&2?RvtPsWxeCDYJj!W6N|Pts z!R&Xx6gQ_vYW;n(skcut%D@-t6K%!q-*umqHJ8IKel#b}`?`%NjETMm1NY6Q{yc~g z_5-}@+h^b)Nb9Kfo{woe*X?S>Lt8z%6Vct3BG*F!`qV8>vZEP=js9R~!w^r1voU3g z`HryTzAI~)S|u{m)n=y4r4&#L^e6k05! z>zu2xwI0+#wyAOppd`J6w?EJl#X(#(S_!P#)HRVouXMd7<52)PpR{%zZUm-}+)K1} zjI0jrD~D(XEjIf(XAqt=w&+W{1Ym8I;ZyM>uxF89UKU+0%~QPlZmCsq$nFv+=lgq< zzB4)|gm0kI6|D*Ji6sR~QE2XlcI>}qdxJ$4y}c%Q8(El1y3$m?|IY=9hGlBu;lGqs z9n2kU3T+3Uxbn0@(`Os*0HdKpkzBn&VXjp9BsWJ~C_F}u9)53D(1o6&)ye)Jd^#W@ z!Sglvf3f;E^X@N28&MYh{;S}&+J8u{%+b##8IQ}9{!>;+s{{lj-lf$Z-MS6ATK=8)zeaX zT3~?ij0a@_6Pcr=`tRn*$lL*Y`@gw*bbEXxkH5-;r{}UUfM?zRpXGmRUZ}S89B4qO zEw58$aug`(S0Hw@cW4jm_M4^kKQ;PzGpQ5Czy1349NfTj#jeq>d5Kv_IN|6#8d!XM z1Xd|lRV|=DH>$tuF~oaCJ2UbSl5lVd3l3F}2X^AjYRhbu(%0@+^3`t3IACYnw}aZ= zlt8fGz8l^Ks0;cZxCyvCu$%o!L4C%dLLCmc;B&k`kWQ1gSb@2`?ZN*#=D}6&4u~>C zu9=&=T@N8Qls+Qj>nazmijJUYedn_6121cOp6eYKmr*?*D>@uH;F_IU<)>30bBYwY zBCWwYMQw9szA4HA45v1%CNG0KYD8x1u^?`xus3~c&QEA_74k2Zx;zrkZQX$V@_lw> z=PGJRZ(tYTihpK2$Ecxth6tngRx<$b(hj5u!d+Pi>PnZ6RjL6L5J1XKVAS|l))fGR zgY+F99aQ?E-oij+dr&KqYf%Bw9UE|T9X5-l-!|n=Y?1!-l0S?G4}5Q-a@oUc-DO}^ zPw)p_BOcJ&Fxj6e1TXxD3R`hj$m563YJ&9gPFv`nWLe6a6NclEUel!I>YG(KHhL-5 z=(T$;Qr3n>WmU789`qEH%HW5UqAGWP8pHV{9AS?M!o4lJrLCiE*}oH9aR0ln{J?r> zHgA1kAh(x)yQH)2EpiM`Sdk?$Ttg|!sAawT`onUakUbY}h*0Ve{nb{&qp{-+lBw3` zzXZ0warveFUizT9;$*S;dqwYk(H+6i{W?y4O{PX8E0X@#;enn|!>0+M^ML*( zwY2*sJ!88l!vUbN!%5+ zmi8_kf(-tThB6}jUbWVg(T4A!m_JDLNHn((wg+CzH<}^;aIHgkUVm<4wi)@pb)R@T zyen)w(z=J+c6b8Mq&G%-`I@@0wIHm~Ph0+&m^o~q}-T#VzZn7=4D?_C!YdjywIs1Wkv)$lS@%Rvjcwzb!>m3;3YrcSLXlR>=VZ;+Y zm+3=|4dD+$JYL&$R1m%2Q4*cx)mc9mD}jE!YP9@aY0M`mralx>M*Q9mnV-HZ$=y_* z*I;+Hvd1-7>uFXkzpxpF{Me-Rq}4}o8-$U2C=>;^WhIsyLf zVs7dUgvS!J1YqXQXS@C!YB6BH|I(U_txYaXvvKEb zu@#Dv{fKecuVwIJ>H|8Qi5sNG8JUhYIn_=~L>Gi^FGd9~C2DUSyy{u^kx2vHLcRIB zrDl6~0Z&jMJ!)CEhX5Ew)|tVb_lkd4>?>&yp()qpi5oarX;8chRjBr5tX>`tVjFt- zXIaZ~CURR~wYGoTf?|2tMIzr=&O6HqtyP{g=#QhbI+Y=51h4W=9pJ$SdcWKkGSg3? z4eG#VmGC0BbcSkrpj2FVQtFOj1H0twG=|ll%uBE;Qw%+cNz_EPB?`WQephMjVV1$m zAC^7QF>2fpq~NK;jT;qe1R3bIsl20Rb6>uv31qNKzPVOw=xeP3j)oz{EbUr{>PG!+ zAUx7+(2eRmnA8murSZ`{EiYTQAn8*Jo@|ozx&3PYY_RFh=uI!HqwvZc0)s@ zrfV}AOQV#hZC2J8Q1>n7vieC}J5_@^=j+T7O4l=$1}Vw$SeMSES=dK@i(wy$vd;PR z1baTw+=}?++ZT9bL+Wy&v`zP~tn&14Q3%g_UrTrgC-{h~sUGyIol@P$EQ_S)ksJ!o zu?}&*mU%p&a9aP`hUJy|y=nc$AWj$ZABYHO0%6sN(_je~>v1pUM*G)Gq$ASi)RkEM zf|2oOW7s#sbLh{SrlOWr%=cVAe6zk1zXU=cJjarix1LRkj6-}{d$m>N2lJDY+nQSH zxpT@mL3u`@9_05m2s_F>goKy6>nI9=aCc}DTul`fg)}aQtqxz?`OZWdPc8c`tdKrh z(_j56DR@3(IX`<{YHxMt*Dx6~U4SQXErd~4g^vD*_%~TRuu0WcP znWrc&xSwcEE>;-oqZ9NS5Cy*L=eqw&!lH*L_Vzxf(r-R3` z%B@h@ya3FQ#`wR^JM3>JUtRXTS%)!i1Nw4=P+#L%M1GhX+S0H7FtHtx@ifu%Cg z`W~f3%qK6Z&MF}>16^@82TD0J(H}|NP54i34%8o716_ovG};dHzHTP6tQ{~)blx3s zdE$&NJD)i68-r84iV?TUcqVn#pY@29f%CVYCo#k2TC4Wx>hI3!xud;dD?g6nkyLW7yQq;7BfTqmZn%D1X z(~-sP1duWZK+1KH%aYMx9DK~sMeCdW*`HSi-drvxoem<=5P=Zym-pXnqg%3`1~}&Z zxGx2`8_~Irxw;nYA3t*&vY%tMJngSET$sM4TTqu@Q(*~iVLn0lw5np}2_3n~>tjX? zwu)%ddrhMIm#wX31L%|_K&PlK@;lw<``JgAj;}a&?FIN|Ss=mTXY5*6Z^zL^6j7Tq zUdSFB{h^kC%Q3M3EOnbFcv?Ix>^C+lIjDL)SPcC*2&wLgWdhW(975)fcbfT1dMUb* zgM6j>CHQ2QS9B!F_~eTBf`=#Uw}vh7T_4~5T@rXODQ+8UL?5E3%9dHdIbdF$GV*6L z8^GA}1&daIsA=qme@P_1ulUzWV<{gnf@-vWT7J_8onTo7^}aS-j5?g>xV?*Wz}N^*l`F9$av z7X80=s(}xQywLn>U~!LNV%`?7OUm$TLeP6JKK{;uRtk%_76CntdyK}ZVH-Rqml-cd zrv)_s7)DafK;?x+=(Z(;H>?g@nEQ?lPehdxQ2F!z0dF$$p}}pId5@TRksVDXm*|8KL_OfRMUJQoVvvOclQHiBa{En)a0IpdiMZ^9b9{WluCBP+r*93c|Q<(hf zyBlyW0zC{cjWMb?00y(|ITeTWL4RnVaD!h!_r(|pdsm55 zuS@tnaKXKQHq*$?>_U2EHaC!Y8!x{OKu>$*{5n}_Uogmap>c11NG&HbcmhDtu7t>G7?U>H3Ez$z`YrIrvKU3PNVe#a7s zkuWTCDmO7hVb9y>%BZfITA7>u&POd>enKsb{4YoIv^4#*`*fiGu06lqaicM%_!&FK zxNVAEM#U61e$^)+Vmfjp>eO3CA>_uSzfs1EeS-svdP9*Z-*lVT7XtEW!i; z{YWcJr_O4&;M~&Kta&e@l#9!pP^r6hlP}_o`QLa}=w)BkIW{V^j5^uHN3CR@DN^H3 zJ#xiTK`6iUcN_n-{azGrDR^j_%Gv<`A4}*x#q*vrXO3?WjK_$T43}HD|Ja<5IXRGG z@yYM(ig!7`jnNqTJPq`=E!*uk=|Ml5noqFR31LQCro7)jMrn5@Q#7fagM5L6uP%Zl z)Wc6y!cEXGBWMMP@;&_+_nNct8X5lY)ZGRWG#GbID5gckgz(ozKZ!zQ$EX3W!$pOw zx!5&kp=}xY!#Q1ll_?RtqPt;hx&($Dfr;85WODNV&|&llUK#TH5uWGr6X7vF4S8`@ zU66m=5Y~j#hIT@}8cP;%p>E|1JTV?uF^3CyA2sswr)0|+BZ-yokp6LFxF_R+?$JN% zMFcE5?-2jHL+CMY$$Ig1nXs1*Ka`bzzW?^mhjrb4FujLXuyeGT%}hJ2{SRQ-|{IzJ@LRZ;E!<6%^T;Q~Dr`ojj2pep%Z%*JiXd)3u02^I^GaXb(W=L9B;Dq@P zpt53}W?mr$D=KA(*=?Yzjto_@#qsoL#rm8{lL}c!+76@rL5+ybZwza5cqY-zHxcAh zb?T~LG9%@GsC->nOehB1&zgFSeH?C?`oHpg5L0H!gG)_CKX!6GwtaUkk#AP>ii{Ky z5v8@*457D=dVdzUuLYnNn+j?(p*?h*+{E8Wl6)iXqB#T?&~LB9>=ZaA;z5Hd8cvE> zGKoIe?$Uxe&)s;~;PeHr-{_-*xEj;#w<5nsS}%A7$VE3k=Y$Lj?^<~Mq855-ulv>w z;{M#QcSo^k{u^@+H{*F4k3UY8xT2VuDus>PqF)lPlF0Z)B$*`_CQ}wcMwfYK?j0kZ zyQr0b;7*FHxP4wcRia8Qf_jHOaIvW4&2uDtEZ7DuCsG<51p}hC1?dmr37d6Vzy7rk zgj#Ak5He%o&Lw&9fq_*ft*kq`{bQS27w_s=;LRD7luHHCj=Mc9?@*(%gsPtK`b@!P zLA3l2;L?Lig##~zp_u^9-(e+~ZRpuCx!)lVzR1*xMU>+&9)7?N477!FaS7Bm)Ho?U z`|0u#t0ALyDRfpYwblamyB|FHI~j$!{Oq3I&cTb(j4qK)`$&Z4)4mmS{Am}>UxfeO zL7!xM`7dLy5;u_C#IU>5LgHud%l^mk%Firb&VK*5@Nul9n;X}X6W*tJ^P93PJj&tWq2eiS| zb-}p^b~oO*iMt?jxIj_d(%YPbOR%FdZ4$cw^b89MNXNlVRP!X?b1@pEn*@#Tk}GYtwphrP&$pwA(AVlpliC(R^i5Bhdyb% zXb>-U)4KNcr2V;nPVDIINskS!qq%DDN8ZFSRsHy-&T)nNe(1Z?Io9ibyvpnYR<*-9 zt841P*k6iL%n6aua6nhWyFTY-o91FFKU^8rmAVXm;VUi-sa9Lp6mn>NT>vRo&YI(= z6MMaCuNQK?h#N+D#*)5oq@@|37XEDY{L4D~S^gd6Ai-JwhuZsL8MtZvpA1>k=?BS| zYA;7~62>hxRD_$Z-dkw?k}s;O$sHNU*?5hS@;C+I%AfOcKuJ(_uZT6v0D3H`_?1oa6 z5x3d+%}stro^}PA;tSA)w60W{DuR4NGW$R!GKj+7Jy=PaH?flLvW3op?6P!)%6?&I zo%Ziwg?m|wGIXR1XtwJd#m>d}aDIgsToIiiYn zV?gaQJ~ZrktGxHpi;~j?4-F;qB|>|nMdsNAMu%Kd+MR#KOmmpe5hb(aYb^}TDA6zf%pP1`ioUj#Hg$F4%l0ge$ z6FfGG7~YIFo(-{C*^Ue0tf1(mGZ(xr@F_N>MvY@PUHBt9azBo?nIbjHbY4Tl4J3MVVY)*Pa*&!TRa|tv4jYVh zIQ*iaY`?Q+&^wr2mC054vBMtQ-bc}%v(TMI#TAj}FOufbjVelt{md2UGHELf;`U>M z*_duWs2O^TlJ8n!>ALj6nGdD9wAQk|K_s^~qlwP!gkDo~;8wso@aj6ej`h#*ReouX zE4;6viq7WcT})jCz0XQiJIBuFgMQYWnL8 zaR+vqN&VbZIls=~li(B3Z6e$wO>@;|=ziy;6wF1hMw`fwbkeFFty`}W-zwZrIMuRb z4Zf8^RPed6lHKW%v>Sp=k8?@bH{b_5ZoFjQyDPHZ^qUIq zENP93_MNa2!V1>G-*(aC_F-#d#4dwWuQGBilN{^R;?62xNRDqr?@w{fIuc2>4&zVe`v9zJILpq0N^^*hMH zVS7o|9S#RoZkfzYEEos|1j!#8xzMA(2D3eODqQ=LHTx&kYf#Hqy8%)T6Nk-eZm;e!`ttSm1OUr zMG%Nh|C*P#DXR0+!9b+h4AmFpW$Ch2U z?hvyzGf9vmw8duOe&$@@a7gSFO3X?2;K5fHWv>B^_&BUTDW&<<|MXvVG5y4sK`(97 z$A(EBYw@^U&z|5l9GfM%)!M0=YM_&S0>D!fSa|=Ff3C0IZ{^R!HOCAlbLX{>28fA? zl->XpQGU4C;?qjmhhIb4wuFMhLK>T2dh>?Qb!n}It?s1c$5{7eT*Fi%qnFEapxCz;cj-UST0q|+$kDms8CHlf^q-Z8F zrJ>Y+(DLcs|7=zs(fPm2(YH>Q8Sl~k^9Txxor3cC>l?nZY?)NPBpza6j6clFpZDFL zjP3{e+v2XOcMqB3#i=5d^BrGYU0r2<+~7^OxMh4$H^Y zSe7)TRQ$1+M{pvy^F%gphw9!-#i)TbV-XR-x;5vqKXo>9s^-iZdaExP$yz28OTghj zmZ&#Qj#8^G?#pu`wC8+$&pyAl{kLgqHcY`Is3XmY--u6KfpymWQf<@9~9@8kGtR5-|6b|Gc-XL7l%Q-Iha|YTTA;%GxwX;9gqqHN6#{^KUCJZ zy$kXk(xf^+pt4;%50-+A^^A6%I`pG#gC1KB7p{Mt9%??|?%>?%-`cs>g8qfoX^G!n zPB%30JzLMAYGD7ZWm+57@wvelY{#B|KgZn;Jh zPO-H?Rjplk)@u2THH7b=_@ITJee5zH9if=DYo!CXlCbbLJ|c=?RLildCERi=anXnRU*= zZ7LROPRAl3NgJT}S@wsum6)bgzi)wUZT3YXvYyJ2; zz1li0SIgC)>n|p@XM{1iC`=ByTJGfmj28fVL;B(um!4AS0FyU#a|Fn>s76*c@I%5- z)$i(Qt3?8b>Fufo0%Y*&Y)svD@{h3J1+<_raT${;%JHjsTU7AJG0YKX zg&F%nZe+~@W=9oVO?57zMZCpTaNfPrVTI=DT=UQK=W#D&yCV3<*JpI@8cdT*NCeDm z7m^+cZh%Y%*w)?U{a^4K5&?IZ0CWi_2QC3(8hX z_!Q4joXU*?1vR*C{Ly$mDaKc?L%e%vh(43?0pDUZ>}rw9xwhc@eC0hsK}I`Mu1ZND zfY1)qc^nSDTeZ}IdEvlLo&2zsU{(2kf+U^*ST1mZVCLV4vkFF|b`^MNh8G`wa=`-L zwGY~g(MaD{9u`uji;yQzwO8hCb#a6s1?eLQRi*e4UfYf z)OQx#KhgIGh`NPcKHQ~LZ-?w20fNXGXaM`@6vkAeAmbZWQ4?$bL~JT)uTxz~&{;Ec z-DzJ~hvKG?`yE4Cp4RlJ#vQ!(&be9)b@xN?%K3w|Y`WG2rQvloZ`h3@vft^zuK>A4 z-CD^-6P3wfHH-5~p0@Fsj|G|VLUGDp3EJ+eOf=0Y?(()t2F!0VerhKlab+4xAAntN zPD~}sK}vO+XY{CYBg4ekE_1IMN?N(CO@cO=*M<`m8Q+NtyFV!2h-nwii0*G;GitV3 z#xO3&`&ksjZoEae0|~jn_$uVGoiDs4_xGPLAx?~Q{m z?)P0A2=EJH!?og1-JBJfC%jNPophx3w$E!f>MtT{!nODT?gwRI#F|!u32ySq4+>1nWttMqBT#~Z$ zEDH+zZbNFPXTA{Jwrb#4NaoSSSvffY5t84VkXaiBtCYnKP6`UM{H3J-rU9lfuZl;}zcOh%xF* z)ZF1Nnn^Q+AZ%Y7ZMjU0?K&ARN9&JUSF6r4`fSBzxBMT>y$4uR+x9Pt1=*s&Rs<9T zY=D4(bm=Mr(mP03kQzFK4pC8&uJm4|B@m1kg_q}5MF^8=gNCM1X9 zNT=4QB^uN0VW9iQTroBKPpNA4>dbu99N?9>gJd=AYlv=U+DWp9jmb48@*e>SdJ=Y@ zyzGTN*ZcEV>2x}I~xPO&ZT5~W;Ror0S5FET{ zF?l>6zH=6zjfUTW3a@2fAa3iC58<;i`O4M6=xi>iC()L)kCVsWxsa9CQr-nhMHREw z7JhajWk8fBGgx}0^J{Qw@>N%WFOqFTfvhT<=ElI&O>Zxij68bx|6*- zj1!q0wce#mqYBxW+-tqSm;u~9lnBK|x}AIKLVC?j%sX6ITK~G@u=@k(rANj!g61(S z_QrY&NN(B%_~8C@OQ~opQ=(M6=?B+cBSAvg?LsbVEbJy zJe8XFL8uni?)o%{xKwE4Anu(Aty(VZZs+g}f^G_?>aMkkCSCUbL|7;>YbZ1>K0&D2 z^2QG5=U-v&PdAdfZr^ux&Bk-}v56zStnX4z9y(v|tDgTkx}3!>MW~N2D;3tZ)_d8S z5p*lNz8I;j)^v(N1d`H>8&oWd+4em__C4AS(6;&LV|Vv2qY>1GrcOpWNjvlH!YSgl^O*P@2C(tRjUz?2l2Ox^1yPs;nYp}yX~Rt#D) zE!$s9Ih8PANGwI`ERE3k>~6;klZLlqc0N~^3OHI74%@;Fts$s&2D4uD?G$Bp(qaAUOCGeu)cp@ZUJ0=lX=hG+?RU-_6E3=Wz#J;< zJ}9yCc$z0_RQH6>f|*e%NVU`M9HRo!kR zhx~*O>>wk4eU;vJTjB)jAo#bsJ8soO-M+eJ4x$qc=3rE)M8>2j>mX-YZpwwcz+}j# zv@O^#oSjI>esj+W%Tzqi=@!)BD;rqYBcW%OC=pAk>t56c#blP)ZMEX!m(+2>ZrkBW zP~D(H#r{5(D&dbR-p?t5}~+qAMVHmPn?9=z)p8P?Gc@-zqPv0THSNCD_J;U-h@_ zwyq3rmW5f8noowaY}RMdJM;z@N}p|=`9_m;ng8>SY26ye^ty8<^a(`$zOO>Q11ivP zV~EMnr3KSt^!(T{5B(jxs(M8fDH24C`3>hQv0qSN=s#{IjK#1UOeXW}VAd>8Qw?YM zLb;bdc^clH#GE1fdZ7Wdv>v(snZjf3+@ZCS4qbFzI~)7{23w8q$OdT6KAS~&hTCAl z&9KsTKbjzpd_&GeSKO&n1PA-rwt!{b9s@m3SRLCYwHnrMD2GR0F5b+dx6L+4EO4z> z+Exx4;_I)i=oEGve54wYloN|kepH++uh&u$)927QAbrAJ<>TmqFUj*$Gd|jb46-L7D^?Z+?QL((c zmMibzbzKsuH%7Px7u#2%iZq(FGF_or@`=YHw6N*~9~gfzRrtPLkrh?A&vZSX(2n2@Sk_b zZFJ0gVq;>W`V4EpRjXBD9r~h^@Y2F6+-(&6asZS9&hO#UlAI%HyZSzYeR9pZVI!?D zFQO-G0NG5~_Ps)^Gvymvq7}D?+*ko-A7{E}gBnod-gm6S63Mv4;!x!jlw2TRq082m zZ*#B;Tjg@xoy2F;cXgpTnYEA;zhgGqoa?H3>n^{>q#5XyWISWNIdUm@k z*(UI;-LtmJSW6!NGP^pp3pHvq{sP)7VZNpg%KPx`fq7i3TU6zIQQCNChkZ*MbTW?v zbu5A>D1s3ZsPjI*54!vDbvXbgVG02&+}CoR2B2ky3Uc~NK~-o*w*P9?~J?%QI)DhRM#^y^4G?W7=g_# z*5s&2z^!{b0JxLK0jG;stocl5?Y8xo+(hi;LAy}6HxnvF4_Sk%|T5>-Z=u-uw^9%TIkaAbVjxQp6gofX$%QI8iKIK>^$7$)Xl}8;mBBYIW%L zdgkz{K~mxyHkl#&`&`5J35XXCI`yihgYF9(2p_z_+)PoL|G+pu!PP4A-d$uAk`)$E6Z(&N&5SvPRPBrW#3bn}4BTOq^f6!eVd<*u?o;d`kI{(voQyl8!r zpcE_GBZ=9L&MlJ3xKpija}AMRlLLK(ptP(%)3qb%z0&Ja7WGIKZ0N<+`3h;EJc;EQ zvuw&zLHV>-<%5NB*=>D2OZ8)!P~!}}#T$h>vZB5dW8gBo zNBXY_w_oSx6|gXqplMD?8Mb;k;>NVYm-RDylfj-Rd@rE)>C$tdUm;h^0@CS{>r-O6 zp4$n*HVsIdMItpt137{V5eAoZ3lNJ=hoen!;z*uo7+oj#%mQgOp4v*l&pEyRfB zq)m3BPW@g;%t;&UNw=~j`J&eRXaYdcC+-s=3B;08s1BP*j+$S8KJ9_+t%Z--;!j?~ zH>lbl~}J{EpxR`yLy%^K8@V)!}2o#jWO__@G+(FT*(c1x3Wk)Ej!3T z%vS8yt$fk%EudJc70%MTM&mhff^-c9({y3Oo8&alljIh9hCL~w+zm!%eB8dt`egW; z)$I@-g|m(=)WXhU%)$M&w~GyFaYPoDy_&IHu{vT{Vdybs9nAp(9_-e}=pa(|CWn#B z@9pY7jZCo%p4VC0K5n7i*U0K11Fv`wIy`47WqAu7q_Cl9A*dM-=OcEFWy{M|=e#yr zTaCHK3M%l?rCdr+c*HFA?x`OfhssR%t(JBHjWLK@U_w5oz=h)mOu!qUsVb%m4DP8l z;i5A;Z_`*I4e&D|1FxMJ*e1Fw=y4;=iGPet(z(sG3CgM%yjW}bnG64r3oc)G z4b^jbe_9*MsHf08?RimF7Uj428wL`ttROAgj1BSIsr8#7Aa3d@N_s6_I?JaG%6yaaq=z=X z=-XL6?tD>P!P#v#>@JMOp0hIPE3A^qH0pThVssGi`U0j&LvS3nRoJx4pH}p(uqzQ0 zTJt%G8#TK~&{K*SE5cB3%0Tw4 z@X9glb*s6AL&ZOe<(Cy&#mU4tH+R*DN*a6WNfjK(srJU0;m`G3NS|pUsPs%F$kt3p zL{K`pgom)~D6TX}q5@3Y7{f2^y{;d%)!}L+=z49XLVdnNlEj`Uo$8@AD2$iq>yLQJ zy$*4ZD6qtz*a;}|P6CPPIzFW~%Ttdl9M(L*+Knx-2p8Ju73MAFHJs2PML2_N@{-I0 zFqRPs!G+!0^ve*lY>t5Ji>O}aDQ2+m(quVr<7n_ef7|DzoyL2ywe2a9M!NhP9IF0~ z<#8r!5z9FZ?ujdr3k7)sH! zm@Jys{XQbfa30)9(!4I@I)7>#h09%Nk%BquF@FWuNw(%A3j<^uC${8wJ1_+tW|s>% zfL(X6G<Ho$cttj@H=p06^_tAv8F&USX6|_F!TWl91g-#sW1r+90D^kas zaD&OSPHx#D`0e{E^;Rm&(LK4o?*lyBa>DO4*|YI^RSfTS<6}vU|A54uMScR##sJ{_dzJiQ zWcMGyd$-j@S*+35q$+qt$NX`{KZ0}uHRSN!<*x%Crwe4`9{+mne7`a1@sQ z{NP7G_VABncc1?no%#R%+hCqCv~ShBPS7olUJk(JG5YY^#6%(ObUD7Es8@o*1?ma> zR^s>3cC+qoW6g%;kCWsp&r}>mLC9Q#l%M!dXbir1Wq7_$V=b>C%W-&A_)am_V~UYh z%H&-5a@MxbxfNU)O`2ZxW5m&@Tv2#OM$GK}_AX>u%M`>RmC4&h!PP-9+srhz)AWjc z?P*uwL5jaQ1+Qo99b`#B=2S+4^^59Qp=RhftbkQ0lo+5SCA<9jXfP*1;&({|rQUw) z8mQbFoDor-RkQA|Q4xM`0)_9Vq+-pkc@{O?9wJBAgcLM^3*>`cz) z5jVbLlnRDlFXoQXl{<{0ciI;(Rrx0cj2IeMFb-A)`3mXPF>51G!WG#R?*vs@7V3x|mIE{B%TuWdK?<;QmxAGo5*}B;j+*~b$qj}lp z0t7~LHmIO;;)P#*C(9gz%565D5>E>{y}khL|Ex8gcxTfKsFxl@_q#?LueUM$>$IYh zQhBIho(#=Sr_3kbqov^IxUl?CPGx_HR}t(~qr~RnH0)E1^Qe3_#3;GQ&YZ&k;2pPC z?%~`eo0UADQLj~+A98_*gLKDuQ`D(A;EX!V;NV!zC(PTU5!{aPCSS;~a@n!}Zfwc( z%HR=rf4~q$`~H2C7lQThh)?=^Ve^HEwSJ9%7og0Jjq#FaQ;I3?C@?5~XPBKQL^{0` zzH2sM2UAc8Hyt;G(4^laGUt9jV`P^>(&&{xH$Z&Jj@@q)Ca}aghX*?rG`#lEe!ok8 zLE59laf{!wX3%b^@QLSDQ5~p`qVL9XiL&!?^Lfc8q`{l`wciC7u3B}=A_XcP&>o0R z(O*&Em+m-^OO(P`8;gS?ZC0u5g@uI8Vh2FzObp@0IUmcLN$vW6+?U8tp(ipWEb%zQ z^ot#VW{h3r$VuA^(uk8BSFF14*QNv|h|%!7(NE7wHr=w2@L2wU@H;|Pk%i2sH3YqF zW4p+s`W<4ID~ZE4-l=2`-`-EKx>nD72B^6eX$N+lT$CC+_#zmB7uE&qSLz=u5!_x& z)K_X0ZBS`$^5Y6i(W#6Ah`i}m4-_{y($$}8@A1p~^p*V?kwxd;1|eUT71NAeu|9Wn zqyOj)i+P-$tWUOTz4W{j5f{&6pltM9oX5d z49hIuog-jJb3#0N67%OECt=@p=Vm>><*R|xm4<2bJAGc2Zy<dP;_c5UGDSf>pD&Y7pc5_ z1G`7+a%Mt$J~&!Oniu3DR*DN~C%aKJzCAXZH7B6s^;P1!2PSKJgo;*0-12CdQ1wU* zuZa=`4U3ZJMb&-#H;HA8({r`26U2&v*<=UID@OA;ml+T+m;zq}@A_K>vWI(_@q^O_ z75X%Ni154qVvdFN!a=oyrfxJQ#d%gdLn$si7q$Q(OqgPjQ24o+N^N=g*|=3!kJOkkeaN#5{74D!yYj~{0+_{`IF*vB)gu0U`8 zSi5Dl(W!v;Hjp@#4~v5V<$Fh0P=0EjOg~{q zC8?kX8F0qhPAmO(bs=Z>xiP)#hY@d!TDdd1woefnzDIX*rRt=9y@8o1>17n zg0+v@vQ~NUHJ+iMb5!^zEdS8pn!9I0z0A`6zm+GQMAsdiEEaMypGKFHxlq=OMmuz# z2XB>;6}As%#pckz(zo@>i?bVs1fM5hVaHT41Mi&+@D>?_oh&|m=heyed#TB7eu|AYN4R_!`Mvip6}y53Dy1O+!%`^-|;6C0Nv* z%yb6i(8e834}Lb18-2uGUs1D<)=4tzXpGL3?4Wr~-~6J! zvE$HdhqryD^(`6kQhdnC9oQF>nL;B>?)VoGot(g&CP5cM-&uYNYVIo;Z%w}6?zy3+ zrIlqeC{FV3HQPVtaqjT!w^fuBT(|Sn_RAh;#y#NcEmVx;zJ*yxzIfaa^erRV-MQs= zIrzf@nj;;J8Oi-QE zD7cAn6z;~aO8!XqS=z5m)B$aJX;*c=Nvybj%#NL}sI>a7)=%~T&kAkE0_A|9CW%gn zD4dFYw{}`%mRE3U85bzhX7De!Fqdkq{4A{zg$H+4dk6YRi^y?ussVjdJSMn<9i40> zPTrd<&!7CH;`H38+(r{|raIGyXg5}3k!SLP_77?L55X2!63wALW>SCexX>9_o@0jd z@)$HUrc!nHK2s4(+DRKT(x?X%*iHzDdSj}juv=sIE5<}0U|I{yIvhRi+LqHoSkb!0 zg||D2!rubVQ5uXW1xi=S-({J89QV`E`K$itK4!Sq&0DiEJG|rmN&=JUa(vLu6{h^; zoD+5w+DZJ#PrdMVf#yF6ww;bl^P1c_S)UI^RMlY+;hGBlM)L;T@X96#73U8fEi6tt z$wW8Hh(UcEa&a&LvC9PNZbLg-%m!$7z`p##%gzmUAH%MyCgFBUCCZm1KvxbY_mxOy zm|wJyWIqOqz7#7$1nFt-Ru-zo?n&yW=&ATAbcR;-wLPc82OJ*!EJgnKpmjY8H`Ac^ z4ibq=aZ9|I2^pJYv);NOx3##3&my(Z+;6s&A3~{uZZtv+#7Qy+B{Zc z&8v={>>v9|%_!qpBF*^7NMh1ob;WW&|47N+qioerliPd$untQEf|WU>3j2mC<>n8&^a-rE^jI7xGO~Z zQ1Q`DINyn8)27fzSZ#5EysSb>EyRSrD4j-cSh#BJh=NB}eML!qa`Qu4gmGqIfto$B z-ZB0Qoyf!Mh`2szUmzWw#n1Nc0B+ia^YDPphkdm5!<>ltKiomYt>(*j3ZFf@@6kTv zO3tAEH)`vOhJ`B?+%@8JIbyL(ARV3jgp~QoAzDp7(8xBkXBa zQG z%J_g;M=f-R3b{`IF-OVLvi_|J(4B$qR0;f%&+<1Shxn}QZzGGGgNqm z0`TWz!y9s0*Kr%>b|X^(DCbMENkYR!OHZ2t&!M}A%jRy{Sh^yB=D8U1uQK!SO~_xT z5Gmh160)w00PXR^RO)Jy@1l>CFsNic43znakKJaus^!^Os_<6D6t?fvWo|V$j)t6y z&&)yr1ap6(50xJEyGawBdz$=**MDXl^#sE!=)x_uS~S=15XpHBY58*j-B{Z%JoH{v z|Kh#O;dz`jKe)6b{%^@`fXQ8UNZu`(W}97Di0@B02&-Ie-E)eS`su#uX-!{>y{XyH zm1k9Vs$X~MI~fA@HQ%rzWPi&d9#}Lw1zK_q4%@OE>glM0EoHm1g-4Rc;|7$5wMa}2 zcbmFg=vKj-KHfJY@nVse%DRlg{YMMRhW5{Hv+kDGy8Y9_YRm}&qyA#S9RUEH5=Tpg zr4KNrSmw%qg;5_qv+9D;P{8DyU&ND9ojt2_|NaZ0R|))QDDPa?eCGr!@pVG*IYC8p4q0T=!?(U4#Z0lQ7{#cVRa#mM zMI?qI1EZ+9dCyw#ogKT56h#vLMDNh;wPzKHkA!LD^DftJsQ4CGNV&xoHid$3Lmo4` zr48~6LVRk5uOmu^sMM>fsV_D7;sXd^EXPPO^IQi_UMHHfat z-KHzJ8yU02rn&$F%iX4om{rWc4R({UUBRKUTG`_l3_jOj|8SiD#DeCS0nu{z_yw`& zRB3Bl;#Nzh{#GoHs0CMOC+KuqUEzUO`F`U`5LDZvcvz}J95zM64 z9clz^9N}r`E`p#|=~cgZ?-df(Gv0oI+r`|kxTq<3yRNc+lfXULy*pvlI6mV>=dn@3 z=f+~zTBz~NT8g+_wR{6s!df=u07|zaz{WY)J`RI6KXT5X2gXR#Js*d0F~nhvNAWHv zX5NcjbE!Y4VxdR2#kwN8xg9MQ)m$%scw5qae>W?EJc(x~Z@M05l3Z{xL?Tr~z`dgb zBf-}_J;$C#L5^Ye-jado1x5XTV_NGMic+bVn za{dT@)ffEZSnIIp$)iOFs->i(*2v7bPboBJrJe7baXd7Egmm0V-<2J}rMEa=1hVq9of}`iCAd+!-gyxFp>|7Ek#Ab%f&ICRUZN-dqd&}8nZ`m|F>vN(ymerkDVvoWnGwFA1h?JRN48( zi_2wXg70W`9^UiN;`s0;@x$s34`y>e=s?Z^}f^-}MHnQ9Jg0h;fwg zwqw`p3h?-XQfgsrJl}I;)XmFf>&etDv2%O}WCucu3OIzlpJ?E+N792FqLe4Zv&)g& z#nwNs%LTt0=4yUFisKm>5xVe0rfA4AVh<@RTW3Ow@C1N z75Ncfadow3yYYk1?d#-!KR`tMM~%(o_7cZ}ssLL@F(9{~@4BK?2` znU~RGkAr)4rEFH2bfo{WGN~CQX!tw*_m2fET)ruaCOpu8>}oFjiIKp<=g=@6Pp4}< z&I#-sHd$>f=RUoqD3STjhD}H-DjL{b?1IyVAT6uMv_!Q-STqLq`kk;nLn?<%>#Zxj z;~vRq7eP%s$AK~r>*F#O>6*VMqFY{ksPrB8duW*Ly`f02Me35Qa>jq=}`Y*?qNBRlHQ z3?loq`taFKnDUcIb)A1i-Xb;78a)~R61ej?3f!%G8$J!IviU3&ZolCD=XJ=IfV4Yq z)pVUn#QE~|M7UjFEv&^6o;yKmEP7!5w=UM^Q%+;M-AA6NvE9s_3Wow-i^_b%mApa0 zCYGbHn55Hd+hre^>;Crll(S3JqJmpyBvIFVq*$}j}s*F7k+>i>3$WtDAM6^rk z?Kxuw@=aN#?93vrea6-~fhd;STMTz<0T`ij$B=VJ%_a`xwes?L1E4{P+|X$`Z{ ztyj5_`aTRE;G~J_q538R2JK#Tj>wYi=?dT!b#6ShO!uTA3fWiGt`9xStjqG;)W&*#7%1fM_j>xfuX zxkanm-^blrBbdwnQ`{|?jOsL~*osXgZ~RnM-xdEmk`F?YBK1nzwRJr$eTnG=_&HBM zhfG5}Qx?Hu$iT8nLinkNdUGTms;`$Yx5K#g`L|cM>~rq18eP9alX%+NjJ5n;_qD^& z;-4`AApW;9YkGX$_=yiYwBbeWMBX{GvAVN_lZ&Uqmzi_8&Ad%K3C!6F0@dV>4=<2!gS@Tj=CvK6X>!#`miO#EVZ+)eeQZI{ zgx=!@PM?a;dUDdM&>`aq6TV1?%!XEvq0q@wfFBmWv^b9miB)zm3)ZU27!C2-mnC7o ziK+UCKQNOT(OF8=@$FUtWyqIre=7h3EfG{;cLDMtkJ+QuZW7egnwz- zK4$#l5VVX1(pXRIi>o3!!zhFUiiG1d`6Grx>j)^R7O%~60-Ryq%k;2$vbUS{s1X-4 zSX)D@o!WYyPo0TNk^fqk5C9#js|B)S9}n3G--||1SC|e+Xl*DLyP9W&S9?TMV!|k6JtY^?xb@_y3Ko-v4yX z|0&~F*ibRpS|{s)A}l3|$au4tl47f!ZZXeX-VGJ2dx5qL&2pS0-?+L|WMw2Ldes{I z9cj?aVXBoZtpGJBdwnQq;@?ivm3t+kce7rF;p<0F(j(WJ@5^$R@wr_Tv@!}1-LPy4 zxW)U~CQRfz@Y#D|q~!W{n%~Nmmz0%M9#%O9DbxJ@1U}4qZ95%B1avS~}_$WtSnN8hJ%^oF_BsM^!qb-^+DXsZNN&jcZv6gH`o zM~lH#_@=6tP8K}oH2(NOE#1m&{)QEDkCrwHl78~k$A&zP^OBRpF{HR^Gl{9uVguEv zKJ}q}Zf}`5y9Vokp00ovu_E6C^19m`Ei8{dysz(XiGH?z`MsK$ zGhR_Em$2Z7$Wy(PHhS#yVDK&VhC3Epr@5!*maJKBxU*hXS$TE^@chI?tr${o^LJRi zxKZ~~(JyP2S)f6tpk9Gd+RTD2;$8Al+t z*XG~$qmrlu6O z)1=NQZ!?`WtD3ybXW`D@ga1dP8As-@lVT-ppl2p6VXQ5psG0_m?a?vI*{@^g{4jZ; z&TvJaiusNj6Wb69Z8pjyLa1>2>j<|*caWiI3VfqaK56sFVB^8rm0=sOZ zMcXN|iULZ90%rre^%}}4vI38fPi~%J`%Zgi5hWfUd#j+1f_fnoyss6vvoSeTiNP}2QHs_w7Yomo9q7qs2VB&g;wEC(>M!fmaesKE|L>e< zS0F%E)Obb8bvx2$M^yqgYV%flnOk*P+=R%ku8WDqqaZcAK-r*T9vzs!?4UnV9JcI{ z_Zmqk*eWprs_K;)o1KuknECcqk-l^r+X-!IV~&qBuGKWg2pV^wfIbpN zmGTl8-#h$P6Q-lI8n;>1^Ia`Fv4ee(S^v_J)Y~4ck3CuMc(O`*vOe6jhm2E9V`kVk z1z#hoR5>v%Rvj);4T5@EU)H1)F?@K}HRC5sgay;?G+T_mNV>0ZLgKUAvbShaJ+Az#`h;k}{wXlsPyh9`%5S0!ROk)4Q+*UewO!tNnWrT!5yAUpw# ze%xu*LDDA(W7oVi8INEMwI92 z-f#Sd{dNtn!OT3K#O}fsOh$SV%>@*qw)Nj)c5fL@Yv_+$sUsTG@jwbAC&F#>e`5v8 zUC{kro%ffpNjolqe1{3W@~n(&8KP&ERsQhV=nVk&ZFr+85=6((1hWsbpsLy(#aK0b z(L-Zabh1XbE)_4OwMc#q;OaATk>7QX^8SYDVO(&JO7H7g6p1e0xRVz)1^f_Px>k{B zr5dw=%fri_V~gF~g%&@|#BH@FZU_ha6)CiHd`Wm^<(!p_FO!oa!el<+Qu)EoIj~$bHw#aX;s<1ew_&-ILkcE%xH1V2THe;1^_Bk$e^JW`BCHVNg z1G_`oWd3{h+4Rf|o_7*p+>%$Pkx>bARsMst*K|?JFPcn_Fdas77{bu*HMb(LN$P`> zf|b`OGn>lDtr?Kwhnyn7iFWfMs5pbW?8d6y@-S6jw|1ZIH>lSR&}QgDUyhlyQCW7x z^kvEh{SDsods!HM%yPcY?+_!NwL3mYm;0tFU1yu^gz)W-HMZY0SCkhoWsuWRTsf3B zzhcXW)U@c8^BIySj_SFT-jX=20YQWV_T9iU#XueFMjT^G3XpL7XDmfT9@b|P4q_f2 zssQS?Jc=!b+V2UIGR&$Nv>T~6VXr$c_P?)&^C4uD>&s3ZxyLEfyJke+lGk>VMX!zJ z!;2NyaJn9?>^xOJW0`=tVpd(1N+|sOy=xWCP|9Mnp}DBVmmI2m5i3<;QR+&4?&d~v7*Bzek|m8Fgo#9df^dU z>#CJE$0X+X5%Kq}B|r;1YUAkF+5e{c(2?tW_xbO}+w|ZFFS!+DN?zZThk7)(%2CL< z4=6q|rJ{g4EbSpwS`-Ky2K^1~7)rMp*r{TR!>vim$8*Xc6&_=r_rsNDCO#7Lx= zdUuQc%P}91M@_dTul}shMET5FN_0NJq?jb`Dsr>ySY!x@8MdL5{nv-yO@$_~jKOmR4jWxovYmc!rKJ;&!*_?Zl3u^)6tQTyr5U&jJFdkoN}dE#EOnE2E=?5w zZ=>_Dgi&KpJB@`9!)-i0f}*s?liv-4Hm$mxUJPt7H|*nPDNFs$q*fs1sKuof)(V?` z1Sdb*lKl##9&oc?C`UOn{ykW6MtVpi1WVGuunIojfIX0>IDW7R4aYK-A$)d++(GG^Q zTh=~{OHjAuvvLeiTZD@z%M8w9JZQFbJS>I^Ct}4DG>ozfjXZ%JkFTR$VYaLtj)&cr zo>4`Xub%P$wk;3xv$z39lt3f)H?sBC(AUkb{V`?ANh@^)J!%t$)`vV&(J|;&DQ8mY z=ga3|m}E~Th+zEc`nTA^79_wG2ux~TDr3KA;vRH#@Kl5fym$+;&bJAVCotEH&vC3PCJb|vJO zR^FkgYTCif<;WxfezxH7y;nay(wn_W)GW|>4r|=$we1)F`>;Au>i(}H^8-n>(U_%o zU<1SX!%{I{eej8l1)dhm0d2Zsw0!YjuF2>7uNDiZy-(@^hAR_G8o`T8A2{$_(WqwU z7%J;hHbv>r*RFXk;R5sRUWK*s`t z79Q?os|c`hmjWtu=0&JNS+bosFSfain)P(wU@Oq6uJLH+;S9!SIXx9MHAr9)YeHDE zoF6i!88>M)c_WcgTtAvW!bo&yYLNQQ_LEbaK^EFK8Kk^8M$fF%$X4Bf$&@JO&Y^8Z zG9{A#h@>aB+xu+2j^}rKW&3sZH`M62no|lnYPo;tjLF#rFJU;?*k~AD7IfVjczA%` z(6T@)r&F`2eizh#Drg02h5D|=*-hEzlGvGd-y}t zeZxekpDak(y%*=k0P5aV&)~KtmgjLo-H6kCXN`heYyB2QF`v2iF6dkOIT+?53F0bh4T5D8ndr#byn;8 zCexKxO9->9V`l(zdOorrWJae4b4h1cm)WT!5#kl7JAt*8$Ra&$iJVtpY~UEj^+hdS zV$|S}*H)Zm!XtnNG-x#=AZM zysz>x&A$ltld5EOZ`eOS-tdBH&Qz)))Z~Co=_9Q8lu!i)yW4-F)*fB**&0AvO}r^J zuyjs}x%xgu^s;H(pKRG?B^PwwQczK|F6^Ga??(j-6wKwm3|~SK-bHJ<)Q05up$1-! z`ho2qUGA$Skd$STuSB67Y(2ePdcp1MhvUa7N7*7f>5L^66@xuAaqA2BAlnopa(~{@ z!XLWw@J|_^{wtP*d<`R)dCLzHYj!`k^8e^t{G=isHub&g?-@r&Y_M6Hf5#Z&-aXy> zJ26f2kK_&XSC9Wq9Qm+Ovi_g>T`7EkS?KsY8MpB#vr-xUUlJ>iuK3IyaJWt|OM2p+=U+grDCA4p+Uos8i7|tUCtOE9_cLY`22^paCF|OUvdT7OrERKja=1g zMr>$j3V6s|3Hnjt_UOR71gL*i2xjczJ<%$iDLW6DJD;+-R$ByOMUu`}q3gc?EM9zc zY?}#F8tPrW>biP50zA!uV0|n5UoGMzqp-~lh!ebn+|4jiGSf1@U-KgqZ?w-?PC*)W zEhnt|{f+iXGbPE~Enz0Q-i*xSFTz~+G*b=sDvpf6;5WOolv5hDffVO^Nxq+l)ydt&wi1l5VQ3VHC^W1ugS_x zq{_ty=|S%UI&}(jH6?3x^K_M8b@e=!SVQyD)zpNT2&8Ojwq6_N`k=2*cbezP`km}D z1rOZ%_%K*t%O%!PAC1j>Fylskv60%buRVuj7CU~s3l*!#Z8r4oQlAH>wKqVQeu(ux z$*cG)(~{Y7Q>glfK%%dEq)gvE_+I*n>u8`>Ctx5nW}vGl+LQYkCA;#1(?yL8ek?F^&<(6peb$5<3Hn=rO=`Z)X@ti zK6xOE;3y6CPh6X|N6P0HSqI4>51;x4of44yUKx)#lg9mfqLc5RS#X1=TOsc=I&~H! z;I4_@i1lR?sKq3Sla4bl!ZJ zc5G3$xhf6LCOuKI#M+JV#$Ad!nx zA{*`>AJ!YSN*X(`=p`r3Uvg=?BpsH>t#Xc*0z2QhCcON4qejLxT=;ZpXX|e18P&+p zw*&mJAHm!_VW|dy#0-r71BwHUy#<-%;ol9TDg*KcxJ5dUrpTLX)iyb;fc_h+@-+-4@21tIuG`PS{8wv{u>8LTzkcxVQC6r zpDBcrd*oEzTcZmXrs2Wtd+Vjs)?Hdac5ld}k8wbA;Y1?3LW!dxAxkh1U%Ick7oQE@ z>CvF0t}ydNJxw+J@P#Bsg5CU(g+e<&uoej@+)7m#Z+;6Uz}%UyfHBM;Ps%MV?XnCF zyyJH7t!q}&D^?4qt| zm&$E7S7o%!(k4CGj08LRVqE>|O)pBD;kxLk#F{+$JDq)=YHyh5Hb4fm6jySa>|2j* z#}~f`ZIh1V6t%wEepQ6_H;`GuI#cH|x+V8vm}!Ba6<0U1g?UdgZ{PEi)D>=}3l*$` zTao8InTlRU(pj?`PcCK;c$j|Ay3qi?;I+cRMbZLQ^BH`LH#^qG0#w=-`1W7`&-k%eJH(Q)JWdNAwl5J zwd0IZeI{TLNPhc#r0|yUuPzYUHHXuX;Gv3Sa?te~y`Vb!m^v6m=t6`y zBzAiFY$@qk%u_PGzt=UrJ~~@HU6Wh;&W-|25vvsc3(=;GW6S zaVGgyJT)(D2ocJk=1oxFD;zVD>oS^T#}5{uAeTrXHy6|D3D(c8nt@8_lPmSinqR4U zxbg>Rx%z7ALMotq_-!lv2_Pd}go$s-nT*l*4 zO7rK#s_G2(*?6xNBm*?E?52E>1H{N~qRr>ODlzExWI*z+{6;ilJ@ecJSl+b8bj810P%-*F}y zrn-hPx^zkJMX1&_z*)3q>Vn|LZG{6F)-4*gL0&yaa^(UOi$y9Q^--$i+MDeH{G;(kcVn` z7!SHtF4@>&|Gr*LqfUmuZX)pb}d8^%?qO|C9HclBsB(=*smpB1^q z`{o1rc?|P?!OC7f2wfYe_T!P4ve&$Z?lfD3mWN=Q8~%)_O$$OyZ8-&J$L>+I8u9}xz+LFvxGr$vC_h*8NxaHop`oy-TV+xRjwhE&FE*o zT`W7Lbq1PJV-f&u2x8K3209m(101%Jjfz-DW1$jtrOG7SjQ;CSLGpE}GkA}KJGMIR z_pgz20#3O%H1-LQ8*WNPf8c8A)EC6T|>Xh!tWW? zHYgfTcAR(cgr2UxgK#2b*N;_858r{J?W=ClvvrQbs-v5yI(glE>RCCh+v&Jc^o%lV#yw;s<(xL7r34Vw*!iras^Xrn z%7MX<{^b?m{SqeOz^B`GZQE>Oj{Fx~F{`hQe?aZ}jFC0WS$}SHoz8)A(NLTIA@JIvG z)-%8o^=5}ss>I0^A~r@4Ei1~a##-%bMu)5r)wdkG7JXW6i1FTEicCee!QnSqzYJui zZ5yohdMWr+1ds2$Y^8a7RG5D=Ck7|YN{l1H5}{lsNrZq-9_bnfJgwoCNj~rMYlpT% z9&ww%Y?{E7%kC2c;~6PSIgj*lo3}hv6L$$9CSz??u=#x><1K7Aad)`N$)!19^ADB9DuQ< zf$Uoys=!Lv?`C(|_{Cx%4QN)+ZM)1eSQBLnSTf&n$;F3kDsdE1%T|=awz0JL^VrSb zhPnMxdNh!|s8lFcLE!9uFOClSOx|2G7FHfiip~Ny6fN(G#@~ip>MM^0k-xcCGa#h< zO*;OX+>kP@-6Cn7%CZ;1m1B=*p6O@^&U9FcE`K4F)62jVJDW;Ji3)2NHM;eya$f0R zA$k%}H)ysJog->78hrmtH6D|L7V?BhBd8 z_xU}Ihtyk-532k^k>YzYiLp;zKRU!z{2cj^IP75)qG zBYxP%@7Pq8R-^gY7r;VfSdGWdg)SLa3uf^TG0_X;g@3Zg_Cn8eC$4 zqg#uCjC08mN)UjVsF2~1s*A~TsQ)5GEY*@8LEc6NTR!W&V0feStvy5;K3mYM1WBhL zrz+YhY90PjvHQ2TafYfsh&>yf^~%Ssai=j0HkI!+Y$`{ecdJH`2xN7cIkgVfEVN>X z6+E!*({_+UF@9iZm+>X_ReI&*#Y7ABJ9?@qIIPh2clt-~5*hf;5ZnX`&zevCoF@uck9ax;%EhDKEKfv-t71Lr|{pKb5b7laZ=tA!#s-|_mKXz z6}8>Z?_hT$1=l*8(rKXBEWjidvLk2C_C>7rSP8yPe2#NTwrpl9S?YBPNj;Tj>^nO0g2#G(ZN*l9y{c=3o;;~ z%G!JA-bDwXRc?j#{`!8w&9Dk8nFm!4-5n6;kxOm+NO$|bQo;xCWTHVeS?a3e9pH#o z!yX^*2iR97WIRXD2#FT%_vL)LmMk>@_-cn&U#l7Ku)xRnH|_6P=KQsmIp{6ZBE4|} zC@Rm`kww@cX$KWF$Jf!sZONJP^Yx?AM1hMUQxu1(UEv-3d8#_8h$lS$(M^1Y7GO&E zKjI5{qbuRL>+G`AO+T$v4$b<}bA&Rpon^WsKXu5ulTWABPC2pNJlD~i=o(nM;z#aI z9#lm0QOj$I`)?DDRBGc$8%e>o)`U5Z{oF>vku6f^$&@7(CG<%P{;wgAi`J^>R4U#pS#54F!(Qh0ontbab8X4D{br@X- z1bz`|&miS|SlcOm+8F-G*Gs5QKa;=Jza_Rws>1Sp2WD^!%*bkZP@tic%Z=)h&H7JP z1{vD;9~k_xCgnaP^X^!{50ggeHk-m~)?&48_B{-tc%Pni5rVuQIO9D`_Ix1LW@UUd z`cWgb;4D8j&}9Y7n1Wt(e>H+XTqR!3reei68RtDmgMb}=JWB1RO8BRjUsp6p`hp|6 zPK_VylB&d@;A-(vH8tw9G)2tw-GPraW3%9-J*5oxHT3~-JA|h}aNVVG8@W|3*nwS%Q%#?&wGKcR>+Bh2Sq1-Fb-ikbg`0&ylHa(9 zY;?NaQ*fYJ>c|nzjl|gEEI^yas_pFshh?Y8mphW2 zt>W23t=Ydlps7{h$ItLq$YHY+>3K8MV_F9U1sY)Wi{p@peA9OLnduq5gruGEEl%3K zEcKla;FZT$EL@n2ugPeyxu$1rE8{`(`O2>=BF#PxUeyLkXhJXq^|v;mqk;X&aV&OC z5>!0B1Vj;cQ3^%Kp&!KAG^2S@{<(RMshRWPRQLs7k?V462{W$VHUPkGtpP0~lxK}U5UiIsg1IMPbM7T>Y<&?8GqjoRqZG@n=2NRCA_-Y@d?n9HO91}A?-TLe!+X@!(i-r z-h+5mrC~5|X-+;R!nLgyotj48;ik-ekaJP1IN8hw1 zNf+ZtExSed(!z8d+pFJmrP5l+$hbADFEVk>xDsufSHv337!`nZBm@~Mvo)5yzaQdf zY!;HPKmRAK=GA+dsU0<$w0~XJQ5T!lDbwKd>>hQq4Yr~wEzW4NvY`jucI;TMwaPt= z2_|0}bpegGKcEDwG^DM)mHqR-$oRtHxAASgD=u^|d`uR{s#mbiYDZfg8k&N|9&f8= zo*9sbI@qck(~dVlV{a0en|&g;W*kWFMetvgU0yf&r$c;mF5fbR-E*`iu*R9Qq z5L#c#yrR98-*z~oRTFKeXw8kn&Vprd<%pfW@;XNMQ+_JvO_unsRb@x}mF!S@PK0gd zQrr`uz4)n>S;-bGy)I9wE2B7+DKv=JIJZ2*TH9BhgnX*L7*X7Vvz2NTjD{zGb z+MDnL^R2G;V%f20JIDNg1To=GUtl60(XCaLU)snbsXW>88C)z6<2aV{o&@emp|8b6qJoUQU2FAs~+pg8_WTkptACR=j$% zPr`@YoA{1nXJ*kIXrtZ1qI&oe{GoJ~+Fg?LKIpuAI|v48vzJojzTEe#jMJ9~mVeH* z>~4=v@coJfa3n7+@0$!ALVWb|V?SSkO-1R3uVQA#^1VJJolB_gl{9_87_gmhgIJ_D zDVI&8amm2yu_gS6peR&yTX)X&Ey-Zf&58(n*=jpZ_6G>9EV|ide~@K!K|~{y5og=x zfB>{wYV_|yp0#z5l_Xs|_O`C;&^*S1F^G~i9#w^p`T}4M4Jajhv)l3#oxW69z&@~z zoY}j>!%I#}ej0jTwvJ8EwJnp?oWu}46Mh3(Dmowsc1>*1x9ZU!@+@_v|JV|yuQfT< zuAelip?^w?V~*8SzfTRM5+chRc^a!AW@~qbexRnm)c^tK8iRV9N4mf(3o0y(Z7mR& zZo*^I4FhNB{uD}vUKFP4bWujNKD7>)7P?J_yKCt(`9fEZCG(`(y1cPz{J9S#Dn^h@ z4LM9=j?3|LR=1yr0)DmWuY4_jbQpb+C#6^_H)T>>3TB?GkqwSHDa^n`4Rk66n0wBQ zmez0F37r|;IT6)PlMIe7Y6Pm^i|O0+zT0f&g(bOgESu90h6gZ)%Q1KlmqqENAGZv@ zV62>i1<0s87t4v2U`Q7BG`8P?$d0Ut0yLT`)A<&su8F9BfAAnT<scsd{SMaB_7%me$x z?i2JCTbpM~LK;JA7Qw*ak;Fq>OELVWCoFkC=kG+p5n;YbdUK z1$bwyiD8u%dcTe>Xz$lq{BlIg`$-EcT>0w87n0eBRwby_TG?z{sjuU}O}GM6bI8JU zznOilhy7fW5lvIeq)=1UeV@^1&YkhZU*IZi)-)>jg;bV1Nrs4*0 z>Iv4;H0B=cW5|1%@ozE$-jNXizO#9AU?9XYvqLSxc-iH=n3D65wCeU6U!yn9k#0N- zDK)b-dm#-gOLu6oI>L!GTdd(eE2v(>^s>S)$<8 zGg|TrA28J0ZT*!G4=ts+)F*PZfsAa4Qrsbp?3_0|J8Wr7EBCacA*hAYPhP{^=}ME) zdRs^C)4RvAn+x&~tD@wT&y3;}a*5V_&&Dg}@ zb?dVlZCXnH#7X#QClQM&Zml&S?G$>$HimL}5$`M-(U$?@9vM)aHTom^-K?&I!yt$w zA}Dye-q3S=LYixdPeM~t_^WH&B84?8kAtN;&C?ZTi0P&slD10yTZ2K-!HIFx!`8W> zxd`}DJ$8&)t{gOba`kdFa(yKdDApaxtZje$$2-LGXj|EU4QvAE_R30H!^=4PK^_M% z+H8rvC?PY{UM^5RcE^QeTJjRoe8?SzRL&dDaE-zEbOFbuy-O3@^zT&S$0j^C2fPTc zESk}$2iRM|!B-KwqgMv&{9M>GEr3M4BDNfVh`-_cE7LYZsg0QM`~}!r1ZE<{0qdW& z7BQ;06yn)ULOw@m4o#GU7MHG+dVlF(^8!x3=Rf!RULqp8W^Eu{(U*xCr@_gxO6CQ{ zDT=#lF1M@M8_QDn#s+pwy><`oY)Nn^x9G~>gF42l-oYa@%!bFMo_y7-qna_;2P@2Z zIPPTEt?(@MigeUQN^lG5f);wk`jiqWd8y6+@s))^)MS}5PpO8dt2nBNj)coO5K#d{ zQjhA%{P4>UAH=ya(s*3*W}Wi~ex1n8yc)>95f0AV7=Fi1S)*G1hy>;fV7Lfx%V(Us z9exgXMPLR5#EyM|5|uJ~yc#=FOtgGh8@KBVg|+ur%_BXwEAWCAMHxW#&RVVLI_O=F zNggE0lA+o>aZlc=Xw{~A)p3;H0BAiK#VQ>N z)RY(t<*Le;(g=PXrr4c&I~sZxqT(`XoY$dUT7lJte+^|g?@`yf zW`8!)Sf1_h2yk5+RPk1Q}BU_cO`t9PfU^G>px>!79mwGXAccjD0Eqpg#$ke3OOjVJ3KG;JXg1u=8yFD@q zz%yXsmQNy{-H7gaDQj*b zG{}`}T0GL$zoL#djgohQI4^|^=ev)_Pk;23;6TX-tqEW!dOQ(1oS*z%pT*Oo_Wq0z$y-XayP>^|tt#CT7`4XXq04PV`U z=N=`9vFp>KwhLlIy`k5}q`nOLB0F}|THX9LI$Iig|7vW_#b*~8me!#jt#yB)-VZ7BFg%3zc`h1NF1c(mSg(rWnCxLGXO`Hj@`qPehHiVO26&Nb3{Tsq#I^BDjme zlOG)rW6q5`xp%gWdCXR-7tI%M$U#N=wHH!1Zbl8&zgkg>ZKP=0(KYtZM`Lu*8fC|Q zZ7PGak4HS6hy-S-a8wE58WXz?1jdTxYw)$vWw4f=##9#JHRY`^*o-IPp4hqb|sy1xCWVFtz?QdYJ?X7AZpy&Q=!eH@6pX(Lz+vpU0@; zLdpQ>uN!V)f-+wE&Md3y^mum-(A>*Rv z9%OB|dLom`QNKqyi^pu%YFkQuL(FT4xI?k}v5KbU^5@s*Wzc7BPZaXh7}|!id@mnR z?ze$tv^Doc+WC!gE3Z^@=e{;K_DfPGkyK37*UR>p(4zkMLHmJ&<=&}ziots0kUPA+ z1R<`>jeS1L%l?3?zf?-MN5ls7h-A2p6!H2~?)SELK}5Xs zzsgJWZC&{&~tsq?&WZ zg^~=j zOpvuaa+R@*lJ~3}l!q_r_I$75Tjv6j_02YYC{6q7uQG3UAqEBr9BD|QH-0gx|W zyLKok8Hx`znOZB4D2daJC+>H}FK*2L6;tt2F3_QRlI`xPswigUK32Cp|5ZQA8WU z%1HyIf*b>YceqV+fRPm-N_7mo7UeEDeo5WZ`46$oenex3Y;gG0>vZ?F{*Fn+Rv-6* zj4Hhw{$;*$D>FK)Fs~Gif#!wb+A9$*k;E0S=#0CSqzk9b)3WNYlP`sJMyS~q%THb+s ztR{jN#VP^vEVRtAUMl!|I<3)&-RRY)iSZc+7$&^<4@{QAIdu?FHC0q}Fqc!do1vqJpEu#y;wK;X3Vj>^bvSNzLwrr5AhXg7xrbthzbf zN@MF`sP|+T`25*smqIH_g4fKHdGdzGyh9069d9CSq^2B}-O%R)er4Ie043;zkRRpf zE7@SI*6A_!PD`PVV$>XVPOMBEMp{6_?}}=j3U?2Fzw|0+G&<#YRH0L*`116p$vl6P z7$A7G(=9*2-?>#S&#E;0h$qTe>mh8{)Q9JHgo&(4=Qzw-7g&m>jOEi)R#->jHZwZ# zlGid%aStex8PEBcRPAG5QoSqJZ}C6=3DU<@$2N|a_4o##K39*4h<4js6ppZYrA@lI zgK~;;QD7oA&6vT8J>qq1%ZUQ>*ZjDhNUKjR-P8o32vT)}V#$Ro0ze^L=oSV11R8jT<*lpE({FtQ=9lh>1 zkTlv(16dZQiCOfuKiGKSFqA&a{JP~_7R`Rmc&rQrdTDejYvU4Rkynfx^@3MH8F0Cq zHQ6QM+3yga)ei|W*+uOftc;@!8inN+T4+~}@%B|loWbI76-gYcL9`PxWot=we zVcqc*(539M(p&vIno0-<*HE9{piFl-NY41fwc@tsSZn-#N_h54kIdry<}qR_@!DYk zpj9fkn87jXc3)Gd#%cv#CMPGi`?`tXJb@!etA~FyN1NQ9sT_3#)$!I;w=_l;S6N}r zJua^tN{rTYo_^fezkbBl2*5kD3viNVgi&uW#X}np+25XSr!l;Xg_cZkIMP$F>`a(w zk|kVMLmfx?ei`YXku}xq+PKD#v;gG#9m61tB_^ByVmc7%k(qHqxkyJBWZ@jO(K{o#PW3nzjgGGrW9oQzWw=U??6^ifF;H_~ z0$D`ifDuj!?B}chvNp!9yG;Cqn7b|fx#N#oDmFe&cHHmop}TRE$C%uRYG59=NZ$Gy zj0xSoI}lFLOvT?YBowwIK8&_8o)nnda5)bgG=}oiwG*SPatCkKAzXVaBS2Usk>499 zB6giCzdBMH(}l9{DK0E912aOI;pIWzE$jcj87}s|uUZ!{4dIe3Ic% zLnPR1L|Z1zg8Zrg0OM+~%JkOJM#h!}lLTZP*OES~VUZVxSbE~aWs7J8ROc4+zx6W|_w{FhBWw=YC<{oPn9=awO=$J6Ppx7a&J-sX7M>31)RoSB5_yHXD|}iRFzjtqJ~SI_^DIEh z=iu5+%^4unv%(!H#wdcQDFO)ifGgMS2c}x{n$<`b2BUj}z`~1EX7f@ns<7e7nxcl; zQvPOn0>tAzZ*Q}<15$H)3747f70V9rwREQ1X8EA~$4Q_>)O|%ETiBuG z8)=5Z8etN>0%O=4Asct2hF}?+;q0eL@l(W7dq)PXRB?{C(*OdsB7E{pSizz5f1|DjQ{R2(TolsS(<}K)>h?c<*?VX_eTL{7Z@16Oq2qt@Aqn`0 zm-NHm?jM#Riy!d(AMDEBKYf0%XD4yQguZ0>-^Fp`|2gpP$-sWw>yOdcRp&OI489Sr|4flK50Vw|ldU@xmK&3$#SsjK$#mGH=wpL{ z4)E^B|Ve@!#N!y{e(cg@S3BMpsnw@N?xDxdY`iyW|L<^79h&>prk zrKYwn@FfBnrZdjR`YQU5A8C0#VB;b4`aqTvIUvUVu{1LR9BAN1m#ApESn6f8z9V2p z-w09lY!QfVR}Ot4m&pE(`j!;l5YV>>i#QILAY?u9ofh`yiD!Er9}jCB{Ts!SVmONV z6yEo-gyK=%bjVfrKa65bSnhv$AW^^c*l1Q3h{bzjehX~hToPoZ#Dzv0@wmwUK*jiv zVatZ+BoUj2jKluCvUCV{%+8nbC|PxzowDoY&e^OgnLVL#+F8ITk0&sHajbY*vSV{+ zkA}(IRC0_G-}6|Fsa)=r6H$+XJ);p4%$}sL+o+Kb2YYIokfY9Bi2_$$*cZodt6{^$ z2`)Q1O6ZxBjY9Xo^On52JR9gWdp`HHmA+nG{PxCK4y^NOl#_7%pY^YP3Fa2gO22CG zdemamAeP_lo>h*&?Vt2Zm>l}nr4*I`ne{OOfQRS`G&PeDwc=5{3Pjt{zowP#?%@P6 z72jr&u{9kLhEt!0z=i8;Uy@5ih7g%2(=@$(rvFg{pI{tj$O}JjG=&y-NIY>Z-D5fZ zFg}|*EzHwvLu$}lW^;Ux+vZ!ppOZiIAI7tJm1!KNu9y;B_Ruu7p+wKLTJKitE}{dr zFTJ9Id1!aP;DUYRd6Uo0W)`cLg-RZ~dS2W3SX}bNL8>E|f57a8nfYkluWQ9)%bIB- z*PK1F;?jZ}5qBMwu6ErwKQVOUz<~15uRG`|_f4n48-au8)c@#bMXCTdZM+fv;9H&H zZs^eQDf&vhl!O6AI-ax}WNpyl65Rzm;$JbEeiF3(O2yr*Q~0=lYsrRw44FS2;EvBi zaK?252HmZqa8EI{yO*QG2TSV-JvdM%JpUFIu$E%%OXxhp_x#xBS)HUeJbH_6LdOpH zQO2yiRUHae=vZ1h|K<8s?=Tw68CvZEo1fP+dm7rSsXsq8dZjBNI0I6hi&FSQJBs^b z>+^iiTJD;{xYHvQ#iX6CrnU4wWVbQR`jN_r4B5dhH<895LE#>LmYwQre#oVxd$O+pO3HQdjE6(G6E8AmItK%6F;j^cn zc_efYv(A8sU9k=y$bW8by_Z|xkczwV1=}6Y`l1A!x10HZl91gYof9f%;bdMPix-ms zD(*T|DW6p>U!p7gX|&s2y*3KH$$eI6WU(zvoR#uC3?2dYEByN`l!;SZgR z2P(-K@fykiioNRhiI$+LqBGeV8G`|zGqK$R!XWr6sf2;zf{mca1pM^xpfJcP>6#cf z%J_ciK${!RvPu8k=GvXw#il?)DJTN6s^e>|&ScY_d!zbXV9evb+v-<}H5BQ1no`G-6mlKHN{%S!E5puh(?b_??D>7&F)_?tSa3WgiE}@axFza5{MopBI40$NxH$?n(YGQ4IU%>We}5tS zE6OFL7MvZ5zPHv7)D#m=#Xg*qKztRzT6E;I&;D?v+nA_q-{OL&0AH^ z=BKL;gmx!jXC)3rUFI6AT|GYKO$qZDcd6B_byX6~%gYSt_Pl~(LZrc6!b;47&mp#_ zjZlE9M+|B#3yq2w^|jzc2R5DytR)c}{Lf`YUA+OMzYiEQjd6GRf}X!J>X6Jyx^?s5 z(QUJHtljQ_zAi_h-ER%MTQnBAyi&8_>W(#g1GIcPo|i7H0@UgFU_*8LL5q{l9bX#i zwIm$ji@VO%XUR;U)0|R>*;=Zl4RrJT!@7mKSb-H$rKryzc zyfZG*k$}#dt>MaD;V#i96RTfo{=OfkB?dA!{%oaDi0e(Q{p6(El_%UipCsCi?3U!? zt4a@1Q?;`HP_(u1Exn}s!IhkI!aKEdeVJG-71=h%bej|BWovVuFpr`C7Suj+v1!rP z&SWecFDFO*>>AMLig4iIaDg(3r{Eg5gnUBp?>t`jpGQ_kpFy=l|ICVXjoxY9Djw1` zrzNM?$qF8SJIAdJ?}smZdKmApO-P<+8XtYbJo@&Gd}Q)O-I;<>^{YIt~syC@FuDwBS9uR`0ec4?MP1l{G;_1p)Kb{#`HdD&@MQs)M562-f?5845K(Ew*~rJ}QJ{V^%3y zY}}U9T36_b0`z|JdOhwdd2wjQ;SCUyBa$p@E0k>9c76pE_4>@%L@+c}b8B~k8UviK z7)ybKjj*?qV8Xy(WZq69xc7>TVr6G`J=AkC+zbZN_6B)3tbNpNc!E?j|2B|*le(j~ zGbgL>j4e2%6vT7yP8|vS=E?|vb(Z2~*2I42 zN&o1Rh-fv$Z9cv--O{bKu4)1|+KjEpcqcOZRJrxw;;@{iJzvnI+Zy;D`c0nu#R`LX z(PS@Gd4u{9r6i*%1@JCw3mF*ytZ!FU39hvrxK?gjNcajKX(P73d*VdL&()p za{5vedFEPdq>_M_{~NU6ak4$_)bVUAoI!OSaHc)NdkbAF%(ghi;yOA`CT9+f}M#ZXlh(#m`1nV}{IwSTfF1}A= zJzf^oBI=mnRERpQlWmtiwY{c(G9`&^wX@yrwANTF7?A?;CDR#|Bfq`vn_sJR>vEYn zh#XpHu8WQkJTL9@0M;`%hnopaa_jRuPc}BTOrX*Pdo`i-=8;((GcgI5ln@_xrKUM= ztzePIw0YDyqvW9;;ODSyMbEj$?0R{Jjd~w-K~p{QY1cBjwgT-UT0VF0g$*XCpSvP> z&$#7=Uw`c9Tp>K`DRlnjOIL;YDIhq00M;LmH};aLxjx*#R{D4&=N=5nbx=GXjrY0H zqHfj1dY~t2!T$Y;p#lq2EZ2iL3)GBq&0&UsUhq6wQ<8=Y^?B1;W@dbKW2aLGCCm)J zxbh9c(Yi3Wjla}=K>DHM$(>pE3w~QxIUz0!%pNv~+O9%<!S zB-y`ToeaIbVc+`cDe;CD7_^4j8tqaq^UcuI+TG3IPRFk;<;i%AM6a5ja$fq>eIh$J zz%ZKkG}OEPsP+@kr`C7$j8AvmLbuuQ?kmC!eI+ihC`otCOg)Uek%i3aBF5|Ib41rvzXm9FlsN7*&o`^me*(JPv-Wo);9uDEpNBuHgTAs=_{;B7;*~+Aun@ieFdtMH{(N5Yt5~>@f}a;*tG@U3FLcMNJ8}~q zg_fYmW}Iq7^`jF?oLCzbqNa|xa2}QJVYgj;ubxB~21&_0R0YYy*Vi1@mOqHipK>f; zEx6Z8)ExWva(IR?#}7Z7-Vk<)JShhnPOF{yULv8Jph8Grt2d8TvQQ045IN}SVAv>d zXC!?R4CpiVVnJ z!F4-$KAaw;B^3&YirA9|(TG9sJZ2gt%dWo%Yz6c0S8h^GNk4LQ94Y#h93Oj5x&n6o^CsvyCfIpJvg|7Mrp;R zJ5LNkkuD&x^`mixZGmO{jitFy!t)EcvEAu)`qxg+?iW{9ob6a{xe>}g_Ia;|2^l2CLqV5k*^M;h9A#;4hZVZ^nGQppzY<;c z^dnh?nV9Ry0q(HSF|MNXKj(#Q0Lfh6jQX6>vYK$>eF#=k&^X7t_PSpi zvtUtqzGfo)i-ue=(&+s{#3ugIb}1KMoW(NvKFJo3e?YtShf%-L5MB&*6nD!Z%ExWa z_=$9u77=W(rh@`-1?i5~RuhbGXSN{oFHaM5!@`bcg$72l`#sl24soTDWH;~mQ`bsY z1HT@)c1GhOviVH(&0?@L!AM4SO+rs(cDw^uaO0;m|TG= zg{Fvgf2F<2m469}l7&QGDw(#RY&^3IV2ebH(TI6S%jA{Qg{21ZxXV#W5z-E)Yc25} zn_`UfuaWzr)E>~1bHtU2g{;#hZwur4;)!<8^b!!>qgz|dE3SP|&K%06Ud#UEDaiHX zR&1J~%j#PI$``R~8o6mNfU*=eOltVC@|J`gyF^P&xh%Y?#yYe%oFN`sBw(`w|6`DY z`4C3y!Jgg>HQf1L7}HD)Jw5md+#z|{PEIyNOyQOvVs1pG3KcIM`Nu)N&)bg&FOj;? zBwAVr4d%Cla!$c>uF5>*M1|avH`3z5)?zx2ENqBBUFWYQoh560|Di&2$?nQM75)2Y zordB?{z-6Lu6E*E(_?@)wv-A@Fef?ruyEe#iz9m8Tf7MfSBX~gFFm6aVo{a-TH%Te zYbCYzG1DK}$O>=>y3^_LQS=AFv*UOSxjNRFJ=AE+TpTLsthmOJ>gQJ`U#TQ5R9WS? zH^)r&3icHOnFI9^$wg%e=2C zX`gK1y(TnJjNfWDO9)>nIXJp^uK4M*jTWFfJ1UH; zRogr2B3HQc%VErpD_sDtyF=6UlyNOLtg~w>!ag^mKO~8(vH}cPIuFxMPE1Gj8SmVb z(OekukkPMVWvJ0aQI1;!Dq(C$?fQbw{0ml;Gwrx?x0AA;M0#FZp!#YxH%_0ZxJ*l+ z(vqOjzE4D7Js_x8Gr;Z-}>s)>NBzD`1nMV z01hlb(6mR2b9G&+)NEClpH8A4K2JECmm8TflO}~=ipGrivcC3Jfx+)A|D6llLeIw! zTp8qnEJRN}hwL9D@G^3Z%hX@K_fvhgg zb04KQrK#-k>mF$}5~m?q$79OvbE(19aShd=#TqX??h*P|!|k4>@LQFFq)Fe}>Dn8P z@SOo?+s-{t_}Ossui>tV?ybe75Z=owEt^0;fUX|x*ZgZ;{Y&J-)|P`_-Qgj&W`l=+ zrgk55oPPUTdWSaxe!u-}eBO3`Z;vC^+RMJkaF&Ik zbl=a5f3P}~Uw!N%olhaJ!qc-Ot?B1d^04Hyk@l!MZF3WA95!s<9S#9fyTaWm!ziW=2em;IurR143Bdx?vnxR+G_;{#G8~F00i#PljV>S8e6H?Wr1uyzs=WA4XDR@ey z-?uz6S3Sdkq4&l0Lo7;zIUPut1=0qVSP>YaE(_jE`8N=jIf@FF)bmEr;s`?zxBiT* zE?c@vU#>?dB`VLV@JpBjHI36`9mS;pkOW@Q&5gnH9abz)*JDqBxE#XUE8sT=_=OZ# z3YB`B$zz_QRn-B#cL%?!T6f&g-{)SNgNdUrHx=bb;r|v<;^SK#)Fs=G%6vGmP~hOH zAq&VVb@G>O{qdoSibD-YzrI{Ifj01_2q~O3qAxoDVOh%@c$e){r@P!vAFS;b zvOR5^y^Tfe3MOlAd$g}1MQew(MXQCJOT1quiEF4zmAbOl*Tc==zMl5~-W?g)(*i0&Q%L|1;UgN`>|hdFkClYHUtij<*PoedR+8ol{4^&oLcD0 zxop2SPoc*p!4-zOS*4#F^wVV~o5Fz~(q9WmfCuzbAwL&kgQL=+{M5V1cHh_UkSvn# z>46(@)fKlQGVCf4EMj&dyKjNv+ca4+@iQU~S!Dm3&-%T2!JH>f=fZQrTid2Ul@BZG zV|7QKHkap&>rzU5_4bd9T$}l+hwh$M?NLc(YaGU&Hjdq8S(A^(m5-~5Jv7SlLE2QPs7s9$(jF+H zKw9eciIJtQ9;Vk41yb=Anu%HpXg-^oa#9fk1qC%N#V6WmYKb=Y7{{7fYwlY2{CUnk z-~RUA-|zSRzP-*md;Yzfx8W(pFZfK^_Qa0^mOZUf^V6TxFD>pcj2kK7lqTdRxQNt8 z6+s|AUJ($++6?wI-!?*FlXAzru9bZ;ks@@UEF6)R`RmDDi|zxn{kk@KigT(ae>zG` zG5JKve%SHl1X_Uox0g;rG3J4H9Vl@)1bq;S*K`zbtgfA`A%3raU^o0t!pzIr<|3|T zX?CH_s`D~9uZS`zZww!JHqmgAEeF||yA{YCdlfB3ZuCsSOaK!( zHrsvgSh{7GTm3=TZ1zQ~EOEzUT$AO8iN5-HKDjTiJia$d8Z?7R2PEV2ML3P#fM9OW zo&i8K$d{kL@g!mxe>O3#`MYO0bQ5U`hRkOy+8KI+NK)jMS((@!jH$dUsrLaFBw%av49d2W;Wg!N7sU`Ev z*{<0yf4!zt`LDC4Y6G4q6qFD$;%kVeSuyvA1>B9Fe6qX*U4gez6?_{GdDPAvW>%b+ zdM~6oyNGh1LII*D-7G(0FVU58C`GiaPl2nw!RLE~)c8ni6@3rx=-o&W($Ay4t}1x6 zuCC{ly>f?gr_wt1P!kwD9gWwa1QYh*a{$kKNHv!F*E(+1wtJ6|@J+peqlAFgNU}h1 z`>XNKK3a&K$=3wDEa7k~T}P#?I(-x1r@WZA*G%p0m`qWPdX~JD4lbQCFkU*!ZTd)^ zcXqGN9CDFcWR<|SJ0!#;OyADGNtx?5a!NgnD>S+)Q*DI{ow`A3j~Lths{ z30B&cZ`=vpx+--mh%B22FqnnbUaU1JzX0v0z4G0PWb^-9%B6kTgm^3K1meCcLTHcs zEyL(>CmQ>L3e~8X1Jd-bZ(rQNDO%}!h!T!(O=O6qfgkz5sxqW)_R9Qlws^%=p*7k! zB^bu^U+(VU5v3eh^4$$vtXi9wRP#a!av6%%Gi`_7DVSkxW5g>f_14%)mnjJb!blQa zc=s}>-rjqJ{!9=*Rlk4ycR!2Sb-;noF}j(BWUume;N`H=4{J7q6)IxMWwaO2zup

KY^(L!VoKfr1y#*7iJYuSKU=nBMOSO)r!Sh!CX}qQwHF! zfhUr=mNmL9A6QvS2_rj6V6#Zx8$H=W3a|nwO$Q8W6S5&yGKPJ#fOgB-ZM5bG{T%=C zO3cbKc$NT8ZL##-xU?|46EKoejgo5A&&h~4U?t;k8ZYrdY*1<3SO~*OQ08CDkLhjO z6xznvSJEABt=!?S$Nj)40I|`jZWZ|P{Xlme!)8#q_-W<_uX&m>r~)BHa0i^W4sN@- z%=XZ=`Wdr*9OKyuyMe1ZZ>!(kx&f#uK=`@H3jsQ3Q$U%)y)OXb*|#rtIJbLu^}VBM z7JPVC3Kvy?XFSvjWAag|<0_Z0J-j-aJjzKqCr3(W_3dK9;V{37`){KhrW*hFOp2Qk z><5OXfAKe?-yf$_Eaj8aExUH{`DyOC@U$Nc4ssZx#%Fcmw-YPk0#-IIg5;nZjW z>N`D2*pPMd^*W}3Gt1a8T@G}QHtzYcPxP`Sy2QX5@5Y?}JRvKM*Tul;B5_8RSf}FQ zinP`NA@g)$2RoW*0zrAPY|r;pPaMoIub;!f?dOOBZ(Rv_S$$PjC0D#J^~zTT5NagKvhs(@l7R;m|(@SlmtDQSeq|&smf_Z?{FAIanawxhRO#BF9 zUv7bftEFz~yPa1H;UY8q9^84!baDq@f5dxk$bxAl$aAj4O$^l8o;n+#+JLD1snS?L zvMkFBZ?;o=bLP3op&TkRTH;*aUxH`Bj9CT;xywJ|TD~5+^WG4tx|(T5BcZl<_L)jA zJ@A1;NUC#xVOOP1E9sxZRVbW$ftmUV>9|a}vAP@e+yiI3i`KfA9i+a0W~tLbqdh6b zvoahD>m?aMqn1Fx`ToIeBvKX5{qV*6v`&Q;!jrcXxMphmE_tJkGuMJKwqQ z{a?MRH&v_FthJ`5duF<4^>p_ySYB2f`6J#(C@3goi60`0P*CuKP*5-@AK>2J{3%A! zeY-*1D~f-IDjg-*e|vy66_OExf~o)`KIy-Idq%MNpI+zZv+MPnj;}1 zr0k-5v;zNgdYTyi>{Mq7P}Wpk?f-otx~0z2n2I_13+V?d1sm@dOw78>Z&tQs214(l z|By)C5LFI+lmC__-v~OcX?amE>^~gi~O^2MCgJ_xQ*)7vZWI$c`BJ> zWRJ_PMM?UGD5hkI{@FA73a1J^6t!@2t&bdTr}E>BmH%u;tI_tSe>PI!QhN{Z9{iEV zhD7a`RJn$?Q;jm!c-e~f-;GqSExZevWZ5zcDDDl8<(uA@kQM1EQj(MYqhwwb4zl|I z9_0}13t!nR=>ORRx(cmIHG=kiBFjLWHlJ?|8OY2kp%_#0p9532QtrS@KUiCSt?W$N zq@c+*Kkgs=@(%)}nHR;9vrr>$aAsCW4*xX_6*CnEsKRm5^jSf(Qr#F$2Ib?*4od6b zpnsIXlEOLIQdJn`0HzX|HIqPY3N{9wA*Xl`ca(4c;y?DVAQ)PKpM0TK+v zMmHTDw<{xVJ9ru2cOc!*m>QaMk6dPztV@<0QEJ*Eu33t8#L$;$?f>?Qep)`-{+sYb zIAmidB0BoBk%?w?@`YTiMq_>b7ZNIkA%&HGM=I-~?ro~Xr@!cT{eynJv{)96bgofJ z+2*%>CI+24N*lkGwEhg9f9=U>tx=}Z^$NVE{nMsCZ^Pve+>UxBd*W5FkjLTG++@rN3nIQ5{HMQu_kpm zbhGM1Gfy1lJEB0D^E#_}k`LMW)iy>!T_Yl;#il2)cda=hM+or#d!1EOQ%{I~NGJ>u z(tN_kCfmfosOFyu*NwZVmDWzptf+JMSJ9pQH{lDH<(R(H+>pl8xUKj&$r`x)xDKI$ z1#^l=Jfe+4S0%=t z0>yhU7r1+a^!>;~CR%W}SI9BO>Yf@VkvX0UCS#7YuYz!FNIszC(uBEM;_umct0?0R zIB7`{AVx!vb#f;~2f#2DNLJOU^1aixjcO~J&5ImayHWSlJfz{PM9|JL*DAr)ZaJ!D z_Xk9E6W_1pa%pqbpo}DO^m)J3efjq72dCn)|F80Rx1y|Y`y5Gd zsfepuHB80ID~n)OtL^^j7RZ^$`#68UCUbK?c)RR3o$D&wo*jKEKwFg!%XeVTM07yevk86x(pkgG->a<{#pC%f& z;VN&23LN8KUYf=MHR8sVCD4V^G}3N6T*FT;0h7RyD$~tu(;E7}$x;I`Yi897=DyhF z2WUbUa60o#41H^4E}7X{c=rry{P}vJQy-tPtt0GOY^<_4G*xYmF6M7V<&}2HF+C)|*#q^*_IXo5=E)-k z*A4}43XLt)RZ*$WzvbTi?4YXWzLMwTX5&z z#4XKAaBy%vWV9*fB$62?89fcH?7Bd*lAb^1v|DFnv*Kh|g;Sv)%FwDuhY}wAg%yD5 z`vtY;oy^01i+YQIj3`neieiLYx}i$I0I|ZURmO zEu@Vf^Rm+t^77!h9gn=F6yj{J%y0@-E`_2fNf_~FDA*FD-^38@)2C1Jd9sYYz7__j zs~$mM25p=6)eFp7wz;k{#1lfIU-=_}wh}|spV9*Mmgj#V3zYUs&<&+B>%bTOmULS# zAXrx{p*&zO4s4w1J~wF$naYcR7>QVBfW5SGs-%6RIDGM0zqh=7yp6e&4GHO9II|Jy z#sU^>T_{g`w2}8UlV|;LxD`mZ|I)vcDN$Dyi&^dfeC_*knTp}}*&JN<#?yWTji-rYmxdcCR z4{ygQF~bKZx~gi}h#u3mHNSv3)t?vja<=kAt*v4Py%!T^PA({LeAtEC3kScb+N6bv zi@T~H1-y?b8QGhW!Mv_t-KK8?lje7STXoI^0q?FMW9PRBNgmc)NVHz*R4A|RG)JwX z==o`L=uft#5#cy9ei~G>&w`v`eLbLe6Sd; zk2rM;fM71}TPNns4InCHpvf)0wGDrI!~qk1>HGP)saKa1%Yvb$hk&k|-Iv5UG`-#k zQejI-=+{{Yn4xu~A)JQPkS5G?UjoTe7iMNU#&3TUq4*Ud<$igKpnO(C_HVT+oF3%f z)5nL3c|gUnL${^w*md)t2n{ z-d`rN=50aH4@k{Sn5qsfS3C*}xL`UEKmFScDJBM#m z=Z^!|rwK|Xy;Hmo4w6EdRW!64fC`5d+|RkImJ$M0x-D)-?|Beu_~?*}=8C5tKB`6v zcCyW7xv7QW?D)4-#cl+}s*po-Z16KZd##mzvw2|F2`o(C|H8Z6LP^Tu0XFV=NFPj# zByvU}x*p%&NgB^?v`^g?)l@87Ur#iiC(^j`Hk62!p#6N{xF1R+^R%A4OA?Eft&7st z%eI7$IS$|D#`SaVmIgf+xkj8`PITo~%5GRH=K^UwsGF6RCk-kkih?FZiftGF=}GU= zf|D^5g|v6NuX4!`?bb#(=k*+GRZ@QXps0&!-kk!$@36_7D@Rz&y+oq&IMy<7SJq!4 z`aC4k=yzdHzp1VBPtUI7UF>9T{R@Vn@~60g%%N4A^m84KjEpCB3y1FX(VM;oqJhCx zMnI(HqfR4VCcgIz75xQs62U{UW~ z)tkZ#jyh~18C3RSoIWmN-??-OvN|;WN_qVia;x(T*_0W5c~`>y;@Zdob57TFw~R8* zD(d{2=Qcy9<}<-s{WkzU4;w)c0GaUpzpBvBp8F_RIr&vo#Zy9_;*#zPe>8R%AoY$%4} zE8!g;P3ZtNI`a-WiPIT^x|N0ZKK|;Xne^c31ghRJ{xD;$vBl;2)L%+Tu{1;VY~Q!U zPJ7BSw9tu{vHc#Wh4iKJLaTUHD}$FZBWpxMNpCMO*)d};`WrUMfe)R{YA41tmej29 zsM8j6*v=7ne&?v*zAjXOAb4@)zV^}U^*^Wl3$S&Aw${MR>o`)}>d%+0H3hS2ff(A) z7FiN`sW@(9&n{=HR{gi;6?SWCx-)Tuoj3OMlZ9_u=gsqwnV{Ng#gzAjLNt5YL0zP6 zbpf>mZZ%X$Mki(>G;@AvOCA|$g&(1n_%=Q%ZpCfp;ON9sTFm4kjvhMauSLW%@Ir6zyQs&zB{=9&6v)gwu zB8W(q*s#e6!to2(gjV|{+iI{WXVVyU=>Zf-m#MC>a?RINCa=8kRk;G83Uc&<^_-Yj zL>#ik`u9JZjhQJ|R1pyl*ZT57#68jbYeC!3@PXAEs$IG+n1-Mk_|7><9^2PyZ4lm< zaqOT49{i}h=HDzW&ssM+Bq?9l2ejV(L1!n9B1-k<5J(_fy~UUIGGR?sM?<;0?Yuj` z2j&Qd;Vej54%pDT-;e+kfVCC;XwRp_G`)rK@5I9dt!;bIUUuzqZad-QDQ1B;#i)$? zF9>&J+F-or9#K(I9j<@xo0-&|i*{NHN`it=nsruh#%DNL6dgdfX;IdUL9y&%l&hD{ zauD2Nizpp|Jf4vNPk*!$dMWNqGWV<=|HZ6q zk#R8r4E&4OaZXTB)#7J=Y%HhYljftG$V!f}BjtG8kCOgLt=UH-EaG<7K`&${o#{8% z@+0qmD7}+2_m*Otwwl4d4Xb}2zI-fgT4m-M7{h4%p7{tVs$hW*hpkz_$^tLUf@suc zI{5rJJdgaa_z1Zuo=V`RcO=1m+*V!<7Pq@U)`j5l>*uxCGZxPWiELu8b}*vT#`i)| zF(HK_DF#-S#iYRJzecst-PPT z)7v5Sa!~f*Tf^mu%XY0g@51P>SY2Ej``?cmC$?7Z)CGzN-f$pp()vUg2iXJ-^ZkNm zWSC#8L_w--NP}nN80RjVYu}!%4>5C=xOE7b(u|#F1d9&r#$ZT4O;#LPW?m3Ezy+cv z{j_u@&RtflN6WXAb$kFLmOI=t7vF)`z$6= z8L`xC^0k5R{KVP<)3E3jdbMg@*mJ>FDi1;{BnAsTjXLU&e4c|VNPzA#b&qx=4|)76 zl!*(g{5M%$L`XG#>72fuC6gVhF@4M_8SaZ<4M*SWF?_a40brJ_eQjiD%(N%P`gueF_H#V*FNaq2~r@C<;Ah zlPAIJR=A_+5I z58*Xk@{6`U5js!WB*WB;p0WcFy>55vDDP!R8LD z;Is1V!B&C`k!zRaY4vo4cHZV}?RLQc1sC|)6Q#MfZjj84Z}bHu#4p>Va>$Lt4IzK{NWwGWn72&as3NL!YlMPt+1`gT%SXX!hrRe<@UT?j?M;bOU3S4QG)hvSf zdh@DT{+2n{hJ9q%#sxL~I&(>i3^n*?{ z%GXGbiGx;WMo7kFc%_5YCnVGEFP3>Nd9jJ*Pg%R&4{d>Kc73&0zuK3^D>8_%M{|FQ zsCru>cs}kJFRw7}-tbiGW1?VxCaEb@Le|~v$$GAO58J{`k{u!B{<8Uf{=`Jn2b_xe zIMCGA^VdVKv$WaJ5eOdB$ z3@;TBlarhTy?{tPbii?STF<-Hww@-54xIbh$N2Fgyv%6IU&0j!*@&7!&xe-?4Hgyb z4TKQQV8Ab7c$@X^_jD|IEOCZEeHgfr@J%qxly#C>-aD_cd@7@3*PqCR`5}t7cvBVb zz3R(uw?TUQ(|@_Pm&C>RA!<*HjEE<$-y|UJr)e`Ww`Lsh)v}p7qC+BdTC=4OdjMij z8B66M=8$xOu!=(>ix{X%b6Ddd&TDbwikH@$QY2O{hZ;6w>+YJ_(Qe8}b7jao!wv(A z4TdOf1?D}3LadlmD}!b0;?FW%z*sh11+C(H2T?ZWyyK(0|8ck|-_zbfoQt(9q$SE) zZVF>Tz~EpBm*;Da^-nkOLnQ0$7G+|Mb)ag8F~N_^qHsaLf-eQS=}k#bWP<=? zsjRJIj``UY2VqbU_etA(J5burb||*TVCqLYe&T8=)-Wn?2gSayCf0l2hUxr=Z&b03 z3gy%D^F*eoJ;ioxYHS3HDQPr$lRaQEyW$6l0ntni0X6;U4M#>oo-P9Kh@SID1j+S+ z_W``@ICLx+XssvC#hfO-t5sBubqtzX8A2S$f^%*sL2GUA5Mz(pDN+P9S0*u#jebt# zP*}A#P!%S0mYZ}aT5>0$w3&F=*h^s(Xt5Ay@XRQVh4P5rCPE~gQEVsbjYdBY9mwwq z=W3Q51aZ|9@_>8Zy&c6GJY*cbg*~nam*3ZfpL4d_(>M`<11p@ckxsOT?G$FP99XKr z_CQQyZt)1F z+=di`IcD-zPd>CXxv3({CZK4KJPOVz0GFfnPpv|GUcObuCdurCYk&5Kt(b^TO!q`_ zsf=>d8d>%Wo_A4QnXsy+kb3FF)^qn44UJtN6Tmji_~G@^@BtBrzuRW-#$Ph%zeDRzLGGF;r(qmO88_&RDQ8R$t1NlP3H#h*`rGX%2G+pQ41PJo zs<*1gY0X-;`LI~?>sjal$m4>#xAmcp^8@dMt6Ay!6xi^kN^ZSG!@@pO4*UoQl6IRu z<-p5XXt#QX(x{nvS0S}v9KuaC`$}$Cd=WlL`olb_MeG(dF>?(&8xlG-jw!B>(1-xZ zlcUo;EAUL`T!AW;HRr6*I4V25AsZz1)2;0=sY%dw?J)IXNkDT{Jo@@I%Q7|i=OL-* z(@%PoB;JXgiLvt~4(p$r<3#y%WM!_}ptNd7<7W`gWj{+i?>6Bu>f7I@lu^Aq&V83; z@x%Ai(UEm4E}s;s8APAoGj}voN+VvAxS+knVN>yxj8q{&w>l zYh}qCqqfUCLTEe`ayK<_02+QV`j|`01%soN)%O#~`ky1n$6nnkx0}c&kQ3WC)Fdk! z(A1ASS$~=pRA+di{ZggK(S_ugVpmDe()~-R`w9*#RY~N&1OFmh-hmHm7VZ8~yXaBT zzDO-FSF^SR1U}W|6?G_W%O8;fy|Cl|`tb>5LE}5)#Pp%L>H3f(h;!ahT! z^7x(#>Lh(kW<}Aug-F0E>40gz#Y&-e7ci>!R&TKe_VAXlx7F)*L%VSv{AAHCg~U;7 z8NnUkki1Z>PT1jXJxmXTgR0@pxgnqgP-F4E2db=yx#r*);#5`62+Yy(u5QF|YXVu7@ zKgJfU3E8Wy|7^S)9p;l=6rxQ_I()PkwICSa(=9c6ZRvT~tFbahBI&bXJKREdZgyP^ zLUqC+={kLY#ddG#!%QP|?kYn!=yQ}7HY8r!FO~ogOC_E6RcZ^#OYug~Y6XqNF(cOS zNfnAf%i~Tzxz&Re4KZX5=!ypv!cmqAA&2QmkH&4B^_S@AaS_h!eI_HO%1xUh9)q*L zN$Ma2Uy1w5^@SPT@8p+BCeJpyZ2Abh7@dw_>feG0#?1=1D}hXgVvtduz+H(q7dS;P zacP(u0lGbZuiggM-HjUoM$>jxIQQ*$fZi9oB~r_ZVC@9e(=G(u`~p*Cx2-YGW|~C& zVb1DpIl8-R2G!$;fL2c)q)Ke)md}46EjDNHPc#u9J)TYW3XG{fjY8sqj^C#~(XNoR z{@}&Wc&@=JS}?0IALW$*4AyCzhcG$CIpXS`MgjDTKtifka>$RE7{t@Qe$02Q3`hk| zzJC6nxG_bUw709It)&#m|AFw0qq7ep;~42fVp${k=jN zP8bN7Onm8{^)sM2sO$N8JioVGfWX_M{P;SPTI!2UD;kax_^q(9Rd^%nZH{b4fX;V#^C-TOw_WHkS}-SVECnApZLeNu z#5Rhvq~AY|lCNKj?PeS^ zQ1TYHiDY{u6GE8oJ2SAI!?T%3&iTi_;=!Z^L2FV$Euif-93G)nhRFqv&dq{$L1w zSFtC20^L3A$(5u$Z{Mv-DLv3ocF81Z8i3_DN%dV$|Oc$&7P(oB~d-bl9^!PlZ= zOa|NdOo=e37!$N~mA@ON;e5Z9e{U|+(dueiWG^4slQX}RQ3d3UieyXUo*`V{RvaYO zo6RH9HO2%kq*)IVjXf+va+9Xr-+aXnJkAH?x-1g~hJgh44N9k}d_6^b-z*i?AIH|4 z7~;q#H$zjw{1Ky)sg9q4$!^e+$8G6L{G%Tm3-+0+l{A;ed#hx>YUHUXLWx}g5q9qg z?@Vo-UT)f)H+@@48rK%)O|<_^<8BQPN%vOtn^nZ!x3^Us&51?Xg~bKah$ZsxPqTJf|R@qht2zP-ff`lY~o60t>mIm({*mUT_V8S3Ub^V(C% z%k1#z?5^kn*1fj2{jf8DBzx^8@`WMnC4qx(1QCj*t(1FAFH7vNbht=I+1nb%GHPL; zn-B$LJYa8;h;U#V{A1uYc0vz$Fab>@vqG8c1eq>p0mx~k0~ht4mxyszi? z#G#C*N#OIrtmpCJsRw>`3616>&l+}nG`O+h23;B=>mu#se8>Pw_(-*6B=e+xWgLTE z^b2DA?Qt5XNonZP8j?z))XT-l0M0}XcUVK7p}{{(;kSM6e6_OFi-(oku;OfI*%8Uw zdr`$=#|htbFIw?>dz!1gZ$qE$06`}nhn>yV2(d5NYSrte6|oZapCYO%!ErWkz~=3 zfm&+sLX&X8U%yyYBacR9WXbYkF26-D52?*7f8#eR1lEz}$<}-{+h@cE4XMQ|e>t=P z{H{QN3->~U^sT{`C@Vy@Tll;8IJvs;^M zP$V*V>5ZICnwQ0veM6FuYCDS&G!<*BE~EtpHq$4SFJU9I{+M>MQTF@^L4wiE1HB9R zu&DMZN>MQ_`ZtrQ{ol^jVuEe*lO)P&A*o++6>Oy!E1c++{!jXK*CSD9G%0hgc z735b@OW}VvwCaX-%lCxRs@Z^njqZ&ioZ2C7@6}PA;iGX%5~VWg$(Ek#-15ER`%%zM z?hseYv-{G^)@y5*QWkOd7I;U$E5oRs{nV$T>^X=_PayUh7c2UJ{{l01!Bell+7gQh zu|j|!o|4aPNbo;W3jnP6OIAvAe@wzw2ly7U31C}By!&{+LXLS{rK+@8p(JVFJFX^v2z`vc zM-E_Hq%?(fY!D+{kL83<^mpeRhiKoy!Oka~ZN_exwV$-m0Zv=%scu^RtFl-j+lemuqHs;)a=An}awQhoF z;Nq%P1uyND2ys=zMX$JO+E^`7dHj^m{Rt;4{9_G=f`rCAf61A=px$Z{2fES)z6{h5 zzIF%!<%9k8e4BT>+iHRMC5lkZ#u!rtl*TR_{_Cr8c@V$dz%5r@KoMRo7_b_VWjegs zJd1O~F(t@*doJyMG09inlc z6ik_7B{XItBzajkG~MU*(bPtTpKS6Dfex=(K343Pj_iR0WWJA&lR-beCWPPS@dqo$K@Vq5^_Cwp)u$@J$! z!|X`m#8r#CKZ493HM09V-5igYu`w`;95HnzB|~Oa5Y%ZGj3wt*R0#MeYTH(c>3HTM z!#z7YCJ-VdBRwKvEF7(%y(Ta~)We=Y!8$=!>s4Cuk2kVHA?^`*0G;YX@(b=8;k4cb zaiQfI2bVdEU!yJD8CHT&2Q`Jr8oP`y2NaI5z$TX&i}0O}1#k&9Vu8N6?dVa^x>a3< zc#?_P6olOY(dpOyvcj+6vdSM6f(PK8mhMW{Q*USwyj?F|>_n7@VJS&82S_i4dinh) z<}&fe{2k%>JH4<y$Dm{))6 z@!jU(bS{#3EKAPoX1wcjjvoRRExX$Pw2UwR>)~oLGzl>d&%DN&}xr{xEt3CmZ!EzBNW@Z7js&0El_+H!43}G_`an3F>UFw zEIy0yvCDR00miZEYV3YNYSSL5E!9lfyHR<>Fu`BI6wL7KXL9H0g7bW!W#e$kYt+Ze zV9@3BK^=+Cc8LtwqYZ>b?VE4H-x+Soeg4pPgamHX85bCS6%&7hZLzp zd=9JZHx;u1YVfO|h#Yr~o^euqNn*(%<#Se^GN@(I{gnCgh+5g$5uPEuoGQafVC_>O zq_^y0|DoBEW|`YHV_?L2GZs!veG}ENE0y!n$M*DLZ@ED!Vw&~~5lFRI+$9s5P0Q(f zUw|y9r#2ji&W6qibmP#{`P@NQ(79QFr?8cH+YUdYzjgb?N@Z@K&87fBghU`9rFIX; zK&v7LDIN?-qtHVCbL0be%$=bFgGw%L*%Rp%(M1dQ^=KumMWMi^YzZrchy52l^QVhH z`4o9@LS3B(rE+IV8RE+)qUwztni?D}RU8L3N0j`2K6@(-?=3)_Ch%hf@5asV=*)7L z1?^gJPxf?r^j2r0;W&BJ#Ux&lX`YD<7$jiUqg?bmOe8GKMcPcsu;p=aAckt z&Aham(eE57b&({OGh9XHGnM*CltOnHvCG<+gy`!*h!&R|%%vqWSVX>C2ee?DM(?s5 zaP4=EfwNAt7$2Y><|>@rDUqdnFWb$(<9aIGE(ojN@3B6&u*QW7?_Hcb>3h`tN#nAGF!cnr-?U6LRj|lDJ-kbO&|oh@3$jh~0)r0qI!b#0Hb+-h!?J_{Yr01f z)iqO$7LDvx1nX|Kl8);1I3-WYhvFz5x zT}4^BU5(SdR!V0h)BI<3B9Q)o@OjVxtf8RR)zJcMYkiQ)DX$M|j4?*{jV4v?+{S`m zw_UzQPt5CX&H?W>cJl-_7e51Joa1~bi*TKkxbbO>q}!#gy97qF{c@1I`FhX6au$mP z-Z%lqZuqNID8ilR128|q9ZyR&7$ffP$Qax(AZXMo?ugQLUkDE6$K2GGBe04-4l zW>^~zK#tcf(U)#zD?EU4L-WWC!)~}9&q}toyKcpN=wz`u=npq1P_Ms`<6nlG)UiEE zJO;$hehlC3c~;x7Z9H`l&U@~WN}ma(j1o>Xv@%R~^QK~5_OAj!keD@HL1(#&g;=@X zc{xkc^pv!&V1#p%h|RAmli$M2!XC(wmbV>Dgr$!Kq*|P zhehsuUNSn!l5h4HYiQ$B5Q>LeM#UwHj1ESfN?VF{sn}gKl;z+g>LdyEP?HYnSZ9Se#2W528THlj(CjU)cF~PY*JSLxrcHUDBn#{FLbS_ggwY zEuH%DIg0zQEtM#CA?3YJd%n0)?yZluNd{4M*BFo_V9K>>&hM~3A zNKca%(Cx1*!-?;RRJorm7n?;7Y2x3^_2SNAaT76aW;<~_ZB2vzeAy4>&qo-jhPHdE zMgrMVIT%CECF%AHrNWf7qmH(h<*E6H)L8S8C{-Hlyjt-#aepPng+=7~weH_d@P`%%;sWP*3iyL=Yq8tlKl$^8RQBc~@ws z`mSnO!Bl`kz!OYOu_mb=qDy_o7>A3k2F{I&s*#4ek$-y4ElekJa-s3TIU8M=1M@DO zVYAnS=<+g_$XsfFH0K;e%F|$CPhyy^EFZ^mX{L@jV{(VP4yu@l_7;Yz0B(Q_th6hJ zB+0K(2L{n4lr(E(q~@<8auL~K1+9xtQqPaK7?Au9SwN(4Rg=%#@$Bb#y3fD%#O{k-TJec(lhf*Qk9}>?$27*l$#|)u zR<+dvnvXfU`Xyw^<@6TvL#*>9`4$F7;v=B)8loLi&sfah&Ec|+64S{ zB!|I`B)kLRGQQ3dyO?938A1FjO76?2T)HSey6M~cX4JOg{)YF;i_Nwl53wx8vSX7x zomf;Y!TxGplx9<p4|8W~jKlnN zkf|`FYPKfpPH)hL%9y{jQ?ifvrM1^GSxl^JX}rjamfhnSxpqN!AZ5uHlZzi5o4-pX zYgW|OcQ~a+atL^;ju(%jH(P3czgU|OJvAyi@5GM+uWBV)t!Kz;PB&Ww1XNpo4ytA` z5b!+oc=FVy|MhJ6<@H+Saz(bJt5e2K`0M7lzy;s;@nR2nTg#B!4+!4$7Q|T1m(-rz ze+)&-NRTBYV)7BN{*&BYuC1;8JE2Oa!yOr){WF~3;s?N8fl^R#un^7pGj^rv1nw&-H_qA5$X>0!Axcfz`9|9dF2 z7`$SPK2(S_#m`~vd4O|ZhjsR1oSxm6lC0~=kjm%u;qm4~r44*@)a65#XCnm19Ytz$ z<%@oe|Io280aJr_Pjau$nR$t7^cj>8N$VE>X2byvUIM{-A^}AV?#*E~gNx}{@eumW z_1tasnq6k*>HaOYfo-b2mTjAD`>N;l=;q|dkZb!olZBMh=!Kw>&)W zV`~r%8y67B85tnnD$$)Vbdxn~_k?=l+_jfVuPIyG=9F|k+i7$ppwv#J0xO9u?}`>m z&XM}5J{rDavW%iZqw--}d7;d@^}Nx}t|9_Z2e;QPad#D!@V2)xa6}FKqGD*yzgBS| zJ3k*}dV@%?!+lnFRGgIu5qeaxt0A*x4w9llTJNB58%w(F4F#xLOuPSs1XHMR0l8u~ zQp&q#PP+vU-Angp7E9&gjJ?B6A0LPuZI0H|O&H%*QyPwlq*pShIk_;>WZu|2fZOft zK~XlRBv0(Qq5f$Y({uA@?02yOnfyKqsz6TmX60W1vZL#9uJ)e2g*KPB*ud9D{nDXZMH4s&=oOp5VuX;Q`Nv(o`MA1`DcT-g z%JY_Dck7`P=_7YL_fQu{R=18BD&zs%fgf`N=~V=IXP`{&RK*pdIR%LbSBZsa3)6j^ zl_lIYUaQxMI{O!yo`9}>u6G&2+<1(QaV*WtcAh`M?lIY6dW*%-@@(70P%&kj;3o#7 zwpz1^x5yfjU`hHHV}d0pv#tBfyW6$v`Bp>tMu(HIH#kJ5Q%Uo2d0J>#x3529Op_yZ z;Gg({_kxdlWKa*8SWq7R(DH?0zQmn#RVThfgS$*llwE26iP3Q+g5x-tS&rGHHChMk zhT^sTTRGfx2A7y)%v_mSLRG)f4+YnZK1KK36zHxn6a}0|5c2%_{acU4cFx55{$mmO z;h(ylgqq@(J*#PM`FqEe);MOC-}`$XIa=-$IfSEMn1fG?h9e0%Fdf$z2HwDrGOC5p z@>Iqd;8_*kwqh1Y#+c;pc|$`CD^%f=3aB#Q&u&MB4#`^)bIt&&*U38k&D6`PxYT!l zoxhCN+uJq%9|6%Q$QJ@1s^;s#{u`5M_!l?L#p1^5@YFhUxAjpRvi*As9fJ^OrT+jl zL<{!xzVT^szk{n_3QgeG)2FUl|B9}V@Sy?s7U?wf;Xz5A{Za-_;C}(7)G+{ffdcnG zX=(+tP{#{{=tcZCGY=t@^i&ux&g5nu#(r#qf444#(>TmU!fS6rac}~lt<3)q7PI+n z8`?JIqweCC-=_xm>D)hB71lp`o`YQrrUBlm!Ie<528N5-V{zG=Cmd1dvtS2J~|7DMv~TMNm!0;Mk+K>V?te1 z>q9Bu7ddME7k7WLx%V&yDEk{K`L7Bl5ls4jy-_y*2QUBn5)n8X79dk+4plnTs3QT+R#`k&kzNk3@$f4(3sWX1WvHxcHq zj~s)lafQpjBYQ1cS!5B6$pcY8AHY>P{htP6i2VQABJb@K zd$53J9f8)ND))@3yXGa3YU*#W;a`;rJ{xlT3)s598w6Lvwv;o>jZ=hx9KEA-ciy(Z+6iu?;|!iRy8&==|~t@{jtg zZKG$IE6 zF#NzM_Zw5yx}%sC$-v1WQ}4-e<(O1xiyaohg2)XP!ArHtf6f=y8xlK)(h$HY@Pb1C z06hOa>u(hY9hDZm^wCkt6`8+)W>wVg7Au2A51EWONOPsoi~7vX{Gj)}l)*nVh;xmd z0?wOGHzp`xr~oJyt~dFRh8cl~Y2Y8t)M@-u0T1Nc4z@qFMl6ygc3Oc{XAe)9oEn}! z_vNvs)*6Rv$a5UI9nTx*jH@1~$vkrb+x;f$n?16u=Jd^Z4uQrml1BN4fG``Ja}-|P z#1C@{sO_BYPy{Wdq`*^Lpv%O!(@XiTNgXfzMo*>n^Fc%#d=|J~p1^i_)E`UsI0^fU zAN(h-_3Ob0(9a3?KX?kZV=_CZzZ{;=GC#StA+~BXs|^*nL@)j{srr{3m)iAhe6S$xSK=&0q8|tV~Kepx;gO#R< zU?BkOj^{stKM9!LjjrH-VX^$mY!FgW?(7AdRtKkjSw&ChUjqFwj@oqQ)JGQI#QuG# z;7QVL7~}8dUob!(XU+zA5Nki;)U`r*-K^1s=e(7#D#bSxsBh&a8V!K_c(D1j z$*&oNwAO0lrT@KyNB%W#-Bu3q=c{v&m+hxdFTs8g;8@4;i6HQoUG@az%%z%vATy3c zh!*fP7U(St5!E#X{`$UnhqZZv6Orvz{bDx+zml5lPjSd$xO-ykGUSwISK@Oc+-q6mK>+OpIOrJ+phEl1;eqeLUHcDc(b z{mW+z=~U;9%7Li&jK%153`nAc^v-cn^Eipz60I9oyFUeK%dio&$K8oxb(<1g$P14n z`!5YuLShEfNTNTtBf1KF^><%VI>vY0d>w)VzTD&U5gk!|mgx1~IM_ktSvY0doK}a{Hjb*nynK66bo;GC z8_W>25D9DdNt{o`_24^~r;gAlHB(>v-Y0rZpD)|t%sD2SIC$pdOIs)kFgyej$J7zA z_NSkweSrugngdQc+M6$NYV&|fzf>Q)S9SW66W7plJuaCi2%WC5EsilOH&ZA+&nJkv zr(VY`3FhGuBN^rs4?sF((@KC?QR6zX_eWRbj^v)_9auZOw;~>ZU{d!DO-rSt`4kw^ z6HbcnJKm9jI%`sA^e!e$?3R+Mws_k`q4j%E-R9do@#Uip9Dxx-TacsvX%2#l<-B_G zPCDn7ku_e^fLXI|9R=W}Dkcr*dHjo)8}Bdu!JB5^OYM|ad3=gnwtG z^Na`S-Z4zZQqRlrlp36b#Px0nYr7!B8leq+r+L$)go*(^LYZxL|N0YhEmwe;+A|Ag_z)nJprwDnfS zVKuQ}hwH|<+Bp-Q%#>AEN2t-qB8fb9t{X?TV81~|@m`Bzj-AneaEsTD&FHsMd7Q#y zyyP2Lllp3`yzX0o6KY~tM^xw1l?s1&*LHu$jotHlmq0Edw{;w<;KBM-tt-O@=8 z3veHRY{xrqIOv$q0-R8d_5S$KEiLF3{ndcC7<57mbiW7~yXO!Yn!)c&M12XJ{WjKa zZ_C@hfYorkc87mam*hD_52P4>vYx>+01e)Lp!QR#j(NO~u zXNWKUuIJe6RxJ!eYhX?uD7!1nu3-Rzr zJcI|>4t*bUl5I{=NYw?hw`fy+apsI{cR0p#&sg9#1;zPrp#E#t z2|peKBFKbTKIOC+g$$FmsP z;;ggWHjfW9tDi}=A*=fixp%8`N?RXfjL zeC?M)(SjPI`fpXTu2IME1H?;wDi(cK8e%3-iz^ zF=;s$_iU>}cOfFqHNWt?M7QZ|`}l16e_ug!ITO$h!UyIWgRF&30a0UDMQdt43OX(4 zygtPm3tW-*qc;^u`vn_K=Lx5jMSwYy2zf~Rg7#S~&5^D-I^jYyJVV3axZ3iU z^#kMS>NTeTp|UPM3DQeoCum#<$awivvW_ z>>k0!A-hE=3c7|i!9fz=Zr{lvcZ;O?Y&KjG#P_YPPYeNn1D(IIO@;wjJ$>do+(;YR z*5rde*Fg#4Eb)XjpZ?M-jKTw<*x>3OGqp!=jf|(Y8)K7ePy#8Dd0P{?_X4R=Yg5S0 zS)+2kEa_cHl!bLk)RvIm$BYW_VAk}+GzDDgF40l*?p*m~EjcD-?kKI?c_W2*4fwgy z9so>e6zvo1wad6rZ^fP@r;Go}%|@^1IswS1=d}Com#sB3D|QgB$pKJgd}ii9h||yAd`5{M}&GF8K&$x;z>*2^c)hi5W3!X z5yk{&iLA9{_4e-{=Lqm?_8mFlJ-v~pca7s~eU+WSMH#P@(7sy2;o0=9JsMx*{bjsF z&o@s>*PhlF8?&%yZJ}6{34hh)vMkBDs-CiM9a3oG+Z;Wtj;;#Lc2~2apVp>Hpesna zCq#COxN@La{)~i^hNlO+;ujgU5|?y{Bx0*xzErk5M3WX-!!6seoRnrj{72`L`(0icwS%NbE#O_rB2z)_cKH$a~_vh zo399dEKBJsZ{pENieT>IM;v)Z+ho2}cbj-3)L|{^F74D>^wk%@K-Lc6uw%RTOK{t` z&Ga=|`)N0B+_C@QfH18xwtPw#=OG&WEZ0+UioMZ8FCd#)_iC8a{PK+C56}hZO)|J{ zRYviw-tIc$H>U?L*AMnvm*A82b%Eh((IkVA53 zw)jm2_^1*50t94JRgrWI@WZi-J>Qg?wp3kv+DFyPd1>Dz1q%biEE8PC`icPFf^qoCBUsZ?>ok-;O;pV&Fv*m3!$LlAqa|t1n1_222&;?AkoW^xoIRRx?JTe2B0m-WD~(AySBPeo&*J% z10#ag(TeK%pWD{0zedk^J$U2Vtzsk1TEirtlTK0-{cz9B&|``3(v67BY1`zs1aB`E zgg@YECEx`6G`h{j{u(mdL?phN0)z722d(zv+4nkk@Ke3Wb_F@YQyPcJ8dk!a>o*-^ z`05u%%ec!>j4FPzNOO8Ab<5?+;I{xnBcBf4h5uc_3s(4%nZu z9Q9$#H;XJ1*A&NW{Vwggnh-H$*$)!5%e^OQzuo`v!Q60nFC3LAMmXPlV>_{Ml+(F0 z+V>XC#HK5)j)QL+rNxOhE4%pae=1*~+#r#q&GN2Bf4q z3*Sbe!`&R26nyM9wgq^94=zR$79}px?Z;gL_ zxDQJ2D59KU?LW{L);PQ*SYf_$wRS`0=6hmq_w|wXHrd*Hl}vv`_(nZo5#r=8V!uHr z;xiEv$42X!hEu5io$2s5Z`|z*N`Is`R@n2MUF*S7`}lQIAPs7qMzIu#I&J94fBB80 zCvg`Z`0%P*!_I<32xFlvTCIPQET^}-sEX2hM}lO7IN(@KKgfN7bjYcO-=lKP)6To! za7t2w_CgR7(h0Bn46kobA&WdS&E|D_#O0U7Hb6*NQ$F(Pu^ncEvzu z$!t+%Z?)KC{#G3@o$Nq#Dt_qp`nrqhq8@SG;YC=G;;;eS0)uIp)VAm&zFNGzbNu+q z1U-U1zw_F%6025>4(Iw&Vk?I8yl+^dv)^Lr_Ustf4S13%X*rGPdVmh@O!z`YWa9|u zD3}prslFAkx+dss zGZC}!hCQ2BE4yFkICHbl9l4gL5vOVCO$DNNEVh&D`Uh%nzTbk2vy(6SF!WDUcAc!> z@!NKkr-#9=O|!1WD$BRLz|n=vjbh zl(o2FE@H)9Kmm{pB_Wo#xfVl07F?V&-6bZ%;6hBa4_#n>jfK+^h3%Bj1^YA5T_htj zV7DR8fcp2F2Al0t$ZrenEuJcv+o+YkqXFWrN3Dy~<<6R~=#!eXq8{kH2 ze0t4i);PParaMG-M=10HC3TX56cUR_H^R6d=gD8Y3XeJ3=WBaqyr>X!SaqH~TeP_F z13nax9FTh96mR-(6ZMXus-nQy0*%@8Ez4naJZfRK-_pXW;k^$ngeS)j>|0}dps=FV7x+CbfQIqsYGXAFE^CVs|FUV5}B9t} z;{EN(D73Io>c;PbjbMEYsp?8w;B|k?=9mzdx?)@ zW1+fs1g%7JeK#GcmtHxDzb-r}-U=83%vq<&!N>gWEGj?uT)%2ct{!|mIPeXAsQ79Z zt{G84JZp+%VznHGkbH0FX-bx{%i;abT0p^}nryD1Ta%jH=cRz#aL6$s)XVu!R=4hb zi86M4cUn2As}ed!(Rtyb4pDz2A2- zZz1`9rdU9*P(-JAV9!E@`G&Z>#OAsLb7vVALw-~?uNzD1=DVcf<efFz zFMdNFkn@1pLoNpEv(E(`krF;~JHyY*^|?5 zX6*9q$keSqRBZG?ms|#cc4i0To$N6RFz|xct?c94`5@Q~%#s*AxFC~hQzzS*{A#2j zYc{?C2SrcEVI`uWV2z{ejmSs}K5${2KjPV;<(VXT*vp%jAXInMdo%=e2k93F`LMrHv;XY-j$y9 zKdGVqzQZIR0j3_7@$m6=?vPPZx{^EvO-iXmQ-&n&k6jc$J+lU(kdBJ1UZHdY`~ z8*%oY87Jq06P#)!&;cq7em!u3*au!(5pR10H``Dv)7tHEpGGY=N?Ade-I9!yMgD}2 z$33IS_-A%?Bb;Z(=ziMDt=~!D&?e43(Y8P=fRmv*a&qnj?4X#c&+HMs2Jo(SE^8CS z?Nb=yvlzq+5DXAjY+xEBvNd@8eZRWR;EW&!yXY!Ago5J^3R8C33oH{F_F%x2zdVX|M{j$Ggq z&a0~(^b;OC_O(F06lPuHjb-_wQN2^)`~NO5Pe-wA;ubb)?(f^`({_AzqK%B2xxD2) z$!&9nRKGoreCx5x$nxQUE)VNF-P0-w; zvaBeol$ZwWaRX@@{Kv+a`qW<8;=7o9djQk*R}EoqrX560KJ{?;$(VE&EERNmYH#XN0Uot=xf zZP?7%CEoAbiVvkUbzhc6lXLUnlHL!rcO@7TeX#!pLHH>-P7E4EkUeuz(h8Q1UTG3g z^8XvIVpRjH^)DOy=S3M?nGWLjfVyki6HD5!FEvzO%b!aNGJKUMCMGJtr8vJOmVu|G zmEB=#-`h(m`TT-5d;8xt=Klkt^j|PmpKt-_6xE!bolCH6@tD-MoJ#!rtPOV&yPONH zZ=#JUO9$o5a+&sF3#W z=u2WG0y9{d^O$d*$Vsvx9k*20a`KwBG2wsWel~m@X#YV7E1C%X{|zqw_mD%;Q6=7T zXiit;L#NhLigyrkgT$NaQ{|de_I=q)!%?F`(SO2=4u1a^JnFw8t4zsM(9&)0pMz)0 zCTH#nUeSUSU8<`=^JqpVu}h;#r@g4S*xdb?nGD3wJTWx|oAf2?&KlqhN{%tbDkL1%V z6m+Vcw@BavARzDZs z{>QMyp$!YZjeqQJOzp3}8!Ue@=mo;RAJc9=M*scM!@++D3J#DD-nzDm&$+Qmy7NC1mV9yiV-Vas znse*{sLeMMK8JG+kZDRyn+l8W6c!?5X+4`2_4pZyyMjy6zowaV`UNfjM|#pGMNlA8 zU#YIj_(m}hGqV$a$~evB(cY1u@3q#!(NX2yUVK{Q?(7Gx=#N8TH(|`C7LP&QY0Q5{ zV(kB$R5~&5K~h=hf;Ox3yy_l4H(Mz|#bdXKmJJx(>I7c~Eif7F5Z_d@G(KAeZfF|& z>(*Y0F*d~C8`=J+WJ>bd-oU@Zz!WZx^2mbitc^P2A2{I;xMkFmz-c4fiPkE01eF57$*T*%%I2{I}ns75lh6+tK!s> zqy+Vd>5HCB*>0x0M_e|&*l0I?%-!gWY{SQE*cx!v4)D|H9=qqedWhG(8mDv3#ZW2S zt%pc^Q3yhwRi6BjU$bSM!gT{fuSF{m5@YqC1nR2WKz{h#+@YOX+4_$TB+^#vxc&Bs#y(i>dV2xCh_PmxxWwaKh#pI3?2ch2 z7GtuecwVR_XAz0!<$P%H>ptml7!C~%$Q~RLWa!p4SaO7x9=rBnQacrd|9OR*LrGSq z0kW=nUsiyopT39~YlJcH^>kqW(mqnXx!)n%=i~nn5Zo1RJc=QzlsMwAr;Z;C$8?#s zaJ5{5bSb?Q?7N(wfjqJiA*A@36nL_^kBp+3HFoW&2Kt+fcOWptE}j{VBh3uUVnf$g@Q? zX~DB6Kf5Q?qnZNinBVqg!k3i4mjr4HXd1~I7zU6 zz#E{Z?abzU<070%mMC%kj{W$&672lcFk|=&Ae&hISuHIb7ctFDD8T5%BgY+ic47UZSgtW=D!_0m z-;erse{At)hR)4c|NfrsVg*6*bz&LF4X_=Ye=uBT?VF;X{5a%PW6k*z_)uIe6nK|W zj@*~ktYN13K(LSK3w`1#7-f2X5;3@4H&vW&XK(vy-RA%qD8LRg^R!&whr;lXe0NBB z;CJdh)Ve;}iITN(|Jyb-eE7+oP%Wm;PrL4+I5pww5v%2mfqCos!7hDFy!~ks|67_f*2+rP&!>+WbiwZU!$n(2E%iukH?x>-1nO1{6<;`)Q9a= zcP~?R20AnZbKe4ARRZ8cr`SJk5~o}(Gks@# z*mZVKu(Ntq)e66@K$h#k>Gb3fSer&c7BF*seYh?MDpn<36Ct8BS__snSW;IFF@y@X zpbB=rgR7X8YZoneW<$vBEeGF^nvR}&$gK>Tx>SgWqw}s54o~-SbF0qJw023D> zwXN&$SY5&bUC2JLQIY1!9)Ouz!*lup{ z7u?}b%M8=(-T)DvoM4WOP+E?SSm@A=da#>?452hrZv>Am_SLeDD5x6{Jxw0(F|rTJ zj>xRN<~KJexw}d~AfYr0-V<^(cSE=LOp(Dy+j(+YnD+1a!So181Y7d?&|W{!Gyb~N zh=blax2q;b4?Yh~6~&q&ZV(#Kt$DS(AZR!yTnALJ4$>L5z7)STr-DE4t8qON%Xz4C zGgqSH$_5f%w7;;ZNOQEF7hONYJ0!Qms4Fu&eFmR*N7e~rC5e!l7=uubMx}f) zbPAg{!rU=ra&@oh2bt8Ic{66Do>}vU+@P_q6-bB!dDb;0Q?3v?4X?~zUnWO)(2xkZ zf*o}XSsqLM%re};9M^rI>NvE;8lnxawt-lS?=x)Qo~-Z<`YBj61&0b$P5bWmpZs?h zvx3x%$ga(4i`FRbi}xgA=^u)p&w~_dxC^kCKOEU#g)Uf`iyI5 z#>tV@fbB6oTUx}Hdobl5KAn*^ZM2@=M@r3P=J`R84T>CZz+erV4nzn~uJ9*ZQ_|pJ zhePv?FF`1^cu+$SXVB@XI%YGB@X-kPfCTG)q6&Y8j#Iw5!D$HTtnp zLpuw5VjWLoNtZE{r&hCLUj*Ox&W~-?TzMWtS8m>3kQutXI~V(5zz}tmQnhQ@@SVEV}(T07ghCzXrSGA z+rxT^?4?4xnr3v@g9!(@g9{?cU}0+vQ(g)Q6;+wR7#qymg^37fiO?FK{R{aDhL(&L z((W!%tYwDy_>}o1*D9wFzF#P9eae~O&Y8O7SB!hR!2~Am9z7`i(() zH{g49CWsVvb&B`n)1|T7S*7jlRz#m3OQU$q%AOrrYfV4$4tLk~L3YFK33SGMuo}qu z3qV!^-!iXgRCIrJcby~vPhGF_-^P-!%r=76gP5foiT!aq%~s{b37>PtMC@s>JF!2% zh2hO@(gbHM-{Nze>jcRa`T7%!ybtD5NM!Ki1q0c*L)iKw&g<;`aM*JgBExtuUvI9T zf%xsOuN#@8C)lsl@;m!mPkjDzsF+Ig&D2$wZXb2sf!_QW9qERYuQ|Cu!VbU#zpiNr z47#SB!@6<6>Isg?E01yIVFkU;f5|WZDL<11b)_piZ{nhoxc`2hyd+_Gp$L;Mf{7^Y z2Tej(FOOAk6F?xKINKNIhU0uN?_qvBu(<-cYy+*RB;jM5fxp-{0~T%J#gUSB*TsWA z7f&pU)bLN9uU$QZk~JOv_`>GEDsAr?>aerPZsg+kteEe(b`NJiLUcUQf@pnioP#Hf z#4Y-(O5VuP9U;3 z4BTezBCThifYPx((JrE74xg$>!IR4D8WElIIoOdY(Tl4AfO%iBzIrpxdI989XvAZg zLq~GMTlG7X`$dsy$9`;=*7BTc)%|4m16$HK@<1B8`Q=>I0$d@^g6FkK)0T6!-s?iP zp>*qKY>+1~xLvk9aOyZiWw z-1V!@Z)3F${=RtE=S3U9+|WdLSLeqPrbcn^y*{CZgL;6$0Nbs+Ac7J5b$nVN&dG{) zq^QGK+huQYE>II!&=h@Wz_^VczTq3*QhORtw4@{T!E;8{=^e62eS6QwCIlzD2r9?> z*LGTX5xoALHNCc?~yRLyp)&U&~s=Tti3+U`~UY>)i3S;dI5?}`I zcU^*2Rb1#O6Bcwb6}oIiW>8ZWP6+S04_+6MY>;Mz=hfkNZY$Wvv5#hJ^EexosH>=9 zTZWy)`uXr&_9i_{-(CW45cT7bGPo3Up)D2bet z-fZ6rqEd=iDXT+#7yO#V@NJTNaH~G{4=-f(Ob&XS0#D^5aop&ND#wdGeo!$gtJuo~ zaDP2xiaYTVa8MCMc;V$g@Z4L;P(Of8;drA0X1=4pdv3}i;Bmo(Gzb?Kej2OyH3ns7 z4YvnW8B^C0v~AtL18-Cl(O8@Jy>H(dQps{KKBT9&)v?pL9<=&NQl6Ue^p^NF|wkJa1?Gj}6mkAIAqn z&tu#gK)zM^r#9H_7mB=Z3stzW)sb|~pKK$k^U4e#U^7@DWg9H=gBA1`6$2GWG$!*& zKqvX*p?c^M7!gG-@8h*xmC|MPCS;c`^T5Fy<~-9AP3-ROrYh^0P+E}7jV!gkWK*vX z-IjL5aXdq|UtW6STrD9{@IdF6%Oo@|-S7N{y4qHScQ<XwqjcG~M)4QePuIg9}iY z_!(|=+D)UrQl}!~)PQAx+m@HBK*y$qfGB;+6D~vJgq$b$_wP zeZaY+nm^@9zTVYoIIM10q{L9v3FN#DlEu>qRXT&UC@rq+^;!gB_M(zwE6n$2o>Tc>krB>x zu&bDNdP~ViFP#db7=7zKoYvo$+6 zHtx9>PQzh#JtEydC<+jUOq~DtN)OP{>Yw%xpF>>g=U=-G;L)iLYWbz(@Qz_vzC8 zt3W1k_n5;{|5GG3eji#3;#ec3zVAyw02M#p`Xl&y@(G>bLyXCGhiV8dl&*U}B~6gR z-IH3=+GU1}Z=tD>z}$4cjV+&@s_F*=nCL8)2&lurxP-Y!Kzsh?;9z+BH_94sfj7ja z?z$CnpwMHx?obNSIWw_NgkS})8@Nj4N`Tw!P^GO|_FTGaeqoRQWuOzp*&NwkuesVRG{0VkM zc~!4^hXH;b{rTbT@X+zy&lCX6jI9Kry>h+nE7`MfzdyZBB%=KF)6Q2fc4h6Vhpy+3 z+3g&;-KMe6bM(NYlqefd?Y73OV9k>V%MI_78cBMsRNV_}+A=nUWTm0`$Z??=Wkv&;7)d&JD0~$>RqOAe-zYg+l>C3!PBhd# z>LFHkhh>2sWv|A2wrLBOfnRat_R?!cr|_>B8#lop^Bg3wKGZQcv!(treiCixutlzF zZT#YUMabpgX8M7Gs4pC#GZ1;UY&LIVhZ^QRf1KSrFv)qj-ySg8KoFG-;zr8X#Iy5w z9CCBb)gY*M+R_kB^PV&Tt~IxW;k-93Tt2P7Hg7K@Kn{2!9_GV1A zJPmgds}m--e~_tKY*n=(-gVGtqOd0a!^+US-fabY0 z`BWE6Kd7Rh^ThatuxH|)gcj~k=~k+{9?!Pxl3Rs9S|oG5uitq~sQ&6}caMAZ))6jm zeH@(rvxM8z+~c-JHBT!-@Fh&wXJHw6Ln*!@If_HuA=6ex7c@wjX;x&P*DV4HTma)CkP85;E4lKpPUrzakW2- z789J+jp5}G>l7b6x3qW)70(z`KgzX-gFxbG+cTA?deyyZw;H2@zCLo>lj~7F5H>K{ z5*VmZ&T#IFrs`M$jD+r zZ{YZ?ohzlyw07iLy}9uJK{Jd)K@R87l@}iIx512-jRVrnaPHKjZ8>B9t;KEU#vkth z^l|*ZO7;c`XN@`=RCce>o2kjcc{TD89VS{m`|65UW6mC(#Od9XWO-#36f&E&xI&=# z{-f0L2gZM)IwD`wx)bHwPVm7xdj0@^ppnhs-?5<4QRT(td0sWlpyzLtLHrZhp~e2&FEz~gcQ)nj8^XW9jQn07*qC>!}&|!g&1fq#^S>{h8xUyA9lSj^z5d~VR;i{QBP8zxc z#F+sNn%**;#@$v@5+31_qn6Oq{pH_kH{#_BLC>*}Dqud~2|M7;i=W{=?so^kP7p!w z@f{wXl3dT;Waxb5SToSdJY6V%*w&o>9Gg{Egz!iU@Ea|kucnl46~hIQsFhS)dWkFf z{Kc0(TMU7fxMBM4`W9|1SKgXekLq6a{#j3DBM?@GnU&r}#|NRUe`_!A^8w#GL*EX) zdQNNe)ci-nlrV)oUl?&u5?jPmfQl9x?Lxvfnr6$e%G=>4i4TS8gLIzAOLC9mNPHG- z#DM=dXRPaOg;#wBk6mP2Zku3kNb^#xD{>yhugQwBcBG)hmxe4=PeDg9Hcd}uUqUGn z1obI7)W$9xo*_JdsWw01ZfzU?h&W6>5W=%UyBo7rO^N!x9g4h zu}9HU8`}FlSYz+BQfS1J4*0n{zB!;7D{)6T%*0Aw6VOe>?FTBQR27l2j0WzGjYvkv zz0ycYg~=$};DB_0H0ppgFFXc(lI$;{SoRsD@(vDn>=u5q}G`q5KIycImcqK(U)Fx|`t8NYN(W0~bx)~-I9yKzN#6Ejz7q@HEmpj6~wk7h*pF7r4OJ# zCPr=5dKlR;1uaUY+KHbN8cGY91-J(NwK6nG3$m87cmRsClZ&W@7cJv?m;acAp&d6pw26S`Pg)dcp;B6h&pf@w zRn#wBB)93!ymL-UU?AglQQ(Rg#8boFu`IG4}`{3 zkFcjo`1;r4Rq$_x)Rc^v6X(zr+Fu8Qyg!q8V5;^S{KP8|-NS^;QBrPJ=IrfiVX_Fn z$#vytvPYVw3+lVZH89c*8BV}KYlN&azqdV&gBq@d5>x;2asg#p5$)8|X%;XI>ZCOe zIH=3p0f`CiKg1M1%DX56>oI?d^YLQ&eAJQ7SWyBg_yqg%CqUOvC*<3sw8CT<@$R*a zQEGNvlHaY;Ra#m!Tf(BK~(f; zj5l>Y&bFlBCcr|^ zilckvkYb)xq{XI#s7K$?AniIpha=h3Wd$l@!%>~#8%e9*A9;yl6{#R!31^fz71S z8iI%)92<*LxRSNIYh=6{8v2o;*ytb8O(ghtT0o@0#K&Wt9~xxJSKz!Pkwxl zJ1SI<`3mzT-&zg682p62LcI#*PY>;v{t8l_iWjrSLLI@fYL5;PmnMaP8CYmn>O!pI zQx^y2i>E}#@7e0)Is?d_duj56b`9oxxOuu9?CDgB4rwo# z)h{HCYW>%AG#AG02&=8iu0iQt^5#;bbc@NcU?}* z8i>K?9TgRjQ+I!Nw@w59_wocTY8NCWIO)BXf_fW>+D0l8P3qX7-s_hH0&4}hAapXZ z))b0~h!M$FD+P;QwbBD&ccfWU=N0MeT`Jw#^HbHYG>gizx{cKq3QrEZH0u7R69NzF zLk;l@u-ACK${7zJe=>LM9(MAPiOVzMtcX68N464ZcFXM!Hl8=p3rk6Nm?Q&FReWMc z)dLm(HD^I^gH$W*S{%Ybj1aa;-Al#5PCc?^A~d74!8@j%Z_5Av!N$ z%2lW{1ITKRIzu+ktj5BM0 z_2U*mEWI)*6y&B7YcC>uEUSnsdn=KZ1K@i7Y!K_PXrT*2nZxtwD~_htde!=wQ{KS6 zF&$6aSZ+1Xc|3_JYSjUx5^`qB}o0T|r0-kKND++&-9# zc(hl4>8JZ`nA+8=7iLZIP9pw~-4<1a32h#Gfywf({7n0&OvpxlHGBYLqmps7vY?Uq z^HVa$mNTsZcde|4_7ji1CS5e~wCH>d1A^V7<-=Hho3F!CBCtmuprTA~?@ZMnpCMl~ zO|wc(Ru<|eKt}-DJaEOJ&ExxWB~e+fH;C7u|!riB+oP*G$^ zf7zx)-v&^VT^YnrvsJy=TjS#-&WsRG3v7qf`@-u2*{@anr>`H`YB@~JC1oTP{g>ro zsy9#XBc$SkutkmkFyTlVkygE&SFY4ym2qCl+x&{-EcjUvt7d*L*Jw+^UqBmFR{K$e8=0r1v>g);JGp^booa~z;AzoQ>k$&i7q#FbCjleKY6B-J zc5rOshX1+WTnFYr;ggUoV3w3hIp$0r`o*Cak(Uv_o>Wvc5g%Y$7y;6GtN$?DoCaIvyA9qsf6 z!68VM(6xENDWI+?Vfv*)iwKvC!4`ZXK7K`vdR`ZreFkkh){7F#z8D?VlM0+=%YKwq zh9T*eKv>?89lP-I%RCyQ)gFxMR5q36ekwyXStTmyW1?tkNn!=mn7;y&7i1qJeh>`19heB(#MV){bOl zcy0o1oo)j8WugBbEgyL#$N=WgPy?Yk7gQ{idAN?GFm9E6P$J4z)%$LaN7OPl2!rT` z4D`akDuYDy8KhJ=h$ZXIcx6GuLRr*&7A>^wl$7dqif_!-qY67SKXc5A7PDaEKp`qt zNQ&Z>l$10_pOviQIa|^$tB5zgJ84c(HCnrigT0c#LVUc8(#XMeU^RCLYdXNPMU-*~ z>{FuZwK$r)VVD(o5Bae6BN3xb!Vg@N2nBJ{Y(wuyGlV=OF*>M$QrLM2150ZhOK_Gk zdaDr#!-h+>&Z3An1p9UL1%}pdAKFZFzU}4l8#?l5_T^# zTP^*d#f=sr9g-jCHCM1|Y=s!=G3%u2pW6d6NNtTF*H&`e+V&$XRc%7s3RTc6aXS_+Q>)if@*9gVe%k3{gkvwVzKxn| z4=!%%OGao3=n!JX3n+f1CI653u~wzn6Oru{8$nf2b#Lg`i@cT+D9$c4$+K!z7TBOP zIDyhy_7#H-9JORr@0%G>Uw1x@>7KV>kdw#{xE9giXi{2AtLc#cxo=@C#5Nc?24nCO zuzkISQ;<5YF0((n-2NFyBVWe(L&JmWHG%Zy>37_3iQ_lH)w~goE1(C(i;98VQzG{H zoA~URvUDl`#WrO&gZAw*%XR8VE%OXUroS{yexjqn>e7cou@9E$KjuxqN^gg)8R4U6 zrl)IdARL^3iZxhCTpZIA z9y&HDylhVQrPU&2_+)W%S*!eh`;BmdihDD}@LbJ(9;(Jf2XyfBvFAp8ulEL5S?ND4 zXyHg@D{2()9737Ho^HgFE}#b%eEel|V-$NX-ILBw zjuqyfl|09pyEU}Nhw__nIe-t{q1-kPwplv}G}X4jNfGPNw{Rc(Z2`TjlYk@h|a zolb5CD2OT<#c3%LdJVD!YoBU^zu7&I%pPNW%y*r#82%L0PgWRlF+ZlSYVUFawTHV< zn`*a2kYfe+9SdX3rq%uwljym{C`UrCOu>yFKF&D7AKH5=Vp*1&=l@~rt)k*;gSEi` z0fGm22qCz;TL^9;kl^l4<1WDhG_JuKcbDJ}O>hm?XyZ=f&h&TY{4*Cb7yEjzRrOZY zQ%{-c1VG@)e;!$#em>}9K6%7m!$=%F)s-Ll{^n|s*yxMA{IB`6?%VZ1BX9rBFyiEe zpP^x4o1M37vk!{l|4+&}v+*5*6oWD+b;8a!fTORJU}rp%o7&+KB~BW_Lrx2D9HKKX zv|#jBRgHaTzZsX2T~3=D!;#rk^}!q=f=&#d*wX+U)~WShE^1@5TWMTs4?7GHGh;S_8m~7OsJuDCj>%Lfu=d8Zo!Jx_W=TTOxzkCVyw!?f$~zc(t9__vTpr z0n%g_@y7v@?{j^q80aV$M>Qz%`V;~O_y2?Ii=Id~*WKTN*F@eJkfA{5R`g){rTnG5 zz^vdMvkY6YA_kum-W3V|hi?kK&d%bX4DN%ks-qcF?o2vg@tRco?ul!mf6 zi+|eE9TkI^PPzNA&w9W`(Xh!)L5IIFym&nS^TGnT{lbCM3^xd}>s#pdn+}{hIG%i{1yan~H+BpR=Q;_3JUq zb96ni8GguofPFi7lFc1~W1cocb18s~jj+5wUkGX_L^_wQZ)kGBI2i8UL%Vuj4`WuRil{h`ZpyF2#^^w!Mg9_+4 z`-!gM8d2QzT)48!H#-}B$gl6eB-MetrXBTGjG&vN1&;MM`zb71$0+ck$5ZmliuoJ2 zf92od&T0u}8}&jf2d(aM_zK}^e_ws|)2-ZN@;S8m@!rnAsH6i$QY8A?|9fRkXZ{hM zlb)IM73t-Bs*Wb)a&mM%LC4_x3n|t|n8;Jd&0A&NQ}=}zow0yNqU491uf+&cPa#W~ zK|lVBN`O25E7?mC@;;VD>0=2fYFys=_@Z_uXNGpNVT16UXhc zR|9Z|QbDqQg{;;z-{9t8p~A*kUDg=7p+E4S2h1X~0=H5U18kp#J{j;^{EMv<$B1F( z*YV2Au>FA^m+eNxd#yV37e%2(h!HtQ^|v##x$93TFRDfx_K<|8vD z+ytcH*yti34$DXL(ez2*HpLo!!wgDPoTs1&PVl^y%3RK=)w<1XM9N(?%!=0Xd9;Sh zQXfT9Pc-tZcs)GVZ=_bK-XR9-tZ%LvoS*Fp!1&AdYxNS}(EAc6s|8nm%8_GZLCZI9 z?lzPgGw4tHIoldFg}Ffb_#5j%c!VPivr-Y@ZS53C)YBrC2vslaDG}l_IJWC4!%BE( zIk&l{?>CI0-S zvX@efpaC6Iq^YyV`?^Ljz#TR+^k+jm;H7Dmo3q>mFMN)x7xMLP_w7!nd8CccaU9^A z?bLCH{Z#mSTtXZ;4MrdenvVIA2%kbzOWQ!BNQ!o%nYlK_Aub z5VM*ynC7$|DO*h^wC3hqHcj;Gi@Y%=p$FhM80|7_TMv#{P9BVPCVORH`T1=fAKpUN zWF<`d8h45Q^0-5t428RtF?&^9343&G_HEDVf^un;Lfth8$qAS@#5b3mBAYUqdN7P8 zQzE4ahRq=!ncaZ>;qWUj_xSJg>VvRiX|nv2miKQPFT#}g0NAOMH|8;u%+f^VEk8Vi zoqh?BVV7bFsA;8d%_g`Bp=reqGV%#&m}+e5%o;c#w#Gk(uf&s5K=d5a_S=)QeAP084&%?UvFdHBHmW@ygs~CBO1)8aJ1nqP+=|8t@9+<~=YfYLBOF`oD%{DxvRXD3Wlxr`Vm4m6cW5 zn@#zRCYRN%ga8teU(MU*3jv5NqfxiGs>Tv8=B7`YpV1OB(&kv6MS@SoI`S1}y^p8l{PQ)$WbhR+|)%ePSEh=)F- z{wa0&X6JplIXi{lD~5b7|d;7M@KM4X>^fvYpz5hBv?MAD`6T|7m(K5~)q`bRvk&fh~7j_I96# zazK2ql7L_o@k=?`_RGi2pUHfM+dMG58Mj5BVYJc7wvXUSxu9u8ff8l?BR2+&Sg`>w zHouuE9!|pH1L4p?;S|RP$1j>T@bEx4cuBg-NQV|Q;?(+WwK?E_DTbiksXXbF1v~Ha zUeu=QL=*g$?_szvRc&T>tDbpIkmXwMMytFONBov-P7C;@1{l1(KJvdN`i?rqqbf|q zGcc-=*e@d4DhX4 z?(84BqN~+!m_;bKhT5iq8$Z>?1*P|1{ljog^$~9d&WZSW#fOLgD*)_2y-U)eHgXi z6<-v_6dcd3n5DRUxp?BNXq`3PHa^LAlSOHVO^}&@LQiB$V7`8nq25PXOz(s5D@1-L z90ebpAZz%rk#nEF8uzmV!QJb=h)%DB2-i%e-bF@YvExdwQsz}T`#%;`L^7(}&dYW} z{;mr^8&fsr+pwtP{s?)#{X}7;Gm*hX1e8ASwrPegQ#05F{osX9thNrn(O4*fY5HGKo_b#1q=tO&2^-0Z=~?MXtUnDxM?%7@*Ajx6@=j1{f#$p35=I| z``dKfR^w*{ZFb7%jW#OM_}hF!xBE|?a^6llDhrq^1nE(dS{SiILLZs3A4zd7;7RKU z*`$@5SaKl>4K(?|Ag-gbYdK?QoIdm$ES!HY!@slAD|0wUc*l+`=Do!#I4pSJ0|t!xZ_%CB8_%V8R#Jjg#xZgeCG5z|#XRU=9^aAR9d;=_K zTSj?ubUN%DbxHEAA>l;HObt3P*8Qw-K^Gh!YAkOZ&O1W=A^1~#==%@Giuvw3cFTKDQpq3)U{XC;%+7dwt2 zne|sXDxU+Exw}FU)Y)X^LV1Di9glp2wlbg8!IqQqgH^>M;o6fV73-ALhqF)0jPXo? zU+;x-be7U)nk>9tK%o3@y29XJ>Pf`%&8QG_^P83T8;wc=gnjkf{QCdceq#-J__e_X zBvioZ+~&$Ey-PURz$fG-=sT6{DM@iEVe%G7Coypy7-84_0((n_s43KSWvO5QeoWTY zWe^vXb!UzwWi^8iDMq<3v4S=}T5T0ltI4?pd|a+LUc9=c)V_RFDP7h+ z;~4H2!U6r9w%S#)BQ-ltpMxoAJ0H0LMVtx+)s|txQO_@LRy;Vc{q$q61J}YY+*78! z8ducE9_SVU_QC&bWr{{a*BxVqWGXby4SyrAaWYhoG(VzVA)PcXmDWM~b^nLo{VRWg zhniT2YR%RD+JUk#&`21sWL<<9jn-#A%@`;{?b?B>ks32Nc0~UHVE$9krK7oZ+FG?S z$XQ>%sfftvY18i5`}u>PL%=DcB?EBe&CHVzQMAmlD7%9Ibis&WW0{XhTgxG|f58_| zx(0cMEkK{Ep7K?^iOR}csK}SZY&vL*R0BQMN?8F#6hT)@i(&PUQmmRI&Z5$(!&{VG_k@Rc(zr|HY@H~x!6=)t(oqA9-Fz=_LAzh3Po?8I7hg*nwmoazu$@o!vze*3QJil>|+{8dgf zS~;Sq>WE{|67TdS+Kaz1lGaeGMCjGRY9O%jSsCZKwxS6!xGa$(cK3M5u%P>-F>AkK zn&_Ww%|5;~381h!vULnG(aOsXdIMf7EuSoPc@mZV=vmAXV&Q`P2p1$8T#yfUTXANi zscekw?AYGkM^(+|J84Ey#BFT1>9H8kY!8{h>+uS0z%ykpUNbr)sknfEN}D?nBBY7z z%$Dvmj^wo)(+um4INJ*GH0tNUF^DNc;y&5=v~txyn=o&o29+Cz#6j=7G)qnzWap?- z9dFd#laxsp1~j)71fZUK(iGjI#|_Kj&&kbJ2Jk5k#ey}1B+N_j zx*U-1a!*2|syoQNG^ap}J|1mZ<7s?*gj&1F0r}clfQ?dxYuOMf619|jAP!mvc@9FC zCzH-CnwTnE=eXI#^(FpLPO?@G4U@7TP=U2SZF+&{;IEckwJ|JA$6tth(bRNM^86(1 zrJ&~n`z*Q3@t>AY2GJ5>EZvjQi;FpCgFYDS%A31u;je4W?^aPdO>P_Zpz|p+eQ3f5 zvBb`|HU>v6^MP%MS`v*4x@4lMMcqRf5~t!43>%9VpQ<0mAq>3C{AXZ>^IIiZ4~6u5 zmbLy9fhRug9FGrcdQ08Yzb4PR(Qzu%h#rkkFZSx7SB{gVFFchkhnt3S+t_~}y=G3l zU^!v?^>m>yC!843mAmHdO=yCFxQb?nFRG*8M{RrUo6deJQO}zylH3|}a>S}Cm8nA? z>gT;%Z*wzB4G?TEX5bD(F0ugX7S3KGa3vXI5;J8i-qMCCQ*(?zZ*9y;!gUDL2a59O zu~L=`xE7={MGu`4#!cULd%k@X7k&p)Tbz&4-1Q&;XZ>b~CBu^IA?{i8RI1&p!n48B zXmB>A-1H*OhF+R--Pd!;ll}fMA+VySmve)q`LWi|jP9mWE9yoU^~wiHnZ980_t4^3 zw6~#Vd>~@SW^$OY06SCdR(K!(0NL|<{w+iAWwuhb;XZ~G*%inlYn27CY&8Vtd|iE^ zuk1%;XlbJYQ`+RudX>@-IsAyx0mdFb!ui30y4oA)%Pn57M zeKTgLhOJC~mLd?_3!Gk`Z7s?oD1_?jl=1WU{@|}sa^xaw#g#P}g?NaEf9|d{yG}~$ z*EZF&wPRy5riz21-lPIUNTcwTg!1-gh8~BMNwdUiJ*@iwxpn^!xbw~urJvW7d9+5dejQh3wLr{#!epVYOIBbHnA<-R* z$C53=Oo#RKGOq7-9R0twLaaQ^PNXxZb*EzoD&LN^+mO-g^C#kil=-Yh_!vmI?lV4T zJzf5mA5r*nnee01-;3vuXahzpJ+U7<=*rqVSvh7hW{|0Q5>GCk8~kx}(N)&?DXhRm zsrg$%NPKB1zX5ijH$moWC&u+-rtuuPNz?KGcDvz2Iw`qZ@-`>Q&&#ruWwsVySJ6`l zMMS@YPmBL5|3nZr2BYxiFo z?4kV(buW#8!)fbU>oq!1)PuoMM;OQEnf&}$BJ=NKnle$~ORUs*%Q3zFqS)iXViYme zgV*~+@61{owP?3TlC5MO=YKE;c=7!V%)?bBN7aA~5r5Tgqg;k-08LEbZ6kjqIUCea@4EHEJyv|VuGAwD=bhvs@+j1>i&84{pXRMB8m1|Ic`YZj*MuB&!R>H zuufc_D(ROil{hkTiDfjccp0X(6XMGo>;ONKv(-u0 z_jm4h5QmY%FIgV1tjeuk6hK*|SjVzn)b1xlI#5cqRS$LCkCMTCx>oHc$h|!4MynL5 zhKOAvX@g@{D3{d^t*l^b@x5d2KgT9`r2X+--lt;g7JW%{~;SgxX6^}j^X zq^ea|9H|2vZE%0@*ovH8kk$S#3Y=(v*D(}(P>SyiocLv=oj5pQ22S_MvKA$8;-qc} zlSpRhi zRE{M8h@qAP{8{;B;9bmNH6eNvXFBUIwc-B#B@DnOot4>-a&lD9W4V49ORIl{sS;nk zngl8GA5}5bte^VOSctmY5Ws%Xmb~hbyMONs8@S=O(czXnbFi@yRehLv z`^n=a!v;^Cb0iLnns7MzZ%RTl=IzrlZ=pL2@hOKlap2w2{MJiMuotyj=N)SLvb(h8 zzfED*r|Hf+m<)rNixd%_nKGw4%l9(AbmK@hskL++ZLiHiL8~9k`luepfkynH?^%@s zV|=@lqN}N`aC5r%(5{{YIr?mnS0%=U?O)HzgV}t?P*NZ#1Z09k3c#>m?#iv`s-xf) zkTUMx`CO*YtDhKljo{vBxP%k_BucSaI_3#J(H+32&x?)LK)&2-c@cdTM;kUX>5wf_ksN1;r;8v0Grdq)O>~R0QI=Wr zAl-rP6O%pwkrxrm1CiH^J=Ksi53&*$Ny0@#`KQZ`)2>RMln2#{ogx@qWe51M(wft` zqkX$M#AxHTu^;@A!2go#<#L18>ryf>(Ta$*>(WtQ-#9TfWM#0%bPzOutNamr&KJ@_ zculJ0e8`x2<$%dus0u!CWo0yMApF9}dV)N*gc=QG4;@5U-3+^>yt# zGeg;BGl)W4rAJVq;6gZn-&OmrD=yAf$yC6#Hx@=R-9l*BzxLi-n`lemRzI|wx`ceN zW+g&y{`RRo>rD(M{1ct6p^SrPZvVLlE(kf_& z&kkl0MhIX-ldqZ}SnjwO3U8b*pEhlr|Mj^F?eUqt@!jJWaQa1-JUkNe5#w`^$K2s^ z^$yr@Jje4=hL)^i_%>a(XvlH$lfa$#S3!hj)T}oaV({&?ZctNwrpwz$CGyM&Z@3@p zHX)4aQ~mj8OCE-8zs|1jk&-)4S9L}^s?ZG0slaIOA__!X>$pVlqrcThIq$4mtVIqc zwKBG~-K&ctBS~V|xQd<_IM&BMzGkzowhO+yfV!#+TH#iA9SF3XjOfVoxWC2<*FLt2 z)I$5kKfPDm_sBTe6YRP^F_OnTe2QE0RpQ-R(tP7^qs*>V(T zXD&D3g2>D5jL7S<_-#z^e*U+q3)nfURb0#?k4A5=C%oHUdg(!N-%WRW;xBk5lY!R6 zoHg#j95*I0`wuV1h1$5}^9@nU36h-y~?-dRrZ&>|Uy- zSTY+;Idsh~F)#24m^&jB2`Mwv#-_X{4O<_bCFL}*0w)9!r}Uk1f|EDl@%6JMMKLRR zbXL-gNo*SR^%7+hs@V*iHM;};a;)lqW*5Chn&kQs?W=e>+=E+u`tYM|iKUzTq^io= z!IL_$rOQIJ`eoHY&?dJe>c&iUWAK*COP znFv0jzUsO1+S=6b zo{0Hmv+L}mX|GabE;RnJE&zA2p#)JXL4#K@hgrhJ8Ek6z)`lDn`8$W;_M-e__fS7Q9hov1{2;H;X08E5|%_3O>| z{~>93(H@bKraz?`ZY5>@&QM2_igIP|q&jPdIM+0w`1-N8ypN}%;V`lqm>gHQi{+}6 zWihjl&z2V@Z{;NB3FJgz!pAqMrOZ6yq43FbNEc@zoxjREb~dkMfQQXoXT;>XUQ51y z#?|AIxSN9Yjd8hCFb;q0lLvkeEL^L{D zFB+$=zu#~Yf$xd(Bk+7SCY=y^Y}fXwtEJTUVM@*MWv{;LUG=&er!2+lq%oeJbn1tS zJG^r}PkPn+1@~dpe4r3aY-_`#}gCgHQ0SGo4G#)8Ad#>7+C8{LZIyQkn9^{Z~A zsUvq1e_e5+XAl0FVtUtBJ)-Z+6_kw6ccqPQ)0Jfx?YW@V`|fd$gK4i$(SnK@!U;ao zl=3`X5(r5g|y)f8_`4uIeDs)~YnK-^ zHU}h%0pIYF6Z3e{-Tu`qZ2m2_g+0!aXE=Edlr0IKR14J>JKt-9lRtO{(9;|76LB5P z8;(99cOYmwRt>hv{dotdM{f(lwrtR$u;|hLly~+f#`=$LRVg9=S)edE>}PxHf~wgA zQK9v<;OP4hz42jA*EAY4>FRD6tGF0ZL!cm=yl%4} z2Fzw$rt-r6y4(;w+DG_3Ce<-oX{PB;qXjA?Njvpn5@GpA2Lg51C7Gemrhy-zg-YCs za$e#=PxSsfRv+oWe$`qOPB*$S7+SW^{Y*DKK+~@q{OYgHTt$NE-2xb#n8;nfpAT_j0YBiZ z58AO94YY&O@+S6VRv#p`UKj-O={v9x^u!k#d2pDgKd|>lMQJTSTl7A!VYS>6yG~zk z+4qKbzoNXdojymNQ{*ND@4fk66564i<@3n;X?y5ew|;)_CUS^d#ArEs)ro>Y&RR`YChBIXXRm2fk2R-@ zUXBd!au?G?Yv_@Iqln@Y6>xf5)RxS;sH=LyI!3BM=FfZ(Vm1QAZ(=Kz+#HAnd;vFP z9sExByVf4SaFDGsw8pvt%#~2sy80}4TGs%gE~B~mR|Iopn(==lCFAE_ft=Z%a$g5` zVj<8(H?|joYC#0DU=$$)A0P&s#o%IxBdv$P6&Gw?KeTB_NV~)NOWd9f9yU-{DrkI*oY8i?V1>(tf|=Sf;1Z5a)2Q&G37e9W9-_Loac4vW52Tc{s-Pux+Q@> z;BBjt>fo;&a>U9ij?Gy^flyI>*Vjpat?fe4=HdmWC$kSvO7P`TP^hcfHk zpxeHRFboeprK4#1$Ji;T@(5RHx^6LzsWdxi5nY5vQ5$j;)Kyqr|O(Ql3qd znQg{vLh)rTYa~hcE;3+O@ki8%x9`@mHlXow3gOS{CQ~ zX3DkJB7NGgMa9}oxTpz;#Sv>Yee?w{SM()~E5*6;6~hp+o0=-j72DfLH**r43Se^V zDy@Z36k`)q`B6CG*bwR{2E3qYsnuUE+DvEVaID_?>w9co-yJx3ZsnEa47pB<$4R{2 zcsxC!YHj5!1%^kgv3}OLy(?Dff66=?x=7OGuWL6GdwE*+xLUyjl889ex#<~#Ed)0E z`W*2SgrjONIGk``ex<-VXB8cOA~=R-$Qe|!5RlGG09hQxnO++lP3zjo9hRE2>T;o$ zCE*Qvn~_Az2E)sgC5unrdaDLUJH6(x8-nbAA)BJAQog2c+Sxtpry^VbM7`kS7Bsn<60Fs}V&3(n3(!O?qJIFgfJJ+i~h3>Vj57S?1(oI*_fhYA+X zG6*2Hd)r_1MKPt3m-ixd^{0~WCy8fk4j&tOhnInI z97}P%B>(kf=+E9wZW@#27v37j-ad-4`|jZxGVr1?nd=X6*_>1iJ>7loU|w#>(*D41 zAYq=L86lL%lxr&-?QeQ2rZmtHn7})v1Fj?>F>B!g%Ahh+Ti0oSEkWB@ucjA0vHw|; zrfMdfm{rNMDUhlOB&;SiL#i->v9e${1PJ2lT+SE+1uzvalD=~Do5`Xlg2ArsiA>l- zJVflOLEOdk70o7~u@6&YxEh6eNJI5kmaIn!&y_u>fxcuGGtl_jtT<`|{w_VJsuwez z(?(kNgVSW8<-6DuHM9GEP+sw){MXS>tdC3gVlQ3w{y>L%^3USi&2KR#UVkfdw?mPh zo{gj*Y`DRF@q!<*qt7xU3KKK~c-$^#&#wEYxBD1a_;atK(P6BAZAR&h`v__C2+4Yv zPp`X4qd&U2NW#dU;{eG|g`XHzK^haD?|+?<+}d1WzV}I4}O%fl*X8 zJux_;$@YsgW2PNR(zMOwN*Q&Vkte0A|ANLM57Gf!Z$HIG;cuDAMM@s>QUPRB1<5pr z07)`v*{Td4WFl9>9Va$}1+hMj57KFG3!Rkm;Ixn4H%^(!Y%mZj`DLIXi}W{iSadiH z%`_}G){EadR01T#fLynQ?s8Ea;Z z#^VgH1NhRSOJ-ogXs)WE=!${zfKR5BN7Uf;`8g$}A?;!|Fd;KJa$DIK59uHsOX*tH zRxGXY{ha5@-jdflmdVxO^uGT{<1){&@ZRz>zTg9QFZK3jTS--z^70m0@(DI!xQ`R&>B( z2@d<~g1Jo&7zwfxW707z?);Os@Vg$}KLb}TjvW^(vii0zIXCOoP0=I(0gaA3$nLUi z=o4eI_Sk_|I#;uPC_0b=}+|iKaiT^E{W;HJ6 z1+e8jKi0O6gQL%5D-M3A_!RqG)ce+~E#{mf?{IR;J<{AN8VJli z*59)-Y^I(~O2@@rMh9*_#2)!dcCweTKbZbta0yOwxDw^>`)c}{2M$(kl0VoEd@*~*fJK3cA& zc3+BiNSPj=m!5Xs_t=J|swq zlNpanqP}OQg;@6oxYu{bYj)>f(}?RZ10T-G+yYw(&t4D(#MN2ZuD_!=K0&$xFnOCg zX;^g2e(Gy@j*_NL>N6U(pHoNURNkJi;O+eDMh=~gbl{&+Nyj96$)-R2QWZ!3Iq=#T zE&0*nh5{%tDk*^fx+P{QNFs=mgK%qOXy<Ev(1+rFdo-qqc(l5yJq&Z(2-DbW!Rau3R8J5wHOP8~M(t-o691`bG|nF~i@kexok7~F1N23oa}i1YCTs%gS(HT_f9 zEu(6Bzk?=JEpBjZg#>I2vO6@OBunf2=UfC3UJG3^&fU{&s6wEtV4gB8%E;j%vVfz> z>i;Oh{n@>@rT>3$5>7Y`7QLPs=u6lL3Ts*5<<^5@$n{)XvI0novfk2vsLAG z57C(tI%%iP#O9E&#NWwYg`sqG^%PC2jo*c*bf>XBGf_`H@&NzfZ7|2yGAt z$a!&!iAzemAvdn%ZFR*$bj$EV6mP8=k(l2(qW3}?*9feF_y!T}646pW@t8I^K$q5c zy$Tk+KSz{boz3vi=^bp#@44Os&YxY9{l!~`WlLre;P*x0d|!ItCGRHBzCTFuGT}7f z`OQrY)VnzXok5ZoHCvne04J-w1%xyujp8<J;*1 z-Do6!cZ$n}tN7?PFVg+qcOQzs_G&zK^ed2HUl?j|dldT^^2|tp%Jkyyr`l_$y8u9& zfXTq(vDgoJJ%qDK5X1sZ6#BHY(PYcuOOPJk;ykY2RTSW^-wBfTEyCb9$HtG0CMQM) z+(Il{%4GyglkK})~82KT$CW+St$BuMSi zi9h2@%i9S4l76(bQ8xM^QK~q>Z}IGN@uw|!HoPTMUr()BXSogb z0aqe!dF!6-2GFoXhjBi((iMZ45Tn#Q`MYNLI0(!9QvmIcS0ALcZf`d6Rx?_D@p=pq zkXR6O0jJCgux746Fi73+$FXL}Q7n@&F; z@)y^Go;XDd*2HNv%GquSgr$ZV<3o!=OgiS~Co3F9ah8Z-TX3Ttn8y9HDJTgPN+n?m zpih(?3d>4j%Xqt$r1eYAk*2G4K>hsWkAT{h^~JmBju;r+ z8@p2ti<@$215pLCqRgxVA_J35bNe^nzh=h<#-)~NBvHu)c3-ZWG04^|^xHN;Yr%05 zl-G-ggyKjC=GCYBnRKZ*jh{^OCkXV1Ns|77yozTJxl-_o8@`$R`YwBsWImxPm4&Xf z=^`4u2-*(^1f6#*G+>i zb*;G`;&IOX0=pEN>3rt-uVLd~Uwog3h;-wJ}4n@9Za?DK3pGs0HwHq-fq@sY9?0*iLO6fIG+6A^ilyTz~^@CF?x07YEv`PX?S4wJ5$puEW+o3RoZd#Nb3r!EATk4>4fe7 zuqR3(*D_U!6IT?u3A`fXcMGtye8HQ13E*lgd5AJT~u6Uqz6_jGg)<-E=)G&9}{HF7#pmGDBo#vw= zJvwzd3nH0*``$=;w_QE^&ZwnnqR9G zz4+~>u(aDEp7~p7URcRg#^o%pBn0X1S`wDF~U4fvOl&&4HQetWBGxD1BZ!;3Hs31CY+p-Vsf_Dsom_D?Zpo^ zhQ4JyGI_uEM(h>G2|C2nmLmjRe->rG-x&#rSsZIQ!zvOhS3&Bv7#jHYg^hwQO; z5wbis(fCovy*_dSPj9*!9lYMAt=-l&@}8UHx4t(VTIxHBPffo7AiCYfh}66>n`GMO z+x%knCN0n)gzc3bk4#8cSznk4S*bqvh|XlBEq|s)xPa(}tVD36p}3UlUpsjy%GYz{ zWor&Db54@bEiE=v4F`EL!icd}8+kJFh@gdIR2+b}FS%dLjhm#Yol3`Eb4$m_SyZDNUm*y4xOw|0278Y*j#wzUQ-`{8 zz&GwjB)ZQ`Og=j)T2XO2ZEj_5IA({WBu5X2w;4NxNI0qZ_B>Qllq&lz+c~M`nUEWWIyTKT_=1(GWm^FAne0eNRZm z5|2r(%Pz`klX(55Ob);B&P7LtmuW zK)0XdD4vTBnRfE8w6g5}gsE_t@2wr`*RDKtezJS-lNJPc46iZ_fw$?!^Rp@Zb9K~U z;7VC6NE$C2pi23N;Xxv&##*?bxPuMHx=J+PB72R!rNrsq#RxCitR30LP`?8BHp%0V zCf=W=A&@Em`wio9{q|SY0-Ud4w58)GOHphjKn3&uEIP{~aIawf$?oCG{1YMlmF~24 zEK~B&k*qcz%P?j?;zTXs;Wy6&u!AX!0^+=X`P-I=Z98Nn@y6oB(!}DtKeY`)|U3-2H zYqR98*T#jsZ$bMx)h&~&SU!oJJVf1UyT=;Ke?DXKq<`&JQT^&Lfa^E+brkHc2%q#n z%9@avU0C6C4&jkq9c;+)tT2U(!d^Mq~_3@ zQXq&nq8%~tQ?O3d&remE!vYbBG2rz*c8$ox$=}IPDfs}8+-@N#P#L!V?m8>^m$3Y* zqgtG*X>5d4Z|lMeRMd|03?~NLM9kfdj5-YG)tN7<2*IBQeV8=tY*e`uSs>G5xdJGY z&;@R20ctCEdcZBvYyh3#Hd5esLn3abNXzpr#Uy<3J*yvFdBoSnRqxg)w3BB2j#Ju=bgQ)1=|j)B1_r`aTDhF)^n5lNTIGf^L;56#EM%X+MgsKS+W;S<3Y zIGb^4!0@t1%iWrup*V?H6~3AJEZ`*!!f-ZJuTgA#u|1qF>MuUgc8+PDT-_IbAw{*s z_2$e$uMPn}ZQ`?K^J`LW#4`^kRiV)2|IXq95}9{G6JjZy(OSGyixc3_Ng`76b@ku>ZfU zGR#@~T47j}%@8KuQXjSAuqgM+*J4ARUr$N(#*JaB0WC=~p0v?Yfipvz zB$Y$E_~uf{clk&S;ZREouVxCpoTZQgNcq$^2s8g(iT*?PwK3DghdI;;Qg`p5Kx2KP#-%YJP; z(^XgSwSiz=taFD3_Hy%BN5Ds@Ylz1DUzm64=g*{y;_MNFw%|FtkYTlqb#G3{R%3TV z@$YGmIc%*47p2W_#|5e;X`^(89fr*JYg?M%=CL}R2rl=(eDHa-*2_=)xiaL6*-1SI zSlMtl>z)i#@Zo{->b^Tmy!!P)H(zzj&Ez$+_@7yU0QcUcMWuj$tkoZQV29mbc^x1y zOPy%etfKlhNsH3B=Q@iXQO8;h4Z)N<`yAGXNgH#bAx_=T5OvV1`Zw2|k!l{WyPDg~ z{&c2OmyWKfa_9Wh5g)~3&SP_OJwC*^&9Pq1;S0;Jlcfy9ba6Y?@=aJ@+h73oxdc<&A zoQ!=q+v3)z5UBaVa)Dq=IR$+*sYW&1m#1IG7d&%km;}rQ@P(t&6HEuDA2n@+;mj-U z2T|_g*V3)@wSHrT-VNX3pQZharga<6J<$?Ehw3|Nflm8JBo)&p!D~@=DxyQ&(d_Wp zE*wLJ&p{p5Vt-^DQ7I0q9#uv=FL@H1uC0_Yj*$iT*=TT`RVo3-Zv%sbl2YlHN=9V^q}X=~59OU9IsuF?}`$lcr}ZKW9(%WbtETOmsF5`3hb) zUONA)uK+x&Irhku#L8vpoQfRwobH|WA{}KE?R-Un`rG%PHp#{NKMXVOx6w$NDNFWN zHaJgPtoPcu?it&f(8~hx4f{J9oQL_=`*8v<{8_U_@L(6@i1VT@9EOMf(j@Oi|1Y-Q zGAzol?HW};Qb6fOrAxXSWJWqgN|5gEMvxvrx^w6dMq0YNySqUcy4g3+^SI7oAg7P6JlirL({lXewi2;U+);#!8@RIe zR{!UAcJA9ua7%GV#uNFcG0Quprdo=R4dJAnk`Ngs<&9)e(6m)a&zQV(J2ErZYe#ET z)XZp}$$JnYBxdcxGsVvAOJEhq-3*VHyuhkBA2*RJDd7-#%Y1Y6^C;&Z9lpupo=1Ym zWo#shm&G3^ep5t2`WOsC-RfPqy>|w9$-0`aWU?{M*pKcux=#JoXq7CAu>}~xM6ot+ z6+6w#UBb?svFXr#eOeTSUiR+gj@xv%{?SFS}_AvAs~~%))XQ&}ZdR*l=!{^qV{jJA>b!}kUS?nXh2ulCtFziu(@xklu zyfI3FnZ8`F)Y|4NKF>K0X55d2X(G6R^=Mfd*BdS+N?pnqio8ZYQb__KXrucjC3a`2^ zN@bh`_m`jz2SFNDQxFEBzPfFBn_d8B)Ji~bWXpR1>md#_p75Ca_q;a?7J|uHk0tv| z+ctMfDdi;gH**UWeN<35hr%~-NXDdC<5oK|%R9DrTyh+2%lO7)NxM3tK!H4JTn2Yc zo}DA6E84~Ynh3e-{tJDa)l$>xuc};~^Yr{!)~6aeV zJ(R)FoD(p45?1gxq3E=2sf{GQI>0Q*up#fLJBC0la)_OY4u(wdZgkuhHKS_8LTbwF z`X-3&%0|0cCY{r9LSUaKXWV#h#@RoUEA}bA&vM%R3{xCmKsu<+1Pv}VAgn7b`&6 z->O?{!&WBwaDz`FIxj2QDapGMh27D&(Dq|W@94*(95>4XFcWUv`imV|>sibFtH*nD z^N>#t*Z0QM@KSI8v6yQv&Tn=?c9zOBLYFC1}L9qbrY87vJmQ5 zCua-)GAp5Eu+wS{^oj8I0DnGAXV|elfOeUpjM;U6}-rm+1$^3BA^Y z1cJ$#nef`ZD_-k)>WA*oHJrNA;I@xH7D5kBK#fMa=Fp&ivkDI9Qj?D6{ekY9Ih;WzTRw-b4Hx9dt*em)n3G%>uh*&3Bz^Ne-T zv&Zl{ixa{B}RJN2o!Ruf_ih<;B<^Y)2L6EX--MF5r3j6Ww>r9Qw%`b@rb`o z>Q$*xur4~>n<)6w74#ciFa{Q-OOc#Tv7P5}NyKp?9>mX69<*5c10SrR6|CtcwV$t? zq`a+oA_$7Kgr_}^fa>1|@XChf%Rf6NA@)Xf8*^eD8qOyIUIq+0^Cc52qtg|6<@@mX)TfQy&f zze|9z){bZSbC}-O4%9aSK%QEEd@-)*)UX?8EqG7cf$)t|23ZQ7HVcw+UFQOvnYdy-4N!GCuFx--jC=7HI($rVvGtgyVQb#R? z3$v0-3`HWFV*+y&09F=UuJ1V}&sKC0!_68II)gYJBmtGS#*1m~>(c?&Jnq(H(+mb$ z{uQq?dGjH5HIVDxc-}XhqM2{5=}rfo0F;!yTZ3x@X?Ils0PcP6jlkr;jTMk9Iv;Ds zmeH53Sj*K@2xRF%C~H>SnERqA=Y<~exX*Gy?^BK^4^H8S6SvX7wctoqa?^bYV(v?b zEWZl^`6hU&{TPpmlChjDqC&e}O`}aq-w-Q(@1$Bfme=K~o|n^4;Y|llqgU`_OgeeU zbe-VJB|w&K9;k*QKE7za`TCZzcKSmZ+bdka9VRhrw_K73gl6nyf5GSb^Beh}dQ{bA z=a`uXpB>z^7_sjdyxR6)KOb``HEz>HRM4-ErTKSf=$qU39{=yq# znjAa9W@G-+fTQef@;&vrhovi5&Zm$FYw!`-h+5e5dr9M2e2Io2p-098|CeW3k>bIx&&%_W=a->$h%`mX-j!5DL8^1ZLLl=!X^A_Z1>Fea=N>b&Ap&cUUy9 z8(uc@@9ju#+C_l$XEJ=!KXNwIr=Exaz4a`%LHX|`>O9FpJv*84?wJdhpdEl8&>A2& zsAmh1@?E@%LTG+bBie-hJE7OiZ-RJAB$JRbA(id@Sb$SFb~fYpf~1GuKes1+%FA?D zuSQ-L%bDZGvU^BV7?@>nC1ZUrj1?u({}#`YGM{4 z?B@3Z6snq39)K=b0??8oqYY@H}>`HVG+i3VUbf0?RopD0*BYO?8R4;K!o*z zY=kd^p)YjsrA!NV7Mc=CmvjU^hs7j4d$#n!t_0A|pHJFl{)Kg37ZZci`1E*}B;?Mq zzOj+#=})ix*L;H3eDDADrdvtt=?M*ohl3fq>C5)QK*BtU)%r_@+FdGHs)-Tc`Auq~ z()8`Si0@pdQ**nZF-Me&C#Xsl?_3uMFI;yr$)?DnV~v$@)f)SqImGVp7`rzz=(7HS z{w{|kUT;R)@`EH8=e&u7(3I2fg zxi>2Qh&eyjXukMp7WRke9|${N=S#@u7<{~!WKSGjDi2%U9@#$kZv!@+g;EO}jYzse zLB-JDE^n%EGJrv};Ra?pjQY?t5F*g?-mCUN=$TkDt?3bN)yL1m6+%dn`mT{~#SO*h zQKuVOTW>wNq%Gh%vmP(3`<~~Ax`;i>g>N12a_F=5?y`(gN?SN{lf;}a!(K=gL5fB! z0tDqlkCT~o0V+Z?oSeAYwKiQbG_susSezzD`+5%AW z@^Cu-uVr$7zHUoQt*EPLB_F$N# zg|1d}e$Yagot=ZG%StCQ$3DqFZdZtAoJk%yX7y>kw=S~dpKX1L&g|oe_qdAD*a4;i z&Uu*%=XOCuCv_ni^h8*Idm>`UnKrKWs(g&l`Wb`}%Ss*|2MZll-9k*x=j<9Ndzy=w zrgDLZ`ciY`Q+K>E{B@+GPO^`|MmLIvPBLprb|Mf-d2s*uLWrU^={h%3iXb^MA_E>q zW%|MW{IzrF*a1}aMWlz$C>j&!05a-&*FF)W43)|O1*_{*>fq#bzB81W0&q4a(jput zxgm6Yh3_*i0{QkQ4!~Ra0(eaxZ@9ZI4CeF*lAm{&)P^qR1^G#tGeEQd26A-)Nsj;( z1$K5B>2WL|SaT-SvHQXIWV&-BzGv&4DGE3wB15Y>n#hnIfY7$*yv%BW_Zy(%j=sTq z=c~Yj&e~51uKXmxc(dSEfp2-d;GZ)S9vJW?an{U0E^=b6y(aN$_3W;Bk3*E6X6&j_ zg>gCZQydpe%X+={Bz1-^d!E8$C2Iod zKG)ER@uB%>rEB(boq~(PeBF(JhA+dp3ob_vh!e=54Je&CtDK%)F4z*rrpqRNjGw-Y zd{i&|$!G}ppjo@DXo@qN4D=ROCrQ>-?C(p^h41CgAH1#5^OxBaYC27+v+MO1t#tts z&5HxdrLez$kh7yZBlKOoCjEZ1TH-ZxroxW&y6h$!ly00^NWxO{z@PFXsm)@+!Ku8| zDm1IVaO8dNt;L~Lok;?nCi86n?h)WxzY&u_{c%3_c=)N7Z(^-Fc8@pT(+(8(4;!o< zKpH1Fqq%r=U2F{Z>3~wmq7lJS zLu6ORFAmfV=WcOEO5y4dVOC1m+&;uKd$dqdKpD1PLShBzp2Yd8qSeNNo1{o1O@)DX z%Of!4CMLUzlTsPmKkt$`0B{b~kP}Dg6)jFC3qIDl$*jn87j1m877J~R`iGg= z`XzGjYZTZ^7vhGXbj8D&{%O*!5Whip0b4N~JGPuC9BB`xf~(_PB~eN$@9P2{yE8tPRfGZ!aVmv@y4;s)n|R z1q_Gd+uz^M&3l(ZSXJ2-P8c3KI!t3LIC?AssDF>+Jm0M(j%VQ%g9+>RvMV0Xxz@uA zMxL)7MjQs0igcmIw$5D9dPt`NjQ}yMBOmNyaDdUU>QZ0NKBz!MgFe5okYj?xP9x7u zfT8;lw(c9uYzFVWdI!`#(-Mzcs}1M#xFHNPNtNJt&F>UKeoQhCRe` z6L}7!QbR%lBl|l`>JTG9J}L-t{cGJuT7hn;?0b85N~aS8@aRx8!7Q9!pze`|&4Uwq z)`8a3*5LKA6kgTwc9(c$uOy>rYQw@%XgtueJFd7K4%x0IED%<<7dn8%WL|X1&z_#! zkUbV7d_<|e(s&Q|kG~^OC-t7* zLLhNH?lo`CB(d`HFs2p15YU~biIQ#wppI{1DRS;J-+X*VPXgTfU;O;!REe9d2_^}? zrSque5iwa@C^{W$Ab97y4AO|c>?42Bh|*5+Y#WJqVH8AHHMJs><&uw0#Z;QV#LnL~gZ#2@`ODu??#G^%7>+c$a#1zqfr*tY9W)gl8;Z>N@*8jC9ctB4+`{pD&P8NmZ6|g^*G#UYLW^JEHrRr=qP`uA& zi+0dDHdc07LP=D`@^gQcCkZe0#gW*Vm&%8#ygVtnFyKG*kR|?a-rLN$Yp;LxI~9&Q z3ic1**O2}j3!{xbrn*k3X~Yb^-+`akdu!aa@}4w2B-J@FpDGObwUM~@DUxi>D=qp* zL>+zlrWr8Xt8Z1I958>7cN!f>4LMYfnpC&2_kfix`^kdm^AbKQ5_rF;R1q?m)0xJn z6APaCi2;6ZZ4joxsAPj^Q}V|U&~#a~a4_u0H;m@v5c#kz4aNC!sYU0~*lMMc@K7NGTQn4?U&>_4s(ItoBx%?OJX}gVg_5#; z`~L{RAlcV*!fn}rFaUjKejcgpx2aUn@V!WsRcW}%Mq*@VA?N9LNVM;ojyVS4ghe#i^HHVhSSQDyvQ|4i}`ctFL=M7=#j0QKM!3*85(*Pq#S4aqhF=zl`PA zsk+U5+i=ShkD^yCk11Dk>4CThs67oo5(PxiRDaXI7DfQg#_Ju^)KouYyiA!n6Ug| zX##(!gQFv=_ciIqOD)f{iy zHBkeLhro2HqZGu}T){zdK4E!LBFs`#kpe~##g55??oT?Ws?6>S+g;l&$Dpx;uC#lj zj{co9C?H7F7^&8Vg@~cc02p2xf+~+q!HL)NFPc+#TJfQ78N~Uofs6obm47c}&Xu!y zGLJraZ28H+2f<-GuS4c6w@BzlI=zc~fwbZ*?*aH#I%YQnh-zabo>M!{7v91EO4h$A zYp;7VCnX&VR)kPv`$CFlBJsgLKHul?VzPP_A5y=M}}R*&HQr<>I9s zir+Rr(?6VZ59zA_b$5xKL{wgqP0G+7j$yisCtFyc|NQ_wuclr+q~Q;@zy|1-GZ>eo;G72KOm{Z*0~$l0~%h#r*RvYQP*F3TJW#w zc7f>+CdJh0D8O-w1|>F9E?I%;Rub{h+EZncdmHsir&L(BX~i!4?VwkuQGX)(x#vB- zPc70gh!FI#KQMxV@TIZsRnxbioS7?VeT-oETx-rz- znbBRlWOj8e11qx&nvAWH5eYBd*G?vDMDklZXK_9bc%I85^qrg{$-$V+&v|_iDc!SQ zWA8RH8u~0b-1wTvaC2l9;~H`Hd{f~%O=NRq2=q*`DUG&wq2xZ?bGClE^1*ws_5H-H zuCbY|oW(`Lg#)IW*yRiF3IY+*h~wr}3nx3h9F%ulTSo{6NSfJFXGW>GkUtLq&X|(h zb6>f-lA^|q36z!)nDp8?5gji!^O&r=O%c0edGkdkWhb&^t}}@xmsXNo{`Wnxg8M?^ zd8STFrzGo&?~q|4oxa&O=)4)phRpODF}S5BS?g{f>v_cE`0VQdNwX3tu5O+n5vka7 zR*gybKPTlZdFDM_=i~2&TtNm1o8N%p;Srw91gxOYnhmaNWiMQdM9QcAU)GGA|UZk5$(H5NhMJVJYp2**{hR17%&Ph)EDXa(APAW#jn-nAq;LcnrtJzp*4v;|I;PScXsg z9TmK%(oR-(0I#Ma5TJ%Ur%p?QfAw+Bk#By|(x6(p@Mc{EH12F&eIu#|jyDy)Ux??64|~&M!Zz8_Mpdhkk|T||v-s+tjyT9}{bMt&c9p!K z(VWprr|AL^hWt5aEw6QRNtj+U)grynZzao4t0pO}j@eZVULYNk5qHo>c+KP7UFpaA zB5EnP$rd<&ZnBZtQJ}sVg!n%fQh?aq<0Al~43@JP-yJD`f~g9vl6!+h*1_EpC10Q3 z$B!I=CGByiAN4WjwcVQ)^L1@%Fu={d7n$@`>$;KP_HnZP-e@^hZmN)ky?D6D9lJ=~?DjpSb4= z!;i`_8j;}?tAu~blr3}`mo-1ZK7aJ_%+tHsNMH*)?E+Ev(t-kJzo1iwp>4Ef`c@}D zNk_Uf(y_I}Jird2bZ3oUgZ@O|+f{>gr||NzfX`O~z?%Qb3yh{Qal7i3Hb;|NrW*E@ zVf7$pDgLb#3402nYG`yOQ1)I+^*zKRc^A!2iDF2N6Pv|#x@g6-5g5Q@Rf6q(`ie%} zcO=hl?%jYO18$Al&098+_X!kQj!2j&slSpaqaef#Y&0oq{94_|vD^3e{^0(KHA05; zZt^_D)aq94e*|;NoK>}-XZG!3>{#u~RCO^h@i#U?vLw;(x;UYX8^jDZ6=cD@cBiqJ zqJUUJ;eRUJM1bPX-XC^}jv4fHWuJeFnG3-zPs^{$MrYIA`ZSUPgUaW39&@8hw=7F4 zE^dSkHUeOuaYLn*QaqD@*Zm-mAR#|tIf-oNk$_>k!4@t-Z|X$5yxes}@vY(tI(0 zX6>6RQyPaJ$Gml}nUjV^h*XOD!-N9c78-BH)?hy>t>_oN)7bvHuU0?}joa9)e8;Uj zE)b9iv;tILp2LI5RHr>6SZ5iTmR@DSTQJX;4l8c`ac;vb)w^EBT1u2V9SsFX%S9hcM{uSR%Wv^Y>@w1Boq5%qHLo&(|j;d1TvS! z{dH!;D}`igyt2@#eY@oMAM5-99&~}5iv^FBIU~e$`9-lS*Y_20o>>|2!k>F^q;mhW z7B$(_B*-K@^nGl~B$`Z~ZPDgtm1U2(Z47I43BgO>7hUCv1|xSUow;ue$NXzt8G}g~ zq?Ib?kkS>xJ$dMQxyl0oQ{{S^#wQ%U!(xPJI;aU);C{O0A{B`~x-EmgRzM?`t&2F% zb2306JQb^2{|O~{%qf@K;F6e`L)jEIv4;a5Ed&ZKFiU5R4Rdf=%MR*08Qw1Qs%P(6 zs^EQxm#?$dUD@cK%tn{wPYMkil`g;VOobgkNSgfyE?Zm#uo~w7T}`S(mj)5@Da~iI z$U&BoqaQv0q}mwjKc}Z50a$i4B^e(ZUk_0%ANB4&MS}Pb*3|Uz?MpMIJpl_FqubHP z@s;}z*AJy8yK2+sJ#nGipJhpsUjz)jTX=hD=9J^%DqJ=C{uu8f9^>^jg54xP?CMCe zP;|00y-N@lxjjjq`v(Rw)=6$%^k3*i zi(WQfRjb7LI>znX8!1Qhi>Tso;V2+vz0I2Jee78#IBT%{Ug8zB)EPssC%2%OrR-x>WcoHf50rJ_|cl92rhtWjTI8tDg>8% zV;x@9=T?79=GKy%NRA$IEP%ZPtQTqh=MYo)>5&x88K2keUUbZWC&af-G9^HmsltVhFpkoGMvUC1(|(F_~cAX#+rK0uUV0pnK*t7tSkFrN(4QMIhhT(<5Wq?o#iv(w@;P zP5a(p{OQ!7cU>3jF(Xz?C45z2++j8~AfixIxZe@YT4LvoPC_uvw{C{ ze=*2>5~5f@2p+V83*=V!C^^ZFn%Rdf`@5~Bz#f4>GJ=l<#l${R3BQZe_63-Ca3EA%BTK)6Nw^FaPN~jEt_`-G7_Q#JdQQ`95&}IS9P*ro9m}BRP#_|CkCszvFV{E`Z?2 z#QSe7%)Ac}T$t~5Z|apA6)0UA)tD)&wugp5I+2)K0k>GmyBBkoWV0tb)&?Cv*l9-& zE{bY8RZIclmd3}6{GY#|Vk{mcujW6nuoE<=@e_|~ZyLUjNMN|hef?XV7nGKQ86Z!2 zIHioH*g)8I9GCN`#0f-EA!6xWfQ5};;EYIt@1M_ZIA(XwoL$G~XvctpD>2!XjtB3p z_yS2s&=rQ>QWX5QKsFHay!-WLBn3EtkXGR1k^bl7i*w}xT-NocU89&3ktpnlU~Q%9 zCIunG@{@M2?6s2N4rSL=!UM{+O*+FhyZXiAr{AN}q$ZWGwD%*fOUJ3pj?67$P%t>_ zsYwn}{R8JJ^5%@d&f{ju#pxFn-P*tSIbY>#-0)Auh1^cah=};#N=BSaY_340Pyse$ z!&GhgF%kEK{|k|ms&OJYA=vo0DB#r4eIzCn&UUc&$ zlX~;9u4S=CQUY5M#6L{m2{MW1C!v4Sdlg*=pCq$Pb@IQ- z<){ZAlNbgt5n-s-!L2&m4_DO~7>S)g@WbB3Df*|Bod=`nU_f(ExdUkD@Y;}NxUHkX zC2IeZE(RgQZ*$VU8u;V_rZJSACKH#HA_a^qJ)f$@b@Ax5?>{MTbD)brgpmkzOGsw+ zMJ$&MVA*w=QM}mNx!l4Lkr(TWI>A+)8prf5S`($GP~((uh0B^K>FVJS^Ssw@vt5Htkj@04{5s|oIplgY_B0NPc=snoEv!EQZSw_I|YtJowf z64ygueJ;Bi->iJYQ1H1S1;b@$MjJIANN5A3j0yh^0Y|~kGg~EqNvq3&3@Y*3Db+I* z`sZ=vbM=gh8 znDwO4da*=B^Y{cJ43_tz1aL0Gnr2g0wxMK}$OLnHDpQvrK0OyPnicX}o48U&@Wz_S z+TCy-g68J_E|)qf3HQe6-bvmJR>2^f&^#55r8A%m_8e|(pbBOT4f+A6%UNBO_cKxT zR`XR#zt;0}=!QcsW`5C%nOE(2Uo8bUHVT{;Tbw*CTv2NZrl$Xt_ zAGmy)KC{Y6bwlv7?S+_kLN8K*qzPcU@?C4z7sv8KFnRY+9QY=`iOd^uKy$tYn_ex9 zZpW{jRr!INVapMKK43l(^o^*e4fr1qZ?Vhd`&9stl;4qJkU;(g%B99wVIUa+ z;G%{ehBT<5NuaGIVG8GXwT=FlDJ+#(h_PC}o?()dWC{&%YcbZH}CF|hKmI@?; zq5Da96UT52cqxJN9m%S5i6;pPAb7Ard{F-WU{3I6GuHm@sMb{)AX+#(Q3``F)f@@l z0B1KX&DB$${Ttr~Ob>;4Vtg#s1=lFk0XpAchbuF*Djwx_RkR%4u*;a)CM$fjh_y4wNVsc>;G3jI%Xkhd!r^8CyrRO-u-8$J+Eye{Emd7VoBJ z#HSYm(U4sz#90@9(k@G1xMXG=Eo7@*$oo5{&t=j5dukQewLz|*u})iNY8Te|23My| z0~H9b&O;g6E^}n&{ePR(o-9V?ROhE}5Qn1!>`33&(g;r75aPPEAky5t(Ovd)4VsAq zOuKqAG7aEb7NK{sgz4e+FA3U`)s^nO=&z{tSKx7z?>H-GBS_e!YTzVP$cavj1aY zN`7x6>acCx8e^r>wW}yVA#gvZ%oXprr%mt;xY+SnxrUAbVa*pvp5aK~k-?o=PVT)hXp6Kbc|5+jDx7f%nqUhk#8O(OTYoiwkE9yQE4vnmX^3xe>XBuaLwU1@05wJIn@Uxt@1}B z6X&@0FS*xKeF@q~Oxw;$yQyd=imz+f_u)59H>ZlI(y2&-doA1kZU zs$3Ck>$2lm_eeZ}RdxY~&Kr*o_ccA+n&(gdhH3X1=Ah0#$E8+C?{>e}@R0tb;$JW&Sz}8Op%{xN71vf$+9y5QBjE zmrY=~XiLYlDV|Pe7!L85;{Vg9Xi#1WwE(ji#8}buF=>D4QjWMDVUfa`Ay88k+rYBglc}W5Z#{4;v!A#l zRqeie6Z9DjqBjiPoUn72LI`{JR$s1vI}1nCLeL6$mMyU%d93{CNGQPhH5CbTPq|s#*gY zPN#Q>212T;eR7P>yJH6xa|eFBpWX_la9TGHngKda?UAOHlW#{D5BdH=k%tMK zhko?ViUG<|?c9Yx|A|^uFs=9aKb7pgArFXv@YlM3bE`DNCWQZK`?6E*L{m)PKEYJrralFDKlYb^L{p?V<$ppdb{;bH zks-nz=jaWXXT{DC4s60@bFY4#xYc6q>UPX6>(!lzP$#BdchDQ}l{AHhs@#v{P%%oD zFsVvyszw6LeeBJg`-!>2C1C`SV9hi~ljh8w4kNM4QZ5ZiC!~dgbTi@k$XtInBI|zE z5&V-^qjp(eW|vb}?L7e1Gb!FMQ{8exk<5GhKjWkDzX}E523kK>As0S`)1D*tQG-9j z)Igx@Bg9EJ+9xzljxGf+Es9&$gz{O$vjZy$1jDGrdLl^amJFV=)dNzC%}A{@LI(v! z*9JmB`ujWEuCg77;59*$Q`G5mba*pkvnHlTj&cK$!ns|p*Vz{s0J`M}4_S-;x8Cmb zdcr6y!GBg=iL)+Hz=0%LZF${%aGr2oJZxNy&4E`c7e6`v-$*3YoEDx5;(kS7!ArG@1Cqr&Y4={0)pJ>NU}U|Fa;oxcq6?<~Tv%BUR_3(5-P04DT>n1V}m4cp2_n}@t{MkaN zMrJ8?eGWQedg$8Ulmu&($Yz^W$sG-YCKI{Z57x&xAkN_QZY~E9Ccua?Hnk`>kxiV zBsmz!yojlMBD_P7BCzdyYcHo`*4IA3TdLmlCUO_fYIT`DaPSP0MY`-Icqkcam-DW- zL{M;DZ{gO_uCXVQuIJGZMEo&%4v?Z*2sJ88D1H<0s-WWrP+7!LgjI=kh+ zz>%xe$#$!D#dqRXPEz!{VS6_45%+f><#|ipqP@0G%>@ zb$kjA9#fkRi^g#L#l?u_5qm;$wfGb72WVi@%35r$TZS(s9YDe-k?rF`ud|Rv^jnTD zZ`hum!x& ze`J9Q>pAEPA{V{RhLYF~gQ_M)wQH=}Hljp7vS7Z}mMg7;dwFI*{j^*|d0_qMx=4_i zYY8u~%fmmOK*cl;cU#Invjz;locXSta^k>y-2t_i`|ZbP?|68`wNx@=ZIUA=;p4k; zHacY#jjjVEYgroMvA*oMp@!>f(J%7GG8dkjD1%!*5{gO!aGOq4YYaxF5?ZzPnT^xc zrCA{ji7I^_5AwPWT^5!i#phT>;D$d-P}Q@M)C>?IW_$EkuIPg#WnbUiQ1Y}*t+ur{ zn7sc;mk&)Y{R~Wq(SC%H;x81hZSYqTAK<4C8dhuN(HKKHf=PmLSEhPa@A8pg4&tuh z2i?U{_4nH9zoddchndE`SUMePGQfXV9z3wZF%3YiqM3jIB~APQesJ77GK{=#`Ha~>l>7ly@4MW~OSbgWX=ub&Tmd&XLo5EIhz*`9g@WVX3Q{fD(&ifqAu7owF9qD(mB?+BAR!KYh0QXhxtQBuk!% z6j8y#Ae`~V)>6z-3L|r{Lj#Z&XXg)?KB#rrlEEV+%p47T48pNLjRjy%BvO+1jC{g` zk8dI*JsyB6N!OSblwb!P(_jxP5E|q;*8gDFKqcrtltkhl_z=+p{e4V(gb@Kk)OD=w z&oGxmXx~4>gpK2bBX7G=tvecIPYfV|MeUqqF&pDvq^BUr#sGkcKRKw1Wfs~j^9O)d zRCl}h3T|~8wKTh20dJQ4Ec?;Pb476OXV2ia`$Ud9kPcZJe2{}78`nlNWLN_Qa*ev@ z@2^UXDi+=iO=!KiYy4vz)7jGYd;&Ur##EC!I42E?X~@toj~7$;yzAj8E#h)2uM>oX z^upl%pgdb_Z=E0CY!3sXz%aJ_&rT|@;@iLA3UJQb)NXu~B^hSxO$_~mG1PfnMV62- z87RAY`E6M`ImvF#Oe1!Xd}sxLqkg--k6LM+*zPED9sXpMFaH;uoH8&EJDOWEqqpA1 zGVE^uhYr0`EDrFU2s6H- z2A~B=ac|=s_r{^R?zuz^;0xs1?jQa3L1q*8d~v`Ck)_w*kTd;@_Wg<1{R&R7AF4fkU?Qv;Q`vGuX`00ov!-uYv5lxMrs9JKG0Sab&0b49B005hGhY8DFu`P>yZP zF%9L403Voy`UMv{23e9Yyem{}4rrz4>K);9AYL>Ri^pB(um;8qxnPID9l>R9V!e8k z^6yV;bsGo)ogll~l7n2N?jTYcjY0uGEgY7YWdu_`tXh(T#@1tI?3$)A2^v+Xycu~w zg-F_rm$5#DGJemRZx+dwwDuM80R{j)X?U;b_gkwP-L~l>A?Z99V=4c?OLzc=Pf1zT z+<&G4-u3thQz!Dj-U)}@5RJd!IjzVlr~|m#0&9^t+~i!?xgmW#Mu6zG2mF>?k%{d6 zC8w&BiIG`AlwmXzPznJw#dwy@so&n?QAzCMqJh%>>nk8GZ8#S*fz=<Efg@~^VJ7tSRBaJ7ua%i&(>~#zrg_Jh!NU!=$H?+ zY6XdU)89XU6Ql$Bp;7I`Vn)aRZ_po;q0#FA- z`iSeIxi+XVk)Se{MUX&5e53%R>2|fz968yD@aUCO`z?dVM^YmB_E6KJjhIez)y3r8Qm0_tbP>aF>`V>~9n`?*K6m6WgjS<-N^_TxF-L_$r`udGdt}U1@ z92KecwQDWs_k!P+J@2IMH~z`8&3_O!Au`svB5b4+DtP*sNmaI|6q1^ezjMcBlT2NP zo_L<(`3THK#L0um`@R2kI$?OVy1LH+AO|-G2b7%lnr+cgYCTuz*Tym-MZabaRHf?k z0E`BxvGLeO+%d%6v~=`)!ZI@p>@#%C{7tHHfcgrj$SvYa0Q4l$N-B1mgp{;i*rD-P z)f_?WCfM-yvmF}DGO>1to`3#Js4=3m4iB3a&?sNWFvv=jj$xFZ zO7N(f;RlSf3&Q_yz^}ok3!g==VU47Lnf0M~CipfX_&Y@d-T>v()+qHy6pe-Ds0tM~ za;C4%p%-AxUR^t3pR40W3#v@zeSp?Ly8j(Z0=D&XyTzI$XUL*UzrG98poELe0y^^c<@scP*fex3gDIsG4z{moPs@2t zUL-KoZD*Upr|-D@;nt0hnJ9KcYT;ZQ_OA$NFj{^!qB4niQ4Dm6es7z!q_}pe+7m1n z`mwdMIY!Q##y z#$BLu@=a`jtIN~X$~7-Vqe(xk1zf&UtGKr1x_8kSUaRYYQ0w$MFg{}?-1kxV@v+4f z-j-QT;LCcPCI~OD4K!Z6Xt|%s>qW1wb$Ax7sSCU^L?>|R_ape290bVPt{z+|Nim%c zcb~R26L~cqw*V7$n=nmfZIw+O6Gfx2|7jz^Swy_MU?ZQeAG9eB?vodzWCbyQ2w!>y z&Rm_R*Bvvg*{6%>4NR86SABIm1luj~SB|$#CATw8As3RvWH-_2adJY9H4@Kh6s~T= zDQUD;Izg9hVzC7hv0*7w3W}OMRUKx~D(Y?Rl6A!ZS6!c%w=FnSZV2bpARAkGzNUza zPfu(7^IDy7mbh59}o7|7wpI2Gv{H9>+gDR6A zLy%Mg;Q1tc(ufA)$VT?Vw12v7Z~kAWZd_=Mhox?iZ?N|?^a(t*aDlB8=s4W``l{s$ zd798!VP3PstQ~djFOv33S-W}dBl1@T_O(_f-_CDQUXZYBhPu;Xz4a>ck@e+F(I1!* z?UJM|?YN?PKb{WX_;~JptGg+m9@ zE}C!W($oI83#YEW!D73FbpI+V<($6vcMti(deWTa#)^@x_ zk2H$m>r!|_0UQ4+JFxR-{`;jd-1Cj;cPI6kxR)ICM~j8T z_8#wA#xUg@!%{s5KllHFJP2p@kcrz3R>|F4x5s zF>OeAAc(#DRsjg_0K#(Qt*{w(G&6@~6;Tle{*neY8eIm>W|z3__*h$%Q~5ZOQtj6e zQx>ujB2rY~&okyZAP0R!=o}$zUXIAS%@+P)DEVg8y3Sx4h9C856@xP0mi=a4s7!tQOyWccH5jU-*}%ldY?N?M$u{8&Ce8 z%TRdQ96jIV2}S4FFD?&wNBs2!P2kBtPvR&c@oM8d-<2lvk(EIIL!e+;2^eUOvat=8o%yM;ByAATE9Ee`T5mf zcr(Fe|4B#LiHGR*PT@mmgKoNLupGwDK4;@%b;0=xka@$bKpl`2u)RU~KRz zvYV!va>nW9xvW|MQl>;CX}UpD`NU2W79B43E}l3p>~TqoG?&ay{cn??JOmANR&!%B6mIa!|OV7 zjuwGK0*m*jF!i^SUlYJS5O@!9cqGqytwT(!P2RoJ-iN)Hcz=t7So-|R$H}qPjke9r zKoGAGTNjB)514^mfHXec`&MvfX6dR|H9<2^OE|^TDEdIcEVx&2Wi?+e|Kr#m&j_Um z5gc?cHvY1<^thM4vq?`sCW^SC(DuA!k|WxVf?#d*Gb@|4@=z9w_9Wi%kSKPWq89S( zxy3EeCD~vkTxQ#RfB#r;AKcPeERqEE-zKduKanXY1j6yL0m+!2FyX6AdI}lP-pQu{ z(DLXgU!4EJZ#su0aUE6Ixnrc!X#)SFlsV7|FI6 z-jJVIvRfBVMZG&9#OlG5RO*fPrSs#FjzS&|Ezp~ELfq|`izsh=m86#iV{5!u&fR+` z>X}&K?_=j3%Xwx({;QPN;;9Wxn6E2NtWTf(cU1r-mycDhi*5@>PU485>L$cw=~bjwQLJ zUc@&EjC-oETG%3G7Vj74$ z{T@eyTP;d9_8nF|!{l%Ka$&wMOz#;p6Vnvb})e=xHv0J9#c&tHih z=0ogZ@=MIikSVTk4|!JtM~*lDs@bL4$T_MPqkMf93@5qE)J70^n11BsUoqb>-=8jg zf8P(+ZCS|Aym0Z;<)u<6$8j;XNYMwC6Gg=TqlCa(t{xW<$yHJwSfB zh&1)^Q6{+YymnlWxm;{p4(J0)2U5slY>I&_9*!QqoLU%Xup^yyy%Ntlu?TK9y`=c3 zsjT?dJbD$T{9;l0-=%}SuYac7LE^h_*T;?sami-Z2%pRPrt3av{)pIjc@g4^xu)wr zVydZx8qV@0{}%(cCQ5J-dUF*OH99bzMNUa5O)8)ElPLzCf$mJDoTETdq8Kebth1+{ zr{qf&)RSCm0#V@&_+Nt?$<0o1miyw*R9%m&lf_GCLFX1VzZrqI3E-Uuv+oeMZQ+pD zI1}?X4(@9(bzJ!uTddO(K0)R{W^BnhHXLeIV*;o2|WBBUN{dxSGM954$ZC!T_0f$=(=F9$0REmfNsSvc^*ufAy(iZYVN!)yr(hayZJ8jYN)jgE(4i+1kvB-O+JY`*gQxew4#^X~a% z@b=OYBB|zy5V{_O#KwdfT|2JaGY-Chj9$+3$v7MG9jCL2yBT`BZu8sULdD;%#Me3+ z%uAQ;DFB0!HaukI1s@&h>RoSv{;MvX*jDCVX|4tsZN(7xMcDUFN7|~#>&#y3SJJbW z>-iKbmmCYE#2Z^NK(hGZzG(NC_JOa5ga-+FVHa)nga5HZw|)O#y7zGX>Ep-KXpO1o zYS;yX^%(5WtT0?F95!z!ww4_Rw_y)ugRx`venDY{`wsh>sTYerA+c)Gv4>;FK@Zrm zoJfm$EF^fn)-}pSbq2scM(gN`-TCf_X|Hg(s-G+3(WzYRsq*&rUim#vIBFV400eWm z`97Wb@Jt@N9pIf5Sr~~2++)n_qD^S4tuG9GVuvtodSNIq8v?x_x0j$@vp9RcAQJQu z=iHXEz4kCm%e4ojg-Gt>Oasexp&}l?d^rsMc2^2L!HpSkaeaM1ynmclnSobNm&VG} z0+k~9R?j*3l+9XhW9_J^-dp;AF^k5A(gM&eWQxEA=IKHRVv$s$$njWcsm7bYX7nFj zGS~tZ{J#)L-8aHxKZHR-_=D;lQ>VrTFDa89xoyP$Vkgr3(yC^rQjj(%3f=|*`5jZm zaL>1EKw1=Ert@ym<7C46>#{~9%KOa^wme4!y;lPmEg)50+1u>Nu%S)$W;*jWggL6f zaA>-)&lDI6y^75mjJLm4vQjHY(A<%c8*8br0qG6ZA=EeoUx2#&(C%OFY#kwuhq^X1 zxYa!>aSZgVSlxa*keqpj=vgply{ykZ6m3Mp?bG)aB2+wBt%Do-lFf*R9*C4bp%DAM zux{%TMzbdAM$X3H8H^epcIs7VcHr&M*)7K~wSD3Ewk_|@7chwoZakScX+-aEz{=~l zNPaLZ>R$Wk|KK2w&_FKVx3`%ZME^ThfcJ%1idU2Kv3Jzb&Jd|{O@_R2<|mJO3#~Uk z3V$auR$Io_E0ml{Q-nWF$&u<>{f_8K2|_2#XwpRJ=`iif@wq)zHj{D1Bmm_Pp&t@I zj+NN6XEiT|plBeHT^B;NwJp<#P3W@$(I#Gg}J0L4fe1DLuICnBjl{kCjCnLTuIfcivzcS}zs z<;_`s;S2&a%zMb>fT}I!Ds<-e{r7_FiKEE$ZL4jkGY}Fq(BY5XXfNSz?EgSLD14wE z;D7C~bdV1HpEKFj^Y8FzS=3}6jCW{b-=u)!tOp#%dY>QJn-}Vqkkrcgzo+vRy|;d- z%(yY1J#I2FZ@w{~{k}u9L0e=lLi{iwCpO=4`OhUH!DNMfH_qQF$%eeCV<8~c?j4=x zQBuQU$mKw0gl}{7_$K$EQR(FQ1~vP1R3kXg?fZYo02>#xhQ94?j0G8)xzTS`n{LfJ zip6#E+wfEiXzcy%J-^slkpNCyF#Dgi>9yCS`kshMk_Tw+O7LsDR8R_{b?gvzz~=6d zy8lK*T8FFA5H^51P&BWYw^DV*eCK*B zHT$!;wa~>IK6Lh!t3mmY^e#>j_*$~m5cvTQ_*HReS@&ns;88ox9Y-Sj7uk!7o04Mr zY@UxW78MW$3~pYFlv=C=$@eAsd`L&PCic;C&`2#sctLF9O)?}3&WS|)q*;Te%cvJH z&4v_K)sEe}4$g?CHmKA0qf`?;`8so{r?Xa$!~3D)X8t)iZZ4WDZ?0)9dkBE9)c)Xi za}~Rp{K^^RW&rAA925b_Dt_=M`o37ddA4l*rT1|A{o^^C`qu)BYS}xz z5*)uXy~5KW#!D*;hXlGd|tawv0lCOq~0)Z;e!sLh5nl z6+j|uLJeq*asYyGqD&t@WSU+MpE>tWt{oq*5~<@Cm>Zo8p0Dq>!jdzYe2VsWc=q)p zviSj{k1Ak68ZIMTZfF@?_pB~+3iFWud0-gTC-6x{==A~$BV6Dk8kjlI&1qr*NsoLr zvr__iUb%|=%H~N)DO#FJ^iv03caYw?{0(Z2LgYR#j-DL2#)wj5{y;4=4Y|47SpCjN z4pd4sz*IPyE_U#ji0M2kp$xuKG1-b1WK24j4CHD*>7NJquSf904m((Dqh(r)n&8`O9NT z+8(jYK^Mg`gWFF;YrW2E#{fMqHn$^1^npulh-felz{r@%vHYQw#1it*s#HC_;N;2z zaEZWN|1WP%M)jB2pmcNF6@2vIh;8Ezo^vW|e2{4j<_KW%_Yy_x(ecqrpr4t>8Rvmz`Ta3012`ih09qf}ybDnL$?P8BzeK zB?F9w$w&n)duVRz&o6c@CU>^b+iz%XTX6jJP5=sq+SmZ3YRBt5*B`TGQp(EG4E^`91QO<53y05J*W`?&&=2fJFaVIk$C6>s&0}TWQ3>2Q zuAAxvCt;!(D&~o|?is4Grb`-`IU8TO8Yof8q{+4vDe42biXEIR{n=c#mX*C`ZNPR2 zNVa?*{=-zHSQUVzMM{i2?pEAdLI#azh9NIy3@FOim%p&Ncqg$Lfxe52ionsZ-TqZG2np}# z2U2hfjuwqYzl>nHux>Y%8?w9jI83B2eH}1+6@ScD1OtV?CyG62v6I+g$R8MjkobZ7 zA!3u^qgzobHaMr^ScSvI-cB%ZoX{(Bsa5L3ND||xTOJAb0JxQn?p~G{{rwgVMnT}~ zwj}I=KDNcuQihd{LzmQYI&plLTiO5x7}nKlGJjn{tjiqfi!P&v+<#ZO(*ZEc@JC+;#y#$w8`d}d#E)~a#S z4c}e7c8uy|MyY|Yl}r-Is3=F_^JT01U#NgS`U5Y&9S#deFmNog4JCi*dF~~8{M&rT zW&-rWKN^M}7AD2Tviy!YtcMEi&EQ@g;Es?>}~ z=6)!nNPI1T`}#r*RVG!WLC(ekpj^04Y#brLkz|;mALUG;9Ok%zEYet5<}lwZkm}50 z8v*Q=#WCs5tTzjVhS!KP?_+6cC@ow@2;X-r+#T5=219X&>JM1y(Q;~P6xyIei z27m=-#?~5HDlp*U$Ey?v#QgPU2B{**g%hOc{o8>TqmyuQtwmuHON-WF#SU4v@b9yU zifN<31pqVDm;(=&E7qexRad?Ym1aMTO5U#>LMgavo$0X3$7>W?OImbOP3Vg6jV73= z{{{&ck&uA-0T}jd zZJkkaXuW;~Ae(^743$)Rk{x}xypd@UpAs|vU z<`EH7#RAV#YQ;cGR3kZy!h?gaRfrzm{R}IasUg{iXfu038|Pgeqhn5g-gn|tua;{$1F_yA_Ncd-%JU&2)4*}jY=wf z94puG$>>Bo*S-5EMO_stz;BP68Qd$%X)?HcRdmn3bvCKiqBx0VsX?FNs%;zDG3`bJ z(AMRiGo<&+U?HIyFPFS7oHp)%-V?Yp6qQ_V!aw_JW>caVR*Nsy@*I*WQn^V-(0tSD ztEu&9#UkSi47*7s%0U)I(LfMmi6G;m^&^TWd~8=C=^qm*{6rk(s=s9y6Xpt}_ouUn zEQr?KcagriJZ4fzCx!oqrN>?eU<3o`%}y?2Y47!DfanWzYR@h#Mc&NsMD3&PTPMK% z*+Sg3W?lh0`L4YERZfFFH$9rXLF^D)8NxXb4jLm7>4b}HaGjPya5pf!6rBge&W)tQ z!07lF5jbgoZhC0pPZvIEAsxNyIR?wP1N-<;iU{O8%Z_L4#L1{6->aV3A}#0*gM~3nngN1maZw0BogRe)o-eO+ow6w(0;J zU;~8@#8A_z4H_wfDxFp(t)uq&a`pVGDmmcV1_*_0AFa<7X4TF;$A6nh0nRv(nBq1- zQd0=v0OGw2w?wauR0g$(rm!WhFhwH5~#vlwSAl%9pL1| zg4@sQd<6Q3+^~M>5=b*gM`k09q66w0ehnMGdt*0Axn$+3vr5xHy*hA=N~?Dfn{RiT;0Sk z;2yd?t?c6}pVV`S2JfJoA9(SMg=6nf0#L~n6Y}!=mS|?{WvyR&<&DEV2InXMo>l&I zHay52xOa(p5?uhW&XNQ0*w+QbyV^`HcXngeUKVHNqprPYLhSA-0V^DHMooY&_1{4I z_XY(CjJ`x>{&Ppe{}}=0c)^{p`oo6CJ`DfgvoQ#Xf&B!hVa33*P%8VynH?7CJno~& zkihsi9Iq0Z-~EDhA+=FqC*eDPGs&6Rw-;V>eB(Z`Kl$?|^%^H%v9t1||9Q?-$y2>- zp|Qq&kdkVs>t7fyxjS}v3qiHpfGCs~b$t~Qu-JnsUr4{HWweXR&2D2~ayyCy8i|)b zbb!~sRN{+yF%O0&X^H*#rR!Jhu}-wk6N8acCWHl7B3uY#m^itMAy2cY6dU1-=R`KxPr?LM?%Z!0KAQ8v;^D~n0##SQqBL(($j9NqM9Bf z!=Lu;r{e*|JeSAAwa0Owmus;|P#Zn*4HUnZCB+UZW*8 zVI9;kZ_rnGTI(h<|9pPix|Opbf*0bom-N|O*D_j#MM3L89 zq5<$`xa=nzT)I$r+NM8kJD^z+=2h%)=#sRf8djmo@Sto$!FqD^&ftgi_;|8~ejJet z$b%@R&Tv2wR6S#}zDm!ps@!pR(3eM^dOb-vVlsQfCH|rL06=j78<2aTV6{M7S23uz zwE{}35}O$h+p_XXp|5@0ApRq2>H_6=XF@u-Obex*>tNove8EvT1@@_Q7gTw-c5La)?EPnIF~`xd=aefV?ZAn zR0{|X5#T~(eaH@ZS3O@zTb7=yRck>3&Tap*+wiB?7`^IWw&7i;I1-zMif4N=3f3mv zy)%_9f}J0=2UC6ve&&=<{H2JuhTcU`go+`o72M>Wfld`|qI)pzmFA(Qbrfk-mdy=< z=m~B{XU*A3z0lJi7U4Apq0!jjh>Mg%$fGPLCoyE zz8U6KUqKqYfa56x%Hp%yu05x!0qOLa7JqjmfhbG|MB$*kfgGO|wyyn1EINaFtwMI+ zS-WQA$E!UEe)zeMGL7K>4>?8W@&Dxz3hYhgmW2gM3)c>JrDtE_WsPrySMn464dsKv z=0{vz=Ei`vT)RKHQ!zqps~;gE2Y}gjdeHGZ@jXS26kv=4u=5)7%-;z_30;d7__Ik) zPi-H{889$h_{7(gfo@8Smd}wTN)@gdAUm8_;PDL;cs$UzxKbL;R4Vb@<8}?j&bwEJ zRgcGp+>eDa=z3D&D2iW(3fPLvI`X}cioJ;-Ga&A=etlcxHHoh2HJX*|K=<=lS*szb z>It})R_GieXJz~h8H885AKl;2RT?hK()*d118U0}sB5JH!0q;nEfVNJZ-L6L0P+@;_f+a`hSO5ZN<>VGUCGmCE>y&zWspS z`(=M$s886N#Xb(}FBUEo9!n)ifD^kGC2qX7CeqOH#=KDZ>x|P-OG6$%XgS%8oJP+h z+K(i|6l>`z_O+zqsE@8*BhGIE7L=IapWLHo^BlfyoH{4}O9oum-mwK)H3WSKv*8jlJ@e!GTA59;rxf~@>xs;UFojLa(XR}fSB!CWN6*82;8TS` zCZjX?lN-!D02!BG}yZ-BeY$>SzF(d50UnkmGq`(#&U(dN5)!;l(>50D}i~3?8*+EULLg9&lj^7Ie8!i5$=CqZri02YJ}oSxld0` zsTJ{fXC43Q>iK?nerOP0Pipy{QYuIrh?A;@!O`05KnIu5nI4b+~?F$1xG(asKo z_g8VL_Cd>e`6FGMPj33$Tm;7Q@&UEE*z;H&*}<&1m$m)}U$T5;UN2R~I_XiCAF**= z@f&awb6#?8eq!W_&NN;-Jc*Xpq!uogOn=Wtja?JP`$||L=z4nDL_p3`l^zfxfEyL) z=vXsw7}6xRk0MC-TVG7W2|bRyL%-6SV0r<&bx3_3kh4twu&ITvEOxj(n%|7sC^#<8 z_QMA9&|>9>3y>--P;A+Eg26AE~X26fqvt`cdhlM7u`~ezI{Q5osAD zaJ!o_d}uiSQGQx}CnACf^97oP@UVCx(2pg4S#hJGKT+d9_2{uV*4F=6L^(3gjgP=w z#XClkn3T<(vFDAM3HKq1yMr4of zc`eU%;Qg1i`0N+CQC@#W7(15Wu;CxD0UC??w{xOzO710Br~nb2qHzD`WV8fhZiE72 zo(beZX#+L|`wiOI-Z?KOF)elqNM;Pjh_0FavluG+g9foS9ezZKOG6jm(S0|=EEp9RFHFgfqQCXU?(rj@k~zIA^%0`hKylfoE6fv?~>Dz5EAJ=itIyZr)S9_*AJDbpsRaCKP2B`RIx%l%n$v-_OriV2yt+OcJ zmQZ)_{?!(?3|cEZUAg!gW-|RJdfd5v>?TA5M0Hm`^-+9kIAg{%xY0bF_61PHd=OU^GW(rn7V+&|;L)Gk% z<+%N(26La5i?y~-DJg_fq?ocXy6 zEy`WGk54!13_!J2b2ZsHEQ+e&_QNc(c)-h$U$#bB16h?mhld7Ss-rIQ1o;Y1TR+$h zJ3d7kA&!KKA^dlVzcs{$W+z;F7LDki=e?!ZIZ7Xo(QnkH$4_FoMWF5y;>*CFPeWvmZKU@?3cb{{)JMOVxoW0%G{>`{AyUDPR zq^mdVn}4MHTMLfrc%}dZl960$sHJkDXc1VhJNBEzMx030*PT=k?{GH(U(ui@%%?dy z9UtPNEUVM2Cth*n?I`U9qw(E=C93|cUy1FtcW0BA+tRlOEVsoJP{tEyTriK_Lqq)3 zgwgR~J72QwHBqz4RGYbVqWfHX()%BUumbV0h<3yW!kgQoT74*saNK15o(Rfo_Od1~ z7RHZjLyb}$G@Xa`zx!xMAz5p;`9l9mdE5OBUIp1Bhd5M^!Oph1Zr5bDPP_i8$!3}C ze+Y6sV)ipaI97V{xrWkk3bdmZHMH&AB&*RraZJBX(mA8{gwXVQ$UQI?KsmlCZ|Q6iI@yAY)xthd5gZ(5yu&IIJ6 zt?F^E*iMXj6pSa@xqUUsGf>)>n*vKyw;yOCTBlX^NUPmvdR9D6N{XOBGM*qlh{u1q zm}ASyYminy?zVK2&TN5BQRY66ZU~qB+2)i^WPz}8M7DiYJA5{?e@1tGE+|!&wD4l# zf|w!el;YC9tYdpBT#BkrPOQIAZuo+6DBk&ly_>Pwa?>yrDo_jmM1qHhzk;WQJvi1Y zX}LJ>hYBP>9V-9a;t+*^Yu_NJqDT>QA49W3IqvzlgNKU-QKN@OD=@nl&x z2f&-_5hF7#N1Dnr_SsL`eV^I3vbub;=cxPpqX1mi{xHDJb^yu=I{5zdM@(iy)ZU4B zT^xgaB6gTt2d_5aa{Svs=q6uYx~ZgRlW*pt@H-7TUz86_fdp{8p>Y~r>{&ekTT z&7%dDpZ9_N3)d}YS#i;M{~uv1NVZN2FM&1KT%}gBwnTe(cV~8c5%nfh=g&3@Wcc1X zA;vwOmXgEt_if}FI?M2(I0{2_E*3By>O zs~u2j3x?*5H|&OgTaHpSPByy3u&y;6gfrQD;?vb-x3OHR`zp>QX<_$6Zc;atptA)L z;@q~(#rAk?Xd~M|u9?>lN0Z>1q z-uezPFNja_$i>s9l(R`bQ!ONGcKAGH*%fZI{z-@iD;)S^qiis&VZlyC5#<`V>d@30 zDx6kR4mIF&iglE6CW8kFgX~KT&#ocz2z2zvxFPc7+1o!epi_Yoj|Y4c(s#<^J5Ac> zb2AWUwjMuE^Hn#=D`y70KG(h!CTjT5+V%uE1t#veX#5nPnh4R^vpJ+O4TT-17Hnlo z)jPqvK|m2o+1K2M=X!h=BD|m9(_^Pit4ABf+3!B;;A#9zcGz*tFNX_(v?}fi9a)(w zv0fmTJuzWp@>g5YhnCA==3?pQHsXL~>R`9O>A@27sr6@=Rjl9$Yq5(C#gGL1@Q{4{ z27L6@3Fn$C%VxdxvK2K6-QOj+6Ww3C^*lFL#-rUu>dm_jN$!UK0!>$uUmklR>Ts?h z2R=8Ia#xN>a-&TR@H){=y|xyPu+TuIZ+RyumRZtIP7qp`h=_<3NID(M3G|HrW}~RF zutO!wMxD>w(Mi|2q$Gn6UKj#r$4^8J=)%r1DyXywavL(C99~~Nl56C?{E~!#jK(!{ z6rq{fu=h3yU43f9p%J5{;6ST6YHv7G$&BxvkvcZ;XBO%-FdB<6dj=G~aAZ=sE%LA8 zR^zJ^-@+>ZloEL|;`8%%B69PJ^`)I9r)3n$R4dG;R5&3;IwsMNc`TfXY#kBxa!p;( z9+QBg4J;(m{27~>N^Oa-WNJ`}BjHKub+UNIq`KlHCX{2o+*O4ZjG+G7XzK6S zYZ=zyuDmZ59?8|-J>PT{m~K>i^;5cjcRG@oL}U{6EPnMi8P2xaHgd+0XEA_{@G5cz z%gn3sIUGqG!nLl-`QN{-gTTHerkRl|t+QZqGO^aMGX1fT#TB{;_WI; zd14E+D5tJu-e%Y(bSw%`IOejiYz*AjE(U%mAGW!Bqk5H1#l11czYko|h$|K_ zmVyLF#mNHpG+%r0Y0=QoER`Hu&SxF+pu*WFp*!?qe}=9Qng2;+B8uVm6qFJPC`H1# zh(wUD(?!O7US10I3YBk=Nyzr|H=BXr&X?m)J!z0;#eWsTm)Qxf2;f zO{YWGm*NU05}FRb$a!VlvgZyEolZ?Hwq(`Ta=s5fz`Mms-$u`9iLIK02CAfOa+fDl zZTEti=iLI5%$*Pv7_iM}?$UcfQ&FcC_a~f>$N2Ofuc%Iw1{veUzRphBnkO~!xkt9MR zYo2Ot799;OjuP(`^iD%t>lUSJ2YzIqSudNx%Q!-#wjUn;DgQQ#vfuO5G*nernVT>l zM2^-z=KAUrClUQfWzN@9nZ!Qj(s+@w6$kLZrG8Wa z-Ka>kn~D`iD;mLo1oI}N_69+3{T6k!U+f$-c&D1N#cucMwwkg)P;d;l`eOu^5KcR2xA?}H zlZUWoAV7uq-MS|t_(|?es7D=AyIR|*Fl45$_!FvMa;36vm`5X5H|ArBC{R? zTV{yFn*#!JQTg@T63fLTLA&ExJ!uJwn~D8s@Q~Hx0JREL#9G7ebocv$9OpxWgkJ(` zMA~C>P{6l{E*nXppC+2`xZ{6m2CJkRk_}_6@$cFG#b%77_Pc>Fik~a=MQJnlpfG1Y zGww(SY@)!Yz$^CS5P?yD9HN+socQ*(TTzgZIi1t+;Y5n^2 z;O<{L<`}unAGSOYJcoNSJb|k6)dLHe*qlDR1F4A-1@dZ!ha6Pj=S=Hvd`!yYUDf%o zSmq>~!%>4vX;!@Y{x110@_2NQB25i^E(`lGR1gak~RqV+}{8BTsZ}cpS&?e zOk|w2ZQV#L(#J~;p8e*qGxZ2MWM$4eM_9vdj}1neJ1)vKERy)D3A%rugKJfq(s~n_ zXDa}SWLj$>hadx7S?IY?yU~dZI0o@Mkz}>P_UGo^2NdgCyH?dql%EtR&y>~u8Da0e zy^G(B^A7?qqL4Iry=cs0SAsK-D=enS#&%T!U^1-Uegu= zN4z>Zw64eM$@hWWp0Mx?&YT%n7ITVulQse@oGrGQs1lxP3C8hEN0-h^PHL%Si3nat z;-3HX-`ZUMmd~;%e=%Auo%K^SeAG}Uto48rM1r+fYt!Gl3enx@$)|6BC`}4iBq>k- zIIzGX0|)jWWNNfh$iie|x)PKc=oFn^)#kOzIVs{y>IKRnBK!sIIcBB%pE(cF%oVDD zI!!zWCeG5!+r)RWpuG(o`qY6mK0`u6!wM<}GsJKrKhg>NeNU%v#uHu@kFSVwXDc=} zU(7#?x(Kzf5J2G>LDG=oSGId1=7buTcR-_5=F8cPCO9==Dhsn6=E`Nu6%Sg>m!hR* zNY%p5UVmz-muyIa3m_Ka50o;BP;47_X!E~UNrzI(TJDG9!>^1_?L~C0;f;U0+Zl(I zrk4CSJWGgkM)$*Q{Ixi~ap-oPM#>u#T2Fq#y=Shgq*oPIV767jmiLaq z?=Og6&dWrVO_Hmt^n`;v>C)MS>@w@~1M@Nh)YGgad`bwAjY{ej=-jw=mronKO02lc z^HB3nMG9zOx6Xm~*mkq4p`Cpxb)yRfV4+Si*r#By-=xW)Up$EP78fTQI3y*_ir} zzG?6c|2+lSL#V|8fr<+Z6BfMVHf)>x%HVriqpOA4l(4@a2%VES^+yiz%pFvAA%o0h zSboMXgl_sp*|XJZNYBOSxCJXi_8#8dgqoLp(}L0&S0 zU_?n?L+7T$c~aC%mYEZ2imHrk{Xgy3yPD5~3)q{Eib*V0Y1mO3$$b$&OSZUIk?e-M zuN@x8m0ra%ar~7RblWfQ8!BkeBPW*Vp-;tb2Xfj8`gD#a7m{w6nyRk+X*D;?;M(|$ zKxhlEN3aQJ!8J`%*|$tHywLKjd6x`0xy{*=<~FN@9e|&y7%{UFof0--Y5i`|LTLOz z9^$;@bGSw(xDbDvF^*%+?psw&ffm)zs|wCZ_)F!f9s5O!*Ux=M!h4Q_$G>iL_4ZUv zFm5~=;J*82^s%_v#%?5gHodzLNewYq=ca~~F_FlIcjV@?Yyj&s^`#S;uvTu#KK^ewj3h81k-&Ma zFRGtLt4$v1j;)kLd~nlTVuPl|Lu#mtai5ckg@VlDEY{e?I=$4aD?B*}HQYpqTe8Bb z6}&9p2{Bd9OjpbkXAgtd?S@o~U|Xdr?FVKQk2mkW6S`-uD+Ya{Ifi6NaAzOKwGrtJ zi8h4Cp$g-Rr5ZR1*b`UGuoWL2MgQyCAeMnTBA^pqk)YF>zR@PKSxWS@xd};3{`0TN z)}||Va8vYm7cd&$;lQ={&KSNiiI=X4gCzmt@#jX7eeFrnVmb^|DlbT-MO2+b8jZ^p z@V}2dJ`q-dQTj)q{(pwy;RwP($Z+AV#Dls15CR);Tmop7BKCZCNrZ$Cd=R2XCz^^G zvGI4%7Ry{J{F0QjcxW5BcoRfxh;X`jXq)9K8@kwGu(4SQ35>YvOw`=jLVTag1%1=D7bCf#dl^h+>zP1Wz6dnsK)&msn_ArvTWeR;MweLATuEv z3Fv4!12r9RC&0Xhj89YdzGg~1#|%1h?$-@kB;bBB-u)`#ZW(yj>@Id6fV4dw+M^l% zchc?ie7U0#Py|CdYlBTj2E~omg;P#j_!)kcW8{wbetS6^C9=~P&8t<7eXkHl?&BWA^uHak@WTbzaqpr0@y64sy`lw+Y1)>8H4J*Z2lE-? z0+=kcM&!}@6`HB1Os1Xc+$!SiM@(#D()THOic9$f(ADqZpT8_U3wetB0P_ZD zVEbNKqdro+CTRutOnt*2{5KPzp0j`C>|~IcrubMzNJeJhRfBe;y7XMOWZJ?(Bz&1? z#aN@^iv{LUbVk|i?j zu8L|}$W6z@MBw!<8*VBWHg2w|9-o%62+MbN{I|X?Ej1&$OK5)Qj?GS3PbwTw4R z)njRh28SP?4ToN|gBNtLbmCv<>Tq$LS%s87#G|<68*Tc!JZf?hDmS9RfXBn(kxGvU zYOR(p$QChbnfa*rhJh-Jikw6>*x020`*0_(&!|f7t5&~{zZlCvun{j|M%WVM7*@ay zPJNzk1^?NA(DmC>MYA+A9Ghn!$vP<5jMRykGYbA^rxO#$JGJT!-3#kHd5JLn%3Cp4 zS_Z)xkN&;cXHnXFB@RqA&+@`H8AyR~v&r(BMv;?Qz)G$tlwF8Qco|~s`(d@k_if3F zdT+MEGRJ@f*Ffx%_B1m@j;*U?CNT}2<;_%!=(?M|#+rX~#5=(?LnAsk5anj|*j$Ohx@zvA>Z zvd>NTcb|BS6D3_kdl?$)JYH$qIKN)(nX~ z5nsE|npM%_F&ZIZ#bK1oi5tv!dQn{C7*VEt^(aajpd#^5L5&b)b6XU&&&@D(RdHU= zhnh;AXpYZo>+K^=+4Nci<7ug9{B6Ol7Vdzr3Sx(jts$9c$h@kzY;%;OrR3>~nNXKf z57bn9R52F#_nW$rcK5D6Rn8<1(X>V;M$DuRnQa%hGe>Ivw5yGK!{y21-OUNq(({>? z&8FsT<4)SZRfQXTgWtY1)H`~3$@jHgrAS7*^NK@9njiy0d~Lsr*~7r&V5k^byc!0{ zFk4S#LUCKcRvhKyoa1TSK}gpoEy?peVggqa*XU@i5cunYmur97h_j3t<6{-2bcKW0 zvvXYs8&lJmBj_%MU8u&pvUp^j#*uYdrbMO!b)FmlE&*u%HEf1evCj=E7s^v%DX3{v zs0=VJ!tXTiLhs%Lk0<cophSXmr(_K8}%k7?_-uZL9^ℜIAtwa_4)(#VO<$X9TdhO!E>5nU@ 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%0AP-UJ434$PRk{f!S z4`$NEpl)l_34!4XbM!nHRzRQGlc`U#6hCG+K9@gd8slR`Dha_y*Ko$(92nigA*^Sr zqms`T*3dE=Z&jmDgTqRr7%w7NxrdTLSH?CWy$nXuRaz z9wn=7nB>!u8Yb-qEn@lr&Z%<^M*=);Gtg?;)TBU3!PS@`RH{|5;3BW{9=_Q&V{pUJ z03T4QF7AQ~F<)dK7%8chmT@t^%v`H02#Qun|1>?Y9Co})e5e(?dw)(X@D6H&Y2Oj3 zJp{B~s3mqz4<6#OGYJ}$9e%w}%ckMEo&Z8K4|r5sU|1ze253fCrNN0d0;2}-t_k3s ze`hhiIp}7>$w%UHxtj9NR9YN?I0uut`d)2gvaSub=08)SFf-lAg(1r7-x4YYh z2cif!3P2N>?Z_~{`* z0>c9YzsLHse`Ep-VC4CXnl%I_ykY+3(jn5anIsYbIv?}>el>aCth6(|x8b{l=SJb; znPeJZuG%sM|9nGnN_odR0k_*{u=4k|jcAG#pki7hUtfR#4N{G~g8~Sy1O`XWhJ?4M zWlJE`Ky<)LG3pXAs}1x(4fH_YuNK!g6#ifsz?T z*6$4Rr9J>6BeKmefq{t-)u)9xF>@SUX79Nf0C30Q-%5908`;}1g(@YyOZp_!R8*h@ zOeTroz(uzMU`Dh8^q4an=Mys~2N~84otyn9QBBo7^YAA)k+Z>fhzubfVd#b1rwVKe zF-9aBGmidouNN9S%HcVJt2zfBQM&I(m*ywtGeAVm)o@&Q3nTkACgOkLedwcMTq@cz zjTL=>$)URxQ%*sPZuieAJMV@-V2lD4r3V-V2{M!@LdXy@TLcWhTaTN$?WrbZ=(a>8 zd+q(Ce39hVELtuKieDG~*wxOgyzFA(!v+ZWPS1f{V?$nWMlW9qFd4xQ=L`>Y!0=19 zDCD!&{Al@U2e|_%b7-ppB)q6wP2S}=^z{T~r!+gu>Mdoe+JaWjCyBC+92t+=rJiTt z0iXrqSf(xp2}l4ANSjnWe+Mw`Ku`Uc>c4H{A>528P{HyA?QVhI z+>h1RmfIuZ$!gogMtO%E1$96ic@|@J80D&+!`c_}J+G1CInbx`pR}zdrxInovBAFE zTi>hzceiequwLG`h=-VQDJE_2o8$|zUjJl{v%Ro^humk1q~Ap=Zjg4Ad>o$eogz#< zD6ucp%b^bBYkj2sz}WLTnO5S>r7ST1$fEmvhb5ns!&76*f(^UOb*1zSI)Ey>_kE}9 zMorascw1EUewt?Mjkz|*+dU)eZBkoXz2q_&2f7uQ^$OhQ z#7Bx{4@5i?Kk)XQ6~G1rWv1c;FS1|1TNUtnBr8tubm`&iH|7D1kcC&$c(2{9AJ9NI znla<3zTT*a_Rw4Uec(MA@!>^91>UakU-ggEe<+S8>he>VAL(q0wsrPcQP6JlECF4fDTN}KqA9(U8Yr+$ojqmdf@jfo0#0T7+jM&(pV_|yVvLlWM2KtVUy;e{3T#9?( ztHKtqU1d44bn=xtbzX`OB`GQhv62sPu!=7(3v!k1rE9uQ=kWJPpbc2FwBGpSn3CRQ zk~v(L$>o|)H&9~ZOI@nNlHiefone~nQU^|UeO7(jJm1-~7vvt9h(#9AX8_R-#?llU zn<|Ab?lr0=MfMwzk4;g%2Mja`X%wP5jKsEB3ptDcm{bQCJ|s(#XoDK)oJaJ)1bEfX z?ZF>83qNOF5c6NV)dS91U&E=v#-}tN(B8CTBdo@yKvKva9U|BbE82G^9yT$W(Va>v= zZpestZ&QRD6aa2$suf82og258`R4J4#}*vkza2Z( z3Usd5jl^O95)b2{^Mxjw2BaYg<`WH+Wc$j)Q{O34yAir9_))~x**;-;F=6IeL%t5U zHH!xoH5yhn53k80y#$GegHMGxYrCu&`?6W;qt68U=TgU}H{5n>+R^V&4 zUar^vn6Y(`59QM*;Cc?I3!9o4uY|*lXa!X>W8JVEUsY7SAnJ z46qDb%=bBNkBgV|A&!gYS!|zy#UZE&ObP5W6!(SGUF^_qF(Gd%Npl~?7l%t@6K))S zYwv35q<+hd!YA(M>15W_^M`f?h_2}~`}^P#(j2QY(YRiVw>7WcYv?mp(ujT5D{II8X8WPWS_XHoR^a_E z?_1l69|H=p{pw? zn@>Ut=^>AX2V`CmN1~S*<82eKnJ=rypN0zxoXS-V8LT+0ZCyDRs(uw1Sgsg(5SOc{ z3qIZX%ihfh9qtbBEXdMU5h zg8A+2wujKKS1fufTTS`*tKS;+boZ9iBq0~!zv$Kj2Po|bK2~-Bwx+{pX{FFUyqx7$ z{{VYCdu+{G%AP=_a*HuVhZmnYGA^$q=Fy zhHgWSk6-h(Jx0c-=n&x;Yj&0PU}`gl72v` zny<<;3Z*xvoqv)Xr6F9-|;=ItHZd|=NoYmkqMJ|^ARew3VrTDDzjI%`y6=xuw=Pvc_v*RU>N)3_V|?Qq zW6Xty1n9k>Z8sM{umPmM{%FWHnLPe}`zY8{08j&-vr(_JBEZbn+j*Emlt{3ob0srq&72!g3A2D{71{&b6V-V`| z@d85W0Cf8Aw}4OrHWF|EfV)Ve5*BnqjS9F} z$e-2@B+R~5tjT`DrkwQicj?DP$z_w(>2O~`r$gCS%I{x};8Hz2crGZBJm{23KRN}3 z`kr=xt~`DRiSq{}Xh0?F(F@_}zuf{*BH#&AAnEhn&OgQb;N$~NtEVMw=s~rN4EYXt zV3dGw5-NxAzr3JAuR>t`0uVI+ne#na8S3Oi)G8B}=Y+R$E(JrI4KIx%Y%>QE6~D zq;c9wCDA%Uv@Ez|+2m~Quv!=#oLgV6wVWY=* zRH%98hlNeg>_k90Xf>Rezvd-7yf(yS$$?gAy}A(%Ixs53luRCvT1QY?3JJCn zK*|qtYID1*Z!#}$$O!5G#!%gX;oNCMw_|SJW9h#4#e=V4D2Vd+UYQ0+J*c$vgvn#? z+LUsjH8>V|y1)un*A*=-&s1ewuCX*=v1prR`h_IQ3*X)zRxbHQ*CNE5 zeBb*po3t5()Zu?l^V+82sHb3zXCjRUKRmivICdyJQQ0d5-VUL2ig+U#!msz>4R=AN zFP9R9=V;DfcR6v2W9zSP;Ki#D%wPVRJAo=9)$L+TTm#n(R*$L_@W3CZO86EJ;0IPN z2Mow|R#!WkR%mL)!~DXpJj>S$cT05Fng`!eWHBbCo2~fvMeZ-vce9tCH(8ExR<*u; zaL*bT>-3a#M?{a*ZqxUCI)2wH7jJGZTEzWQIg=aZ5VRU04Yvz#h`op+%tqHkGAVia zafLJe13#tBWhg!$3jXPE2ZjduP$FTrP#h(!S_@XJz1~r3)LnfleLW3#f402fq~MKs z1%ruA535=!Qw!j`e+ngk|5UHt8pZ2uf~SidD>w944?q>sbim$Q@o*raroC07;Q<;2 zOX+#`NnVdQgPyC1QiNe-^twUCmL5jTnFQLA@rjyH1gQbP1Ru6MFFeJL{g&lz}wceC6vqWP}%JvN$n4_~Gx zIG0Alw|C;Iwibwyvf!hgCqJ(QB2ttNT}#N@uC^F#MjVybOF+v(0@G+Fi=mWOxo;rG z^r^*IC5JA%p)siFwrkcd#z}V8lzr2EFi9aSQrQsbc5O+5%5hIW95os`HoscDw2PhF z-5D67M@Btx@_9DSsv8GHAE>{m?_yio5F4V$pjORa{`|$TrZbYU&HKqf%D!9NInA&e zB?_?8gMdd`MwZYi&bI#b2PKX0T4TIl=d+s!_YzFNdVf`w8IT4)5%kz8OJU?F??WzC zS`TbQ>(**}r|f;4bbb5k(Dj3z)IGPCiz14~U8DZ_4mUwfVcz|<^yYYFRt}$FTaaQW z9F4vHKCO)YJsE_10QpfL-fkjr^d`SliRcCa)oSh z>Qy?Q@6v-_xUKZXMV}ZTRH(9iSwPFWxj@}Z=%>t*eeaUYV9Z4bAez zqp4ZuJh`XlEw`k|eHUU@rfxf#BoI9%PB>o!-o2(6vCX{>)hlDDpj7I({BYbWpffWC zdM=u<1bz9MIN*zrEOxnyHWShmt=Ny_`N*;~ZDXbk$qR;aEgA+kVZ zIJWxQ()DZDptyGdfs>D1SaLAr2Znv`p;g&*rf=cV&l%$8S6R0cBZ388Reah=TpXj{ zW4Bk|PL8sydzHNh@ZJL7!MaRcx`jxaGY=~Y1#P{-y9$dUEc3eGP1P&vj151b zzORaSDQt`f@7K1Z=*>py$+GrpK-@gj7uIhZ?;!QtlyXPR(XH5XSxONrZe+6@Kp=9( zLW1vRstGclP;@B}7eX!}ZE3HRZogez#CoB#j4b`yl|c*z0KQlg{)pQ@MNqARR-Did zV+H|rYqT*=3qJ_ngi4EaiYfd!dSaowG>H7dqwg}dS(5jmP^kc6cZ z={-DIarsiv;q}y9OEFSsdt;u~Q_ zj}hpMcQXze@97(_`)ZogVulsJw9eZXWo=+}mztHAg8M1g7sfj#ppUtsp>U?QF4^GV zPM3OizXNQK{o2OOKoN$r^U7`<`k722A#LHT44q4TG6$1R%&v{YIz=@N@%lBd1bjcvU1 z!TtLB-l4ATOn>R#C%scdC{7funke}e5cw|2xy?;&kLQa7H!8P7@Sbe~s>dmK3sFjU z=z*_aEPt8EZ6d z%pb@i?t44X83kIprQyBb^RDs|B?LQNbms$03q$)te>p793P#l7p~tka0z{t}u zhcN%-BnXny`c0&#k0Byl*Mrnms`{o+WLnQtkPk1R)en3_d1Z}jP);Z6 zYqz@6HUMbGT>2JEdoN@GZ>B_*w)uy9&$WZb;&8xRrXtYUbtt3nWZKap8dubg_ttZ0 zhp1U50OQK4-|n`Jb`lw0>TBuU7rCm^H!hva8KzWby~5B=oWQw$7Ux$Zz9R}SL zZq^FYZ(8rrnj{|jgeqWF7yDo?Xo-NE}a3djJ=-jn9 zE{FirW705IT(-Lw7Dw}B*Qo8xnW(Ce`EmGX`L9s%+CTL*ulD(S-@Z7y-M2nD$-7!h z{cTi~q_R`TA@uEo8UPO_T5UiSJ6#L)gr$wiHvJS8eU3fW#QdirwUVKf+_`Td>M$2# zEz8r~y$I{|*gJ3E<0Tt9t0pK;({Tq#Cv+x=FPhIsF}s)c3~a+n}BsV$IM5 z8qp?AuU9UL=(+Dgm71;Gk)1tnobDf%ML1s>t!*JIZQNrPl2%$%XkCxdHSNRb7BE98 z$^Ufl9i*YrE39(ql5)kIIoE7IrRm^|rMhZ9u-_RTWbL_L=n{@nC{&F(X7})u+GDrC z{S>T)6K2fNohuwJlkq!<5Cngv-5$%riQcEcs=w@p%J1DJ@vg1)v_G#btFVQ2d*_^? zAgJts;75M`3+prKX624SZ%4kWvI^5Hu=4ge#FmtTLR%9pzvEBktA`bZ`L667odsQ5ge|6B0`dF(~! zH-Yqv0ZE}$JMrSow*RlGvizOB)VfS>nFeS2Z(d>QyZ!qMsj4eEx8wPz)EUX(7LWH` zhK`c0%AG;9NI>}IKT9pX3UI#oZ`By+WGKM;{&&(J|I1DSp|k%y@ITcg@_!?X|E~^) z3B(P(woa~J`qe`C=L_wNespY&{d!Eu^C=%wUNZ^pW7EHKob5qHla^b4*NF65JL|Pm zD6`<$p#7Hyv zr|@MxE>3Q0s$6$wQKj+ERVE9+f}Qeok&2|M{r)^29;?}8bd&}C-wO#_IqU)dN&MlmGo`SZz8k=l%i9zc&(-Ie3yG zu^(7el4-X(1tUDpgj>T;)Ok)x}=aU*Bqx83a0!9~RU&f7p$_Vn)x;O%U)# z1$Dl0b4QeZctE=z7d7fG;S*IplNx}p*b5MO_ruR&ccFKuankgHnU^+lxGVd~%272N zUlb&$E-N81jyu9lA5N}rZp180wO6JMIgd*!*LXVHiKF=*-dkzq@MWvoo|E=m3U6P| zrDgM5Mxf4v6P!0~U13#MA4zhB8j<0;z~E5osv3K}TfLcDJ(;$LZQhZBtru)zG2A~{ z;N1vU9#0FAGJg<2MlM@}3Bh-enrH&q%D;HM>(slmribF>LqjN^0?dQd4?9}pzcA7B zE6B?<>tB^_UG|zCh>}UcMx{^MqZ7@eAprpTy@#aP>>m&ic#45QN@v-N)4piK zLpjij76FlBqlzFBe%6~NZ>QjpEWH7%ca^0Je32H!^5TvE#9r# zOxWr67>N=?K`*T?h?YW>wU+~}4ku*F-eby^#MK&Argi?qJ~iarB40lcGxXKndauiC zx1o&{_1|y+)JD3TzX$T#!9p+_+HzoProa=(aO>$j#g5M61I}iFH|47Pk>&O7T$0}I zF?~;C)~m8CpZ-p*&`SPiw9S`J9?-BG%0_D3mO>(H-ZgJRDDCWV=1allyS)kxztsND z%`kk}voxTVajY38-L$*$YFgk@*kd2$D+a;6z7(+Pr@}qnbWZZXm+s-d;IkN;zr5ya z+KiP1n-_N;FL9T7O+@H}%7rVsLT909>pYG8PoZy1K?7rr9vFq=gMmX3p}7?{mpuxB zKICD4Q4ggBP=xZ)&w=A-Rxk)5C#G1+luBqEPU6pv!_N=MojnN4IBPV-sv#KRIDGC} zy$qeU3@dV8@1Rhl+4T&xSJe(Fm-lnTz0yZ+Pv3F~`0!$bRA6PX17pUlkyK9ubR{;$;6W_c_be~(JAa2L3L@AapKNk=!p2~o?2ix@6tsS-sgdM*X zZ#N=p;B)xUL1b5ST$xpmR;v6uZ#Hx%$8!)8uIsooOXqT6yxK=97dr`-g<4lCl`s_| zLS#EVkZbw3D{1i3%jZwl%A264I-0Z1wkQ_$GUup}5*za}`|3wFz!XpTVxjmE9Qv9bU%HoOsXh!k zT1MQm09GrKHvQ3LJ#(1c%E|pgJ=h(Pe)bBhXhiVacJf;Tl3a9xy;Etnq>Nyy;pJ|K zbzc&w@C+!jyO#=Poa(2Lq=E>X=a7UPnd zm5^nKMU~bq;S#JmaB%*-=8RifW2P(qVg30rV_PnF}2F*3YDYp64&a1BV8#j59f+EmZN4w5mNV;riNpFn# z6U7t2UwW*|xn>h&wcNO+bJgRRdwJ7%U7r|n7G{Mqtlodyj%9p1))kS-c0HF@snbY< zQ;)L}u*kry^Uz7uhpc`Z!?#J|am!*~M?phdTUBI0k?F2*ql%g$>plzL2uj$VzgQ!@ z23M|rET-_x`?HIx`K~F%C2&!m?u-vG^`q>KD{5A)xU{$+X*+x5{4RE_s`U} zoPgUIHmU#@E#&)9Rg2~eh?9^|s4i9F*!YWd^;4znbNP9#pP zMHDEXfGB3yvJ0ONc%C8uRj#T?n;zc52JbD|ZPd*+VXBY?CxZV{Dqm?})JN0OB7-*2 zE2KN}S>dap_iv>4%(u8wpze5LaCqK$j9yyylRB@23AFw8?cNj!g=Kn7CBw z@{tr^t6iR#QI3lC+*47xn_cIJI>JJDj@^+Cham*;oP01(c!y(W-)@HsvK8#md?C?C zxJZV+McuZk;81x74EIa)WWJ4D{(ziN;iE!npl6}|M; z@xhmMuOV*`hXtGfel+8HEw*xfT!7b4;C{{A#UKxJHh*_r{{vrxV>A+x_iOySC*m^_ z0kG$>dmiV`P1{MsyALA*8z|eyRz;aF9M9JC>tl}g&v5(ZuMYB5psUL^ZwZ4zD=@ME zHKG~oe$f6_p1W>b)ei^mZt46yt?*F(feDvXp0Xdxj$-=7zEBZ zc<-y6?(qK>&zv`^DZ`r9bLbS*P8`!YRs(w!qH4xk0mw;MR7h~>{AEjnt(>Xj((SHI ztD5uOTPybxR4oWb`mMl%JXUKabZ!%Na)?tcsLDa$h0vL}3tyMwt!t1kR#DWq8YF1% zYMC5svM!f9rB;iWN*H*6Ht?6V9~;3T4{Kg+Q&yk0?F?Hl+r@<6U3p!)0mSg}3H3^E zmeoC8$5|xt#<6wTK%9Wri`JRAD4Z^A5k6bi9LK{dF92`negmN7J6!;-nl!mK9lgMH zq-a#UhQX)1f7KzP@!qGtUKes~kW*b~L{YCZ)*k_MB-sA9;gn1i_W@^i+4N{v@phq( zmLc(q=NU>J&RGAcy;OIE7(%*xBk+`gfeY$w_gd+na|p-KWtItTzu`^cXK^7g|@yztP!mr ze+=K%hL<{N1oc7sepNJSIk1{p8=b#)mk7A09ZRd$zLgj$sZv>VU>z}^(Z+5?+D)rp zw}dl-6C^P8PF7>PI+`n#Ln{i|v96cXg+QQ-?Tr=QmN z1enkeZ;USlgr7rXQ^#k!xT{5ruTXHxXr3}0TgY@^=ajL_Sda9FYNOpBIj>203v;S4 z*k9z?S82_M_zDyE({-u^8qe%%hue2 za!_B@9h7vEatwRQ(7qTx`U0reO*`%)T}8`~V@FqsAsT1E*Mp}?n|XUTx4*k&73+C{ z|I&hUdZKj6_&v*NCmFN82VAtW=S2eIJ26lfVNT?;^Gd};(c_H6@y6_*+b*EnUGQ8bk^MP z;Q6&(!Rm^4*L&DN>`FP{bU{;a)qHy2Tv;QUhu@w#42{p%TFaS?o)eC4F-4S0iw=Ku zY%zfqLK!#A^ysIN?tfVpWR5Ibg83%R21|%4C?nynrD(DUaQfM;drS`&{X%doii6fe zIYXY&3Ya2Rxg*2;ld5eCG1&?;!d@NTX33Pu-sR`2YXqj!r<@IX*EaKUPGhK*6Goyy zoY<(Zrm7Em{BaT$Xa|Jn%6o@tlJasr2``7A43?yDGRbf>WQL@GKMlE+om=BBr$=ur z3bZ3+m9F?|d%@j2z-N%tEiZ(c#0Q=W=iHrqtEjq)T8uh|iZ;qN#hbEF`p+;2K}gC1mBl=h19#)XyI2 z+%BST$CPeAAvk)l&^gkgDZm=;?aA|i&nBJj=>(TA&3?8NHB~F5jqXH93JJkLc+`q+ zjZY!YmroL3a6;6IJJ~i52kxPf+|54Qj8THtNDxx#c3-|6$KD1jN<}$^ac;h?-f6R~ zVFlI|Y*rz+lTI%VRPLwtGYSeO(8(4;r0F;=e37&yj@O8SHb!~&MnF|}!=_EU9Og=) zQh+R5xqB6n2FIH3?k~!zx!J^07P3Rns}C06L0x7-gFmMya9{g_YEz@MDULxH)Zi$wgX1utz(aTdVZuN2lV|?gya4m4;Fk~4jdcUFExPBWW9!ikYv{5uS zK&xV#p_J5&oTVCzV!g@ZVpT3T=5au_ZO^E)lOWJ1{iEU{(0bEZ0NC}Z<4~?X@BFXj z2QyEb+Z12!!|iu=iZP_%P)L=2r~J*+MEz|^*j(psSe|z9$Bit2sx|H{xQrfc z=Kbu7C%)IiFu%^Ft4i}3?`S`N+bv|#=4y?yhudPFY*{*T9v0NOJ9Y^+ns(38gilr8 z5I1hNdM^hwjNWj1Z;NTv@FJrytOTzLkm)1!=(yuLubknxRZRt&8fz5X)9!92`)OI+ z+#OyIFT+kVe6RNCReeX4w1P0jTB`ReSNkmCe-(<_5PEsuwYxxNsK%R5@214rs1IKP>>K zS%StZ`D?@9Y0Xa~2p-}#fpfQ$H&*ec@1>WV23D(zTc1;CbYLW9$oL&ediOY6KkUwD zw8tF*VTQ4+jllL{tFxR0m7AR3HisV11a2-%PQ0+Ut?#C+m!sJ%Z@|YStI_QYYZcZj zg>5x@WgtI**?RV$NNJ0-)jx5pj;y#lwRgAs8U6b)$^sE7`BM(kV ziCJBJY_%1z$7oC42KoJVtMRkPT$@$4oj_%PL&8wvbZnildA|4Y9~1S+*M>&^%M|wZ z0Zd`<o#ekXeENN=x z4;NMNahCxl3aQ#o{hHv=%1-oIzq0nyt( z2mkr|e~!ZcpNSRx?*ak;Jt!qiOS9|)C=Idm(cv0&5d7ICUmxqrSAh#Co!0QKS=m^d|==G`&jNML4B|tlqNUED8%|LIXL7iT5>q$>?8Lr z@*82MAt@dRIpxk*|G<}xG5q2h^-})T=rA3jeE1|&d9Pndw?q6+YOIx%{~|(DyOv9v z*zcl%$rzWjo9T~ak^Lfu?(cP*6DVlVx-6J~>WTReYzprBAeArEvpR9x6ipSglXK8q zwW9G~_N}vBg_A7fY|}bwS?^Wxuze z5w(8bOPH?MvB~-lN@zROPGsmt^8XG(@DP)7Zf!GD_hWq`hLF=`;WM}IJ8~4%J`y^9 zYjwd6%_%hf)O;LV-c#Ypfu4`I^MPa%VTWWAA3zH}Kp1=C1CtKj@Tbp`^kGI@x;teW z9(D5}eMC6vR;EkPt{+%7xY!60!=AKF@!g7eq1%UB4_A#`r?3t$i}}UiF(kxazm84w^a?Tjek$fdKP>2#7=afs#7#qsE9eAmk zF$^2Q)DFRTdHx1{|EWDX8OcAxwV9-v?2C~fQ^r~FPM8H*XPB{M>Jm5M3-g$Z!Rz$R zx^>zlLTuMbMxshIsYdB`4ysiec-!##Rx$IpY-K9%?bc@_THCH?$yg&8Rw>wd3zT%L z$4albU9DQ=WYR>hx%x@+jDDc2YQaCXA~0ATbc?68R@Dv_@BzEHeSbN^lDjp4`fJ)~ zh&jjMGt)2*PM(D>dIUB?n^;96)iTKk(l^s0Y&Vr3PgzqcB!^#-3A-B%v!@~LNMKqJ zq8hrVx`~U+XX-21wZ*?&sIQzhgu2HQl($7m+!;wIXR@M>dvS~^k+z^+=9uc!pjulA z4rE##%92bX|06VFh=3RN1jy|piBnIA95ys8;w*Ts+Nb3G!RQi4O_bEWmBE?ICUG(9 zOO|p5dsVq|h3?K5!88PDIjZAu2RZcCh#tyh`YB2%=*%9=C{5|g2WTuBnNbodcY>S5_Y+E!DS{V|5l^4B@7RG}I ztvK&8Y$!*p($w$9Pri}r8p$G-1u8++)N0aM`n)a6FP0pB7^gi@3{eV%51CDNm|HL_ zrr%c}&9dg$KIl4zagv0g?R)@+ginWFk6w)ZpE2oAj7_S*{ysyY{JxS}l+5URjx8sz!%)DQDU~)FV<&+zbwC0IPY{Sca}gF z$Ro>WUepbgV#P2QkPqsK2`0!T)2F6}8cx+#m9eX9CS6+jpY?Hzkk<5U6VFT)V}Tj0 z5BtyYd1fHxL-q534PI5rd{NDtr_ck)%KMwP+um2e(H)eZ%SQFCQ{u|8d}z|7%^D;|Gdg$;_jS#_wiik&Q~f(dqMw zRX{li+@>*23>^GvN7x&e%Xd77j$w;2&psu{##Cr|mu9o0y%i6O(abFOs#NoeJavEB z*n@E8gM2p=)QRnIXxu|ATgQZk(#I==MLa4j$b|D~IsaBfq;b!F*ckDfNtFr>wLMd* z869TtDI(QxqtEyG-YwRg^rgm8lwu)XeYb;%^UJHRrtjGCBEjugF|h5ue(|a&(A8&= zLv{=(V@lyq*~s=)IN6YCjEqVn2Ln~f>uqmL^2`j>KI5`Y@vU{S96PU7*B{O=Tg(vw zdD?tBuKj>L0rIw+--5;m>f}opp#jW;d(TZR@FP=q6VfTR1s5ymS*^_!EAeMm@zRMj zz~^S9ncr7g!pjEf#}q_K2kA;Jl$*~!(V z%|4hR4LqZ^-jZ1{jg@?XC;gpCZO?2mt@H0`L{U?di(O|j(N=$o#VzTP&$^aGVL-yE zjYy`OU35gqJM$J!+}L$FD|ao^pB;1fGwAq2tggwyfbDwJl+BcHfiM3I$R)+2ZskQz z7)U5FeyN(!EkU;>!WAd-N{*`6E$w!u__R6UhpJzyDew(^VZ!m&K@7m5dqYY z%irThiN*6NF1r3bp}cg_r?GuSFk6AdKH|GEQVy4Iq)9`1Le}R`QaKuPZ~WQoW*keR zzb!AD#K);hP$nn(w}A<;rguoZ-B6juS*H6xXR+?wcz_*ix^WE|wSZyrX7z{PDmOUs zxS?I-w0_2eyZv&^#%Z8mjOiEPsur!-WILP|tDle;Q5dW*6D2iF`+P%t+2Qo&Zq-CV z`s73IsV>o(J`qV6!w!kSPVRIU>aV{512tIbBK6cLL%lred#s=Ej#CngZ4fdm#uXb- zCauYWx5^XoH2=+aO)Yw(L+khKrB`ki?}@@AifmgSA_riI29<6Z_4)O`oA#2QrE~Hi z-Pkea#Ao%RdkG|+{hm*F=H#A-g4Vv`$I;-N2g)HJ1niGQ74Nyes|f4kNQq92@{YFX za8qOBlt#KF9>l^c?3_ATM+sLZqx_HA^94*J_mfS=QjOUjy69p!Z%Mt~*qKMl z%mkBfo8+7Zv8>!Sz|N(SkrhwT78;yNA`_U!ealBGcHB)P;`fiX7G@O(5_0b6G3wKK z76#E$P%F%}(VXDBPf#sQCK@m%RQ^M76oJ4rAUOF7h3r_~MZiYQ+hxhI<14rXxKm5f z{^tIXy_4?=EZ!%|G7UAZBH_ho(kCtWr0cWk**cQbb2q#(9t8=1t2k>V-o8qtdJbu$smGXm~)%YBL^>BCs_rwPx&^KYnpAY zu9qL$yq-@;KenEYm3;%qyzX#~T)jrT$Y|`~v^Ddv-Y)W8_3riqcn_6?8{_5$nY;%FE@YkNSb&ws^a64M)r~? zj~V6vWG$HPppP7ww4p^AoOGd`Q{!nMM<(XUe_l8?=HHi&SbI7M609hlo!;&pNozfg zZd{a^!%7#=3JD<(+E(3C$&{rAa_={&%f|Z3kPGuHKF5A96}8&3M`@aVbqnJ_(_IDo z?{Q66Zo48-W5?&%3BL^6!6}mOc3tLAt`#AE8dGGD+PDm2&0dEZ(RH@2JG4yqOUb%= z;O=P1_@{@_*2mg>9QT5=RW%4SBe}yCv*|I>&t;kb{g4~pOvyVcJQNM2{{v}1`FQm? z*KMXSbmlx(tUKOMka5%l*PAB`P7c&Bf|2aTSZaUgW|GB6km{3=q4fLq>zjVfluh(C zm!|7#4nK>nB;ft3e`dp+p(EIeAlIdLaj?1BuXP^y8qJ@KZK+ZUE`lKj!m zUTwGtmQI%8Sz9iZb1d^GN!oGYzll?WhPMsDWq(+?;B7!gvF0#U50yhZ zmoa$ksDCph^M7nI@Sx-CMS4KM} zk%~i{CAzE)PDryJ-gyn|%%&&y+z(S-Lyp}ASxUw6#cbfc;MfAcI8aq(Uy!Br!IyI+ z%LOF>@bR+p1F{Yt#dGrgJl;-R6RG=3YxdJp>#_ zBV((UEVSg}9y+#aWWB!;JyE7(kRMT@GMB^^WshmG zv~oB)?rNX_Pjr;ZFN(!`BnS6LyM~yYG2%oL+sm5i{8^pf#DBjil`fJ2X~q7qWTd*Q z{LrL5+*fsnilzfk6*N&a6D zQs0dl>PtI!PZNl3@tnN-9u)h4i`T&okt8>M;EdJ^SeVQ}!dHi+s#+KsaT>CH!OH^O zIlb?^Sw<2)zKy9>hoO8`jtes)9aQ1NjOX2E2FkZ1L9qpN;%}L$bvKE@zv?+^;$(P< zn#t?*t0tr?LhJWPYhyFb`E#ok2NllTwYWm);Pb_nAH;}81u=Vgg;=?g!^wl1DcSy5 z?0f?SnYeH+97)mBrDsr!w_Ns=pT+}hQJSi~B{9L;mOkan0$+kq`r<&laotnp>;#2r z9-NL=^!%P8xQP-Y0fzHkA&Z+mD@sVPQzv{P?YXFNug1&20G~(CwEzuRjkr|^3R%o& zlhu1As+8Iqx$GB#XH9KpD@k$cfUXcF{LK*Qv5hRo1j#kqQZTx~zxjU8t+al^$?F15 zysE1|wdG779`imEJ5-ggUK>sU*Vh{e6zCfJI|7gM2wCWbP)>3Cy=uY z23@d}R9%<+1{cBBQJf~T9ZWot8wBc++Q$%JA{{sR$*x@rTS~^YvDV2w$Id$Ef~|G+ zp|OYprq^-kT_uEI6XaZ>UfxG+71AHw{3w$7h=1^D zJgwLcw%$s9J>WSOVteJhRK*MD0k_It9ca}Z?FpsMJqhm{4cd5zoFP_K@R2Z!tM)a# zw(b)lUmTGgA6xWX@Pj2P@4XwcQn{(W_{|+Udj6|K+I5_Jk;= zNCq7z3Mwd-F>OtrT{iLVS=Z|ymmFr7Hg)y#zAmsB#zh!TzCzs^4`K|6;PV%sy6E8>TK zsVw~Hx?;jyl84_Qpjo+d=~sNC(q@N^f75+3EO}fq_ae>W`>th!mrH^{rgnzEeq~zp zQb`$UMd0>k5$kzuCKH-4()k-%gXHi>ea|NG13>|%_it__`S-50g`pJo z`F$#g@1F!&YG*si9~T#|9r@yK@q}c_jbG6<8=)3d6n%1wQhn*+{d5m{9sg`P_;Pu9 zzRrvym7PFIbV#LKi5(l_Gm3A`KC(IzQXqw-^?M<3Iry-Mx-R?u)L(gLP4}Ubl8B?U zjT_0S7Il|R)s2CX{X+5SK<~*Pd!H`FGx=H&pE3x)+)5OaBJU>2+Y7w}*dA_}5p~CP zy{37hxe>|wK@S0MuCa*p4o8b0UtE9(XWtbY>L$(%eHU5gu1$=$YBn)Tp0wp^$`Z>S z<12-K+2JL_XV_sN)fIz__v4hIbvmq=LNVK3n!`dY<hAK2<{{{u(U?9gQdnO`Ui#5Div?K$M2` z7Fn$NUOZfeS3sL^`KL%nUL0oNCA{$^AIif*;$DpD)sOpx#EzcD#fh4F$&8Yfc-fFj$+8s9P zfbe>F(=Jg~tKg-0p|Sq@w8V7d{6sEqa0ul@HLo}kE$Azdj*UmGNHc6ZJeSlRZ>3=U z)T&i|=-krf{0M5Y`a9q2NW3B?+?6;5HExD=tC^LXiUE>2kJd=XE?+iufJ`2T>uKp( zm5~%_vQw0Jd>pLPHM>Zl-KW4wpmz$M%23eX*}{ zJ@Gr)ON6W}aJCDQcf-ri>6TICZo~l2Tt+rd!pFtM1)ID+3J?7(0{XhXZ}Su%+*++` zEl?6RDVu5R`;7(&M|1&PX1bdE>+qg1XfXH8AwaVOX!T6bRm2S-+2_?AW-LZK9fG)9 zy!XD*%T$`zn<^4cwwWe3@j_I;bDHkSP4I?&yu?Oq+Xs27!Bwe>{L7;wEfon< z6`6!$?2_)a!B1N1Tt>~MI?V5?I{3Kl7ctR=kwT~dBUMI|4{2Hfgi^76?-e_0QJw)UHnPFR3o`nfyCE#UWdy6Tm^QpY%U4qZo~j&)wW%tx5|0(53~+A&;<3VmkTsi>ya@q`RHl z4pM;#*xS>P4qIDJZ=+WQy~9!RS;B26BM06)n_)}Lp0a8E;I5nsUk0)NoH(3r=*>(& zAc^$Ss>GKhuIv82`{gEAuRe$2Q$?_%tp!zjJH5l~?KRPXm#M(ggI0aDN zki0`D=%}4ggK*7*!kjRWKjC7ggv##RkOvxr6rsm@0SinLSYQmm0`nxZN45n^iq8-* zOf|e1{6^oZwG<7#vKCH7OSV-*iMreHsAu~1Zu0%t*i%kmpO|YeOFAzDgUJ?1x&7!DToogW%uYinJ(P+YVtWdmU8Mfx?c)B)H6Q1FkiW&iiZ zRH=;nrNWlfP*4|v1ufBDmHyPK^Tt|>5t#{>uujc)UJ`F*T)wF#%YnPdjKPLvMvlg> zBVT-e>-;QR;vF3y8@N0|t>ZaZAQck21r%a^H7_Y20Bao*=&1XLIEav&D-=ygqZg0* z7gnvhS7su?(DbCT^kCdwGEA1IbISX&fXQj@fXJZXt(t!Zn6YFQ zNqXfBSNkOLPT+^Rx$Z4z+yUu-^}mBd0_7aCA*72h*$JU?VJyI55N z;d7*NFnjLMPhOxKf+eTeql5+i)!I& zfzxsY{Xp7NlF8KTNyqlJi^>=crD=J7X(9~!?nxpRc8}R>EunT+QcM=Rv#QQcoJa%< zR`T3yfRyP0Y?TYZ2RIDYXGFuhNyr-fxiku#YwH)QZ$*#wvd5yR!o{jLf`kWY$KElc z5JYCNmRUWRx7SRW;X8a}d`Mf|?)Gg=i-}G0Z7W&3xU$RAObop*<}%S(&9x#;{c9)Z zT8D@PFRYo8A6PP&|16m_E*xoP{BV}=a&U~xI`sP2^^vZHyBQi{>Y@LfXx=o5t1w=q zCO>h5Q=P80HX8O84#|LptmxQa`BG}=K9_5eGSTKBE=d?gqA@F8qA?a4P*CDAC6(f* zFTiAdBH{D_#dA5*Q^j+ay9sG2*>l!`;QV*f9`IOtX{e5Eqb9;_Jr0^kAym(p*`BCLSla{7oW0Lc;nBrEivH4;=aGTP}u z4zRTW_3!lu?~mP;iG`Lsuew)`6fQZmi0Kl(S;bDUXc;zFlp-v)@JvJUx2c*XDzeC< zl?{w?*eTFj-C8Fs@K3x+(Phi3c=H&6Ulo0%y{+$<8rYTT2=Z^0+#70+EHypqZ{M2du;1p4z*OR> zULfjoZY3TpS>YTw@g#2HY$gVd*huIy(W;##MVkn^BX=~K5(4V66sWP#^W9c`Gg5o< zI9z*=d!Lxh&Wh|nn?%YMCuHpDQ!7@!RH~DqcuL}{0cGP2lsC&hH%X&k4qX!%gIE#C zsq1~mH)rsQCv_lIJ+nKXKwVxJL?mZ~>bH zfX4viZ_x%Qv$|>o2Rj8q?V$WDEt_6SB;57Rn`53C-ujbau4E^-7ZU#uS8o|rb@Z(Z zD+s8RgmefiN4(YCU@jvIi_nz}%560lr`pvc0 zjOTggT$3FZ+ffQAteNj*dTSPLU0}*n#fz6jyFSHZ0C4R+jEdRXSjWwRWiKX;%7DQ8 zc_o-1dvH+vVL-DA##DK1wOmGQb-xYoz!Ooc$w)aoCvRs)iQ{R3CQUXaXg4PS(!Y1r zcXoNzJ|^}9!UMunw$pjMaaV=UbC`h8G8!N?$wW*?#((n&|ZH(akGB!N#DC=Q63*- z%R$&#fvmvJL@H``YOUkIcELZFEwsXHBWB{a< zw|GhjgX=(44l?2Xueuvs?g`tyKo|>GNy&Oq{C8z^??i7YQF!`()q|UF;njjFeU?r( zi;|^R#m_S_K@C&xSPk;9{8#J*q}pG7`C{q2Q7D-ZfH&=1TG_}&oUcD7wx{u-!+;s+ zLvcLmhy6o=k+GuGlD*ih_%OsOk|PeS(j!c})oZHs2L%r4>bm{)OA^8YH#(V(6UV#H zWr<-r(!#f)mh6pCybwaP_5<4wJf5~qq;{aL_8B|<8PaLVL@>#zKZP7Hr%E5v!5Y1^Vx7-r+7k_N zp+u--H|igzpL!RS#=$Ts)Tu)rk*1O>&YzC`tiiS3M*0)WN%WnOylsRunX1vCNUkDt zBg|If7L7c!xAjDt6r2R&lrdBBL`TRBELgcl%3<`K-0Z zK%w!}60_a_T3}lcA zPGA}^YC>z6i5<#nFN8r5AWreuPkL+Fir?|~99$h4#tXubhVq&kr2e4(aO3j)u!NZI z4@GKaG?%u-9KaYYC(>z8#sGnD&FMrXOmuOasHZCaSMbrH6>-aNAyuR-%%Gss#Gn(y z&N73&nhZHHP6^>O>6q$stA_IXr3Toa3V7KhrR#>h8m~i>?3Lji`wy3+60}nT1lknx z{1V=29U6O#rbnllCdv=XXV+k)t~7untBHy6Otwrs0f9A2y-6m?F(7)=p&9M+-=%F) z&X#)F_AZa)XSyGn<7yXgP3bLXrvr%}7m+oB;PLTCRf`@Ch>3{xRge=!EZ&oZVBd_I z(Em-t&OULH{DtUtjlW?mFuoMTmgFZE}z5W7%xNBNBQuM%--ni!A?pU|_E z@l%|DsC-3acfcRb^uc##*QzIKr4Dx39_Hry+$A>AdNK+00?6aKp4d=7b&YiWrrDCw0!OW zge%IASKqnolj9xlu<7rvr17d~m(MylmVL#q)h?UI{T(hX#l~WBYLk1@whYfamqkcu zz0VgJF-(s5D$5ZJk%Pj&Sxk^T4>p2-ox72~l41lw&LQ8-=m6%8qJ4XI**&@_ukyyeU2Z!%QEdNQp+D2=t3ffY|Fn!A+-2^x0_rpg@2m$(H=VxmqiCrxw4>d-}RA@O3}yXvzWA z|5P>r%@Hn1>FjoNj_FVIN=&c49iSVxQ#B`Ra@GVhT6T@|y89Y;#vwD6RR zs9|FGb17|Zq>;&flQ3vBeY?M%e+ZDKT$G1o#H{C?6(=yjKfC)OjYFad;{7546iLat z2}Jyw(VG8#FX?;k7LbKl2|MkOClJNRjFAsqcAgO|nki>;%E(x|%vr&qcCvmJdmZqV zkcPZ;A!@nx zTnrT`J@6YN8>=@(kNhyQowvU+vW9{hxfUWu;erNo_KlCd{2Scu>q~zPgy=OigMDj~ zV*YZ-X-U2v5bg!Q8YW29P5`C|#$P_^e`s+wHNOV^5fx=ty9)_a)Zv6!bf(4;F7MjX z-DZdqFQii|zT+l(@YPexg+cjA&U3qAY=5+S59B?W5)p4~%+wJ6j7O-M_Hb&18_RY- zc#*Jw2m?)zJ{xMbpd{-J23wclc!E8^ou^KG{DyhNvU``b3AqB(uG`a+?8My8-X?^O z)_c4F2oipTc+PmG#%gU?^(Z%IMG!Gjzv%7pYYC8cSrG!{pR0SGOWQYD=%kMKADD#* zAm8_0*TU;%dqbc!bu8!#nL3P;mII;zA^(+ViO!8<^~Y!+{0S`DwRT9G^K0IGZsBQ* z?t+e%Z;Y~25TVc~PWy~oK*wOc<#R5^85hwlq3JofOoOtzALJP$rE!X?Vo7LXghl}e zRwsUf>X_}zYV1awXBa+V8){}xq#+oIsNer#umhj~eAyYpTjwi-X~lk7a{*A?!H=CM zit%h~p4E-rJEGm8mPJj*Y-kXHqD}hOVM4=ucI)1~24CfrdH-K$GN5LJH->7muvh@e zFzDcaI+hZLpwfi5Q&A^vkVh1g7t{f!uCe@luFqOoWMB z(r9(v4w=Z}Di7l;?wX_rqG^kxvjF$}QW$*{0-LSv#9rQ)EE}&sq=_*bHR?%~hwnf^ zyP>wL3%&WZGPW=M;cZ5PygF~c1{-)d{Uh&qXH#rw;@>~Ooh?WlWySgm)M zgcN<(fq@p)nznTxV&U=*x@f@KK549!M?kOrHJijUKMa2~T!;bpR++1CFIqF+PZ9U@ z&CV+zL;&(J@R-Mcu9Uh_vcOxV*w{ilhkkrvtx|M=#pxZIhgdt-O?*}&I9in<;7XB2 zB0>v|OtA2Rv7I%_ZkhmMtaJ6|t#|3|-Yl4^eeKRa$sR3SQtsU10-)3`IeT=K3}W~+%0mMB(zVj z^93Gxe*E(lq|{ZjXGyDNH<&%(>>=8sXU>v(E#0tC!a3A^n(2BwHB>d-wkGK^aTY~ zG_pjx`9(6~{b;m6iVVapCqO(7dlADxFSabj5kh_4%;yhyMVBQb~WBb(F zmreGXIjDQ3YNQy{lsQ(+g;r$ki#scdG0C{Ey*JEFTux%XxT{p$|miO(lE`rUl2m8HS zv2Qh*Do}gQwDvs8@oy(NI|PQaKlC2Em>fl!hY*G!TDTc>hr72%>$b(cHPRnz|z;^28qi2LI#;&8ZSc|9lgywz;YoL28C3VNGJ13ZuEf!7E z0|`jkhQec2>B+%;t;^cp)#|3o(YcZ{`PWQ6l1yu6bRfgTRp17K67bSRKv%DNxK{!7 z*LS6oV*Pl_0Fazw{o%cb)(+cHCfv%7VAQ$`iAHl4X55rH&hi5$=b%tR`nP+~roFef z9DOZ-{U>e+px)ocj0*NdqSe9j-#;xs*M~Gg;Ju~c*Y;a+4_ne8s!3f zp#E(DAAxmfimU+F39=DNf;`ha*-y%*RBnAjWC-i2k0c^a!b}53QIYAZxLS;HgsflF zLOO5AL%NQeeG}OUE@^$%&HV_EEpK%pbm8XJI%+of01`3N@CU*r{w$CbQ%KTp1O+Lu z^O1^G2&K6$XpKK!{&3-hK1B16Ckr5K4orvHAJOs{0N0<9(;S29&PxFh#6ME}YV(F;yQbHKPX@esBzD zh6Wx(-Ara?eSu;>8;WX{rP)}!V9CMbS_ONP&2(}Zu+@YAIPPV%e{k3-bn(wu13cLH zVQy=Eb1kx9Y{G$D5|w_~1i)DslxX-nIwY(y8U#-?dq+6NDdX>NrCe{#1vePD?sSpR zAS>8bE|k>ocv2W43>WW*^YV?3@uJ9QC9WVj?yUG@U`G-w94vT8`yk<4PY*h0v@;+H+&oB= z-5I~q(+k7y-0&(D-jtJ1&CXt23Ye%a_4o>=M8O_dcZIapRXa@Bm!0P9qKQb8BS&_m z+NW?XOw6;L287u$z)$T7R{?fbaZ|4Xb_R$X=t3Z%$2P2#1_J->*(rGMVZ0g`t7VN} zNaw51XlB_X_I0alVQz_vvXU9l5y2nE=>Pmaanb~vA`T4FwQNjO?ebz!asjYi0RTp4 zRzsp=y1lPM?Zfx@tvt=bX8l<&+c{YN4#jluw5A#pl-*9a+oXskwHa5;jALo7isrh{ zjq7&NwTtm#_kz<|%8FMlyrpDKITkU@e53GAhh!UrC^ ztTtWsJ9XxI=SeUXd_NoceIb7{N^Y=@a2k8%fwNI5W^D@~xIn_@2g7WjdTwfBp|uoR zk9+X}DtMtZ0K59)t=;%wltDp4L`Fd}zsT<9pj%oEC}99hf(uCXv(BFi8Dy6M-wm)R zz4lL}*HyM!EY8CMBVeq4oR#T&ADMzpyK1H1(y+bn=?QX9_4>TFcJ49}!FGH#_vNqe zeyQI+yz}wMbI9-D#4qjh^KhD73Tz@@LN@SaKn@08zq-96h-dQ-aR==Pj!k9gMimGZ zObLi%;pRG`X-$J(A?Q;D*FQ0XlK1s0&VOGXzoQ_jc1%20)c37Mkl?yG5}I%v-#n`Q zH2idYnbBb)%(yTEP`vO1cM ztwcQhjrUnbjkEqSs*wt8Viov+sW|%DlaK$q_ZJk3pc<~7UxEe7A*fgsSaU=(_AsNo zoZ~C&IRTT|>C81P$yER0=oxk!Rw?fV%c)5{I_A}tMF@{I)cdw% z4tc(1PiqGU90E=d2GPMmumGh9m|!lVD>+=1Zm-M2id<~AvJKutugySMKyr=wsQA#S zTNxZ&8D8OIu>Qms^Yxv1l~Z*)KPa$qHjdPiY88*QMjN#ZB)cVRC=`Qr+Jbe$+JL@Y z$S6e{D|uCO#o@N>ID&W=d#h?o#*1g2Koz!W<5CVPc9Vs%)+kNPeiOW$u-u2+Rz3@yOK*X0vsX{ zxPwk@00{NrV7HkZ%h~;Na8-B=^bFiCG&E#M*_3JOns9|opPy)Po>9KS2is1n#{kS( zGiSGa;lpk~SJR)1dZi-41#+Q8@Y5U+#g+l~1Y$H1UFP^v`SM!T6jrjqctlXw#X=6Y z1^Az3wPK&bSQTaa)Tk`zWl6mD@;Yy<2=F-Urggh_H^s6EEBBs%;8Xh|MkP!4`|DHy zXmH}sG66LzwkO+AN-o1SzBJ;#N8Kj~eStuYSr129=HSd)TbKCmvLo9tHFEE7M^`t3 zDT9voR1&OItCy+cdMsDggVLNAJ0R&1#X5cC69g<7P)Eb^WJ#0_Dar8ExDw9s*J&rE zpao~27_DPX-PE!MrQ$L_AU4vE9j8A(LG|%_PV2P3gz$GcTu%GSn;P2Nv&tf(WF?kw zPuCvwVF8W^U*RsEZ7|+Lof2hJ=iA?v6e{l9WSZ1(KZ*jEpO(3Hq<1T{8{^huu1QH~ z+UUToCp4=~P=qR(`Y7&B#Y^1k&i`GF-(1qIq*GKJWDKexhLwZ(MbC`8qkS|+mZ|XM zs~QXUTY1(XDQIUz``*JFRu(~&rqa1kDfEuUmUs^D~DlU5lk7mPI^JmpOu1)ox=q)3pP5S7_`hezrfkdV08Pv6JA z->~j5p5+Rngf~aaYhOYA*PlSeq&&3jkJJQKrm9PlnWf7J{xXgN2n{oYtdtiC{~G6U z-t6_0y6@ai*SyBuSfhh8IGaU*;4Li=0`Chw0f+ScZUGW5PRGhjxd#6lc09S^p;o9; z;ZsO`g2rN>j-+3(J#+4D-VdB6znhV|Qo_28IvRmo>mC|^lSnK~&PPZdFC`~ssWWJz z;=IkHyPNwbeb(TO>S6qCS|OgqVmtQ=EKU`e5cXs~7Tg^b3ypezO!?mV&jvU~?_`2- z5}2AH;?$Z=sqtJmQo@<@&Rz1hQC)g*bk$i#2HKnn(k4XP?Z|!??HL@Z#)$**DM_WF z$z+)wpld}BcpwFf4d8*3A(NBQc=pcnm-8NAMo1Tr(uz%IE?LLgncgrm5^Q2V3jhR^ zW6hoQpHwc4gF1t$FEub`9S<&YR{ju#I{R~Nk_B=AH}uL5qm#fc!lSdgDv0L!+rc5f zs*ysfx21D_0Fee-SbdLTc2kO2@FrUXHa00qn92c>KjloG#&_99*yxL_YODUK$Y5zA zm9K@s`K*G1=lH2H(6LZ9U;gr3KID*CnNTd3p2>@rg8MajBEXTy1(b%PG!=hI-{P2y zWxYbWm2uuG6P<&LM-_Af3c=ge5UBsE7u4TZpAod2FpdHc5tCRH^ec{57;x7q%hMt# zk98?e^QEv@F*`QQs3uF^Wf^If3rQ$m?BsfRSZteoQ!$)vDM*;%ZfaBnH{_{xY}E(Y zZD0Dk7Gl(d(A!v(`H{@UIHnJwYAE%fu6*3m;!a84Wcb#@QL1-;c_Fuu=IeRT|7!t@ z-?z8IxvY}AnhpJ_qW~Knq#H!QV(@kmf?&YxHjU)wTk?t?A$2kCo8)cFZJ()?AXEMF z=s{MOw!MwJg#r-2bF$tk8_a%85NaMY?dB^Uv^Kj<`ZA*xt1D`VlZX0V@+&xbso>;^ zYPX*8$5;GRYT~*5&Rw<{KKqV!<4O@v-#&#-BZ+u0Nkeb4R^kSPzib#&YnC8 zuSQ7djGwvDnYlT(Iar_^__b(?9Cv7D3xW8@8<;tRP*ykv`T)25gesfg!b?7x zX1s3bwjB><$CL7t_`MK%Ip;lwsBAO)G4mJ5bIyK%?X>?!qRpB8snn*)v#=&mUvkBv zlj@My^?Tnf=WkS@XqR=7IMqme`fRUT*v-=wy=`95ZwW9=K4BmM;bIX0XJAE*U`0|# zSY(-GK<-Ok!L47WI}Ka=RXpa!Zk3p*s^^nssF?J(bsDR}n`)*iXC&Gbe#sKzE47#Z zQkqb;(-b}c6Aj3*;6Wk-Q{tx37JyNxO)YpJ$HWJ`{FwgVje5;P<{a1@k93PhL zy##B}4;mVD4sAN@>pz-OtefCR{`I8iLxmedEIBk$P_BgZ6|=Vo8YXjw)2sjrrwKrh z*u<<88i_V0f>sN#jLqxFP9K(p-9f|C6%;z@ojpbFvkR`=_uBdnOHWaG4cGQ z&nI&iRT$~K=P>T0(D-GUF8oF6!zKfPP_=FV;Al3sfRhDzE`JZls^a zas5@rfP*hgc@(ufsVas|)aPKyB9$_UcqsnsXHZ5#q~Ik+WIsbFy*83OT?u~uFX}%h zternP5m?U(SWoveae9Qk1Y#=RBm+?df1C;bA1OB7QN~0DrT3Np_J3tf72qV6&t7tW zf9De!3O_@tH{-Q@1cez8;t{b>j3LGvsIqW{p>~M`{QUoI_l>pm&E~+ezwd)GA;24f zn(h-l<0(D33yltVmQH7RFl#UWreiEaX11`)3z}PNeSz+-(t5)+X zLdscc=~1lK$SUubaC`SKedrp_ zZPS!rF1mWvTXLZ|I!B88jd-zKH`jA{M3?Wa?t$aALM15MIMnKxyH?M5$P?dyy;XVITR)hd$WXL2M5e@HLk#o+?FwphOU?Wp%WCj+ z{jNo{IQ_h44m6gWMA-_(j-~VmFdkNBQ;cErFEZ2m@lwawECqwAVw7$(W4ujM#HCXc z+Y>|FGdm^X55pN}VtFdpd%~LNlKB6W@ zkax8hoNGVwB(B%114mlPk(r^#w~_St5VC21R_D!9Uipi{CKDtc|6`5QfR}RQ?{nF% zZn-(y3Ngsu3O#FTpMn>glf`Dlr=;7juChtOIG9tgwitr48uBN80mk`5G3z5Rt+s3QBBoH7EEUr>l=q* zc3Vv6MD)@;s>(Pqf))yP9VtIiTJ6e^K>iBc9kI}^04lJ{Y+#pL!7c+KtG2Ggk3J-> z$dQ9TL_;^KH9xE;#aU+^Gp*OZ8MTA($BdfGj#9}N-8PC_;Vwn+LZ5?@h>~hXNUuDs zN05o4^JboL|6tFne~XEyLYhjte@HnlKmsTr6v#mgVP`=Yv#p|RSvyL1H}36%L0`>{AjJS#u_pXK_JN*|h5VqePcFOriKGg8 zBB@r52hc`f1ihbY(6!Nw-LDwlC7=Ho*^tkIP!j}!j^bGQ)8+F~@P>4qbv0SYloZ8% z_`UE&lxjEz8)qpY(v9oNBad%{lP z?iUA~eJzZa%#R6a623np44vzar#+2yh!rMc7-QIm&1(1)J03{pHl^86BwO(zw$*RM z2S!v49{ndOBO~>R`)-Mew#TYzZVUccvf|0d^a7N_g+m=`B(J9uVDZ>R19GXAC!=~K zP$mfH+Ox%@ZbNqcU?#t+Xui)82vpJMxQw z0+JGLGh@A5QzYO=9gRomY!;j1)~ZQLn3rK4sVVe$we#xltU1g-EsHvyxnjC zms%|3B%WV9_=3R8m1WkpMPkmsD>5PuO~2>r$V)kiH>NduP13q;5ZPw+Q6u=8G|6k1 z?Sni}aejoK^G5>T4oM^f_ftL7bXO#(_^j-y%|FoVkz!BH)ShaNUbfv<*thX z@9EGeFr!m)ZIVl34~QOP44`2U6u`5d36{CRL~&PE{7Ab5F6X_&+}0`Lg**jMPER9% zC}Pn-t-4qL?^P$$_*UPg|Hu@+2h-=c04i_FIXLfL&)8qxJD;5N(`I#&BdokAyMGqh z(&Z9q2Pfcu(}g*(S+8>8uATA46%c13!x3lM#oY6Gx)EoAn6h$`#*ac|xz;Eeq0i(D3ZvMcpu7C|idE1eU)qM_=Ocz9uKg z<~N<2d>bVuD(PnFWI=HIez@P>kFS2f+Qqw@j|lo!U_dyU1_%lO2SxdMGxG|s3f?{& z@lO_n&_l@m#@@kTD}-y&zp(IwLlWL1-lo;rOSI=DMMYo#iZ`oh2?t-0WV8XPE&*s? zM07Bytq%KeJN)s<4db`hhRtV;zQ*I~|_+UWSVNCNq7`_7bAR~?5iIN)sCWJB#q zv1<*yD?!?P9}%Rtv>`*KX_#>^_$G&M{bp1E>Hbih9Vg)}x$^s|!yOi~v+z7}HpgzE z0zjHzBAm+Gf?7_bRTG<3*ZBGM2pn90)qb zLU5w))g9*ew3*~Np|f9KmwZerrss1>KB|Wg>D52f_6k+-whvYp<`rWqY0H!w>gZk4 zTs_2V66F;$S8x}rn`KGNa0s^TK=F|R?&BXFXBeTMg}b$>Pt}Z$h=mKzgLf1x!9eB6#n|VNknQdHf72nH;pSQg zI~=WqwoP`XS4pwN4QXUCfLqDbA$gJ&fISUb)$gEZPVFjhxs>qRxNN=@aB!LXs4r%c z<=elZX!ZQWkMtmnsg$ggqY;Z8b00g$TJ3aHcZj*bCobF+1^B)hKZ6fG0h)VC2YBDK zT+8$;Kl6%7F`s6d(ci4oC!ZZq<_rAA+_bw{1$> z57eR1seB3)wIK`m`_a?yySqOO-@2LRAF`0mVb2Ru&JFh%b_=urudk&j8hiJd4+Flx z{m@5R?RL=0L+M^vvOO-`5E@$4UtC%FwP|x}wKHfUDfo<@iHY#pQ z1=}x1EYZ)zELg0A#oa5)$U|pDLA;7;7oELE%y|V$+kNyt7h2T(jGp>LFxB;Ebm7KX zGAD&nGmm`V(ICixZF|?BKUDrjgqIDt*Op*}IvPn>V({p`AnN~Yn|*GkLO0AX|7%-aLX+G+W8%e-EYzy^Svp9ipOnYxUD zO+6Y_VsEzX@4C2}GeT#vGl(Nb^PfbMI<0V3?G@SCFL-!(c4cC>1`@n|ka64e%JYYb z7XxTZX-gS=g~Zs^Sfz@4da6)DeQjpuk6aohbw3cN_f^wWZ}hp=-+Z^`0|Jkgh-M#E z2WE-InD#nLKRfHy7f>tV#OFMcmel0#_{IEe#x%!;*{DkO7)A*t3kLGWRNGG*x|gRAk#%<%Zi{aWN_KNeo}D*l-^w1=$SXZt7fYjLEy3;Y;G;ysKeFj-?;N z$dZ`3{u1$2Pu2}Y4v3{ew;@I?T^7ohS20E2oFy8R5*jho^XKj)p6raes5d+LtJ zBZ|k*aNJl|H)FP+foo?wT0=)bNJ#tOMNFuossBs2(r{NO1RC~Zr2F%sxNT*(KODdv zvncT}hXipO8JXx=Mbo7{2?tN4p&D^AP$4Ia$aj=Ty)i6iY|5oElLwA%dd%Q?$m&RS zWO|rTR;WKYI5kwnX<|W`?fOJGz0n7@2j);z+DGXGF@qR21%4*diM%-dP0ERQCmDv& zCJz$X>wk*LEEd?NlK^Yst$adgvqIwG(o4hv@w(6n5iTf@#a5au5?~pi4 z^G}(i0awe(0`naux+h4R#Zdb>#%?ra@r3n62*OSo_=6%OtiPkXE^SQ$#} z!xM|esuXDtaq&de`GrV#>WIFGM?7J)_`MB?5Oum0n-9lXUnyBn*)p~A!V9aL=0HZ} zLp?bqzK1_qtICa!^pPEiDgMXScHI;DIkNUu@#jR1EjeQ}_P&%$m{cygrQOSb8-5i& z6%{(Xx~k{Ur*XX~e=^_KCwblkHx2s|^<@b2^+MkMcQl8NV4nULQRh9h4^&aoN$-?6 zQNpk?%R7t;Q6B?7SXRNNb1Wm;gi8{XTM+fh7oJXhF5&&uS@7yg)Z9Pcxg8^@7{(K5 zFNi-#nrQT$^YPV-wK_|?>}=T%7#cQhDHkVo9niYWwUl*+>9RCLZi|IhC!VCoOS6) zVouzAJ$&oMCJowK=X(TXocz6v(znc`oSD{N)~1#jv-hnSlRW!A+QkkKk}j+-D=+pR zob}CN?!>O^hACSUMC(M*!Ve~Q`A9f{qeRa_Gu+4+<|1GYs#s%?5W!GM50>{YowobG zFt*QfQ>D0mT%_x>`po{^7KQy8x+WR5z9DP394{Ci0AoS#M6<(yfyT)@stqniCMFfZ z5%ww;GV3UZx?YZthGugk-6H7~tYswc_88;LkIv!X_LOqLbLwwoO4t+F1V?m=tY_zs zppDFlep*rt1OQuh-Y>_8lVc}|{6k6M`uX&aEgOOJ8@X(*tQg~6j*lTQhT(b6ooB=@ z7UJ2|V72%X`f1||a2DSmU`P)N54(Ef5}~A8e$)g~^q2Uid<61~!%Hvz#kEGLM1}sZ z6B7B_7mO=z{q?#i%$`)$<6_2mqQFx4@rPG;2TL~*+iGR?bFV`-Je0DzgXvnEtXb0! z!>If?s*c=5wMT8p6Ocb7&Tf^rKU!Rr9Yb%_y}7RQ=IONm-}kDw&TAv0qDo8r6t%rE zXK9yIeMhf-cK=8(T|NlUjWlMweQM|4IAJ}XHHE!XVkOcX`$;@Jk#%XERvlwv5y@sa zYh5QAwJsOeA2KsZf45(&#LPx5x8PxtPI@^BX)A2v1FXlWAFQv!M`iHSL?CMw1-p9U zWR>3BnCpmpzRKKZc21BRq5fx-=iuyYPb0~czXM;BhTEX#0KaizHR8Uu-OIhhxj_6p z>Gq#7Y&w6$n1<&XlAW&~n-KEGggP}FWv+MCxOI>5{#q??@;^k0K{|)o%?lNWlLBd# zSYzfX9H0rTi@rlnj=Jqa8Z2*CN{wllS{vnt+RhTgr}p;6PZLw7Zw^Dtw1=6SUei5T zarOm;9MRrd-!BQapYiJRsK%67`( zO;B&o>1iIvG3ohONOus?Z)y%Z=Kk{fr(y_M!n1}Icm1Tx%`AHVz28&N`37mEDd+j2 z(EJa}q{jpR{DPS%L2yO!m)=UuR>3y<@K!~g$mnM#=AQ#rqRh(If4;_!Gi1I^mc;DSeIf6Dz_PnOV0mqy1_`jy zes3PV#@*IIv8P9zG<;#Aq%;~P`4Fgt2RbQ!pLbxg>HBrN3BzOT|;hM{c zwjOTiHA@5@PnOcW?5vW)@GHo9tXcFYA+48i6LBi#ne6k0 z&oaGFI;k8dxTx{DOlrz9T_gIm+=#;4L)2)9t1Cuw!v(Ru;DM2RGoTPcfx zVB5euOBM*#k|+r?TcG(I>o2Fsk$zP8wstwmPC+Ruhhy@#CaI!A-erj8YUF#6!nYy_ znzwGNMe==v&My%D#qiI&<%i|x z67-02J;9;-jaRCUW@NT-DQRs6pN$M(ZMt1xYhD$b_7H3HDSUk~>z^qz8)i`HJ%t;L z5Y$XJ|0)1VBNF;5!Z%U36(#w+0;|kGl*G2O%f-Rf7lEfDZ>@tg`R7|Ol36dF2R*3S ziB*bkJggeoG#nyGBl9 zPT5;cj=&;W`~6+Nys{VF9{OatM8_3);jTNZnpfV2s%7j*31ruD?n{Z1^w*pC+?S`F z{#R=O3(C>d%j@{NnLr3ZJ^7 zZLDW0CNdfi#m6in*|q^%_yGG2lZ}K=1uw`0m6rQJ0ZekmufWJofyp1R73muL8?{r- zJA^F@Upb)fS4tU za5FTT`3z{fq6&s(obfza1|6)!%zWZd1Q~7WL}78VY=B8eZ%g9~hZVu2x*=BBBZ_e$ z_3v}sLN@(y4If=2T4i%NvbpCmEpe}1XXyhQd6rf_iw`mfeeq7B}h=)^99W707d|}zPiuBE{4ORBBeXAN9 zK3LPYYk_qq_swUCiB)t%34i2I>(xx1_zs1n8daW*7cCNF;MyhkpB-j$` zrvktNJejCzw7Uo!6Y#8spGGaBveTbLrVM>-=Ak0(domKv} zAuVFb0oT#$z+35F0Hud#1uxn0yM@^IT~xb>{pV5dnA<>;B_dZHI(`2|u|`c{N|M(W zis#)(hVXPFw4xqzWe3Ma2JXfT3YGU?)w4sRKk&beQ40{Z!jUpXp=sd;*g|WjG=c;h z=~rwO@|d!Y9Jnjf!w4UqzvlU|I1!jzOuYRM)t>8v&m_K-&0X(GPDv>7LTdp*pIwab zHAM^~+Cef$rq0Dn1U)Um6XZ(6X;_s8wbDUHJkea8FxpYDWXTY-n9HO9hUgeboYT%O zMamcP5ilAPDP+)d`^eY(19R$|ijMRgRpPv>o;&HKe2Y*EcB5yhPr9PciT8*G*r7>OPZ zEgK!S813^(zY(0sriLn>t7Y}mM{A1}z)zSfEl!?)qKd9r_f55=ATF8cQSQefy;*d| zeQbsja~7REmdrhrp)t9c6QY?PByC<-lv@XQ@+@XHSs`ZU;OnSdz(#6LKd@wS^p3vQ zC3*cv6`tX>V`UR3{Ugd^A}k{XW>i;(7^B|cXFf*N=xj{v*bJs5b6x7TL(CO$w`rWdFU!}?W@=B`4+pYAFH$O7pN?5XZWW73_l`$Nn(9#7h4b{9^r+;Gj4Gp z>gQ6s`&lJu{XKFK*%yU_?f9(w#cD^3t4XuFOUsSR@TK!(-p2dlsq&kU=bl6atSqNl z6ZIzc#w3zpkX2&ivV{Fy>dG~>v-vbmz8{Y6Q18q`SpS^gfe;k=u*9rwW$=KzY}dW< zN+M`7wUDTtz7P-kvGYlY53Qk+pyGS_m}&J z;DIXrZ6!}U^sKH=A3z$_Z4hL|2WIgHL%6wWiYdk@94q%rPgqf>rFHHMEcL9lRdNwg7j{%vx-hA4DO(fGU4BHh0s z4c2m4YP$gqQfCkxQm1}dvUbq!$EB3^&#i_ zDO`Q1wnyjGYY7i&Lzq2Dw}_S@RX+;lHlwnS&aWV3(5Twrj!MSuZ_H~XbB#_F>kc+rI0>r~?1r=;7&1o_m2T)t0*8~DpC9{{K6Fn7Efx71b=`AQwZlk%n3 zbIH2vm5R}mCPD5D(+x(`PDCc3r2MKaSbQc_wYjC=Eyu5q)j~J<(iQB=yEkNK9(SwF95GR-eu@dY1=ySd%BDTI5eG2pExlCmrn8v)T zTN8vo^YQX?pM`}?J9VfzXxZNxq9;~n$8#2Q@573~P;?s3_#pO;K9-2;?R`R9cGf>U zoiwkqz2W`JjHfBdntsoXlrRWi2X~`r+hGL4Q?HYlwWX4=p+aFNH@Z2>dn(N4`+F#r z96dJDg1K7saj7hsS7(@%x%}Jn_>CT>lh+e8$m`96bH^7_;tz|9#SLYU-<+pmWax%; zilsx{n(rCd0S9BFH<-v_*6ua`i(fo8=Ts@TC56k1WOFDb=Wbqn=xul@;tT`zX+ zNz)&J%1e?S;X^nXgkIo((gRQ(u5FE`doATg2Rt#2vf+E zUScZT5f}5Ha>ukU(u6*X(KjhD==uxKE+J-B-B=E9ZaL@GK3koo&WWIeI2X`RzIKVk z@<#nf9eAAtma7BrWXbv3H%{EnNcXxR;o+~h)3fuxF7Ty-)_Cq~cfbp}}pkjoRNS^slawD0ilPNQwt(dnPHcD#U;peG;ukJoZ0VZ9+V7@v-eA26N zue#TRXhD@VmoUb8;>#K=xTqBiH)UZ(^Ftn11N>NvfXAEfvy<;~v~aGjqEBr1(Z1#2 z(U4eJ{(}5M`!Tfnv1Cx>A0Bb~;sn^dQo;mkB0o@G5pHQKywsn2-uURutc}E{8Kb!C zEp}$w-+m5(h+Cy$p>2SvQh|*t)Ly+N$@J&w_`yERi9cyS4+wv%6ZPU>{sFO`424xS zVJ3 $G^5{aZLtCe~tGX^TTMS+TrW6eu=6Te*|Mtu0r?tbr-0Ef<~~ZAKqDB1uz2 z=>7?yjUg{^-(8`hJeXw=6Ay6`sR~F|+gD{7h6$nbAky~~PE_YT+sv2-!p&dn&s~l2 z&Koz4EKrHC1eRRZA54`)11d#%s0b?FW^g)7`)cvQ<>{i%&hky?CMl=>9+wU)IZShy zo`QVreVe!X=XSWwlv;JA@OL|s_rhny=t)EuYXR=Y5@_@qXQ^V`zq73jLEO=xZr)e# z>zHw`L--_x`G~n7v%kEN&jA4gZdBjdSg2K#)@eBtRbxx zd-IYOXLY_L7MKcdPlvlc<`+pPn*5H*H}M~cw=t_Cy)t}gI`?wg?MjcgREuuu&;8JS zRpRj_*?v-Z@Ych4*HK(#(lnCLB#59!57EdUFlaasCoQ_VWE8Jc)6a?jKd!zqtj%Q$ zw=D%W6nEF+6nAfNcXuf6?owzW!QC}@kw9^GDHIP<+$FdKmz#agJ@?1`o+lr_CK+bd zto1H?hlorqAvYQ{b?BVRRTmiHy{BSI>EEz*3?N1)*r8^3-8s_^ZiX%WQh`UnQS*y@ z^rBk`#A@EA`+wTA*T}hTWhk&1v zQ2VMuKsRo|pijVLj9G3WEp%-Ndr5<4$G98)_5L@!EXb7Y?KGgeJ2>EAT} z!yM-RmuJ;Rk?T~ST5aToy#L~sV5EC}2pvD`2RJ*eY5tF~IZIIeg}6_C=r%hB@gj9w z`!tpSJxPa_M8fW$ncf?X$J6+)MK80{Od~x zcCV($uS9O&Ty9eT8~bQlSFzi!v`C%p)NW-FSrsI>cS}-_;8~?I)UzG`@_KXnzV`RS z3*}wAd@^4ryFy{ZN+cPGv4D{oRVCz#-|J!d7%z8rTzPd*3c9z)iCHSJ2pNC&(kwfe zQeO3>P}53zOlT+DWo}4GTk}~mdKO>b_e&Cie;2y4{L-yr|J9CsRzy;8*X{n}gz%-h zr-=XtmCQ|kXb~4 zJ7zSWkL6_jaN@70aVxF9JZIvtVCUptaof*QI|g;{HRx3QGc?9v36(0bZ9EkY1$Q4f zFM-}p*HGAyR*98yHTQ2ZAA-!3t_?~LWnr8?y`-W%h)efz#6`&v)GyqlVks|cm#rpw z`X^~o4b)JkV_Si(t8w%<7*dM)>d8(0E&bojfeY(+E}%FDj|(ozw;%@_86kE{p@v8?zr z2Ej`m;*_t^?=83WEaM?@h1cNhI5=ECbqFzZ>J2gjrXu_f&=lImSZ#HLKgN->{*X)* z&;f*riBV*FO!lV6$4eSejU!2NO?1)9=Jr^8{>{K3gqh%N5!x$A@z=1*soXz=l8@~# z@Dn&!DqOam6-7QAqItOLW#UHC_3*%LnZzu<#2ha;&`pSdy`7L;io2Hby>NTW+|#)i zi#)dFm{lprmCxGv5PE(PwkTtcDpLt-YjToxYgkrCX2KbSy&Ov}7bY)0hb_Ldpp5cv z@SCrQ9B!w7yf-?;FC~h6U>Ks2PWtsu8YdRQWG5GszLp(miY#eQu!>*!F3Ahp6BMq#YsF^!J+Dbvzmp~m7jS* z0}kyAhVL_O)$i`MU(C1Y?3!QoF2Yn8Vy)(EVvDhuY z^S@Zi54;3E#MG=uH`h?mx+n32bsW4vJux%U==CL&)}~4^YQklYh?4XZoz#-bL5AU? zAq&N**EZ$Cx}728wlmlB{*HmGh{HAhw@M{3Qp(5x>p>-BauuhapJRoZ>_{><^QHxO z5SePwP|(X)KzSGv76ohN7>)wP>#=<82u@1Ga(LcPsWwgChi#$_UNm%wHU13m1WA^s zG^}-;@w<@J(1|#GY8|{Q8*5i`F_eh%qqO$J$B|+J@7^iprU6>?V3DBN{*26s3m=o1 z)@BBu8o(o6s(8tSFX@k+#8aTqk|UCr^jx{X4q213OeuZQ=OHS#Hc6O?^iU#FWF9-Xty2uZV;UGKB$zIh3C zD-W??)i@|=iqWol6qxd_egET3!R=rUL7=u%fBcxCF@!#D*iYA+n?*_KpE2wblFWXVQ;DWP4XOGG3m^FZ<{C1CY!a}J{>9Up9-L- zHe_RT5`cX!j2}M_l0!3-JTc3ylI?Vuwx*ex&{2)V=%dds8?#yAa9ykNcnM-DOw$F7+K^EWw;myhM(+DH;Ku`2K zf;$g^|EmQ!CyZ%(t~2P{4ZkO$_8wbq$?&#y+A+`FQ2+l0{T!if+TiS&shCbe-xhSn^9H+Z$KW(61@{6s8f)Plr9u@oMZpHk##EQrz7 zgpN3w+IG_soh|r|BC}r8c;u-ec=(c6P3C*x z6(gwvr^lPJf7-8Mzqmj+syl786lkl#vC1bKnvdi&+ox`f@6Cvt*1gXksLtl0NDpK% zJ|wJb+?aAe7M(GjJ+vf)<`YHZ@q%3jLPD+uUs&dVsCjICy{g3m4K;X=FAdoFow}9I zo1ozhMR(C=`HO;FtogTNT{Mo*4Ud6D5bhZ1Aoc@%*;#< zqLfhDnI-%9up1+++gx(Wt-U~_jtJlCvOIrO*?5XnFp6;}@`<3j>f-W=dz<0sDia{V zV}|_2XO(ZHTNbk!Uqh$yRP2nxirQ_tCWH+SMQX`~zB?@i(M)8JXbH}~RTu}Ra4Hl@ z@(b#dFCI&bi&>>KS(tV{u%DRlCi8LiYAflDLi?Qul}rPzrS$OYw5u|JI@|SkHCqcM z;}iJYQkz4je)Oi8FjTd04F3vhqQl)xb_#M$4LkM6^@)1(PMf!e(KnX6stcQAbi#EP zKH29Nl8>&VsS_L|e|6)JL2seIHT1xx_UUNKG7*7E-($?7J=RX2MhD#?$=c-_{A=D; zJRHST()aJ=x$Qs9&2qrI2pL^18pD;N4pmC=tX}ym|I#;>?9L_})(T_gpLXNED%H;E z@dR+QkOjnVw|D@%II$0l<~%Sh&ab{0{j6z$mb3L{$@+60nBfyUJSOnb#$nUz8exV6 z>9b?iiT$putjv^L>Wp(6iJptPkvW^pL>zSZX?(%N#2_tt^%0uk5t11F{=&nfVe8x@ zyVk~KBVWI6rdl<%u}?c!IR?FjEufSW1Ev}yZGfTYAY{X7|JZ<6ma|%~FYoG@aq25zLK5+JI(fz{%a<9jEBL9I74R-NI z6Ef67L6e*Grr$r2aGI7_+-dgL>9x zaV?sS?Lt?PZS}-@aau(tVh&O;6ka}I)7Rs#w-k$WuyQmoVnGmKml%e5X^*VT7|&Oc ztNlqw@H8@sQE{u-o$e`fa9;fGE z*#MgBq89(%+}N{Cg*@JG(lp8?YB}t9Z9Tm*67;|!-c`Q;@ld2*oyUt~=$3D&@QrqJ zd((TIWewk1EA;*!6GEj$_`|Pl`0W84cT5eC#!4Fr3vVB$?toqtrkjeg5rEGEr!c1( z8F$4jj{rums=(f zs?XR68k{TTrM4^fhlXE-OlWUUm1G1s6vUoQ{VM@)Uk4g?tbNF^i_e}ly0Xo6_(GD{4b8e{RKY3$dF z{3AT6p}D@K4(p}ByZtB|n2cWd=hQ-Q<=|(5EV{f*mfmJ&5y2Y<2iF;WTYH^xqIylN zc&*}AYwX5?(@=jB`hoqy0O_D|fVA?(G*bLJLVN!=YeRvmOFEiQA-kEs_-$>E6x>l) z4!SC*ZheX zh|9vA?W2|sKc;rJuO@r05ToNH@aadbTP78s71!oMj$_H`;iZAF7-{?Lk;8FqA>$Oh zeXq;+ME8;uUqB+jv40}xFe)-?H^___oyEzvED@7X=yhKWk%f%7Rq-sqoh&b^`g7~k zuBe8DXVTJG0YC(s3kAS2Xi$T>A==!l7IYlOrQGnZA?|?lg zCMfQ{wrwG=h}>$d$zpkr3QC)WpIQ26K!v=sO&z7?6G_%sKq0}R8c?$a|Au&^6QW8! zkr4N1T7fJ|zP9M(yZ{d(KglylM zJCcjWE#CJb>yj)}4pJ`w__cj;=9Wq7D!U8wwigF-7(Xx!kz;@slxmau#MqY5_c`LL z`qc}TQ?JHRF5N<^9@&6iXi?urHslD?nuSoM2@xw4H=+FZ?3B(?md9deXJffn6Rk#a zf|wY>p?z)vOfHqa+KHAquDql}kC#>`EjOgPO~{8%98GRhgPG@%e!Lh^!Z~xRz&+Fh zU0K#|`zu6N?rh1M$GCFGGP#ruxt5@=q5%F(=affl$vbSM@BBzhT2G-ZT>8;Hd@4Y@ zOh!`rja9Pt@&SZaXoIgFAyszuF_b=DPI}(g3#qb*qO6IrEX=arBSHJOZ9?8Q1xYyz zDkxI?`@dqCb8C;>4oL&Z6R=>Bx$1pccE-+)aXVD-Z{@B;SFZ@?_?qO|?#eTya(TQo zrA!jHIRT6r*NB0ji4B?f^X&;}W@S6nZda@dOgq^^dK0XU8Az3eWYB zlM=%>Cm`*yUW{iy-l|oJM_59?D}UYHdU6@|IfW#S)>IG*Zg(Lv@aNpK@(F?GkPBxD zPaW`&V44-~Ifv96FOhC?(=*mRRM?Tl%Pp0WenW4FI4_gXbXUq}PjeFze`I!h&vU|& z;-vE8llGhNe0o|Xd6RBf)=OM@qCU}SBE>RbdNvn(#hXEA*TwUc9RWzz516fiDwE_PzHlD{m!j$kSQ z4OY@XmPVKB6ixw`(ku4E(rg|AT!xA>ZF}zgyI*Cr?Va&(FUv1A>)R{_o6uyV?EXEx z3^7VRnSL{hrKZPYQZ(|DVN=1cUpV9A5FAEO5}>qxt|m0`rxibxkK*kGcNm6B}HFqND6Z z^O{rnLhVR{g$=8BTwq0A-9LKjjmx!0^iYb&#cQ z-VN$|i{3}#1ErJ`_t|$0z(jIdq84@(&6u2ZZ<&TY3>|M02`W4brb9N0Z-VTs_ekp_ z%@43_{H9}|#)T*U9Q=EytEd&Xp{S0qrvRD8actt!um+hJK+sw zBG^^5tN9uh8bxy0aR*b&)+re;l23to5GV7l$22w{Mfx8~wB&yVnq-bc+{AxcC;=vK z+&sKa>C9)&_BKKYjiX+J%uypoY0G}XhSiL!2a*r!a5?tBagOBXh4t#j^j4Y1OJ|Xt zm)zD~5c!w2gRy^rQw#JlcKwTuJ*Z!7rty@X^2uV7oN>>xzEu(^d#bMd^}+hlo^r)4 z4?fEVs$+P)TU5(^eAF+=52=>?`KkuCAk(m;rvngi+|~h!eB4lz%Jw&oO-(~RhJLyY z1fn8~tB1f7J2|=H#D9NpJqxQfy9;}t&OOFS{yhZ}4vkIr^0FI6RlW)!r>~b+Tj_vo zB`Y-s`Aau*O!K3Gy2Z3X4_Hcp8}F1T3ZHU>RPuUyO`?#~!oD1{X$VixMwrcm{O;&lwb9?YH0tj{ZFJC3>~*G(ijMpwJ}?2=1vr&Coggqr}S`^ z)7%E2Tji&>1rtj1#YA@{7AyVZP}Q>#!uC0!6fE%7UA2Qq9O>#Mkhmt;8>6O`Uvsu5 z6>4RwRr&Y1*#Gb9Z0aos9qx884>@;kwDq45-}PdUa4f#sxLqf>rhCDa0x@J?rK<+pOZpgQXIIy%Gk#zR)1dw- z*{)@_B-!y!3oorSWpTuqQ&TT)3+@5l1~^>mZT{6MH4%p@iK<0raqXW~Q5+@*7CVk8 zOaEjU*5tNNMcjJ(3v`)r6>yj+sH5DmVJkK6ybG~Xtah0DGsOfQvQHYa@agMwr4ovM zWHv4^OX*rD(8C4IMdj)V&h|`LfNFQZA`aE~i7ov_-xila#YEWY%!8<2XQ==>q0-<0 z3K=U#aTZQe?{Qk>_I&jAb_%Zv=J5O!vo`%h*Hrg79UcnpNrbv;9sAnyeK;GW*4W_u zj1X9bj#~x4lJ0Cu3C%0G-@0PuLy;pAJUju)<6dYCC?<{PgYJrEIPsB^D6Y0Df1z`e zBLfvp2IdfwpBwTuN?=4!*Aa2KaIyK@3RzE#!Ewr)MYzNFtoIrxysCf7d-|M%o%_9> zz$nH=WOLuUEUQR_8j(0Wl|3p-Rc46sUTY4}2_`HuIrT|d^2C+hddgQCmgbL_N)u_J z9?ZlYT)YTAD>3po{?wOcRc4m~<+0d+j3*$D5+M!EmlG*Qt!r*yL;l;8R;?(?M+S47365=A!aoaI0!22+vfqY^Zo zaH|K!N`i}75CPXYFG4Ydix`*w=UMLx0AVb8n)FB{a8uAIG)u_Iptc7{ljO@d14f$K~D>*TdM#qT?513%R!Ul z#Z|U$uUDb_1FN$Tom$)@UA~{;1wsR{V}oB?Rd@(2>FLTj zH6PktmVmr2zHFg_nnckLdBR_=L%m(=D&cXv{ni^dm$k`@;9#nKsj{NRQuHS8#!Gta zM{a<2rn-h%bCccRRR3fC`C6UM7xw)E5CX$3 zFXNBmkKRj+F%vTp474&kyDe9P$cbVln{vrQl12}H!ZtR3;0){rJ5r-R<)T<7h~MvW zuIFr||Byr_qK;QB3S>Ys6$l~`U1D1P$=ZaAMJTUkf?Cn-b`T-@;dH0zSDdn3QVHFXNQ%0 z?6D?|a_y3PPgqm6%yPAPrOe&Vpcb$7!~Jl9Pa0J|I8GLtztqL}avjm{Z^+%kr47;w z+Hm|c5%JkwzVv>GR5O@Is^mTpJg(K6-#Wh>*SiQ<58%6%tB2eyG6>-do3VojP{2Tz zxK7#gUEJkbp8#BgpvIj*t)DPR{a~?(P4}IEbp%$y5v3BJUtf^E2AUyl^^L3iYZlqv>i+C&xqRzed>W^4p;n^ z%S#6F>$0+jq$Ew0eM_=@=96o)uYQm!7TIKg2j7QLA1x-r+$!|N*8!QT=kj;xUK&BB zoyUQg4iu{~&z9 zK565@_m7d&Cbz*VKDW=pZvf9q+fh54I7IvxWeC#} z?K%VKd|KO&?(ER z{VSRWxc{80j&vCGB<)X`b<@)Aex?NPFfE*cXkq4d9ksRhJH!4qMZf0`5kdUR4Z)8} z+L~jim5k~vVxx%r?N@~Dgt~f`(m5Wd9I_azx%7Mtc;Wzb_9V5f zJ@Rol9~AB_b>t{2RjU8f-HL(#a#J{UT1RguVBoQ2N8_J-zbxo&|)xTQ!r?%ORBg$#aT{wNnYs`V+butC2GaeWVC5IR$q|F;|R zOGS5CkMf_Weyi@xw~{%RK6sUn;*aD0dL+jgx7Vx#r4imZ3WiR?Vga_atOTcaGB3d3 zr0?IqiygAp0fQzC3@>#0IMC)=>jgVjOrm#Bs^Y)D+s2Z9H&pl%Uk9LhYdL+0;)iNf zorm!y%3d{q?O4yJ>mkEd4Ky10X5?GV~_U zq~8TzYqv>ItAK|`zJILfQ4>qw5;i>X_9npn!5OlvUn%#^p&nTs0WF6}PnkIJA5D@m zZYcZ%+Thi0pb?s1Eu_|=`ndn`H#vneL)%hIiw{vU8bDQ7M-S^Bmz;dn#_MgnvHml+ z-p-S5qql&X#R7d?+1dbn58)Z9*MIl0N6&Nb{oMA{s@Yen_<;2%lpQzF+Kj<0QsrNA zG&GI3_A&7?0Y!tf`GMsF#RF7)bOa9vT}NoeBeX)%UTssQ7p^!=xHvGR7*&MrPo9mNtPu;3}f7v@o>V3L+oWw0pM?j--0Oak1h9K z55yPXaK^*E%|CvmxohQUbhFknW8zJ8sf&7`3Y_6S5mzBb67Q5K5(#OD2Gu7<+D2tc z{QeY)VsLxOu)zP)OVrO8B$45;v;zs6NX@gDvw12IkQ#&?G&a45G?@T8&>#^#jg zga*;5g6j3a3yO&8{?y;4V(@=hgL*@!QBIXtv#SWmoWEvSgIwpe{pQ_A(F_d}9#xU# z0?)oyh(ufY$ppj8Lxh67hD9~?tYUO$?xQ+u$v|lTP*1lC+#T~A`m|yO1DPy{V}qJ0 z;RL9XH4~vt7`FqvL=`kzqu(MEEXY8v!vZ`U90ckumaIY^Dh>yN37-`h_C4C$5kU-- zbWoH!gQ0onaBi^!ke3`8PCTO}9*JVsw26yb2`(BUC#hsH(^nEBsDfz_pHvP$i}e<$ zh?AAgq{})vSa5W_dT~LG2KAjdzF|)h0#~ z0ofA!2RB?F9yK6IBSv2_Kom7SfB<=7ftMJ(9%H zCk>87N>mhV@vV}}KN)Z>{sixR^z^rnCN*nr3yDOdPdr@-oj2fKBK;!VZ&<9kAT3Mn z6ceD$o0taZJUJ=Mb>02i%+ifK3!^70xjSuG-ctd}74`~9ZN|9SZkVxxT!-L#3pVs+`ooq?hQqQEizqJAFtq`*Kz5~pxm_dd;jXNIp1RBu%Z?a>FvV>9 zgRq-@NbCb+BEz))%Gz4o-X6i>JZrx2hh{av!VxDIC$Ya*YTVuIR_%7N;5F%Q-08y$ z-8|kr$B1gx!zo z$Ypi&dvv>(qb@tOp+!=81JLlB8$KRh-d;yO#r?vgyZU8vxwsi>L&|ECw+6ywdN!6Z znE(GyDYCCpXsSrkE<$t)AFzmG6`1)Jl%E*ZiULhNBU&bR1EA_JnnIrN>uEAF^zOTK zYC}{}#Vv-WHslWhV;mK)HR|PpdXYny)*r2hs0D@JJ`i10;)+BLQezhLr8a}^Dm9LS zEB}$E#NUSG*|(mfS!EeR#ieraatC!PwYz{5Uq2sLdbbTYEIWFmaSqYA>6wuZ~@F3T1 zR5Oz@B79VbGlSpTHv7nNnj9mn3O_UIR3dVF)n%0OQ|kmNcV0i94>ytMeaY+t5=Amv zaA3eZVx;k?iK4@B<(4P%XV0_`A`U$N*^}`sZJ2N9ow4`wS(5RhvXY{SK|$h4X(~`= zJ_tLUYBWp@`&C$s^7tBnm;daKAQs|D3%5jCCb6`r)*v$=Jj#(*U0rQ!Z!cqLm@P8< zNsk62dg1_*L8K(FoDLQ&cEES4zH2M}(xoc3SzURlRNU)S2^alM_=V=`lK>U|Y3h9* zU-yW>swLCd1HIcnXL(qhCIb(9Q95J~*F-wvUBvlfwMYT4UjM*`vmrLvh_Xrwb$U`r zq4Z4iiYG@+-b^>h>&PFsIx zZxrx=&^X@SnW`PY!l9QOWpY%86fKFupjULDDAtX4B2MqOwk?_CfHMx%;8u+MS8v=X zF*X?wD;C`$H95c>+Udl0X@O9@bYW(}f~AthFV7m2WM}O?9Y=7r4jY#G;+0`uY6}<{ z&bO6|0tX{)3>sZPJVzCwa0>aqD78(?YV4_Rzri;bG+TQi#T_Lk6gElu7Z4UXZ+X@o zKay++_|n_Hty&z3Te0llr_YuH_5tq^u#oX_oqWwVCj-e12|z;Nn)ah5D=IlgD9*i_ zPs19mm#Mo-Sck=s(L%%xeYU4@*KzUzRa5h_dO*wDA7>N;qsR;9Fx+gn@(lq4hvgI# zevlZAP;jSk{GcP1TPMrb#f~ikeHkP7-gk_{ZkcTS;VjZQ7Ad?_c%j25UTZyr0jS#j zFI9LiZVud3Tvos670HgWCKB797xUcT7Wup6u6)~%Uu@PFVKcFOMV3`NuSCB)PK;fA zHRsGyZTvY&10@A*s~!XAW@cD@UVw4k67-#bYqx$+qygF1_GU+o<8?>=%3DSVQDk|y z8CjHLj5Nd)ULC@gD8OGF5E?;x`c~mvZPOCR&Wh3iW>oU)sx(6_|8q<^a4g6X+$;oN-Fp9BN2;? z16G1bVv6)o${4{9#C4+-sEr!m+JAPuH~gvk`xeOfP@7pN0;60#mG$)c#{QBI-b zaZAo374#W(-93kp(?ls4o73dHk-s4W%frr-tdvvL3jw=l8~;s195%*mpZ z;0v(MLBQ1KkEsTd`zRDM&gL`zWOeWnhe9-Gc*0NNXPKORLTm6W{zCyKSVCz-`uoY-b)Z2nOf z9AiHdZ>#OVZPiOm9ixEJTjm$sS<#)xna_a|5Rdyj|CHAh45PO~t^=h5R93z?Xl|o2 ze}|+Hn7wt2x{9&Avk`_D@&`_vF}LoPxCGfdG6bdYD#$P*9q3}^G83!;y{VEO9CW-0 z)6l4_tv#6ze_u-084n<%``xF>xO$PI7r4q1L@&lKnAc&EF-@dBgRw4FE1)))MiKax zgafXYO_-!EbgeEaredz}e&X8WipZ zK*AX+JRj7PLijBaC0$nku3-{MVtZ?g!*U4C$Y<5-ZjZkkxa{1nESAsbL{h4h`7XRS zG%Jhbp7K+Qz#E0PM+Xu^En0qH9>r+%vYYvWiYmlUbJl|7Uo`!qbC?s#yRo^WEUx|0 zVikKh4%27`$LT8(mmMn4?f$yK^ri4P_420Q3|=~#k?J87@Wte&vxMwPFE_T8>%^VJ zT8)=4nX;%lV;_zKA4sRC83sN_!5(Z|XJww|UmH6qyvR@SCGh-XBze?0F@6vZ(U6os z1h5L_zE$J2C!AUL=R6m5SrfS@pad7^;f#4IDk|Zjv3w}{l{Gd~9@B>rqPNItv z^#TQWX=YW6P=L{n4g@k?27ST^y-{r?#Q1C|DQq9l*D~`F3;m-IQxg#KjnLY<7wWpv zKVt#IriuCpCz~&@^y53{;hmE#<1fDr^jNGGTlP-0h2)S4PUNqs6K@fSso!N4#P>>1 z(|636fK3X!;2?iM01tyG8t`DsidyWnA5YZyL7x!|Asap+Dt8Z$-Os9=Ev?S0LRz}I zm6K{;zkc1=ie^tkmLFV5NlDqrw8=~CE^T&ulLGknDGwpFMJSN^&-1LVhY=d}?ayE| z;aH{EV8Q<7?pQnd6rO2vdO8DUMATft{r!EX*gvCh)oA{GKrgZX8=83Li6kMtwPLc4 z0D&jerV2j$?xyPQq%?gyK4HqMw;aasW1q_8wiyiw55C_`hZc2)2ZZ8a|NFpP5bQAj z_k~c;n>TY6!zNzv(W7=QgQKc$SM*47!|{~t>jSO)`wPH@meaN)NacTL{J*#H5e&X> z1%f`OMuJ||asfxmX!cQ%mhPur_T6j&LME3^LCw9Wg-c#Jh5rrt&)=Qu1!Rdbc)cM!9wHb8IWZrP@w}N?^ zw>U2h)+!}||JjrOy#j$r&g7$ZXTB$m3u;AHT;@ic>VN2e`slJn53csy=8Yn5$il*g~g>Ah*kSxh6LYRlFg^6e!0AF-u%|SXFij_lL0FE zVE?yyZ@hc61gwz4fU=sR9X5G6p>JZshonEsAKKbP79jr2P4Hh}gMJomeGB~$>#fd1+q>`mk{JOSlye z#~HWpFG7=iK;L&e0)mbkh9{`d;jL&PF`d1Vpyy~@42tgN+Wu=;;QF_6Ss29ZpF4dm^NHL32;SX?jioSH2T^|5&qquy`N!pz6|;G*TI{u} z{d~1Oe>g46_Urf~O0bZopFhVh=Waw@3^@PSK1++&OQ)~z#g*Puc7WU1>e*(wWaOVQ z=N>Pzw{$e9F?MVOYy5=z)7HlUM`9}<2es)YUf+p7OmzA>E5_pNU+q6+7~%LDGB9dn zx{u*!PVqYTQSPk+AM<=ECPm%YojY%x@brrpx`V|aGm!wAEEJEckcd`LaPt}E-Mx=X zzi3T{JMO8U^9Os+%nXn9FMnX_!yj7mNK%Mfjt)&Xo5qHzTQ{k6z$*yeMOZM^R-e7? zwBHvJySly)d)enjkB|)aTc?&oUCNE}@_;{+!?|5Zq}iw!X|iPgShs<%NGn$l!5O=E zUaxi#eYSpb{=8V>?hFK&P;WH|0c- znE3cJ?{yW<@>a{?I5uSdK?gwR=f;2t9Q7Se7hi(2lLk3#8$5awnwps5okaPWI;3{- zN7OtN{6CAZ*Ozdo@ldzE){JTsbeW*(bl>NS_VZ4c)d*A8wNU%Whd0>R>hY;&_ll-+ z;~Z3WD?CcL>DF=5HRZ~bYheqWvni=nJ*GO8sVXy^hZgsLKWB1V#b}v>drL!Jm+L!N z?~(b)lj1ZGxc41*;U>uI(^095c_{>~?l=&)TYoQCqv<_M@U57){CHaN)t*_Nf1_~j zve4(YuQW39Rtn<_Ea#awv8f$EcGSV_EWiiriUk0pyHyb3!ss_!!nEgyaTPyBaHk>DZN&n+`Ls>_^pOT(ifNABtw6K;4r6EmrE zlE7e9Y!j=)hK*S8uR$y*{ZD0qY>3q8^7e3iB^(NMMO^X1k!$Wxm!ucSX9k;sPkj|a z>ai*VQ*K?QIQSNG%VTv{K<>(pIHvYK|0Q96rMm>gEHk}bpQ(#O&_ElnRy$4Jzcy;8FP0Ihlk;Dp!*RQ{Lc z+u*D{e7%<>JfHRDxSteNd)JOf?``$~)b7aR6*Ch75d^taNiRx+1)HNmG*M>IugHp< zGEd7sRDDsq?254N+uBZsZzJt+!KMkkYxb#aO8M6=EcwlHs8lI3Eyv;i7^QRh@fu7H zmUsHg8##b6_>K8XEDoUH?032y@7b4c*FmO1K8S;eiNA<=+$vquO8%grvb4h}5v zzE&3S+O>4m@zbGdNR;qd2X1R?S2ADpe~Umn;JWCSQ4Y6|u@GO;XXB~o=||JT8S{a= z4m#gmV7u$?z}MZk`iOj8?Px9?CZU~Bd^nQh9`}U#R!AlDK)z6TtlY5a94BX49j0&T zh8RXYWwS|?dQ*A2eA7z%)E_{~4EZ2BC+(NF&Q#$pK&#Q6Br9B5aureMTm}s!{bfiagd* zrK7pD@g&$;$<^p!Ok%%N`-SwHvNc7@5-`Q>(1wbeB7yhx(YV{m7I$w#n6ScjU;-?r z3C8vU|0_MAyFaxncX(R-{QRKWsx&3lL=ZgwkVB`zg{TEAFr7&fOpUWcw~H zquQt*pGB8xLHcKTq^Vx4Wi>roZt$nzI!{5dmvc(rdtm>+;g+O zOrw452@7%%kC-82>Af_4C3sylMkrS8$vG1bTX=n@UVDAi*jeX8w*1n_UuH*encqQC zqy}V9do~VYmy&`s+SYL>XvAKwULtB!q*dL$&-Y(RqZSW+&VFw6`a;JSck&S=XQTEG z`{&s0h-_I$$(q{%Zbv5Nh?vg{v_eWMSk6rj4Ruc2KTc!fkLf%UMo=5%_Aah@2Y7XU zWfKA*MhUfAe=x}}&d$F5c-qB*ve$QeKAH}d2EDn4>ozqtHL9}{CXK}h#UGD-AJ|9u zO~bPnjD2#Syta5>uJT{Yb>ZHA?hnIG)Y02@-}lYA=_s<}3%;;v@z2@4;GJ2Ui)2!l zp|BE4v*&5lh9ivx?q}wwyWh>{r&m5^_T@rx@MG7O07r9h6j8>KX8HSB*IY^ILtM}U zvPhTFY!>&~(66WayNT-fZ5X?EQN!A|j4G6j1wX&V41U#l+Gz!+Jg0VKu<&o540aF1JGWu*NA*s54Nrl_`Ub^=h;CJM@;#T_ z-R6qox6^=}8Pq%s##^WP&zHAv0bl9_eb+Uh$k9KGUpQ2hl! zJ`wawYcqil<3v9mf9y3*eCPGeRmhV_7j#hKYnDGU0eepPpPOgjtKPD6{ewzF$mI90 zZ?v!wGCmNpc~-wS?(nS>sb#u(y{4}L4i9+bu!s*XJQ$EGNNrZ3!GE_TFn}o9)F1+L zKFwdJubyoHy?K1NdOf4q#8m@HlCtB9_c%$xVzxoBW!mz+7IJRVrw9Om@oN_9`b>(| z%n5M+Vo12Mwtc3)k@t{PL*IKDy@f-uvmgmsGQWc~zM3^Xs>bn8n|0a)Kmm+t5f+b9 ze@Qv4%Kk?JHYC2eIY`>mM2W4gidVRkva%Z4TNIXQO>AZ;D_It;GpRCpcm45xQEl6& zjEyD=OS&X=v`2FOpnyIQ*+A6`<>#6_TxEYtF2@<}?Z=WBdY#CEBMm-`Pl2eDoiD0* z$2HfpGIP{I84@YkkqngWZ!KMk&O~oWS@)kzQNN5JNg#5D-ot&ut#C{+2`#OZoFzE@ zUjAVI%Qb_@-A4GOa!#}Z-0vg1FuLF+d-@0+{>47fe0iDRGmC%T$~a^cVc?gg&dkLy zs;j1@!?Zq`c`!FtHJZgmb~sbl`kAc{e(1h9Z*`o}u)B!WgwsUQzmo&+NI^A zlx&q0vX1YQ9>r((;MAGOSPnIaKhaal@H(SB@7X2hAnf`P8PfjF@e%HTulxkx_P-;i z|MNoOFZ{VRGTbV`kiFHW*XD@M0X2dpmaqgtXfUp`L9QAJ9Yy6uO#o_BKI3rkL4ow~6paNB&+G5D3Jq?>ox> zTddQ2d7d|pEIspF6>rGgnNHiTj#cWhmFw9Ci?t4mFR+@NG;5qpn+bVm+#vjfG?VR# z2?6-QTsA45Gk{#vpi(1R8XDBP`1#W?Vi~1YXX+aGeb%Yb9f!2VMF_IDHQH?EpPDFZ z-=J`Fh=-)<-rMv+C`}`;aEieKPrPC?j*dxi4NK7?^MLfY*7uCbx)1lt)D!-kb^p-T z5SHSH`ioqQDJE8#`26mq(2NA)3Lo>`E4VgQ_nWj{T#D;0wqAr)o_3+RA6e~_v>33z zu6{$%z-98nwflOUu=Gp5<@}U^GeoH@PybJw85vFqcjUI`RstTd3BNb&{hyp} zthK8MWzDlb72n&ZX>1ET72=-MlM@YRiacX~ZhD3T zGY8he#BG>636Z4&hKzMt4}buV%`o&w%@dNwX8XqE-CPH&)G~>>|D6D|dd5l;H6s4^ zXN?AQ{K~wcRmG>0_h?(9IM~xYNzL!`*SrbryL{1_S=T@&$5Ew@?s{roRsZ0B+VU4c ziv2B}#zfL|IeFgRp58ZS?U5Q{ag<`osL}Q2LVugnA_3c$Z6N!0zkTNMYmg16$y4vw z4Ct+;bgv5JZ|V_+0Y=frYOL8hexjkKrl_ZXxc?-78fdkntE>oXHA8mYRV`nDq<?vVO-w`;RWxJmR-75oz2~ zlF>^@Kh(m$vU17pm<^m`k5F(Cg=-dregzWhbTtq~zfkLJ-Qf-de53(=vl``h9TN;U zV|&3l1G8(gdrQN~fHsm5rir-RIou;+2WkuTi9`gjA4=Vi4eq(}{?8(}$jIHSa{0M^ z6UVobm4BoyWt7`_U9UZG>~J^bTVKt8-u{z&M)!Wt`+Gz`yB%ZP*ldt?NyKO7qsL}< z8t1;xcTjjgBV)mah+6_z&p!M3?^fBB^QJNf#O3o3dTOrgJ0bZntDUEdeUjJ3{Q19JujldCi0=xiOu40~Z@6p7H3h%oaNK zY?;EYpBC5leo~oNw?9Iw6gbYBaiHY&LdzEG5L&#(T>MGPht zGFGbKVPGi1l`g}8BCx0~nE^PS96INd-~7BwvQPKDZh?(#f@!4-2c#LEGN{8wQ$cj# zep3VB8G_9V?)J76ErASCLp5n!;(1}~uvh3IidzC(q<1hcShvyttBbMND@&bKcRufN zLmA_Jm~nu&p^7KPt9;Ah*)mU5kloys!(70cQQny!yLiz&3oDetVUcfa_ZU{#Ojs#- zwq$OZ+`}g`P+giLIitG4t@Hog!?Wv-J21;I_I7c7=tQwvB#613Kj7sNQ;u7ie=c2b zShhYJRo;&+fh)%F%}UubA?N1SSMe1WU6_m#|v{#En3W* zk#D|vp%2(YB55wxzFV%l>|Se~a~o>J@_E2DiGq)-nOAL{K53TP-=$0UZ~L>qXv+CH z?mrd&YZk{{zvNl|wrqA)Kg2DES~C=^nR1?XZJT>GE%ZIal)xP?Ja4Zve(;~UO<~>& Tm;Zjx8Gyjk)z4*}Q$iB}Qn@0J literal 0 HcmV?d00001 diff --git a/images/dashboard-solidfire-cluster.png b/images/dashboard-solidfire-cluster.png new file mode 100644 index 0000000000000000000000000000000000000000..37cff823259adad9b7c760e99c616ec14f684898 GIT binary patch literal 156810 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

i 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 z z_JR3g|FT>+QgHyky+HT^R`yUbrY&S&D_|cQNwMg@mvPsS^GbIY>p4xI=gQSuH# zo~-FhcJb+UlDHWZ`S=(P)wI{RhXuO?D5++J`*daS+8aDI6N7(C!?HLuGyd3}Vf(f| zoHTK{lim|t!?0?ntzE};uD!qIHrH@bFS(Yie|uRcFgN$(?{G$jX` zL-eb%WV4g-*Hk&30tg|QTaU}FWyt0EQ+q9&oq3s}!6GM*hMpOoHD2kf3QvgvL2$CF zMT1-p;7H}iEuYyBJd+zHpmmNkmy}Oqd3*!6lgd0exqQ5eyCySu&Lp2*R)QzFM1ezz zeCKMDhZq_2@ABwWl1@l_=P7fH!ozw^oMO<;59vi|iv1_~)@$>M>MmP4pT2>h_P|Ki z6az}i?UkK^g`FXI_J;%iPDq9DNL-wc^W4=hq{V^7m!03g5pSM_=~ubh^XSSqW~mry z@JeO3XB1d9^fs=q**Cd`R_`+;))1pJ8&mPlcbs?#+|#j)34fS;$Bs?%`Y0cT*ibEK zcH-#b^yer?+jsAbV4Df^gx~Ti11Y8BRd3tA=4Tj5x*=q`5SODjj)aUuvfY~QTRDI2 zx8Gq&Jg1~A;*BeaNQ{*#pFMcCl%J9Aph zQr@Btw?WZPNoSxe>XEKyuL<{#XmvN-Cf+7J$4f)-nZL$W3skSi<-KA#-k95X{`r9L z6pf=#`4R?CAGKWQhaNs$K(;+Z%*+6rT|#5HpN;IZOX?4GYaZe97JRxN8)Z>tMI*;w zC`T?+-Q14OPH4wZl(#HmTGZ)Hf~tNozq90eEO+PHCapyeMhvU>*ynVP`)mno--SG} zc2lzDJNc}B1f$kh{wF7;LaqjkC{Mp_p$PBb&|mv2!Yel2wB9ZQ^(QzNC*j^z=6iu) zCJ8cTicRyqK|Z+<@*Z&36PN~5T)wHwL+{vC(_WdwOY>PkzDzYOT3_ee)qm=-G|)g) zW2(B9&f7B7OZCq2rctya806lTUU)Mr$z3Jff-`{ptuF4!VJ#b{_p?hYi{j9`zx&Hf zN5(FEP_qnIzb5>mebp4}0zbl31jqqL;Fw+OoY9n};^mK*54fKss89=|zQj-J;o?i@ zeYI~|Q<@GA`DL{;`$*wg7@(K_Rm<{+d#w-tR6zanOtC0eO!#Ha7}~SzDuIl@VNOKt zkr>I{y{B(%xG!6{ zlBu8NJfQ&3V+74cckD37-15ESkKZ$eUWRc&o*>xk#B^?a-m(7E3hDm%ZlmyI=``1?;#MT`l4i1<(y#gSzSDv_dT=-Tj`nuy{7N7f3JI81s$dp}kM>ekhgE954(F0i>C4|xbJXXC)P?8FsaJ2sS-F@a0m?*lbQIS`@k-wh3Ffdn@EmVI#Br zv*y%+Y^$bk7MMM;VFw^-_p6#WqR*~Q}vPpn0huaIw(e;K&uI$f95 z=f^tKd>0gCv@OVJx=gHNWe&XPe{85gQ8VNTCHjF|!OrF;{S7Aj<}*mL3wN9ihEwFD ztSZE?RA2gEgA1lP%IZR?MHj5P*@9#3aB35fnC7J!bW3c~n_h;q>_D(&4WYBT#8t z20gg@8tja{NZ}ST+Ia7E?uEc$q{(ZSA8;mw<&im+j`z(lG$BMMVrFo_zqSf)rgax^ zEj(U}x}9?uxyA%}U_Gbe!^1(J#76x{I6k5wN2K*UURs}H^a;{yQX(0{#s;2*Fetz6 zEt>dS=^<0>(3~QyJ2?6_x@m&5E1?%0A&((wg$OgbS!abp@$3^vU2_Xra^)d7GW9+_ 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 b-LVhz2;Y_a!?d*r2i#;oD@j&~8-M>FeVP=g literal 0 HcmV?d00001 diff --git a/images/dashboard-solidfire-volume-min-to-max-histogram.png b/images/dashboard-solidfire-volume-min-to-max-histogram.png new file mode 100644 index 0000000000000000000000000000000000000000..1ffbeae9d669065b9054060462ed665dbf8c616c GIT binary patch literal 96371 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 z zp!?C!^6j92?=}NEDNnzYNzriJB#r>^WxEE869+wmYZLs&vdk7qL=&7f_pm-E!A?nE zbun^4gh~qm^d*t4w959RtpVPu*4%9h{Sq%Npr`s3J3d< zwmpoC)*8ZLD$;{RX;m#qJ1Qg6{Qt^wDMpBDVTPZWYvyK9lAc^&gzH9r=eh~&!JKy1 zilCq^U`y^uyHNt3KXgVme+Hc*)N6=xRl*0KQ3tVT?p{NjNR(ekXo@yegZ-X}-Rv1d zLYtnJlZzhuQ_hT!hnAWVpayjQeUl5!CglAM?KsG;=pGUGEXi6!t&?|jj%|uCgV~dx z3q5aM*61Yyd(k3lQ?zZwTXM7X?Ms8N#tfTnp8cqbLtSiKLTd!lBdtViN3X4E9Y8Ql zlk9)zCZTV`DN6SpSi0fmo*dQcrr=`QMaI=nr@ ziT#H6Ep_ghVOeKI=33fyqD84C1*O73)eB@Em#`CQ$AK^ZEXB5#x-PPf3`Z{yXgT;v zU&dp&wm+_)Z{Njq&OddIleHB4=8xuWh4C1pVo zglQBLTJjhjj%xRw4$jtW3pV|hLjbn@nMEMmVe+@)F;I!W^b%Zm2l~%bkEz0{Yc@0e zfx^zo)wh@D@q|n%a_Jf2CU|L+x@cyQn@aaM1&!in&T>(+p znI?3mdR4^sDsE*$7e0ALTKk`9l$7=hvhN?z?zo-?*{5{yR#=E>eo{cVB3u z1$BMXS7nwIIT68p&4`9jqe$tZ--b31y~8B7r22?&<*ZeIQ*lcrw_=$}JG*@m{f1&_ zpz{vel+@7L6mGQEj>SF8B6|DVEThUW^Gh!dhqE1JCzJj%Cr&A6oV1KP z&YUx9$hKKu>5!JKGcSWxrr@ZXFJfe9TFtV92@|y=ZA?dC+)j-DbWn65E$mPaTA2)7 z)GKrAv2)={)wElc-$aK+#hfzK6um(}wZlQ??ehJ{Okr^~iC1>SqPna+05szC90XHP zHQ~AY_%uDeE931*oM)%v5?GN$>2OY07kVa&j5`BY$$5<($y)VY_{gRn7!ar)mj|i%bWLy1% zeo&`%5nSJYNjFeGJAP5bkXSukDGZwG@1LVT+8H%e$A%tKVCBQ_m(6A?h}{y4LiF?h z-3fs!qZU?DLLNeh0Uo`_ZS8=+yGv>G4#=6uqrT3G>Ccc-jZphEM492!kugvq{wSrS zVUgOp;OXBDgLXc*8(?3Ee@;Es;o}P_(T@N6W%tK|@O9=#B#aOi`0QqE-)rhn&F+Za60@s^>)% zschY&n1GAZvu(aT=9%GsGMdDFzbD~yW5n7hX7#d;i!)``bg3QVZ~+o7`#}Cl#>F}b zAx`63iSho|8h`AJ?ZcF5=^1t`|tM?+ts(O=g(Oo{qUl$k1JobIr=2>^#T8_Q0 zom0~hE;-~rI0pIrd84bnkwXEyHFO*Z6o(5qbfJouDRwWDR7p$8j#`0(|RJ_1>W#C1qxZj^&^S;U%KC%~-)tg{- z&^~%MyxwzVKl?3Pek9vCdqOjAv^0v|iFn8yE<_Ib;XwY)2YRsj zf{b+;El7S0*2@Sq%QWKmxs#qPucQD6jg}YAv1V3`=a5HKJ%y+#%YHZblzSCy|2JJO zKsL3f&X1kDSK+m_)Uj7{lxLov86u|MvbTWeE$ z!;o+yJXw>IYLzM#D%39R^#m)0gC>B#|M$SKz)(O7w=EvrD93V$vu1n)b)YyWX1Zn2 zDLHX=Xm9Xfi03i-9n(}j&=5spHDhJq?t|Vm?4aj$?dv7iUTIh~)W>bbe0Fq%8H}Y~wE070aZ_%(h0E1QgE|mR` zIj2!?_O%9wkS^%<*J0|mN|VdW1n)?G1ctJVU#)QGMYI1Pr+{ekYdTfzVimOtA28JY zJ^Re#u<1d++^k1$x@Ogr`k=?6vEXqY{2imya2D&URvYFgz-0A|zN!m>m!WX*ltP0* zvUDK{|r(_Nv5f!Qy9=%Tk9g=SpgL!~=NK@G^92)yoWDV!Kaw*9p#c ze2aZ^>}5aA-&3~=&kA;{iL3K(!~5=dxS|haM5KK&^Ti|)i#VA4t-I$?KF;tN<1^H= z7BY|-k<#0ulQInq0m5gPK;<|QFb<{GS&lVjytbTxKRI;RTwmwNG$=$=`tW!m0i@)b`So=6f8x! zj~pVgiNj8-5A5qU`NUj9rEBpcZBUwm% zF-K;D3rh5H%CXa$X=3C85wc7%p{Z>uOQHaVn@y*Ij890#5Jn<1C5!1*M+(~Y6y zy%*&^DMZK98@|l^>#rJOfBuaD!`-5F1FM6RmjensE7rjwzh1qbZTj1tgxUsOX_ zGzGYnbi4gcEQ3C~u3+V94LN#7b)e7NC?CkjjB5}?JteD)1+1*Twuhf9FZbl>F>mG+ zwY|5DthSX+v7?IdQ9^{JEn8Oh^@9)E-^kfDTYVnH~&2btt9dCT$o)0eWz5wd6KY2(gW z7j%+y{nu8;Lc*;P33GTMEZ1m6#n1hTGVyg(|CcKA@W3!MJrNR4Z z0y8-0l-MlLPhZLrxBg8wuio|7#;Wi3!vTy0=o{#iT{1Sa6@~|$zDVR8$+Ty_My1n( zHvdYk#yKV&WQdOaeSOMdJYJ^2YWd)_y6|(7OvR$6`$p6u3*+*=eziYTN6g(vYSWpC zrxp{Xa8`dMoZn_{zWVvQsA;E|IY$qe+=c120{kRr?rT^tiZZXoEcGSP!rQbIIKxri3%3;L;fxF-z3I#0gM5Kw`7$&HIS6 zwX!OBroSu$XE(pCwE0Hg*!_!I_&5C%6pA+m^tFeCPDKw4+hhsnO09XpOy=67&YBBR zPH?2+*T9#CVTnCw5+@XMioK8QrH7t5TwlhJjawlA9wVPif9@7>>$F` zaNY`zXw1Kt@^)Eywf`0#16c;>q#&OYCBvV5ALDKWk1+)*OCKMuA2(d%n3fzhi`fO6 zalHZVaz*BFTf=~m$*N()9>inFPpD~EpBPB9?r}r!Z2zcE^Hd8adRNXGP3yM{H*9lK zHr<$LS5_Wsm2$xvf!N#ec7#BISnt`3o~2h79sLpG;7#zN%Akqp!CYUzvu8k~WA zkJMR!ApgpUikvj{7F%MX`bxw&)GXGAL3_>JXJa${g%HeH}Y)qXZD)Q(uT)WLH zQYgdsmRDPY*DIv%+RZ8Nh`v_ z3`fV_3;DO-?eMj1ARA-==UYR;#%YDsl&0Q5Rpvs?I?j>p`$CUl>w^WCW+@?S_QGmV z(P~ADZ3iV^j@I6ba(I^Nx9PWOgU7wK@@p51gOxK!4jrdjPQw=sSH)s#!C>p#1b3Nv zrks_{)l7BewmseMiIod{TU*!OqhTeRa&7HujrNGqeI!}|*(ZGLK%JWoy`(PNT+YqN zVZ*15j{;+Bt-zt|lLC0kWFr9mVmi|u27+wS#^!4L^99B0T_=%aR}5^k#eaXi+rhlz z-h`c1uis!{S04oOfPh7-UxJ*0l{SQcmi#UvEkNKI5I%5VYe$&Eaq;=}F=kh2KOMa5 zHx5@47X>Tvrv|HW?FRFZ*)D<5mw{-!1>YFs!U~mtT=ggm%)XZ4~uQPAmYtN34YNRLE z&}_AGzQG4FJ*y!LHGX!!Je-|;#YKoMi8!clf{;PG5;7IeN^Y^yn#>_h43_TKrSsIH`)dEV6KE z)2z8QiK}(qutR_!AyCp!JU_7G4v3`I-j+Z(lO~)8F)z`et0gck z^E7)J2TpSORrDKL#f(d>Zq>c*9BY6>$ zIpz-;V0^Pjfxg!*8A3^Y#OwjYz)(9`2%?U7rZ2H6Z4_MyXD8wx=nU~Inxefv_Cv2P zPp8J5ydQ|Gyf3aALmpml1Pu$?SoN-zfGd#Vq7OAXU3;0Ye0`R~I=TV{zHs*b9z8t) zENdfbGhBtMLrDNuDu6ScmM8XHmlLoI1(Sp$fWZm-+T` z)?%X{wy+79-=ke|hOf7+?VK_uQ zOml4YIvXYcFdasAN2?!fFFQF5o(Q@9Mr_-3cho+WR<}A+Z87ln`z@MzdJJCh_0h`F z2O}+h8Se5VSmP{@;ivmaW=@)_Z>xrfGkMcS$8x`g`bdE$K^5$VU7fsZ{zD-=ht=r<+2Ku<P>gCP$DH1KR-vEML$>(%TPsCZe8`wdcEnlm~5GQ)GV@fLVOesA}=BVz-cuclRMKtxn!9T?UTj zcgCbREo4J;yTksVj|-B%4}&3r@JsPjZ;#!-lQo6sa8}H-@r!K5d=8KsY(;~V;xMkB zA}*&&iJBLqy}+lGnbxu?KHp}Qv6(Wtzo_+Cg*&7=cn`f^i60t$gr5dFzYhF+6ZT_! z$Z10j?Wt1eQb)bIQin80KBe&wz0^xV(u2njVVAX!a2MHTEukzaSJZiptSGk|Kso6$ ziI~dKML#C!dR^xfMtee%=qSqXDGAkfpBve^c z-Ms96Do04W6qB2mws!17H;pT!8nuR4AVy6pwrb&)rpJiKz)zxH&=K+QWVp^MHvlvu z9x(3i@spN;ezjmv3bCz;?B;m6%IM5d&h3|ujI(7wTJ{iQ35a&f&}7CnLqlG92{#Yg zOY*fR?dQXHJhBpcR*2U~aY^USjqS_1{350E=&!VwTn zb>jdHSO#vUvZ?#4Bb1agkQr^R9`DHBe?0+7dbV#LUAc#I=HuwIEit~N5@47@GNR0{ z15f>gdu3};OuV5e(Nsp~agEB#keV+_)=TS-sJyl_xCfF-Pv0_<##QD@NRn^~A6`X4 zt|GX^1*WNgUjD}NT_6JnDY(m0nYw* z5*N>L1ju7FrSASY=5b*QmDlP%=$Smv0Ac<-3t9<`0z_nA%t`4Yvj*MTBFYG}@!dPDiuEgD#y(r7hss%xCK3B|Jk6je8$ty9e5 zCot7daD{r!{n?881XvNnVj9xn0ZLCsyr2cmE5*v-G=$=S8r?^;F6GCt{$xfP&7))B z1?@>pwXx|E%Gn+DesCY8X=ngYJX{9g@o@zF_#ol%5q&u+6ERi9H6~;2Y_K&uwS(qo zp@=zTtt9GG?VVK`yT%ixIGyfc3sCDukWppjctop9n#0i$)6fokTtpPJ(U4S-hXU!k zCLg`w6g(Sejo+FWa@(`lDN9>1+6FE`@&iRAT_WeW52ALe&ia1#?*`DK5f+3T$)(SKo*(NeE>3gf>X$AQru4+lH%ZsvR0E`U$q~R5}x(i zZw7oOXh#K})C~M}sZ~DphIq^hn0V8kad?7ndZ;Knm;J~oK#p&03g7cB8;9OIS5*#a zzH^9FuPX(osp=zQg+|+~>|2t&&FOEEtMw1^>6i-Awuum1Ei(1Asp+~GG}=ZLh4occ zePG;sP-R;XLeFcl0gX0#l)wcAvmS2)Mv-~3Cm2;rJC1+rm!FkH-(j|~$`E-b9ZB&L z&)wqdHkCW`)$kcH+Nge8rPjg#qsjX#fE5M)jj)zdoWU8^7>@R(2jKlhQl?r0I(*4} zqj8dkCmRszoxA^LDPblXEOHx@uWq{HyR1EOStpBn3xh$*Q5Fq@+)~=%h93CenLZ?6>dVsmx z7Cza?d!m~6!*>Pkic%Cd3#+d91k%eeTR%=-;9BD+FzJaOF?U8owZBN+jx9Plf@q@X z(w@Yc=Qxzg448$;QtoEAEdh)TNXz)@cv}3Dq?-CiCK5q1nvqe=W{K?i^F!A zIc=Q4{8M`Am+9*vh!QZo`#&+ghI;^me<)00=XrKd0M`FcNN-$%>(E!75gmc?yv9uD zn7$&@)V-wH0tO8kNoU~cmid&PTQfgqMBYQt0;`cv{`jnSy}XuQbp0IGH6L3*tFB7@ zO7``K9=OE3dNDQlnrDTS6M4E;Trc^M8K1`OxyM5dKwjAn!{qoPu`!Ad@6JR)K zOCDyK8sy0vMZ#tR*a+c+KbbM4Z(fOyIe6sFV7;?~(qn6bS z;A@tkk@{Om$46`UpASS+b#M7$2mv_A|0Ze&{T}YE?S>?`;WESqI*2rH}v|`X;n6D$F+f4U5cYvEfdB&9+6}| z?i>2@_CC?HkhIEij-V6?3Na0`p!cP@^7*10>4?#a-q26)s~Oqi(aw~V=$Wku&z5aiu9y~ab~{@TaYu8lJuluTmq#@ zoZX}eb`@@5S>l-#7%2U(KMrW7NaW$I7S58CP)+M8aEgtLk-$;UsRj~xvl1~OyO#k zkLUu0R?o8qDla~m&js$x!c2vGL1~LlXHJC z()o9^|5gV8z!;u5c4T0;oRz%=br?IY7(f9d<{9sy4{SZ5#$aoe7o7_?+7I*>jcAR| zW28`BDIus2>Po@p^__=*jQeEXhx-}`ghapAsnSz(B~&PLrB$}ouIZT0-xJsKJw(P~cMC=01)PZ^AKuxN+Pm|eQQK_x~L&QO1o zV-?2s3vQSgmTUJy*Ne_iLae1AN}wEF((4sCu3DhcRPn>9Q8NfMBooo^GEqA(B%}2# z2N#ARZ2P92Gd}qdgWGe+qs>+HhympSLT|SH1JCv!y?T_qXUj_n;Grk_L9LTWg9$daYmNDbDw~M^4*3h%eL$V{e(!wZi7F7^C(TIfKQcS$2!R9` z@|4LU-z7Qn^n#JvAu{C6R92qxZ(bL$*1})y!iqARLyz86AdkvLC}g$_e|y~ino3H7 z?4e*-z2N=5(aqAXMYXPb8()FU#&YnFf5OxbnS@rUn&`yNPE53z;q1c;3r*>Ht(mXM zivEbOgajoz4V9F{;o1s9djkh!BMWqbCIm!`>c$eUVl3!wyeqrLEzKWawp ze~R<pqcGqP9Ho)k2k8=5Hr3YezS&-4CG>Vva#^yQRC=;@E^BCT26-yh@%CT9J$)qL-(4YoUVy#pE} zx|Fe5NtX6tI&0G2^3bUvW=fif)Vs1h%IKKieZufB?gv5#X{J#L7J+M+p;+8rX<|{k z;Rx>*7aq(GK4J~HPY|U9iRaTt$MMt*@bTr=J@Z^LfRT>^DfK0`&{!v(z>r|^plbm( zrw|oWiIz~}sbk$C??}he6Dep{mL>{3oVlc-OCj}|(4Lic0 zo?;*rK}R*8&mOptwoW6~b27!Q4wiq*xt~jpicQoxj6yUfXi~?g%h^eC?aoJ0Y%9#f zPr|jxLK2IdO=ru}n~U%h;^F4AgG!Bnz2M4nOo9Sn6^2puijB664m{f%;7%*;q+O3i zO0|!MF&4hXFds@h(GN!2h;#zx zFFJ`8etJsrJa0|fd>)q)FsR}5@b2p!vH*QRz|C;tm#r%vpnrb-alX56yY_Iq?W4=I z1`j7KOPk1BP&QXKRyjIj`;p7R7EAb8Bb|Y^FZHdZNS-`O8pF3bf-zBTdQizp3q@2L zQSJV98K`s%{@{c5#=L7u|B)^Ks%F-6G|1zvX+%c`?&wBS5*@d2=+CRyNnlpR)!dPEF{ zoJ==j59Anp!5$zXgxhuirUnfv;jI|m&k1|2hjgcjtz@}-i^qvJTEA5 zmDNsY9GX9Ld+dC4f9&k8wUI!DuyiOjyJklhA*b9kK2*r_SBdLS0Lo(90?ZI5&u1s1 zMZSrICjL|tX)O5mY*WwRkb{P}EJblIgWvk5O2{T3kd6Q*t7bO16(T_vQbBWj2UwOr ztjJ@!2GZGh@NC97IVJqkL@WsW1$Ez3I+j##k8BAH_Q@fOY0|_4z>0zg2MVQ0dvkMB zkyBX-@vlIz(S%vY+GhAYiuZzP(vV>HtLv={-%V+g_b5@sW${9=>`*ZjHV0dakn+9% zy4&_cL~k(NyzZjquSMRsirKAqq%lDRr$H+JS^IM`{3Qp6z4@G9HNgC4yi$0Lj{x>w+4Vh)Sc_u~?gris@0ftpJ`i?u0b)xLfGM|L^&@9Q+~q@v6G{%xY}C3q)EP7!7v*UFreN?PGEk=1WONRX|rzwB@G!+Vk+vrzU3F1v$&}H4~XL@eJ)jH*mte| zsF%=!l>N~ft;S34xkzkP`r|`UT<3md|cz+MAT`ZbKkC9SteZxSC@TcQn z+IT1G?ke>56n*H!@(fVz3n=RP?YKXf-VhP`hO(74@ffpW`*r zbi+5+RS}HObQ=>onsto@ z;sf&)*tQ3f4g2Gt$t>p#HEhgQZYRbUN0w_6I`GD^v}*&5TcfFAaO{CVZ)WoMoUYO9 z+L~It8emLRMG=yp@{~Y5n)MGyQ+Ho`{Kr?(hR!wn=*9uR+8g#J{rC z#m2p&;4Cqwz$%82HJJ*k?dh-kLm)6<$snle2=qTrgA)z=EEsZ=4(dG?wVK#9xyz99 zGiL5v*Uv6TK)p8SehRbjf%+ls^r2iVCAhlrysrVve6imtlRV@MxN=T$Sp0+jz7Fn} zot%(`MWz}-3OYrND+{M~iH64fEka#hZ6A+ZLVZC*Z0T%V-_LLx#Qw!*NRx3OKqNuy zaVN!+48vOcIV@M`cEhy5Poq+dcj}_HjJ}BQb1;Q?L^sbb-y^+a5&GYTm1tz z{z4oYM4-7y`IC1?&(aHYTwa-5O7F;cZS~XtoaVodbi-el{AWf{8w!?Fn{H^VV~Y#UNK_@F1kaSOT|@8fov)>b|Z6>h~r8oZfL6Z!~3nn@yfOjJKy} z^={9WiM7b_&Xk!oPfG8yXkbe7|HIf@N5$1V>%zFZJAn{fgF8VJoZ#*j+ma`mKp>}DSdyyq>dW7<0~=2IPifjoj#`FoCu9H@_R(+f>mCE3KMYG z()8vpbj`2pSMp22#5WIF5D}1fus667;2>@lE%n)n)(B)*=9cn$$;g|eztFwl5*hID ziT$r&M8-tFz6Cgv2?l4#u8))(gvBDNlP=p@YuEfxdL!827)QeuQ)HE1Q_&RRQol)! z!~dlmLr2^PW7wRUc7Z3UTmzq=%H(MXca_H#!K-{R!fqj?`;j|;=^Q)Pemsi~`L^{B zHf_0lBR_h%q>1!tOL3P$v-YBr>-*{>o&~FgUYn~jb=1vAd@H0L@j-^)tQn)_maWCZ zs!F!p!`0Foj8CrtRgeQho=Sy%$I#5$c; z4}Krv_1{aj;Nm{+?G)l~o=OB!=nY_tbks;1%R}BpqH#<0FO(JQV6$+B++`z%$;u$D zk(*UBGrX$2dPRl$AKbuRzKiws;UD$i=rSY`ebB)8as@l~KQOB4FnhBv@%W0uwZ4p| z$FbujRs@FGR@s{?OKL|1A>nb$n)k`nRFE_d2j(?=Kuh&T-^hI>oDtkMXF=Tbia8s> zj+jpuW!jPQ6s~;s;QZb{H0(nvV_&~A^^fgT5J}c(TDvPSQe?eKSO!qwexbn{y*BXB?6#!wBQHJQS@@7_*HdUp1D=@&#H+1j zag&H@!*WXVW>QJ<;bXR*P|C${8Izs!f}ER|Bon#zq7>D@fwNgPnHnR#*U~m)q2AE5 zP(m1j0s>ADuLrGGV3hg?L%t|v*Gz;&^}o9u8WrF*G^Bzu05Q<;pd zZ>;=mLel>UFl~Ll3!oPy5nR-|l}t&L4Q&p~2-Y{MVf21$_ZPxFqTc+Yl-u&qL@7|ATx9Q(ivmurjng6dM~(>~`d zQiOtiHoa-?amQgHF4Q&24{CxTy;X>eS-SP_Mw93yPE#nQhmKMiP!Ym+V$FjfNf}Wm zUpabBWSDQ%lP86&zort2KFMUnBp&~|w$K+h?zXHnquk^7`ec)gOkgk#KuCp6=l#X+ z2u8;n0cNDRcO?amacij|l$;nLk*1Abj$PEWsuW7Q%kjuN!o6_OlF!Tn zl$jiJS@+&V|4@9hj?hn2%hF#^uQU0BOw(CwtK3liLo;*_Buf38KzWe^+t0VEY9}?T zK0uQi52iZfrKrQ7HSNFRS9VTi>)pCjHHd1tiUQjOn1tI`HR^C6-ZEQ|BEG8|jmhB*80^f08kd`? zgO(P=t>A6B7jb-IjGS9{;hV}`bH6v#Ui-2CgJw)!Xm)9d`x>XpeH2P&-oJr0CUJEC zL<*??Xxgowz}0bX#HVS~l;s$`u-Y3yPVQC1%iDHX+*hH;#jL88)PM*S`a?7Zr7M@0 zcB44z$8cY^P@YO?(jZ7laM#H4Px$hG#Ao=d^R2gvELl{DNymo+kp)&GF~^rs9bk)Y zeQ0qi&&+Jv)E(T9;J0R_$h_gQIS<3U`1VNaLXoRa2QYCp7S(4L_B*ZKb=CKGyGA6p zSA+bC#fBJ^&B5QrR))(@`T*VPku~YkGyR~9z}$JL4II9XdGu8%E$#R;3y_RdB~V1Q zr6Xfzszk81e4~>Tyk>&`fzlD>R9ha9C+jN9O#g;+9hABAjSk6rd+Ps%i3}cW*h|tE zjAc^aQX>p&`i0up8pBu{@(&{km*mYzG*GC^#B$fR12fg|Eq@VJQGq8f7bi_DMf#TA z)ozqr>HBwmrsbwGqZE^NIq5hW8gnM@v3q-FXLvL&FlwLsy?smn@88G0_*}7Lm{k`S zEV^_uL9aQ|@=Z)Wy`R`x+L;6&&qVc+Qy%Mq@%&mFrX?di6KmU*f8Qz)+q#&}-ox+k z1N<+1i6z}z3I^jhZyyiljy@(wR%WZIWlr)W$ZF1MQwRgv$}(vCd;J)Bdf*2#&PRPGzx-xxNA^1Xf9ESb zId$qjr{0qsMz84FA1z~b6E0zM4OV|%D$z32kQ|8OM#!d9Vtm(yQgBvj$LJQJr>B6kl$ zdZT^89xe+14f+(G6-(Pqa}fd^UghQBI6y@iAy6y}3K9P8qOW;oofFyt(fe}->BslP z|Jmr5?>6^an+-9@G;8kbWn3sw@~81QdGs&He~@BUSs|+eGYt8c4V6f4hW{q0r59`~ z$)G*@3W-12`HBrw_unh-VYhYPoqzcHr(P@ck72$~$r@xz-VTUf>iVyYp55}Jz!suA zPc;WfUBCmLUIx&Wh-fCPA2#S-8GS>L{`;uzpJ^NjSBU96J-FGKqle|qD1GSH`S}IT&m<0NvE6ECBKZTM^mR&%7D8hQ z2Gs8>XF~nztgcp_?lbCIQaxrd+k*O4ilY4-obj!_J?t@`ge3i|yzhferX77DH4#Y$Bk}wZ`k6LRi!1UpunAYo411nyB(HLrdi^m&gfTR*k~5)sd&wp{5; zky=3Yx;@vV%zKjg{0I`DF_*jtufMU5gN=LYj9+ z?AULG$;mpeGEG}gy(u%)J3w1Cc}Ju>ksu>CP7?US?i9mXJ4E~MkB7qE{})r*OV*U% z_c^gXo=w;@snG-8?W3708Ku(yD^og-5UyjEGC9oR45w_rg6@)0@ip-4CTelR!f>5k zZc43ao2+ zeg;+BJ=UQ-iPmswbQAgQr3!@)e3_fQAol+OeczR=SVg+3>lzIW?73Ahxh@(V!xAJH zH{|4%8AED^TqlTub_&&_Rh?iqsWM<|>Wv*sCy0YEkaEs9a3A}0VfVG?cR@*arhs$d zurAiF3%$R_LqJ?tjh^+pTny|azXrsdEc-%z+@7D4hd1TxjA3%aOaZUs2)?4a@m5ex z^P-Y1t5N-DaDUPg)oSI}kKZ~i1o~r6P1VD~&9a6Q57aCmo)|u--d5#$L&y0m-+&8r z%nKcn9?unHjj#l2zcVG|^P^}pWc^2+83EyFuOR@4?a8)t)lkf{b)Wt7ps^&3X` zNqGA?agQDv15;tklE42wmz=lhxEub-ZSNyNY&5>LgUNpGjA>UXTz^=(kw)|y>0zXG z#{UKR9{(P1O=?RwR4O1PriP98M~hx@!}=pzvPxyQPxX*r6}A=2Rh7)u=5v9>9x#hF zhn=YdcXn)7m;6nPPGMV;xLVw(C}JfSf43U#%P!wGgYn$II4sG*k|72D0l)mb-u>#z z6XgcXFzR)KHJm~pXq?oX72BdIvJDVYH?;aWGnYn_B6Wb`D$8&*>AaRa$G(v#gk&bK zg^LpFqqM3u`Gh=~mRQ6#!*+l>4lr_Jm-H)BfhbS}k*+~CUqrtuD|xT5nq@5q{|EKH zdpP?Lr@v;Vy=XOA$m7O`*fn9K&k$E#M5a~%GqO~FoM6AVH#VV2D`rkB<(4|<0n#d0 z)K4EiXCw|ws2Z4$cN~GDIfKkYqdTRDo3hrAK#H!^o-PUP^{JKRt$Zw)Ndq_NmgjF0 zlg2=|x8Ol=9ta};1PYE*siaT!?HV=Cz^Vw`+t(H9x^`vlC9{lCUtu=JSc>Mo)>q(dWLdV z3v*>yKbMc6zeu+%DVC%8t-)}`>epsspeH*4Lhn~rNR>yd;a&1<7yL@u-FJ*bwh`EW zJ(cdCN62G>AKw*SHa5ZrA_Shy`_Gvat8!|*+IMoTd3FlB*kx)dYT<&hgSx+eSI9Lf zKQUIVO%_02h+uMf9V2mupCD=t0$kT;M5lk^=D)^-@&dGMaIW-gKq(MC z=i7o#wM2d4X1Q^(>l-_PX1M~`R~e*SGiOeN-)U-xW@Hq$*}MMR($=~s6kam@PjdE) ziK?n%)OW0^Z)^FJ}zP1-sIN4Y;>Obp~Lv6L`QSgG+T4v)M-VqDgYWC{>s z;zG;COM9Etx~(Z8CH0OMA;HindhKocZ-JDqKAM6Wfl(%}|5wDTPl{f(!GCq8pZsk>)c710zlY^9Tb~% z{;8$%%}3Zpt30a3AKk{i(Vbm|^p8Bx(_>(L!FHTAMI~Yr>W%>p|9|-GLLokHfBiXX z_$keMRG-n^+J3CX9Ba!%{4vlCRx+_!S^3fXR%$)lY%)#+Ki_fe(G7gQuHq|)`E_r1d;LhRh42tEh_-gk z|Ep!nJ%F9xIJq&$`Tc+Sv?;%Tlh;N@X~+%X^ghGv3)TN#o}-02g{Cc17l z^9I|?!|gAqlvYh}4)`1JSJw7xZ9$cEhc#>m+9uB)NXEl1dgFZ_NCJeWBYdyG4>3q4 z3_M{=vgdued?ZKmz7FXa$TL1kkVSTI)eM$!d6}Nmg7IB>*8bvO^k2CEeo){4k3neS z9EREzuIagOmu{Zo&AAOvphJ}qL6zmVgSxx5>9rMXD&+USRdrv%<~DI2q&M$Yopk88(l*I) z_LUu+>T?`lE*Lnu3p%?|3IXkCOpcO*-@`2CYxOigY#O_10$+S-ayr#E7CxeoTwGoJ zU~1tHI4{Gjiv6!lxni0e%sxcM^HRr;>kAv7;w0jXIZ4VJ?f&>yhObb{snPgQP{_jr z^CDjCd_*KrVf1lokDQW5$B_Z`gn>%Iow8qYI>9v=nGMY>lI|>~-TdTLAO_IIzm5P* z2@C;osjMwkD9Q^QWM1=mZtMgX10iHH$9T_46}I^D=nxV3%MdHv{~A&O%?I0vVTZAQ zBv(-|1d@BgJL0{Bl|GbFUxcAO9a2`0JH=hlGq;eoi*q*p{Ewsa>+>YiR&XBrbYtVR zj7>5!AG8|(t&@^~4*A_2Is$oUAn#z=!ZW{y_C{(c3`YyhdF;KE;SGPq#bt=6UhmoE z^nA(JuqKncPc1Nh;QQa=K7VzQ2H}rol$f}-TS{P8OqeNhvGH2WrdJ{I;{eyq)-b zJecrbPp{{H9yvYd0Q|*3f_5o5Ygrvu7!ssqAOCtY&>w-n|j-iZ^AJh+1Y9J8u`$U4umt)FH0I0zn zSo-m}Vw1Ywvcg0BbZ@DuP7_$Y;e{sl@0&)RN{dxRR?=39(o86BcojWMjm>4aeTV&q z@I6Yl?lL@muCQALID5U7xew|DLRIKz&s_>^ywqf|!ahhpyJ|w!&@irdQ+ig!aE;*4 z(7BtZd!`S)hiaRYK`76OJG4pUrMlA19&{OHiINR3a&>y3aMXIzLBRGen%Aea0P zy8Mjh+xx1S0nigZ{{(1=no12}G@45VuChe5v-0E;s0=)pEH$*WJU!I^=-PDLy+45G zgeQ8Y07@UQ)0RF2R5sE6D9Z=}ooz4Hm}iRk)OJ7Y@7p|F9fT+|6cl8grTfKqLY}+a zD2O~yv(0ljoKLGd#g-l>PBs`g(W{O3kQw94R6y;x`wWE5^nG?;qtd+)-`x=Xt=xBZT)xd7o)HKv5q*BnKhr2 z#v4AX@Gkvw4nqjE&R-f4M-}bsulRvpt?{2!L>$U#XCpLV-8`zF8MjN2<8jS`Pf_) z9Kl+4r_~LG1oaX=7)K_Y9J&6y1Q|)%zuq(1&5nuuuU?@Kn`u~I@LZpI zQ7_Q~lS7!r{gML?7yf#=YS*Tz`u+=B4zR5wTF}cN2E3Z{@Kl735nFO|G)cJx+&)BA zC-Gmg2v_#U>E-QJGq1Fo>T5O-6M_fo$hm^;?#GSAO>9e-2cF|r1>7jBo}S?wUJlqF zyf((pr2vpyY@M&a@05k2!plc$?(iPnLnHIk2Z(jh9 z7yP4}@#}Iq6-E9vS<7xK_v}MuTdjmp#}p zmNO2|Uj>~g6=w5)mLvg|<=Fr=5XTqe9~j{QPT*zn6E+|lbpRzK3-J0ug}?5=c!EBI zaFm4pxv#6EvwcKd3b3fbspGgIw=ig?Mc4+SDtZDzwt68Hdn1YLFo7(tLfPXBOqh?>nDPubx1 zQMgFSF63tXirlPpLk|z8;T<&XNXE1=x4HU+_d0uo z<8Lr2EU3~g+FaAkIC;ctvB3`eQFteIFZI8Kcv|!7YgKF^gM>J`ReM%1+lww0$yDi5 zLd{F6yx|oI;PXfmH7OY25m=k3zRy8Ew2?6|Gk8v$zO;Cjv0=&EikS{ePE z+;n9?#vMpq_?7ELG@@~|Rp|68XPmait!NVEl*)^@(#zQT2-xz@c{$Ro`ofqW)D>9l z%cbi<_y}6-7gtd69A{YdmHNiJ3_a>#!CzwWt2^vzr1CwYItjQ8jPX5`n5v5U1-9wl zyPtMl0I%Ca{nW&H{18`R2=epuP5~L!u>W8TLBNAH70E})IXnrsxnR}FNYPa4q_~ms z1bo5Rbwh$_b44VOwLPXawPQfsUgqgFOAxNYCDX$d@9E*nIfeMxgWS-yp%O9CKxZ}t zpJOdsa&;2WeNuJ0JCdXF>ZZu{>amKaXHEf(FRSB??S6s=A*fW;?`i1_=!*Ax87KvT zVn5h64Hklvbngy9OW+CQHt-gnV?BcBUH2JeA_E%~_;y44=^#W!C!1)0EWox0p4A_G zc6_&i-|*rA-$^bSNY!m_D0=C1tmEr;;*p%8dp7~PH}vmyGs|w2L=Cm=;f$M+0q-8Yv%z%jKROd0PEU$9?dxUy$RxbRDQ-Mj~ z4CP*o2HVpWaW8o|5N5Nz>4KqT^_L22KSo=1nqOS_zjnC+x0{e$5y5e&}Dhzj_h& zscCZS0M0Hf7YDNV^%46jUxfTy}2ml<;eIx4PVvQZSEWafMfS6 z(a9y17<}qyDbS8%`(g7G61_Xsu`S(i6m)xu?PACs49fu8uCI901UvVD4!Ga8xjFNW zTVqQT&feTED>};sNINGdh*wDxQ&FL)`ODpV4QuOcnUmT-1#S;2QMOdo6ud;_^ix@b zh|y|72u9F4EjE<2^PYtx_~H1iroI|qsMloyJ6^oxkBBMfdBpETWQ|gK*7#*=&qB~> ztEhr?!<<;ew@=pm1S(-4Y>+UiyW>K9@e6N1dbGu=yxij&H??;U8thDoF^E1I2B}Ru zCj}D@ke(5xZu|<|w`+EIirdFd-Fl1F zXK*c6g+RSh_ec>UMvKu-+|?U3i8ch%m+1?{jip*oL-BpPpRR+}DN^U=rLpbULHQM4 zni-~5w2&hpZbQ&DaQAKfYvcr&0Me<6C5bU}?r$zxF-o_P#E8`P9&)F)t}SEGoaKg^2C$v$vb=-Z_HK@%75|q8%tOo0g3y|Z);xuBmTQDT zZSAhR$K_vJ)#oFnB0fqe?H#Y`*%bU7AtHTMH&tciq4)jGmud0+h>lOx)P$5hPKRh6PSJtIwr$lPK+yZthC@q|p7YDxOi>T>`v@9R(ncJ4i^;z}rc$LPsHV{+z79$l zG}$R?>@zQJcOVGBpo#{KzV7S`^R>ilTwN4C&y*hEJlrd&hSHDr)U|uX*^AU5#hKjq z5(z$c<4;%VHp(dhV}5>EY7QOo(~TH~a{b81j3Q7hRBFNRL`Wt1n(T;;=}CYuu{5#E z98b`OP8_m?^T|jQkh>5_LaTCI^t(%Y4_Yf=;T~we@-t5!_4W6|0&%G{L+4%OL$k!Zoml6a6%eS7$)Ij%8 zCUf9Wy&8uz=U2;Sc`>`iXPw8$inAP(<3+Amo{k=JED}yLI(R12rPIoINY~Ld9&W{3 z)BcZ@O)n8ocC$pDY(8-99mscW8m((h9jpuw%-oxxnBP~nm~Uun4dIU^jm^f;ZdUO+ zY@szQ>;JTIIpOaKgFM)ZvMu2%N8unE0TP?uH2m_<}SKQ^2jjTsKVpBdKDdypd$GA z;v~MKM>=T0K;m42T-9;ffDD2#K&%(KiIuO?K*K}th#m;226-8?VMRN)>c%0zjg_g7 zg+EM=syEHJB954HXekh6!wWCnpVBBFJyD3wCFyThZM=mT$se<~1$tgFreI-Tz0ip7 z<4;8Oocspd@CrqjT&;Igf)`xk@FJ2r zEX94g8hCdFmz!SjCZct^kI&i&9?By4)qj4>N_sz4kmrMf5EL34t4a$867XKWQO4m3 z><$PTJ>8x3@rqak1Q#>fysXKXPtLDpk_e}A6~wlI!+Rptq;f5E)4U*I5?r8SU`xSpoBLBTr2B+enh_M4 zSlCaRRhM)AGq%f!i$~XRzO+5$4(Ql&*xv1Pcc1tXT7DcB-?}Ii73>uv-8^$C;2A6TL0|dtQ;YheGr;Au`h0ia&B?G!$hYjd!Mi(!3R^$& z9DQQ%)ixu;SH;&^Se}z}_?4F~Hj`oYPw#sXJ1+>7p#lN*Y>Y*9NNFt^gbd? zXa__`CtTcF4>#`jOk5Fq?&`%pOuRx)hN*6yjd$)r#0@~6N%ImQF-z-!e}Iz{*cS-d zPHP(rVOe(~GqYvK%Csr8%{j5SjRMEETM`W1nvQv>)|MZ&Lf|sRDqP%+NsTEV5)*^5 zON5@@h-U-DsXMBvwl|KNEbon{O8w4tZ>U`WS}3NQKgD}QC1siiPEuj7a^FhxuizhZ zMAX#CuHGcrl_B^sq7`L)zaj=^W!h4?Lp zZJ~6`jSgkGcN7TyyPUF)_%FFp{dzx*}h*G+-^iE_p^q0GqcB|7V~v)y{qwKXj9aJOCWqv z_*;vOdY%0IVzC>ikrmCW*^S@zr7WPms;V>VsVN$aWAV@A0IQvrUPSv9U83690(zbc zSb%7kTJ-uuApG^pmU!5T6Q)5WgbZzVwxBspV|-Q%a*t^=|CnBWNQcC#jo2%0K(N;_ z>?ilUSA9|K_5o&5ZLf{N8THKnx7ib$ISJPWA{Lc>o2USIAgID$L*GK{66u%0_^V$? z;c6S+kboN=uZPr`Hz(!|Ct^K!HRdG3Na3o`63|o6#1cj5+uI9#mtb=JCNT$Ab7GDj z;z~TCX?$Pl&08O^{|T+tFM*fKWolI60)~&Boy}z$=QMF!#Gw&S5lKS+(X(wBhm1>Ww zudu@1MuERPq_FqO*z2w5dx~e;QAT8m1fwd3&uHYF##FFHtC_#ryyII;B{({&{Cl-; zy7m+Te!|Y3beCawgg;0ZIOAbP#@^$8(C!6Zh<~T`?o02!>hM6IN)p?(5uox$Bz?H1 zfg_G@2rb>7M@HRV9R=U0Xu53f1)g>?D&Z%} z8L8*4Z7QgWNT33S1n`zoG6=jwfUl&4X|k~$kjTW8wfskpzawkn}_@|oA=+8 zB52BWS^Xq~e5b%en6~qK*@q<#KsYFuP2Rd9}!H^7XBX;@~Om@J@t z!G%<{a5hi)`3*$SI~vwS+$@=s+uK#ty%t%vkp4ZQtMtV$@bTVp0B`pL9!%HpHn@g}+) z-ELX9bAKast*ze&hsEi;r}ctD3NVI=i8L>Ahd^*6{2FlO;?5U)shW~2$$fnMyA0)q z0>88|u3TraI>q8O(_jE)XH^jWe){UdHZqp$h){Ai#ZHXs8W5fzeI3$rI@m3&<+Zx3 zSp+VFZ{B6*7EMuMg776SjuHy&1HMbY3Ge+ zyx0ENS`0#9#o_m1F}>WB@|`c13s8zx@gA{fODRIKfz zU7NIq{DX7nv`Ci_jC7X6>3UMk72Cod-2#Jy)zKE2=5&wm#qosBv3`!WBIb(gaiY>> ze*8Z9mfG~_R9^2yv(0)BVtv-JT~K-fN$5OnS5H(#L7;oD4oj2Urx^n0iLg))OJqRk z1^u*|fHbvm*JL#8o7hw9{rlmHBV#ZTy5X2#MT^^_F)QWc%y93lKR%k%)1caRDWbLI zU=J#uu72}7%@W4n70q$Oy5z&O_D0sZUiVXiDpB7qx@-59H|%@ICA1ZJs~uq{@U}H| z(ytb_LPVLTt7+l8=MN+`BlU(rb5w9|Y^O_qZ1gCzwyT5gIZh*ock!~{-b7QdxJJvF zR)_x;8oTe$t=a_^1JGETABV+yJ0X#%UPJpE#k&9q8b86sbpi3)rWx}$sc;gw(CbV1 z?}F{_$L*-!=d%MSKXmg9n3}%S>*q-oIl5m}n6KSZUjjzANu7tLDL^%WmbJ>O@a88V)Y*VRw?5p#nK>u*YD+fsUH=K9*5j|p!%GIzE4}e_y~JCM zn$%og!wvguAt3HYhX}x+#q7!F0>Li!S9=i&I(H5~gE_3HAICOH9z2B;0a}q2N1Yp4 zDxC!|_!k}4!=;s(izlzJgztzujBi;$?YC6(sL#Vfziot;5$&H{XxzjM-*LrhdhQii zmT67jaoI`(1(weiNJoK5sx zc)L($I17aS34(!7U3YRc&gQ11kyhZFyS!d=S74L33O>df1~^1QulJWz1#CI2eHVJd{q(|XyNinrAt6z=aPjb|jcpkP<|~Ww@K)~bPJ=F-?M9z6_vUMA43P(6 z{Z9lRuG9tcv%13(oi4g>-vov@tW2*caSOeRlqzfxYKS|Mmc!*&LhpSWLM6}lU%3FI zD`X92D*y%G95+5WqOt9rC2=(n%2cgLxlw!ROzi^&=)%y$-avR+**Iez16oopE1 zze3kPZIJ53E^gA)l^#ekPkl66GNz}d4!3U-;XpAPvyi{MZ57cg@FR@>Mq1l3BFa>z zF=O>agI%QNO&R1C?UMi0rbx4dx;(_8RbZO3pC?YfQG0E$v{7cVYQ&+YETDWJpeZ7L zR9iI3^^^WFv-_!%5XWHLPhG5_Ba5PJBMk7ZD zjUzZ1@C%`**y=$|$uv18{7M5C^O#K`jPs-trfAQ%8<>gPxGms(+koSQm=tU-bh?Jt zOXLz1DT?l|DqYTJnYcrq=8l*YyR5f=$F~oSjL}_6aEN!@(o;KC0ugg<_2$B*TD|-! z?N$8V3P;?#tTp&Xe7@c*blBabNL-4mWOMr}?!j(%>krc<^v3H^lsI!LaqdicdzLJ` z;?u|$m_n{s2L`{YabUmIXk}d;j0H1p^RrOFf%vedTrE_KJK&1?{s>5{E>S%Je!$Bg zFEQZh8sz5&DcIaK3X4!-8&y$PO(vM8dk1t-zN^?a`8MrD5-SkP^hzxqQAZkjS%56@ zEPA7J@bF$>zk43Pvyw~7w7k5tC+_LIOSf*MHfls`=JM9hg2f=LS zNPkNuu3BhS*fh>R`6Q+}D`O7B=NHE6bL`4)vp?=B5FVo}8fA`zy}KCf6PvxHAq!dg z21|FJp?&teJA%*hHo*qtA2S>9vCsu&`*=ad=^Uie{j;2&OW1D9lQ+l7T5NJ5eku1+ zuXfikTTfT6(aE-f0A}RW)(xY#ib64lT6{Zb`WCGA&Yb^!I^1mB%Qt5X#6a3V7dUra zo=}I%-$nUH`XRVpq$3=A6VKT{BlyPy1wRjBV69)O_z-CTwf(WydwlbO0b=L$uH&V@ zO=)TI<`AN-WGtLa`#TD1=l&TbY3c97s))IfeR2OT4tF1K`}=0VYmWzl@gM)*AoNqH z;YF|hqtQ^EPRc`*z>Ol0gJt~FE1q#BIuQSzIH-iR|FPedsM_R2X zKV+ej)fdMMBlBlQwyZ}}jcr!=;Cof~+C?{8usUDT>tEE*@0_4MA{agcz3q4*N@P@vp>zS`ufwuT(9A-k9V3MuOpC7K{)(}cU z@Z+`e9iA+?kCa4>{~ai$AfcAQZ!1@W0R$gNxNlOo{+&|j+PRh(Y5xJ%WR(dvIUwy| z08Zi`-GPqG&}kH~;X4fHgr_1~#Vget(NY+KKTnK{yJR@cYAe@3Ag<(y(bZ8Qa%F2d z&9F9#TfzEKbXp>hajW)?&80%gC`Ta{c?cGSL%e6}gm0x+iOW6)lJsWgmk-Z>jsB3M zyg}+OI=HTv10rJ28#iBJVB8Uc2$G>FRSS}5hr?+V%}aY_sHIP-5T31~)$#a<7Gn9| zd4o>ebTO=nCrgYzmhumk7O$d}i(YmX^a4$3a)p9!qrvYsyc^R8DH#E-`qT`K*EKf! zk#Yb=OR%RVbrcVh0^vXMM@y@uT!0Xmm4tbE{H3Q0!?o0xWH-rTXs=L&ks>; zQX>ZXju<27Q~X3IH+Co6bMsfP z$Asbl+hdH6Ji0vk3SL{mhuD0YzZ3tl2niEL&P!oyvlk9QWEwlR4v5M9I|lAl-%zh= zs*0Xm!O-!sG88sv_tMAl=P^gG(}kHQ*@Bl+w8F|QJJPA{u(YH6z*1+;3auZ$Cd}!$ zK`a~J?ga|;D+@4hEP@R)5Ew{U%c~*(N6u>f6b;hCn^xCFqwHGf;ipSGS2|dB)19Jk z8SlzInU{>_q!PJ+N@p%C7rYd9(?gzGr>#5`ht2i4IkXkzOS4+PK{V{t|6LZk2Mhl)wTUE#>C=hldy}pc$UeuL!bn;+> zwx6G$oUh;y_fMG&d?m)YG0xl?BFJRF#q#&RwE^yP^g==_bss!x)Ml8LNT6G7=iG)Uf}p~Pt( zGL;b{r&>PZt1EhPXMSRJ%2GvycqI(S_twB8E4%-bIMsKMWV&wdaDWa-#*cz=o4?90!BUZ~4$b`WV- z3|HOk5>bfjPZJ0|43y>d*UoPO*57d+a^HM$L|ra6H4&dmJTEl5V~X6HHWT3p=WMx) zdTJ!xOfoao&I_p#32t5;V5E8I?>!ufKONE^Ss%p6RI5M{OOIV!>i4Z9II?q|z{2ru zMD$$wbn}=9^F^6&{tD-Z`6h3 zK*W3HpBGM+roD*pEa;S#Mn)J!Cf!*PKRELhf+f2;VC65ibe3w+2|2DSEl5fH#piqj&yAbneAsqb=(yyQGAkpkuOG9c0!n^gnpQYK0m%|nUbL7u4hX?(Xs9r|p^UsWn9-Z4#w7EfOW@J>yG;{9oe3%Bt2$S40 zcSw$dUY4*O+^*pEZP^6S*|>ayr9W{`I$j?}NUK=vwJeTX2)e`g{^KtDS;SxQdVeye zgS{1MFhHFxsh0?wIvP->K*saLaw$_eZf>X0?b_|yT<7(+7yIgD{zY}ix<9hu*msp# z_|OpiF%Q#2vz8!P)C%Es(Qcqs0&`HJ8958}%5+zI17Y5W;YCr**c9Bc6Z(m7&#SR=)uy7^Y zTuF?=xZEZRt^R>n)3MUO;FcJ+Lc|zv@?x^lz~!P({#D_%2}#ph8Im=-KY2If%GiSG z7%$&|lf;~+HbRY7pqnF}^4u9I1@h4gTpK@u=`+T6(k5Gza<48JJ&pU?f);Tq!nBi% ze{^kV{YT4c$q)Ndv9!<>h3Ag;ewRl-n6#zNP#?GL(}2JyH)1FIT&b_^{Z?+nmB=DV z9oW-e;xQeMGU7aIZqjH!5IHI_PqZ>VX&5bSnt}EPji?8Fdk31?5E-BPRRUB7SHJTH0$V?Bj6BXhgP*r$?{k2C2fXv-q0NbnH;}tf>tZa%h3skeP zKn}BnsG!RP_uxit?ctAkc>5y;{v1owBW;f}sOvZt2p6k5y?1dZ?V)myE||n_MnCaz zsv?Hwj0_eAxLJwM9Mg5 zYPCHB+Z?mq-BPO+i3;P_8{}nd}yc;gFD;faC z=o|6li^;P?;-723Mh8((ScM8nzWaE+3<=WT)cx{Y`gmBo&!54d6?R03wtj2)xe=Kz z4I*|EX+dFNq({Ct{NA&<_H|3n?hJ~-ag3(tvGTQsM+&PLMMM^h?k9C4RDz{uJR6ZF z&5YfeNLCw#`$1FUSe58=G2636kf($i$z_2KqlNI-x?bl>>RSo7h501<@#w<$4RBq% z)^gLQSVr)TVX(NwuYttDti&TKLD3v*wMT?13DhCpD%e{}jm|ClO~`)LRp=(z@-+S) zI1q8K&C!Bd`rU~0mu8Z>Lqq?MkiO%jIHqlJbc<*Ew7ElkToEOF5+u8X*IOiV4PxG`v$`pzU1cTW?>K}MIOKNs+ zMk^OntR z>FyFK>Fx#r>F(}cy6ai>{rP<#{#vfR&b?>m%*=UB+%r77Q|4c1HKGF&)WPQ8+STugXS`MrxUn53{gyF^~YOz6i*3Bn$uyvm>D~m*BCFY*s&zO$0Fh>*^P;$CB@b6#}<08 z^9CmGKqD!}#=_VXPPL?u1G5Qw*j*L}T?a;;^%z;S#qF$3Db76(QRsVJkgpCtwLICQ zZW1d6;=8fyGxhQ@;_t1_CZL5I9Pf4Uclymxdkn6U+CZFSYHw&f5SpQnnOIy9=QQE7 z)5aEqeN278eJYHk#wR`d$V+7xE|klt6OX+{j3@(Pe3}bI){TV&K4;4D?r#2pa6;rQ zVg6ckPW=U**$Bi9L1Dfu;dd!U=={VfVtrQ5aL5f5(C*L-me zeZldefT`JD?*=?b{n6Re=aC0ioOK{w;1`Q^lFhDxi*+KSq&?j}V9*^aW1rT>rkSUM z7Jmw7*jc7-pyrKxSN*w8HSwwJTfR=o?X-6k$#)JQl&vO67Zdg3ELoP_M(@^&V0MVi zy1TU4l^{2W))T+hQEQ~jA9wj4ztHrxVzw6A_g}u=JcYv=n;~N5I+Z8m{(3B=DBW3y zwA{Xv5CtC^wN{*ft;x^-$5fo$5np`AXDare@x4mBv7Zdi*#Q`X=n;i#Ce8C=Ab1%F>F(&M3ZkilGCm zh4dM|X!((mw{jEaZ{XyO1)hQCr`>uQ@4$e)ZCelAmho;$4@*Xh6B{AWeDH0J#dSDP zp7HA~(2*E-YY9<;5M6;5#usH%kOkdZxTR9>IXaxHl2)bYEh=^;lPbLXg6Ij-Vn zNpx*`CnbW-KkJrc^thq)GgpN|Lb( zkH;cWVny2OmdTW%r&_$Ts6A0t;?yn3;I22)Pby6=#DKJifvzwQ5i;1Z6pB(S2LD0q zz%w~CEc~P1c50-tCThH>@blA?y9=04cVd%GxA~ao0vTKnDCVxaqV?r;}G3CoBJYU$Vw6E^p5ZM zs}Jr%9dhTz+ExuI#fUrslrQ~#gm>7y=zU6`UDSW>^dk2b z>{&Df-M2n>#>27sNkzr|4&iL&X0ZXdCN1*fZ82hu6!v>GV!kuF{7(qw?_X>I6&T7u z2Gd~XG`1qm*!gsir~Ylrn4O*uik|j~!-cggq#f41VeV*u>#d0>XjJAm)c^&M+7$}t z-+IfmO%eb>Qn+DL>F+XO*tGB28N7V>4bDNhGn?$#y#b?Xz3OG@+LZeViv zlTW*Rn&?C0wXLykG6?PBe6Qynbl7x=c&*iJpWSxSKkB|oi90Gbe6=fOv?b=(IekVI zX&N?Kh7Q?FZW5~ez2PrDu{64G=OCpWK)H14-I1TZ(O{Ikm!t|d%2*-EBDFFUJZtcD z<(hQK$rARqRS$Rwoeudwr=K1|b1X3`0KLfAE|ynKfT+2nOB5b&*(IZEiBb1Ogw`ut z(^|)@tVsXNZDax-m&9y52hMNEdg#cp!wVJ?S#o-OG%R3JcbABLU^5N~7f3^r{Cn+u z%9Do73v8^L-dXoj0f^it%0}0-fP{w047%V#df-9`-vzDrpPW6bC0FpC5>Xu|8#$OD z>`%;ocXe8r-1ic-4e1yu67-gmEfNH@US}d!c$b|i=C!N*i*->@Omg)K19Y-aC&!%l zYujXd4}wcB8_*4|c|yMQPIB6b(T_Ih^YgTT*Wa zSfD(d`n*_{r=ysKcy8kDneI#rK6BY$#U<{SMOq+#F9IBv3l55b)Ay< zTbp;gYm*ycMp7R&ev-Q@0%ScwH;ZDRzAhFv$%$0l+*}X;e0H?=RNv4yMp?t^_N zI%m39umHmvGFEV#YdH(2tLdN^9s=2T(@F({836e>Re%`GwxqvtnNL|3dLeOt@h7094l{%AR%_Tr=#MOg}c=Wa}VVkm!we+u!6Yw&Oe~{&}e&C zc7G>>4OYFS-tXKK#eb7-<2bLOn7N@pcEi#W>%08k{EFwdO2lS&&oD7Gvf)i?4!_qkok zqTrwJgo?w()b{ofe$^M9SsS`|DztaKCY^ZMdES0*QMz9HnQZW|sq2ep3A?+=Cf%=A z1TVy_hT5nx<0l`4ovtex?fv;G9(a(@_W`r};BAm0hU5AN z;PYQC&+DRw)Igbp4tiW${&d!bx~uEt?m-;vO7JOGmFfpH5iBF{CeN zKa-_O3D|a|(>q}dBMgjr?bfC#mZ87;neOW(5x{9{2Lcr5b1(ndsv9e~`+MLMo@uJ` z4!@7P+T00};-(qMn8P<13TFc2Y!{9EmGFM5Cppy zi9LKLqgVXYpTXEZOW|IheHQDLMHsNt*9;(pNLpG`m8Ku+2sG1QL^5eWKt=C)OdJmC zK-XZgWY$?FCETw55F2QFTK(ZITPBAgPQV%Sx5w)gls-=j<;cIBWA8pklqG!=6_@+>3=3tI5EBq5qbMSs?;>JaRo<%E_Z$5 z997(LBW^n5C*I&e-#+-`PAh!;R9-6rc}utWu=Z2cvIVZe(q~+QBF%fIPHN<^|I|(< zH=)05$;NRZ0H^<^9v^6#va0)o6gGMw%t21g#ip~B;tt$z@xAh8&LU>6$(F120Az6u z)ibOpPm-}~dhG=VdK92UEV>Oo?=Y4$M~;d_O}QXV?}QzBmw^a5?FWZ=V<>~7QLKMh zD0uScv$5#&tkF2+O?0$|rn7hHUHxFh8?Ay5uRT9HZYzwH{4Fo#NI)w?hp5OedDWT4 zP!*x7Fst9KIz4KP;{E2+U_V*q{O?vJ(2K_-vtQ*1_Z(s>2TkXnlA|r8@*o_aj{A!4 zkN54Y!^A-a%!uOF9H`%!mJ9?F1ysyxcsF%_|E|%MJ#ABH)j2=!N3XaDOY)i9pf#n6 zT%1@QnxbxkitHa;MlF|y^)rnXHunFq7+**LNnCbUdBFIdkd@6^SNZ30 zrNu%%udc?}h3gW*iL%o7A^HrEm*OH-+1B-=c_qAG0RLX_Dl9>fyu8-Yn&U(et@C>; zE|&0jFT;`*t$mxek;~``{y3AzFQnnGXBO z_%AN!a;Lu{@P;zKLIe=s)sX6W=Q@7ud@lj~(QC_m5cAeg0v*7tMe56go4FXIBE!Gk zqwZ;YUV%yiEz#5QMr}AlHpID^_iQ$uGMwf4!N}(YddoOee@LX~eu_7D`sjbP0FDUf zGsC3mK1JaWW(Covcg8Y1_%6XdW`2?x1ATe0{aK|wLuCPBS>>_@-1mv)H5}^LPW{6bAnhjaWt7YG8`?Lg?>7o}#BE&VnWQC8?Z62hqP0gQcZx!RcKv6k%cB1g{ zasuEqCY*Ce$$ghGTJ;ywN48V0ygy08}!G3@WB#HZ{ z7Q>`&_sp4Py)h{t_A=@0W!N-BfR6xLX6CFy4pUc=c(jR21#v!WYjj_%MaAN_@aRC1 zYgzkU3-@@wpe+SS96`Re12V#ua3<%2D^1Kcd9^7%X?qp?>qa5xPe}x?+JpCVrR_GF zBFUPhKW4ov)A>$S2i`MukWGOMY<&~s`?FZKoaK{(QHY$F>$Um z16e@{$6G6YB^NBNQljF3& zvxmK!n98fB$(3+)xWXXWUhYBb&Hb*`+`;&*(5NVVKpCn0-p&{=@B4i<wi4mb6hTh61is!Dedan z*V_1Q`+NwKl%LfpzE{ZZdWgHtWk6d~7M``oJZgk!um0ev*|FHuwfi2@3TGnAUtMqb z3$t}2zdbwatV%J2l`?8589St(36KoEt6&RH+4D^9>F#A9Bo{l{yjO*pEw;fi_+wor z@&4vnN0fWdqFGFcG0L!IPac5qFHcNkZ42*fs5Dmi!HqCd&}e)ILM%oCq%^9H!UKvS z?YIsv(!^5G0wnHC!b$Sx;vYr(RZ(9l5|TbDDcMkj?z4Izav2~t)(Et~(I$xZg_=8C zEy@(UtU=ei5D(&ui^F=Esw2Mwv}nXNL@rfj6gyI!$L9OOIXen}=A>yN8(@_sGCVf9 zvpMRfJ>|;<*f$(|xh@rSpP)|cIC5qWKV>k_WctJswP##wMm}FfmexqgAYp2?;Frh) zhu4xYkQ>Mj=3lB5(v>nH;6|B7d@U)wqUv|%7Oi*Q!f$5lG$vjg0Kp#skmwGj7Q+Iu zu#?`?7%x!o%Afrj2%N%HfT-aj3-2C9_(P*;bvyan+-qsaA8lB|fj2BZH)&n$d((NnWf->HPKOeGtZIs-lvu zs5)3#+yP0-;Un2;bq-Z@isRno>n?EO4r~k+Ra|U5q^(XUNel20Vu?!Qw#$W}FfLDD zGR4L1DJ#XT2lE;y7DI9K7?hPl93nWsM~0Sg|NHRpFGIkvf9BfKY_MDORbX~OFa*TP zdpF#{lP;1ysxlg`dhaP!#uh8CWTp8iv(RWEpuA_V;N4&XBo6Nw%sKi}w(u~MF891H z`Q*d649V9v-&b4+^zhw&o84x96*|w^R1%ctWb}GhH}i^l zsYu@-k-w;Os)f z{Pr*?{uV*M^Bz>4a@_~5Htdb9AQZG!Eim4PWq35Ub}{jYqJd>8JG)-P&u)vatZ&%~ z?f~+``Hg&bn1a@O>5wPt^qSqCesME1$&{|W0$D#-I}{poAoK4>U(UzIF5yaD`=F$NdKumvWu3qx#yGg z#YdsM)i(E5mOpoVTEm-W_xWEL(wuiqJpdMg4)hbDNaB~oB6?Vx{j-V)`O2T=FiP33 zn>pWF4RA->PLc-0DXlg1o{0&hL>SH5KYdx7;y3=K&u2A)*{;Kro-8_&%e6^cCr>Cq z52u9cI%h7r4UgalR;Q3 z4wt<^LH=9ilLo8kK1$4;Fh`m?q@M2OtYh*43-NVO1r>^r@yXhX=W+u?vfCpwgtnVO z29y+rVUACWa~`=C2$ z3Q&2LuF1yu1huYL784f|ZR%6kV4J_+F2az%A`etT-LDVaBs5|bj{eZq(VB;jIfT|ewWwwN3G6ZJ&M zl(tgW@2X7GMLg9__bSX6mam!8m*$y67wdPmeZkHg2zj%WA2$TrwWj>ySE&4;-^U7n zw&h-@ud?c_C`RuNvpZYQJG~QLp38IjCOsLkOPrDVNsKfSs?q*(%&pSbr4oIyZK1mC znnjwGw+Qs*57a;IY2S+sA+b1?m==r4u*Z#=njiT|*0>9j^V$bRu0$YP?c?Ztpt5HV zC#V#cAFQWtefkyGXD9yAGfjD7BCEcx{nq`c5v;8i?ehR>VxFNUE6_nHS%~!U-FXI_{v5BcW*nY_NH!Y?9g3A)V;G#Mb4-!t?^nxd{Su5#-Q6OM_XXx^r6`pQfL=NmXN=f_@JbmmO8f zSoqbvDIAnEO8n3F`1Bb-7e{7l3{#Me-OW2j<7BbI+Axkp)5Upf13%OEL(?yx;>aBL zHRB;0r3g|~{g_($|NG5Qv*y6)GSE+ThiC*|YX1{yjHyUBeYZFHe3*$(F3$`Pt@?a- zy9|8)qPEiS{%mvG1aDjTr2qP)+eZNJo&MSr4eSI2wULP4bCVp~jaYxgh=;(|2S*vWfw5T<@V$uBnNRVd=zkHu0Z<0h4f8@*0MSB-g+d*!QgB0>p#C9Qy%KO6m)`)(HE!lEcxBH z0s~YYR+pZkT2<@-TS&1VHXgZ@Z_&f&`PcFQ_oDx|s%!w2D=9TqI{TP%V0bvsI0S7X z$d2o?$IU?@K%>bDJDtbYXjSrZq1IB_m|HbZYeNJ+XlqlsO&yXPX@~m|5!WcB^U?Cn z`y%O!OP=02F9*hUCL%;3JiA(+f5FOQ*|bl9l+@ILvv8K}Z7ABRY^I|`$RKRc%1D$UN+e_|;Q z50|~_sNS)=VmH2Z)Wr?h<#r69l8W=6>g_%;-Ea%l%Lp)!IRf0@23gg=@GQHSu?6BEn|Eo83KIMHL|ydU_}! zBt8~_o5^?Fznb*t+^)SKk>Ulxgl8Xn8DU{UApjBEI#pj}TT5$+y{|76YsUpgg?y%j zukSNV%Z&AGrPm07o~J7V@nXZ?#n9{Edd(>8`XQsF(}grG$8LF5sa72W`C}C;avp3Y zQ}{R3U>dJ^+oBD?EOPko*CqOxeoK5*SjtRY3WNk*ce(+m0l`)Bo!o*)|IV-x`t5Vi z+l5OLd*8@k#%o$a=3l%l0&Dx3yWOVvMSz!=^|VS#&>ooHIxffg^j6=TI|RIh|9D;$ z+!g@7rynRyC$rjvplm^Vku5NBgKU?+E068!@I0{Z{DQH<@iH=Ze~LCeOBi@@JQeS` z-WB3uy}JZlbb(@0To9EZY@r^}w(Xx7<~-Z;e_aaWm7tybHrMzyREY-(5$98e&!x~p zx<2Lkd_%&m{N$3hhZXCYox|TLAQnPJUb?09F*Y4l3>M==4eT~4ruSXJMon9x_E*TwZ z75%==b~}*a!cgFmS1V3bu{EjwE-;BCWrAPduUPyNfXf?mdtdx%tAEUTL#QQU-CHDn zUc)PD5A3$^+xlV5D*r_+<8fx<=mW$8G0+cHzA=_0!PW%?qu4EsS%Ix9r<^zqQOnjh zH*i&vU(4}4RhN4@!m_+}H6_+uoIOo98Xa%h3_AS;z|<7LZkODm>=Ja=e;Q07F9WH= zgMxu~ur6KtBPIbMXr?2#)|hRYI81jbjODFPl87E-D_6%0oEuBn3+jokP;L$cP1OG_ zSNif1rW1`=fDN40;%{-sdofr-M@J{OO~a^JvkRnA@WvyXCHCmwri9c#n?ilJosV3` z{A+aIzAd85fimdrJONi3YqrsxCxTSlgspL2Q-$#TAV=$Teily9ic0Ya9S@1PY5!kQ ztxPxc-~CR1k%VHqJZVVnSl{|&Tdbfcda18grUlojs;(>DA4N=9#!LZZoQjl(Rysk< z`)|9G8kjf$J=Y!V_q9i-Vpyci`l~<0QCM2nqcdDKLxHW4+uM0w6_1}w8QDIGL5jCo zOS+jl|F_nKiVAQ%Rj7C$NXXjp#1Rw(x6_d6vWc|pJryZ*wH_$EC{d`8nR2seU28d2 zpm)To`GD=bHv(hud%Z>ljt&8Ddiy~>@4cMAmfk+=d0y9D9MPilSw=6BQwTyrv;Pqu)|rMG z{fErxaAJkk^`KH9L}jvU6uIkdFP1jX3MNaRw*HPxoV~|n?<2ml zKMs~!-si_&2&vuwxb^|&V5v^rxZ%&Wny2N64gi|n&~>!C98`O)RrowUH(l?hBf>&+ zmpiZfBRI{8zEn*)O>w2Nz3A6ke7O~EPV&B1y}uUmsXkf}DH7dUN0DxG6*!0n;a9iJ|Mq*<^IVC`Y7ptC6)j z?2LaqSt6Hx!@#-b8N2j2^F%UL3de!ZWy7|BAG!3#er^k&r<67GP=nQHd_@j;0AHQ% z#IR&z!gh7u;AuU4?&05wLjMz6Z4vw9=jGVRfDJW+85S;T3nk$6jd8oMlVZM*8T2New7J*wEl9y@uJ@-1P`O}8luKA^WG^z1V2WbP~xdLPl4>iQ9O<0K8=r(`6$o|wZIMzntG zaWZ#0IysFa{N0(XJWa-I<8aW1FJOddtv+fZt+2&SS$AZq!_)eWnN!4Eta0}mdCqtE zn4f%ht~%;C6m>Z3j_Xnk-z3}j?cB;*P-kQVo2_jI?^HR~fsNtImLjJpZ!=x3p;!j5 z66ji>f(O#vk3IZsBmXGoi_Yw|HjU^L%aQ+hQuETP?PpN|d0=KWH_Sp|Y$ieUEbVwb zoY2czh)tKQ*Q{j(AEah$M{lgo-qt1$o*TSY;$i7{M~c5{O=;ip0_WQy+B|;RA01sD zz_Na8sn50(nfMFDMg%#7SY6y(02?>=L&bVzI?tT-a|o@7R7bnd5a@KZO;Ax(I5n2C zf`XN`!u$TDVO2>4tS|p3M;VMN7!9!=bB$4kcs9$8p;5$wF$*>4#qVykPP_~~LF89p z&Ol#ijo|ns8KuP+ywZMK$9Drgl3S;%1ob{224ruso{A8UO7|=m8e+!lpU=JYXix6} z(*4i=XOrrPxPFf7L9i_C81~ileCnmf2Gt1xuDdlCqNj zCFxd~n>+jV%Z`h{hLar;dyL%yxl@N{bO;#azaw78=d)Q8VZhHg#mUb^JUjNvyG8nv zg1Wke&v~M@=u?BJKSpUOi58xn-g)Of_eEX77?SRqtAJ*EKU=BYXs3ab=_CGBd1eZ^ zSfc9;$#PlMmp%9kujE3ORfn^l5EYq=(=1$nyv9uNMKq*T6@PobYhc&${1Hu-)o3S< zNXd9!awvi<-y0CKKn zQ#l-=In{!sM~Hqeh=pssJSlladB&!D1YY*}$njlP2!TK}oaK!{`26^9e4eC(%bLSC z;(20xddqZp>Ehkmb<~DE)6U~XXldDE9F@!ac=vRFi$rD}h?izKk>1K_i$DEX1q6US zV~@NQoexe*=Px@ zfuH2$PPQ+2N_U6eV|TK^IS67*y*~31sxtuwT^<^1>7TzrH?Pin7!$)t~o+WzsmXWSEoF`3Df+OL5!Kq7i`6RRbTWN;(hQjyJZu_2)Y)n=hP$t{2{ z|L91l0f+4U4Sk#85DxNEB5&ivtzOjj&4BSi)4siqh$Z$)xkp3@g6+CKdB(0~>XO`?8lkq}pfgo#9lgUO<4I6IjOdBs#Xppry{~v1W0J5{OUh_2(!(i$4 zvdDM&qyyh3)SVv;4=PRRm1#t}BUHt!Y_Y5P3W-BJ*EZ9RRw;ev>B^C&Zt0 zx!8?L*|A1BKxIv3h}_Al&t=33O12T3PYj!;I_w z$!ZzIPrt?2YKU_C%x^m0d661)5j^WL?ju-tolw^fCgxAnMXd*>0|{V1vY^!!4l%R!*;M0xD~(PgL7ZO9Y+ z0^$^GU^Leeh*5Y?_Gs0on=B62#%eU*r0@=qaGbL2V7p&L8eW6fUTq2=qGb+I2)OS* z>Bq_fkv2r8k0xd9IX-?{t?IvtO(QYexa)9U$`ij+!0&Y}JlPMM8EuH`x9>X=1zgoo_D zi}hJ4)6sc!C&aGZ{ADfaNI~i}RtMTUx98w{theSf9AaD+*kzto{{3{W&f)0$1$A#A z>Lv6hbbzw3+_EtwsZPW!!B<#PCLy7Nsvd*v) z5Uz1QqV;?D2jO@Ti08yx_W-29c;-f4!da@*8Wu5Sw?kTppdoaAx-8&He4;?wYx->T zEaW5NWd@fb>Iof>8_Z{ON1cH;_Yw(d2w#cpWfqSOn5@}fYl@*pN!mJc=Qfr|BHlx% zA8gKGZ}DEelR8<9VxA(|$iY97It8J=;*l7P<{=5S$6P!Y9r2fa@gPP?+KWp|6>n3l z^Fq!m+`2U7aJo2ZeH=X!0*y6Y$$hrp8a*+%fvjoxC7J!!xT*dKlO`G%xX`4_FL?9P zc$rzf-)btbMLTNZ^MDi~)KSm+(t1V2o|OL3V~%xd{FH#|LgI+Pi&i`?&+Yy;yKH3r z*N3Wpq^qrjV>Vfwatf7t1^Lr9aoPLRgq=L}=0MJBc#h4hH)?X8S#YZDCWzCn3UvyF z7JV=gB$r%_oC;fg){mG!5885`6!g5ISoQ4vu7eaib}W`J|`e8;|sppk;XwC)OEPmgBOCv1*6$~ z2c24? zQx8hREVR z#O3&AU{6QkLX{PR?j>uzMe(!HtMzh3{5k16il?idK(#$g@)o!0MNYWSvcOEUs$<+u1b#y%!r8rtlftDn5JZI zr8=8;Jo;oI&|PGzS^DsL%_}&qdZJSjwx-)r?}D|fG;Uy{@_Lc`#ynO%Glru(hsz>S zE099&92N-b3%VzEpBtSGgdF#|PF5o41ME3GXXf%Qm}kLlDU?1;`Gjj8NJWt_~+!Jt(;%{ZTM!=s(6(?RXURI)f88G5Y>j3$Oxz zto8BZCfCE2U3W36DN})`xxg>}c_DkKqc~Kl$U^tzm-hmMyG;3>OC63=yKr)liZM*V zcY-_J*Wljr1RA7gkeCgw|@TaBDLsQ|Emc@j4EzC-2j8+2^W^H0&1-^$|D* z83y8?poZ$bQM6B7NXLUyW*9XZnA?8e?AJ0MrTEsibnmq2*daD3pKz;2+ZkW(s@&Ml zOK8cl21gPPCUmWFx;XCm!j^`K9j%)5)XO=zn;9g-@-Ts-%R<6dNyD?%0eQBDI~QXM z{SCja+M;O*cs|kQM?~zZU4e1>CtNu-T6frDzGmIAzAU$JvJ;A+Da4P?UeiNnD5_)P z6voWv;w0tXm11~6VL>a2FnsuO;+E;+3CA}sOLcBODuxfKLwBgI3; z?B5>VGMUeB1NeOh=^`*&NtkJ;yoA+m4RtAUM}V-lS?RTZG7&1>ni~N$C#zYAf5Hjp z^+st{xa|t%ia_aaV{VJfRv)Kk53WTWW4G@yB+CqJ&pbeV@BDBRMQc2it=YN*oZmEb zKE;)`nTojvXiS_tSoFw7$VU~;K0*N&^x3ZK+e=@2!iNb~LgA@b6;>{AX%rrC^|Om1 zZsea9kQuoIC;+vPg7b5xl-p>AG54KBbxZ<+u%Vq|f2B}lQ*UYTB zAeE1Zq}0)^l$ucrKebV3T&Q3(frLBdvkgNcBA}p@%rZ8!D&Vy{j8=$f<=kE`^^)Y^ z#=^+KVfyWpmtCIYG?cEGGV!#_YAXM>)@D>?-mY819(k*d@AZQ(Bg> zv^zB`DYTzJez-|uF`_dGFGyRZQh0}WDl8~uscWa8SrmJPo|F@4*7d4HR>e8BRQrRR z-c&`t9IaPzmGibA8Mct|GH%xR8xn%#Ml`YA`-A#uJxA#APM+vBGKXHHELH~9lFi!gp$bIb*D(^$s+~nwJ@guGfVKask0})@0*@Dy`3+U^L2JetgPiP zoYgO=KKRpn4>eywfb$cu;pgmAzPnj>sW+ehbOdz$5D5oh{DM>|fxjbU!BD5yESv0g zi4xfGnwk+Ld%jE3J1-Q!JZp_)zl7$RjDm%m#Y;lFC*=TNfiQ(+6<(ceX=dUV>kqui z;9MhZWqE31w~*J_W+wiG=D6=p_4cLHq!rj72O6kvJn7rG>FnZ`OKZwu%jw!0rE2>G z#|Lb9DDa`71gvc%XWv+NQdxG2!?A%G*A9L2 zzRghRp&dH{QCk13+gK2bi@#w!Xs8f9pADbK!~~^*mO4E>{D3wR1%7#a}A3n zU$~{z=6a#0+cDn_wW5jcc^UnlkfnYkp^ATSTMAnaV_$V4-c^_3vHP%5?@y%yPNjLr z--ACNPkYjugVo*g$Co|Q9v>GSsVm5^GkGX!&n=#Kvhc5|2BOsDJZ^ifDn_;1<=kvU ze*J_(XaC$#ZGYa-cn%w|$Nr9rh$kYv?{MJP7m7)>1w2*%8kiJ_)FLbRwqdU<{#ut_ z@No-X_MEU>1tPZHCzujKp9JbnClaF~py6^w+9MLdA9LAQAV?CRA;LnHZD4^U23ZiYA7w*$Na7HF$5rG%7Y>ccv zMYRNE$)V-vW%xW1+buWF^FB%^Vds^4y;(;4Mz3Z%8#%PmMS$g7pkvz{x4tj}<~Yq% z1D9@>vpQ$vgFD$n!=YrJ#@~9g+Ag_dY3e#4aG&w%{Nl1zI4s`77ed$+MBiI5r)9TV zJC#~gisZd|KtGF41pP44^UV1@yPSE&YC|i?;U%Ve3i#W+a;9Q&3BY9WSfN_7cw*3V zbe(j+imlEC-I?k$AQ5U6DSC~YkaTNE>diVkOFSVMNtTCyH|5)x{epB~q;^Guo--FN z9{!4I7;q|HLZ;fk{D>6nh)VA6@-aL@+*%m+k$CRA16+NV^EVt`O0^26Tewsb69EX5`NXwKpq;@tv!3+xP@KM1Z!M&-C00llJ$Ke`{0&)U-!77mIn&Bx+M-gZ4(V7*#5U!6!y zRTr|vQ{F4Pd1|p6I8ewN8(F0BeWQhMDBfj=r?*)>TrYm1#G7vt)`gEUKCB7Y$I#nE z2(ML{{8sqrS5D>Do+ zd6b^J?E4a<_CRZbZW=u>1=dENeYT*i=_iW8vajyrPpW z7Y7Ij7mO^8+phc6mIdjlPc`_CPBg-5g`Ao>SEqL$u^VDw!LLdg?EyWF450C~c`HkP zk-HMf^kdDXLbWZ$&jS%*7S&u&c61-}LvuXSZ~p8zR$9?nahZHoqp8eG@Iz;(v3+l* zaX)*pI}j5XZQzjX5JhuZ-gVrOme3u{Y{_*Z7#zC-ecLCwt^ zbhoEdJcOSmt)0wy^{I^vColK350>ATeA0~730O(*=uJGs$OT&{8Z~Ulr3yqrAG6a7t~ZO*@aL4pnm zt@+a1f)(U0cSPNwC8WzG#WU4uGyOi=#-#F2T;9Ml(cxdd;n-V8nJLHA<_AO(l_B3! zS_97ryDmpFWceOhJKJobl=T-LF^1h%v15j%a5i!HXXB-sp+HyNx{RakGp* z3)0jE+oDKmC47{7l@=1r7iDirj^R2zs)4qR8i9;fhG~}bNJDx)$s;a%I4p6K+iG$i z(^8aB{@79>+W)U%43oowTsa}2bXQx8T}AhTUT<{^E^FlAH@C1m^B zPW|9mbe7@7Pv!`#Omjskat-s+d}qD9vqCtC-MS}$iN|v-o<+PsVtiRh#6YcdJkODh zt5!JaJwGLvJ&tcYB>Qw7aP?0?2FX0nWm|!CKSqr6xCCao$eVD#&G;r!*x zP+WoEPDdWX`h`d^?Eh)Jwmp>@;~g)bb|PeO?LK02!n1?DT9L?qtm?^sHJ)UgNU zQ1Wv;&z!FNtkbBZudfL2%4FH}?P5cRKXtes+&cPJUyb9IIduUW`^ZIb07xDSE51_{ zYl^Fj>q~-FbkQund^%6>ne_F6^Nt%_JMkw;@tF(Xh=SAOIs8PP%oolMmY1Z}#G(?K zw<4!+X_7DU8-%o@p5i^$u$Lc>B=4n#3o(|(OTa`+hqOy>_e~g&;y2GtmLe|Xm%vlA zryi8z>4D+iktkjFEgrzL08OcPY@jR1VEf__ohy6HbHRJR!^3*>`t17h>1N{fv%;!Z zUHL!SA>BiP^;4Q%38tL#qIAe%KfZs*xGRM1hswA|N#NJ{4!KyD+bL7~zxMFfw)it= z+ZTaVRerV}c7*aSf97j7mb?g}i^52TOZ>{vnRxPdTr{12&&$}Q(k2g1nLtF_BSv#b zVU@2n_2eXLrPvUtKXS;r<=?PS(-MEcdQ|rYiEy(j9)L*T_;yA&kR!EVK-YZ*4t9~j zB};%E`RZcqtM|0=UCq5= z=`SGI>r%>#vaY)~7$JDLJ?bwLZsr7zt~oZz*eBRdbi>WGgP|A7ZL%`>n&umS{kjP{ zc`egx3!ZFPVOkAx+~9)Sl6|zE^=;_?sG>!4M6;~>V{V>o%Q+6-+gCwWHNX~-7WZdb zAou3@MSr8Qr)~0PH^-!?`FX;arp^*v(T^)ny;^0Aw$EasKUIVR{>&-+WQn|~fNa3< zJpmV_M90dfdV=oWuJ6PBczeqF z^eTof0^#*}O`I)cocL%6PAN1K{-25DEbin3$WfvX4%e4h&8p;1K@#(QvJIIQf4t9W zA8t&@(fJ_!e{{WNR9wNb20D0xy9WXU39i94NP-jG-QC@T1$TFXyE_c-?(PJ4ADB1E zx#zz7e!N*MVAjmuySu7OyZWoopFh`I%>NP&B-uH0RmE|Euf6Xg#l#?iRC#<}7gEXJ zrIy7;dRw>aMY(OiQ~4N^>vpQ9oMwtEq9j@&!qhDi+B!G~TwUr@)a_qX0<&C6pr-7fTG9*!mW z9CaJXTJ*dxPx;ajgwAj{^U`!>{Ds}lGnqFt{4^=;-B^8mQGb|~Z#;_2(bD>3ef|NJgoq#U-7V;4U?dT* z9a%&RwZ2DI$fD(=h*lKjSZ5MYZWw-0m8hU=hte=F`V_%?Z^LTGTH|g@*Q{2guj}`C z?Ml*9Gt*QSTMWmDYFiM7GUl`L6KUuh^N`Qf;L)VDQAcIGXCN%p-_B(UjuyAWZ%Z}1 zd~A2>0CEZn^?Ez9NJ4Fe_%ixJ$e2J!a#(<&iHU>MlF7Kl{dT>RuDO)LFm;#?aa|k6 z`B$|m_?*RCow!w1g5={GxaCHkNd%OE6ElMOdcLaff#$f;O3mk;b%MRrhX<{2u3yZEy;pl{=HV+nLCUC0|GFtF6%6>UY&Ku9>3Epq z0u&Tt%e`KmH5$#-XUq00c`x*?%8kP%dYNpMv$xU!b?AH&QDDKZY53B zJJ#)7bo_3kYphi|h-(x5-wO$62mRR zqw#N88fY|T=E_px4_bI;)XaB^f#nJUAdEv*_`l*63N7j6bPDHwnkDcG2hlMIezQk= zE#|Wp1u{aj>;&994-q6BrFLs`C6l$!fgFh-jz#+WZda46fUDoH{A}ek$vVy@8EY37 zZSO?1Tr{-3Rju)${Km@5d$y~qnVrJn#9G*o-E~V>lde*t6?Z2(7-Y{k>d36roK#vlw24HpACiZw#o_vNM)lFG|t2TYFmZ_m6z_h%J_M==q*=0e0YnvXB# zdps5HoA2(xWJ(hIhvZRZhS9E8Vk#MQ+b{eZFY- z_O;5b2k~e5Jr<-(PF2C^-~1U~{OA|JyQ#Xv3TZhH|IkpOO!%VN;StWwork&ubklh;19g)Mqh9q=!Qr9?Yr zL+(lXhQJI_V150?vT%TWMmqp{&iD8M=`{9Oou&;9E6_k>_SJHs49NBn%wXzKt9xujpXZhI5b#|bHJX1c5 z=P7$SSC0x$mx{$=#1@w#4kb6ODBY$&3YYTcFIhgfcGgz@PIv{w9n0eA*Vj4Co5 zM2&E_V*kMF1b|-l=l6sU2vC=$eo_1Zfb(?YA|oTq5O79hMk;$us)tm3;xc+ALax-! zVQ6Vz>OD0}3tmL{Mebkbh(mx8R;XUB_BB9QNWn6Ib01QUNsqUa0=uZ1YB_v4%mLvO z_1q^X-aV(XwObZPjxj^3IIwCP2qWf6uiu)>1oaxD=9}1f+?KpH-u3TaMeaDPk0A7? zR`F9^4s00Yr<#ActN9!iU!Dz!@#}3wqbAG6K@;Rl$!gk=G^)0+Q!?69_wPLDvT<2p zjrt%sF)%5x8_B66xm6Wxo)q9GW}UpZQ%Lg*7JQ6<2Th9Ak|Zi~y$WQR4tJE#K~O&- zft%#mM?f!s!6twEt(}AU>zXS>sq#?Omy3(^9*bW$N>dx}IWgcSc0|UKyK-tv4p*dc z6ahl&cVwlinZ>-dwz`Oud^hxf_wOtIEak#fU}{Vk*cH{rXD>>lQ~@&gvjh={4JMdW zS%WY5=XEJVbkg5I_?`Q%jF0;H{vJKkn_2u6lhV#bHG0eGsb2P-pUC4%o#6G!_>}x) zhasy%q}IdJ<(Ep2SwJTj)*}CJQ`cXu6t`tFWq0DQY*Wi2l*(i_^}%rn6Tmk|MEHL; zDnSDJuQ&ELYk0^^I=DapnWx0Kk{R=K56)KxwI8E4y!0kEITF**5E?9j>7t>W1K`zr zC;3B@xmQ&6UmWsWmgAHY)^-+6=U5Y$@Ft15R%H|6;~DgNjs#zZjz0Tq|1~*Er0&;$ zsm6$zRVEYFWoh?pPWs0DPPYsbOq6*ERsz}Ed{+*2<7Cd<@%Lc*)>m9?d`!0eDJei~6%wz(>(6!z2xPneN$(m$)g6Y;lupy*u;Am^`F zFqo=h7ja|n6)F67N0o$y&N(9zc!gU(o2V;$>xDw8O6JiS?DNfoumTHvh|v9Qo}X>- zaj&E@imn)*xJ4v?Lw5wVTVitYoo>YrT3~%Yd}lBw>|f8n?30eaaU7S{egDQci@N5CDXSnpNjhM*Z2K-RA6U7L&%^VGQ*!-5|{vN z5iL+&-n&uO>frsDRK?XGj2+Pa?X9Cn8lEkMd^>uB5QT?-@J`8DT-dP+crwu!yRLwC z-{qG4xS5vf${aP6NPqj0mWjLRY1nN>;#4ZG@4UlCCTHRRj<8_DYsBoY6v2K!~22wnv~ zc(E{i<(fw&f*OX|gf9Rwj_{7;Az!OcjZ2m&_Y3nKdHA>IX!@2ISdX^7o?)O9hn~vv z^Se1?p0j~5(oNf!L2fZQ9E+T-=DlgR!tUmJW*j)l=oy3@k%JtJe;UKNDU;TC)Z6?Al?=4yAPj{3v&Gx<-Fqp#Oh*<4H?DZb!KZ;M>fVEUEi;7(Wpaju^?MP zV79{gNy#YkjH}H)-7EFlVGZ`fL{lnwTTZVljwF!82-J*4oO;VLNS89{A;ZZd?mh8b zz7<-GdfPmp(UK_MRCuwq%I&aa=#oXh|2mfacs zoNtPp-~HcYBtHRYEc_6_{kEe^a>7%!u2(+hk*Z_-_U%8^E2 z-w~Rvqe&GYT}UX}TQ7x&eUQ2sUh;Gmnbmgd%8EYG#><5SHVnvr>VBpy4RZ;!X2odQ z3_jj7L|A>iH|c>FjA~G)=X%(3_od=)o6Wgn6BWFti;(HkJDPhx|3dLZR}@#b2$fV; zjglp82Eia5n8YVSkW9h*Z!N&V*2bl_a{6fr6;GtCN6H|AbG~}L@IjVbs^G(i`#tRJ z!eN^ z5Jvm55n-K2^OLRzOl5=5SYM0&nu{i<&!YtcZ{5e|=MVzUJR*jCvYT#5d9rt4raI5! z{kNa|jx-T>`=|TqqTa)X0@RvWCb=SIjbccttV!stb)_aJ3VeZMkG4$q>xOa%4ckyusSdNNTzK5xl-di!_O*Kgczod#+@*-xJ{WD0 ztA$h(DzUY)+*4Sp*E%5d$3YX_8tnAx{5*5dRIl6E4*8=K;n~in&%Tpp!ZYYglUA0} z8w*2St-BsDaM*Y#wfJbG@V?88me%N7#6Q6G104gNL7zDBb?ofd7m^7E*vIR|~16Y~1RS zIEd$d2}eA9Es0NZ7h8M&SVq?rVArjt2-_do%s%vu)MSM^ z4(WedCv<0{=NU*=imZJ@8r)+dqIUA!e}v(onyCaPy7@e&kRskED~H@NSn>Gq@_T@OWjf^#$I3k&q$IldAwUbW zoq{}e98_?UW_n|pY09R1W;D*~II9C+Bv=D&4^E#F_B{cZ)6UG2w-FZjewC^_5oG}s z*>%TX%?e?b%-tRFe5?^z(Jq%c1>r_A>yoP^Ehpte$**}{hKWyL1VuY@G1*1~JOm=$ z5Xl&MA&%VIw@j=H{AT#a>FCGMtfG0Bn!mx2!XU&op97%1)$>34&~Ctg)R8ZB8fan8 zBuN;u!-j?uY3Q#|i^z2Ip*8(t3QtvI7RysWq}Kw?fIHT)e}|rz-xsv2DVREznA7N< z5sIPsp4Wk?(v}I-bW@#9qHnNiCXn$Z>N^6mjfVrv?%Do$uH*Pr4YEybAi-{yp{WYe z0KI3h2|z#6OwY;~Sm0_G(y%pQACLd#z~(+e4!%3y{TGGcD{^=2ogizoB2uL}GOsTW zaN=x`VC_&C{`j&tKzk3MA7se~OiuSP(A$*2m-I&Us!rTpVEh9MH+G%OzWNkj8ZQDfW&I zv6hL5W$RcEaJh8Y-g2wRTIQ&|6NlR>Mrn~Mxim;fHaz3kg}$?<_CU*yZ%SsJi#JH> z{U-$HlvI+c=5O3HLM4Z|13ldByAm{WZDVE4W6<$Jc8drBC&%CP3G7-%@3A=#-S9!) z?xn_>8AEhqb`&;Wc;E3|`f7PbkW7$+_{4V5(0U!?1csveSTGKJH|?-!a+E1LXSiFV z;|_;N((UNtu?%N0-`ib^wcZSO)+*R-y{G|Y*`jXkqK)9m9+}>7Q26HRXf52${Olpl zcZZCH(D?g%eH1l59o-VEWiM`hTPMRA&%HrkcjMCfAUFD$5pV4)@66eB-zA0aYmA~p zVg~5i5mi*Tw_#ea_9%Tv*`B*INJheGWqmo?l1Oy6TAdR>}K*^OSdS5oPP0wd#mG_X>f$+nen18SB55B`e%hbvq`mZF6QruOg1HWS%ixt0k?~ksGT# zA}3ij+1z&2&TUisYn(!DFi{2tO%?(w@Hr!m7s|gQhi;74!dW7%4%Rh!#uQ~|jm=__ z7Up|1fm2@ySCOK|{jE=>(cZ>sjT_W8m+J=uO(%;IBEZ1+DwAo0&ttgAS&ztAAv)1l z^SDua0BYCE?PPWKlN%bC%J+1}K(P!^N{cTzA;Ts5^0rT+`OA&r0pqebYSB{NA+}7V zH87QOuE=a29 zB&nn%o$34I@$E$$pyjH)dZQ6#u41DYE@%4Va+7U$yhneQ-c68MR+*{ei<*N&7fjCl zysQ4>G3e-rX^XZ$iCA8KUUiVT60@`RbSRYLo5gS=yc%o40IA@!D}3%RBz@TSEddz=4SVdFm@e~CXpOPACZ;~@6=#87pyF|2TPZvQ+vED>=zWr8T z=9l5`kWtH1#;>=V9Az9cO$KpUP6D$n+vFh%wc^u_oRa8xaH#L-#WO?+^!*}gHquHp`kAUSooo+`P2bX>jSsnT!*5ww02Zdk)#VoO@Agw( z9{FfSrD9Q3|J$4Uh|v$l=$fm#NjJlN$@lPoIRS}7Sr9qwWp3kGhWfyQk&n?a06pih zyLgV-!4hhmysSF(4h7+oGgipqsKZsf?R))(v}1jIGywP=Vt z8-thTarz_ArS0W~}CQb=ggGXb{(;!mSs^Q z3gy-eNyen~FzfXP7J(6{h%f0ck9si#D%(`XL|uFgJD1H_`Cmg&>uoZ- zEv1sLXUf&f-}J_xaJ3=Xyc8AH%^=3;y@r7?`RX$yFS!Sf_eRRar2&=mF2fVmBuejJ z;j7d4v<(doXnulna#9ebh5uMZgvM{Mozij3-_1p4Jf;dL=)a7{lbph8;n@x-pw={g`IjKCAiy zw@5C8CrEAjG-Pg)N30qKY72Tk33yRt8+IG*EjjsUQXL5oMjDH|X%CqTk?zT=!vwnk zO#{OYT}X?9UxqtY`Ysfzz4I~I21WY(w>}{PZ|WcU$K1NNip+h+ym5V;yMo7IimBYu z9=Tp)ve$IeQ(6!kD+p`qIC^{$D{IPtx&1y~K}3c-YKOTWbxb|`N2(5#`E!gKgFzlS z#PVT0@-l~tKeN{)y!UJr%r84dGD{qDQ}+1(?9S;4x{n9ExQ9sIZZe3T({a~)2UgO6 z*@|mtp=i_u6sCO-dp+adtKh7=o~Khl63#mgKxn_&c%7{*s8@fXh0U8;9le{R$uj2; z2&lw*bB57uI}cr^w|`?3MWg z+kJz!P7QbLO=H!QqogoJ0c$zC>Sf!!X6P=_cv6?)T2y|8afh=&1hU@inhRDk$^O?y z99LeZqYiD+s^ShAE+*U{zHA(6(w54M5z=&bJvcAehv^_4aQ^{+s0S05SK!1^17RmN z6NYOB_aemSq>%tN6pJj7A}91xtxO_rl!3TR4tAdeNMCG(kg`-$_S!OyOyFkV_(_Oz zw#LU9i4RG0;#o9%qr(~pMZ@KXPmXr`P~aDv6n zJ}h?reMk)W(j2u*fHP}upnW0{sW=Rd9KLFN5?wdZ@R9E*gD==VZsW~qe zdBPsbw(gz(o!~AFx4P%mQ#Mzb7vLHZWmt+x{i?Rfrm%x^ZOifWJ5yNJ7LANDjb-vC z7=Ysouk6ADxVNP7`M~xid&~-^Od-+wpJ`AGjMSa~a}o;-42J`YM|qU51p10GJV7vz z!9{}GPCQU4Ec{`RjUbP=Rgr11p# zlMomAxmL>_44})tS?wDAii|MEy~dm%+x?+9q;5*_nu4P`$adptvhoc~`EzU&ZqT{j zj)&uCc^EEhSA+evV`jT7?J|)F*Ha*l>I3$vk(3Fx&IBtYcg9^kD;Pcz2y0(6RXQImpk9j z+x#!G6-_(GRoLf60gep(^TE8rP};zb61|o$tXcH6Ya>~fxwP(V6&V|(J;T^^sgo9N zS;!e*qcBVh@1h`Ugo6EAr_ug-5MB1XY5OrG7(=Y)j_|89E9WYgJA3nnuli719`I%+b6T==iX32WL=nG!x}#=-}YJ`II5~>eh%38oO<}Wv00w+HXwOmg<_ld zgA{v=3r?4V_S7ol=tle5BV_KG80y_Uy+we+5NIg?#!#t1= zdyG17*jJ(VHl0S$O(Boo&9-Ulbc^Bwms+C+ej3M1hX^1p`(=3oQ#XknrHUy@Xd#I0 zu`^(^8X6+vRI5h_u3SFsd@>Hxx{WO-x-@H-Rgm0`@)bJRgO{KxBI`&NZtKK={zZm%qU*G(W^}LUx!YZv;uBs-S@{Hi(#Ob0e=uvBrI1mLK#@uc_=P>ygYe$0-d1iR9@fr>Yun9pbJ3SXdbbajB&-DA;k>=6jvFH!=>v~c?*L<6rpsV&?~ z1A7P)xmVMBa*H3=g*-=*x@vdM41uYCD5}D-7!qkS;>GUW-49oact+mL%zp2*3J`gF zUuyip3YTM3*l>ie1ok-2NSu>$fKb|L1T7z{RED2If=!!XyiM&kN_CK&)qyTAUMZx; z+qBKNixR+&FJ9B!M!fuqT}6L*#J>``bvz0VlecYMS^X0EgQWM|z5hj6;mRF`ASjqO z{nU;q3**a}7tE+)YBO6P0v9=~96#Nj+vWMhfcjh-VnQf z*WMS8(0K>CQp4uc*UQr*iGmXAx8!#0Kv23QP})BVIL&pF`5+y*c4~D^83ZZ)VD+>_esW!M0D#Ru8F)!?(J3c_JD(`VH-AHKrS zZ2&nQ(^H^FNYGYByp&+Z^5Iuro{CGT*yUN~g`T|foi3lMk;l59&Au$~vQ<~!e#Ii% zK=_^8P-jLvVt_!#$y=>`(OoGSz?WKx)Y8O{f4GuV)0gEWuWxjpiU*al$8eu{VPts`1N*O&G#QnAv3y zu6O3iK^C7+uB8359cu1f^8~Yk&Zf1n1yj5$9-W1hnJaYYrPkFvjSW6zM&8LHEI3p3 zXr`8 zSi7MvP+yo`a`3v*Tk>e)*?;E<4BWb?Osuj6?T#t6(LbE)a{kfJFB+&K?*p+5y z{ca%SZisi?Z%vml#x+miDc|zQD+yKz!nV^nGXOKX9a25f1E?Nv$#+W#&N0J!FBF4b z{gze=w_{{pRable3EX!66}PkXo!>$QmfPMoP+2D!k`8Gd6ZM`9+)=&Uv_^qtOjEmR zP~OrLSOEuYI*723adlhg*dY4c+&?KS68QzV8>4Vy*(R}SIcbFkF9U|I@<^1JPfAj1 z5RaR53KH9V)5g@UZK|On|MyC z?B}1A>~QWwn5IDZM)Pqru$8hoN}6fK#P>529P_s4Me11l1@at>K!PG{slxNC8C%^n z_>cGtL8uZlg)sLq8mv2cLLIK_!X-C6T!QPhyd&_`vKQ~Y6EYAF?Q~e;CAUw++h;Bk zxO?!BZ-aP>w-d16mQWRx*OVGS!UF=n8ahzX6eqFDP0!}(CFAlJv<48A8HgwGO;C-1 z`HEM){nJD;ok04(=|_)*Nn^s!DtDMp1TC6lxta*LiYO9F;j*NDZ;=uO9bTv;sMbxl zlexVyVd~a7zN@80>EH~3dqGPDgSkno%lbM+cpnaH+&J6w_3wr;yAjm8ps zSw`rJX+#XiXS;GgE7_74>CixlT@Tt6`m^$QG3%>Ye1_VW7iQj{Ti%S&hGN)HZO8Es z{vUjua7LAv9V33|ilZ7pt!SPeisRU17dC{N9gw|}g$@Fh- z{whf;zSz%AN^(=zp<4Ux!C*%FrUNw0Eq(OV1YqqaZ=qhkD9FNYo}hb)Ho?^?zEX`` zZ2=#iV0v*;d>^*1vEh7wAiGPP#Dl%UJ{YAHPnznV#0Pbb|FrC7raCs=n7qj?fFVO9 z=8)&~`1>R4XRbJLzTeLdlj>9&K%j{7F#f884P#ceTlHAe>9rW5FI{IqGTD2bgkbHD z@Vf@Z&}WDn77qvFs(x9N^i^&^={Dhc6YtLDqer?{;3O*6jOcDmrgYOzkEC0gOw2@O z<~@02==RaQDh2(etvkp4JC1{zX`!6si&Jh#x{NnDU&6^81X6kscm)i}Kjo7{b)%lG z#%F;3;+oTIaAiYa#q1X|U9a~FhEF%Uy4Lo)_&iaia1mOaiP=n$<@oQM5}P0;IiepD zFT^xYdLhm^*ahWx6{-L@^|(vk#Ux&X9I2?bG_FE%d0+S=(xEGNF{Oo!Lwj1Sok+my zN$j(3Kk=}{MS3(z{EB-)=mzD2lccBr5Wk&`<{1Ze4W(I6{jj>Bd zj>A-m_V?~}UUvU4+Ati;o;R=?ZD|NAysIO! zE}ly>_o^BPWN7Ax>*XD@8WkPml4T7Hr+TXlNoH*th>0ozR2yvpjA?n@W@Fu2U4rnz zY{<+op%;e~X(wLZhu6=ni(ZdjUAh6CPJ#M8{2auK&QPd!L^kwH$p(a*a1YIu3E)2D zN>+MXPIP@US}as(UAz?yb?(A!*Ta|ZHqzPwc7rK=U2W})L*1b3hm--={?|(}FToPz zS+oE<@DMD*1jg<6{vi8gL-pMPt8dKvle&Emt{%@RPP!HWin0MJ9CqFr#<1&WIbNDH z=U}|xlMa#c)ZoL-BX>OGXbpSon%%eJu~~$JcXYwCLCy(vCIdn(L^qr3cE5vayR?43 zkY>pajU&k!LK?zcBpS-nXX7_Zz$v;!+Mr(J+aKkc54xC4hbO=6va#>PS z394G=>9nxHm6f`!{^6n+LmhY+ZUS4+!FAVC&^eCLLxm~qORzK|KSaaV(Z6PrG$oyd6n15V=)Db@(k(XOM~+xvk; zV8R27u*v77HIGJ1TC7TjV-Zhg+O4v<%+)*Ex zd|&i)5}Pq|RI5cEX5La%V~>u|tMmRefs~B@9A^dv(Tn1~P& zi$6c-!=9{u*h+)cRHh?-gV(b-7VVCIeHa*s6gaCh84r)>Iv})---x9UpKH^$vMT3% zM97i`=1W9BIYljQx&`hjP(a~xIDCR&c$Uh&goO^df2_lnvQZuJG3i}j?*xoU_?Pq2!_GHG@S0ufj zj&9i_ZHUZW6CxZqFu$>3FETT)ANO59IQ%gHW?H~C`MXP0c;=TN)979_u;K~(+9|x1 zqdXY!ZZg4V?57BR4pCru2mOV&cWAPcsrTB0!1yMB85!m#9mQ0;<)X>+SlT<)ZhZXP z$)AzYcZ42!$GM&&pBLaczc5?V0~>2f1ha@zHk|Z4XQzj#?u@GmQdF^LoW;(pQN}F8 zYbx&SwN}aTgk7uf^Ra>*Mx(MkU1gwdqHFf&q6R_4vXf(umF#4n(+Poo&4Xh z@$l*x3_Sx+2ze&b@N_O)wA9tJ?{%*cOt2Cc#T{Mdny0LHFZtI%NRJEd77gyIt z`d=JcO@}sqUulk1X}=PK_WIVUEbG$3vip+Z3mL!N-O{u}pSP#ONE=?$`;NP)9naf8 zEHy3{zyRF-aVgvfu!CLcALK{)BofBE%Q^Abt zN)nOkF3`LK&$Y}S^YQ-&K?4K_2SdmB-kRmFT8~~D-OSrmdTwecneGn0rYwv?ITECQBFA9RSr`wIv)h&_+O>-4tBjx41!1i5moO>_l*wOTh7`pIwl{(N{G4ay4$Q)8<8=wuu=rP2`Pfn9vFSk8cIz% zb_XMOAr#|?;yCPV!5I&%Gm|u)VrlnB7KM!B-z#>a#|rQUG7sC?d0uU%R|kE3eZGU? z6Ydg^R@hlJ>uun;B_T{33{m~x3zDuW;pdf*%bue*5unVYAcsV3+P4?AT-0?hYNsxl zQHd{&9)dzbZdRUEk57{wFNHFVIX5mX0oknox&Zv8s3;@0k1e!TNr@HY&>QT=ch7Kw z*&+-Ql5=eV(6K%sGHQ?4=2Wexr^oHMq^M(5JPIF}CMa-0z@ql=>c7AI0I+~My63m> zNK3Du>yQ%v`F9}YU%!4CJ>Qn_-ObHfxxG4Hn03!XMp9>V6$p8I$3x&tiNa1@S*cnj z1)wQCT>2lNTXOQuu+4OUD*S1l$DM^!8^jK|2fC)FrfT7?M#tg=`m8ziqTs`qtKX1Y zF0_B^@=3Ob)akn|22$@{6cX9!O}sj`90lvn(y_+%{e*3_9yPmd57tNj@Bu~W{_PaE zOYVP3cjNz=zCA>DurkGcF>|c_L>3SnEuC9H5a`(6_=ao z+n!g2I7b9(?e^CU9O4)@k|I4qI%*w+e(GJXzEpwYpVn+g#B9*c?(JnvPJlD7hGf0;XYpz6*(+t|(QydLqd;8AgN5Xf-u!m#x&Szl!SAZ($1#+3SOn_(je1c5OO4FFx27|=F2BCGTJ#VSxNCASQ+b^Ik$J`9sONH6mZ%ChY$Sl6?t$>-L- z_rm}9W-g=Xxz^$&=eQxLTzEm{?7!gCiRW&;CG2Il!%T^JtBC&bmRnm=?i{D(BIZamXzM>MFS_lz50rnsNh2O zqRJn*y;Z)Ax9yY6IJiGiK2 zVuP?xS(1D5Tv`=&HDGJIH-v!Ih*?2Fp|5|SR?t%r3_6T8Aw7gFBqI~!*wn;*lsDy- z7DqhDAR>ra0y24BYqsw=kNF3D*I9yC41L~rmnu)jb~;<$Y{o=m|4++9i1mxY2CxSO zIooOvI!A{7`nAJk`<4n>8WS1Zy%3YSvjwz;ac=d{h6J#qNeplwd3n=Ui$Hj$6B*_P zO!+FVK8ZJ3L5Z`6Hs+Axg59#QcM98~4gjKw)T-@b(SZMHxd71su@e+q{Fpws(-M4d zk63=x@0#BdlUvGdH-)m3>=z^S?`|e%AvXiy(rfj-y}rQs==`tRi29`G4N!U5-{=q( z7sDXMlSpRN#^>h=TI+3LIL4~}9IVf5ef(j~chlSHXa>$N2#Itr5bf>w!Es)~`@gM@ zL%&HJ!&J*a`)v)w(lat1914QDwOgIGle-?_ykBm&FL(v}_Z_}?14y+Nn$V*8+A|;y zAe3C)rtxUfjmrvE7x5+@;{UlBA^_eAJ?1%rkmHvGsk*FNzu#Y4>c0jry1hmU?%Hu_ zIE{sdW=W^>L|Q6RyCoZ&n%3!Ulh@YOb&MkSE;f}4|F^}hXu&?u%*T(`BmmgSKixM6 zSg#I)^7F=4;R~Xp#G=(GQ>nfn$|2};^7T4G_6Tr7sqZC0y{@0CrwWzNN+~ys=nYq zmK6a0`V#+M^>AM0Pw3yxLWX%vQ3Ai^sjET=2H*I@hC%7$>{r^7U z%Pi-n7hLy#vhH;0F3taRjD*ONbuI-QV4Q*Rzmg15yKcfC1YWDs7LppcUlunO%nY8r zTBH6eb~7~uZVpeSU5yF<$H?;3B)O_l9|pzPkf{aGr^q<3`i6hIX1$%d# zC~t~_B<^Gi&Wby~YnmVHU}3~|D*&pokdANz`VDf+iKVGHek7%p<6=?EW%V&5ui3ap z0<8)di9W;+)6WY#Uo$uZRs z0WJnfIU^wr_l#jqO7o;@>o!fUsdL7xsdgeJzW2^6n#5+Vsjlp?J%AJ|NQ0UYPBG{2_%n z&lr7Aw@A$m#&_<%`3p-U^M`ark!gc`*_HX8t-2c07Vr8ZOf8Wp-cOZQvKZJ687i(X0+p=dMB866aW(ywVz9^-6Mr)54y0qD% z-7~vaJsqVRSg(YGc%xUs^7t4XOq2(MmuHO~8O2&}z5XC_s9FI~o<-_6%M|O|=Di<` z9k=9?T^qxkMRcl8`!i)B7@19(A3`QMTwo!pO+^9H%9hX+HD7K<{#jiv=Jn1d3NO(u z&^N^s-E|&kNzSK#qFk~0EIIaaR&+iT4fSK7O-+ruSKhpEKPwo`rdT zrX7RyGss4t|J{j6FJ=y#Q)Fj`kG5RQ-7p?8BUj|Emiqk2B@KC?oc-2`muxn##PqZ+ zmtBvf(FF+kHR=0La0LZ8AiU_ zLi^WhHILN{;^B>v6`YeL_x4PZkgo>c35cZh2Y8K05IjeIEUf7a?JB+rnY8ie zK76z{V8v+BTyDQ`noUPYJ2Tjc^BGXK=YP-0FY#IXXyCg;oq+M+hGE9tYFO)a?*=~& zH|RZ_vGXE)P_O~NYZ~T7E9*o;fVI zeJVR+97wJSg0;--8u`&ikG{jxssGgBvg)gD&BdkpamhrcoUwOVhAXav*@eo2Ku6SA z&jRTNp(960n5>HpD1op1)5Z(6$?77D<&}zt^CRjL!4g4c{+7Jh#3mZiQlAwSNCGDG zWHJ1FfpvoTHJD$Q!N(P}C$c|FWH9OqnESlQ!q>y58P^ubaHLLb zzQ`ni@kypNb57LL6St=qcRcju2Z6WPr)}chUDYqu=e}t2gqXrz|4(CQ9TnBr_Wc0_ zkyN@C#D?6JE zoO<{1Xo9AL#j_AUDCl@FPcZ9Fq$)vSEmL^zrz8(sjkH(?KBGOUP?wrcn6ZjNplqY2lGl$+4ST^qqyHpIxKY&IUl26}}BcOE|`YX1ez zEJ5>na~C{8T@WR9@_henhO&|^@dC3P7Qe=4*=U8=OI$+vf@-?#)m3OYbK~g+{k~Jcu}z>tng7FVCa`>&YO8RtPO3O>3)}QtAuh zscBDH<}Q3<#36j11zjX&+!p?5eCgIBt!S+2&Ef_y>fy)U;3es}ZkV2QXHQ!A%Jcie z;BFZLXywb8hUmA@n*?b}Q+3mU7EeKs0D8PC{kCQ52^Tt@wXoy?Wo`}A??Q&SWd4h=0VeW8vla@ViTLzY)(;OMV&`WG1t0ZLjKu z#y4JPy*l9wxsKo8*jKvRvUhc|-oVioau3~{AA+{;jRN)+dG$J)4t`lmHV z4(?^ecov007V8HG16>y0W?YNCXT7+q!~olq>ah`X;tMIclA)S9MQl2I$>ZtltP?0ddqCrdr4P!A8TjqVy>c| zW5=-#_VpY4$Q%VMaJlKoKlZBo#yOjSQ?gGkJUgt?GZ@pj_XnP9b>FRu)7%)cv^fI{ zOWoH6+(mvH8|)Rj+vt>-m)`pff~m%u$i}@$iyH;s6WF zG6y=^FR;4jxIoO?V!srnBd{UizzAmLM#+x~x*AA}evsj&5b!)PW9fl+(myF}&s%8T zWQdy`(Td2hfWY$>Dy<)ck^A%3JUh*`Kt5nFfjv>2uwO{C#`cM8v}P{6ccI^MsWiRO zEo44!e_Vb|IlVBG)MQPnz{$LFh^S!6$q3mEwSJ6h?FvsY2pLuASA0r5g7V8;-H@lt0vfk>Jzq3C3sq)T zwA}&?cD+1bm8a!T6&3bEmTA0r)s!v@DtyI^_0R$#`^XHD_;HUu zWpE&G@Kv((`GYuiL?4rtWU&}SnRoc+ouO0_0>gDl29t9PBCrnZ`N@n8hZO9ZcXZ$R zTb5YEY2b{wMN1I%pykBPS*o(`naCPLdC^mFRG z<4i;*EdD5BJd#>C1@?O42#)h)FH6HM{M);P%Hw035$q6Bn%$7)3=TU{THWG=n9X9v zEyh5k7ZJ98Sn}mvWQfiJY>SA*O0I9XhSWKSqrwY5RWHQwGjPrEwy>HG4saNx+L(`h3P~c5@84b*QN`$I3PtrVNFP^M+GANZzT)^`yet;j3uE@YGUa(ps~9}`1T~>r?_7lNxQ+zK4%4~+RiGI$VEfj_mv7pDs=~H zF0~#^BXH6tY&^sHakqvDmjNzMod~8h?sYoKNnTtdJ~92E%Ah*+`>qw_14eit(Y|ok z16>ay!@kX2hTH-L0iJ#}6wFgo+~ZBRs9Mzw|65BXhK64HrGeGx@h4&XcgXy@(KSs} zvW|R6rz)#%Ng>;ATpxC#JmO^O+9P@oNv3(($Z=um9h#!aGUIbH$$&9Tyl5$>ScM-) z7m9;}%%d3CTMb51Y#(vI%yUc>LhRrfPxvHC79W13WG7@Jx~)VwUDJs8Qsif)J-wnq z*R);iDO#e-Id?%cXt~Rj>)ui-QdYWSI7WQ76*IWyA|BtiC($iYmmDgeV*{XS4hJ{e z^-hneL~(|}>7EbPUl2jsSAZ3NrOO5K;$cDUsMRp4+!Q!K`_!wri-@mDp7P*d=m-aU zYR1H?GfOnXAf(6~R$ONwq*fMw8j%`#T95om=3^r2coN!Qz}HeUoLU-e1uQF)QN1Y<%qrGp54_@69b}f3&Z-n+ z@vZ5=kIIuZJ4iIyAWo{`M1{*x?$@*jz%D@2=&KMM#lK-~Q0 z)877K=*!CoM3#>0ri+AEll}e%_c%teU6qJw$#jf1mhLvb9EcU-c)l7s17`An=If=W-&m=~V>-&$@V4Fno2c;O1q4L=xhwI|ToV z*<;6s=yHW@jF@LpuPSR#;)Wfn|Vfof;Kql|(?68GrZ8{XC2iEqbXR+`jr z<@^lK%9^!nhv$zbr^ogee##;UuNG?eOB)*Ut$01vCt>JCDRwF>@QdCz{Grw`;#|#Y zO&iyvi4eUof}iSG{$ojl`0c^kfxY?LC;9wTcK0 z?ZbYI(T<nPO7t98j;J6Peo?Dz#=k#(z{2dac)O!xJ`+=S5MAQ_#;k|j<=jVSFM&~0x- zM)rYv+5NI(+G|acA?SsIxy&Is$BV!T>FA6L>MOK@<|hc=ZsPbs2w(I*&rxr`6fbv7 zdh7cja`PnNxoBP_wg<&y#{-H)mn$q`r6KUg~|!@TB~*Y?t2RGmpjYr@KCs zyKkQHJ!0KBuB*LlCclGwJD7-r&L^ZnJr^t|mIi2$oomdRPsQu1-%Lxscx$LE&2@2Ve%ro#oVs71FVakMRoR~@W2 z?n!l8sl3&HgK2KXYXLtlu9Tvc(0eUuNHj1{NYn+L?pY&CJ_#smeC*j@F;NIncSt20r^ zJ{?n|BdX|Siy@oT_YcI-%}}tM_9UNs9_)L#FM4f2MCRLL2%{^W-Q>AlP2@bSUcfVa zk)}>uU!Qw3s>p!S^3(T;QEwC1js2-N6u4;OTs8mp5`3h1eRXsf@APdPL(ye z600Bql_{I+VA-qTNV^ZS?GzL5WwFXw+$S_x9_R(%7g$4Gi;K#A%RccwPL_@`tBL!J zce-cVX3rVV&T*F%g3ZOHbG0g>UvOw~Yf?D&XPD-PS!n}*=6mB^gjZ}c&?p=`4U>ds z&Ojy7au(-V`ynb?Ri$;lDw~qBb3pRNr*~o{maB}Reqvr>XdI}%X}yEiMXR@-Re@M; zA0hqKbJaKR5MAZOysSNPB7t>5y*Xb)V&l(;a+vEblp3QI_~e z^Aay~e|n~;5z`RCihY;V{&wr~)Y_;i3_|Pr8QS4}KcZ&P!~({hYe~99b2L|fskB?| zU^S3UX2;gBYji`C_mYa!vzjL}S27LKnpctzL%rZ(&%a3o~=#;J1L`^S9Po~{+rLEiGI>6!OXD8VlFZECys-^?Sm{nHIJ=-;5L&?6x z5%Dgwap@t|(1JOObllfU%=gvI;UKAz1y$+RbuGF_9`D^t;aN|&HJjivomHFQB*6>K zvPubws#8@46UNNlHavS{#0dT3AR=1V(L6<2XG*GfoL}yz^~nHgct&S({|(XJ!mAvm zx_ReFh!k`@`U#~wT^Y}HT1M}$@2OPR6POcv{67Wve@1T+JC~LQTy5>>J9lAEVY&oU z^H)gP@M&4{-WT+wOm1K!AGXaBK+@OJHNeKJ9azP{7}z4}J@81L7ax18I9Pj|c$%_Y zbt%V2+bQTvkW!V2#I_uf>1RR2awV;qkt~@>{K1=o1kPxl(e;xRq z)cioLw{%vKj}Ilg$Q75>Id5xF6zerBF)$On`{`{gvW>dRJx4MwLLx_H#dU3eN)R2K z#n3l_FVKD5bFkG{vU1AqIOVC-w)%lq5882j^lSm##3fOsb)XB~#B>Q}dpL z#BG6Org~*cVC&QU>={-2lKhE(Zrh0mO>qXewc}By*%?|lYT#x&xjaqu9mC`=o;y`v zn|0jvy}Tk$OVy$Ki_Qr!n3{duRYzK0#S-pCRV!1|lF?)nmTpAY zN-uQ9qp3x%btV=+zTe`TohT_ab^n&I)w_}=jUB_Gz0v9iZy8VFmvnQgj(!<0A-2ST zIPc3rkn*>r}m*yugPx_*-dH(XeO%gd(qs$lp zXv9PQraJ)M|{#`O>T3#H#e6q z#_>lRewxc=FNxb%DyD8ZReiHZcx?|fmbCneod4R!zBiy$IbzK?o{wJ z@b)Y6v*JAf=eb-jOTIjW7GrDznN^`O=+K~mKSH2OhmbkdE%ZjMp~E`RC72mYh+}Hc zDoAg1KuaOz^|9Q7FgUu7xV@JF@&TYMQ#CDrMILJ+eAgc8Ag6FJ?@1sEk=u=Ks`oYA z9H;*3QSt3#?xo6rR+Wog)SFV&n_1MG`>v}17)dD7Uj*%|tC~YFIpSZpZhF+4Kfg!# z(QZywnfG$2q#n{b-u-`{1jjMD-2wy$*2*k_nP}Z-C#smLC#B)rhNfGu zi?e@^3Uge*H{`(sKvedo`Z93I&BbLi4MZc`={>g5Qc_W|MxD1^q3!|<`a_L5x-&D! zoA)fs)X$r<7!L(>XkCnFp1*o>QfgD=xXk}AfeuN$XsbHe!p<@wc*~7!NrABtub$Tc ztx+v}^Se^p9h1Wmet@(9NG-qW=tKDWu+ao}kd!}?7QmGoPClo4d#n{%(mz>!oEcKt zvz4WDsdTEjqK)W+xiN~UoecZC5z-d?ZZ`y*2b7d19bQ~UgV~<%2{*flR!@OMraCld z^;|}YU8dMm&vWrPz}uODQNarYhGXL6i#DjXJOZ@!qobn~;|ye!8P$u1#OFG)ACiYH z7aYXck@f#8aSoD^kWj>^f2l+G#GjpcIkx!^+n}X@n6$r{ zoL|3wN$vnhg4f=Om_G7b#P9?4ZwXl5W>HpdOLdbINn(!jq+qI=p5rgFCKARccp0~I zGns6w2Xu_}We(~@8r^rE$FPM8iESpUzN>zvk|ym<(kbB7vZyagRF|q=*oPs z->J-qnHWF940!U9V13Py$UpX17h-G_)#J+k1j3^W&Evht69A#E-7+kxz0hePk3k}a!Vh&mxqPA ziPCd{sAAaLXI`h`c~zajXV3CSFQTYq7Yddb+dmwxoXu34mpD9UU)piJoTCM)C^2*^ z@4QBNBal;b)mHOOxGa;A5~ z7V&k<7zB*L7FIIg74DznrVD_GJ-yxD1pqaJ4?6{toEt@qhyko+Y;21!Ty`g7v}N-B zZQ^(15`S&e2qkb05w*~*fZbg?n8LLxFo$&Sme=0v{CLr9udAyAs_?0J`EM!;csfTw zq7EJ&vVhAR1qhr2RpnPIY1IZe&x!p5FfOkcy8joLGIFCDz#a5XVopN#KnutmUfB0~ zc#uK*)x9(VVn9yw{@V=6#(+r71*5RAFnb@_PJx=O^FLqt^oMc??q9GZRMGSnA80l( zepiJ(rzL{vk6oK!2gt{vkr5mwQPF8c2rBh8IRuA-oU+bU>2F1tg9kwPSQd2+-YUJ^ zHsU?XzYyNlo)OL8es33|4UqGfz1S80-M_em_P%Zi0AdtvMhk_7-6{1U1%5WiqeKA? z($;1E!w2q`NrZ(}-5KQNj!sngpF8R@p^1{JCC_JQ zKX!b$vjUohr4J_yTV4A2{cUwLJLlco5N_Tmle~N(z?~|?Z=Lwlr%&IT76Y+v*8_ZD zB%N%@)W(p6Q;a<|b(Dka+iwZ*>l?VARO!?PAdLM}wl;$VE)n3xc}H)|fW;=yjhT4% z!-5)H+67d5Al7e?^x*B6QB|?aA5!TVtqDDdCe32=wr%9|8p@n)oj*O@#Yli95ZDjO zIjVUZas(zd{Y7xA%HLlU6wiT}T{UGoNfxw!0N}r+NaO`VZZ2DhkWM`2_k8u**?R~W zyH{?%6Ndk*#3Ge|X%8ALGs1p!y1&?Pnt>1n-*_VY+u&;lErvHo`3qtf3kf=yyObXAk&j}vHsG?XxF&bau{C~h17#d&UaXRj5Y0TtgTIE<9HMNZ(!^gvCv?~MVwOp zxkJDQ=~a03*RS0di3tr4@>P;lrc7ie13Vi%ZA#C#F+XGA#=u~s&FARL+x9-g7h z*N{8cYh&}P+z}x=lq^ge00g61=ht5{|5XkFz(_7$-tN79ea$!j{)T%tDf4^z#}@~N zG#_{`0xgIjfoyS;sm>p2 zNB=@}_YOUAGP~c^@De_fumxg)wg5pV?lCg{;mw{jG+ZKK3YUI-odQW{6HkHD>x-?4 zJbVyxgWnXnPJHQChE5v(EGhy0Yq8XHN}r780OlD7n~U$k@^*1~KEPi^p0Dw5&U1Wh zJ6H%FTziKG$!^XU5JP2~BfozS3n-X7n8+hOoSwJwlW67tFT`*9mnWz~H3g)Xn3guQ z0+o3TkgH2JB$wN0!shFq=OY>JUpJFvz$l9!-wQ9de}uu`UYuG9`*&cX4n|RY!jbFE zIwBaq`Rm^$wszxyz5U)xk?B&ShH!WOw#UHcG-~a?s56BbF3f<0j|9};7OO3VEc*UXXKF;IEK(dHfPu+o zVa0gQ3_xe#<~q2V`PzWa|76a#HYEXb{L^tCs_!Ado?IP04b`vPU&F!j zPx!Cyh%VE@0To9;q2_%{9bMhMr1a$2zx}2_=jRF-fC*7WU0?a4=l0p(`%Q8Ehb^Nw zE+7Ws#9{v3Gfs@3OM$G3o-+TjZNM%}0|0vdU2;ja{;wY@s8vpgbN?7RmI=!g+8jI~ zOs#05Lbih%lx)%P#Rjtzq*9Yl8zCi9^O`!~I&IKSTGcZl_>=kGa;#|G4`x=qr-IfA;CXC@LI52(n{?42O{XS(&gu z*WP-evs<_(&xs96&C9|s<^0PDo~8P~(FEiZd1}8u_W>*iBuxO_rWyX1+f`JU@gh*h zXs7tHi25O1ZkqL{-m{3pKq_tIe?82JFfP!nT~zR^1Z>VfHI}X+&L*+RK@V#L)T>$- zFB5{e{`~1>Dt{%1$%-bWHmKsQFLaj+_di!nHB)I#(sF}lS!!6z!!Q4u+qQEKoIFq_ z^wT28pK9ozxxUfC1EF(UxnKF;nilwx3;4kNQzq`{bbt2kzee)neF2#Ye~&7eer@_q zV8LGd?+UzSCtaD>C|E$_I&4>11j-zxX|0;#Z#1IpJjOQC2|~fPua~LSMk^3qbK+=G|YE znwI7^j!vJPtZgmbC>0#d*(tTT*g3g?*CpU901pq31doJgk(XSXx=z*xI?ddw6DCSxS_GBxuvVSr?;HL_U`@x3rhJ792_hh;@^~E-grU(V6oufskjiZ->D&* zy5LZAe@4QUO88Op8<~bj{T$ECbrJ=imUn~h;&0afApM`?9P-~H{qLOro$~8101F9b z6ZShS43s?<3@jGRD+EA;g@K;HVgVAsBYQ9kzzF2M`CtA6cF!p;=;CUl>Jh`>71&ps zK%C@-xdJynrQE*)#|RRC1dHELVB0|&d#dn8*GI`ujW`sh%yni?E5?Q+EItKpG8}%{ zU0n2{9odx8lm({SpL6ONH*MYZs_I9T-*FiiE{`&NM;x+%@33Sb>GJs`w_++u7S~mw z(?cAau;X32s^lO$rX4(VP;DgpeMyki)km93s$-J+{0<=3d1POfv)w>l-2Ir)Te2)t zvtQca`Kjj-K+Z!FWh*jy@=OfyGi+|IKffHMbya_Dv9?tg*`g`rQtX#7?|UVl^;1|EI3^Ulo0ed|)y%T`3`6~# z5{esp5|7kfp+!xDhUKBko)eUC2`(CD7{LQcQc(($Har)P8`{~A*n33o+0^6D{-R0< zLPxviYhNS@De5&4&c!w~;w|baW4{IzvC9A!Px`MwTrOhJf@}9HAQcuY*4RT%KP}4S zaI<2z%fiT0&l?jm8shmgy0rmDL`|<6xeq1}!>^kHSCnUqD5f$d2(M=yo7ys!h!8_T zelM2Z8Ij@RCk$o4LwKy&bYn@oW0oOu3?k7^TaM-G%Q((D`ox%5M-I>j3$9^48Jy=v zvWJGH75B0YXVE$)Nsjq$N{9=74gV4x8gU{?Zm^jf!%r*_bMnb@hM0`JkL3F`+}rn( z?Qb+?9IA;dQ7_Gh*N~htg@^$1gYvshx%2BpJKyXX?S>?HuC}isk7=%7-}}V&s(6;- z!xj_fp_!mPsh#&nGd$AA1>yDfA!Bh5!$kvw3rYPr;(zl76xNA>`MD?S{5!{8R5tY; zHmlZHA2WC$ zX~ym+qH5qrf+Hojfvuor99+jJ3Kqwh@i17bP~6*G>9_??gNq%g-*q)))zo9x{&@xT zX(Pnok|Z=TfX7P6F3W)WCIYq$H)}%E{=hnS^$qhoT$tV4Tq1ueP!E06jCqW{kHar6 zL#HcKDhmWIrgsPe33j!SIQu)5OuH+3;cOU$`-o4R_vu)d110@i9xMU2&&DG2FpZI1N0Fy z`R}FUJeJ?#5O+RcaBNidDUk*B=x4{AJic#COX$y+*?wO-!I=EiYWjv-c52jFZ7Dh_ z7(lG@25m}&`{N$rHwNI9SHiODChB=61@|$kE4)cWLepgW{d;`^AvdheB>%1p*5jv< zj1Tc!5>u*)9LYohR9cIh)uV<+m+He{|k1%1*1`S?E#6ytDEQowQmC6{O}#izewyi zxxfdR`vp$3?QFa3Px|06*Q3x$urEkPC)C#&;(Bh;t^+WqEew&oYgkHN2$=%8^y$tw zjncy@q9t2&Mm*G%{&+O*mJ?fHynxbX3_qEXsPL7!M#l0AEx93x6TzKh7w$5AB$_`R z_9DB9G9JTE`wp}bgQC>rfx6w8^gfZWQY}B%Rji9Qff@c=dK5Je1hw)PZuBt?E|@^T4DVpO)94kD>QeGjeuFZ!dEtmYd=bx9diDty| z&Y|hwPYnI@MXiDb#4(s^Ef(D8|=>mB)T8p?VO&qVXO%;s(2@z`BLiV=4HT1;_Cwm$Piy9+wF z+=;jLt-SoC5?5Eqh$Ja<$cQs8wqzb=b|A0)2k+YXZivy>7pt^QHf_SfRBFjYx>Ui2 z8^JZIPo(}ACD2ZEyyOm6YL>TXVs!{2!XMoinLvFnXA6yeKwE~v+1blFQAI^kT#mTC zuk75|vc;ULt}PbAZ=SS6H-ZtBH1<}ZM$SS@?H2&}A@)|?-Jg3shqFrjVYGn_y%?)+ zq`+R}BjbMsjKPzv`TRH9sk`f}wdLHI;ZdjGf2Y|CA>NjtWE~R%Wfv@l%@>CF^ZE>7 zd@CaQ)0NaYkmG~cOf3w30j@ABjc(=?O70u9Md0|!me{+06Epk|n>IJZ-`DL>)s~V< z-;;n)FaF$<#QV4QGSV6miBT=gQ4Z^!{m;7&Mw;etkU>jkB`2|>0fuiN8HG3eID&MN zho#-{@A5E(FYwBhFH~i<|DvjI{rRi(ssEWFmGHOtADHjFccSJO>ZkMCF^+7aVxTSu zw(Sp-$aDriXrY(`is?(GIqE#|=K28mQQA9jY*><lmz}q&};?-`lo(%uFBgF4NdK{c<@jbNRy*>jUUI8CzPLnp9H*1lf9R8?A z3d8q)wROC`xm8=fH~;vZRRf-zd7TF>gm8O@X3P^t66a1!+F$pAI3eEsQS#ls+~Tny zFO2mDdcAZ{Agc(@t#9e^z1;9<|H@WeH!jT9D}d(zvBan3F7Xw3H+#Jz`*I`6UQr%1 z;{4YS`9^I~8R}D%{XB;VQ1=<36B8$u}da4Fqc?#{5yKB5jXw` zb9GW#qd~)D#Kh4iSig;;Y^TjmqPt9kS#yK3Z2mi4h)=%nZ(LPTy%+=L@?jMJUvCNq zzdZI2AXZX@3rpEw-2H^}v!4lFPoQEVB|zFpe*Vds+x8LZ_p*@u;GoPe#LOqEhHu_+ zz2RnoXIe(NjQ2iGk8Lh@X2JA#Os@cy1l}vK(CzgKsiBEGm=dbOVlqHncK^}OB>+(wTdf1!&ZRqLRxI@p4HP~ zV?l{4ZgrL%Ea!}g3p4Sr8&aSH8q5|2fha?%cTNEMpQgZxmcTOf(ZMU~xZzMeREaYq z)OFa)qFu4nV6mKFQ8P^B!-xxN6Rhtpg&oOksX^TARx3n{J7-rdO!v`#-j6dd1hFsV zc2(uQTNH@O=#_Q2fyzBRUvB&sWB~<~=r9PL&@U=#s!i{deOT^Cy}KXfU66o=1k3zk zM#lNG0Ng=B8u-mfejmKn5{opldC_1@$vdZY5~pxq`Ds%(7tvU&mL}7%3@?DkJn=1n zhnpx#L|ey2Nosuz9q&#IeiOs@hBYHDvRlm1WowLt8TQQG6qC4f%jdI^MB}6P$^V86 zw!nn-&fjP#bn{#HXqe%Rk&+f|(dx-jl4c?W*MBW#e0i&c8Bgn&_(=ixO-Jib@7v8t z_Jnc+gF93FSRA(3{u&D1g*h{TO$X!O*Nh-)>^n77&_`tlXC zs}}KJQdpyLLp(7!fpI*4#^&h`atb6HB&W*mZW`>#E~}&yWY+O?BN|D73b#Xwxl*s0 zk_@v)0{JlG_=VUH$$xeVY@n1`xBFL)CKs>F+MWkTJ=4AUYCkE{W-!%7=Vx#e-<`kh z214*56Xv4h@hQeY<@%T;Hkw1csocnrgck_{35q;SoR8B5LBGZl#7HU!dwL_qvN>b* znxQpa=S8n??o_JGV#ma0j3_E};TIW2Ptcn~-|Xw~h$k*uwIhA;ZTVB=%Swmkw-W=4 z%NRtzXk)tMhRYm2!VDZ`aKr{OvI>iXEuA)2nCN2-nrT{NcYS)4n`p^3IHPf{Fgf3p z<3;gLMZ?tm-Aj3gjrX*eM7D9+;ur8f>N(KX+io>FRMMh!Dd_0{3Ja<507M!az{KA^a}?+`lglFX>7R|=3;X>!>a`^v;fuTC%$9jd(4MZqkf-IWp#OQLr^AN|78M(h>g zKzV)>j#k1qqGnh)Iyz17{CUGlMmh&(sru#oKDsy$w)(>9>ou8l?+e-Nr;q5Sg{Z&X zD7}-VXur`)(g+W%C&aDfn|Htie&~RAc&sQ@nRjyO4vuOqmP^OY%u5yVkQ-6i@WM3(e{+e|w6K6> z>CHi(|6_tpL3Ahdu_fmazHx??onnXp<+GFm?$=V*&uX~%mJm&WvC1P!T!$yV&2b9* zRN|^ghmA?z6Jlvm?GMXrJ=5ctDYh07(Sf?mATrM|qJTi)4e~uEH9Qq4(kRN7> zZRxnxO`=bNKt>JQulN%=YvrQ9Hf5yTF28&UMp%>iW zITAssnviYbpGt8!S(D=;iM(-!Y?n&$_PXk=D#9rL!xV(Y=V>7B`$ex+Wru!qiu0sA z_kP~V04-KLS}w-EIODlf6j-R@*sNm`{5Wt*e&T2rbE0#b84Rgp)~zHAWVUBAkH)A zFz3ypGGqceK@#Z>SR}5sXVVII!-Tf!yvF{0okVHU-4UCj(Mp3;j>(a+aWX zoZruq-%hDAA*ajm+Ozc5qM8 zGmcw93ipckBgOPHDKI`hC$t#7I&oTkD1HZj5g# zG>e=dG#l;qVzpozR~s(M1vVYWg@}1ciQ{x6viu&nePnT}S?YB(+PO5Be;OpLkE@Y7 z^AxRX;2!Z|Rmel-{THsc{!1QYdV_}zlBzS75^>|BV_fEq`D6oTaBdNsV1diARHs6KD!bWrV*y``%N%I z9@>$SS>KI724oXCKSHa(dnaZVZwtFjgyn7NB=}6G4dgVfCA2T`iJJ!6DF;sTnNMJJdkjT={J%QLp zDxF4K{URLhhXyxFH*Gr3W0%sn-!2WR71Z?fep<;SXv@GQTg6QN z`iLy64Qu~KlJ#FYhy8DK67XVj6qcE;3XGQpBQ7p1G2u+)dUD@aa9BIJC^(NKDa7}0 z%g`Vmu`zD8RSmhe{;X1#EkdB23gG$dnmFlTTM@q59sW69}v=Ajom5 z2+MG`EMk;o#?!cHBe`sW$1vr<`-100FAa`tix9eRGDP_2d)xrQL+kQEEq!x)1-Fh~MKQhIRJ~^=uBZLR<9OitU+`7ffe+dj^^Q;U<@h%o1!y7gATgWvo#u-8uC$CzjqO z(PA2BA~SJagjXO`eDJx|={Xy&K|A~}b2ywbngZG9hQO0_2(M*#FAg48&md7OTZcX% z@o1uSe%e}|i=_l#wG>(d7Ld_2)T1kKX>SwhKN~U%C}^+uTPB)~47}%t>E_RCVgH$? zMiN7#8n)HFx#3u713{Io>x?mLPbiEBXl>M0g{@6E89g~7fkLlM{*2iw%NYxs(bYDG zJmHkpY~C(0nci02QBv1_KT$6DuqCDJ_i`g~%s9-yun*_CZ3!TQ^%?SQ&(`nl&+6?2 z_`^h)+?z~B6F2#Cln8UK99j+EVZ*(Ykk@}JE zF0MD%1G_BK|XhrOjTX@4`rC&}T}{77+jPzf5)uwh;KxI$K_jWKi~vk|CZp zBE#zDzxg$36IjzXDNt2#t~T7DquA;*Fef&pE+3FW935FCq9QcX)_@*GK7K zp3FR5TO{>0gvu#z$^A)&o2S7a#sq2n@GVat3I{M1pmQ_an z(tc4*4psS`-9#55G|uWwd*~LjKLfR42GWUIZ)^bZpng#rteDZHaicW{ns%sm#@1E-SfRMI85g z&Jk%{as<@vZ8eW>B-%j>FGi|)y8dh_2Om3nUjc}33%A=V@I5xAfXnzG1Uy9`GG&ld2!GOu`PDr$H@GTpZlSw2IW6B?9CMV=iM z1(9JHmV(n~y@3_uCAQz}U9{G~u@!TvS5TQ@b~lL+)kTg7%FTfy)byYhcsVXt)adzy zIb6r=ZRZWCKj&6OD`=+8<&WiZT)Vk`MkjPE%0xgiO%R=j-)4=$Qx#b!jqj>fWshmT;__!czNmGQc)U}y9Ayz;?3R}_1RwZD}X%SZmn3!G{*eF zzoM-5Q%g>)2yDDYw{{LbSiqQf_n=U#VK-?REjbA9~lQL?eM8GSF0Yso-)q%n&(c>AWM+PMOa zQ85(`YyoEv6ihvYhK)%3LFQvTyL&fTV4)L7W1}VT8Ha%n9`#JxNBo~6As?-t596`b zy+8EZenghwVgQ*aRS5O6YdHnb&$rzR53QY3{MfPd_UE%p!KYVq6!c93A&)OgdCWFb z?s)H?zRWl|j9OTJEPNS5UTi|@A95SmibeXpw@aSSH&UvqG!`JB|4*nHdXyM1%l+M&ze zVmt9Lo9a9jxmO~iIP?mfa0Heqd`}fVzDX1xEc)vTiJpms&e^llEkqDeXq^1|?Dt?7 zyW&)B%T)tti?C@bjJ}?8?Y9Q3wx_?7}dqcZw$tz&}taZ&*e41zrXSMWfkN?|A zL~u}W48i3@r(q928#BM;|Mvq2%=upb5psA0#4;vw*a1cxMP3jdQ@qzjvmR?BP2XH@ zC!prNniASrCXo`pRu|C+o?1tjV6qR@JF?>DEfwlq?i=*^EJj9)g)1J7QlF~4CKhV3 z?`{5)l6_>R7Dy*GHvA0GHFBr+acX@&hz)C|8wIg|b6Sj#8WU`L-P~AKY%9tiGho=I z5d@@gAyGT!)x|?!T3_^Gz!7lK=CBf~Gz*&k^D!%X*5eK*!}<0OfmeS(8S81aH+%un zG-$#p5@l}oDm+>#Gx~v(O|5GNcE%xx2CfQOV}T!#QwfCBW~`)m=HtBqv~6uZ=UI!X zf@D62$N5Rfu+mA%{zsm+PL#sygJCRh4Yi%_OV=T0!^`=U$J@AN9*rD>87<}U>ZGto z;b2z`S$fJnimK+yEH;#Siyd_xW&KqzxtLt5JG8M-VL@VbkUAf3ri0Iu% zj6KK*X@ll??oJME%^tiu@+-KPSca>1FN^eQp0KiXW>0X4Gxd~>p)k?6ta5L3$Gc4& z6^Holy8z*I2}z&miHe#X&W;0z$5H$62U{JNVsw9^;QpsT$mgzg%)5Ir)e*T$mZSwG z6IZdoH6J7Q{d)08p+dMs@6r}mljrn+3~mrd<4q}_#;h0rM(QpcrAnciZ~09kj|0&w zkaKT-FtZ2f&{n7H&~MQZHo8~&`FsixW2YUmRR^gQ5~tY7Vny#A&){zVOiF3a?YRcG zKpi7ZZEeeDI@rQB+)8kM!OJQ)+*m~07#Q3_qVsi%I3NWLr&WccD^Cf|ks4kuZ%9)) zFR9I#njN~{qAb(NO3|pyqzCLvrME+H!Wy!djkjf2iIbQD%kx%Jf4iGzp}NNIUH&j` z%DsomrRS2?kJFD_chG13gR8r}pMGs}dtCkQ*8{<6!=;x~&y)-UBRkuEkdfp&0i<=r zF7VC|(r9z1+*oS{#eL+-PHa(6ID;_wIr)-wz!uz1cz{24;J7Yr11i zVpXNU3*pR)$9NOeuW{xn0b3+$72o~aHZp_=tA1{K9IRFshW1FgBo{PmC>K0f9Ok9vbK<*KR4|vOPh99v)VH$)J-yz1o$!_;K?$)S~ zQGyKepEw*hHeY5*fB(pX_-@Df#y{)nHk|Hkc(~!FzMW%NsNP`q-c+}O2QgLGNMC4K zp04@310g90mL?$sQqHVEn?02cxpTsp7agg>3+q;_t2$NG^^r=E!?Zs>5|SyoJaWL% zQD|2xDO!nkOgBhji)!V{qIfv=Aw3y$F)WRqZSMzhES>mWAAyzwNUuaioA0@7O(2(5 zrD8(MLImA6xE7r!N3l%}*?5H_dTv>?sh0vHE?wmXiGK0I)}knz4@LARC3ICmcZhTB zbc33j0nypeENt3a{i^gK3iQJ_h|RGaTxdI5Cn&HekA_=0+ z30f2cc2hx{cM)9`zF;O6DJ=%ZGX2Tq%*a~E@Xv(@zZ<7%$K#JP1ubFn+Hwt=?1f&q zdQs+LF3oP&cydgCW-0%(Hc1R(Bz93P7tz{rvC3Qr(T0g`2d2*;8--Y(q8x5|;5}`m z;ASExoaJ(}Gfo9qhBnd7R-u^%@=%a8ZO;$!ThxbK792J#*)i28dbZa)fGckm=o?xu zC!k9p;rR$?da1qJj94B#BE*YBpipyj>-w0h*2HDYu#LFW#oufU~)YD1b$(0WVIQ-tx5 z*xoDfh2a$#M0}!}len5!gJL(7LC@>`Y(2wYQ2&MsuZ{D8<_!m-b>F=LNFH%d*Z+=1 z4l(-i3WOX$%czd?SA*`jgP!7py2#950WlAXClb5Pr%btjyWTfH#@pO~QldBy*L?-X zjpSYd1PD~3p`Sb{gizeEL+MhJ|8G`7PyeB$|J=K<1$J^>`HA5ijoptwA;b9g+=qW1r2rWf5NiqGaP#BGaPR^ zB8sk82a8s3uTSmc5C5}4{@<_*i*w&yc{aRIqwK0Un9|r+12~lXNT+Dl1>Fcgk*(^QVd@`vqcoLrmnf-Pmq_x`qR^dO&SAlqF2bwz+eyw-h@7q-Rc(6mcD+`ysM+os-{}TPEgPWX^ z>|il_<^{Ts;l0l~3vjTf3sQ-iSPfoVW=uqoY2+;X*r%IJ(l(|?7_a*|dand_zR&UJ zuEySOTg5PK>QS0fWtxO?XtLc4vA@Y!yV&Lkfd!gsfu=VI9WW|#WA>X>q z$RRoKh-RpNr2ESyprWvj7R(dR6S-G<*y=|>S6($r*Qg3Ua+~=j#}>yuvJsxN0~$Vd zo_5M+^3#3=TvIZ4cJ3j4R<#$^3zM>~dQn)82dQX0sTM|0d(9Muo~B~8NjDXOmj`Di z1`n;|6mMSvD`DJMppL1W2zL{hVbl^&PUP4 z8+8q6FD-HPm{P^^XJUzGx!lh&g^sJhVDNJm={gnUTX#}4(25(`|>d6i`rq0M^$UkpCt)$S^FG zZ|z7VtKwbdn^v!xCYE)4x-@k=?Jz#Xqgp2FVN$|wD8TEZ9`!{jRp8blNj2jcYeG7p z7^`-4$l{eA&*L#U&CF2z{KIV?f1bp)Xnm6rnUL3LL8`z3b zJ&*d!FRR!oC65Bf4mLw9x2diT4efvUPGXCRbO&nbX+_?f%1$91V9ug~+vli& zShn|e8`6A@Upj})SGuQvl}=**$=>D! zd1{2UMo-yAMLcz9msIj+dtnZ|adN9>pOks-rOGrhv_2t}uK9-w-ZDQXKY?RwT#%E; zT7rRr-O1jMp?5wG_PgJuS%*quilxjc8^15C{NCn{NB&*q()>qp^)~b6$hcic`r^=z zz*q%q}{MLs0*-Az~ z4H?UC8PXGcqQjvOVEutxLtCs(abl6P8jCllXuPK5Fvs1uUp;fQV8m;mLCwnTRaGr=_DlSzEhz+w8U7m}_t& z$X#qoCp?Tbuy;&Rt(9~WxRxPO4DuKbijtNmIe7&{*u9E2c3`h8Jz@KJK40F51(c<- z``T-OOc+M*79Jv#&!N90tLvXmpW(-5Hqsx*Fa7dvYhyiW*c@vKxFreqoHa0E0x(|% znYsRuu_WFNcbKG>Iki0$HCZt+pa=&|w`4+xQU(c-k&ngc@&}>5sUaUkSZ5lV&;8X^ z`EdfwyLaVPM-D+a7bq{|OIkM)T{lVFjhAlX1|~!OvukxH1L+=k%D*+2NO|zLBQ9kX z`T^^M_q)?S{&@VG>DKjyZT9p}CZ7?PS&~{?hKN0Hu2=F@$DY}S9%1>@A3s5qKtC`6qYCX(i62BFEOlNWH}I>i7L_q!RREoeDn7W47--x$BVIl9 z($=mGNZll9_F#OOcT8jzV6vj(Qnjn#ZKZLe>AO$d(EG_onu(N$KB}ZUQ+aJQ$!pcn z=x486dCJcIBXvhIN8x7};dq2@c1bW~Xw^s}flUJ<;enfj%{O6m}w z%G3daHZHkOz4~gbx12PrL!$d1H(u@1*3?jAq`1rS)nyg-W1awDGVoxwIC|JeCJ3F_6 zsbQWz?e9=<*oXyrM?1(iRJU}0ljd3CT->^_q~r#tX1K|-YlayA{c|!baVi?hO^(=9 z)pxe)&UAh0w~1mbnl?%--z3r;F~#VXed$(4i!I@5(wv8yzkOlad@l2+bFhzLlelg}M}3 z)^HD6+@}l-m1}j;GX^>gLAEpWetz##q%bqNx%~_7y;suv~ z=o=S0l|!V9^&~PKJg}8fPb^nRBZ)}tLp_G#orehBDT#r0Xb#X(gd{TYFllZe7&HTjj0#P^SA+(dN+e& zI1(`R5&c4t#+u9Ph`jR_Q6!8TCHCDRr+tn>tKDq&pQG)ks3^7eDKBlEgWa}K8vC|_ zBvnSpH_lEQ$X`CgF39Vt_YudO_9GAVxdOjVcc)X%Y~3d%!hhVZEq(V>tLvG%(L6tQ zE?CdodDqC~@BBjde8N%G$fhS$!|JdTf1aP@+~&LUlMrq%>2p63Y_#15o%)<}Xr@=p z!;*47xD%%nw&(jNOaW0B!B`t9{PKfESD_BeGgUpe#gl>$k4vur*i0Z@!<_U!ji`UZ z0gfEO?aN){8fIuJxr(Esj`ovwYmSvi?$j8g9J&(bah4s^6$6=ibV_;JZ6#eyx_7=u zOZ^A5$W;wP(XUMmpDM^&OPDd_M*O@sTkO?SqKNsUvGIj$i-hlTiRZIH8Zla>ue+uXG52sJ2 z=I(Qz+_FS*b-?|89pfj`Ce|v>L6^5DZdVe5`Hna@@}3ot+P}U~v^BlI=pUtPsS@Ls zC!(RX<{M;%+hO3a$@g4IIj)+dkduq5Zt~^b577275|qU#lv5t^FJZTJIul#1n%PT# zndWrkD|Jjz;Cb)4Zt-$!R}&a$j91NNT*0hfsI0#0OP_go<|pP^b3bMs6J{P=5(~nR zAML#q5pnI~YRIsgeX**U^nWT(tL}g7^U#f1P-}Jp2Tcarm6hCUR`+PP}&>EuL3?nWO7+hJTr-5TubgWc<8n%uuvEGUp2I>K%3 zwTdAu2lZEv0YbN9KIMgB$w`shG1EFaEp1grQPUIGocA{r=-PONtVUXh_!|PMss8l= zDTR-NHfv}6fw!x~Ut_S5Iwq2caJPNNaD5&1)R57<*U7^L%Wc=Kk!2kV@AW#@(m z87=jN;s%O0xqO9nCc}k)?#ZnT;tD@|JeOM|YJVvtPHy%&7#vi}c2g8yG*DpJRVI%i zrN!?E-=UG{Xd;uR{3s>775&!dm*~83_YnWB?SbPnj>+)c?LGPR`@^sIC*S(noopSb zK=sMAX%{bDQIVHPe_U5e`-m-?K40!_>q$DQ3SPazfEnBay`QI;VO{~N(XQNB&sXyP zW-M+KGr~5Q-tX*ji{DTD$vZiSR#+$$Lp$>AO$b@o8waxmc*FR2a4;c(AuOrP96yy# z<+kt+nP*G2BWttvcync#_|t}N#8dCk4CEVTDk~G;kqp{J?Z{p=Q>x~!{Hj&>+~nWu zc{N{Qk0czI%CGu36-}^4pSI~TW|y&>a`L<|qB zgroBc#ADtme(G%X7H z-`{x_f$A!K$%-lZ!~}ooMG$rt-A1`$0C%Fej-9xi5WgZ6353>QnKfvLiIFg z9b)qIJ-{mW7TQEcsxOiURaNC29wKZSBh9MEe_Bj9jtM{`kBWWGE88)dqHSCDj^pQB zNrzww=)C`nZP2CZbwzYI>Fw6%Q|JE+IUJ;Gn-Dn4ntI-x#a^#K4K2hdO_&3KTp7*jASeqI`^B0fpvv zkHlRQex*zrO8Mg=xZ^mik%X@Jo^L-X6|VI=m!UP2Ux9zNHdG1AeTr~glB@@}5Y!wJ zV2vaqYfZmzh9|X|JfKP&)ze@eyeYiG{_6m>46tCBwY!OXL4(R-gW+?wuYeyk8fKtD zqYTxt`a#|w3@NxN9dr1(bZvF`@gsJMR*pWQ_n&PKUKL#d3EFsARcWc>Wjggi=fY5( zEWj$wCuki9T3uxc>bMYjgeJ|_`Q~2%qWnX!A5#q%U zo-;zpzPrvafz~@G3W5rTdWErdSl5xJPg~Gi?@WU}E^+tJ1`ZNO~!``r=2JB7ibKajNU2zeSsB@7r&rwp`g1+@iK$^AgB!m8lY)cf!NT;G~uE# zZflBn+M{5UWVxW`DURgClI@D+&D-_3)7nO78DBwG*b1G+P3jp^%Tl|8CE1FgUS6NO z5xab)Tuj>Cf_mG3Op)9~qE8EtI37$WA^9ro(2i@&>=PnUq zJ|KZ^a}tLyB(6@LkDkWW&dEQ!ZIlUVpP}+~hcOoL_o{tP6r|nGK_=`M8k6ANWE~6R zcRw(-94Gc49sIOh@$<~yF+khkYYsWLhgMd`bgj|Y&BbP}Y~dao3oJQA=ZbXil~2Pt6$`3-*(i#0cOT$D z$oHkXIwLtYWfdQfYcNF5jEQK4sE(*YysY!#?`_^-Vn8iQ=K(2WDV57I){5Mz89y{x!1QByqVp^PEs&AVKhjT~(8LW0 zH9uPLbN#THR#W{Wv-nAQs<=_N8Ua8Qc*(8l1Vg((8y|ASN7eM(r?V4-m>26uzq-!n z@(K7D=0!(7I=>TX)!K_Uho=_bZ0iOqYT2f_rRv!36aL(nOBE+LpeJjyHHX}*9KuZ8 z`HpvcM=n%;+2S2A~)kRC^bG z80v14D5m*=2uB(M1E-DiwPdi%Zc1e|$Yh#7I(ZX>=nZxs#)JQ#wwglh@2saiaHupm zRo*H85bF}HESNumnZw4%4^BT-n_DrXJsF!z<^p;6!VjXKA%jN*Rn@CRe_ zR$ZkLZhzb+jpp0}I|~kp9}}x-H>6EEcCrvNF)%3>HFg^KjhD1LkG+?~u^8G}%T8m3ZQ-?FXpaibK>= zP(ip>U8kk2+-YXEp`opg)qk&f#KtqGmRx~mhor-De53#&8YWkNtAs$rkAYC6voV0R zzM(zyKIimJx$~GRiDJ8VlPnV}16=`#f6sHP&CnE@&y1eiZDOo>pX6gt)y<29E z&F?lZcum7M`}OM<|BC#eYb)KFN~)*|bv1^F&4&;<%tbe|`OK>k9bDJZs8H z!VfbIH?QE-fA2o1Nfk{Vrp_mhOgw9S8q%nfoxy%@7M zG#Y0-@2zyV#{{87-gRZ@dgjJH%LT9Y4O8stXCykHSremhw6ON01 z`P9imDb(|cgc4iUU~gRZkR@fYC_lfx{Q0M6Ys+-{alP1~ohC@d``eKFmavLTEP|S= zVlHc9T5U}8q2G~KKwHS^&CW*_=Ap^9kJVV{tv--SSrqrZ-~o(dZC=}1jVKRuOFEBH z=xmi|euS%u$ke_o2cadYkdH`IG%?D>KE2(+y5gzQ<-omUw>Y9FlwjDoP!hJ1AWnd$ zNSa)N_(8VNW9T^Lw4&2V`h1~@Bf`YqzM^5~Rk3{fVz2eK2lM*zaegvjDv1D5RA*@L^dc1y)?VsRoPRQ~o5U8J4eC^BQ z%j9U*7|ZA7b+sq5C<`o-%U&v8O2>PdHlpFQ;-$ziF+K`0>fg3acXW!ilBd3Lw^6C> z+c?yAO6X2QWW1y!;hm@T^73kET$9e6WjDG3_qcK`c%DY>qJ9Z32_duyapewn3Gq4Y zk}c3|1`#!EIXI>Tv^9uJL>z7$wn@x#UUh>{gqjb84d-3Jof%^rCI?p89dZ@~-#M_QOs-hsDvQ z)~@n+f~>EB(q;RD;p{gfL~Yw`5q+_h-*lf1KPLV%hl|w^r1Ypns;>y*xc6;g2m;S8 zKE*YZsenPlBS|-HWskykLmFSgpPIF|Ly}GIs$5ThxE}GAhbULD=6^IvmlQoUjDEw( zGx@Dg0dIIvCmm9*-fDMwwe$jW?SAoHP(AeW;nKfGxt#3uxN^Foy~t~uCjozabopAlMwiNhM*N?=F&?0p4>255Qi#>5=RJHz{|9kj9Tms3ZaV}BK>~r`8iKnA z87w5oput^&+u#}kLlRtr6Fj&R+$F&R1os)--CZWHf9Jio?mc?%IqTf_7Jo2ny4Q4d zRe#l0``deein5#G4e{I&h5?U=zP$g8238hr0fA8Y(;qUoXnWdn3NU^g8c=Qu0%)Pi za$RF{#-$N`3<&n(l}8`K-WG{3(VH(?&^DC0h&DyACw5$XYUfp+rv<5ibrhM@0)zZ(#2uPvB&z&#p_ zKTpE@1c$@5M{lFutVkt)(6InM+m{>C?hKyiZVOg!0_R6v5K0EE$9(Ksus6?tvp$15 zF6y}Abth;+sAhneHMAwbwk~IK3wi`m8#mxdsKaAq@O~bdd|mDR=IQN^4%AKoy`Bq|=+Yu8{i?yh}+G}9dJKiW1nOz3PtGRqR~gi-8OE>qcDIbC|d zWwfwzGXASkq3p)~h0C>*x6F{R)DRc>8`Fkcfq`E3HdljAoHxb(@4EjCJ*C_XYY`*~ z+lxwf+9!lQ2lJvd1PFHwNe&lbPzN~%QKH~MU|;ci*Cv462?6i zU%KI8*<_GK4~%E&gp%6e4YI*n=`2EigUp}gd?VEE*6IdNrP^h~*+x0UeXav>1lU?}$ zp1svmE2v#pKfH*wI~JCBcqRDeXs~O1vGlExSjf-i#`%WT1~g7@)LO4O+0Z}(@<_n% zB9x-6rutrfz-c^3voY^zR(G)&oPFCc#CC#yIPWS$jI^>i8O?m_U=(?S=AkyX+23ha z@yz`u#*n{i=c=12C_%We8LVP?ulBS8OG{npeN?J)%?oFHdj}?tXk(Ru^NKOvIf{X! zod~!qv>yunb;Cs;Yvhx`@vaT-pdej!#x-5#@|O#%{|34pk%oseCouMr|F)4&XdlX# z=Dj*brvJcsl>WH`s-j)K#J;M=;;~8V@L{)a^s)4Ns_Eu2=FOyA{y+Xy+YtE2|CGlV>Y4lKRd|{~dTNzYGsk?A^qfZ~ z^3%Gcp=k<3;tTCCSvuEBQBcl@4}GNI4?l%U^Qe6t_Vy+-QryQ|e}mZ2^z)eV>#CKY zi?S0hQ7AS_}2~H#CI#cfdbYB`^VZW(%(;qTnx%{i}#9Tjci&SYdC|dt_?3(u_^aXy!R>t8wA{Q zMj64xp z1Z)TdDlS^0ZG~oDCC-Q-53B1B^L~Rk8?RyOz4xM?*W@3bg-U%*rdNITn!CS%^oQ@* z{;At-m=)pn6LFf(YT573jd5$lNx&=2}E_tQK z@kE?a2y%$5^Igek_L4^$>G2Zk%*`!ZP`~$Q+h^pluM5vA_a!YZ2eRQImX%^B(#|fiD-l==p+qi}?-3=JRYAIcTw9qq%g>Z`v1Weh8J5j;_h$r&JwMxp^WjCT?wK zYk1t5jLHe>1r+N0bPI1MG%@;HKUJ-3>$UqB(`m8U=`8CI=qBLALYnu+BGL;>A7b8q z72X|s=bXm+)=WDoC9l!3O2N}_@61W~Ua@h)%bsw3U)Z5Q7*ar5SRx=V!k?J9Se{RG zN>7`xfzN_g7{jEtJF4>uSN&tJ|J;&QncMQw?&HA$CN_j$V!NYy_t0s|mx1h(HyUC| zVzqvk5*$eSx^)_kvb>$**5TxA6qj!Yf3mp8LQtSz5Sqx8w}g4Ql^IR3U4{`-#*!3QKrv3!n(&yr;J=Kc*! zpL%3fby=14#-kE%#maw!Qh!}AMdyjzE%UIY!i_I4>T4tDxUPfu(H-EIoVHvqj*Y~N*n%UgN6EjJsJI4ZvK57MMsJmp&0`eTX zhaAr_-|~KUrI0`6@tW6tkT0&KOM!9%!D)U;N&QmjB8OV8kTaC4`PB)4e1w*%<1_T{ zD63a(4>Ga6uQ1#G4Vt}GvSYKm4)0pgefEaVw~J60a}Kl$?pZXTkk#q9&S$qpGlwxG*4JzZ2U!176 z6F+IRnsv&$8pLdFM3(SPJoC<5o?f(5hdqk{m|t^%mcUEFYAp# zcGeMtsEUelo&5NpcpjS3SN0LQJfLS@#(HoMWi8?#OOfY*z%NGm7gBZk;qaZy@dQCg z&A2nPW~{ZMM2W+*S&6Bw&DF>&yJv?t!zjC;P-0f3!uSsLvVw~usRc^%vY)3}NkA>N zTHj{4_`q$fOC~;kpJ}}hK&Cg9D+s*jCbPr}d>TJ_f2Cs|XoF3}A&kQXsyX5OFB>B8vw@qHCx&^u=na()BBo%G*(o}Oz z7uGD{^ls=+GfgjzHyheZ@;E?1Gn5PzZFQxUWLW!;3KvV>=Ph0-+QT*za{v}Qa|DXyJQTG@w|DTl0%m0B^eK}QfUMUHo4Z_^7xwTnoOtDLj-~da#{`?Au z0EPR3No*f|We+IgIR>Y^o_rXzW@9`|)wA{tTAM!&VZ3avtqq#jidB;4N7zo+715tB z4AvzsdOFhEu_n(wltI_kdGLr1?THsa9TCMhC~ByginLAH8cK}QdRLGm%ah*^r`*k* ztF*Qlp0O~C)qH7YyZ5e-;G-$i7h1~o6&If!1|u$fbQ?Awo$^CzRn9RO$;m*!{G0~j zD?@PVrQv<5Z(>XI5Zm%0jZpKsz-IdQzY5WR4@cyE>hb#L+=Ke$vM3!!FIuzv*CFhm+e)}uNx4YCu;iL3gTzFcVu z{V}9^Y1}HN7iX8MZ^(3%S)ke_@3y6(S^;6zam&G)cuU60tB@|^`l(je`hMQAxv|!+ zz&A}|mdSf2_cfY3Q|zk;o<-=muj*d#kSb1d=(v`xK6Z2`;}{#a*gX}qZzod67PQr@ z)XvWt5IJM8AR9V`Xk?W2ecwNVuj$nYIun#LTF0cZXV`w8RYOHHEzOGZGr^-=ssEv_ zu>mjoHD{D)w^_7tOw3u%gh4v|a7#wOjML8=yiK2Dy<76mZKQkDJYl2$m&}W&-xzci zzJWv8JC+kf%;=ABF<>$^j%2q}Mh8iwy5$*GUF!md?1m&*;$sSM1|oAn1j{zR)yOsI zS=;m!vCWgqthJsuKXRWhvHbImpFIyOIl?L?Xxrei(PacNz~VK8-Y;YpU1;pci>B4` z;4btcO}TGQibG)ohu7Y}7BiU=(_QrEymjlnzYvhN)Doa>JPl-Pc`;Xf_v`A>%(b#t zIgr552bM})qb#~K>YsWwz6Rw%O!ABqSy-z}UN%;2Kq2$(#{wHeBpPkjW-C!5sP<|)#0^No9-+2p`E6`*wl z)zfNAAJFU0ui@~v?7;V2|qW)h27$=oqdyA9Wfha*f!snFqH({Qm=^OwFfA3 z;_fWzIp81X$^F~1X| zajTN{FKYLWv=L9L6!Y*ixqeiN=E!tzB6{}o;y1DM8n;vwems&rDn5 zVRs`5&1_j*#M3{k-b=OIL%3bl_=a z5XjPgW9Ns_s!MAg2lddd9oznv_qBkZO6ho@Ffhh|C!q;hcHsEK;;} zOloJRtCXMk{06M%p%2#AClYvMscl22OV7dnH3vILvaHARNr8v*NU0p$GjOG4Qr38- zrozW%pbbIei__m?)6L$NbE%nG`?a|4H;Be?$fdjOmurpqn9TGhnd*>;RoG2nl|)*x zF*^uP3*rik7IyWfQ7rDM(b!>6{pWf3FwS$*_t{m!ec;)X7oU0u zqpYcW1#<4t6f|@>5BY>#bYw}bFHQp~j$DUyKFgYb$82xV_rDEaSpjZ9OA}wPSk#oh zS%RZf7~kV^i#SI_*;=4;(43p*FkuXmSlK;xoISw64{p)s&U(#Z??Nb%jM8-_)1ZN?yU#}_sR0VBSe(tNkS=r#wbw+lmse*^4k|NmF<2AQSlsx8TFUv$1o77C4 zzFJrB+Xod#orQ;-`hrPyzsM$#Dh)P!4)kq0FIDy^v+1ful&388wKds$3)veQP|0a! zPi`+J2)G|Ik@%|5w&i49q2?eW=*xMcuPw;vK!H835e|;OGHR&@ZpU^J<@ch|FD;ey z?=ynZ>c%Q&HULsZQmb&@WeWElSxsGp^y7iz=TK=LTFtYqj-_|zzIIH30hxR*&1V3c zVl1yqs8md7BnRtF0D-DJ-zW#cl;bh?#ud7wD|d$eH3|;t-Un?8zk|UsAp>gVS5_Gb znL!g9QubJKOA=@m(VO}rBd&G#M=&t0{x{1lgj%mSZ_1Gi3r1TvXCRzf-<{*|%9y;UOgR+%=U zf%+BR&7}Z!rX;GmmWr<@_-S8{ znr$=Z4#F#rNaSM{w9^OrA!h3p;EyFR{2r+fy|&*~*Q?ZG6`)OaGnYG-<)wKd4exm4 z)6y~zHRo2oau8|MhAAk+ZLPl_nfAl^2t9dOldM(*ZubZYyw6lSdMngysi}GE`4TfS z*W5;iD@m1MCF42hf`be;wZ0Xl2p$LIL*LRT@F0;u8jB?sF;d?w2WTTo&M21z>vtv#{zO=z2F$DP`r*-JFfb3eBgzZ96?xi4aAzxH+vWvW+(6Cboa z!Bl`y9rRI!6HF~9#l@Y3#-C;$`aP_=DFwH8-bL#=bMo@MQO&c?O={+dt-7@m@IJ!C zC)pGH@;QWcy-ui={8Bon^KL3&`M({_v>YsH7a5dtb;HrrfK6G0PgFqKps2CH4=(yR# z98i^5@Vjr*uVSiemX^-4aG9@us1R;luIbC7NxY4fjs+tWvc6yTH0XO;Vs+Ca=s*!> zCYaBr9iHB=Bwejur+HN@0ozfucDkvOkiEau?R8J__cUX=+rIX!%dNq6t*sLGGVf(% z@yEKK2#k?A)7!~Wl{(uj6P|^*8|Kj*%DT@RamftX*39h-*{G3spLs5D-B!(BjFzdf z+vvsGe#1=A6GY3c6c_AfJvwd^>dy#p>erk|Fj3UZ-x`RinL3VztNK8^C0fA+#TH|Q z#l2q`Glsal`W!L~R!XNL$u&QG`&*idf3`FKqW4jNc?$o|S>lu5kcrOEbW2lndYqnO zO_@ovCMhXSClp~Oz@%6F#Z~)?4_i3c@G-3o*Yj9tB=yAup{@wRbr~YT%2m-f7-mPE zE1YF3&==UP(lNP-`U$=vPoRuI+l_D?TvzpDlCD-( z$x;28#m@UJ6(eD=mkHna`ByIR!(KM$iCV-J3lV~j5CmDk^*@3RL!Tv_o47v)jct}<+_+{y>6`NBYvNY1S~fiLgpL^A#&7+7zE2z1Zar)1ir9F=@jfF{^+PC z+-4YYs+nlCSf_oYB4<_|=6cu?4(cHBw;_oY!EQVPYnK_sR))TckFzKWIrnXUa)5kG zIi?leBEP>V+i{$3%P58FL?WITSKwD#`RAM?x^s`$5`>u?-*yawd@etp_le5pb{6(O z5JjAje16f){QVgvrBzIZHEPknvV0Nx4WgP2pJx~+NQ~0=j_a=z3=n(oq&-h4Rm)&4Wo{u%`exAAk#)HgLP%|SgI_>PWHhO}?Ju1=TA(@zW(7>3?Y&pvXG zG?QjU1vhIuJiR(=@1^vMZ;R)8{Y$7b(Huk+hdxXbH>!ZOzw_Crt(Sw&{hW{gM8^^v*Uu^ERhNI`8Lq8l zKh9Xh{O_+0Bnn=|3tpRE7-PeAb`yR zcD!=D&cG{|Uf+eAnhPdb6qd`rs{8RWX763tU;**UrSkA3VfvVzRmFn41e(k|);O|h z9-tED@~u&XC@2XQd|^5@yJuN|W6djk?3W^3GLPliKZ)K|`4afKk6l-H7*wt-i}obz z=v`E6VKX+3n%^)If$cg^Cuo z5IrVuG*|_=M?Y5@SjR8;62OZ|75$r**ww-dCdjZcNoE6Y8yjW&%qY9$gi5X|Si& z9^$!UWaKlD<^!D70-C+Jn_A6GZ6EaT@Pc3Fn$G}xWsgtS zmYICm&n3PMtT#V-C^vtVuPmPC=jJN*{>Q+<^OWw%&y;R7L9bA+(FqOjzni-oW7C-* zTc)YpU2Y=pYuN%zeS)KV@044__Dk{ZnQLNs=#%GzXGI$|uZDf4`r%7m^kI?;a%*xq%z_VmoHBb0 zko3+g?H|X`=vC+}zuxdB1qi18IKCT!cuSoo!9R13`kfL|Bz0iZDy`2^s9 zcbMNQD3`aKw)_u7Gxn-wCFkcUC_Y;o_`{DPu)hiyxIKVp;6tCmYMLgC&>csGtf_(e zJkyR>+c(|wGLFSVvB+CWC*B*M%GG*6j0epYsrZ;fPE-WEDUyr_Sx`<4!bG>dBzEa< zU<2}?g(pl2PiAH~y^wT4;RRF}S0iYAQdw>I4JzOLUhf`C(!BH=mSoqP*k+yW5>% zB#Oh%;Of!YMIT|zPbjCRsVTYAuh_RPEd+p%TOpMlR-C)}j)LdR6u!pFSE`t!k)w;R z){h!$8lpd4X1~3|5tHcaHn)~fOnn5*sbUk+*PAJ6H+4A<1mS2IrrD&QPO{X9Bjp;(t|9r1IF0kamT7Ous2B z`NYi~sN2tX{q=K}iDoF4r0CI>S!d8m&yM$@1FU*Ic0pT?E<{>j^NZV8T9kmG6}c}F zU(^DLDedE_=a`Oxgh;%yix-1oWsJe8j{| z`jv&-|5u!rpp6A^Lk8vqgs@n3G)OZc=n>t>CrvUT0UKcJv7Gu-WS$vH=;b&{e3GG?fLbUNlWL~>KlkGBC>aUvg&yU5QVLQhX5ewAF$=Z*H z8xoehoRd4A#c||i0ut{ZXjtD8Wl$~dncIR z2_?JslwYD`1}m^Sa72A_^}HC<+l8!C?WUMi>{rf4V$b`3wE0SkA2 zJm=Q2QWIBD@jO;fZ(le`)6f7i~BVaAVZ8)yCCtl`x@s0B(!Z=Qx4ID{t=DIhGpz>$y3V>`%(&lLIo zu}9}Vx&4SawZ?IT*_F9iG^LiGg*S!W$}niylWKK9l%OY){6KrQHiU`J25k*BZQ60F z_>?uW+&o1k!G8W;4A-$_Ty+hS=eFZE#`9{XOGv(j#apJfs40vxwo~kGMfqRZy=rN$X|12!*JU3a zDPOzaILE^5bRN$fYog{o37F&P&#kfBr>_}T(A&A3=zH5}#$5DXnX6(Jdb#T(783n| zzv4L(zXTpv*j$y~cU$(8gvKW$ZM9ZqYO=UD?kY+pKW(($A+zc zaVqS2?Kbii$c6^%c?O@yPYzYsJc}|G9O#c;W~-sPbKl)IsAWApwQ;b_oGZIJaFfYo z;%sJYyL4q*acG1>o%0sqE!s+E?=K(nf2Q2?qI$`e{x!^m^4&B`WAyUp%O=`d9x%s7 z-bQ3*2g2afc!Dt7ffG6f%7wB2S@fP50eqZ(8T)j?JD?3uS!RzMw7d0ZQTyKudR%aC zebL+Op_6X3W8p9sba+y2l(2=|f=|L5$VYTD{$#e30^Zkr&;7lo1KhEN-EIeb9-VCq z!ubpgwwD_c*|tr>gmv>WF-3JU;C!6xs%+^4&;LNSBk_z!|9~il$IqpQ$;2}Y?K~mw z;-T3psIt`e(&b+pT2vUBbUQm?1?({_9)ZFQ&$?c^v6>mteLGtWCV4Zr4Tiq03wmUg z!XG7l%58B2=>e-fh>)RZXajY^_8`&LetH|`< zi04oH>^t~JT}%X~KlG?`t+GDt3p2rHa;MEPYb7tQ6~NXgC=;IVJ~v$DI+V4V*He%Q z$y4n=%1EHiO_KG^ZExn7hN@5U*)}SF{^ysh|Hxhm5A|wtg(4lZ6gf=SRVC~EIcXcMJ@qo_f710nG7^!xUxg zK!bV-(s2NA_jXkhvKo24D3&inhwmT)d~f;Of|kz2ljH1QB3j>w9Q{yt>e#DhL`f=f z(nom@*rK@0CN|4iR|g6N#&#X%IZhc)+29MZ9Ii|A3M#HtYmOKe_oKrqQVpUv)bW`d zXRS>zqwMMOHJYPvTQ3@`Acapod#^D_*P@fAcU9)cbK2U{I}KqE<_rAazkDaBPm$b% zg7dT4FCAr&IBeIq?sW0sv5%*~%9ZqrLI%55MVUhP_V-?yISN(JH7Pkk=+o;aWN5urbpcq~d} z?(9=8qv90AGrrX|{_ROy;89)gM&iZBuA^aKh|umOAQ%>5NBs?|@gvs#95XXN{MpZv zAR|+)y+4zUs5jkb*$FL@b9H^lPaBXgqUI#*u8};s3SWMQ0=Uu_oxo;bioZdA;X0oD zZfq4n3-lATWBdGlT6T#ufuD+lzDw{dIB~P+b*Nr_I=WRHPw8Kjt&hU2aDdM_nAId& z$8sxBgRFKBUF=)()ZMi#(AcA^7sBH$Il`v>Ku zEwN-Sz2#^T7_L#ERiU#Lf3bh`{QccyCx=wKPxXyonl@!`#Za&{S8#_Ljw?Mykg5mC(KU zcTOazoo$?3PIj((^e3WHLYvPDF@%}9eTN;t4mv7l*0dGrA+8rsD&sf%pcJhafC`zf zkD*Q@ah$A63mzMB-cj`#=XSNC)qI-Gc@N&6!>_z8RvuSh1ixbn?jI@bK<)*fY6#GY zQ>8q!OhPt6?iT#Hd_(MIhPCJbK+QFJ`aJ8=MkPuv#y2KFnrlJ{R5@I%4vk0H%I)oi zTr8uQO08S`d;`JG;ES+2%ED8bXtDBsJUG~*)yM9kh)AwnMn%Vwc|;jA)*526%q-Q1@2Sb8cj*?D}Y*1z~eMQUL->yb?6hQ#10rB#NCl+Os7^K91Ii-#in7q9MJ zC5fd|_9b}wwz$2o%_Yj`kc226V0zxdAz7+u-z-1x4S&))yS2(;wPYdDjTaJEm$0lX zw3JaTxsEes9^}!zTsO!KhP8^lG6<$QUHlEQNdeuctl$`LzvF{>>eSymlu3hJKilvu z*vKqM_2;}v|E_37=U73ynX;9qfKZv8mz6oVi?CIhmCcx*WaHx7<_hw#d7Jg!k<7Gk z%%o1xWxcVNYKQgJtg^;ICR^>)uR?_kR*%{n@nBzF@_!}e(Z=g#QuR3muuA7Ge60rABt`SbB|0wyt5r9Jbt<)trxWm+H;yw_${LH))|$sM zUslpnr8{Bv68#bXu>He(hBU9tWd#87&!e-_Jbuw^QyR%Ttn_i`VSTLin&80GpZH5^ z2tCFb!hzbP$8kZp7>~O=sI-Eeiwq^lY)7Q6SYqm45#~cHL0=X6YEe9(UHfmo%133T zfM)-8SmElch1LiowCdDG`l9P!=g=4XXKxd_$1;HAF?gkf2D)3`ccqw?T3Bp zt!s!xz4&(NepPqcT)*LqcME>4wWvDB)3~2(_EoKF^?0Q^o&nnxFt3Ig^G?K942+y( zw?0_6YVq1@>294X|FQkjjgyo}t(}h2{8O46S$TA+hCIGjt)SQT^(D^*cgsQ>GIsie zpOe4H^l0ybM`~1l%9HtXBEgGG$cyr0|L$8&d@#_{W!!^P_f=KAdV1$7(8YoehTABW--sjX6}$e$f+`>1qesI=7?GbI{p zW3hTKVkaFgm@-%z7B$MxwnE1hn|Ny*UY|-iJX@uZbHWp~^5EOoD;3b@vdlT8PcN@? z7&zv2-!43DwDGaOlm|$v>=uGivh(M^K^Dyp08ty(1MD0`(y1*H#<;ZH>R4#fj*~P= zzrT5oc4PHy6_Mv5%3;Bv)Vp9)Q(mV$d|)NgrMAAQcB!sVeyDl%`1Wx}U7~N%y5z5_ zdNM85XC~ltiyp8Q)s9%8G?_}${3lzLYAuz6CN_lBao~BZl6OJ*FboUgNBswSe%$^7N;CMWjyMtET zxesvxiJjQRHI3r?m%#+vO84`o^c8w!qA-&2fFD0qJ{44BDCm1*@?*;2=P; zV|~ffXjhnsFduvHdBr8dTr>-Sf;cIm0i(%PjaYuXh0#2dCde2gpm)su7Vvts*Oiz3;t-6OM~91# zIyhLQsBp9`KhS+57rowGPU`=T>hI*ZQTo0|XG(4Qja^wq#m~X-!Yt>;p65jX*%}L%mY)x1J@mMcHM2n( z1w^xQu{v_9?`!E9QPbj(nBvnvbbk=h8bDxUtna>eP=-*OXvgDs#KC<1&H`D>zTft; zo_X-YT)d8fn_aYCfKi^P1B-pZ8NQoE`ySk1Dvn} z%|4{P50M<6j1n&8w5#hS^2O+WEPbhhK7>L07C{jGbMu@Zh0+5?Xad6S-Y!$ z^RPDWup6v?is%!$fuO-|*?<>%}0^_<}PMB?H9U)BM;NWiN+k56pHu_mEqPC*>yc& zjn(J`#E98glh*U>_jmBwGPT*}R*uP?w|h2-q{RO1t%Yq}-vOz&M?P}xbtz-`FgvR8 znpg}2s$VY7jWS}b!UgAHX;u0AHgyXr3tA4td3%9-&+^Dh3J7DT71$6eY?VngXlO}K z=6VYa==4h1O*(>6{HZ)~j)cxcr=m$z`}yA2huQcviCb8?Pi+%?JA!l@4HmRbd1~!j z0#zlBzQ)TslUzg~93eI^r?l9w%Hj@Ut=EM&g9=JEhjr@(?p6+PyqT9mt-f8c)74Gw zzOPf4aQH${cLZs+KH;yRkzRWM&%}6U1;410?0}C?s?GX9g)cw(SM))N>TQ|=^#i9uKHx~tQlo9BbjN*%ANs)s%{L#NQYF+h|8_Ss&(wlr%X^y=Hu9g zLaLBxXiVUqYAJ7~$XnjG;rTu4D0B1%{Q(!tu&`F9|2wx~-T=u`h0xmatBqmB$peWR z0qdn$ghpL0awuWx$$gMq+51@|rdPBk;|dZP^yu=ezdIAmU8_r_eF)!8YfMXy?hF~(CMw?Mw#_cV(Gtv9-+;}J!)qX>Io8g6cB7J3}^ zq!xbcO*fHsD+AF5;|(lGui^b_Q}ae1%gbA=@)Nxt<6&yRuPAElTEVJ7_HQNp|ApoD zUyx${g~9!680|m*CZ%>4W(q>iCa2j~L~gUzdLs(1-^=Tp%@M;<${DL{W%``w<4bM& zBG3}*;F%+d(N!3BNO`%@G97UhvoEzTU)h;zuy)D`Ou&;qw3ZIUTW3H7_i<|PHeSv| zrpEM!BA@;S5lWmjWZeGa4navOv9T-a0y(mJ>Hqp@!aFLDg5rOWOHf6-ylVOC`=Faz z;kH->8K-VcPGmayPU~u1N6CM)DV}H(D$#fFI#{{8=|1yQ zN=fm(6G?9})Q>g$Y;I0u^0JeSW!+GR$X$rFqi9Wwh^0S1U3hDHerxBbt7@joA{ln2erKhN{SR)jadwbbI$Hr4Tjs#?sLM<(j5 z2g&8~^bAwReB&VJ-M7F238x<7l*d3B*1HFXa(wvfc*MF#!<{0Gr4}?)zY}tIlUcG$ z$&f|O@7+FibRfCPyjVBB7vPJ2dM9z~mx)aKuuatE@n75#O8+9u(S4^api%3M=oJjX zxG7k|uBA@?G3PHV$+#2UJ`#NUnh4`g=QrpvP+{#iDAVyYIDK_e|08Vg#69U~{Z9I> z0_n%q?`L!=>zAh^gp&*GgegDbN#W&r-&zmdpG*A>NdNzBm;V=C06f6pmCUPSn)7p0 z3GlA7ArJ?!Ig$1oTPtd&E7-+7*F6|DyPWRZKiZZ9$IvWru)d+;f5dzCX=b#pP;fM@ zHdLIt!BF6;GI?dN?>9)}F3!4loXpPjT_N}R>%}dV`)u4QBs(mm{R?ckdvnasBT3ug z5x_lEg>?ddz)EHlak7iY<(b{CY2>}|@98vCJ0rUBJ2BF@H}TT#U=sB7%4u6>cF68}NX&`i=h%f zqDwUQud*&i4zB>d%6~dv_1w0#osb$%1*j?=tlM6UxnGNh3%C1D$Ud*J?{J5cf@Tf~ zV=;uf%|z4-N^>mc#`q#?!bN^fF@8t^@ku_k1`UG9vQYU!mi{;+D1UtQUk>6we&f-I zyf*6o|Gjw9wJG=zWgt;tcpK}le7 zu=`rS@%TD-cO=CrErDe=FE2iOe19#s<=|aG=i0|Fu?Ffza$*PHHEsEq? z#gOZezN76C&p}uPtCw}*59))YDFx3GUpJ$q9iIjw?U|w#`gP%3IO6q%p10j;C1N`M z-P^x?dz7sg)t&<5+i+3U0e*_dUE`HH&lUt(pZNE&|4N3jc(CTsL0BCn=kWtHG!Q8(g5? z-N`VJvWN!kF0eI_K*1QiKdeV9ufmbAn!`I{Km~gO4n%l-x>1Qx^iC5|uvr!LezzvsY=u@44ht4R`fb=ha_ zu|V+{iMvt`_3N)dwnhS}qdviJ=&D}tqaQvf)cfpvPpV7lBVjEq@;c2?fAhB=OHol{ z^wdkR)HG?y^4r@fyz^T#ipt1$YWUKHC&CMaWrlBKRr(6{`E7PGWs5{bU?IzqW+H(B zfrOlw<4g-Pq;m*&X~W(kcro7yO1EO3bls#dJ;FniC@Hq}#a>H)gl#wdCW(bz1Grt# zCa;KV=1%%INCNJO1PZTSL)G6I_etE5(IB-n|EZgzF*_!?15n+?D|SF}yIxC@cNYhU zfMbBqz$R}H?+(ZeopjvNgtTwoDgy^BfI;9WY~@-53g`UUSR@kVPu7ZITsAc!=5#)0 zE0nxBO6Enp?<-r6b)1X%cp?j~F=HQ%$Jv>nRhQRR+a}Xp?1L~=n2)vlg!a3g7gL()EA_@^QfHF<{A0>lL)2yE2gmW%_!|y4&Hthy8g&tPW^uy8SkdLrVCAp{{^@=OlFB1`V?PdbzakTf zhkiH4X_e|w{Kq}mANh)Z`^^VJ|bCO-Vy~K=J*|n zKR-gi(e6(ZsDhW7y}fy(`d)q)z*3p0fcBm30t#)8-drz6<8zN23Rp8yC{jUvIKhyPpYb7G52?Ti-bAH zE|XSobi^XW`&E5c586A=*{}SN8|vbjey`?dL~{Cz@vWky7jc#em$5n3UT-l(UfiYH zXoP8{@kb1HZ*F`UoqG5knC~9?iz{D+dooP5yV28! zV7>lSRVZzbr&vwkYq#(tkKCrbZ0=-N!f!sxRj!geVZtMKkAPZk2Sg@x*|AbU7IKr0 zl^oxgMjW04oi*MV(z@0h>N%7hu{Y>sKd9nbFubOt6Wy0W=@qJo&P(1%4k@m&?s?-Q zfZ>?1W;Q5TETf>iwfCJiVJ6OBkY?v&lXzpwOW}#^c&&;{N5{KIB?FbAP814Fk5QkD z62?&Epr%F1I!XIJ#3neNpxmMVU%b6#RGizgHrfOd2#_Gbo#5{7A$V~2;O-uz2_(2S z0TSE^?(V@oI5ZaAJ$TdWzN~f5K5Or@&-m`WQoP7boFW=mQy#K!q1Dt;(7bkqA5bb-_Ao{YSw%tKT|>a0JIwpBV(1Tjeh-O;!=V1$V1@A)3-vN zK5DX6;a*#=gu$Ls@9RL0H)b34RYle{#zy)-8U#g-ifx5d1APTHt@GR!{{Xe5&>_0e zBsft@zW{wm?o|#;CVSpcIcY`lImTH|bg97Bcn)3db>wHwa}LVuYgw z`Zl>zSfgHL%Zri@+fN3!vK` zRA79WVgGRhW%Os*M9^IdXv4!eO50PEJXqJxB4q!Cj!koP1E+)ae0UEMC&bY6>$jTd z`EE06M5T?sc7}=f`q5gG<41a}6N`I9=8AM_5V@q$!_7l95;MPcyx@+hUZW4S&Wt#z&d24rS7Ri4iKWLg$*N$B z=kL;+v<8T!-f(Sx(Vv}bt6Q{~+IH3O*il%VN(pTl$;rt`YD>%1_te_krcEd^GSFKx zT3nXZ8@y6LKNCxml}bRP{)B%^;x~cGXMqUD#olzgvgOsToANsHwPy@i!SQb`b`v!U z(8e9MGn&)#YA~$$x#veyzI5OsKj%`ajCM3+Wh3AcQ#OWcTCgJrSTC6 zb2UwTu3&y^utm(YJ99WwF;_G3yIBz0dGg=9Uqms@>D);c^VY9i%#xo~lRQmvsZ<~K zNE7k-iNBhEOwdMY8kF*Y33WiG!{sCdL^CIic}@Ds!;UrNEv60|&~IPZiA>34c-9X4 z+m?3c;)XE@KxMniz#gP50zMb?t6PIi{@dWT4=Wt!Tdob`DPnQMVV4K889o)i=QqL? zT6j~PpA<*cym~0>1YukM&6;Zd2eL^bF<%i(Syo6_>nztaGs!h}NKCVMtNc)a)!>e< z!wQaUvoGphDE45!y55+Bucfsw)6UfwdKW-d5^NWbL^GrTJcM2TE1vS+u*lQ!xKKV3 z-DaG+y|#EM3X51&FoWIBBcx^P%2jD@wiGY(hPi9wbxuJsZH1HPmzDN_KS0Y%yY9xg z%XZ} zgYtQgd|g{AG>=%@tq(-|*V%62fUVSZ15lRj*gs&^?2K3n`3;b%vK2zxwkD$A6US2a zu#$F`S2fZ&<%sZt*s8tQ+hdvdn*I<0DM;|UsoCd*B55wg-roBI%MKv8zfi&5Fuz?E z>ixCY!+=Ol&1hp;?Cerod9cP>*ZZ^d)8iD-u2>DL*sX&>>vTubUtn(UzffVv{~GW? z{%0g6wFd^`^rz_G!(ggEKtn(Nu@N7y#IV5QSAf+F z8qS34tNsJg;T6Gt0#=b6xLZSIsGv5a$nb+Y zoB{PlTZM$(uQJ6keM%lyZL{oQlTX@UyJ*j9Batt}yaHZ_qFP_e(#n z85k-KjV zOMpL#NTGsExKZ|Dr@Pq+dRR~BH$Szbb`Y|h`Gqs>te>ZifH6Vk1D$^xtIN7=s|bTu zgkm351h0&3y8p&&efZ?n!*^pJ$-{N*3_VV8>4l^f>+O9oL4QD9`Rjdm-o=4w@kB`m>!qb^ruei3>PHs0U>HQD5&YB%ww+*cn60$!vayR-1xyfjiklQG*LMKaGEnVm^2R%H3I*@0&vw~|JDKmeEBJwSZ_ zKZVu!Md;LsSU-b{IKMs3A8T+{A;HJo#~*L-eED1h^*J&k$$Qi09kLH`L6c{BZEPsu zZ^MMH>R;{!D~{8m7D+V@sA-NXnXRZ;ERa-nhcXY@+vFVek%OsCDS9l#NwgrLHM2NP z$rrqv9p}=y=U$WwnQ|Ii;2}t)@eS_ksLmd8@S!g#9uT=LpA1v60u3*S)LEMUo=O#Kwui z^HXqH*d+K{Hb$s>3;0sY6JYgPkQ88X8iEPFL&m-=>OoKrV`?J>V(<1%)rtumFs16q zeMf7#M!mu@Gs?^dkZ7P9y;^Q#9+HF8tJ8tPeZc>g_p&q5#igEPwz$7K<-4DtgxhHp z($s)`>5@c}m!cN@$g{`c4N6tu>$3NB7Yte@8v05K@D=d3Om)HaColjB-;$qxw%&sm zKNjS>JYk-_x%0u6iTzQssIh;tp8%V}uL@ewpQyX#2HFL&)OuVzEAc9%-y}SqG>0i= zH4u_@u=DSBUT6|F?Hz8g$<_j%i;|jw2G7nHfAdUuvTH-ApDN37?nBaK|MxdnlS@** zIN0K4n}bMBgv@$`iw~5DlntXYAG9@tn31b$sLA=VMhU zV&ct9(C02&IBC9*_7xSD^g|{;W1CXmxQf=WItYB`4Q^Fgb7#dAej# zxtsH!=jxWN_cU@G*8sX>16ilJbBv)(xtvihS+mfa+lyY%{_zB~4ZDMY~ zitheKj_{H2{j;SE?+2!}wsNbKNl28&_rZmQH;nsZgAM-N`#$jBvq@ESpI8p-My28F z)|2aEiMbc}{L3HH%YL54NL!EEu2+vd0|XZI z&Z177+=Eir@o022ACGj&&Mp9tl9Wm9CU~8{?!iSj`}Cn!>t~W$)+icz~)ZNA$y zzhQU0IH`7*zCiZbb-14FG7e8C&6khKtuKSA&6qnl?<%MwKvtdl48P8lA3p{qY0!KL zBrG?#Fp^R0U?=SdJ|4RvU+XSaSTEzf;?r^bR+i}+A7a%=uyYe4`5^`)ALI!}-(Z-&WZ2qBHqlCdQ*m4sZA4? zz1ctx?qS4-P!a|^7NGS;3ea)@_uG2Z*ZSPe21a&b=1%ft+CY)q4f0TnX|t(I^AO(w z_tXmB{gs)`n6;z4H;~#FXw)IH=Om2m%-Nw;pf$JCKR|lcrS4lZJS~x-QoJt9w&g00 zguaQ5-(H8mz8~MN?BfTVn5?&0fssGHgD}MTaX@$fdc_Nrg?__hr;r+Mzn;R|*g&Cx zX|hc#{$8HUSptcjSh?KJMlFqs2okB1+|6Wt=Trx4;E2|dS1Tl><3AzZZ$9c6H+xgX zD^P*Ab1zagH4-YO%mXfG%85OrI=CYX;CoofZ($oH({(l4UM|h^2^girAd=lhZCF{X z`&qPE2_3!wxnl6_Y37a-3I-g>)IyBQQ;yuW*>4KvRX$s8Nr{;Fvz*W5U2e5y^!lO! zyPqHRf)Uyq7%yB6yh*wd$h#{024?3E8b5RP`mZZeyd001@)s44R$Z&SD;)TU@IN!r z45ili8)nQM)hF+Nhz%y@t&Tk&bGhlof}5wT_t>a!#`>~)WhL9l0jpJNZ^AJ6moVy+ z=jCe+?lIc3E2dgJmZ*k-gBnQDqcNUQX-`}NZKr9dm(*<;kMgUJ@7Xv>a`C>TDDEbB zwj8!}P^F*6!n}LL_NnsV&H3qeGV9=9MZk5lO)Kp+kCQs)vVVP`ZE|ufDVDl=a=sY0QPmhV7Pc>^PJ|x~8;ks!YuF8P z-1lddosIC@7qr1GZ%==~`t`$u-7S$%an#LDO@3_L%a=RZQ2(MT<3i4rw=?!xcJW{n z^X!aS*jVSY2pV$+B3{APJcMMkX>EJ+%IN?GX+@*S&nK+VvdmP0EkZL6B5CYTdfK0k ztXF07Dm=DGe~U=!PYCm@DG)#R(78k@r>2m~mlA_oWoUL`!9FEn@y=r4RM88`I45qj zO6f{2$UAh`XKuOentjei&46OcgGb66mZ4WI2iZU8Vb;}rmAls|0l9@Mqpx2}x?yKy zaaLVK;@^ki9Ph8BR?cq;F|#I|btp`4+?(kcFWT&uTePR(;#E~Yc^hEb;skkvtBQ$d z^}cb;8V#2r^N~f| ziwZBKukL8V+sBf>2y1C8!0dQC{K6hp&@H*w5Z;p%nkd>i;oidmJqP!2;ey~h17-bkw||02TdhE-hYVm_ z=4F8EH&bOt?pim=Hw*wB*Z5WK#`tC*yyq&Ivcrc8>YJ-ubb6_mdN2xCtF9Q}<2Cr@ zEPFDS(%3utUB;^_Q9eEwSuMBLtYrp{roMGTZg=XPtB&u90LyEL;o5$x-Y8t^%tyxl zqpg((|0#_cw6(ISMTOll>PGJw&~3XBI|7o&&c%sg z1cw|CPW^7V52T293tvEl9GciM@cSeL&RTsM-)tzZkoplpnMJdGCp`_;P42Co8J;Ux zt%PP#UgQyARhPV8WKuM!ouD|hr>8bSp{M;k4Wte&J@-?mKs4TB-Z7429`Wu$niZvdp?iHZLr zGpiz~jZu?*!cmDqj>X9%z=?Hy)6er2&sL8qy;&i_8_tAJd6U&@TU!^CqaI6Fh8Vqi zPGONOpYm7O(Q>K!_MdkO8EV8S6A}_`@T_a(3$i7Z8W^WkU2?nNxTv~yk8wpzG`1{U z`NxD*2?hlUI3a=uTJnMSB{&Q;rphgk_yg2i1Q!7Bz55Y+x&}vq%L0kVkD&hF=6qs2 zMv3FabpHS~0nuLt9-`m)XM5l!j0aj|H24eU`)ELyz588K!sNSoUTzlS4nGVl??`yU z^qG&;6dIt^Zzs1qX*aSn9^|gMO{{Yi`yhm04rfd&t=BN|KbQy4OePYz;jhn(T!R#|<>_X`38ppW3 z>NsTpe|1&9U0o(WXZr(WvM*C!<}S7z)Cm@nhHE@d+JEv`DU$@?v@#+0xj?1Nc*Pt8 z{k|!K1HL^RTf>ErR3gUj!(8l@hQ(RfI`tr=gb0y5t?4y@3<2P-$sv%U{1|D4fX|We zQh3U<45W&U3<)AigM?;?(Q*c|;bT>YEW~*cFQ3b3kuyC}wu53CUjcVPc)J&_zrgPU zv{-<2Q^JCVyVW}7KR|{R75U`XBgyC;fhr>3ucq`}D`X`CR52{bTE}PAz^SYYH^#D4 zsUvmObrDJ}vjp7<`^Jvv{)0TMrCWLVOr9+b%T@AeRHdc~Cl=t=LNB0V6K?E7aGlr# z!=!EUY2l+zQG8>3Mg@NkcmFXCmu5P-N4CklQ!h~gNIHx&Ah11Y69lL3=)xGwo}LqE z{L@|ai(Pk%B?6AGu`_tLv81^H7J0yS=cRsb6(4q!zjsH<8%m0^Gt)E6-6U27hW7}O+pxFUUnad`d#hkM* zKliN~P*wN*!bnuUqxP(_+ia;sT_vr_NhlJcI&Kn~SlTg(gWYhy{juYf84@V3Q&?e~lx&uw2zIk)tFav_P%LSKnNuyuO zB01x$)~jcM^bL{BhfY9&m%NC1@d*c-$}v(ju1Ywr8i>_7w+RQK#=lHwFFtQhT?ShL zUYd}}6$Sg~YP@wDuHxL9A&`ZXpg;BNqvOgtQjn&l+`9;@M2#BEg)V4T!Z?Ur9#rAA zPRiON#nRiual6;f*`GkzKR(4oP6f#u=8Wa%RyJe$G)G>{S)2z+U2OiN&-FTP5%H9iR6>t0@Ehaz$Fg%f$+vE3_>?1 zxbvy*$g1aBu`rxWHb08E3my~kmgAyL86AO~**7ibP0GC`o9D-8@_nz~?q!KPTRE~Wk_o$5OZ>=J z`2ADMV=m)YVd;#CB$dA((u9lv4a)WwDzjj+ru7BKZal;A$SFCqq{f1rATqWZ@fBlt zvlu&ht8zNtXb001WC23SpT`uq{A$Wj$;1V^^3)RdLnW5{&=QX;_j50ql(}|4Oci9O zUlqc&Hx~E&CW&x1_B?N@EdpYV;3NV5A5qwT_VTu6C&%YyEVCy?SGsn_+I4m6N$pyO zFZb6htmpNsWmrYE;?c6ij$XG~gjRao&2jsv8|*b+%H_coi)gO7W)lymiIj6~54IDu z?HyAjw|3VLjM3Uyfl!x08VPxqbPO#eQm0vz{i;$;8T0CTUpn2 zv5aImYBJDu0i)(1^WxGBAP>2K!~G-1UJP~*NKr6giK z!AD~*Kmyn{Fzj6OKfb5LUkhV3hSds31DnANK79#>E9ItQz!Jfy=3=)he?1NjcpM7` z6%Z@Wj3kF40+u)7`{PE?7{drL;2I>2u{(g&1pzj7Sefjm+pbv7%8InR+u3L{Y!bSn z;kwOxI5plP67*f**lv$ATs2xg2319#sA-Hv@1T~-Nozb~)J*qBn&k%5xD<+<(86_E z#ra!3k=Te*_j!H&FKAfceB2PfL3gorD@$!VhNWQsp`l53MAN=c#{}y;L0?v9Odkqa z6o$x-#MXxH^tE?zDts?QqATP2-k=?DKCJQxNq-pMh_2gh&0DVD(og&R2Po?3QfTqM z&Cz$)eXwBB%E2F}a#5H*i$nGeQetc8tu7zGV*W?__zSEp{frD2Q*vhZz4J>KPp`w( zw?Z;;dmoPK8%zp9s~Uo&5X|w8`&2*>VpmO0d4^f$eottIWDh02Q%a39(ClL8=Qab#pXzV|*Y-t8KA(1SN#T=TmK< zvv6g_VHM^i8Q`t=8a!CVOnXH3f7};dJ z`1!Q0W<@e@)XK}>GD2bKBRXV@BWaPUel0k{KT2^XBw`zYYGjzrGxEdHpIhmUPC zKG&kK%}WcU*AItHT`QfR-@X`J?j$D6#1MV0>uq_U+1gRv>M`S#pESF@vRr`OPh4vU zqC&hj_sb$}GD~kHe5N(+Cst$!ZL2T*t|wQ zqS-_Mivrhyo_se>Oo}^EOwLHy2x7OR-{+wqKJLiCra|iWWb{}&M0BaY1X}ruZ9S7A z3ljMT9CqGBS_&>-y9W-J3{-HTc<8Gl#a2lcH@=s( zZ~or7i{_!yAl4ROq?cTOb>+G^vQ-hF>^Zj$^r*hwXp03*L-Q||I{n|fNig*x-A0# z!Uj~`$4$G;i!)%RNjE?}<=z6?4ldtu!$}VN{-64F7)VD7ebleFRpeJ&0)SI<2K!V0 z{2N7_lqif%>b`@WX!8_a(v~P+m{m;M9?IML`IkfA-S50*n!w zOVEwQ*jf$OH-gqp8FOv8G%mf{*Xr!X7**6|xNu$8Rgj?>_T8J^!6i+v6|ZcHMJ5$L z%9P_;Y0I>DT2U9>CIW8T_UouCI%ULV^SWwTgr_fNYe83lED2U^dT==E&R$c9Ok-&_ zs`@04RxEJL^P$bZ`HC2)+xAov^V&ychvrU(pG}>c4&tUNY^5f?h#BxaRVHrO5dJ-i zmzO_$qKSEp}a<}_4R(b}PhFdpmG!s-umGd9?YW-ImUy8-uWI6+vkkME;0)U_gf4c#Y0rD>}#1)Xu z>_1_M{Xd}s0EGMtDj+{Ud;FS!_?~-^%!4-{F$e&_hl2mYAO;<`);>f#u*ZbsUjX9^ zO9jBuEx>{N8UUYXZS{af*kJfg^dPa|gg;jqWe=KjZ15dLc+gK6raWau+J`R`KwB!Ozg3jP%;OB&d+ zYHopY6wY$Ovnl?jnJh;ic-ybGK3CY;ol_Z`h}s#=I62_n7Wz76?_chau8EUbZL~}` zbWE8{v*u6L7D=r^yvwO;S-itB=Ciq^cSqZZj^8#o3<}3(na369f_!8`cv>1NGd0_r zr*{OwpKA~5bR6?pEmK$|EHj7QsIf;hac+|_N4^hLSK~#a2C4ug6+|}0n^?u0dkvg( zoU*9fI!%Rl{p?DpKUS?VhQTih^K)ANSBK4rH`OxCuJ#~kUGP0vr}ATY1x;lv9Gk<$ zgLL`FC`&OZbD!2FHU6u&3E%Jp{I)N0!}$i8ErLO2y~T><`t!>NeCoF@Y@f=h-8{Il za+mzSD|6W=aZ55GvF?!btFgcNg;;PpTT{AZ*Mf8^a+9jAUqVzU|ow*Se|hO zHIO~9*)l4@66SoBT2!tn`?MoW@N*Yu*SbJVBJu8=gB@=A;WpvPNK}Rjn091kbn~ll zi$JzT!su6K>`yizWSZO+n)J(wnwAt1lR6PB2YZMQE-R%k3yTvPv;^gt3a`L2Ll;lE zn%a(&o8^KZdFBg{a?axQ_pps!HW(HB$XVn~vx9qLZ|H8P(8O*DDmo5H3&49yWs-0l zv3_+Rv{-<40|80|iwTCR8*H!r$<&|C#aP|rN0wXq1tw#5z>s9f#j-0@r#vd%@?UH{ z@BL6aPTSm?a!%~e?BMNz#P12v)eKWTIeCP_jxC>Y5~^~<4-8WLBD+CM)2>RGD3a%~)r^c4PSDnJ z^8D@3!yaVASGSX){B;tZSeLNA5!a1iAW#^` zo9EoB)xsuzoThB7%-4!K8NU{*u&%EasT z+WIHTb-jWHQubB1%2j4DJ6pPMTX-M7Ak7nd4Mzo{Pc|q4UO2- zhQ^ik#Q>Q+Ncro1ntT+B2A!k0P&Az)WaVBZNrQSUX@G_)mRkmmVW$zjKc+Xf4CImo zb$}ZC6j)em{xPMjT2SSIsaQlI~&rU5Az<@ z20pLk2#1~Cc=jwV#&yTN9PX~CQk=@FH|9o}`Y77P7-G7pBXwW5*kY}5t17NK8OZw` zlm$|G^6#%grbwAptV2bYp*IHLU5Y*>Xkt8ejZe@9i49tLl9sb#ew-j97HuI%WH1G4fEkGPJj8^L}Py;U3E%(Nk-z<^K{pPsivNZ79j+G)jI^9EYT zFYZprTH$qFFc^kNd)W|11kF>|b0ka#3a0$UX$v?Jfcw8N3fAZ5zyGkIUTb#CSVR6^ z(OvZ>^M(<;*F>OsqkXgX$h!V3)gj=74DOHWxWbz0_`$J-@qK8OL9*65zitxuNA*9p+ z!og0UX7p^EMO2~cJtND-&^}8E^-=yM4CAYhp}nx7pL}E?nt(KRYno$)9TSUSLv}b* z!MgUAQMZT~rxMo`b(~8E*TT!+4@S>YGnKQ}OqWq0U0wpZw>$#@{SzvluBc5t0bH1S=IvEsg@* z&+l7LZDE5i+iCPHixa~`VmsA)MVEc?c|Z-{_<7y(0TTlZwGTBM$0I#8WSc2BgK~pS za?1^#SZ+$=eIt{={U0m#~9zKv**J2 z!9ik>zlg*0acsN0;_>g$Jq6dkp1l)>27Q}C1sg4^MqhfG&u^23%s|xR9<6EJ2+ovW z5E;pFZJ#`6c5sTGZXk*-``p&MoU3mPMGK3XtXociE=U`i$=K0hGOL|L4MCXIe6mQ% zN*vY=iGG~fvl?r8>gcV=sZBWLEK?{{k+^i(nQ_Emtm=kqy16t9z~&?9K^v>R&7br0 z=N2lqo6e899fDP=@jj$Ixlj#)ZVNc1^i4izG5-|*bj0}tJN3&2Nk1_Ka+xihX3|eo z)kA+#0g;}T!_5W#>5mN;38wO2O@w_e@fkURM6B=6c#^;6?h~8ES2lQJ*omU@jTBGz zdN_W-_3P_#i!KWS33p4K(U#@!@qYMnFqCA79ZytXX zo#t1KbZX!mghGdnlDz^4-pR!yytJ&EU5_x8N_+1!D*tt;|<|OfInNnR9M!RuW1>0xK=h4at;UJa= zuj3x|uEsU{DLB#Q`{s3V8DWll*^!QXAIFCBB|EVWpXx1d`_1ZEl_>^+ zb@GcUwj;hjKrV&R)Z{wLiT&%f=|qu6a{6uQ?Uz|IdQMXGcZPJ=FQ;ouFka<^)22g2 z=I?19mcPHhL6W;-3iIpg>`ZVrNN-$P=q)6jGX7X>b2yr+AZt$w|MRIv zG!EnIkDZz-AjCirPKfrjdx@dOTh^(Od+xKP-V4s7l-KW^&Z~E9=(g;O;56I_*^kf( zqykbB;6_MvE8m;dy_cG)id3;{1?18Vlc z7mdH5W&G!&4CBU9Ty7DCo1QOWML6JXgaa(Vo+8$f$(13%_N8@D50rkMEi3LVYHLmM zoSkjp-KC?aNi4UhO>hn;9I+0X4&JUF=>B*rbtkJm-{Jkm5+= zqo_2-AXVnz<%M6}2H83&Z+WE)P?x=c+IxS*1!M+#*ec%uFq>5Qf%fa%84VmIz~kkg zsuUIU0_5Wq11FSN-+Ox0+F{HrzT09sN{1Nzst7}gjOTvk?)RaI&hRC@%7ZuqE^vg{g z`=7B3aF`MPdVPQYfuMK3v@CvF@--?#L-5id${c*xUqx!eKa7M}4AHx+f(eH^{a<^KhTxVULS??&h-Pq&;|C(c;wUXY{-d z6rP{*F1Sw>x#|{^qu&6J@dIakyf)(n#HB6aDEI!Fs}N{;Rpi>l)41`Z6xfPKO|Jev*RQNZ$db$T=tEXj8X(jJ>Rx8l zQ%9tH!!It2Tg(XEFfD~MRRyM`e5FC@_|C~&`WDa zy(@v*Pt9=-K6A2P<$swW;6(uQ`_YubDh&durLc5gHog zP?)xB9eBD2Ul+aRJWq^e9%>1DFYvvP$YrbjsHMfTEeCR9@tvM`x>#t@JTdVedepFJ z_%i1asr}c*4@AgmY0%QjUd8#SoxcYIa*33$a6`PTh|29af!J#J^m#$EZOQql{RZwu zgsR<~!X3AXvXZrjTEeYd6Wz_?=2(4G^p8L$!-a0}EB&RM;a5?dl>;LEKZAo%x{#ir zP!RFXYqdvhTAhA53#!*PZlNMGoDT2?oz==#;Cy!JKS3|sx6|b9C?T25#m`yzy-eoi zc512rEh^IOX*C}WRfr7e8cOtD{Av)ffkeB4WT@0^XoFDn`1*GKc5qXJj*dq_Lac^Z z_k$sC+sk128=-vNO5X+AHmVyrEUBAfznxukitA@h#bzbbQ>lrbF_|%dmS2@*_+bJ~ zrV~!qZFlOHx&bnlY+ig)aB?7$#71X){aKT22=t`2ds!aJ5{dIzGaY@@PF)di$ZkOZ zGn+9t$xB#&Rkl)vn?j=lw zq7P;Htt?X~QrMJx{hCL;f{>lGf_hh{6NiX2A4-Duc!gsvUOOuBte0Y{rlQz5Cm0M;pJvyhY0MQ?q5E zD8`caY~yiqphCXxdtR{U%KGu-#u1;}w>9s#pPj<&Qq8s{Ui)WA%g*~{xI18TyD>eH zMZyEWba0>l71DR1QX7G0r?0C;m?Po%>` z2L$(F?_7HFq#LDZ6ygv(J%=%03;~_BlTJei?OdL(txtQfbWe?TG^UI3Z%M=Kaw>W< zy(LdSsl(LS^J@$X#rhQCilmBesd3{DxI>5Eu%&)`po_gmDM*bOTSulAV7-SXlf1v1VZm_BQFi~CCgp3k3Luyy(TL+~^9KkBM1ey80KFy~A_MNx zChwDK!C=g3rCW9Jg18gmTW6voMb01D%FM-a);2)$We}F`IF#0uTFfLki z7Zqy7P7Q$;(IQ`b0siHY^Q8u+*;^hx0JnYLXMr6@lR=G_fmH$^Y9O>a_PXN~U}nxG zfDALE1emJqAE1*ZgARBom+DdBME)K@#UOHZsMYl_tkauZVjsA05eiRv0|D=LPW#%n z(b4QeVgI;oQR0xjH>-2cQ`XAAx77`xw_8=+ra_pR(@c#NO8;7fQ8<-a4KwgYDsM0E zZ}E@wGt!@n9hIhhDiuS@0ASRU@^Bk@wEHPAlSF{cSDDA~8an>i1vo+GKO=1a7H<6S z{1Rd8rVuWi0Po;FdEnRA28wvZ!rOoB~VbOwP}o-pk7@qP|PeKB5BBV%Dx7b6o~DlVPyTWem8u*cw?okYdx93lxR; zT>;lp{c}|I{s0`d+@}%f7d=4=NZfd)W z-GYG7@P~VNFj4Ho{ba|ju1sw#>@IW_IFU)nkNJXdAYbqqUcSxuZu+XqnTqW;mlivj z{IE62{!{@&E=t#zJp?{FxCWrHboXhZt2&!L?u5FjqER|nrBcDe%7k8f`1!P3XzyAi0!V^8{^g6S{h8pXa=#Bg?>bk22Phu{;zL1x8fy&xX{P!I zsN;h+P*35nG{`?kb^h<~;S&WXv@Vi8FCU)1Twyv6o~dk|)XWTi${1qzgtX^K`kiY! z=s>Gn&wt+C|3|?aCSMOzzYKeK+?DIqHfXyL6WK_J9xc2%`NCa=k?jUG;Cv z4!Ili;LB|$CACpJ^l$Ydg$Uy9-5MDQHpHAXyDh$yo4$X+&}vfBv!QaY+Pjilyw|PB zp?_4TKe_-r z`-Zx-j%Y2CR>$gPB5bI!3bLLILk=<}QWjD9jNhPzh1*ai>3W?3hEJ^8SDRf2T<>Qk9;rv0~H zjp=i$=0REu-fyirLCCe#uyqEYKP@DB+$yVwU9AgNX|HL);Q=rSOwiJ`(BJ4^5zfYJH`^!(}d1HvWw{cS$@d@RIOJrvOhJIZ|9w;NQ;K46yFv%1r*{%u! zejs6x#?|SRhg*@v`n0;{+cBLROV44po{bJj=lhzbrWXHC=lGoOW1OaLJ0F;+OOq`g zY*)30Kl$KYJ1n=K+)c2C&6h_1+r;z#(=UJdY5TB-7u)E4`?gW-vpIFV!HFA+@3IZG zl764M(Hugrc}l`E92MUS^5NNTDeCsf_YN;FH>+w48AHf@&0>m7=YkZy5?rd?eVF*#~< zzRhHp+Rv$Ls~5SnquLsTrU@D0TX?Q-rRw6conuL(qpLXp`mImut9SNdd2s4!Sy@@s zo(;3M^T;)=c1_4u!76EwY$T%Ln}V5KHueyctFP!`W}pk8&eqMiQLIFbj(L4kW6e*h znd9x2n6;HH!aOYflF0Ny4q2Lu@=dNM+r0XQ<(lFm_+4Q? zdr3kT=HuW&j`Z9g;mfGZh%SthID1XVr&TBCvO3cACBeXF77Kji= zm-Ymq|KDPmC%q?;$9Vg8icIfXXGHtf8MZpR-G8yr7QKlX;(Iu^et?cEN=$NB#2|7)EvXzByU-o~B}v)$F{W@%;5g zeynXpGIfhrv%_1%s9w*UC=+QA4G~YEua8t+qrZqQ3-MsAN3|fzg2UL-k20dL1v4lr zC=VBSoEOovR39I*d>0!BmZL^A+>yAq7kyb(Xe1*AZ$T|_xPec%%j7X4SK31c4#*R%Kio;n=JKFH0h6$p(5Mt|xmlxn&&7LB0j&o=ynEJ%xDAe#_%r_sl@f*1WN?UUsBP zh?2~7WT3Q{AS@kX(Sxk`F-cayiMVdkg zr>wqaNaE`(4K)K`m}o2Kz z>ea1gE?GqC41-icxffMe33ZhS0pkW!727GZllxGg!?DG%oD@FDvq6GyxRGyNOWD_y zG-9%TBD$x873bpfCd-d1Ae^{RsCS{JDJO2!yDmABKxdaxklnwF0RMG}{!6m{9v%LV z&k*7(cJV~%s*(Xk1`xXlZ{zXYm#b!_Zgb5&7FWkcHF^Cjugya-SeTX5|+r(`v2lnmY&@e<}?L^)I+=TVxR0TzoC z9MmdBY8GZw{(8Y%4tvn3Qz#MQVz;Hk>OfueTD0hlCvrShNn7nFCG^?Pi7s{=kY#by zs;BFLf`(!;wUZg^`m#NWzVsP>T$tx5xu4k4dsR?!qCK-TZ`~SPr~_^OIlBK}ZR{RFflFnh2Zjc32LR$!CH>8m z>i-F2jdV-bFyH^W z>zrL@@9#h7{Qq@vT{FYH^XBucXRUkP>s}Kp`t>sQj+E^`aGrnZiJ*4JjLu#hUy9& zg$j;GmVPkY$Mypd6JH~3(W}I&kw$OILQ7cQV8B?XpL0H7$Ie}m!BJ0 z0SZX6cF(r!D>0d0QnY$}{DA?P%`gIRG8$*|VGV|F&7szjHgt(}e6AJ9I(>w_s(_|| zRy))%kE!^CHBY}Ng|j7UjG!4C|6Jk>Zv7cPJ&(-QZ=k6olSWDWX;HQ! zW4+nASwm%tXzT%py>BHJgCyk2HMwM3eTrWqI5Zg29Q)#Y4<0^1TDTUT7Ae)ytAEt(ZcC0C3Y3Tb2RkBwsJ8_1c<*YZ6r!1xfI)9fq`;W}TKdH3+R{_tT zqW3?)pnN`g92V=osrYN&r$?A7(NUTLG2R98*!4S1w7u^V(DwFJR?XA{eIXEw3GM^G}Ewh`zE_5 z;+o|C9T2A%n7U`M)g@er16o!u@NrjtwiX}{T6|+0n=LM>qmjJG z6>_Rd`cp`Vc@e5;?!yRGd{Vb9 zq#c*Gv~lHpdzbXWvz@TuF(w;RrOAwO^8i0u=zry&ri7g^Vp}^emd1ql2%|pMw%#aM%;9XByxGz zJWdf}!WFH`@$^RuSit|VP9$hsc{8`fY8Fso;rqw;;vtdcPYf+d%G4pwh~zGZZgwt9 zMd63k`;?@sW>==7;pu9Yn`X3cl+HEvWQX{Dm*_7Gw)v<1v(60%jPTKynU_Lps4ESG zZe-7+eb_If-3x*-4=wb}bRdFlI-i> z@+Wr^ej$3Mq}<3&`fPA0twnr?2x;^mI#hj(dfH9z>1mlhe*hu%F=l{JpsIYSwoG1^ z%B})AW#`JpJ8s#QCyISb#0hf>Y)o4s8KLazR&72#%n#BOcWmE}>CYTDUhd-_xyPoPhbeZ5 z!&HCcQvRb|tNzpl_p%xVZ4K=oxmMPeNwQPUrAtd0Una?0Vp70!n;&YnQz%C8B~R=6 zk)TNX!yVI&_|oW;=goD572++nBkEV&BU(M{ks#B_>Oqjk*~(S3FL*+tOuT8E2q}|k zvnW>2os^l?5Xw72i|ZP6(RbY0Cy?^7YUj}JU8Jt6k&&k%9^`V0Ay!{TWPQMGP_&6M z10Cfdm$*aF2$>K;Rx?J;MXa8r3MsHYP;Fne3cOuC5OHhrqqHt2#2Z?w>OTaX0?^Wf zZ*Gz5*m^;ALES(sBy|ZmwM{IbyBAA9f24yV)Sg9wu9f;GR1>kjSF4{pOLftk<;tN(Gr?o!wFVe+$uqoGDxKltjO;sS|0$R6sgO<1J&M1IT z%d|lHITUv7>%Z0ao#}1k#Z|+7yMNh46#CW8EkL3Qp(!QKJmZ98ATW(-`Ta-Y(oev2 zGOqW%c;0C5Rg&+!r`GPI_D>r0$>!~?JNT)9PhTE;W|cvZWO-)LLn-}~B4LZ=^VmZfa_4!F2#{C)+o^%c;bdMJQBda@ z$@2Y;m!J+xJv02WILb;O8+9=wg1s+3{!#qAhC%JQ!d4C}sWXa$W3sED2oJ9cS9HUz z>UBu33Vh5k(>isl({_H7l6B+DL~-?(+VHm>BY6di=XS^Cv?=45KO8BAciJibnmTsU3eu;807}ORZQ=^!zw6`Vn*?{k~JuQX@{P{^B z2c9$%fc(2h1Fq_c-v@Qn7igMlHH=H$dDrDi)8G7RtHWRI;A|q8DUN| z!lCSV2D7;SpM^8PJ}X(jf%F&7#CD0ymjpjw(I=3ikV@S9f=a7z$w8_GfNidZbO+-7 z;SKN~flL`m^l_2@^u`GI3fWOSERe+ZoDb8IX#WSwPprUI+m6-f7un75BT=@ zz016K9Il(e>qV8LG2^+OBt?hADWb25z23B|rVx7=4jk}VjQ7F2DdE)2t0otx(TMb* z;eFw#2Cr|fUOndtjeYJ~Y5cOcCD`3U0MO9(^7r6Yx2 zv|-30SC2b#*wfm*c|Uy~kkDz_Lm`2*p9@}4Ow`p;^wPie4v{o(Z}9|(>+8)ZZ70*9 zih|f*c?Jg+up@DJAAH54)s1=owNE;w5j^2|09}IR7*q)j^W|(mw`?tDYIL?tEZvD> zvnRWV(7n>sqU4UboDQd%k-JO}^8in?hT%-w_DE8WQ#78;PJaP7Gnex?7Q5G}Zb ztD@$9_3iOf>8!avTj0B$R}6yBq^LVh z*Wo{EUpA(B;^NuiQU8aGZd)u}=m6|gX#V$1bVq3cNXz+{#`T|R`#@Qs;$ zXvP@-h?HwvsA?A`m?(g{aU3RuxjXh*5hbWi5I#iV#7=zs*gAQ5OAb5l0yCS)74ldT z+u_&|(SSvTei=AbOV2*&V$5W)qmpdf!BC!-!sa)(&m|*c`#D`~3 zI1BkjAFLLYs21Z>XH*0S=33s}w_r^U9Fb$;*a8xHf~xE7s!S+C&&1~FD(OW?cA z?+h|rUUE9@2{K{kBuv^~&p@VFWB|6^pM`ZWmEu7Etn|KnC&0KMVRxo{I+==O?kLFQ zoXy2`C3}CLL#!otI-||Xj(dpIL;!QOPw?q?!2_3}9#NO4NJ)~Iwn5FdkH2frIijXx zaz@p@qD^Z!f%v)4j0bYlh(IJUn1e>$NBw-Y11F`A2<7xEKv&GjskUs*i8+q40_TcG zaL9<}*otILq?IQgGrs&oCk6)FJrXMERS3?b4AHOr>ybq)iX!Z_eq|6+oUy|1n8Kjm^sM z%-8F}|6Q~^j{Ku=w{6=lhjLF&wRumwE0|1Zia?kQg-fp(^wvDg`Mff^$}sr84x6Rb;6)pyeccBPsedu}(4fCi@e z)(7hdBhd{cr5GxCHD4~OAW_0mN{f&nrIUB%+L!+RG&_hheU_<^Qq)|Q>Vn64p7X9o zk9?Ixo=oVf4V*UuTnG3^VfFivXW;Wh*3lordw=iP{YxJTrT3lx33iWM(%q9Siflf2 z{Y4BclEjl9ciaPwsPEAO6j}X9TgZ7qiRHO%rmVWr({!xw%J|Lf2R#mbKt;NH(tu*%4bL6)t)jRkKql2D&qH=ML9uVb$jL93%xNXB-!%PAuHY0Owb*#jGWf= zm1AoJLk(a#s>zduMT|=ez(0J%`vM$y5=-+mCp_v^TIb1Q9~#9-)1N)Ae6IIn)yV=7 zpm}1}Ak&6Ls!cvwOw{}d&CcKO`pb;Im&w56oHOq?+PjT+2J<61Cb*AwsgG~+E&`N# zci5u#|K}~&AAMVZ0;3y^Xea&+bc;HP^s`i9NWruC&O>j#?z1LWe)8Zz!%H ztwp4%)p>peK}i2Y8bNOL7qkMdJul^rn>@atMRYZ?e)Npzx?AXvjW*3990F-Cz@i8x zu_TecphAkf+uBU6C6$Nls3-qJ?}ebYmti^UStj@=9<*d4}mF)bW^Z*}-MEu|LbWpv>4 zIe_}D&B%OST8h2)5_I1&N(fx>sihY&3Zt+RH|vvJm~GE?{qk0CrLwwo2k3*|T?9^Lj{pxW?fVtpc z?v{nD2QMBaa9s>CmJlzeoDs2d?&tH-^b0r zaN#C*EM$RJ`|d!yi1sm3J>yJmwXS?iLP8^1(y=KSdB>m*TLj^$SB2<gWqejY~AGL410xpv5Va`KXezZO`wo6GC zv7;LqVDdUPSvEu20!KXBQqp3BF$1p&3lnW&kxp>c`?3Cf?yYy zZD_Iiczz_jaKifjG*C=!Q`Db3vpq*~Szzb*n)hpbyoJtl`-w`U6;blLl9k?jj%zSL z#vP6Ws(c1$?wKM>Hh!OdKuNAUfrTG3y=9&}zs`^N%=qb;eQInn!P3(fg^dlFOab+Q z6j>H#>zeq_nR~SA5jZ}e6}esw0=N6GmEYpnW?oY{0?puTez7#~I!w-qCnSCf0~{pC zC`LS7BeP?fH5jX;MwRn0M(G={-9_ObPlfKtvG0pc#lAJsK{xvyo#JOrey-@T*6fVUfm}wqHvu zV7tb=_nC`#9UC@+aHY#lQP-zU#{(4Go@-=@0BHJxqnOg%t5GXce2Rk-==q5C3?3Xw~$+?PxT zy8z{S%5^cnmuT-`1^d4Ny<1VX{;*pl8xeWYfeaKpSwyB9sq1#e&Skme-5A?(gy zYG6H8A4M8Mo~^o1^_esrYTMobYmF@Z2xM(&Qqh>PfBGFGm>?U~l3bFPdEx@d>uQ)1 zJz5NCy|)uULYM6R&*%FQWO*A<-G={m{fpo2`g|a6ruxippi&hS;D>q0!G6(y_(U+V z0&oXU*=;2*ae<*du2+P)U-)~#4T3=v8gTDGF?d$(4yezw%EDLstEWUz0`z=exrqWV zgd>(;VoZDdiU&wjzLYppIkG=GB&ov9({Il?=T+$tf6eN*3OL&QZ$v#c^M})wq7&1+ z{S6U%WtCtzgWA|3&2k3q-7>pqt1-?kV9Z@LLmdJV^6*5f&xGolQmH)-fc{et`6=bG z(+;8@MJ1XK>qi#9nl~VP9l!pw%j3+sBvb!gLPCsY{=xB6aXaXB9>Cadko7Qm?(OC9 zihKNjDe-~9LXE8!n$Hq-a}O3SSjtAq%|$ zo|q;`tknR-g;B6CiH_l?x8sEgoNK{>~#t#baI1tHHo59k#QroPwW&A#PyUm2A!n5R!z)bl>&r1 zA}L4)=N|C|sepbRCLhyimQ<)`E$TNAw`|)tyx4f_!3aT&?HK&}+f(jdK~V@E7k%W) z;K*P^NOW>+W&uVdsLI=(k}z8u(o>}9eR-5hRK6u|S33n&8Yym`S+a6&dY_l-SnQ!& zWg^me-)mASPxiZ!aji;lWHhLmfFmFQbp4``e`d+HY$gMg_d%ApVMJ=6F z5mj70B~@x2`wd!;#NurI@#x9q-Gplm)b@7eXC>3qf@4MgIk}Z+UU>9)`L8kjZ1>M& zxR_U_?5`ZJe>I>bxZeS^U))9sF+v58orqZPT zqn>YpZ3AQ)?oZ{Q)0(xHcietP2<(H@PHLRS2@a*X9;U7;(_EzbFmO=dHtla9Vh{sH zNJ`ohGqq;EeI>3!nEH#uDU(+FgCsxEbYtcfsNJ7$b1=akyHqk;Ub z?>GQ_&;qe2ad{djUIpAUE`D}h*`zxOH4XN4kY3u2?#>cZT9oJZz=sE?u|YK`!k1ck z_5L;1cDB3Dk&gb!h{}0!r@m9|!ih^hojnOSI@WzrKG2?0+Ge zQ*$dPupVG!?cRVd3PFbpr?+=6K@tQ2K3^({`NvnyHmw;Lz}%kBL+!#yYK;oRxhWFQ zm~5Cea!|D7}B>*Ygyox$&8faZL1o6z{)0T`v8g*@5;1qyeXpy~9V;?=a0Xrw2h!vrC%H3L! z#28+Im)h>}c_dJDDQLb(5CHd5e;j;32E-wG-!utleiuqeliVT>;L}OE0MwCwg@_-J zq)Z3;@c{RyJ$1*an$9WcMQvp-G!R|wl81rjb+IEEVwbA;ROK>$*CJif1e#~TVxP0A z#G_o3(mHtOP^OVUtQrZy4-p zxNZUA?EMzPuAS=?S4n(ketylA%eSSD`H9E1dQIaVc{`@#uN#C6ZZ9Jj#`WHLQxo zzKnTE`H{k#gU0l=h=~tA-U8n(>OKllV9_zE-N{fD)b)-?s$JVCqiO9`PNyBSx-Bd# z>$Qs5HS?YJQ0bE8(;Q;kC)O~L>K6Ew>8?Cm-yA%+GchW=?!Syqzy{rp{HniC?zyi6 zA8rEET9WecGM{~L=*w>M*(8Cm8!uG_1A|zG7Y27HZ%}xWog={lw(ENx07W2}gN&z| z#6Ma#VOd&UbT8awmJ9D}dFm1R8%T)1I>4>6=Dd1{hw2IE6G~`j6I5u4v67~lF?uS! z*%vAFB@u|LNK?mZh@Cx0S)q$P{?&`t)yCSn8e!LbYQ5Xq3pZ!472uh!vavA$9X3jscA|KOZ zbjQo3ur!sxvQ#&bMXtLq-dxE6-#jzfb6Tx21{a%T%ZZ5zKw5dCryLD|zT>bh;U6`g z2F`tm8WO~8NCMd8^7tk(wBluWLw7$x?Lx>-#lKX8hgz~v;zJ9_WmD8s`S z^h!9iJ)Y%exPMHZxgr0o>;yy! z3!5~f8M0PafFyeMlZ?nv4ASGE%=jgsEQST;yhw*?0xoO^2>7bB7-!DR1M!zgBR5s8 zltklV$BDpt=H0<`OyMF>5Phu*Xj6W1qJ)8G)X#)&_jrl_;NX41*j)im`G(jd^A24P zNCQ68?)01^YujU){XNF{A1=Ka)6<4?(D^0h0p73lkdi?cj34T2)0F^zYsOk*@{Eq; z>GLrrul`6kJMJl%Wz*b6W+?p0GVb^Wj9}YHvEh{|SBrHba*j7^T^loyFd=J$TazU} zn|Vy$)D)jW@K2skJB&aVWW)w{n;f31?lx2qZd zBlFC7=EfMPnl>gN--}h>9^n4$p7<$nR^BBG2{sE!KQkEM=&17(l#*RgWLpwHIyMnW z85`z~w_~j=+@{z^PhvCDth{=c0#}VDUC95Ke_x21bi$+1jMS@(7qqzX2r<50UnYv0 zuEYA+Xo-xOWPYgF*QuE*+C->;QZzfNBcJp~Q9m!FZ%OX;w2{#Sc=^+9)d<^8^oPH* z6BOS5;>B#cw-%&R_zS7uqGb1p$WX<4%zYGuYqvYC8y+ZFiixMSKmz>0;GrW z0j)@_1l?T?FMwNzFgfZ0#D6d^8b{|VDneA=8!m8kzRt+2;-#!=e5juu!Sp%e4Kw2m z-=0!Q+SULUa?|;!aV1sUc16=~(Lac$r z9VRdpcOJdO=&GInSOTC#9_@!O19=Xqh=K=#W(w5sPSiif%+Y-g zPP)Cr8Zd${{x(RbZRWE6J9F!H70(2R6%IuF-)5mIc*|KXhmhSUn?b}#THL!pOikiG zw8CE`S{CF*Juizk#$rgc8!l z1>mZcyz<~A8N}xv2&1lJfYc0WrsYk1RAjR`9#=9FV?X0ym)EVSGI^2$lqUn$+uktr zIf~#J&cSjj!q(^nwh+L(!+RhUP%dJaBEmG2XF&s)0bXaDMzQ0GMsN{YZLTvdO8hL* zyMvEuOqCn%01ayc00{2u3#6TnPNrJ!jesm?y##?6iLepP+Pnlj`iFp+!LoyVxOzgE zUKV9(?|$a(Tbiq$yVuz7Cz{tMTIE$Q0U{qbI3r(^4DZxze=PtBEI-;LZg*UQQ6;<{|C zo@8=*iBV8h>F%f(zY=R1 zVALd0FAc2M&qWeAFkaM}$cuD7$3 zM<`jhl4^I~%_VSG7l4c4c|D=Z2n5$b2$P8ZSFV8?rr6Jr$3ZBf*r2<}b?p*;VSnyTz*h6IX9#QOyc5uS@Dw=V}61uggu;SIR>*!iX zdGV}n7jm()HM!HRoz2W@D?2BhW?2e8Xv@Tx~9JVgH2{wDvlzw99sgg@{r^j3s6 zjl(o}yMN(l3m73o(+^RRfZt~#umR6j3wQ*m-CoWARZ*SM3cm|S;DO;K;!7pq zk$9SGa_|i?M2Y6?5`4|}8>j(8419Az11AGoSz|2JMBkhOxBpik1p2W)8AQMcAV&|r zlH3Lk^Q%@gMB+~J&Z|s#w&U6u{HY=r8V8_uOkBnzl}!V0&h_cZ(HHlUBHL{ zb``sG=^?Rw(E8H^&~>J~Xx*L!|Fj0`U1^+w^zL>yCmfds9xY#$4J@-(z%2a@bmy`S z#Fc+O7-Dp)b-P=l{SbWJn>#lOTr_YdXsrkZp?&ZOaDgEtz?ss_lf&TGz+4OhZd13- zuLA=2@Vhf0LW}Raas~+R11HlPei`;_$5?;btni<11}O$M!vQt}h5*oqL0IApFo>%# zgxMk6pN@Hhartj;lvpUS*%m+o>__Jh`vD-IrvvbgdBDlbG`SH5O2QH2QxZEgK+&oO zIFx!g8jb+QkK3=74+-Gy8HD{`jpdbw6-$lWWwDc^%;7IDs+n z0c>Yya{gsSOv-iQ;sS#M3+6heRsKHX*QuOtVP)BBujA$LOh?rX5f?|#Jf~sis=;odh zW0);_o__Wlh{7z7FqBM>G8l8?fiHQ496$XoAl{=`KwOsM_od+r-=fjk+HYq^@o?+3NU7z^G^D6cs!pIf$m_T3pyne(*M38+bG_H-gqEIvxOpOd}# zcs{wY`V*2}r1s?&vm{$9>2!)PbrMZ_F(ZVL^;Gh}zsRESWr&_{T(Lm)mYc0tqpjna zbMa%`f=5wBBoPJJL~%{^+7?f}6=j=^=jYixK4$Pud)#CTyP+`ttURd%h*?R zp58gbz708B%_1mhwWd)1xH)ASW>VGJ-816RoBV}STp`(F;MrSS@zXLdP$$p1W|}SR zseFp^n)+I+4@Z%Q;q#UhQC2xECGMnWCY>`~PGkNQdsoVio+hUA^IaAX7Z$Q0EZtK& zq#$s_p5g`+C{M9}s-zW{w&3PlJH+r9H5<*Q6v|xqOTh5=c+9`kQ~Cpq;2F66S>XAd ze=Fi60B}?J5q}cxsB%JD8_n>2mkslOyWYY=W->q>at6Q&qezjE*yW0>8HqUZD!I8uamAH3@%{g!DqL!*Tt0_BK3 zZ&-}ZmE95ZzX~9|%0jR9^-lD9hH&EI8FN_Lb9rv@3*sC+?a6}gfKCGsB)BE z{?%NhtQ@NG3dm19{3@-U$fJ6xa?k(AEL7~Dvrtuh!V1qE52+PRKhgWl@|8pq^>%z3 z34AUfxah+`CW<|-1thYb3gna$Egdv+3=EhvV1BQcW!yMADD_^t3b6V*SOGj(QGho# zSHk#q}-xt9!biOh?6%j`q@~r_H>Ai)FRw^qzMH@;be0m zRaIcYsoc}u&&OusHRG*eXYDtpky~vZedjy*xh0toj^oVnWm6CViw9_a$B`s7K$9{@ zvx?^$3wAs&ii&z%MS1jM1XdP0oc8UElp9!wT)Ye7Xr=XYL0>Z;a=`hm&8SN+4L={z zRi@}>YSu*Fn)!(jO?$nZlja~^GE6_23!CjNUJOw?z$rng9}sMak*{lpZjiQxqEZK{SpH+0C-P{RW+Blq!5luxig z@P2O(aPcA|Y?Z$fy?STQZ$Mb%t#>zR?uXlc~Ne$kW|3Vq6PzH2Ij>mIwcP+_0E%u6At zli-GgU%GzyhEe$iAYdoWHbhFKIBr>AJDDGgEE??)ye!Y96o;xPnn6xx2~_xD!ol9I z^tOqY+~QT2sf|9489(zYaRjqd6m^deN*RiKJZ(3lD;W|q@d+)gvv5l-ejFHBrMKi& zEU-6sm3YgEl*&=q!xlFg!^S7&MV3^tbXV$2*W5JB6IJS?P&Cy)keHR}vXSjp&T|1MEw(Ep7LYPX04xOY8u0_)lh(ju2Ji>8LnM!<~GlC$ky@>3Mh=6 z8kUy}mp{o%=h@|ZllXay0PAR^aOq(7nx5l2&FSEipZ;^n+v2HS(RM#~EtBmuHdE6! z;WL{6bjXZ9zqZ-${;tn;Y=F6Z&{ zM>F+gJww;#LGhB8UqHDT01V~#5;=B6352-~U{oIKH6R6~*|$d$r5xEC@(^Jy5K1`_ z2HU{W+-f3tu;KBAYX#H3hmd_p>~|C?^U2mxHf4OX(gNMhVX6$lQ-N1_2!lAa(mH zcwqbs!PJc8C3HaFaq))$II&$Ezk86k9mNbS~F1Z2l6OawDzPD@V%lL)h5S~XI$ zc{EI;mm?$Tr3)PLLO1e!ZTED4li`nnH2g75i0`idbJDlu#6(7{JJa7O`r+&OcW03>kY6rM3{L+bnm3_jMSm47_O zI=AUN%_)N?pOB>-k&ixfx;~|L2$p-)ludgoN#FPr*ZVn1Who*Xt)-N{&&QUqTF;42B&Ifn$wT9pv^DvBmb$uhC{)kygSAaz*_%SiLGDZ51v0Q1kVN zDd{Ybc_7VKxY)NTE5EReJuH(u2?CtXF9H+PKJ4kwrPsag!gw%n%WKf5C_)1H;NrC} z39NqRC%m6VDM#&=Y@PkRuP|Eo&jNjgw)@BO#gg zf)T%*9l_=4)U`Q`Iz(xTlj8fK?Xxu7!z$0~>PlHS3_+@A4k}q*{;{a+^2rm(&M@mn zsiKW?C%jdUw?I;{*hm!8Nl0hJkJ1g~omg9Rm11f#fE3WoTh>E&I}-<;RF_9Yl_};$ zaq7NkWQCE@;h(ghbiS)VT3%Sl&r?K|ad2hL!Ho-j`B+YoaTUa)$XuU=^`A4{68v!0 zf^@@f?`hD%oo`vp?DFz^nW$li>SlU%t%`qTl`a#Xi___R|ejCrd9dpS>{G zQOJi#o+=dPIwap~fJq&d3=tnn-m zYqkRxSseq|B@z#JG)Hz2DMb(i8R`Sq`{Qzp>A2HTU;lj1*%tm6I&+(@fhD55wH2hj ztfaUPc_G~~k(G-J)b%?R zFT{POoW=koKB`3IP$Af@cM>g?<~|YIV+TU}j@|1f1LD$KHI1UQ#()U*ZqE?4-Shs9 z6;A%M75+o~fwFCa3Mit<;fU-w@HH|J=kj;h#VYh@#nQE;XV3?CbAJqMwMz0lE1ydr zo)Lru(zTvU!>seE^f|p%3wP(I+80P2zZDFa)pcz;M)e|;391%9en}I(X6XA3q$w#P zfj7G(^`noep}DTvdh}qaX|h^&Fv;86=7FKKw496&nA4&VPb0F{cj+2YK&xr?3Cq4D}GY_Bs zz_j*)nBvAc>pxx|-YMbo>7!o=cAR>bGZurl@_|@a;7q1eI`PzK*2K2`^gsna*D3g| zXrrM`e}aZr99PQ9P^~<~mQl}%G1VUAc5+kkTBcaP9IjsGx#TqNt&Q%(P8Y7h^_`g_ zW0?sykwRqtk`Skm>9md1?U})w&xGUAN%*;IcNCx06p};Ol)=`NFmHTJ3(?xsJ!;1e z8vX!p^VAayUHwCt28x2`fl> z4uQT*f9s$i-6XBsZd9MB6^JtC#oECjQNqRSi&1(0nCO850Bsoi8fsCrCw<#}s@1YZ zp&hC4Ch2cC7MM`=5>2eBLi8o6R>0IV2XOoQEzRZhXLDC#k^3;)g;$a^F{L}aWVg1K{G_oqN#&tDZfy}| zunnU-bK>4XBb8oE84s5a5mIUC^^9_h;dzx}4rE`YvJxi$Qi;DhJ6Qz%E*l*s>d2|1 z6r?jQ>S+CCZuioyhjC2SxzJ#RwmlB-AhNCfW^+K<+VJeUCz^lPD70m$F4lYlQs}G@Ff1f`+|{j;RDqA$pYvyjx6f$EKreVP17#A zxD({WZeN1x0Dg{Cv@ZyscR7$~U2K;N1tNT2g#5Pl&~zbC@Gk4oq!*)(1M_%$wX1x$ zQA;4wO6w53Vf-%qnl4K=Slspa`@OiywhI4~@P1Hmc_NzpV9V!S7{qn)qR4#mJ!z#l zfCsmP1LgVJVqgG%M3rRNc?^JH5|>(X?UN}AYwV}TC^5d2gp=FR77LN7!3~SSlErmT ze(=xz#P{@`F~Tr8cbdv6v_>s(@{jq(UR zO?4Mpq)=1!nI^pycV6=HHz*Pdrlut0OEl|IzL^#yol^GHmr;(&Rj6`n+QoD_Y2_*C z-BxX;0#%&SvLO0vu!0N&w%#8*;3laj- zh4((eH&G$xX8Muvk3IcdpaE43)rv=@rTNv!C!fn+xV#AVayYULE<96qa_qW#RJUD} zg>}BfF(Mb_$hSjR1(R0lLbWBb(@Qje$ghJI!MN(C$eaRd{yPEq0Q2iRgq)EfqTPGt zR*N0v_6K&|U#j8$0l(*Wf=9m-mqGzB+Ibb4YuVf$!B*IBpfUGRj1J^2D|HrP!fg?6 z*NkTIrU^1e5><4t7u1>toMthB>Uk`Q7q*t|xbXNsHTL!a*Z^cwT@g1lo7^WN5t7kn zEl348YEmhigWqIgQr*546H$Lg5nO_}`D_K!xFvD4*uuDSqKLJvj0=t*#ipH1dh{4b zO7Tx9fe3RPkJ27pY~0&|wi+!+KgdPOiMz&ZQ$-959ry5cm@4-uL`gl$T;G1XE&9Oq zaH4>y8WeW2hUUe#-MA6kEx6$yP;DdfEoMoSag$gk=<23Nte)l*IodpCS;q5~Y617t zZ%jULsdX5iK1Y!EJ=j<}6?P`N^i^nhFg;Vnx?o*4#weSq-j>2eR;s7J0H>#raa-)( zrosrS=*~1om}ghN?%;DXtj5FRO$a5SLh2I1be=tOkA9*8SumWT&S>&~3ouOW=NDh# zh-w0;RWV3BFA7`o6~Iol0b0`C+Xnt3cmjMTj$UO1^wCkv! zCif_CBM&lRjI+Sd+^%euXF?9@}{i8^~fv|bMgU|7St&3L>iU6CL$QsC`>`(!D zg;%ZcI7uq!&?dZ`YtCUrC+v=MzNz*3RnU#YZ5ZcXNUPIim_>j|IxSJ47yzJx zs2BZ4QAZaC95b2bMb|~Bk_30t^Q@@~k$gyRaIJY6fx$-YF^v&r0lGTExZr2ap`oL>d>10&9qq0@Pv=&-`6=)W zTPX-3*#Dk!c+&(%Rp%U7jj={w_oYpK{e`@wc_AhYkRH-9>{53T4_)|hq3nWFej5gC^T3`0sJnM9U_0PImq1#$pXaXdcatwhDFNg#b~*j0naR@ePDqegVhCk z+Ow;IN_w?pGmGP{^0QZiEdB`*(!?g|Zkn5W=IgY{yp+lKgbx|sE=T~^3Pi98NpEH? zi8+XQb|eruh`dg@PE&qEsa1K3L-*rUBRct~`)Gi1BY5tvWiG!zxEG>mAj$IMx%Q%hA6kOG$gvaZ&OzznmBMnJn%MU{ks<8A922EB9GpV zc2RIi<7<0--#;I5m+Ze`fXFHkKdF1jfo&L15E4n2p zp4^-0elqs^pX1K^na36j1xi8;@ZuvWFEOXB+K%cBueDF1n>W6mn=bNdSdZ1xEZ)?c zKn;C&K4>}C*s^(gRh?IXv-&ugO|8z9tXikSV+f(XD4Fr#CN*I|SJ}zgdwd>Yh#|7I zSzX(F>uY=m|M;9l)1kk~ZuUFNc%rAM&gHw8A0Yq@61@;dDmfwX^{7I$TIQgE z?_E6q-Er|hpv?5=k^aYp2jB`+gD)QduGZ+2EP^P$#!sOd%3(++h!{GPR2x#Jx8hl8 z61A+4Z!)GUcaE=?N5BaePT1O;fgV2Vj>CN6IH zqEq;0#3O}7Jzu+51=+}(zJ6#K%H+k#Km+lX; zeV2P(Kim56_w5fnt&S{Iov@`>LG`27=JdYkC#rtM6K>l5ky>ButNMJ^{nP%j_CmSA z(H8HQ@A?w;{(bi4(7au&mn9}9^`4*hiqlbJLYabSz(NoELyne9_2M_p`da>1Fz{Kt pwEsoZUz@+IKOm3Tdy}!+sBar&RD4iYYqae<(5Gq!`+@)eO#oMP1(E;& literal 0 HcmV?d00001 diff --git a/install_hcicollector.sh b/install_hcicollector.sh new file mode 100755 index 0000000..fb1df74 --- /dev/null +++ b/install_hcicollector.sh @@ -0,0 +1,328 @@ +#!/bin/bash +############################################################################# +# This script has been soft-deprecated in v0.7 # +# While it works, it is recommended to: # +# - Review and, if necessary, manually edit configuration files # +# - Use OS f/w rules to only allow incoming TCP/80 (or TCP/443) and TCP/22 # +############################################################################# + +# Check for proper permissions (https://stackoverflow.com/a/21622456) +if (( $EUID != 0 )); then + echo "Please execute this script as root or use sudo" + exit 128 +fi + +####Install HCI Collector#### + +for i in {16..21} {21..16} {16..21} {21..16} {16..21} {21..16} ; do echo -en "\e[38;5;${i}m#\e[0m" ; done ; echo + +# Set some bash colors +Red='\033[0;31m' # Red +Green='\033[0;32m' # Green +Yellow='\033[0;33m' # Yellow +Blue='\033[0;34m' # Blue +Purple='\033[0;35m' # Purple +Cyan='\033[0;36m' # Cyan +White='\033[0;37m' # White + +# Best don't customize this parameter +GRAPHITEVOL="graphite" + +# Read in variables + +echo "Info needed by this install script:" +echo "1) SolidFire MVIP and credentials" +echo "2) VMware vCenter IP and credentials" +echo "3) One of the IPs of this VM where Grafana Web UI will be accessed" +echo "" +echo "You can use CTRL+C to stop this script and run it again when ready" +echo "" +echo "NOTE: HCICollector will not verify TLS certificates of SolidFire, vCenter and ESXi" +echo "" + +echo -e ${Red} "Enter the SolidFire management virtual IP (MVIP):" +read SFMVIP +echo -e ${Red} "Enter the SolidFire username (e.g. 'monitor'):" +read SFUSER +echo -e ${Red} "Enter the password for:" $SFUSER +read -s SFPASSWORD +# We could get this via the API but not everyone has curl or Python installed so we ask +echo -e ${Red} "Enter the Solidfire cluster name (NetApp HCI storage cluster name): " +echo -e ${Red} "If unsure, visit https://${SFMVIP} to take a look (top right corner in Web UI)" +read SFCLUSTER +echo -e ${Yellow} "Enter the initial password to use for the Grafana admin account:" +read -s GPASSWORD +# echo -e ${Yellow} "Do you want to provision sample dashboards ("N" = import or create by yourself):" +# read -e -i 'Y' GPPROVISION || GPPROVISION=Y +echo -e ${Green} "Enter the vCenter DNS hostname or IP (e.g. 'vcsa' or '10.10.10.10'):" +read VCENTERHOSTNAME +# Pre-populate with common username +echo -e ${Green} "Enter the vCenter username (e.g. administrator@vsphere.local):" +read -e -i 'administrator@vsphere.local' VCENTERUSER || VCENTERUSER=administrator@vsphere.local +echo -e ${Green} "Enter the vCenter password:" +read -s VCENTERPASSWORD +echo -e ${Green} "Enter the vCenter DNS domain (e.g. 'vi.company.com' or 'local' if none)" +read VCENTERDOMAIN +echo -e ${Green} "The ESXi hostnames resolve in DNS: yes or no? (e.g. 'no' for IP-based hosts)" +read VCENTERHASDNS +echo -e ${White} "Enter the IP address of this Docker VM (for access to Grafana Web UI):" +read DOCKERIP +echo "" +echo "NOTE: Wrapper script wrapper.sh applies default sfcollector timeouts (10s to connect, 20s to receive API response)" +echo " If you want to change these timeouts edit wrapper.sh (after this script completes, but before Docker Compose build)" +echo "" +echo "To stop now without having to wipe this folder, press CTRL+C within 5s" +sleep 5 +echo -e ${White} "Beginning install..." + +# Docker compose configuration +echo "Creating the docker-compose.yml file" +cat << EOF > ./docker-compose.yml +version: "2" +services: + graphite: + build: ./graphite + container_name: graphite-v0.7 + restart: always + ports: + - "8080:80" + - "8125:8125/udp" + - "8126:8126" + - "2003:2003" + - "2004:2004" + volumes: + - ${GRAPHITEVOL}:/opt/graphite/storage/whisper + networks: + - net_hcicollector + environment: + GRAPHITE_LOG_ROTATION: 1 + + grafana: + build: ./grafana + container_name: grafana-v0.7 + volumes: + - grafana:/var/lib/grafana + - ./grafana/provisioning/:/etc/grafana/provisioning/ + restart: always + ports: + - "80:3000" + networks: + - net_hcicollector + environment: + #Set password for Grafana web interface + GF_SECURITY_ADMIN_PASSWORD: ${GPASSWORD} + #Optional SMTP configuration for alert queries + # GF_SMTP_ENABLED: true + # GF_SMTP_HOST: smtp.gmail.com:465 + # GF_SMTP_USER: + # GF_SMTP_PASSWORD: + # GF_SMTP_SKIP_VERIFY: true + GF_RENDERING_SERVER_URL: http://renderer:8081/render + GF_RENDERING_CALLBACK_URL: http://grafana:3000/ + GF_LOG_FILTERS: rendering:debug + + renderer: + image: grafana/grafana-image-renderer:latest + container_name: renderer-v0.7 + ports: + - 8081 + environment: + ENABLE_METRICS: 'true' + # GF_RENDERER_PLUGIN_GRPC_PORT: 50059 + GF_RENDERER_PLUGIN_IGNORE_HTTPS_ERRORS: 'true' + # GF_RENDERER_PLUGIN_VERBOSE_LOGGING: 'false' + # GF_RENDERER_PLUGIN_TZ: Europe/London + + sfcollector: + build: ./sfcollector + container_name: sfcollector-v0.7 + restart: always + networks: + - net_hcicollector + + vmwcollector: + build: ./vmwcollector + container_name: vmwcollector-v0.7 + restart: always + networks: + - net_hcicollector + depends_on: + - graphite + +networks: + net_hcicollector: + driver: bridge + +volumes: + ${GRAPHITEVOL}: + external: false + grafana: + external: false +EOF +chmod 740 docker-compose.yml + +# Wrapper script for the SolidFire collector +echo "Creating the SolidFire collector wrapper.sh script" +cat << EOF > ./sfcollector/wrapper.sh +#!/usr/bin/env sh +while true +do +/usr/bin/env python3 /solidfire_graphite_collector.py -s $SFMVIP -u $SFUSER -p "$SFPASSWORD" -g "graphite" -o 10 -a 20 & +sleep 60 +done +EOF +chmod 740 ./sfcollector/wrapper.sh + +# Create the storage-schemas.conf file for Graphite +echo "Creating the storage-schemas.conf file" +cat << EOF > ./graphite/storage-schemas.conf +[stats] +pattern = ^stats\.*$ +retentions = 5s:1d,1m:7d + +[netapp] +pattern = ^netapp\.* +retentions = 1m:7d,5m:28d,10m:1y + +[vsphere] +pattern = ^vsphere\.* +retentions = 1m:7d,5m:28d,10m:1y + +[carbon] +pattern = ^carbon\.*$ +retentions = 5s:1d,1m:7d + +[statsd_internal_counts] +pattern = ^stats_counts\.statsd.*$ +retentions = 5s:1d,1m:7d + +[statsd_internal] +pattern = ^statsd\..*$ +retentions = 5s:1d,1m:7d + +[statsd] +pattern = ^stats_counts\..*$ +retentions = 5s:1d,1m:28d,1h:2y + +[statsd_gauges_internal] +pattern = ^stats\.gauges\.statsd\..*$ +retentions = 5s:1d,1m:7d + +[statsd_gauges] +pattern = ^stats\.gauges\..*$ +retentions = 5s:1d,1m:28d,1h:2y + +[catchall] +pattern = ^.* +retentions = 1m:5d,10m:28d +EOF + +# Create the vsphere-graphite.json file for the vSphere-Graphite collector +echo "Creating the vsphere-graphite.json file" +if [ $VCENTERHASDNS == 'no' ] +then + VCENTERIPBASED='true' +else + VCENTERIPBASED='false' +fi + +cat << EOF > ./vmwcollector/vsphere-graphite.json +{ + "Domain": ".$VCENTERDOMAIN", + "Interval": 60, + "FlushSize": 100, + "ReplacePoint": $VCENTERIPBASED, + "VCenters": [ + { "Username": "$VCENTERUSER", "Password": "$VCENTERPASSWORD", "Hostname": "$VCENTERHOSTNAME" } + ], + "Backend": { + "Type": "graphite", + "Hostname": "graphite", + "Port": 2003 + }, + "Metrics": [ + { + "ObjectType": [ "VirtualMachine", "HostSystem" ], + "Definition": [ + { "Metric": "cpu.usage.average", "Instances": "" }, + { "Metric": "cpu.usage.maximum", "Instances": "" }, + { "Metric": "cpu.usagemhz.average", "Instances": "" }, + { "Metric": "cpu.usagemhz.maximum", "Instances": "" }, + { "Metric": "cpu.totalCapacity.average", "Instances": "" }, + { "Metric": "cpu.ready.summation", "Instances": "" }, + { "Metric": "mem.usage.average", "Instances": "" }, + { "Metric": "mem.usage.maximum", "Instances": "" }, + { "Metric": "mem.consumed.average", "Instances": "" }, + { "Metric": "mem.consumed.maximum", "Instances": "" }, + { "Metric": "mem.active.average", "Instances": "" }, + { "Metric": "mem.active.maximum", "Instances": "" }, + { "Metric": "mem.vmmemctl.average", "Instances": "" }, + { "Metric": "mem.vmmemctl.maximum", "Instances": "" }, + { "Metric": "disk.commandsAveraged.average", "Instances": "*" }, + { "Metric": "mem.totalCapacity.average", "Instances": "" } + ] + }, + { + "ObjectType": [ "VirtualMachine" ], + "Definition": [ + { "Metric": "virtualDisk.totalWriteLatency.average", "Instances": "*" }, + { "Metric": "virtualDisk.totalReadLatency.average", "Instances": "*" }, + { "Metric": "virtualDisk.numberReadAveraged.average", "Instances": "*" }, + { "Metric": "virtualDisk.numberWriteAveraged.average", "Instances": "*" }, + { "Metric": "cpu.ready.summation", "Instance": ""} + ] + }, + { + "ObjectType": [ "HostSystem" ], + "Definition": [ + { "Metric": "disk.maxTotalLatency.latest", "Instances": "" }, + { "Metric": "disk.numberReadAveraged.average", "Instances": "*" }, + { "Metric": "disk.numberWriteAveraged.average", "Instances": "*" }, + { "Metric": "disk.deviceLatency.average", "Instances": "*" }, + { "Metric": "disk.deviceReadLatency.average", "Instances": "*" }, + { "Metric": "disk.deviceWriteLatency.average", "Instances": "*" }, + { "Metric": "disk.kernelLatency.average", "Instances": "*" }, + { "Metric": "disk.queueLatency.average", "Instances": "*" }, + { "Metric": "datastore.datastoreIops.average", "Instances": "*" }, + { "Metric": "datastore.datastoreMaxQueueDepth.latest", "Instances": "*" }, + { "Metric": "datastore.datastoreReadBytes.latest", "Instances": "*" }, + { "Metric": "datastore.datastoreReadIops.latest", "Instances": "*" }, + { "Metric": "datastore.datastoreWriteBytes.latest", "Instances": "*" }, + { "Metric": "datastore.datastoreWriteIops.latest", "Instances": "*" }, + { "Metric": "datastore.numberReadAveraged.average", "Instances": "*" }, + { "Metric": "datastore.numberWriteAveraged.average", "Instances": "*" }, + { "Metric": "datastore.read.average", "Instances": "*" }, + { "Metric": "datastore.totalReadLatency.average", "Instances": "*" }, + { "Metric": "datastore.totalWriteLatency.average", "Instances": "*" }, + { "Metric": "datastore.write.average", "Instances": "*" }, + { "Metric": "mem.state.latest", "Instances": "" }, + { "Metric": "cpu.ready.summation", "Instance": ""}, + { "Metric": "cpu.usagemhz.average", "Instance": ""}, + { "Metric": "cpu.usage.average", "Instance": ""} + ] + } + ] +} +EOF +# This below won't work +# sudo chmod 740 ./vmwcollector/vsphere-graphite.json + +# Create the datasource.yml file for the dashboards +# If you customized GRAPHITEVOL (which you shouldn't have), also modify `name` in: +# ./grafana/provisioning/datasources/dashboards/datasource.yml +# Change GraphiteDB IP in Grafana +sed -i "s#url: http://DOCKERIP:8080#url: http://${DOCKERIP}:8080#g" ./grafana/provisioning/datasources/datasource.yml + +# Modify any hard-coded SolidFire MVIP (SFMVIP) and cluster name in sample dashboards +sed -i "s#192\.168\.1\.30#$SFMVIP#g" grafana/dashboards/*.json +sed -i "s#PROD#$SFCLUSTER#g" grafana/dashboards/*.json +# Work around Grafana issue # 10786 +sed -i "s#\${DS_GRAPHITE}#graphite#g" grafana/dashboards/*.json +sed -i 's#\"DS_GRAPHITE\"#"graphite"#g' grafana/dashboards/*.json + +echo "Script complete. Use 'sudo docker-compose up' to start the containers the first time" +echo "" +echo "Before you run docker-compose, you may want to consider adding a few firewall rules to allow remote access only to Grafana Web UI." +echo "-----" +echo "NOTE: It may take up to 15 minutes for all metrics to appear in Grafana dashboards (assuming everything is working)" +sleep 2 diff --git a/netapp-hci-compute/hci-compute-ipmi-collectd.md b/netapp-hci-compute/hci-compute-ipmi-collectd.md new file mode 100644 index 0000000..91177dc --- /dev/null +++ b/netapp-hci-compute/hci-compute-ipmi-collectd.md @@ -0,0 +1,106 @@ +# Gathering NetApp H-Series BMC Metrics with collectd + +As tested with: + +- Ubuntu 20.04 +- collectd 5.9.0 (5.9.2.g-1ubuntu5) + +Save your collectd config file somewherewhere (e.g. /etc/collectd.conf), make sure collectd service is stopped, and then start it with: +``` +sudo /usr/sbin/collectd -C /etc/collectd.conf -f +``` + +Minutes later the metrics should appear in the right dashboard (H400C or H615C). If not, troubleshoot IPMI access, IPMI login, firewall access to Graphite (HCICollector port 2003), Graphite, Grafana.... + +If this minimalistic approach works, you can include the plugin-related info in main collectd.conf, start collectd without `-f` and after that works fine, enable collectd service and run it in background. + +We should probably also monitor the monitor, that is enable gathering of collectd metrics and watch it from Graphana to make sure that service is up and IPMI data is being fetched and sent in. + + +## References and Tips + +- On Debian and Ubuntu, it is probably easiest to install collectd with apt, avoid installing recommended packages, and choose None when asked about Apache or Lighttpd integration +- Getting started with collectd: https://collectd.org/wiki/index.php/First_steps + +## Minimal /etc/collectd.conf + +- I haven't tried to monitor more than one system of the same platform (H400 or H615C) at the same time using from single collectd instance using different `` [blocks](https://collectd.org/documentation/manpages/collectd.conf.5.shtml#plugin_ipmi); if that cannot be done effectively, consider using a separate collectd container for each IPMI/BMC host you have +- H400 Series chasis are shared among several nodes; if you have multiple systems that share the same chassis, there is no reason to have a panel for chassis or PSU for each of those nodes. Therefore, if you use Instance blocks in the IPMI plugin, you could use this approach: + - Instance Ch1 - shared IPMI metrics (e.g. chassis PSU1, PSU2) + - Instance Ch2 - shared metrics + - Instance Ch1Cn1 - compute node-level metrics (e.g. system Temperature sensors for Compute Node in Chassis 1, Slot 1) + - Instance Ch2Cn1 - compute node-level metrics (Compute Node from Chassis 2, Slot 1 ('A')) + - [Optional] Instance Ch1Sn2 - storage node metrics from Chassis 1, Slot 2 ('B') + - [Optional] Instance Ch2Sn2 - storage node metrics from Chassis 2, Slot 2 ('B') + - If chassis-level and system-level metrics are gathered separately, we have to edit paths to appropriate panels in sample dashboards + +``` +# Set your FQDN/IP/hostname here +Hostname "h410c21" +# Hostname "h615ct4" +# Note that the IPMI plugin uses `Instance` blocks to identify IPMI endpoints (see above) +# Above "global" hostname is used only in the IPMI plugin doesn't have it set + +# We need at least these two plugins + +LoadPlugin ipmi +LoadPlugin write_graphite + +# Plugin config + + + # Use blocks for multiple IPMI endpoints + # + # This is the IPMI (BMC) IP of H410 or H615C IPMI interface (BMC) + Address "10.1.1.1" + # Create a USER-type IPMI account for this - do not use admin/root! + Username "monitor" + Password "m0n1tor" + Host "ch1cn2" + #AuthType "md5" + # In order to call out sensors, you must know their exact names + # If you don't call out any, a "basic" set of metrics will be captured + # Best to not call out any, make sure it works first, then get fancy later + # Sensor "Fan_SYS0_0" + # Sensor "Temp_GPU1" + # IgnoreSelected false + NotifySensorAdd false + NotifySensorRemove true + NotifySensorNotPresent false + NotifyIPMIConnectionState true + SELEnabled false + # SELSensor "another_one" + # SELIgnoreSelected false + SELClearEvent false + + +# If you want to send metrics elsewhere (syslogd, etc.), use a different plugin +# This one sends metrics to Graphite using HCICollector configuration + + + + # Your HCICollector (or Graphite) IP + Host "10.10.10.10" + # HCICollector's firewall rules must allow access to port 2003 to collectd host/IP + # Other clients should not be allowed to access Graphite (see the README and FAQs.) + Port "2003" + Protocol "tcp" + ReconnectInterval 30 + LogSendErrors true + # Sample dashbards are based on these paths + # NOTE: + # Enable only one per instance of collectd + # H300E, H500E, H700E can all use H400 path + # Prefix "netapp.hci.compute.h400." + # Prefix "netapp.hci.compute.h615." + StoreRates true + AlwaysAppendDS false + EscapeCharacter "_" + SeparateInstances false + PreserveSeparator false + DropDuplicateFields false + ReverseHost false + + + +``` diff --git a/sfcollector/Dockerfile b/sfcollector/Dockerfile new file mode 100644 index 0000000..9514906 --- /dev/null +++ b/sfcollector/Dockerfile @@ -0,0 +1,18 @@ +# +# Apache 2.0 License +# @scaleoutSean +# +# Based on SolidFire Collector script from HCI Collector v0.7.1: +# https://github.com/scaleoutsean/hcicollector/tree/v0.7/sfcollector +# Can use non-vSphere dashboards from the same release: +# https://github.com/scaleoutsean/hcicollector/tree/v0.7/grafana/dashboards +# Run this container with -h to get help for arguments, or see the HCI Collector v0.7 documentation + +FROM python:3.9.19-slim-bullseye +LABEL maintainer="@scaleoutSean" +RUN python -m pip install --no-cache-dir --upgrade pip +RUN pip install --no-cache-dir --upgrade solidfire-sdk-python==12.3.0.203 requests graphyte==1.7.1 +ENV PATH=/root/.local:$PATH +COPY solidfire_graphite_collector.py /solidfire_graphite_collector.py +RUN chmod +x /solidfire_graphite_collector.py +ENTRYPOINT [ "python" , "/solidfire_graphite_collector.py" ] diff --git a/sfcollector/README.md b/sfcollector/README.md new file mode 100644 index 0000000..42e6567 --- /dev/null +++ b/sfcollector/README.md @@ -0,0 +1,23 @@ +# SolidFire Collector on Kubernetes + +See https://scaleoutsean.github.io/2022/05/02/solidfire-collector-in-kubernetes.html for a simple how-to. + +- SFC container v0.7.1+ from https://hub.docker.com/repository/docker/scaleoutsean/sfc can work with Dashboards from HCI Collector v0.7+ branch +- SFC v0.7.1+ from Docker Hub only collects SolidFire metrics (not vSphere) +- SFC v0.7.1+ can run in regular Docker environments and send data to Kubernetes-based Graphite, so users who have own (or don't need it) vSphere monitoring can use it instead of the more complicated procedure for HCI Collector + +The YAML file is an example Kubenetes Deployment with Graphite and SolidFire. If you run SolidFire in another Deploymment, send data to Graphite container's IPv4 address or resolvable hostname. + +## Kubernetes + +Use deployment YAML. + +## Docker + +```sh +docker run -it --name ${CONTAINER_NAME} \ + docker.io/scaleoutsean/sfc:latest \ + -s ${SF_MVIP} \ + -u ${SF_RO_ADMIN} -p ${SF_RO_ADMIN_PASS} \ + -g ${GRAPHITE_HOST} +``` diff --git a/sfcollector/graphite-sfc.yml b/sfcollector/graphite-sfc.yml new file mode 100644 index 0000000..2c238d8 --- /dev/null +++ b/sfcollector/graphite-sfc.yml @@ -0,0 +1,66 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + labels: + app: graphite + name: graphite +spec: + replicas: 1 + selector: + matchLabels: + app: graphite + template: + metadata: + labels: + app: graphite + spec: + containers: + - image: graphiteapp/graphite-statsd + name: graphite + ports: + - containerPort: 2003 + name: carbon-plain + - containerPort: 2004 + name: carbon-pkl + - containerPort: 2023 + name: carbon-ag-plain + - containerPort: 2024 + name: carbon-ag-pkl + - containerPort: 8125 + name: statsd + - containerPort: 8126 + name: statsd-admin + - containerPort: 80 + name: http + - image: docker.io/scaleoutsean/sfc:v0.7.1 + name: sfc + args: [ "-s", "$(SF_MVIP)", "-u", "$(SF_RO_ADMIN)", "-p", "$(SF_RO_ADMIN_PASS)", "-g", "$(GRAPHITE_TARGET)" ] + env: + - name: SF_MVIP + value: "192.168.1.30" + - name: SF_RO_ADMIN + value: "sfc" + - name: SF_RO_ADMIN_PASS + value: "*********" + - name: GRAPHITE_TARGET + value: "graphite" +--- +apiVersion: v1 +kind: Service +metadata: + name: graphite + labels: + app: graphite +spec: + type: LoadBalancer + ports: + - port: 80 + protocol: TCP + targetPort: 80 + name: http + - port: 2003 + protocol: TCP + targetPort: 2003 + name: carbon + selector: + app: graphite diff --git a/sfcollector/solidfire_graphite_collector.py b/sfcollector/solidfire_graphite_collector.py new file mode 100644 index 0000000..7a9a8e0 --- /dev/null +++ b/sfcollector/solidfire_graphite_collector.py @@ -0,0 +1,478 @@ +#!/usr/bin/env python +# solidfire_graphite_collector.py +# +# Version 1.0.5 +# +# Original authors: Colin Bieberstein, Aaron Patten +# Contributors: Pablo Luis Zorzoli, Davide Obbi, scaleoutSean +# +# Copyright (c) 2020 NetApp, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import argparse +import time +import graphyte +from solidfire.factory import ElementFactory +import solidfire.common +import logging + + +def send_cluster_faults(sfe, prefix): + """ + send active cluster fault counts by: warning, error, critical + exclude best practices, and only include current faults + """ + fault_list = sfe.list_cluster_faults(False, "current").to_json()['faults'] + group = {'critical': 0, 'error': 0, 'warning': 0} + for d in fault_list: + if d['severity'] not in group: + group[d['severity']] = 1 + else: + group[d['severity']] += 1 + + if to_graphite: + for key in group: + graphyte.send(prefix + '.fault.' + key, to_num(group[key])) + else: + for key in group: + LOG.warning(prefix + '.fault.' + key + ' ' + str(group[key])) + + +def send_cluster_stats(sfe, prefix): + """ + send a subset of GetClusterStats API call results to graphite. + """ + metrics = ['clientQueueDepth', 'clusterUtilization', 'readOpsLastSample', + 'readBytesLastSample', 'writeOpsLastSample', 'writeBytesLastSample', + 'actualIOPS', 'latencyUSec', 'normalizedIOPS', 'readBytes', + 'readLatencyUSec', 'readOps', 'unalignedReads', 'unalignedWrites', + 'writeLatencyUSec', 'writeOps', 'writeBytes'] + + cluster_stats_dict = sfe.get_cluster_stats().to_json()['clusterStats'] + + clusterUtilizationDec = float(cluster_stats_dict['clusterUtilization']) + clusterUtilizationScaled = clusterUtilizationDec + + if to_graphite: + graphyte.send(prefix + '.clusterUtilizationScaled', to_num(clusterUtilizationScaled)) + else: + LOG.warning(prefix + '.clusterUtilizationScaled ' + str(clusterUtilizationScaled)) + + for key in metrics: + if to_graphite: + graphyte.send(prefix + '.' + key, to_num(cluster_stats_dict[key])) + else: + LOG.warning(prefix + '.' + key + ' ' + str(cluster_stats_dict[key])) + + +def send_cluster_capacity(sfe, prefix): + """ + send a subset of GetClusterCapacity API call results and derived metrics to graphite. + """ + metrics = ['activeBlockSpace', 'activeSessions', 'averageIOPS', + 'clusterRecentIOSize', 'currentIOPS', 'maxIOPS', + 'maxOverProvisionableSpace', 'maxProvisionedSpace', + 'maxUsedMetadataSpace', 'maxUsedSpace', 'nonZeroBlocks', + 'peakActiveSessions', 'peakIOPS', 'provisionedSpace', + 'snapshotNonZeroBlocks', 'totalOps', 'uniqueBlocks', + 'uniqueBlocksUsedSpace', 'usedMetadataSpace', + 'usedMetadataSpaceInSnapshots', 'usedSpace', 'zeroBlocks'] + + result = sfe.get_cluster_capacity().to_json()['clusterCapacity'] + for key in metrics: + if to_graphite: + graphyte.send(prefix + '.' + key, to_num(result[key])) + else: + LOG.warning(prefix + '.' + key + ' ' + str(result[key])) + + # Calculate & send derived metrics + non_zero_blocks = to_num(result['nonZeroBlocks']) + zero_blocks = to_num(result['zeroBlocks']) + unique_blocks = to_num(result['uniqueBlocks']) + unique_blocks_used_space = to_num(result['uniqueBlocksUsedSpace']) + snapshot_non_zero_blocks = to_num(result['snapshotNonZeroBlocks']) + + if non_zero_blocks != 0: + thin_factor = float((non_zero_blocks + zero_blocks)) / float(non_zero_blocks) + else: + thin_factor = 1 + if to_graphite: + graphyte.send(prefix + '.thin_factor', to_num(thin_factor)) + else: + LOG.warning(prefix + '.thin_factor ' + str(thin_factor)) + + if unique_blocks != 0: + # cluster with volumes with snapshots can have dedupe ratio < 1 + dedupe_factor = float(non_zero_blocks + snapshot_non_zero_blocks) / float(unique_blocks) + else: + dedupe_factor = 1 + if to_graphite: + graphyte.send(prefix + '.dedupe_factor', to_num(dedupe_factor)) + else: + LOG.warning(prefix + '.dedupe_factor ' + str(dedupe_factor)) + if unique_blocks_used_space != 0: + compression_factor = (unique_blocks * 4096.0) / (unique_blocks_used_space * .93) + else: + compression_factor = 1 + if to_graphite: + graphyte.send(prefix + '.compression_factor', to_num(compression_factor)) + else: + LOG.warning(prefix + '.compression_factor ' + str(compression_factor)) + + efficiency_cxd_factor = dedupe_factor * compression_factor + efficiency_factor = thin_factor * efficiency_cxd_factor + if to_graphite: + graphyte.send(prefix + '.efficiency_factor', to_num(efficiency_factor)) + # w/o Thin Provisioning + graphyte.send(prefix + '.efficiency_cxd_factor', to_num(efficiency_cxd_factor)) + else: + LOG.warning(prefix + '.efficiency_factor ' + str(efficiency_factor)) + LOG.warning(prefix + '.efficiency_cxd_factor ' + str(efficiency_cxd_factor)) + + +def send_volume_stats(sfe, prefix): + """ + Send a subset of ListVolumeStatsByVolume results to graphite. + Note: Calls ListVolumes to get volume names for use in metric path. + """ + metrics_list = ['actualIOPS', 'averageIOPSize', 'burstIOPSCredit', + 'clientQueueDepth', 'latencyUSec', 'nonZeroBlocks', 'readBytes', + 'readBytesLastSample', 'readLatencyUSec', 'readOps', + 'readOpsLastSample', 'throttle', 'unalignedReads', 'unalignedWrites', + 'volumeSize', 'volumeUtilization', 'writeBytes', 'writeBytesLastSample', + 'writeLatencyUSec', 'writeOps', 'writeOpsLastSample', 'zeroBlocks'] + + volume_list = sfe.list_volumes(include_virtual_volumes=False).to_json()['volumes'] + volinfo_by_id = list_to_dict(volume_list, key="volumeID") + + volstats = sfe.list_volume_stats_by_volume(include_virtual_volumes=False).to_json()['volumeStats'] + for vs_dict in volstats: + vol_name = volinfo_by_id[vs_dict['volumeID']]['name'] + vol_id = volinfo_by_id[vs_dict['volumeID']]['volumeID'] + vol_accountID = volinfo_by_id[vs_dict['volumeID']]['accountID'] + vol_accountID = volinfo_by_id[vs_dict['volumeID']]['accountID'] + vol_accountName = sfe.get_account_by_id(vol_accountID).to_json()['account']['username'] + for key in metrics_list: + if to_graphite: + graphyte.send(prefix + '.accountID.' + str(vol_accountName) + + '.volume.' + str(vol_name) + '.' + key, to_num(vs_dict[key])) + graphyte.send(prefix + '.volumeID.' + str(vol_id) + '.' + key, to_num(vs_dict[key])) + else: + LOG.warning(prefix + '.accountID.' + str(vol_accountName) + + '.volume.' + str(vol_name) + '.' + key + ' ' + str(vs_dict[key])) + LOG.warning(prefix + '.volumeID.' + str(vol_accountName) + + '.volumeID.' + str(vol_id) + '.' + key + ' ' + str(vs_dict[key])) + + +def send_volume_histogram_stats(sfe, prefix): + """ + Send volume QoS histogram stats. Requires API v11 or above + Note: as of August 2020, this API method is not well documented so + stuff may not mean what we think it means. + """ + hmetrics = ['belowMinIopsPercentages', 'minToMaxIopsPercentages', + 'minToMaxIopsPercentages', 'readBlockSizes', 'throttlePercentages', + 'writeBlockSizes'] + qosh = sfe.invoke_sfapi("ListVolumeQoSHistograms", parameters=None) + for i in range(len(qosh['qosHistograms'])): + for metric in hmetrics: + for key, value in (qosh['qosHistograms'][i]['histograms'][metric]).items(): + if to_graphite: + graphyte.send(prefix + '.volumeID.' + str(qosh['qosHistograms'][i]['volumeID']) + + '.' + metric + '.' + key, int(value)) + else: + LOG.warning(prefix + '.volumeID.' + str(qosh['qosHistograms'][i]['volumeID']) + + '.' + metric + '.' + key + ' ' + str(value)) + + +def send_drive_stats(sfe, prefix): + """ + Calculates summary statistics about drives by status and type at both cluster + and node levels and submits them to graphite. + Calls ListDrives and ListAllNodes + """ + # Cluster level status + drive_list = sfe.list_drives().to_json()['drives'] + for status in ['active', 'available', 'erasing', 'failed', 'removing']: + value = count_if(drive_list, 'status', status) + if to_graphite: + graphyte.send(prefix + '.drives.status.' + status, to_num(value)) + else: + LOG.warning(prefix + '.drives.status.' + status + ' ' + str(value)) + for dtype in ['volume', 'block', 'unknown']: + value = count_if(drive_list, 'type', dtype) + if to_graphite: + graphyte.send(prefix + '.drives.type.' + dtype, to_num(value)) + else: + LOG.warning(prefix + '.drives.type.' + dtype + ' ' + str(value)) + # Node level status + node_list = sfe.list_all_nodes().to_json()['nodes'] + nodeinfo_by_id = list_to_dict(node_list, key="nodeID") + for node in nodeinfo_by_id: + node_name = nodeinfo_by_id[node]['name'] + for status in ['active', 'available', 'erasing', 'failed', 'removing']: + value = count_ifs(drive_list, 'status', status, 'nodeID', node) + if to_graphite: + graphyte.send(prefix + '.node.' + node_name + '.drives.status.' + status, to_num(value)) + else: + LOG.warning(prefix + '.node.' + node_name + '.drives.status.' + status + ' ' + str(value)) + for drive_type in ['volume', 'block', 'unknown']: + value = count_ifs(drive_list, 'type', drive_type, 'nodeID', node) + if to_graphite: + graphyte.send(prefix + '.node.' + node_name + '.drives.type.' + drive_type, to_num(value)) + else: + LOG.warning(prefix + '.node.' + node_name + '.drives.type.' + drive_type + ' ' + str(value)) + + +def send_ssd_stats(sfe, prefix): + """ + Send drive wear level from ListDriveStats API method results to graphite. + We could store them under node name, but that doesn't seem necessary. + Note: Calls ListDriveStats to get driveID to use in metric path. + """ + result = sfe.list_drive_stats().to_json()['driveStats'] + + for i in range(len(result)): + driveId = result[i]['driveID'] + lifePct = result[i]['lifeRemainingPercent'] + if 'activeSessions' in result[i].keys(): + sessions = result[i]['activeSessions'] + if to_graphite: + graphyte.send(prefix + '.drives.' + str(driveId) + '.sessions', int(sessions)) + graphyte.send(prefix + '.drives.' + str(driveId) + '.lifeRemainingPercent', int(lifePct)) + else: + LOG.warning(prefix + '.drives.' + str(driveId) + '.sessions ' + str(sessions)) + LOG.warning(prefix + '.drives.' + str(driveId) + '.lifeRemainingPercent ' + str(lifePct)) + else: + if to_graphite: + graphyte.send(prefix + '.drives.' + str(driveId) + '.lifeRemainingPercent', int(lifePct)) + else: + LOG.warning(prefix + '.drives.' + str(driveId) + '.lifeRemainingPercent ' + str(lifePct)) + + +def send_elem_version(sfe, prefix): + """ + Send the highest API version supported by current Element API + """ + result = sfe.get_cluster_version_info().to_json() + sf_version = result['clusterAPIVersion'] + if to_graphite: + graphyte.send(prefix + '.version', float(sf_version)) + else: + LOG.warning(prefix + '.version ' + str(sf_version)) + + +def send_acc_eff(sfe, prefix): + """ + Sends the CxD (no Thin Provisioning) account efficiency for + all accounts with one or more volumes + """ + accounts = sfe.list_accounts().to_json()['accounts'] + avw = [] + for x in range(len(accounts)): + if len(accounts[x]['volumes']) > 0: + avw.append(accounts[x]['accountID']) + + for acc in avw: + acc_eff = 0 + acc_eff_info = sfe.get_account_efficiency(acc).to_json() + acc_eff = round(acc_eff_info['compression'] * acc_eff_info['deduplication'],2) + if to_graphite: + graphyte.send(prefix + '.accountID.' + str(acc) + '.accountEfficiency', float(acc_eff)) + else: + LOG.warning(prefix + '.accountID.' + str(acc) + '.accountEfficiency ' + str(acc_eff)) + + +def send_vol_efficiency(sfe, prefix): + """ + Send per-volume efficiency info (dedupe & compression aka CxD only) + Can be used to identify low-efficiency volumes (e.g. < 1.5x) + """ + results = sfe.list_accounts().to_json() + for account in results['accounts']: + av = sfe.list_volumes(accounts=[account['accountID']]).to_json() + if len(av['volumes']) > 0: + for volume in av['volumes']: + vol_eff_d = sfe.get_volume_efficiency(volume['volumeID']).to_json() + vol_eff = round((vol_eff_d['deduplication'] * vol_eff_d['compression']),2) + if to_graphite: + graphyte.send(prefix + '.volumeID.' + str(volume['volumeID']) + '.volumeEfficiency', float(vol_eff)) + else: + print(prefix + '.volumeID.' + str(volume['volumeID']) + '.volumeEfficiency ' + str(vol_eff)) + LOG.warning(prefix + '.volumeID.' + str(volume['volumeID']) + '.volumeEfficiency ' + str(vol_eff)) + else: + LOG.warning(prefix + ': account ID ' + str(account['accountID']) + ' has no volumes') + + +def send_conn_stats(sfe, prefix): + """ + calculates iSCSI connection stats at both cluster + and node levels and submits them to Graphite. + Calls ListConnections + """ + result = sfe.list_iscsisessions().to_json()['sessions'] + tgts = [] + accts = [] + for i in range(len(result)): + tgts.append(result[i]['targetIP'].split(':')[0]) + accts.append(result[i]['initiatorIP'].split(':')[0]) + + if to_graphite: + graphyte.send(prefix + '.iscsiActiveSessionCount', len(result)) + graphyte.send(prefix + '.iscsiTargetCount', len(set(tgts))) + else: + LOG.warning(prefix + '.iscsiActiveSessionCount ' + str(len(result))) + LOG.warning(prefix + '.iscsiTargetCount ' + str(len(set(tgts)))) + + +def send_node_stats(sfe, prefix): + """ + send a subset of ListNodeStats API call results to graphite. + Note: Calls ListAllNodes to get node name to use in metric path. + """ + metrics_list = ['cpu', 'usedMemory', 'networkUtilizationStorage', + 'networkUtilizationCluster', 'cBytesOut', 'cBytesIn', 'sBytesOut', + 'sBytesIn', 'mBytesOut', 'mBytesIn', 'readOps', 'writeOps'] + + node_list = sfe.list_all_nodes().to_json()['nodes'] + nodeinfo_by_id = list_to_dict(node_list, key="nodeID") + + nodestats = sfe.list_node_stats().to_json()['nodeStats']['nodes'] + for ns_dict in nodestats: + node_name = nodeinfo_by_id[ns_dict['nodeID']]['name'] + for key in metrics_list: + if to_graphite: + graphyte.send(prefix + '.node.' + node_name + '.' + key, to_num(ns_dict[key])) + else: + LOG.warning(prefix + '.node.' + node_name + '.' + key + ' ' + str(ns_dict[key])) + + +def list_to_dict(list_of_dicts, key): + """ + pivots a list of dicts into a dict of dicts, using key. + """ + x = dict((child[key], dict(child, index=index)) for (index, child) in \ + enumerate(list_of_dicts)) + return x + + +def count_if(my_list, key, value): + """ + return number of records in my_list where key==value pair matches + """ + counter = (1 for item in my_list if item.get(key) == value) + return sum(counter) + + +def count_ifs(my_list, key, value, key2, value2): + """ + return number of records in my_list where both key==value pairs matches + ToDo: convert to grab any number of key=value pairs + """ + counter = (1 for item in my_list if ((item.get(key) == value) and \ + (item.get(key2) == value2))) + return sum(counter) + + +def to_num(metric): + """ + convert string to number (int or float) + """ + x = 0 + try: + x = float(metric) + except ValueError: + try: + x = float(metric) + except ValueError: + x = float('NaN') + finally: + return x + + +# Parse commandline arguments +parser = argparse.ArgumentParser() +parser.add_argument('-s', '--solidfire', + help='MVIP or FQDN of SolidFire cluster from which metrics should be collected') +parser.add_argument('-u', '--username', default='admin', + help='username for SolidFire array. Default: admin (NOTE: consider using a dedicated reporting admin account)') +parser.add_argument('-p', '--password', default='password', + help='password for admin account on SolidFire cluster. Default: password') +parser.add_argument('-o', '--timeout', type=int, default=10, + help='timeout for SolidFire Collector to connect to SolidFire API. Default: 10 (seconds)') +parser.add_argument('-a', '--apitimeout', type=int, default=20, + help='timeout for SolidFire Collector to get response from the SolidFire API endpoint. Default: 20 (seconds)') +parser.add_argument('-c', '--validatecert', default=False, + help='Validate SF TLS certificate. Default: False (allow self-signed). For "True", --solidfire must use FQDN') +parser.add_argument('-g', '--graphite', default='localhost', + help='hostname of Graphite server to send to. Default: localhost. (NOTE: "debug" sends metrics to logfile)') +parser.add_argument('-t', '--port', type=int, default=2003, + help='port to send message to. Default: 2003. if the --graphite is set to debug, can be omitted') +parser.add_argument('-v', '--version', default="11.0", + help='Element API version. Default: 11.0. Version must be supported by SolidFire Python SDK in sfcollector') +parser.add_argument('-m', '--metricroot', default='netapp.solidfire.cluster', + help='Graphite metric root for sfcollector. Default: netapp.solidfire.cluster') +parser.add_argument('-l', '--logfile', + help='logfile. Default: none. Required if Graphite hostname is "debug" and metrics sent to logfile') +args = parser.parse_args() + +to_graphite = True +# Logger module configuration +LOG = logging.getLogger('solidfire_graphite_collector.py') +if args.logfile: + logging.basicConfig(filename=args.logfile, level=logging.DEBUG, format='%(asctime)s %(message)s') + LOG.warning("Starting Collector script as a daemon. No console output possible.") +else: + logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s') + +# Initialize graphyte sender +if args.graphite == "debug": + LOG.warning("Starting collector in debug mode. All the metrics will be shipped to logfile") + to_graphite = False +else: + graphyte.init(args.graphite, port=args.port, prefix=args.metricroot) + +LOG.info("Metrics Collection for array: {0}".format(args.solidfire)) +try: + sfe = ElementFactory.create(args.solidfire, args.username, args.password, args.version, verify_ssl=args.validatecert, print_ascii_art=False) + # There are two kinds of timeouts (one is for individual API requests) + # https://github.com/solidfire/solidfire-sdk-python/pull/39/files + sfe.timeout(args.apitimeout) + sfe.connect_timeout(args.timeout) +except solidfire.common.ApiServerError as e: + LOG.warning("ApiServerError: {0}".format(str(e))) + sfe = None +except Exception as e: + LOG.warning("General Exception: {0}".format(str(e))) + sfe = None + +try: + cluster_name = sfe.get_cluster_info().to_json()['clusterInfo']['name'] + send_cluster_faults(sfe, cluster_name) + send_cluster_stats(sfe, cluster_name) + send_cluster_capacity(sfe, cluster_name) + send_volume_stats(sfe, cluster_name) + send_volume_histogram_stats(sfe, cluster_name) + send_drive_stats(sfe, cluster_name) + send_ssd_stats(sfe, cluster_name) + send_acc_eff(sfe, cluster_name) + send_elem_version(sfe, cluster_name) + send_vol_efficiency(sfe, cluster_name) + send_node_stats(sfe, cluster_name) + send_conn_stats(sfe, cluster_name) +except solidfire.common.ApiServerError as e: + LOG.warning("ApiServerError: {0}".format(str(e))) +except Exception as e: + LOG.warning("General Exception: {0}".format(str(e))) + sfe = None diff --git a/vmwcollector/Dockerfile b/vmwcollector/Dockerfile new file mode 100644 index 0000000..9beed2a --- /dev/null +++ b/vmwcollector/Dockerfile @@ -0,0 +1,5 @@ +# Docker container for vSphere Graphite collector +# +FROM cblomart/vsphere-graphite:v0.9 +COPY vsphere-graphite.json /etc/vsphere-graphite.json +ENTRYPOINT [ "/vsphere-graphite" ]