` in favor of `proxies=httpx.Proxy(...)`.
See pull requests #1057, #1058.
### Added
* Added dedicated exception class `httpx.HTTPStatusError` for `.raise_for_status()` exceptions. (Pull #1072)
* Added `httpx.create_ssl_context()` helper function. (Pull #996)
* Support for proxy exlcusions like `proxies={"https://www.example.com": None}`. (Pull #1099)
* Support `QueryParams(None)` and `client.params = None`. (Pull #1060)
### Changed
* Use `httpx.codes` consistently in favour of `httpx.StatusCodes` which is placed into deprecation. (Pull #1088)
* Usage of `httpx.Timeout()` should now always include an explicit default. Eg. `httpx.Timeout(None, pool=5.0)`. (Pull #1085)
* Switch to more concise `httpx.Timeout()` keyword arguments. Eg. `read=5.0`, instead of `read_timeout=5.0`. (Pull #1111)
* Use `httpx.Limits()` instead of `httpx.PoolLimits()`, and `limits=...` instead of `pool_limits=...`. (Pull #1113)
* Keys used with `Client(proxies={...})` should now be in the style of `{"http://": ...}`, rather than `{"http": ...}`. (Pull #1127)
* The multidict methods `Headers.getlist` and `QueryParams.getlist` are deprecated in favour of more consistent `.get_list()` variants. (Pull #1089)
* `URL.port` becomes `Optional[int]`. Now only returns a port if one is explicitly included in the URL string. (Pull #1080)
* The `URL(..., allow_relative=[bool])` parameter no longer exists. All URL instances may be relative. (Pull #1073)
* Drop unnecessary `url.full_path = ...` property setter. (Pull #1069)
* The `URL.join(relative_url=...)` method is now `URL.join(url=...)`. (Pull #1129)
* The `URL.is_ssl` property is deprecated in favour of `URL.scheme == "https"`. (Pull #1128)
### Fixed
* Add missing `Response.next()` method. (Pull #1055)
* Ensure all exception classes are exposed as public API. (Pull #1045)
* Support multiple items with an identical field name in multipart encodings. (Pull #777)
* Skip HSTS preloading on single-label domains. (Pull #1074)
* Fixes for `Response.iter_lines()`. (Pull #1033, #1075)
* Ignore permission errors when accessing `.netrc` files. (Pull #1104)
* Allow bare hostnames in `HTTP_PROXY` etc... environment variables. (Pull #1120)
* Settings `app=...` or `transport=...` bypasses any environment based proxy defaults. (Pull #1122)
* Fix handling of `.base_url` when a path component is included in the base URL. (Pull #1130)
---
## 0.13.3 (May 29th, 2020)
### Fixed
* Include missing keepalive expiry configuration. (Pull #1005)
* Improved error message when URL redirect has a custom scheme. (Pull #1002)
## 0.13.2 (May 27th, 2020)
### Fixed
* Include explicit "Content-Length: 0" on POST, PUT, PATCH if no request body is used. (Pull #995)
* Add `http2` option to `httpx.Client`. (Pull #982)
* Tighten up API typing in places. (Pull #992, #999)
## 0.13.1 (May 22nd, 2020)
### Fixed
* Fix pool options deprecation warning. (Pull #980)
* Include `httpx.URLLib3ProxyTransport` in top-level API. (Pull #979)
## 0.13.0 (May 22nd, 2020)
This release switches to `httpcore` for all the internal networking, which means:
* We're using the same codebase for both our sync and async clients.
* HTTP/2 support is now available with the sync client.
* We no longer have a `urllib3` dependency for our sync client, although there is still an *optional* `URLLib3Transport` class.
It also means we've had to remove our UDS support, since maintaining that would have meant having to push back our work towards a 1.0 release, which isn't a trade-off we wanted to make.
We also now have [a public "Transport API"](https://www.python-httpx.org/advanced/#custom-transports), which you can use to implement custom transport implementations against. This formalises and replaces our previously private "Dispatch API".
### Changed
* Use `httpcore` for underlying HTTP transport. Drop `urllib3` requirement. (Pull #804, #967)
* Rename pool limit options from `soft_limit`/`hard_limit` to `max_keepalive`/`max_connections`. (Pull #968)
* The previous private "Dispatch API" has now been promoted to a public "Transport API". When customizing the transport use `transport=...`. The `ASGIDispatch` and `WSGIDispatch` class naming is deprecated in favour of `ASGITransport` and `WSGITransport`. (Pull #963)
### Added
* Added `URLLib3Transport` class for optional `urllib3` transport support. (Pull #804, #963)
* Streaming multipart uploads. (Pull #857)
* Logging via HTTPCORE_LOG_LEVEL and HTTPX_LOG_LEVEL environment variables
and TRACE level logging. (Pull encode/httpcore#79)
### Fixed
* Performance improvement in brotli decoder. (Pull #906)
* Proper warning level of deprecation notice in `Response.stream` and `Response.raw`. (Pull #908)
* Fix support for generator based WSGI apps. (Pull #887)
* Reuse of connections on HTTP/2 in close concurrency situations. (Pull encode/httpcore#81)
* Honor HTTP/2 max concurrent streams settings (Pull encode/httpcore#89, encode/httpcore#90)
* Fix bytes support in multipart uploads. (Pull #974)
* Improve typing support for `files=...`. (Pull #976)
### Removed
* Dropped support for `Client(uds=...)` (Pull #804)
## 0.13.0.dev2 (May 12th, 2020)
The 0.13.0.dev2 is a *pre-release* version. To install it, use `pip install httpx --pre`.
### Added
* Logging via HTTPCORE_LOG_LEVEL and HTTPX_LOG_LEVEL environment variables
and TRACE level logging. (HTTPCore Pull #79)
### Fixed
* Reuse of connections on HTTP/2 in close concurrency situations. (HTTPCore Pull #81)
* When using an `app=` observe neater disconnect behaviour instead of sending empty body messages. (Pull #919)
## 0.13.0.dev1 (May 6th, 2020)
The 0.13.0.dev1 is a *pre-release* version. To install it, use `pip install httpx --pre`.
### Fixed
* Passing `http2` flag to proxy dispatchers. (Pull #934)
* Use [`httpcore` v0.8.3](https://github.com/encode/httpcore/releases/tag/0.8.3)
which addresses problems in handling of headers when using proxies.
## 0.13.0.dev0 (April 30th, 2020)
The 0.13.0.dev0 is a *pre-release* version. To install it, use `pip install httpx --pre`.
This release switches to `httpcore` for all the internal networking, which means:
* We're using the same codebase for both our sync and async clients.
* HTTP/2 support is now available with the sync client.
* We no longer have a `urllib3` dependency for our sync client, although there is still an *optional* `URLLib3Dispatcher` class.
It also means we've had to remove our UDS support, since maintaining that would have meant having to push back our work towards a 1.0 release, which isn't a trade-off we wanted to make.
### Changed
* Use `httpcore` for underlying HTTP transport. Drop `urllib3` requirement. (Pull #804)
### Added
* Added `URLLib3Dispatcher` class for optional `urllib3` transport support. (Pull #804)
* Streaming multipart uploads. (Pull #857)
### Fixed
* Performance improvement in brotli decoder. (Pull #906)
* Proper warning level of deprecation notice in `Response.stream` and `Response.raw`. (Pull #908)
* Fix support for generator based WSGI apps. (Pull #887)
### Removed
* Dropped support for `Client(uds=...)` (Pull #804)
---
## 0.12.1 (March 19th, 2020)
### Fixed
* Resolved packaging issue, where additional files were being included.
## 0.12.0 (March 9th, 2020)
The 0.12 release tightens up the API expectations for `httpx` by switching to private module names to enforce better clarity around public API.
All imports of `httpx` should import from the top-level package only, such as `from httpx import Request`, rather than importing from privately namespaced modules such as `from httpx._models import Request`.
### Added
* Support making response body available to auth classes with `.requires_response_body`. (Pull #803)
* Export `NetworkError` exception. (Pull #814)
* Add support for `NO_PROXY` environment variable. (Pull #835)
### Changed
* Switched to private module names. (Pull #785)
* Drop redirect looping detection and the `RedirectLoop` exception, instead using `TooManyRedirects`. (Pull #819)
* Drop `backend=...` parameter on `AsyncClient`, in favour of always autodetecting `trio`/`asyncio`. (Pull #791)
### Fixed
* Support basic auth credentials in proxy URLs. (Pull #780)
* Fix `httpx.Proxy(url, mode="FORWARD_ONLY")` configuration. (Pull #788)
* Fallback to setting headers as UTF-8 if no encoding is specified. (Pull #820)
* Close proxy dispatches classes on client close. (Pull #826)
* Support custom `cert` parameters even if `verify=False`. (Pull #796)
* Don't support invalid dict-of-dicts form data in `data=...`. (Pull #811)
---
## 0.11.1 (January 17th, 2020)
### Fixed
* Fixed usage of `proxies=...` on `Client()`. (Pull #763)
* Support both `zlib` and `deflate` style encodings on `Content-Encoding: deflate`. (Pull #758)
* Fix for streaming a redirect response body with `allow_redirects=False`. (Pull #766)
* Handle redirect with malformed Location headers missing host. (Pull #774)
## 0.11.0 (January 9th, 2020)
The 0.11 release reintroduces our sync support, so that `httpx` now supports both a standard thread-concurrency API, and an async API.
Existing async `httpx` users that are upgrading to 0.11 should ensure that:
* Async codebases should always use a client instance to make requests, instead of the top-level API.
* The async client is named as `httpx.AsyncClient()`, instead of `httpx.Client()`.
* When instantiating proxy configurations use the `httpx.Proxy()` class, instead of the previous `httpx.HTTPProxy()`. This new configuration class works for configuring both sync and async clients.
We believe the API is now pretty much stable, and are aiming for a 1.0 release sometime on or before April 2020.
### Changed
- Top level API such as `httpx.get(url, ...)`, `httpx.post(url, ...)`, `httpx.request(method, url, ...)` becomes synchronous.
- Added `httpx.Client()` for synchronous clients, with `httpx.AsyncClient` being used for async clients.
- Switched to `proxies=httpx.Proxy(...)` for proxy configuration.
- Network connection errors are wrapped in `httpx.NetworkError`, rather than exposing lower-level exception types directly.
### Removed
- The `request.url.origin` property and `httpx.Origin` class are no longer available.
- The per-request `cert`, `verify`, and `trust_env` arguments are escalated from raising errors if used, to no longer being available. These arguments should be used on a per-client instance instead, or in the top-level API.
- The `stream` argument has escalated from raising an error when used, to no longer being available. Use the `client.stream(...)` or `httpx.stream()` streaming API instead.
### Fixed
- Redirect loop detection matches against `(method, url)` rather than `url`. (Pull #734)
---
## 0.10.1 (December 31st, 2019)
### Fixed
- Fix issue with concurrent connection acquiry. (Pull #700)
- Fix write error on closing HTTP/2 connections. (Pull #699)
## 0.10.0 (December 29th, 2019)
The 0.10.0 release makes some changes that will allow us to support both sync and async interfaces.
In particular with streaming responses the `response.read()` method becomes `response.aread()`, and the `response.close()` method becomes `response.aclose()`.
If following redirects explicitly the `response.next()` method becomes `response.anext()`.
### Fixed
- End HTTP/2 streams immediately on no-body requests, rather than sending an empty body message. (Pull #682)
- Improve typing for `Response.request`: switch from `Optional[Request]` to `Request`. (Pull #666)
- `Response.elapsed` now reflects the entire download time. (Pull #687, #692)
### Changed
- Added `AsyncClient` as a synonym for `Client`. (Pull #680)
- Switch to `response.aread()` for conditionally reading streaming responses. (Pull #674)
- Switch to `response.aclose()` and `client.aclose()` for explicit closing. (Pull #674, #675)
- Switch to `response.anext()` for resolving the next redirect response. (Pull #676)
### Removed
- When using a client instance, the per-request usage of `verify`, `cert`, and `trust_env` have now escalated from raising a warning to raising an error. You should set these arguments on the client instead. (Pull #617)
- Removed the undocumented `request.read()`, since end users should not require it.
---
## 0.9.5 (December 20th, 2019)
### Fixed
- Fix Host header and HSTS rewrites when an explicit `:80` port is included in URL. (Pull #649)
- Query Params on the URL string are merged with any `params=...` argument. (Pull #653)
- More robust behavior when closing connections. (Pull #640)
- More robust behavior when handling HTTP/2 headers with trailing whitespace. (Pull #637)
- Allow any explicit `Content-Type` header to take precedence over the encoding default. (Pull #633)
## 0.9.4 (December 12th, 2019)
### Fixed
- Added expiry to Keep-Alive connections, resolving issues with acquiring connections. (Pull #627)
- Increased flow control windows on HTTP/2, resolving download speed issues. (Pull #629)
## 0.9.3 (December 7th, 2019)
### Fixed
- Fixed HTTP/2 with autodetection backend. (Pull #614)
## 0.9.2 (December 7th, 2019)
* Released due to packaging build artifact.
## 0.9.1 (December 6th, 2019)
* Released due to packaging build artifact.
## 0.9.0 (December 6th, 2019)
The 0.9 releases brings some major new features, including:
* A new streaming API.
* Autodetection of either asyncio or trio.
* Nicer timeout configuration.
* HTTP/2 support off by default, but can be enabled.
We've also removed all private types from the top-level package export.
In order to ensure you are only ever working with public API you should make
sure to only import the top-level package eg. `import httpx`, rather than
importing modules within the package.
### Added
- Added concurrency backend autodetection. (Pull #585)
- Added `Client(backend='trio')` and `Client(backend='asyncio')` API. (Pull #585)
- Added `response.stream_lines()` API. (Pull #575)
- Added `response.is_error` API. (Pull #574)
- Added support for `timeout=Timeout(5.0, connect_timeout=60.0)` styles. (Pull #593)
### Fixed
- Requests or Clients with `timeout=None` now correctly always disable timeouts. (Pull #592)
- Request 'Authorization' headers now have priority over `.netrc` authentication info. (Commit 095b691)
- Files without a filename no longer set a Content-Type in multipart data. (Commit ed94950)
### Changed
- Added `httpx.stream()` API. Using `stream=True` now results in a warning. (Pull #600, #610)
- HTTP/2 support is switched to "off by default", but can be enabled explicitly. (Pull #584)
- Switched to `Client(http2=True)` API from `Client(http_versions=["HTTP/1.1", "HTTP/2"])`. (Pull #586)
- Removed all private types from the top-level package export. (Pull #608)
- The SSL configuration settings of `verify`, `cert`, and `trust_env` now raise warnings if used per-request when using a Client instance. They should always be set on the Client instance itself. (Pull #597)
- Use plain strings "TUNNEL_ONLY" or "FORWARD_ONLY" on the HTTPProxy `proxy_mode` argument. The `HTTPProxyMode` enum still exists, but its usage will raise warnings. (#610)
- Pool timeouts are now on the timeout configuration, not the pool limits configuration. (Pull #563)
- The timeout configuration is now named `httpx.Timeout(...)`, not `httpx.TimeoutConfig(...)`. The old version currently remains as a synonym for backwards compatibility. (Pull #591)
---
## 0.8.0 (November 27, 2019)
### Removed
- The synchronous API has been removed, in order to allow us to fundamentally change how we approach supporting both sync and async variants. (See #588 for more details.)
---
## 0.7.8 (November 17, 2019)
### Added
- Add support for proxy tunnels for Python 3.6 + asyncio. (Pull #521)
## 0.7.7 (November 15, 2019)
### Fixed
- Resolve an issue with cookies behavior on redirect requests. (Pull #529)
### Added
- Add request/response DEBUG logs. (Pull #502)
- Use TRACE log level for low level info. (Pull #500)
## 0.7.6 (November 2, 2019)
### Removed
- Drop `proxies` parameter from the high-level API. (Pull #485)
### Fixed
- Tweak multipart files: omit null filenames, add support for `str` file contents. (Pull #482)
- Cache NETRC authentication per-client. (Pull #400)
- Rely on `getproxies` for all proxy environment variables. (Pull #470)
- Wait for the `asyncio` stream to close when closing a connection. (Pull #494)
## 0.7.5 (October 10, 2019)
### Added
- Allow lists of values to be passed to `params`. (Pull #386)
- `ASGIDispatch`, `WSGIDispatch` are now available in the `httpx.dispatch` namespace. (Pull #407)
- `HTTPError` is now available in the `httpx` namespace. (Pull #421)
- Add support for `start_tls()` to the Trio concurrency backend. (Pull #467)
### Fixed
- Username and password are no longer included in the `Host` header when basic authentication
credentials are supplied via the URL. (Pull #417)
### Removed
- The `.delete()` function no longer has `json`, `data`, or `files` parameters
to match the expected semantics of the `DELETE` method. (Pull #408)
- Removed the `trio` extra. Trio support is detected automatically. (Pull #390)
## 0.7.4 (September 25, 2019)
### Added
- Add Trio concurrency backend. (Pull #276)
- Add `params` parameter to `Client` for setting default query parameters. (Pull #372)
- Add support for `SSL_CERT_FILE` and `SSL_CERT_DIR` environment variables. (Pull #307)
- Add debug logging to calls into ASGI apps. (Pull #371)
- Add debug logging to SSL configuration. (Pull #378)
### Fixed
- Fix a bug when using `Client` without timeouts in Python 3.6. (Pull #383)
- Propagate `Client` configuration to HTTP proxies. (Pull #377)
## 0.7.3 (September 20, 2019)
### Added
- HTTP Proxy support. (Pulls #259, #353)
- Add Digest authentication. (Pull #332)
- Add `.build_request()` method to `Client` and `AsyncClient`. (Pull #319)
- Add `.elapsed` property on responses. (Pull #351)
- Add support for `SSLKEYLOGFILE` in Python 3.8b4+. (Pull #301)
### Removed
- Drop NPN support for HTTP version negotiation. (Pull #314)
### Fixed
- Fix distribution of type annotations for mypy (Pull #361).
- Set `Host` header when redirecting cross-origin. (Pull #321)
- Drop `Content-Length` headers on `GET` redirects. (Pull #310)
- Raise `KeyError` if header isn't found in `Headers`. (Pull #324)
- Raise `NotRedirectResponse` in `response.next()` if there is no redirection to perform. (Pull #297)
- Fix bug in calculating the HTTP/2 maximum frame size. (Pull #153)
## 0.7.2 (August 28, 2019)
- Enforce using `httpx.AsyncioBackend` for the synchronous client. (Pull #232)
- `httpx.ConnectionPool` will properly release a dropped connection. (Pull #230)
- Remove the `raise_app_exceptions` argument from `Client`. (Pull #238)
- `DecodeError` will no longer be raised for an empty body encoded with Brotli. (Pull #237)
- Added `http_versions` parameter to `Client`. (Pull #250)
- Only use HTTP/1.1 on short-lived connections like `httpx.get()`. (Pull #284)
- Convert `Client.cookies` and `Client.headers` when set as a property. (Pull #274)
- Setting `HTTPX_DEBUG=1` enables debug logging on all requests. (Pull #277)
## 0.7.1 (August 18, 2019)
- Include files with source distribution to be installable. (Pull #233)
## 0.7.0 (August 17, 2019)
- Add the `trust_env` property to `BaseClient`. (Pull #187)
- Add the `links` property to `BaseResponse`. (Pull #211)
- Accept `ssl.SSLContext` instances into `SSLConfig(verify=...)`. (Pull #215)
- Add `Response.stream_text()` with incremental encoding detection. (Pull #183)
- Properly updated the `Host` header when a redirect changes the origin. (Pull #199)
- Ignore invalid `Content-Encoding` headers. (Pull #196)
- Use `~/.netrc` and `~/_netrc` files by default when `trust_env=True`. (Pull #189)
- Create exception base class `HTTPError` with `request` and `response` properties. (Pull #162)
- Add HSTS preload list checking within `BaseClient` to upgrade HTTP URLs to HTTPS. (Pull #184)
- Switch IDNA encoding from IDNA 2003 to IDNA 2008. (Pull #161)
- Expose base classes for alternate concurrency backends. (Pull #178)
- Improve Multipart parameter encoding. (Pull #167)
- Add the `headers` property to `BaseClient`. (Pull #159)
- Add support for Google's `brotli` library. (Pull #156)
- Remove deprecated TLS versions (TLSv1 and TLSv1.1) from default `SSLConfig`. (Pull #155)
- Fix `URL.join(...)` to work similarly to RFC 3986 URL joining. (Pull #144)
---
## 0.6.8 (July 25, 2019)
- Check for disconnections when searching for an available
connection in `ConnectionPool.keepalive_connections` (Pull #145)
- Allow string comparison for `URL` objects (Pull #139)
- Add HTTP status codes 418 and 451 (Pull #135)
- Add support for client certificate passwords (Pull #118)
- Enable post-handshake client cert authentication for TLSv1.3 (Pull #118)
- Disable using `commonName` for hostname checking for OpenSSL 1.1.0+ (Pull #118)
- Detect encoding for `Response.json()` (Pull #116)
## 0.6.7 (July 8, 2019)
- Check for connection aliveness on re-acquiry (Pull #111)
## 0.6.6 (July 3, 2019)
- Improve `USER_AGENT` (Pull #110)
- Add `Connection: keep-alive` by default to HTTP/1.1 connections. (Pull #110)
## 0.6.5 (June 27, 2019)
- Include `Host` header by default. (Pull #109)
- Improve HTTP protocol detection. (Pull #107)
## 0.6.4 (June 25, 2019)
- Implement read and write timeouts (Pull #104)
## 0.6.3 (June 24, 2019)
- Handle early connection closes (Pull #103)
## 0.6.2 (June 23, 2019)
- Use urllib3's `DEFAULT_CIPHERS` for the `SSLConfig` object. (Pull #100)
## 0.6.1 (June 21, 2019)
- Add support for setting a `base_url` on the `Client`.
## 0.6.0 (June 21, 2019)
- Honor `local_flow_control_window` for HTTP/2 connections (Pull #98)
httpx-0.26.0/LICENSE.md 0000664 0000000 0000000 00000002744 14540543546 0014373 0 ustar 00root root 0000000 0000000 Copyright © 2019, [Encode OSS Ltd](https://www.encode.io/).
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
httpx-0.26.0/README.md 0000664 0000000 0000000 00000011370 14540543546 0014241 0 ustar 00root root 0000000 0000000
HTTPX - A next-generation HTTP client for Python.
HTTPX is a fully featured HTTP client library for Python 3. It includes **an integrated
command line client**, has support for both **HTTP/1.1 and HTTP/2**, and provides both **sync
and async APIs**.
---
Install HTTPX using pip:
```shell
$ pip install httpx
```
Now, let's get started:
```pycon
>>> import httpx
>>> r = httpx.get('https://www.example.org/')
>>> r
>>> r.status_code
200
>>> r.headers['content-type']
'text/html; charset=UTF-8'
>>> r.text
'\n\n\nExample Domain...'
```
Or, using the command-line client.
```shell
$ pip install 'httpx[cli]' # The command line client is an optional dependency.
```
Which now allows us to use HTTPX directly from the command-line...
Sending a request...
## Features
HTTPX builds on the well-established usability of `requests`, and gives you:
* A broadly [requests-compatible API](https://www.python-httpx.org/compatibility/).
* An integrated command-line client.
* HTTP/1.1 [and HTTP/2 support](https://www.python-httpx.org/http2/).
* Standard synchronous interface, but with [async support if you need it](https://www.python-httpx.org/async/).
* Ability to make requests directly to [WSGI applications](https://www.python-httpx.org/advanced/#calling-into-python-web-apps) or [ASGI applications](https://www.python-httpx.org/async/#calling-into-python-web-apps).
* Strict timeouts everywhere.
* Fully type annotated.
* 100% test coverage.
Plus all the standard features of `requests`...
* International Domains and URLs
* Keep-Alive & Connection Pooling
* Sessions with Cookie Persistence
* Browser-style SSL Verification
* Basic/Digest Authentication
* Elegant Key/Value Cookies
* Automatic Decompression
* Automatic Content Decoding
* Unicode Response Bodies
* Multipart File Uploads
* HTTP(S) Proxy Support
* Connection Timeouts
* Streaming Downloads
* .netrc Support
* Chunked Requests
## Installation
Install with pip:
```shell
$ pip install httpx
```
Or, to include the optional HTTP/2 support, use:
```shell
$ pip install httpx[http2]
```
HTTPX requires Python 3.8+.
## Documentation
Project documentation is available at [https://www.python-httpx.org/](https://www.python-httpx.org/).
For a run-through of all the basics, head over to the [QuickStart](https://www.python-httpx.org/quickstart/).
For more advanced topics, see the [Advanced Usage](https://www.python-httpx.org/advanced/) section, the [async support](https://www.python-httpx.org/async/) section, or the [HTTP/2](https://www.python-httpx.org/http2/) section.
The [Developer Interface](https://www.python-httpx.org/api/) provides a comprehensive API reference.
To find out about tools that integrate with HTTPX, see [Third Party Packages](https://www.python-httpx.org/third_party_packages/).
## Contribute
If you want to contribute with HTTPX check out the [Contributing Guide](https://www.python-httpx.org/contributing/) to learn how to start.
## Dependencies
The HTTPX project relies on these excellent libraries:
* `httpcore` - The underlying transport implementation for `httpx`.
* `h11` - HTTP/1.1 support.
* `certifi` - SSL certificates.
* `idna` - Internationalized domain name support.
* `sniffio` - Async library autodetection.
As well as these optional installs:
* `h2` - HTTP/2 support. *(Optional, with `httpx[http2]`)*
* `socksio` - SOCKS proxy support. *(Optional, with `httpx[socks]`)*
* `rich` - Rich terminal support. *(Optional, with `httpx[cli]`)*
* `click` - Command line client support. *(Optional, with `httpx[cli]`)*
* `brotli` or `brotlicffi` - Decoding for "brotli" compressed responses. *(Optional, with `httpx[brotli]`)*
A huge amount of credit is due to `requests` for the API layout that
much of this work follows, as well as to `urllib3` for plenty of design
inspiration around the lower-level networking details.
---
HTTPX is BSD licensed code.
Designed & crafted with care.
— 🦋 —
httpx-0.26.0/README_chinese.md 0000664 0000000 0000000 00000010750 14540543546 0015740 0 ustar 00root root 0000000 0000000
HTTPX - 适用于 Python 的下一代 HTTP 客户端
HTTPX 是适用于 Python3 的功能齐全的 HTTP 客户端。 它集成了 **一个命令行客户端**，同时支持 **HTTP/1.1 和 HTTP/2**，并提供了 **同步和异步 API**。
---
通过 pip 安装 HTTPX：
```shell
$ pip install httpx
```
使用 httpx：
```pycon
>>> import httpx
>>> r = httpx.get('https://www.example.org/')
>>> r
>>> r.status_code
200
>>> r.headers['content-type']
'text/html; charset=UTF-8'
>>> r.text
'\n\n\nExample Domain...'
```
或者使用命令行客户端。
```shell
$ pip install 'httpx[cli]' # 命令行功能是可选的。
```
它允许我们直接通过命令行来使用 HTTPX...
发送一个请求...
## 特性
HTTPX 建立在成熟的 requests 可用性基础上，为您提供以下功能：
* 广泛的 [requests 兼容 API](https://www.python-httpx.org/compatibility/)。
* 内置的命令行客户端功能。
* HTTP/1.1 [和 HTTP/2 支持](https://www.python-httpx.org/http2/)。
* 标准同步接口，也支持 [异步](https://www.python-httpx.org/async/)。
* 能够直接向 [WSGI 应用发送请求](https://www.python-httpx.org/advanced/#calling-into-python-web-apps) 或向 [ASGI 应用发送请求](https://www.python-httpx.org/async/#calling-into-python-web-apps)。
* 每一处严格的超时控制。
* 完整的类型注解。
* 100% 测试。
加上这些应该具备的标准功能...
* 国际化域名与 URL
* Keep-Alive & 连接池
* Cookie 持久性会话
* 浏览器风格的 SSL 验证
* 基础或摘要身份验证
* 优雅的键值 Cookies
* 自动解压缩
* 内容自动解码
* Unicode 响应正文
* 分段文件上传
* HTTP(S)代理支持
* 可配置的连接超时
* 流式下载
* .netrc 支持
* 分块请求
## 安装
使用 pip 安装：
```shell
$ pip install httpx
```
或者，安装可选的 HTTP/2 支持：
```shell
$ pip install httpx[http2]
```
HTTPX 要求 Python 3.8+ 版本。
## 文档
项目文档现已就绪，请访问 [https://www.python-httpx.org/](https://www.python-httpx.org/) 来阅读。
要浏览所有基础知识，请访问 [快速开始](https://www.python-httpx.org/quickstart/)。
更高级的主题，可参阅 [高级用法](https://www.python-httpx.org/advanced/) 章节, [异步支持](https://www.python-httpx.org/async/) 或者 [HTTP/2](https://www.python-httpx.org/http2/) 章节。
[Developer Interface](https://www.python-httpx.org/api/) 提供了全面的 API 参考。
要了解与 HTTPX 集成的工具, 请访问 [第三方包](https://www.python-httpx.org/third_party_packages/)。
## 贡献
如果您想对本项目做出贡献，请访问 [贡献者指南](https://www.python-httpx.org/contributing/) 来了解如何开始。
## 依赖
HTTPX 项目依赖于这些优秀的库：
* `httpcore` - `httpx` 基础传输接口实现。
* `h11` - HTTP/1.1 支持。
* `certifi` - SSL 证书。
* `idna` - 国际化域名支持。
* `sniffio` - 异步库自动检测。
以及这些可选的安装：
* `h2` - HTTP/2 支持。 *(可选的，通过 `httpx[http2]`)*
* `socksio` - SOCKS 代理支持。 *(可选的， 通过 `httpx[socks]`)*
* `rich` - 丰富的终端支持。 *(可选的，通过 `httpx[cli]`)*
* `click` - 命令行客户端支持。 *(可选的，通过 `httpx[cli]`)*
* `brotli` 或者 `brotlicffi` - 对 “brotli” 压缩响应的解码。*(可选的，通过 `httpx[brotli]`)*
这项工作的大量功劳都归功于参考了 `requests` 所遵循的 API 结构，以及 `urllib3` 中众多围绕底层网络细节的设计灵感。
---
HTTPX 使用 BSD 开源协议 code。
精心设计和制作。
— 🦋 —
httpx-0.26.0/docs/ 0000775 0000000 0000000 00000000000 14540543546 0013710 5 ustar 00root root 0000000 0000000 httpx-0.26.0/docs/CNAME 0000664 0000000 0000000 00000000025 14540543546 0014453 0 ustar 00root root 0000000 0000000 www.python-httpx.org
httpx-0.26.0/docs/advanced.md 0000664 0000000 0000000 00000132137 14540543546 0016006 0 ustar 00root root 0000000 0000000 # Advanced Usage
## Client Instances
!!! hint
If you are coming from Requests, `httpx.Client()` is what you can use instead of `requests.Session()`.
### Why use a Client?
!!! note "TL;DR"
If you do anything more than experimentation, one-off scripts, or prototypes, then you should use a `Client` instance.
#### More efficient usage of network resources
When you make requests using the top-level API as documented in the [Quickstart](quickstart.md) guide, HTTPX has to establish a new connection _for every single request_ (connections are not reused). As the number of requests to a host increases, this quickly becomes inefficient.
On the other hand, a `Client` instance uses [HTTP connection pooling](https://en.wikipedia.org/wiki/HTTP_persistent_connection). This means that when you make several requests to the same host, the `Client` will reuse the underlying TCP connection, instead of recreating one for every single request.
This can bring **significant performance improvements** compared to using the top-level API, including:
- Reduced latency across requests (no handshaking).
- Reduced CPU usage and round-trips.
- Reduced network congestion.
#### Extra features
`Client` instances also support features that aren't available at the top-level API, such as:
- Cookie persistence across requests.
- Applying configuration across all outgoing requests.
- Sending requests through HTTP proxies.
- Using [HTTP/2](http2.md).
The other sections on this page go into further detail about what you can do with a `Client` instance.
### Usage
The recommended way to use a `Client` is as a context manager. This will ensure that connections are properly cleaned up when leaving the `with` block:
```python
with httpx.Client() as client:
...
```
Alternatively, you can explicitly close the connection pool without block-usage using `.close()`:
```python
client = httpx.Client()
try:
...
finally:
client.close()
```
### Making requests
Once you have a `Client`, you can send requests using `.get()`, `.post()`, etc. For example:
```pycon
>>> with httpx.Client() as client:
... r = client.get('https://example.com')
...
>>> r
```
These methods accept the same arguments as `httpx.get()`, `httpx.post()`, etc. This means that all features documented in the [Quickstart](quickstart.md) guide are also available at the client level.
For example, to send a request with custom headers:
```pycon
>>> with httpx.Client() as client:
... headers = {'X-Custom': 'value'}
... r = client.get('https://example.com', headers=headers)
...
>>> r.request.headers['X-Custom']
'value'
```
### Sharing configuration across requests
Clients allow you to apply configuration to all outgoing requests by passing parameters to the `Client` constructor.
For example, to apply a set of custom headers _on every request_:
```pycon
>>> url = 'http://httpbin.org/headers'
>>> headers = {'user-agent': 'my-app/0.0.1'}
>>> with httpx.Client(headers=headers) as client:
... r = client.get(url)
...
>>> r.json()['headers']['User-Agent']
'my-app/0.0.1'
```
### Merging of configuration
When a configuration option is provided at both the client-level and request-level, one of two things can happen:
- For headers, query parameters and cookies, the values are combined together. For example:
```pycon
>>> headers = {'X-Auth': 'from-client'}
>>> params = {'client_id': 'client1'}
>>> with httpx.Client(headers=headers, params=params) as client:
... headers = {'X-Custom': 'from-request'}
... params = {'request_id': 'request1'}
... r = client.get('https://example.com', headers=headers, params=params)
...
>>> r.request.url
URL('https://example.com?client_id=client1&request_id=request1')
>>> r.request.headers['X-Auth']
'from-client'
>>> r.request.headers['X-Custom']
'from-request'
```
- For all other parameters, the request-level value takes priority. For example:
```pycon
>>> with httpx.Client(auth=('tom', 'mot123')) as client:
... r = client.get('https://example.com', auth=('alice', 'ecila123'))
...
>>> _, _, auth = r.request.headers['Authorization'].partition(' ')
>>> import base64
>>> base64.b64decode(auth)
b'alice:ecila123'
```
If you need finer-grained control on the merging of client-level and request-level parameters, see [Request instances](#request-instances).
### Other Client-only configuration options
Additionally, `Client` accepts some configuration options that aren't available at the request level.
For example, `base_url` allows you to prepend an URL to all outgoing requests:
```pycon
>>> with httpx.Client(base_url='http://httpbin.org') as client:
... r = client.get('/headers')
...
>>> r.request.url
URL('http://httpbin.org/headers')
```
For a list of all available client parameters, see the [`Client`](api.md#client) API reference.
---
## Character set encodings and auto-detection
When accessing `response.text`, we need to decode the response bytes into a unicode text representation.
By default `httpx` will use `"charset"` information included in the response `Content-Type` header to determine how the response bytes should be decoded into text.
In cases where no charset information is included on the response, the default behaviour is to assume "utf-8" encoding, which is by far the most widely used text encoding on the internet.
### Using the default encoding
To understand this better let's start by looking at the default behaviour for text decoding...
```python
import httpx
# Instantiate a client with the default configuration.
client = httpx.Client()
# Using the client...
response = client.get(...)
print(response.encoding) # This will either print the charset given in
# the Content-Type charset, or else "utf-8".
print(response.text) # The text will either be decoded with the Content-Type
# charset, or using "utf-8".
```
This is normally absolutely fine. Most servers will respond with a properly formatted Content-Type header, including a charset encoding. And in most cases where no charset encoding is included, UTF-8 is very likely to be used, since it is so widely adopted.
### Using an explicit encoding
In some cases we might be making requests to a site where no character set information is being set explicitly by the server, but we know what the encoding is. In this case it's best to set the default encoding explicitly on the client.
```python
import httpx
# Instantiate a client with a Japanese character set as the default encoding.
client = httpx.Client(default_encoding="shift-jis")
# Using the client...
response = client.get(...)
print(response.encoding) # This will either print the charset given in
# the Content-Type charset, or else "shift-jis".
print(response.text) # The text will either be decoded with the Content-Type
# charset, or using "shift-jis".
```
### Using character set auto-detection
In cases where the server is not reliably including character set information, and where we don't know what encoding is being used, we can enable auto-detection to make a best-guess attempt when decoding from bytes to text.
To use auto-detection you need to set the `default_encoding` argument to a callable instead of a string. This callable should be a function which takes the input bytes as an argument and returns the character set to use for decoding those bytes to text.
There are two widely used Python packages which both handle this functionality:
* [`chardet`](https://chardet.readthedocs.io/) - This is a well established package, and is a port of [the auto-detection code in Mozilla](https://www-archive.mozilla.org/projects/intl/chardet.html).
* [`charset-normalizer`](https://charset-normalizer.readthedocs.io/) - A newer package, motivated by `chardet`, with a different approach.
Let's take a look at installing autodetection using one of these packages...
```shell
$ pip install httpx
$ pip install chardet
```
Once `chardet` is installed, we can configure a client to use character-set autodetection.
```python
import httpx
import chardet
def autodetect(content):
return chardet.detect(content).get("encoding")
# Using a client with character-set autodetection enabled.
client = httpx.Client(default_encoding=autodetect)
response = client.get(...)
print(response.encoding) # This will either print the charset given in
# the Content-Type charset, or else the auto-detected
# character set.
print(response.text)
```
---
## Calling into Python Web Apps
You can configure an `httpx` client to call directly into a Python web application using the WSGI protocol.
This is particularly useful for two main use-cases:
* Using `httpx` as a client inside test cases.
* Mocking out external services during tests or in dev/staging environments.
Here's an example of integrating against a Flask application:
```python
from flask import Flask
import httpx
app = Flask(__name__)
@app.route("/")
def hello():
return "Hello World!"
with httpx.Client(app=app, base_url="http://testserver") as client:
r = client.get("/")
assert r.status_code == 200
assert r.text == "Hello World!"
```
For some more complex cases you might need to customize the WSGI transport. This allows you to:
* Inspect 500 error responses rather than raise exceptions by setting `raise_app_exceptions=False`.
* Mount the WSGI application at a subpath by setting `script_name` (WSGI).
* Use a given client address for requests by setting `remote_addr` (WSGI).
For example:
```python
# Instantiate a client that makes WSGI requests with a client IP of "1.2.3.4".
transport = httpx.WSGITransport(app=app, remote_addr="1.2.3.4")
with httpx.Client(transport=transport, base_url="http://testserver") as client:
...
```
## Request instances
For maximum control on what gets sent over the wire, HTTPX supports building explicit [`Request`](api.md#request) instances:
```python
request = httpx.Request("GET", "https://example.com")
```
To dispatch a `Request` instance across to the network, create a [`Client` instance](#client-instances) and use `.send()`:
```python
with httpx.Client() as client:
response = client.send(request)
...
```
If you need to mix client-level and request-level options in a way that is not supported by the default [Merging of parameters](#merging-of-parameters), you can use `.build_request()` and then make arbitrary modifications to the `Request` instance. For example:
```python
headers = {"X-Api-Key": "...", "X-Client-ID": "ABC123"}
with httpx.Client(headers=headers) as client:
request = client.build_request("GET", "https://api.example.com")
print(request.headers["X-Client-ID"]) # "ABC123"
# Don't send the API key for this particular request.
del request.headers["X-Api-Key"]
response = client.send(request)
...
```
## Event Hooks
HTTPX allows you to register "event hooks" with the client, that are called
every time a particular type of event takes place.
There are currently two event hooks:
* `request` - Called after a request is fully prepared, but before it is sent to the network. Passed the `request` instance.
* `response` - Called after the response has been fetched from the network, but before it is returned to the caller. Passed the `response` instance.
These allow you to install client-wide functionality such as logging, monitoring or tracing.
```python
def log_request(request):
print(f"Request event hook: {request.method} {request.url} - Waiting for response")
def log_response(response):
request = response.request
print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")
client = httpx.Client(event_hooks={'request': [log_request], 'response': [log_response]})
```
You can also use these hooks to install response processing code, such as this
example, which creates a client instance that always raises `httpx.HTTPStatusError`
on 4xx and 5xx responses.
```python
def raise_on_4xx_5xx(response):
response.raise_for_status()
client = httpx.Client(event_hooks={'response': [raise_on_4xx_5xx]})
```
!!! note
Response event hooks are called before determining if the response body
should be read or not.
If you need access to the response body inside an event hook, you'll
need to call `response.read()`, or for AsyncClients, `response.aread()`.
The hooks are also allowed to modify `request` and `response` objects.
```python
def add_timestamp(request):
request.headers['x-request-timestamp'] = datetime.now(tz=datetime.utc).isoformat()
client = httpx.Client(event_hooks={'request': [add_timestamp]})
```
Event hooks must always be set as a **list of callables**, and you may register
multiple event hooks for each type of event.
As well as being able to set event hooks on instantiating the client, there
is also an `.event_hooks` property, that allows you to inspect and modify
the installed hooks.
```python
client = httpx.Client()
client.event_hooks['request'] = [log_request]
client.event_hooks['response'] = [log_response, raise_on_4xx_5xx]
```
!!! note
If you are using HTTPX's async support, then you need to be aware that
hooks registered with `httpx.AsyncClient` MUST be async functions,
rather than plain functions.
## Monitoring download progress
If you need to monitor download progress of large responses, you can use response streaming and inspect the `response.num_bytes_downloaded` property.
This interface is required for properly determining download progress, because the total number of bytes returned by `response.content` or `response.iter_content()` will not always correspond with the raw content length of the response if HTTP response compression is being used.
For example, showing a progress bar using the [`tqdm`](https://github.com/tqdm/tqdm) library while a response is being downloaded could be done like this…
```python
import tempfile
import httpx
from tqdm import tqdm
with tempfile.NamedTemporaryFile() as download_file:
url = "https://speed.hetzner.de/100MB.bin"
with httpx.stream("GET", url) as response:
total = int(response.headers["Content-Length"])
with tqdm(total=total, unit_scale=True, unit_divisor=1024, unit="B") as progress:
num_bytes_downloaded = response.num_bytes_downloaded
for chunk in response.iter_bytes():
download_file.write(chunk)
progress.update(response.num_bytes_downloaded - num_bytes_downloaded)
num_bytes_downloaded = response.num_bytes_downloaded
```
Or an alternate example, this time using the [`rich`](https://github.com/willmcgugan/rich) library…
```python
import tempfile
import httpx
import rich.progress
with tempfile.NamedTemporaryFile() as download_file:
url = "https://speed.hetzner.de/100MB.bin"
with httpx.stream("GET", url) as response:
total = int(response.headers["Content-Length"])
with rich.progress.Progress(
"[progress.percentage]{task.percentage:>3.0f}%",
rich.progress.BarColumn(bar_width=None),
rich.progress.DownloadColumn(),
rich.progress.TransferSpeedColumn(),
) as progress:
download_task = progress.add_task("Download", total=total)
for chunk in response.iter_bytes():
download_file.write(chunk)
progress.update(download_task, completed=response.num_bytes_downloaded)
```
## Monitoring upload progress
If you need to monitor upload progress of large responses, you can use request content generator streaming.
For example, showing a progress bar using the [`tqdm`](https://github.com/tqdm/tqdm) library.
```python
import io
import random
import httpx
from tqdm import tqdm
def gen():
"""
this is a complete example with generated random bytes.
you can replace `io.BytesIO` with real file object.
"""
total = 32 * 1024 * 1024 # 32m
with tqdm(ascii=True, unit_scale=True, unit='B', unit_divisor=1024, total=total) as bar:
with io.BytesIO(random.randbytes(total)) as f:
while data := f.read(1024):
yield data
bar.update(len(data))
httpx.post("https://httpbin.org/post", content=gen())
```
## .netrc Support
HTTPX can be configured to use [a `.netrc` config file](https://everything.curl.dev/usingcurl/netrc) for authentication.
The `.netrc` config file allows authentication credentials to be associated with specified hosts. When a request is made to a host that is found in the netrc file, the username and password will be included using HTTP basic auth.
Example `.netrc` file:
```
machine example.org
login example-username
password example-password
machine python-httpx.org
login other-username
password other-password
```
Some examples of configuring `.netrc` authentication with `httpx`.
Use the default `.netrc` file in the users home directory:
```pycon
>>> auth = httpx.NetRCAuth()
>>> client = httpx.Client(auth=auth)
```
Use an explicit path to a `.netrc` file:
```pycon
>>> auth = httpx.NetRCAuth(file="/path/to/.netrc")
>>> client = httpx.Client(auth=auth)
```
Use the `NETRC` environment variable to configure a path to the `.netrc` file,
or fallback to the default.
```pycon
>>> auth = httpx.NetRCAuth(file=os.environ.get("NETRC"))
>>> client = httpx.Client(auth=auth)
```
The `NetRCAuth()` class uses [the `netrc.netrc()` function from the Python standard library](https://docs.python.org/3/library/netrc.html). See the documentation there for more details on exceptions that may be raised if the netrc file is not found, or cannot be parsed.
## HTTP Proxying
HTTPX supports setting up [HTTP proxies](https://en.wikipedia.org/wiki/Proxy_server#Web_proxy_servers) via the `proxy` parameter to be passed on client initialization or top-level API functions like `httpx.get(..., proxy=...)`.
Diagram of how a proxy works (source: Wikipedia). The left hand side "Internet" blob may be your HTTPX client requesting example.com through a proxy.
### Example
To route all traffic (HTTP and HTTPS) to a proxy located at `http://localhost:8030`, pass the proxy URL to the client...
```python
with httpx.Client(proxy="http://localhost:8030") as client:
...
```
For more advanced use cases, pass a mounts `dict`. For example, to route HTTP and HTTPS requests to 2 different proxies, respectively located at `http://localhost:8030`, and `http://localhost:8031`, pass a `dict` of proxy URLs:
```python
proxy_mounts = {
"http://": httpx.HTTPTransport(proxy="http://localhost:8030"),
"https://": httpx.HTTPTransport(proxy="http://localhost:8031"),
}
with httpx.Client(mounts=proxy_mounts) as client:
...
```
For detailed information about proxy routing, see the [Routing](#routing) section.
!!! tip "Gotcha"
In most cases, the proxy URL for the `https://` key _should_ use the `http://` scheme (that's not a typo!).
This is because HTTP proxying requires initiating a connection with the proxy server. While it's possible that your proxy supports doing it via HTTPS, most proxies only support doing it via HTTP.
For more information, see [FORWARD vs TUNNEL](#forward-vs-tunnel).
### Authentication
Proxy credentials can be passed as the `userinfo` section of the proxy URL. For example:
```python
with httpx.Client(proxy="http://username:password@localhost:8030") as client:
...
```
### Proxy mechanisms
!!! note
This section describes **advanced** proxy concepts and functionality.
#### FORWARD vs TUNNEL
In general, the flow for making an HTTP request through a proxy is as follows:
1. The client connects to the proxy (initial connection request).
2. The proxy transfers data to the server on your behalf.
How exactly step 2/ is performed depends on which of two proxying mechanisms is used:
* **Forwarding**: the proxy makes the request for you, and sends back the response it obtained from the server.
* **Tunnelling**: the proxy establishes a TCP connection to the server on your behalf, and the client reuses this connection to send the request and receive the response. This is known as an [HTTP Tunnel](https://en.wikipedia.org/wiki/HTTP_tunnel). This mechanism is how you can access websites that use HTTPS from an HTTP proxy (the client "upgrades" the connection to HTTPS by performing the TLS handshake with the server over the TCP connection provided by the proxy).
### Troubleshooting proxies
If you encounter issues when setting up proxies, please refer to our [Troubleshooting guide](troubleshooting.md#proxies).
## SOCKS
In addition to HTTP proxies, `httpcore` also supports proxies using the SOCKS protocol.
This is an optional feature that requires an additional third-party library be installed before use.
You can install SOCKS support using `pip`:
```shell
$ pip install httpx[socks]
```
You can now configure a client to make requests via a proxy using the SOCKS protocol:
```python
httpx.Client(proxy='socks5://user:pass@host:port')
```
## Timeout Configuration
HTTPX is careful to enforce timeouts everywhere by default.
The default behavior is to raise a `TimeoutException` after 5 seconds of
network inactivity.
### Setting and disabling timeouts
You can set timeouts for an individual request:
```python
# Using the top-level API:
httpx.get('http://example.com/api/v1/example', timeout=10.0)
# Using a client instance:
with httpx.Client() as client:
client.get("http://example.com/api/v1/example", timeout=10.0)
```
Or disable timeouts for an individual request:
```python
# Using the top-level API:
httpx.get('http://example.com/api/v1/example', timeout=None)
# Using a client instance:
with httpx.Client() as client:
client.get("http://example.com/api/v1/example", timeout=None)
```
### Setting a default timeout on a client
You can set a timeout on a client instance, which results in the given
`timeout` being used as the default for requests made with this client:
```python
client = httpx.Client() # Use a default 5s timeout everywhere.
client = httpx.Client(timeout=10.0) # Use a default 10s timeout everywhere.
client = httpx.Client(timeout=None) # Disable all timeouts by default.
```
### Fine tuning the configuration
HTTPX also allows you to specify the timeout behavior in more fine grained detail.
There are four different types of timeouts that may occur. These are **connect**,
**read**, **write**, and **pool** timeouts.
* The **connect** timeout specifies the maximum amount of time to wait until
a socket connection to the requested host is established. If HTTPX is unable to connect
within this time frame, a `ConnectTimeout` exception is raised.
* The **read** timeout specifies the maximum duration to wait for a chunk of
data to be received (for example, a chunk of the response body). If HTTPX is
unable to receive data within this time frame, a `ReadTimeout` exception is raised.
* The **write** timeout specifies the maximum duration to wait for a chunk of
data to be sent (for example, a chunk of the request body). If HTTPX is unable
to send data within this time frame, a `WriteTimeout` exception is raised.
* The **pool** timeout specifies the maximum duration to wait for acquiring
a connection from the connection pool. If HTTPX is unable to acquire a connection
within this time frame, a `PoolTimeout` exception is raised. A related
configuration here is the maximum number of allowable connections in the
connection pool, which is configured by the `limits` argument.
You can configure the timeout behavior for any of these values...
```python
# A client with a 60s timeout for connecting, and a 10s timeout elsewhere.
timeout = httpx.Timeout(10.0, connect=60.0)
client = httpx.Client(timeout=timeout)
response = client.get('http://example.com/')
```
## Pool limit configuration
You can control the connection pool size using the `limits` keyword
argument on the client. It takes instances of `httpx.Limits` which define:
- `max_keepalive_connections`, number of allowable keep-alive connections, or `None` to always
allow. (Defaults 20)
- `max_connections`, maximum number of allowable connections, or `None` for no limits.
(Default 100)
- `keepalive_expiry`, time limit on idle keep-alive connections in seconds, or `None` for no limits. (Default 5)
```python
limits = httpx.Limits(max_keepalive_connections=5, max_connections=10)
client = httpx.Client(limits=limits)
```
## Multipart file encoding
As mentioned in the [quickstart](quickstart.md#sending-multipart-file-uploads)
multipart file encoding is available by passing a dictionary with the
name of the payloads as keys and either tuple of elements or a file-like object or a string as values.
```pycon
>>> files = {'upload-file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel')}
>>> r = httpx.post("https://httpbin.org/post", files=files)
>>> print(r.text)
{
...
"files": {
"upload-file": "<... binary content ...>"
},
...
}
```
More specifically, if a tuple is used as a value, it must have between 2 and 3 elements:
- The first element is an optional file name which can be set to `None`.
- The second element may be a file-like object or a string which will be automatically
encoded in UTF-8.
- An optional third element can be used to specify the
[MIME type](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_Types)
of the file being uploaded. If not specified HTTPX will attempt to guess the MIME type based
on the file name, with unknown file extensions defaulting to "application/octet-stream".
If the file name is explicitly set to `None` then HTTPX will not include a content-type
MIME header field.
```pycon
>>> files = {'upload-file': (None, 'text content', 'text/plain')}
>>> r = httpx.post("https://httpbin.org/post", files=files)
>>> print(r.text)
{
...
"files": {},
"form": {
"upload-file": "text-content"
},
...
}
```
!!! tip
It is safe to upload large files this way. File uploads are streaming by default, meaning that only one chunk will be loaded into memory at a time.
Non-file data fields can be included in the multipart form using by passing them to `data=...`.
You can also send multiple files in one go with a multiple file field form.
To do that, pass a list of `(field, )` items instead of a dictionary, allowing you to pass multiple items with the same `field`.
For instance this request sends 2 files, `foo.png` and `bar.png` in one request on the `images` form field:
```pycon
>>> files = [('images', ('foo.png', open('foo.png', 'rb'), 'image/png')),
('images', ('bar.png', open('bar.png', 'rb'), 'image/png'))]
>>> r = httpx.post("https://httpbin.org/post", files=files)
```
## Customizing authentication
When issuing requests or instantiating a client, the `auth` argument can be used to pass an authentication scheme to use. The `auth` argument may be one of the following...
* A two-tuple of `username`/`password`, to be used with basic authentication.
* An instance of `httpx.BasicAuth()`, `httpx.DigestAuth()`, or `httpx.NetRCAuth()`.
* A callable, accepting a request and returning an authenticated request instance.
* An instance of subclasses of `httpx.Auth`.
The most involved of these is the last, which allows you to create authentication flows involving one or more requests. A subclass of `httpx.Auth` should implement `def auth_flow(request)`, and yield any requests that need to be made...
```python
class MyCustomAuth(httpx.Auth):
def __init__(self, token):
self.token = token
def auth_flow(self, request):
# Send the request, with a custom `X-Authentication` header.
request.headers['X-Authentication'] = self.token
yield request
```
If the auth flow requires more than one request, you can issue multiple yields, and obtain the response in each case...
```python
class MyCustomAuth(httpx.Auth):
def __init__(self, token):
self.token = token
def auth_flow(self, request):
response = yield request
if response.status_code == 401:
# If the server issues a 401 response then resend the request,
# with a custom `X-Authentication` header.
request.headers['X-Authentication'] = self.token
yield request
```
Custom authentication classes are designed to not perform any I/O, so that they may be used with both sync and async client instances. If you are implementing an authentication scheme that requires the request body, then you need to indicate this on the class using a `requires_request_body` property.
You will then be able to access `request.content` inside the `.auth_flow()` method.
```python
class MyCustomAuth(httpx.Auth):
requires_request_body = True
def __init__(self, token):
self.token = token
def auth_flow(self, request):
response = yield request
if response.status_code == 401:
# If the server issues a 401 response then resend the request,
# with a custom `X-Authentication` header.
request.headers['X-Authentication'] = self.sign_request(...)
yield request
def sign_request(self, request):
# Create a request signature, based on `request.method`, `request.url`,
# `request.headers`, and `request.content`.
...
```
Similarly, if you are implementing a scheme that requires access to the response body, then use the `requires_response_body` property. You will then be able to access response body properties and methods such as `response.content`, `response.text`, `response.json()`, etc.
```python
class MyCustomAuth(httpx.Auth):
requires_response_body = True
def __init__(self, access_token, refresh_token, refresh_url):
self.access_token = access_token
self.refresh_token = refresh_token
self.refresh_url = refresh_url
def auth_flow(self, request):
request.headers["X-Authentication"] = self.access_token
response = yield request
if response.status_code == 401:
# If the server issues a 401 response, then issue a request to
# refresh tokens, and resend the request.
refresh_response = yield self.build_refresh_request()
self.update_tokens(refresh_response)
request.headers["X-Authentication"] = self.access_token
yield request
def build_refresh_request(self):
# Return an `httpx.Request` for refreshing tokens.
...
def update_tokens(self, response):
# Update the `.access_token` and `.refresh_token` tokens
# based on a refresh response.
data = response.json()
...
```
If you _do_ need to perform I/O other than HTTP requests, such as accessing a disk-based cache, or you need to use concurrency primitives, such as locks, then you should override `.sync_auth_flow()` and `.async_auth_flow()` (instead of `.auth_flow()`). The former will be used by `httpx.Client`, while the latter will be used by `httpx.AsyncClient`.
```python
import asyncio
import threading
import httpx
class MyCustomAuth(httpx.Auth):
def __init__(self):
self._sync_lock = threading.RLock()
self._async_lock = asyncio.Lock()
def sync_get_token(self):
with self._sync_lock:
...
def sync_auth_flow(self, request):
token = self.sync_get_token()
request.headers["Authorization"] = f"Token {token}"
yield request
async def async_get_token(self):
async with self._async_lock:
...
async def async_auth_flow(self, request):
token = await self.async_get_token()
request.headers["Authorization"] = f"Token {token}"
yield request
```
If you only want to support one of the two methods, then you should still override it, but raise an explicit `RuntimeError`.
```python
import httpx
import sync_only_library
class MyCustomAuth(httpx.Auth):
def sync_auth_flow(self, request):
token = sync_only_library.get_token(...)
request.headers["Authorization"] = f"Token {token}"
yield request
async def async_auth_flow(self, request):
raise RuntimeError("Cannot use a sync authentication class with httpx.AsyncClient")
```
## SSL certificates
When making a request over HTTPS, HTTPX needs to verify the identity of the requested host. To do this, it uses a bundle of SSL certificates (a.k.a. CA bundle) delivered by a trusted certificate authority (CA).
### Changing the verification defaults
By default, HTTPX uses the CA bundle provided by [Certifi](https://pypi.org/project/certifi/). This is what you want in most cases, even though some advanced situations may require you to use a different set of certificates.
If you'd like to use a custom CA bundle, you can use the `verify` parameter.
```python
import httpx
r = httpx.get("https://example.org", verify="path/to/client.pem")
```
Alternatively, you can pass a standard library `ssl.SSLContext`.
```pycon
>>> import ssl
>>> import httpx
>>> context = ssl.create_default_context()
>>> context.load_verify_locations(cafile="/tmp/client.pem")
>>> httpx.get('https://example.org', verify=context)
```
We also include a helper function for creating properly configured `SSLContext` instances.
```pycon
>>> context = httpx.create_ssl_context()
```
The `create_ssl_context` function accepts the same set of SSL configuration arguments
(`trust_env`, `verify`, `cert` and `http2` arguments)
as `httpx.Client` or `httpx.AsyncClient`
```pycon
>>> import httpx
>>> context = httpx.create_ssl_context(verify="/tmp/client.pem")
>>> httpx.get('https://example.org', verify=context)
```
Or you can also disable the SSL verification entirely, which is _not_ recommended.
```python
import httpx
r = httpx.get("https://example.org", verify=False)
```
### SSL configuration on client instances
If you're using a `Client()` instance, then you should pass any SSL settings when instantiating the client.
```python
client = httpx.Client(verify=False)
```
The `client.get(...)` method and other request methods *do not* support changing the SSL settings on a per-request basis. If you need different SSL settings in different cases you should use more that one client instance, with different settings on each. Each client will then be using an isolated connection pool with a specific fixed SSL configuration on all connections within that pool.
### Client Side Certificates
You can also specify a local cert to use as a client-side certificate, either a path to an SSL certificate file, or two-tuple of (certificate file, key file), or a three-tuple of (certificate file, key file, password)
```python
import httpx
r = httpx.get("https://example.org", cert="path/to/client.pem")
```
Alternatively,
```pycon
>>> cert = ("path/to/client.pem", "path/to/client.key")
>>> httpx.get("https://example.org", cert=cert)
```
or
```pycon
>>> cert = ("path/to/client.pem", "path/to/client.key", "password")
>>> httpx.get("https://example.org", cert=cert)
```
### Making HTTPS requests to a local server
When making requests to local servers, such as a development server running on `localhost`, you will typically be using unencrypted HTTP connections.
If you do need to make HTTPS connections to a local server, for example to test an HTTPS-only service, you will need to create and use your own certificates. Here's one way to do it:
1. Use [trustme](https://github.com/python-trio/trustme) to generate a pair of server key/cert files, and a client cert file.
1. Pass the server key/cert files when starting your local server. (This depends on the particular web server you're using. For example, [Uvicorn](https://www.uvicorn.org) provides the `--ssl-keyfile` and `--ssl-certfile` options.)
1. Tell HTTPX to use the certificates stored in `client.pem`:
```pycon
>>> import httpx
>>> r = httpx.get("https://localhost:8000", verify="/tmp/client.pem")
>>> r
Response <200 OK>
```
## Custom Transports
HTTPX's `Client` also accepts a `transport` argument. This argument allows you
to provide a custom Transport object that will be used to perform the actual
sending of the requests.
### Usage
For some advanced configuration you might need to instantiate a transport
class directly, and pass it to the client instance. One example is the
`local_address` configuration which is only available via this low-level API.
```pycon
>>> import httpx
>>> transport = httpx.HTTPTransport(local_address="0.0.0.0")
>>> client = httpx.Client(transport=transport)
```
Connection retries are also available via this interface. Requests will be retried the given number of times in case an `httpx.ConnectError` or an `httpx.ConnectTimeout` occurs, allowing smoother operation under flaky networks. If you need other forms of retry behaviors, such as handling read/write errors or reacting to `503 Service Unavailable`, consider general-purpose tools such as [tenacity](https://github.com/jd/tenacity).
```pycon
>>> import httpx
>>> transport = httpx.HTTPTransport(retries=1)
>>> client = httpx.Client(transport=transport)
```
Similarly, instantiating a transport directly provides a `uds` option for
connecting via a Unix Domain Socket that is only available via this low-level API:
```pycon
>>> import httpx
>>> # Connect to the Docker API via a Unix Socket.
>>> transport = httpx.HTTPTransport(uds="/var/run/docker.sock")
>>> client = httpx.Client(transport=transport)
>>> response = client.get("http://docker/info")
>>> response.json()
{"ID": "...", "Containers": 4, "Images": 74, ...}
```
### urllib3 transport
This [public gist](https://gist.github.com/florimondmanca/d56764d78d748eb9f73165da388e546e) provides a transport that uses the excellent [`urllib3` library](https://urllib3.readthedocs.io/en/latest/), and can be used with the sync `Client`...
```pycon
>>> import httpx
>>> from urllib3_transport import URLLib3Transport
>>> client = httpx.Client(transport=URLLib3Transport())
>>> client.get("https://example.org")
```
### Writing custom transports
A transport instance must implement the low-level Transport API, which deals
with sending a single request, and returning a response. You should either
subclass `httpx.BaseTransport` to implement a transport to use with `Client`,
or subclass `httpx.AsyncBaseTransport` to implement a transport to
use with `AsyncClient`.
At the layer of the transport API we're using the familiar `Request` and
`Response` models.
See the `handle_request` and `handle_async_request` docstrings for more details
on the specifics of the Transport API.
A complete example of a custom transport implementation would be:
```python
import json
import httpx
class HelloWorldTransport(httpx.BaseTransport):
"""
A mock transport that always returns a JSON "Hello, world!" response.
"""
def handle_request(self, request):
message = {"text": "Hello, world!"}
content = json.dumps(message).encode("utf-8")
stream = httpx.ByteStream(content)
headers = [(b"content-type", b"application/json")]
return httpx.Response(200, headers=headers, stream=stream)
```
Which we can use in the same way:
```pycon
>>> import httpx
>>> client = httpx.Client(transport=HelloWorldTransport())
>>> response = client.get("https://example.org/")
>>> response.json()
{"text": "Hello, world!"}
```
### Mock transports
During testing it can often be useful to be able to mock out a transport,
and return pre-determined responses, rather than making actual network requests.
The `httpx.MockTransport` class accepts a handler function, which can be used
to map requests onto pre-determined responses:
```python
def handler(request):
return httpx.Response(200, json={"text": "Hello, world!"})
# Switch to a mock transport, if the TESTING environment variable is set.
if os.environ.get('TESTING', '').upper() == "TRUE":
transport = httpx.MockTransport(handler)
else:
transport = httpx.HTTPTransport()
client = httpx.Client(transport=transport)
```
For more advanced use-cases you might want to take a look at either [the third-party
mocking library, RESPX](https://lundberg.github.io/respx/), or the [pytest-httpx library](https://github.com/Colin-b/pytest_httpx).
### Mounting transports
You can also mount transports against given schemes or domains, to control
which transport an outgoing request should be routed via, with [the same style
used for specifying proxy routing](#routing).
```python
import httpx
class HTTPSRedirectTransport(httpx.BaseTransport):
"""
A transport that always redirects to HTTPS.
"""
def handle_request(self, method, url, headers, stream, extensions):
scheme, host, port, path = url
if port is None:
location = b"https://%s%s" % (host, path)
else:
location = b"https://%s:%d%s" % (host, port, path)
stream = httpx.ByteStream(b"")
headers = [(b"location", location)]
extensions = {}
return 303, headers, stream, extensions
# A client where any `http` requests are always redirected to `https`
mounts = {'http://': HTTPSRedirectTransport()}
client = httpx.Client(mounts=mounts)
```
A couple of other sketches of how you might take advantage of mounted transports...
Disabling HTTP/2 on a single given domain...
```python
mounts = {
"all://": httpx.HTTPTransport(http2=True),
"all://*example.org": httpx.HTTPTransport()
}
client = httpx.Client(mounts=mounts)
```
Mocking requests to a given domain:
```python
# All requests to "example.org" should be mocked out.
# Other requests occur as usual.
def handler(request):
return httpx.Response(200, json={"text": "Hello, World!"})
mounts = {"all://example.org": httpx.MockTransport(handler)}
client = httpx.Client(mounts=mounts)
```
Adding support for custom schemes:
```python
# Support URLs like "file:///Users/sylvia_green/websites/new_client/index.html"
mounts = {"file://": FileSystemTransport()}
client = httpx.Client(mounts=mounts)
```
### Routing
HTTPX provides a powerful mechanism for routing requests, allowing you to write complex rules that specify which transport should be used for each request.
The `mounts` dictionary maps URL patterns to HTTP transports. HTTPX matches requested URLs against URL patterns to decide which transport should be used, if any. Matching is done from most specific URL patterns (e.g. `https://:`) to least specific ones (e.g. `https://`).
HTTPX supports routing requests based on **scheme**, **domain**, **port**, or a combination of these.
#### Wildcard routing
Route everything through a transport...
```python
mounts = {
"all://": httpx.HTTPTransport(proxy="http://localhost:8030"),
}
```
#### Scheme routing
Route HTTP requests through one transport, and HTTPS requests through another...
```python
mounts = {
"http://": httpx.HTTPTransport(proxy="http://localhost:8030"),
"https://": httpx.HTTPTransport(proxy="http://localhost:8031"),
}
```
#### Domain routing
Proxy all requests on domain "example.com", let other requests pass through...
```python
mounts = {
"all://example.com": httpx.HTTPTransport(proxy="http://localhost:8030"),
}
```
Proxy HTTP requests on domain "example.com", let HTTPS and other requests pass through...
```python
mounts = {
"http://example.com": httpx.HTTPTransport(proxy="http://localhost:8030"),
}
```
Proxy all requests to "example.com" and its subdomains, let other requests pass through...
```python
mounts = {
"all://*example.com": httpx.HTTPTransport(proxy="http://localhost:8030"),
}
```
Proxy all requests to strict subdomains of "example.com", let "example.com" and other requests pass through...
```python
mounts = {
"all://*.example.com": httpx.HTTPTransport(proxy="http://localhost:8030"),
}
```
#### Port routing
Proxy HTTPS requests on port 1234 to "example.com"...
```python
mounts = {
"https://example.com:1234": httpx.HTTPTransport(proxy="http://localhost:8030"),
}
```
Proxy all requests on port 1234...
```python
mounts = {
"all://*:1234": httpx.HTTPTransport(proxy="http://localhost:8030"),
}
```
#### No-proxy support
It is also possible to define requests that _shouldn't_ be routed through the transport.
To do so, pass `None` as the proxy URL. For example...
```python
mounts = {
# Route requests through a proxy by default...
"all://": httpx.HTTPTransport(proxy="http://localhost:8031"),
# Except those for "example.com".
"all://example.com": None,
}
```
#### Complex configuration example
You can combine the routing features outlined above to build complex proxy routing configurations. For example...
```python
mounts = {
# Route all traffic through a proxy by default...
"all://": httpx.HTTPTransport(proxy="http://localhost:8030"),
# But don't use proxies for HTTPS requests to "domain.io"...
"https://domain.io": None,
# And use another proxy for requests to "example.com" and its subdomains...
"all://*example.com": httpx.HTTPTransport(proxy="http://localhost:8031"),
# And yet another proxy if HTTP is used,
# and the "internal" subdomain on port 5550 is requested...
"http://internal.example.com:5550": httpx.HTTPTransport(proxy="http://localhost:8032"),
}
```
#### Environment variables
There are also environment variables that can be used to control the dictionary of the client mounts.
They can be used to configure HTTP proxying for clients.
See documentation on [`HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY`](environment_variables.md#http_proxy-https_proxy-all_proxy) for more information.
httpx-0.26.0/docs/api.md 0000664 0000000 0000000 00000010136 14540543546 0015004 0 ustar 00root root 0000000 0000000 # Developer Interface
## Helper Functions
!!! note
Only use these functions if you're testing HTTPX in a console
or making a small number of requests. Using a `Client` will
enable HTTP/2 and connection pooling for more efficient and
long-lived connections.
::: httpx.request
:docstring:
::: httpx.get
:docstring:
::: httpx.options
:docstring:
::: httpx.head
:docstring:
::: httpx.post
:docstring:
::: httpx.put
:docstring:
::: httpx.patch
:docstring:
::: httpx.delete
:docstring:
::: httpx.stream
:docstring:
## `Client`
::: httpx.Client
:docstring:
:members: headers cookies params auth request get head options post put patch delete stream build_request send close
## `AsyncClient`
::: httpx.AsyncClient
:docstring:
:members: headers cookies params auth request get head options post put patch delete stream build_request send aclose
## `Response`
*An HTTP response.*
* `def __init__(...)`
* `.status_code` - **int**
* `.reason_phrase` - **str**
* `.http_version` - `"HTTP/2"` or `"HTTP/1.1"`
* `.url` - **URL**
* `.headers` - **Headers**
* `.content` - **bytes**
* `.text` - **str**
* `.encoding` - **str**
* `.is_redirect` - **bool**
* `.request` - **Request**
* `.next_request` - **Optional[Request]**
* `.cookies` - **Cookies**
* `.history` - **List[Response]**
* `.elapsed` - **[timedelta](https://docs.python.org/3/library/datetime.html)**
* The amount of time elapsed between sending the request and calling `close()` on the corresponding response received for that request.
[total_seconds()](https://docs.python.org/3/library/datetime.html#datetime.timedelta.total_seconds) to correctly get
the total elapsed seconds.
* `def .raise_for_status()` - **Response**
* `def .json()` - **Any**
* `def .read()` - **bytes**
* `def .iter_raw([chunk_size])` - **bytes iterator**
* `def .iter_bytes([chunk_size])` - **bytes iterator**
* `def .iter_text([chunk_size])` - **text iterator**
* `def .iter_lines()` - **text iterator**
* `def .close()` - **None**
* `def .next()` - **Response**
* `def .aread()` - **bytes**
* `def .aiter_raw([chunk_size])` - **async bytes iterator**
* `def .aiter_bytes([chunk_size])` - **async bytes iterator**
* `def .aiter_text([chunk_size])` - **async text iterator**
* `def .aiter_lines()` - **async text iterator**
* `def .aclose()` - **None**
* `def .anext()` - **Response**
## `Request`
*An HTTP request. Can be constructed explicitly for more control over exactly
what gets sent over the wire.*
```pycon
>>> request = httpx.Request("GET", "https://example.org", headers={'host': 'example.org'})
>>> response = client.send(request)
```
* `def __init__(method, url, [params], [headers], [cookies], [content], [data], [files], [json], [stream])`
* `.method` - **str**
* `.url` - **URL**
* `.content` - **byte**, **byte iterator**, or **byte async iterator**
* `.headers` - **Headers**
* `.cookies` - **Cookies**
## `URL`
*A normalized, IDNA supporting URL.*
```pycon
>>> url = URL("https://example.org/")
>>> url.host
'example.org'
```
* `def __init__(url, allow_relative=False, params=None)`
* `.scheme` - **str**
* `.authority` - **str**
* `.host` - **str**
* `.port` - **int**
* `.path` - **str**
* `.query` - **str**
* `.raw_path` - **str**
* `.fragment` - **str**
* `.is_ssl` - **bool**
* `.is_absolute_url` - **bool**
* `.is_relative_url` - **bool**
* `def .copy_with([scheme], [authority], [path], [query], [fragment])` - **URL**
## `Headers`
*A case-insensitive multi-dict.*
```pycon
>>> headers = Headers({'Content-Type': 'application/json'})
>>> headers['content-type']
'application/json'
```
* `def __init__(self, headers, encoding=None)`
* `def copy()` - **Headers**
## `Cookies`
*A dict-like cookie store.*
```pycon
>>> cookies = Cookies()
>>> cookies.set("name", "value", domain="example.org")
```
* `def __init__(cookies: [dict, Cookies, CookieJar])`
* `.jar` - **CookieJar**
* `def extract_cookies(response)`
* `def set_cookie_header(request)`
* `def set(name, value, [domain], [path])`
* `def get(name, [domain], [path])`
* `def delete(name, [domain], [path])`
* `def clear([domain], [path])`
* *Standard mutable mapping interface*
httpx-0.26.0/docs/async.md 0000664 0000000 0000000 00000017614 14540543546 0015360 0 ustar 00root root 0000000 0000000 # Async Support
HTTPX offers a standard synchronous API by default, but also gives you
the option of an async client if you need it.
Async is a concurrency model that is far more efficient than multi-threading,
and can provide significant performance benefits and enable the use of
long-lived network connections such as WebSockets.
If you're working with an async web framework then you'll also want to use an
async client for sending outgoing HTTP requests.
## Making Async requests
To make asynchronous requests, you'll need an `AsyncClient`.
```pycon
>>> async with httpx.AsyncClient() as client:
... r = await client.get('https://www.example.com/')
...
>>> r
```
!!! tip
Use [IPython](https://ipython.readthedocs.io/en/stable/) or Python 3.8+ with `python -m asyncio` to try this code interactively, as they support executing `async`/`await` expressions in the console.
## API Differences
If you're using an async client then there are a few bits of API that
use async methods.
### Making requests
The request methods are all async, so you should use `response = await client.get(...)` style for all of the following:
* `AsyncClient.get(url, ...)`
* `AsyncClient.options(url, ...)`
* `AsyncClient.head(url, ...)`
* `AsyncClient.post(url, ...)`
* `AsyncClient.put(url, ...)`
* `AsyncClient.patch(url, ...)`
* `AsyncClient.delete(url, ...)`
* `AsyncClient.request(method, url, ...)`
* `AsyncClient.send(request, ...)`
### Opening and closing clients
Use `async with httpx.AsyncClient()` if you want a context-managed client...
```python
async with httpx.AsyncClient() as client:
...
```
!!! warning
In order to get the most benefit from connection pooling, make sure you're not instantiating multiple client instances - for example by using `async with` inside a "hot loop". This can be achieved either by having a single scoped client that's passed throughout wherever it's needed, or by having a single global client instance.
Alternatively, use `await client.aclose()` if you want to close a client explicitly:
```python
client = httpx.AsyncClient()
...
await client.aclose()
```
### Streaming responses
The `AsyncClient.stream(method, url, ...)` method is an async context block.
```pycon
>>> client = httpx.AsyncClient()
>>> async with client.stream('GET', 'https://www.example.com/') as response:
... async for chunk in response.aiter_bytes():
... ...
```
The async response streaming methods are:
* `Response.aread()` - For conditionally reading a response inside a stream block.
* `Response.aiter_bytes()` - For streaming the response content as bytes.
* `Response.aiter_text()` - For streaming the response content as text.
* `Response.aiter_lines()` - For streaming the response content as lines of text.
* `Response.aiter_raw()` - For streaming the raw response bytes, without applying content decoding.
* `Response.aclose()` - For closing the response. You don't usually need this, since `.stream` block closes the response automatically on exit.
For situations when context block usage is not practical, it is possible to enter "manual mode" by sending a [`Request` instance](./advanced.md#request-instances) using `client.send(..., stream=True)`.
Example in the context of forwarding the response to a streaming web endpoint with [Starlette](https://www.starlette.io):
```python
import httpx
from starlette.background import BackgroundTask
from starlette.responses import StreamingResponse
client = httpx.AsyncClient()
async def home(request):
req = client.build_request("GET", "https://www.example.com/")
r = await client.send(req, stream=True)
return StreamingResponse(r.aiter_text(), background=BackgroundTask(r.aclose))
```
!!! warning
When using this "manual streaming mode", it is your duty as a developer to make sure that `Response.aclose()` is called eventually. Failing to do so would leave connections open, most likely resulting in resource leaks down the line.
### Streaming requests
When sending a streaming request body with an `AsyncClient` instance, you should use an async bytes generator instead of a bytes generator:
```python
async def upload_bytes():
... # yield byte content
await client.post(url, content=upload_bytes())
```
### Explicit transport instances
When instantiating a transport instance directly, you need to use `httpx.AsyncHTTPTransport`.
For instance:
```pycon
>>> import httpx
>>> transport = httpx.AsyncHTTPTransport(retries=1)
>>> async with httpx.AsyncClient(transport=transport) as client:
>>> ...
```
## Supported async environments
HTTPX supports either `asyncio` or `trio` as an async environment.
It will auto-detect which of those two to use as the backend
for socket operations and concurrency primitives.
### [AsyncIO](https://docs.python.org/3/library/asyncio.html)
AsyncIO is Python's [built-in library](https://docs.python.org/3/library/asyncio.html)
for writing concurrent code with the async/await syntax.
```python
import asyncio
import httpx
async def main():
async with httpx.AsyncClient() as client:
response = await client.get('https://www.example.com/')
print(response)
asyncio.run(main())
```
### [Trio](https://github.com/python-trio/trio)
Trio is [an alternative async library](https://trio.readthedocs.io/en/stable/),
designed around the [the principles of structured concurrency](https://en.wikipedia.org/wiki/Structured_concurrency).
```python
import httpx
import trio
async def main():
async with httpx.AsyncClient() as client:
response = await client.get('https://www.example.com/')
print(response)
trio.run(main)
```
!!! important
The `trio` package must be installed to use the Trio backend.
### [AnyIO](https://github.com/agronholm/anyio)
AnyIO is an [asynchronous networking and concurrency library](https://anyio.readthedocs.io/) that works on top of either `asyncio` or `trio`. It blends in with native libraries of your chosen backend (defaults to `asyncio`).
```python
import httpx
import anyio
async def main():
async with httpx.AsyncClient() as client:
response = await client.get('https://www.example.com/')
print(response)
anyio.run(main, backend='trio')
```
## Calling into Python Web Apps
Just as `httpx.Client` allows you to call directly into WSGI web applications,
the `httpx.AsyncClient` class allows you to call directly into ASGI web applications.
Let's take this Starlette application as an example:
```python
from starlette.applications import Starlette
from starlette.responses import HTMLResponse
from starlette.routing import Route
async def hello(request):
return HTMLResponse("Hello World!")
app = Starlette(routes=[Route("/", hello)])
```
We can make requests directly against the application, like so:
```pycon
>>> import httpx
>>> async with httpx.AsyncClient(app=app, base_url="http://testserver") as client:
... r = await client.get("/")
... assert r.status_code == 200
... assert r.text == "Hello World!"
```
For some more complex cases you might need to customise the ASGI transport. This allows you to:
* Inspect 500 error responses rather than raise exceptions by setting `raise_app_exceptions=False`.
* Mount the ASGI application at a subpath by setting `root_path`.
* Use a given client address for requests by setting `client`.
For example:
```python
# Instantiate a client that makes ASGI requests with a client IP of "1.2.3.4",
# on port 123.
transport = httpx.ASGITransport(app=app, client=("1.2.3.4", 123))
async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
...
```
See [the ASGI documentation](https://asgi.readthedocs.io/en/latest/specs/www.html#connection-scope) for more details on the `client` and `root_path` keys.
## Startup/shutdown of ASGI apps
It is not in the scope of HTTPX to trigger lifespan events of your app.
However it is suggested to use `LifespanManager` from [asgi-lifespan](https://github.com/florimondmanca/asgi-lifespan#usage) in pair with `AsyncClient`.
httpx-0.26.0/docs/code_of_conduct.md 0000664 0000000 0000000 00000011033 14540543546 0017345 0 ustar 00root root 0000000 0000000 # Code of Conduct
We expect contributors to our projects and online spaces to follow [the Python Software Foundation’s Code of Conduct](https://www.python.org/psf/conduct/).
The Python community is made up of members from around the globe with a diverse set of skills, personalities, and experiences. It is through these differences that our community experiences great successes and continued growth. When you're working with members of the community, this Code of Conduct will help steer your interactions and keep Python a positive, successful, and growing community.
## Our Community
Members of the Python community are **open, considerate, and respectful**. Behaviours that reinforce these values contribute to a positive environment, and include:
* **Being open.** Members of the community are open to collaboration, whether it's on PEPs, patches, problems, or otherwise.
* **Focusing on what is best for the community.** We're respectful of the processes set forth in the community, and we work within them.
* **Acknowledging time and effort.** We're respectful of the volunteer efforts that permeate the Python community. We're thoughtful when addressing the efforts of others, keeping in mind that often times the labor was completed simply for the good of the community.
* **Being respectful of differing viewpoints and experiences.** We're receptive to constructive comments and criticism, as the experiences and skill sets of other members contribute to the whole of our efforts.
* **Showing empathy towards other community members.** We're attentive in our communications, whether in person or online, and we're tactful when approaching differing views.
* **Being considerate.** Members of the community are considerate of their peers -- other Python users.
* **Being respectful.** We're respectful of others, their positions, their skills, their commitments, and their efforts.
* **Gracefully accepting constructive criticism.** When we disagree, we are courteous in raising our issues.
* **Using welcoming and inclusive language.** We're accepting of all who wish to take part in our activities, fostering an environment where anyone can participate and everyone can make a difference.
## Our Standards
Every member of our community has the right to have their identity respected. The Python community is dedicated to providing a positive experience for everyone, regardless of age, gender identity and expression, sexual orientation, disability, physical appearance, body size, ethnicity, nationality, race, or religion (or lack thereof), education, or socio-economic status.
## Inappropriate Behavior
Examples of unacceptable behavior by participants include:
* Harassment of any participants in any form
* Deliberate intimidation, stalking, or following
* Logging or taking screenshots of online activity for harassment purposes
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Violent threats or language directed against another person
* Incitement of violence or harassment towards any individual, including encouraging a person to commit suicide or to engage in self-harm
* Creating additional online accounts in order to harass another person or circumvent a ban
* Sexual language and imagery in online communities or in any conference venue, including talks
* Insults, put downs, or jokes that are based upon stereotypes, that are exclusionary, or that hold others up for ridicule
* Excessive swearing
* Unwelcome sexual attention or advances
* Unwelcome physical contact, including simulated physical contact (eg, textual descriptions like "hug" or "backrub") without consent or after a request to stop
* Pattern of inappropriate social contact, such as requesting/assuming inappropriate levels of intimacy with others
* Sustained disruption of online community discussions, in-person presentations, or other in-person events
* Continued one-on-one communication after requests to cease
* Other conduct that is inappropriate for a professional audience including people of many different backgrounds
Community members asked to stop any inappropriate behavior are expected to comply immediately.
## Enforcement
We take Code of Conduct violations seriously, and will act to ensure our spaces are welcoming, inclusive, and professional environments to communicate in.
If you need to raise a Code of Conduct report, you may do so privately by email to tom@tomchristie.com.
Reports will be treated confidentially.
Alternately you may [make a report to the Python Software Foundation](https://www.python.org/psf/conduct/reporting/).
httpx-0.26.0/docs/compatibility.md 0000664 0000000 0000000 00000022670 14540543546 0017112 0 ustar 00root root 0000000 0000000 # Requests Compatibility Guide
HTTPX aims to be broadly compatible with the `requests` API, although there are a
few design differences in places.
This documentation outlines places where the API differs...
## Redirects
Unlike `requests`, HTTPX does **not follow redirects by default**.
We differ in behaviour here [because auto-redirects can easily mask unnecessary network
calls being made](https://github.com/encode/httpx/discussions/1785).
You can still enable behaviour to automatically follow redirects, but you need to
do so explicitly...
```python
response = client.get(url, follow_redirects=True)
```
Or else instantiate a client, with redirect following enabled by default...
```python
client = httpx.Client(follow_redirects=True)
```
## Client instances
The HTTPX equivalent of `requests.Session` is `httpx.Client`.
```python
session = requests.Session(**kwargs)
```
is generally equivalent to
```python
client = httpx.Client(**kwargs)
```
## Request URLs
Accessing `response.url` will return a `URL` instance, rather than a string.
Use `str(response.url)` if you need a string instance.
## Determining the next redirect request
The `requests` library exposes an attribute `response.next`, which can be used to obtain the next redirect request.
```python
session = requests.Session()
request = requests.Request("GET", ...).prepare()
while request is not None:
response = session.send(request, allow_redirects=False)
request = response.next
```
In HTTPX, this attribute is instead named `response.next_request`. For example:
```python
client = httpx.Client()
request = client.build_request("GET", ...)
while request is not None:
response = client.send(request)
request = response.next_request
```
## Request Content
For uploading raw text or binary content we prefer to use a `content` parameter,
in order to better separate this usage from the case of uploading form data.
For example, using `content=...` to upload raw content:
```python
# Uploading text, bytes, or a bytes iterator.
httpx.post(..., content=b"Hello, world")
```
And using `data=...` to send form data:
```python
# Uploading form data.
httpx.post(..., data={"message": "Hello, world"})
```
Using the `data=` will raise a deprecation warning,
and is expected to be fully removed with the HTTPX 1.0 release.
## Upload files
HTTPX strictly enforces that upload files must be opened in binary mode, in order
to avoid character encoding issues that can result from attempting to upload files
opened in text mode.
## Content encoding
HTTPX uses `utf-8` for encoding `str` request bodies. For example, when using `content=` the request body will be encoded to `utf-8` before being sent over the wire. This differs from Requests which uses `latin1`. If you need an explicit encoding, pass encoded bytes explicitly, e.g. `content=.encode("latin1")`.
For response bodies, assuming the server didn't send an explicit encoding then HTTPX will do its best to figure out an appropriate encoding. HTTPX makes a guess at the encoding to use for decoding the response using `charset_normalizer`. Fallback to that or any content with less than 32 octets will be decoded using `utf-8` with the `error="replace"` decoder strategy.
## Cookies
If using a client instance, then cookies should always be set on the client rather than on a per-request basis.
This usage is supported:
```python
client = httpx.Client(cookies=...)
client.post(...)
```
This usage is **not** supported:
```python
client = httpx.Client()
client.post(..., cookies=...)
```
We prefer enforcing a stricter API here because it provides clearer expectations around cookie persistence, particularly when redirects occur.
## Status Codes
In our documentation we prefer the uppercased versions, such as `codes.NOT_FOUND`, but also provide lower-cased versions for API compatibility with `requests`.
Requests includes various synonyms for status codes that HTTPX does not support.
## Streaming responses
HTTPX provides a `.stream()` interface rather than using `stream=True`. This ensures that streaming responses are always properly closed outside of the stream block, and makes it visually clearer at which points streaming I/O APIs may be used with a response.
For example:
```python
with httpx.stream("GET", "https://www.example.com") as response:
...
```
Within a `stream()` block request data is made available with:
* `.iter_bytes()` - Instead of `response.iter_content()`
* `.iter_text()` - Instead of `response.iter_content(decode_unicode=True)`
* `.iter_lines()` - Corresponding to `response.iter_lines()`
* `.iter_raw()` - Use this instead of `response.raw`
* `.read()` - Read the entire response body, making `request.text` and `response.content` available.
## Timeouts
HTTPX defaults to including reasonable [timeouts](quickstart.md#timeouts) for all network operations, while Requests has no timeouts by default.
To get the same behavior as Requests, set the `timeout` parameter to `None`:
```python
httpx.get('https://www.example.com', timeout=None)
```
## Proxy keys
HTTPX uses the mounts argument for HTTP proxying and transport routing.
It can do much more than proxies and allows you to configure more than just the proxy route.
For more detailed documentation, see [Mounting Transports](advanced.md#mounting-transports).
When using `httpx.Client(mounts={...})` to map to a selection of different transports, we use full URL schemes, such as `mounts={"http://": ..., "https://": ...}`.
This is different to the `requests` usage of `proxies={"http": ..., "https": ...}`.
This change is for better consistency with more complex mappings, that might also include domain names, such as `mounts={"all://": ..., httpx.HTTPTransport(proxy="all://www.example.com": None})` which maps all requests onto a proxy, except for requests to "www.example.com" which have an explicit exclusion.
Also note that `requests.Session.request(...)` allows a `proxies=...` parameter, whereas `httpx.Client.request(...)` does not allow `mounts=...`.
## SSL configuration
When using a `Client` instance, the `trust_env`, `verify`, and `cert` arguments should always be passed on client instantiation, rather than passed to the request method.
If you need more than one different SSL configuration, you should use different client instances for each SSL configuration.
Requests supports `REQUESTS_CA_BUNDLE` which points to either a file or a directory. HTTPX supports the `SSL_CERT_FILE` (for a file) and `SSL_CERT_DIR` (for a directory) OpenSSL variables instead.
## Request body on HTTP methods
The HTTP `GET`, `DELETE`, `HEAD`, and `OPTIONS` methods are specified as not supporting a request body. To stay in line with this, the `.get`, `.delete`, `.head` and `.options` functions do not support `content`, `files`, `data`, or `json` arguments.
If you really do need to send request data using these http methods you should use the generic `.request` function instead.
```python
httpx.request(
method="DELETE",
url="https://www.example.com/",
content=b'A request body on a DELETE request.'
)
```
## Checking for success and failure responses
We don't support `response.is_ok` since the naming is ambiguous there, and might incorrectly imply an equivalence to `response.status_code == codes.OK`. Instead we provide the `response.is_success` property, which can be used to check for a 2xx response.
## Request instantiation
There is no notion of [prepared requests](https://requests.readthedocs.io/en/stable/user/advanced/#prepared-requests) in HTTPX. If you need to customize request instantiation, see [Request instances](advanced.md#request-instances).
Besides, `httpx.Request()` does not support the `auth`, `timeout`, `follow_redirects`, `mounts`, `verify` and `cert` parameters. However these are available in `httpx.request`, `httpx.get`, `httpx.post` etc., as well as on [`Client` instances](advanced.md#client-instances).
## Mocking
If you need to mock HTTPX the same way that test utilities like `responses` and `requests-mock` does for `requests`, see [RESPX](https://github.com/lundberg/respx).
## Caching
If you use `cachecontrol` or `requests-cache` to add HTTP Caching support to the `requests` library, you can use [Hishel](https://hishel.com) for HTTPX.
## Networking layer
`requests` defers most of its HTTP networking code to the excellent [`urllib3` library](https://urllib3.readthedocs.io/en/latest/).
On the other hand, HTTPX uses [HTTPCore](https://github.com/encode/httpcore) as its core HTTP networking layer, which is a different project than `urllib3`.
## Query Parameters
`requests` omits `params` whose values are `None` (e.g. `requests.get(..., params={"foo": None})`). This is not supported by HTTPX.
For both query params (`params=`) and form data (`data=`), `requests` supports sending a list of tuples (e.g. `requests.get(..., params=[('key1', 'value1'), ('key1', 'value2')])`). This is not supported by HTTPX. Instead, use a dictionary with lists as values. E.g.: `httpx.get(..., params={'key1': ['value1', 'value2']})` or with form data: `httpx.post(..., data={'key1': ['value1', 'value2']})`.
## Event Hooks
`requests` allows event hooks to mutate `Request` and `Response` objects. See [examples](https://requests.readthedocs.io/en/master/user/advanced/#event-hooks) given in the documentation for `requests`.
In HTTPX, event hooks may access properties of requests and responses, but event hook callbacks cannot mutate the original request/response.
If you are looking for more control, consider checking out [Custom Transports](advanced.md#custom-transports).
httpx-0.26.0/docs/contributing.md 0000664 0000000 0000000 00000020367 14540543546 0016751 0 ustar 00root root 0000000 0000000 # Contributing
Thank you for being interested in contributing to HTTPX.
There are many ways you can contribute to the project:
- Try HTTPX and [report bugs/issues you find](https://github.com/encode/httpx/issues/new)
- [Implement new features](https://github.com/encode/httpx/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
- [Review Pull Requests of others](https://github.com/encode/httpx/pulls)
- Write documentation
- Participate in discussions
## Reporting Bugs or Other Issues
Found something that HTTPX should support?
Stumbled upon some unexpected behaviour?
Contributions should generally start out with [a discussion](https://github.com/encode/httpx/discussions).
Possible bugs may be raised as a "Potential Issue" discussion, feature requests may
be raised as an "Ideas" discussion. We can then determine if the discussion needs
to be escalated into an "Issue" or not, or if we'd consider a pull request.
Try to be more descriptive as you can and in case of a bug report,
provide as much information as possible like:
- OS platform
- Python version
- Installed dependencies and versions (`python -m pip freeze`)
- Code snippet
- Error traceback
You should always try to reduce any examples to the *simplest possible case*
that demonstrates the issue.
Some possibly useful tips for narrowing down potential issues...
- Does the issue exist on HTTP/1.1, or HTTP/2, or both?
- Does the issue exist with `Client`, `AsyncClient`, or both?
- When using `AsyncClient` does the issue exist when using `asyncio` or `trio`, or both?
## Development
To start developing HTTPX create a **fork** of the
[HTTPX repository](https://github.com/encode/httpx) on GitHub.
Then clone your fork with the following command replacing `YOUR-USERNAME` with
your GitHub username:
```shell
$ git clone https://github.com/YOUR-USERNAME/httpx
```
You can now install the project and its dependencies using:
```shell
$ cd httpx
$ scripts/install
```
## Testing and Linting
We use custom shell scripts to automate testing, linting,
and documentation building workflow.
To run the tests, use:
```shell
$ scripts/test
```
!!! warning
The test suite spawns testing servers on ports **8000** and **8001**.
Make sure these are not in use, so the tests can run properly.
Any additional arguments will be passed to `pytest`. See the [pytest documentation](https://docs.pytest.org/en/latest/how-to/usage.html) for more information.
For example, to run a single test script:
```shell
$ scripts/test tests/test_multipart.py
```
To run the code auto-formatting:
```shell
$ scripts/lint
```
Lastly, to run code checks separately (they are also run as part of `scripts/test`), run:
```shell
$ scripts/check
```
## Documenting
Documentation pages are located under the `docs/` folder.
To run the documentation site locally (useful for previewing changes), use:
```shell
$ scripts/docs
```
## Resolving Build / CI Failures
Once you've submitted your pull request, the test suite will automatically run, and the results will show up in GitHub.
If the test suite fails, you'll want to click through to the "Details" link, and try to identify why the test suite failed.
Here are some common ways the test suite can fail:
### Check Job Failed
This job failing means there is either a code formatting issue or type-annotation issue.
You can look at the job output to figure out why it's failed or within a shell run:
```shell
$ scripts/check
```
It may be worth it to run `$ scripts/lint` to attempt auto-formatting the code
and if that job succeeds commit the changes.
### Docs Job Failed
This job failing means the documentation failed to build. This can happen for
a variety of reasons like invalid markdown or missing configuration within `mkdocs.yml`.
### Python 3.X Job Failed
This job failing means the unit tests failed or not all code paths are covered by unit tests.
If tests are failing you will see this message under the coverage report:
`=== 1 failed, 435 passed, 1 skipped, 1 xfailed in 11.09s ===`
If tests succeed but coverage doesn't reach our current threshold, you will see this
message under the coverage report:
`FAIL Required test coverage of 100% not reached. Total coverage: 99.00%`
## Releasing
*This section is targeted at HTTPX maintainers.*
Before releasing a new version, create a pull request that includes:
- **An update to the changelog**:
- We follow the format from [keepachangelog](https://keepachangelog.com/en/1.0.0/).
- [Compare](https://github.com/encode/httpx/compare/) `master` with the tag of the latest release, and list all entries that are of interest to our users:
- Things that **must** go in the changelog: added, changed, deprecated or removed features, and bug fixes.
- Things that **should not** go in the changelog: changes to documentation, tests or tooling.
- Try sorting entries in descending order of impact / importance.
- Keep it concise and to-the-point. 🎯
- **A version bump**: see `__version__.py`.
For an example, see [#1006](https://github.com/encode/httpx/pull/1006).
Once the release PR is merged, create a
[new release](https://github.com/encode/httpx/releases/new) including:
- Tag version like `0.13.3`.
- Release title `Version 0.13.3`
- Description copied from the changelog.
Once created this release will be automatically uploaded to PyPI.
If something goes wrong with the PyPI job the release can be published using the
`scripts/publish` script.
## Development proxy setup
To test and debug requests via a proxy it's best to run a proxy server locally.
Any server should do but HTTPCore's test suite uses
[`mitmproxy`](https://mitmproxy.org/) which is written in Python, it's fully
featured and has excellent UI and tools for introspection of requests.
You can install `mitmproxy` using `pip install mitmproxy` or [several
other ways](https://docs.mitmproxy.org/stable/overview-installation/).
`mitmproxy` does require setting up local TLS certificates for HTTPS requests,
as its main purpose is to allow developers to inspect requests that pass through
it. We can set them up follows:
1. [`pip install trustme-cli`](https://github.com/sethmlarson/trustme-cli/).
2. `trustme-cli -i example.org www.example.org`, assuming you want to test
connecting to that domain, this will create three files: `server.pem`,
`server.key` and `client.pem`.
3. `mitmproxy` requires a PEM file that includes the private key and the
certificate so we need to concatenate them:
`cat server.key server.pem > server.withkey.pem`.
4. Start the proxy server `mitmproxy --certs server.withkey.pem`, or use the
[other mitmproxy commands](https://docs.mitmproxy.org/stable/) with different
UI options.
At this point the server is ready to start serving requests, you'll need to
configure HTTPX as described in the
[proxy section](https://www.python-httpx.org/advanced/#http-proxying) and
the [SSL certificates section](https://www.python-httpx.org/advanced/#ssl-certificates),
this is where our previously generated `client.pem` comes in:
```
import httpx
with httpx.Client(proxy="http://127.0.0.1:8080/", verify="/path/to/client.pem") as client:
response = client.get("https://example.org")
print(response.status_code) # should print 200
```
Note, however, that HTTPS requests will only succeed to the host specified
in the SSL/TLS certificate we generated, HTTPS requests to other hosts will
raise an error like:
```
ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate
verify failed: Hostname mismatch, certificate is not valid for
'duckduckgo.com'. (_ssl.c:1108)
```
If you want to make requests to more hosts you'll need to regenerate the
certificates and include all the hosts you intend to connect to in the
seconds step, i.e.
`trustme-cli -i example.org www.example.org duckduckgo.com www.duckduckgo.com`
httpx-0.26.0/docs/css/ 0000775 0000000 0000000 00000000000 14540543546 0014500 5 ustar 00root root 0000000 0000000 httpx-0.26.0/docs/css/custom.css 0000664 0000000 0000000 00000000273 14540543546 0016526 0 ustar 00root root 0000000 0000000 div.autodoc-docstring {
padding-left: 20px;
margin-bottom: 30px;
border-left: 5px solid rgba(230, 230, 230);
}
div.autodoc-members {
padding-left: 20px;
margin-bottom: 15px;
}
httpx-0.26.0/docs/environment_variables.md 0000664 0000000 0000000 00000007247 14540543546 0020640 0 ustar 00root root 0000000 0000000 # Environment Variables
The HTTPX library can be configured via environment variables.
Environment variables are used by default. To ignore environment variables, `trust_env` has to be set `False`. There are two ways to set `trust_env` to disable environment variables:
* On the client via `httpx.Client(trust_env=False)`.
* Using the top-level API, such as `httpx.get("", trust_env=False)`.
Here is a list of environment variables that HTTPX recognizes and what function they serve:
## `SSLKEYLOGFILE`
Valid values: a filename
If this environment variable is set, TLS keys will be appended to the specified file, creating it if it doesn't exist, whenever key material is generated or received. The keylog file is designed for debugging purposes only.
Support for `SSLKEYLOGFILE` requires Python 3.8 and OpenSSL 1.1.1 or newer.
Example:
```python
# test_script.py
import httpx
with httpx.AsyncClient() as client:
r = client.get("https://google.com")
```
```console
SSLKEYLOGFILE=test.log python test_script.py
cat test.log
# TLS secrets log file, generated by OpenSSL / Python
SERVER_HANDSHAKE_TRAFFIC_SECRET XXXX
EXPORTER_SECRET XXXX
SERVER_TRAFFIC_SECRET_0 XXXX
CLIENT_HANDSHAKE_TRAFFIC_SECRET XXXX
CLIENT_TRAFFIC_SECRET_0 XXXX
SERVER_HANDSHAKE_TRAFFIC_SECRET XXXX
EXPORTER_SECRET XXXX
SERVER_TRAFFIC_SECRET_0 XXXX
CLIENT_HANDSHAKE_TRAFFIC_SECRET XXXX
CLIENT_TRAFFIC_SECRET_0 XXXX
```
## `SSL_CERT_FILE`
Valid values: a filename
If this environment variable is set then HTTPX will load
CA certificate from the specified file instead of the default
location.
Example:
```console
SSL_CERT_FILE=/path/to/ca-certs/ca-bundle.crt python -c "import httpx; httpx.get('https://example.com')"
```
## `SSL_CERT_DIR`
Valid values: a directory following an [OpenSSL specific layout](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_load_verify_locations.html).
If this environment variable is set and the directory follows an [OpenSSL specific layout](https://www.openssl.org/docs/manmaster/man3/SSL_CTX_load_verify_locations.html) (ie. you ran `c_rehash`) then HTTPX will load CA certificates from this directory instead of the default location.
Example:
```console
SSL_CERT_DIR=/path/to/ca-certs/ python -c "import httpx; httpx.get('https://example.com')"
```
## Proxies
The environment variables documented below are used as a convention by various HTTP tooling, including:
* [cURL](https://github.com/curl/curl/blob/master/docs/MANUAL.md#environment-variables)
* [requests](https://github.com/psf/requests/blob/master/docs/user/advanced.rst#proxies)
For more information on using proxies in HTTPX, see [HTTP Proxying](advanced.md#http-proxying).
### `HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY`
Valid values: A URL to a proxy
`HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY` set the proxy to be used for `http`, `https`, or all requests respectively.
```bash
export HTTP_PROXY=http://my-external-proxy.com:1234
# This request will be sent through the proxy
python -c "import httpx; httpx.get('http://example.com')"
# This request will be sent directly, as we set `trust_env=False`
python -c "import httpx; httpx.get('http://example.com', trust_env=False)"
```
### `NO_PROXY`
Valid values: a comma-separated list of hostnames/urls
`NO_PROXY` disables the proxy for specific urls
```bash
export HTTP_PROXY=http://my-external-proxy.com:1234
export NO_PROXY=http://127.0.0.1,python-httpx.org
# As in the previous example, this request will be sent through the proxy
python -c "import httpx; httpx.get('http://example.com')"
# These requests will be sent directly, bypassing the proxy
python -c "import httpx; httpx.get('http://127.0.0.1:5000/my-api')"
python -c "import httpx; httpx.get('https://www.python-httpx.org')"
```
httpx-0.26.0/docs/exceptions.md 0000664 0000000 0000000 00000004100 14540543546 0016406 0 ustar 00root root 0000000 0000000 # Exceptions
This page lists exceptions that may be raised when using HTTPX.
For an overview of how to work with HTTPX exceptions, see [Exceptions (Quickstart)](quickstart.md#exceptions).
## The exception hierarchy
* HTTPError
* RequestError
* TransportError
* TimeoutException
* ConnectTimeout
* ReadTimeout
* WriteTimeout
* PoolTimeout
* NetworkError
* ConnectError
* ReadError
* WriteError
* CloseError
* ProtocolError
* LocalProtocolError
* RemoteProtocolError
* ProxyError
* UnsupportedProtocol
* DecodingError
* TooManyRedirects
* HTTPStatusError
* InvalidURL
* CookieConflict
* StreamError
* StreamConsumed
* ResponseNotRead
* RequestNotRead
* StreamClosed
---
## Exception classes
::: httpx.HTTPError
:docstring:
::: httpx.RequestError
:docstring:
::: httpx.TransportError
:docstring:
::: httpx.TimeoutException
:docstring:
::: httpx.ConnectTimeout
:docstring:
::: httpx.ReadTimeout
:docstring:
::: httpx.WriteTimeout
:docstring:
::: httpx.PoolTimeout
:docstring:
::: httpx.NetworkError
:docstring:
::: httpx.ConnectError
:docstring:
::: httpx.ReadError
:docstring:
::: httpx.WriteError
:docstring:
::: httpx.CloseError
:docstring:
::: httpx.ProtocolError
:docstring:
::: httpx.LocalProtocolError
:docstring:
::: httpx.RemoteProtocolError
:docstring:
::: httpx.ProxyError
:docstring:
::: httpx.UnsupportedProtocol
:docstring:
::: httpx.DecodingError
:docstring:
::: httpx.TooManyRedirects
:docstring:
::: httpx.HTTPStatusError
:docstring:
::: httpx.InvalidURL
:docstring:
::: httpx.CookieConflict
:docstring:
::: httpx.StreamError
:docstring:
::: httpx.StreamConsumed
:docstring:
::: httpx.StreamClosed
:docstring:
::: httpx.ResponseNotRead
:docstring:
::: httpx.RequestNotRead
:docstring:
httpx-0.26.0/docs/http2.md 0000664 0000000 0000000 00000005012 14540543546 0015271 0 ustar 00root root 0000000 0000000 # HTTP/2
HTTP/2 is a major new iteration of the HTTP protocol, that provides a far more
efficient transport, with potential performance benefits. HTTP/2 does not change
the core semantics of the request or response, but alters the way that data is
sent to and from the server.
Rather than the text format that HTTP/1.1 uses, HTTP/2 is a binary format.
The binary format provides full request and response multiplexing, and efficient
compression of HTTP headers. The stream multiplexing means that where HTTP/1.1
requires one TCP stream for each concurrent request, HTTP/2 allows a single TCP
stream to handle multiple concurrent requests.
HTTP/2 also provides support for functionality such as response prioritization,
and server push.
For a comprehensive guide to HTTP/2 you may want to check out "[http2 explained](https://http2-explained.haxx.se/)".
## Enabling HTTP/2
When using the `httpx` client, HTTP/2 support is not enabled by default, because
HTTP/1.1 is a mature, battle-hardened transport layer, and our HTTP/1.1
implementation may be considered the more robust option at this point in time.
It is possible that a future version of `httpx` may enable HTTP/2 support by default.
If you're issuing highly concurrent requests you might want to consider
trying out our HTTP/2 support. You can do so by first making sure to install
the optional HTTP/2 dependencies...
```shell
$ pip install httpx[http2]
```
And then instantiating a client with HTTP/2 support enabled:
```python
client = httpx.AsyncClient(http2=True)
...
```
You can also instantiate a client as a context manager, to ensure that all
HTTP connections are nicely scoped, and will be closed once the context block
is exited.
```python
async with httpx.AsyncClient(http2=True) as client:
...
```
HTTP/2 support is available on both `Client` and `AsyncClient`, although it's
typically more useful in async contexts if you're issuing lots of concurrent
requests.
## Inspecting the HTTP version
Enabling HTTP/2 support on the client does not *necessarily* mean that your
requests and responses will be transported over HTTP/2, since both the client
*and* the server need to support HTTP/2. If you connect to a server that only
supports HTTP/1.1 the client will use a standard HTTP/1.1 connection instead.
You can determine which version of the HTTP protocol was used by examining
the `.http_version` property on the response.
```python
client = httpx.AsyncClient(http2=True)
response = await client.get(...)
print(response.http_version) # "HTTP/1.0", "HTTP/1.1", or "HTTP/2".
```
httpx-0.26.0/docs/img/ 0000775 0000000 0000000 00000000000 14540543546 0014464 5 ustar 00root root 0000000 0000000 httpx-0.26.0/docs/img/butterfly.png 0000664 0000000 0000000 00002467402 14540543546 0017231 0 ustar 00root root 0000000 0000000 PNG
IHDR MJ ViCCPICC Profile (c``RI,(aa``+)
rwRR` b
>@% 0|/:%5I^bՋD0գ d S JSl):
ȞbC@$XMH3}VHHIBOGbCnₜJ c%VhʢG`(*x%(30 s 8, Ě30n~@\;b 'v$%)-rH @=iF`yF '{Vc``ww1P y !e pHYs %iTXtXML:com.adobe.xmp
2
0
72
1
72
1038
1
675
2020-11-04T11:11:96
Pixelmator 3.9
BW @ IDATx`\ŵ*d[VV"ظaJ A" !HB y <L
9`\q.\xI薥-wju33JqC @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @(:4M3 E1@ Qf@ @$P`{wP[3:{o 8b ^E @ T@s |,ŬP ^x-2 @ 0 z |ggof0*hQ5t#@` 8hG" @
K3 fڔdU&,ϟ3b+N@ bZAL ^ "5~~a2ەdVFY%:GEB¶hi D -8Ik@ @
; NXqơuF0! h0+ͮ
~? p6*# Ā 84@ Y@3\vڂ^f:l%&2ɿA߯9 wEs ; @t 0T! G @ (#I_yۚ2
3k:dTRs&U]3{͙T @ Q^ DmΚ[{5l jUNWĢ3~x!
Q{x8 3 UCIC@ @ d ^3fIl6)ў?vw%h
A:TY*졥a ۷<ſ]Ҍ9e8K$
B\ 0p88ǚ" @hEW^.|JU~^4gڭcRU " ЇԢ~x{/4
l2no9{g\q>B @K8R"6@ @ zQq7=y l*1˒ ,-9>ޟ]w2DAŽQ G-@ ) @ jtk2&`Dsc}
@ `BY'@ ߹s?T]t0e4Ѩ5fUW\qp|@ B B @ ꟶMZ~ڐ8pHqNZjMg ,[Ǜ $@A, Mڂ |E}r6mϫi66C o(]r[2-=htTZrݏ<=7,! p88 4pU|;>zkO>Ќūd5E>!p m~ٖi4dTnfj0 F#i @
qGv! +`C9||OoO~F(>m H@: ZŦfw9gKʛ@ CS]! "j۾}-KkVkV*!UVk^vٜ6ZݩN NYwUjR2{hRY@`` 8ǟ#@0knk#+PPdzg7}
%T ڍ@ovݦQ Wcۓvsp+'?7ʧ @ JA_I @ ,w
N'3 %V#^떍u J*S F@vȟҔSݳ*?cY߹yG4" ?( X`W ]X[+e4d hhXxǝq0MG hf\xήSN2M^{ "g,yTy @
8O} A`ͷ)qS|] ,v%v%g_5[{5 Q$+鍷߿b
sڽcЏ.y RU@ @ gm&ǚg^[U .-ԊGheڌ [~ryJ1?*sSƨ`qax[uޚg@ "Eq 10\ٽn컓rIjhRWw=K?x_:pb@@M.ҸiKn1 @h p0>MG 8n;GϘp2mNpٟ[9ι D>A*fWW98W+eJ :uu飻 ؤifWIKQMXʯnr>isS" <3&Y^H #MX}y&##I@}[k
z%{0mr^d{I. @
蝞%x0M6
k%yʒvYث;0X@-8snjʋtb!3')UG @ @ (p}i
FkrLY""ŴUǔqWe * Wйr
VgF8@ @ @HM1~[k+rrjô⬑]oXR #>I@6sr99%hXMpԧ ˾scG~]_Aa
yI@ @ B0֟ld |\Z% N./dx{秏|"?k6o;럎& @ @ @ HfT *WZhZ¢yhewy^}E9S/EGͩ% Їzuǯ̃q9.g" ,yqٸ|߸܌\2YcL#^hKPXpuɸ֜A/S i;͚viٸ\|ybz>/sΨA >eZMc?jT@ @ R@lK^_U\0yrTN&\2{ڙ
wۮx a wK iK<>T@ψଵEeEy;L곷ޚob@ @ @ i* fKJ7i0i)~XqTyan ]s8=ЋS j/VU0S =@_ g^uK市u yd}~@ @ @ O@:|~'|x✩s9"P' Ψ(]^|Ң7ssKE) R(0]se M.)u'NҳA?& ;m|0?>@ @ @ _=|Ve?:yقҁ#5H#@M )퓝@ @ @ &ӚQʟ.)xﬓyqv< wX9goa2~>&{=8uygf/9u ^چ D>D+gO,.800?hr7Dۏ>:0fVo{DlE .]pRW $p4ms긂&I9{ɖb@ @ @ c.mj]1oSˊ>>iUZ2\}@eUƍٽzܛ={ @ @ ٗϙ_ajȁfl6.^{#/>塖7L*{@ N4;dTM-̽%lv}.| 0Ybl >k 16vΎ@ @ @ zW@~~~mCzw6] o^Q;g:,ti+ ĬtL' 7{iYQ^Ǭ ?njG٣}/Pq팒qWzZ]퍒@ @ @ T@lMb|anYϖ>=ѽ39~̽E{UO}H= zU?(jX9q[ ,
sY=z3= ]G @uCM(4gYT)B&{LZkFde?t`@S( ;nVQ|EA߿ȨD'e礲·~X#uB @ @ zW@O=tú⊜&>fcJۮŷN*9xٙkf G6 _Q@:W/3p۬ʊ4m+O-/8u_i0 ;MD @ @ Y@j+47WjނGQ@JS'RUyӴ=0?@ @ h7eUYcN|R 4VYNS$?q
h TL7(-=cmb0h͒e9釖͛O @ Y>@dXlq&ᳶ+/ɬ,ȩ[=~^lV! |coQ]QYT Q#
~qգ+>X?5
}#woƎ녧Oos/uO>R=ъ+7ZmbJ D (y w>;}ȎrZ gujMj=y3 @ z=EcF<~~^ % d^^xٸuK]i x
@ @ @ HҴjɒ%~Ycߨ Vk>yyMWLewDVJ! @ 餤+%" Q@7Z,/gi^/jkk A?O8E̙\܋7-E@ @8:Zl E֭ f;jxWYn _=E~p%ejue[XȮ5C @ @ hMi>Ch "TstjA'J r;ueH0}Ƽ Ws3&}_۳Uv!5l?Gy#5nmQ3j pO,<'?M֨j #kN>쩺'S MF @ @ +yqfi_=Q 'o}+yٯL,qU%= _O@S _҂粇ݳx̙dP婖7Lݳ+@ @ @ \@:[FuM _V ߗO>`JNˊv]Ƌ=EzEB@ @ @ zUݓK~9vHԫ;Їgna5'-6O D?mĊ2a3(, /yU 9mѮ(@ bA@N̚Vg@ GN[W&Y9Æ J x)sd>=xm}?R@ @ f+:Ę94^Ѳf-15oMLˇ^ͬ8|ܡ=}! Lq }'g뫃9n "A@ۺ:s҄s N*{tlYiXWΛ>47i ܉m/R @? 1> v.@`o]Y^cH]o MߞZ8:YU?Q&e ,
nj{U~Pcr3*\%hRq@ @ @ Oxyee(H ^:ClXr\Ei'-{q|x $֚Ϭ^5|1c ߴiSjU/j |U5^y
SQ@ @ @ L@[fUN>y\O1W˿ ˼djՆ.=#^. / ]+3vͭA,ߪc=Hp9N)+vK4VQ8@ @ @_9,;Q#fE%Wο0C Z0uG/[ _}{nep7W]+TgwnXZpw@ @ @ O=ŋgf .-̹Gۿٟ}pE{46~R7@ @ @ zM@ۺ:z9cGwV~[mVx$kuyUoj\4f 4m(i- fN[wVzVƙkO_Q'-" oaHQv cF{g=tެ@@ 5c5 p^XRV|
ٟӳio:5mrf8;#@ @ @ c&Q=raƈ!T3eŧ)_fߥ8f @H:8ۙZ0u\=-uzJZQ/o)7˦,@ @ @ Z@ _l zyt
QݠYyF3.;sqYAN)+%gBįi 1,
}ycG#_{n5M+Yhnޞo ]@ųe
i~<
ie & sAnڈ +֩%9JժZ6S iN40ЊB ۿ6o@ @ @ @` e ^kb
|cǧ/w5הL[@ rc
x @ 5sêrǾ_=oa,"*6emX{Z]%**N%@ @w#zǒR@
5;a¢Qwj G)F *_OZh T@vڧ/` %H0!f;Xf]U]Rܶ3c&D<&
G @ @ I\4$}ߊF9wr`G0@=HpɆ
7 mOeS䇑F! D (8yٜiG4{LZ~i
q'Tn5jϭl,zfk@ @ @ '[5)Ud
T^+?mE6
'Ο}Bu8 oЗSU@ 8
sy@ c"PP`k&N~ъyH:&;< z(eϾ;]'TPP?h@ @ @ n Z78hk;͙rNuEOP
@ @ @ ;gOXY12X7AWV3*vW,:oZ_>@ @ @ @hGߙ347SdYã)ޫg̙6K/9יּ
,'iU9/>x&D55fW ?,8>@ O~MOO@ "]`Y *-+n3[_ߏ%Er%h21ljo$ח! ,7Ҽ qD.kI8e噣6̙^> 4 @ @ k-B .P_Zʲ'8dA rU;5+1YK@ @ H pG:!
mnβusУ-Iˊ2G \8{ڦh[-(@ .Ճ -«H@ -599p8Xbօ}# SIf|xR S]qq[$RN!A @ `Bw@ T
陙%{͍2+?X:/{;)뮽x3Q` D@zy j пzBB~ovkj>}cb9Ǧ{o_ "Ч'%zꅜ ,DGz 0[QQSükރWTuR__ekh=nj
55>?C @ \ @
A'TQZ9{ċqMxŅWΟ9e.ʴ @ @g |Q(k Ă =p˝ONIymz>}F z~ D@DZ" p Æy*+o5L-c>Q1m| ||ZG Qg@ ?h{U]>IcM2,ᵺ9ŞP8V\@ @ @ %' LVUIKK[19gVZvm@ @ /@ n vw(^{SU.+F
AEuB @ pп @
+֟n37<'%aݻn; Eq@ @ @ R@:Ƶ+5q|-|I2?\>4m1їf @ z_7D@ zE@:8
O; 7[[}gܽRRS3\θ̌1*5[eS upꪥkM\55vUjՇ |G>o7k||^k?5# G
|Ǒq @ G@:k6j5 :g֟Y5i-
f >kOK͆CR W2;?} e0UU;V.{ʦM&( |͘k03ͭvrKGn}=fSW̟uG@ ,<
y@ G@;IO n># Z]X6
M͗$ j;\bNz7ϬEI,?
O" #@ Q ~aoVȟt= AJY?5I$Yq*TTfk{ߙ_wXmRS:@ @ # }@ "XsxKp?RM^V.2٬ Ip Fmuѷ np|ZjjjlO_' Y>K@ @Ø17~J6[ߟkYG2[dP(NwZ.#D6 jߩZ1I@ @ D: |dzߦ:u~5ӕrY +WK ;FI
5ѩ jXO˼THwm:y~" '@dx @ غ5՛6, ɰrsnK?Q2
dT7)w
*
+?M
ilPRn1b 55p6*! @ 8Bu@ "3 -mmmVKE's2فKbAZvemQ?4%Ν
'@ @ O |*O@ D K$&?
{2
,f TTuʺ5jtioW-twM, AIu*-;JK5@ @ ` |]C P(p+HAPŹ j\i,ح>
Z8V?tgw @=n 6bdSeӧ\Tmp ].;
gn:P #u - Ā--OYm*0)קrP@jjSMUZixy }$@A A@ zKV3ڶ#p8 Mpũܼlo
T|KdŢ< MFfoՃr@ @``tJ@ @ -a[K@] 4H575!C
b+d Orq ܢV /@A j W4y_6fcUҠ$ѥ:j;U4)SS]>A\|2] |坱! d 1@ @ :d٬FK?ةƦR
+>ڹW54 P&Q&IM&YѢ~@#pC @ Lņ @cS B* ֔WYnƖ:`wT]_kRSdAuxG7o{.K D h9R@ HMȤဦljTXtƩ.W%'(2(˥<^K =RLr̔XUO |e_
@ G gu,X&Mp>lUPP(Az
Qa2(!9=k)=ێ9k p @ 8#D@ 8B`W]f.TQٷ[_S$@hnSA͠>W&40fQM4^7]ÿhuR,+, a]@ l³ D@|B ٚZ?dŠz/7 /T{{s:Ώ)_R'|{渚&uǤ^4M397I xm!)ͥE>:|5d$DgJ! Z! plKhn' n:2Ǩ8M,VuU65m,|谬{ xSyBeqZUAn=od LSKK3OYLEMư%yP|3y^eQObwī l*/ ~ji픷[57(lV U%hlU&E& Z*$9erŰ.a}G2e{Y1)eǎ.$wd+ѠO[ $@|2AP9%@?Pzo"$ZP
^d4%H̛Q[oco! p0 2MD lzvNaNäͪSuj@P2ҹ$5 68Am RBT0[l=CLOL0HPA :w 7`P&,`P(H
F .fBXaTӭ` BCOOԝ嗉 5k"s
%k[ 3 ! esċR.(#!#y4Ik1[# @4
8ƣFO@!_ fn_mJk|_\㇚\fcJjY3NKxr;ێ5ԫiFON 睠Vx|2 4@rxߨigji8H1uŊs&/ R*,F9mX)Y>3ߑ R`CN*&uu^q(o6]0xG2|m.J 4X9kTozw%VNeqU0.A d(XTbt%g#n\mލj{v t0ɐK3x8Wr8l2icdZۻ\h@ xУcھJ@'Rv8::>cۜ,v{M
cBpjJJ
Y5kltؒ݃%퍳L
C.z.w3!)E,~S;Ny$Zeo3h ] M Kia{oF}wo .i2MN1H> iS%?jf΄Ғͮtn)\2sR0-my_MQe(
8I@$lΔ (cK
H0B=
<"? ՓA`"*>Tr@ ^_U p˗K+0[ {exO2 ξCɐOhNCڵKUWS
v$U陪ӻU6 Ʃ6>0(M+v_ JR WCP?Jcj`qBݝ=ԳO,ϱ( @ @`@$]ȈηAFɿL避_y;;[ݦ)bkuǻKåK %ٲF%$ÒZ-)&9ɖL.{ͲĘt{dq\E qBO O&R]]VL4fuD`P HH&'~lrҭ2^gn[dS=`+_w*(RG]^-lh0\J3!)6`66ȄgPX |'G&;7<.ohw\&㚍Fr&Xۥ|Vq'Lv!)9g
ۃ&cނg^n% 62ck
VH Bn5ظ!@ e볮8KW{u=TSGzQPX dyEy!V5xX{4`j%m}7a0@0p9\p|y,2i`;ί*qPJS9 W}뽎B q"Fj$Kf =%jIڜ]Π6ueL4lCjPY+刏].lqJb'2fIm4^Wn[g{\ .sYv6=DI_]UO(Jг\ ;$L oG%7(ܾO6talj/q,'ܝqfzP*V.9c ԐoPC ~e3U?]z-(\ݓ<]rQʖ:xTwkĔA=3$1 i@zn Ҥ`u˒nᐶU*d4Thԉ|{4a$w. H ߙ{ P
Um9[@NT3)[CT!j[ճzVp48пs|=g4<]~<4A6 &J6}}L(S*%E%
NPC҆]vIU< &PX;} h6~|~ߵkꄿב=8!5vʩg/ Vg 78U{ )-iқ;z YAܫUi7JO2@Qi)2I=n唴ڄAC z恾-Z$ɴ_>%H|rb3c,f@HH OF96zarJ²&
}u,z@A!e7IVB L))&BL䳺N1) ZCȿb3Pӯ-O$' V2u߰h
%kj!:^aY/\52NW$Fo[Cb0:%HR)ɩ2rID;e *wӢ4%贪G4ݚS X:z|J`βaҮvXy{$cq]'=W'C@=.NeM=S exYthC>R>e #f el+^G@.Wj4][{gFCt{ۊ:
qE AA3'XRa7;eak= p[UPd1
tÒV}
r, &ɵrLH<>>ANe6+3I]w5P~R At$ש%%d+p/=YP}y''zgMmJBA$LMVRHXCLCrb-g )f&sC%$CM{& +*W%j PYH= ɳP%x&+ z=J&= ntKփ 5.Ue:y}97H ,.zE=("ntgp֤ܠ=]q/g]+ת I>Z %m'uӇ f$_p:=29DGb\?
̆( YU(d52>'96Feٚ|iu >m
:[۠)]VwB3.A0[\ΐl
%ZUkRr&K zaܶMfЧy%Cw|هio9T ^~S1[[yeD=+.B~L(|6LJ ]%07diGM$
'-'^؞A]MDޠ`+T|OI]G҆U _Xt+ '0 31+V@һe25?o{-*hnm*5h$i&[6%(W媿\zHVZk2#WS/'7 pvL@ˌ):d0/sӇ X%-$;/WNPKA??@O7* n&'ޞ C@8%XV }p)O?i?Ճ|
2bO0'
zJ>YzlQ~*[lR¢\*~M ;zΓ@H@;Tʐ4.ͻ+K`erHE0 2D(O zX'SB~=#$a6zeId{ia(QVٍ%DZmv]z^;?>xO$SCg,&wXzB14^?p ֏rL=iZ'etG SSrԍA: Z&9,&-蔶'&[{qngS vHhuX΄w%6[-9- rħ&2+J%uD|JR{OhRnz-Pi'Yx :#sOHud.m 0n_wOOqj9>'(.~x%*S*Ttg^c~C~-jPLR˖-T&u]HVdLʰq|xUVY.>^6zݷ%,QU/)nmC hUj$CZeHߢhig~7ToQ2e^a{!khnn6۷ٹǐ:0Mol{~Kjc DvjkָdwY l-feH~$W%Bfr dw>&?'L=ɹS*$m7>a|"K |;S۹#1:RX3_&AQ8g~]&ۓN\,')+ dpPH
tH!ڥe,wO/+$ga$1^z!,'C:4\3HXF\ z'_tdVqU 'z&S&;&/UYL\ }>AL i
A:s ЇGH?W'W
I鑆$!ϕ+Q>Ɉx KAED]qW))C$rX
NIQcƤ!x ,;@yZ(,SH%r'Þ=
} i]r:QZtCS !W7Yc%GVg)RPOP'NDg=$=ηs w6 . HpIY%%N}K',UʱxeVId,Si&pIȋ bvwvwvrN f~J :+0t_x{?gkKУLx5o_i! ?j_
#G툊9P|aM8&"KTjֶLـA5N;/Qr{XnCmsk5NjlɲШכ\콷c wyZ4ݘ
hH ƣ'4~8|̙Vj`(DGLzeu%ys\7Mul#u_j+W[(U7F [2JP"1d0 rf"# V.tZf̤vTyDGcBl`\ &S2u97j 6V[RG4T1@[B ŕ41 /=M jW*6&6e^l
مbp kwP.V;LboO P!#T[p'پsG@;~gn9 C>й_3vL2}+ j4 d&]QngAԼخrKaY3=rz`D²:Z' @ycrH W|Ĉ_
Π, W>ێ9(MCs=1}<0xl}=e-Xx7C~>t/~qv'-+2>ypbkDMekd,707穓0&xm\Y[p 8Gd֦d %M `SgWwX25-`:+5P\c}yeEU۪,Q\r\y5S(@V[녶Ω|>0Ա;йޠljS'|+dHF"e`o܈Kmg. Dm^[ + 8zá#g 嫡F cXQY/}5g{.Ư քES+)6
N /kIsʇ"sІ̥D* :1P=}Qb6:+~~i۹|Oy}>z|^ ~7+^it7xSө72ٍ[cW*e퇭FHU*lMF7:rR43C!&Me*tTj.IwhjLFm#jRd@ގEZMGmէҴ
J%֛o'Qa8rZf( (2+kk+:TbZvYҚTt
RSi>D)B-8ֶ(Rޮo6V&L5Eb@
c8[-6
E}V+qjfMMzz=[? ] ``5\ζ3#} /43 9f'lJE WhP :#PߟcGc:
N#GN% @Ag BX`lk\OM3pu<6i(u\ʄckho h
D ;1S4vR3aCax' 68rp_8C۞#Me,`
Tz L&Eg8~c} #@O} >L:BpzA lKΑ|:mf:l/) שwV w
+:SyFnv:O
%·L
S&E`oh 9@p?E20)9'XRe\qmy$
} LPh)D{Ʈ\ =6 s<\~ =Lk QT!46Tp5:hW4-9^M&K4Sm&*wo
96 H`BB,q1)}+L2'7 ax~΅G/g' ?/
O9&'VBdN5N !*f8yD)vy>;BP0 \mZ9_ddq!v[~掻/SmglG:8bK Ifmo %_$XW\x챐xH<x
a2ZN FP:jC^6 ϥ}P"ѱE0*X^&P K+KoVJlmVD)o7{3 B)Xz%YWct? #Q =^eTI퉎pĵk«
;* Bu@r es~Lc$I2_^XrgGN TZҮ?a˗/W^y%t#0܉{VGrN]Ƿ\
tdk4j*S)Q qL;UY )H݇Y뮑kWFR젱g ͜ZbJ:FA܌b4XffZm6WLA\. \ŶR{Fp~wuE6 6ka\p<6ld?Z
k?
pcz @:K02waimee
Vςb[rQ#稻;,MLk}CԽw < ^zi= ]xX.P%g_O {dwӹD8Cl-a:sƹN%8ɩE-k1Mj8AOA&L쁫3@m :Vd77[u otwW'YjљnR#h{m+mPh&*PeiAj )6 z
7b (͍DLL9!G²4yR;Ϲ "q6LSv#[bP3lNdG_< C8g6O'lkףc}б055¾ ~45lit; U/YV&Qc?h jz?M×tA;0~>0sӨ=}byUwEZ?C.FkpjȪ͂жY$[S`Rc+c瀪aw8^s&xeZXLpyZ n { z[ / lE j5~K{Djζ3#}pHWK'_9 ='q%ҙ`ERk : _VFT#O:a s7qH*_jy74p7B[>2?J`PȋK/ =ze`h b
!47_r2GTXob|~ صԷʂ P^( GD1v(j
9R Ykøo,
P4E*5 婐`]mwCgzE݂bm#NdZ0
H
0XQ~ 8i\VcǕ{gwR>2TzxS~Ҥ(ck-@"_"VxLty"=ӳ8105 3dhԨ8: OVcY&M."5: LKb}֙
Ͻ~!u
6L$[rDC sap`m -V1Z&dH0`ؠpvAbzHN%{=U6mK0-FqfƇ,|'{Vu/rk
ȷSͩwӟAZ_c WْU-RJ \ka߁
}t)'>K#}#D?|6:
CqQM&|[3酵ܵׯ7ىVw%a6nnWzé| ~fBzm7^ 1خMyt2?׆Lq9hi2 XRܑ 8{5:C .NZv}AQj'PVYPX-DOj]Y] V $#9 0z/C֪m}fkRKIzdZI,S a0Zl: am)t Px%\ ݴf(`.tץyj5y\}]g
iV [ԩ8 BVp,V)1~' J `Y#@jGނ#h b9) dn6 3{B 6 "|a-:\ yp(`r&4t,C[dQ/ I+ksFsXڟwwy zH'2}l;#2>/;۷<Լjſ7gee©|.w #\X,fq^Q*i2Gi`GpS;2-Xg=+bs8TYD+ h&AqQzZ#pl &4+
.2K!&6FUPY#ۀ[KAnm
xebMåΟE^}QӐbb 1 EQM]z8"RL7:XpF@ Ph0 nJ[ηeCTBilR5Cs/4xbBށEoǸeS}t\ B7s\_ װ 8OW0E{߮\j VݲWЇ/{({] ^vMG\])CYqSbd
,,,R i%LJΧ=mXi
5VWXӤ\Æ'lhgv d=lLlB
(vqt.
T}=]?Q8 tX
?i0lJGco ] Tu^-Pw># RT~ zF l<\w7}MK8P48.\L:> zlx췿P#8⎹s|ӄjh_XDiuoΩsƟFTE{q qR1
gXrU" kܢ%ʳ=IPo( 5:$Ke]h <&E<.Į
ȑaP==t Dʞ8V̳,%Rne97020Z<%!C mJQ!jV%2dW8r3P2{ˁWo|cs|86??|wb|ú#LOqF )T`r[ʾz6eB`RnxsKIoc`kS㥝: XYi
Lq ̿:| ;?/K7FO !pGQ TRQ*
K6 trdoü2< lSo"{P7x)3[ 6*: r}s+1r<= T[aHa,.Pz[A 3cii3
| 1ey- 4o2ڈY
ΡfB6ׯMrwq z j`SxX/2ܾ,66!9M_0`Rxg=㇙8 r Dw]p cӍ^DΟ[6M;N{, 9Ö1}`Cc^X U;?l
K̉$bI)jZki{H} /Di CA9t. ZpY{,Rmn>0 RC
E^^kͺLюΡ kM1=&` B&5Vq&#,DC,^V_N ^z[2+ZH!JuV]T輞$_'쇯>3gփPvt37bag GLLɯ ?.g{cf&dQR( HQF )
Y[Al=
ac_ dEl|ppl7p
d)JD$#I 1)tSʼn)pRogHL1St\# /=L2.0g*/H[3B֘(Pq;wu8U4Rƈxo3*t(QS2U }QFFſzyDԳ6;:
x|o{ fGwv'gm*AE,N@~ ?Xoaen&]x= >DDz ܸz1,(
TWq"61Y\kvCsu{#t)j`IGd7;
(7LjƉF
)6ɽ^R
5?GGqhH@ 3LޜvEA.
) Nū]$Bfs~<u'cKr1szqo4kT;VrY)^$[p{ǺZ>kKi:~m <"Jocyh|4辡&$fdJ$ì3] $=S %Zbc8xhC,Q"yL̘%_0%alQ1똀F6Yu
7P2=A7]{ۧJ t xDKeb"b?E[FܹGӗ6~]<:q S:2o\H#VoR'H\#HawtE Ǐl>1~5\ y76G}Zhm"FǕ[ `Ϭ:s2|\LsSoGoR=hf<7}m@@Щ4p"ƸE}ܢs7Hz#d wA?v\7 N (}V1T`/A!XdD+1yq~ΑF0g/篅^
νQVe|6C@͝QW槣#}|@8pDF
#=TIb Ƨg_
Ig'}fרJ xS:"sYEUVdѧ/D @ IDATcKHjHh|]curHT[6Qdy#h h?y#atqu0<46Icmg8 CtNaY^{paT
5Pw=o r ];*
:Wkc hshnc1NCG5Gc>169`)8D^VchXk6%TCſ}>w3Nx V(F}c-t%H]]^ݢp0>N $tt[w/#
7(F - g,V {_,^`W2Ioyk7 `
@<\F>Qi/swt
a͙bzEٶ,Ы~3yvΡ2^ nunb'h/m2]6³ J$[Wb1eg!`'ont36{S~ࡇ xxczw?a_}맻J0z~<'~ Ā;4^9w!B '. L7c==`@PٕeDiksƩ wQtYv{9x' &W1-" ak/`ABR@ҵol My">k(
N4HzbtPpo*
BM\
x;{褨ư⾂[FPQ8|
UrS )~c6C+HU,
s hs,xlǎT =f4{pRf3 sS TH)"ݫmdJŹS
0 \
ts25C B>Qr/*w1~D* Fù7/g b( ǗRAjʌJ^ha^wQVW+- 3wdH|3/-Phg@ۉtXz=&n,!ƥ6.P )ϒk
+U]'VPIHB1i) -jYzNJQ_
Wތ(pޙp
z,#W\lT,_ru+ks(CL} 5&9썹:EI42_#-DY7Drb,(b_Urɘm T50Bڭo9F]lsjNALigHܤ/0qdf]߶(q}}H۔*j< y·GŦ8Yւ91oUZبob-ɍՅ&]:(Ѹ^.=/ 9:zGa+s)gCڝXZߙ[9Q>> } F6Iҕ92;7 ]̘Y
jo<|x<qiX%
vB2g6-? !7Z"y>OZ >{
C{z'O8|ȿyG?8~os3] G[pN3wB_\S|jp~nlZ1?Llʹlӟ;TQN!T]gj"LS4$ Sy86o^]'TUOa!N(6^@ikKx/-vdzrU`yC4 PykEGS^EϔŽ]u? +l[܅ ɨ Jo5+_36 PbM,2OAhanoyS" tp1;b $z.죝Àso ٵja^:pu Vm2m,"c({? Va-`dH
a &Ў (k3 #vAL~s8"y) Ï?:*$<im@Ҩ2)X)AD|4 ɐc=aƑc/|!\d\ ylOfɌuPG& D[FkM ^jF>m=ׇkpH5ݶLI:WdΏ=ӠρE1L8g
?ڬةd !s+}NHc آCmJ.` U a! axx(w= .^T
1>+9rfSCք)qXیq07(gAyƺ' VX K4
?30w}l0Ky&;۟hGSgWGA{pw79bD Ç <+)sjwhx /_/UZ!Kٶy"
˶ wxp ɧKx %DqB:#R\EO7"-$!rQ! ii7=9g߀eWUR#:@ApKI\N QjhhD߶ ʷ
8eW9FmHC
gQj
h [:1JӷBl]Gch
ʠf%3rn:G lFA >B&J IL*hr>S K3QP*P;$7l#2H A
Bnw0ŜmSymuy~
]?m!Ia5QrU#8 k5Y{1P 4J4q+[S_gI )/µXP%Մ8^,#?{IJ16
!I j4(ZF
)0ҼgJ(={5>]i.(:;yhV
zu,pd,/sLa\0ma5Ѹ.*c`:|(Q0!8\v=D
DCFϤ9>ۮ
.#ޏ5M $d! 簝fgVDZLtyρCԘndjk
ER -hw=`] 0 T>]74GH8I{`X)֭Ŏ 5ooy\f/q aϿY,f{n9~C?oaG4\z;~ٞ'E
(D-124w~/~*tw"34n;q*D/~#vX F2"Y \jjXSu@MjkR e<Sy b[~ŗQA g :v |c5n
썡|?G?ʔ݁+vhn.gF'#g+eҺ Nx)S<)}6>g_ g;Ci UUU ʿ-8 Au#Φ]iKa{.ucV+2b_ O4if_N($ZŘ`qUk x
:FfX{6602Sk8gdCU yȾV`&֜zg(}-NL
_k"fC_p
rcv\s|.U QBSY͜X7Demk`!
dn ~ ^^n2w=k 'q d|\ؽq
V
-^]_]J2Wp&=7{} ~衅_yd V'=㹿ŵ;D">8NF>Q2
SIo/^'[O[6rDoMJJw ^!KQ(JRV4 | !̕Bua2vѐ>A
-@!Q\xB+RAWjKgw@'Em+aj }C"[G9XMXSo$Yadem5ufF)Ӄ
`FNtAt z:FAkC!ap8% Hlh,XT|RUv(ȷ%.Hɹ^,ʈ4 {ĩPf%Jߊl8^D́5נfd
" Z Ѐe*rNr$1(A5DN O6ť \- <$pY
Pm}d"ad? 5 /ʯIq@kUfs ܔ*(, ϛI(mQu^ñf6TqЋvPn2.h [(4D}n(h*桱D1R5bH[D5]Ã~icq>1TKNk
r̭
-AЩHӷu 7&R߂P&~p
oDp`.
O5Ǐ$d (a@Xd0) F K4ZlK_ZasbcM{'3 '
Z=jԷh3,"#A=ь ӉV1vfAmrÿОskhu% No G5 10l'Y^ tb>3뾊!YRW -[5>NPz\jݽosx1D U۫Pߓ_<5>5j,Sdry¥33>Bh#=>8B5wḣσQgYsc37`R'&$*"Hlׄd87 Z1 " hC]f n!?Fo} rvwCǏ"Ikk&<|=3 a4 FQ4$/{mqb2CQJ [_r-2 FD|B9-د |bs!KļimL/M
uH,eGHC` О2= a}Zs5c6%#AڑORMÊ92N@A^u'Gx(7uQ؞kQI4Bg#8Х0@t nH`~c6| @.O\
t)u2r>U-P٨CR?*PZ D8p>$Eu y)CCE'F{li [sd- 0_?G,Z :YjS/]2- ڂ
fBc &Ho) rVV xk ̰FV=ծ2 S@:Ltn r_~RXv̐nKG fq<}-ikM
w;7דk@]L/ߗ ps-U5L17&D6(*eۍj|9Ͻc f q]k9LO~r^߂is < \i[ `d..57$5Ǐ=sߟ@ ~K<G /43ɍtO}ebdB{gV|(r XM l,i3<`
8?v! ⥳υ ufzRc)HQR 9hC^??@XNT8x}PDU>K IћT; 8-r1~Gm!?Ù<~
!M5rޚ9hKp
^JWjv-DEX X\1̭Ǣx m ~SAObulc&\+gbƔG|=
&C^)o|̱ojyQM#JYsXއ~j@;6u:i!mՍ+L&Qk:8|țz3HϳO id(80wg't^8RWtJ IGýw {{Xe_ ޢ'
2L"k[,ӱ#SIFr@uyvS ȔjVfSO<^ ®ݻq(M e·(B62X+}3S7./_= تW{njݒ,,V3Mٍe]@,6! 0U1_@Ntv{21sFg8bg{t_1~l;0Їq 2$ =FTɎp\u]:6>? :\M2okt,BfL/Y}1R̵{/2"ս/f1m5bSp,Ϭ5 1.GKsn0k[ :in{-Dd ( \5e:w,>%@ƅ#PH{vbL}5Azx<˳7zuJ0M2 B<04'M݈ ";K]1@ϯq#6{ B8G g) Pɐ3@sVY\M M->3*k);p jؘnڃ; H݊8 p_)Ry dW浥 0eD
^g,7hc < 9#Ch ,5#Iř\]حE&"m
W0!"."e-]`]ΠR|>n
1Њe0xZV<0ܓhN{
3.^e|(w}/H3}7 {g yW=gz':{Jڳ>fU( 3g~D h>^,T&߭?c_<<,am +#8H
Bqľ5 e!om1
jEH5HDϣ.\ l
g|/LbyZx7K箆u7l]d"c@pPYMj' SLjӱ:=cA9yӐ1 k pM
8[d @@[XQňB]al1>#,X(`a]ChcTrK0Qz:CS&P$b[81#o~G1֩~(e>{ODWqF]$OnȞ Fsj= F~̶:2cQ SezjsӘ`p Lwhs|\c筓#Zw3%"G LȮ|؍tS7F"ucNovsDz0-o9]
3s+k 6
WYoE ֗xF1MYd8au- hW0PF1|; PtXa}P<YIW͓x8I KQ@Fg `HEn0 kf c~4s>o xơie^y,tũBIa a=O
s1OymDww;;CO' ur8ق C;Rjx*C$`Q&xM5j apmϻ{q 3< m
U3K N$ T [R!ja]{ܢQ6T<ˤX1$)j qcj&u><3ڭ^ϔL>"2He@X Y ״PAzQ 8#4@
abӵ]8p_Y3uuii T8;u9Qh#鹴ad< ?O}|ߎ j31s9
ςIFz=[v| LDl 32iVV>ȞVD)^q͕.:ײv!#/1Ѷ
5Ҡ
$+V}؉c_'KKsپ#F@kgch~/O|GG(dw 5 ƹx,
J!AWhmab'
'c{RG!L83S!1 m"n]f_
㰧Kj>("]ޅ!n v[By& 8M}52\4AeWWCƼT9 깋ǿJ+>4HnRP((=
~X- jujiܤ&R{P?Oj-uT2GeX(4= ܴ U Qs
TLFcGPi! nkTE[2J bs:Q6
u<' k*])#'
X.^y&MaRع hsO=H)fQT iUQb%:`fhYtqVV9e
EPs4kQ5""m#SgaȞңQȱ@ jݜ\&3JQD"K rDO9EtJy1*k ~f6^Oy 6QenDq &J7goGg18=̘-ދXS5nbV$h0(2n\7F¾= ҁ|u<^I08 «>7i?hryүXau cY893,țKgYkԑ(]hYcm7emiL vIu*\/}'?3a[GSO?^]^d t^
'Yo90JLAf[g u N oԞZ0XYsnI o`,s5$q]{KAHƦ[ z?p8~ 1dr dX;'c7 ƵEڿnFZP26]zvt
^P[&>*\3fjg9t=̃8;)R+P拔=ډ#&QW;[as]~78+ {{X4փs9"\sO V
1%c>gu{Vze}S_MZ
4Y/!H{ofywu{WWUnɒ- y-x`BB 3f
扝g &1!0-13ےZtխkvޫ&g}i a#,{TщkO
F!~goU7`%Q@y6*C@dlVssCVKY@_cC]lz
m<#[5U̾fͼw=c ߣ{ qc,kq-Kq݇b`?
``'-t|wY.fzzz<2>3S\w; YO?SW/_IBƱ#\BSXu38l 2w)5w_x[Q?Hp
/^L}˟m=}C[;a̤+;jKQچ44 h ₕ`K,@{[6 4 :lc"^ 3F ֠g̀ٞ-f) 4Y:g/C֭еB9?sLlE p t Љpj%) Τ u10ŀ ]W:Q)'Xa dil༌ 4l*跿+A1I;;:ڄNYΜ6 ^DV9la {" R\){Ɯ\9~zEMxYb]};liGL]+s% ? $pJ'a_8'AXdgo,SWs:feV
r621D_ K) ;Qߨ@6+>9δ 0QȤSn`=Vc?la'묹# +{"u S$dBhL,쪣t1t} -6U-]@,Cugd53Q m)C2*+/箩sP.,1Q D3ښ<
@f^2#-u=d-n @ IDAT]T#h*e1Sy.h=\~|h=D8|}e^l{eux2q=c(q#i ~ "c33<\7)Wd[~@{gȐWH;EWWG行p(ti@r
IWʐ_V(6s"+9?V=r 'Ϫ?M'?PVU'*vŹŴ"*
Y;{T*dxU߁y^Y"ql$`T0q 2i4qF 0xQ0gc6|U-aӌLiw u, !ŗu>b eӲ2JHZ+C mzq>m4> :910XA38t > d25:<'SO.^G@^Gge:ngYs:^E c&u?S Ϯ6s^ɮeA m _YMӀ +M3 %xY"@ۢJI5tK*"Zۛ$sc 455@4=v,oH`I3%d :46 t6`dzoqHd XW ^s {g_)2ജF1D&0pV&FцVŵ^afa_+<P*fqzVa ɰ9~*lD}
.qA6S9q%6܆˔IJZG/,z\Fp] ,due dChmM1ek6z]ߗ.Rz ՀS.k+ceX!@v=]|!'[xʗؠ8@p#
]UzRd*xdvSSا(͔;u F?B3i: ؔݝ, M)6yl_:6࿋>
}lj9>mx +55_ wԛW_+V wMt7 Ǿgfq=4ڗoEj+" #ʼnE'Y? Μy?c[hY4O):Ĵv ~A0@%1É!udRL~+{BO[cxZzl0
pf$TַTSr6 )W ' .Py&HfMa5?O[3|[A$k
"0U: W`:c#:(5<6
Ñq`P:TNT\-lj5*ؠ3q<|P뀋bydD5N:d@ iB)<]
6xpw HKdaP"@ױu1% [@L-2;AEEVhSB"v֚9XX-@g %:s 6NoG>zbh
b~lh.4Q TU8/-/] ^;ͬ!~Оi4 >:ێX;Pav
mS@pCeA0NbdPkjr #d~k#ɮ
' Q4\CgP KkkKmŵ~ &| YYz
2j;3Lȓnm@(!թqVW^87@ #8EKi
| ?}աo )mp9 to Y1[]8/ y 6Fz~_ q^:{ @c&9q!۟&2m}Btey,D :O*i<7ș۬k mƀ"~ꋎM#V~%Ɍ1xZ끃"+a,XSSWqV0P$ }Nx Y|8{ RS0ZX3I]ZB&{#G= }z|P{cŗ>5/
/>lX mYOɢ||r-e9wt*q4ԝ-ȁ34WGf%defgGXvOg{X@q1nl5r(-[aF_Tz `:Cצ'8WVM,Nlٗ?{U 1|(Ad
͔ W)l|@]]tZۦx̘S A? DS?
wD+!0Q*}LFq- ;yAHK([]w 7L3뜳x^jiڇ= yPĶȯcwc^lpVUJz{@UCc5xUk;N&2esVuAweVnKёN`*e3}Mf}vueBUnUI.Ӱ@KK7V P''聰 gs3\_wd ʹ:QTl Aj-̟@ xmb0fZb`\t +_5 N3-pd ֑#[-; 6{e ~moVzr|,*c5@GdGB3g ST<
,
{p Ɔv'3x dps/Nq:Rl
F Z:vyd{ 6}Օb6 g4<>ah>R(tVvs?u2Ҭe2E s`|yV=?EP8JZv%ʃoHŗg$HoK汾TZnl@T0>4nYm0cqGБ0=`ٍ[_QX ΕFϥ!( 3 LYb) MW)+ΔuX/b` 2ly>et< I2Uoʰ6&Ɨ,!u]Y+Z?v tM/N \;@)Q!G1ic+(K):hv$~Q+2?7M{f8F"e嵡|:FH3li 5nѵo6^+` {Jv^Ա .h_wq
JlxU쉔]íy~n0bD(-I!h3#
" Q{}CRʼn02NN=hc$(IZNBKQNkϱXp~F`~F◟ GZd5G ݼl4T:,SUJи39"u\Z 4bm0 25b
mgQ@4(5vt jtܥ`H<
vJ-`$* a1e
m-b}s#pɤftdlf8},?#8xrS!=ay3ʪNH+]ͨ1:pRT54ZaDjvg zu1 ZEN[3rrϾΥe3 8͎;YL/{'e-RC9#9Ȳ-eq9']չ =2 =fV
lGWCس;NXg c4%?dj
IoF6Vj}Tk} eMO i 8%;)G @/X1po;/tmcSdYX580f)eO-Ɉ+J35
6}0:Z;08p3 cZ .5R! G /><]tEdCrw X(kqKJzAHF/Cw>_OG8:
{ӿ_?{6ײtޱѮc3-E0M3ڕe˚) mkbg`d'/دĦMI _Fc9
Va6%-A~>G)mʮvӳ#o]lL&;i?$hvk,mhyr,` 8=ʎLJk{}`:R{Q7 ZX"^zEM6`a
gFB/hEy2Ӯ \~&C,6
?lYϚ>oq8ҼK2?wQf+ `Ljw8 =
c 1LS6_U;x߂hxpaZщ=BrVK`rLs3| r{q\ZXW^.!$xƐwΗ~w kR rB A{}*!>@^.,t4",:\ռSOq+ئ%1JAԽg{0h k))kL(,Cy 4 빭! X
CY .a@seȵ3\
6J a&l#7Wϫ^+*%UK!%[cPZLќ ">vh1 &JknGì6lP.@C bpD p4L?s gDOg!U]1o` .Lx尧;Rlm,%u>(ftu,t6)d[K7 rf }^ N=Lt7u@klEΗϓC@& @ 9_:&CP ؋n֭}Oe gyvLTW7~CnöZilvpa 'Bsa+heTag
y(k.23 @C 'y W /#
cJ:H Q$vp7oGGхq"ayRV%z?tb&zOA'M _[Zx>wmBG{?G~ak>4^e_< u%R_p1 Q~3J Ġ wS4Dzf d^j{xpx٧WBɦ ^tL
}f Z雷ݛpF9[?[!* v LF6(47#f9ed[Z2=5^>ć#q]Ӝ5?Y̖;|k7 (8.ȗ5BQ^_5 ܄í'wcl
OV&F]ǶڳŠkD7ՐY3p|(2KfU:u2qÀv_>:;ڴޟ~Ko<2uF%|\!['ghS .g_Pf+7P^ 8 lA>Kqʆq%;\ Ʋˬ>6idU` s9b6 }7,X 30@~O#b{ٔ &twQhPt0qI 6SxZ CSZ ^tjI |"PU3u: "A[A;xCྺXC[/1G֝-gW{QW}
א]κ"^n Jp6Y/v k Mʤ >G ɓYW.`P?cVPx&W{oe ao?JC-="j 2Q"СC N VN]]V'fK9{9|<%u
ܚ:%X +q.y>KP o!ed'k} Lc iUUtG M;HآzT? n φN= r" 9ʗGls;]{?Bo Lg_x۞{큋ԩ?}߳ʞ@%|ͰEfo{(k˷~0LߛmAQC YU%wvv(+ݒ¹_~Ψ@2 ;iZ4Cq,ph?5q|4dSpc6 9e(
&ڎɛi|A/`7;ID6luv2 SdBJQҬ]uMd8L\eٹ j-G9ˀOy.==R,fT
9p
-СȚ%>@Gi:\)dWx`7cLDG5nbldTUX^>f rAuJkε2`cHG7etn _*חdb __ 33ɚ=`)7ڲ9^JlFKkzl Jݶ xFs. p٪5"ͪ賃^1
S364%2&T Oy8@dhCLo(x/GHkS\Cu *RLt ɗU!}Ko>ˏ} O^8WUcϞ-G_8!\nmH]^Ώh6_gtls _D '!IOThda~(GNnj=4`# Pl*uyl4ACYNWAƧQ@0HZ NJ{ ,%1"i%(: +hRl$o+j̔A
od XW@#<65D)/
h
Kc͵DK1vZ)[Yz," (=hoIzI.hPl2#+
h::[e
&rtlֹ$4M5XY$̽*nQU>QpZ:qr=L"< 2h5KWN f
6` o\^r
=l֮ b 7 CZJ WQlkcQ{6nܥS-}O z{x6|c}*}P1up\=gcdXCG59*s+EYRVA&}j,cg ᙬxڙ@)լlZO~-8$vUq`UyCx.~l;+Tb\o~W.8_ q8I֤*W*Gƭf *Wg9m rPo Y)GA7D^\243+ԗiֶo G vȭaj[pfu6 J
=W 1 24t^!27bR@/ٸQ-\ Q} L]A"مKщ[hm%HsuS't,ړR%[HA l[[5@ Ek%7CC%ݠ1;u3}:@.W8w乾kWyk8-˟W=s =iMdpbm;C(h7t2v4pi Crg >9aԗl=/u+^>cg~A{F^8ZX!3 =8fw`L,6,KATnI oxi$#P'uGmvj{+[N$)Zao<Yi2,d"Rc 8Y5GJ sבmrHguȦF4\= OY硡!XP3I0 #t[^=:ZVA$Wʞ
#YBǷB
YY%6͎b&<X+W7
|m^wiij5 M]5ww.:g_FwO^z)G"Zʼ#wIlV5DD
V&f9 b0 u/` @*
7CswS8r~pk &}nGi@\z uvƵtðaIt v YY31C@ˤ 흁0l 3ї =arpa83f.? ~uk ۂ%| xl+zNUH|b)`TJYjftTBoޔu };AOq(%c0FBV { aR&د PӁ}lPR9#1w4@o/E( H߇QS o06 _0/d
c7W&16ٳRM,p^vvu-Y#@]|G+o\gB .A }=L{n"mlmj,=C˸ [jsc"gG 9=)Į `ewHД՜D'
iwk^O}i٪,q2RA(|p U:֥lx6A-@("׀&v́eL;eACD\(P>w iG8cX&G@L&|@Ȼ_,+!S\,LŹ>kѲ~Wb"ebm,E `%{ a hbcI֕}x-70Ԙ
XCc ]jFShU<;1^h~`oq k8;Yw2eȰ"18M g$RB#о=)1:xwPC*KOJ `J{]R_\n
p-b$ݡK=Oy] - ?qLZc-} n )_*0pnׄ| 10r턾~kxFc
9 b/`WUC_ y|G}voѣRĬSF,& p7舺'^M >
m M+\y>Ur(DuI Lre\S'23yF Z=7 ei2^o$kmJF@ e::w>(p{,8ّ?0 K ~sNGGiuB Ɇأ&܌r|xǷ~kXĝ#3g
4ҭ!H^Ȋ3 ?Zt*em hWU4,:v^Y$4o :2R_gTL$)<2bYbBЌ *>2n0Nz-̅ _aMfqR]S_E ; Vr;[@ qhadrwWWbYBw=EI VM ?A
qP:MooSAP"{%g`0F ijl\E 8
R(r4u|h 6 U_ǟ~
9leRZMG` 41,P9ְL"j5cMצ)K"1C%D /1*EPCSL\0RWgPf"hڈ:Bt)F@L]uNet@pvLT!.9t
86b2#`}Bu^^%;2˺8PA"i%3CMp)X}0 ;=H %+mh;$%3@5d|f5uiWp:[H>
]k#H+&[ sȣq@SGgנCɓ* ;YvպM2dYBUgZ*\ + 1M
8< {416 j8:Zg1Nʝ|Fa6sNpyz͇9Żרg ': `_,5u:+fq,t !?p~)>FT0 R/1mY250|dE&j)-ug+/M{
F[PdhjwwOh Y>gt/͇024NN¹=l @ IDAT3 g)A"f6p 2ij]% H7¦A3T:3u,0>υÇo,F)bG,6P[$%#[ǹNipwe~%L2eeمXmk=w.LNV:qPsIJ֑E.68WU'JʸPSfUs!xChzS_g{@|}O|=}ÑǩGn
W YFf & p_%b'k'eP cKeapvџQvxw/u} ;xELߢ&(b-V 5ߔ*yM<.WMENX[ ,,^u?Oใ;>s> 3ؚf~n*@EXD +Lƛe
-mv&/A= hfz !r0U2n"N>֖fз b,Nʌ3m>rfVe&A!.=<;)jeWھP Ddda&Y`u0Kj9`--NDO
wCײ48\,ӥ V:& ~ne$8 u O0ʲ g$JaZ
vѯZ؝c :[\=TAe% M*0G.u.Biq~gW o0IT֭ ) N4vrqGŹ-b)`
:-SIWb~S=~e"9,3Ծ:C9Uu5-/˿oS_ȇ~k?oۛxWײ\{wϞMd~HCi "
MC.mfSR(+0Pi(ŰW&[a sġKڙ fIf=\HXu@/(3"=461[| vMa\3$zc!☂ fkqr`A ω׃`@ɜz-|ON?w5@lS2xbY5҆ǟ
/2̌yz$xl3pc+1ܚM28
;9)"ìFMGR @<8XF MU r 7Ϻ 577R^UX~/
lC Ϗ]{YTt 8e(UdG' ѐL_> tYss g ,oYZF8d,QNN Vԭ U}Î~yXhum>G"v F Ɍ ~e>X:&=˷ #2]r ~ߩBR zjήyDc n fmwDW[>{ }Y. 3[o\'5Ŀȳ.iRѱGsTF#*l/Fwxqu.|K%@$J rdQٜ6;~);GwKC`x5gSN 9;TjA3E"q0xχhpϊ"MԬѲƽ
Ηt݀2= Ja&js.Lgmj1 fمRg\I`CkҲRJзetkͿ"pT0Yv
}#z;A?cJ;3卹R\( )jV
cE HqlaҶD9 gPh2JW3gkQہ
Icvy @ m͔L r< 288o؆FP 0cI~kiN1h5X^!M-(=^v7Ep3F=ї xƨV1"
ܡ}_ IFlwʬ@?: lq6Wǚ W
}taz
oAQA)4ؙ
صJ TԇLxi {5P &8S4k *<7G(KtP =` 9lX, 6 wE09W<3I
@smy"i{=aZ#; Q5 TMDz@/-|?(Z$Ú/7 'snȤ 6Qn4 36 @\&pul27m- 'L J' @h&
́]P08u dQ_⟄{ x+ Ypux. &H7\kDkq[Cgk ! Mn.;r 43zg46F閠fp4(Tmz>d1Rw+)cQx2v(vffbQ 4jvβ~86=3K!.KblazlLtl #Zc: _ ttcG`Iu?`Og9|vNߋ`?͢Eӵ
Nt"31_T pzp,5(Wce@EEcDQZ lXѐ3p ~ߌ2JRp x :Z]GO!#d{q-x
i ?2ɕpS'`o"Rճ7ϨFq}B m>2 0y))[Ծ> /3\$5S
!p4hf ݍ8'NGd䑩4ϖ4kniΤ7iS<`=N:2 Mwʎmtslޒg1kt TYh .&cnPR{~eFp20 ڣA|p?Cv%6GRr=AM|}wA;" bA4b!͘5%Q
n6r.캲DaZk?W&jŴ~fHaJ2 Ԣ4(_^Uϩ |%X6
]x(̾IQSX =)=dmXh
}~A rXN 4Ɋ$&&gB] _2L(-" Q,WL
[ ɀBu V l[Ƨ=|WKq.1 R?γ]Ylf+kFuyR!~ϵQZp?+#3}
ۧ)a-26@
NhEd ]ulZ⪜Lp-EymD_Aho,Q%τ-/.w
\ÅDD
t#LK
!fhDS"9 K=]4v l\|eA Rrfhb]qp;#uV 9h5=?' Ĝq0~'4 &#[(.(*_gF2Yg*ءi_灨݂QBY`7
dՁpuj1.R kb n 룑Qnޗu}*$rd1k8j I8vQ:&*| 1_ӬCO `0eVVzi>ivQ:7 Rqmߏ +^9ftA2ހKP iݺ5t= "Te3h|N'-|r`}>,4cinikb,nv /Qx3+K( 1HUEP O Teicsa
/ n&@u8Q@ "iC/\808:54SES7a% Tl8/ZgNG l!]x<#%+ztH u!gɻs.'| ~ Na> E;Y+ ;Bg$:ʼFGh;^yDA`8tǰPuGcȦuнgp0G+O
|` $";O:ڢXN9%ϏTgQ J粄Wgta7ٽVOfkhzU=22Pޚ뚨L%d0dH{ۻɅ=>8'wwݧpiʆS
ϊsqVpb62͞snt_a&t-*'0Õ.찁[#:DqҸyiEG+3f0OܳřytAXK+0Cˆb28u } O[{٭!d}]u֩Ʋ3~d,] ёM祖FS}8|??9uرS+FXGM=63=K07 "6rFR=Dm ۴3w(mi c5Qԏ_|de/\ ʇw'P0_E(4F(g 2#0Ԁ Dj{V7n$%T.] 5N-bB1`ɽhplp%d?j'd >Kn0,u6 mdO02߈l΄N}[y6 Yu8aP3ڈvuL
ΙRWЯד]g`욧` _"ȅw?"ַXY^#5_<}>:q?m00BgUV,4al ڻ낞]{$p`Dܝ'S67^ t/MH%P6 ҔJ@VʓvE^ۦ B,s<r<4\ߨ͝-BVl%{4Qvi%dY.}\HHaVnȫw 8Y9
ԄG8#:]ko줯pÉP(I>A{b"'f@ j5ׇݭ=K\O
y
{>BlD
Y0}=Ť@ ѣ= $t)-+Nw˥
!gcGwl?V1 <@zV ʱ &$(V5^o*i652ޯ_ H4 c+aF?*be=UJ ճ ciRP|buŒn}a\$@_F
Ь3ACka {r}cP} 38VϩDHbeMlMN|tcKzG {衇f_.ī; |ĻZ{ x3kĦ}; / 7@Ӹ :,HI͘K86iii"{VN+fav
DsDQ6)H2 ʬݩ1*y/Fa[>*}8l6+P,-̆j[ٙi6sxQP6eYZ_o;X{nW/Xlg'aL[ N$NbJ8.JI4h&t&OB' %R"YbrX.v踸ۛ缄f2/Iw/o<|SQH\"(+eq <:V r42>醴݅~G@4 Ld `L x.ܼ
qH) ]̝
?Fzv dy8fpʸgxU TO
]4e<)R0^&P*^ h#] ̑Jֽ1r _(Q~N` z 8;LvQ"ͩDdmZ{}/q ] crTX Q`/d.c 8k|u&:BhG F3wTpi!\4 "Ζ(7Ӱ.yapyTVNׯ WWd LpvN/4[wyִf3er\zΣdA/AzrDhmT 5@n3Z'Dp(Yo[q^Yxu!Xӭ+@# ?:>ɾY xdlJƦrh8
fk E
s%=+j#\hꞁm#˂|^Y|do Y._pՊe<.K5 49؊ ]%,nf szL
0h\jIYƕ
P_sYʿ vܿkdG ^*GRh+G= (#|
,-DV51 Z{ooO;q](p%Q 9ߣF
71Ν= ' cMmNkf$Z.Cr&@Gt3d{u+/ʓ2l``OmL8,ϳq-H^
< {& 4#V֑:ر.2
¶S!G|1kl@o\[^ ,A\IT{m#wR,"g0M@ׯr $CO8F{f6y
@VUR6
h]oxx٧ v^
73NW h 䤀b.$d."E}S&cι28Zu.v"|P]3*AG.]w?2-cWJ鬌D ("| @ `yKv0G\ .+^a@y_ F2r̾l\#266(uqSr+tӧ
nY29VB( v ^s 8KySuȕ> MyEaPDu<'KbW [Y{`a;t Pr{,T mQrPIFE.?<:"
<igMR;b :#dR?=
'ÉF߁tPP
Nr@Yie{*i#9bx*5 %J## 4Eb}
n/qXEX?j[
xq
(g¶+6GZO>a nHvEŲ!eUA I #e&&`L-p U*16صr\Sb0k^y저 6@ '%!;6$#*T b8
yO)dL8@mu˩+/T /QU
.1}~??LChZz
:RU+8"s\q6|2yRΈJ`n%A1/sԳCnG fkjc0Fi1\9
fx:|f}7qd ?klJtގMg p r$ 3'" |Z{䨤0-' $[\I'/MPvZ =f :+~"UmCً>W}%sof҈nt5dPF h 4~~ n0k+0 d=thxSiht @YڵUKD_7̤DZ8zR@ :2 M*v K6Z_yi^vs{[>a`<\+iԠڑSUX0Tu5InLkS߿$g_nCᗪo k7|8njLib.Q̳mFSz&ͺDۅYeD6)D"'>:2ݻX<)+yʮ8{tE4:pEܥٷfmGR:RgdkjҥaN̸`tHy:2vsf,osmk ̜KQ0CqNVuDq4ߧTdg[~3G#:9JQ`NRTٳ=$,O=g_lz /O]<G0 KQfvgӱ(ru@A }5աb & 3+fw H]]]$ `M%WʕK 6M}4
掶9dԖq ФL/M&O3]ˑ@Vct샢 p;m:ل9粊ps6m }diEƅzF~)WoʜvQ}Yu4j'*籯RDkMO4V4eM.{?J"R !` x&׃щΫA>ʙ~PB}+ggP_%;(DYNWKKZ5i?}Б6N= ^&~UI0r%4u>c {" T47D ߘK eGxv\k)M@`?ln0mb?o>:H)lSm ]7蓘8')("c1y}&L|X k~S̀5q-EF=SOԉN-l3:s׳D^y-C{ Ae}#2 sIXJrﺄy 2YmN`!Wl[q ~q]aA6Xwo OP>iSly=(t"@ \钎qh[dF
Ba[$X#C- <JLcVnu/Cw"[xVFjkNIg. GyᐡPEr : Y.pv`ra{ikG ^2d q`"p(%3@<hP]HR.5%Q c~@t3 OFAݪAP9{"]&xq ml[s F,,ƫ bOedûN KϽtiGS!gڵ) ' !9)58e ,PH+#6O`N~HiFNq {1pS 4G(&&&$ n X{i\{u*'TG H8j'Yds-m@5 h`bq:(o( d::x 444C6VW{ C2+dB]'kg((gy4i(u
LYXMojzpא q \6+qET
iZWN_Bf @rϞid1po#c*B#g sV9u@V!%5 o`R 3p0*CŌ!gkaqZK5[άp:O)3.QJY!9Etfr"Ʈ B)qK;b&{l4R^@!'0X_#Cl:o)GA )v]M! 'e9u $fsQ6 s69{ mֆ]ύZ5A!zƦ,A;A3N9Dv pDʹ}[[e^x<3VQy47n}p8 k{A=4@dk j(
R:#Y W ẇ`ςf?gЩ+5~6?&{FǷs Yђ.:םN _`FC0( @6f~z}vd˱7܋j->VW],t{i)&X9.:(As8kdSxأ dF}R-
l8Mېu ӱ UȾB`Wnjhkr3ȧ['Tz}9*tXYL Zx8r_[VI`29`c*ͥ3ehkNWURfX[.0ণ ʹ 0ϹD'r%Yc8mϹ˗N1&xNMN-KH:>5 y*Z\E1Yn9e y C' $
mG)V.[.; } Lىs,jbOyĞkh<~^DB26<9ա=YPބji7ʵMojME~{?7= G_|r X&0gy _5BEIc";uA0v=+]AedqEO-iR\{FmlYk"$P ?`d;DyCхdM8./7a/ 7v):4d:Dݢ< ּ3 p>{NЮ 7Y\@Fښ})y4;0|FsJ䞸X`ܽ\t
`uŴF J ٞ
);r Y~Mav" u
1<b&ֹpa1q5"|z!&kϋ*ی. UBO&({oEqڈ _ȪK{g} =mWd6~_WZ^WQ\䒹ʐIaT0 b
@π ȢAT.BNU q^{IϏk
`ݻ#:O?ph\s='Z;:ҙs') h%T< 54:8 : ו=ONstC]NfkXGu[܆g*G5fHz/ p0-R8>>}L\76cÑte.<Ηj=#a8ȆNqhDW k&uGπG-ۥ *lRʙUhkk
]0J rm8#eq]# kɆl`nf*`<8C=˜
dM9:NKQ?oG4ZNemM i
dn21ݫ:$^n
615kJ )w_bYE U_ dza:=| uZ8 A]Eg>Eý b/YBhчe
tXKiS$6, NdK z8>'f 1ȟ1])ACu{G˞]V6/;,z5DXs|l ? tLO kG$s&zG8c<,$% >[I6NX:git
.ׅeW"y ]T/B) z}u xW7\h?aK Qdlyqo~brDh\BP?ksUiK&MUsyO =+umVwfuKm]1ŀ6\I$A (AKWV1ϕl.e* DcPV۰l2c ˢli636+iwʱ7ޛgשe596ؔ_Ɠ7hB@ZP
c$~S8+͑E
P(f釘L#2A >L÷?HLFԴZRYxV=;± bPKO?I@E ȓ+͖ u`_
{iz${8?Z>y}dɜc,vn|6&]9q?-A4{]
0Zڿ%cYd7k+ ߝP']&O#
Q[֗P^6Fs0. `I ? KdCbI _Tʰz &[Ș\!
qF:pM_ Ï KrMNa,e}wy bF@ sǽ7QUGDYЀL!L+kڠp>! JizZ GW[y5\s_0
{lO- R8u4k8ui /]Ƈyt 4YM1J @Fd h HyD :~bcb_ %'Cdfo!! S ɣ~SϏ_K|G
d-ybRZ9>9ӥ
oB! ϥ`fu8]*|*Mڨ6G 1 P.}HGCR61Io5T...ଃ@1y|^
G+bV9YcO,v"kR qq5TwYOxԟONhW`/q Ǡ}߾{PqAzo۷FIi|-:f%d'ˠ}¨0WL Y\}wal [+SWw3G(qm3?.AY( wuTOȾ}X7>}s/2֬9 s]2 0F8T`
WvrϬ
j3 viP3k@" ۇf (xƆ >[q2j`7 Sнjt;Ra1z+͆*,8?<^s9(]Gm` ޥi}qق=vj ̤d1@U8
dA-amAa/nFR7%ZL&X:! Fd~\p4ixlIvŸ+ld0[Z#nRcKkɶqt|dwwD22 HAa(FlVK&3-| K]c/]*S7/AgAh #SdVThtڛS qfQNߺ^01nff,t"*\v2q*i+͖ T&i2ޞhJu\qcpyQktm]3fd*u
*"~~W}x
Qסv
VV!s ;eTM| ?EBͽ.L{)F`o#vqF{Sw=L0 |~m&= 7< B.}/EFabdLy.D[L[N{`I ".,jqjA6l[cfu+i{HMumUv
`&Ur38˖g=,{ϋ Ϋ pw <
)V FX2:Яsʁ3/!K68SEӀNCWɾqЂ6 v@fu%ѩ f{ j1g+6w í 9\,<@2W (A`o;ƒOzJ w $y
όM
eUG5 W QR`s>X{ Q,7pكm bxُc 1 d]+ϧ*t&ko[ϊ>MAϋs.lC 2a0[-HT y.im* W}X4a(# .:En{{9u z k>0) K8KeȳB 'Ē4/nS*H= 凷#aI!{U8;ޯrG!Nrx'ɵ
ywk#+(ԸB<"} ,V ({F,f6ا ^'9CSVqu Q5lNUp@
t#8 gno(&
8̋8 Ec%s&tg]쁤 nb 8rfUt9
d?F|t$}:8`:`RjE1p V9qc]29oooslB $ Cw6L۹YZcdaADaSf1t [H&k
À ~XL"hچ|(@c>M>+1tf4E0t1o}ZM7BP :E͟ ٔ'\ pW'Ζty\hJ4Ott#̍?fs6>:u: :5P>>ɂ(ԃAif۟yL`u-ӄs`i.``ba5+é0Ȭ9dH^}:IM36@Q6s1½QފqD u4hS,ЩvWr{`a^\ O7*G
q10N!7j?5vT#dX\l߹Nݧ#.(5jE1m(2)`柳ߊn߳j:}^}WiWKuJV2e{ʒ0T߰;YDV3寧)P
k ˫-9bM;(36|ܨS=%kAD ~LbѪ}H֡H64UUMs^eS>
@) 9y=BAE @G4_ LC3C3SH6>}c 5ʩFmWH .[d³-В-ǔlk:$,rJLVw _]Μ Qg^,e
o ksU+2n φW uJrh 3ӓW__ŷH~[MGfqo}; 7O-4.:n͠@CCȠsPt|XE(f X,ؚ
E3(=@ȀT s m|r Eg% R(la(9AqNnPEb3>>]jbgS.PKg麖T"^M嶎v TBƹ<k ֲJ5o'q3*^> U7 ?y &H `MWWkXH==yv=}^1CX@r ښ3`,
8o(#S>B6M^C2+tzP0eܛtd3/^&#O@ 5K)$*2ADa 1JRLxw3k63QY4F$b!*'AaMONQH?7: Ck>d rkd,i!LXs*`և$UsxﾑFл)p* }8Mtz҉t~]8K'1 +v@ i/R5hGE[i7 )%1Iy_*XE~A7I]} uԷs[^8>kQ S[e3ښFt ] A&;xqKe;ݛ/ :,}1;
FF^Y愙,Q0^'Iӽu~\ j
}8&lh9N 3yG4yG #[M5o8Z&X3uH%q کCBdXתCSQAoWd%v?m2 MP|YS "4;= Ӌ~&p,YGL臊<`m8;ȷcZR ¦~pQc %0ϤK.<sNiFáBg ܿ= y l$ Qj#fpLϸg3{|qmr6I6 C>*\le;o('3φoK .
F }=YB1::#2ٲ?oEG}GydA~n]Cc8:UY+S5FE`J,7_Aqs}1?u>v`;udM'C&}|GX:IGz57 ~md˝_v}0심A͝'>,MݭmAb lk:- 픊fUvE U!˚DҙmhM/~1=Ela_ oS >3A6|,> WPG duv0s1i d7uf`X#ٔ[ҋ/ 2 5Yu?ъ,pbl,bjm_C< H`)L3´D֛W`2q>Mcs"q-r[+~4~tTFa ,sNQQƆmu+ \'lD
\4E
ysw}pbC]==铟~!=q$5ȑ!sQI~Lh;dX0Fnɡ]21ȏm,Ld{+A e#Aڨ#
ZS.Hr
G8& {"d@^vwd+s%řqe4fA^ mW
pPx63O
I%{ۢ ௐw:\ @yfgZg 1:`d$*gdR칥 ꜒ 7H5Ŗ
|:{=s
k b;Cۺ\_t_ﮝy:KnFmk1qR 8g8H@eOP^lo8slr `0HT [KoJyoxDۈ Q<ͺqC px@?jV.=p6 Q"w!K`141d:}dR{ N!=ޘLr7-3iu) ,!5 ;y?zWUG
d# :Y숬
iBADPD@8DFw8{8>pvxN)A
jDbPN06A4BAgx
M 0}x=Y#Kkƭ~ 2nr},'8)#c$-"knM#8n"k0I } {73ʭŻLB4=:LAI_ݯJn'kGr NzF^t~ς 荷PS>hUMf,?Ƒ @"K 復_)hl%4ad/kPU) V84(i_e!]P\Q#! F2Z&gxuy8ʔJ֏]_~gna[q2LMDH -Ȭ]CPe2s㬮mDI ۷# !Ȥ
ً$IcYg!/Cӭ5]e mZ8c>Kc6;8a F|+
? ȒYxnӬMJYA9{R Lal ,]0)Ev`vGwܻ{a̸(u|+QY ;~PafDkXܣ Ū*Ѽ \F_?S1e.:F:.f-2rȯ\Q(
<q У, 0Yw[ (g#VC2,ȗ͆ڳA `]8M5 TZOQ%r- Pp@Xu:θ_J =`
87 ;4|
O~20p++Up Y]e٬
@3 o< >4 #6\Jg[~wfjWKtY+\I7Mz31TeN[چrdcL<7~
Yx_f!S*R B\ xEW"TIH-TJ=qӃw8g0Km?EE7Ҩx~8 6tCVrAX<:l77ч 8\,I}hH4}Vt,ёUǔx9'NC9.po};-aN#h}JsJ(I' c~g1 ،p Mj
GJ י'aSe:Rб6y[ȸGT;k$T3 Mtg?e, wvLWd8,
FҤ`sZ86Z| p\CRY0G b6y0cM@ÄPl4*`Y
]!Ѧ')$42Ԍt)[ SN ٲ #{{ԬAg'gCר_M /ul֫*xQk}x3No|gk`ʽ6-բart&UT5YiGj,2 Ҧ |6{%p HN<ڽ3 ;T YmʲTY0vs)_,1O'b`A px +# g,M (%4%Uc"E֦1_w=$_0[/Xl
t6z*|L Dd#Ƶ!C\3LCa =x!Bc#D6t\1?,&m2*-ZX+ZR@mlz<=ŸOn˼,j&WҳTb"'RǙ"R1F ~un4ue͌6+LGF8U,X$)3@ 6ry839kdt'
3qxN8dD"=Wy:H}ue, _tE/s7
?f H$0S ] =cq{dBWKä[KkC
g;s+' ϝdr:92b@+SDmCm~cU[[', |X fU6E`nS6MД)uG精' 갯@i>g@R}
*8{%'}V9,zʕ(j`aO|= ̓K0h]t8nȗ0x߉ts":9mm'@8;WPY\(:9u#`dCH3'iAGsBSY%SY=c1/}_wH$$ܳ`2v&1n ]fBm*n?bA E_~fո73u gNޞ%_ƾ:oݛdz nؗ2R5uw!(I٭b ^,D:B- XB : ~ '1XJhEudrpk\ }8'[al[ʹ)ᇮ߳]PIyNr wG;gP2=5JhI;ibe ;Ə X̽gψE[̸`O"
=g嵱 x v \T;m er:m> =ifbzX#Ӥ '{naiZLbݔ#YqՀGکeK ձgw>e8q6m,; 9TGrgJh,
>xu;Sӄ~mioTﲆ~ ԅO/鑹4| Oߪր2OeJF
8,uj۔.`'dt7 `e:Q
^q1kK uiC.,/O Z|Y @_Sk00
m]ϾqۼlMu;S ֮l'G z6b+gpRyΗ$WE AsWzE8uYЖSS9[op!ЖPH.|-de1 vQi6
) dW;6 cCʠM e?+"e'^5 >嵐GcEkgc[YKPYTC@{T>33 q$.X~@&
g` oB?}|rƉQ X0SQx{rpwq@ ngDÃ' ~qs[_?fyG
d5្d\Uߚ @ՠc!%:usW9E:K T1*f(PìXZ ߬wq+L3r:P lNC#,^)[ bF5$nnouuGP[ R.?zx6 Q;Z^$ݖlfש=ĭUTRC!huvD>gq@u41,}^\شX؎VGzCąﾟ~7~ϥ,}~ Ɖ21f tP,8TNиmO{[[ĩʙSǡڡ{k&fN>֝1lS3t߹|,S 4 2Z YX/)J:?E(
a\562 jx EY#:@K)'DM Υm6Mj@kz_SQ
Hwkgh` U 0"xI#cGdtaĜ;!@fvz`-*a! a,O)hY v Y| Ƀy =2 Z -~2^G$(^R}5 :YLӹVuB^lXJ)סlh +WydVl oȅ3fIΠk!xdp^T# tN1˻mm t CJ-t dL.L]Ӥ !" gaeEC' }7s/"e46c b>1H_꤬ BӰWY#Yƭ3#c0~.-@dgcW~RGo{cPdmcI"\ e{f0ZzG䳂e?9(\A l thپ4H`Λ} 1١$ʨ F*:CFǨ:ӧӥɆפF}L%ȧLi_ X^L9~ ս%k+,ۘKIƍ{mXٸӿ>ϥ>Ϳ:W@ ɂ<6،w=$vGw=io IZ8(Aft&&#hmEiw[7G'$Skmi r( lK4c,}>+0% RƵʞi @/ˌf^W·3eI]##ؽa\pp%SXST2ɸug!/'!xogϟvb *tr:VsV7.=z4H6Xۚmsu+v/gsсȗehFp>d`٣tHy`)g]=%^.<_
אָ l?AxބiPBct *jV9yܚ|.ug^.%<gs= o+3lsOK 9- Ȥ
("6=e&hz87矼^>#z82Ie.BXPB_$ڱ=5!چMNa@S0b,2bP,Ohk,pԱ6vZ9Rg,rLۀknmj=܃ޠv Hyw CÈ(< oxxrwX796snii
DtIRɖts}B
gHy]l=n kc- [4+nT*.s9kGG #-]+7%
i|`T9DPFڳج(Eo} PKf `#8~StާழZF?VxMX+^4 z_Li2OPo >69B% &P'2dK |̂@~6 :Ɍ- NuBlMXG <|d' \ 8+N+ @%^} S~,ۇay: 5@-"ml] pTkNP7w?Mx#0u0Km֞
r{4~pf9,Tߔ"X Jx{zp#ck%'SSOoʭmf Y#Kk/֊ːd:d-9-Ho@؉Lؾ0GYzm%vR,Q 8p[b9$6lPY&2gG66=هw
`V/ U\dM[ؿ=do:vzX]×aѸV{? /|n =\}?m_ /5vw,#|ҫ61pf$ AtdTYB"̇~;ϑ2ATea3Bnn$J80"XjJ
l|~'Hum
,J]2ɨ|h,J@F j Ba%%P\lhiEQ FzݘyqX3c=dn&L[ݙʭ{ȼ
2hvUP2흎@dm\b=MgC `f ="ֵ$i]aL 1bn&\9ݛyY / ;)1CUVfO
pe]_3*]2@ֈau=
5m(вMvQ{^*|^!H<
[w~.c Z tfρ J}ȥ{6F 5Leίa\ Dj=v<E}Ӂ}.8A3ԇP0tJk14Q%㣺?qH~JA!Tmtm4i ꠲z2ܗU ;^%:
4Na,RhY3Kq]g<ګY 4yZ:ILY{ Rͽ.q681TvBy=YRht,͝[ Xpr a@<}a&7Ka-Ϊ61, L*FxOc)>H4kyS/}I7Z%W @ IDAT f;ЗNjе47S c*zf\7~|=.ӻE] @h)K
g#J0zPR\a,q(
m
{z >[?~dD~D;Kާ;)
?>˞@OA^{FZxC>WNTF0` g id)1=,Q#99"i'0 zχ0dO^
2dcj9LK!NdZS7rem߉NlQSA=-1UBi
}{ee
Gz 24>ęgO 'lM9` a)L?>C:{^y1ۜ] pv>l3E
=91_tJ%@RSʚ/ۢ
qя56Ҕw H`!{kbQuͬw#ӛ* rJw*Ư(c g@&Rk^OO߃#3ԢCΰ<W,kwf&a I"$ 2A6m\V"g\:=W U mfJ:;.HcFU{M!`w gj`L,p?G6-1uzoog`3} &x(3ɡ3 % Nz{Cvul풛ʾPZR95vC7*[C;Xu9sxń\>2 W |
chk6D[Sm)r.upL=Z[l9q>5[AnѸs O(GG0 ̝T=ڠ, ^
`Z}4~ N\ɣ.Hd
tɳ27& ݊1G[+6h?}Wss +AUތ@~bgp^ ry]{YN*d
nݺ_d~&G ' 8l?S_~ƻ` xHY4[5>"cvH哂nikC;QéS4q@M
k_!gB3߷@caXr¿Ev g|(437 ؉15d[Pp4 CSvV6 %X ]Jck`s=>>!N@2۾#u 'ɘ 24TZX\K?a6M 1 CGxQB/@ҕҀϠV'$]Oz:K=ґ<1HYי<څ҄am?F@kQ(U(@E0 FsEjdΔAˠ(Y@w ]g踠}wqm>fF {N*b ~{$V+
oٸ%:fH}T7ʏ
옙Iֺ̋ϳB}.z_H-W] re^3:= .ҌE0jFڇk_ZS 2|!.:6Qr4oq E\[j#( ώ ܰWv@.vq lP{lPA6PU0[6ytNqШ1)4 m2_@,>3Ŵ 29ԓ4FɎyw\C>Ν2 ̦4-4(/idj,\mg`N3>U`]l(Q k (@μpWXbc 1ʹCHc?` 8vv mLCÃW'1kkxYdEaP Rc'=3|fo.0VĞ
03þWw )A\D VƇF#c.AGw %u38FHAwNs "/~%JNs !9[a" rdlfrkG A ,ڄs~\͠y ƒm I78ƞ^Mt1MD'v)0fFFRֲ=ٱ`kTvn芾 2|gT.Ə'ƹ V9tCcgQoOi!
n/~cϼ^u䊌-PvVG}l%vU4$Rϝ?9_<ÀWDeV LA20F[=E9
ndh=8?~ _"킥j~U`N =l52CϿO K2;κAdnLچm0f@&Y <ɬ` A#Q35PW
(w 4E>U0`NÎ03^HO< 3 28Ï0K~'5g_wܥz5 8o ~@}!H O =
rbh I;o߈. e\P|icb}lme4&<ig
ܴ9B)G Juľn2F 8_epթNsm6+`
HFȶ]o|D@-( ^V@ G;gG2
/_ `( )A!%ΝM?
$
u3c "R?
9?G&f+;~6BtȾ7tw3hn2 6bKХ8fM ` Hp=ڞxlmp[AҨ05 U)&5(NG ڈш4
JJb2U,ںiz~
}W
[Lڷ{ POߣg-'ك!h BpH`N6YR!vW'$P+[ߧ"5qK ]j92P◺Wںbt&(O}9sΓgv6
$-ʥ*DR\eo\ 2 TKbeZ%HdH D,bfvNy:p;9wFt=yN9Ͱp #}Aa, | " G7.1р,$Hυ>~)
0j֞D=_y,=)!Qˮ%++H`#baHk:{
0Fpz& ("Q`(N&jzΩF}W97px@q&q&NJ/Z
@Ǯqc$SAIBG+ >x0ritSl2zam{յBgt蓻L ta* tmm/Фu\o7,"ac9GנK`l{By B0eɸVTKGuFr)džYo=yBE Iy` f3H`] ov0$קCpBu
=#XCha4 2'I@2
AHKʉY rU3_'gF *nb& 6f>؊cӔNR:LG PI/$P2!R!(S!-"֨WH)!C5d-:$<^)Z5d<1`165F&b'
8j59߃(
P`FjXME`Xq]YMYzYFg: D k-YԌv @Ej/..gq?<ݯ:vA': Bl?4J 3:f
{ htlwQI`?x SLK7̘Ys$S L
g@ u.ܬ'p8r)LΎBzt>Z:%ռg?°l wŻc2Qs(.wrwN| vzx
4?jLp Ym~ iA1A;7S)A@1 {WP8fj( agLd2 \R1d[S}~l{ed{ogN@-?v*WV6YV)l ҜM=<=- "(\rkG?
`@{-Q9#f w'lW70' 0=.} 1]>BPmd2eu2rj(c
`۬ z@ټ0 N2ك /o|wLJ/ ͡}Id07T %֚%2qw퍠IǷptS 6|?H,SV> RmgVp2
y͓7rtb;{1tK+{Yc3]3J= 35}DdA};:[C~QJ$U- /AFטz`yiK@8B* -x/̀)߄C%eZ7DL!P2UWɈQ&d`{ C =Dҁ b-0XM 6[Yi>cs솚_l`L=l]z0 r!9@W`(TmC J6`@j|*L,X"
&߁<ΘvS A8`Yvw`Yؖ jsexuؔr#2Ɩ+y+=OagKa $Fc%6٣
eZr@4O(5IYBBF7wPvGScf|*i^_owkr=j :A#dٟˏ'{Nt2Џl'< *F wMt.-a -GRCó| 3_cIL|JrɚS&2Tsv$} 2,5&SgLao?k K}_ '2]7a&8K&W[360ji [P^zoIcc>=|8 ]BŦ0.oϼG|ƅlGQΎ\6|?Ygqk?~_+4 9 )ё7Ŏ֤
)҉0H cBr]{6Q+κb!#lr N=dI%$#jVNA ҝ
Ԥdb s
:
t'!ۦd[ -mu=T:`5(l+A6 `Vp{(bQ pH ؈˚ 3F3ax 0 " HC@E ǡ\Tw
DR. ^?Dl%"1u2
̋ sdMӡ4 @(dovvtAGo
eyy98~s%T/h(
nC> Y_ ɱ:1%( c-)bgb _C|
hm2dhM
%uݝY|'Oꆑ Ml ,i4އA5RouuJDWg,]Y;r| X5Ksg6T;MYj129?yJ!q+k9 !f|5tvve ?OC C =Sf6ETEmRhoaּLN Eϒ =xDi5 (
nm4@"YY1+k
|]dÌzg߬D|56vxQ75S!/ OȞYm~[v_ duE,K9,t Ju3̩}Y#\1Twɢ%sN LrXX`zh
{0(U>5R熽őAr gr˅1vdx(\ t=8iж3|(< Igt t=vw,X ڑ꽧\
HS<ݳMh1q*plBdAՇ5dp [p,Lܟ~ͱ)GMNVڸ5~6GЇ!>6Tpf K"u4-m䍠`$Fp Jz g& =2)i`oCK8J'Z:;Ap Ա|BBN p xUG}@r>*ki`p {W(k{xFzK4;AƔ kvq0O\ : fLI)M1b3J*Jtu%2<LCGm l | I3lv-՞O#v
Y^xJ-aϮ\y/ "`I}B.,nGw726;3G^>?` PosM }K- kgiXxA6uE|ᨠշ22tB-({ S=,JP_=g>G;L8Ki v=K 7c!2, Z7o&xj6E09Q
DcVm(L_'ԛaşTTJ@KS862ηuړ!( Ēf6{YbR uQ@YeiO3ML[rvG7;(CeL> ShX=Om
3=( j+;r6}^7bGn.<{fT+iᘞ
Y]ҵ_&Sg;@aj|P$ -A6BmG x
6&k&zYX! + cA0#($H/{hxs/|JzϽ^} DƆK(aj QGulC{{gM'az2
hT%$Ke+v]6q j
+r[qϕCnWyud[8qU-] h ^Q+Ns ` Մ>g3g0B ِP t ʮlYCC&ϑO+cNvE(t fܻ oS',YsX2 ۿk;PʌB.h) R"\
*
i;ݷ{Ӳ ʇ }?V7{YÆ $j4bȸ!*5b[`A!3<+Վ{ñ3` -mw8:$Ly+y A_"x:TP
3m5 k ( fGH~:t#t\8?O =Phё"qh9t6)MsAPKj`݃cTOЅ:ihd-Ac WQ8>.b
<*
ִr
:M{+njt B> o銂;yGE`I{:{P47t*< נ>_ZqdpKXHl4V l)*pJ̇NA9#w$}p"ك%)p3:f]ȡ%>t*m'SUplQG 3_&6t=;)" cCJX#ܰ'8G0OSI1f
q < ' ¨Ky \hFfޫd10m0Z (=$/\:*J3CҀbG/dd*Y94S7}$z@ p
Mz\ Lu.~kz)m--m
5G?fx8fF+r
.B.vN1;${E¢Iiy:
o3 }|hZƿK˽i ^= EzٟcW I4*
Жk1Ay)㢉34hK >l0 Ø!H桯 رZGlM0bDA!GŁr"+8"isp{Lr
)&rVANU
FBgU3C5:Š cˁnݭKҟ/C"6X%L*#ek 5Z.
fm'w2EA}'&8SdœaX!( *e V1uM oeQ[SS}'1N$]z
y,O\I,o%0=[ֺ>eObHS#c: +^ ObـPA7
c=gdZ[77
%/
?YE(N_O6b MJ}ȏNOׯG6Yf v3tt62r+4ӹ#:K5[ZLvP_O7? K3jR[:QI92U3:w"A=
Z*yEHh99$@ qiʗ_vvm
5Xg c'mΪ{SP_"&% NrV-P7|˿=#SOx@ʹ'0V#MTxP(Gԓ
@suzlDk \JoWӀLj/#KCୄ_rN-91@X&dw!*F^#9>?wx / ?t[<>CPJq'ٰyhjuĈSu K),K #Oރ /s] {(hՓO)W/'A7cYQ se9:==Ir]&`ľal",E| xL7 a/K H6|n,pY2t)5v F{ͨ¹ =/[T'9=^MV@f
jU < =
d}5AkYO% DKd*~_
[ Y7_4}rsB9UYl
A5 {i(/F($ x B?& 0tv `L
yt', % F;iO*1QDsFe0yR&`1d8+QҺ,.~ p6O},C #`Cm,η ydC^-ѫʦ:2/]6rl³ʔcx
$mWGCQ*gOVxJ R,-EGImnFS?_C E@a5SRomcڅ4h"JI^ԷP ¾0F?&wKgOz dF# =YDG[.@//E^#Y cF P er H,.ǔN+9 LM{`\l i{m&{Rbblb dt8 J'=8Ⱦ=,+\cK@^% ʹg<e$(d=Ì) EW ggKbYo@^p˼gRϩW @Sm]c}o][I?3 p&?g"?ق
x)qtRU(dg Cʆ[M ̮P: ]_&
wz'#Gժ8(ed[zz:嚆bR/#71IH٥e(8&:z cF3uс.R[ښs-/OHV9>+mzX3
A x@R:4!=LHuR`0ΙZKrKބXJ:4 tH[JRgǽ<=fo{{q<\
ƛ(VhYd I[gSptsDQd6
lT^@a V ::Xԍ,
J{I(h l̵I)r u[NvY+'0mh#k8
mܠUקϣt>cr88Y(244d珐?n^'-:_ZmgKH30kuBT|Z & Gr_'Dܱ<5 bni Њ@{d~`ƈf ZpZpBK#0~ 6,-BYEt8Jq^p|zuKP֎A65hx g~fv6$ FY/B(fxN + f4̦y9 `JP BGY@Yu@jCKv͚9v
Y12k~1*
`=_>FƆ
Q)|>,} KÕ2HfseoIA1wl:5ܭ`ט
6l
s4tju"e$x$rJpn৺T!9[[!;TPhx -sdh˷G ;K}rF{,2u(~ ̵k ^{e8'^}ϒjx,N;zMFBQPoKYg$(Yg3i,ߠ1 yfJAY":ȮgLP:*3?-,./ɒc7$gw.[o70% 2dC \ׯ'Hyr==NTXc SV7ÙV]oB 2vl8Iqm2gN-wN4~+}̂&BP=?x&24hH4I[jb 2 P,`, 4h$c۔SA n7s} ]vAM!geMD0k$TOMz{Η t:$`uu"Y;ԕcs8ś
$Uu!ִs-v߷ dslpz/(市x@t|\p海b!:m Zu3ܮav_If ta~/[\| נpG?++6{3G@pחhha:
- S@P⿸H==( OғC?2%WdعD6y}+md 65 0^}B@.cjėxPnYK:s2[\ 2hdM,!/#^k&Ss :D '֗]ClP|r&Gg^p"`G`m#Yų"wޠ rg;E|5L-^#SQWYECika*$Bp+чK;fmhrj!23]I"3\Ȇls˴ ۠ A5Pe2 G>IV@_/2F)
J3cH }2x'ƍhAF019r `yV[[+۩uhnG[Mg\X{1+D7@h: ɗȐp|ۧhwBlqTyܸmvS&dC
.ۀdc'ٙm<(v{`H |_Ml.t 50ؿ~/6"{6@x|怃ّ;?pii D T EZjy c.G*J]S!ʅWڥNW+YO#(O;Xvt!n䝎W84maxUl
MolKk)MA{^cfS6XKWf%Ɗ
})gǢ9w$$Y9MpTP:!11iP5 rL!Vϙsfj(kM*x/;L## 1b aY6) K-捖ϑ'52O& LSc47*1$Np|ׂcZ爐raFj9QG .d@xLc.QB1߀
X?}M +ރtNwv
Xg ' #D\
Gx
PR2m U]w]nsAo&,#Q]Ed"
h@=y?m
96Ȣ
{"2Sn
p4|86Q4˓>Hu"9&={ &5/ p{w& C8t59^pWs6W ?9E56C"'@&+?qy *ɞ!\ 8{12k o8ŌQ1= |r@ohTi#>3Jrf%B /BšL,L]o{9gƇ ͏Z D L9ZGm9˜8 Av,5~Yw36L55yy Bbu
28qvp\4QZ w
m 6罔-ft}kE 5r=j4Fpn9cqMT|6 ۆbvf tgm+k):0Jh6`R,_W R^ju c cRƁTH7XcW14k]u:`6pCkueةfwu"֩F{ڶI=#d:=AN`&` @ IDATDeSjj5F$kХ[ #`n\02_2/Y7{+CW*C; 3q> 쟥s/` 3kYct ,I[PF?tr:]n`A z&W`ʁHg3 @0JK28Rxпv[]`))«ZaЬnwaY}3*{V6/ll\` ~v
QR +O4i;CF{
Bv;ֱi [?"C: )ji|27Ԕ0
ywAӭsm'UA-fgeHy}N<1{/:eJ}^z-]AoqFYbl"{f\o
d K/GɵR?eE 0=6I6F]pS
A(~K5HG{;^g݃EA0vxsH `JS90va4:-5 F M{ݍ bzf\Opys@ч%
)#.# GIt:?G4F7/+?lkM7 =g0Ec6]8s1m= ?${
_褺V W(g{.;bJFeoH=Om G% PWQT"H2/ gJzZ1yd8
yq N' OR#[d)Hݻ@f?;*Ko t҉`Udl8PbR뭱q]r UhyycES: *hyJ 1H(iea4Tв':ZPV+Wۿ~u"H qDi8u
Bc2le Qѡvմn b`H؆ ֵL;wA@/,Bdk[,
tCvՊg 6)Ihg 1)G ? 45R֧oz,"(Kj
D{ewX" P\L , e#50SuCs ,I! ϘT$pd=P]g)Kw&k Dgx6~"6Y*x>v5ϙ&9C QFK_,YQ?^KXC-3_[Y = djqd yE yJCZ(%7pg lCN>* y(}"\E6@ g1eV5mYQM^N
^L <9̠ c%ŠfmR"`̴8ʞ'!{^nVc
@ 8J%dxYnNƘ% #[`,l818q6y Ph[D>K0ǬK f_el{,\fj
9 XexoQdcl_QvFS5X{:uޓG HRנ {:} aY xhoc }k8R86` VKR˪`R@V2:NCJt_76GS Kz8k}ҌKPfa.ь B[gqy!hA#2.= P؍G:q3 Xs{tZ #OӫO&=d[Y}s\N|IV @da@eil { #1J!ӗ=LNO\kk }gp>lmV-|TQJLx$C@`ǿG&S sؐȈ[ x _rM#5q~ BU]e(nUM=v $
L9 T2֚YY߈6>vy/(eߗ`sjFr5U&]ϼ큉Z E+ WH ֡O+W.P(T
cyJ
v-- Fx% b6-'Xϻdks y&>!ü _@r- _[4E:js[({F[w 8yn}ܫzgfl`FJce}ŢK-Fk>es:T}'t)?c٠Oje'CzB*~ӻ32E l1. x , Z&1Ξ l"=n(ύo| :Te 0M@O?@VDy( S9`]=OB9{83Mi/Bz~PӅNDFzcQWM9-,93t: 1{?n=f Kk?$I`''pLɲ~r}//-crv9{Q[n'2W M9y<=AϳhT@C#Y R ErωƗތݧwHLa˨?^#ÅS M-`h lf)gaN*}VawYRpL)ken= 机D? 5a `_ko0-&Ź1C @]
۔ _l L$f+!(ĵc+cg_>D)e $
$}X}ʼZv
M++"I flI(6qds,jLN@f8OK- >i#<|X߾J3-]ϲ+"3q(@dD<"X"{@@4Z#M%:>7fR1uN<ʱSkw5pU tuw1e[f0<n t:wt4= T : T=+C5apLB> L,Ed=*QżfDz ihr Hƭ#W xaXD "CY@:gvS{ >"K=
`،YJ`o*KEtMm )d2}sbDQ# Ym91m}:tm28c0u|nO Щ&|Ok'1 *c#$*=20se j& **F
* Z32VF
YnS#С mjmcIQw y ^' MW+wGx? ;`k{o3uPH64E$Sg &hUGOh
VjK_[c
uMT R/SZՕ~[ WdSae|Ar= ~µ1K{d8Q384+aoD mkILJzR#Y2~=[bO=VT} ! E
doBMC3DŜaiRg _ϫ
ˈT'ZV8fl" ν6,ArgyS[_M`qʎ~GuK$w` A} YI` W` P?ۇf'#u 2XgNyv\OOe[~&>?Q6 Ii COOs Ks$ȋU_
쁁qqO=_e[wo*~F'.s_@ Gm?o$*Cƌ2rd'u3RFĝCIFZh5!`:Χ,MJ (#ϵ}<3!lhGhăgP~4>П ( ԟfhBVgk} ʡVA3=m=lnK\ 04.l }x
>PfgaeLMgɪ[qlU q2#طK A6uY$}d*{f!CQҕU & J`xFk`;7 |Z=]DU6ie_6u#Ab!Ʋ;CU4|O
*Ua\&@ L}S%bh==mq=CṼ'qB18+ CXAm/N#u
@P<$s%Qi[t4y:S>׆強 U3%& 35Fϋ; ~mF$ͥ:yZiۜ^|<ݳ A, 4ڡF=CКا ]ΙJ:ʺ4x ]ct u40den(6ִ{Y'866 EKs5j ZrS2: \ V~=kߕΚNٳ!_ -hd9@#2.xFF9:TQV861*@vٰ:虅FI9rf>J}FyT^P\:NtTa'9Q*/ ?p"I, |Ng ;Q)KRqٗ.2=szo!q\3? k(rN9M, +vK7x[ ̍_ִ
__8*oBc&TN7vw"{f
?};ڽކ<:_ t.9ydq e5sK! x{o֏=wcYLXc eQ{w75_L/v%ac98þ 0:FkS%eƘXr~+<:~I)f <;P+8 ̪Z>o&/ϴZw'ov x~-J0y>N `;d}w>l(<Z(ytiϳdكBߣ{ |B Cshoo Yi_y#@?='#L)!v {j =-K|zr6: D;9biӖ u `6D 3 c7ԣO^5n߾Gi#Թl8[VC h{ 3 Ƀ&OD{u=,SWzA @1Wѭ[ jr"_#[ c(<$=>_Z?Z>`p0<ˎd
ym8+Fc/GԢcOPo_"L*xY';5 jgD 挞XAkc Ø<
* +-8TL!^^ZL ~Azj #sߘ^xc|I fY#41\)HћڷBΔ,,xYV^ $ yʰ
Y;6va+dQwG2ڑN~191# QzsLR.wRG%Zt vfvq
k3:;2\9 fi:yl5v)c}
[MY&_F ej[# %O2ͳ]3s|uled='/ڋEdI
T+䟉5Ȓ{ 86FAƱ 5K~ 8/EVAϿ?ٸu||&ooWE?#,bA?j*_ > v+(:з jvB-
Hp# 4Z 4PCi,j\ 0: E4
ƙKMfz{u <)iũ*k"㋂S!:>ˀJsD AI۶syGAאڙ}xdkZ:C9|0&Ѥ- ԍq!y Č,LgwkRit*TGZ MR 8|S\q b +7N<N-J4S~mib|C
5 e"0QDl wBY7 u_I;nɇ
O%e%j|EYCgVڈl# M |
u1 g5:WG+"s%4AN'=9+3^%UtCt1s;A2,ÉYi;CyzE'C"G]yQZf sdEq^QMӞ٥\uI{s#TP.|!t4 n2dCΜ9bCc35sb 3 <gE'^ 27dq:9fpdP)7އ uD"`1aס$M <|&0uT
m" NeW&U
g5HyjQ"
ey5õ߿9kGs^CX[ke>Di)$+ he)D>|`ߟl^Sp-ʊ93w` u\ h~n@G "sagS a 3e8-(V vMqn4ޛR0kr
k^ )_Ø7 L06<__)p @"[8H3 P"ۉi ѱ56[S&^6Gi. L-7հ
9%QU 7?:pOc[ &òA&U*]f#\8lQw[fs@u"LdɵSVٛ_@G {2n)=kZ?̓ٺO}y?MSN:Ͳ8#:`m}C}b-9X >SZ'{nE9ikkU/fh
Xnvs_k
y2>OL
8$'v: }u 6 n:fc=6( RV5!W}t 4W OmK.v>asǷÈOaͽ[7 9L`5CguV)8p'Ei ͱqC4DD(C #~^!e!z ~w ^?G^-)cQ8K˕Gm e)gxkȗ{y 6ck$;^XB/NYe Mݯl/P39EK ?y7L֙W/bsz:>i|rXD bkbX e{ӷZb_ =yweG{>I#,#tZ4e-ad iCؓ}4=7Y y ! M Ⱥg5\59tc [=+W=w=E~ػ}2[xHm`L22ވO戴^>a9iJ1Cr?}b;Rs=ctI*ڵ4F;O2${~ CA? )PKe[Uֆ R
2
p$05@{'/*
? t,v3>|(uAμp>}k_Kgm8uW,9qalx> |$k c>Ͼ0..nq k6X K;z{U9DX%z@lcc= #@6|>>}
Nc'=]
Ȇ@^{vO:9č
'0wƇʉZ:($`2c9E8>;0&*h7.m?7t7kg{ +VWW]/7]^{4=Pe?،?oUZv36иuxnATDہW:B
!B5
Y P81i}
$;#3='ƇғYSC2
J4GNՌM}icۅcAø[ǎTF 3ԱףgF՚ Jy1S pT qlFu8C:r2?A߅5> LC31&p,M3Su6{n}wǬrb )OC'̄р|wdC|;F0 j\x^1ALNs.Ϟ=A0{t4t:$lmdZ2 $1D3}1b[Y!$y~t .S& ˀdcIhZqgGPl)[ـ #d 4C,4zk,c @*Ḭ>'N2v#ɵF&T"Ced @ bS(j n9 ;rzXe`(Gz
|M#۴sjjJdyFts_f Wh347'uijcFaɾ-ʯR:y ].
+[Ag4܂f dq >-)Sΰa=ҕ+Q⦓lݼiH;NpmąW_Mg_u? );i>
f_zUY3Nq[SkjSY !;C[WnJv bC,ܡGmX EDC3}sna"? ޜaA%lS ,XyēX !Θ
` 5M^z@;:71YCN9EƳm+IP̯#@\đlfՋ> raU{m[^DW 㠳339;+d'aE^M ZTq-̦7n~hdn ?]*q+H@Q JišocQ^[(ú3}nOW7})R@`wO3$BT^0
^+ MЧ5 \Lowi
-2E; ? `0,u*|R CV
4sL|N U/F?[?d~(3&Fmjo^^v$?I -b"_ Ce':
4#l?@J4uQ _31=+2)P75:Jb{'>VB.\]P̠^, >8^|@&K)G.Sל]g8M(E/ ױd̤#k ~Ak ^pF+7 SGgk
dGʍubʬ2cOY /1/'XGܷӧ.z/^, c /Xwb^{nϞJLYb`z{}c"gb"/$;m?ih N0:ce>o ݻ:t]X4881>Cד4dƇ K̾cD e?[9o z~ %5@XIP
[}6a676 IZiu;Le`'6cYvؖaL"6\w >^ GC#KJK˭UN3ӗ2зñP`I&Y4foUn??ϐ<|W6>S 6` hMJ n yP2)x|ݛo~o|~x/|:.#G =? RJPJ+2QmPX"P nd*qNU3g8bQ m'Tl*dIn`h؏<12Ķ"G(TL%F
6 Vkk v0>8 87
`,
T%27ߗV4!+^.;u=!BA6b b Hkҳ+q:[ {J'~ ތ7
ŌTS!
L 4 c<͛ ӪR;+kH/]@N@9P|dZTeqwDPn3#d't{\mK_
L]#]pj\JOto nڵZ' s~<\g g3t3U2 1'ކL5aCppbn* `1נ=Ϥk54H/m$#q _,x7 iI`UNt"ݳqiQ-1lG°!am 6t|qt2:P_x%d cL G^'oeRa8ߛ8ӫ tD + Y@ Tfd uk~ZztHyQ U7+i~ƨS70`~WOo| V
>ԠOX-!RYSm :KjÁ mmCK2NZ)8s h"C^;S^I_tg(/I#-2C|fOˇ)t Cd$M1,Xa0O ?9 {oApb_~p
Z `V(!;j]BN=;e`#,
?{ai:fc֕nvЕ} c@abFt
\c&tK_d
σ Q!8uB:wsk5~,ׂ Y (A6 wci{3#}eyo g #@VHЅtÙ+A @D@h(4l˥yBDutfF{e( K6
4=gH-An7:HSYU~lFttF#3 n]̘]?&g[;zƟK8,+y}} gE u3PkϴYSϥ_s|+ /%@yՑf/2,+tftb&KrO]L?$;>TAO]Lrp,HHٻDG sv]F(>'*:Agل 2Y_ܘ63IV LJji\[>Ѡ,@xNȎZN&#ݝ
moF4_k3}Et) l#&^.OG( 9:tKxZ nΟ] unE-w{;ԛyL: efrq6fb-(ݱN}p/?"{зĀ wPop {dclC.z: KqdVT c͍$ = ;7 gkd!\@6ϯ[?r#'8_gUiA{ A{ȵ|QzD2AQVĵ]0r @-=[9 ~䳱YȐ me'/hCJE0K)M5OiZx =[WO6f#c0`HcG6>F70k-3G>7\3zaOdJ
x=!.N3AjvA Wdi <2Q/*&\c&Ls
*`URV8G6WV?+S4zL~k 3-ρqI0q #E ll =QL mS3{>:?_ 4p@WG WKq>3ste4G@v;A8:r-j)
dm 3db ,Y625P9 (uhPHP$*m&7݊uN.|u SuLhNU(eI;*zq|K 謂zA՝l
ߧ_ަV{:G? ! s I'A_*HӾʃNWpEY,T}nnfv#ݸ>ba&N"=ӎ#DZxd
p> A%e3::
Es妮硼`w1$dAqL` @ 7e:8Kv `le ٯ Q^qra eӝpͦRTeؾ^,h2Rh[[KtV# Kï# l0IG0~ͷ옲aGlq gR 3! Mq:2R iڼ!:yK/< &b!JȚ͢:sf%ACv-7r6}rx鲉cf=63E
@5f ٕZZZCK]~^oǖWE ,RuCG,zVR,4S32^}$Z/3XBYx!3f{)ߠ8FBc z8 @$6YEB(l-[_ KC 2jG G| mVqt89[fK"8+ӑDCQ_l͂5㨜4bu|)\xG~ؕ*GfBuΛhdҞf H,{(A'L \YC0ϫ
B ( 6N, A%k1y/,L3=ׯ]qk6} })Pi˛쿵<
%؊ Xb4ZB6 \ Q)K?'I1afiYEliP >JѥLAϝ% k"=|?K:z1};
Gp9RG*]c}+٥_O$(mT aUq
K`RLb;Q}Yfb0%ÆŔ.[> K=_ EE?M_K[gK*3fkf3 \t @@#~ylDC'xJ-6zr̠7$Wd sm~r|&^i_n3`y5&|Lr'0a>Po`|hkA%-8Lkk' Z74lVXY
g',iaE2Oeʖ5Vp,R~='aBM͎{\YGd?"@ٳ\{ƲʘM,M3^֮S{Atxkw{^a8`_68/6w+5!@CCj
3 YCEi%S8樘5
Um% Q
4 /5]XK"9EQor46%
0Cv)2%g #wdSa~f~!GB0ꗊ}arznGn7oCQul3y̏`8%)>ͦjͭA1\ۀ
| RMl*R"H4Xn
D): *UiCJg D7X+(^ n*QQ=pf\_ DJB)GfT(4Gښ:H8E:>Ā?ˮ
\K]%#hi ZBcQY{ ]!J?zp<EGyEΜ!j.J=ϤZjoRX"b#!K'>8flwsU^Ӕj\a5' ʅ͊W!
JA9Fe= ~(NX_HIfY_#U5 m[
,A_]OXp@
6KuPXÚp:H6šno bcj>wİ ` cSx3O2 &n@c?6te%d n7::+ޤDn }OڇљvWO
3lmkrj22;"c)PAu(4b7+}Nt6.%]ã 5Jψz BZf Z.N|K;w>i/ T|#TPf
,9pVk JW=FR~Cm O@4: ]Dsgi3z.uNٖAT֎Y;ulJp qgF9 |e恾"Cfs) IzGF27t Ӌ6 MwI
:3kvu}e (q(hvJDuPG0$! !xYMZ)XO ?Lދ斳d~
ڱ~:ϐ5úF`6dy~Y۠pgʑ gٵ6 h636 iOp< r
gbjo;tP5|i8F_:,K t}^38(༩fqRNp1zdsV ('
S=& ݂QJ9e3א{ƹyu6ĤI,N4MF<
V-/H' `|9a稦L 虱瑴0t1^6]Ʒv3 4dTf _Y:v
lo6~SncU)$0e2m#6uk$h&p{[gI$6%v}gC!qZ@12%HLaA,slfi2 YFG&$urdZV3,83D3>dN'183=s,> 2f 1^DMzP2lf |y^t dL.aW'~Nt*;sLL@> щ0&&FfAO bXq` h2j&(,WҸ() o^0҇.R`vL]9Lw;QgڙL_ L3"*1݊ ,UP^uZ_E[7&'"2?D ~ \z!3{dZ̳EΏ\=fz15t[$ùlξ%I Uo ?lU>K& ߖTbc/Ϣ '?ӗ GLVl 9V{3Y'k{}&uя'% g l:8<ʞ\p.7[BR$` u )! rΌK ɇGb2MwkXz_ޓY,.Wx;RR`4Dq]F\wvbTkgu, /{gi,yӇy! 'ddLvʢw= ^VN,_<Ʋ,T( { W&>T*GGRfcYfeTi+>Ȏ48?نJl7- 3,M:OA5a(l]O/ڠD }RTuq* wb Cֱ50T,U" M(Q:۩PdpwDH}t
tЏͲ0RkwK:xS@o/_@+|
X"(gi0 7 uKR< 7hAqФ\ <|KY83bB=P_k)pߵ5bܲpSOoTiry4{_nKx,5[ oFr`5|Rd]3="d̰/$hy#|k*Rku8hpnvD."%4+%]Ÿ M8P8P۹8t]e0wQ4PG+cl1] 7Q+(x35)ȩne;1`Y e @wmIfg&KtԺ5Q8(J ƴ3~.=]iћjf dQ1ǦffUHE8I*ovVl4\ ͦV,KOFw`
fzE#;k qYBϸ}|Y#pv)|8XdN p>?DA7j rykECEJpry2.P.d~f Ȳ<"(x @wdX_.gc@pb28=/zmCsziqL
}_'f=Ήgsl_3YN5ތ9[D6A `(ۊ,J^'PDsik4u X T3# !\8,:1- Hpt/0>@@g F쬵PKq?y
ہuRqJ jnL4Ef u {+E>:{6l`uf}SC
@]ZxN}:tMadQaq|GRG3di(-G鉁:LKQlpݭlAc4 )+" g b~}@JTp8E6|4lH;f.1})ku`9QCƇmtӇwv07 =Y4xxe}Cr5̀ӲB2kz]gaX?m)_242
PݹCK8\8T;8p'Is
ۛ7üaz%d{eq!M
豧tT_IlY wQ2 ݣs9L2U5QR675 ߾Ih65t:CR
paY}DɌ"WÓjAaNfǗ 44 0٠rW `TLU
)$t;)].{,A7.l9tn6mr:/vU%j]Ko$]65S~F<_gq__OO턎03 V \b Ctk
@S@&ߊ}XbZc%|ԩ + OSО9FBpl4%ٕ57Chuk v2;1ΞI ~q M>c;6( !] / aԟ)$5mmAw)MA+}l`)A / bw5l8FVg
0 tRKOmG.`%xeRݽ=魷^ܷdٽTڶE^ 4^$sp>U< d >)aOs93r|~։$2IJx;p{qޕ-nCYL_mAud#[e:R
gs &Jȶ8Vt6Sڇ" cN}mCM쵲8}~&2e}3u3ؔQ_5&ŬA$L2cJ&Fs
+gɘoRy= CK;q{
`,kK6hw4-r aL^#e v|{yw8|6071:$;w_ߔ`e^j ?] e ]NXӈ(% Vɞxet7tKGsEgl>a_-C/߮ /,{:=95F۫_62d \l#{4ތ+=<3(CFKdJPByl)q,' ۊ8G;ḶBL xedb =+w49lz}ƺJſ/?]A< _??ޯ]Ɓh 9rrv58|bOb5
]pE
؈KtύSZ$n=_dM<8igޣl Yb>;s(PTѐL͟ PI , ]z1t% xFlIȟ~۠.p48Yd>O]xtG!R \;
<z=(f zjPdTZ`u3f6/)"qw=OoZfRVDסr g7i֦% KQ`&%VV H DȤ(ِ _㾨/}P "'613cifGgФӁ7ѸLiJ V9p=QL,"vu=u (oP
=SxϾ:
rpNP'8U=Ѹod &q=J݇rG;3d>?z2~ō4); g͐@.n}k8teؤJz$=@"*jwsZ&3ҙ9G]CI
PsU@ G& Du7 "8YC*lTjt y >+泽g!D`
@oZ~ϢT_R= +-XP\_1?)/ HGm-Oe
RL20to]62vٵ& 8d}[k),UGgO@\}Sq
t
W EԒ(j/g GgB?(WR=MO30RP7^{ "zH[%# jY}2jz >=>9>IwOG9.xlM]MiPG5>vaz_⿵6Stg -o2c`o3SP%3۰e[K ,g3n0Aguʕ O&\{#(Џ2{VO+o_-:\>hG,?| "?,O 86ֵ-nld8`5j ;7!kyDA GNrITXƽI%5zjwt==ee!Y,H 8
}a X:bGޣ'La0;A7` {& m.8i=PN+il盱w_
iQ
} k'%w_@|i͚G6rȘ2uV> "&g]}+Ƹͳ p'Y; k
"~xdGq! c&؞ GYf qa# id,~[4)OBU 8L3v T"ĖGsKF u:뷩!Lׯ RGT n{ĤhE a}AKveQiX 0S@d
y6$ EĴ:PrDaت<U R2#ȇ $iTsRqs6T9;2iG>Zn F½W7 ;X@0[FX)/ME2jh* |P6s #F vh4kmW^Avm̩!<롓F DIGoiz0pN=S4:Au83:3U j'ŜgOaPESf.
n QKAtwFkbzg7Ψ>
7RKJ{ N1zBF{kFMe6i#|fss+g\ւc; Ov? x dkr'0zdz}Cqks;) *:pg)ߚgiBZdq|fg]\ kOo֚,lHs&ا8 = g3J&Z2j Ruc4"5˂@St Yȁ\9[/!H)6vBC c= fG/N{췀!g3Wn=|CS==u_ z(= 3'`DG3 ;=2/nz / >JzC ::}QynG{8-8j*#\ho:24Y"ttO6Yњ -#n#9G SF O0M,쬄Nd zAh==x4CL+W^ ~A~M!o{֙]+h~*s3R,WdS_nA3H ?+c/J buu{a',wv:eZbn@:YF]d 3P%` GtEfIa> "
ZO ߊ;It)U"C i:)
nF
uB:^J~"*D`
:8#Laϗ +Xwq _/E }S)%]2R Vz^Y [ k)i\
VȦ쓠gF=7 ]߾"lim~Ly]b-7c}iCΎ
!m(@QVUnϢ4A'd&}<1| ̺G2Lq|
mJi_cZ͚g;U}#a+,+!,@z@1Zsp Iߊףdž\;GZ, Ok]LJ:!Jʋ:G@?xϪ}3 h,7g 3{ɦ kYCFN 'p/=Թ&lB-M77=`ltSdd
mZop)2`;5 .Mϟ sY cEM ZfXPn\g%"m>>>ڟG947Q86ZeI_4 RC&Nf(݁yܸ<3_xg,?/ ƞ>x<گ\ڴfeiԴxt ֎+L S#A0!P)8`ql BG
p͌8=HlAF>fl RUVuhb:GR"MUr@Te? &a:*8@hzpq>}< ,uVʄse e.Yc -Ԃ:[tu<@0Vah4ud*1^6nfec(g;[sʀNÕ]Q2
á14+=F eu2W`
[c f u r= VZ]
fE ͽ_c,goZ,5Z*UF) NAy_wK5B(3^EByTVa-λ6UX^hg$BU<@8~dh>eR~7["YІLN[ l: 礪(QƵm??:&3B8$>9ДrȅiHf
^@I kby_Z h/ea*qڃ ~:uˠ33aq Ѩ or GۏͰA>(&ܗzѱCӯ?U$\h;دtKJ/b%
_\g0{ g2
js v(Iz2I pL#Ozb9}Ț i,rXzs2=8 \Ef Sl AS^~Iy
wchWY(Ffl('q ]{m.l #6#b.^O9(kob`,:Y*u5ua )ϰMQY])POIU` 7( HgOa5^:ױf"< u=/}}ϡ
Y})3JS䤔#ҩ2 SFg3W[ _ǚ<,ΐ&;bCd$Pe n e&Lb
ޏ~n5:0G=" `>;~
Pʼu 6]p
) 3k/= qymPEF>>מ?ϮZγ/V je6>$GA5I [o} U@\ _9-QAueGZzgC7g`Dl طB4dQ ߞ.uO&]gV[ d ;Mzu, 0%@ ڒ 2 ) 颱.L;@ Ē
]ndʞ0Tbzy1q =`o
Nr[yUbBU;.ӹ+3q_eg\Ɔ+GjueGh78kc}XST`c/e+ G\ 3|WqXβ ";o
ι/?<$Aq'ݿ }pw x`(3}gΦJ_}5()&SD{1)d`@1Ud#D6OB/ 1! XfE:
A fV%(ϑ$ PkZ ._Z[,wN*$8d9,@4́PAX#c( ?S4A3Srw yf P|hκMP(4HjmkZS<@;XY > sz([M`Fzב`(-5χPt* ٸEEѕQ>h:fd)B b ҚX"P3 6i\ۯ![5!GWNGZnMdu0J爀p(2% *7]I}+Ϭ}l 7qo pZkӛ]$nζ` $bx*l\ tȐMH}6(WmSˬ`1m ) 9;ȚyQ
vX"!f^49ͩH?M42 cBV*+u7V.34a)A!i
2a3ܿNEUCYJ.( FaAsaUCUzwҹK̀&d ٽz TTh dkϠl)ʕr76sD}Y(,r,m _֦pS# $o&L-HsOP\9& 8-8 z7Nנ Ѐ8
FLQ e D h z6cd,{2,YQ* DX}r 0HV3'uOO
3e5Y9`Bf͜dD;k(YAYG '@O>Sn S_VUȓS9dq増(818$;A@FɁmC+htv?L 20lMCʹ6
E݁S+\јl(6%t:^0 ޛ5!Y S @K[OWgvWMpV tI\ǡɂ~3
l,E} u?vLN/ Ud[sY>V>0L3fn ZX.' F6P *2o6z_s .A暖m ӹ{j*L P{6 U}q(HVyCsCҐ I__A* |D0-h7C>u)(ڱF/L}d8)G8{,87 ]j 9:&4l>֑/>喗 B ̗YE2χ4kjӧ #UPQgӰM(-,a-J6u
~ŧ*5(oa|EI<8Ȭq`z{h; I H/7UYF f52B wQk６^{y;V2}LСeVM : \cAw
8*M Зb<+O K=mӖtIM) z̙>Zfj˹ hu 4B"|K}B~p(+/rW*UύHJv JD#L !e5t_]#ΩgyR 37 rr Ȧ&5. _:~] ~ԫOq>9' V
L2^]#. z+/؋<,gWUs~=9Pj}:Y?;M@r;/Z C~Ӓʽ+d/'Df|>>dFQL,jrP=` fA !eYklvpmYQgl # _/}i)Y~ׯ'3 ̏3EG t Ju!.4;GW\]fc,I_63̘D`\o#Xɞka3=yL_ @2lgq* fOQ,l(`|Jbq
Bb ' NY|6kk"(jq?RȖgL%@^[ #JH(\3fב~ -?fk_)5 =X@Twz5S)x{8qg c?)eW .A⼡Grq>ɍOG}?ӕ i".-Gtuw#d DǠ|1D̠ %!v ):n_"X
Jƺ-W!RҟèoDuRi6: TA~sY@[ BIoI:{fUf-x+i.tKm3cU[C& 4; X%c0_59 4i436B ,m'Byx+Xf㘨 Zۧ"ڐI'p2kT~fa,-`x;(]i6A7Y]qR$)2C8)E88fpͲڀI+gYV A/)
)kۀHGD9B S'T ζAcrrʵqMV@fg9$^YCRs W ІeLV)3 ` Fe¸"K4ZbЫk8e [z
&bfblIaFP'6w CfP֣S|Ƀ#|jA\Nkz"464sFGtb쑙9Lm4I"M=uյFX9It sTu+H7}}UDCHY(IDW~0+u [u8甂^觇vX
MIr}'?ɡKȲSd$Ě1IO]6=bC$vr2!y]d||KEpQ9
` j_p{#7--b}F'{2\Zgx^:⫲?5bْQ_S}v>5FK3De 0}rr|sm˞+U| GY|{XR32Mle
AZenl"kVVs >F^I=u{+'ٱ `^ό`|eŧ1%P}Wz XB%@})X =y9(7U%GNPQ ڌtiKV4>/3x@͵lN\{QY N6~ g{nȁNX: (S^y]Z0}@ = Ish9zVΦ6f!f>%SK7}N5y۫,z?.?. Y@e{TO!ML!&;Mooof!?߆?OGGuE&\][& $:> yo]Fًs<{
%Dhll͏4'?1oE<
*x QBojc+5fs4"[b |91 iv=Kډ4Q*@eR6,HP"vWԱ7ïlHfk{7S
J#KP`ۀ2H]V~ FhZZ M q(-
n+wM M役9BfjAg9zJH$ӆ;8Β]ThFyhyu6یhϢ:TG&Ff(G 18: @7
Y6Ή* )QPU}~* Ks-YC.ϒ~ ɠ^GD/@Z>(2KsauW?X
P<>i\
ws=OO|ct7x_|N3} K#TSNc˩}&| uQΊPe|e3d|
o3H% I>JR( ﵃",f 2d06dwkf:,O:+fu ;"otl2( ݏCO\<Fp~p6v2 ;_jkqdq}>Vz~{ 8SNC|63f#Y#fu%ܻ]@y&) Y2 m shS4Yq}u2<,͎%gC|=i L]qsb1'b'0 O<;f̤l:}BVBNW1OF ~LpY (=ٷ\ #Zpn"0v̓ !fs=l圵Աf,PWݙф.&K FL&N3s8қ+/Fst >K}x ̐}f.)I@V+"Y)UQ i. 起߀YTE kʺ3hGN*MikMPhl@^ 55XDp S,` {9Bö'
؟w"K_~%}OR ,jjIW\ Pas] 8^1R`SuNݓm2Oрg>:Ք!,--Bq" UQnF/gRFld@c"S$ 8iW&d&EH'd=Q~3梓\ԟFGFpY4Zr:lW{r9G7E|#:91NþW_|Ʃɏ Q}DоLR?Jm6MUPy-
?|N.9dp3xn{ > TJ" $"M4Ca^ZXL=P<Dtd7aRMl%R\]Y <6pe.9$avk\.^ͭEMi y}2,}$7&_J~.ӵoo GuS8_P)?ޢX
>z F.fb h{<t' 4wa䪣YxlDD'Pz iِh1 W\iv<|J9ϒ
" 3$~*2A螌=E7me/`H Lπ=xqZ^CBZ&4u!|[aOomຢ"KOdb'p#I? B/*0l0CJ;*Pcğj6_փg/_'_8AE\~YlOyBP?e 6F|!D6aN[
d
`0Cbm&x?l)=Fdϟ&Ͳu|}WЛ24(gT'j{'O@?RXBn"=_'I ,dG9ꮺZd =h?@]_?l&Ȅ,.M* %4 u"vh o.Yf m+_c9 } o(c {(yc3:^elXY;Qo\_<ه s7l!c @U Y@`!-jE@ӿgIY=\2 &8
?C~! JP2J<:7[ | ~&hA@U !pN=: Ȩka HT8eY%)dҬS'#05c ɑGA + #8aΨޠ| gU,VQµ4 G- L 5fq̺DpRB; ?{T"̸cttzȲP?pJxpb Ao]#cF+fa5k 8"Pҿ 'Rv ]8Ov/tDPPf5mÑsͶƚAFkl{Ae ʨq P,HKKШ4nfifat"FfRaz /4L']
@8ø3eX,A-/uq}mtmnDȉLH[PP~G: ! ŦtK:q1e
RәΒeNNk`g/pf8ʆtI@ ۀ̷gyѐc]_'g)]!lwI o3Ze$N< l'۷B$={0&Z"prp2pڸNi߀} vd0RN$Y 6҈3P{"#Y%2Hx# :
8YR1>Aa(
t4d:, uOdot}8\@R жi)"pPO 0E C#J8r-pq (rayFAz,"ߚ"D; avqٕx5NOt1,{q gQ]ȏ%ܼy ;S}X=-E^ ; P.vetHzA` 0aMK+@i(Q}K[aPIA'.l76j|8Nr*cN7Ed >0<1g,,|'t3A Q5qJq9أ:J- Ԟ.Lϫfta?Mkiab`fKlulm
fRП. JA`Q)gCsb+A>&=2ӿAdƈ Pb@&OIz|9۳m]gGn[!TuϰwϨd Vh)jJ:
^Ȗ܃]{ ͭfb!)vyȀ x
SQ91x&CX0ᲃn^&g{Ӿ
5 YG/` [crCm#h/{+.."nBM1[ ؓAUŦR ¥B2OGTXۨs "p8 AP_ [1G% jxK= )TV\6BI &(
]Мى0 |E^BHQEІ,`-'Lؔ5S{j@OVٖ
[l4::JwZ^iy
"Fy: vk>%s(3z = ufa1Ȭ{h+g[Q{ 45:BY "¢ ԱYV[FFp&vȂ@ktPzf
z,#~X\
gsMI>1}Qi%A. (- `hpvUosL.gDwt]8Ylk
adT8 k_ 8s=Y xXQHeWِzm}e K? K 7 G(*㦌sd`:_=` `A| !`OyZ3w6~Uڠ-F uXYXx 6{T - ^)k[g.BT Z K8rՍّ#C8 X1,@Bg f
FW?Z_Fi7ߥ Y:gΥ7^}{CYW_%#څYC7o}nXS >}YFu`mP7^yjNj[[;AdX#sO/&J`*(,xY]T;x0Y`s͔]؏<`oM29#f /vO؝QG~CO, 4֊P;8p5hYZ#sJh&0%ǵr?A *C( T3q?̞[c:ڬ ڙ5ئ6%+P9>=nYF]7vamifyq{(
Ga9 ] o<G(=JsV Y1 .ۅ @!q9aCr)h#aMMjQP^4#Xg> jI?=t3d F3G'[-Mbm)o=e$ϳ
K/DnG4)`ώH lA1֙$M
Sr)ƙGE<*Y_/ +j57S=w"
Ѥf.;fM;
YA7WN` : kVٟ tռ~+o;0 e 8gl2uM( Kyu
wDΧ71Cx ;EL"3JgIF6I㟰Od% p4l6 _k!SZe @Y E;X
u ;aM /x}z!@I| V72vI^WKVAF >*Bb!X+okmϸ#16aV. xyhv_ר f Ϣ6BӦ%&+Pp#=~ӌ-\_[_J }
2:>}{{ Noݰ GH&{)u}e=i3HuE ϑ ٧r /djj|l/o=~dS~ӿ\to<xe}q Q3}8K(R @ݾ
wGp ]g/%g2T{q6bRAC0l!SRȼ qȢvmc GGo{( [T8EEi\ɮ@ة "D</N#g/IQ1O!r Fp bRwg}ɣ&d
"C`#m] 4
M ֱk :Ϧ˯^m!Hj0Ve!0au4 8 v B&km{ ,?Mo>KWWU cvbvY
".L ą 6`YR!u3==]MVz{o+Pɩ4Ӆ6i0)#ӣ]7L:{~F_iua(Rw<"xoK 0*nn-t +d֣f<k1
=]Qs,%`YjafUJȴŚ۬MAv\!k$YzcpT("<`t4y)(KwӻU?/of
_T~r I9
> ҹ h!0!
Kh-5\Ҿ9]&k&3 CN8[Pgo4<<b|ro)'M4f t6|́~<}(s_*c4
NNdU5Jʩ{zV|9_6*;lQPs\Ρa.œE sya1Y^|#M:Loϟ0
@'.|k r<;z-_Ҥm j}NnӸX{ك
<3LJ_;ApC#Oq{wU @%tր@'lPܳdG:K]iU O'Fp ދeHa먨 è~S2&{^>g ?y n512嚽Yc6-_ݢM5[BPԅAG֜R31>`r4ﳻ';o)?d_>lMYFaL y>Lsd 4pܵ>t ZqCˣ @3H=)im]sri^:]HL樰3,,Vӌw9-LMl@\o=Qn9P,mi]CI,
|v҉Z2_S #5ݼzYJ :rYo &s i>Dos pB)-Gv+k~u9AXG2d
PV29TϮS17~#-ӑmuAM#[ۣｗ {XsmLs .uG%u%D1X
og: g믽u(wFJ[N2!;* l e䍥n@Z.9Πz5jہ?54K<ժ 3^}
G8pXm;Ϸ{ko`/ H {{vsC=__uYbrPX0~NzUyvW
' BjhW;}}$CKںQYCQ $1PKJ5 օ0u&(cYP*Frbe$ud;oMi05v&E gS?=ٮXT.zK- Vd潺۰ v)
z7 ٽ9[7*9&{ +fZi#\ 1 YSwii/ 34?p|
l$]cMlY.B˧۱s2t7]Zhz" "'M IJD %c mvq@&}ieG/?~;3㡼tj>/ch-cȴ*ȞuOGY4-ǟ3)i"J \>\^)@ Sb3c T`*zE
GAc0GfQ2ѐXv`W`auʀQA(T]#RVCSiRQa`w͇vyhBjhnC? KJr
ZTM(= xk
w
x0[A'Z`3H6A:4sGs;2/CXC3k9vʅt*- pzg* Rz1K0(f&+!k "pPNkdFRTꝒ ʇmí<W.٬~Y4ˤP
5ΛdMXK;[cG@3+gӍ[1 ]Riw1 ѸP[RNngXV-a g_287>RFYo_GB) dMF.1Q,.f]6=>E}O 8
fL nNTkUz*ݏCJf c,S0ptw7>dCyjwq /
|0 il &7pa,{ o Ϝ=ゅL
MC\ S~R7a y ¡PN m*d `rrg4@ *N?4uT' ߲(K#eyP5u4>5/j)f 6^lUzDëv9ó7R
D/`lm"SX\t46 fe4
YN|GB硿0He ̖E2 ܣ9NZ&T"9 V G=%.mR{iB"܌è^YB\;;ӣá9pJ /< =EPVHI4f`AFke١`^ HFf̀$RJb; ~j,s_d}HWZ 8tf K -/`)pM|cl<ۄ6/F^8As/L9.KkDa=~]<;a#V8{:^BgEC ٢ @ >H<ls( ѴǵK&=R˯\KWY_j8Ԗs^iCv:,*=,Q9'˓M bL=gegY4O\`AƖ4b`g d-LXB)(Lp,rR:O@,aeUA 81A0Z}XE919q!= ÎIgpfc߲m{T O'O3zQ ؠfPSia~Uևןsj V=K C!Y CbI؊KԒP:f&繧M!tzγ uUL=`kʸ6 Ӻol`{f3`dz]2^ly
VoEN#~]HS330Tuۻt[FՕ(⨑Ǐs=s )dJ]zp%4' 2dԃ- _cؓ]8x|C6C]g0') QĘTJe, v$]\N/slB3V~eƩ _ [v .(;.Ic }Q.~dYb~$(WYF
dE | fAa7zڳd`0 ~ e߀R\!2(%a;;:x >s=6;s[J Z Zn( `<gYi?s @ǺłQs%+j6T&$pq krf<-T8KeY&}Tu%glh_srd>/群Bُ?K3n:^bFpQ[!2s^24@UJ 0vuJ43*
nO LM]R2u-V1Z> DdyH|leKfDU8Θw4#/YA
ZrtA9,HCGOmTv%u.X:(prBӃr]q|^!N^:tsKP_X
ZبyKo.2PRu,vk|` YWǘ4=ɨɅ~)4|-0sasr" p[J9c
_*rtΐ :n3:-15 8z)f"tHw.Ÿ*~A K;* |M l
1:[s`Z#hO6I%`!HKkc}S?nC\:s~TL?CdpA,SCKK8} `9Af9`[%g 2.0 C d̽, Dv{ϐ{Ӹ.Pc!Kfx_@%_GfR[W qzhv1=~4R`-Ycv@
Lo:mHQXd w1̖#
R+p2 8,]\W p[881.磋ghַ %uNۻ!Fu
12Lffc=˽Ba68o~gb?2\#YC}Ò(BNP9J3Ϭ'5ž˦{0M >~)1ҙd;)M1\ɠ@\F
IqZ4Z]Ѳ@zz
m2@@a|״~mu- CL>>5إEfbp}c=_u:Dm&YݷNԾ6^ W.z B,}t92=7 N3+؛o~5kS}դSh Y6 kvP\mt]m+`#K%eØʨ9ʑ[@<f
4Z# CSLC8-LϪ C9
Q Ť5K,:%Gз a= Gk| ;}Q&(ؼ CC6N?ceކ~RpF"chկ-t
Ԭg+&UG M 6=kf)mc4/&"Umk=K:ʱ[BGjQa.|sfeϑQ~EjՇ!Dct>ѷ&E[{{drlG{%)2H@f,3}SGvWiGkyq7DIҋʦ Sg? |{ @]uoE]h| )pY1xĎ<63<|>g=<ڤI 2g[JzJ@pd q LfW=O 8L܄T)>ӁLK O= H`s*#%iHN' 3`r/2ew012C ා?dA'f,K+W=d7kG u%إ}`
Qd@ֱ6Dlڟe?s jJ} hp_okӼmD3
k.T"Z89>t12Z Y N o+J-C Y
J@#k#(GCՁ$*FAr|
Uqح
MQwn$IquZD
yOG72c`+/dl[Ol#؆*NѲ1G?
6ȿO> ?Xn;n{9(:Q#Ԍ0
ؓ% VUTy\!w7~?Σdo[ceuD 8xP*KWq #ЎW&;U/aU~m œ䨹]tAJl15^y0%dbT]Jgא˻A[o}f7CXrje'ƞ/k.d{piq)J a|UT;}uU't;خ֗ 1M)ȳqH{̵bB[8DdT8:֖$N:ԾCݚBuv Fu@tl DX >a諔6,]-(v B #(@- k
@ IDAT
SCaŠ@G3qR>*A^^D@/86m(-^dUu T]cm *~
1KlGQ`|N8| g<0˃ E9SBЁ(+ /BN\s 2iB4VEi,0F;66uy q42Lڛ
6`m@Ht>QKƦca ' @(aQOuI8'-f=p͠3:6 B:Ɉ
iX 7e! ߛ 0Giy':4Fp8~g:.P\. :$s>OgL3JګwGe fi~4%de8Ӳ)6:Y:wf 8[d 2/JWz}@ %W Pܿ 5pܞL2 Y1l46TB@7 ut~eɩI۔[<2K4 `7+92 sfvqv Y6 f=~!N5}sJ cFZ,,M? +
(.i6n Esb9SZӫo 3i WX]tp/=lP0
}[
2~\gI_z g!--Qf\&F̄`{oD0 KͺsC+23>>Fo[4A-`1r`bYp}d ou@a-J߾/~I|6BeHC97q p)H)6Ή ӆڴ7wNq+DUW
Z~uη2bY T 8z p=&֖T 74b:kehPaJ(0Nӕ PZń7JT#Պw,`/f7#!0n10n?(`%x % Q օf6Țȶb?%o6Gs
dۛbe3eH.xOL
s3_Ja`DbǛk
ơF˼ {i =NI
5*
wQr&'iFI0eI:=n,Q? f%W5 f-J{3? nЙ" i;mU"=$Jn&@Eǧj w.ap`0٧f wR-y6N
P9l||ݿ@:_K
m mBø.2Cy1 ֘ ']|u1˶uYOFenBV=ᄫ&J}/=zBg8p
vh1 T{4Bl zIAXгTh 8(O2 :5QFgt\D0,&b=;nt@>kZYZtrFa\|F41 I;4TX!YM9ht(1k2u<Wѭ*ed2RvTtrgJ g m 6lr,u+ [ Nq 7*v c'd x$ 7>1~Ӡb&* 5^[5N Xad m(1MAR\ mGZN[JC'7 Aר7#^6a"#DcJG݀A3@ FCNpb_Lv&YzD_LLXbN8d03-|τK Հ|Scmuこk-(zd$:P݃BX#( J"QgiƖM
lku T<4c8ؽ3`4Dgѡh㭃c01g Vaﲏ64/Աk
tHʞ9)Ǻ.zϋ6 3c
#GZN^8y1M&Mh
B;֙ȾLLsdL fs20[ 3_fhu =V4 fOv*K`W+{=4 lģ_tQH\mnJkԐ# fJ6< 9!7[POfD`
Y~2A" kpq3k Ivl-* H XB.-=},= }
J ޏWoʙg%r{ęc ӓ;Oӝ ݎTچ`P\ Ȩ\(礛7ΰ0y~ޅ=Y! VFAP/eݩ9 QVCs 5[;'$doJ3.!5zRAݠAf=2M8.^3be-=~4m D84rL`>&DO =2eɧجOhxT>s%
jA O/1LYܑ; @7Bt)W~ !^W#"osp272l f-سMǏ&}XgoЏq"chWo}JAb b1 )hc n@#f) X!a9txjv cd)l{@2h76= )AɆmV_T䓏O7FَNd`,RA g@< 9r0jΟR=hp3ݷ쫈}i 5/dFdCFv<2"wL T ="Jc }<̕[p%pU\u߂*0Ut#}a n}| QtSv539uSNi:A/ ͱ/H (z0\:frf129-np
Nѳ% e#s w00"Xρ$o)NɅ:y{<ק$F`ȑ{< ;✓V4k|F=z^dWx'k寰*w+7Xʜ\>|D^G{_G/;!hH2h.Ʌ p, WcvC[k^EF>cZA5} 館*EϪ*'Um 2HO5|-)-ede7 _a2ܟvelL
9eMOS
bcm C̀ ІF֟?ϵzBw '+\3U?[}E=`Bu3D
mt*>at ]p̦C__M\L[|
Mi$R6>3]9 ߆kˀ7@P. OE8+2Y ?ׯZ 2dD>F]4p-].ꀙkCpM!`
TѱH]MewqD`{
[z͵ 76%8XȏBlƅ_ye h{PHO:P{c"Hup MODMmZYijh_ƞ&CKS9CKgߒPtm%$}$\8}Q*a6 44(j{lX*^v8G U]e!rs(tIӷ!`/AqMF]}f+{նOv @.446<W.=j@<
Z[[ZymI h":"fE45*
$3Qna73 RX.t",QtN͢
0ۭК!*ё5[Ca.jk"Cs0PׯLu>yNzxS`MѧSt)Tk['
"R
8*͍uh M`kzrn"h$8QE? ^z#OO' jNX3 @y_ۇ
dooa MV4
T.UסTVB,s8(]c{=F'WY?8\FJ`'q'@H跖F׀g2D5}=Sǧú i=~8s=(c@˄+dTCh,}X{JLD"NQzE3`iD#?B uEuL $M=| l#!9f4t,oFW]rC&di-1K ȧ4 1
zg{ , Rrkl%
&Mo >ƽ ? e:ͷ6Ӄ;҇ￇý3)* a ֭&G كV6>
"k%($Q]Z:WEݲce|:>,28xj:EaP8ְEcA./ '`j5u;Gꕗ jr
q q&N!?[?! \ƿ z! P-1AgQ=̱@`?Pb#H|H 0p!T@IS7٘Of T ±o7X>Qۦ piHS MGQWRltjj6r\@ &GdVe_'GYp|GaY=eȎIֹck>GPSR{Gk'͕j \w6|[Ѵ|rP! \ @9X: (fWf/ĞuD?#CƵ!of+Ѝ8z
8N [ gr[ ;f'
R^SoA5- e]k2%8.!@}<\KMt__I6!A-iP1?Ⓩ?I_G weRZ\M{B9"N眠4 Ph \Lأͥޟ?8m&
˂ё at v sFΖl"kdϭ t(nY '\X\XkPXB_Rue )z^{!^:Z>> P߉ ݫWiHL)Z+#f{kcOMQ8g ,.^ZL
!dl8&2< XC6$O_Ȗ)]cyycr@JZe dzLHi|t)FY< "
_=4kmO 6)vMl:zI&pTRF-Ugrޖ 'z P (] P1c` :_W1e.4k$V`I^,< ]GG칠$:_b>`75nEt khp WYX
} cXOee2cOE \R0g5!W߅~0(!rƚ܂nDd2
;0hb^!7 -R~qfXOD{cbiwa=&)OR.Ro\K>ʳ Po&X֑mcldwC/=|h&/>n>}4[kPe', ݤ r/c}uq';q"ǒpu^+ ZkȢCmtN&<) c9D< wSV~{i A"U#R嫻
hkWO_ҿ~wvOݿGs]ovNLM[;2HV\_XaыVg
7^JU @h!ٕCPL,.ʘ\
V |5@pQfl@5 5hfcyAFZH` >uMdWp`͒gqDT*Z'qRh=#D6 40k_"0͂f&QDփeh>9ncth:Yk&(yD^`ixh(p-Aɹ/ǯelTcTO#ŵEOkug 7=C)z;fvas0 }= 9vsg6N<" -5pqp{KИ[(7` 2ʄL*{kfB@=xll1U4XR
" *# fsl(.RR7[Uf4= Z>]܃bkj) +4AZ҅Xe\M@*y
y3i Qy_j7\+c__aPOB62< ֈ 4f(#V{M2An@}zgB*#k {֚ Tؕ NJu0+bl똝]x/7F3S \I# Bf sI?c9ԡF8E.PH &:ٳ>Ħm6v=!8=H "\XPϲ d5ف\} Ӕ93c%qOqCNQE`UW٥{s~rR:f{d۳d BAyQ˰Vƽq6,
tˤ.Ӝ5H}b ^k iY.PW 08D!6 %VdJJm->GAޣyz~$hzqTdk|p\`Pmzhv8=,C&C)e*2kiO} t
{t$ jޏ1\? Ncc] EueccG-,NK>>*,u "( 6xg
wgzCR8mzA},`-Ι2Lq'5+;yV3_[G 3^J 65FX%|2<7dm.)_F>!c^F +^n CNZ@d VEVC,alegYGoбf\lDifHk^7 K{IYh 4t/iH3Ahޗ>gDfҼ٦,q%S{A9Vϵ%@#8k;K , |G,,lTgI7"Xύ j(A
[ m6n0s[Y
pYߋ, ܴ6 54۽F)%2W&U(`$@d^g]]+*bܵP'l%8:tϥF%))T6([6PN!W]{4nb|/s6 _X_< K &[}@8*_cFLY; =o 㟼OT\K&P({³C="hSe'j/R@8l< 2;z@۹i@X9Ҽ5? sd* & CDf/JdRsFV6; ~>VC{k3}*+_LRۓaI"2_?| %X_%/Wo &cT"[կSX¡:"Pȸ 9\}YeRcw,s (OkGT8"F3Fu FoǫG3^_!8?)P} ОW_C'oj"s|o` Ua² Li*PzS[gPHa {blk $nS:)78##K6\3S{
>2a? M>2'`@q>O_O}, ׯ*biI1Fv`{{po^k/kge-A ]5[z uA}N|/O];}c|\O=s{x^jk~͍W6E (;m_?hfW
N>T7~7 w9R%K%P&@PYxCp DĿM ZRG_ט!^S EP ilSPr.NU HKH:
up;`
u,4t0^
b
Y@폢=: jS0jv]$cFG糑̂tBlM؉AOc R@~th=D0IkV3 = Fc!vvOpFumGwC Zx'ǔD/
~)OPM%·UttǁЀ/Ш$%k 'F'Kp@Ƌq:kЅqԲS^yZjzdWH/I+'#^>7U*^p =G ?9AAYCF`_ D%{{ XGf53 cGɯ=Fڿ8f4 yTG Ƚ!sc_|2 l ח+ȸɵ| / bMMyȪ(TDYU9Ƒ Bxd|QXh
1 {F:r9o٧ @E^^XMKs5kfEpDɂTLTHp
/5BBq?wZu`#V OpTTqخQS$e/ AqvzvJu͒p'`RR>>7 5 \姏>!M>β
;K '_{ƈƵ8>Q3
ȼϬ`2]$T⌸Ż %+?|CGz Wg{wzq} (v%_=y~n_sMбKV0rn.΄<-)6_3EvW rMwiho}73ΏYT2@Y xce&"+=Sgᐒ0 ~<$>' 3
ԭy5(GnR<>Gw!&]' # k@4TKξ #ks
4 $qԮW{k'Xe`'\.0)3˵É A)->2b{;d~}S/xȵr+; 9Gd ۢ}gl{Gوٷ#X@ G/^n?3Q/_z,dsږm'R#
*
!>p YbS:K +lUO?àMYsơp+e:
' @
e; $8Z?}R?2TiZMkx/i-
7n![M)(reo1t"j@
v į )$m`GA6R R (
"H
3F] .\y Nq-< L8iFyeLܸw6m~ACG uB*&Gr.yæƜS6J9TfeY·% /ϤerKqee1[0軅r ^ ՙQ_9PGh[2r}~R{YtI)T;bbNmz;aL8H/fƂU,%5QdXƞx%cĎY,'ȯTT ӎ S. veNv?=kt=d#al- Rxleu짶Z졙y|p/ւ#IY AfrXytJIJR4|wEXc+W~1' _6џ==pi ?Kىl `q 4?_ ^R? nVW7 ?˟_#?P?.rmb+1&*^
{V@ߍV LF 6ƫT@~@hs_(7294
LA-A=YY3߹ʬXW___^Z1{ < Yw}WT 6B[z6'KBcDž ǠmۀU% &P[ߔnU O /`v#;3?{ x YªZmg@b*$)0p(A
GY{'p WVP{g5ۣ
OͻPN%Z@tgѣ4FùHP .: XXa ,0;6d_`l
y)GG4-`1r9UFYEAɁN !E#cnIC JR'r}jpXKI,)2wdpPx* C1l0>ڦtxNYMpGeӪc:Xa
~$rtzMvQG㘙^$ iF
Fd ~P(lGTQqJc aGk: 8#Cn}q CTB^u49` ^701g{ /ޠK;ϕ& 9Q e3ZqRT r[(т1q- 8/<':uD=s81yNgJ g@r[ [GS :GZZE~#.Wp.P9@$)OvkrνYz6sbvجXg@Ƿa 1J2PAo4l6u$p,
2k-38,8Hojq 6
8:hأaS!vje:g; ѝ!fk }ZPRWkniv݇KʦW
tFtMp๒mx'}d. mg/bifIٳL9}_$_u#ŦQзj9A= =+%ıJY
lkָ-?,ȕJɪcAZRn:$ 0kq b qZϮ,5d=+3^cpOO3t j_`hxNnCn,SC ?RL8ĉ{k@MSŅ,ȶ[^ y`bZp
=n\GGl}. n cAy?C&_2IPRuVRr,
|yNvn Jӷ|y&8YYKC#ht'S@rUF0 j,0+H95pI 3Z`@O=5QY빯\;
t)!5X5tJ
uP)_l|9;J*>tiT˄ʧ m^(@Y|ll^U_}d{{c|)]JˬԳ1&I>zkN)e6ᕏ;4t9W ߓ.ewsHj` $)Z9ﲫ=kw}I%0d_J* .P{W5S.&M D p)7_coǶ34kyNh"I^l4 Ooj hFQF랦eJ⩱F*p\6{4O~6zg
IH!sXZϗatq2ҳCo=k n&\̈́M۔!\ʃfP3)zIM0ɾn65vh jŬMq)A~0W?{>-*{/3
{cmxyj78@7'O~c
2.Ev;%&)ьl $NX ȱ
ϝͨm+]dӨ^,M>$l:\=ϡ>kBF~!:Ffo@ } wu@PQ(RtM]+M
ʿ )'/F:qJ@i KKJԨvba t+&YG @#u8 H즙@;߷'q:Q:_@}"kRGO9ݩfMt&WS}[/YETQeg:ec:skNCȭKW_I =̬~7a(-hiR=8(wW:[>Gy
:4p0Ffq̤z
욱0?V{.tegh>=Cfwnq)(K# #ao>(
\,PY,.{4% thIqBV掃03&=qZ
iʹH^@aQ"RI os"*!",\d`(
ܹ};2|>+#X F>RL×c`Pjhg43q@1v9+AA9/Jn;ۅpp4ߤelq9#8GdVY/F
p] a+,
u/ !01Ӯc!BX9dl<1^oHGkC["8`
]PT[]̾P1]s|a֝`ΗYvy88>P 6 ۥ. PS.G4 ,U-Ω{~N@)D.0.8
Q 잣bmv\ RtYͮ&nut.4@"(@4Za pR%MxR^J6=OȘة9ϐܣks3M {9w $Ѷl۩ }Ơ3d{tZm( )P Zs q{ "sis9gt`0spȸ̉d: A+4n^% O.. ?)!p:s؏sd&IRpDDЋ Cg0VǞ;`q38"? pǣ_~d.NBg,(֤meH
#pu.bm`
f!]~& O[aCY;7:g N@% s[jYFiYX&ss묕z)aٙqN 2;mО]v9uKiוu"%lOR`ty-:ޱ|5`hH(@*L~IJN {cBh'g܍lW
dvг%;K4"lΕUn<>/ br|: ۟q-C | 0/?@_S 'wIJ.Ss[z g]"|-F\K ^<លPƾ 6iozL ?fh,* ٣X2# KY{CAwssM p\"> .a7
X^țk-멵' 9>A@#]I ]㣷rd gЍB
/d"Д`jwJ
VGn
uO 5Rp"?1
(؎2#j?6z(yTvCF퉙Ee٦|N9|1N)!|turC&7ǘ(OAj1
ɋ\c;7hKLQ1 o7icC\}RL0zכ -d31Ui@cjt*sW o ։(!\6 ̫d E!iE Pşsytdh ()%4,>Π=
:Za!vhq v="{bf&JrSI0{O0T 3E d|;<1, :Į1_A?:sR 0A
9122Bp:utwzv&b\ukK$\&_ Di@/MHѨp9 ]E6MS Nn~аW5 ^_h2M=
TS.3^Onڭwr >ķχX짋 >Jkf1|Q#`U1Հit ni9s%kr say' ?F[d(誻OM;(;86[_9^~@yLӇf&fӥwCɩ A1e-1fZб&V=I2'&Vt]LM>i-H]mdp8)
4J= ø (
EY|CoK78f
VRdUoPٔtP%hbOo3m@>QR~1' i64Ia J3jȴ%̃FƂMNc(t5F@3-8E MlBZA!¡c ںZ"2Ifj4OأѿW:PA{l /.LK#5~Bfp*(~rZG[7)dƩP. c& rDrz| &G3-`ݣ,?Ki
3H]̳> ,hSv ZS8謈B[GyΌ=EeDz=.ʐb(1lETҬ , _uzNN0ku:L#c\N$2@@pu}w[eـ93f5
w :ҽ9kx >JdИ:n]k^=Di2 Y\A@(Yn:ι}^7 p( PWwA;Nѵ6sL C Xs4[[PM@BCdhdx !Ցi.KYw?#s@P(NAd @sMt<{2T :+;dnm
qĩ9 =vWp 3g(v
B~id,_wa>/F9:yp !Ǭ]k Zs't>s}yn {0gS#Xr\TL2o @ XT?rKgpym=?-LN ?n2ITQBDzazXJ_9`
Y_Ew:1,OZY%ح ՉB %p =ߑmG?ogJ2E \>%S5(>
G_Р:nZZ)O62=Öڤ&@'0ws:
E=bd; h=~ _u8Ɩ`N3S |3$p7Ao
Se_Y')3nH H:9ϙ_\vQMj:= Y'|ArQһ7`GW|99fl ( ~RZXLQJG m%@
3Ck`Kds@VɸBUXK6ӮA6 z+C" `;zi kUOӓa|TXѫÿ )Nd ew9tTb)`Cc;[k0e OL94e\saAI!'#0՚!匋$
CSq\?ϊe(6Of«!c
W_{;m٣Fq?M- a03SQY<$/Sh)&2F V A T]$Kajٯj {>[N>NTbIe,,>
Mzl!ʗM01djj4<2FDLBO<@х%$.3T Zޡg{8r&`C sIY5 76HFVZ OLteZso"[ؖ)Ƙ3{#y2Lu! Ζk.]z/҃{ N1_x?eƐ0uv
leVZi _x|TqGHahҬ± L:C;39~e|z!d[JAI# 1
_E[$`4d뀌TL&T@QkhF`e 3 X;+)חZ̚Nw !݀f^oURJ)
j aDu@GrRuőA9 =Gj áFYktPRЃgQr45GʬlݼԼ3NudfhHuJ-oN"qJmĵ q[ ,XggOƿC'TS(f@NuBp=!;Ә`t$m m_R9 } c85bh n\N7^J 8`:64ysy7cg8jK E#n͘ aoQf"deEC$:ju+4Z( / @5d(EU#p&mU]= ;ÑkCx;ѠͬU9JftԽ^^ Q6
NNN e(O8[0| %,ا>NJsp
й
+@4ŴUW\9J>@T:2uȍE mdljm:j8e p$&N_{zfLנ ={Vug: tlCBF{iv{2Wvh0
91҂
mJ{`(Q
!i1b$*83 0Fh._YY{|R@߽ٙ å8P~ f GR I:Ֆdy]ӆSIP˽ʵ#:{62Ɓg{iG (| l9Fw!UgPj? h% {uk$r6Cȴ9a'l
T6JgP[8xV.:gaDI {L:zZnzl =2 ѐSq{ g?KiY*QVf9r4*,~'Fh$3 $(U\Ȅ v^ |D6&\927|hOef2C Կ U+zlȁM > yq
s}GY4z'l(,z/KW ]ԩnk7>' Ux~xr %y4[ EK \_GFQ}ص_l>y+yUd?A
ٗ3A
+$TwP ̐V"{w^{1Y ;epTGiY0er+EG:ʾ!ȃ6:
p #
~X0X9 {GFS1mc]70o@:ovq4{E?!
#xV! cvM( Şw@&g?F PeȠ+`^
"YAtu Q!VúFFB SϞ}C
eވ<}Z`$ ak
nS4u{~q2sLnM?32N3` C
&P2 txtR Wop,%Bt t]}Z?}]1G6 Cƾ kdZs-)FP-mvJf@y @-!Ֆ >T*rS~4
* W9`wn.JSSͶ ivLP /_)ꂍ kxa\c͌gSn|7I^ ɵ뺶tkv]zaXǗ ^f] JeU3*w/`{w*W yvf-٥HF J]=~<C] z8Ksr@;!: eŸUVZz鐒R)pvѨe6t*z_[)d ɚrVWeT2+A%ayhhrJ&fz4F|v9 9|=ڰRX|Zb@ !NPN'>#QhKAHA1! o |%й<r` Oq6-USz!Q22/Nh ]Eik4ҟD=tmd1^)]Ǩtz0ءCl2Ӽ4? %98.1|yq& B ~v]pUR |/Ir(0 U
`Lm̌73^C'ڒ;4Z72:^є g
8 2Fei͇*[r@WVVpv-3gv朎[_f kz$5ζTmb:J {C2H Y=!X!dù |Ydur1::r2z.__ŹGsoϝ]~ݿ:"@/\Y
ٳŸzB,ѱf:NcNV)P.aJvq,4C۪ i|%Ԍ"#\,hR.g͞<l@(k&XTk:J$.~
1gà,;y @g#Kw9fq`YYe58CH \?EUy=
}v_ k(:Ͳ"Q B
\GE?\ @č&eCBO:> bͽo3">]\Hu ,[8z$&e0y uٝ>Oa muk m3fʃgfX<Ŝ Ksїh®ά so5tퟣ/ *Ϥ.,)^Cݢ 4,%@! #~$Ȓ<3gޟA:MfA5 5o5AV) [3ITB41Ea]kt1G@h
@A}~@L7,ڼA_e xNln* #x>zoD ,-o|9@EQim]X xzt @Hz/h4 䆠)t] c1gF=Ч,A 7W~յ - `!I2˰\J|/|ѧUy(s3) iܖzsl6 m-:LokaPӁrt^oߜ@X
'(hASA>~}ffBzK'lƳ {k V
t MGa<*;Lu\4~B96VT Lv wyiGx=lċ+E2v`Tώk)τ)6ZjHذ Rd;d eX;Όg3ؠ<:䒠N 3}?UN졗Xr
d`eUOTs?"-S0y2< -#GmW98溌/Tz#3Bb/Q4NFSg{5$)T* ^Wtu +ys__j}Dĥ9H ~\GT̬*FL
n:44X#6d2G6BpD*boPo bav2QG`e
:pfy ]O%{0Js)N6x 4fa3MLd-6FklY KsBxK8 d#5Ձy5@f#P4f-PQKaٌcD{esg -g J\%%q.MhAUVU ˩V1;:r_p
h@ /`{o#h5dal-.,: 1G>N OGR[饗`i0@uԙsyKO 2l)6鞯sEBu
<zT("{S&kG⚝S9 Pꎾޘ3`k'cS3ļ@m@(3*)}1g R2Q薇aE1ɪ E׀b(NI tY7+` "dad"ikJ|(s:f3 2e03izf&Efgf9sd <ӒҮFnye]ϕ@MΡ_Voc2z3Z
Xki8(^ '?Frz!"['9݁ F@nyUm}m.A0Ǿ2:ɦI6 U?/ 4 *"" /˓H3|Հ&N;<ſQ)~ ȇuθW/ Ys 䳖PȬ 0'<,l 3gȿ+@# fsq
P20V ˸9}ۿs$_j~2x1z
47wt K Ⱦ^.Dg~ v$~:lG
L?{sHͣ1 +xrL嚞s\٧DP8Kl |<8v|sD+vw]tvum
N!ܱDžѱ00a d
9C6uL&ÀOpe.f
eJ-Grޑk2e20ʻ lpnRv~Yܠgg9vAb4 .%]M?AOVZǑ 2b6$s"m
6fy\SYx\B,gge
Ȕ S-f-+W`q ѵ1 ʖ@Ls u?) !,c;{Xo0}alkhxfB@/eFXQR =ZXr.;)I6_
0%zV8#O _ۥk_ H `-ϰm }BX7O\}fOdTꅭl$^cL'!췑~z_߈vM>5;^p k96(g5NvCq9]kzH=Ǽ o]]8Ss5o!~qȭ u܋U(ikz:) 0b<(kF3 (YuP"Ʊ4|==1i_>??a_v P%@'ԆaK+[Ԃ05&'55?@_q(W0dcAN5p?ad{Xs J #́ԙ=0qݤhXL/4 ܆Q*3[E$ޏYOkGt:_L ɠo܂q-h;: g{UѠH/2}v55@94::3/ \
=oʐtQ((5 {63%64^\< gVu!kRCF=oW7MD{T] Ј0`Uq@]˒)[Ӥ
$YIe*8A;gr
e^s
ї-UVHr
T@x;3Fl:gf N 0+)os%m@Rϕ3+Poy'Nw~^u+|gdeؘMdvv^H-܁E&I]I$ӭ^JKcz< t"x4I/YJGȾAFV8AǙ6P>jpJGT*C_tB\ ڦ)@gΰvP:=up¥p}ʆQp\Zh\wݳӠ^<1.:gU6аvb/;MD} wѯXmhxN.}#8-gAT :1f1u6m(go{hx]R{^I
r8 xr
Y;~wz1.Eط|# zZR
L9ٹ!|8˻HȈ 6e":u6 آ rh9{);nYg&|
m`2h_ eFÆ` rHML7dJ u=}v c];;9Y$fp^ݩu r`r]DB.ga:[:R{X_(Ϙsc^Y!u_>nXsxΨqI2B6o.BMLZ
a|l ڃ m(qΖ͔g
Kꮿ <8}OG榟I뜚/a,96
*!CJ ~.*;$|{OFȬ1?OO >0\EjS3eMf5 3!_ 3O%H >+5_ 9P5 a<ͻ
Q;W"gc> ̩tKW_I}706UPgiv7JH;:
֫cY-&xueQAO?z>k^*QeV@XG 3⽭ /%4U_M/SD ˁ=ҙ!GvuYτtggƾR0 Dw|d(' F+9A` !І }#IoF 40P$Vgumfɑ=:GAg/4.0M*% Bu
4C*{g K-
mPT#+9 YdW}a8YTz0D=!Ο>& I >"Cy3P;4^-4 "XJ3qրTwv XCɳUX8VUFJ@YLZk 8OZG 2a60N7*QuǘE6 \ׇ^|^w~XecH.An)`]O Meӑ3TWܚy,\>D >R L{"ܪ
L@V0X,@ g+ҀM=Ǒ lx{koyo[eC1a|954c n īE}k0(50( $(x r*=<^Y&5$Ǥ): "gy?ϋ]`s=Q\D".3!p\!
!1,*ʯ˾^y77D{. }d3BcE+F+j'
π^wQ EԹ` ̢"dQC*@Paf,+Уe#0*0 =7,go j~OY3Kӣ +{(G['Ӯ ds6ɽ
V k 5qS`P{a3n>u|e}Pn4y䒒]}h0cO]m W;g?hWrϴrk_+~Lw@*}nz
ז `3T#Ϲȴ'j 8@3a՟~dcܚxKi1eeo^66YRYJ;[ ʢc] Ys= ž~Oeqw墂 R Q8uwVN?ob<*` QKBWa{Ne:1|i }YzхS[̎>K# Q b Y33$F]F Ww7
ƛ&C6u*142V;$R v~Ay[߈#rcc'`/T0Mj6u}# *
AYG [~y`1qOorK=N1ٵg{TD# ~cp:"#pDϫ 9+5Of6S aY+x1PklnHzaHk7X%m۽$pAo^ko>z Z<Cf1⨻=ݸv%kdUnAVw?j X˯Kt]qg{ ޫ:E6nApf&2HL3 q>$kҵW_%s
8_2\Ctl{Yg=(emnp^W
N˽fY]2/F~29i2">; q}o3ʟ@g3- >3KoO=&LmU DPi{ 눘TUATb_{]q(Ң :Y:Va;;LSKNZ e- HF5֕@v}ϗ\^;R<~=gPP !ӁdQ d
s yOgsљd6naluk)lc8oLLlƪ݉RyL < (#B Ivbvp_CVG 7y;~a2֓Pղ?6"az6ɆjM "'gQf'S7ٚM$!l
Ɔr+x*=12Ny6#(!{ jjm'% 2-̋xVϳ6Z!WFg?55~g#dS2
0^8^po: bBA[Ā3` 4qͤwȎ_g?`L7ftedl 2Q6Z_>&rzI h
c? }C4 YUe]e Nbq> ݻR_loD=+d~nm Dj v{>9>4>}Ux^MUg[=kl.H$+SmhN$M5e٪D/g=܋ou] VOLc㟎"z^ 7G 1aSIC6A#p$ FIFc,*fԢշ2m-5Ў?D\
Β2TʐR aʅ2K%8]n :&9N}@fٖl)mjO ~\s5ΦqB 0R9T)YXqt+ʦGh ڑ<0/5-o?>?omPҚ;8[|b#8 j0 hV9$1E[86)5Qzp
MV0CPg R * $;uvf )+ H6dg_hO Y ;J 6 ] ZK{ztz;4JJ\Z' 0PQJݔzāJa oS5 2g:
f
4Nևz{ln$Y]&4k)x/u+k!S'gA)]n aUu &˴>"y"v0߆"+ <4t+uw3I uU(2/ PlzeDZYƏ5D[[` a0쇥'i NN`Ξ̵7kuzQg" -}f4fFl. .als&U=;O8cC xnD/xPJ
X%=K Y\Jm4H%Cc+JplE{* rl!:F {;|p1Y~N六0}fFЀ7@pt2t\gq뀉L)gy3D,DBCUbh}nD1k]V_ji&/ hQI0 Rt5;#g-/)~/v@:_)
oScq> wǡ*G#rp^lt)kP9vg#3³OCZ Fk A] kF oN pZDC;]! -Sd^y9}HUil!N
ZEKAam%gCO [Iҏ<"3RY| AS>K[*T9VJ
}8.O?:쭿tchRG?Hq]l`NV-;ad9Y k#{γ"چ\Yq>1@w f{_BGȉ<)h SoYSݬ>.{8u@9^gQ`AHxޓX U M&4-բKF^o'~ ŌMu~/Z5NNisb}|m 4 m }f flu{ !>&2 *'ΐBM= `>kZ#63tw|zǵ4p ͽP= \:t*Bdog5S{ ʁ u
X Їڭm= ;
k4S8}vvDvFVdܤ|4z`m-zbuT0ԯ9o2q2u^ LEc -;U "d7?3M<%
Giþ.-4L콙zY.!c"( >?>eM>7 DU}k1d(@Syn)C [`plF
A25eں 4o e 0٧-09 Z {o OdgW d$I`uXR/XW ^~aV48[F6Yw%"b
:]2*iưً,WR O <) ObY "γ5Ox^ʴ1G,#VJLX*nJʄӦ5f
tH`0cW3ICȁP9eex
XaVg .C'HD G K{6VpVX#i荃<χ1%@[fx
MOφSAc'kY6rZ(''Q ކ=F c@
%
mVP蚸>"\:N5չ6(/`96rWXYkɼ_Y(6AYG38E~QEzQcbr9 saQHзވ\#3J-+Ҡm҉ M!=2
>Wqc^BڛƎ>;3ܻ7
QʶcoGC' %͒ 8[(b3*n)Qzg ;Jm
9$5<%
\w`'zNz I2Aο`cp>qj15}P1~Gx9bfprpds` _J} ii$Oh+_ZzhLK!$:3~k8gD.l z kqP2+SM@-mmPYe\JϋӫˀgƵutjz;8ϓBqaR54hkW%,{/r]Oyܐm3{:{ .<5W\M/
b4E#N,ћJ&A{ .Ta>V|1BQC[K5!5+ZzA@Rgʺ~C*QsX2cpB2#3X
&@._9PF]#˪{2e5w_z^lr^lZ=6P 8`9\); *zsl;d u ѣӴ@`na{ ?Pc
niJnɖd @SOi#Ӯ i{>N#O69t$?D,3|h؊ ƢyN5 ( sYcf +,͔J,M 9qO|vA Tۑc ɞ< A:X/03`4(==seE 46JF&9 ٞ !~C6
K ~>1ʳrxyYkCW6քWUױӆwK;CLfr=f, Y ݙo-ܹ6ndВ?o};- a`G+Git$
HB;>!xe,|v
LCANuʌi ޯeP?m\`Jԭae (&vuuG^'_ k>QCMszVr&0}0i~a (ӘZlq OFPܙf?xP21$~8s$FziD>2~_ noY!e\K^&8 cwh rӇ i /ɲ R ݑz`!sBC
Ϟ>M}1 q> 1wY/)l]&} _CO7NxL@j`jЎczΊ)̃}ACSEFLau:_9Of Zm$&}\{o|VJb >yrK qV *mq䙩"Lg(9:΄ЁduC4,O888Rvn>%)E 4 ,a3*b.3֠)Lub'QrG(Gp("@5hEMG=:ƨZH> &DƉ V < 4oп<ͣp lld48֪G sPSxuf/k j'L'm&K*
Rf6|/dl Ȉaup|Zkԭ'(cD2k \#%q :2\{jr>MNP\W+
Rcг .A8*LQ40 ktPL8gȌ]Z{&Jϵ`jU6:c ej8\|Yy5_1!6`9 ۮͦdlų brLZmGF.!So9=R' m9C6TiKFTmw6A[ivӴ1J; XvPAbt)? խ9dW}: |i% 0gRQ[ M9ټJݭ9ƐL` )
l5*kaVEbPD)\GLf ی2` zID
˩.\rJlN T ʜig5o P%SJX(KfNR{@mP Ly̴ۣ4x"1p2f?+h"ue)}Rj FZG#Yg *J S;r=AKp ;ҥte v]kK7{?y?YCs}d+w:z#g@(;J Sjb"[n =u]dkx"f=[8ڧ_jz1Gʱ~~4{!\gPuj3:\|Pƛ|R
1Dƫng _1U#s3V:_9,3)ӱ.G?p|g7]?xu(]z%+dOpЙm/AU( ٸ, @RBMF6Q9A28t YlM츶4rH PtuƏj Gc1kGG 4YE螥yY &
3KySc0 9%<+u5AAmgkۀm`\ PTZ@56@fm k{K9fy Q֝4D#;N
h *4%uS@gCa
8-2(3bߐ3rVX9Ȏ` 4n k1P: `a^֝%»>% =HΗ / ۷nY)P&95bUY32\\5;hٝ0a<̰F۰Geat$ )[#d2 I6gEvt-' 4fz*\X{kԝɖa*HЬ 4yʂ>=NHPDL2 d9p d@op= <1m)srf$mJ?0U W&9ȳ(3fW
R85mgTbK=o_fp %;H>ӎ_{בG4 o6qR)ڈΨp(!Hu _ |`W@u1DT^^Ev
Do^X& DZ'̮URǞ/Ӄ9$`~i9=l̫k)5 Ą44qDJ د\֢='"l"bH 4 a)
&J> ];+pV.ς=G;ʌgw>a Z¨6T ;m 2;w _z?Y_+!?8>J; oex.5}oEֱ#1 /3qJNE`.җ f (gGpIO[xLTR{h!?m==C^~6@+ U{1 $<"΅L (C&by=}2#Xt
EΛ"7ƞ:4(xdl%66^=#*n ok_ P߈J8|??/~K%x;EY[
EG hlF@Ea'ot>kRt6IC}:G4ʙ5s|л`jr6h\*&<3(2t߫6~=p;AH뻆S
kcr{8W4; q1[?;>'۲I&B`cuVe_:MUġtC;,h4¨J+S)E ZE7zf7Z@jutP2;ۛ1tP:* |Y×&+ fG{;k>xv6a4}n}Xg?_ *Y58ڇj
.ʃ(M ;)cn tę xi ح' a@HXph̃ƋC!xAX:^@
u4!QJ*u~WB&س6vt&})$y 2z'Hc@"`\):Yq
[xx z2t9N a Ɍ\y
|]wు/3?v< XI@JM)Rw7U7pfh7H'aZ&''0ԑUɸ_t3&] }c|#sf[zx,
rH"fvͮpFVI"ZM@_|@2ՠ@} csө,ZIR4ΞHCT `y W}XL [cL7J}%f?M|1,I % vtt驪! Q]AAIǼ~{)-r :LW 8oNK0 +e+S& ٯF6,GHt̤$W 4^~YK,>jqpmws`@ѱӿ>:FQ9Y^sL) dm&-4U"HC -8E!Y]pYfamc <_yCq+*7._F 2CfS+/5I {zf0{/H+k)@J0g-αkXJY6K$g%mx猑^5:UeȀΏeiUK
Ү2θ}b\54Ik{ kk@L-gh8[ekBR>ɒA VL L 8
(%#ց#}isC}fn8S&+Ь
QoK; 0MA{ L C%ϛc*-K̀#m8bKXwf
)~;^}C02{= 8Ô|-䋠e ^
2i= .jAi?7[;0^TGۀ#^~sLvU !S۵0x^O ȸ@PyIEUϖ? 4`e2Q^ ˳ *i%:
x6ه@-. h
eX[ v+&5iEϵckNl ?jw p_rj(zO*;N 0y d
er CySOMrc SDSƃ 6 "&{pf6 u797Ѡ>~{oj\k9l lB7w-0fU\錌6 g9$6,&iu} Gce
gmkkO ^e
C@
4,!0Sg{UTћB?Z@+/֊4Jv<&3TcEkpd̉ęk S}S Fu>d@ۘM'8sIAjllJEA, ?%~RJGWٝcb #qU 4wYҘɐj@NT3g.sas)PМ* HŁ:ΌԨUv SGqpl c \q4=1Ryj|VW@rf1+3il)]@ZIN ? cТBMvԜo2%n-kQ$$;%ċVMdi* X
T"8 qu7 qJ?HY& : M
4}]=ǞYk ԍdϒiK S@CU@bJDϚ+=oQ
Q<87ʱ=:!&*p b84Yf8&a? [Ě9p0 KJV+ 3\6.ϰk$
} $3Yf{WK[as^{p8~C5b^- c! pޫe-H Yj<?T,Qб!. oLndM3b&YD`W0 +@@~3-/RRB0-)@XY{o3&vU* rp0n q ×hagWhH 禮{ ~|dK_zxd[)Vi bE ]N
2y_8ɔ,+6{$[xOL8S-?'U>):dIBلPƅ ~%z
οp6rcV]wY'KDزq[qF'^2iw;YLwCcGvgcm
_i&fq/Nu{ (F6 ӿЛ-6lH5z
46v&沎ywm nWW[nO]= s]=-y2::Z!(*P VY,J iXYq$*z~ c 8ex<'zG8~d2&s\== p x=o}o lo?\o}[ {_y AEɓ)9I0̛
^i'`36#ii
ʌgyEvu4 #w Bl=!E
ӨRZUQz(bpBw|U
ԋ806%
":M]t)n.hg#o%~s+"~: R5,*5*LKQrA\Eg@U-MMс@', ϩZQB/*}d0$"!u]]Y;\'JT% )ٺq_řXcd)z `gVYOEiu h:HX/o O0H :[0M_?q_"gOD}[I]@G$2&N[fY"h~u@>LH6jp{;Td G~P6p29Y!㾖 ~ m;._N/ߎ e çr~rޘ]`w88Zӓ 4 ^Z t8̅DPi59~ޏғGP/|txȱ{u
&'ϼk8JK8s fȵlY :+pY#G1V G,1Ъd͔a+Q~rO-Ḽj@|Lolx:LeEH!@>Y{ m v[d>ۻ̨fM* eh"I ?9~գt(G'g `p]B~@b2J!@
dYtbCl!4tN:lJzС CKt7>s, 8
t 1 ,-.:gbd9lص۷`ڻ4CrCz.G5苮t̜㐟$O^0}.Ȭ~@L(Im a?1$u&ْ֢5zh?ØfssCODcjDQgLt$PLߨ^Z=e?Ĩ)S{/==< Koa} D : 5Ia{;"Z?Ɩ553!,>Ssk~`{q=~kKPONǦzHh mlOa#\"d 0
A9NC sc}l~&Hx"
giY#{r'22%Gv
:PooxƕS+HLg d=\O":L2{ sLʪ ?>{ LFcx^& eȀk-FF~pe;$M`&GgL_a -cn. "CPN! F(*qW Uq1ld l uW_Wbppd9k~Nwp"Fb`L^ 2Y5N!،Czͺ)[9NchAFjf>&( [8YG(Zy
R z^[611
?vooQe
߇`-c@`Y Q@8"w ojn:N4ԉukBq̣L4:MZ85>of;Ή$zoكFU_VQd{v&Ͻ'D
m4(9aC jYTis:dƇĢEWG,Pd#QKq eLj۱c8(J]E_R @ IDATF.jq]7644GZ?ό >\CmC>?&dÆ;q# R͌I-+{5 2jZ5 Z3RA:-oJxw'Y4Qp@۷ϕ5=)ivaDhOO'<|?9}3,2gjVha<#>(PWNg1X oO'\cjpL
EN
SYsح6 I}-KaXPkf[ǿ7 ЛK+4ǴL z]#`JDx N3XHVುs CT@ g ]NNЭB'8inŧ~g6G9:k锺G;_ P]ѩ4|煙8X1.> ]MKCĦs }=wgqg'!
5@=:ONo$c4bYO#zـ Y0P7 a7}ҋX} c ŘYX0P48D=./wT r*"U~ , rLrMգݖ{&lꚎn"GΞDeYoKWt7DTJ+u0`DP *:#$Y>5ލZ3w3msg ,Axj'ԥ69t))Bn=':34ry32Wd7 gOL?}8xy2$BimlVdF@UB<iKWR˩8.~Kߍc^JȜII:q_`1ͻur>wpk L8B-h23gQ6{=_#
gl} sJo4@6LSKE}IXՅ/~q;(ddG}>5?F'?#IΞKΟ nߙ~8}{IQ7"8 AyF%DbHD93{EB
قDZ0!~=s+3ޫIv L2σmlAvZ5vᛅ9)`@exџ:Ixv?e/L`(Q4?32
`Bdk3uYb Nibi,SAlA3ge"J* p-i:NФTwK\_.>>>>~`r(m$YVD! M.avakUa7kJitpB 57n Ɉ1}* Udo Nk%p.BVXQ &cq(W 6a Z^aa 8ښ[l^QR),9|#+QdbD6W.ßrL S=QyLCPɳ!:"f b˃y!2\H N#6~4Wnq lClW+'Ե/
_ߺ<8<nD3)ˌ_S|@D+%T q:![?815
ڌcNFƆAԠHP3M>T$+pS+39*kO#8A?QJGebpypWAaB٠ -1i@nS
F} v eDKz
yt69G.
mr >k"H'u%`fFqf CAr]\=DO0y744 0Kc|;㸠pp t"tltbrQtŀeG(.WהB%0mT>!`:UG+QVyi 2Ƒ:) !8RR,p
³19* X#OC@ fEfeؐ
i~ `Ħh36L )K'KȀWH- Cep,0Fd*Him``Z@;N }t翓FPNnNhd.#0*'1([uΠ5"O>8@e
7f2]L 5hbZA5} .PoC}+2:-dϜ
yTzŋY I9 { 8֎m:rvJuԑMɲYj%.A#T 4m8U-ҙΦ.kB>dFrFj>M?>9?0aX@ͦT6H]1N4h'&OQ ZL/T@P),PM7 {&3gpjq;oZ$F,#[z/̙9^tldu$KFu dixp8SuJPy\ O
N 8_eXUKim$-.=9gm20fG7H|9\.K_Ou6K][Ξ:N2b{ 1ǹ/Tℏ?-{'8K R}ϣ,617y( eLk\w"YTAIMpgѯ1p?#f7יV4;~_ݿۦk +_5ӻɚR24]K mfuY@}"t m݆G gÎF",p]H dN{[ 0퉔z[a ]Vx~oH4ju{،
#S )A :lghJjJ
<Ӎf
2q@\Ȭ5촼D Tu{ ) 0J v! 68Z#W#AgslقZS["l&zң e9GeAG"} L 8;[ [3M99
`w صCMJnxA'g͡_/yEV4)c1S:Zf`3WÃi{Ƿq]
VX63bL8C~= r7/ ~X k.W{@*;M9a ˱m1 {4Pqiri q֏ \ԃR%=4dюN2~ + ɪ)
հN83A+ğ>"n|̬.Qè<ŸGMC;@%TKPLdžn_ hd{Տ"SPw+:a&)uЈ`Ȥ
};$=7ـ21TZ *q {_kGyp_ t 1؍ً^Wߝ~
e}7_? yF釈b#Bܭ8
'Oep {X&O?A<97 @V#CC)R )Y8JpX8xħV0\;ԑM9 >z NM H>.Ŏ1sɀKgB3zX?A~)J@BC$
CHٱ zX?5E('Lh,nSCsvD-".,8@ ̘^DfQC A`M#*3\+cE hh?p/KPRFDFCsTNeEs1 $ c-.Wts~"LtMweǑ][ eg̀1}86ĉwptBj
3ㄬӛ`,B9̫J{2x}0l:;N<& כȬ; H3] 4Ϩ FNM3k^>F( 8ֳ5
H
| Ns9ѡ5Gi#z(f}/< ɭO:hLgNXH -](!K9q-Ȓ{/?SV =A16|p
&2 f8! ht4띃 ؼJw 0q}K8q8V
\_`ΧcV [[Z)9^>1GEȵe("}m&<,U\6,|
爌6@vߣ'izLG6( հoYka\01
`` R]SCD utG^VkkECM^D&Ƒ
cr@vjkSn y`t@_ s^uu)%@vJ_|5_ l @,
ϞV I6;FI? 'YǺ0 V| O:ƈQvi>
d88;3p~ '˰
BoFMDCe6:KYѽb
B4 //E73q%=J=_r1F\6 qZ iH te}tf(ii6$DZWE1_}(5\&2|QޔO}YcG03Yg1 ?I *'F~`c`^; CPqwm2lǾTHTR
[m9:)ȠO&§ cP[:B
plnl|$d0# xQ ^s o։툏Cz[ jRbYq. > Pp?V$ ڎ8(U*teP)=^ ʶ#>~ۈTAY =7Br L8 uqkeu
"DTxj|2DeF% Y4=6!Z:O 4@=KtF]c RC YvRC 1쭾4z6SȕYu|" ҹEXcYh=~ ڦm}T7Y?'6d ;!` `+ oh_]? sA!dY~l >&Wy-D \{h G=k`v}L6)@2a שJ1:A {)Uƺ<6LG1 B-ZKUN۸ZSv-#s\Ziźʺ}ˢZ&>kc+Q=d c W$2:$,IƊ zK 'J/IP5?:ExnJf/q~?~ G S)a iV[SJA<~D+PUPRi
yiI?MSE13dK[#9"6^Ry&!j~Yb̖F(wC %Ch }m8Rb@@gv>1yvk1ef>=Pyv2_E((]FP*|ds)Q81`gf'J@w
O[C0܅g=V"fqz3v}v^44a=taչgx U;26}@qy6 C::{:*=J[`$"7Q0fPThnfv;,@M
K%K-2}.VFЁQxDY34۰ لCAapbd" ft/Q7 uNU(9nӕ,n~/]:3-k:>0ݻwχĩ xF8wY'64acu3(Scdl VC%އ sA6L nf@ >9Ϭmt!C'bcȄ ͙w#d Xmo='6+̍A
c
>>i$`P}B
ͭ n}( it/3©Ӊؠ!$A/&B>Yk4Z^dLkG8>E]2Sl#{9#M! `E%i B:pٳd_a>lSsDFrÃ\Kp0@Yd' )~u(mڡw(
=O}w+N `a9l"SW遰'&+vqnI.Xk3A'HK~4J^K ǘ"8[fvdGse@E
ڋ/&= wPjmhIլs7}>#CIU
e-!7:d7ye&Z86H04\$%܋ afYK(;4`̪̌NrN|Ν9nݾ9;ȋ; |kUX5|6t?}/ݹ KcjZג%
Skݱ :C}a^ #S YkFŵ++/_# nB2cY *']왺F:kfA ÎD3ÝsVN `[_arn Q8v-=k#'Ta .ᯰ}TH!L$L gFzg0&54 =d3:ڳnso`{?j`UH$E 8$2ϥT/( r662ڥ{qeU%jeOؘ zg9B^ rj?5zx2 ,H{ii!u߱ޛ=̪UF L=}>}M F
. e eXipV^JWyIEt ^4H%5;Z6îp~
vOͳ0/j(&}K#L Z`& ˣi6#3k 7
OSYlnb-Q~:B= l 3[ ʍ w&2
3XZG<}p}};E3RRF͵6;ˉ<31N)l~HF' |UH<\:;[* 925|
IQ2Bw #va[?w g)Hpf(;\c gZ ++ Ϣ_e{zLߞM+JxO/Se\$;A!UWE}M>3AYL`+_,rRY%ዳ_ [{$21
b\Cs=
du?#Þs*XGg?}sòyWӆ_*ͲNcӎXK@j(@N
a4
Mӆ7KhWƂ`[$kok ?TYp ks: Ze6kSR\ZE =. E} b5Jz:eֆC#$+c5wܷM9F pΑsXO8` gkU<;(M)h0
fi
VvAu~$nX_yG"% ,"`V+*- 5RHGVd=5Hct ;S=aҨ^ڻ=D}Bq}3
A4Ikc$ dJ\j/M^f$dĤp_Kd Uʑ dR^H)f[BX807uª: )v-&Xfv,FGmQ6j?I M#@XގYم1hL Ҭn&
ʦT
PFV c*Ǚ̥9gJr0rXHfP(KΚP3 tZTegw}ld𧣤o̪Oh xę Nʂ+RC«ӫ5 I) J߬2X_
m@@E
::: ?^ 4QP{j ~t=}xF, =M`0 Vvv}7Kg F
6LQ^qٍp$0't@g2 JŔ4Ʌ! ;XC9mA'o
+?=tT !k7s;L 1> e o~FA^ἣ5 ڋ/ ,S'Nl px65Id51B .p,kO\Svi. .I$;i&# D0@i2 =D' .ɢCFmҠgG bJ}b jO< 1tD=1#e
̗!0hq >CTgBVb }
3ecϝ>ӳ-;t+KL@_j8ʡgrmu2qI ƟCAk=iGDe'[k5z_u&kd54mYR.^)( udsQx,J#ojQJOP\ g˦d(9;_ ?6`QvV7F ycY4xk}wt̀s+\ 3cAPEcܧQCqTn;BVS
Y[WF&3cT6DYE_O 52YNYF`ɟyAF ڳF@AԔ8+؛bdXaI`9^fzh@6+ ] X#;ol+t8gnq=-cS-nlG(`RfZ STU5:>5f8nn+? L'ˉE-aq t4M/ "C(E Οk4 2 m?]Yz3)k,Nd;h 8aG!TJ]S %?ik KNKIdAHTqhr\}RYK.M_:Fz9
#KSn ؠgqll: (Wkva kư4u' c\sZ!'sSrfHF_ e!X襺ʴ4(GҲO=F!%);G~; onŧgDPH D9Mu]kcCp6bH l?_KK5e/\~~j{)}D\B//['b:^Q%X_
5V!h%o([X߀ )48Wv 11߮/9w6gPCfQBP(C#jP8Av|&]t$vn%T좨z(Ϝ.6EAZUӠ6[(7Y%Ӡ TdF D9*K=j ERgݒپq r]@f.IjTAE{_8=gדe ;.x%(Rz[
Ah5h?VYazPnCͼ_9FoE5l<}u
H joF!)
r\DS-P_i~yu"Cm QKED{$Zfz -:Y8,XgMIzq/}r}_ %87YU[c,&uvmoh>bM-܉Nִng aЬ-bx[Ys ؽ! ͵0zV TȞ ΟpR9
@Ӏə#'.q̑oYA QVsXYEWIP*k5N0>> 2bY.>11J`vE%XͳK1t #BiC3΅#ǟ l iS@\#KoBܜ<.={q cĩe/HX$xH}#,skcx5q Z`Ѓ`fIݥU[ *e<½Iww pf##^ N)ٕ' 8ߣGJuQc`FI
t'&bC=(5f.!;}:q{f8 Yg-zOr DZ;3A
@Aj@u@:
}uvQb$ku3LJ2l=Ɣy]٩ jh{\漇 x:oJ=LY N8RMPl*d>A >uڝin0znRm_u2ÆtMGf쥐%l {Xz'/{O/x5: E̞ C=i&{3'[R{w І}(4I~ZuG:+Cp
̥Wy,zQF#ep]hޔ{Hi`uv1Y)2` P'8
g "`ҵ ޜ69lk-Q0qb+YXBݜ>xFO8k:x.{g7ɞ=o N[ikm G}F
ˎfQXJ`PpAjM&E&(N ŋ ~IOGu'& Ι^H/!̠AٍO Ί,!7e(2 +á.ӼL3ucDI)P6vAڢ.}DN ^H_ t/9>n3ޒd ðHGX6ml1Ж -M?gBrRdF={H5{hȤS _cS"7
&T& ]L7>. Bg b a/MƇI@0c KcIMϵy~!$pnR#<`T $ߙCSY O n[;:!FH4,+9UAc@Ȋz-tI-W9qil(Eo5F.+R6>~M6Y|3ś'J uױY"qȚUGsDOcI8Pdz-P)$~ lA/yQΠ OIMd
Y#C_98g "lh*X`e<~hߊX g)t*QrkL3*'ryniaIZ= 8WkhJx]ᜇ ԲIz*, fѸGidI^2f+Ě-Ӵ zɎ-Gϩ_d\ ͡gYQVIצ״2--eok4^,{`Y
& ϸ'˅0#wWr,#IUitق&Q= ^pt[#94XA
&{ 57W^^e/GF:o
T#ZaD
}vzr(rVQf tM Fn^
_j㋌'+e8yX /4.I>!OD>AAαsVqȀ ލwq8WȆOSԅbPv(?¸uDu$7 {zHHFnJ0
:## cM K4 f=&=dӚ@6)(_,I @ `Ay6=VR]w/%t<©2B"Np/ l8zڨ=l(q khB*zthaR Tp*\7kE\ԪMQic|ٵyttYYRGsK26D
tttj
]';݆P: Tv`/-'X! Fj5kr?[Z`鵴m{e.F7"ͱ 0@>'Ԗov!
CBV0PMm6w)1myfkgWy|r@\ezT47$ӴGl*y"`ٵF@ |:QX"=p,` w!ˈRFakU3@s} hlAN=c4R
ARCʥڎ:7o^:l6BRM4| VE6?+)# ]X3m8L> #ʇryaKn Ea D}
ěZ6" $pMBb0< q7w 39#:Cd7(q3 QΤo&6)OJ?\/hSGNW! t
@c<5e B~>CX7e2^Vp6,ᘙ!i8YJYfBqS-ͨpC&*=e@3o%Ę@>8[Ks[ C'C/;HUeRS:X/pű1t4g66m-@$['GfLL 2YG9竍cz|<6 ͔M
"l>de6=(l@&C$ SPƍ>zo/KxH?IAî T @ቴ9^ 40ЁܣN~1gkR dW~ tv}Kʍo?N6wfȨ gwon|T8b
PHoG?>A
@^^Nt ĉ6ޟ attДB NHT v!a2&ya]~ & `
Ķ_N[bC`vgO'S:Js0ԥ#pO9R~i@N +FF`Bc.3 ܨ%ep.lX)3e{ٵtr_zt)؆"a P\dKؿb
fW }0S!{m,uPϡvx D'BdU֠`ɸ UXS&S ԏSt_PNcRm7+4;2M}|sj BhQec;7#>YMЫ|G}TfpZUeÀ.~ݳA!dYxkd3L`&ef' r ˘NtJ[b?vQ3m&~[Gg aCKؿW6 ( y\~.[܋P8by?Cuަvo
8-)m9Iv%Fz5̶_!6Kmvx'Ib¢0f ?% ٣y& oBj?&6gͭLNΝO:HOROl(-? 6dnEy2ɚ| pE@ƆA Б GV_G<!WFG3 SLdٳ'Ø֝kL\:r>36g~L. 2ml#CrП{FS
NÇ}?iJP9m숳e9Jz3/|05teii!=&d_8IyJQ,u2{rU@4=ήS#HO MM~OAPB|v .`
(KKki`_$%ęЯQZ% &?_O
)LQjXԃd
:ËY&US%a~}?X;"6J# оR-茮l @ IDAT}i=h_{wrԓ;20]WPx ~DWossk}x=OA/[ MRJLff35 }(kDvqܤ3k oQohQ\(~~)CZj 5Ɍ
8lZr3.:F&-7D0CVp>vϨ~6IAθ=73oR
X)5 \2zLQL"֦pɖ'n͐觠Ia"Lᓚ
t"VF`T 䪹7N N{$HgeSws(>f>-\P
jan sr 0XcͷsE5\~ 6?
#8o3fʔSAEN"ٳrwҍX:
%qKu üu~ &^N"=u & ^1{}$Be
,nC=B6Lq.ې߾qo Ts7p _:M<i3-NU Ko B:}u0ՀYcKI7X4s_9V
]V_d~gX:zoWdq2?'vR3Qnl;b,8
&]sGRXў.ዑjP3Ce.X["`%+
ܒ
p=E+my/
)bA?DGPn0AX/&mr' =aoSz ̷Ig Ğ'ZJƵ b7Ebֳ`|`pV>[[S/^z# Si
o?Y&c8xA'EX F< F}s֝ۑQ l\)sLP
]
@o~V7a y>z>uډnJ`xfˊ k0gEOM팻}3e" rN: K -dȳkcVW?443x3#B~ NNyGs Ge
YHu@)hCvl,-\ A5.8٧O&3} nZY*]
>/ b bѓ 7s!2<Ėح=
8͝ 39gYelZnSYY6`WZTWKC:pرYѨnN jvmNWU6
Xr
$ɤY5kOnz3z_
; ߛW<&` n*:u g ,7g~S0Il>d=H
S1X5y0VT Pfcfl`SFbٮ`>e~N8yBn&g4\F)Llmo VʚMId!B>INfM ɂ!)&>-F6
9&p2\`@ e>^O[Boa\?P;X;L^u%>cWퟥl ``yM&##C 8ky>?ab<47H[(=A"Xgml>eV2͊z|l5zTNSr2z}vd (>
(|= GG
1Ȍ 3I F[
r[uf2^]XWEW ItJY);G-o=^O$b%ϓ28l69~}5`@s'7I5=b ~xU7> W=p6} 3
+ۿOXc_)&*m
cQ@xTQ*3`0F`&D"Y F-
(d4N
Љ 3ƾTDd9(ukldC6/H`6d@l(( g[* HG!ˀ:
` 5> "Xxq404NJg S?ZΧpɦ46Ce ` H9Y꽵@^4M&6ΆJuYhVa
nm#Q(:0g
Jdqvp
[s Cbv3QUiu✝_J>Noy3wK L1dEu (C&J*BuoUܙsQXn{j>]ڣR
5R'`ɉ~>bxn`Hޠ4X2b)AKTl3"6+*d_$ITm)it "WY?NL'+F?ʹξTa)k= 4鷂>`Ժ.
Tg ^cH%%dg7i&yCV({M8P+|S Vbw ^ݦ!=
]H}Hgc316NwE@PJ cs gVĉy:Ü3{>?ml{Ngõx]˽r~ $M$ڲ~;wne]Ok[x ݼE~ýK$Ԡ9A|oG7adY
BNVr@k }넳}5sPpƆӇ>I
iQoAg odW-݉\W{ T "eSyU?%'aYf?F+(Ml2sg.{- ]]~XzK
d -:W8Rf7|SAj{u%0|B]xxьȦϼ ƹshKCn75.ct汷M
B?r k" It*F\y>YvS؈f$آD' ֿ zɟ1:h}
` GtbR[co jL
2w݄]# `@{S=# Q) /2(G>ݗ]А;:qZiU֥g^`M?ǹ"z_{rn <:꼡 _8@ڸ'OѰ1}d
#N6ի//Jz1 5Xp
ħ s& ΟNϜ= fldmy=l칳Tq۽ @s@,il^ k3%0 |I2Ǐפ._֞LF/^e00zƊbŰb&еEEsS
xO gzlRY\TEؖ˜bB 7gG;¹7*Qg =`F 2
xsvcsQ2,ss" , ,(29bG|[P5}Zmĵ`:l Ʈ-aSci> ET2 }J @e&+ J.mJ') \=Vio, #k +4@]'T=s,%1 = Q80/
#/E6}5e$`..ģb:@F12b5zn {_
) o=YAOw . pzc)Al =,י Ϡy2:FRMF=~&}Tw?;?{=Nsz'2
?v7Y/2 XV@B5 =s>A66vޮ |"t:lLo_97:Ο8#X L LE0@N[2k˫# PVR,դ6_,{0jϵoީ,ħ LVΥJЃ쑬)ew]a ϩ'A/~@ae| @*O,P:e` cSH0,-0bL"9 >yLUR^3WY`i7@{npSy@* wt,8}?/
p7Vܵk_?:%o>s3G s6 RDooOT#)2Ù4+p
4_3cs(
g%ik zթH: QmvDE d\Ntbԥq(?u\ M
EƊ qˍCf U ggٌU6XqIA}(DZ:$Ygpt0PgfKM0 D 't=ǒcd4))A98aQTzzvѓ;M aLT"љI6;W|,K`1M bᜧlCMwq@ؿͣK,zI}ʫ ;]\Kc
d$Z Rd' I(-N060
jjS"^ܘbOf DY=s
V:r B}cscԮ.Rg{Oood,K0С(!0S" xʾ`nD~*hkpV"=K~z^<q^xWgPC&d`t 8I# pH֮6+fDZ8-Z ^ q 5X_[ #ճLVEMQ';l6R^ []I>xO߂vJψY$u QXͭpܲawYJDCT1(0#xh0?
p b1B_s /6ͽ602sd)<6nJ,kʾ5ڰ ]W<42 fA}8{ >I`5'/9' OɡӺMßеg>fU$fr*Y{2qbo6MҼx g'miefΑhwAt7$Ӈ/d[< ǖpr!:1gnF6O,|Fy( +}XB}0`zr6}vf:u ̖7ܛ^k8)g1 |Qe 4G[Y S FN`Z͛0ӝ8̌I~tjy؏DG=u*dҋt LPqM9J\K@!.|kۡ#bYR XsKS8څg 5 jfl~>
d `
"/?^ z& :zyll"utt]M
h,9BNs67 B!锃 8"t-@f 탙TI\[2GR{ X]̎ l)2`<@`ɪ""6@zJI 2lre`iѩhb쩲 W4=7w|TDw
sW?e̞ ;F~l.51؟\;\; .~x6u:;z:|fo@m)gY`(RX`˗س
;<6ښ8;&w=؟$c:a?O#rVSYM}Zښm z0o(,Jc업pz)K ᚂzm0` Mc R9zs ?rw.^4Yin+1yPeV3. it#6>I|)}xrY
g Fis4_ 4I b xn"
S'شĢϖao1胅b le}eʳ
c cտOy 1V6PT(jBү\TulkpU
И푲UL8TЎr*!`t
8KKnf|J6uH)tH\*=u9Z2 >G(2kF@1cF'p=q{G&ojJU3fjiLd|`pZjVنo{JהZ !cȿ7{4t &b}̮/t%x:.X>{o HRds l#p:'Oe/@*jqvRʌkuװWt@ ̸"!4 :?֍s qLgSgw7{O νٯU w~t#GT7F6n
D(} u$gexe@Y$]pK]ƳOFQFb>w7z}x>#).AXY#Dζ AVצh_PZ )'x!YGb%Z)߅
RI 5=8C[:(^,iqmt'Q^SٰfrqFp,ύN<9u,.0? g9,!3E uý
}٫7gEEh͡Wg%x|zEmxt