From 32fc0b463c86dc03136c22bf1e45591a05b4275a Mon Sep 17 00:00:00 2001 From: Sam Gammon Date: Wed, 8 Nov 2023 00:59:47 -0800 Subject: [PATCH] initial commit --- .github/CODEOWNERS | 1 + .github/workflows/build.module.yml | 0 .github/workflows/on.pr.yml | 0 .github/workflows/on.push.yml | 0 .gitignore | 42 + .idea/.gitignore | 8 + .idea/gradle.xml | 37 + .idea/inspectionProfiles/Project_Default.xml | 6 + .idea/kotlinc.xml | 6 + .idea/misc.xml | 9 + .idea/vcs.xml | 6 + .version | 1 + README.md | 257 +++++++ build.gradle.kts | 62 ++ buildSrc/build.gradle.kts | 11 + buildSrc/settings.gradle.kts | 43 ++ buildSrc/src/main/kotlin/PlanetscaleBuild.kt | 60 ++ .../src/main/kotlin/PublishingConventions.kt | 61 ++ .../common-conventions.kotlin.gradle.kts | 128 ++++ .../planetscale-connector.klib.gradle.kts | 8 + .../planetscale-publishable.klib.gradle.kts | 7 + gradle.properties | 43 ++ gradle/libs.versions.toml | 84 ++ gradle/verification-keyring.gpg | Bin 0 -> 198557 bytes gradle/verification-keyring.keys | 719 ++++++++++++++++++ gradle/verification-metadata.xml | 564 ++++++++++++++ gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 60756 bytes gradle/wrapper/gradle-wrapper.properties | 5 + gradlew | 234 ++++++ gradlew.bat | 89 +++ settings-gradle.lockfile | 5 + settings.gradle.kts | 75 ++ subprojects/catalog/build.gradle.kts | 37 + subprojects/catalog/gradle.lockfile | 4 + subprojects/core-api/api/core-api.api | 357 +++++++++ subprojects/core-api/build.gradle.kts | 39 + subprojects/core-api/gradle.lockfile | 7 + .../src/main/jvm/com/planetscale/Driver.kt | 10 + .../com/planetscale/jvm/DriverParameter.kt | 21 + .../com/planetscale/jvm/PlanetscaleAdapter.kt | 111 +++ .../com/planetscale/jvm/PlanetscaleConfig.kt | 158 ++++ .../planetscale/jvm/PlanetscaleConnection.kt | 13 + .../planetscale/jvm/PlanetscaleCredential.kt | 95 +++ .../jvm/PlanetscaleCredentialInfo.kt | 10 + .../planetscale/jvm/PlanetscaleParameter.kt | 69 ++ .../jvm/driver/AbstractPlanetscaleAdapter.kt | 87 +++ .../planetscale/jvm/driver/CloudProvider.kt | 9 + .../com/planetscale/jvm/driver/Constants.kt | 52 ++ .../jvm/driver/PlanetscaleDriver.kt | 68 ++ .../planetscale/jvm/driver/package-info.java | 4 + .../planetscale/jvm/err/PlanetscaleError.kt | 6 + .../com/planetscale/jvm/err/package-info.java | 4 + .../jvm/com/planetscale/jvm/param/Defaults.kt | 11 + .../planetscale/jvm/param/DriverParamTypes.kt | 7 + .../com/planetscale/jvm/param/Parameter.kt | 85 +++ .../planetscale/jvm/param/ParameterSource.kt | 18 + .../planetscale/jvm/param/package-info.java | 4 + .../jvm/com/planetscale/package-info.java | 4 + .../core-api/src/main/jvm/module-info.java | 16 + .../META-INF/services/java.sql.Driver | 1 + .../src/main/resources/logback-test.xml | 13 + .../test/kotlin/com/planetscale/DriverTest.kt | 50 ++ .../planetscale/jvm/PlanetscaleConfigTest.kt | 128 ++++ subprojects/driver/api/driver.api | 0 subprojects/driver/build.gradle.kts | 16 + subprojects/driver/gradle.lockfile | 9 + subprojects/impl-h2/build.gradle.kts | 18 + subprojects/impl-h2/gradle.lockfile | 8 + .../planetscale/jvm/h2/PlanetscaleH2Driver.kt | 35 + .../impl-h2/src/main/jvm/module-info.java | 9 + .../META-INF/native-image/proxy-config.json | 5 + .../META-INF/native-image/reflect-config.json | 5 + .../native-image/resource-config.json | 12 + .../com.planetscale.jvm.PlanetscaleAdapter | 1 + subprojects/impl-mysqlj/api/impl-mysqlj.api | 20 + subprojects/impl-mysqlj/build.gradle.kts | 21 + subprojects/impl-mysqlj/gradle.lockfile | 9 + .../jvm/mysqlj/PlanetscaleMysqlDriver.kt | 147 ++++ .../impl-mysqlj/src/main/jvm/module-info.java | 9 + .../com.planetscale.jvm.PlanetscaleAdapter | 1 + .../jvm/mysqlj/PlanetscaleMysqlDriverTest.kt | 57 ++ .../api/integration-graalvm.api | 4 + .../integration-graalvm/build.gradle.kts | 21 + .../integration-graalvm/gradle.lockfile | 101 +++ .../jvm/com/planetscale/PlanetscaleFeature.kt | 8 + .../api/integration-kotlin.api | 0 .../integration-kotlin/build.gradle.kts | 21 + .../integration-kotlin/gradle.lockfile | 7 + .../api/integration-micronaut.api | 0 .../integration-micronaut/build.gradle.kts | 23 + .../integration-micronaut/gradle.lockfile | 101 +++ 91 files changed, 4737 insertions(+) create mode 100644 .github/CODEOWNERS create mode 100644 .github/workflows/build.module.yml create mode 100644 .github/workflows/on.pr.yml create mode 100644 .github/workflows/on.push.yml create mode 100644 .gitignore create mode 100644 .idea/.gitignore create mode 100644 .idea/gradle.xml create mode 100644 .idea/inspectionProfiles/Project_Default.xml create mode 100644 .idea/kotlinc.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/vcs.xml create mode 100644 .version create mode 100644 README.md create mode 100644 build.gradle.kts create mode 100644 buildSrc/build.gradle.kts create mode 100644 buildSrc/settings.gradle.kts create mode 100644 buildSrc/src/main/kotlin/PlanetscaleBuild.kt create mode 100644 buildSrc/src/main/kotlin/PublishingConventions.kt create mode 100644 buildSrc/src/main/kotlin/common-conventions.kotlin.gradle.kts create mode 100644 buildSrc/src/main/kotlin/planetscale-connector.klib.gradle.kts create mode 100644 buildSrc/src/main/kotlin/planetscale-publishable.klib.gradle.kts create mode 100644 gradle.properties create mode 100644 gradle/libs.versions.toml create mode 100644 gradle/verification-keyring.gpg create mode 100644 gradle/verification-keyring.keys create mode 100644 gradle/verification-metadata.xml create mode 100644 gradle/wrapper/gradle-wrapper.jar create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100755 gradlew create mode 100644 gradlew.bat create mode 100644 settings-gradle.lockfile create mode 100644 settings.gradle.kts create mode 100644 subprojects/catalog/build.gradle.kts create mode 100644 subprojects/catalog/gradle.lockfile create mode 100644 subprojects/core-api/api/core-api.api create mode 100644 subprojects/core-api/build.gradle.kts create mode 100644 subprojects/core-api/gradle.lockfile create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/Driver.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/DriverParameter.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleAdapter.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleConfig.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleConnection.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleCredential.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleCredentialInfo.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleParameter.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/AbstractPlanetscaleAdapter.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/CloudProvider.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/Constants.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/PlanetscaleDriver.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/package-info.java create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/err/PlanetscaleError.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/err/package-info.java create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/Defaults.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/DriverParamTypes.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/Parameter.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/ParameterSource.kt create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/package-info.java create mode 100644 subprojects/core-api/src/main/jvm/com/planetscale/package-info.java create mode 100644 subprojects/core-api/src/main/jvm/module-info.java create mode 100644 subprojects/core-api/src/main/resources/META-INF/services/java.sql.Driver create mode 100644 subprojects/core-api/src/main/resources/logback-test.xml create mode 100644 subprojects/core-api/src/test/kotlin/com/planetscale/DriverTest.kt create mode 100644 subprojects/core-api/src/test/kotlin/com/planetscale/jvm/PlanetscaleConfigTest.kt create mode 100644 subprojects/driver/api/driver.api create mode 100644 subprojects/driver/build.gradle.kts create mode 100644 subprojects/driver/gradle.lockfile create mode 100644 subprojects/impl-h2/build.gradle.kts create mode 100644 subprojects/impl-h2/gradle.lockfile create mode 100644 subprojects/impl-h2/src/main/jvm/com/planetscale/jvm/h2/PlanetscaleH2Driver.kt create mode 100644 subprojects/impl-h2/src/main/jvm/module-info.java create mode 100644 subprojects/impl-h2/src/main/resources/META-INF/native-image/proxy-config.json create mode 100644 subprojects/impl-h2/src/main/resources/META-INF/native-image/reflect-config.json create mode 100644 subprojects/impl-h2/src/main/resources/META-INF/native-image/resource-config.json create mode 100644 subprojects/impl-h2/src/main/resources/META-INF/services/com.planetscale.jvm.PlanetscaleAdapter create mode 100644 subprojects/impl-mysqlj/api/impl-mysqlj.api create mode 100644 subprojects/impl-mysqlj/build.gradle.kts create mode 100644 subprojects/impl-mysqlj/gradle.lockfile create mode 100644 subprojects/impl-mysqlj/src/main/jvm/com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriver.kt create mode 100644 subprojects/impl-mysqlj/src/main/jvm/module-info.java create mode 100644 subprojects/impl-mysqlj/src/main/resources/META-INF/services/com.planetscale.jvm.PlanetscaleAdapter create mode 100644 subprojects/impl-mysqlj/src/test/kotlin/com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriverTest.kt create mode 100644 subprojects/integration-graalvm/api/integration-graalvm.api create mode 100644 subprojects/integration-graalvm/build.gradle.kts create mode 100644 subprojects/integration-graalvm/gradle.lockfile create mode 100644 subprojects/integration-graalvm/src/main/jvm/com/planetscale/PlanetscaleFeature.kt create mode 100644 subprojects/integration-kotlin/api/integration-kotlin.api create mode 100644 subprojects/integration-kotlin/build.gradle.kts create mode 100644 subprojects/integration-kotlin/gradle.lockfile create mode 100644 subprojects/integration-micronaut/api/integration-micronaut.api create mode 100644 subprojects/integration-micronaut/build.gradle.kts create mode 100644 subprojects/integration-micronaut/gradle.lockfile diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..e84bec6 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1 @@ +*.* @sgammon diff --git a/.github/workflows/build.module.yml b/.github/workflows/build.module.yml new file mode 100644 index 0000000..e69de29 diff --git a/.github/workflows/on.pr.yml b/.github/workflows/on.pr.yml new file mode 100644 index 0000000..e69de29 diff --git a/.github/workflows/on.push.yml b/.github/workflows/on.push.yml new file mode 100644 index 0000000..e69de29 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b63da45 --- /dev/null +++ b/.gitignore @@ -0,0 +1,42 @@ +.gradle +build/ +!gradle/wrapper/gradle-wrapper.jar +!**/src/main/**/build/ +!**/src/test/**/build/ + +### IntelliJ IDEA ### +.idea/modules.xml +.idea/jarRepositories.xml +.idea/compiler.xml +.idea/libraries/ +*.iws +*.iml +*.ipr +out/ +!**/src/main/**/out/ +!**/src/test/**/out/ + +### Eclipse ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache +bin/ +!**/src/main/**/bin/ +!**/src/test/**/bin/ + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ + +### VS Code ### +.vscode/ + +### Mac OS ### +.DS_Store \ No newline at end of file diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..13566b8 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/gradle.xml b/.idea/gradle.xml new file mode 100644 index 0000000..de7217b --- /dev/null +++ b/.idea/gradle.xml @@ -0,0 +1,37 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..df543e3 --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml new file mode 100644 index 0000000..e805548 --- /dev/null +++ b/.idea/kotlinc.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..4b9d7f4 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.version b/.version new file mode 100644 index 0000000..62581c7 --- /dev/null +++ b/.version @@ -0,0 +1 @@ +1.0.0-alpha1 diff --git a/README.md b/README.md new file mode 100644 index 0000000..c6b16fd --- /dev/null +++ b/README.md @@ -0,0 +1,257 @@ + +# Planetscale Connector/J + +> **Note** +> Under construction; use at your own risk + +This library implements a [JDBC adapter](https://www.oracle.com/database/technologies/appdev/jdbc.html) for +[Planetscale][1]. + +Planetscale uses [Vitess][2] as a backend, which is wire-compatible with MySQL; thus, this library is a wrapper around +the [MySQL Connector/J][3] library, which is used for the actual work of connecting and running queries. + +This library adds several features, using the MySQL/J connector, to make it easier to work with Planetscale. + +- [Installation](#installation) +- [Features](#features) +- [Integration Libraries](#integration-libraries) + - [Micronaut Integration](#micronaut-integration) + - [Kotlin Integration](#kotlin-integration) + - [GraalVM Integration](#graalvm-integration) + +## Installation + +> **Warning** +> This is *not* endorsed by Planetscale, and is not yet published to Maven Central. + +| Coordinates | Driver | +|---------------------------------------|------------------------------| +| ```com.planetscale:planetscale-jvm``` | ```com.planetscale.Driver``` | + +**Gradle (Kotlin DSL, via Version Catalogs):** +```kotlin +// in settings.gradle.kts + +dependencyResolutionManagement { + versionCatalogs { + create("planetscale") { + from("com.planetscale:planetscale-catalog:(latest version)") + } + } +} +``` +```kotlin +// in build.gradle.kts + +dependencies { + implementation(planetscale.driver) +} +``` + +**Gradle (Kotlin DSL, one library at a time):** +```kotlin +dependencies { + implementation("com.planetscale:planetscale-jvm:") +} +``` + +**Maven:** +```xml + + com.planetscale + planetscale-jvm + + +``` + +# Features + +- **Easy Planetscale connection strings.** + + Use `jdbc:planetscale://aws` or `jdbc:planetscale://gcp` or connect to a specific region with something like + `jdbc:planetscale://us-east-1.aws`. The adapter builds the right URL for you. These examples become: + +``` +jdbc:mysql://aws.connect.psdb.cloud:3306/dbname?... +jdbc:mysql://gcp.connect.psdb.cloud:3306/dbname?... +jdbc:mysql://us-east-1.aws.connect.psdb.cloud:3306/dbname?... +``` + + +- **Load balanced reads.** + + Use more than one endpoint with URLs like: `jdbc:planetscale://us-west-1.aws..aws`. In this case, the MySQL/J driver + is configured with: + +``` +jdbc:mysql:replication://us-west-1.aws.connect.psdb.cloud:3306,aws.connect.psdb.cloud:3306/dbname?roundRobinLoadBalance=true&... +``` + + +- **Eager driver cache and solid defaults.** + + The Planetscale driver configures the MySQL/J driver for client-side caching of server configuration, result set + metadata, and so on. SSL verification is turned on, as is auto-reconnection. Equivalent driver options: + +``` +autoReconnect=true +cacheServerConfiguration=true +cacheResultSetMetadata=true +sslMode=VERIFY_IDENTITY +roundRobinLoadBalance=true +``` + + +- **Support for Planetscale's options.** + + Planetscale options like `enableBoost` can be applied to configure the underlying URL properly. For example, adding + `enableBoost=true` to the AWS sample URL above, like so: `jdbc:planetscale://aws?enableBoost=true`, becomes: + +``` +jdbc:mysql://aws.connect.psdb.cloud:3306/dbname?sessionVariables=boost_cached_queries=true&... +``` + + +- **Configure credentials via env vars, properties, or connection URL.** + + `PLANETSCALE_USERNAME`, `-Dplanetscale.username`, and `jdbc:planetscale://user:pass@...` are all supported, as are the + same variables for the connection password. These are consulted if no user/pass are found in the connection string. + +# Integration Libraries + +There are a few libraries shipped with this repo which make integration easier with various frameworks or systems: + +## Micronaut Integration + +Adds [Micronaut][5] property source support for Planetscale configuration. Effectively, the module configures itself as +a driver (when enabled), and provides connection parameters as configuration. Otherwise the driver is identical to using +the MySQL/J driver library directly. + + +### Usage + +Configuration in Micronaut is pretty easy: + +```yaml +planetscale: + enabled: true + databases: + default: + db: dbname + username: username-here + password: password-here + endpoints: + - us-west-1.aws + - aws + features: + boost: true +``` + +`PLANETSCALE_DB`, `-Dplanetscale.db`, and so on, also work. This is roughly equivalent to: + +```yaml +datasources: + default: + url: jdbc:mysql://username-here:password-here@us-west-1.aws.connect.psdb.cloud:3306,aws.connect.psdb.cloud:3306/dbname?cacheServerConfiguration=true&cacheResultSetMetadata=true&sslMode=VERIFY_IDENTITY&roundRobinLoadBalance=true&sessionVariables=boost_cached_queries=true + driverClassName: com.planetscale.Driver + db-type: mysql + name: dbname + username: username-here + password: password-here + maximum-pool-size: 32 +``` + +### Installation + +**Coordinates:** +``` +com.planetscale:planetscale-micronaut +``` + +**Maven:** +```xml + + com.planetscale + planetscale-micronaut + + +``` + +**Gradle (Version Catalog):** +```kotlin +dependencies { + implementation(planetscale.integration.micronaut) +} +``` + +## Kotlin Integration + +Adds [Kotlin][6]-focused API support for Planetscale. Easily load credentials and configuration, and then obtain a driver +instance or connection. + +### Installation + +**Coordinates:** +``` +com.planetscale:planetscale-kotlin +``` + +**Maven:** +```xml + + com.planetscale + planetscale-kotlin + + +``` + +**Gradle (Version Catalog):** +```kotlin +dependencies { + implementation(planetscale.integration.kotlin) +} +``` + + +## GraalVM Integration + +Adds metadata and a supporting feature configuration for [GraalVM][4] native image compilation. Reflection configuration +is embedded which supports both this adapter and MySQL/J. + +### Usage + +Reflection and resource configuration is automatic. Otherwise, during a `native-image` build: + +``` +native-image ... --features=com.planetscale.PlanetscaleFeature +``` + +### Installation + +**Coordinates:** +``` +com.planetscale:planetscale-graalvm +``` + +**Maven:** +```xml + + com.planetscale + planetscale-graalvm + + +``` + +**Gradle (Version Catalog):** +```kotlin +dependencies { + implementation(planetscale.integration.graalvm) +} +``` + +[1]: https://planetscale.com/ +[2]: https://vitess.io/ +[3]: https://dev.mysql.com/downloads/connector/j/ +[4]: https://www.graalvm.org/ +[5]: https://micronaut.io/ +[6]: https://kotlinlang.org/ diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 index 0000000..ead80e8 --- /dev/null +++ b/build.gradle.kts @@ -0,0 +1,62 @@ +import java.nio.charset.StandardCharsets +import com.adarshr.gradle.testlogger.theme.ThemeType + +plugins { + alias(libs.plugins.doctor) + alias(libs.plugins.sbom) + alias(libs.plugins.sonar) + alias(libs.plugins.kover) + alias(libs.plugins.kotlinx.plugin.abiValidator) + alias(libs.plugins.version.check) + alias(libs.plugins.version.catalogUpdate) + alias(libs.plugins.spotless) + alias(libs.plugins.testLogger) + + id(libs.plugins.sigstore.get().pluginId) + id(libs.plugins.nexus.publish.get().pluginId) +} + +val stamp: String by properties + +group = PlanetscaleBuild.Library.GROUP +version = if (stamp == "true") { + // if instructed to "stamp" the output libs, include the output from `.version` + layout.projectDirectory.file(".version").asFile.readText(StandardCharsets.UTF_8).trim() +} else { + "1.0-SNAPSHOT" +} + +val spotlessPlugin = libs.plugins.spotless.get().pluginId +val sonarPlugin = libs.plugins.sonar.get().pluginId +val koverPlugin = libs.plugins.kover.get().pluginId +val testloggerPlugin = libs.plugins.testLogger.get().pluginId +val sbomPlugin = libs.plugins.sbom.get().pluginId + +subprojects { + apply(plugin = spotlessPlugin) + apply(plugin = sonarPlugin) + apply(plugin = koverPlugin) + apply(plugin = testloggerPlugin) + apply(plugin = sbomPlugin) + + testlogger { + theme = ThemeType.MOCHA + } + + spotless { + ratchetFrom("origin/main") + + kotlin { + target("**/*.kt") + ktlint(libs.versions.ktlint.get()) + } + } +} + +apiValidation { + // Projects which are not published or otherwise do not expose a JVM API. + ignoredProjects.addAll(listOf( + "catalog", + "impl-h2", + )) +} diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts new file mode 100644 index 0000000..8843786 --- /dev/null +++ b/buildSrc/build.gradle.kts @@ -0,0 +1,11 @@ +plugins { + `kotlin-dsl` +} + +val kotlinVersion = "1.9.20" + +dependencies { + implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion") + implementation(libs.plugin.nexus.publish) + implementation(libs.plugin.sigstore) +} diff --git a/buildSrc/settings.gradle.kts b/buildSrc/settings.gradle.kts new file mode 100644 index 0000000..1f34361 --- /dev/null +++ b/buildSrc/settings.gradle.kts @@ -0,0 +1,43 @@ +@file:Suppress( + "UnstableApiUsage", + "DSL_SCOPE_VIOLATION", +) + +import build.less.plugin.settings.buildless + +pluginManagement { + repositories { + maven("https://gradle.pkg.st/") + maven("https://maven.pkg.st/") + mavenCentral() + gradlePluginPortal() + } +} + +plugins { + id("build.less") + id("org.gradle.toolchains.foojay-resolver-convention") +} + +buildless { + // nothing at this time +} + +dependencyResolutionManagement { + repositoriesMode.set( + RepositoriesMode.FAIL_ON_PROJECT_REPOS + ) + repositories { + maven("https://gradle.pkg.st/") + maven("https://maven.pkg.st/") + mavenCentral() + gradlePluginPortal() + } + versionCatalogs { + create("libs") { + from(files("../gradle/libs.versions.toml")) + } + } +} + +rootProject.name = "planetscale-buildsrc" diff --git a/buildSrc/src/main/kotlin/PlanetscaleBuild.kt b/buildSrc/src/main/kotlin/PlanetscaleBuild.kt new file mode 100644 index 0000000..afe58fe --- /dev/null +++ b/buildSrc/src/main/kotlin/PlanetscaleBuild.kt @@ -0,0 +1,60 @@ +import org.gradle.api.Project +import org.gradle.api.publish.PublishingExtension +import org.gradle.api.publish.maven.MavenPublication + +object PlanetscaleBuild { + object Library { + const val GROUP = "com.planetscale" + const val CATALOG = "planetscale-catalog" + const val CORE_API = "planetscale-core-api" + const val DRIVER = "planetscale-jvm" + + object Implementations { + const val MYSQLJ = "planetscale-mysqlj" + } + + object Integrations { + const val MICRONAUT = "planetscale-micronaut" + const val GRAALVM = "planetscale-graalvm" + const val KOTLIN = "planetscale-kotlin" + } + } + + fun Project.baseline() { + // nothing yet + } + + fun Project.publishable(name: String, description: String) { + baseline() + publishJavadocJar() + publishSourcesJar() + configureSigning() + configureSigstore() + + extensions.getByType(PublishingExtension::class.java).apply { + publications.withType(MavenPublication::class.java) { + artifactId = name + + pom { + this.name.set(name) + this.description.set(description) + + developers { + developer { + id.set("sgammon") + this.name.set("Sam Gammon") + email.set("samuel.gammon@gmail.com") + } + developer { + id.set("darvld") + this.name.set("Dario Valdespino") + } + } + scm { + url.set("https://github.com/elide-dev/elide") + } + } + } + } + } +} diff --git a/buildSrc/src/main/kotlin/PublishingConventions.kt b/buildSrc/src/main/kotlin/PublishingConventions.kt new file mode 100644 index 0000000..d22502a --- /dev/null +++ b/buildSrc/src/main/kotlin/PublishingConventions.kt @@ -0,0 +1,61 @@ +import dev.sigstore.sign.SigstoreSignExtension +import org.gradle.api.Project +import org.gradle.api.publish.PublishingExtension +import org.gradle.api.publish.maven.MavenPublication +import org.gradle.api.publish.maven.tasks.AbstractPublishToMaven +import org.gradle.plugins.signing.Sign +import org.gradle.plugins.signing.SigningExtension + +/** Register the "javadocJar" task and include it in maven publications. */ +internal fun Project.publishJavadocJar() { + extensions.findByType(PublishingExtension::class.java)?.apply { + publications.withType(MavenPublication::class.java) { + artifact(tasks.named("javadocJar")) + } + } +} + +/** Include the source task in publications. */ +internal fun Project.publishSourcesJar() { + extensions.findByType(PublishingExtension::class.java)?.apply { + publications.withType(MavenPublication::class.java) { + artifact(tasks.named("sourcesJar")) + } + } +} + +/** Configure signing for all of this project's publications and archive tasks. */ +internal fun Project.configureSigning() { + // resolve the publishing extension (so we can sign publications) + val publishing = extensions.getByType(PublishingExtension::class.java) + + extensions.getByType(SigningExtension::class.java).apply { + if (findProperty("enableSigning").toString().toBoolean()) { + // sign all archives (JAR and ZIP files) + sign(configurations.getByName("archives")) + + // sign all publications + sign(publishing.publications) + } + } + + // configure publishing tasks to depend on signing + val signingTasks = tasks.withType(Sign::class.java) + tasks.withType(AbstractPublishToMaven::class.java).configureEach { + dependsOn(signingTasks) + } +} + +internal fun Project.configureSigstore() { + extensions.getByType(SigstoreSignExtension::class.java).apply { + oidcClient.apply { + gitHub { + audience.set("sigstore") + } + web { + clientId.set("sigstore") + issuer.set("https://oauth2.sigstore.dev/auth") + } + } + } +} diff --git a/buildSrc/src/main/kotlin/common-conventions.kotlin.gradle.kts b/buildSrc/src/main/kotlin/common-conventions.kotlin.gradle.kts new file mode 100644 index 0000000..e5c36d0 --- /dev/null +++ b/buildSrc/src/main/kotlin/common-conventions.kotlin.gradle.kts @@ -0,0 +1,128 @@ +@file:Suppress("UnstableApiUsage") + +import org.jetbrains.kotlin.gradle.dsl.ExplicitApiMode +import org.jetbrains.kotlin.gradle.dsl.JvmTarget +import org.jetbrains.kotlin.gradle.dsl.KotlinVersion +import org.jetbrains.kotlin.gradle.tasks.KotlinCompile + +plugins { + kotlin("jvm") +} + +val javaToolchainVersion = JavaVersion.VERSION_20 +val javaTarget = JavaVersion.VERSION_17 +val kotlinJavaTarget = JvmTarget.JVM_17 +val kotlinVersion = KotlinVersion.KOTLIN_1_9 +val lockDeps: String? by properties +val kotlinLangVersion: String? by properties +val defaultKotlinVersion = "1.9" +val kotlinCompilerArgs = listOf() + +group = PlanetscaleBuild.Library.GROUP + +sourceSets { + main { + java { + srcDirs(layout.projectDirectory.dir("src/main/jvm")) + } + kotlin { + srcDirs(layout.projectDirectory.dir("src/main/jvm")) + } + resources { + srcDirs(layout.projectDirectory.dir("src/main/resources")) + } + } +} + +java { + // include ancillary jars + withSourcesJar() + + // set target jvm version and enable modularity + sourceCompatibility = javaTarget + targetCompatibility = javaTarget + modularity.inferModulePath = true + + // build against jvm version for tooling + toolchain { + languageVersion = JavaLanguageVersion.of(javaToolchainVersion.majorVersion) + } +} + +kotlin { + explicitApi = ExplicitApiMode.Warning + + sourceSets.all { + languageSettings.progressiveMode = true + languageSettings.languageVersion = kotlinLangVersion ?: defaultKotlinVersion + languageSettings.apiVersion = kotlinLangVersion ?: defaultKotlinVersion + } + + compilerOptions { + apiVersion = kotlinVersion + languageVersion = kotlinVersion + javaParameters = true + progressiveMode = true + jvmTarget = kotlinJavaTarget + freeCompilerArgs = kotlinCompilerArgs.plus(freeCompilerArgs.get()) + } +} + +listOf( + Zip::class, + Tar::class, + Jar::class, +).forEach { + tasks.withType(it).configureEach { + isReproducibleFileOrder = true + isPreserveFileTimestamps = false + duplicatesStrategy = DuplicatesStrategy.EXCLUDE + } +} + +configurations.all { + resolutionStrategy { + // fail eagerly on version conflict (includes transitive dependencies) + failOnVersionConflict() + + // prefer modules that are part of this build + preferProjectModules() + + // fail if non-reproducible + if (lockDeps != "true") failOnNonReproducibleResolution() + + // fail on dynamic versions if lock deps is disabled + if (lockDeps != "true") failOnDynamicVersions() + } +} + +if (lockDeps == "true") configurations { + listOf( + compileClasspath, + runtimeClasspath, + ).forEach { + it.configure { + resolutionStrategy.activateDependencyLocking() + resolutionStrategy.enableDependencyVerification() + } + } +} + +tasks.processResources { + duplicatesStrategy = DuplicatesStrategy.EXCLUDE +} + +tasks.compileJava { + options.encoding = "UTF-8" + modularity.inferModulePath = true +} + +tasks.test { + useJUnitPlatform() +} + +afterEvaluate { + val compileKotlin: KotlinCompile by tasks + val compileJava: JavaCompile by tasks + compileKotlin.destinationDirectory.set(compileJava.destinationDirectory) +} diff --git a/buildSrc/src/main/kotlin/planetscale-connector.klib.gradle.kts b/buildSrc/src/main/kotlin/planetscale-connector.klib.gradle.kts new file mode 100644 index 0000000..164547e --- /dev/null +++ b/buildSrc/src/main/kotlin/planetscale-connector.klib.gradle.kts @@ -0,0 +1,8 @@ +plugins { + id("common-conventions.kotlin") + id("java-library") +} + +dependencies { + testImplementation(kotlin("test")) +} diff --git a/buildSrc/src/main/kotlin/planetscale-publishable.klib.gradle.kts b/buildSrc/src/main/kotlin/planetscale-publishable.klib.gradle.kts new file mode 100644 index 0000000..81bd009 --- /dev/null +++ b/buildSrc/src/main/kotlin/planetscale-publishable.klib.gradle.kts @@ -0,0 +1,7 @@ +plugins { + `maven-publish` + distribution + signing + + id("dev.sigstore.sign") +} diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 0000000..8be84de --- /dev/null +++ b/gradle.properties @@ -0,0 +1,43 @@ +stamp = false +lockDeps = true + +kotlin.version = 1.9.20 +kotlinLangVersion = 1.9 +micronautVersion = 4.1.6 + +# Settings: Gradle +org.gradle.daemon = true +org.gradle.caching = true +org.gradle.parallel = true +org.gradle.parallel.intra = true +org.gradle.configureondemand = true +org.gradle.jvmargs=-Xmx2g -XX:+UseParallelGC -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 +org.gradle.dependency.verification = lenient +gradle.enterprise.testretry.enabled = true +org.gradle.configuration-cache = true +org.gradle.configuration-cache.problems = warn + +# Settings: Kotlin +kotlin.experimental.tryK2 = false +kotlin.code.style = official +kotlin.parallel.tasks.in.project = true +kotlin.build.report.output = build_scan +kotlin.incremental = true +kotlin.caching.enabled=true +kotlin.incremental.useClasspathSnapshot = true +kotlin.mpp.stability.nowarn = true +kotlin.mpp.enableCInteropCommonization = true +kotlin.native.binary.memoryModel = experimental +kotlin.stdlib.default.dependency = false + +# Settings: KSP +ksp.incremental = true +ksp.incremental.intermodule = true +kapt.use.worker.api = true +kapt.incremental.apt = true +kapt.classloaders.cache.size = 8 +kapt.include.compile.classpath = false + +# Gradle Internals +systemProp.org.gradle.internal.http.connectionTimeout = 180000 +systemProp.org.gradle.internal.http.socketTimeout = 180000 diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml new file mode 100644 index 0000000..5faa6f7 --- /dev/null +++ b/gradle/libs.versions.toml @@ -0,0 +1,84 @@ +[versions] +atomicfu = "0.22.0" +buildconfig-plugin = "4.1.2" +doctor-plugin = "0.8.1" +gradle-plugin-commonUserData = "1.11" +gradle-plugin-githubDependencyGraph = "0.0.3" +gradle-plugin-profiler = "0.0.2" +gradle-plugin-wrapperUpgrade = "0.11.2" +graalvm-sdk = "23.1.0" +graalvm-plugin = "0.9.23" +graalvm-metadata = "0.3.3" +h2 = "2.2.224" +junit-jupiter = "5.10.0" +ktlint = "0.49.1" +kotlin-sdk = "1.9.20" +kover = "0.7.3" +kotlinx-abiValidator = "0.13.2" +kotlinx-serialization = "1.6.0" +kotlinx-coroutines = "1.7.3" +kotlinx-collections = "0.3.5" +ksp = "1.9.20-1.0.14" +micronaut-plugins = "4.1.2" +mysql = "8.2.0" +nexusPublish = "1.3.0" +sigstore = "0.5.0" +spdx-sbom = "0.1.0" +spotless = "6.21.0" +sonar = "4.3.1.3277" +slf4j = "2.0.9" +logback = "1.4.7" +testLogger = "3.2.0" +versionCheck = "0.49.0" +testLoggerPlugin = "3.2.0" +versionCatalogUpdate = "0.8.1" + +[plugins] +buildConfig = { id = "com.github.gmazzo.buildconfig", version.ref = "buildconfig-plugin" } +doctor = { id = "com.osacky.doctor", version.ref = "doctor-plugin" } +graalvm = { id = "org.graalvm.buildtools.native", version.ref = "graalvm-plugin" } +gradle-commonUserData = { id = "com.gradle.common-custom-user-data-gradle-plugin", version.ref = "gradle-plugin-commonUserData" } +gradle-github-dependencyGraph = { id = "org.gradle.github-dependency-graph-gradle-plugin", version.ref = "gradle-plugin-githubDependencyGraph" } +gradle-profiler = { id = "org.gradle.gradle-profiler", version.ref = "gradle-plugin-profiler" } +gradle-wrapperUpgrade = { id = "org.gradle.wrapper-upgrade", version.ref = "gradle-plugin-wrapperUpgrade" } +ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" } +kotlin-plugin-jpa = { id = "org.jetbrains.kotlin.plugin.jpa", version.ref = "kotlin-sdk" } +kotlin-plugin-noarg = { id = "org.jetbrains.kotlin.plugin.noarg", version.ref = "kotlin-sdk" } +kotlin-plugin-allopen = { id = "org.jetbrains.kotlin.plugin.allopen", version.ref = "kotlin-sdk" } +kotlin-plugin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin-sdk" } +kotlin-plugin-atomicfu = { id = "org.jetbrains.kotlin.plugin.atomicfu", version.ref = "kotlin-sdk" } +kotlinx-plugin-abiValidator = { id = "org.jetbrains.kotlinx.binary-compatibility-validator", version.ref = "kotlinx-abiValidator" } +kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" } +micronaut-library = { id = "io.micronaut.library", version.ref = "micronaut-plugins" } +nexus-publish = { id = "io.github.gradle-nexus.publish-plugin", version.ref = "nexusPublish" } +sbom = { id = "org.spdx.sbom", version.ref = "spdx-sbom" } +sigstore = { id = "dev.sigstore.sign", version.ref = "sigstore" } +sonar = { id = "org.sonarqube", version.ref = "sonar" } +spotless = { id = "com.diffplug.spotless", version.ref = "spotless" } +testLogger = { id = "com.adarshr.test-logger", version.ref = "testLogger" } +version-check = { id = "com.github.ben-manes.versions", version.ref = "versionCheck" } +version-catalogUpdate = { id = "nl.littlerobots.version-catalog-update", version.ref = "versionCatalogUpdate" } + +[libraries] +h2 = { group = "com.h2database", name = "h2", version.ref = "h2" } +mysql = { group = "com.mysql", name = "mysql-connector-j", version.ref = "mysql" } +slf4j-api = { group = "org.slf4j", name = "slf4j-api", version.ref = "slf4j" } +slf4j-jdk14 = { group = "org.slf4j", name = "slf4j-jdk14", version.ref = "slf4j" } +logback-core = { group = "ch.qos.logback", name = "logback-core", version.ref = "logback" } +logback-classic = { group = "ch.qos.logback", name = "logback-classic", version.ref = "logback" } +graalvm-sdk = { group = "org.graalvm.sdk", name = "graal-sdk", version.ref = "graalvm-sdk" } +graalvm-junit-platform-native = { group = "org.graalvm.buildtools", name = "junit-platform-native", version.ref = "graalvm-plugin" } +junit-jupiter = { group = "org.junit.jupiter", name = "junit-jupiter", version.ref = "junit-jupiter" } +junit-jupiter-api = { group = "org.junit.jupiter", name = "junit-jupiter-api", version.ref = "junit-jupiter" } +junit-jupiter-engine = { group = "org.junit.jupiter", name = "junit-jupiter-engine", version.ref = "junit-jupiter" } +junit-jupiter-params = { group = "org.junit.jupiter", name = "junit-jupiter-params", version.ref = "junit-jupiter" } +# Plugins +plugin-nexus-publish = { group = "io.github.gradle-nexus", name = "publish-plugin", version.ref = "nexusPublish" } +plugin-sigstore = { group = "dev.sigstore", name = "sigstore-gradle-sign-plugin", version.ref = "sigstore" } + +[bundles] +h2 = ["h2"] +mysql = ["mysql"] +slf4j = ["slf4j-api"] +logback = ["logback-core", "logback-classic"] +junit5 = ["junit-jupiter", "junit-jupiter-api", "junit-jupiter-params"] diff --git a/gradle/verification-keyring.gpg b/gradle/verification-keyring.gpg new file mode 100644 index 0000000000000000000000000000000000000000..740faf3b44bfcc4eac980203ea4593647f381a7e GIT binary patch literal 198557 zcmZU4V|XQP(`{^fVtZoSHYUc7ZQGjIHYVo8wr$&**g1KgdEfJ$?>fJ_yYBA&qpNzY zTI;Tz1{?)u?wGZ-SEZmCAXi?Fc_BN*PXG#!t+oZoU`D*(Sw%nl8WMd@H^6nyYD6 z48;VVqx|$@3)D^@Zc<(vUQD@LUu?i8DkW;g3N(m{7*p)ZEsF z(AI>|>FY|!*4f6;olqFy=wxL~C~0FzM@T6Pa51(aR5G@+bu@Rfb#NyXbZ{~^0T?!**ci=rGdbMX^v{m0wVzxmP(IbqO)oi zM7wwBo3^Udelx&7Me7KlaXr>4InCoUaAL8>Fu;&Hkd}n7sBUnGi)+Ukkgl^_KY-BB z5m39sj+3IOl9Z~Sjf({(aY@@LBJB@m$P6-5@XSo_aMF1-cW?ci$TvC+@)BMAx&Nco zA}!NI9~+NA2wvYycb0u=tZ6CilsSFWVx`-t2RZjOm+SQs=={n0L8@n|H!VH~Aj~h* zUoJ(pQ~_X=w5i|0vM#d_LQUX5KSlSszR6OO`n6bJ29;ZE2p@D_4}wM;_RE<@tZ)o% z#fCkNdPv;|DW$WLI$$>_2;D5&ss+-m62lS^hvc=JBFt^*e*A$bwOI7( zT&D|N3sP`yQ$K|P@wyPPH*}O_RipqPBsKAO1|EV!X`R%i5*%*E zz78Fl2LC2+lUiGL?ut(wsucq)nHntAC@s3- z9wU@!qEQ$JN0PlQLB3*G3?~z7@&uzfL$*$AmW6MqQFl)eG{T zq8s(RhRg?uDYm1^$lOB%)ZB7M;(FhGi*LU(Ql1OwsY|$p0j8)gQ2Df`o>o?ywV1i+ zPA>{6+Z~Wn7Q+3aVW;a>8FNXNIMIAAdj0JzWYZW(t7kR)-@3z-1vnTIDwvsDncLYB z@>qXe30OGWm^=MjE-n94E?K~>TNPws!aw62JjU=$J(&8#>!Q@S@$5&F=)vZuzv;}BT^{y-1rIYthy6HsSh=N}9 z=1CrgskqJb6iHv#)&-pTbof5_i$X6;?zX@$f>5B7xnR;zdx%dwe>#{)!HH)7)n^C- zRWg}KD}+dXrKW=GxMtRxrYs^Bv!iLPE+OY#d*1I088Ec)RRU*gVRN34`W0*eg`35- zGPneaELo8@l#rFU5{+D`z`@1rq6o3PKpyP0^r^gzVj41Kmqb$8cZK%W8NF9z3(+;% zcAgITk)CPeVm+!X2e0}&EWIq0qeM@ilNls(-uiEFo$%Zqs$C~B@M&*rk7*k&tRF$K zRhi*tgoYx;6{_5NVTc3%5eezKWk$m{r?fSJlQiGY`{^JVaXt5fK(e+e{)}!11lT9c zl1ih;*X)Iua7x7>$W(vB)FB~S4OD7VEZ|=erZ^=TAN##%pJzZ2cNxmZE=7`63#jT| z;c(&+cl}l`#bq_^qZ4-7h6DJjU|)Bs~{1nu@}hNgsW8i`J{B4x*-;PMC4wTUb=hj%t%cOj>DJ0iGfR8+v!@s){xWq9XlYSTW}q?TmwQPV(YbjCreP|Y6x*Ql}! z`74KS!ks8anP9__%}JWrPSu7~3ivHqP91|$ zHrwW5ALqVPJ#|EAd%*oSPy_D5GvSm+$XJ-dkR$oM+rBqll9UQLrb2NciY$8Z>e*?l z^NjX3mPHa54ywM^=thd(zmY?)K?@@xC!ABGyVdA1c5L+xm&`EvP>}K~_5mk4EeEUU`&>Z3^j94Ola$y73QZdcKr*(|Ct1 z7_dFiG=phuSPDXSPiLyE_SfS4OfePwwJC-fN}f%Wyyo1fJGK;YPFqvbwXI*I@dI5_ zbB%C?mxIlZonYP+G2@sQzk?C#Mv=JScUTwo!A8pojj6&?{@PvQPR^SNW>nuU_~^^U zAvSk5Hi4D!&vChx6GDE6Q9S6IB%8FD9#sk;9tMcogUj|f+O~j6*sV_*On;%}f)^Hd z&d$5NXYi^ji(7|o=%F(yZfaX-40`Yk;fH3IAiS2P&qOzDv<4VJl_PcR8NxRN-MCJGFCH#n#XO}20nj6dLe?x{$7h@{3JTq31q$R zs;zr*mHZb-{w0>b^{_#FH;`)}uvmip4K@A+ZS^{8*>6_=yAv92zjJ3m+sO40#){~M zz7@5>(~Vp(Y^}Np6Pb8kHl&qQ$IhufV7~i>u5CJ|)!yJO^NYZ(%9PI5$GIeuG%h?u5IpOwg78AXWr@cm8e;V~reICY&eL<5FFT z#@wc2GyNUZYz+um7J-JbrQOhMPH>0{bDS(zUn%m>)pTpeM*xO9ey;Wo+8Hpo+9GaW zTO|U%|F8`_VqlsM_E}7owZxFc>50v{)3l^+-{1q=IFx!UHez&%%T_JSQq6i6j2!=H z&bLQQ_{*<$FO-muL>J4G_jX$R28^i3MiGgmFg0GEG16KU2}U-Mnl`F};%4_J+79mT zo4tmL2ZW|vp99?%8XgnNfooR9!-Va}h85l&k}Y$dwr#NO{MRrZv8BfgR9Q6$hp35G z&0&QC7X|?kMyS^MezjB6P`RZpP$NQT`}0#Bm!1;22v^xZ+JrON4XRsvk1`7}*rZ+< z=G^3hu+QKBKVm6f9I=OLR@aNGRd))p|FvaLWuWv$EML{~A7c4$kWe1+gI`j7WP9Qc zI5wV`uL8iJ?y0{~iEw1eViNj}81Gy~f{o<{e*Q~y;dY?))g5FrUsDlbAN(mH5 z$OLD>LBiF~Q#cNz6bBX%=laqtTHOk<>W6?mA1pgwX+=XA;x2Al$F1658; z47#+E%@vv)Jggi2M}l|$mqKrIK75x1(uhBNQZ2eC>2>J2toAJ~$!fWdrr1HO;p{~D zUIU!yWeu4j)%`|;aDI6MyB(taXz8kc_Hs*nB(-(LqN)ZC5sr*bc#g|xDcl~bVRA9r zxac)Fu2CjsAt?&NWY9v+#6bs2Ep%1B94rNY2y!r5k=LRSRl%qN>f298yCXubp+q;M zwHUuAQjyaQZ}bDP@U^n<#NGtiSxebO8M@7$Ba3XljuRPVMVxtZ)|QAlF`ML1bmE*mBuG^n=uJdeNOSDOzhI~ zYUfD?RS52(+rtl4dV0(>DVnq>kU8zuqQ`j=Z+6S%sW24-D;lQC?5!k@H=NGq&Xbuq zyrqWud)dfn?YGRfdO!bwOPjoGZ-tYo6-H1EY%WC_XZA81ieaKJfrRZG1xMQMHv zoDu*GnZtR%ucjvN9f{8R{DcT}Hgg0l!4QMln3}A!+fP}lPNxCGgUJ?7o_{qZscJhN zW2i<_3@}n04Unm&42Im>v9R;U-yNb~TK5x7xjVnl}k>xi$@5PKX>T z>!G(1@hfVa*01;a1p3F}h}-5KI%vk;k?pZC_U$HsWfmsHHTSQ%Bqr}KJh;3FJ%txb zK)-WJUh`sXh-6z+3iCxrrH(7J?cB9(398#g0?(&!MbZX}nR~w>rQzy=9%WR%*EyA! zVvDEM{Mx7ck-{djP@+zhlVSCtwN15iwLompVGtk&Ft&OUq=_jWAVcAJGy|I^=tpoC zW;5fXolOwc66alRc|caFb$ED*k&5U`3jn}8Kl)btZS^R9@S~$%QCh>7|83~G#Q|Tk zPz2y&ZbT^VU~Kx2NTd|DH8Li2{8EVKHl~D@#_nG-(bV+sq5!}SU}$Fix847rms#&- zVdPr$Ilw*&hhD7058` zgVlw#roGKmeKSq`HpVR5Bj&Pofr~uqz#_vx#o^uVxm7F-1A5W)*zA9>WdDOozyx3I zE(j1bILJRW_FwpUAKJ}BF&OJ-fc#XkDkBtU*x?P_gwR+I+V}9&?SQlg=YP0Dwaqh3 z8#b!{7OrTGMw1*gO5TAitw+pghJ!C7?F@^a#IG8H=IM7}!Z~Qdr8TA&L zZC91%NuTN(p}$TE&v>Ph7d>Yr%>z+TYHQr@t%0xnrY+^U+qv281H%kv(CB z8@cK$k2-enP4-p+3qt{i^pxczUa16?sQ;>{-UD=O%IyM0<#HH*PYmluAmjHau?S-u z+qf?_sbR*?lsEE|=7xZkW&yn1D7cM@1+hvONB%2%`VLi>uKLe6;+~S*5t1=-YHoTA zQi)?ud%)|Fxh4sBRvMvTpTT|_a6Xv0j&lPt7|=|>n2ut4oBe4MYbf%el$o-n>`KP= z;)^xvjC~>7*p(aJck^M`I-sFF*{GQ|)*=0u3n#^l7fz}?bx5z4-|NP4?CZfzd>_06g6VYZ`P25Lpp%Z9 zCEjzi@j~kwL9qUWk#(@YRIlDC0`U3^gns$vdD@%e%%dfh3y4^EppF#om9Ak;3s_;H zFZMfgo#O4roip+l%0{aNvRRON=asXU7$G-ZOJpP>jb7wsLBiSIxb-`lv*EqSO_&hq z8$#KMx10TD7iJIx8|63k!4v>-bI?v;Xle^kpA-!+YnSH9vdFbSESiFSs@3D#E|0%c z0;K|J95~drdw3e_+wDz}lUV$JXlW@V~zMFPZ<9 z#VI5xpwT?$jcpNXa!=J7lE=IY;y+bhg&U@V$mFXVJeS}K#)9@9<{>LnIlFS2;T01? zg_QNpLpBIz3?c7C@HKCptVeFW41%velV<#J58U4Z*4P6>+)ECLe_W+&93t}23G&MQ z{;iq$xS4;SOlm@oP(R~tdL&iA$xZ{V9l;h*Eri6x@SWn;bB-N1?7fK^d*VK8A}1R& zqc(e-mtuewf`1t9YJC*n832cEU5$eJULrIh@2luNuL6eaQq6__HiwcPjN>$Z71tvR z1sQ=t8c%)OTFV#l~!#eR1>tHq|yac@J6*nMdI&%t@iVFrm5NWL56-ecq!B8w&RYVVduHfM+qU~_?K15 z!0>3=PqINm{hGVwXQfOYq4Jq8`$9OW_2qXPbh!4h7zdyF3>2gTR7LU}F-dSG5+FIO z#317Pnr_lQ;(*H)K{s-ndnNEU8`^$gBMioGr2-B`G zYvKmL<(S@5FrkztCy%jq)qn?Vz^y`DBu2}ZSDNn`Y+mUBy5+P z1?1(VckYT9fsVZKiB{s)edESM$HeH*pf`Z4#tTgsM3Gj3FMEnNFS^h^ z0H$FR+9!N$Wt72*&4f`vd>QqU2!>;YWhXX4GqBcA81KwILk7Cf``dqFSnnCwb=B!a z(w17$dti^|pa=$mu~~v*MT^8t;YUQv!x;9@RUw49EPQI*%^M{wIU~%WzqCy!=;7>O zOsFg(O~?cI=hV^2(%8n-(cKYXWNmKaC}3@F=wRz;YvM#_Xlu>a@;~pd$vN+yl6rGb z5N`}>b14t(Q-QPKURxFHk*hAYZ*tlL?wBUFJK*#Xq{_wvQ88V{0PTicDCFsk=)83= z1ZnNK80Pm%Fq3Il*uG|#9@mKw-ZnB^Y6VW9h$I9Hbf=%FCMl3DlKNh*c~VsV(H{tW z;twMA%I8_5{<$inItU$1!HXRtr`e1p3v}UbE7;@Yh^R`3O&30}hu4AmH1F{J!2k^Y zVbWPSFZW|rXdwze6`H3`B>hW)O)w==`CMm2)+%;7kn!MaJ;_R1tgAehb`z0`>Yee= z9$}B@?S$OI+6s7W;|v!G1f4iW0rrl@$8Sx)tz#?==O|Fc(PYfy{^|$d{}@wW#rjpC zT@;+o_rdt^n_O+)Q93oPzjBT}!9le16Bhq5rv4k@xrY3-VWp>(E>Rrp-|+mt&Au*b zIJ1TQxvn*yABtq5HQlS9EB;}jC!2ahmidYj!3%8OMH-rmeem)Q~@?!|#i>L27M9G^+JoZ{|u? zfWKIUlkYosL&o`FwdQdKO`sFz1kDDL+cWr1lAl%uKThmjVL7jdG@sQhf7r+hDKZ0` zBa`_Hn;CDEw6I_FDnE$=eqMeka0c2p>cexb(G>hiW*fRXV^w`9d$?IOH)hpPWgo?6 z^{5$=(xy1_1yY7RFYc6VmIRju6GVkYQnxG_rEZKr{}?km97!@?#!Q2V9*=0C7DTLk z%&RI+gHO~gev3wfaI-na9OQ;`Y2aA#gYxQd3ls5|2yxvEqhJ%ra>u@61K62bxqeXl z%pPL$*F=gOxo%ZJR zSt(Dmw8|EVP!84>iTwVdK5grEdtOQ z@SKF);&kLhvH6@IotGo_wn=~eq}4wf9JC;$mz-!)-3}7bi%IE0JO}<6l;*L~WZ={Y z)-k{Oum%V4aY7G2a4l4x6QB{WVdyMq-O`xMU(y#avQ`>G-hjv1_-$V!m=^Uq!-sW; zp!j>DuVrkY$d~g1^!n{pOBEvdXI+holoT9MX(yzptnYo)@aYcNt$YUaVD#Mhl5djT zHeTX$PDg-iUU)&Rz-&g>^-n__cfB_#X}Nx1cn?3aYYn z+SFjv80>~@M^|jjoj-V-H#v>GhI-z#rp#TiFYvO;HL#zh+{wjccCzZzQZ9q476a*+ zwZPJvUr&^|_|9+G`8QuUlCf$2MO7!Q*|x#)uL`XvNx#WKw^e4Cu~I5sSE#{`5|ADe z7%_!PJqZL)Ww{WlA`Q3d#r)Rm3Y@98p3}WPm3eZ5PL=*=Hd>2D_mn$PGmdk0cZ z=Wg-$xoEgg6DdfUkYcBye036PyovhLkVv3ahh$HxO(7QJ#j*1sjG#R0&IfsKGvKLY zYLHhZAWh?7rcQ4|`Dl%$;IWlnj}ikgL7Ie>sb|O){A9hH1=V}-55PcF_5j1(7gH;G zam5UoPc?L8WpKvf^1*Pw3h8GSxjX53qmP=fLni^bj(hLwlGZ{~m|0hj%K;FvIFZ3q zR4yfGGGlN01hJ;Hfwpo5F=~$KoWWm!VPg#e+nIalI?ron(doNf8V6{!9}!4KNB%_V z+MyIW<~rF3u*1h36>GY_!*uh2AAyq#@1_NPIBe`&9t(|p4leMVSlkpn{dI?tg^{B* z%^!MA;LCRF7eg+6JS~LG@#s8RKuJPUEA^!TwYj+m+2CqU5AJ=!wClJFUWfYXFeAiM zWl)7zEj(A{C>7q*MRIGoI8O-6|Ed%l| zShg5jfaJYdW_OM=1B?Gjcv7j9It~u<1wWb~I3VEA&?dlsAOg@x|6S^FA_V*P)gj=0 zJt{zSdHShyEFe1pLjhB8&^OC;l=1h`e-Qn@5yy1Ica-8&oo&Z&Lh_vzQgvQq!g}Y{VuS|DRK0R4M z_tH5L{#nxBWr1rS$TLz1pVLNT#xW2B(mE%r6w5Or(_=#;Egm7Jaru5%&J6~>22Dml zX77wt@Pebr;o<=Nq{A_0IS}L@=XJ;K(Q9^EwEuA%;}?fG)$=|>`gR=S#)v6>gD(4Y z@MU^Bd`^a=tsB~fGs;z?cwJ#*Ss25*l^1tB7L#;@`f>?3Ilgc+VZ1(FMy43L?G7g*@;v4iE&&^_NiWPB)bMlr>Dai7}Bsfo} z;PgxoSc5*;F&|qbP#>AJ%nzunyF|6aQYO0}AGOKD+vAdJ>xRcBDpP(#5~z^~fv@L* zE*~ZRykSVT5qYY34#^-!2{lkXjuk*&)*Fj5N)vVGO@_C7i42QQ!<*Gd9z(w!i=aQog7k9Q>nQ zHm9(9KMuS|r#wqly;hy}P0GQ#O|tl6UwoIWi2;N5e6REYZ8iOU#F{H}y%G*aUbwJ{ z!;F{MZBQZdkj^*IGq&#$h-tAmXkAHc{An7r-=-d(;NoIO+O^Fk%)wmE%%|U6VgH{KlTzEgTxdABQ5)lpN6y zo>Ui!uF7(Ue=!|6_}0MFpTRHn7~3}nQO)mIP7Zd|gWX09<3r55fK#~2jBEScDT(q9 zfmyNv?-E!FUg23zH-jUMD<-FY>a)9pH-tJq z-sw_3J@#$w(Aoq*!g8H*%-ff9G~(r$Orm%Wqn9)pl}D_@e|8>ak;Jh)l}X*8B(%q> zw3`_F`lJ`xGom(6xoJXFRjH*k3BlP3{BKvorflc%kM}9$Y;I-bNJuFqsPyl|%vbEo z3w8W=@w>slivljzt^fz)e`QwM*O-*P)f&*(m{ezoB5qGNH4irHt(Wl9NVjrR4{6jv zJR&p9En(sK6v0^FQ6!4@2K8$T-!i-2amT`Un~ye}Sh#gozoubzSCoDO)+0>^U6En~ z)e1U5oH%%tgx{_CK0dah2mes6aFzGa{sGs`}R?((t5db{AKqE% z`Iuq$_KcY5b^Ykjywvola(6cpN}+QmFbl6E!QG{Z{e37$Oux;q2=-MQs08;h1n?#% za7(-9VKqiwbYwhp2W|4r94M#RPrvY@PmZ z9!W&ZO-vN5oJ|R3WQ4yG=V)bU?BFC|^cA)HivC9%|KFr_8=uRou@i*F;KB;``)7|8 zCInh?>wkIm&o{c}-ZCi`pc+N-svsb;Bb`U}=dvfk{Z(7i!XJ<>e(!1esg;iA7g& z^~Dk!o29z3%wx+mZJH14zXIB_r8UQ9+*na&#Ts!UO+ClhR^Xj13GaTg(?p-8PsQbS z1sP^h)q3s-d2hJ>iqSr+HP9lj)Kz_%m(!ZS&|5FBF1|D*`~3Zw8KQ$dR{3#;``mkD z6}6Cd#aR$vMrD#KuY(ljfC_@vt0JE6$c{%_oOBmE9ZRyjBfu8$Oz&OMuj;znuMU1y z-Dt#?&Qrg(Fdzks!PA4*K6k&Yca6A|#F~;G6Il*(sV}458sj40N)$WP7iy1~%DJUy zk1Yo!m0IUTWpK!h<3KwQ9Pr~3q{2#rVoehgt9bA#3`MdVY!5f0wqXd;Z5sA)_*CGY zQH+1)ZwCn6{(n0_lTpAa;?T({3dR$2a&vUWykQG0ILJSr*q3kzhX(C61^TC-`|nb* z80-gq=ruklDz!j5f~3ZzH{{|f1|`{02riyd1LllCw$7O3MMG)&c-V!#)oJZij$CY^ zu@Ft$@zDsb!fZ)u5^g!Oy#`&8qFn9W3lfO~Ei??wBAmBVuQ&|*+oKr4h>6+|jUc|B z`C)$s-R-@A?m1R()V4@8)7!SUZgb2e#=7MjPpCj^*>Of4lf>`k^^-pZ%G2kx(@T%{ zyHL1n4<1v3OPQe(i71SHrCxec@6=V1xgI2OJ(?Fk;BQKY6EI8aqXWXW&y#HDN<$U{ zINKs~rM(5+uxO3Fhzf#-JPEPr<7flp?#~{MSp|EF2Jwt!eaN3B2Ma&fwOxDc^#|Z6 z9}Krx8;&SH1+t!E2PP9P)5Gx%5ebp`akU zYF&kU6;v0AK90A$%bRnD%?$=x7tFg~yU?XN@rfeO!EGO5g_!ru7B*Dw57n%`N`F^YE5v_JUa`n zzme`yuyo!Yl%Lj{cns(Ddg&MgR;diCD&eLp*0q?3##90$%`JD8TFx!$>GOYSWb4+B zAGDH}jw>IA5s2(T}w<>%Obrn?xWL-qv7%6)n~}XPxb^{M$nu^RgT;Ue{nCDcBF$z z0r@Wmk_s9DtiR;BhljC~lkt~bX!xH~0aIIBQ>(ws)$%`CYn95J%TSe2NR2_*D_2h@BaZE)y#$Gdu(oY^LsIETqOJJ=TvCmFpqjLt+%=%9W@d zYntc0$5;X8>uK+kX&Mwu*XaxF>bPMF#IniFmKzdW)lXOD_mBT85mP<5+_5G$2Pv(6ohwDkYq}(W{`Lq-khZtHqWqBN}ohqP|)IIos(|wjf8sAe?b| znV#q@B&*-|im1P1x|MW40-?jP#Ix^|faD0YcZjh}aTNU!Qs_O?+aKQ+EL@Sf zN$}f8OBIT7KFmg+^jp67rpWv}ko=w>x_#=Zd)mqz2cnB2GaFBn#vHt~v|6RI2hXX1~ zx*TXo>JTybPB0~G-L-Z2Bd%l+Yiu)^#T3dsoYS9eE&FkPu1;1MQZ}*7P!i4E*4>7BLIx z+kLHPghDVY&u;1LdW6o;DY|?vS$3j&gTkZl3m&tO>M{(MFm=OfS?jTgci_9047cy! z9&!3Hz9EC^k+&ZdR2J=9C9;=aP#_466h@M?si&~dFVraUzE5)u@BbuyDSxIdE9GVl zE)kHeYImuG+3qZ?m$zCQ7;E{DpwLYocKZ?(la+0QSZwGHg4#-tI2#ir_bxT3|Lx_*&D#=uUbdvkMcy^*2 zsIBM#72(iouHqZM=w%ehgGL0MckPS$G2OCR;0U^rd2%BOePiZ~12V&uV>#&&4GX5& zgE=nWd;cg2%6!zmH7}2T9?sovO9a1#ocEpDVoWmCA#Yjr!NV+$w8FZB-+%WVf%~fJ zYeVZC$GCA;xv(iRM%pLqZ4{i&>98N(;*w7hU3Q7Ce!hGB^m$X_CLZxqEFEcFHdZ~&jgXW!r0A#O{l1~A70WNqyB zGeV@IenM2IqAVMR)L2G~R&W4z5es*jUcvbhRj{8#x;QP|5ZPX8c1rci2uZw+cA`+75wmiN zkl~BEjGBLdR#0*gk=9!sJJvdozs*;~y!>G`Qc9x}_pH4{4t0d=qvhT?3x-0KSN@r;)Jv`T!$skw~A9vzslo@^mKob6S@z9@&Tm9HdRzWR<%se3$6=o{98ibGy zEEJ0X;?Br`8AXPga@WVTSmr}G@{oXhX$wq3>1RTrnqLP~X%E-fl!T}t9mE=ijU@7N z01fO!x25_xUZJoWPo|J}rGNi9^su0LcB} zkAzW9MX~m=0#mzvz3dwfoB2kRrw<`EX&NwiLAcCNdRQr`^65$9AqChL`-%>aXLLrr z5_i-?T$NvdS>n`-|a7}R)8#T!0 zA_9AKIApXNp;CTHc9RXF%qaPv4dbIXlr1Jd^9Svu##+M>2Z?9>#TRrmb1$@gOxueUr}f)^J{82h2A%ys^8TvBWT!cB{PcQ4XYYo zE@}$h%Q9S=lMd}=U7Nl0_O5IFwrxGT!_0x!?FCaDjl7&|HC2WizR?GspczRbS8`<~ z2%@kYH(bp>is{u0GtaO3E-msXsjIc^gFf2lTh)qK*KN`z)g^&8z8C+>X6KbucRmCOh5>$-*4Dx0zMYXGbVdh~vD< z(JGCJ=GVTLH8S8|AS5&n&pqg@*vOw_6Uf_nA&$!LP*X)ZOWvh!w@v}S7}PkvIJ!%jBo#@ z0F2I2lOP+f5jiujL76YjH#_wOLn{AY?|Tx4^niS(R)2$8s$U|A;@wdbKqg#B>HGMk zLTDpE`!J$1I}9Mdl`W3nQPs`Z4?=6rGGi~66jz1m@V(7RR!akTmLnSmvLr!$e{LcA zoK>lC1&41JEC0E>QDAn_;9Py#s8EL_!Bw0hAi#scjp4K+3c-tY#35uVGt9MufD)oL zCUV&{1=;AVoKB=|&O`pJkQi>n&?tYBrp5Rr9^j!TPc@}PA*@6j^8;&?3LTe_+`@_R*zazHK_M(K=YX0?VuiJ z4c9Q3pE(+nCplix-nSih&~w6GU6XgWPPNkMeh z6g<{+MM9LzDx4zYxTa5DCyDN}W^vMHfX}v-!H&k2K+~%z(Fs!2qgN|jHp^e|DmZbn zzV}uE-5cm2pGcB2)lWet^$AG2d@|1|QGA{eM9^rRc_}@_O#no zmi}tY=4!AVRHzDAW!SUs;yU_(HWiOR1YZg(THczc?sm51nOF`5PO73ePlKQc3h4NV zy5Qahli4CHEwG#EGa2trX(Fc%qw2u7qTz8~i8kkDQF0>}%8ee<42gnF>0x*rO1yQT z)ETAIZ2r8hLH~yLkri*5JAP2^k67+}4b^l}NA2oP=VM`6z;{-Kxd<9d6Dh772r|IF7 zb_;#)PkJ!5t`<2;VPdQ9D%4p|9J3e`c!QxU=AX`)qFS z8_1~|jzFbxrR#wPX`kA^>3r0&+-Q z3kq7HphN+wax}4K2!+y9_fZjW!6F$*DLEk<0Vto{A}xJEoo#uX2z9M4gjp<9c3-)y zE_e4i_#|#dwqeDn$QAfP%QkNk$fCq$xy~P{Qse(zklngY)|#Z_KaJzgemh+(|x@wn1ww92l)qg z{!2;!3D%_}emdI006h57r|(<6ad)0!!b%N5R;{SS->8zU`htxtt>YIxB9f07d(28P zsZ&PZfBlwxqY2rA-&}UKGc}HR|Dy-Vq(|kB8t;(Lpu!@03{g$XUI5Va(W*M*zNdM| z2*&7qyP^IyW3&|9m;)4C^bHr0x3noD54OeVcd1cM`OJ3rF4HfpgkyjEqE)0W2Q3GCb5A~FnUArw zzS&^r^)j|U-k3%G_asdBjU-D8Kx5;GkcImZ#JK3(i8YGCdI^DjyTz+?5f&+%iHuU6 z!Crlr(@q#8b8W*pw09!6%yti8k4AH(gbk|F8I!B3_+B81ILZ} z&&joOScJlE{!x+W7!+n=;|y}S*8n>K%My4&Q4Q4?$Cjts6bgXdO1j%IcCBu#sQLw= z$(SYKX(r{TDDtH1)?~#O>-Z1^3)c*Wg-Zi}@pdmxxx+0gG5HQ2a!iaL^L%iALHMX_ zohbINHzdZ4{pAe}JbuII!-c=HLJk!xx&w2RWr8dk5F}>UjZrB*P%Q^G83GU zLGi1A984*?IHp+6zPM%r2334=pPiEB*{u$VuPmJs3` zAO0-@^l~$FU70ur>Fw*7bXQ36>!%9ZsI{583alkw9B0BpOCgw>9~m8L7l~=n@>Jca^X50J>?`0WggzZj($ZO zWzx?yVV}goXCogOg6CPo(HIKJ5QpE@O4;8dx%ByS10V2wn8e~N>p-?~ch*3ommQ$P zu3rkdqxFws7{^$sqT2J->3T{C`__i}8go^WU@MRdnxJ(tj?54lPH9VGA&svC-l_hq zc?31-@rk5c@fd!+u`B(iRkJ@WH8-W*w;7SfQKhYTe`N{2wWWizqb0!V>#v;uIs5-y zp}+b1J(`NVGpzS^KFRDr$@7zA^;66efN0zV_>&#b0NkK`ox=$>gCwW2-58iScQ*uZ_7Ruer5 zPJwToTgnAZ_gt*0T)7*>tTE(02?f!K4+PFPP*+wTiz7ki5`|nzn`A9Zy`?~A1SA4j z5E0_UKxCH9pCpX9U|d;}cEk6<%#qQ96M#sMdPnu^y^&5t#ZuEnpzo?DuV7#zMF5TK z^%#yrtzC@w6HzI%5rkwg-r41;?o^qN4wdN8)%g3B>=#ZkV`p+$Uy zCf4W}D6#kBARMpd-qu^Ydl%~38U7mB6zbD(3`StE{N)DX7V9XpE~wgSW%_UrPWK1r z$vwA8q4%mS@_q0HMOJ7`<JGqCgm>Fd=8|Eyb(_PKBEc4E*B=aDv!y=~=kAN~E zYM|I+be^Hxu5;oD$Z6;7OG0>&eVC*|Y%%XkYk{Qh84lq2h7fAL3=%LTDj06lgGxBS z^5?)7w*KLs%bk#(AiqN?r(`yNoGEQoLN}yC29zx9t#OzJR*gH)#X~&2VAN+Mj0h9o zcFGd_wPZUHFt{RHOg4T?Em-tS&fnqF3jp<>P#vxAbJEMB>F;E?%An;v#NjRWGpB;(qnniezAz zj<35I5eMf6J>=+MEIv8R|JvnJs*P$0&EV%A5`53k)AUlL$mX#@6A{nyVe= zX4WtnK{iH)A%B|Hqw5b7)qUPUpLcq&k?G7d)ZBwsZ$-*7p58(catVcG&)o7+UV8W8 zMsk2e1abFXs$KIidkDV^EW1zIy0#*YUB=fagA~G+NlPY_tWW!>FK>39F8NrO3~aB! z^*NHorDptq&GfO=7N11z!tN?MHIL5u3!lG$HVU7?@n)x5Pg26rya02}i`~v*wb|mC zCj089A2?;0{gVhZ+nq%%eWa!3Q7Pzhs=f?@n2etoKg0$L@;Frr#}5N=BF_25>~Xpv z+YiteJ;LmYYd091LQZyg6ZfVqGB_6e5N|x+l+UIhBKcRDr*{Jik=6#p@&Y~X}+*|$YSM0MF?}i@gmHYSZJ5a&8t(;26!w&0A%vJNE=hD4tJl;Nq29#%7zU-dDHb)irJ7uRjK|L`5@93 zUjGH%O3((A{d{n_Oa5o%d-wGX*@V|bqjy^de6XAxDin*4xFUMx-|$N!Y5G-~mol}m zFtno)Otg#<%HE<}9?Vt< zP2@=NsICLW$_w2>Oi&)PCb&k#qrG)N37O^o__|r5;*S6|g$Zx8lbs0m&`8w$x29lO zq6`w7D+q-$dFAg58om?92)EpoHKU%VG&#&Tp2;QLf4}uQb`?RbG)T`2LMrPnGUL(N-W*cZ#kohc?n^W)y ziSjLC;aAmWQek+o5`9hRLC0G&{pdzuEs`?Wx%7-9>@Mz5jm= z5Z-s-hOxguP+PGP3wD|8192tF7T*DzJr_f*Rl=~ljYY>6A=}DYoM3Ez=yYR_1DFUr z1?dH-v_r~^y_Srt&EMhP++c;meEX42f0pRjl_Y8oV&bdA@?MP?rb*R5Z-kD6MmLSn z?!-MiSLw~@MsR;3J&?TrtK=Ut9Prqm3Q!txhSvehz`2wJJV5q+mFN0M z>p4t86%)++d9&;{4PuWCHs(cjma6Av*0VA56R&gKew~D zi}Ni}>R0`IhpfyFb`VR$w}qAoRQ`t0ADJ7rDcoEz+5T&NL_p4ZcWp+IEb$Sn zNV-p@VG$xJE%SnH$%8dxs6E;g!>43kpLO=X(h0n9@rz;kfb{~TzOf&k3VUK_a34g4 zd2O^%&XFa!by@-J^F4MFW#t)QaRMEvybM7P?+=A=&Ui%rY+9KlGH`gZ3KIMQ@4A*j zyt%Xm+(`8jnBR4hrw4}l7}#kvX_RA%}_5Bg5rnCiF$u1_=E7B`;E@l)2A{<<{JLy)F4yAO*=IuB=h2Lt^n z-{GKQYe>E3P40GcqvyrxC#WMDxsqk@_5ST#5gon4LAlF|=oI9T)(_Y8?E~d}p5jIw zZS8cl87(m*?WkG$kW5rjcrpumyh+Y8ptJ)$zv5Xq3Jbnv`WCcKDo!YQ_qru-jumCl zuxVX?5{!DSPUkaGOXAy77)0UkRO1_{h(0IIdXY8}FMG&vEC^RF0fcIlC8dAkEz^I~ zdMv+eZvGVF|Do~xZSehN_88geS{gcA+nN7I<@oO`mUMK4L&TH}s6x>Zf%r*rqSxGW zsJ@D2h+i*MsTo#Y=(?n{u~Iz@dC*{dk+0fAzCksZ`zPP|owyn=kOK)vv~|gAz%Pe> zQ6B~J0BP8Z%vYb$?{VJPnE46JDvw(ge@rw&F`~zo?{545Adq^4fT7TgK>e0k_kbhVy$x3i#ds2Wz^vuk;%Li6?a+tQmz0dBOAt<6pgfNdBGUvNHF76ERnIzJ^yO&b#NIQZ@SXwx9_8z?}YiHS8);j8u4 zS|Q_@@OR(zAf8}XGU}8`)gr&E#Ps?x=)mq>cjiy>xLw1;>@^_1Q`-!^ zUv>3gd0zk6W^~C<5MRJOGEvcV%m5}@!VGm_p9FNMx(lV-tlP&bt+OP#ODK5 zJ}lwiN)QN+7Q6PS6SH}rd{t)aOpb744TsrtdzX-ZTX!Ae^wI_QwBvZ?0ObIVSz!UG zm8L|}9tWnZlgvmMQwT~XXr8iTyCV`k#K005ZJU=I6F)^Tv3?uK4q=S@PyuQetct5o zV7k&&7piMsVtqGpa3ooK8KUP=sJX>;#Oq?H%%*1=Cj*+yyvW8aVa5#Fb3MoaeH6Ah z-$~w0?o0E+qFZLaz~}`}R|b_4XTot&(&}J|A|?PP)DRccZ!&^-YKCc3iBZ$sX)p2w z{Gml~Z!gv!kC4Baf^f*;gw|T7S)y>gc&`n;F~PU~&UzdXuMN8Y+=TnQ-xlY?OlVqK z$R*v~R2}k4xrPYilPFy6%R1AtXOF0uSxHFv<1H~r#Z*nKIiWrT$B6vRZO#iT{?B!t!e7;)MCGxq-$TFUKXLl+ z<1qr5j|?#hWJsHMF-)JhUeU+slW*>|RnRNX zP?D<+h1e`Mx9(U||8TUN%&T@ZmgBhhG)`e-n<@V;*C*f5@Q|8g;VWWc2dKLALqzxG zuozXdc?rKib177mX7z4?zIb%Ehpc5+(J^I_oRScs(q#cwstbrx^Di$o6zEUrh5REh z{{xGELvLo;8dmnW-!y15+z06x_XpQS+H#4F!F$(!H*r7@QZ&~jJv!LMyH{FKFY*cY zs}kJ9^G^(XFO@tMe*{3(84A-fpVPG}ziN<|wPg=xx zQnY&q)||ZCL~bym@B!I}A0Ljg8D02FD~SPG__j#g&z>K0H!)@%{jn5*aOG^v0u-@0 zgvefTr}_Cu;FeHFu+cnUz#`9QOvZ_CQ=E8)ltYO+zpR8nX1{cOd+lWqFrqwY>}RsS zeCx>%U)zZNScSpF3xHr}A_U)_nOo)Uk6rLCK(S5cVPWedAuGdJX5cnV2romAc4j>a z4l@jI@I?85JOtQ2tUT4zw(}DD;{%^IaVvTnV|_CGlI6er)1hHdQb znhKMqiVpv?ZGB=-()LB1O0j1o1!A`D9<65$*AD#cw+jOGP5Dh30GNq2hMUCODyU(o%>jIq;@^)gUMUp zQDQAW^REt`Z(EtXMUtV=J8E??OPT`CuKvHNzT_i%m*<4}&~en=V0Z)wN{wAv9lc3zCWvmPFKL%!)ke&?)b39}}FC~n_H&pWBhz5^Nf7(4?kH%wEksPQV4YCfmuoeEw333wOn&hX)v5xcc4 zRA0Ub!uA${7ZlY1Kr`NZnPQbOFUD^Q(afrFsiK)dF3yjf{#mAP9n8Kbs4RhUZ4_V5Iv~$y5CihLBvp^lARH%n!tVyM}CLk)q27LL7QIwc_ z{^G}Ax{k%kQ1zMD-D4Srk-nzdHHX74?kU8JQ8#;8+Xu^^Q^6Ae1FsTnS`46G?noAH z-#nxahMUB$w(HF#qsLMZPL`jX>%S%2NRzv!trJJ#9|u|0(mg&|;8Kr&cB$T#dny`{)SM5r0)gsL*d%3WDpt}g{3$J19hemlXR7jalRPahHglX5H$%c8KKny$4Qi5-VmM)02j~ec} zC~}%h1m=9mZz*!}{8lfm;IWYd+T?+smOV`^ZyH0P$n-pNnaTem8N@*1RvQ0J_5aJi zFTf>}Xwx~Lh;b4ZEUOtd?i8Q71_bC&toe5v`kzjsD!5M}3%AZXAg20LO1N0gSVT!k zkBy;OqKrgQ+z^f0sFkE*^J$8bblvY;dGq95jnbwJ_UT*YT%4{G3B}8F7mj7DHZami z4?;JMpt+I0VJVH|20-1rFoFO^JKr2AS|p!+Cqq-n3BLn}ZGfhA#}EOHs>o@Y%i8-etxCZjSn)-5IpI&1r&& zc84biytZ~a3=1Q~K>A~4GEWRyMfP#T^Y=r=hd4y*NI$a{VOa>J{g)pJzX`*#X%pZt z$g}?6r9)F>r}$OllRn!mSWb?|{kE)izxIHn1AwLNO*sHR?MhG`nNSZ9;(kJZE6l*) zJ>G1tdTI_uo$&naoKtHz52Sn*$nz#|?4f4tN(JgUM+ZBw4~n}UKZ|uQf?0K%_qaUB z>xa8;5H7LU&R3+@BDm{_#OJZaFiC2!-;7jz|3PNXI35Pqwogkw>|4@i9ZU;VZhHG}1jXQ+F|5`IO0tKahu1Okng$KZhG#Z&(>i zj)Y3W1VB(VeU$85GJToCLM_kI;)*k|i8V&|c3-`=4{lBUbJH5!J1Av{IgiDY&%Hy< zp2tQ|@TiD2J(80=f`woy!Zvbg|5ibG2DOKz*5Yt-uWy`engfvx1?%$+!>K#T=ThT8eDl`HOElVrHZ3Gapc)A zrcN+LH{4J!1r=w4k>FAaE~h~s)PTkueMkz_i=xMt=y!Yt$5!z>gR;T-s$Xnb!PKAf zOF#SQFE#~tJEapofq%-m1E=Bwa@WSb*+{_XK~;i=|9Ts4qC^Tk>Tv<#HzEFVupwnnbTR9ZP+t3B8PG&LxtnQuaGKi*{(`Yi9b9#ynK zrW9~Tgn_xfOYV_R zo@hV~g+>qJ+}O~HbQX=gHadS|H3|ntPc^T`So!AlIJfrZFl^2gfprsch^Z`Hyg06M zFAg*6OHurFkN7YP+Lds(17qi$Z2S~-r!ppost<=QWeY}H}Tt&DR6 zt^^(@6^Sexps9k?aG2`ZyO3le?wbLIW3N0a-|TX7;V|3xvVL|VaMCS4Bd~X+-|cKZ zB6nM9I0n^z%JOFU4_wyifCnXX`ftGz;zzFSnwZ)tq z<&uGIW;b7^${^qjV6;B6eekM(l);4RC+*J1L(&zBVoK9CSPhS*@Ca3U3}ETwW1WU> zS~OZx4t1stHaWotWeVczPloXpZl7=$irj0?7eyok1P(}Os0quW%@p%vt3CTi?Cl$)9GuH+&9o+Y9D9PF^cWb~FlS8CKWxo$(QqLaTL9Y!j1qK;P*qWBaV2P$#*YMQqu87K{ zy=Rm`IDNS$#K=(JErdr`h#CYs5}_2PKr-7OyK#syGC5=piX$oPbBvjlTfg`Yph6A?{=iPQUbo!^9r>xcKN9VfCKN>q z^8Mk>$5~3%p6aNMno(Bp29h?8VSfdjsd{IW%1zHU$%4HoCs7JgaDq;HxN*6_< zO8VJ@pMc?=o)9Xctu#6VUD*j9dtT+}H_Xl(XzL3X&PvE|M|wecbn#Bdt{c`T@7CC- z#QpaZHA_W>6mjDOf{PeGAhq^%_h9p@+n&X;9*%j9idH9lg_in40OmK=BSm(VCS&4HA>8~Wps*{Ak<3i*DOLvK zpm!Bkg79wM`r>5KJ#D`nr>2GGfV9kC2=N&fgc#aTd=(iAig%Qe!N)o~z)EXU{2|0b z<_AY(jwc;MBLr2vMnrSkWG8lroP2TzAhcBhw#Cvb0e}(vS0xDiGdod`EVjZnFO=@5 z>5_{zMDe>~DrxXnv@}^t^2Z@bu#{<1Z)!%Q;Olk1<)wtuU9(1GcX{ZRmOosH=VHmJ zOex3q)G#J^qm)HtSm~2K z1^-#jE&q#$W+MlYmHLW_W|PMtZb3>y+YWMVU8=G?gxT^sfA~VX+iq!}!bg}cXa9T= zm1mjr#(iPTl7ln#bYHk-{E?%o^qsn6s( zP!T{+S*3XaXI8X4ebGaT4N^Hpl$?#n(E_lrKF75+I-h!5XbPwC<#J@e%i|dvQYI!M&p5x5-)Bo`nI3J&iu3NSnPtu=84?cfXBt^59ZHWk$uIAS>%y-Mnk8#3sM zja>I!2U5aK7sX56DA3k9hd7xzcsNx9tI5#~8Or7Vo!>cIxG`EU@2w4_Cac~s4oK>SEoO`LIPv6crJk{U=g?@fa7;~j zWSk{ry&)c5dCW25PnV^$#K(eqtQS)+uPS#1vOVu7AwFkh3#rxLm<8 zJ`(|~tq_T!=)PjqQaA01tK-qMEvbFfmr2IH6 zoS(D9W=J%gA*4g*9Qz;JtUqDmPZs@Un^k~|G?JPiAOEHMfga@VDfrhmW$; zIiyv04ADeI^djbDKg9a7;fa04Np4p-<1PfSd%!&D`jhn3EHM(NuA-S<_4C_#K5upK zs}ho|pv=h~%YlBF*v}R_8cfYt3XicsQh8q(CR?WF_?6b)K!;8@ZN@PQ#78$DMmK&R zk#+unHxq;Ta2pJ`U(u57`4$8DgI`BDM!STH<$w>nErk;puh&hgUsk?AW<;+E8Y`2} zI#z|71}IVeotK&Uz%mu5W9OIvl}3MhlAbI!G!BT{K1bQSy$5w$P61e4e#9h#G3%hpo39i)H4Qf?@|Q#+j@ zHl^Ugw~o{)lzF|*C+5i0A70cPDCnc)4kOxbz<%kpLyF}NC;Vh1=kQy4tMxwnrT_NS zT`-h;CPuOF`w;N-$(ggVKOM3Ks7D>P@MB<1d%hR9zksZVl_F`&)1c(1^PLKK4aAf;<^A@|lnG7@AVR;3CAPe|{XP7-~6r0_)M=V+o>u!|5O|Nao{ca%o z&QR^hIEv%jcV>zSR(F3SP1dSoz-5X>jK$f{A`HA!8?{7xd()1@Qkj%32137Z!dKQa zTG)x#NBb??MWt93=EMTzqsQR6EyfFdcKT%tEBk=i1L<_WI9_y@rlZO0Sdl6%3(aW&goPI>{~erGzlyC5f|Yb1pfX5Amc%(easTA(sv#neVfhMrf%>&Tn;W31n2&s=e4ww%v>qRxr$4YJGUR zBu!cIK}KkMyP6+;D=gk>X!ws-Ri%6j-lWCSQ?#&hUMZJWll{g>v!q~H^T#W!1TWhU zA3A~5s7-Mrez_Cpjv`T+#EKDkfc3+Qa;K}QLc^+AOu{ezW+$%c&(@FDHbooyw zpPq%Ip|hzKjlRj3CEI_#;{Af~_hP2cGDR|GDw*?K25iOyJw)oMnv)MY3&=c#ZlQ-0 zNN<6|P_%j1BctXtJ=rH%Z-<-yg=<%nz~)#e!8<>72f$Vl>#VLBhcXcZo%AsH=g^y=$Y5Mac zRHjk|2vzpRUv#{?D#LDFD%-K+n7UU|1;ehIG0suqkgJdkL9E&aGcSUK_xAMu`G!8m zk-=;zrba(j%y1Sh1jwv&Zm3j0Rx(JB4^lAtEPWBeZSm4CyGB$yX68J;^fVNq?=!%W zpL>KG*-;~wuHM_)H1xx77%)IIq&ACL=5%z;zaohA5ubmrRM=x$0EL@)A`?nC+F^H> z8>DSeF#AeZ>$o40&BAyFOZECD-^LP6c=_BvcSKd5qDx!EOl&5CC@Kndc?l9W6jVHgB zKuo9)2EEXU{SFkm+tSC|)M~BP%OlazRB;2`Lj}AZ&-4o@cdXt1MNwx&h*33KB6}CZ zTx@9b-ASW5jSj(<@a;uj5&LbWnhQ>DLV_IiHDZ&7AFrXo2&g8#Nni;;@E%eYNCQRW z_5u%$zhOde`XoKSo8hLRZ8tLiyB(wMp2Pr!m9yt3+Oxh+?oy(OcUhOAq+#k7;&T3S zv`bfp>(m}=$0#UnuA)QphG%F?8z6oFCej!$-Y`Z<^bjDZ2P;f+&G7CRI@{-(VqQ8l z6Sni4P=Gtb5Ied)lvY9NwxJqhwkhgpep>NX@>aWAU<4JEdySn)8@UrTBtQd>PLbep z2@IV80h)W)j88a+bXulFczAGT*o4)*oLg;gR~c^R4C>LIgg{=TwHtNgKKwHKR_UK? zTgA}_lkOx+s_`tXg<4NNODMEfFBUVGMpBKPO4`5EwA$7ReAv0G_mPSX z4euBE-R)N$YoV)o=Of0oH_^$x%d$PN&F7!m076&?@>#gdOTHS^5QA7UjZRe{or>f? zA(56RFqLmb?q#i!)ghOOY15QS%>}@2F{Ngh8&*Y{AIn|H{kRIs;ei%|(Wx6=zuX9E z!iJn)*jqd$}T_~*ZK^QOB)Y8vc}4fy;Q8; zA=PMAmCtC`%EiZ7s_A8|_?x2yAl=hCh79M#Z`-3))!9iWlxiokVUN_~8!2if6Tvzbc)v27WQAFOJ{p(13PMmKP^68OI^{;$!+xL zaElbsQ3DvAEm2APbJ|f{uu>;YP(4sxETr7|uhoXqd6hyZz? znojrWG{%hFIwbXZT@l$y_&cGJjm@;n*pf?x;Xy!sC~1zji^O0TZr0lwgwvo~c8oR8 z>iuW`=c5}Q2sVvX5Lzk5Nc2=VesQG$@95R648E?VX-%4KyN#+0m}kEndRWfN0?m;X zOzypGddPQA`PkvJ0r-2cKVK5w1THxT3VPT(@b_bQ<614`4$y4%^HW zz)SLwkOjp28Xt7vU2X~`@rnhJ@~w0L&*ixk2~CN3nNDe7|~4V%hZSvbqu%R zscIl_v^ajJSWwY%1+!Fyy82qxYEy9+l;-a{WlMf6VRO!iclH|JOT@6FCgCg5 z7)660L#rFHcIc8QhS3)p1Pg(x#44}dL$afVx9*r!CJnT~lJmRX`I*ewNnoLmGNebzFL|kf*z4cY3(y~i9VEbChMm^y zeAgGl&N!6$55ukk-kr@TZe_iT5gs7Q7nFN#r4ti2(OCup%@HmEqPqW+86RbpTeEo3 z+Np(*=_j`&(o$()2fexXX>h z(3Qcjn-*1zJn~~H z**%<2e^U66XF+ZkX$Rj$x5oN+cE1=@xximvBi3`85zkukpLc=Vs@6pxo7N!1{0{02 zKMuq^;pm*cHw=+&S!`xaM-U}hqaLx1#49nHG`mZlE&Sz_-74>W54=ffleKA3z=P7Y zsDKXKbL+HAy9arE-mN*|5RD*oz!WIn<$@GRL^*+O6W|)rTH$Z}vd9mkpKMN#$2Pe& z0NtUwM5Y}DzTCV5VsSm#^a<=~FwYT;uk2C)+>A%T_3%|t?t(7IL6!u3mA>l3zZZ78 zNtSr>a?UxGR*`5i3s|*T$<&4J0MoJAQ8|b<-Z|nhe0g3jF8N9~lR^@e-&ggL(p00) ze)h%Xzy78-4Dx06eM(lBl-aUq?>@m~zJ~UDyIWq`!+`G0h0J39jb)&$Gk!NnhI^j%V=~An@B;&fjUILP^v4tTw%|eyG24GcYPiF(QHeo+wRf3p#pEiqf z+|2Egvp-Ccr(>;js$;yPEFIvIAZub^6p=Ssr%j4M+aWIi#$!VqoTn#c{MGXIdWxQ& zQlLv3lS@ZeJ*f9RXIZPhz!rt)mE*)XnrGNJactTN7_@)S=>ZNfzhVDb1%Zz$Xh zq5aq)uh{x@sW&ChOTv|si)LOxE4Myn>;57_T(BdT(!%W(g`F7NBm0y(*ZZkpk;{MI zsb8*qsj(SOM^CK#rHhY|*+<%Y+BqJ@r^iQ74x+w3&qw8C;vrnCVrET=rQd=7h9Hm0 zJE!WB(+u7i8C5xzqPxzz67-b-cJK*I3EiUDexsmxD<2JZ+f$tu{43) zBO3wnQ3<$#n}&(yMrTW}Ts;?IL2N6!G~ivqHvbnVx(vB#UpUE9Liul;SYg2f1RS7r zwrK`p)ImNngCm`-u_nDtdjXy;tHG^19qC;rZ*w0B80o%8jbYs!PtPK-r^$FDzyQuQReVfeGC?6r4A7d~b zdxKI>jy91zlSOntY^|s^Ffh*T-*c2=TqQ~|K?~@1*OuA0<(GYyf~=iaXbJw)I|JAT~5H7 z$G!~d^Oz7ZpCrL0zrunO&}rk|OlwL-f_US;lj!wnd-lwwvN?aQqe&S5oAWUxGpoNP zS%pu-qlD15M_};#x=@={?32GoDuV>Iz0(kB;q%rlkaK^5^{z9r49~c+6|BxI1*KIQ zaiR(W2zmq+6&Shdo0d(a51l`#$FPYfT<2` zQi{>M0xehnYRordHE#>lfk1(|SGGDO?@BI%>K!E-vv;Ukn zz=Cjn{u?JU_;8>6lS;Z*0)t5rql3|cQFNNu7~)(%Fj92sELP_wZvjML`}TCmHjJ5> zPiXZ@I0VbT+m#vY_zn-Lbo&o|)cop}z_bW6DRN2oPRZEA{pcqeraTEJ1bHxMD_}t# zJB|)`{dG+@>_w5IjI}Es2aTeCGN5{Rl$Xx6ISokh$o-Dh{83h5+sOpXA(*ThLz+JN z#z==Rm2Sy8FOLC)&fj>zM=R}hGsVGN(q+H2U&CNmQ zWsrC0O|0?&mH(vhv>9*c3?w3F%?p+9!fKMr-hXs-P?2CQ?WkB5H8R099HuAbXLbP{ z1)9gfaWgUh2t*_aAm(ljII5=iGd&KIT?FTOV}FNwz2>49KZ@Z94-2@2F}`3R_11h# z+C_T8Md$O%QD_8gNY_*W7W2;Qy*v7fRS3VL9!>{8OxGJx3vQ;#FWR2iF0BsoPnv9O zhJ$le&}3*mNq;!&(kxe2sYpuEOSBtE9NU6+&-SW!ST4#*H9B58a_iOcdY<}fyIZu( z)$m3>A?^C%AAJii-ceFjO`kmIDAyPlJrWgP+FSP#y7dF3lqP$)Pz?LuZDO;HkOdz> z)}MEAe@;8P7khzUr=1qFG}ReuX=*m)Y|!!D1$GMSV_KmkB(%``RQMf!AEfZRz_QT=tbpbKIc~JJRAE-El$1zYp*^7c$Gu@Wst0&U2kaa=%i;Up5$Y*;7n?Ao_0QU zlnsujl|0!}RO_}^bSp-EM?id71PAgz*zNMKomY!VI+t!e28$LPB=#vSUqRj&1d;UP zK5eP5?xLQEmHa`c*${U~1N0$y?2c5~W+ONX5)N|83@Io&TYyGPr8&VMOh8LB<8vx8 z1R$Z%+^}H@_gPybE+;THM>sI{@|TRN$yIglKzX=B)$f>K!!uIg#{q%@7@S#ns;7>* zu23oN^&?o5MQhQ$MMwoeSunbw5ikw4NZvcgqk0x{k;(+|S`(ek9QX)u(F|mK53l?? zaBYmmFZlUHr@~E8F>2j%l(&5`w;5TDB_Lyo5_0<&gzm{-XYH;vJ3+1~-O5ItC>yys z^3toK#tk`QM^m6>)at6nl(dJ;MoVsPPqH4-g5%xq8%H@bwQZ_$b@#KnsB3?^paPR+5nqmz7XxUt2Q!7(&8aW%sB(_! zQg06%NO%1`?GVd4TDj`ln^;(z>*5KR+B^S|blUvs`+p0G{)J7??E{*p%nq%eh!ebM z*4ebxiS=jOUSaIb*3d(%n95|qYwN{37d7x3UY}oBKqTy~eW=rVee?iVU+XM+27e(_ zbL%)&=q~$_3=Nx$8`g`KR`1v(*R{VPnH8uv5UcL^b(pp)BBjJNp46+e5)+u=z@ceN zEhm%)9%R>1b&kiDM~x*M9wcw<4S-<7c3)(B+&e3vqPQccp=i7a(3&#k%vswJi?KQyE7(e9UZ%tvQ6OMr88t=$f#x zg$EZv@?rK+W{9BM;ms;{^Qw>rcsx!b0k3PAE^I`ar2b7eD?~jiV+Iu*!cdZtE5`FO=9V!tQO45F? zHFMP}Zm7r`8)CkDmCM>1M9BXP1J+Gf>h9X;FD?}giT$}<9sh{Z!Bm*MBtaadtDx)% ziwmqdrwTr|V2~MiGow{$j9vB!CbpOUo6-@zdv*_IRuEd=>q(mWJ^|7wChpnUMega5 z5~j`63F}Hg#6%4b2|pmEY!#thy&QU< zW3k~i6`iI9fJ1bv*N8%NlPvpjI>j*NJEpnj-($|7XAu5+%jm%70o9zD(2Bc6 zsaLqkNsK(V*?jSPzJko3n~6W?o_{;n#o#_oW=uYRUm$qltn17g@IG5m9~n1A;k#Q> z0v&*V&m(MZA;)o zc-^6St*epX0jp|p`2qL989=>x=Xtb|agFSsC?0lc1-qt_AEaa}S}CPNCZMtgg&LAV z_b`MXsE2T&l#iW)-}KD|;|$`xm2DN4U>E_s3n{H3HH5DHE=jFrG=q?%^Ae)U;0*5D zvcu1|11tP+3xb$7p}DXEEfar~^IeWJrSGPV$m~n#9E4*y{?ci&COu1yuks-xds$=# zZVA}v{ViH-_3f;DNn9MT+~mQnYVy1-Mt-xni$y8C#5ylhsP+p2aCq+75*eyvk7naM z-FciRgVL_MB#X)4*k9Cid%cq%(?8%J>~S`}bhGR6SOYRmpfJ05R7y|!OuDhXO!t1zOv zlZk%Hex)72*IShupn=$+70^CDCkDVe%-7FtXt_t)pXUp??@hm_AXd4c%gVlWc7vb#%fhMic0oYaXz1a^uk6a}af}|xM}~1K+q-El zjUmoKeT^lQrv186!~EcmoyVuPHWirWn|%C~CIUFXq(iqqTj4(F9yw-9vEYY!QChBq zP_je$gmIc`MO>b>{8*!67uBH;C`%KP8pA95rF3aO;zHi}t!|%J9rrw8z)ipmi%qss z*#28aqbP0(f<f&MFr|ZZ#zMGO8l93?lR8sTsVqGA%`cyjLYEZQJEz^!6U`yM z87L(tev>%%7ogg51IvkEfaA6aA?yhS)@xuS7W-iBcLcTcOH~lEfM~S-AB-^h8e}l8 zPODl>!pp7wD!w0IgzoJ8!$~z?su15rHv86DtD02=Kds7vi#gs#&RG=+1zHf&%0Jr@J-cEC+Q)L+X{SYVk9$R}K z`23@WE5;3et{WVnSGy-p3Ag!}?leNmc#Tds`)12vqV?;=1~o*W);pULJ!d7Fjfb-a0u#=JC z(e73Vj7ZN`UVLzju-b`1wyJTWygsr_)wrnNLcL6I`YQSn;tIvn8?BEi<*}23lQA zRh;P>!GTW}Zzb;M5$qursTP2tL(kOaG>w`JdfjtF02R&^E}ZMjm6 z=Z($Ar*e528yZm<5WWqHtWd=&c|``IjmQvCCdTC~1?405;+vG2Q1`SkVm`z1esZBZ z4)|>rVw6(+px9ALF)!rTl>Ss6Xn_JNts-kT4Ut0Xgu7vV1ONsB``}PApUq;66|g8g zj@2cH;f8+*1Sg~^epI$S2*f#fWZ;J(hIV&Uh$YEMRWo7H6oo_uyK4hn-O@IJ%!j9RB zdF7XG7^vZ-92-rFt_w#fo++dG(H=Nim%@pEM4~DhVmDtR(Q@R-@8J*WnLiVjjXL;2 zZN5tlxPfscmQ+a=Gkp)j9!>vw>pc{}BY&!H>Lgg@gFY|mtm9aDP1@dLxO^3vKL5^@ zHUeR3g_EnWC7B>jJYlyr`oL)eJ&JS`rdB)F^CXw8S_Rd{o~$6jGwiYzNWBTaf?_XQ zaofV-V1M0Ofv%+9hf%d$cS699-~S_}80))XQePZ^+(~0kBaY8GaGE0+;pZBR<1rcI zqMiQm4?#!gN6QE;7Ldd6@sqd$byTre#^kr9vuBEk=6`qv7l&+QI z*R_G+KW#oseak;>8Y@GGe_qu3ciIxw+ZT$rEo_s4t~zb>H{Y-j%pzYz$FT$@#o1$3 z4-iwRA6L*tXbk$oFMYYqo!Cx?jitt|2Mx)TO{_Ap zvoH4t{VVyYW}dt4uU5xF1;gM*pSWT;z~E!&9EEU3n+M2utM4(`!?&M`YP{UY&oSP^ zyd-lY%ORqpRkBsAaqz10O`}fiute|a+^~t!-}X}clI)h_o1{peDPP&}dfKoTtp{=V zEI%@=)Y0l)Q~=mgt4pZYb`t-ll7Rn_CjFU~f1))uZv4B*h04;&!S06RW@BTzv6 z?OAtnYQ2|a5*cm^F0Xfm!X%mOqus1|Xp=@i;CIhtxt38RP~{uv9t$ddOs?aH6_uW! znvKxtj7zKUK0wJ1R4<2Rsf0z4kzgh^ zD>o8PCm*jB}^IO)_~_wzpQuSa)}{sZ1` z=h|nSFZ;}EuC>>idrjRlS6TDSQ+K-0KFej-S;&~NT2VvSFrcF#VEBFJ7|O8;Y^M7L zysm!`^T(6!-~G635g$JFj~+w?1W!YjIZ73CYp*I}`0~hBM-ybp!Ze1LvPU(-PKubs zH&F|vO4>THBu7qG5R$LD+zMP?#~MZL30<-g*!IZ4?+yt{H9hO5QKwb*Gs77!BG$gS zSmPLQ(=Ip!2Vbxl=PVxV>+F!^hMx!GK<1ol1CD3vkx%T;p8NKmrJ{P4*IxM1$#p}K z0jSecvl6S6+9h?dJv|AXq%{4>_vsd54%z>^(WJ&hsaa^-*pma~IKwR^8YCQNu?>Ld z1{UiWf_v{?6g3%*I-1+b1}@Jo$7FEAWV+du6exhcZH74`rXVL99`54_{rqMezzL zF2#QX|74g#`6>wf;MH7WZj*>gXSx|u?s4Nja_VhH{M-#{R}{&$ajh{Q&Q8%6lU%Y- zjA*UwuR~t+4lVK3t;ODVmoet?{PiZXMHo8_&jqj@pooGIZXqM+>&L@>^2~HURI1k` z5mshN4LX1By75zasICOSx3@qgwAY1J9 zD65TaEqLKwzE)EYVID6adSRsK9W!ANK5zDm(Y??PK#LlZ1cai-k%F0d!52e8H67a7 zRbEvsU2c${Ro^JSqbEFP;pF3E1K%vVdX*Yx@pblIsF_~?@|VH%s3@>{)J)x}>clY% zCgEe#@1RCYAK`0eA>enr6zIz(`)00BO?5dqT#dWXAV=4zw7I3LdLW)z7!C~zL$%S_ z@YTu%);aVhu32kDH`CoM;#Ig``hwHkHF10Kak+95Z_4%3p9c3vF=W_7Q=%M<%*{|X zT&W|h-0~-g;sR+QuL;Iu@|QvWR6+mZVT8$kW)7jTUx1Pq)mQ|7 ziUJs`2>V(@JY!EU4OIV{oLHQ;L9Ife?>zgp>Pk=?WFmAsB{nZ0E%-}7`kFQDnxlU{ zC9rW|P=&9On=R(ee~Z8nHQTGxj~oulbqFc?V2VgaLZrQ zZPoy!{GGF@mqNhHDDMhKz-a1FbhDB0bds+t<@*8GB~B@_Vm-9=Sq@jJoo0Wb!7w8g zpU?oG5`CQo78U-2e2tsXmWpLHum)}aFI>%Nj~cAVgI7teM;%T76qh&U@!LF1hsKe& zK(!)d$2=lknVh&%sGmtwH))Ea>)**|FTHX1MD2-i@o0$?_;c}vr6=Q}g(Me+Rd!;d zA>AR$a$7*uB%Xm(kgL=7t?&DsI+Bd=3zemm2CJUQ%gOFGklw1nWTl zcy)TBkDZ)P=U1~@HN->lhIiFnK@1g0J4iV1@5}P3k<&}*nLWw@e!@tl?+V%?O@>WZ z;&D6JwySmBm|&#b%AB>%6zX_=%sIrnAx=>tI=LW)GPZET*Cea~&igi{X z=xCP0Ma;RXu|(EK$0E)Qp~1Cpy1Rn2l$>*%Yuu{PEIGO8{x$eABQoRUScXO0;Z>4) z*ta-sD7G)`|06i{yFHPL7C}2Ko6WQ&3G-|?OTu3U{ok&uZDh}AtX$J&uoMj7HNEs8 z&0h6>^;7FJQtcN}`t5|J3wM~pa;17k09#SGC3BOB*HzJm?!e&OqbpQ2m#Pl&R$2Q2 z&Y@VFE--)b13vZor<#+u?%aSYFMh)kykIYqL8Q|~tmXGh_=;IE>Zyve zsT15X*dM%J%)v7?fF_TtQCp5&nJh~xOiuyd$jdX3YU5()vtJ-=hj=1ZBaWm1D3u|5 zTe~~xb(d_iaH7IbfCU;Zc=Gb-&>t|$I0yAYa29*9`fe#wXGW=)#^`%lM6pV_F4M?r z5HJl4X2sd=nndJ9yz^O;-KWXmNO@Fw?9Meoe0G9F1afvu6g45&&P)8j1YIX5=vtNs>Zu z@E`oG`Qb~8r>lbdQ<6@8agWKIEphzOKFbHe5m9z${o5+F+zsqt<~>im74bd6PQ+kOrX>a~GUo z|B!VNG*UMdz6^Mc9^K-*5>L@_$|j}xb>)+68A=*|qxm$*dO6Uu_tN4|1@-yKA_`RD zH@Vd)XkA7t#q01IzE2s}?igym&LL7E35|XkPd6`&o9o?X36;`ogTiff;QNyxfX^fy zHb}k@4>S+DqB$)u*A7;>xO*MEeZs?psCn_=9vel;Lw)a(^{$8HOhJHr$}J?lWdjz1 z=@pPufvT*2rlZ!2OOzG65E93E!F6@*5Co>!8P<+e1EZH#&(Bf_(P0ixrYaJL#mIfF z-O^%7PHJ^Umvse6^>mPGjEj%iUsBr=RV6Jgb836CN4%6vTUk}<2V~Ka1PiLm8VD1; zvWLPELc4!d6yfb6@;^k<#3}OEqLe`1+Q8Y=&e4WI-qG%lkLg!a<=+(=M-%HW$L0S= zL(?xTy?$Y-)dp|-@GQ(W5g3*$MBiz2{-9ltf48F)3{>zpE}?R1Y+LklQ9)#h!eCAu&*kt4=C!p_e6mJh7LQuYy>FT*6a(yI^MM~ zSTpkVbR*7(Q1Ip;*e|y7?m82t%+K9HJty8vSz;BwlcM#K0nzLr{(%Bw`DGVt5#1^^ zk->e=N0V3X-A@K6&=Z6ScBTAPtV*`<6qV*Cy}7`9UvLIi5UY&3O3>fS1}}4aS9xSo zeb1KLsh_&cuzM$5Ds+|U#o1kL7XeEVl4@*&p`(DCPz%&}#LBKlgbukofyet9n~Xp4 zjDmQUVajX)yB<7zm+nStQJr6{XZdO(wz3+AiGo+~cHG(w?Q(&@J=DkRo2B-e6A}W6 z6+y`i{HZuA10La@JH6|NG;mW+~?P)N|p3_}zel3-8*(Y&mI z=7va?Tv%4X0&#*m^zHtZrGg38P#b|Z3i zi)$|EHhzuq=G$%@od=Mk7|d+b}5N z=hE6ppc);?-1-hFz7@<;m@vn3L_^2dj1aM_`+N?#N#khMy7-*A-DFddrR&$lzt{T4 zImpbEar!DB7;Jcr2pbhe5#ATnFN}Ft&mda4&j3FcRE;rpprW3PMZaeuIt^#L3qz%I z5Ro87zMC$H+GM46vFGmHh<9|)`{lBw%a#t768KBYlm;P>9=p^J;QWrxp7ixxIM~G5 zNk^sx>QCrmGgx1~1I{rn#3^VymalcK=Rk3TH!eH*a9D7_;nM(UwS{<*=*60-0U@VV z{Jq$%na9CJT^qO0m5ehzoa2)%T<%TR?MKhgf5*_o2h!c5G+dxah75XH#s!96aqeqT1_e=p5Ss*~7WJZ%MZL~QI{kDa zku&fJ=|p@{vtFLgF7Gw4!VVcHl|q&Opcnr^)ED$lpkE=th7S&1`93&%|E;!;>En7M zzS%q)MnB_WRHq?96zK^I8B%s0c>HNAVP_{6bmoYaFIg(-K!P{|(u;m7JgJ;;{4={~ zX0R`LazZuP+Mlf9VDw0^8FaVV8%u7KDt7iR4N|lw9awbvwa@$x(JWJdEMHoQhmp*8 zeif)x=z#QfD`*lD>J-&BNVX*g?x=}cVRBy&BQ?SG8;)5#UF4FJ_RP7C*$x9eY_kS* z+jQP1bDFpNmm5LI45$AG^nqiRE5|eDAoC`wRGLbP3_wmv7q6vFXQ-Z9DdA>{H4>6# zMS;XV)`!3iLUBQ_f>Zzy_isTJ0+Z2NJU9^hfmz!H0n2?%%EO!QyCHA@5kHR0QumeQ zH#KGqI!NDgeuOK?-2L)dA;}_#D#*Y=2-^+)E*1*u5r!+81yL?AEGm?*o7|ykYXI%h$m?aSn z92xN+8u?2W|206S_%BZW525@YLizt7lrqyVfnkNzmV$Vne`evK_dW~Pl$?rsm7lr8 z+-O!IMGjypy*FS5t1Y)Ewoie>Y+fX}?fExlfs6>2B14GIK&P!C#_uMVl^LN*SF01J z*#)!|$yTx72H{Eq=iK3!FUnRYkqXJ03rDOm5$CAXm{%1m?&ub+$W>^3q9Rc1_s(`_ zrE|G->w^kN;m^~WJ_!Nud^NvI5yX5?)AM=k<;NYbUaGj6d@X0`;BjI{0F=kiO0o#_ z&Szw6Z9d1Q7SQnF9a06?aZWynY=NqC+lka3he97?kS$0{!(pf89$H>$UwpZB$1@qn{>=LlS3FcE=HC-73T>et6jKuFqOs*poVr>|8+GpQK z&E20R%rlhBl_U;%p3x5p&I0zDom>cemhBnX>NZ}4^<-8HrM~?p&2oog|GpgyvPV_+oo@O3M}A53kq4P6a?P-#QdrTEEricgB^u zx-xYS`PDE`a2sEhc5KCG9|!_<+r>XcXob=dz^{a)eLUXtA$VR{FY5jd7p$061X_}Zj4xRjWr5zFryAgI{O!)H_gO2sAHBuaGjN# z5qRtIz=ZCSD9f6aW#TeYS4s^2hB`PYyxl?3iUsx-LM5eTIr@)D4r&yz5M@gvv8@FL{80sdK^Ppnk@>#UmC{Er0U4VDOrrm{3N|(3{QQMsTU$ zbT&n~LhxWiU^<{wK>;m1#3qm1TTo*#vgPJ4;xta$15PI%(J3@>>gB}% z2GEW{iT0uWdjz2ETE30*=`#9H!{bV$kzauecB>!H0t_#rV z*KDUK|*xnNIU1QLpzIegwJwF266Az4Ykn#9&f&|ET?uKZFt^4I{`b zI#$GF_gfkD;$xyhxaJij=uYAWGL*1Gm7*t_H}hh=5D+j_^8H;4oFK&toBv!0*X`@* zH>4NCS0kQi`I1<< zD^lW36$Pz$l~0|xF5Y^Al5)J=l^d?GR{wPv1|k$?`(K z!y#%fh8CAOI7p#%&uDUN$*>HkwmCcyzOe(s#9?6Ejp6g5CpXm zCZBTlSZzADI>2ZF3Z;lJGmWk~Fxu+P2HiGAd;a7vAcz3^i!S)T5c$FwDC8dzG$8-~ zfzkg@82!JzlvN=R0MT0_7EGbuvICL`z(0W3*p}dL*;f0} zKQi!DFsN)7+K`wIc*bC^hdG6HzQ!X8TW(6xZ30l9bNQLk7Q)@~vmKYDt15nPYUC-( ztvKl|+-P)AB371&4C4tgvoDp^=PB+E5PQEUT}*PI9>1Tn`ISRoIBv_l0o7O+^;&Jg za+Zx9{?j+{YtHnd?( zeP5ZrzZ7e)lhB_Cs95UZ_!R-Gb9`0>jV@z8${ZifLVFFo*nTW97jFk|dvvC*Li+~I z8!%z9!xlQe5X$5ZNB6cU)Ryy=e};?8^zKEf0zzsf9cCR(2XSAs+B>{x1>_`Q+mdls zH)*^Wu7U=`dH|MLeY`y`{4|o!5Jxx}bPmRu zf+y4C&fGbT9b?CP6^3_?Ozqw(vRM>~LY9Jp8!Tg$X-6wZJ>;eE!PlI6DNHa9 z+A)E`Mz*tDWk-U2vhMXYxIvS#$HC8g$6?y-(pOn7@S{ImN z7EhMuofI>QlCeC#26PhqA1?pXhW&Rxx@Hi*oO)D@{yX;8Ew>3tZ16jqduM3_ts8VY%8 z(td@&eA+6^5=g?N>6B9qqV@4HX)@vSViTc@C^(8RyuPZV`QKAJZ(3sp<(nP9Nl*6n zR5JV!RGDT>0{~lgB~=}* z?wh%^3E!Z@mE5D4ZdBm~adpS3m59_}vxDEE?n>KM5*dGa)AFB4(4>1_D)~?aYVlX| zuRrv(+Ig7Ivt7TG%X9Zb`@9kc{2SW<{~fOXHDmP)CSToxuX@cS@IOA|o%iS*rfz^q zlKBt-IecS`3MrPpZUC#;2>5=msNn)LNdO3YgiyApz1JPuHr$Y+dPNVL3Y{955{Af? zyS}_5OHwf$ zz<2SIPW6rWgbvl?M4vu~rIn@MLLsG}KCQ-`d1db|PPJIXmFja_>vNS`Qf23((uCtn zP5#9uw93kdT`Lk3lP+vKU9@~>@rQ$ZuX@P zK_Upj<^&p!_rYPL*i#lJZ~AX3S>_$PkQjDK(Q7Dqn(=X&EM3EPqZFeFjF*5_; zO!U6S8c&?g(PK2z0s_Y?O!2mUWA4RQN9NLHNufw^@=Y5qX?iP=c^05fvXU{Q!+FZ* znL2bCzoM1*F|Dx$lg~D`Cb+v% zcEuy93YU0Cvc_%NeO-82HLNxIvZPHlr8hFZ2yKAcvjvc4%Oybm2@!CFD#yV4jeFH* z3$#n*>WHP9ZG^!d@dvO97K-ihrt7k^X`v7NDQoir2aKh=)&mcl11s{Ju$`amgK3); zvW|zz>o1&*+_>y-tyg^@k5Hw*S6XHnvB1t)UY0X@?2UTWJTeCxT7C?80j<!u7a=S?(uF%p#lc7G(yhe=7gXJpEm|y7k)ROe>R}5K zB}w~sad>f$b8-^bAGqD~`$tQGI{Hv6)OK=68T4illBTbVnvf4Q^8oaX#S-t;^KhZx zC=gvt(vP2c5<4XD^1$h&&yAPR(Jc7;_G>1j1yX(QkA6PEJ+?Oa0iAW}>zaI8Jb=(p zW>bj?Cd%GB@XDEr})V*8dR)!3rC^oy0MS3nn$KG4d<8&6)(4Y7PA>E8Y4$A5f zpml^OhJ*BG;)=Ea4BSuq`? zZaliXmzUJ57%hhL2R3Ny-%297q#JE;Am)I;bcNUE}$ezAZ6n5HQ(II+~(ia|DkyOFO8&UP<48_ zQ`@C`Lty(1K6MJSO=<%B2h*pjO<0k^WJ|6ZNa7kOz`{8D333ZA7t#)-S1^m)eN5it zli4=XosE}g%*hL&@YKV zX#}!N|7D7bZr1tDLzKfM{Ch#c>mH=?Dw{~xfa{OgaxSS;S(n_4Fn(s_ZPh80>dYrb z3ukr_6|6%t5FBx!^;#m@z;|-&sjXhRXLR}aXV*&AW^cHk#{qx@axvXFu(3fMTGz8K}JTq45h3-;jaU9pAQJ=GcM3zTFYc5wQa-%}HppjMszMm|vJ7(qI`QRcPYIDQ zFGJ#yr_cLItsH^`bNc?^@Tdf|j)vwfR*%Is$6Tw0)~&E3gHnmaz`;T@9^XbZUvQ*I z5ANRP-_zRt&gPEE72>@~HN~iMVyuTqjF*RR@O&ca}ltXpsp4l^#^Y=r;E+jDWV9mb$^Q4~X$5Bb_d zBr{9t{p(7MD5_(JG=YF;E^Rv1m z%0b^`0f2X-j&XQ2Zk50##ARWg(+@Bw%^i~yZ8U=b)91co5ZA=KScRwP*83ALNi73> zf82}%Xp|++NRm78z*m|+JB|iX(Hd(Z9U*;Tp^!alEdA3^q-&T2G%xxL+caVuT@@ek zqOBx>tMGENUwx4yevjz%0fvRSL?a8ETWMQTY5J6Cyr%@3C~aLao#ViZZSC(Dvr1!+ z*!JR_SOy={k~2jG^B91*9prS4sO48zIN3N=T^n6j7Jt((kbfsHfCBx=F8)csfcwq< zNxynfF?P_v!wdCG@LxfihnYxdPWkW<383ok8iV{F%3IUD43--&QZ-xJ zz72q+#g1r+h4mnz=&aMW2C-?zCLTn69J7)0v5H5k2!^{2Mq-?pCA_(R2W5vqG?`@=l`QVI}&-q8Pk+U^%I8P0;%`r@}M%$s}Eush?R+h4_ifs{3?pXc)N=9@CwiBjXf~6$j*~IFR5H`iZn5mBGNn9d5wA<*yn1@SA7% z?qcrsZN}ee`)wU>h>Y5^*EuHa^T^F>7h-G$*h&JIOCx?2=(3f8dT~^_wL%sTd#t2L zE4W5$bO>f-Gw_zED!OT4SCLAhjA$uYc#xxP!LxV7Fdvzr~e>;XqpvW{Xc{v)|QIF1<#OccFRvp^>!kV7*DT+~qlL zLtNn5aoPlIjqzqTVMH-FK!V>#OmQB_Si>|wIqwu=&`#{rd+;u>9^!F!bwR%88m!@z z3pRsBJ3__BgX6JhI56t(WPD!6j08gjCa^%na-U{}Xt0>je-NQ?h}PDJoRLbFRiOh00LkLxVC{Y0)Mxq_eJqliVJplnXqe@>2|Chotb{4<54DE54lM`@uoh>0HIRwt}7e5eNVET#`2VrQ;n zQ=RBTMj8vV$GA3tvR*tL4vrGR+_~7Tf4s%x+FzO>b0MBySYQBMbOBfcuRRkhp9=m)$$23{zFwSOWPI z{*-zK5y9lAX7^~lYg+g0WAek~eVX`~5$@8Cuo$fZ??ZTD>{0#$I+17rxUKazNd$5(2V&mE-(tCVkid z&_~+hOi(I7%%Z0iPZl(P0sd}u?T_mVehv=1hhQxn&?d(quUn}dkfkxiuZqJ*JNzYS zz6(=@Fnzs`q4Fyn;jE8{3&=E4AIK?y7yorKm}_l*?f$Ga8#JJAB@PU#_CR@5)nJL? z8j=Df3z8- zU-dFvs3={xVfWGz5@F4rbSVLmQ{+cbpg+6yKV#6pU#VDvf2t5h;>UjwiMy=#SuW;G zr^9*4oD|hsK$^NzoZ7|*u8R$y=($lUlB}cfEWMJRRmYI*9CwAdk#4m%u^IS#i{v$9 zk_|cBOOG^Y`kSOI&oRaC*Qih44fPU9@X1-@0AfFI)A|sEijtoi4n~O_yjbf8vKw(& zMW*oF4)w`UNYKdmDWoP{ILVsLH@`hN0C1`h?!GXnsfLC80My$w$Tf2Fk+HF#ZzUK5 z6(x_XF8HCtE4)ToX@{1c3y*&m{Fpz<6Q`1nUQXKX5U_9b;1$FpC`_>ke# zTjI6|pkV;+c}~R4_KHp0w<*AZP8yU2$rC>GB8AiYrdpoigvW{clusF^Qi}PX~SLC8R9g@?RWD z2t>^C=`v{($*HZvB=^E)cW%C})B80qkjJhq{V=S)+SH1LPA*eoP3weo<1JGg$@PpG zJWfy~|L0DKkoxcn`*;RubY02)B4OLVLCupkOm`i^A-u&ABsEikxFm}?WIjJ|~ z;r0!kpC|hA}AbgKEd*Xb`p6 z{B)&E5CB+(As(Xu&vOfrp0XYjh$(?tUy4LB3Fy{6@khkB*SaojHZ(%LkuTUyV{Ejf z(CM=`-bW{>TkTRT%eLBJSaCL9hq>&DXXXPx#T0&1u;sV<>r2_Bp=59DP9WxJU~Fyj zC7p9Iv#=$QbNd>N=|n(oW#U0#_GN?RXy9yOOkn6iAYgCrLLg@6^3{5?{W>0+{qrjt z`+t5#WB1RmzWn%%-T#{K{TFIKGVk_8`MTSrIKFF<;xPv1e^+BFl%`~Cp|($kSE-`K z)u2995y6JDTnZ>81wpQ~v;g7@3=F}?e_KIYxu~&sL!th0#O|L9gJG|H8xG#OGM)=ud!}=?sGA>a4itYr-+Kn!uwbrKd&!DC6V=F(;xjLu>dA8bZcq<~ z(=)9;eOLIEp|6PX-OX0hv?!*zjljxn!OMsK;zUGI;2m#mIfQ6F~9D2?}OVdOHA1b3)v-{^cTF3fzNmb}9wZ^#~t)yf4AqI8tPn7iWM4Q5l$*1qa_?|iVNFN3T<#Pr47e;SPc zSu_@g{}khKh&d{Zr9WZGuVY-0^Y(ywA=|v?z6ITH-B(b{6ZiVb0T)fh-7m@Mnn;QN;4WTiG z?s3sDLqE*ktxHp-i2f#HKu849^mh0VQ=~J!&vG3eRghr%vt$}snV)fn>zDjc!Qnoo z$e-e#W_YSU%|*V+CCLq_8OUt0Tv2J^DKv>11eX=jq#X+elTpE#YKmi`Xm8KUC(H+*tw z_~H&&>}M{yS=nQRCOg4Rf{1p+P&gf$;N7Z=;Z}a7%fh>D&_S^>_#(yDeloi=jwFLh zN_KmCmHiY0E&>uB(Y4MakKi-Nr9=-?wgMb2x-ha46JlMr4)KhhD(ZzRdiZezNXX>} zK%88kPyf0YUkG9hjmj1S#V-#u5dNNe!O zXR+1&e7k23rfLhjTjojGWi9V?YjH)>=U%9g!WvV*4pfxflPHrRTj`UiXy8I9Vz{1C zo`7WoA}~vXo#JrpkK+6%25lP*bmZ?iDhi{y^;U&z)Tr{ zg&<8hmilev%{YLgg$kX%lm!@3FQX@cq-3GN_O-vI7bYe;($P$=b z^!nL15P)_AoU!f6`ykJT?=VN{xZICC=zJI^z~U%#s=TQoK)^L1r&Vv};EB>X4@}oc zb5<10ZUuY&;}W|TH(qx8&cPpN7;29Q>N*Oms?&&$Jxtcf+FBO$XmHY%wDaM>cb3xq z4T}DNe%aALi5%7mwiY0UPWp^$G;V~j9QeLqNgu$UnzTZ97qMTBy8W^0~R1)HjXPrA+5L)h`OVkc|>r ztDG`^HW7=PIJ%k;2->+go7i{|aGM+c{q#R7hhHJ#&p-KfSN`pM>Ev_;87)40|`X#>vT^S^(Gvw5i#tn3zlYrSUAXZr{hD30e zL@|RiETf<&VS~Qu=#Uyr_a@3oAAEq?5}Jc8vOBj#ks&o0PFF%Klt08j1Dw_Y%;G8o zd4Vnm2xc=Jq)JTrC^=PL+?Y$JS>f^A8cU7kGWgA!mH^H@r%OxATeJcGf&FLllT-iY z%)MsoTN+R%qW9oQcAhsrWZoj?kuend0r=tk3|!U=RRnw8|J2sW7>mv`>jk zjZPp9BfKBOfP{t)VC?wF$X$rIAYocBIh_|(Cv!SPLxn#%Yr+DEF>THju&*~^NsES+ zDqqBl59ZA9OnsWYhcg{#7A+b0#aL0*L_Zjlg36fI@dalz6_{}NakgR`kGaCopsab@ z9KkItV5;M*b9cc9p%supq|508%FX@__=tdwlSOq@dpYXf?>dOZ%=rOJNtEr zW7a;1xK^$4;Ole(XAux@oMk|&k8D@9`%r5Q*(`ROGA^aVCBE*;|8srv4=Vnp{xNF3 zb9*!#L&qS1JQ*n^_>y?^pCno^G(XEn_G3kYrUCNQMIU>=KOApzMoYJr^M7S;?vAH_ z4wq`Fozh>2%O3?KT)L%Tu+!;uf&N(6izeau_8GPFv<4cy^j~**`2r25yTq6|O0d5* zhB0q3;n148@pR(|3g9pf^Xy>6n&{sEh)#a}Q%gyouXpcDNk=d^*=(N*aGRR7oh&rl zE7%s4(U8Dmj;lj1UGWCF$HK}#-6=yqVWORJIc!dYa}3a@+2T+bd?w1!;{}iBw3V}r z$GIkyx9~lsscM=SBW4Sj=ah28?ywOH!Vnu!ZpHLEXp^U1UG%0vG}?iTMxX{o#mITE z*cVc8y+KYLkULenKDQ%ZMn8!=tJA3M@rL6|Xv9v6M02ZIHnkuSD6bPS)4=*Cv{#OT zg?(wofd4sM{^=3_yC2)OoC$0SwGy8yiSz^NSZP~G(BW@xFyHsYH4^Kfh-e5&_(l<7 z5N=O1`8dwsE01>U7K&a73%#?}m6xopuDEHaAYmb~ zPMPOzO<=zdmlKyhmAp7|6GvdR)_8~lDC zrx)w6#T#aS7>Z&i;x+ozpUWhb^Yc_$nLrXUGYh3?F)-MoF28F%RY8F=D~mvzNV36@ zdtk9t(`1!$=XU6Ck@CMi;y>H+g|#n*O7QeQMar?)il8zVj%3b8@K046GG}x;=W0r* zs4TIE*hY%EWpMem`bZL5bJZc(-4H=j3?BATdj{fGgdI6IY|9;ZY>7<2o0Jlq4npKX zaQI#V3jiCD?3lzm#PCgz3x^_Zeg%!$>l1srk!Rs;mG0%W5K()OYqUXOnVpC|ZEXKY zEn2||mg5*=-f34mSokk!$`DW{syj!ZuD8viLR>UV>!_3I9sbnUAK}Y z!&k6pA}1e6>z+J*Vl|H}4BR~mVp>~M+|bg%^Y|H)+NTPRNv3}eh=w6LlV1nKM2}I= z-@$gFBIdTuiXjQ*WE`F_@B@PbI_iCFy|HTY3P;8j9z}epa5%9p;cDT!(uE^pby?Op z)c3AERgDFLcrr)7>PfF1wxs*`*Cp5a^EYUD;%?(+(^mJv#{!5ZW1Jim!RGj|)S8N& zcWi#kEhrC&zMvNax2Y#RV9*&Wc{VRNmTUhW7vpg7mZ~Qg^`8KO>9C+sKCm;i<*b`M zuzX0SsH-=>nZ$y!^$=Db(emggJm9tLb9(4!QyFfp6cHd&Hzd_aTdeCnRs#O{-F&J5 z!P8?b9-!GG?4epns?dUT?_nRXP%8RfD#U>&B#%KW+BY}TD(!HQA&ZFcW^UrUCCKsk z)l^2r8!;%0Q8qN7ErVBZreZgWSBsMiu^6Ht?$RjIuS^}E)?2}B?Cfo2HeYl@3D@W8 z(6-k6p!Zrw@DScfVIqmg)*GCTbCyZx>X4tyaT zm#4wzr%7o~r0t)Z`)$YUb~K47w!F$feUPrM2{x>{54rb<_Up=iAd!ClX$l!YYq6G& z*jdfJFiTm|=o9oD1g~SXaT#woymTrDd6vL;BtcP>+ER}Ir#2Fpo@5KN z;MAwPzZ@9%cBgvKBubP8QkBBQ+OpBtRvatmoH#56YhRG1^GL;+gZ>t&zNvnhAb*vq zq^u2W%?P+%|9PUd`t$UEv!VPKHr?lQUL5}j8n71Ss4Ng>lhLOasAA(b3yCM2(g8mxD2kFlA)FAd=ffUbjamF zwJTpoYcA&@yxl-SU3;i-R@7*Xho)Nm+~6-cY}qGAzB!#|Hd~2xamCYKzvbpYM#F$S z+T*j$U{r;DaXoZXp&@kgOeTzIB(qDhIAS@pNlpt~r)*-cPGCjy&|rQ-Bj<;cQsY9v zEjUu8gZ>MJ>Gz5)-y9Wwy*CSG>XwcmYS|JXw7N#1C9pt%1NzT94EOIv-PUEe+9QIV z+l?pooVLs_yjryU7QFqQ71lpsl;zRJd)U~P4PtIM!Gu^CXZCk-C7O4TqFn--J;m~C zsm2O$%@eeDFQa5z#k>L>r8=RRv52mPP=tg9ybHjtqvLQCt8hy_G3xE?JvE&Mue*;* zw^@;RKEc2lKh<@uOoXNas+c*gIt1;Jqs<1ED*w_g(0|Kx@+IV-wd&&Fto7h|v%t70q5}Rqpg@1n@(&CDr&aWy zugW9gKWN=9Uz}AUKNkwzLB$!tSkkyS>ejCVpj6KWeQ6q9?a40r%U#KDTA3n?%ucM)8a5%?1Baj=B}Ec7 zCFwniVz*V_-ngAWR*>M*Y^!R*ey9gpB)7D1yGd%W>>G$+D|dJig8aIaE>|42uf_6Q z;+A;78*lB0RqsS$1ohT(NYn55tsWtSA1w{N%~1D6kcRr>b7w09KEHX(+wG`25nwyM zJxTi@A%*%710#rPh~FR_I(BTv_T>do?pwTJzRO-GZ*>uDL3^hdlEj5-xgV=r;xqv| z8Sm$oYQ-Ng2-1O_fK0xsn+X*O#9+8k9v)UD{D?Lm!+t@-c3Tz`v^3xfhKZ*eJTm*I zOvwjB_!Wf~bk(k3Ay5y|pv6bqZ%Z#n9b~b^BhisWK(0;Mu4zs^>xZgT{D`N8%ecL9 zsVg4hqlA8EdW7WtQelGK$c)iYUUd2(I)~U#PmI@+fHB|swHG~JL~HG;_*obL_}Hl% z1rg*+1B^a4NomT>)ZUt71+AYg9qr}woi@SHV;>f}icj0tyuFIm#fUhI7UD=0*fya~ zjXQ*b@;=gFhIW5RUzQ<+SK+m@ z0iYS(kN%n;QW1;MxnZi0J52XXH0Ap6#9*HB6OXQ*&n#F;dis91@`gm&)HJw2o25K= zF=|&5c1NwhI4cmA;WiLl^zHL<+5u5$*!~htucqEmLO>kNmx`BtaqvcrkK)MDNO#1_ zB82QcHdB{_J4%^ydVWjMv7HNGw}X^6yNBgd$Vgygk&@#*R&|63QSvg2;2Q1-vowLe zJr2;?WFjt=z?j-3qHEu~K_=F^_dau1yVEo{l8wYuUrIlCA+ZAu`a+4baO-oPq!m}} z3a~@?T?C!?|6=c*qBLE$w9zywZQHh;m9|xB+qP}ns z?HQvlzla#$#Tzl7>1S?eh*`z41)(Ts!Np>?iq%Xm$|$)693^4O79=Td&(x^jPw;MT z5oRk%`9CbkW;9*e2!Pb)tGh^}0MY5)J1??*v~3{0(UENx88j2x)(#jOo!zhaQKCj9zN#AR$;f0YL!)!TB{}>(O?c!nToNlY88yb`{ErVkpC?2M6;84-f}9pj3eY zA;ABNPC)?Rf8`aJ=ZD1u#?DTk5Db)NtJ8>_x}T4}qElag{I`qp&tfDfJU}pI7>lr{ zZ7T@xI6rcpnFgp$sU)CDxkSc8L#sRVa$qd$m{}f6a+B4SZbgW;cd_!lVDASivU2C^mXE zzG?9NJ(owj>gqCd$hYo85QM~uJxUoOu&Xs5^roHIo(X;_VA)p>!mR!5V#saRI}>UW z-xap-2@GZRdkrK^y-P*sM;aOsRWxIZpt3>FA~}WU9sAk7!vkb82q;C1WZL05`7W3O z-SraEE*0qW(%#&e86GV@ls1BA6-o|AYD+;EV3ld1g~QeX#gQZ9c^-B4FSst}xL!f{ z$QWz3GWZ{W_Mm*i#*F}?s}{7l^feANL^a=@zh_)Hi2b0)GoJdnJ7=jP`+W@s|9t8g zh|F|~UEP)7VAb>a~Rcj>Ci#V03whekCO2X2~sNGt~_bj2Q1>AWv zUSZDFMwkZ<3S8oSBac=t`y)Zg^PkhHNM3_?nz)#Lat5dQe~_rQGI-7BFq0c8QG%_8?)j|-;&6>tF( zto`qxzm1qhVO`SZ?e7y8qRvz(PmxktQ+eK+MlX8n`l!2k~nL<82O8>*5*NE1MUNjVOkVm96 z6vIT;mM)P{dM9Y3CH~OTCg&LR(SsET^HI=%64;CbphuCEqS)Xr{>NWX#Uo{=XN50q zW@%|;PxIaBYqpp*KDn^H{g(~>#YkXng#U+yK+nO*;VXk;@UQLv2jBBw&#ANEXBV9Q zrKRZ<8R87MoQWq=A+mE;Z7bHDA*gdrRP83aXKJ>2u`=If3U-k^4$*$|H=zafJsEg$ z(!T57@oRNY;JzE+qt<6jkm=<5p%&|#=LTgP1Oe%-2m$^~oQ;#V_G(M987FPmv=$u3 zT#ADQ-)&XS5K}32In`}Z$xxsBHkt#4@KmW3z$+(~57sfecIKBsYt3+DfO`tU$@>y1 zRO;P)(x1N@SG zj`2YWaB11cEi!L^p6dhxT>EwLi>Fq~NsJn@^LOP9^}atT-N207H^s&ezZxg^>^~S` zLgw&n4Fl2omdXw*GNnK$+A9!eR-OJL(gd$GgIdwO5(N4o>&Oa8hNOFu&N)lJr)Nh& ztERsKlB+9HU`xO#YzwY?cC=-}5K(7`^Onnc|759kJ9nRN9#(u+jIVox>I-OEeZX14 zdZi|A1g}W1&J}fe4XxP7ZjBRcF<4Fx`mUnU)8ev2RXH(4`LG z{PE9V4;e=DhUH}(g%0>%`~+XGqBt{?p z=lbgb9GnK=iDX`Lfuf!vPM;nnU98CTV3bUc*6aX!C-p_eNd4hVKt4fmr3wBI%riDL z76i?#K-Br|SADEpKQ*~h1P70^r~9mRb!+xxOL0Z52F|?vowZ44j`D4WUt#icy4vkJ z{V2s-_K;imu#@5KB8Jg z(wNbnrc|_$31MfcveEfk;&*XxZGeA|eTUqYJM8n3L$x~u3hp1RSI*KVBppgckh3Q4 zbxIIh`r8BAUT*oJl8%-`(8iEveZx`snow0F(-`;SC-?IGcLe2N2uTAINJYhDOxmc? z1owSWophl!S8lB&BAdH~1h^oxoi=Q`3K^bXYN(-uAOxtVGgQ`~$}tEDst-=NZJo{kI`B;mNy8IW50=LSRY)$*T%NPMk_sTq8m+!$DSnw_A4tQo}OATdtY@`csv-z;{^ z8-MbjdU6PgWyeZQh|CdI`5O?9s(u2&-K%?)7q=}dx1 z*xhuA#;c52DOz@gdY97;x$nc?Tqu1^{5MG|v$US0qp6V#zM`3d#n-e;az!%}YqPJI z&R@0OR$sdg|JwQQ8JoXf(TJ-*x_!R!oMfKbs2!we0{JsPndx{L>BN143dl~%i~IBe zUs1$fn$6Q=B#)P`o6G#G_!AKsz9bK5)a+69ZJ)6$Di|DqsVzn`S^*F zMu=AL>V>+1j~2t^WM;P0p#dX(QO!vs-8MF_cw02(-v%Yr7YE?G7!>oVmTInqo-mQS zOCH>)1~IviO7*}q>74MXQUVw9Zbq9jJ$4bZm_L{xct&=N1=)40%Kq-6oq<9?jb;F1aqh*1=@e;PuPPfiZ#n{%D7%)!!t&DO z8?G}vt8v2UVbp`OI8CpRM?b0Dq&v%qG}DJ)=&WsSHg^ORWVZSWl@}cXg{I}nmcRr< zLgRFAQ8q}Bo+DrAa#f{1MjDo(N26>kLfRU^e;|}uPJMwK!2Xae>8dmef0}3k5bvbV*5$|#cA=ce&Ii7{-pC8 zh9MG~sLGFXCg46*tQ(+dN8En7I^bo`IF+^ayd)p22iGP|5W)WbZm8tUpR+{v&>rWO z)PYS|e%+@o#1(JZVmulprn{ulQ2X$`Y!&WPip=UM)9*XSx5W6W$lFn^H!kQNT&3|} z5duXyzKy-Aln|~xX=?&|(gS*n!)A<$TM>b6NAMQwsZBrLdx}X*dP%}(VY19>%_$faI!7?e@c2$ubJSm9h7`L7 zq&i;iPH-!yRU^Jfl36 zP}hI5yZNFc%4*JdforD7k|H94jBz?q1wwt>y>d?h=<&ofz+lJz78ZaX)OILKAD^omfrtziNILkZG&_1#v($~n9N57c;EJLw5qeBXMX?GAxxV=c9L z$G1nav~><1ARlKax@>MVToAAR@ps+Jxe9tbAiclr>@fE7*y}6Pc#wq{iDp0~hcp)y z$KYBhCr`ORN9vEOIuz-<09DX%i#{8hA4_g_8xkTFKv0sN8LiMBq{%9JD|AjXro2d%=qYe#Lz6 z{u%l{u}R{{%)?V$6qZlti)y1rRIuDk;!I=O%&Hw4=xUFM&%pX(FN>-1eSzjD$DIE)r1SLQ-bg^n= zh(1PEpRFZCA!PDCS<__VuqH^^hs|yjX5@LvS62zpxQF#-P+qXOvzOqi9?IgCd|n8udRgKp|ns8ZQ4K-uhom`Cm-=f5nu4D<88# zxK9(Ro~`DG&XuDh45+mBnQ*`?{A#>x!cEnHJI^rRUbuqHlJt)4IT;LGwptAEZZl3L z>M@Y!TyI@$;un93r?pxsn%;dcS%+uYK)@j-d+{FlerwqcE= zC)f=mI7eq^#}fh*O!HIt!>Gt)U<|dl`xlsrfp82pT$)9&dDr!h7s{-s82XFq5hGaR5g>gPMl~*17W^he;rjmDtbN2{0tP{x!}rCehk*%oNOfM4 zV|+EW#-~d%(8w-8@~{R5&(W&#Y??TC#yy?gQ9ySntr?TnPIJ{w-RLGmeeFgt!UgwR}7->zj|isyr1F^Z3$LtlbebR5nYD1dyN?M zNjN$XAUTJtKA@jn)K{9(v z9G%NkO(~6b_Lkd1z@6w_lpjJ--a5dG$PRc3Y?OB$Kz*i*<+0(97Bwf#f~VsCuh2y| ztc>KVP5cA+^?%Xje=U~(PmAT>=z@R(_d($DHO(l>Kx#uoiOFAWb?hY zMB17qv?|rzi!Do*IHD$4%u8DuAOGjDgQdl%7j=P)AlJqAc%W(4eXpPe{B81VX}87U z;c;53i_plOVD@XNNc+KUbxx|+2S^sq<2<)Hh(c2@ZI`JRvJfln2Aex1Fv8feOa%}O9=?kY_OTPgd*jMju+p{vUz`b z&nCeJ9%$6oi`r`)=udi)o{*z{^g-e$vZV|cA+T<|Yoj#rdHFnK#JOL^YRJ--c=2r$ z<#OMBOtya#@`!wfa-KzD3K%;F3Ei$(CgDtsjaClo1Cp~uGR5h~^!kp|iJy!I0z7+w zbIi>1`=fyqEKdnPDmi}OT|?*??cH4md;JKb(`H~V)mzAcaVW5 z_|YAHzKx0@RF0@Yl*r{sDUqZBMuBMT$%6ty1I#l3eeP@tjjCC41@+>sV_{fo!e^Yf z-&_?ZxOv486b?E*Q~vIw$0cj_nw%9^!lUD^_ps{H$|#H)sT>PE%l)Z_Q3;pE!`1f< z@CO31g|1HLI*8GRhX>_o(rFQAY=a2*66WtK1-{=!jM_&G%1fPLQbI zZ3+mkmxW`v%t4K4ERLE^vX~+AC{m4?^0dye`2d4HF|i*KadV8&eNi{XC9TJto|UE6 zM1x+cw=V2Eb+I>ARzvmlpqzpLU!0iXZxsD}sWq+Cw*oSJ4-6DjiC~D-yx-p%?v8xv zJrdTratt&Yv{rHBuHwN9Oi-GETj-Pu~YL@AKm+mWY2*F_MbLkH}q zbX(cjf}qdCM?rfW*LyZENu4LO$)Jw_G~DCNlYn}CKtb4)?~C{P^ z%uV`5Wyr1XDF7WQq@h=!A8r@o2FZ_7+u0@a2op+E(k-4M@!w5Nh^R_AE6khDX`){0 zM(Q1ouC=RhcrAl-QUxWUu@`gtwevI_tBJ%{x#E@W`c`@qcZ?(o*}{0pAJYX6aa@kb zi7}$Cyr?LvQ3igIvlz6`fUfR9c{r`i0U1J{620N+b_vD6eAkN#*_pDjG8l`TO^R;^Sg~i@saNsJ;>_$bcvf$j%(38k(iL&sK>ewA zNFWr1UgUV6g~R4F4P%93rBDniRuE&>2}G1cn%Vch`Vm~v@9u`YD{eQ`qlZ=PE=UJ5 zD3|!lS+Ze3mq&_XS%!t0#rgwsjMIvRv_V7$Gb|1rU2HC|Q-Sv>%4pKC1*-E#Eyj8- zs{6c14&ko=17OpC%r~qdVkuLaxW!dye<@!XG%B-iqucm$3%+FU?|An=i*F>*0P%T? z7r%7Of(j=da;cK~EvJ#7#5)NGE~~s&I(g`br!;r-Hx7(Dlx_J3;tO~n1#V$-@pfWe z{0`q2X3KTiERdyO^i*o8bTr1DQwJ(?+H%SlwH`Gq6w$o7Nr#S2I%_D&nK`~$8GBH` zR=R=-g_7VX2-N$>W|HAZKHj%e71Z0Y1tL2w(bEQmBx=GQsU3)2nD`Gd9suX$LNVop zp**p2xW*!*y_`TeAaz^=8T;HBNidI2@HaQVGD}Zou^p-nB_z!50zqY3Ao3)eae{0N zvL7XuZ6wtxK-+||6nPH{W6@2lB}*lAO7=`Ar?P8sFEw4QfITOKoXX`k*6kw(-C( z-^|v%@Lw{{2$>X+Qk0DNU0)zPT`yO$50gv~RZDg^@G$++#!r@_KVNUu2K!NL)k4vSf!jWQ43NVS~iepD{$%MdbJo#||o%aZ-rYBy^ zVxW{C+E4$UO6v99QrJG$N?LQC3v#$=u1!}BlwZB2rs$ECm+gyqq zCoK6DgGt=`C>=sb-;1oa=18`W9KFjg{{>3~GDenPP=qh*pl4w5RS<9eub=!j|N8kK zy`6u5vWem)fu?v`9OXGM8y55^_+exWu*Wl=?x1XvTjkbUmU#`yIzC)AigoS7qHWGS zj}dAWNeUj-pO#9d6L&SZ*7*u1GTH#+*5QPG78hAg=F*zs6uQi3xGK+r74 z6qLg<5@NrE%|$>>q&<>|=hVEZN3s^}cIt87tt$^SWkoU9F)c-^EJk<7ij}Y=>l$c(?XUAE=9b?R-M(VV+Ft{DA1p;^u$*)KVks5fhd(z`NI1P`q zn=M(P_P7jOn(RC10=OMWCuqcnP^Q1+bPxr+Z#x22hlFBvmZl)Ep-wrv9;@GJ9gHWt@d<=njd~h^^_510?+b~1j_sDG<`|nyzA~t zn0%Bqhio-qyL>;%8_6MJna;zE6Yw%^Snm^$(cY{<1`YLa3@1V-S|MU#V){2axAVrt zH{aFLDFxwQ$E9_{r%<6*d>nP6@}NyzX9nUh2uAi>8-qJYbi|czh z&sLlm^O=^bW+?1~G86(k+$#dK=xB8Ts$JFpx-R~P{W?cCR$wf_o#ZT2aH@8d9@k2`PpP< z5LK@ChU$nROs^y=Tn1>t)Ng!x5kVK&r1k6(B1FhGt&jn9iY4iLdQ>-azV;w{4*AoJ zMy&4htPT&^JjaYo3P5lL(0%kVMRBFtR!i&NnAxj-3n0?VV3D3 z;v%e+YmRNa<3aF2g?3MH(Lt{|{zAxd4m*JTkvV=9q;RBGXmwB;tAwq2R;$>?eu}J( z{;3RUVNHg(t)*V$z?>6vTGM zmy;{B0KEfyY`$H(r~ruth#|#x{zp%g{KLS?Z^8R*0i7l+$~urWqIAH@qc@4qT`NY= zg}!cH${wAq4ep9lU%;$iSVTN*;|TR+)8Kc*-oHB@`yTNNZbFrYh`x(Rx<>;Pa!6+^ zp6{LW<<#Lkg<(DHK-y5exS?H~>vA9WCg@iM#;xhyrXwO{{}gw>WYl>17;e$_xt3)DcY^||#F4TmU|V&q_gUM(3T#mpsYsit zb5pPL_(#{(LWm*2>KtBqb+L;Qs$c-0i~?A@G^|Kn;elpkO-1Y4sFp$>90l!0Jn;aE zf+3<8Kbq8W4eq5ncB=09sq#zOhQYJ9DkvpO<~yq{DGp2%_Kr?kRWyxmxyx)3Kh@(* zrE$HKC%0jD&~9rb_L7W(KmI9P|4hLA26q63qT=sW(;XH|=up`6g3qyGXfBl}3)_c? zKDB(m7Fk6OO~6sGN5vsJX4|$ga#ni5IYp!_nzm+u=K=YL{s3>HdJvL>{sugMqpIgj^OQ;Dw#RTUBGjsuXnKq``mu@7tJFUoP<8Qy!eO5oAWjPI=v>vcjE+Ol>&2gV@zE|6HZVm9a zU~?-mq43KjjV-`%gX=RNPFIL66eW8!FPA(FAIQq87KOv!bjZM6dvAih9-trbg~GU#weZ4hCP7 z-v#Wg^~~J=5E=j3r~RTg{B&t7Hqq6 zFgn{TKGZl?z++!E!}+W2mF*o5mU`~(QxKPU^Lo`T&1<`pZG5VF)pMy9EzFV%-CnV$ zEmtNFNKi@^B;}J07=KPK8C(5a1Pum0Q_c8?u!K)uFJM|ZrHF`^s&W;fA_fk7^mI`l zx+Gc#$3mo@2(WhNxqLd8l%*ZRy2m8tISvj!BA(Jw_^3SK)BV z?N5h(ueID4%Yh7q3C{+a*y$y5ipTnd((fx4i0{rxWsUBZvx|sUlrT2HU0kn=h;oUz zu&2<-HHA%(GgZ6*A1|4sZ@(0l6>GOonoDdeOecCXF7KV5N)LGVLR+tAF#xi24aYUr zaHd5;VT58lOx?u^E;l5B>Bs$ze~s%+>v4;S`C(ARfZ)u%`QRVs;)QogfhMbtrFPbv znxxNraDP8^QKJnX&|p&iy>y!oqK?Q}soN z@dZHtGMb>ofBmc9>7T8@TzG)=$rWdN&(`_a3%`oxYS~CmC5o4jN$EO~99`NxO=EcY%r6nX2&wRl<+o99UXVXC zjKp0|rOl9xu7?c;<)lcRgKO|&-ouBfNywKq0om74CwJbJBSuYyCL!$A#fRUQR&uygFV#bpJ zI;5;YyaFdq?Kd_RzxVT_EnR%Wzpc(n2laBiIjvfdmew=6!vFL<&A6Hbpfy?ptP!s& zu;cxVVH&#~ux{)8qoE8cp*X)ZRC}O747K`JCr~|Py10!adimgQP7s&mdfi>|G2NEoh` zEKpw0K3FvvT#K6@wH23u&m{2$YLj??Ph3^LC$HDSj5ST7-ePvf#?X5%w#0qr2OKlAwdzR6;QnI~6FnM>ji07%} z$rcYsmRhGc;^Vg;7#0!s*5LN~%TYB0a#a+fXF#|+T(Gemt`KMhsv3jMPx6*SqvZk?h(zi5oF#ReP;{S{D<1hF1-%n>w zewOHB{V96l8UC=xaq-C5-faSs5-D;GbCG9va06`p`+`o_!NMexh@dKvWMkT|Zd5b_ zz+QNIHzULL?7;EI#(h8c?|ezYN)5m8M}i|?P})tFjI!TlF251no5YzY@3}E@(A3>|CkwQr%0aujZZ4H6)d%CzVP(o0++7z#~Q}de;)Lg4~nv*Zkm$ z+${=$qv8sm^?pMft+}s}d3RE{~a^&$=ab^I8nIsg* z1EBJ2029MG+j9h+p%lnN0P%ZKj@W#S#=1iXFifY#`lv|y0H}wpkZSK<2m-}*T!iFzk%U5&AfHK=jKwex1A{utEJh-~xL--Pbfl zV~X=I&H$&ziR&$IOfyJ5gjcRKB>S_)RHZgQLUvQsJ37`K3B&j)>XOf-jg)T6f4KwyX_h0_ zin}?Aj4S*l)ClA5T>#JsxHiw%e1R{Z`P)nQXAuJk9-xp(iD63gB7^ksx)ZHa&=9HV zp=_d!6ov1FGuJ7D*rQF^An{@J6Zz+|t)DyIVy2nSK^;88fCa6VCEX7PxT~cR7F+9q zLn?;JEO?`1VcgVF&Wh`m*ftX__5B{B%I}&rq$jdtB~*zQg?XOoFm?;k5vP(=gyJ33 z923Uqt}vNf03UBj8l}pv#jEK%D_A|tzbOb~SiSC5to%#~H1LQ$EF4FrW6yYFz8H?* z_D=+BsXyi8q&PpmXFhN{9>rXeW;Z&WdNAgxGP*l8;txD~6TnY-(?yIDdu#;Z|F{)} zdH0RmnNA;#$1q90gg@6%BkVy^W)B@G-MtO&M|mk4&dlmSv$hsQBjeab!dF4K_>6w% zZ84Q-ioq$-fXLX?w{=SX1HwZmHEBsvK>{$RSv^l2>xpF|mq4ANX5h~86bUvbI3E-GM8Wib$cr$gU4Sr=u9Rd4(ie`X|bmsdDkFC&=E5r|=Ytbgtt~x#DIXL_e8ZC48?J=DU zA4Zp4;H*-_UKOp1_9`(RSuk6lhW#Ge^wH)&85Nybox87$%G}SB@BC$0@(2v-g1)rX zoTE$=149)U&#FHi=9-RutL^Q9P80=w3_Q|%w4FSeuK=D$-%>4047%AMlk!_yr(6w7n^fhuHHiIBv>_3`=^dzvRjz{vV0h$ zk2rw8VJYfswe=Fo7Aog-TuOF;a1p`ZnquJ0-zR`2F!-V7>wR$z9ziDyqgOSsZ%X+v+76 zw2x{i^9GC`x!Pof&;O1AAbSgttMXgSV~SpI>agVI>A=p_pm%ev1=oBLG94>Owdgy7 zBt91OA!aV~ky709k?o9-<=W`#Z3lrMtZ>vKIP-EkHKsKhoRHnd)HkNg)G*LCeNOAJ zI$jpTWN{R26Pe-5_fYGtwZFqN9si7c`P0?b5eq%{o}LwJJzf~G=TD^$^o=>|3zFpr zYQLBe1joew)M@^+&N&J7>5k$RBWiuUeA~Zq8~~0g+1Ju)scfM*?h{u9W zRh8x6MI_?<;V8zf#5fpdasSBW#8`K)$nb`noS6swVt ztTi!~QumAyNxdW8ey-~i!UCCLIk9s?vhpnd-qyg8d!+il0J2i0eCsw1v z1S(2JUO5<~OlK4W{@&Eo_uqst8J}`kP;8!p$NAA#hw2GYp0mc_=3ZuHY^8UR$+q$x zArR*d;s=P(vVGr79UH@lNdpBAwUSFlWSwiS`^#>VqJQ^EFzeG3i*?vm*K#(n<#80< z(f!J4!h@qqSPYj(Y>ef>&y5W-ZR%L5_Ca0RpFn z`gaQ|j1>86VDbJ>XQiUHRqscMIt{w(%+msxN4ajm-7=~LrhB{Z5rJ(wNei~7BwVX|*}H)YzA2cAeLt>xj?ty6B~Qqp07e_!AKcz1t<4G0S# z6!M=I>VK|Jw-@R+n(r&02ET`M5HJ+`Aj7&*DY}AUo$2|?Lj@g@;^1l9#Y$B<`3G17 z=0=X-4rkkAgvjfL^+vfEoNRW^Lx07PR8b^&nA|rkrAn0+*?Rb)zQQWI7haTJe{imY zs5~LPL@KY{EqIKCz;F9;hnvk)rPaX%Q;2vduAEn1ds1v-*wL{;Ow5i7`YmQL_59kY zr$4*QZ5h9(nH_+EH)^tIkVMm83OY0#Fr7~AL(rF;1wL@?-?QEBbc8l%4405?%^l`x zab?%%&q@K$2umF}vbe~?JR5db2Yp5#7yw9pR;ar&ClgUt+ zy{}&s*vpR1%Zot7k7_`HKY{j@VZyIU%|h<52({!E8qcb0)bmgvg&vg>`WL;8Vy@6# zse8uthfcv0j(Kkq$VPXP)thwJ5VUsp_tZ11Z5j!!W*ywk*}agr4u7*wH1it@<>7VR z^;fWcJ(3_hY6U5fx4}4DB)S%q-{NnMGqJ7o+&_i=Luol6*)%0dtu92tU^d`8rH0j0 zRG>XW_px)O#@MyM@a%)+iak_lvXNLKaQuCSvEMTD2M~W$Jb@6NB`UJ_Oz{k@OUZ%q zbmO$SXP%Gt$Q*Fk&{eh!nnQBETZ;$%?vLu$#O$snm+naox&~$@or$7DBLy6=mz+(J zi)fUvDudxtW@a!(LGUQL&mY97YkYe=KU1Q+#)X*i)szYWUv$zJU9`^FxqMxh8}SQd z5wV2XlF!DOF8_PdII#UcXbAK_O4Jt`X8%FMaY(?Pp8G$uUcUk0e4Rd8cX}s&(wWsw`h%MPtQ0yy1N1Ttz0Wv2VlQIXR}f9207G;bxv1(F{lro7 zA|bK&4z~iX>Wocc4rYBng06dZ`n=#2+{uw5u?5E!M+__@4dTg+;EQ@&^)+pl-A~Fg zW03%-7xfJj7D8t7TXSp0rX+lSF4$K@0h=&&vUUj}E7ve7gD-i)fT7r7h6}RYNjPz> zZG#?J5fE=Wi3NUss3UD;4Fl zmR17$zNfmDF=o6omg*Ic0y&vnCy8NmsiiK{Sq|((&i)oO}fqjt@q8Y&@t2T9^Aim*ajao zfUnuhQuBK_FSL0-ReBeKOp@QaSws7kRjs*;63RaKQy1KxHCD__&Y<8D53YP zhk#E0_}A1dl_TokDzeDfQ6!rji;pd95qw)&h%lRdVxyI-nnmC%pc42&?H_2jly!X? z-Tc3k*@$$}4x&rZHw0AkMcQ~KdP@7hF=O@_sxpX!Z0SR8gYXsZHZUdmBeasx&K6CU zEFcmRd3DNxkWK3r-oEUoBbNA7pFqi~{2es(EX1R_eX~QH5v7f4g>7@_x1g+`2GJ;{JvE| zeae59_&>bT63-8L9v=ahugRS&WGdz{7+o7hb#TDrDb+UXE7G+?zyv&Iw83UPI$nvM zdwsrIrS2fDG7`R&fz=+D6P){KRt@Bg(Qa*qh4wW$g7*wyY674KA>8|DoKR-N|H1~6 z!(_vNiCkGJFzWP>r*jrb&%hFO1IBV~o$pj;Ul@~JU=7^n^C$;%Y-PG>@_O6z8W zsBOMt-_c7}|CD6Ts76>;tHIdvj?yyzeP3=il^Seo+Lia+EMRU*I;Moc4ru8hnWoY{fzEVQ$IQ3E8Ns@ zdECff&eP0%d_^>Mc?@72!&=Nez`r|SSRF+9)}_K0f5g8W3;SKsQ04kzMlJ!m#$7#^ zE9hCiPGusen9-QmNjwk$ukHp`iNrp7yzMoAJgmfj_oM=iMF4?ZDiDCltBy9q0qhq( z4)}rPVEfKo0&P&+OM%I@j!7w@=k?!~hxwP~F}SdCCLa1JY8mSSEvqL&g=OkYsMWqA zmXCaob60^^=2s%hPU9!t;1_=;%o4u&J;SP=B1+qvlp9z|zj)%YF4%|XVOmi4LTo%I zB_I__ca&4>qK+A2_-5rUSaL(o)A>1{-ak?iU5w30Ab8RsiOIHE;bKO0KYN?uj9kDD zrua=t^i5$i`Ur|N|CbX-f2rDc`Y|3xNe2}j-Sb&$f%8Vc$7!j2k`iTN&m-SlD}0C0 zWUvZ-DHkq|fzWH96!RnW)pm)%+$&$ECj_5_#)RWS@%Hw7se$UcM+ZcTLyHe+OGsQ!f+5HxTpnI)Wn z+@1uT>F%Ggf!{~8qwo@i7Kq`+xm48V2l?G+L~&cPv6ozfFyH{5RY1osVzP~%DdcKN zL^(w8M#ya??&uO-LJlJmqMBpjosc`vx;&7SHRl7zpkMVEV^&`+m_C(_tyvu0O#Ztc z2K_(c;Fsl*^e@YU>OcEoyW>zFTq|--xYJp|@!Q74NBv+)gq+UrT8TAN?8M)u*NCx2 zXDT3YdAYZ$;);(BgK93&dcy}xtkG>*^V2Rk^){i~slQ+BI~uXp4SZk$qVqB4t})MX zV!mk}ds7*my7R(-Bxmp-M>fT zovT6U^5av%sGKP?S7XV4M-PW^0cff2)z>)u2DUFkPco0>zTY#^7Q|?3WZmlT_TfB{ zx%%EDU{+%+4*utGqt%Aypl?0N0PfUBbH- zCmVeNzS%_}O#8_Fn8Zhkz3D)aZ1U1|2Xf#$P(8l(K#w~2ATc0)5b*$S_$+2JTeb!} z>^KfIkfry0JOT~Jbj_a4Qh@Tn!6nwcUy0%hDE&RPoUFADaui4#@&CpT(>4EBg6+Ti zVQ)8I2H}1CRi&%GNa=d-7WXWxRo-iGr)-o>TeR5SeCZ#f)tJjRRGvtCO z=S~bG@P3=4^#)=^!p>HIUI<(S7F?zY|*m#?J;dO-G8Xu`zmfW-h6L6IfQ=bo15# zQ7BlkSUM0g5@O1qpU4f$9xgr0eH_Ywi=U7 zm4oLZu7u%$m9l!iIYyTcO%}!C+W&fVvx7x%4(ms(9YhVo%vzUNnwFey#@g%`Z*+1V z(=3Eu>I)p1JyM5)s)Q@AO{zAjnQwJ$CX*qb?pPU|3*p(KM zjKQ#Bc9PUyRo{@L%{7SD+esRc!b%4cI4@+z3Mz~Hl4sCQ0Am&T=AG!I!uez56L?c* z(J6iTA=ttz1F(VO_I3_zX*7O{n*5qVhF^i%XN;yG`{20lgbmdnTSoUl#sQP#In)MK z;({OMaTkT#Q=*E#(QS<+&@?r^opSduB5XSvHqw+=@*y0-rs$IE!-%YR435*7QX2sP zpR#Md(KS@bgJrzqqzf^mhNnPXsQ<a^IA!CqU^ zgd|Lg-2DZ!hY5`4mf&6~G4YAwQ|L zB#cCNt111M`kVZ*DMTfSm5E4nnh>g;4c@WI9q8nP@a$R3_?)X#Y%!`NWnqzU%l;2z zZy6QW)B?^o}xHQ1wB zRl9c8s;W6-VweU(X8+)$kO6xiOudM;E&sw3{LSO+<^B8mzdNn|rL^iWj}ypDngJGh z!S+xs$k#F|rk4ze3q2-^2+d)0i=Bhid1X0pP3=P7x1eOP>H)<(UtEUPX{|N1*innv z)6-N`%|+UnwYuOpumHE4p_y7r z;(S=rAxQQlNZXaoV0rRc4pA4^_TWDIYmEp1=ZrkLy{qbaQBm}!(_9@(EPoe29k`FI zFOBB(c!z7uZwAzjo+4@8h!{4CVGJZtbb?jB6<6a2GgdFLdB|Z>&Y{iqH|Y6T#r#aF zu5e9Y9*XA!6HYVmWQ_D)?Xh~{$s}EO+Ec-C1npD@CiBtvvJf76m%K7U$d0;oGmMSp z`fyB*INyXJl_@3^Qrw!Xv{>3-*16?_ACAGv2l0yYCpS!1(|Y3*e*~IB%RDt9+&7+> zR?Lql`RpgHk8@@ZlNTzKc9qfOCoVZrW^C6lPD&&o8Nwf{o?2OCvA8L#m~6+tkEFrh zYAt}8tg)tYT{QpqD-8JlV$g9JxtKci9r#u1Gu2PQp+eFz!f%Z^jv`j`PoLRzo(H;rR@*jOVSSgC>wHuAHP*Me zZKP&|{R>teEX2VCg8ueAe{t|({Xz$NUHxg?+_DgkL(LkDxALA^=4q5dHXVvO!<*?I zHc}l*F)S@dxD&>->wvD(o4DK%pKW)C>ytr56Fs}sa!yO`VrKFn3cE5rGm9~6!?4o+ zNgaQU`Eu!pgrZ^1dh4X@yp*xDzuM4Fq#=Ms{@sMn0pf%&Idm1ZZ_$ca**=y%tBz!V zb>f6LUVH^TjgJWldL#5X=;TXe+m~iZC}_Q(W4OzW(&gjR^Hq&bX4VSpXg4xBEXd-K zl}h!K6DOu;A1F@7op`elisB=g_$$kCtmvpHJL5zJ$>Z^hVPcpup1%;=SJP+ZTXor$ z#1cqXTt}%V1;IwBK)_@3+&}@K+WATiuFi9*zDC+6xQ9R$albW^QM*cLqINbBj82#T zjOL{8S8cs@Jkc;?=tZ!uess6(*^0pj_YnznXB4iT3*8W8A zNmF6E|Bdd88`2^OX}zJ#FV(n@G&5Yx$x{9rJL#G{ygIT%xvT2vSC8+v?x1sQpB@K` zwQ&x#T%pMOd%L`&TIy(3U`M;$%65Fj^GIa>b#D}5y>9(t7a+Qj`^fE}- znF4mb5Z{igS@|Go6Tt!ICmQNO^4>IQnQ(aUI{H$Kdj)07d!hieHQvhr*pmo8p; zFVr}mKgxx}*}7R!5cls)m1rBb${pC;i2Bw~UykX`@%W-4_=aQ5f{PRn+Rp7!s@o^X zmcEu4e7nN>lR-;QFs6Y<3_}^#67eJi7m^0uv__IQ)AAW|$XSPz$L|X-`Kb4yn}P(_ zeS~2?4%vP^Qo^R{4bk>en83GX%n9DgGvDtdo+VFpDF$bkXj&4>t1O?WA;_~*_}6lF z<5yur04XwxP+uSOW*pw_X$|e$&e2hnq`JvZB=f;(zOSiCfORAhHR!G`~v+!^0VJvZj2k*gL@9X)o{`{(V3>w3&cf-Jl7t7Cafvdhf+s35x%wL zt8vjH&0$LbbZL``-DqN+UzUhb>c9XJwqVpvp{uhg8*y--#+|x&hJUe7&*^YtJQX$L zwBzxngv6SZcJW5W;dP=CBj)Ni{}1O4dg+Y9z1hCZoCUFrn0RaGaHpdq6Vc?QsyI@7@6gR+LUeqm#{WqEaY5nh;`9S0AGtImnv zkjvVyV_Xo`y&+72NR_` zB>7icWJBscH4>9>#KXu7pKDz)&SYmEZuhMhwO`&p5OX^CAkR{1P!|svR~QXyMYHm#*5z${?IAFCAmu^((- zG{?2wTv3I%-|XOn`|*)vWUfaiX>w`)3A=bN-WC%B70bc$nh38%xNQS^gwj*L6+*>A zQxA@=$>08%P}S1G&d7yW*vQtFnAg=9`0?N2@W1wJPJtxijdW6)YA>2wtZoRJuXvf3 zRGI{QBn}6U`6s^OSJ-J7XeAyIF{(Qr zM=9cZZ;W+~8$>pl3gvD=oW`xm1r-LQ$ovyZ`>|9EQfP5eSvfC?_wJ`hYL#O*VzBeQ zJYiCF6xIMfbB{lDzYsrcx#Tk)aZd&zeoj5?;J$oej*atdWSP#@!D3-C>|`VudV zu<6sJ7AyoO)uy=?TYk1F4bA=_7Nit3%!WQG{u7S=dr;^EkM95rZS0gGe3Ifki7ji% zZdV*w)&^SFe}$v}EV0o;y(?Z2n??ZHA}0-)1oy-pVp7C}dpyxy~bQN%7_j;g5B%QQFz_Z6Sou zr8sfw?YlJRaQN~0+svZbI~y;KU+BYon^2>Gp=&HMW+`+hC7-yEOzmx={m(nAo~;3)fopJV*(k94g3xaJ;C1BDM3{RNT9n_&E>tzL%PX@<-P z7Gw}$r)`g!fYa43g|FhaMY%qR72-b0@~76Ic~d_|DvpA{!0)y~grf+lykwwZuvYKR zS|OChwWk^ub#5%9CK`T+g9aHxG{A5$4eayz6@A56`lX>@8?5P0j)>y%wvepbF~+1W zY4P2Z(sy6fCmHBw`kdn~4?nMjb&qkF?~I$by8IP`w@$&!ms`RyV?EWw@Nv6W1)?I* zBy)!C_^{8EXW^N-Y1MF?0O}|ifkC6BT<$NTu*q{`Q!5AXobt|Y1ansEZ}h~K%j9)D zE-bt^^%TpT+IH723dGLn`aJFyp@@jvmB%%Q6(Ru-^kj8s!hre6Tp!T!}u z6~th90;;LTfnvL@hP^e%8AjOJ5$9AMfRe$JHMY4asF0+UOi&mD;0%)GDX$#Cr-VGV zX9cx}i#Ewv1V1t#-JEKuC!Gc!-?7<;rH5+N z&_Zx6!``f7?@38YDuunEKl?JB1zmrPO&;1+Fex3rvb3Uo7-6D8R~#QNKFZA{be0Pu z5N6u1M~J=0U&lOD_3}|v2sUTDdKGNC=l$9hquxCPXbVvZ&8e-ht%SBJTAx;t$w{_c zuVEAnDDADAUfb$HQbn`35NBDkZD|yI=GUm0+<^9;jG=ob#jr)^O2!n zcjt>I#Z7`f(koe6lKoqVkGr+^`;ZzG-jB|X(<>j1DZnQu5yFf_2pFF|hM>;(lW5Um zAFm1Nz=PLtG8CAtsk;w3V=mb>f{P_NW|3Q=cce9PHQbOhnq!g^X8u?A)=N=6oZDLh z^$JZ|0h=q6>JDzPmQGpygrDyFcIJ*^b0Ra^sZ`J*T*!49uOWNeb?zWf_(I-&3Cjtd zC{(5DphfY~4C8;qUa@O8uAn#!uSEv znE`iUWn0H@A0-W*;x%?UJFk(W#ZG8m{VOBSRU(6vcVC#de z2ev6U&BweOGWAxguTI&HYcQA)_}rj^=^wvP;6q$StY?NOQ-7;x-?hM+3zxCwlm^A7I`r=(v{JBnqV_K{1ztdj7!KO$IY%b$~h z|7iMz!*e=B8=wH=!CV@?oTFNLXKuy-R>^^$=11eTvsi(Ap@CcBM-Z#cy!W~9gOzc9gYtFxkD5d7piXh(WLOyAV#D59A zG|*xSkg32ZG$R?WSPC67%B&qV{NRW2^^N+#v3L^x(-QrJwN=k3b)^aPuw!O)nt~RN zypHDbI)ue=pv)rLz_B@#+!&pNa8R56r)OPu#f%G-2qaV(`N}|s%!2zZOHow|Uj9T; zvvmSg&Du60sIv@cRh*ZVl%_#12^WhEl=TC;`H=i`vmoV$AB8QGIhWhu%c`DfUvUP2q);d z6Poy@LP2M)qyKwnUbZKb`1$5x@Y79XR&(ZvkwFv$-ZgA)?25k~MC!z?fh0oV?3?dT z+HS<3raYsN06zk4eHt?6(_I=dE5heH|L$Rkq;+UGGFHSZjKYnTFHE=zWfC;xRw&&R ztiYj47bF#Ck?!rDCbwMsy$VgOGET0LiUt)xIS4Nyrl(^rF znEl&R#yW?Niws~FBGVK6+{!!+6TrzRwp zK>_2pbp0$g-Q>kQOIw{-S8?0bxTRS7Zue;=WF^(Nbk7Z>M}NnFlwzi)Zp3oHsZ@JY zGvFkc8SpEE-Jh@jnT7v*&R@GxaO~e#)AK%$!EvIbd4T{93M!GM!LLfwK&k_}GTga{Y#y z1pDUPBGo@u5M3g7FLDzmTv>wA_0EZ4 zjG>&36$9WE6F?GJ@KWIfSw^8kLD%e}NGv4_i>f^Q$=w=LFUJL_^Y=L%8LO&rEO$m& z_y)YtsmL!5v(1rBcLr3d9Jk{t3y*U}Il0El;N8)bUB=IkzP<(8_bhK^ERH$i8^iGc zePx%RbAuM{08PYH{4{ScWz_O4xM|O{ZAokEsVRza)wpq_kj12LGiFK}!bPYJ`48W0 zuoj1fZ&Gm|VF?g}ZUzK}n?|*}I9B_7FEvXU;Tdjk@m>KSY(K&((l%K1!3A@bns_6|}OF1czFs-g93N zt716O$RA*pMwd~w($_@GD+30Crs=k@8@@v4HpnX6Nz^RSf<)Brq=dIDh_arDLUtpu zmvH3O0UDGi?K}dl8V^yk%dyXpf~r%@HI7G0PTc+H1;1KYe`dIA;q>xp7Ctn(M#2u< z!5O3mjFdjcG+ABYKWuQ7XVem>2|lZmA+869C#yQAr{qC^OsB0wnax?rQO!X_f7Io~ z-S#okpy6)u@@hB!6EksO=q~H5AS31+!sU_MnLA?bi6I zikWS}n^CR|@v*Y3$^bP`C8#p9JG%V3+geUu)e7cj?Z8J6>gDfqnW=|gD)im_ZY#mwOr^H> zu0rf1S|W7Nbn{$(spjIC&)q+dg|wb`<{n(BdYaq2i0GijAInSlQ(4z0Nfor{AId8s zwa}V{s)uqB6w@+x&XZ_DhYv&gban6Uxv^W$=Wog` za{*Z7Au`s8mr-YC%S$Q?7`w~`<2g@^X@e`HqA;SBdhg+J#mDMq%Ozh$kmSE)!(jI> z6nD%MP`8~}9cuaPe72g(y1;O7+u2H$st--J4p{%l;_roXBKNh|bEqSA99PY6sXPm} zdDi#c?9DvHiyuM4kj*)YV!6wDStb=wF3n@jUDVp{N}<8WyiQ3fUW%l>CIxf~2+2ye z8PEkfKM%Ni-|Yv-w@$iKotjk(&3^?5GjlFUeWJRqu?NK-RVw9vzMduR0rL0MuSs7o znU<)g&cV_oQ#PHb(vsszy^@m)*NzrmEk~2?=*}QnLLd}WfJtbGE?7InpbDg#l^G|DKt?BzO_@YFxp%(#J01Uz7!ZMd{vP0I zrbLkt7j-jh2<>^O4IKRWZ7qKs^FKm&9ArQ)qTwr1)K`iy{zx20%TF|(dF|p!=WF^h z>3x$MY#oa*VAoCqft{eErFMB;LZGa8rCS{R+Iv^j4uAe%uP+cjE5rmLZtGssWJ=$*q4WA@RcpT7lBZqlW_%Qi z+#zERoVS>MTGJd4kks{t5lM^E8wQ!FwwT7aDSMVGM#B#pI%@lwSB)=z z!U8DJla5@8UtFdN{0r|MNZFJHi9VNO)#Mna(|C|8$$oBU#olv)M7k4)-oEraruRS< zJIr&|l)lNw5gq!a2_ASs0%HOPgimcvy)`RQYcpK@&_NbV;#2>e9ppEh&eRp|U$aN0b{Ul-`^{a2PA6_rL^ zdSZ81U_lyK$HEk+_3xFewZH<}NHL+*zD>upN3w}jZQXyKw+Yg)asmCZCT5owghZu3 z!%%zg0w}2I(U7p$gBo0LOG;@qJtJ@Hec=4aAuKI+)%T7;ZH{KvrP;R+1{jX zXaSjh`%F)x0D2{;Em(zdnVtQ;dmHu_Hg-i0kT<{blAY#t1pKq1crG8pYS5CVA)WUF#GBQ)5P^3o$HOZV3qzKS`_%w~!1_v-olLt&qRU z2?YkxoSJpz1+nA0N*VR3h=5RE&@(d#mZ#D+kxTyuR0Edii6zZ|Eb%}nBkMl`LCe1c z48V5>e>*V9_^nGIx9{ADD|z0MsUbfBKsxJ)yj zd?!W2Gc@~}YoG)uYi8nuVR~}l37rFZjh>IPnwOLB;jHC7(GNoUT5tvWKXw{PL`cUz zSw*q1p!9VumIlyjA!p0BDN9x-LNP21Ni!bDs-|{TO(_#G5DSL+QziIJ9bg%?@lT0~jd_JU0ia;@--wD^JTBt|3lQZ>o z_BM~Q`8E=iv2XwYgMfNhVR=e*H6P=Ys>B;5xx?5%1gw90@$i|h4a>ePs^98&UTRB@ z3ih#|iyBh!q2P933={MCQknVE68%Jb2O(9wH8*@#xr&8c%$xMA{)M-WCmLRVp)xFQO2C<6-#5%~LGDA`= zVyrxJDDHXFk8Cpf5sOdGsUztM*>_jCy^*MbZHbm}>L1_JhT_mPuMk9wF`O}k&?XmOT5uvO6yU%T>K0}+M^cD$v~F@fpI(54 zBnKKe`XDgUC#t{QE1k`iuGb!b zeF7AOt3)WvQDd=cLau+)zsdW`FDBIfJ5^NRWB3eA6?@^D&tWcg%h#c>g?SRrmrVsI)3Jth0t()x2MJ(*;-U&S=Gtm6{VbNj2|P&)0f?bx4GQN$963*zeFXbI$TP;_v&a<&0- z2|50C@xOJ0KO5H`Vj(NnvUlg$iJ-!JJmcol_pyFAs+P~Tb!`+}%4gSdvT6)YGitc! z={p+`(HMsQTqC|Yr--`%aUwaMBO0I80iJFa^OYzekIr$Z&up^=CmQr}eI!^|DS*CI zB?f0?q@2M`)^72hQA+E~YV?RPj57TebrXs8kzd28cv*S{5+%%90TBW*Hq0;*VlpGR z&*(vd7-`WhWJs2tyfc8nAunn2lo5N}!o&NAmSm(|22ZMkPuTr5`arE)qX{_8@M)Vm zC;{*7FkkIUc_;sV)t(;5k0D42wc0W%_j^)wth}EXgqz1{?)D8ZXD*oPUk>v3daf%oSiy}BRBkX~{vyy@kwE&*pNHN2CL~v3 z8V_L@zlc7|VMUzpXimx{psqe)j7)My8r4K0?ED*COU2U2+#G0;yvD#>!pzzDx9~sB z5y;N>`{w_{&i6Q-JR;-*JtTzvS_!AY z3Sj%uNmBvB#*0|EtX0VTTVEd4W<~)SkOT>MU!XewJqq{FQn(TbU>`+touHhA8kv6L zl5m^5PbY#eOA_7hW1yO^AaO8-3*g-n^kdeBwnk&d=Nh@SoJn$RZKh+%@6~WTPL<0O zIgjwaJ&-143KGx*rM40r(tF_MzFam9Ia=#i(j!5u_IE!$KMq;wNV*M(em|_|Xt##o z(b|RQ$E%h>6}LpVJe|*tfd_kS4F`M_;oIg;Q#M>se?X%NpZTu+ktOBz_}w+&JzAR* z#7_@x-IFrXVBO~{7)lW+*XMPa?>q~}Sm>&W2k?L~VaVLjHlMl?2}%|Pn!EWol(*-3 zxGsaNojFOQAMbq9-Kyuc zP8y@fJ#3z8hbg}B%v@_Yx!1FgvOkhej*5Ong`59+8LhRbrDIt!G}Fy#HMoiKQJ^11 z87t?s+C)d*`tMWUCNfDgXLmDT=IG{XW(SN2ERFxZ`Y-O7e{WiUS|#|C)6lz!%9pa> z1Z;7O=Md8X35)4XinzEHE)VZA5tXF%Uv$(I4ueOV_pOnEMBTLgW-a&REqo(hG1pA? zPF9D5n)S%9;-NCN8(fm5c%Xgl{2g<4ZX?)UrR75>YHDZc4GH0tM{qdxvZ^%U)#xl>bi z$AMHn%Js)xu|a9dsA#tp?tOyFjV9BnsdH&R?lz>89_?4CQPCj0CY#AgR1(UQ7GH=5 zy|XrOA}W5Ms4ZJUXMWy9U^ZNXt~{HZln#2N$nK26!kSq85AOpDfPn!0ZA*W=4+y!J zxEx5Ibz(BqGiU)V17%P1IjnA*Al9&Hzu)k9am*`My?(N(YPcZwUFnWkNaG;nnX0Pr zyb@hqlb=IMj!AQ~EE@<_H=-1#M?8GzFJzwN!IvRej|>KWjM)|Z{?{Dady-}{94imw zTy}Px$JlSg&Q1rF!$kg#KN`@`n{wB4JE0Aa`$3wcQrCIJl#o>@@&hH-v3@Z76u*B_ z%^U(Bt5rto-tw}C!hj!SS`pMJdl*gg7ZYm1Q}JYIoF3H!%f~zwfI*!yG=T zVf9k;<-_lTDn-4jDBwZWxyAqqA_G>>l%*leydL};vqQE@cGfU_f}`%jAZ88_$*A|( z#4SZEjgh9&Pom+6Ql@3jj9jD5q83-~1>;4ny32q#$=oTT8V< zXf40Fmop;{Y*MR*l6C}e-ErzUi2eOh{!@SJ0g>9WX+ZrJ81sk4gvBn(XJ1s~2hymK znz62f-5q_!=G7A<&TC)spG~t2(NcW95Uh8rPymz?wvI!Gbj=e}kh}n^%E5E1T2e!~ zlhTDsiYW%MU8G<+yT(40Q5o~;Sg?8W;)u%GxXKhO1y)r3%{s+9-2Nz`9yAM~7503p zTKTaAL}S?5+~<&ex3nziT4yJ37i4?bzB zBVHlN=wkG*>$MH{)sS7e*UY8I*(IKfB`hZp7Sy?IX2U;(JG&7Pi+d`)_l%+uBMUj{ z#Pe#r^r;2F{(545=M;bJp>A3|JuzNe{D2ohH2NL@i%)V|?*Si8tN61639rKKkT*y% z3|ju13YrqZtAy2ER5f+-LVEhkE7oF*EVDR}^Dpj==qwg$lc-G4tIwoDQ?U3BLqKn> z`{^>WyR}dfFCv@GcXliPk&^$(w+l=|_#oW&V^_fXKHux&4l>2FA&Wjcx;(Q;LXKKvw-Ioo!5BKOz) zK$zLRfw(NEGKy+?)5c<5k<)%>;?L(UnAo30e^uXwP%;t!(o->|kZU`QEgfk^U}G^D zx+ci*K8-1eDBnJy%oM||enK6B8E9wUI#RUW6*7h?I514!V{lZfWKVQp=>FFHZ5rzl zAaTf2QY1qub>-YU(sa{s3g{ik(|a6BPnDU-?y;)^tUhhAwn zFNb&6vS>2|dX<^=Sl$pcHxapf^bz&>We`rhOS*=p6H#%*kszB5LNGT63^4Gy`qcLt z5>iRAY25Fq5o_p`FLhZD5LlCu>KegvW(|yjLWi5uo_O8MlO{(=uMy8`{Tzb+F`vU{ zA+Etqx@KS<_%Z(WprF6wx4%5-Z?pKvgZ^MU*FPG3?5IcjMXqOPR_ZvR?`NSpWV$eL z-#TO{q&C?TX+c^41fhQ4r@)`C%^_oXGC?;NHF>vyk$pJpD!C=4ztHX#I)k|VzB@7Q z3zt+E3kAyvLuLpKmN<4iX(vf9w`9a#r-fIMqXV_tNyUe~3U&Y(pZ+AVWCSi@i=VL2 zh1#?|=?ws{)b2wM@mh>JFK&05?p6k}XC#Hns90^N>Y%wcdfMj{b2#^6SINoPBeU;T zE(G2Ojw3)v91K!Y8~ix0uWoYKO=ZP6AB4X6LVh^5BGd@JozP_HcXCU4lhKjQ9L2z^ z{oV1#w}uj>aF3A%=*P4D(@{r>T@u_U0`)=}L-%dai*91D(CUd=%r~vQ8L7AzHf+ls zcaWY5q(qaT#=mg9E1-V@|Iy0GocJ!gd?T%uL`}N>{^p?nW@;0nmh629Q&J>um7Me| zaq3|F8px(aA|u`?YO9>%^Wo*38!qo#+ZI`4?DEp%X#bFViLh zAIv8t4cWZ7C4y8&wyAK4TU5ae5)&MmK%#Z+kRlu{oXq(??qOrgsS4z7YSLZ8cK@FCFa#Sd0#17z5>nsMnew{h?1kP4 zL*#xPb8X>BaZ~5YXmTwL*A%aRpddV@`fl8JnDYax(Vo_wYb9;I?(@xEJ#P63U0mIR zVtNrm>kH;n+yOGUnxswXbRSCGhz=F$qj%Kqerz}f?degtNwE9tnnq+`@Y0RyhS@In zQ*XGbrx6lc_Tq;;k=YZU*}kV!1z1MBnE;0& zXTrJ;fhh+ng@s)+7zK7Wa1OqG&o5495`jf~ETv_`WD3z}n^xYhG;yKhjy&>K z@^3^vfrGZZ-oHS$d*D-5$W}$znT&3*3xf4|_tQ5!J`jNL=BFSD5Qb-Zd<{E_vh(aH zOI3)u>To28{(R-FSh&}+RId#l5m7(zBt8tIv$msrGWPxK-6FjJr9rEi8$mQI_h5Y7 zPMh^cBd;B%$VFDCzeB@yNuaf4!wARLebFUt~J*07|dg{fy ze((;cKrIPcS&p^0%Z3+%8NYEOTQt;+g2 zp7d;BD^FTfF?DDnJ36@7?}EjRYkv6)ZzVTbmZypuom9Qa#1X6!PL|H^K5O#w9)ZAB zwJ6Ih;d&IqsjRehnGb~hWpY3|Gb|&z{CmCsgpb}}NCq;?$Da#WDM8yvbyZ3QnEnT- zPLz#NBsd?-Y~M_1G!gE(V<9W;Bk1PL|b39d0V_LD={U?rbC0eX49? zTXh9NSJRbeOAtIc+S1bZKb{uvX-1Mz+PA0)Z*tWnr49{?9Xo8{*UwCM9I1wCUY=G- z8+57aCiBx%ah+>iV|zw>GmUm#VnI;eV4=U6^2$G$kaQD{RlI4<(k{PKxQRmNQWr}# zdb1-ce78Tf5R16>4@C*R!|?Q{9~TiJ90) zIa8RD!fa~{yX|fjI^?TgLquthR01aP#?&U#|DDAD{A}EXFx^bx1r!;LQ(b1n#=-Y;ZdekD>HA>gC3 z@zpIj7Km^6E&h|ejbEjDk2+E?;N2|a4oO!+?K%P(GLV^@a)BFkp&&Oq`)m~!~-hbZUemCQ}+ zK3g9|`aZCvvw(~ssophA!_rVo);?!GNVJx^2OKdEp)}0v(1uK7n5Y&RLthB*#z*(U zzw0N(H53C1y6R>Nv2DY_Er&AQ=s%}m?rx~Mf&F3-sUvNVzj_=mJ>$UHy>~X;>pKon@w=Q!zcW9s# z)7k2vlnH8*p|lN;3o5T!PMY=LVr9i(VNkX~L!8&xE;3QSG0g^Nran&QX6updGrRk} ziGK|27deh-Ns&g&HLvB*q^JZFh#ZJrjm$L9-J2f)#&-5&RXC)i=^qeYtG1TLTc$)O z$IA6hcA;L{1)VmIt`#0zDtz9z1l+k^a4bM4BeqG1Pb|abUqRJ291(Rw1xV7S zy)Bv`gqxA`Ia^%3&~C%kE7!ng9kx#QQ=~Ru==(<-lJA>3;4d7Q9n%Z`zspN+_-bnA3_NyF*CB59c`ixZL<0~d=Nqw7?)K;A zvKFve;_yC!j=s0tZ84yiI~b=R7TJMexng^H{_4ugy1tBjvQ&p9&@g&G#vCf&_dY$3 zM(<0Iy0}z^1KcW;mryHoJtav9P5kR#F*V*XN5p+(5Cn60Y4li(Niwui+0^ue$v9Ih ziRb7V1%hL=<~w_mHr~}F59c$*cq*=;*Ccsd6N%Ae8Q0|W?v;`FnsMjSRvx;a+6Imb z!E6+!cXdmOY0%M;WZLb|<}+Fq>;rEUF*1nW*e0b31|+}Js$N-iGHwI93YzE3Nd`k2 zLfx5dt~&hDr_w~`sDB{gj*0;A@Kk{pl$u8gyL?6DS)^4-OiHVIfL%?wkI%WXv^jgp&Kst&4)B! zA^+^ecf@}j`|L?M>x84LXPaY+%yn=$w52im6R9gtDji+=m6e}(59~PfsgiGe3wUaFbjVSZ(?4O#03jRO`4LoC}LLHa?c-dU&Qw zHwmq=it-<*hgv!l61XLsb#aM}B71n3zRt&;bUOB?NbJqavRs9bHLq?@qeozef$9-;Hj@T{JmT^M?*v~-$B)=W0k(BQ$*cIw$=o91b@~Tb&eW= zxcv{bZb+Wx>95wRv2m!C*KAfJnwNPdQo=O1>!K`v#R1hoY&}}fDMhqvPCjZUToUzV zE>cY&9&>^EE^!j^rZp6m+Si~R5mEUgO|2?%%h9h8#cyi7dmc<)?TF#W3Egom{>b@- zkp{z%L)cA{S^S-;Og%5ynF5H{(1JP!3p1Fd1%(0-P(pUDNoX;bBY~Hr&h7z?rZg!c zkuDzVUY%XR|IsyWS_znE}E4Elg3>lqr6s4p0i z!68oi{9yiAZ?fE10!}|k3XSEc`LjLd9?R(B#?-iuv}k`$vTQ7pxR_KO?>y)uHs@}` z#?to>u3O-9o>V?JPKDs4B7(f&w63{O88Vr_7#wCf%OE}swm)Ld`|>-i@4}kFxxX6- z#jOji@O0-+Ra^@i=dGl&$TF|y>W;b#mAQTjw*+xhgr7LPPdW)D>`Jmj4L((;W6!Z? z&u9OSlmS?x0R|_)aE-BpdM1{E{5+(eWe|$Gpzbj|s{{<8tZUP4 zG+qwM=>xQeoj@BrN3~S$4vlYvS{wqb7|Iy3vh!*^3ll)zWXuu;ciKC)dWgnGN3V45 z?Jbj23+2*efaYP?j#_r=2da^#7RejG<9xcOLi4$SwVuUjs=YykP1G+14ffmUg+(y1 zCxMy8nsLQv_eOLerU=2B&3% z0hb#GA3;DrCe!A@D-Qhx}g2X#x(ZMx3|ry;r}6KsF9rW-GSKs;##Yv6jQgWH?B@CWu*^|i zSeFAa^l!f==>zkI4%dM1fx#9`|7+e0=FH^jDe# zeDqQy2Yo}&{8*Ku5LVJ>jPx~#=+i8gaiezT{9+nzkL7yZl!@jb)Jca`$Tk22*wezN znu{s{jdKp1n0v7ogkj`OhCHDyGA0$9@u!+e_9bP3y7)R-E>cmR_R7rPlHN)l80q9b zX`;zKcDZZVOv5>Su<82V*g@2uP@Q6ZWrO#c?{5fO@vZTQOm#A5g9}GNe9TYTISKhr z;M*g_fxP6#VAa?KiNvtg|1b6Fw*{L53#4Up9{;I6)e*QS5at6*>w&EL??=8FZ}NOp zA5|s*RB#9ApbYrXr#rn2%n>G}7t77>y+5bqKy08D+V>Lkp>u^5g2^RXsiDas4Nt4! z8PF(2EtU3UK~0Ooa95bySC_YW^^L$+Jx@)fSJQ9j>QpI3r^HCLqEp2wDWFe|GdyGc z9KXor#8<4SNWpEKFQ6ACeO0HJ& z(X`@CRv*p5)eksPQ)XYu=m#fo0BacVvL$hZpOof?$_SqD^RS%u?(`eZHJrJu_D2sf2y_kIym0u z0G6#M2j?e2s`~9}X9#D54T~=-d9shL9?^St9-N!;qO`4nr!X|X+J5oTg8&kdK!7he z&}~UGZrpHS=ap1>VywLjdD>e@7}}NOCJ!`5_dCoP0aKLrL;*(^nnMGIY5+()1x{OA zE-#4U+`rWKfAyTdUv+<_eIP$s1O8Keia79qdJ@*3yZe@4K8OmB|A)PIjLvlFwuWQd zcG9tJbdrwKF*>%BJGRY^ZQHhOtK*Jse(AmU^PK0LG0r#Mzwa3Dzx%H1->RBbbIqzX z7hnOG^l4It-;S|Qjr14DwS=wDn0f_CHmH3Ktp21YhJiBt*k1i&jY zZ1*YD6_g=`levaTjhDT0_Rb}xv)qK`Cf??{9aa3jH!>M#yR#s*KzKU7#)0gN7s0KS zlr-r~#K8Xoa!&Twhaua>RW6@Q15yF)uJDDf%SiT1ke1w0drLs3SBD%^pB{!G7*2B? zA)g5gj3z}v4Pwh*1ai0glZ)*BK*H$re@Wt3KHkuRJ1uUe2MY2-fmC%(T7jiPU>IxJ zJp;p9I4mz+gqcrY{)L-K0VP}!5!M(LV2yMVp&U6%%HK@eD}u7K|5j7zh$oLIvHE5F zA>g`|29z$OZ)$AQxpdwJ()E&xeEvXs0e_EYZ19YI++K73Zdsr7dPBXlq_J;mvy?&?{xccn}*}6 zs)N_csMyWI*pUL~?Ua!b`KS-hTkpz0E(kMj39y9cL;BSF7C&TQO!{J+?f?i-(+14m z4+*GaXqE-s-hrsfijmo=F|I|i~P%V@>5j$UlH{$ zE~3Nw->qJ46nz}VPi}N5tI{CMp&cJ0qoBeha2iNG(Ks5fy(`K7xkspDh2fA{#50F3~Z20U?Y^s;ynS#OaD=4Q-B z1s?>h{2A70X+?(X%&) zAn@bkn-Tj@dwj~218jD|!!LG6#2mCuB42lhBs%2t(23zX1zp=}nPd*fbbfixKA>92 z;7InZInR(4$+b=DJ+rH3qdeqN#)}u7b?gDY`{Eol+e^#UbYP#55-eiMcW4+$j0_D5 zUZG45yw6c6jiF{2CK-O*S>rJt3oe$9(gpEHrsA0-6!}*ojoeIbNlY11b_kM`RA=GS zbUk$qyTP^Jbd-ku7lYJLg8five;Y+TH}8kdU<16t?GX4T$#+ZdqP`4T_&_UIaGLaM z@~8RdC>rOT^H=#vpBqgYHPX*R2d6Iu7F;~=HT7KGL_X|Yp2aqF(%8R_2Gq1ekmZBE zb>;AVWm+bu)Z|7j=IQc9Y1(-SsP?kkYJn({>Cb(dkCj#Et?ehfS*wW{R9d7ro3q0m2CZBS#?vI|iM%D?*33#OKfdmHSaLpg{}`y#-ccmwch#U{_SE^NQ-w#* zn0&bUoPzC{s*G}fRMfiRrF%Eu#Hs98&V(Ur*>KC2~CH@zUL#dGL&dbLs~uo+|7hI>9VN0)nmJT9S!*h z?K{3OcG0>Z4mO>(EY%(D%Xq*t`&p7i>)}1lK8k8(bmYr6S7PA5tzQ5CK=;WYz5Zg5 zo&OJX|F?sVW*GLJm{?!x{+*F{%1a&p&@Nzn=Suh-& z*~inxGm4;a>G z^13M1sJ%0K39YYRlD=S#pDnukj<1l(Z!kllO2iML^>1Ku>7s)qq~A72cs(P{447PS z8Wd|?NX2#PZ+q76?>ssVw~^)6RR;Cs!e(g~FkiHs@@_!*g?ZByP(O~nz7YsXfJGPD4lPp%b4pDMoHjS`pa7V5e~M>Z6U^nf=X`3if9Q3UC9V( zWz+;J>lBKm;f z39k^@hgR;{44b$_p2sr0)rjB9cwx4AEJDFn)AzpGLuW~xN=4iS8KET2QOZG8aRzu| zrPA@|@%KJDf_>P1aoiGb;xUH4^YO1;`jp9>2mQTMhUAP~odc1R4C=h8kFZb)e)X477C4tM(5 z{RmDntUidZ(qoLXBJ!*`n+KJP$mt$C(3(+=oMf`L_}m!yo%5!&`xOk6kHncZT1xes zjo;b^W`Y;L%-!BoVVCEu&c0Rgs-1f1}EeACLIrgjyV4QJTNlLAx?mO zYL`m;TpEhRkn1K(*$4KHz5wm=+04D|-=Oy8*Hnm~5BYu9i&wB==x z6G#9aUh-Tv4VxVW&tp3=lr&o(z2zO4-^`yz!b`Pw3iUOTU?cbo;fE7=P?-IZa_ykm zPM&q>Xah%BvfSWYoc_a-29M>s?8fDUI&q&lrgx4tuw1@7O%i|wp-_%irH$~o!qc1m z1wtGj)nL7^J=`oZ#PLY&gJb`R_=`d`t2(wbc+&@zNb^faUCo19aQvnZ+EUN9!U1gA z*jgF?Su|)X5Lzr8mnyqVwDb9+ptFZMUF=wvy&x}7+#R`q$>0t9uFS0p-}cCQiCh*8_^Pk3T z-%Ic$cK~TjvIN^%iSmFVWr=89pv055?cDL6e{yWT&m4Ov!}^Q+31RzenG*l-DluqR z*MR5iPNKuwrM1bHZ#uF}Z36f0&l&GwhEb|b6+udq049+n1g9D_vtxgi=5ZxeI=1pr zagP^D7j$Z&YEli-FLO-@XwEdLQC2R@)_gtC<0h21u@VLhJb55zV3>wE6L)*o7#iWw zg4xzoo5r?Lfm(i;IFBQj027^g6XD-23e*K2S}x*5l)b>-W$>mkuyC)5vFT%}j+L_! zDWH8dXCY;U1Jm@J9O_k1huy-3Y}=9x>5CExo2(%mU|(TOx0(_J3JG;4p~aWUAC!6C$vsDrbbt zE%hc|@PoMVk`kqf26&%#ar?xB?|!b?P=!{bB1UL##nbaw%lu@!BjQFw$*_2++I%EJ z%eaos|J3{cn415udjIVoyY zRpF1Ka385L6J_sYUZ8g~J(iCOqj{ca&$(d88FrBExY#RpCAF)s0j?yPUcHK~hw zmWLP12Yp`e17#ld^`MD)dy-#P6~L4@izKl%BB6H+ni z+h5fP_}G#~_~W;dSaKyKH>6E7#nGdL8h0a^>kp+aqy@?Vf5BOtZUzYLi zB>jXb-9Oy`? zxY!wCJ0EuRmb&oZBuaT8h&aFl$l3Ds5zwJlt_3-zDy|KsVRzs&KKd?=cfzcL7#=Yt zOIL^tbID1vG?s|F$RjV9%^oca+}3)mKDjo8G@90NSGR>WbI~0M1tP6$sOy6KZ^iNR z=JbD^zRzsU{!g~%!Tz7qx6cO$6u;>&;GM@^M3d2Bl(C0aENRCo3|sEB*iXy#k~cXv zSA1nwWKf*Q6wF%x;;tOKMZJ@-Qee4UM+Lv77)`?o(u5z^0L4k_^CCN!_0#02X=k{J z+bsYCie%+Mx>f7e5a2f-UvX;*67PNhr)}j=)UYp)Em7k}XT<8ErK!-{wII+%o^K$? z(RGkdis>^3Iv?j>e4J#rx~TU-i6)OWUo1~!(%PK$Jn-eQ$ znZ;-eM$MmVcH^Mfl*6hKwAGfwB?!)w^(d+x&wu|kZMXU5^;omB}C%1ht;itBG@ z*bHN7FOp7vYKFDbif^on_p%#!_iI%%1=!~dK<{(-u*)#v*&Ft3cOE*+5Tr5r?=}Q6 z5*xG<=-7ydr&5Ww0BGvqg7oQ}E3wk>`v*mcj=M(6xSD;jXRCYo8UK%_@00gS|Hb>G z|8x4rC15`kO@|Y)#x?XoDFSg*2~B^#A%V@8bC^quYS;lG8pSZUI*6!VOV4$?_QJF@ z_99MO@8IN$=SpuS3xhX~-QW4|Q}vbNar~oqnK6%@DCM5PW; zEKJ?Z>@Uhfh-cSISxb3vF?6H+5$Lq1BYa6ak9_n z*$ZlqgfE5{0}!iG_Ns&5v))4W*uuznEEdX9g^L7nzrpt(0}9IU1(mOC4ZJ0dh}1Bp z)?^gTfyoD(^)uHF-sk*sOY@T7z_u~^V(&l-ewy1eAY~vaHfdSJ>l|=5w3e%KfyHpf zm%~T+3vFsT779D8rSW1&^KWu;0}kSz_1p!6f2yt?DuZz$Mv)`lnR{yDzhkp39~`jz zE1@1qZ;QOM2U^J(qKS!I36?=Otl+HT5GVfl_w@a*(EDVNe1AQb`k#8gOF8U^EV7Vz z{e6c09YUQI*$*PhA_=VY)|%MEH_ZH9>X=N8xDPH41mUEB&>1xnuQT|s$|GTe`5Ln+ zy7OHygha;M6GlL%F7$miUL-5G$M)sGwiGe-C77!657&Z{R}fYHCQjSX$S>Qz^u6bY|tZ@3U{9FmI)pm#K!iZ+9= zJsVL+7>trWN7gzr^X;;`(fbz_RkT+HvRVcjWOS7)aE@nInoQ1I`86{d!0ECt`~sY4uSp0qV9&)xOmEPwE}= zg&Qb`Wuz{B<(b%KY)w*#Hc5I%IGWJVWG7=Kn&I?2ATe6%6|vz-r(Gd0K2*f$+Y+YZ z<;dk|56ssPofh)hva3(I%15nVFvytPVi3fb{j9$x>dh1DVO?2<$ir(o_LQ+!4w_c% zVJ+zW`Y{i9Qm>jedVbrFoBUoMtv^v{mm`bTGqJsy5jb z4Q8LYi(#{fi$y)vy#z=_7&!XP&3}2&ue@la;oS@kno2khj7=`5@nbm;K%9UXjShS+ zi9MGT(nIiKsA&&|TXv`-Smpl~c=462>JU=1X|Vj!obm&o&Wy=@UL?ejfgs{~fvfh! zl$cLA<9Hl__$DTGlM2Q!tWDub=I;k9%>UT8$~YQXT7DM5ezwpy{hBN#`Q-h-*3c2B&}3;OWCDRZIUf`pQ@pF!(DBQMiL%r6ki+J|ARi1lA$5I=Q&d@| zGyWzhO0uR-tk03Y@!mB>ddq?zsXuvQ&9#H92BB>uyk8{b`Zx3g12K1sO@tV7(9jld z?%iNvo7RbURSf)FqQJxCOuli6FxP#&njii~79GDqCxxdpIaXaap;Nq^xenxgRBKCa z#iz}K5|)xgH3M8vwC-GUJN6$E>6)O%)G=@T4r6YoTXnr%dj#n9%^lcSRau{+nd|j~ zrNHk>t_aRRkc~c|Q07Eokx85A0~wp)Kq{nwc$yS`zc+ppTd4T>A`~1*gK!{BK9GW7 zPQ&#!S(<8Zd*n2mdE2BVD*!gc)t}TypZ)+aBdo7Zm#RdJcX%}I0<)q5u57eJgxm-r z>(HCexF}GsexI*PQTXMR=H(fcw6w2-VA3tAR`!iX)R(={D-wwlXEk9voPaFiLKOp% zf-f{WcP-7_G05wz6l?@2A&}kgN?DMR zroETH`Sf3}h{+}lsPj-2D>s*D8VC{+8kp(G9%6A!5)3!XZ4P$vq>W8GM(5nz6=-J2Kkjl3 zAFsy;%DSBuU{=sMn)74HdBI%(G??PaGF%B!7J+M7XxfOXz;KdmlH6j22(Whgm~UQL z{Bqifat^p68CA-|@kR-%@b&wWzvM}{N?qRB=QVFrNw*>-l#^8rpeCg`2QnfJwse{V zqp`i~E?$A1ODSSb_*z@zxzFv6jm?}X585f`D?;WI1 zljhdl|Djfzoor?)@5XuK4ce8>vB#7?B$1sq>_(11-jY;7dXuRv7fyaC<^>3SSF(R6#w9+Q&Y(+ml}x30c+PSIER97G@M7AS^Q6F5uv=%r^^75yq=|=i5?NJ?Vo>w zwtxMjw*i>&xBOSYy6644rYJFki8f%^jpn3Yl77&`N}E|_fViG+H^v&=ye4-?`W@0= z!yBAh`C;ZTqp7WP#UL`Ad!`ZbtU_MCp4l=WF=TD17AWeyqphoNSd)eMQQ?4lUAM*K zRjx2xxsZK1s3sC6lGa_yGE!VbejXNTs7G`U71%gSV4@YYRDrmfTCn0fGLoKc8Tx?7 zj)K?xJ$`Z;gpqu5z>}gJAZ0Pua*{R(4%&h)yXODi0smsm&^Ec1FIA`QqLM}k(!ZIf zaiI7?M#2fAyb}ncAofJbpSF5Rwn!9G-r-=<_nv*A@|{2pH>Xjauz2zapXZMGf}$&{ zFL2AY^9QjT;y)?-zuhnXtfPOn7=)j_n<7m#H94%1?*dOrq>kca{0jLW-Qu%zI3A)= zIM2yfHO>0zV%dq}a@T8bBa3itE0a?m=qfSm%)usL#6c_5B-rPLuL}5Hwsc$S%+o-u zhOp+_C6Dm43%bf*-C5IEG7{w1#?#tFt?yG^k(sE`on<_{2na;v5(<(X_&y{(az%Q7 z(j$}Jz2yF&t+o+z{YvgT8P`Cyzh@Yvwm}N_AgfgQWeudJe~U$A_~QD`Me!qq5}OEl zyHH(Owd{$==xY64{wx4(%(D)r*=pyPj?Fb8pdO|v~{I(&q3*6ACSYBjc|6r)1REimHZ#`>TFI^t8*;A@O&NaZ&SfG)p zhjON3ZrBh|83l`*sIA^;Ncbhk_cVc7d+P>$IiEvp`??jBSB@OH8dQv`UrK^k{Snr? z<1qjolU7Xsy=L2a+9`=ytiCpyi_Tr-bj>Clsx9a8fi{J_?dfnU+%si=6PqtGdU^l{BWofVM@z#` zH$Wm@D+g1nzkmNvtA~FAS41g^iBbWH$vsq3pXS?6tLu1pU2nV=-+@jc@+-mf?l7Vr z>bINAv!Yj8E1nQF5f^*|Dh<-y52SlNQxmG%E?-W4-JEu`sSINE11^d}ln~(hCtQ&h z&)ha<&4Wa@d)a8hKD6CoN>&$GiLIpx%$(6twRUd;7r8OnwAI)FCz|jrGLgu3Ooe#! zRHK|O3GV)^^luR@Md8y7@=-oXV}-K^nsgFI&qn*b#NoC|Ge%ClZSFU#<=1!iObyO) zm#~ZrTC&fzWfx&dYO~@L-WQex{kN7L!q3mf<8%b`bYXCy8l>?S3TuTf9X_Bk8dD$@ zQOS)jn5Wp^LLvL)nErvAMw>f>?jelM165N1f#G4ZGiSGnx7;1_Kq7sC_af(Q5=j_y`nOAmi`?sb z^~8!dy;=CSINw(B&T|rU9K^Ye?)+-v{YWp(Xyy4cqvY!J&*=7@t|B2n1em@y-g7OF z-(q1$LMpxZUg04=t>BoL_hh)y-f8}tT83hBBvl^47Hp<)odq7NeyFG^z@%!u*=d;oNxW`QwjQeD)f=FEj!+Fk-ep?2tj>RTbjZ0tiPLgqx`ln>W- zHN^RZ7%j_F+V)*;|8E>piCR0^xDx&ALHyr_oqrp13L5?S^y%B_;!1C3^VgyGPw1A> zrVPex7bW}cUahv^?Y)aD?!7OiPk4Un$=x58DdGB3c;)|i0+BY}DwFNx$)OSkep^cl zCCIQdj_ER86Imt|x_Ee7;E(6;D1xeWqUb}L5oL}Ynd;!=$<_XFFG{BLpiHZnurG#t}5h2@A-- z&ji9JgTbS<7H|Dvf!RZ}o!RaSvIhq|M~aL{rJh^1|gGs zzmaJ2s+1HAjy%i=)JTQ1xRQU^Aoj0d0M@NZFLM*U}sStZX!AFv0pVehA6!57G z>D$Vw>-SQZ2h=wD(FC_u!nl&2gbGv;fhbuw%Pp^tn+k^`X}?`B}8N*Xy1{vVM;m6`SUQ{>2-W1Uzx zLuQ5Gh@uoXnyCu!AlW9Q`2K*T2p%NX6O_bSJ)E?;CK<`;R*he-37h%>#;m%;DzI}Sl2@4^3=fl7(fUh_L4%C*Dj7d5mj?G zX8%snc)(0VU;jWxaeSm<242UsoC?NefL3DZqbrCvtK1S6_~5M510K-Fkl|I2pYdk0q?L zM|#pF5cwfRW0o9?ZoKE%!c?<}YvUh}Va49PUU){lrUl;z0Q9CB1UzhwbV8Z@SShfHdDGuF>o(}=bOqJTdXjEN zR|;tg0b3Hh_bP1wST`W8O>GwA0!=YvdE9f2he78Kcy7^{_w>q^*A z51NCWcsOv#u_-Ad6KECmoEL3xj zY~+Qn?ctO4y*r;S;bz_}NfG(Az)=sTMd&j;J+o5WZ%MoT)3WM^K$}uBe-fui7Dovw zwts5kPOk;(ZHE3M4#cI##LK~VWv3{V5y7u-{FTq&X!6x@*YP11Z|_iK;jquWsV#Kh z1YXV3O-NIq+rz=H%{ikkzK6Hn;Q89MBl)%!bbnqz_IZ=Q2}|p#Z4)q>x@LO}Y51U; zTGBjOv-o=+0=blgym4jkjGB3P-aQ57WG-Sq4hj!K^s3{?BAmEUsCZLZvF%0ofN);{ z1Qv6B#`{gFZ|Z$?wL7VGR?>nai-roFb_nU9=uN16s%RI5X;pfD>cr9rz^edpW2opq zshUTA=LLnsQ`2iYcfTr=%ui%t8f?{MO4{cMm!x)TaQMC-O?G}4q4X6;R*4xOh(#W;RsTv?;Ht-62Z@a7}H3Eef^aci|LxXVM+ASAhos=6jv-E zs?(wR7X)XSTqVpZvcRJZdA_MDBWV#|&+*4>h1$@+_u>E2H~uV(e>Pn7Av_pa*r<)O zYb2nQTPY;GFUhe~N5gouJ8m&kcbQE=+?4@P6bONK_L@}NQE*I>OQlD%&71lw=o7l0 zQ4W`WU8H$UFS`+uRQ%OU;akt?cHGZbf~MW|6FY$p<-sG3S^n#F&f=}J?*bk6`L)yL zH#$jagVl&u(0$PsV8GVTX+-_(v3bLzu9?oqE*)<5b0*&vpZ3JA{a_Q(G_|~yiK#!dG=1TWH6=5<-u zK6>Y@$uTFq=yzY$3C1Zw$Z z>9-O&89jpgtZT=NL1q|+QZWhGB~DcppMg(X6So+PeiT59KP-Cd7SvGEI=uiX&aj+_ z%hds1HONJI%kygdYj%8jje%#h4+L%>TawxmyxS#PXOkvKzES*rP61%Yi_m- z7JJi@A6Xk#xWfq)J`vXLr2@h=`bvEn zu_12o6yFrFLUIoit$cH=g^;J^SP-G36O2W)1HdK=;;4q1fL*mhGYh8WL7K48HoZ-` zD~Q>E%)L_Xmr>c#9#;_RILpP?TxmQe=YEnrR-f9KDlF1kvG;XefpIse{!NydHD$00agY$H2MLlB4FUli(%Twrihe`-PGk7wK^&_3L6udo=jfFjZA z`3o^Ef0EIE;z4mGyDC@>J*}zK5>?i=BhTUy9N;5(HVs-BQTp_;$T1mEw|03BQN>ec zLiV&AtUx&~5wm-fs&$=PrPuDeGjojFTQj1oCGgo&Q2j)-2i+*g0Q{A^1>eKo#PA`O zWz;qlVw<5K!b4jyBz^E#a5~XLKDhpElEiX@%07?-S9W&QEPm!&-*pm^F1e6jy%rU1 zS#r|jCSeqs0DsE&+p&|1Ivf6O9B*cwik!W>YeHk?)>ELhlXKvhOzDqwk-DJxkPjrT zY`^|80Gr0E&Bfz|kpQ9sj_Yo=^wQ%pf4#7bytLCQY&S7Q9{LTxmXV#3Wcie!i(=lG zg~?{i-;IMqf&Yui34m{u++Z>i#M-gXW9EANE=0V${OmOI8LfXdmVXU?afbY`Ub*z@ z8Ok`Qk;Y*?L$=bFnX0s__zl;WWFxA!i;O|>k^poNfImXbk_dC8M#OYo;mkQ;hK*(F zcrbvHy#nV>+MZ0Y^p!_sX(;C1EuNC8sR}~?y4ZVgPsXP`Y3_jUIfDX>e8iKb`1C5` zYp>@;)*_@pnz~&h^t=n-N9=ms&+vvo9*+tGHoL7N6FFSs;mZgW2{s2mRIrs zS2AEG!~vO0n>9f`AOfzpLL)tN_-mw)6CCl7F_-u0wUE%d z*r>-T7KW(PTUH_BuOhtO5?bpvFHDEt+`ko2VC6w9p=U&})e=%og!IyD{{ZXzME}$$ zu$EJQ1yc(#woOS2wWFT_aQz_^JWY7UzF&YEL+8hyiaq zK@>UW<^Jdqj~#EWp$K8Hw>~>1ou!ALfAOb)?A^46PGsQHLmkL9cz&fCKwZu|lnb8> z$uOq%c;+SZt+i6k(!Tv5@p?1qwzVO|PV|lbdP{U*@Cf_J_U~oQq z>6luI%hGqCjhta(9mXJuQxn2{EZvr29YLjtAp#e3G=_ny?NA$tj_e-QXi2rX!oRO; z{s8NrcvO~|v>+F`=S@>@ckcbBb>vBx;-`K_Gt9jX>}9U&EGI`;&qQYS?P+Ut5kQ%3 zw~Q)}X-6~FCQN_QM-aFsp~RXSb(g)8`p6mE?mZ!P@N7wHAztgD3IVJE2$mBz=w<5& zi;sVw^q>j@ovV#}hq~p53SrpDhwSLdDw4CHIRi;wZzx`BH_p>tnxtdL+w_!rElnM} znD1qDWlS(i)>L1p>IcP3`%S#>{KD}y2ggO2DzX&uTRJA?ek5@3Mk6F5U_7fr8#fl} z>J-SH|KW8Nf*!C8ASGbo%jgJ9+G`+pTO?SwjD5m0-}|+ICkc64@AL~CD$d}|Q0bRd z^S@H0f9ryO!txJ-u(@&-V9W4hgbbj7`X_p=WZLub_o8vBz#1gF^PS+XgY^3y1KT+a zVobGp`!B#z%pl3S0_U5Vo$i4zO;xMhT!;l5ZTydEqCgdseJ6y|P4$z|l#4jGEcsB5 zYU-OP!=_XXrvdpm_|LsZv2rT&t3`ruA`UPC-$19!ZH}^^3GrU&ro*w;3Rq)zhV``5 ze?|Ax8XNrn)!$%l94jsLI+^2<4>P5>ad#6i?GYna$%qojL{bl(w5~+{t<&aU(73Mt zN$LrKKpZkHVj>BA=F4JLNf%j}`8r&}WA&Fder`A&kH!=(cD>W(t=460WCBhTICg|3 zE?2#JB#Et)QsITelh}2+Cdmcqv_A-vzKZ^1Ks~4$&O-m#(_4)|6{3xaouIV);)qPrMIfJ-(WSd+(Z)CEH1rfIxwYT$)Xgoatgm7nw*d@H83C&)AqKdvUxh88JD6wcOUX4oAHA-I{$@E{AX&P}K2Srs)J1@>P~6eF&x6tN5{QLqYh+_$x%4Rekp1N|Mdo_HDD*b*G8 zq=uQTI0A39TrJ-Wbn^{(!D*-}%7o&y{B+{qN7Fy?=pZRLi>=7Yf+XTAr;ZC$CxdIN zszMzi*eL5s4g+wSWi@ydxoUj&FUvzQ|MBfX&8+;;W#JM-Sx{|MdWbj2<+AIjJ!BLD{1lN7zY zaMbdLIAUyau=qL;uf<*(^|#iTQ$N;6_yR1+i>YraX`O3dh>nCl8}k8mgvxzG{MFDl zo<{plI@3I4tR#&OT2u0EDS|9q76Ml!pJI$kKk#pI3rzkgGJpUff`j}C%O`@sp@EZY zfd1%uIMjIY9fye_GZ~O?I8%^vhi>z0E`W$KXzY?F4>|Y4;?T3V`J6;LU+&DMH{n~> zdPpc0mcIz>b4k5QsO|* zR$xgsT^>!3QF#b_MT`~*->e94PM;3UFTeuT(D+O%a=^x^eiuGyYar$>2g8;R@lNCM@W)D~=e63?r$EwDB#p|uqJcv&cV9<+Jr7Di`QkV+B zP1O>5`U=$HC}28sBsrZnCU+t-8#yEyB8fR+}u)Ata)61Yx1xqrFqU26_g7WaS264G z!k%=IS*CG~o5#TEg6*FiyecoLyvXPmh-~M`H+ZZ2JrBvQ99qFacy_qjb-RmB9&T*{ zrUUUF)63}MUiCDP#(bfTHmWlLc22YBGAm4g-QVF~@3DwkBRVMEXas#&(TL zr^-?0HuAk0k%~gKKe9_Ev#C$d3`oeHlJ$RzN~2o|%4s-NF*DP{fA@KUQ9prL6_gms zn*df=>--5_J4zE_V;kTQl3|19LFnj*K{5X}*B7M^5>IbHF@zcw_xk|zSdmIVrtiPU zNtFY#3LF}a2o3B%<77Sz`OYis53u5raWX}bY>1)AOMtXvIR%#h@gU#>yi)Z6eVVRR z4Cbc<)Km0GLrH)VbxijW^nvyw(Gxp<;*I;hKSyMk_HvLU(H6(fkO2mg^C!`Fet}H%T=_0h z6xl@ig!XW9$(2nz;FA9yCv{ZgC2(j2P?+-nj8kR|6i{0+Z@<$!X(1kopsiyS@m1p) zFf#!en|C1zRdd&m#1Q1Z>J)`63?GOl{qW3iwrNE!u-&ufxM__`i(vVDt22O7TT;+A zmC-s+(b%ah_IdH^5VSal5)zV%*ATPccr`!m2JmLCH=7z2Y<(w1v2T)BVq*qNhKikg z-lz^3>(Q}tretMpIudPekA*wb<^^cQ5f-}HJ>(MfE>WCO2t@S2+Qt){GhSfRLq;rB zIvIK4$t|*kZW9@!mEiOfJgo5LbeV|BSN3PE3jqTqEaV>I!7CbWF5lCGd*!R0#c{w-Hs?=BdUQ&y@4C&`?g#mWY7->A zG>TLt-vH!Ax`D*11^0Kz^-@UrE?b1#`&;4_e3_K_X0c_Hn)%Hw)M_@-V-`?(DHy^I zoiA9~77O;kKuBb`DB7)?ouQu8`Zrse2oFWgYVB*r)el0CXi8Lih=V})nfZF3Rc6yj zKeHKg*%~G;$;KmIY6XvD&QVAj~Vp-7uO7Hukl5*Si2d@Ge79!tbSjv|)p* zn#xaYxI?8LnqXg`!bh6&ZH7hbO{Ari1Y+FeHUJp2ifCHVXPQnY)OvjjVWz0CW4-#`8|K%@8#lL~6nk>X*i;AlhQ&0?ooix_4< zN9ebP~06>M)-@*WUJSD9 zcda1i$dj(big}V$#fiL+&0Z?{!c`M`J%d%i0{7-$a9EXBz8+PjmwU<+jz7p*k(2-! zmnZwNIhoh#I0&iERlX#+E_ZZpmC(^%>@EQ?B{YNzRIKX_k!KD(h(Nf!K)Y|3pc^u zBd_7MO*faI z_ps`j%Bu#Hl`zSF*pb`1Gd|vGqLTv7mIoI~tcb+*tgLK48wlI$SqXm1z=lTjPM-}R905l5f2qO$ESO0Oc=K2ISSX7_64~kK z{6l-Xyp6VijQea(?)w`dHAD{!Iap63)@AU+oWX%endeFqm+e__^?D`D2Ji6MTDPuY z34$}|N1&oQi=mK3BpKEBBR;=Kx`Om)K-d^tJ<101K&qJ zN1r;OsW^QbGUE)dotW9z4JOZ81d3$ENZBFU3Q*Kr=vFH-Rc{<_7eNgF699I zd_)Z~MY8Mew}4*a(y94I8&&3qo`b-+1kKM!wqFaz?7a{PRu3OsC3&5$};YCpSWL} zDq0y@Nh(_(BML)EG5jQs;S?9!WYi7bo7ebQw(3veNdCB1!nQ*5)6j0%VH|&V!15)w zj1s74wJbZ9h&WmPiCMm*Hp{-}Zoz*>_^SsRAmASmIo^@q5u;Xi@pJoRPXn^zXvHap z8o{h|#U1dqPsAnsVQ5e%TX< z@%{C)O6%$SeQR?caE_WV@3)$=JQ|gm-7r*^?=oA@uL|U_Q$l6ho~TC3VfI{G+Wjp& zmIEIy(EV>8FwlJrKk`xtzmuU?tAgYU>&s?vQ9)Z+jsumTbq0o0;6))MM68KH`vXo7 zk7RrkyIj%j!Zy!7#ss;ETvCw18P&`B?ASES#-LV!T%-3$u1|M~q*x2mE2UyM`Npo! zE+#V6upVj~v!+ndHkA}keBlVqS?Hpf^vx1n?WHau<8E$M*u&+>}u+uD2jJWa*wu*W!;UG}D9O2l|KE&$5*Soi-pQzFAPY0}*uBzjG zwU?6M15(K3?Cda`-s06WIfX%RwK?aM5lS%+wt?`(B5V9_q9EKsr zK)M*`tH-56YdDqJAmJ8jfX=0wMCG!?RLFtDQuOd@*4z2~thOeGJ`@wTC-ED?G=0nx z-?g<#S6ZBMZprFk3@MdtCww&wBjV5bqZ?Ea{(1g%eO}VY*waTMu&h#JCK4zlHl)IG z$n2x}0t3UC(^LwbR6Cl{TaRp$n!M=4=}_S3dKU{9 zX%!Ds)GEUtJ1>EOVhm49buT(1=U1x!Sf)}jo{$65ZI*QNv|Oag{LX8l8LZ+Oxq^=) z;{L*G$zB@Ir-O@>w9+(-3Toqr4YpJJV9@)5YGzZU>v}fyWh`{{*KZlYN`dc|j91Yc zqiZy)rt>d&W?|KHF?BS z3GnAIO%4zyY&OT%Y98G3S!h;a#!lWz`TP9&%SIHSXyXVlFd|Z<7osQPHM2Gb=>6p( z3b6lc{NFaBxH znw7xEJFn*m!`@F+0&IXF-8>i3#T8+mhKqx)kN|2py6_Y*ILOOHVVVt^KH9HgEwz9* zI}kvU8_Ls$+GofuA9w%O>HVf*K4ZeN_3`oc|FQQ@L6$a67iinIjcHrcwr$(C-P5)? zZQHi(Y4@~kyHC$M-}@utzc{xi;#}>$tK!)gPgSnWtjb)=SD4v}{^$O*JuSbbzzIMD z1Av2*2khP9QMb(QHA<2eg6=unO0;g3{)-xt;PdOjp;`xv+V~sbaJnu*eopoyU0imB z{}HQ&d>i{4N)4u}2%JkI5Hc|N3HWH`V2a(%dZ6b)TEI4kMgD_`S&7VK;nDe2w!(I3 zXU`<2lx>2HbiMo3Mt_4$g-IjITM`8nAU--k~SZ;jzbCFxQpDcG{O zDuf^eBF2M=Ua$|01V>;{GN^{{_=&Kzs*96)MtjeLPFQUta5VihDl*fmB z@F93+U=cf;P0i-&0zSo0=^1#z3#%Sk;pKtb1>Qk{wzZGA^v_(afK%uW=y{Tv@V6NR z7AtR~EZ@fM0M5~eF65oH-|lndZmJu@PR&5$hP?n?qzzDReguZvPO2s+w5#-8_2j)D zF(k>}yuXI_LDls=!lkVLIwBBQy~bL`YvO_cxLyk6Y4L~dQS?d{eAS0>-u-Z z_2J8PnSy3`LaE|p(Tn*;s+Ne38?K-!I`4hmV{`vL4#kiqnevTo3yP3;9IAPdM*eh= zqX6>=*7d>(6NpP?ewz?9j7`ZRWGvMXq$DG_I>lWM;R-@}h z@S`BcVN0?^4dBDz9XKlbq$@W7+&P!e$=}jGns1yLwB>J`lIx}O@jH;W|bq35Ddc9rP z)@rtK-45~Dl|}$Ajq}uOTfdzcW9_|~eQi-(G0#s&l!d03SW{G^%GgYoxXYeHh^UU> zJ{$K^qUUDJW4Y*&qEC%IRt9wg4xcN4ca_)iAZyF65WNm=5W0ef9>~Y-8_x{pN|x-Q zMNEObpM5%`g8SXRIy9OHzSl2tvM}ReN}y|rpu^|!^x*rZLcj!B+?G(gd^K-tXq;?v zY(g=^98KNiP_Ni%x*l9gN}a!6A9^XB3bc#WxgHLfO!N`^Gm6+Xy>`rq{Ob)*CBlB7|FcJn&-NKZxL`GQmAV6 zf8kLTXaVdWiBgxF6b!f4KR21mJ}O0_=L?*jqNr|iJg1qya6XxKo@>LyNLj=N{D86S zdhsMd;A9EV(k!-t-k@ekSGsjdlKs4?Ic$?Vb|xi_1RSIG4wV3Lk^{@H37W~2!>eZC zD1;4p{`Lf+Uz%>a zeS>-gNVYxJYSn*`waVFG&(zYiZ$~cjgHbHPpJ>45S$drAOY~~`nde1X-KlTSYH>q6` z-JWP&9G8Z6&=<ti3D0yZHlVJ7=_EV$Ca;Vvi;AWt9rXnhL8ydJ{IQE*V%rbEw78^n%V#%yRgtlmi@aE)7`E@ zQQL#UuLmA5XlNlf&VkNbiToPfZ&?@N>)mj&MMU$vyB6a}m~tbze(w_P@!=$haY2P~ z+9MGT#IynclA-AhgaTJTQs5P&j;#RN?WA6`nsX4g=tuh(+P}HIt^4LXNOk23c6&M1 z&8*EWEzc*kOEZV~S(P>?X~~L;&&B)d-w)PUi?l4JH(hC%#s+)Nr{+S|Lscu{+&AZo zRRSj;q{MGh%-9{kUpsF6Vv)~%l!Iv4x;aPX;$j7Yn&Qj^RXtXd^Q1g!%!b5UV`saP zdu~#v<6`A-aPhtx#n`7zv6~<;frRxCgic50Co4MVRwa%?XF<-V+X9%WD`h$&3H0X4 zk#Ro-?c(dnxq3MFd$r@poxfCmirmKh8$SFaePCwnN+9WM^hHa!D|hWehduoIQin^_dEN7^4( z`;a&gqVP4#@1K7KxAW`CQY94?D%B5^)rHFFaoMh7CUbpCeR7vLa%og`;{o7i`&j_9 z03}{Wj{Z(=^lcm6iuF)EyureR+n8WB_t8n)gm>8&2$HF6q4E_EN=5*TNo~?Y8YW`c zvg3HziB?!$tC@bc0PRxOpFAc4bkzSU9t`_|MBx)li*YPoSE`;xN(2xt6T0<{vS}6O z>GJTf2TvsTdv^3T*;bF$^>pDjGv>aK2j`6RhaV#n5S6tAcETbkU~?1%TIN};Ft^VB zgMjq06gZ>jjgMO|NB#DXsp;eQ@n$HD5Uz%&%?3Dk5*-9rq6H#9q0gB({35&&CB_^gU%ZUOM2hX2Y1qpqgbg9V8e`w&e#HT-b258Q8%*9-r zb3^s4f}lVY9PwbSA!!7#YYU2VR{G?6Z-eQt=LYNe2>{+#qU>Fn^%eA^zW-e zF^`HH8OlKioz@0lstdMhdk3stbCq;kqfe1Q+qd;5J73o?8zUrqUx3I9OqXhh=UB)Lu znHa z?ASoGaUi7dw)uoxou}q!u$w0DfHjrB)HB2jn(x?yn?Wxl`U@hSDQBLNY)U^kR zD7;B`mc`KOmN;)YRsIUX(Nw{PMNtN>T zhEyN}i7_eTh;!de6W25_G>RC`2`&Zyr=pSjX% zd=gg0*$UnLIo7%$poyJKeajd-dfWZx()OrUgy@du#bO{imEo*_IpYuUP;~OPiY#M} zgJd_NN5FlMQd>F&2;~2VA?ijc6qT2rFvrjbU`egthQdHrQk> zgZmI`jd`z7Vx^dMU$BR)iRwm_`s)$tUjVgn2V?mt5)gc>G^`C>G(kgc_O7zGl>L#X zf5iDi{#HPGu>*v*>?9qk&QCm1-eBCmL^ZXjUmC98 z6pjMFWrn&$5At-uQwcIDOi{R!Dp<+=i-Ckfwyri-w)#e2;tT)z_J2^W>&c#Rd@b4Z zZI=W(6A7Rh-n}TTAepJwmC#E<7zG<(7~eWaBpwcLZCb_}zt1ZvC*hU-k!q_NEKqs} zlMxklRw5Wn)eVe=pkHOc@uq<{HNW~#x!z*Su^WndqP3Md;o#!q?Dqyfh@zJ1MPc>EMF@7RWd2~k`M?=ejz`3> z&;_Saag`^870(_kRK^u-TuyE*a#FE{(5Uq0$ zr&3ICGkHMFT>}y8xw81Y|=LkGfBhd=&@=Ja0#`~tbJ9HhZ|7!Ua4)HiJQMjYQGCZu)w9`K8D z9ggn`6cW;uh3!u!^6xm@DD*oLIOhD8{F6j1YsLd|mcfZv`&MKIuw|1|T_>b?3|L0j z(Qw&9EST7mb6N9Z9R`c-whF}Z-1AtG7`pNuM$squWrCM6+=OB$KfB?qfvK{-c@IPj z0gGa#8w@q$=jP@TAOQ=E zep+KwE`bl^$HEm-Q{07PWEEnK)xpi=W^qK~bue99?){1SEB;d$TK7wyo>xik#(r;H z_xiJDM2sG6vMy+vQ$;v=FM=A8h|m=|Yg??f`~`=v3N`o$gib!QeocFROZQ?~V^YZJ zJH#Tn9}8eK?DXXm*^x7)B3?BYSvoji*jjZGVjL_gmww^A($|Pk%X;9i#fR>!cP->X z4r>X!hQZbYNJPkp#eC*xRxxQ1k z>WAYM1gCKsRrM|$eT<}V@dGj(wEn&r-%A(m8E&PJozq$_1gHtw(!Q_@U-YSYWdM$TndJBecVQ^% zQp@-)0WzR`Q6?*sxXW(;wa8m2tK-IvuC8CNYUtb486~RPQt5Zz{*w3DvbBDlVF|z1 z0MM8UFuTj=HygQ-(g}AfT|^$XuKi%S2gv#75Y&5J|mr{loP0@6ZEq>ClXQWzwXz=7_D1EY zEDT6?J!9*Nar^E$0gZn#5Ldf8!JOe^I;`M^?x~U31Cl{D>f`Fk4ixh|Y*R`JI}Vh= z6meH8B3Sof1?@Y=f%%I$kJ$)!)03Gvv z)n6w$Ukm*QKmQ$}CHzvkdyem|V=r@CRzarRZD<1w(SX1Lu6Y zu*8T-{-}jfJ$_+_^_4l(1_fpSil7Jt32vXnpf(&KnbaT`rsQX>R1n%rn=eL=JY@n% zR9|s_*xe8RIglv+J&aaATfRMg9qY-OGYf|34p2D1vkPW50z#)L?}vu`@p_FXO%E75 zYlf4!$SwFJ%%%1)R{Z15HJBj?MCJlD&wSc-Wzn;dI_R*Wz$&^XhtpnweaI?OPF!N> z5M~7sZbYpYcsm&`m_+Z`vJfxCi#Gy#Al zDn2vTZ!4B$x)ia~sl#3YS)>S6a+&Hek`QUadFP-4h6W34Wc`AE$FEv+&Jd;nN2|(d z`MGnvD50J>(dDcls(H5uI!bh^I;-(|ETV4jS;iKne~wyU(5aELG&ioDP2bx_(*yjn zn^2j=@#&H=b9Lbs6gjTcu3PA_jI+w4t=_Q@2nXWF6=dQE6U2u$RuXA7$G_+ZX>DS& zvzoca&5MaBtE|Q^BnqXGHD%`aJ{GFal+fA~#{a5g6ackIYjOK2|boob$O zajo}9urT7#G}$1SoU7fP+*19{w>Jg9(}Ph;5KLTH)=>y2cOkU-V2TF{SBE7FyY~xj z7yBOB4u!j|_XpgKN`4>~4;vJzEA>0*IbReIlF)3cow2?htNxW9%Prp|9~dRI3N1g~^SiX2|8 zT8De|XC&ttU>9gat-m#{50iy!B~JCbD_ciT%Co!ji!L7%&=!i`x3j1@G)%A8M_~jh8gDkMry^60f>K%yHI^7> zh#odXLqE>cE6onEvka=)O|{h3BLg>k6Zd+ZIp3{$?6*o0pJ#Zra~Hez+-tEUrk%1$ zL4XwO{NKpqT=^^V*b=0f>*D*B5LKK-^&)W@k-=K#_--^oyAXs^cl7g9`?`H1KkaZ| zR+WUW$&iX~5hLwn7`Rev!m^x`RE;xwUSaWx!p_jPSw*k6$QHV5nJ0bip}{COsZxBU zTJs{7H0q>vGH{&?oLE}y<=3dr#&9xng-!q6oo_caSMp%@WW?MQ{^P1h<29Kq%x8)A z-8XOGs~J}yO7LA1qgq;>b_+)#6`fXZb^x5tdqbwPYL*0K!UZvT1ZFM~ylNgnkmVGkSa%l0jn9D+k{Hnz5i zaf45$)o$xOCXJAogP<}y@<7$fyqEXEzfJx0Y+0Nf;T-8k))aLMDpYTli`f*Q6+omr z@Jyz=j3_?BOeL&@O>i8fWQY}{agX5&9f8%0p1X<@Rh)1ME95{S)w;3!M&Md<3ub@1 z6p^kjVG|9O4ZtSkq_kT(VMb>s%-4L0w`KSoGa_7&d*LOPg?HV;!O}Bku3)Y^{#18R zg&i_h;FPUsv8vo27VvDpt1xB2^%NLcUySokw1G0wU$y(z`@Dwh%(Rs7SnQ1EMJx{O zeC`HlgVHMS8xah#q?D?D(|_XPRoe4sQU-`r8V?HNm2_E}tB##m-tEkDW^8g=IG7n~ zmCsI5p3-!G zdrX$N3ehWSKd-G4$A|IpIK{AiJk5;2(Em4i*tzmQ;yeEyB>o#XBF(@6bQr5{r2=UY zap{R!?LM82c1fG~aLx;E!)xzXJtZC5ON?-jp$?crK zm%1sH(;@SGk*?`)hyF&^7?)-`5DM-!s#}x5R@Wy*CbEBFIy>QOv;f1AaoJSO@hB7- zU;iQF&a>3}Td6bkm$E=9Xptt%D97$QBlQa*HZ?xM@`gpDXpTjbA~Sswgn6b;lgE<& zg)F{QFpQO@)3y&G0lY8z%&cyVE;97WPNVpp4Cc!QD&#wy@P}*|`jBXSq|Rfsmxeb{ z_ge2lu6GxPD|R%OgC>p|SrGQVobt+vl14+T0{!-jzN3~@P+Nhf)$gjM#?zyyBy&W~ zQ*4?OFTnXF3rcBA&=r*Qkubu0>Pc&ojTgeeq)*a{0q5U3@{w56zx5FF3|Lcdys`~7 z7^bGoz;cf<*oHJd*aM2D^+wFd?;X-4cS5T>z;zuqPsOAiA(^A+vd^st7oO?x$0Qi^ zi&!zZE$x>wr3+WXZvNDQ$U$;!f8FR8U+1RExH-_!DX`MT11>1NB*2GPXcr?)7*8y^ zUpS3B?1?-YHq}00du8pYy&GC5y$`U_y zugLFKFo7Krs&v8e#3N%fTudEVS3-Q+datdaV4SsrEl5jT7aZ_3@Q06clkFYr(_t&x zbPj_0bD2gb>#2oYEIGR)%{W)zUPm$bsnUa)w0_3UI{^~6940p1gtYb#8A!rb9aI^y zGQP;(nQV3J!Mc4kZuaR;WCNoIlP6*IR4YCIiWw$?HddQRLo{*4atr2eEsNh&83f&H z+r&!ap?T)x93Y&RXEigBSng~t>X2QXO$e!{ibMguLX!gobR9l-De0euJ3jdJAs*i! zIGPboFhOdC0B)i0%B?YqU{)QtdFwhPT%T< zy)IoSYq1o}l?Z0)$}9>_`g@Q`uB30>pX*2<=xFTlRe;!^YxzaRr*EzA$Y=O>MBkFu z#@Okfn#BKXoOam@MI-Xl_I)7Na*BOa2etbgNXuo7;D>{%FJ9aAT#Zd1446VoT5b2! zQyGf*#UuIZ{=*?%qkL01lyadW%#c=)UG5!BwYX08iIz+#)nx>xE#UrN z_wkW$3lC|gE+VWH7U6Zr(Qm-t=dH>H#Gg731(*i6vXZGXo=TjmvVuB zi;QXL=~%c3$MOetNQ&{1&y~+v<;^I3dU|OMIK=c4^j)eN_kUfe?<_P~-RH2>Uh8{lj$4ywK1+e!dg4fVyb8X5yv-vYIkmHE*M? zufyx=^1$_w5}B3~&_TiG&0PV0fyW#;zR&oQd6t!Nuu1WzEreX0BG^m(2N0#I#~aW^ zPw4m0;Ytih=EJ>n43!l|u@$Gb$^|LPPe0PdXngoh_^HRAl%KMGosqys8y-p!hXWW! zSE0PsmAxWeCF{9FmCOB)Iu+D5YsGZ%0;y}boSowBNN(sl` zu+IOwaS)z=ns~k#`2K7QAZ%J7imx+*MQ~Kv);5k_?LXBXKmcHWXa6|ysG-}L^0gUs zIAR2Vh@49Ec+v_CuyGz5INiz;Hp*Gv=$cTN>;OzT#sdpZ|EaFVXYQ4ZrU|_60l0&L z0~?wvTMZnwVcoM!n)f{i<@X$CHENp!Go~P4;7X!efN>dT;K+=MUeO~~AXXY7UpF;D z_B*6ZL)@0x3jlFHCgLL}j{uk3yNz!2{&1-BVxc(4_&<^b3Dn)q^ARoC7@>qK zB{Ue#w;QdYLqmwQ-do6ts*B)5XOaeG4p6^Kld#?!jQyLJ`&Go-^H9)(Qg zwcjEuwvTHo%cpcCn))vuRwdVFFBYAJmI#n^z=g{gr71|nn&^Lt_wlcfaSwyX+w*$s zyu5`N1vGw%R7a24`vMHuoWj~{+(`=R8s{Lm_PF|&aw>GrOoh`E`Vj`_KY&WvkL1F? zg5YU~dMUH*c0P1Ck;AIIyOeJ(i*YF_*L?u6X&x2EpkN6^5=G`Waqk85Ndt7aiuTV> z+9SS?`<0z!7G!}|@rwwzywc0BM*7NCHi|}Y@kI0@aSB4k#d>DV;)v-Tp-2R%UqF%6 z0CIR^SnQcDu9+Nz!r56(sRV6H!S>X9EIFq2SwEE6tM_7lj_~9)f1#C~#!l$kCl} z)qEA3VMZykY0FPuqk8YjKtCRa$XLUC#HERE$HhInlefMWEd;`I6yJ|enK9B!cH^!@ z=`DVPwiM#EZ>yxBeWQ2m6qI2r+`P_E)8rKvkNfJQ^A!uXyvgyljL9^;O_;Q}oJ}y~ z4JBhdq5risl|fZ%d-nkEn)tAj9lp`abk0Nx1+Jz}ZIFEG*uVSPz5Cf<@Jc)N?U6x8bJ0_v`Fj}LOB z*^%}r1xPoxSQnn`V``70hL59WCuHk}(&!Pa(rL;?xNrn&70qZ2yx+F36e0v(km1>g zJ|CW~O&K7X&J35->_q}0YxrWj!KcZTzRhy$f^NTKb@Z?n5Z?<0emd<}YwcpSiHv_Y z@DbY9jt7eB0(VnOzaFeTTxD7zDZAfefUA$eXQPI8w79KLUp5Rz9`Pf<&xMma@Vou% ziE))|tqBD5t*pKru))^{8zb}oWWfDus{POF%Ic)h4>6PU^mq0`1`msG!kst2ikg%h zV?kbFwnJw1W?M}R)5tCoBRBCOE3iw*M>H$rUk(49fqi;)$R@Uq*I0vCRp490w@@#s z5h0gEkwbI-Hb1d?q_2+C^Hbl~DxB>(WIyPOQhc?<;~66_M$7qFb`!nS{ey>FGA6b3 zXa1B&oA`mb5!YS)6|J&o9#2hpK1Q*11zy1r5a_1p;~aHgyQ}0Jk8SH&la6Z~P%biF zslQS$G3sfMq0}f8&-fsS-L-rK*+Gt^aEY(Yn_R~ z=npg_yG&8df%ADB5=e2xY{QPk;6sp-6FEJ~e2kH<2 z5epm|swC2p>yFUpce)iKV}e(Z>o7vveInoSh{&nyE%-^%LY-Mbi(uCvo!I^Rgdw zHK{UIql6FNYt!G4&}UKjrZwBfgWcdXteOZN+{>sFI6xDA5~}P~f*_ulYd{%!3S>94CfJ|NMWs|Y(y)d#5;==M z$0f8M$VY%rq2L|K7672Jv{8MwZ$ib>HM5sB{Ocp}Fp%JoWg`a#9M%rYhPUi9x-etj zwc%%^KER6AfuI9vzq92+bz0_>Ke5;F_$w4Aa1UY@$V;hd_zT+5!^I&XsvL~DoKW2( zSDfS7)xO^Qxf2H%e9mgqR(ginB5CilyamV8VY`!SqQHD_A+Y;U*WD$G)o~S<1}Kxh z;3i^vDhxxb1fi9+++bp=rD%IJ%mmaUsk^=l7!^fMI7O=G=B>ETQUf_<08-#6Q_NM^ z-h6gn=O;{rS7-vm0IUW3Y4&4pDF1MQrW{wQv#5s2I@rd$p@r_bfedfJjKFcY`*Zdqy7q z1sL|PQ2&dM>OYabz9qpoenk-qf^Yxw^m^n{-+CO;vQNm- z%>$`dVqDE^6MVN+R{bl{o_blUWwIvAeB{1&7^^!M00bp>>rFU9Wc>(tM#7VzWYW~m z!5myc6(C#dQqL9@751+4P^_d`1^;**bVu)k25S5Oic2G%jGW`OrvSGt*He$YUvStg zEDZNr;Q+%Yo0>KYc|S5pW+BH76$FAMsyG+nuD}&(FCtz+vI|cx@02h=j-i7RzJ;A8 zoO(2`l+TUV;6jn*lQZ#wC4hS)y0)2iXx;cbQ&ktjyR=teY^V&4z>mM>MTk!$*+uFx+FEPh(jG@DZffleePC0YG+a#SSiOC}BZ4p66E@wcx0toF z$NX+7r}?;cv~wmt+(Ps4F*SazHMR7Lv_*wZ%Y$lUas&$W2Y3Dh$^Q;Uw7`D~GHsop_-+R&VyARW+{FS?I3DfP26qb^@60tLpfo#GY z_(lA|1C6JZM5MSy?dqPswUn3WbIG~zOjT{xeYl#_(sN7tmyfnp_L0>3Q~ z09@Yhyo94A&c(AV8%lv`gqqq$xwg(WKQwxhqja_v>JSoLN7@RMP%I7mxNUo4v3A1E zG6N*T`r|k7@?+)eSj-7EVUKf`@AcLO!=(WTx)Gb%8r*-^o;|O3I3rWHSa9tzrV~{- z#Oj*vyI8RIoM9=2Ne6k;CU<`Ny zzR6BbS^M;D6KoL0me@1{2;(+(3o5doyA)Mxt60Q8B@@o?>?T7M1gHat;t04OK4?WT z%p?ITkwM}_U?-Otj!y45(49<*a2@38K-2O!M-6FpSPn=zQT9(Ltp2ee5J!+_Hdxhm z4Ilbs=S%3chw82BYJAc=oIEGKi>H85ITC{ze{71=vmSpMQV>AH5GE;tGTY>iQW%u7 z4^&|0c-4|Fu%I#pnC~{(L)eZE;(8a_@u!Tny(WMiJhI`?AL&zNeWhKODg7 z@SUrqd(z4fG4z!pjdAC&lSF1#fGiO*>g_@~^ZkCkd@%j=hQ_0~fCPnpIj0;p&)*Jo zJlb>W(W7j4C@6NlT-i_~`HW=Gz>7?O09Fxs_hn4V;8l zn@5^4bX4)x6Vvs@5aSBxTXk<)qdLeum`lm?0h4h8!-ZJa6!f2)uxDKSz#^ zA;0~a48LkMOJxJG95;rDfa;GhB7?BYa0Orm^c%FpX^2RrgdMY~kgSxC*K8$%;~Q4Z z)l~_mlc`?DGh;dt4U*hnGfN?&^W#fK*T;trR0JevV0z9;*FADOxeRt-pqUZ&QM0-f z0MG(XuR(g4qd248zV6k_D>j2#Rdzi{4xfXl*I--gD{+}OdvnD$GS;qNe?g`Kg3$=_z6|6aV3PC8}Z z)^^U!;_{jBMY8YPjA1lLn%p%>b4jEQeqfFgVjm+_l@#dwnm*U$o@4UZ+|Mkk01fmd(ME7RMs-H zY$EL<*CbV`2=TR_!|1QWZyKaxN&TLL?ur4Tb<=(&KML^4$S!zjFvP<$g55@1>Bx@h zRvFd;Iv|S58DSDuw}gkz*6K8Tnv=0lp-smz3_=Ws2}HsA##HRHVv{BT&PYIbq9N~) zH1(#8`y~s&?#8(o5NlS9(Q)z3VnDkvKzES#Gp61}9G+BtOXkXLq$U<$1 z5*@{F~pmH-#t0CJY=w@t;5eRIbVR#1GhF*MBpvw$INUb)w>&MNvdqu7Ycuw z+W)GE`gh7e4hA6p%F&#DPZxL(`SdzCS$4m!j`etAk2J^khVV#(7sv3@_zb$Y>W4DA zmk*95$llU)kzu(*G3qii@Yl^dnWh|oJPZ4-YV2F$b^^;#K9uLrgHT;a-upddB=|ll zG&Ml*vNK0JM`cZ=MJduw5d|OUQv*ckIkh)A?@=FrCo&Vv4DDIkuyqhwxrIg*1Y#_@*f| zEsKtGpo+o6oEGlF4c&c`3cFGz-x3edsgaKXnbYzM`f1ml2)Uz%YZSSPE%PzNW3;ti zC_sxQR?7Py@1j1R7;PMFCte4MM89Rpf)1RsLN17Zxf&Jdh=90~nvN7wh!3=67QS{=kWX42ZSQ=lhsS;t3BF;3y1f-zSuM{5Gqr(HjBgp zW|+yuyXy&X2z(jnQHDucqpL6XaAd9`kDO+F&b?-$kb&1Z-I|D>-(Mh&V_)$SdePJC z19~jM-a7sb!@h@%mzhLR<6m>-yv6vPefA{D;w3gpCQ8xN*$820Ws){alH^DHvOF7*a1XgcvQz$5CR}b9>d}8aUfjn8q&i z&3>)o4nGE*^c~#!A|{Zf%UEGpvs_^^+0FJ7pmKkzA}#{NNd482NF#ys<&i=KO@OV^ zOSV+$&;ese1nP3T#lLjv|CRdwc`g5mv#33hZVC~1Np*!G01CRcW1%YaJEI!2Cz<wM>uT0NEEhJ0+9x z0*`BN7lAqRwD=+SS-tlT^aK3yds7YP)F-ddnFk2%mh*UciyPB_^3n~Uz|k5xa;jfk zrkHXS@L*0Ng zRI8Vf!-;t5>Ctmp6fSgG*Q)0Lv;|hl!1OZ=oQjeVmZ=}lt0OHd!ZA8ey#hKX#kHM!C{(vsd(1+7euKSbvsyG+@k(^qb#)FRJNXDrm zFqB>dG17m7Z-juja^lpga6HUW0n($P&AlX>ehLx~(s(j6tIPWZ)3xZtm>3&TPO8 zdbsrDz?^n@w+3XVwFOk5?dcSkyi`O~=dOwhFH-TVpGZcHHx+P9Amjz8^hLbpEe%b! zeL!XSq>Pg(N-fOHpitBWGsp$+cnO_iTB|i$tQ%zvIf=*q%7zEGiBg2;pzm^90z*$E zd04Y{NTBiLFdaMcLr)r_Ej7-wxCv0^M<|y(N@j5h1>k^`!;z()vWFLCfdl z)%Ss8PPjqAnJx}Bfsr~?I>!>!T%bXcK3bWy6-2zn65s^*54N=a_kJihlR7!fMd(g1 z)9q<2Tp_4UIcRpFI}GHm-4GfdihAdSvk&Uh1%j?U8QB{S0qU;`Bq`#9DC8& z?Ty#6Lzg!KVc7gcEsdW>i7!q&pJ86Ac&V~9>{ki$qG8q}l^05jUWQe^H`oiZhCDbS zB$r*6n7GBj%O9KP?5pEzbEWE+Cz8I0(a`C`E^qA)F!+$qqB(;K_bK_Xi&|vMJmNnk z#2F@OrV-A8#koS~^=Nf*)&QQZ$+SyZb86j&yn&oc$X}VFq0s_{#Y+rW+g=HX5iMG| zpKy#e{E5rDYog>3@g5L1Kwwc*E4G9V3_k9pTe#nS#rqVF{6(#xnqMwMSZ+49{v@D+ z%uWVz%!1XA2ab}x*^`k0{v9;Xp3HXxcxx+O4a>w#oTvVz?cLClB!}V{JctZ=%%j>U z2mX8AbCktS6JTJZKO4zhED&`D?|N}kNN`>|3Og3 z3X_4?Yn^dn3Iu@OvZJYSh8eF4imdS%@Gf&eRGcZ7Sc>==9;jSPTvizxPMdeIHtTWK z{S3+Gs`HX6KpwDaN>T>sMZrehP`JkNj?br?Wl3LqU2tKZeUaNFveXn?o_M-YK!I4%B0zf*7qFX*N5|qNebdB3MD8eg@t4(7EZEu z{O}FzV#p4<`L5a{oGJF={+Wbp81Di+3E`N(n<1rm$OTE)a;7viND;I1op35ac0y4e zU}v?tQ@ggzGf&1p6cWNBv%0a5c8da=9jE7$_zYy0o!*r4lLjt%P)60{NRxyJD18|i zrD{W?0Mmd+d4fQ#@BY!n%ztAzhOk(5f`xdKu1DC zLozGH=T1ZTnS6fIAtate@|J!pcsQ(+A~cf}QU)>p70v{`SazP4yXIT&4C!tn>aQk{ zRHoU=`NxCk3^_A=d5{r({ar!mXlx-g``2t^noem&gHQKfsK_JH}xM3@8*2M>0 z|6&X`3un$jZq9rks)HlL7Q&unXND%4eR4{bMms0u(v#6jr&2bh1a%A8lkE|cJPI$T zm>$(2pJk>bKt#}-AY>XGNcx%m`?~6OSVO^#I-kNQ8feQtmu^uMpq1e?MssrPnX)qL*Cy^aj5Gh5sO$wG<0G%-R7%)E*I&ti)Ww z-VVP09=a(vqTcCOMRZ%f`>kEa7@y@k0Nn$vHJ^>@P|s!Ig{e{ty-}p6qVdKPt<*^e4rOOQ}KUYvribH$2_*-z~nf7gc$^_GDyqZ%(27f`QK8?FO4xmUcR3s-6r;AAmy)r|8x)nT9ea9$t zQXfo@pn%panQ2ur3I>mUr2K$oA)zjxD-9E2c)WHOdaHLt?YT|bK4Gi!;4;Evg=MvA z1G(jOEtKi{T+fGTb#y>a-MwOR`RH=@ACWw{%YpBXJjV=Ip!9QkGDNVsbKxpn|NyM7T|vwM77t3Oie=b+Q<7cmZf zb79Gtem~wd?Dd078V2iuCcrpxvCIuCrNWG_QZ<$vg1)zUN1r;;29~xDhd0{G3HpKR z#+%6s#t9g`g~4uVlk57e)g%vBw2yiIgRnGSO^Dsny|Ml>_SJbEtX90TU<5Bs(_$LF zHLB0-JOW(fQVY+o0;4Mfsq%x{-DQIl_0-lHf(9&dJingOs>+NjPocDr;@qx<5066h zovJOxi$dY#Vp_t#aqw-AvUFUpTrh&MkAA!6y~nqtPyn5>^V*yzgf-grZiOB#&|}sk2hzllqhZi8UQQRPxuZU{^lF4n07WK9*;&jMuQs8>dxA%-@4& zBk`%+Y)36Pv_vm%T=>KeOAG>4cHL=A>?ez^~#=S}xCqRsgM)6qV(gM9(Uft0&( zez#4=nkxj?(MtuK?RPYssO;QBVgo84o1Yj7jRTbh+pj%fqUGNY!V5!5IiX{P`nWZ` zz+=HHe`IIiNoVAKi}34P!p4D`lBz5TPz;^vd-mlHcIYa3@tsd}MRy+vg4h&D7}&=9 zo{r3KHw=c?u}HAx7_YWQYlfUHS;Xn2HrCAcE8+J*F8AIfM4P3buz?Qa2_3DY}JOFU5 z`X&n{K%6A0?hH&H`-*P`Z64PewswW18Fh7{2jF)lU^3R;+s=unWWK*7DWiPK(M@$& zy13MapzB}(VC0ARneB)4r+g3m5v&n8EiE@7^jz0m(1(#s+As^U*S~rn#ZD>Oa3{0WO#*IA;)!sVfKIZ!-jBhxQpkyx$Y(M6S z%)4dMHs6$)R_h|IRW*a&eC{OMH?6UiEtjww6q|$R&lYw;0UDlY4FCy=wgULL4WD)hRu75rHo%9d0%#l6a)wnQ*Rh*#@wfXKSR30wKFHtrKMSLTg z7ip*sLoK{oqjo&z4FZx0`ODPq%aP#!1{^(~>WeSa<21{(e}|9F4gx?3gAjvs|HNP% zVa2Y_X_V$ALVhD=S&zhZ6#)Ye zQa96)Ywzxqp}sslN#Sn@H*92o6ckPly7NZL`I!>FhMbme7$oG zC*9K42@)1jF+ia_z|`wj*>H1Ot{A!U5wYyC{rI%@mMW;W#quom_r9TebGsGT5P@;5 zYwAV7=k#}k(BcMRjGfDMoSF6Ojuj2Bz+WP(XnXtsN01OuaMru@5N~0SGfn^9Kw+Kn zop>@$rZmMK!KM=NyS^BSw3ib-R(kURS~lc#zG*RmznDF*th|2fs*y|n(F=Vp1fV2{ zT7i!F_Nuy2ZiTvTP<#epjVsj}M7cT7hu<6%Rk2v$i11Gu?kCMF0Wbg=hWfLQQ#>2t zB3j*6XIq&f&QLXxMl+!#e(uD^aI#S}B~Dyf4nIE72>k`7CA_jCc-Ateg*Ug0B)LHe zRIHBkLDZ{yAHfXKSt3SM-_ke^+`H@;)23L%12#W_1jF_vZ11|ppJcH>Z;PLn6Ens> z$vGyi=zbwVJ*|5xzQ$;?Oxg#>O<7yEbk zpgzLCBh^=~f~%Vlo2L#!jv)uwXn*Te#9-2kHq6jFfEC!w{_#^6=)e*>dlrfJ7-nmU z-OD%=$O~(+y>&QrYyKG4;sU|u5O$1dFt9ToT`jd!>v0qNEq8%@N*+0x9Tb_;qK>88 zIk)ZtBs;s(i_CM$pm95gAg1jN?0`_HZgzkq@2YR_gv1gEq1 zLmWvnGKZj$89n`%T_MXv9l7#WO}P`B&n-`SZ#jD1i3&X<0>Dk<;?@9U;QEbVbS+Se zqXFs%;|$^s@h9X?d6T#g$)T)f9nPaWa+)oG_L0&`!sP*b5eShw{G~X?+zblyN1tkm zQh*i>)NcAG=!N?I8^z9B@t&mDuFCEQ`uX(%@^~!_=SYnF=Lv;unClL<#1X|Jp-JLJ zgTcv&gk!PznL8^1Y(Z_ZkQPI=k7Z?AfF3lLA%7T=R$@o|K9dBN^2#a|@{~Jx-J*m{ znzb#}XL{Cmm7c(>T)@e=$Wy|hSc;#=@M}Wg+)%^|2XFnd4vzi$w|rPLTu=k2fd7Ke z{}{9Wh@3BK`m(0qVf6WT_&f{2e`<9r05TGOx6mRUaCJL$Az+G9w_O^*RSCT1Nmk8IyTKB7eUkh=luSgcmer z(N#P#M#VS*NtKh=17VUV?z}(9e>LC~H?ERBy44Sm7|)aBYx>%To!ELI@GG&Ic>Qgi z^@oS|o~4pl<1H;O&QX;es&&Ol z9;=M`OsGc4r|9sWPkw;q9>{o(G_kOPGNdrOk+&=>03x^I=lHVGZs`bfJ=aC!Y%vXl zBB~M4L9~tH2YD2^pS)Yl{y2z>&07&3v2enpU zs?YCPieKh7cqprTH>6IJJ6cjmWxWium-m`X`|)(w7(1RyaMAh|4pY!$>Z_gK9wTteDiH`HD~+f82McD znG><6my`uuXoU1hprFy`tGn=)dzDE=Mq5BYU~Q0&4lg5LnxUUQZHqzcw1*+Pu9hKY%nOadjb2qo z)XXnri2Gn78WZ`!biTb6CX=s=Dp z#)_!2t)n{=PoUY9~X957&9If*FG} z)|4ZGVN~WgGzhlLO8+oM{Hr78FBSY}b>{z01#eD$8M1myQw|rnTLyxv^XgQ(RvsuX zMU5v?O3SE62`=y|&0td0U1GwTVdER*f6Fy>SE~zw11Hpwsj9YqAN`hp?_e1d-dmDF zl;i(vJcfv=hTu{K#?KYa`!^<9UYV%Wh=xek%MD?WmWPP=Zk89H`%K#pEtn3q?C5wt1v)GBpUHcp`NZDg^Efhm710*O=|wp(0t3Y<<~RjnMY(+-ZiMYtodL*XXlY1E~TZ#{FlLAAs!Y1-kH;FP@Y3>GBJ6()SKDWo>^`%1S*r3#MwBg)ug;`80hj` z`2Gx7m^0Mxsev>oubnhX;@(R4xH#7ci%^@cjEKQO9xj`@DUR<6fYzwG`gUPEP~cw+ z)Q)42PW*x-1Sv9)-ejDGPV>9rW^aB-@mAztap>=9$p15N{-uIF{yh$n`on)Pp>bZ5 zzAvu$4~>YGRkUY8=b_|RQXbrRMxf0aQ`NRH3b^aZKq~FLn=7Jvyyrf%sj_vAyRFfc zP3^5AB-L@hpKDDH5tmXHXv7l3c~h~c2K)@2RHQtghyG2(Hs2jwM9AS#cu_a;sGD>3 z`UDane3^Z8y20CDH zM_y+C!X7uiUpA~zwXugY;{0@BEN`qjG@T7Ap<<2$()kdSGcQoAh4Ce-$`f3|?d$dh z`RkY-Vq!pyXpM__4Tc1p0Q*_irt?!Gb_e$NOW||AiM}*ijOl9*8@5g?q7W@ea+83Q z^A+<(_!nw^nbtB|{ewbK1qBq|MYh`h*Yr({Qry+=#-;)(x@8vGL!11}v0g+g8 z23sP^YDNU&im=|$0M~oR_N?vbtVfI=e|a2Qcqg=dH}H-KG{=2*{$Ii8O9iL>rGhE{ z9X?nq2mqmPZEYH(INyn-FO84b)&XYJcFS^ zolmkUXhT6Sn2PNEa{lTW%9r>lL%c!P;QPRjG$GqxP@0l^V$yv>FMVZZZ#8H+{6~C_ z($CB0XsVB0s?ZH|Xe|9oS6g$tDK(NX2TFMI*uq+)Gc*`_mzKQ|3F4d!#n3WLGO5&g zdBkY-ku-^b9st)PsU%bRSV5=1vK)8D>)X6X+0Jdm#%j-UT7z#O{Y{2CYtC^3P_RxR z3Xr6#JCAae@%8j2Mp3!B%x!<3aI$5uC9l98vWUTuV^!d{tp&7`rUoIGEGJ}U;-Sz@ z0FCcnB*PUaV&HtpRe4=s)3@-&UF;UCC`Mj`ev<^W5IMYSjJo^R5|*g1q&##5d($$NN+OUGPiOlMXFb)ib=4>YO4vM~;gJVoi*&1>T#GOJZ&)!ciH zacyuk5HjkGEz|f7kvPyfef;;)bJ_CE-}&w~GX#u*nZuiknEPbB;BB(LVlwxe7Wc73 zJ+_a|X;5O>j#|2m$2|zO(oX9_IyVDbA#UBkMhIFceu6OEUL$cb^%^s)!LK8zt={dYq5 zEl_upa@N<@OYUG|q^H3}9E7=xL_+AbUfV)mCQ{@HIAlBIiA2CBPC=o0u!yPjNBE=S z7~>ZB?$zLlp6rmJesc4|Dq2t5n`fU()ikxbeglE5wL2g>Fndc-&sUgxI{sJcU_YUy zfN_Y=sr|dC-$?&qgND(Sl1~^wX$G=!hh%8YZ}jN z=2=DUmrlFs+p@jViz*+b5LOtCVS*+uP&4oG(6H4Wb?6H}3fg`18E{-o@evpBh-M`$ z{}$~)nnMb+48F~$C$>8eAZdp>83Xj!Am7WDhDs4D$etp5f6+9ZtX1Xawj+|WW%4_B zf4WlL`KC>w6eAUKqTTrhdarObB$eE-Zcen)4|-G`iA9Eltg`U%&;*v8KAr)@^MDPC z2bK#h^^xzT*hC8=09D8Z^H0-wsfTAWIMVQ%ICBJoyvOQDhM|L+e!|(bv|M#8W<1T> zTJ?Ih9}gt1afz85Z6=&s>5q-HMGiXX{zW0C?8`mz@Zy1b&Q-{n7xk$IPG0872tYaB z{1G0)4jbpTDJj1PH0#c!N&&=J&J;#9Q8s0iPsukxolJtL^xnv|sV8fEgBS}Bj7KV5`lQS=?(*bu#?!sLVf2(%pj;3#nvDbc< zR1MU4jdiieN0(kzy>6vPy~h*L5SqJmoWz^nF=!iqsF&WT3R{3J&*(>AyYr|V&XpG@ z^w36!jK&`C=35!7sl+|n2o<>e$pY{wXK0b7DGebtB?mEk7%bwpK5l_&a|{z)C<^D% zu9PZ=$AU|SoMplMg#33|9mL`Y^NyuE0zd=YLLnX}6H`4wqr=w;pkmo~vpK^U?rupSqdY_poLBl@l!5B(S%UJCQ9k9C>$(!Wn+@A0Xdd6o;Z1 zI7$nvF9LZ(JAy5K5LJ@O2i7dkSn&R>U2M;ZZhCBQ0Y-}fSz+got%FG(yb`;6RN4|*uml@; zq=ylqwsk($PGHyh@uI@H{gJFl?R+5&(rJo>ZAqYFh-}17?d82J$^2}LLj(3g(Og5; zRM?GyaJOK>P9eXQ?+D|MFzmEEyhWLq)CdYRAr_7&BYMT!O7wER%RN+gJZ@#S66Od`7bCR}RP^H%4(3@XIAF`gj*{UY7YxwppUW7sRy#?Yi7q}d+`i?(}qcgL^g-n_Y zoSrYV6lGCwh{V`e$^8AlDhT7T@E;5To!~k>$!a4tXrP4=+8@KlIUJ-z%Pj}GYumh6 z>L?DUOC^O$Nfkd^gh8Qb-mDyI@6@{2Z*}RxbGu(&+l8*QO)Tp`|^bSQt&~W5_Xc z*qsT!Q;k#T>IlEofjhCr+b?B;Vm=0~_=HDtziEA7=LKp!erv%fjTx&BCmr9*@0^n@ z+%P?M71t4nIeimg8D8-Lw?|HMTF};R>5r^%oCLi&D~?&D;BFLYP?`PKPWH2Y{o0=* ztWL==D0$AuHS+UqTTA(G7u{k>Ca3=6-tzabJJ#=)dn>}uL* zYWMen3`D_{Y_@WOr;$VZ?eR!gb`O@d*VN*Hcd*2B{OziS+75M+x>F zc&9J69rK~h5ZZid5yA#wop~$YXb#S0EfFYkzT~eckL9YJ4tIXqSv`sgDHl2ZyNN_1h<9M znuU0wW8o0L3q?|IyVNtkOtcR15k#+KWDu=1K!B5;|7vrrw^Rnyj}-!U`4Ptur82)* z>`j*wr~Jmeqvs{M*_Czcz#9P=E$!>?l{;ND0zr~|r0vJVQ$L(@A{Xn4zMxz^@F}pmeO+2i4&>(ftr{zF!*8#I% zCk!XfQJB8VYQ}x!=+2K#9Vh>pcT6p?&P@wsRI1s~#w8&_@$xk5WJ4~d2AU)g4{TCb zXb(UZLzNN*@Pq#5#{bs3ANj|_>4?wkIcNASwBfDyu5B*KfyPyrmM{G#Xu})lbfb{M zv+mF745$nV(s=|mCSrDuRjc?CA%E8=TI#KMtat&4ZU-Ea0XjdMZ8^PBI@~z! z;3|}2!Cq#p$lNJn6T{qJWMOBn(j#?UEp7(EJ)*_V*|{NY+5`()M~8I`PWF0qVS%_M z;0rLQZe{AFIG_&bS>^!i42PdsJgQLgyk*NMiN?S z^(w%9(dNNonUJ(&CU>BI?q|PT{=ltwp1-VJAn$@>_IXSVgm2vejiwDSuJv7NfRt?( z$&EpKfFQkQT!Ul5wx{rNAnnS*%uhN6iq?l%NM~_esjo>HeE`?z~HHL>fOHNN@Xo##!g$ z;d1G2>IcZ)I)OzcGYu$)0g2)f=!8f%+RxlXYk(qCRLp6zJ{_*h^u!7MIP;Jite*TQ z)97NLdYkX4fM8&$$~CUvD8c(=TIg(GP- zO)A24RqL0JF6D+7Uub+uF!O1~RRfM(J7^A&H3&EdS|Hd=;Go^Sqh@Wl1J$>8(lffD7@hP^+Y#Oc zav!T~W$Od?{!HmfSyVs|m7J>Qe@DG%zQb{FIWN-H3KRCRI60mUzV!Bwz)WOf9PN6& zY|-c86L*0L9~&8;wa}v>Wkm9a&Y4C|;KXZ4N-fI^d+xq&>>4}iJ-oP2`@r%7zB7au zjZ=dPEeYp3C4r;ileGmF(|_GWiX^&W@EKWaXh6ly0z%G41=fTke82)|+jc4ff3(+D z1YM!YM(#kvn|}|I;C;;Z?}gI{bL z07{iS{bSrP>M&Oq6x#r~1KnNrfVyZsPOE&9P*l+UTP*T3M|E|K7FW8oP+chWJI=Z> zap2z8OP89N?A)3VA$qp4AD-vShW@1Hbf7}D3$sBIpQnR=m)cj2xJ1qv!iookua2(^ zA&DXF$rg1ZqI%_dku^ERX9H_Mkj4+YmIE@sx#dp_y!efu+1KgbTHW}9yq8)}8`$P* z+#X*11(_dj725tM&OtkjrqG(+<=TrT|)p=aL~2CVtF!eU-XUd>9yKrDSzd5nX_~afLjGc-6+1cZXWInt5nbc!>(QO# zaaDy*NcBGS3r;*|-Z!~qE+PQ=r}x7*_N*Mry<85npp11?KWg4mO`J!*Ie$HX9U)byEA=xkcF->R&;^`A|Pk=UD3h(WmdI;lW26^)XJnruF) zmsHqF+x8aJ63N?V%c)Hzj+h~vTo>jr{YmF8X)p*~f_hdr$xA(O^3WwV|Co0lA=z zkT8LQn25BPvdjy#SYbO<%0i7D1Al{0gu_Kr#~pe%}_8oCa2G^n1>TS;`*&C$+O8Ccp+4OG`LIDf)5lksen`l?WJPRTu8Bkf|P%8@b0v1E#N1h*oYWr8#5K{L_EzV zfJo0$nnb{+!@?K~21CSPz7lg+3y-wQ#!Lni#w@}6>%gEAKRs@?-ZsM5dL;(PxO2rx zg0K%IMvZ7(=s{eZa1J72zHbmRX)-)o&u5;6itB8lP>A+$O^M?)LEw_3f;fu~?vx$| z8&6emvH-(uSqe%~b4E5OVSG={(l$HJqJ+Tl;-+FrNIRw2JJ!=PO0c87!i=VClWPJrg zMZcPtPFpU@gxmQ~Hv)&FuEkNL_xUV!D=rhXbV_6N@}8lD?N7VaZCK_`VLPY6J6^t; zC!r}-GW!wqqSj3y+>W(J)hq zGnP;n4ZA0_P6-+u-6ht?>0PotX zj|={5EewP?*Q@5P|2|4_k<)bAWZ(prl(g%7*QSWI4L8p>V-WGIC1St;3hC&9U{cG1 zo2zK+;b8%qzJnzG$h)}P%G}>PN|Psuznx6x&Om(&FBQ3B+0PODm^py>KN3ipPpkP< z;r02O&UHZE{jmyrfoej9NddL?2c4CY04N4Mpg*o`nThdQKO?9;cLgwu7mlD;{$^cL zacdJ@D*{nn3qw8EFPDx#SF|R7UHvzExPSa@Ni}n7T6-P()f<#9Sh2b#iK~vcW zz`z9oP+Zvam z3_z6jDn4iZsQdAk)yQc)iw>Hau!>7(=P9i10Ms=f@#N( zUdaRw=T<2Z>d9hXHB|-YW#8e|YH_fV%XZ#wfW8v%we{v4Rv$9k=%C-TBP)Nrcyx2U z*8h0%>;&rueb{jhFQbVv&G#MU296pC{_Y3s_Fw;YNX%64p^KD)GM=DnysKI!<^0rS z`upe=_|YvO|H4?(M(mJN;y!RxfaG+Ei8uMK=30I;CJIg_5#HvvTvdCT;92m`UEs_s zh#mGN_Q|(E2w?lc6(6Wm&W8^=7+CwrGB@7~^|kgK-)R3!t4tXy&Z(ywUD^XgR~e%< zy2r8=DO6{z2Y!~2Z(eP#A@~TsIdP)m(!otgdJr3u0g+ullibe5b4mKXArpo>#IRGbh96rUy#BolgVJ-3_%44T|I_ku zY7W>djVRa#Ls1#Lp*hUkRbm6ShNU;?@h`;w*;DY3_fh{GYBS+IH3mcG?o#dCl(BHm zK3^)CI1>$yJIvUC9-1AM{@yEopd|mRMZ<`c<}?N0VFA7vf7gt$01vBJDijVv;1(nV zV$V%uRCC~+>)t;8Guu3o`O~yW-h@oou6Zsy{-Q8?6Pxq(pfA^TT7J`5Ra;Aow}$G@ zpT?i$kVb(eZvi!0CM^;?KX?>lRt3Jn`ZN7y?O41HO5!IN%{9*ZKF+U<;pzES7DmN; z{cGA@MHBmZ1!n?4v%6?D`B7q?eDXxT^r2Dug( zsmM(ui5@mIn=G6*oeEwA?%<|{c3I>gOjaW*10;kTu$hi`ZQyOTI3jE}%T4Y<{;9)s zOYq0bycH?yA2p(Ak${IqO?E!VKdWNt(tp|Ju&F1^=Ze^)fn8{TEus;Q#bO%`vtcfw zdvbk8*FG#8p~HQPi^gfi=^pG&y#r)4u0n3BkKa|!z8rYn#RMfTjzxfT=kS=~C-%=O z@W}fIgEam%p82PrQ{>Eqg+z;n?>OU?pJo0;H;QAm0Tk%Z+xjQ5{NpBqCJca|7d94z z#yBav#i8P-WB;ir8KiEyf7GU60$Zxk3VJ$VnG7M@{_`P8+Y5@ay;zdf`)>b@1`B=E zsCvnYZlDwWn0FCC9}W2iz}AEqdI#<{;qrb%^isqM5l(ietB*J?IkG$h6~^7hO?(|a zZrtjA9e>{Od(W$oscNGq^BXmTu)sZ>vGc1v_txnp3+m2%N$%lFi3mRhz9jAq(G_@V zM1ZD?i`*M>3au*}Vwm8D){S%J`6E$kcBbi4kj829A)IbioD>~0z>9ZP_jNkoy3VZJ zgC@Em3R*Wp4OssWl%SIBY?ToZ z9TP|c2!OtV9Mtx^<-3xncdT6QPtuA48G^D`c}x^=EiSMlx6DW-8uEzygXB66B)v=$ z|Dm82lZraT~Nc1J;S7j9-3eKB`ma!xe@nUI{p>$ zvWG;rc*KooD=RPj64JAAK8umePuFUF>DZ-|hB#b1E0qA{jmEOD#1>+}0Wh=GmU3uk zmuk`u=}QO%e=^t=vr@H2TFWqlt&oBt*K*_{v^Z-=*9IO~Jv1hh)XeFgVr8vbV@fD` zbLeYll;9K;JvXbzZtE<@4tA6x3f=v)AM_JxK|zU^-ZDM?|mlY?fZ=c2EdyU<>5F@-B}{v3d+KZu6cDxbidp@o5Ty;Xs}kw zRxzVnEZe+<8VwC7^-`8&g#0{iqY-Ax3=wLZuyadC3;u58#TL0uXfTe)vDw7q_3flDw8wYOjE50gN3P;r>WKqYCdpys=}1ro$>XM3q^j8{rmXd$C0P#ix{W=UYt*jD8!|WF@^vR{llo9fg0agC8JvpeQ4&$9 z4_LuHUV{&9FRi1lm#{AM6%vPp>gAYrSR8&j$0Iy5$x1?5aiHODtoI*5V~lf^kN@lo z2b-8YEODL$m&CRizyN6kX!f(#Bzz8ryq`h_jzm1tGo9mBkqf+1vGzcx?>qI{jDpBo z?o*7eanDwnjdg&IhGAAe&F=|$gu0c197QX{@M5gKK)i@wy`rpNX_b7YyDO4{z04`XPFdr z4;=9|QxpAwpnmxtBViLXElP|a-yBM_-%<9*fy5Ny4_++NXU=w)U@e0l;`JPl`@VDg zacX?jWbSNf>uehatD1aC*V6Cu_@>kz8Wc&0$QF&cn z;gT4o7j%TnY|0x!TW{>Egz) z8)9xfqp`d>Qtmhw)!dhr{9FkadW;n|TSuA6jTC@9Ks;&YPO5KOQoQE!#{|HChk(Cq zLV*6*g#00te{el(`cCXTV43cCECN6Z;nj6}b3YG8LW6iZ0P&4xC(7kEk4jvcp`sCa zi9u^<6Chx8-A(r}NiuFH;Kw#QO$E_c4$Z&Qi%znl_lKE z-_l7*0Cq=^BF!WUQ=FM`q3lT|P!jSssLs(qEjnNAMsWL!C<_AjL)y`Ruq}l_2(k59-y9V^O1@Vr5C{MpKK!wBlq1!jmlcB(@v0F4!o-G zP@epxl3(Rxks!b8+pF%zUx*q7L5oil!u#d_9a7hOzML9;2DYu-BrC)V^BMlvb~%DA zZiyZ$rduBk72$UycieTK2L356Tcv5)xb@P69np}=?~Gl|r=BG7H4bn5AK)(t?Fp>2 zpfyt7$oD(E0VG1HE5vf%e`1YB{XxK2tl3Xx;tM{W+xBf^Q($i3H7w9~fM0}fZ1SVtXg@QNDVOiuf1bu?fe=~O& zKO*p820G422w9S)EaO@9l3r>oJj?)O|JlvMZb)ykJcsVDa-)H816U3RaTE{|T=aPv z$YkCTMwl{kde7z!++?40s+HgZ6-%}4T`GtGWi<{?4iUuzl6*dp|4* z6N+jllL8l$#33c#vBnwzFV5LGVRZ@C?3yq}e1^#tGZ?Phmg~#JIJiL*4rNGl%C zt%cZZ0mCd7$F^~+3fNtLkpRBPw>z^+eRO62Zn_{>l1XzfNvYd>EjN|J;d&sVO~o3m zZ40C}y5P?mf$JEbB-2DSs>M{?W(PwGffJ+X7E}Qp@yQ?4Ti-YSFC`6aSSD~=$JWdL=(Sf zG0KbFsn;Ge^o-Okim)$?y}kdAHJrlw7N$1#h6J*9)@FwK4g^Nlb_9afmX_951pHQ3 z)(*N3rq)*WUj}!&GzNxFe1?C2{a-fAUtkLU0#nN*s_N@jYVh%0n_nJ|bzO7R}X*xSi1qKQP_cU1tajLkkD^xW`iBMuaQJ3k#NQp++$k!QS+{+|9RLN zVDss_0FAKX;64k}9p=rD-?77(N0p=7$>tz@Vt(ye+-}O2@I5b3-Bcd-fdm(o%4m%9 zTUg`6gXWJJm`;K*PUAB*=DIL}EB=(OM4S0FF$w94Pat;6JD2`eBi`>d+{ zmGM8XSoKtLZyjG!y!N}YCis>d>0my@NJ~<9`$~E0;11nM3nDzWk1&!6n z0~F{FTK=l~LK*@3{Hgl>^U>c`UkCu)ujECoc*oQ}4)9$RIXxSWLF2qJk&@)^pZ;mD z{pTHPI`}t;U}oq((v{cM;0=gKKuCfG>H(=)iRCbu4Ly8gJh^@&sYCCp0}YXD$Zjp6 zSA;aAel2hT*v)v6xH@z7Rq59_8#tukR@$5J zhXM9LgCm=_FxvP6oLAfTQ4C_}TD-w7Kma16!-br- zUO$e{&+TaUnZP$%%=3`BJgM*SU)6sPyhNGW8`;NpDjvugReQ6|4QzZ0KLq9qfl#vI zTSOXfLgy@;S|{IKkQo z_u?(lJx-a@SSR|Jw1S&mcokZi1Do!%;qC{1w5~SLEJ9ym{&f{)P2XImgzevLupIH0 zndaZu-ip57$g zr^j~!6Yu?+@tA3)v!H~lx+&OSx?9SidpAyGFI=9KXu?}Ds_-)b5z9SvjiY{Z{BOEOvER3nf5%5SHt{(EaTdxM%2s-Dd6#Gw5#h|Z=bWKX@JjEVd(2Jl zck0Tt)1t_mWuys?+g6I6A^4znNqoG9!O!01{rwRb0XE}2z|#=_#^=c8q937W5bfhd z)2nDdR1j2j)~5HwSTp67kc)|b%Djjf3Bw3PR0A?BDV}ZOwnUV;#BOJ6UeHIp@FELZ z8adsog4e6?$eEMv2x8InWU! zlc22)I9KLWAj+!Gvdz_eBr>e^TU0+q9aiqs>Wpv+(-GAYKb+&<)n#q%#F(+^t; zm|h*c{#|H)8b{5-l(DhI+eXyIn8PD4QSkFEt+3H#K_MpLxSvbheQ+#S5AH@c1oTv5 zWq?`#cqg8fN_K4;=EF6716`5y3gNb>x6)QF$g0GgqWg`*Ph@-Zb=eRbi)u_^!HhNt zgj@E+yFD30kq4uxUKMhh<+l#9GyuN#WhomEkZ<*}v&kgYn+)q?f0GnwVZ3lf<{w2P z+0Xtbd#>@nq16;Jgu&w?K`li0w`G>7Y|Ri2h=v@N3luGOX48RNhT5oJi=q7vTdmZ6 zX*G4QKVW0+n{9gus7yv_$IA6!i7S63ze#}+CS%Wpxs1rHo&;e|J}8OwlRQjiebvl= z`ZH&)L(QNe%vP3L#hlg?1K;Zt1gH2 zekXM6%6D#VLm8}JG`DKpO;uyy`?$zZ<@*AdA*d!L_W^6BoLf3tk1*6|VVS<j#>*u3^BMP+e^Q4oi)O;N(6anY>?~_T;QP6V%K{%bJvjbyzDh zo|A3l$%~f)LDc+c=y&|83jG1_y!A9sD)Ulcp${V#D+G=w7$B1auxiZ(#k;l0b%}MS zblK0ncv#)50S_h4xw<6RL&CNQ%9w`;_FmTZDquY=yZSHNFEgBo@h*2t?>?WqQm)|U zee3ot)L1SBcDIur3QW&-$n!3!4Q_12lK|)Dp1BrPS?#S}{VB)qu2=?{)gucPlp8mK zKoWZ8I*4SMWG2Gcr6fWm`z7$pVw-m*6&X=z2@@|6y0>twr$ zq@K8ELwwU277rRynMV7@%?tL95Y_bx^52lyf*T*OrhJFZc%Lgk$^w@``bt9Qj6?nk zLM{J=hpvI{BK<+&>jp}lGR5#oFiR<}uu=>#czZR^A`w+5M1qbtCT3^S{qCzpmPzi6 zsM=^QrjMD@%rK^fWvM-07eB#_1$G{sTz5cI00N40)54Y6XKulqHc<$92Mmj?X$Sq| zyv7OQN)9SzZd1jcwx#n4XzGa0UnRD)Oj9Mb!p0Bk$N3kQ{~u%T7@b+ybdAP#$F^Z6_VuwmY_+PEPv9^Stjj&Kc+XbB(=M{kg{8wdbl;HLE6VofFZbViKi6 zB1OIch9d~6Vh+NqLMbs%C5vC$Xt~Fx?;5}{5N2nbPN)vMkM8YF1BP93-%QPmF%K}! zOR8nq{#c<+inBmR&1$E|UL7C50PXjCF_n51a)X#cC1lcNh!*Owmek|dZb67HpoSlt zXrI2q8?>yib~w(Ar9JY_MjFBsZV7jy@DDX%&z%`%VT{M^mHX793MG&hjo}o{6;A3fq6f7Gc5wJKS^4Yj z7vNOvJu=jHLp{m)?D(<*F^^&R_NEVjLef)$$(Ef*GYv6PlD)HSvI+<{?D11`>zV_KVy4XWBd506dKK7>8r5WFP*(D&_(gT1mLB-^+6%g(Bh{4gc$#> z_g%n$inSK77rQ~EjW-y<%%rV9$JnMCk-J4}K_Qu_$`WgPAmYo1TWRuFZ&hyY&vl8M zDP9VC(ZAdwitQP+>p)jlpp`wOQLdT=OE8MKc>I2|4nt!)C|lC^!)Toxgxt$n(6r&( ziHa!3+&2UGn5`rGA-UJ>cV)2hrt3icxOGM?OCj(!{4GBSL;y_pxZ-o_gpTeATjE#> zcgV9$ZB`z#s%3OA&UxTU@g2W*&wmVP;j@Z~T+FvaLjMW_e0qN&73Jho?w>C+ihSxbvh}EG>!w zb5yEUQIRf~v2d-h_2s<`*b_9xfbrtJsRCg3jl#!U9K;T`7X{uQ1h103yEHQpN z^J=#YwrX4>e*=TeuwxcJItYzv<3Hu(&nd|0#EWwZ`N(&-nm&cNAC67ot4@PHyYJ@* zQWm9C2%-m?1ACtFw5@A!rilZ1rNP$VNYyF#fx$%=i{LM&urRmdVmeUH7j_#;yScny zU+G^vAJ)x&?nD+Sp>WAc<73_)Kk(&#K{xrvsA8BiBhSOB1H5-4N@z!(iUPX>%K4v; z)30R8S8V$K?moJ9gZ-e8D6EML|I>XyWZ^%}-XR*Pafu{_H7grVjkQ-*hiw`w?mt;~ zVCCyzF#ykV6x96ghU|U`AHWuVJabbxcdnm|yGh8K5NO5)^MnO7%;)&NfNAyr>MGUOqtG_ObfIFPvFv< za#V+`9#S|WK%3haWH7JT8#S7h$^a0PXx>0)&aDF<^kL!Z>%e z)Z+j}+>bx%XbM+f)dMS~?eZhX!5(nIAz_}*K$%N`(i*vl0z<_rPUk_azv~Ba6-VSj z0S8}^#@yxV_5zes&5D}%w(EbCpq3ZRE9pO?6|l7rhD7|?VKH- z6Ybei+l7k~q#b!8QtZgwWn_8A?ElJrw1pkDK_S24G>`pH_u))}|KO~12J^P%U!8yH zlGB-I9uNZs=z>}Gj#rh=dIu0TEF~SJ4PUe^0No9HtR$^El9*GySC?$mq43M4&u%B`QftjSm%xtbUw@f|jb+y4Hz z?`DrJy~=1q$F&O}=C5ksp7PmA)t$(=3&w2T7_cw3vgs?o^BZA^fG7O@WxvuPLCFF;<18_2LvF>!^k^i9Kp5z`yvjLU+GdG(KvOiy*Y#-Whdi%hzMEz z)0@r{X>1`5Yi`i?SS3<0Dw~yliEdX>mMv{>6?EkcryIgzTPGMbz!fQFttGTqYkE9b z4JHNz*%P{)VumECHk4N}xXPkp&Xx_(87Kw3FcfHu>~i&0xoHo&eluBe*ug#(s3(kscD4a^|>uv|Fp78tSHq?+yULAyjvC$+@#`3lc zZjG|j*61OJ6Spg?N#FH@k9@IeGW z0SNxPOZ|VK()RY(`Pk3aLH}HP=nlhBu02tyW+@xzUDiQJ^=`unZHjdvP8As_X}8B2 zt{X>XKG)22&3oA8cAsK5+Ek{_2qGL`EU0NNnFbCVQFre95NI5L$HT(Q0Hgb?DMeWT zNM_p6E>uhc41X+X{o1Mape`zj=P8QtqRr$vf2<_C5_ z)=B6xeeFZn6e_Rd$Ii~Hdw%YWhXyL*mx$%r(H!|0>NgkE0wa?vqE_|68RQnk_|+nY z$!4oV*4u~6xOH@n(Y)EZZT5gOsr^c6IVek^q{t|VvSinF!Ta2D=A{Gp z_T6hypkU}G0bla9S>YC-R#N)@$C;ZlZF5%Jo1i`5^a{U~SlPZYvC!HVaqk7EHCWMX z!(b09BrlOOMNjkz^wln0LZ089i!eL4!Yu|CSXin1@U2@x#uZ7e)U8qU+n{Z4A@Omr zmW%(4{YGm{Er`Y()TJb#0!xvfsxLd$F|%Ww zB+}t#cTge3%p=Vev!8dAqSsx(YPx+#CLXKwCcAM!7Q={3A#NWeOW?QI-9oGJggZ=e zjBiwmSgWMcuP?0kWCTG=u!Kp*`ut`F#t4RS0)B@TI9XD3lq5It7uG&HUB;BpU|ihr z22+B$8S@9}xZ3xz^{T7%bnEi5R&M855(=Medk}7HV9hp80)`>ft0tNnZHcSb?l3>l zwgwb{CgjWpx?QV#)?ovs%VuH7B|I{y)4O2PO92?7^|j~z^ekS9(0%$`Er~iiHC9U% zT;p-gg=?WugexDuaVm|Zq%Hys@g8SgxQMu4d0JuZbpZvHS}gQ!+8;?iLa?Ost^LJb zB}Z%r%)iMF*+#LdA@B2x3ni2f_%%u2Nj7{b&$Edi175RWA3$(k2^w~qT69W0dwta@ zuj|Z}tkdqIhe#0J*HL;X{k{{L}@G!p*(Yc9^lhMqildA3et z(X7>Kfb5$c@Hz7F6xR4N(zytELtf~*W%fz5ArfbT8#;Kr{^KfxT$ERi(rQ2d8C!!h zFGUD1W@eblogo4bw&PWoxUcg3+1O^9Xjb&J`iX0E=h{pMtXy!SpQTJyklrd!&nCKpdaa73$o7;n{$kp4$>WT70fKESZd>e&&3CU` zPI86l%SFXC3u~$y?jB}@RgAi)*Ymyl{nU5A^Aa}m=PFueC^T^odcg1lFnCPN!+CD3 zQRi&+Z>2Z|dR>yT#$-H-GYRTBEWXeXK3P|GHZ`+2gVU0E_yKkT-5TthJN*_!t-Dbj zS>ie`K5x{Arghec(4Y(zvijK6nhKmTU^x_2RAlS7DnzM;tGOq+^}R}|jNqB{Rc8UZ zwx_w@)1l4v!6>EtJpEznR>e<#AFwb+s`8(GmMyA;O3tap*4>!qV@>}Eq^LpereneN zc6BJxk};k$WFM#q(3t^7$~s3|bHw-zmDxte+FWNlQ$rY44L;Aj1!jSZBsR{0v%O-q;1%xYZ5>9F-&z#pvVI>cs z4=5s8NHVjTuCaA2C`{<_^$6ok);#z)>+|qdc(xq zsn-+_q-x^zOBIbr-JwgY@_7{~4;_Zo%rO}x_aV-ZipY&3*H0Y(bKQUrq!3p^aV`So z{k3G!k=Y6l7#y#VkJsB4`}?b6ftz`}NOSTOjm9-fHb-tV1su7*t1NV?)&|BFHWm)} zN)}GG7FKpH_}q^FT+zDxWBWhYk^elv?R4;Pqs)+iX*v$refB~Q@B>(MjHwE*Ha0+v zDQ@t($QN}R=?)!3jJV8>TZoN;zFGf~!RWVhuk=!(%M2!GbLH-``)6shp?Xw0mHG4w z?T)L7WX5(+5w}seq#VD^Py=F*1=5*r$QP}8H5x}AzZ9LgN|G|GNXOBe=IXG=m+;J! z=xH|Pg6znjC`5B!1nF|13%hn!m@hRrOv84vjoMC`{V2!NB{S-N+l}Y34l`*IHxmA% zSjy$M9El$^^;lSykXRxq8Vo1VMO7-AXw>l!9=Pb_79xl?KU`L5--k3Y=h9BDacO|! zGR9jnd(KLGF1DcY@*vp~t)Zsa{yxM5l6)QFfdJq^f&M&}KhY2*(gZNTU-9z2H?IJU zSY5yy_@}uq{LN4}$pq_Z8XUFc=Nsr6vD!yR>G+xyG(pb+Lo-J<_jw3WWwhQGm88^k3VTapu@Ndyz zCsKcsq1x94RbR=_+@)6NLlzoJ0pWf2+R{vhiOg^qZ)R!a=##{cEH`H*bfCwoynF?3 zwTmtq9SH}Eji(=V6M=;4buF6!PRvDu&ay_Vzt)0|P{KioSZ-2!Hdbt7#0pwN05x*O%P0Qp6QNM0kny++m#| zghe1zQXVot|D3#GX)Z1^zp2Y>1Z@Z-PJL4yr6gfb6df-?rLX(64KAnxlitLckvdqX zTb|b#Xd$~S>&hl)8^D*yNrLNU@Vh#*Pg%Q5TKb~q)qkd(P88Wro3xMs(?O}Qpu$*P z)p|9#{QEM=E^MH(eMT^!)k&~Gf^rt8&l7ZtHp7@L5?4NKmh>p{(p0O)rKc04bAV#~ z3#OyhDA1ICM#8NYz~0#6R(f=qaE`iEq87*QTrPeFtZ` z&4l~DSe)JEoLt>*1`#n~}W08Kx#QTlnr1ZSBz_a0t- zz9q{`U)6kqIsKEH`O{On*T)~(s!GSozlv>})+BaZW4s|x^yJ`0vwXRWQzo)tp=#;Z zF%i>j{x(%4F8Hqyr3`c~@uK~!lxskTX%c)P1axyF$02zPB?u3A+7zwsB43w03D87I zojOCrUI6FsgVHB784-R>`Vg4oXHDp+A3kmtcHbz&^ChEV_?5WS1tE7&qsOpVs_IP} z+|}4Uz2I$P1;r9a)}|vqiyh3CCBIXymPnE=1(*zOY5%Ud;RVk;xGwv)jJM{HEq-$` zj{fcwjBlQj3-JhRyyvy+9*~9&!6ai?8g#ju7LKT_4|+P|ZLO&BDL{VU$dp_bu?GTT zJDA5o-%eP&YAy; zIqlkm#*mX1y_d`z0hbSnCvih0GBuhwKeH{NiD9$;1onaSRQQ!M{dZBn1^xrSqL+jIrd5l`T1q5%B086w z;GBBjp?GGmw?$3-=SlHiBsICda`nSa6$zen#4QL<_*2JNN9JXksjNX2o$UBFsvk^J zyDI>X3oOJSq%_tM7?ty=w3AxMf-^^QBE{>?iSyc}L}NN&2X&xPsg z3~76wPBz1MLlssCIc`^t;bhDzldr z8uKasf+cD8X9%q2R4{R9#yD`Nsuno!sMy1Doa&K=q$ z_V@6Zf;18G5d=GaOrHI0>3Dx ziJ=D{2Yx#zbZ+ZXEzG!e93V1lqPIFFkicz`6e3I&YDr(4_G)GqnNHtET`0mSuoG!MSA+TT0u~j&LYsE7*F~kmgtxfd9xSzun!B2!xgMEE84^-9=006dt z=sd#g6yaV_p8cki5C8n_Bo`3DB?}Ao6-#Yq8_BLw1WI~d>*Q>|rPZq#$|PA( z-ciKz6?^ZwTPJwOhyEx9xIK}ZNmidT**#r#$JfF!oX>rTA;}2rYPDtiu`Lo0c?~T( zUGK?yDx+Gs6!vs!PKYuHZoMvFB=I(HZzBocY@>_oLa=bq4@JT|Wfg&+1lew$nbz@NGrxtE1+A$C@1IKEKWX+LN>`%1tKsRfhC+w{%FegH%BoDX|1?XR17Q#Pv6*7 z{1;`2Qv=|+T!?adQx7J*c?slMpc{W;uQ#a~w$6RVom9?5^26UigzTQD{NsC*{D+Yg zpnON$p(?1#f%EyP>I+*VE4sy-)(OimB9caCSlDx>K2@pJa9lCYR_sBIV3!k z5TNQ25&YcQ$N*F}X3E9~&$Mp0UKeIHXxu|1kN}Q+H={ieQ!-CO<#|+Ca4eH??G}rj zWyfzOtSw0Ikhu3y$$-J^meA(*WI1-4HV3c=k&?L^Zz$x9?q&KL?%jp{gS5EN_So`C z_>>6p<8+VNA|E1=+tX7T1G8(&?2Tp>-^@%?D1$XG4+{l1V!@Xs(LI+RFM4K%ulYMy%)I1G`wtg(r|ET2sO)nxxi~@(Lrv!A)KVINL8l&vZ zVetRb5B>t3zs?4K=tX~arGHJaHt?TzsFnnRR6I4DdEcQc^n{;xm3|T?39*xhkVf#( zh7McqG~dmw*4uHNE+<0I0%(Wb4!*%v;kX~l%_VL5kQo&{k4>xYY7ORGpm6g4%AAod zx_hLAR5c9n7Me&CS?VmV7S)_pmZ4?$I{sW)2$=*ofv#5}J2>G8n2(m=EQU z&w3G2TY+2bJxQ^PLWJq^_5+{8B8A3@@IzA>wLaJn-k%m7w;6O2PvGkLfH+Bm%+Fn9 zQ$&w4Q-F-CcU#j0<^5PGRy_pufC0!CS&n9X?N4g&X+ja45P-HYz3#S!!YY-_l4IAf zx;Z0<;{egrwqW`>$7oY9N@#-nE9)I?2|%6H1ytRG}hG2Q%Pb9H$x{5uWe-JW#pps6ELUlLef12 zk=Y#E08kPO?h%_kwRRUef|?q&GLgY({2K_QrOe^{Ts97~h zGCdSOu^Jt~7?qXuh}S#OZo->fhHd6^J_kq!Lg1k5juMUQnUyHYES5zMH%_LKl{ca8 zd3jJ0pQMDAlSAHDQldm%Vu`mi3RsQ*Wcz||?4F;wWHr#r!EX~S zp_-lbOUe?HaLE(i(qfiJbQE^ef3tn;)R7DrlWDh?svvGdUh5?E1DIbZ7-4PtaLnBf z)Xs1gJl%{!6kIgiX(F`$E0-?t^yk(uJg^%_=jDL#NZ=q6+Jl>K%Z zmUY#bKHAu!P-VRX)oY_Qp}r9p)ubvf9CM#4m*)F?DMVNl-J7?gksMe>$TOstDDdyL z+eMWA&L;3{Kb}V~>>WaG>NdLM6bqU?0#VIsNs_4~!1iSnLwuR-ZMkjO=(Wb|;Dc&6 z7_<1ASU63|*uj*9GJE#hC@kMHApgHUr?&q-kFMWtJikqkSo;AWrpj_XRaM0b+ASL^ zJ*dkzqit$g#Ekqn^N=SWXPMvY zr8BE(Q-1Q#rHN01s-B5&F;w!5lM=UcO&?b((hj6?IY4LKfsu+nDyvUC)D~5=;A1Z0 zsad^e7UGlXFrDV0HK#<=se(#0jZ@(BeiaC86u8JiA#aYs4nV;nDc&%{*$1yf2(vW(a&uy#U z=C0b$9-%pjXxI9#3G3;fL9D(=nnShz#_~^&;SW*ZZ+H<=#sASIF4xWxw86t8mshq< z*LeR$LHzQbzu*P9&+M<%!@nl5MhF1EIug5NPr{(Ud`l)4hZpT3d1dp1C!3~<*XWn0 z4u23n(;nbGR0RrEDbE)8x15+@3)zrl(}wsb;*pSQ&#}RYiW$D|-$jYEGAmEufmqg~ z!jlc^dq@|X5rbiJ88}uC8y)aXmdO=mvjD!YbBCkH_egYiB&2F2``NMn?EN@SqAjg} z*+kR*e$qDVV;i?9zxV-F%??5{fKgv-O3KQm*2wuX;}2R+F9Fz%W{Yw(A2kL5`g+)% zAAMP+VZj1m|5UG}g9q>f+mt#gq_eKS7_mr8Ci2&{y2K_oEJKK7kHve>$L|Oe>^NVDA@f z)^qMq*9XFwb>9zw!AL*OoE5Cy4i;I1W5IS=o-CDz9ji?+eGS}@Sp`$zL=u4r9=VsT zQ)^pKRH?B7Vm^GvhccXwJgTBfZEK@4>p~zo;I-%iuQ+OXv+&@$?qz**xv7&MgV?5* z{jsG*!!_fYfvg`R6?kT?;0jWvH(bnwWti(4-Dd+tYZ&PPxfzFIEul#0duP0BJx#y8 zBN`s&?LJ}ycS4MH9x}ZT#ai z4LzC&cuJ78-V6GAH4%B-jBMH|=R3W6n zl2EK|m?PdszAy)v4u1*ep%ugAPLj|-P~I4O^c#PO>$FHOqy2=szicr2YHL*YZSV2= z^dZG5bkY>zkl7-J0wh3Agm62WCLap9bGI5I*=k-8Ab813TKrh3N9>D8W#0~%hbr^p z;`by&x8Coorl(RIA`O>d3c_j8S@_j?^#LkjC){nA>+(^O{tH)k#hb&abL-uGYixocbT>nIP|7n8% z;}-v<7Wm5NCUwUfkSVCXMEDq~cXvm9G3qMs{M(2h*<`cy^meE=KlY)nhS_d#`I?@? zHNT=G5QW3vUM3A4d-|ZgL+p65o!yXe*U1ZOn!Nmcyq(D+5f@3cK~_1G^RShAqCY+q zd#D6;H+f)K5i56LOKC?NPz<6WkvF$Y&y*s&^;k~kP3F<8 z$!N^WoRAp)rwOJbqK9tng!WeT59xYrue|E5~ivk#^g>n3Xx z8p-Irz+h^Ik7%du;&k+$*t_|2 zVWALeKFTg15H4H{<8EgMpXh}e6l>y|TG3{ElxvCFkC{ZhHmnn?o`9X)!MG+imd++aN$%@?_#Jw{MvS4y@J{a6UYWLCO+6`m1!i@3wDmgL@pT^pwqoEOvb z3$Zo85KTU!SOX6{=7ZFaCJls0M+Vf5vX#h@Fv$thyoYbHlJ)`X+oqk$4w8+UV^CNj zO7}9M(*@5^bo``+EPyP3D^-Ij)_f?X>wNc|rZ}%^NKqt+lq439_kt$&X}IMxb%W6> zXh?DtYn`ly+!V<5?KJ;hp;!n=A9lQBFAde&5Q3`jZozlKllXB~bzVmbeICb(O`2tzOGgGx=IG{x?5q+v%V2zF?Tc9E zGh1Ac4ynd;wH{dnlLdn~x<0(RnVX^;rK+)K0S@TR1BAD>g zbhp>s;p1l|Akzy7KgC#kSbdF{D_;n$5=AO2QHa|01hZw3Lx5BV+6V>FK~Vb5j%y~I zTMTKUfnTmPk`D;wnw!RTp35*Nq0kkR z>q*N~Xx@Ff1C15R-@6Qns)d!)SId%=^;doypWEfHJ6fwhcmK1V_FuOdY!t|ms9%-7 zBqT52Sy>27x2JprENE<-xf?l|7(zUgcPb;Uw%jI?M;lv-qm3DKL}J)Cu%L%9wbJ9K zTwby2rV@p`lHKec98%%XW8}`%%FGFIqvRhGklbt5WOpoM}Q@ zZ#;Cl=jleUUU06e`|>sgNyuOrFg>l|8M*OG*a;$U#&EirL<3cctb8F~{ibRo68~}; z5X28&!AmMj(KF$Ed}K#oeg671V^WdrkohMBpf{{=YKX}~FnIxdWq>K@1R6-5dWp5f zDxP?3^sNn!PqlNC1Z_3b{g?3jO>GeT{#i$s5bkZID`Ttf-GkZAQ@MO(VZ9GbM~f33qNjwz5jfjyI) z1}E^jD)bz(cTtv4sZOL;l1pVkGb?TldEp=;#Z4M2iou?oKY=Zu0`7I)L#5FvNgsAG zXz8p9e{>Q1W#N^S%bCXs`d8Y1Plj?kdEjgxCI#-BI@z>hs{9pxcx_JBlzPckb#UM# zgymU`+K{zWnQY+l(?ok~f%;~6A(U8O*@=`4Jh}v;97q|a^Pi38PihxWbXaD(k5u6tOQ^M}T@6D-Ck-Ii7wecKI_N&dYcK*3K zZwZzXXz50w4H11Bl}>tlLmD}A0Y;M$|Wfx0keS0?1g9fRHcJ*HOTB7D;-8d!kea+1q%?=mx8SB%zs|v`>bSw z{^Yk%l4Sf$GyxUe&YzM2o{U3+`Z(MGMXh}qIpBDE-Yteqwqavi3?G~2Q-O1kBr#D@ zGU+cu$t>0ixJ+)60nNI2z_$BUMlsnyqn=Lg)*y`)I5qA%qcwiR@JZVW5SPpx%)iJE zps0l&0w4&h**~q4X0l)cBCy+#AQgn^IH*5#MjafUA>fY_i2!RX_^x3gsQ{D zB`I_WXjUH16v88E$8Uzmv78p{^XyP_XiY|G3Uzlw>>3toX$3^NB62lM@j#aZRne&K zMC<&RgCD*T(24Jo5ms3a!&m7+sM2L_R+>`fQ#LrG$*16nD+LQP;{&tW2b2SwdAUhGQ^FDyF1%3IdUxuZ?##@%LvvX0_|mxBVpnU96E)hj1K zHJXs|DB0e=#Y&%Vah{y24?rTj?CoeFVCt2DH_(Xg-!gnyWhRiQ&J^C~i4Spv`q4tf zEHmfNcTvVhWJxKZQZxfVRE9Sz$FNd0>zd&f#5Z@DUfwHL4R-;zdrFaKXM}`I$0-hI zs}RtjJLUF(ZfmxEKSo!07qIBJYs(?_8f|di?@sC4NWNsYM=j3Cz>=_a_$+M0*fi}d zq!?Yiy+uY;bGF*U2>dBAWvmcpK7fQDA#k|CDFDD?Z|2Mq&tCccK^=NXt9XyN`dsr( zVj}-WcTOdXKaHp|7EVqk4mQpv*4AHQ_T;v9wkBU$W5+)>TATlA`=5~i-)Ffnq`&iw zd&-}FjC8jCoq-;8$7)tcikp`1>^BI4g3-y3=#kjip7|4a$cu21vS{M0vJ{R@Hxml} z5VL0oMYiD~QC88TyrEMaKvH8wWc$x!>Phxr5odfqJ-s<$U=Vn7H{p`-3o$adU4(+D zxSC(5LYi>vZfBCJ-07!|78q#oV;r8LVKCmQjLBShj&s8iy546$lL9kngf^b%UNLK% zj6F^;1LNLiV^3dESbhi-p_s5jp@3sNwLO7$Jrks*G-^?0fjD%6lVnHui8nf-9{Oxy zrWx6jV991crb_Nc`9y#eRu9}$kLrGl1EzGCD8{fM3Z7kd)Vq+Jb)}Q|8}j};VCs*H z{ex{{rp$#FvfnL@^1(l?o}zb5GCPqoKADY<*br)nTx{#WkD5XB)CfV1>yh1yfi1e? zN(=jM67@&#nyZaEHrQiV+b*VzV{mpz3UeWXS+-kf@DBumXgMFx%dx4~UAFxsBWQCA zb^;6RifDuu053L(Z!AqaB({>F(Lg%5qObdqHMwTE=(OsqPl3wIJoa$|NG6KurGPWZ z8$=WUYGsNBPcD7YV6Nja1=W~zxWEm5w{*Ej{!lsG_Z$Fx7?_*-g&QNls2n-qoQzab zU-c8l#r@Ntj|AJASKP7b%4xU@OSCnwuo_Zm1)m2i#o5FhVA`!{_I4BWWE`);IYZj@ z`6KVwAmn_&LDKyCpV-m}p+e&;wyeh}RywnG+vU&&>2(K&xA0EibJBiZ^{V(4XwO;M z;`};dUj>k*dYoOyJt$KDQ(bVktK_@<4%bC$dF34bK%>=xv6%vb*<{=(us8p;8;jZ! z7tnFgp~F!vF&0?1>6==(b(fPW^>S7lmsIw`$*hI4Rq5NeWxm{*OCq#O2tncoHe4yx`btxfUgK3oF6k6v zeL;oHy{C{(Nstg9!bkos^7;Hr@c^YsB@NH;UpfVxqHzd9qnHi>DP*<$gVHrb)1i*p zXk%yW?4R`zTENN>s`p6L|HSnn9QVZ?_$mvuRj>^kHBp{=~6!fsIa@gyF zDgcihk57q2JAU@u;h5)%kM(=oqQDIP#lC_yp9!I!cAG?|D@PtX5ef{vOxTJkD7ru{ zsEs~tyV_U=KZR6>pObVmwD?&4>N5JWo@v`COs%BM4Do2A&@STQW0%eSH=x)ztY*)_ zdK%_BwmETiT>|UQ;H8IzE`TI0@=Vh&ZYaH~k`%5B;+y)Ehw^HwFMH^ib7a2tW{PI! zALWU$<$W7?R-W3cpZ}Y5)QBr!Z}0pyKGfOP_zStY4ZiO9&Ft*VtWEyIm-xqD`WwvL zU!iS0TczGO?tmjYwDD0F>wWLXM@;pAy1X=ah%uLGjDF~*TZ+BoSdOtPe{wxH{VrwBSusP8iFL7ASC)zhaOexxMVvb; zBjmOav&*TXBd<9U>Uo5N`p5-A5S#8SpK?j-qtZ3w`_xP5vh@BDP7MZ@lYe&;M+5Xk z3h~^d`euA|;LWI4qIMLs8mg+Z#4znc)Rywi6=I?F<`P345r|v1>&%>ADv!Sa;M3n9yO{~YLgHrW=G4fZa29AGZzNz-P zvC_x&cWy0251@sG6}Rf;N%@Hk7uUc)0HcZ{+|O>tKm(1nucq&fa8tu1Uzki%p#!2& zFM-+7H@aJ)FcX6<|R z3nlym^##aqgNYjPN`eyx6V?Mirxv^ybK8bKDPz|}FD{Y&@MtA=nFX*q6M?Xelq8=C z9(SdpZpTzMm{}^D1wR#_ulmOcn7X^ChqH0)^@cDxsg$YfaR8&rLFNTb^B`@7I}#8= zEnnk9verS(Sxyz6Y^eQR_=9l%IHcq$~cNy-5`sw zTJVUhVs|%<`zcyG@4s0TsGFu$3HtC8ogpyGxqnpPV9b( zQ%&Pl!2G6)xyWMOWU}B;^HebmzL!a&>sZE*T_IYqyT1lVVEaKGjRS}(sW=zQH+tl@ zWv;7Pis2jkjNYe(wXs&U@AvVVN7%!cRS*{lroERrThLrHm?jzzCkT}~r;yaI^MQP- zEvyb2|8_JWXH4u%eJ9>rdP8Ka2*juFt`g>~jpg%sNp8U;!P-9)B|K%P9 z{A#2@dQL}EKY*GBA_Oy0fqx=&7j@WIv^}9B4V_*87N$T6&wA3Bhk#6e8$EX&yw&`z zdFj!qj+c+7UuV_>Yk_PFyR2=^IQU4ayM87iK;6nsG_ihQ%_|zg)%SFNFSAcx_n2}H zlda>0H54v_uJt`)#u4y^F=KQFV%I(TzTo10&Bxp(8wAk%s6=v%p;-8a3%5&RQ96FG zvIoJ|9W+57AuLI7B7I*WmSD*r-iMm2#goz!lFoP*g%{Bszp!uY%n4nS=OivMD+_N} zc)$PW!UhZ_B95u)8)M(oTNeP~dT66aRwj`8W`P&9^FQzFSTIQE*^X?t(s47Lz15L! z6~3V)rlM$~O0Ox{iaoambcR2wzp~^`U;*ED2sgVA&rNu|7g+WAZvQpn4pso>ik`)=@OCq)6iTE~bSWt1*5fm`dai=Zy$q^{3~@ z@N(lmF&cI|xj240j4=OfeZ?-)T*{kEEO?SR6?DUG35x<>ARW!y_wdPd$GS2zL}Fcr z{&`H&?RkK!Zi2*}UgVTFMerMvpHFs#4VO~1SW6W5enrW@;ceYmD+ZA-+~v8&bLlpM z2hh}#{t0k@{-=HyVqiT#aP7zI$R;Ty)2)%T5HGLu)#dy3b^Qgu|JLvRHThUTe`+8b zB%itaRfPMq$3g3wNvu^qfu#aMsv$d)Bf*3?f^KyeDq}VYB(dAMj9i%l#}t5gqrud! z>#XJv`ivf6e=%hU2!>WLAEGaE!f7!&+3EzC4ItD@g*|7th^D9~DknOIx3LTd#_kMp zq_hMAV1@uqK4#WoLZXyL7x&`CN?@fuOzh$cK{F!CZ#r%LzAV%&-kLtZ4%A=pH%`hBT0Wm}tazgjnQLWNfg=ebB?q zoF>35+gC)yKRQ}3@w+{90YEgB^s&eZ;#KS(pW@jF_gU8oQ?~j0W{GQThr7RInzJ*5 zata>wbw@+*8G~s?*Uk}4sQm?h?o<(9@Ha4H+cS2`#c+kbF{zS?dp^Bkr1~D%_hZ0J z_G^k&X^nTuIWI{002k*dnfSJ4(`+}xu42H#bNRA&OKWKn*)td-YxUK~3ZKo=Bp!ts z{elb!MXak}vW&1@zM5A-yLvU5iY$$Na?_OgXi|oPkO4xP6*tiM@I4&L$DRRB-uyIx zd_pitd_=8d8-y3tQLXc!c?5Gv2SQ&~h8TmUPEa3Vn3Z)Y5_2KX5%QPX0JMyE0b7(G zDK!(*>69jYiW1+r%fK+?$9sahA_=pbF5Rjxq~OO13=ARhHek&qTKEqNa$_boM+909 z(etFYgbOK6nue6o;3EE1k&&!DApZl2C3wXtOEscicVn#SR4z8*IT?ylxn!S*@oFeF zVDzrR?>*Q#lfP?~8&L76@Xjcv^+wdxpuj>@$y7~ZW1*TLK{;jexUAK#BBh1~-)K^P zqRB}9kUZ2z_`W}nLB0RYCPVY-$#$HQZdCW$VBrLIear(T906#W@r*qgpUVAj_~Q{a zaIrAPmojj$wX?z}S9Fs!a52Dlv@o-^_{y|enYe!)!40hbvKmu4xLJN#|4(%M`*qGR zd`DGKY3TZPI7Uy?KDFEhzr)O7K|asI@&IZduKE&^CG5LZsOim)!!gL{wv;K4FKMUV zxf(`=;?l@HHd+!f?jqINp%^aD-lgSzBGDItSkPc1CvH&uhUx_hH@~e^MB3naR!9MF zL(wg@LS);e(Vs*(-uZ|jY%W#AwY17($6q#SB%c$YHX8x;(KRWfZ@d4%3*~A+US{=n zpfn+9)at&KUokQCh?qX_tFk}kh;R%cYpcY>b{a-0e|74YX506B$MObPSmKp_|GVEP zT3xJ|eimN1cf3|`dE@dL5dEOiA zC_fMWbrBTF)Am%jw}uieT>|&wZc8G`CzkvS>K?3#iHm#~&}-Y`W_UEYP4|*3>{YBLr%5g z^Y*Q;5ym7S-&PM!X#?sz05cf=LC612hdr6#o~_n6R@h(XE0F(O7WZauYWqURuebG2 zR^Z>oS#%hHcxxZ1%v^+p+gqSmesd7g#nJ8*3;GSTg@9#qw)QzM-o6s;<6rbYaD#s` zxi}5eR>{1veQPRx_4tOmCt*O9h@-HLaZ|D(b4I*B&1rW*eMss#IL!?s`nsh#2{KTh z5zQwd>i`@TFPPK7@MwyO>Bb~?*CUZ<#Nj^H69#JA8_{E0-UBJq%wY^Q1#3;{<#z) zKKiO=2~qoq(00(EIUY~g7KzNS>pJN{AkoTb2HRfga8uI}9@QNjUEiMSxX!-$J)eHt z)>>&O_OMTAv~SKg1yN?vBBkUB(t>l6QB$$hR{kvk!n{v&ML**5v!l5eypybV}dKJ2rNiSKN?PdHNuTlH0k?DZ~O2VTYjb(d7#Ps?Pk3DW8--yMY{>e(1(C$QjWhHiOPOn9! zMnpkvpuxpb$riPIY$D=|Sf}1vyPB=ypHHt3Bfz?G+n_<1GL?2w14pH`6KEa)T=r@F zmpH9oP#Xw75^OK5+*j6>@gTj40KWq74e+ZHROU;hnUi(!5K@H6G-wHSAx0%tEi4te z+IiLpbT}GdvAajNyazAbYISd01g!%JX!Z3SK|K$wg)z*KArJ)iXpVq;#^6#5u%!|pN zo*}f{xgyS*@39-yBayaIy9i~q7hLNTl+m}-uyq9G)_g*5=`(s*ZI! z=6u^=be9=;4rg$;XQqDXuJhc|okb^^0Bw^N@?4MJD1gxvr(Sn!v;J7JBF>RLdUAo| ze7S=RABbdnvC#ZGdCQzkc9Wn?vClfcnZD=Egoy)*1T8#yH!L}hwR01yNq zkyf895jZQQ`a@v?W~#GL$pW|7%=Sc7=EYW_=iVZjdRMH#ER_2@)!}j^k5*Q`-S~mr zCR%mYX35a^+s8#PO0?B1cfZZr(4pQ?XH9JIVY(47JKQLVStpj>l}#EMse}xNhO!svsb>7c%Q~l2WJhN?I$WdLazu( zNY572ZL|1x5rP2G&h8uA+FSSIcvc~;(#9MmS4T#B?v}1D4Ay`P3$9(kK3+pm#C6Xv zl@z%wmTnFRn98@M0O0{MESD!FWZ-wS6p-`$Lmh()5TD`;f6yHz1V7f7RiYrlU)`N2&BjdH*?ThQ8{j3iFdBEc$No!jk4MUQ8;=lr#aZ0jM6l@`3u2{R zjZ4H)giClqQ=%dtj0(l@A(k&0rZpTO-Ni}T8xyA*o?ufO1-=js?b0XqV`mcM3=hIk~ zxwktF%kTgTEn@csin4z`QRR3olxFzgSm8{<$mzWns0$Mo(Nc9C9p{+BRc`ii=$Ke^ z$_@`v&>U;7KQ3qt2f>qr_%pxQ0oP{>nfz%&Y)znOVsH1QRkZtxf}GrKjR@QHa+P>1<7$2`E&YOpO0&9r+)8VBqL%VQOIH>_p&fZs1Jd+oNGv16JKS@t4eF15>} zD%3`ffZaj+)kLC-)HEw929`rO@us_mHy0F(L|rZ5Il4acpN#+xH<3j&SD}AiqkeYSd6D;{HQ4iLEmTN0Iz|nNMH)z zx_OE*Z(LQI5;8g6y)NP2`C)u;a1M#iRd<)y((PGGF%3TD+`ABf8gHz_H^_Tni1HSC zQajnTUmzLe(o0Oso~NNt>5>Y1Vx$lR^GI=XHk0DZMP!EoxGZ595}3> za=%>ArubbJEz)*J2G%LF;W2~?4Qv=i&J975aAV7hlI7 zEE{1`j8VyY_`AmWa(c4E^zAnZ#j!o_K+)?`I;OzDwX zuVCM*XYwN1FAa}SJHq~zNg70t@EyWJ? zwUH8$A%#poZw3$=?Kxj~r!CeHAg%c+c-PL`7C=)`3}oAtF$8=Ju4gpynCC2!EV+?|Um4e=yp}f6jsltw*f>I10 zX0KBBSW&y%H{n_<8qfO2mg7Gx%5QB>y$#eI7I9C!dfZzrdC2l2#M6iRnx}Sc9g|w` zUMlpu1_Sq{sStg#GDLWoCmrx58P?p{ zkoa%cQA$VzwWMRb1A`2U9vuP@%&%fA*x%3mQ4FB+dT>+ADqv8b!hfoj3R=_~dv43V zuZdnZs}nGY_?M->i!4SCZF)T1#cS851L%F9R54Fq>F-3@O3qC!FtN-=B7oEs%4W#f z#saH+Ww)lW@-O#)rXesl<9~u9&nx*%CH}50C?HV&EQB=JbaT=SduEDMn)9*aP+Rf5 zvH`DAzCbEH1M*I@SHSESG?{?F#}?EN@iVub<@VH7Ljf zA+&lgRr(DY{yA*pbg1V+V)c#iii}mi*ki`*0s0g&%T%ZlG^y2pIp@^mR~3^N1E18P7|oT;!N~8q_OS%7 zD`dd3;NKj* z@B{n+DAg~H`{!5Xq_4KhB)>Ed)5dq(eZNr~d?4`%pcsF+edKK(DwS(Id*X8XotBfE zX`k=Nv6weouOvW=v|TT2m%a0t#DXa;IvvCgFT0TW`O`J1+G602m4c_(H(tkX;U`|| zSkI;w{C=$XsSllpfNopjr`9`3q>hLE!vL1K6A*43p@ry-up=*``LD1#bT-ppCx+To zbXA&(;jMcX@ZEN-=FK5h<#-J3=)jU|5+L6!5W$Y8?^Qf3HuM{tt(ZcEV?p7Up>y~k zqI#LkLoAvKQ>xpa*-LrqWk<3%GagYDOT#V65piB5H@3-`q|CdOa@Pzgc###3TCdos z1jGO~AmC=65f>-K?)_DleH06EL)TJT)I&C|K+;$xY|b#cHxH14AgU?R^LTA+4B#vT zK)%P0fc^*&wUVtBoy-`e(PStzp%{x*4>Q5++hjBJzxo4KWmF_3zQAe$6!iIOIZWg^ z`jb#N%xEUHa9t!VXJX74>AMjp9IZ@d;ytt+M>anE>B`%MPkC>#)uvl48{C06Y}cMI zwQp31WJ2mJaxFqw6tJ(@;Ag`Xz{Yf?$Q zpFzDD+6Mc25SKq7;_D6pavDpQNkbKIyZ2y2!puVRCX*Jn*MUFX2tZe~ZK$pYtn`|W zg$9bT$QnxJ5)Ag<3FuVmUh@a02F0OcyUh3Uw&}?HGmNjNrLN;F>59=Fn)u$xpuWwW zYr!Q9(l14I6gTBZZTMhO8M4NX;KeFF z2(POmW0Y;w99KmFf3UO<L;@C=E+w?R-6GpC_3yM#2E3$Vr8L({6>!b^yB6-dua8R?` zvi^-F+r-G2*R-yF(&&-uiCtG3={6bJntIZ5_L~}eWv8V2uloW4BE7fu2}7w=K<3Wu z@rKm0;i^(-XvJ LgWWCJB>BZgr7t8H7WPzbXX9uxQKNP1$)cz5`1U6=|kkaK5eX+;ylB2b-3qzS!foq zL8^s~F|_)8p3`0Mrxpb&+KVIBz_FOlSlev_00xBsID+$H%6cu75^PY{1I4@zD+Mv9 ze9NG+WWF8vg^@cqG)?Yh^Y(4C0LN|Ko#`x}wYizuSYjh#pT)F-fZDZ86P_h4AdO^A z*<{H*uPHdU4elacH)g{;)u&)!CZA_Swn>S*W-{mr_Dn3Pk)Qq@Y?Xb*I%A0`;`AbO zT~bd`GspaO$=diVqK_+P1Gqu^CDn0mlz~WNxBh$yTaq2K1#_r|AUwByE@f3j`d!Fh zEW@7-j@mTe&x&rmwZNu;ochjCIO-%$5iOaIdQufu7atjT9gucAS#n<%(RL6dl-pb5 z>?GQmV-=vxt6#7f$nNc?tl8<0AkmF zL5mp;w>xxLj#3Qi?S3V&RN1oeZF-ch#ew7BZH$ z7lh1opU2+QRY8hryObYy6xE(yU=0*io`(jFc^PgYj0ikOK;v-M=vZq6jkqQi@&YeN zW^;?IxW2U7<-yNG)tIYgpa$2SxhqLp$=cxOZmNPdq&U;kmk(b&JLx2#)1-!|a<{+O z{ELgF@^?K}A?Wsb?0x$Q1V1=4AS^~d$9!LC>`D^*BVZg!(TkCaPLXPiIO+F99a88a zSe&HAsWifi{ee2ZOWNdB?lRiph_;h z9k_mF)W~=$$5Cgcf^mBQTts00%q@44?yAy2*7ohBDa*b29&`7tbhk_jtx3Q0EW)-@ z;P}DM*HBuF`ee*5yA6B+lZ^{T1O;skEU?BbjL~^guc<7+y@ zKpie^R=-a^L4PT*2D%SC1es)cJaZSxc`_hQ3^AzH^+o%A?hJAI*UCMB@ci6`HCQ~j zRh-!0$+Y4BLjy!No3>@ja7^apkjK=Mec-_mWgkfcCYcIUXcSgrE0bNF*W*1KmNEH6=jd{^Y z_N_@c>0ZkN`kH5+A&(9nNzY2av}^Uwr6 z^nLOBv`h-lrhW!Js#K+c+5V_3GuV1+t61kElsscZa)dEH|DBPKugxNkK?ymnGbR-L z5+t^G*bbXVz6CnS!mmYr=HcD@Ghj*XC+d*Ey~))A1@(c&Ps7Rtav#a`NT)m=D6~qk zi#ankIKpZ21GXJ80S~~3uW2$YzG$@9nCpJi+pbBtTG8`#3*7|L*SM4JEStlebG2t> z>m+c;ep6WhvvXrT#&`&_w^yWfB?(whbAHjWyW}*+1$f+@1kh} zfn;%G(18ePC5#C+C%pZ$!&IY8L2jRwY8OsuS%Zpd_!|a_4$t9oRn?&2LHqZX>>PRkSV45w3nq zXr#OqK{hbZxE+P9T0^!R5G_oC!IS9V5Kx1VtJYvxd1FM+@XZ2<>SKM%!e@^L6 zn2rx6@{}C~XBJ990DpsAjoQyRK7{=iu1bOmAkYm3g){2tU@H~W2O|~56=0Oj*IvKV zrhj_2;2G_BTvwKTSA#Y}5`(&{_^WQH_U%&K5 z%pv`;`qXf<{Cm8fRK~#B+1$dw=_?a!{>4_a`SiJ@_SF~YdFltn z2y+Auu6}?UxlRd6T0@#Z+pl6~Enh75#0Dg=Lc{mzeze?Iu2dKw&R>H5oZ*`Z0~S&{k8YiqET$Y_lOcVY>gE_ ziD+ZB-}U|pUW4@=>ht%W26DKbE+^j z7siz{=$U#SaZP_Z)MV@E{KUBr+)atk60v7z9j7tU{qHDGstXoJNVL(r1sc>*bAh5Q z2?HSGNVN3M_Z$1!=J=CZx^6cx@E{k0bZL#@4?9iVKzR9-YyhnI?PU`k-BEK0i#hoX zG8icaQ%;k(!d}1jQYD?)3K!WjjP>ooh&>|>h5Jf~a(mWZ>8vNpm6Z#oCvOnUmtJx` z>R3V~iRlKf!I+~?n~aAyfY-OZPdWKAxKV+tFE%DIV0Q0!C3R}aMwcEYJ)AJJFVF+= zr?1){tN4c;0WHS*kGNS2bbJE^hQf6d8W3Q57S20Di+9K_1rHt+Suf~KvGieKTdO#W z7M1O&fZP}0gIs3eKD@*lO7s1zKm%zE*a8}=YT1OQH2=YJcyd4e1&O|iS<%xuEvmB!y)S27i!BT_LF- z5nFEIt}EQwQ?NmXQN-Gk5F~g6&)fHuLJQi36le`S0oll(6xPV}3MeiZ#VC*GngNLc z%JAtl-uXoyyXi3}8ZZc5pzJ#Qb?FS@FyyJSS9hsm3OQs(0uARzR`_qgnqBgO-Wt#7CkW!I7}oZ zBmB5!Ulv4rcUGFPsIapixSy9EOS4V$ad!cAsZM2_oVkln?n_A%G2eJ$_r)yszeQuS ze>nGYM>lI(j0Y<_?*eX}wE`+*yIU=-L`!RBo4>o?ee|@=h-WOLt$sb+l~aw|%wH)| znK83W3diA(&qKk+Snz9$F;Y-9PFd7586Qo=s}atYC-o+Vl!Tn(JxpzmemJ*Pn#L2| zIOIBO!qLNBM2NH4D%PA(uNe|2`H=a**e-A-zh+Czsuo9e@PDF{^6UuJNV&hp_q3YD zwLnV^G~FTSPU}0oD!6bMT>gQ-M&Ylx28etee}$KO0ojS%A>HnMaJ);!VS>3Mqm1Nh z>i0o&(QBBHR*9`AZiI=T;%w|1Bmcm{`4P(sH z^)=@8Yn%PElmA0=`p>EO7#M(@rKeT+yy2my4X?)}SNv{HQm3FM17EsA%wwlAEqQ?N z%^&tgXdn#J`YXOf;&p0aQKRmKc-mWr)N`+yHI-8R<0nxfl6|bqr?!Ig(Nl}*d)>b? zQ!$0}O@5N`X#vU>gjp#GmRh)|pr$&SuEi1F9z>P6J4Q_lhGe|K8NZYI_Hp?Z0Lv$F zz|ud9Fj2ndIN)I`M5d>LY{=6N76thM_u%UhsU4x-_jmInBqzBVaNIC{zI?{3ssbR* z-wu@B@ZbyVsK5E>kZ+OdMl1au8o%KtVC7@NG-Po)}n+9LGcB(Y^fx!Ypn3EPPN9L@sZpAkEToUbI6ysXe5^?n z_9#rNF`|mz1A3$B2at>N;X!OYr0EtFH8WD}f}+DnMsBZ$vJfj|>J)D=-jhip(}Usi ze(gj{=PD&8S30iY)J=?kLFjvg6;0A%s(|?HaJlCg_+I4;uxDHFCp45DQ9%C+4JTix z*LH8rz|YX1Upmn`>g0`MIe5Fu7&+n{pHM_cs73?DfkISW&qdoH6qch2l*y(#v_KdQ zgwakVTbLhh_pbNhgCiY~jZ9OGtEixM(Ib9^-O;Ci%$8WYU5<2>!+~_BfXU;77?QtV zHR5V!+11G14hfyzmzQ;%@{cD)KF0Fo$bgpjsDwPWf(*?o=-zTL6p^_-Z4Sbnj+I8s zz$>Hcp~%J!g%UvSr}JAkI!2)FS4@P37Ka?5ES40cBZHS)Ym9HuNw7v@a2lq()jdaR z%8)_6HCFX}@}qD>4BA{hOw*ClqnC zFd`6ibor_yeo1|}O$`72mEY9S#Dvb&k+1mgYvH4g&J%n?6 z$KyDM@tQ;_;Wx>z<2(bP!vRmV7GUjzri=a*g{Cm9NJ%FNR%v%bxTC@PLUo9Ue4%Cp zn*+m!_WbzqM*5afZ`uz8N;-KM%)ZP9r$YlvCkjVeMg~Vwm0zha$h%ucahy$VpQF_u zIZ1!=Yd&wWiHTy6v3>p?CQ+}~n>`;7l9Xz8-!?I{&b|5ay&d4a!nYJeyh5OleanR= zOJcY&gE}^MFZ-*D1DO^gLRTGZp0JdEV-|1uN5j&+|6#MQ*(|aHI)%28^m%nu-4ayI ztayyR`xwzr$XDYvu?N@``IOS^wfs#Qn7<|W|0{a@V@dx;k9roB5Uv2VG?muipPt;! zn|yv8s}A)`uXVmAcYxYSKKL^s5fUlF@vMV^SxB4GoJEcpEX!U-d?mA4FlH;iTD3(W zrKzvjzpZj07rSuy;)96*HiQ(9QB2S&KMu1`9;^PGA*k?!nTQs(bP9KnTC8L%%{;Iz zRIkRxgRs)w_n;e&;Gpj~!PXA(`z8C_mfAOb3H$w&NI{Aq;BfcG+U6o@L;V;4DG`Xx zMBlkhXjCyGCmFOjAl3F&z|hX}TJYv^g__;45zB1ddPEoVo`Ip(YtX&gsCf$E(!v?6; z6Mr}}W`I(W6dUYKAyVSqwb7JZphW(Ba>XE2XYu^ai4T#}%}B><8gmz_GvEKIi! zW+BkUV4G83YD=6rDm9nAuW2V!6;$L-pjSg)?<^Y+EM z=Q}tjy)oFJwo#zV4VOrOExm{GZ3JMdMyK+PCsN4b?Vt(d7X%;E z-pJ86s+2Xz<9CE*_`7Z3HZ1aaNM476=a3v6_L%W{!ebErOSJNSOdE6FYVQMG?jz?1 z`uO<+rA*-X<2TwP>(Vw7#V^?cwS6wHT)lC&xsV%JnROocQ1!eP3?#qrN3&Wn0if9B z5~NOi^Zny6jyqdD&=vHUV`0Pj2)psJ&$+->en6AD{n>+GS+98`o#B)Ac=%r$>-Jf} z{X}M((^NKdwyh=TYfnL^k<;T<&*@H*6rA3zek@>(-j4P#zB%?p`TUpFk@@3(<1EeU zuk~!b`2j{Xx3aiPcEdxoXSuvk4s^Grj#*lC4wHW3spNQ-*kl_NpZ4_GQ=RmHf58s1 z@)yvd)o}UZbBlld_!5d+8#sAb*!^!g&%Z`fPxZ^OB^Ab>N$u<TnEI$>X_+)yf)8K6ZO|@>y-p?wO z@zOtRztcjxe^8b1p#aonD#)!FAKtDbKp4ex+;almaOT{E>Re?az845Qdp!U!ETC44 z)JHHYy%YZ>=vV*Tgax<0lw-N(E4&Q z|M9;69<+~y|MY0*dJ>XJ&jf%@>~-nJP4b`*pMS1`uep+QS%6MB!ntn3QkdZ5MK{=% z<%P#b%|1rd zQ_=3y!2e8FlkiyC;F$96?71FA>TE2EWnrX)ErQ;(3zycGvJW&?C#%~auh0o6vkxC9 z(rg}Br=P2FnY(b)#xH#L^})w1I99B2tf{=koDT)3s{MiIl#XN*c6O17WFb#O&10Nv zoIjS+Ul~l)1W!>s;+wk#ImT0(^p5JDKCFemR$Dueg|;AJ8WFGS4{t>hk=ZkjHN(K! z7rEwR6b#o3F-J$0c{XSfhNSw)D-Nh!Qk;luq`&RMa5RZQUP|>k~fKNu8Dj^`A6Ct;K3z-Pq{1Q-Cm4=yN=K(2qAX4x-igoGZT$A&HV|d#pRA0(w~` z@ita-IbPsn)@X+P@9S$GAdgy*9q&XFu+SVM)ttK!&kQ19(EBh@|yPJY8R zd9bM!ftl?$jj=?a|J+mo+oVTwogAuI)m~XvxRCO&RcO*qpZYo{6rP@#)!at-tlF#FANlH`_V8NW%0fP5%nM?Dj zbqHj0d<<@fZBNb8brfS!>J7{;pI2 zxG`po`j(<^feVrgd!b~|L?vA>5cP4}xQ&tI2Tag55xB^E;-*i@U2 z4|nAnjG&&d+5Fnvq6Sv;zP0MH%PTT|;jDY0-Ui;dpx>skcWB@w7HK<#R>Y3n76u2A zpreF2D#OJ;mr|<4_dm8raIvz%E8BD0(qYt#sC29>{0c>~nqowk zL9ZIT(U=Ein+{9;2IXBjmI+D$r($oWt~jplbJKopF*S{nGF z1Z~7c{mS7JQl{mQShuyEmHd@lvb7z-3+gTHOwHT+K-{k^s&7nIRTDFYznGZHBq%%; zG-ejHXrDSZ!pUlcBloFIecGKJLaz$XDsjuSm~m$8 z`C^oHC)%D|8W9loj13q9SUc5+>cqxhYr-A3+I0{w34N3VeI=BV0U8!{sCt(5+<)Rqz0g+(_D?sB2@-+ch5IU-HQ4|D zwNK}Gr4cE;5p-=B^_}B43H7SvY3DuSbm$=nt;hlb8HY9KgAn&{NSV1yOf@6W5lEbN zfTfH4wc@>5TdYR~yF!~Ka9#PE3>GJ%+oS|pa7oa8#PL(~sE)xCI)DDUueid{v)Ott zPYNlRv z5Fap;FyjO6Q>o|rNZsq(Wkrc=*V#)gdot|uId-v3P?Clam9qL8>r8;SlNpmjoR_8u z>^Q)W^2rRbXAr?{$1kyqY4pNanaF%1MZ(~FO;$xINm)q}ZkQYX)r;WC+u7R~e9=X1 ztiHO;JN|jG=XW%2wajxKl# z@_dD^1nS;rc(@T6CJ)Ym+ZQ&-u3Mb;XcWVYm%cvL`<9RJlfs4PX81Uw=D4A>xyC>V+p`{l23WbXI9)*Q>}VT}smV}w~Sj$Ls$c4JRSY;f?H zmbz!uEwu0QQS|R)Aa$%iV6|BDN9Zm6TEdV7#_dW2-}k`3yu1{3e^MSK!`MamGuwI?PR$$3W3xyz(}*{5#tI8Cl|BUeAi^xd&K{!K-%wA@rxN(c>$^h4r|~76K2X0b{N~ zW3w*9TlUOuNtJ{(`C_&`@|pfsrIGh#c&$@<^my1~ZQZHruD_Fv1WbLDXF>M8FWEBe-&o1Mc zPpL%#VRSTsI}zNS)B_c7rm7Jt=P2ov@E~V7u{c+tF_4uwi2?}RV~S0y9RnIh{@9u- zBYHD&oCb81&GWeC#a$FZ*P0A-cE7H*AV>Vdbt3=MOWgK4qe@l@(XNm7{jK%H^u?Iv02nSvvLQ9P$fD9h!(=zEUdcHehyQY@vA7l+8a7-Ej(SQ_I$Q1 zlo!=6CbNN*crMAV{>l5hLWAnG_~}^PgOy|6rgH!|d<5__YMZjpZ>m_{ns5^eV{D2= zO|UC}f?NF~L+Y>KwoLw;nOvAhYE?2Zo8VD_&&$@Tn2Dq-LRFVg&PPu_l|-vaO+CB3 zS3OwV(0yTT5Rp3lZ-)S(lqNU+z3$+a%REV1KwxRv~7UUrn`xd_5 z>@5Y%s<|(jL2*?>{zg1GLTwTeGX2F}=y&+S^NQOxSb0KcNK2y-yq7|5h#H{lCED}} z!-ZW3FNOW(Jy$g5Gz+Z=Za;getpf4dlfjKerz)?bBD24Sr%PE;kkUBE=B69*W0;i1 zGHiJI!Q!u=DWaI=i*kY09g+@XD$pFs*hlO@3xj*Q_qv%;eJUXCT7eIF<-@GZ36hk4 zzwXZf8RVQ-bU`v@?nStIE_a8I5KQdUWzIf7R#O*J1J<-1S*uA#0G3utN-!SHQFVQi z03;K`M7xM+GTRP|2f>%*g`>{T+a91~ZoEscPInxovMcRdZIFa_bf^3VQtsAyIqa;0 zv7JYY`TQ4Nkt;d47<{2CA!`eJ`!A`ooxO>zlbwsBkqN)kKWAM2*8WlwK@6|K3Xnmm z{XqbTL5M*BP9)Yo&1r3Owt4Y{C)Rdba$aLS(qNwV+fg8SrCZ1SR1+gVftHH z@H^N!(HWWZHYfjcxk&$WxqvHiT=eW*Pp^Z~R)G0{8;qe)KHs{LL~fi=&Ay@(W0~vq zN0N7nC@Mkf6}%1Yn&=;PU<1Zz$iW9%*q0VmVm^cb4F{%A_Gma0xsXm~mw|H~2YkZw8_23Y#-Z~2AA_i z5TQMIUlx%DZ{og(^GqMWZmpZDllBOs@r=O4Fw;~J(gXn; zT?g-V>{x4#*x786dLr zMO<^H^cT#gdlo*aJ10>6A!Hp>?(&8sf`gI!u`0q#!X0Z^(RmM?-otX+sK-C1<(+X5 zap%2HWPI97E@-0ylY&&QwU8yR#9hcrqCkKpl83h2(L>yj*WhM278 zRc=3B-JmMC?%S|oMiP@2%IRTJXP(=ybPT}e>7Wsyc%-tx6MP>8(EcY+XOaXPC|a_N z7biJU94p1CSVkRaU61__uc(E!lL)6-z^8dk!{+gf)8_G}YMyV^g<_{#@%DH8W~&mk zpdyp`htB0xc{@0}R1=laV1px^21&e;(uNF!soQ^eO|rsLH#!Pr9?yd$(W;Vw;g1Uf*_()6I8(*_e?w6rLqD z*kh)j=Z~vxNE5Co05=(OB9EC(je<0P&8YB%0|90R+m|xjkw!Cvh1aimAi3O1R#f*Y zQ`MA|^zsBF(7>VIgJ>amPIOnT%%sic8r6S3z-Zz@OK!9ik?LG_NMhR_vbjpyH^|qH`mLYbBOB zr5?T(S%@kLh6%`Q`myf-1|zvg z=00k7ZO88rBD@HAmscmYcnE#qN*e{Bw(tHpxRBBPdU6!QYZ*? z(uq{Q^i)!rr{`0PahzOWWU)0E2-K|jzGXfgyQ7=<%Qa|8wz6RnJ#}kg_uT;ASt8Ts zqA9xXCM_>D7~zeGrfR%m{&#l)*d})xa-Z_g zI4Ah-u$@G1<@3Lu2uI$)#hO6sPeq>lt7W#CJ-?lig`0`t|M-`GtOWuf0lNSC_xf^C zTKJqj9ZXseN1ue!I-3rsd$P|ym=0vvbRb`BZ2*6w63yLPl{zIDq%ZZ)lu64ua?4=2 z_AJYTWUOE4DB`VfDy6wxD(1#@#QYq{mHp-&bTNLdf}txnEz9aItp#!^RqSQcF3&C8 zFf!_RM>caJJ@YVhJ7L33E)gwQ(jP%7-fa}g6Pdj0Y6V;q3#YDj=+O@aT0f{f+a@MN z&Flco{TUIFPDwqo2NnwfmEzIxFJXRGg~v?snck|Y0@_N{{ebAi9b~MLmO4+*` zIE0!N>=V9}@xC_0i9$LE=m;Q(jN@5;IVkXgWOS{%e79Y)zQAeP|C=8H{-f@J`a@j# zvn*dzks&hxfUt=GztlaJCg_&%H51U?|EPPQ{-}HYeCCh3=OkEY!2ab4giILxQ)$aQ z*6!gv^M01+`@!yZ=s4@r!dj1JKoN+a5==%9u&N?AHk%nX@61{ucIhP^I?Mg2nsy2i zvI-i}YXy6QsoZi(8nkiU0ptBF;7W4lAVc)d_e}D$u5*Ou{lwwaBY8q%qG|q0jD*BT zR1}h<3og{RMSXk^OR3Qc>2_T3$QG**5Z#W|D>L6Q(LI)A5J$BkFmWRRpVtlkgAV=S zGti%s5N~_!QUgl9#NT743Q`_4`bQHCv*fos$EZ|4T|+-KcjPKMrZ(R=eQ7!qu|!bP z>rnYrsM!;)_N4k#w~wXJ*`c?-8f|1u3oqXH#I*|V6@KNChTaEAcmHp%Pn@IFu0-ZC zClCahyhfj>!$;Igf$P|FKp)JGuaz?PxC;|!ekYw7beFtmth-<|&CH7Si2dg4nz|u7 zj?%BF9q{0?5MW3z*JW0p&=>fCO9K0sNCh`%7oGMM*aR;`rBL!lFsLHM#$ka5`S+X@ zf*2+;wAPn3*GbNgddqE%XAHBEvC$1$k0X0XR#_m>!iZ&@#}PHGZmRe?C{$q%?&%wl z5X`v6!(kkkzXR3>CNl;*?N1oV8=9Os6M&xenvyql%>o<`IxH}gK&oN8$6*KE7oiml zq6=7n2$iQ|a5k)gGS}tBlZiK(W`6rL8vvh-Iz_}L2St}t=_yHD&5wn4bOb0>VCaLC zxPz~iu4&BxJCvpBNo`Ha)0j6L9c>4vi+0x|1=?MQQ__|g{0PE~uAojWvJv6Lo~wll ztgqlQ>X_M;SnJ*Py+ZM_Q9u^R#;4-wv3Sde!7ULv$X>#Ay(vaXEZGogmFp##tfkudiUzz*n6!W577%KtbMDXHYuj;!>3{q*AfM^D}yxjtb zC;apVJ8v$l%K1peOJQ~kwnmwud{F82LS$kVXB&Ay6`^eJ&A>dr-1LupZ0ab34`T4s zI3{v%E{bZr!l(4}(6*T;vJenhM98Iwi^?;~@sU28SHCIx=#qmu z(QqieoQ!ur4rvI0

)uq3jV@6`+p3+E%jZ0T3=hnKz2JW*@InOdNTL95{5dIOs;K z73n~pPhGKOL410Vv;o)9*s<*22G7Pd6R}Py3cmay`sH73(@3bydkR-9NC#A;1Db(3 z2!>`0oGofKwoT=Q%zhI*exg_-GH3e=_0NESm-|u6OA(cUKN*rsaTP$ zd8TM4N5W+;ww??B!D5=o!?w**H;wr+E6I^j<9nbqbadR_F@Kf@okAEF7<~Jq@D5nw z6&d?9yc_rieEYJjw1-uH{}RQ7-kKK!G5OIGls(6UcI+wSMp0SnK%l-mkU3|vI%inV z1@^zS+C+tbQfeg{adJwWnyG^c#s6d{rS#A>ii7Xz;-582zHx zbM?3X!`?eaSGsj=gFCiut76->Dz{_=Q4zO;+(~olua@9AA{u_Nvtfi52<=wLpji zt92-<#@Fb4?>c5cr#{8O#6LiJ$02L*lbl_arJ zc!n{%biP`yNhDLe{$S-E>);`}BlEXH+{S{%Qz>ds_-QyZ zQ(K6F3@;^W>kEpRVWvzOY9Bmj;Eqio<&v=4%szZaA-LM%teYu*J zGKA%q(N{+GA1|3OlND7gWL3`o z;*@4sGr^`IBlvFlbzMCDHeLc4T=i2P8sxQ&bKf2*b#WCDmE#*vU2^*}=@npNK)&00 z>T4~Rv-w47j<1Hm&HEcK`~S(!8~0p)0CV%zAWutH=`9T$vk$idJB|cdqiw=OTyqex zc|YVBZ@7-6ib(A0X0ezLl9@6(VNV-OzoG=E4wOn+S}!pwT?;3@04V7S@O;pFAICZC z7Ysriw%3?M_(G0sypNg*LVlA)##~vISK)i{9wV%ZvYcz!Jhp^G5IVF7MyG=fm6cHA z35np5hY@MSCt6q9X>xW{q5m{{Gxve=BSaRTENBzw_GY7K#3W~ruua(>BXr}Wx6dUG(0h+91yy17jqK4*>eA1A=W`=bA zyB{?%jRHsc9iQ_RX2UYbu=U(Xy5g^vd#g+8S7RlEC`7F&6+}B@ES|%ij<-*Vlw(S9 z!KDfCjxBVrRF$eGala9Ynh|~l$=}!}yYpbLTJAOZCQ`Y$!&HgOOXSBcFE+qe)I}&NgoXCwx0#!? zP|}q?0&}3)=(|y(yf8r45wdt{!Rt)XzCMT>RQJ+NNF1yEtrfHdor zgjPwBai~Mh5b70z!x08;oV`=bQ3HwzT+8D(8aRvm0 z#8Fm6?D2(1trpjwjY`#@#5F1R4EL>a?m1a%bvQ5;ir_J<(Zq$k=DLpZY58GI<;^|L z!?;rPFPmRF=W1)$xM|2f5qv<;(!hzPt9LM`H;Le~4e zLf?T?;E|f1d;{5R#&uwZtJ_`M-Gg<{&?Ly#;Y`2O`Dy9$^)bS>vFFsb_$duF`4T&h zk)+w>7%RXWJga+hc!@OS<28k?K1}y6qdqJG6i8V2b+D+xyUSz~m7Hg+RKm4}uCHs9 zy*nN@6P|$WGZMiHJL2k$6u?y_z2vntV6I7Qw_;#-#HXcFnfSBBk!#RFlEm<&qL;A- zmnlTXrSc~Aj~xo;YsK^!vlf~#REna0>L=*;Hz(Yb9uajsi0CX&f2AFx8{^67f+-Aw z2>-d^DN>Pueav%Awp+4$&n=SGiM`T#I;n^nIP`@+u&SC`A>8SE{xD{8P#iJ37`(mO z;{$`tJuM0qbP+TD7z5o%ACU1eXTA!BrG^@aFUJ){Rd_sYE6RV8XtFl&O28!Aw5}mZ z?5keH&rP_pGr*!bo5Gd@JJ#CotR?GaO@)wKEZi4^G0XA`JR>B_G!XMT-E+U}WLDc}scxY&do=B1KBRRs zoan~)gg~(X3@?QGE3O*DW^+Pbfs1Ft+7^`+&cW{U^ua-3U~~&hQT0 z6kG0Q6TA7v&w6?Bt9oqRJ`loNU3+N!dHHVRSfBb5>Tq8C5~CkL?tW1@;QZ$}w-QJ? zn_2uB5F=}4V)G|QX7gW-RsSy6X+K2YLfp*?^32FQ`*K1n&T(2DyDJ@>KCFprr zc>PE?!I$(?r=udV3nUbJII1?~7wBN6w@2vUew4c0lkbC%Ey)@5g5n82app5?_^{oa z5kyIMLZy=_^dcnd0@jZPUOxumWkg~ewZQVFBSB+3RW&mXxF$bFi-OtAi^D==VdoFv zOny}mKWRLd+(4Bc@I}704fQ)6{p57h#k_S+~ zSZTq-$YemHm{D?-hY#QXuY~>o=->QvivG@x+0Jmx*jl|}iHtyfDBQw>BOaJUZ4srV zo|H~=xHl)iu?8R$9eSeJ^3*t9>h-yW#)ZyJQ>g2Pnf6SJ$r6A8Jjyd}H>oLej*_V- zdoqRZW9*4w!um2jTFDE1vR|2J_ z=`SBP)oXQ5(8>-7Z)@7@&>S~LKv^vCUidT$ss27bqQKotxO#ybH;=RVLw7cCf!YZ< zns-wam8@KUC`09H68!X1eogwb+vB^v?}59XjfPDdHF&?P?H>hGcn3n?paH879jDY7 zvsGd-(DgEDmE79Jqa$E>?nUsI;MX5<8J58%h{Tw|Miv@jgP$B;EF!M7>)(?v;t;~f zAd|UzM>xWQrGJpCo4P&?+RkQIvgUpCivs5hwAOBmqluY4GI+{_mUthR&4+$P`m$zA z0Q311?{S8)f@MVwD&{y0zM;*%pq5Dr%_g4MWz)@@t@G5ek^?7IH=1jSGRi?jMobj}`|-aY7)RoTApqZ}d@y-i7z zGxP+M=b(Iw%-VaOO%!4VghzfhbY8{VmVg<2xygw6sr*g77vIgRW6yNuF9jnOGqSe= zBHZQ7?5zIu(b)dy=l__g^(T<~d&L%yK>hsN#qY|f>rWP4>m{;M$1YQ_!a%1b-4I=P zLeqQF{ErO>JWhP^%biaW_+L@kt<~wz$^z+Z_m|^q*M4mFmcwejn4ZfHuvUrz*(@;t zPi)(J<@2*~%pE1XS_`CKP``}|SFlcV`Qecb-TDk&@%+AS2&zaYE>C!(?~Y54w)-4j zMew42a!)C7W~Qh19b=8Vmv~|e?R0M3g`RrQMk`54DiE{6_@tN0rm`7aF4QBGLbUZ5 zF+cPZAi1}+gX>Nh`6!(`2bU`XbvT!|U9{U+X(F!6P7O50PGy;dfaJk*%rfl|`+*T& z=d3XV<+46&E`95L{}5049OM6lu>G?vf9sgDq`?wo*Hi~FG&CSWTt>*%aVX~5kllUR zPcTCE^3fl!0Ze@)kqMFGjTn6;ti3vCaxYw`m3!?cSH^)hfOrDTt2#8XoRbTDTf2c>*> z4{?e+0)U{qA9kn@_S`19%GzdQe*PSxM1&MOLzFfzz+5LB5?lDvSLvCj5ai?gYIzQx zgmb@%|IxMpsJ35o;aLDN``WyBjjv2mv31F%(F+?}U%Cz3bX9~fm{(JigMiyLn16zL_esX zG;T>Q_r03xejo9W>a%Bw5b~p)DEw2e;OUH4#kK7>lUj&ZtX*aB^^_H)7s=vU)&a+b zRpdBL-Q*}Pp`oR}hs;E4cl}M)_L%{h-g7D+qe-K8hpxEbug}JQ{@?Y;69Gorw15NmQ5yyz~JgrM)y zJswd{_ji!+ThZ{+>c^0vhVATVF76)4S|}Q5PsrL9C*CNoDvsHU(@Sz(un=M^D6!Ab z{DUcSCP>v@^qAHO*O=)j5Z2^#8n6N^s~$* z`h^IaNQdefTkuJCT|4f4h|rvav(%!Hqy1ny>)5O+^ZL6Sb+pG&z{9<&vb=@t5AZoA z1_Mvhb;Agq^Y;`)X9^8=;aCizm{-RAp*8LYXBlw1vi^2#|K(71|EZ90Rik~|{+q+f z`TY&U`Ip-dAcrdO$o-dN`_HR}DQG~?y31?FZ5L=Zs#xx5v6l{_Qz%!N$o>}jy6UE; zI7}14ywm_APEwCzI|C>la;{IBnQZ?cTUzW{>O#Y3u&$FD)t^U00>gYV(jf%f zWSetXv_jW3`NiT)pG8q>_+UGIY3UR(g~xy z#JWcjCQQ^dkS?^n5%-nPJ&9VL2h1h0Q6rfPl?p}5uGFOVheKn)l@m#a{8_^h(gC;o zbMuN_kyNilY$CK|FGY_&QM6D(Om9Fzm@^`(UoeA1Nt`G{o3($8z;^2y6PUy*3L4FO zy(MdLGCvKmdlaSd5bpU3${Nfco&2n&3jx&0YCaS)(QeX5(RI6V7Rj6TcEndA7K2Qo zhU^9Y%<|Myi11`8-?6)NwwMa?saP~(_*3;89AUvUh}RS$n!PGPrHHqFEb-{BvKfA} zuvgLaua71bb&9yQVsA+~lFxp2?2^t8mq|iB&IiK7slwV|`wAlt?q&Nr*wZ!N#IyC} z3fy;*G>Y|bKZ?4Cjw6|tIu*8M*-Z1FO!iwL%ISW(5m_53n>Gg)&5sw3hDueRMznquu(7~|V+;TP>+zQ%W)R*ZXVh^W+S z^{UjT8Uq~pR@o?Q^wtv4g!DDcp5xOCTD^iwzs%QC{?^d{)mZvxS^mBlU1To#MU|2h zo-!6mZW}sOY@+ud*-Gl4d zMtof+M$6kaozp%oxV7aJ+WHC*N5hi2FA4$ODG*x9}+?=7?v*xQT7 z`rao9Bn_BBxpBDGVWjPcDUPjzn)mNUU-pSN+%yRVv$PoPn~^YIKTRW93FpckEYEq0 z19c!af<|u?la73S_Uu3=!*d3ccEH(t15>Mb*d7)k2>lzFmbs`?dEfU<12qN`qr|U? zBq(Y8ZL&nnT?70vhjUi5IAL}!ZD!WUOh}w?Az>Pd`OcoWZzq_ml2%Z8b6w*x6Mczs^*WLL;RWeMHOXgX_9= zr?Yz4|H47El8OTP%It~7%uH;6>|1;$7N-CC?SBvP{$8_Pc>*kVyO57<;=N}-<22%; zv~LKKj?0kX{lNa6vuJ?w@0Vt|$T!<;<`vIwh6V{j&A@ez5P1s^k!dp`$NcvDjszs$+*1juV^O2F zj^Pjnaha+0o=LRg6Z%igSpH~D#zC<&M&31R@)NcPeb<0Mz)$>g_~`*tIZ`3bljF=r zoZ2rG9L3clUA?;#7hD%rLk6y50n<@1_{oS#nQG9zVu5lyqYvtLQih`&qORo}($-yG z-lTiR&GIswyNrcEx%TrcDhZ;>kMy1?oI3A9a21HZ9QG(sf&Y{zf$a}}mIV}#;ZFs@ zRbz^Ecs3v7e-tMFy!}&{toeD1YSSS+CdarNv~bk>GqRMg(Jafm_w#jfp{ugEjG)?#iC0!hOtpVwa+~ z^XqIlvj7Tquw{fc0-g$fRK*0b=g*B~NeLscA)5_6dqn(#@>J)2t7E%rwfYx6rcl2$ z^JYO+Ps|TO(yT6iRk{{u66mo;{HI6uM;tE!aSSKo6*x&irM13=pnxojc7UtRLQ#cu zM?C@d*DqO>V`7LPXKk|^dD_GY0jc8tMxsyG2oaapRgvMv?KF-dK1y)#$yZNG9^9sO zb#emiv2%XIi$@g8x(!}%2lnv&o!oHmW2-^lehtFufEU;HR} zUOvMp4#GowsxV1LF-bvTiS93Kx_E?_hpDL|vD|MT{iLeWa+JoJfSv~x*2Z+hgO7W} zdtSXo|Kk8^z%B7{US@%rC3D-gM~_N?J@B$HsqPsFBAoI-H7u;|Wa$xmw5C5u-~dTf z^rlFox@bhEihi{QA#wML75`KRQ$7=ZqKPPRa0{fcXQfL~res?sWJ<3SJ04j3WGNt6 zl`EBI57!~vfUE0WS`sCyVE?l60mXx%-Sa1dZdz+f3(TNTnuna=8_NR-&I+C&M12nv zer=o`aa&nKZ8|@;x?-E(29&1S-okalAqbV#Skr~qHB|h;USet} z*EhvLmotK~!-fb;P_0TYhe-|?dHulnH5Zok_&WXx-h3a8DEtD8R7DSbAf(9J5n1G3 z)5=zqaet?|x@gOd7v{{JeTqJ654590ovJmE)pb^?<&7K4vuVV^u&uhk;j;T_{?~|O zRW+5QDeD*pw#rYRUV=S#jB|U}j@4pfn6SVi|HdVh-IFpx;`_8Mbt#n#-HnFHG)CC4^^EB$*!Pr!RS2xdWAX>&28Se(eIHWW=;lTRTmC(vYVNZv#8Js9KDdeK zD(<=QS3KEDr{wJ5>R{|<4s37-GQqe2gK)>cpZskIEu0;D7C2J)9TU zy?Z~zouaQwe)D(G2onh%uRaHtyW7UJXC>OaIcjYARw|UKIg%kSxiqh|pL?LX7FBW| zmAU4ncoNVH&)??!BU6mji^a@|^z2WqMFPsJ=N%faKy2Lv;Nny0kB+$NQ69IycVL)F zhv!fpUErB~%5U(_{w1tz9JxcuoggB_)Xol{Q46pIXnqj)N=Sz7z>$C3ixyRpw@pP8 zJ|415qt@P)tL`8jG~ zic!Ak-$F>rhliuMOK(7$0jJ2{=VMS}ld>eGyrTUx{W^LNyf%VnJL9{bY|x2cIpV+&$`f&DsJH+x9lvh|-WZfK4zKHf%YS3%0|B@uKj! zxO802jMGCU^Y_K%#L^rM11BVK{t{fmd`n31N=3E4%A zs>Zu8V^@ki(yd`Ta=SvJ4u3m6|ISRnRl7>6qaFwdAu5&kg4m%Lk6s2s`TpqIe}yIg zyjpvN2V^$Nhz^;>%8}1kXO7m=ei_XeEP7u~;QZ3@p*R~0L1XbV z=?3eBzOy2|UHuZTJfr$ULvI>G$o?yng%}t^h}`XwVX znGhC(^nF8Y*6>eR%p;MDR~xgSL%m;WntRZ3ADab?J+te$Y4X&ng2)5T^~MR_6E_N@ z89j?!>*`4u2uPcZpUp%%Y=^CO(XVzE*KHm?UtWS66cH<>UCxov1xR}N?OqD=-~0Q7 zw~0iE62e9)km$J#G(gfH`q*bbkLx)dPVDvDU#Bp7X|FXCJDCv=m65+t!|dIR_cr9xtkXFKu-2mO|10u0=<)V^-R{A)XU@3Uo+6>vxiFj!&r@ zE?7$nyxBf2Jio8xHsTxv5zWf_%_URM2j61u(Im3t8%~*Ik!(fi`Dy&FJrqw}>wBk{ z(wY#JPB+m_j@(nCpic*2IASL0-ZX*cRK)$6!6}o$Y=r_2sA$2kDY~?b`x=;s^KqLT z6?1FX)WvW_>NVFJbdr#U8?d$FWs&@Afhta!&dwvX%$#sJrN&x2o;$E%ef%TcW-QSbJwheX})qj9PLEqi&&`O*j+aUe4%V{6`J4e zG4k{(^4ayjtG#UdQBSe&zsc1Em~VXRo~;P)yvQqK4m`h-L5LIC?D7ukzf5BkD!(*~ z@Yld-Isp4n+|bNO+hWmmN~`AUdH7dXOyHVGLSuo8F(Uue2k?|Svj zF(4A7nw$Xo1)(K;pw%YVxLY#oFb1X6_~>&?h0+&9`5#UWhX7G8&H&gALdTAPU%d?1 zB$Ze+OD$L+riZ#wKm8bbymuo3;Ju%aX3U>32mEG9$ss5ZVMix&a>Nzt#{62z(9|;?66%`qEy+JqR@KJ%n&E(9EU1s3I8Nve(v5uskB+7j6=pMk z3Z%P2&SQjev%gs_T)Z%-o$i01JJV(PP<*9=JWh4RO*0w8Z-T<$fUo1574ryE$(46e z%#_fCNX(@9K#jn1WW*R}!wsuvc8eTkr%7{fc|P=h5?xCm1i%x2@4|RblU`gF{(aB{ z9Sa;4yi0WQ691uUc%hUtd3m2ZoR!zR7|i$cnCO>i5LeYu({e~|w|NU%Wai!}l}UVp zAS)A;AdYnqr(lqCn8tlZU64(IsCxD~{%^)9RfZ#8yQGjJM(a>zqPf(5TuTh3vhf6m zI?sHw%+aj2G4{&F+t9t>sceQrajCVJZ7|I)v@Ty~r&8GZ4lM`FicAf*Cafe&d=LO$ zQ6!--wSUigPW{PPYqRQLVWz}zZ{)@BvAqiz2jxtDPt#2UUq5MKI9_a(LsR1=>rcv&c_{gxe} zdI3H4wt4^0mN9m;g%|x6ktx^M5i4`L}X{eF`a)5x)B3A&*1#eF90xv*DP!H?{Y|MQm+ZXVBq6BD3H0 za+=YMeV2gcA<>+^ikf+m;%n$W{^xAXoRXhn%mF^MTIKF<0aS=@fk&8VU5&g>9!ff2 zRfQAF4>A@g>>MVV4n0mfMG4e=q}Et2xqW>M=o_!MBuWNa6{J(KCisn@Gj~j8g?RX#O$X|9!W*(YH^U zUv)mR1M<1h?i$}9AMeyS3p}(i3{KCMuEGF?kxq~|MG9>6<1s#ks~?W3oe;TG` zuj3kk4buZ(Q|c?!?x6HqD2Htk?^noRVt+RJe?g&B@`g}&szuR7Dax^kX=T$Qu{7Bm z9_=3bj?MmjI#eff)`qGnNfJ;xm0;X3UMyxNz-yDvxVK}5>LK@)&#>#c>=INpH^nLX z%IEIj1#{Q5OnPQxxMUH&(lxKfp4HRB;n(>KLabheMiCu4ihg(-rB#A~gCr9Z-h;za z8W=RjijbX0ru}h4L*nBPw$O~%nEMTg>7_1{nT%Ki^rrFv_$POyXX(2inrC@yM>#? zjD44B!Rf2p&C5lr<}W8m4KF^hVvsju6-S#L%3)<}N?Gya-6y#Q2{GqIb~Q4^v0Y2T zHJ7c@n=!&rCwk8y>HN5^8ehqf#hsoW{Mym+>W3%Q)>~`4iO$3G^BYl4HI50Z(O4ym zzmkL8|FWu!7k+Q}S9zbQlj&;Jq#dOJL(GRuh4A(d+B}+m>sb zTG@9}=j}O)Fh(YN%{ATSqh4IxnZfFQpxIS|QnL~xZ*6oLX6O1f;`Wn+ zT=fVvS&=z1X)z(FvcOp^f>CZC!*mGJaH=xp5U1}~(FLycDRyE$QWlWIlTdK&hfnc) zpwSl<$cP+vHnBoExo7^%W3M+z_w|G8&71H-_;5-r1f+N0G9Be{w7ymL_?75kNehdB6=DLB86C;=Xjdur+CaWAK>f+Byx z*LpRKiBy6RT!fJE*w0(cqJY>gmWQP27REkF@gPw{cn&h#olf*RdHvn)h@E8s-JN2# z;I5e?SseeACmMEm{d0MVX7X>}8^T1P4szE3RqCKqO2yBSqEe`DFS_Yz&AsYUaC4qM zwIU&?H;MxvT2ys=D_oj>pkc6h=Y?@GJZfT|0UA|w;xUjfAW$HUcJ5aLdw3rbhxI%j z5i?cCVwckgcVScfeh_WI;AElpT!?A~JXGN2R;>u)#UuBDwsgb^YXUPE-WE(HlW4=h zyk2S%SJlr*-5AD0+R$$eT4WO!i||wx96)?erPUrIcJANn!T!CjJO`5XulNA; ze$jE9n1i? zU!)($QCBQ^hmRjp3LlxQ;6{R~(U>r_kRae7o03Q%AW%Yn7-F?DD} zRiOC}D6QiUZf$R!H@j1FaAE?|2zzH2Yg66`cUnL z2y_vXTyLzYUgfOj$Zht9eyg$Gg<3CHE<6SSWJ%RV6O=pb1e5-dE8c{BuuAYMH09M= zk4=}UR;l_5|0hTjJ;^@?25EKnnD~jXEOR>c((YJ4Jgaf)Jszc?nP>DjQT^Fx{7QV+ zmKG@khF7;5Em(S9kYn=#2^!0>O?>Ma6PN6A(nU1`ZYgMOQn)-J*9 zvBgo3IiO}8*xxGe<1r459Bl>b(6>9g?Wr!gc-}O@Hw-Tg3t%J)LsI~SA*B0ubrel` z8EvEp5%)dCioF4{V6RA+;e`eW%pjc(hWXz!b-$9GI|}nJE&f(J%6iP6BYRgyO)765 za{q=FmI$A&!fcv-VE?}9EFlalNFEUa-u?JfDi_aV*F(&|*p zvQt&{Ji~Th*>^$Du(u&%P1e>-{yUb^DOPTJ*K#0$T0<>ZHE0LyLoQ9uC0naTNPmT) zNEKW7lW-ACjiA@S(*FB5(aZ#&@Cn7Q&cpkBu!9ZeRmqAn%aW`TUqs!sx-H*SCn z-l`5?QP=JwU-0(s^Zc%5n|8&l$c!>?bGA~@Lxtyq`fmAmRX28C)ik&CTS(1)pm;0>#k1I@a>dk@%$QL zoWgs86Y()U6B2jGmD?OqOt2-PTHy3uhfV4bGK5M+6B3Q#GqsM~J*eXp^K&IBQE;7D zAX&%Hj$t9@_^HZmVa372@G`7ZR_atovAQ1t8~1u~0dev~Kj$xF9wnX?&%~nxfP~cx zRt=F7|8e7i7^**~;!ml7bZsmOP~htK zE_S6uLrxvQpMyvEkx%~Zp)yhs3<4l*RYQZx1q-sEn0|-?TB-ynjFHCQOaB^c>@YP* z%YGUXv~`2S0LX>@!iJiMPz}9Kzh}RPX^(4buh#XC0Oo%MP`(2Sq`XuydPGdgkfc1N z*HODU2eZCE01BkN^!o3&Y*i!nS_Pn84!6ETSyKEXfb(Ag@aurWo-Jsh?@k|moF2dO zjaR@-Gt#sN0EMmNU2Tl0Ra!l0cY6jN_R`&lWH0$>fR>XWd?@^|3^T*CHN8YB!V^|A*k#boUk0!L5m5iH0ACeAfq{T?HF$YSZZ`y& z#w>!kH;{@+3y{yqK@9x}_P%Xq2P>xdx^TRR5;tc0bNlI5A%xM}Mf+Oz4Hz0LG? zGpN)6VS*yvE}?hHgN5QBLYsZu@R)P{uV{=%I<+<;&7(B19_gV^KKHWlqelWgnIpll z)m6AT1US#R2LwBy$(AyCfcDQ~ua}9nvdV|(t&@W7!g`Hs{a*Du?h4`CLtJic*cW+N z^bDS|Yaq*M0Q?1r_B|zPv$$@E_~S8#0%efa;bOdo{TtSZL0R_Da4G z1mpH)Pv6l9@8Hie+2~!eKl9jC`CnB=e=uXXvgTp~VK3DshJvwE=((29Mc6MXlXWrk z1bm%^X`6SlvVTQUB(gvZ`@cmE8{l6;)@H88&PG=D|5h^$QecIFTej)9J%j^eju+9h zduUq;A(BnjCZlE=0QFrzC&S(O`nmBopvW*W7Ts~195QuCNN;aHf2JdkoW>rD#2}!X zEtB=oGEDm6(&>m(u{}~weUZJ3kxwZ=YACN|INxL6#X9SR&{@XJv}NY1`NM%xpvJN8 zotQWZ(Y2HVXGpK0Z!PK z@YLeFS1|SR#`_vSUpB4aDw(Q9`U|ViV0&hJEISvwE|4`LoomrB`7WvPD_;(AJt(9&e9=qmqp?X z#JncOFw0I>geH3R6!0f#_y%e8WhT4BC|T$EP$GCel2N05wq_0ip+>f{3U8 zW3&H$zSjZwA!mrTw3*xfMQcsD^P8#rH_w~iyR5s#$PS)Q2KEW8(A;l9DAW#O1aGFd zBZ7fByj1Z`iy&OfvvnPd`5Z-ZJU)A_Dnch&n;d458a?*4L2a{6j#zgY2Eh^frU0V(*-tyLSEj<3P@JGgOa<`6_IfL?Z>n7{JK@21Rt@OOLyV~Z0si>E-n&1__FoCJf3{U<4ep&+ z6b7$=A(!yLcVrjgdgrd=8S%(s^g!d`M=Xy4LMNy`%$yqMbW!B9uqky)(IQNdVs=)| zhtQi&U1Du4iP!@EHwv<(HoYH~C^Z9Z9s4r?^KMj8#!%QIezQWkTFj!u-{sdujh+Qb zFEl%utes4U2{jSZ7fg>{8d+>`7y7rtpeK3Na0-+=>&?~9`rh836N6D6mV%}YAVCdh ztHbYgR-*Ruv9WIX0}mZ^6Nw_O@!dz|@ePX9wCTaBw*8_hl}hLP4gw2*Yv@b9-8(Ki zLTt8@0sJ)@pT6#2m#b`qjHY!^Nt=MGJpK$V{}BpbLu6Gx3p@G#t53KL3OJp_X6Ze+ z=GCUJ7*RNpFkH{4J1d%I$FNmoUrAI0*a+2h*w2Driq%bAz&~Q43`io$7Yv83jroZk z36+ufT>|OLkID)}DV!a8GK{P$jCp z&(q8d!z;%ETkaL?2kodwAp}go|I~JY8{`4BhFgr8Y4U^UsB|=jfX^3pq?@vNoqUri zWzW@z2>k?Bd7vDJNRIJ6LYuv?^vlfjLK2rDt9WIrNG$k&5sZ+ix)TA2j z1|fZPwHU1v(lZeC3K!Q7VlVpw!f9MkrT1SAV8P9)oxk^zrI>{dTzyFQD!;l=0f*L! z{B+BDd@_&>J-g(aA~FuC+6jmXQG`I8>=1EY>G;iCskdNnK7D~^hM}te%{BEXUBhzk z`$>rB=k(|tJ9=`9vWK*&ko-k!MhY;c-kH{i*#xs~&7U>p^)j*}fcasooWs81LyD<( z(yvjU)vc{^>;Pi^Ruifw%I(dQgO+8!;wC(oM+zo>R#Yd5$@vq~$YK%DccBjL?;Osi zk%ZD+1#CzUp16?IfP?9{l&cjp>HQSR_A&&S%HXOO>J*1%FHT*Av^=3LL=}Oni!4N_ zL#B|8Q;2b)d&WF6ZwnD4F=T8HzNT8v~ zvAU|!8AE!?tMAetN@^G?N>=uub>bj)5gqbftv4~i4^MAEjEFnK& z$47pCtI^XxxQJ8z1W2kRL~~ZPk%Z(sc^=5FnzNRRp+TN%UJriY8lwQ^yavc&aDA2b ztO*=w!P);^viYPbR3S~S{dR7nZ**Q`H6!{hAF0UY2_D z`)f&UG)Ww5ze{B0K=cxFJ>`qP-2POQJq!t^TFD-Ohvf7I?^hR)ut&pH z#Mc5(MU2Z5SNBdS+z^X!UM)3*%Iw#)Gxq`P%Jo+{6=2-)_Z^m*2KNeAjT%KM-Zb!l zH)+k!%^?_lda@onixfG}uoq84Za6uB|1<3Hm&#Q^C7GDGI@Q!kf5JMF?OZsQES(yc z&k}P6VQ2gS;&089e8hY#UY0W}0rc7@GHfw}6S)EtoKhPY;>^USukVGADg?YrA)l7b z30hRhOHqz&hFXacATef=BNAr>QxFH;@^=VDg5yhU|H;`P6RxLh&8( zHVOkzG4k(l&$EH>&ZAXiCWI2-V%^>V^3+5z-iF06g9yl+j|8$gqJR30li2 z$$z~P{dJ(KNcaFJz5zed;EwZnIuYhOI!QUV{}`f-;C_^3oQqa~4WGpdRoae5HH62k z;gJsJHTUcD_;tt}`tDr$?-N<-0>ynb@mh!ghG(a}6w#8$x5w8`7|&}JA#u&S&zZ+@ z_ux>Hv9(chqUj#8QU562|E@c z6|KM8K*W|bAKGuim)p$0nI)kSR`)WIvpX6wb#S)oXb;vb{&Y95}WTT!jy|h1RNsk-Q3koLb`N`u5Uvx?M)%C zVgB3u-D4=Dot=bS3%0nFjml{H;Ix8d>;jSVIlO9CFJqkXF!}5Oxo9)v5t2lNJ7k=_ z_4`N|KX-C>52JE`sPIJ9y9C$N1@+q3n^9gH@Frz1-8caoV+OtE2e=LG6os*w;31x| zDQKr>M7k|O>By!s{<~rrpQt+Z#pwc9x-eAX&(@GbzPE3P`s=@_&El3uZqxYc(W(#Sj~3h)(L*tXSsE0d7;GE77_6h(inm2 z(0bo$Z}V-B)lbr~LnMED9*IEDW5K$mx<|~cbRa5rWz0Oet4V)3+rznA`|9)Y2qY>( z62^T$-zd2TDan1Pg@r&bnT1|rUyn|p@irA<>FV$&0s_VU1dtsRQ+}<12m6CY%4gdo zs^aq$R2{-wfLZL1idIa^$vWi`5j1vKsF0x^shR9b9^9d=V(L19Eo?%$jl2qWT8X)} zoq}Ey_Or@`>&t#dr=&s5rmJsvh-!-w$_}}06O|D}As2I}Jb1KRySMXroDXdHZq0o2 zKn~LS<4dO41?^_XNlF;uEZX-9>8bK5bI5^LjFjvYKfcq=+%;Fj^ZvBP7jNPNh$nem zw_FE5ZZ+K-GvfOsw;ehtf$0e3FVOFpLW1|a4=#PSq!@ETFj@e+Lw7+;8DffQ3i~c| zqi<(TBLOgX%^|wk!qvA9v&VELs`Ii&x1Z48u52~-lNS`mEPs)4>w*~8AaZ;vJ#swj zy|6v(QmSlGboH=zF#)!HX`@<(-Ti`OUA9SXa+oCWO&uEi0%4jPT=KuiVZ{Hpb`Thc z(f!Bs$o-#jm?{X|hqB*Wn9hDeF^Y_%JiVu>(IMi4jJLgNj1J_x9NmNHcwYe=-5E^{ zZt+i?9mU_yY?OQi*lu9+Mwm@i=ejm~s%V~M)qT}5!@pY82b>;}lpBJu`{Hl(e}5^( zS6(kE>uDG`x;Bveg22NCS-nuKO9-;?xttu0CyF}W)AKzn-SL!>*F9C`d!Z4Un-rr< zP;%cAL)nv$-^vxK8S{aF9mjks)ivG^=}9q_Iz&(kb?c>PotBUc+{#s|9JDl;EH>e| zXjUNt1J(8jiYvg-6c;wa`HEW1Wjln*P??N7mYbNNzPm%u*Mljy8^l}6Uzge&%(e{K zKJ>@Cc4MV;V&#w|X`bn$^|%_8#9>Nc`S+HTpa`wNa;8`dz{jOfcv zZ@}4?T6PZN`Oz3a>Vy*tWhNT5J=5hwR=_6`LrPYd6NYx0OfMHK^tmx#d;6=KT=aI7 zOx>PZ!t>09th+uM zK6nt3x50v7LeCI3?ayD7j^Z2_d7qQdM0>D5_|khdr!Y99b2Gp8Q+O)l(kO`%AH48T zR1W)iLg0;;0)FYC!Ku4UfN?Hv>i1K~v=a8BUOu7sj@M7em;)Xe8%d9lUQJmt@D%F3 zcECR=FzSKQ4$zPQ@&w%+Z&O)gOqD=WOH_+jwQeoVKfa5k+x~2hV11ls#wRLm>#ZkahcKoe zz{QYh$mo4L@vdcM07!R>y_5yF`UBHY3=o3@!Zaq{)1)w_;Ih7S(vg-{?R&=L8e-Ql zhztw_Jbl9y0ro|6V3d44AL2xP&~~y~RYE{c7K!_mUZQGJ5(i`dJvOL#$f(0ju9Y8z z%4+(04-7~-#yGOLfiA(~f{P%@zr1lWQX_b-rL;v}dP4Ih)$jbO%yh6=Pqn}d;HN*m z0vi_FAP$!jzE+W8>b;}ejBu_+H$agEvG;!j`U3_0;THl}hWIOWKU3%<;NER@6uyw7c9p2kaG92}D?+6`sYFrA5~K=%j@A-Q7iU?-cyG zCpl3w=dPJXHweP9$9cgG^I=Ih@;Q$c<00Fc!PHACmY#>KrY;0j? zXk~IBD0g>vE^csVVQg$JV{dIKAUtkqVQg$bZg6K|Y-}!LZ*4xg0SyFCe?$ub2mtHB z%OYd%1taG&*wh`&#QFyuu~oAyOCwc;fpFy_);_x_0ozRX2Li0vCS85Efj~F>l-7fz zy6^ZHrDuz7^6=4;YW&#c=~HKIrKw7wsXl{_gNE1?%O2yRH4+S{8G{=xHJD1e*e^)e zPU)zb=WGOKb?!RjsRN0p_P#-N2Fbz4K1ewb_5IgcjS2mKOxZLVg}=IR7y+$NH6gh=TJt3o>G-Ol^T7y}Ff;q+F{WL~fm zAd~V|0(NP>EyfO%+%kxN8N?uH-*kUyl3(Z@7Aqt112EkWoQVX~n4N`FggQOcS*i1DzjA9uZyW;CCdpPcsnnf$qfv!`y5|7^eXGD zxRt}arqC(}>F}U;(y{bPK?oE1d1>NNzG=t)Da{)$HI`CvQGl1^g|UxSfzbU2=f%5= zzFMe;E8ZMMes}Zn3k3(Ofh{aAUGZJO3?^W2d;MTdH)*mh!Vc}70A2jMiQ=bD5xBru zjvR8g*-l{l;2CUt2mr9`x~qDlX8>>xH3xH#jH}jgY3NztwyyL@@~q?8!&wpuXFILT zWlgi%`)pLM{ruUNJ1UFFGGQpQgh|#0g?)SLcw(~%>gBKwB%OCKr`httHb>ZZey6#9 z{6KbK4}Gl2C0<|oHTyY}Vl{0#pEp8%2_UdH=~$eEFU`cZihKk?Pd2v6!8 z;+c?>q40lT5C11$$^YdC=IB@Sh*5W$&`UGa9R;oW{;DtqgfqKtSQLE?DlFm`MmDcX zUEtIqpa`oO)}~bV)+;;5g`XE%86~e(Ui)?ZHl|29#n8uE>kn{C=)4ss(cFCuZclO% N4tVEbc0f?&K$X~SMNR+! literal 0 HcmV?d00001 diff --git a/gradle/verification-keyring.keys b/gradle/verification-keyring.keys new file mode 100644 index 0000000..68dc42f --- /dev/null +++ b/gradle/verification-keyring.keys @@ -0,0 +1,719 @@ +pub 84E913A8E3A748C0 +uid The Legion of the Bouncy Castle Inc. (Maven Repository Artifact Signer) + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQGNBGR/8HUBDADJ+V5VgTXFG4xVI/1r07a/pTXoAQhHyJMkVdFScGARsps07VXI +IsYgPsifOFU55E7uRMZPTLAx5F1uxoZAWGtXIz0d4ISKhobFquH8jZe7TnsJBJNV +eo3u7G54iSfLifiJ4q17NvaESBNSirPaAPfEni93+gQvdn3zVnDPfO+mhO00l/fE +5GnqHt/Q2z2WKVQt3Vg0R66phe2XaFnycY/d+an73FiXqhuhm4sXlcA++gfSt1H1 +K7+ApqJsX9yw79A1FlGTPOeimqZqE75+OyQ9Kz0XTvN/GmHeEygTrNEnMDTr1BWz +P0/ut0UXmktJtJXgLi5wUCncwwi+UpCSwwou7/3r+eBh5aykxSo9OtYe4xPNKWSo +EiPZXpCH5Wjq9TpXOuhnZvRFqbR24mWz5+J/DoaVP3pwEhGXxr5VjVc1f8gJ8A34 +YYPlxUGcl8f3kykzvl4X5HDIbHb9MAl+9qtwQo1tFA9umD2Da/8bSsxrnZdkkzEA +OpJYwT1EkQRZRcUAEQEAAbRmVGhlIExlZ2lvbiBvZiB0aGUgQm91bmN5IENhc3Rs +ZSBJbmMuIChNYXZlbiBSZXBvc2l0b3J5IEFydGlmYWN0IFNpZ25lcikgPGJjbWF2 +ZW5zeW5jQGJvdW5jeWNhc3RsZS5vcmc+ +=/HDf +-----END PGP PUBLIC KEY BLOCK----- + +pub 85911F425EC61B51 +uid Marc Philipp + +sub 8B2A34A7D4A9B8B3 +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBFrKW9IBEACkqUvM7hU1WqOOeb1gZ7pUsRliHuoUvYIrd+hdp+qhPmJ0NG0W +YhZK5UtJBmqvtHKRkbwYxUuya9zlBmCfQFf0GpFKJ65JSrPSkZADI3aZ4aUkxIUw +nIRoUHucmr10Xftpebr/zaJk5oR8RdaL5FapapmcZmAaHR9CDWB8XtI318u314jq +M5rKatnAZMERoPugOvvuAOz4bfZKwdfCmZKfYUM/TMSrSinXrGExSW6z4RhtqmpC +E5M/7OoVfvDynVJKqNazqgigpmMNhOyzAhQsiKh1K0akyxTZbjeZKsdYfhCXvq0q +k9+KM/cTllQ54MPnFWiObLkHeK0Waw8bI/vAJ4h4x/XM9iGYpkXv7F2/FVsHQdPe +YJcwD/CkD8KHyiPaRKMeApiUtZsdAHU0L4X/lNmcooea/7ipskruUgwcm+RdLhRZ +P949t1e7nqDZfpEHy90NiFxmlRAPSNqBLwefxY/hwBgog2jabDALJVcLCMosFWPj +MQhFlGSIODiVcW8folGIjzkyNZbNMWkwnl2QnWp/h2TAwYQJOMqcv2MG9o5pyzpx +97Iz1ngq1FlM/gJnGnNUydP2tAjT2L2U3MP1uX/EdRChdgPqdolqYhdFfwCr0Fpf +W527bUZpReHCEiQ29ABSnQ711mO+d9+qM6edRyHUoBWz89IHt8sCunuvNwARAQAB +tB1NYXJjIFBoaWxpcHAgPG1hcmNAanVuaXQub3JnPrkCDQRaylvSARAAnQG636wl +iEOLkXN662OZS6Qz2+cFltCWboq9oX9FnA1PHnTY2cAtwS214RfWZxkjg6Stau+d +1Wb8TsF/SUN3eKRSyrkAxlX0v552vj3xmmfNsslQX47e6aEWZ0du0M8jw7/f7Qxp +0InkBfpQwjSg4ECoH4cA6dOFJIdxBv8dgS4K90HNuIHa+QYfVSVMjGwOjD9St6Pw +kbg1sLedITRo59Bbv0J14nE9LdWbCiwNrkDr24jTewdgrDaCpN6msUwcH1E0nYxu +KAetHEi2OpgBhaY3RQ6QPQB6NywvmD0xRllMqu4hSp70pHFtm8LvJdWOsJ5we3Ki +jHuZzEbBVTTl+2DhNMI0KMoh+P/OmyNOfWD8DL4NO3pVv+mPDZn82/eZ3XY1/oSQ +rpyJaCBjRKasVTtfiA/FgYqTml6qZMjy6iywg84rLezELgcxHHvjhAKd4CfxyuCC +gnGT0iRLFZKw44ZmOUqPDkyvGRddIyHag1K7UaM/2UMn6iPMy7XWcaFiH5Huhz43 +SiOdsWGuwNk4dDxHdxmzSjps0H5dkfCciOFhEc54AFcGEXCWHXuxVqIq/hwqTmVl +1RY+PTcQUIOfx36WW1ixJQf8TpVxUbooK8vr1jOFF6khorDXoZDJNhI2VKomWp8Y +38EPGyiUPZNcnmSiezx+MoQwAbeqjFMKG7UAEQEAAYkCNgQYAQgAIBYhBP9uLAAZ +SMXy84sMw4WRH0JexhtRBQJaylvSAhsMAAoJEIWRH0JexhtR0LEP/RvYGlaokoos +AYI5vNORAiYEc1Ow2McPI1ZafHhcVxZhlwF48dAC2bYcasDX/PbEdcD6pwo8ZU8e +I8Ht0VpRQxeV/sP01m2YEpAuyZ6jI7IQQCGcwQdN4qzQJxMAASl9JlplH2NniXV1 +/994FOtesT59ePMyexm57lzhYXP1PGcdt8dH37r6z3XQu0lHRG/KBn7YhyA3zwJc +no324KdBRJiynlc7uqQq+ZptU9fR1+Nx0uoWZoFMsrQUmY34aAOPJu7jGMTG+Vse +MH6vDdNhhZs9JOlD/e/VaF7NyadjOUD4j/ud7c0z2EwqjDKMFTHGbIdawT/7jart +T+9yGUO+EmScBMiMuJUTdCP4YDh3ExRdqefEBff3uE/rAP73ndNYdIVq9U0gY0uS +NCD9JPfj4aCN52y9a2pS7Dg7KB/Z8SH1R9IWP+t0HvVtAILdsLExNFTedJGHRh7u +aC7pwRz01iivmtAKYICzruqlJie/IdEFFK/sus6fZek29odTrQxx42HGHO5GCNyE +dK9jKVAeuZ10vcaNbuBpiP7sf8/BsiEU4wHE8gjFeUPRiSjnERgXQwfJosLgf/K/ +SShQn2dCkYZRNF+SWJ6Z2tQxcW5rpUjtclV/bRVkUX21EYfwA6SMB811mI7AVy8W +PXCe8La72ukmaxEGbpJ8mdzS2PJko7mm +=Xe8l +-----END PGP PUBLIC KEY BLOCK----- + +pub 8671A8DF71296252 +sub 51F5B36C761AA122 +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBFoQh54BEADOuivAfgGKc4/zDwx+AwJdctjTT0znL9knRTYG6ediv2Eq+CXm +gBM9m5twl+qhUB1NtrdHb4BH49VY9/gHr3JDyo5ewu96qkbeQl4pxW0zmHg/yJx7 ++qvAK32I1WI29iu4BFnda0EJwNCcVNrEsRuLl2dBqN5GF4cmniGW23W2XsvXiuws +sKe/4GClWVYVSVrbINk9ODaANx/UZw+b6D0evTEI8lEio7WIvyrl3bnpK2dQ16Lb +9JThn/xmF43D4gXK+u3mGjueGh9sQ4vMTtnpID9yyh0J8pVumY/BVScAPDAGseXu +vJEsu4LOC9//KxeBQtij+jR5Ob704/kFrq5q83LACcfrSjsqbwkWLwWbQ/a4doRB +8puXS0GRb/uwevvAljXrp+fCmjkKfdSMMg34TQufAktf2uzh+YCarGO0EuBSq7ug +3Om5wKTMTu6OGHsWwZxyKTLZw+5FjUNsZXm9pG+20ocEmsWXFcG7jK5tpv73NIvi +zys+8QoSoLtVeo4UDJa8qUuTUuu5R+d73i9iChWdDsYgTCXlxuDV0eAmVQqjBKbN +Zpmk401Efz9QORJI0C5kaEnT9mPFltuiYhOjg8I08AbfPoijB1kgzYnKgNxXyUT3 +8vGvziOgS1A3qTGvMwNpkd1vg/n/B3wPBZC124wx/yHl4YM19b+xsvp3SQARAQAB +uQINBFoQh54BEADdIvTFoGJA1qcRGROS+hTa8I3YgNJgLXQUHMR1voK7yfDHFtlF +3WBsKmL48k6FC5BrgU3/gpuLEDzPl52w/k4rgtwKf9O0hkA+KGOfZlYA51Yy7ovf +MA2aao5MXeUjwlsa2jfTgXoAFwvmrisWbB9ZiN6DBX2tLpk/gav8dy5b0nRz0WSf +UG53ejRVPB9L0L6kXrTW6pAMlWCkh2uwAaGJoFUInNFPUMbh5f9TLPKODsrOc6j5 +Us8wgX+99ST+JWrVSx0gpQgSILEhvhUzabk0p5vsZBNt/AbVXL4M8K2TXk/+IlED +/XUtaQptEYeqQ6FKwXavrRQzu1Ru0C0DaNsAEU0OKzG5vGNo00HHKRfMJZBgUozx +79C6vf6CFnkeoFzhFOsBBVfWHMO7rQ4egchuDQ+DmV0a64+ubUjHaurpbtx00Ele +w8b2NswIWJAaD46ndt+xCtew3J0KTj/Knxn3Fw3u0gEQhyAuI14Yez3z0EfyBCHB +blEQI6SYkmAxjG1VEApNgyosjawn8uKLFOEctfLjtKz2DregfuVeuSs8ZmvF8DVR +5pPg97TZPeEj32k8u+AE4KL7iDxG1/ftE01XBnKNzbpayFCjdjBAAjEIurPEV+pn +h07XvwNkIHVx7OpddsGnTop3TfFcINGetFXf4/dM1Y8aJHwWaTsmQQv5LQARAQAB +iQI2BBgBCAAgFiEEptbJcQi4WF+RsVh0hnGo33EpYlIFAloQh54CGwwACgkQhnGo +33EpYlIgTw/+P0lHyeDN9Amht1fWD7MsckyvqUumvZg2kbvlEDh+3lkRqo397fy4 +PWizw6/kKVWKL2VTpb0pEI1SAwBCZhvVckh3gHtDkRapGwthkXf6uEWvugbaeRq0 +xPV3yCmD5p0OWMnqLnTqMogBlwNuCKsiIgPX2Z46h5aFyF6O8Ug91KhQwriiDb9I +EMmBDZWxFXsk8IfsTVzzHCPaq11aRuWQY9LNq+O0DEXusCVjKfXdtEOiq7Q3cA9x +yqnaYJ7YuZKMKm2s1lVZGyEbTF2Jn3bKqQzjNWOWphTMRfAFHGScKKQkEg7OhNWf +zeW9ErEJrqJOCyc/hhGFFKV81kIpo8pQE/yLc3DnIDrHlHhk24+A+CRE6t19FeVG +iduqLSJ9H56d154hm164e8nWNn9zzZslpTmhTm1rD5/MJovd2Pz7Rk/n7+iAXJG0 +BcFIHw7e1e2e3VqTzPyeCVm7HVMuHSQdQH5lZVLMzl64FyATfuodSmZwmaGx1CPG +VB/1CbyJ5lTBwWhaJ7dbJxE5cVeOzD0P8uKqTykXUYOstM+qcWxI6N1069PsljI4 +fUrIP8I2JSxx32jfwv/xBUtm+t2fifUn2ZwSXbjjkqydQk9g5VsqzTgMdL+vSvsy +jVr+xeofYWMziT0t2piW4+dF0n6LBoN1aHNh1woiBG5nZtw3cc9rVdA= +=Om3K +-----END PGP PUBLIC KEY BLOCK----- + +pub 86FDC7E2A11262CB +uid Gary David Gregory (Code signing key) + +sub 59BA7BFEAD3D7F94 +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQENBE2kzuwBCACYV+G9yxNkSjAKSji0B5ipMGM74JAL1Ogtcu+993pLHHYsdXri +WWXi37x9PLjeHxw63mN26SFyrbMJ4A8erLB03PDjw0DEzAwiu9P2vSvL/RFxGBbk +cM0BTNXNR1rk8DpIzvXtejp8IHtD1qcDLTlJ8D0W3USebShDPo6NmMxTNuH0u99B +WHCMAdSa34wsg0ZpffwQmRxeA+ebrf2ydKupGkeZsKjkLlaXNkTVp1ghn5ts/lvg +KeHv1SJivWKCRmFlbPhBK4+mxSUSOPdoBNAfxA51QzZoPizSk0VbRz3YufYRVLFy +9vqPSorDmYJhCvn3f6+A38FS/j8VE+8obQ2rABEBAAG0O0dhcnkgRGF2aWQgR3Jl +Z29yeSAoQ29kZSBzaWduaW5nIGtleSkgPGdncmVnb3J5QGFwYWNoZS5vcmc+uQEN +BE2kzuwBCACzeGpkd6X/xTfKDBWvXgHOOKIJ2pht9XmtZZKiIj7LIiSwvSds/Zko +ZKxAm7AY+KPh8Xjf968FtoUBQJvHAG4rbowEqT7OOrJae2JcenH5qzaod7TpIPQV +v+Ysz8I1wLlC6LzKRj1X99Hng6X+obsEasnPbmEEkuiZ/Sgi4vVC8SHkDmYt1Dx8 +jDgm53oUeWkEJO9LSI2zcrZhSgvg1xa4Q4gY5UUK7gE4LbmGCjFlATuuW/0sryxu +8zxph15gkn4Nqgk0CPMSjesMYEGOsdDzfQXl2tXbt+Pe6mBoWh67MZ1v5zOq3EDt +oSqDpWPxponAeaCuNDDFX44vGjfxGE0tABEBAAGJAR8EGAECAAkFAk2kzuwCGwwA +CgkQhv3H4qESYsvEMAf/VGyqIEcw4T2D3gZZ3ITkeoBevQdxBT/27xNvoWOZyGSz +GYlRbRQrlo+uZsjfMc9MNvaSmxyy4gLVbcdvQr3PF//GxphJ98W8pk9l+M57jfyH +nnCumn7MO4o9ed+WuigN5oeuNJ6BIq3ff2o1DsrEvDChYOJEOeFuWxv+u7I2ABJJ +ep7NbByM2n9PE8vlGU3zUBgWUBsk6jT+klKnEyHE76WzegPLz3jtElTuyB7jRhjy +QJu1yiJEMbs2zH8aJGObi5f8Jum4tILZuEAdoI0M3c3VRq12cz/vLy+9VXa/s//8 +IsGn88kjyyYqOy8WJEjoOXFh++dpWiM7nZkgQcNi5A== +=ggBv +-----END PGP PUBLIC KEY BLOCK----- + +pub 873A8E86B4372146 +uid Olivier Lamy + +sub 1AFEC329B615D06C +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQGiBEdddbQRBADRgstdUZq7ceq3NYcR5kpoU2tN2Zvg1vptE9FxpDbL73gdLWnI +C7IAx+NNjdG7Ncdg+u10UZv6OSmhWAd8ubWcD9JxKtS4UXkNPHxhHFHqVPHuCwsQ +q2AaCtuOk6q9OtthQX6LfOuGqwbv9uH/KLUDn91PrgKuHPVfVveiF30ZvwCggutX +D0jTGRHzUJl7F1wViuckHJcD/2z76t0ObSuTnENi0IUjF3Toe4tv+qO+Ljs0knvK +tu1b8A5Bs+kxNcbEqV+zdIph+6gCL9jy+dB9J+t6uZg6ACJexbIkDPsutNtbAVDV +w5AtM7JR8930dRHfEt26ahFohFi+73V8RiA7LrmMjA8rX4zuo5Pr48xt/RR1Y/VE +8ohCA/wOqul9eHHevxeEMDYoGVjGl2EiuIThg4eYuQDDSisBNb9a6dhE8ECQFFBx +mGz32+I8gXSTKFAkkQUI4HmJmTX35nGJql6E7Bn5yM2OaOG04PV+xkhScJll5ZxZ +BNEccFDL/aI4N33cwrLHyk+wFNZHBL1hnHpxpjFZYv5xfEBjmbQfT2xpdmllciBM +YW15IDxvbGFteUBhcGFjaGUub3JnPrkCDQRHXXXPEAgAyqEz3eBEKiZ7VbAj96Ht +IvGufKTdZ0ERJtrdPO4FUGVBcXpphtnPn+JOWomszUKkKLO4x24OaDCG/SENsPy+ +Ned4wjBB+4uV0YEc5Xn8gts3g4Z5p+YiVu+aWeYPPC5BPU61tVqc996i9ZYkZiYO +s9F5Z+dKozk3KwVcijaCr0IQMjAtJ/N70zcciP23KhrN9Z3Nn54Xm7GezD0nxTUG +P8gM79zKHnVhDBptrxIT/adCzU9/UX3UVAQcdq86FfzTEpqFG3TM75HBTQgHihIk +kirzurE+ivh6aaF3UJwmDBe5Wu3gvxF6Rl0Ja/YBNkkCiOXngXSxwvUUR8KJO07R +GwADBggAxOFV2DfMHsTBu++gKJ94L6VjETfVFEYPo7e4tO2Zn2Unzdxz2BoTJcQY +0j6/M3Tl9hCwhOSVVL8Ao/wp1ykjgXnwV4vz0be4d/ZML+KF15x+8730H7Th+aR+ +Ug6K6Khsp8XIypmLJcYgYLD02PlSnDxCq9Fbv0JDlbr6tbsJiVzoRjg+WNEIB3II +rJbTIiOFrRBhloinYoot216QJ1rI2nQpMEBlSuX6f4jYF6F7X4dAY4V4ohjFeJCb +6SYkKbj4caqBA9OVrj3vh8v/vAUKDB8pqVhpaZicFpMd2pEEYVMEU4i1sLE3X73y +9RRuaJOvPAx2HHT8MlWjsDmNdY2Mg4hgBBgRAgAJBQJHXXXPAhsMACEJEIc6joa0 +NyFGFiEE8lSzVhfcJV2TRLz6hzqOhrQ3IUZkrACcDtB3CttHYgGrF31KCocX/gwC +iYEAn18D875QwNruE4Qkt/W0Rhy/QRIZ +=BrH5 +-----END PGP PUBLIC KEY BLOCK----- + +pub 8D5DB0BAA89FE87B +uid Azure SDK + +sub A2873726B043F3FB +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQENBFyikLMBCAC2ILxO0mGhn5q+4kRkA8n8PkWtHLIZOx0VFqBObS9hLdB3z/44 +tzzu9ofX1LFABniGrUFOrLQkkexRLf1VS0WysvC48AHsrKZE150OIK2N9Bhp5IAN +NDmP8nBe//nL0iFNmv8mxMeB2RGq/J7v1J3jyMShNPKmOt3WLw0jI6f6KPh3Qoal +4jX5jXx0h9VfxRxXPQkuhCeZrB5N6h3URdW8xQRZbofDQ+hsZJs5GjIWoyLujfqU +BBtsGHBGzSvF28QgknU70SUD5D21gc3IX/kBd9p06UlvKlF9xeMr5aUKDjG4SCfZ +WyNoUFaKufbLGovaQg6RnR4qHN7yUhhOZBfHABEBAAG0LkF6dXJlIFNESyA8YXp1 +cmVzZGtlbmdzeXNhZG1pbnNAbWljcm9zb2Z0LmNvbT65AQ0EXKKQswEIALd1ofUo +Kt7jQR3LCN7XoQT/UDmj9VxVBPc6spDDztB6DOgrkMCC6uYCrm56D1GaTGIU8iZC +hvjrIey644YQ2+imCrXZhTJnv4jkWp1fOulCHeARDJisG4NESQY0Cb6ARVokAG8Q +WOOgaZWNoufxBh4i/iFYrfnSZMTTrmSyBl0XQe3hIXTSm9dqFUPAbAvoloqNrXLe +dj4E9vvF1Jl9ieTGghY/yCTSTnx56FUJQieAVCv4vhBg7kDeBFIkT6B1DzWuNy4C +zIXwX0mtLBjvoTS8ZkSsr+HM/8FDeo7gk6CksawNXGWbdkgOXZExQDe9tvcZt7Vt +j2tj0ycTRxRMaZEAEQEAAYkBNgQYAQgAIAIbDBYhBL8nOXX1hR4N3jq7fY1dsLqo +n+h7BQJcopPWAAoJEI1dsLqon+h7PPAH/241LyhLp1HGxN17LeA33EVj0d8a/9xb +zKKHEGpb0MJgoEf+al9NmPIlnPsSijMNJs/EIM6yOtjBb9lGfJ5DolcAaEbbP7V3 +Kf/xIsOCiNBlhKqi43YBcu14jKV/6zjklVpveW2Nx4E5crXtu8YqXFEUKdzifTOt +NWGBRqx0f/07tJvsxq9a6Jsrg3QXzSvdEHj5BeGVgFusPxuQ9KSrPXpLPmzSP4jJ +2SQRMAxzMmn6Nmg9jUtDgI7aPyNQHqGihwGbFBkq5uxbypcezjNuLrJlVWAIcQzS +V3gzVYdTflG4WI3RI6m3kSbVJDDjfDuXnjSTdrRmD1DWJHidTFLAFvE= +=9om2 +-----END PGP PUBLIC KEY BLOCK----- + +pub 928B20E9AD5298CC +uid Jakarta Contexts and Dependency Injection + +sub 0AA3E5C3D232E79B +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBF04lUwBEAC0RF88RYNbBpBPj/tVG7R+jfMeuVm0Q7hpFtMH3XWpg8um9lPa +yLkyIk4LJ3feiCc2QJ15Gu82YXBnbHf+Kn7S5hc/sIqnF+Xz3rcfHkOIYRQGxiq6 +0NR/1l5zyDJ4RHgnK2Lp/PTlH8msym97e8RpXyvK6+EN1UrK4dpZawZGjnMQGqyl +gCRi7G6XQuoHe1JVhuTQ4bFO6lOtwQy0n/L5VY/odOPTYDUo6p7fJ1n1NMdQYMIb +G5WXpxYvT7ZAcncjd/cK2iuBjrxIE8aUisa21hFFWoi1Qlxbzrjl8NPgH8tp1kxF +y9Yr2hHYJXB8no+KZ5pjoA7DDTCZ9u7vANsg5oQ82YPu3qsSC7GDZ7uZXBbkShhR +zyMeldN22SCxPeMLujkl0hExenUd67YF69i5YHyZ2HWOOZwTDN8ZZObGk1W4SHvO +B985czkSbv/UytROIn1umvv/LGDnxsZqIC9JzbdV4IREX4+XwQ/sAYuEmXrdt2J0 +tgS91Nr22wxhfnQVieV3pFPTQCtAbjC+o7rfWc6i12BAZG1SxxHdDRvdtXGwQZmN ++9E+GPQOUbXNw7nLxaV/Oe0D8Pz7W1UGlouysFRKSgwhqb4HRU1/9Y3I6uEE80+b +M8aO08zXf5Vw4B2U+Z+Xv+vkMkynQTELSM4v1DEdiaOxQNKbrtAg00PMCQARAQAB +tD9KYWthcnRhIENvbnRleHRzIGFuZCBEZXBlbmRlbmN5IEluamVjdGlvbiA8Y2Rp +LWRldkBlY2xpcHNlLm9yZz65Ag0EXTiVWgEQAK2p0Gdi3mUE8iXhXkbLeT+FzD2W +mSawKtRnsKp5QcOD7q53g8Q0q3R2ZtLOrv9rTpspsRYQ6DWja20/X0UzpvSAyHW1 +PokQZWei7a6+LGjgYuiorFv4SYDOxnjaMwrLqSledwjGvacCwSMKRlCtX0gOe1NO +himlWXiv1qK68Kwbz/zB6uPDVKJNduRf7jiO3laNmvzpo1r5FUzj5Up07HiS9aAU +HPjNlxCcB0bqhz6ySFc9lGDQBxADruYl+FW3hmrMppDUAjEDPNx15aH80QWYJVcH +72YCt8wEZ3T8x6IUtqkFkK1890jFCoRaIK2Y6xGsPyXCOaOv4w32AQApcWFj4vpn +bC9HUZtM/1cVEVMFMcirxomArEv5NE70S9Rk/rCI5nRATr31fa+nuqRnCtJ3OO7F +AkaRRMbqEzpSCSVlfS+TRreZxburUEYqONCfxqhhyGVZQG/R9Qmye/AzRdD0oCty +CRRWihBk54EhmlyHJ11pXZ4OC8joOKzbXn/ILtRhVoPO1f1no8MbNjffetW2PnJ2 +DTkYOyfBxLLmjKSMyrC4/l+3Bdhw3O3HdsM8uSAzkhU8nQCVQkrZs6mCsaCg5Z4F +V3T2ecNDLNwc1XzmYFgKySLPqgik77k876sSrH3Q52brqkjrFpzZSQcRClndMex1 +RMQyLNw2SHZPFik1ABEBAAGJBHIEGAEIACYWIQRqy9UHPfLYN3WRaASSiyDprVKY +zAUCXTiVWgIbAgUJCWYBgAJACRCSiyDprVKYzMF0IAQZAQgAHRYhBEAh7ur/XehA +Tc0KJwqj5cPSMuebBQJdOJVaAAoJEAqj5cPSMuebc5oP/RKm6l3gcxlCT76szN7u +KuJwX/C8M15EV27jbZQwSMtzEHQ64XyEbWI+NIMvKr3zHXIDLM7vq/O0XRSLB6e8 +23HXYh+P1LVINjUIHpej5P7TCiFbcI6XhIP8t8w+WgxSuzZU6L/IY4Yq5lEzHjaE +OVjZNst4kbwCIqIUcnm702oSNdDr+ruOjBxbVLtj854fvQSciy3rF8W2VALDzJ3U +ABQ+wo0c23D1Uy7pq9DOrC76vs2J/6fEv2occYM8yaQNn7sraDjFjwK6001SkDzJ +TMFuK0tHikZZ7v30qzsEBdsJJR8lcXUQo/obUTh2cgH4XTjLa8WEgZF89Dd6wmjq +peT+84+AkQ/Pwf3RJPzoj3gxF0vyFU345YMFfXL/zokU3GNwiTFOrxJ87xoYamUL +eKumvfemI72HfzpDt3P6OzCh83zYqCpDnp6r4KL/+jwLJBuAkJoY3g3JcjkAF0HK +EIGDnWSMAGvI1dZ/k4Fc+K/i/PZoj01ItQHDyBa19VMBZx6/tlwX2eRIYaJavMRS +FrDDg0m8cSrAE0H8E1e9hrEEmhb1TTeKN5MscaeMXI1od1lEZgAdnvUkmDhdRAU7 +RADvRSTwqsgGf0UVokbfISiIqJS7wDpbRtijIjRzs5lXig4p3DNNdBdFIPSq2xlj +FCCsCeTu/OkLnvvTFUroxhEbDHgP/An8PPLWkJdsIoZ1lt9dqQLY9s4FPL5B0NGE +BLRgBOg+NowAwyVLTFYInfSUV+apMnBW/rGWyODMSdvcY+hmVM+Ax0gTjA6D++yD +dv6nxD2IEG+KoVUdcpYCjbsx+46S7WbEzxanqoXFfVEUnWLD+S1jtA9uGB2cGCVc +T24ZBWc7uaAb106YouyrIjZ0BFxC+HICcp7vOY+ULQznnYyOI05L4rLsXzY/AIi4 +BfXO37ybmJmd/pLAkdIZHkFAOSYL51viai8hRAfgt+hTEyMpGgBYHMwfav5UAX0Y +f7vWhJC9MvMD//Tqw2w6MQMzwGeyW5YZuQxetkYoTwAmp6u4p72x9WhYol/48F1d +wdxtprPNCASPgEXrdpfB3iSHDZuX57eXU22ePMvfa1JCokUyaIAuIEyIVDPBzO5S +NUNLAF1poR37qcvZFkiNiBbhIInfM2FPYq7RL1vYGLRzgvYXzENFWPnh9YiN54Na +el2k7aN1AbDL0bTb1TACAqvWYIWFVrxNn6Sv5JEFpV2rnVVYsVgs/EpybbtJpu3k +R+IltzAWLOzjqfYU2pr9yW06nNytDApPQ6S3OGg9InjGUIzmLn+De5DD9wAy1sKE +3FJGzPjQA8RuswK/tMxVMAnI5igOgDGugSuGdapzbnS+xiGWC3Pos94VYqMrYYD9 +s5E5s0wc +=+V3C +-----END PGP PUBLIC KEY BLOCK----- + +pub 928FBF39003C0425 +uid Spring Builds (JAR Signing) + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBGPF4agBEADsWnQn3m/dMw1Q6FLALQCEucRkRLw4wcmtzXuuYb2M17aHvEb5 ++OnXDdgQ2QcnnjK4S3zQp/Jt4ZQnnLORqx919+c+1gT24U06VxeGPW/TLRn/hnKA +ZM7bwGCz7em/GQ7JaIXPn3aqGrCiy8j8N5jAQ4ePP5ESQLeWisQFlbKMFVU09B7t +0IPG/LQ8xJs/SveQw8sGrz9zqyYE58EauyIKfiI91Ruk2jMcb/m+SRL9Bhen3Q12 +g6kFrHurLtEWzy1rwELt9g9OILv0FokPa2m0goQRHx4nFY0kIpJ/r9kDUg/tlg4H +OxP+5XTJxEXGW2gb9zpmDpdR8aUgi67/Kdm8+norzpTTMAuKCgclCv3bJz2D8Jnl +IgEXmSoznn1EnFkm0Qsr8JwkaPC6LkGcI7YqvEdCXtRXduot+9GgWytp/IxrlJ4X +vFEhOmChdVdn5lT1T0ka6NxEJcmf5mfgyz9jRUVHINNJxQKP1Gh7LyMFeWw6V/X7 +RAeU/th1pL2rAeBqn3gnK+CIR82/AVDJJa86BAHiQBYilgs+bGYriXYd0qmIFvYO +sSfC87Dbl3kzwcAGWB4d6tezLxrzscfbzWFIa9woy31/OcqK+uglSKbTFsIklhM8 +Rr2B0tQS1iNzq5gyWGKnh8FsqcAiGvDpwhF7irGhU7fNRVVSuamVDnV0BQARAQAB +tDZTcHJpbmcgQnVpbGRzIChKQVIgU2lnbmluZykgPHNwcmluZy1idWlsZHNAdm13 +YXJlLmNvbT4= +=DLt9 +-----END PGP PUBLIC KEY BLOCK----- + +pub 96B88EACD463B90B +uid DiffPlug LLC + +sub E09F6A4522F77DB9 +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQGNBGBs2wABDAC+hlEcwcAqPBo183xD18nAU7fBJI3lkg8zCvMgpMzPH8uD54wS +fd0q+7k+2Ddf6L3VLW7+uxuQDNw1gLfIWHcSxGI151pyXkSmYlWsLmGRRwWNSIDS +Qhdi1nnQ+JERKXIo72IikoedbNJBhSTQLEWAeVY1RbeOEeJB61L9+ZEoG4BiB8UN +BRyZ6OCj6BrEL8tzV1wx1GL2kBHCxbxJGEoUxsePW6IM2lfvttC96VFWfZ2aoheI +cXExFxWyxBUJPSovE0708khSh9NmCtX7yYXAqQ/EwxLnMrVp7x/kVbQpQeQWQB3N +zRypv9QLWcp2XUx7oMZuomhyKNA36hmodCg04iIZUfP7ytc6yMIliCxLKT9mIbmb +jg+tr81v95U7j3EYG1/2mM7h9OblqWN6UQ+5ZKG/kra1/IBpqujd9L0AxvI8/RXj +yJU4q+UYgNer6ijFkpvHMsp+M/DBBtdChycCjhxHF/i7CKyrj1SWyC43HdAFB5pk +cOnnt2I+JodG3C8AEQEAAbQjRGlmZlBsdWcgTExDIDxzc2xjZXJ0QGRpZmZwbHVn +LmNvbT65AY0EYGzbAAEMAMBl7E9XNx+IjxwLQ8SBnsukk4NrO2DMUzb58l5pfUyX +agNZpZJVAgJNyb7ns+xN6YXErt9LQ/4HdiamBrAozVQ4ZNQVjekW7drtbPFzxJSY +mvTlGFOhfYRSZQOCexI9MmViYQ66CUi8RvqrgC4XOAofH5zfopSl75Gzpkjd3qle +kDPL2Cu7WvY3qIK7nktay9F4NRLSRrYbjGd7yzbZDXRrIPSLNyuO65rPkaC/hGOd +KbF74UJ93Xeoj1zrsWJbJq1eVfrUTlvNFl/cq6+m7mMl/7X3nIZdGsut/usc+cLy +bI3Vme85o5KqKWagT10QjXITAhTCVEeaczcdLKaV9JDQkCPY4UA2gvkvfazEVXfi +xFgF76+2ZDaaPLPb1cVKCxY8wRS80/XYX/AP15U1l5qPjKsK7mBMXLqPdk+6IZDH +w4dxD5g5319xGk4ISpiyfCli5jMbcizFhYJW7gKsbFkn21oHGKbG74gSScAE4xyK +sbTHB3jQC+bI6kD1MUY/0QARAQABiQG8BBgBCAAmFiEEZsph6g/H6eoSFvgzlriO +rNRjuQsFAmBs2wACGwwFCQPCZwAACgkQlriOrNRjuQumRgv+L4fwHgMTKkCaDklZ +zn0H1toWKCXHhhwdUrQX0UCeXctJ7bSpmsyI7XFs6rHPn06QpGVCK7vo58kcUNKn +mJUcqzNxWS6lUU6x9PoQI3IsCQoK1gx9dMJHCjf890YfyWZXxytBHl9p5sSbLvP1 +QF7sGMKN4ESOMvzgfV64j84W3Gv8PIdAuqrom7IySLXY3Onxo1PQ7CzQ1/f14ggc +NvZ6z0HXnIdIlBIxw6l8X0r9Kq6MoHojkcFa7VYN8qnIkxens46CiODslW/TqYbW +gjm7jKBLfUF4GCxlfCGjhcd7IBgvkSyDkfXr9ug1QcGlxh1kTX4m+UnGpP/cXHfB +cWDFDCj2Y3yiUOutcuxAWIvG0lfNuJZoS1lliUt0yam3uOKeiHNS/Er55WVGXFsg +L6Sqn51We6BHCOwRkbgKnHC7P+tBBz9ZcwgaaUDznWOa/Kc+PmH/EJEVkRb/VSwy +7BKzJCRkgSUK+0dwSoh3NyBxizsAWePMOK157AXfExz+iRUK +=3vkz +-----END PGP PUBLIC KEY BLOCK----- + +pub 971248996DF82053 +uid Adam Cozzette + +sub 098005D377747985 +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQGNBGLYgmwBDADA1D9lwr5+zStRxk/ifx1qsn+5PjitNlWGEMkxn4QAhzL6yrVs +vMEMvbjMVjQG4fjJZzZ3PpNzxvASnZ8miXBOms4fx4SEcK9eUPVUE3ZIwzj89O7y +7HLe3TAsdhf0qOIJqV2SlLmJBf42ATrJvs2zprxzC/Lb0m+ymtcAXtntKU7+ecrp +E7nDOj4lUgXlMGezox5USXUIM7w05ea0V0Hyz4qjopavLFe3DI484dV3tRD1Ehhd +/PZT+Ny3PGPUX8IuMYLaKWKurQzQrNxbMiHLVIOMaWviUrnsay8voqhZnl6xzOW6 +JqnMU+aIH0Tj3iXv70sM5Rz48khFYMS++4eK39qjGMJ+5lCKs19P4+69dbJe9Dow +iG2PvKL8djMJZgqrOYNqMOTI/p/Cdt1YNoGZs4rmSRLfgdSk+sXSRjniUduTFmYt +Og/ylWhWZBgHoj9atvtatO0JsSIlsTRL1cx+XcIbWXpW+37HdoBN6QVMQWk0VU4m +ZB7W46Asyb0yUBEAEQEAAbQkQWRhbSBDb3p6ZXR0ZSA8YWNvenpldHRlQGdvb2ds +ZS5jb20+uQGNBGLYgmwBDAC6SpzTm1VIUJiPD+TZhogakhSeUtbGJ9CNqjo2vzst +thqciRVMkElMyMcAhWhYfGVCVzZLy8QbjaB6T8EjZI13OpRYkGehdeMxrAR/e3F+ +nGeEkC6+fwF3c91nADTeOzGYCoKK4FoyRqhN+OZdxkFmE8lZoKSo4NphW/6Hr7VT +you+pQUSZ1Mvauf9a3wGaBxcrC+jlCf4laSZyfYlMJ4hgvlMHA5hVQm7fouPWAyE +qH1zxTBxZqrZH0O4tsFAzdf/4/NjxjdLy1zHG6sL2ixReDiM7xoPTRgYBS9w3A4w +mmcumcwYQQ0rAucQCSykIFSnOT2O2gOHJJkU79qmazTJWU5mRX9bgp/gms9vAudD +AjmRoZx7FTQj2i3jpSotF3inwPcAFQw0kjbh07vBjcUCn0C8vUY0zzilVkJQwutf +5MzgQaTZTPKTgOQUmEKPdeaeFc6A2PV9J5z/5UktooR1k+vCKHSB/nLtl1ZyutI5 +oQ5yIJJWWPf+T2uzuB4Q8hEAEQEAAYkBvAQYAQoAJhYhBPms05MQtHe2kfTj+ZcS +SJlt+CBTBQJi2IJsAhsMBQkDwmcAAAoJEJcSSJlt+CBT9ewMAKWV7sW0lb1EYi0f +z0Ntv9kYPkSm9LRffjFPfJiA5DjLCEQ4QD8CVLSQaiGUc3eKCpFIP4zeFWskAWhk +OP3st8g6IRRKm8jnO06hA/JEncsAP/7yTzXo6CSWkeuu4yNBUrFk8iByZUyRZ0JL +Tu5d182gyDK2HW2DRi86pFoJndBSVXTUqTi+xygxlfCWB7P6/q/iul8o4UP1IOiY +rVD5DqTSqooDhLOpkDAufXYCO0fjiPt+V4YcO/5yDtkzdocHMWF+2VsDFhc0l7Z7 +hHs5S36v6jm6Dr7J0VRjbLwPfrKZiDlp0dTDjOARVzI+UdrJ9h/VSEKTiAPATp5a +fGgHg/47bURogsPi+7MxCA5oq565vr/3CaKfpe75p9h0KfwIHS/DhctqSr9jiUhn +eBi528FqknI+8EmJccTgyXRWzN1ME3qh5ISEqo5/rkTjoqOjQQkQiCOV3l9Q5D9C +tkj95CvoDYH4S+5P61xNSnhtBUiCnlVw7lIXvHVDX6HasYOQaw== +=5JK7 +-----END PGP PUBLIC KEY BLOCK----- + +pub 991EFB94DB91127D +uid Antoine Mottier + +sub C327DD2B96A50E1C +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBF6WyHgBEADOrbvGGDYVckFcUofqKiYrBneClFJH1ANheF+KIekmnFV2SH1Z +RS2rw12IbpCjwqjhFTMWH2UTLF6pAsSGIufTrSVUAF2WxHw84Y60KmwuYayJCVd3 +R91/FaonEcZkH770vNaij8BNnQUOXoyhTsmTw8tpMcVMyCjLn5qKtNVnGsafdi3C +8VJBTP6x/LjYyv/m0/PgSIX8huzD6m8WzjKyEd9sww0K1sm6C3kF9S1/yQzTu8Hw +Y22fc5HMNU6IzyUxLPht4BIbvtCIVn1HSfiKv3CUd4B/4z8voc9HJidFzrWxei+W +uev1h8GSIGQdu7csfsuuFjbpIWuU1OpTRWNr8lFHtGtgQfE4AemSnvXycA/gSlWC +M5BhTW5w5JuGSo2LBq+YEthjhrBrjkWsOGHiD6TiMvsFPw9UGvhEvzlqeA83sXiX +KWHvroGUduKyq4/G0c2qCxncCB9IXA+Bbc2je+uSXxY+Phgz3b5XocqOKphTJ6Y5 +dvq8oYWrx4T0Ow/pYWT3n2gJP7BN7raRr2WafQ45fPKNYcE5qTDtLJ/HPPFKdHpP +jZj8cFKzUw6VPbZwRQi+itJOUQeJ1l4xWvEA2RKgDxDcunO9270RGdSsj/rxNWRS +mS5He7HuEYdzB8MsO+HrhQgTSTh4gpwgKr6lRhWJTyKH1qk2Q4pT3N4fIQARAQAB +tClBbnRvaW5lIE1vdHRpZXIgPGFudG9pbmUubW90dGllckBvdzIub3JnPrkCDQRe +lsh4ARAA19eaiaB/MmKFSR4czYuNaB6KYUkN+9bmgSk7WOhsTVBXhiVpk5ATCs+F +rwIgNgSHGB8G9GRiMxJMKijifnemTP5DjOYfJtffBEhSi5OkV4C9MqnBOsvPSEVB +LgbbJ25JEdiCKwvNwGtYzB2+aEYrXJFQhpM2RGOkuInKq6RLHmFu1Waw24AmH20+ +s5ma05U4QXZAAHn28Uhkn6ymXOhQMrxxs038GzZp3Y17fiAaJJkBBaOJTMeaiKkk +U+rplOYnBN832V08e46bs1I7jfaRroCCaJTn5O41aK5CG75typ2Tz5shQWkcniEc +zXXKly1vGuXLk4CgiVpHVG5XB7ilH3EVDBEU8kKpP0k3Zt0hnI1Pi7TMyvIouWaL +osZxXOCUJa2LL03jWCgdVe8RVHKIG4wfmxjUPzlSs2lSYeX5Hwn9iSqo7LI5W6ZQ +8NhxL5D7/U+JttKXbfC4CHAZNYSnVhD2nhz9YVRng+1sSbg0wXRNHb6zeZ5OcKJo +C0/qJtlQu6qAt7TqCeRiKbPiXKoftN66JWSPPYiuzNilt4fjnWPX00uHwjXb0vR9 +fbK6GeBt0uEzOBTAfAqmjhHYoGzPqhyJ3cMFk1qMI06n72xBAlDYkcivP8oXfMIK +1D9V/UtE90leW+B+FcrDf666D7LAZr9Kv0gUzOOS+zZwfJWk83MAEQEAAYkCNgQY +AQoAIBYhBBDzx6AuylXlArrc85ke+5TbkRJ9BQJelsh4AhsMAAoJEJke+5TbkRJ9 +E5kP/jTtiHVVQlgM2tzjUW9OXEH4Fh2S6+tieI6zqGijTr4JJZ+sHKmwV03Mwgc0 +M4zj3p2jw3AgQKQbddo4uksXFIC8453JxYGjQkLMDTvGdVG2P59ugz2+7U8WPe2j +ewawz0wZbL+/Epkzq69gd15WeNw+UhaYko4UUWG6vu6M4YRPhE1wVUX+4/zH22pC +TmJXz2a9vWMDmKipl7DYSCitCn/E3kAKXee3QTY9ZCYzPWKqfysZcFjVYymBqP3j +SGMvYaIyuoFi0imoRA9HwI3NAGY6EJrkHiRCFMkA5ApFTOEwArVTauj9E1hoN+WH +sWickO3XUdpDLh59aSPaqYI82Iy0xZ1JA3+L3w9+665UOoWJ4KZT8fTyUDN2WTna ++t2sWAcjHFHPHx8dChyPOWwhhh2QcxsgMqpjoGwGCEIsZSF23mcC3b6t0JQsuKER +/6xIyLbedHS1Tm5TcmJyzth4sYKlMLZDHB5r/2Q7Rx3ohZ84ouvhSUMlasA2Mk9N +qHanXuE7UqAlLk6iYNM/dZdG+zt0ZfreeQtfKklVhML8xVroN3jlswrbHGOFPzOO +FzyWklFxf7wTK7SngebKJTjm+U+B4zcgwcMRUWGZvcNfEvUG+CwnVs12VUUS2yIy +ld2takfefAHfookOb0HbBH7aOiIx4D0GgGqmYtjme81xWF4n +=QLy8 +-----END PGP PUBLIC KEY BLOCK----- + +pub 995EFBF4A3D20BEB +uid Ktlint (ktlint signing key) + +sub B89991D171A02F5C +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBF9amNkBEADKyJj5snYd8bZpONpu1QHf7c/TK9HxcMzGZaIv9QzViX6CtEHb +2Q2x6ejXQ2frECMrvns5JAJd21B6215EhlOqrHSMkTrQ6fvOIfWd0huZ0QHr4FME +58xSA5quKBUfl1iO2qx23qv6Haw5G50twq4A9WJdEelJJDKzzweVw0BJdv8z01In +/+sfiitcTzRT0NPbsuOnKCvfIa3gn87BvHCtqai2njq0b8ZQroLaMONtvzrn/gln +R4oPBdeIpdjf1CrAdWs8zdiHAZWuL2mZBieEgr3+je074ARM3yCpo3DRw2bMwJe3 +JiqIKb0ebCs8ddmOaT00UngmQqCOx1qGjQeXwTD3x5Tzcihdyi5auP/zsBUZHf6d +kmugzOWrgQ+rdfUCRI29gLWcwMp5dvMJxanREY+p854Hib5n4HZflmkaZCnEls28 +Xh1h3T6e5pWKvfZhsu7qefFjgY3G8O1vKmHjOQNoc/sEUwimAXJxK8E+S3iH/cSV +9mdtr0TnlzI2r7+kXdyUy2rGgieonSRVRtd0Gdmu4MkiUkbrX3MBvqP14OvT4xkC +6lcbQK1lrXflWSSRmtfNKpysVOfaIgT5p9F5zJJFEFGm5J25z8beCD8Pics+OHF4 +xfYB2SlM4xmbow2kr2htAE2RyT5EuUNuokkdtrZONmBGHBqzBPvj1vzncwARAQAB +tDhLdGxpbnQgKGt0bGludCBzaWduaW5nIGtleSkgPGt0bGludC1hZG1pbkBwaW50 +ZXJlc3QuY29tPrkCDQRfWpjZARAAuOrtDh19sef4TrMC5WaoBnbHBaYxhLQHHwIU +49c6PL9r0zWF+BPWheYUEkJ3h+fWvUljhQ8xwr1VkYH8bbqVZtwBTz8lh3G9MbEM +n7LBtFROk+AdzwTT+dqQLd+ra/YIevaMX85Avwifw5pSovA8usKrfQs1huL3IiN7 ++2EY+iTnTOdj0q/t6/CIfBGGA2hDwGFST6jWKrfnIzuYKFagkkHx8tQ7jNIIL2dr +2UAGcAIC5iqxAwOsUFInB1TnzdtjCBLBsv6sgu00SYMoSc1NimGr0t8kqfoT0rn3 +zYd3r6QK1qRTednur6t5fuX/IrgRbjUWrJ5CAH+/KrLtJ0duaTvBGM83XC+QMJI6 +tvOutT9r3rg/aHkd/QfBuArDL2EPIfaCi4fmfIpdFgAsnLoyRmhcSa/4Zt1roAkp +bc4QjetKHAjmjQTKvuayxMdT0NgwWn9PcZltElvqTJeXVA6hOtv3BnVxdQ2gQq/B +47o2eRl5tmQq7i4pD2mFNsxJPaX2YXkRjluLr6fkn3rixaPY7euU22EL0/4V/Bcn +cKRtHcELbjNvvRVA0qbu5NNDQ7SzFMBfsZber6OPVbdBPZwzGB/ThEDqMxSU7cRD +WqThbxxAyNWQmMQnCjgEyqq2lsw/vjKSiCH1WK0Wfgk464dJt0NjQOWmQy0xJswe +UmNMZYkAEQEAAYkCNgQYAQgAIBYhBK28mH0ae5HbawqqgZle+/Sj0gvrBQJfWpjZ +AhsMAAoJEJle+/Sj0gvrspoP/3NwCmF6PxXQ9bp9HOH5CoipYgLabClH/CmWbMOF +ZGttktZ6ipbnMcFoqRcql8r9qLVJ/CuG4w3e2HVwZ2WP/fFfBzJfKXkTknKiMFQ0 +RegGryw3o2Fafluu6zv1K/0WhRa+/PIqqNFk14W2nwCFpRkcDz2pt4qhC7lk6Mv0 +Mfub8VwHSp665shSMi4okyXtLrNO4+q4FF8x9I3S1LtalnwbgRFO8SpoDtbZ3AbR +OdJ4S3EAiFYYhwEUWdZT6WKOSURpeJ4SdBzt2hysGYnyQYWMb77+msSP3MgWQRLt +2EJ9S1PzilqjA8U7fGpBSBxFBw6aRQ9esOZJxMhC2eQa1GHzKHpQsGGtC63weK+M +XQWeJBWIiseUS6POCA7ogXGl2hC/cltycWl7PmVM/suZw9KFM9yqNvF9F6XE9SMy +9bYj19UAy8wPB6TkiiIcFTuUsFFDX5ODw+Km2i6KapfelDFKvoV8w+7QdBbJ07vI +nyz0RPMzcPYE92TTJCC0VUubztpVHnwClBtTrGOY8bVeRnOjATX87pbTTrw4aocL +3vFUSL3GQzI2OYR29VkE6QSdQPoSVYdZzBpPKd5CggvflfThZXevtqyuqAZaMZ1I +e2hKgFFE+F54t2w+kHP2hAsMuAQYHCsN7fz1RyjhO0VIzv0FhugiHo/55eztIPdT +bZRG +=N23Z +-----END PGP PUBLIC KEY BLOCK----- + +pub 9987B20C8F6A3064 +uid mkruskal + +sub 80CFA7C482552DC3 +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQGNBGJGMxoBDADF9xkWwxwN72wRh0al9ARzTTIHpcVBIjDij1Xr768zMMRdKOsQ +aEHRTBKArAfGl6Xt6CfYnu3wMgEDUfh50s9NPOKvhpKtqdIlUxZLEJ807ebW3MD+ +BnwoRUe0OsTItUQA+vLH8K2Uywd9f3OV9KQnqItUFMptaFhUC144hZhj3c0xhITS +k45zucoXLKO9yqA+tlqav7taAJMrWbhRcRWXizK1wOZLyhu8NdIMUSL4Ei0blR90 +uA9i62XlOhpyvfpaC7oRh+jXHOCFK9sXe2vnvnTtJ1yqdXH4EOCYLjoheQN1R0u4 +6f6XoAy9c3tOSOZM9vwE56iOZJwv0bca6ZENnhHnYwWhbQwrY0JMIon0sUpx9RB2 +w4E7AeU8/maQG9hdB7s7vrAJFarlFQvc7kJ5FMTKFmWPalUTcT6yXntIQ3+xiH9l +Oq0jGlAmQWYUvzHJ0SFjz1xJGBDM3GH9KfHbeoS3Xz5Emmw8YwEDUe9gt9po8bmw +8qnA85uMZY2puh0AEQEAAbQebWtydXNrYWwgPG1rcnVza2FsQGdvb2dsZS5jb20+ +uQGNBGJGMxoBDAC1ypgR4chf/OzOM3IoPIs42hmmEjJ59iValutsAWDCAlURaIhY +ajUO7R/k/qDenb1AP3BImtnanPxNTBQiHCkLEDnRx5M/MReLnbfOepaVeY7B0G5X +peMPsGLRkQuD5Cu6Zl9IOUAZvt9To7f1OjWYOqDdIjWPJsGTo46U9h918gjvbP7W +yYRpSKQ6ld4ludfCqQBoHyNAGAaKRyIAJWu4/yMxHAQ6nUlwyPWFM4yOxs1hjHqz +c1jw48m+D1GpZ9YALVXp+wQERKVhWfDchTmwwnPD3j2HrRu2oUWOCDoYOMP1eTpE +lCMhm2L1dBWwg4CzBDa1QdiPsqaNf/mHpT7GZm0VFhKQ9cwCOPurfW3f4uPtWFyb +gVkaJ1jQDDBkBAs/q2JHatwS0nYTXFeqYAz2dPXl7JbB85WH9VW5T8MNo6VsFDKr +CVO4pjEKPhTJYZVWqBLAHIXNiloqRbD3VFfTTx5P3iP2yP6bdWp7lDxVPeVHCO75 +MFpDPRXpn+QqAmMAEQEAAYkBvAQYAQoAJhYhBBhzZqP/5r+PlLkTapmHsgyPajBk +BQJiRjMaAhsMBQkDwmcAAAoJEJmHsgyPajBkW9AL/j9CucsaDsKdb8wjEfmJSjQk +XEriC7PDd/80aIzM1y6BTggiwCkyL8mDrL3DGoae2jcDfQ2JUM0keG05mH4PSk2U +B75/adKukDnNk3fhUeEDaQ2tUWhD3uljvjqvrI2YzwMuWFvvpaOkTxnQbfLQDXR5 +iNloZJ4zY5/XFS7v0rnYPdRUljwRWAsRmCLJAzIPWRJvFr7rFW/cORtATlyf5EkG +fCX+ZpgG3zPkS1sCmONjxR1/hiBa+sYfMJRQY+AvA0hyCz+fC6S68TvToM1LzSb0 +EqsoM2n30am2UhVjLhFhp9Xj2zhng67MddOSBvb6FrObk8lDIvO+TSKAuZ50HzB3 +EWrOthmYo9Z7lqLhPl+CA4HNVcqvw3RfoSvEvfzrnnsmGUsXY2IKQfqjg2XZ7P8Y +bq6FPZJMgigvJOCtTFvzxw/QUkgP/XZE0KtHq5kCdkdkbLNA37l57/+6EGJjmh5e +1oqRDHgAffhmvyMjyB4YL48bYbjwFEar/jLCQJj/Dg== +=pXEQ +-----END PGP PUBLIC KEY BLOCK----- + +pub 9A259C7EE636C5ED +uid Liam Miller-Cushon + +sub D66472CF54179CC4 +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBFKD+PgBEAC8IkWujQlmU0/7+QPZFsc/z/rXgg7BQyo330QK4HeMzeCK6WHa +SWzVDM9h6nFDs6Xln6YexbZUjLsxS/a/Ox2i26Qg8B+NghgiratbdJsByRrU/3la +0d8eYXrKO8BU024o+go+LzJEBqOb3+bn23dwF96dyCUfnhabYz+ZbPd3VmZV5D3G +fv0vBMnQnJkToOW6fVEoqjzCpEQmSFCWe6Cryj0veci2JmFIiiLA45hwuMg3hj92 +Czd+mdxcURtwm4XFfUoO32a5nAhNfrzKfz2eoV4my79MC8JA8OwQau5aksVu0Ohs +3z5IsdXi2hUqPF3s+j6BQFwSPmLo3r5XwZWTx9RAM7D6cOHWr2jW61o32t6ABSiI +cfhECTb0arEvjGtr56kD2JhgTA5GTIBGPwbdNBHMKZc4VmIFITnUlJ7MLoRv/gP6 +XyCerPB4Cm6kOTcNZnm33yUMNB6GfR1/l/+3hCFP+0z4/WJ0aK10d3/9opikkmep +gmNtedS6ScgOnU3pj9UF8jEMleK47nD2njc7FhGKdB5+I59L1ri0tSUdMhpuBAEd +u497Ei/Q1rt+vkNwA8uMQgXOGka7NLpgPcNw6sDCq1fecCEpt/HgmGrHdK6pY8KE +3I1xEGP6GG5DcBs57cbZv1Jdjf3A8fIozX7Ntn+7nBCHUVEWCzaASlQYrQARAQAB +tCZMaWFtIE1pbGxlci1DdXNob24gPGN1c2hvbkBnb29nbGUuY29tPrkCDQRSg/j4 +ARAAvGahpasWj2fmPUDbK6KbW32fP2C//tPahJIumyf2z59cMADqX0Oey0h68q1R +WV56jDv/qEk2+szUb8uAuVRvC76HOyahkqP33OZ33mcBUtb+fI+HfugH1jz5oNH+ +JrdyQEqB6iVcLEUxELGbLmspD7pQPQ1LAef8DEF5SS1P2HsHJpA4oEB8NW4RtykT +kxZ5xadW1sBENAt802gfZiXKwrMClJ2rgyFhnkdK9wCxpZT8L86+EXMMEy1B82kH +nkcyS9/aEaVPoqv91luBzemrfAUNox4mrekInbVjkDSkE7648m7Ol4JEbJGZ4qJm +xok2w4LE6df+AUTA2/tJ0Rods90CI+GT1YNHdiEn/NjNADHWacz11+icN6PwO07+ +KSWuYB8zlEw04ZDhYkEToFT+uZ7z7fCTwSL8C+Xmhua8w15uIlqumnDJ0RBs+40H +QtO1L1cUQG1WuJghxiSjbJEQ21nRmQ0+HJWBaDEGzLqdgjDJDmyWnDk8YmeMcu70 +FmdqGzZG9+0TayCqghcQnLkJf/QIZZGwBRa6HRKk4zRzhR9Lqtf9Abh914lvV4od +wGdHy9cKu6q5dg1wSGDAG8wAaEL4hmKEV7wKUkn7qMxZ1fQf8vIciQ0ESJ8x7JV1 +v5ZHawVogWA2/a8SilwsxNVmGB4XMNARvHY909Syd3ODSnMAEQEAAYkCJQQYAQIA +DwIbDAUCUoP7TAUJCWYDywAKCRCaJZx+5jbF7U1LEACf9a593cm67Q2krjQN/e24 +UARbJXzeODWLGkYfb7FS6eBRarTBihBfDcWy7U1/QlHYIduyKepcnG9hoeVMu9E8 +iBLLNhPIHy6Apm53s0J3wFBY142+3fjLXdV6xP2o93CX7aBIfBbzWVNhHwhxlg+3 +OI/OhCOpWfaiKFM3UjsQxulX/agSSGxxn+j6H7ww/DV+0hs7jaDWgVKjCjp5k9Ti +5OMeBJVNsLTVjcdXNMwyMLaNjm31Qc2KqHL//Rt31XroWLJvWtXjh5AP1M12z/bc +xPnfbHp1GsCwg7qWG/enKGvnNzV0cgnYyPOlbZQsg2UM/p3ecZg9PA2fg9zDJAJ3 +YvS7Zo02k4w3E2H4qYqMRpi51UO7l8axyxbBXyrI6yh+/7NzsJsifh8hpw5AA2KE +TQQ55+tFfR2cPeaOin7euSvUKJR6vm4A5UD3viSeomQcOwLmV/rHDMjlx4g70XyN +XbfaziRkdPhuhkNIEHncnCXf2OADtiz6haO/6qJiBxv3jejQC/v5wWEAYNh8q9Em +3LFss7kn7OHIcmd+c0GfasPOaEzecGIr7Knbh8XxR46vu30tYbgs6mV9+zhBmK4N +gcC8x/VO+s0EYihYZJpaYjFmx+nAMfXHQytkZnGj4Kw3cJJ8pBH4WAxu9ZpiC0SN +cFYKw6eZhSnlf3dtLjLzKg== +=hIWn +-----END PGP PUBLIC KEY BLOCK----- + +pub 9A2C7A98E457C53D +uid Spring Buildmaster + +sub 92AECA6AC21DB816 +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQENBFjN6bABCADHL68BhnXVXyJhOA9kO9cBwJXKmav2RftpcpXfaeHJTy+CMQa4 +rFxokx5W7E1IPlLg0qJfKSMeWhimVLOsLhY1MZV8Mb4fkK+SlDz/ah+5ej6dzOs3 +kMSzmn3nBbeacv5szjB8dzF0ZGPPgciGp28KYrjfPbxrZvnX0PgL6C5RqNkI3cTh +oUZgYqXGUe/uj5gUiLr+eZvh5lajPqe2YF9fmxfRXklmX47TMYidFkcQKGwxIM47 +7AKa5mKCp9MPKmxA2TG5F74sOwtSe7PYfzraVgaK0GGDJhm0Xr537EdtJfOpDRJF +GizM3hYSgOp3Yo1wjPrkFA82EfB4hCNZK6ipABEBAAG0NFNwcmluZyBCdWlsZG1h +c3RlciA8YnVpbGRtYXN0ZXJAc3ByaW5nZnJhbWV3b3JrLm9yZz65AQ0EWM3psAEI +AKi9vYsJkKjFWAswJAWCTTsYsfU6WPtJnErx1q5ZZa3uYXibODcs9sd8LhmJD2u8 +iAQLtWuDl/SC6nln1ikCRYy7v1JbENmJw8gWQqIBLjmma9v5GPUe/Dg1QSJqrem6 +VEjNtgszGJGr4+GDSCJN/AkNKlyMFgSdpRrMCBZkvpwnvSM2EFbhxonbtD/jvqSl +x68OY32/2cesXPvS/Nj8RqQfj0RxcOK5AHGKFQGoMgK2NGXfAxdOhPOA3I2NwfQL +nCNbAVbPOauNcV9tg9vbRg0l75CAbW0tmM1i/8Geh248QAlQL5NtApB3az11wbCE +MAoFRh8maFLFtTJYTnKgW1MAEQEAAYkBHwQYAQIACQUCWM3psAIbDAAKCRCaLHqY +5FfFPapEB/0RqqVPeoL01BivlBtcO6JGzfse9c2JNJyMeKCrxgA79GjVdda4u7e2 +IIlSqgUBebS4fW+kHZn5jcwQwInbpMjQQCQAFpAiOdrA1pV6baj6s8wedPvj+v7j +fMXa7udRvpZ6GQo3YzVsf8n9a8Zb9bX/YwUPfhY4eW/tRu02Qj1us4JVClxwJkqS +EOGjj2mGKfILAT7NzdxHRfDd27JEZ5CL/YGbhj6HeSgtmM5YpoLwlZu0ywyFwON7 +Nf8pkuNl55/cAkDrcZwPxiHlii+mt/oPBqYSoDWsH3J9iNV6IU7lPPwRZekWMybY +uuUS60cr6DwXd1f1xbULR2+AL3uiePHO +=2CAN +-----END PGP PUBLIC KEY BLOCK----- + +pub 9DAADC1C9FCC82D0 +uid Benedikt Ritter (CODE SIGNING KEY) + +sub 923C08F9417B222D +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBFKws7QBEADEy9+PqF0cjeS1yG4xMRBV+teFNsS+WZW1ATDBl5ETASqMZT7R +zFWjMWq8Kf3iTMfmPlKVCPIFH1FG+SgMvWpQEEcLCOmUkJR7UYtn2y3vaXXYqawz +sDozHQtDs8WvoegtrhjzB3BhmMY0BCgXcTR944OTmc2lqYmDNJC7Picge9ql5a79 +MMqOv8H9IS4jYKyZzUrVhVf+bRD8qBEi6Ne/5C2Vnz/4gVfTs2joH5FlyDmhwtgU +0m+/5x7CMIfBvB5+oAKgActuHAJZqZiNL+mFmN0m0UtnKkNMlFzrOR17EiT2kA4i +ZuFrqOkl+Iw0NwTFn4gzkv5XArxDrpK0lDTwXFpEs7jYN/1odHUm3PrHMT5TsfMf +dSC/Mq2fMTTMKALOne6fH6g1G4bkeeacBvdFbO3il+OXw5p+HDDZOe4ZwgibVgZP +SjQeeFVevTaOJSIDI1tKQ2O3Zgn4uA27V5BZXOK8pn0BSF4i9XNJvJMRo9+YEec6 +dhe6qlyoU/HX9V8M3s1A3f036YyTXwbl+bcf+eW7koA1I2mppTxOwLeviPsr3BIN +gJVFr4E30bnkcxJUnbQs7W7HTZ4wts1zE16Aot1B5XNe+VocwtBEQpWRSKvEkNMZ +p/1Dp3ceba9h1VJmWpmIYa342DUALUqb8gtWTyP8uZWyAynnHq0/W1py1QARAQAB +tDdCZW5lZGlrdCBSaXR0ZXIgKENPREUgU0lHTklORyBLRVkpIDxicml0dGVyQGFw +YWNoZS5vcmc+uQINBFKws7QBEACfb82u9+A4kyyzAvGZJPvwTZI+yQ6tHKFHAXr/ +GcMP9J9E/ZRzIQa7Sx/MNlTxHRe9fnSrKclZPw/HTvgrUAH9NchW56eXa8ypsHI2 +sHI3CM6M2KV0HWHG++1hHP+cYmqI4KZ1x2MdCgC+b0S9F25lGfArd0PhkeojWf26 +rPP4upDceJLXM7mhi6umZbGYnBYg/VKhmCuy0bPz20bYuc6HTi8rov428geyHhBG +TfsHjd5m5qGsQl+U7TBFyHdqJDsY1DyaZ1k5pj//A1xuxE2CSjEazJBCG3VxYLJx +bL6Tr4dWpPc0PSqn0MeYmF9RA/8vY+56edq9ohIsvXw5+BR5FSR6sXKL05EDem0T +WYgW7ATmn1/WSbsnVjWclrxcT2uJVdG7vIh7/qhkzVwhYIi1CyO8+2i/r/UMgqB3 +UBMUrGAE/K1j0S19rMISkwPnEprpcSjiVVEa6ubX3gxSFfbIaLPbIBE6nv/DLA0x +gMljUvESg90vv3tmuApERPmOsU7k28juu5ggWPT5G8M39Rsyms36ZZvN8dpjGcNS +uMJxU2KrnFVRsokJ36drb73cWv51bc6ir3VnUTr1fWeYODjRqxpRw1K1tfaZoGyB +RmxyAVjYSEZh+uenFly42CHEndiJRy7b9NYxp8rjwSi541R1mNcpKyMRrXjWDk2/ +AitcBQARAQABiQIfBBgBCgAJBQJSsLO0AhsMAAoJEJ2q3ByfzILQBrgP/ifLPf48 +7prZqHBk/b/lwCWEwROPPM4xGAfu/X6apsIU6h37VQ/2+V0ZIX5XoleDEQEW6Zmh +cbke1OiIb838cTQ1a6j+ONGKR6N04+2+mmdX4+dK6iKt0vkmfCygxMdY5MQExtG6 +jtSb2pt9pTTD2V7fQs+G7wH2jdRbZd0tTg0OWyEkzIBx6rlK4phfwsXcdn+7RvIZ +jiEBOcj39uifM3hAqa0lALlA4CZ77Pn2od8Z03WDHFQCH1FxqoRUHDpEKPsf0EFB +yQ/YFskdF336B43t0WjMJfOYdj7HVokkvmulSAXTXZEx5LyqCQ1HPhc57FCwgbQp +5/u7JYI3RQdKpAIO0YxD/Pk1ulJz6Xgg7gYdaNUODrSNCq2KNtEP3mgj74no4tN8 +pOecZfIgR0ACfEI4/m59WprhopTEk4X43x+swbaRgcpXXxVv+UvSTBa6eVMSHSm8 +7UgRH02ULPjyFbNI3I+a9jM7IANxavGzhHT9XWwPNqGeSV0uTFWbcadw/pDr8t8M +CztAx1txkePcVzRcV2BB+XG0lcGW4e6SV6d9jSoSn2HkL32xPOIxxwFPgYEjmT06 +XNO7ZiaxI16pTXZk6+QmjKpUb2jNf39gCop3uD4vpDkXAORGahhBdXxaHNM/Ds+0 +zW9k+nXG/umtuGWBaZVODvhr9hDoUpp2+qte +=sNEF +-----END PGP PUBLIC KEY BLOCK----- + +pub 9EB80E92EB2135B1 +uid Slawomir Jaranowski + +sub E3F6790A5A167F5A +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBGHDIagBEADpzdCwVjVlHuo8qpu9HtmqNpEW4TB7y6+NX7Q39mj8w+iVskE1 +sL0+BOCdP6ZMiQziWbOQ2FxCd3mD0ixZ7v1i7+0jowySPacJbVNaPPECP38gDte4 +RQwUTTCHgW8ADhYJBxSkA6RX0c5sZvi0fxgunZARs0pE68V4kUnAKiLvHerI3BBE +kL1Pq6+CvT8K8/kU7kSk4SlgU9C09S3/CiHfb9k0ekYMJggvJV5MjqrYyLd0boBQ +GWo8hWM4Reg/ye3+6301FDkmtza9bLwVW+euhPgzKYNoWMzOBj2pqjfWk0jF0TRR +4iOW9aATlIZ2z3/NH3SuufW0HylmMEIbtxZ4bA0wverDje32YGYebEb73xui66Cf +Ezj/mZPhyRDA3tV+LulyEy3CgMmDhpTSoN2eRTeXe3rq39fgoVFBE6lzJkQeNlbw +lrFhdYEQhSddMReRlRHFeQYpbMWiS3lW2e0Zp7zjGKLqs5/0BcX+xuwBq2WaVKyx +fqVNuO0xP8+J210B9I97Mv6CnJHg2US0q9cFOPyMIIaOtQAuzMLvmG6c1UlBaQm4 +N1PvV1ycKUpBFJv/qmNvhznjJHH5M+Yjm7Zp29g40XD1m9e4RdFq+3/4btJ6eyRn +9eBRPp5xYNqjt4AApHUmSnWquihKXXw3sT7zsv5H8ZA1Ol4N1pFc51IM/wARAQAB +tCxTbGF3b21pciBKYXJhbm93c2tpIDxzLmphcmFub3dza2lAZ21haWwuY29tPrkC +DQRhwyGoARAA0A9BRIeDnOZAxMwVnNqlSAWDhSQPvDs6Yv0XX7MJWa69IP55KtC1 +crcgtJr4QHhk8CfefAkFA2CvkIFajn+xNbPSfFArzZrtacI0e9+A7IVgZpkL9pcc +zlX8twIsZbUhUqzKFZD1Qaf3hzC9186JWtH74+lPU8nDt7LcdOe/Pc8S7sp6c1Bx +9m1dz4fNAMX7SzheMgZ+exNsegR8TebIt0nw4bRqTI/LmBHq2fh3tASXcE4peZrd +JY4h6ERUHFslwNG5wdQVk/3yvvjmypkjgJtWy4CLC+OdzINgO9p1qmGyjmaa9g9O +VeCQtxyW09tyqB9ZjWqtwjwcgAy/InJkhTAdXBjy0MzP6vBIjNBc2bdGabp0Qx81 +9mXt4nEnbAbUfZo4VB1AFsTDrQ5NG4fGfzXciqIKcyfAh/iuxhPUxMLRbIlG8vyF +vGTBewwshe89Ul7sZyLN9RtjON1iVvHyKPZRr7TP+lK3OPVxe/WAG4VEfhWvlX8c +TvST/nInflK/awmBpU9/u2ugTxX4tNSIlpmbE9ZI5G+YzOLbubY+3AdktBn18qGX +vvenYLw2vImOf9asTWnNrD9L1opfsRdQin/qCch2LysI4Imp1ka8ymXjeFQ7a0uF +oP5S4FQ7PtJaqaw+cFEC3z4Q0FDrmau3yxUqnX3oeNGjLCdWkAofrWcAEQEAAYkC +NgQYAQgAIBYhBIR4nSTfd6MkM84fB564DpLrITWxBQJhwyGoAhsMAAoJEJ64DpLr +ITWxJK4P/0Rser6zAjS06ysPkTuREkwKfN7H0ySclUcfiFuyjtqWp2vQKqibYRrg +otUpv7ZOaTJzm+CrPDt5zZSn2TDudao3cA1OE/ZE8rYGoY2Bipi2KWQCwOMNQwBm +4gR0KrlM+AOpJVNOnQRg4OoJ7Mc8t3pCNErUJtw2hfrVqFTK7vwjY5w09AS+veuf +32xZ5NQOhQQhRQlhKrI05v/A2Ly/ajoIaxb+X76G4+E7aBIX9CBRA9zc68gODUQy +J0jazqJJFFdQ98l90vas/koJusnENV4jqogrcy1pyEFoMtlptwGwCuzE0qnHzyjr +Ia7MzoDhuRx2denEcTezsOQCToQDTnNpOgH/cqgWdTQW5hGSXQwEpZwZP+nfuK74 +uIkWzX3Sd6CyctUCVvCFPvxSZ3xZZ3ksBn3UMA7F5QYf3ZPTHPVGG67rovfZxj+C +H91ki0vXvECmYrlD43UTQHzgMs4nc2O4E6f1/ihrM8yKD7var2KQtoRsguHTd3EX +lv2NwnAT0AqumE37wv84xodoDbvRlBmBR92WycDJ0bPuzK34nTshxaITpyJm/zHU +H4+0Za2RKRMWJjQAIq7Q6JeBqNDvmDYtUja5eR7N3xzLMPz1r9zlCG8tXd9vCH+G +mMc1ojZ9QHu9WXM+cEND6KY3m407KYw2ItiMcY3Y5fNTRdEMvu7S +=hVLP +-----END PGP PUBLIC KEY BLOCK----- + +pub A1AE06236CA2BA62 +uid DiffPlug LLC + +sub 030DD9087C31C9AF +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQGNBGPAYVUBDADCs9PkY8zzhzE38bRZX+vTrr3LdChGNBmObV858NGRrXeZtyLu +U7YwYVF7w2vHUI/JQWrlPZc5tBFicefucfUtKt790WzAk3NBjGtX4IWpG57C1Z5t +QRI23HqWr1If0UanH2vUjy4fUgNZdYlH2KzookoU0950dIcqwA/HwiosO5RmQ9iY +HztkwwvFW9QxiJgL+lR84EcaIVN1ukr0ZKrG1a6wOJ6HLf9S2F3DMe7fQ+O+TpT/ +A11RewOZHwE9spH8cEsNYgutBouw/MttuYHjZKD7O4hN12MmzecWeMAPyrvYgTJp +PHcjQaVeD27OGLRpy5n5LonvkzJbhTzM+Ps1qEj/4of3EFVhxNjR0gdrkX+0Ub1A +XXiw3gjqAQuLQVKIbwvCbfj2go+YHrfcXN6kpKkYZU8ERPxI/VBTw230PPdXXwXP +Ux/JRQIEXOuMIuELm/91H8TXKutw6NdNRu5q+LPcUkU7W6jsv28dmQHdC+ebVHlA +vNcBOWVSY5e8IasAEQEAAbQjRGlmZlBsdWcgTExDIDxzc2xjZXJ0QGRpZmZwbHVn +LmNvbT65AY0EY8BhVQEMAL4ZVuEVH9zbhY6AewA4T3u2XZ7k1KGOxoK74eygzYEp +fKMplWQtCxcxBXe2tboT7I8U3MrV6m7KDwcxLNVZM638fvfU3Px0yGs0jBzyjOcb +Vk6n18xX9UoNyoEqpxHhyPbTBr+U9OINcneXZ/iG9FfLURZjDxhNcQcnrnmvbUB6 +M+teZ6Gpb1Ye8ghVCJJNjRRQhFxXE7XnmX3C1pZoSoGcBx5zVspSuHjq7nTTw/rd +7OpC6sBK0ULk8GPAd2vJUfOtZcsLvOs2++bHxNULTXraTy/fYvXsTSe+PmbJo1Fd +5o3imI0eUy853UJmF/HbuWspFe8yONHjo0+uZITsAMq0jbzG8MTKMmgsXS/i/vaW +8BVUmLfhB7E+bUXJLJuQAan397NbYZqPF5agLZ1wHSki3iuYEttdMsy5PYCLeCqh +8Tv6VBNkEToKDAvNbaad4ZgBdwbBQaAIrWekWpiXSXizyGr/VTFE2hT5NC0d1BXy +sc9P2UCvHit6A1bCl7MSywARAQABiQG8BBgBCAAmFiEER5e09dzEbOphBZBxoa4G +I2yiumIFAmPAYVUCGwwFCQPCZwAACgkQoa4GI2yiumIHXwwAh4/tSXSQ9Btws4ZP +eLfihAb4ogHOsrJ8ZO+lZMyQOrEyzDK/y/1LpFVlHYEP51XS5h4u4XVivXGzsZ+r +tQoXaCS6n19dyyNeusehZx/BxxQrdV9OYEkgb3BC+05AWogdHXTP4prGdMtpSttd +gcxTuHwx9RUv/d6CsQ8DyKyjTv82hd3yuXQVl1829NwDbM7HJ8eq0uZPmez2ewbx +Ze9CxjKoOLfYSQ4k0DfcIFqz8CSqTVIz5aNLLXiY6NXPhS9B9/bXkRNAXzUgMrG4 +GmmP8XLYjBn9g8V+fAad67N0dUWDeAPzz3OXjp6bxyScgjT6OMlp55xXaE5HWW4a +aE9epjKjLuOD7LYdmv0GI1HhSrOnlqznB3TCwJgKMw6/37uGZnpsX0JoMs947ZIm +pcN1kNNR3e4aAFcpBwj2OSjds+G/DI3/WOXJj3aaRI4nBRr2/IB3TVhzLOizLTNQ +Q/IKL5Iy5doINK/iyjb/G/JLH1/TkhW9zEheiKUY6TiXeR3p +=v9Tm +-----END PGP PUBLIC KEY BLOCK----- + +pub A41F13C999945293 +sub 8183E80D264EE073 +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: BCPG v1.68 + +mQINBE8YNGIBEADEgcfvs8TL3X2Ql62HJ6SrXWAOoHw5CquJxUQkvBGesIT1Hk24 +exiPwrlNE1qUjbVlef1Cwk9ZfwMOpJdfP2MQQbx0nxxqv+JtsoeXUy9bTSvZYBUL +9yCmLEVzzSt4VCStMdPmXQGLvn0JV0e6LmDFv5+UfOR+qxjyNXfeF93W7ndVFA/o +YoYgMJN26Xneb+r9bx3rJcT1zbHYpqUqkswiQ9cZSApe5GHkDqOvu/lJnlFYfFiC ++f0UiR2tEQtdIYy1Owkovcy81gMEKw5Mr49d6lrkQm+oES4ZHcCecZ3Y+z8V5Rqt +qqlrV1IR960VxwhmUm1+VkxGeGClxCFF6Xo00wCWlcJ/BCAea7FXXr4QrF5a1oQb +BDfoVDlXt2cl/0Qfo9gCivBbyZ2df883MmeG/Vc3IovAP7Snl0fkX4KgdrfWuISa +nbARk5xsIxlfC0CsnFNU9CuNh+lg4gNV3E1BiCVEa+boy3XqvcfJIq4/ZiTUXyjq +chI7QFHmBS+uhHGnTtqEAYzl8KgRQdHijgo2cUVw+it765tM17Ekk+NJV5oQ8C8u +nlVS6YiWDiuaTfxZZicI3bOBq6kjTr/TZsv0ohhtbUh5JdSRKSxpK8vkWRnNP45W +m9oFvUmI4X209lzFvu1t4/t33Xl0kzp+8q9Qs6tgnqCpSnxSbJY3MZb/QwARAQAB +uQINBE8YNGIBEAC4ZnRG2rSszbho94Y9Qysjcb0pX2EsqqIR06uzgxClcvPAToCl +9w2/d4OjRlf5T+225UUbqObsWpuBQ/Byc3HFFdLlHxBAoMZstv1LDA09/ZzrfOnd +jMDRe3/etJn5KWALjAL4nqmihOxuLz7Dj8dUtU2gpis7tumPQg4OgOmysWD/YuAX +U+uTq1EoA9nMnN7PbfcFWbM5rmATLeGMH70RJu4FMlN0/Q1TDeIhurGSpLwI1uG6 +5YNicKyv7h5JoBnCVVoK3k8YVLY89TzmTUW37qfYwBUMb6DnHp2gIB6uxduXj7Wc +uCZBrqb35E/s4mGy2vuJ9iQtg6Wa4Qpmkoj6FEBLipAPD7W+Gju5PRm67/VvZE3O +rvwZ5ia0RWzTp2I7IFFxTfkdgdQXLp4eaWg+T3dLUH8J93k+axmT69lOnkrLhsFu +dYgtl+/2zXyalMPdKi+eSVTaRvFI0/opOTJbePAPM/kkANzaJEkVYfsZsi235Epa +IC672Fn+tKor7RTG5AVZDm7yWcVVR8CpssyQWsIktDLXNaHTtYRS5p/a9De8hY8/ +ZtvtMtuzFV9TU4fptofFKl+RbaqbXSqkAvQT+jLRsmpzFJDEvM8z1dRyHTKVZdEj +ofScPx9GufaICnm0Fhhib91lfvVvPXC2FQYt4MO9ainvstnp5CJ99bRBxwARAQAB +iQI2BBgBAgAJBQJPGDRiAhsMACEJEKQfE8mZlFKTFiEEDMZBw6YkU6s5AGbEpB8T +yZmUUpO/4g/7BH4Oorbk0FLr1NjcUUWqkJYnqHBB22EYp2Pdt7f/7CuPYB7uLVAN +y7uD7AfsmSLcZFd8RRwFF2LmhDxtCU6kgDsnRr+44/XATnDfGAMyOPey8wDmZxSR +yA0iHJ7ZY8ExNNeL9YdE5osv5/dQ0KAnrvQyjySmMUZrKEhJw58QJYFKJvPaO5Lu +Qh3BB30wxJZiWW0Zlc/wjzT7Y6O8Pv/zYCGulJZuC2spdasCSGhz06d1ZM/RbUXL +Ngosf+5ll22ZoIKpsvIMidC335IzQpOPuOePthrJUHf+EGpJDf56xoT12l5QwQSQ +CkhBYEWQX6gsNuZAHbuYOwMgwnpNxFBSpE/JYrcMHJ1Ab5FXPS4ClVr9PzU15m2Z +Hr3i6SIWLmPQzjEokYmSAj1zoFZrvMEW4UNWzB6DVX7G+VGgWIRB/LgDKsDs48z/ +kHwwvV/ciaGxUP62wwUbJWibDDskpeKvX55xbUW8BcTNbVHHk75fmzKRmKTugbMn +dok13bOAkOh9gxBHawKG/qj0GY9yxXPY671NNvQei+reoOcEm7pv5Tnvg+HP9IcL +e50Zp0X9xwPQ6ux3VnXoa4s1PqTGhb7++w+QF2JahE68a/9oR97XTe+8e1 \ No newline at end of file diff --git a/gradle/verification-metadata.xml b/gradle/verification-metadata.xml new file mode 100644 index 0000000..e8097a9 --- /dev/null +++ b/gradle/verification-metadata.xml @@ -0,0 +1,564 @@ + + + + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..249e5832f090a2944b7473328c07c9755baa3196 GIT binary patch literal 60756 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 '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit + +APP_NAME="Gradle" +APP_BASE_NAME=${0##*/} + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + +# Collect all arguments for the java command; +# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of +# shell script including quotes and variable substitutions, so put them in +# double quotes to make sure that they get re-expanded; and +# * put everything else in single quotes, so that it's not re-expanded. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + org.gradle.wrapper.GradleWrapperMain \ + "$@" + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..ac1b06f --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/settings-gradle.lockfile b/settings-gradle.lockfile new file mode 100644 index 0000000..25f034e --- /dev/null +++ b/settings-gradle.lockfile @@ -0,0 +1,5 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +io.micronaut.platform:micronaut-platform:4.1.6=incomingCatalogForMn0 +empty=incomingCatalogForLibs0 diff --git a/settings.gradle.kts b/settings.gradle.kts new file mode 100644 index 0000000..3f809a8 --- /dev/null +++ b/settings.gradle.kts @@ -0,0 +1,75 @@ +@file:Suppress( + "UnstableApiUsage", + "DSL_SCOPE_VIOLATION", +) + +import build.less.plugin.settings.buildless + +pluginManagement { + repositories { + maven("https://gradle.pkg.st/") + maven("https://maven.pkg.st/") + mavenCentral() + gradlePluginPortal() + } +} + +plugins { + id("build.less") version "1.0.0-beta1" + id("org.gradle.toolchains.foojay-resolver-convention") version "0.7.0" +} + +val micronautVersion: String? by settings +val implementations = listOf( + "mysqlj", + "h2", // for testing +) + +val integrations = listOf( + "graalvm", + "kotlin", + "micronaut", +) + +buildless { + // nothing at this time +} + +dependencyResolutionManagement { + repositoriesMode.set( + RepositoriesMode.FAIL_ON_PROJECT_REPOS + ) + repositories { + maven("https://gradle.pkg.st/") + maven("https://maven.pkg.st/") + mavenCentral() + gradlePluginPortal() + } + versionCatalogs { + create("mn") { + from("io.micronaut.platform:micronaut-platform:$micronautVersion") + } + } +} + +rootProject.name = "planetscale-connector-j" + +fun subproject(name: String) { + include(":subprojects:$name") +} + +listOf( + "catalog", + "core-api", + "driver", +).plus(implementations.map { + "impl-$it" +}).plus(integrations.map { + "integration-$it" +}).forEach( + ::subproject +) + +enableFeaturePreview("STABLE_CONFIGURATION_CACHE") +enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS") +enableFeaturePreview("GROOVY_COMPILATION_AVOIDANCE") diff --git a/subprojects/catalog/build.gradle.kts b/subprojects/catalog/build.gradle.kts new file mode 100644 index 0000000..67b7ac7 --- /dev/null +++ b/subprojects/catalog/build.gradle.kts @@ -0,0 +1,37 @@ +import PlanetscaleBuild.publishable + +plugins { + id("common-conventions.kotlin") + id("planetscale-publishable.klib") + `version-catalog` +} + +publishable( + name = PlanetscaleBuild.Library.CATALOG, + description = "Gradle Version Catalog for Planetscale libraries", +) + +catalog { + versionCatalog { + version("planetscale", version as String) + version("mysql", libs.versions.mysql.get()) + + library("driver", "com.planetscale", PlanetscaleBuild.Library.DRIVER) + .versionRef("planetscale") + library("core-api", "com.planetscale", PlanetscaleBuild.Library.CORE_API) + .versionRef("planetscale") + library("integration-kotlin", "com.planetscale", PlanetscaleBuild.Library.Integrations.KOTLIN) + .versionRef("planetscale") + library("integration-graalvm", "com.planetscale", PlanetscaleBuild.Library.Integrations.GRAALVM) + .versionRef("planetscale") + library("integration-micronaut", "com.planetscale", PlanetscaleBuild.Library.Integrations.MICRONAUT) + .versionRef("planetscale") + + library("mysql", libs.mysql.get().group, libs.mysql.get().name) + .versionRef("mysql") + + bundle("planetscale", listOf( + "driver", + )) + } +} diff --git a/subprojects/catalog/gradle.lockfile b/subprojects/catalog/gradle.lockfile new file mode 100644 index 0000000..04b678d --- /dev/null +++ b/subprojects/catalog/gradle.lockfile @@ -0,0 +1,4 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +empty=compileClasspath,runtimeClasspath diff --git a/subprojects/core-api/api/core-api.api b/subprojects/core-api/api/core-api.api new file mode 100644 index 0000000..bd9936b --- /dev/null +++ b/subprojects/core-api/api/core-api.api @@ -0,0 +1,357 @@ +public final class com/planetscale/Driver : com/planetscale/jvm/driver/PlanetscaleDriver { + public fun ()V +} + +public final class com/planetscale/jvm/DriverParameter : java/lang/Enum { + public static final field ENABLE_BOOST Lcom/planetscale/jvm/DriverParameter; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public final fun getParamName ()Ljava/lang/String; + public static fun valueOf (Ljava/lang/String;)Lcom/planetscale/jvm/DriverParameter; + public static fun values ()[Lcom/planetscale/jvm/DriverParameter; +} + +public abstract interface class com/planetscale/jvm/PlanetscaleAdapter : java/io/Closeable, java/lang/AutoCloseable { + public abstract fun configure (Lcom/planetscale/jvm/PlanetscaleConfig;)V + public abstract fun connect (Ljava/lang/String;Ljava/util/Properties;)Ljava/sql/Connection; + public abstract fun getMajorVersion ()I + public abstract fun getMinorVersion ()I + public abstract fun getParentLogger ()Ljava/util/logging/Logger; + public abstract fun getPropertyInfo (Ljava/lang/String;Ljava/util/Properties;)[Ljava/sql/DriverPropertyInfo; + public abstract fun validate ()V +} + +public final class com/planetscale/jvm/PlanetscaleAdapter$DefaultImpls { + public static synthetic fun connect$default (Lcom/planetscale/jvm/PlanetscaleAdapter;Ljava/lang/String;Ljava/util/Properties;ILjava/lang/Object;)Ljava/sql/Connection; +} + +public abstract interface class com/planetscale/jvm/PlanetscaleConfig { + public static final field Companion Lcom/planetscale/jvm/PlanetscaleConfig$Companion; + public static fun defaults (Ljava/net/URI;Lcom/planetscale/jvm/PlanetscaleCredential;)Lcom/planetscale/jvm/PlanetscaleConfig; + public abstract fun enableBoost ()Z + public abstract fun extraParams ()Ljava/util/SortedMap; + public abstract fun getCredential ()Lcom/planetscale/jvm/PlanetscaleCredential; + public abstract fun getState ()Lcom/planetscale/jvm/PlanetscaleConfig$Companion$PlanetscaleConfigState; + public abstract fun getUri ()Ljava/net/URI; + public abstract fun multiHost ()Z + public static fun of (Ljava/net/URI;Lcom/planetscale/jvm/PlanetscaleCredential;Lcom/planetscale/jvm/param/ParameterSource;ZLjava/util/SortedMap;)Lcom/planetscale/jvm/PlanetscaleConfig; + public static fun parseUri (Ljava/lang/String;)Ljava/net/URI; + public static fun resolve (Ljava/net/URI;Ljava/util/Properties;)Lcom/planetscale/jvm/PlanetscaleConfig; + public static fun resolve (Ljava/util/Map;Ljava/util/Properties;Ljava/net/URI;)Lcom/planetscale/jvm/PlanetscaleConfig; + public abstract fun targetHosts ()Ljava/util/List; +} + +public final class com/planetscale/jvm/PlanetscaleConfig$Companion { + public final fun defaults (Ljava/net/URI;Lcom/planetscale/jvm/PlanetscaleCredential;)Lcom/planetscale/jvm/PlanetscaleConfig; + public final fun of (Ljava/net/URI;Lcom/planetscale/jvm/PlanetscaleCredential;Lcom/planetscale/jvm/param/ParameterSource;ZLjava/util/SortedMap;)Lcom/planetscale/jvm/PlanetscaleConfig; + public static synthetic fun of$default (Lcom/planetscale/jvm/PlanetscaleConfig$Companion;Ljava/net/URI;Lcom/planetscale/jvm/PlanetscaleCredential;Lcom/planetscale/jvm/param/ParameterSource;ZLjava/util/SortedMap;ILjava/lang/Object;)Lcom/planetscale/jvm/PlanetscaleConfig; + public final fun parseUri (Ljava/lang/String;)Ljava/net/URI; + public final fun resolve (Ljava/net/URI;Ljava/util/Properties;)Lcom/planetscale/jvm/PlanetscaleConfig; + public final fun resolve (Ljava/util/Map;Ljava/util/Properties;Ljava/net/URI;)Lcom/planetscale/jvm/PlanetscaleConfig; + public static synthetic fun resolve$default (Lcom/planetscale/jvm/PlanetscaleConfig$Companion;Ljava/net/URI;Ljava/util/Properties;ILjava/lang/Object;)Lcom/planetscale/jvm/PlanetscaleConfig; +} + +public final class com/planetscale/jvm/PlanetscaleConfig$Companion$PlanetscaleConfigState : java/lang/Record, com/planetscale/jvm/PlanetscaleConfig { + public final fun component1 ()Ljava/net/URI; + public final fun component2 ()Lcom/planetscale/jvm/PlanetscaleCredential; + public final fun component3 ()Ljava/util/List; + public final fun component4-O-1Ai9o ()Lkotlin/Pair; + public final fun component5 ()Ljava/util/SortedMap; + public final fun copy-_5V2Imw (Ljava/net/URI;Lcom/planetscale/jvm/PlanetscaleCredential;Ljava/util/List;Lkotlin/Pair;Ljava/util/SortedMap;)Lcom/planetscale/jvm/PlanetscaleConfig$Companion$PlanetscaleConfigState; + public static synthetic fun copy-_5V2Imw$default (Lcom/planetscale/jvm/PlanetscaleConfig$Companion$PlanetscaleConfigState;Ljava/net/URI;Lcom/planetscale/jvm/PlanetscaleCredential;Ljava/util/List;Lkotlin/Pair;Ljava/util/SortedMap;ILjava/lang/Object;)Lcom/planetscale/jvm/PlanetscaleConfig$Companion$PlanetscaleConfigState; + public fun credential ()Lcom/planetscale/jvm/PlanetscaleCredential; + public final fun enableBoost ()Lkotlin/Pair; + public fun enableBoost ()Z + public fun equals (Ljava/lang/Object;)Z + public final fun extra ()Ljava/util/SortedMap; + public fun extraParams ()Ljava/util/SortedMap; + public synthetic fun getCredential ()Lcom/planetscale/jvm/PlanetscaleCredential; + public synthetic fun getState ()Lcom/planetscale/jvm/PlanetscaleConfig$Companion$PlanetscaleConfigState; + public synthetic fun getUri ()Ljava/net/URI; + public fun hashCode ()I + public final fun hosts ()Ljava/util/List; + public fun multiHost ()Z + public fun state ()Lcom/planetscale/jvm/PlanetscaleConfig$Companion$PlanetscaleConfigState; + public fun targetHosts ()Ljava/util/List; + public fun toString ()Ljava/lang/String; + public fun uri ()Ljava/net/URI; +} + +public final class com/planetscale/jvm/PlanetscaleConfig$DefaultImpls { + public static fun enableBoost (Lcom/planetscale/jvm/PlanetscaleConfig;)Z + public static fun extraParams (Lcom/planetscale/jvm/PlanetscaleConfig;)Ljava/util/SortedMap; + public static fun multiHost (Lcom/planetscale/jvm/PlanetscaleConfig;)Z + public static fun targetHosts (Lcom/planetscale/jvm/PlanetscaleConfig;)Ljava/util/List; +} + +public abstract interface class com/planetscale/jvm/PlanetscaleConnection : java/sql/Connection { + public abstract fun getAdapter ()Lcom/planetscale/jvm/PlanetscaleAdapter; +} + +public abstract interface class com/planetscale/jvm/PlanetscaleCredential { + public static final field Companion Lcom/planetscale/jvm/PlanetscaleCredential$Companion; + public abstract fun getDatabase ()Ljava/lang/String; + public abstract fun getPassword ()Ljava/lang/String; + public abstract fun getUsername ()Ljava/lang/String; + public static fun resolve (Ljava/net/URI;)Lcom/planetscale/jvm/PlanetscaleCredential; + public static fun user (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lcom/planetscale/jvm/PlanetscaleCredential; +} + +public final class com/planetscale/jvm/PlanetscaleCredential$Companion { + public final fun resolve (Ljava/net/URI;)Lcom/planetscale/jvm/PlanetscaleCredential; + public final fun user (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lcom/planetscale/jvm/PlanetscaleCredential; +} + +public abstract interface class com/planetscale/jvm/PlanetscaleParameter { + public static final field Companion Lcom/planetscale/jvm/PlanetscaleParameter$Companion; + public abstract fun getKey ()Lcom/planetscale/jvm/DriverParameter; + public abstract fun getParam ()Lcom/planetscale/jvm/param/Parameter; + public abstract fun getSource ()Lcom/planetscale/jvm/param/ParameterSource; + public abstract fun getValue ()Ljava/lang/Object; +} + +public final class com/planetscale/jvm/PlanetscaleParameter$Companion { +} + +public final class com/planetscale/jvm/PlanetscaleParameter$EnableBoost : com/planetscale/jvm/PlanetscaleParameter { + public static final field Companion Lcom/planetscale/jvm/PlanetscaleParameter$EnableBoost$Companion; + public static final synthetic fun box-impl (Lkotlin/Pair;)Lcom/planetscale/jvm/PlanetscaleParameter$EnableBoost; + public static fun constructor-impl (Lkotlin/Pair;)Lkotlin/Pair; + public static final fun disabled-RKw8F94 (Lcom/planetscale/jvm/param/ParameterSource;)Lkotlin/Pair; + public static final fun enabled-RKw8F94 (Lcom/planetscale/jvm/param/ParameterSource;)Lkotlin/Pair; + public fun equals (Ljava/lang/Object;)Z + public static fun equals-impl (Lkotlin/Pair;Ljava/lang/Object;)Z + public static final fun equals-impl0 (Lkotlin/Pair;Lkotlin/Pair;)Z + public fun getKey ()Lcom/planetscale/jvm/DriverParameter; + public static fun getKey-impl (Lkotlin/Pair;)Lcom/planetscale/jvm/DriverParameter; + public fun getParam ()Lcom/planetscale/jvm/param/Parameter; + public static fun getParam-impl (Lkotlin/Pair;)Lcom/planetscale/jvm/param/Parameter; + public fun getSource ()Lcom/planetscale/jvm/param/ParameterSource; + public static fun getSource-impl (Lkotlin/Pair;)Lcom/planetscale/jvm/param/ParameterSource; + public fun getValue ()Ljava/lang/Boolean; + public synthetic fun getValue ()Ljava/lang/Object; + public static fun getValue-impl (Lkotlin/Pair;)Ljava/lang/Boolean; + public fun hashCode ()I + public static fun hashCode-impl (Lkotlin/Pair;)I + public static final fun of-5Oy5_50 (ZLcom/planetscale/jvm/param/ParameterSource;)Lkotlin/Pair; + public fun toString ()Ljava/lang/String; + public static fun toString-impl (Lkotlin/Pair;)Ljava/lang/String; + public final synthetic fun unbox-impl ()Lkotlin/Pair; +} + +public final class com/planetscale/jvm/PlanetscaleParameter$EnableBoost$Companion : com/planetscale/jvm/param/Parameter$BooleanOptionFactory { + public final fun disabled-RKw8F94 (Lcom/planetscale/jvm/param/ParameterSource;)Lkotlin/Pair; + public static synthetic fun disabled-RKw8F94$default (Lcom/planetscale/jvm/PlanetscaleParameter$EnableBoost$Companion;Lcom/planetscale/jvm/param/ParameterSource;ILjava/lang/Object;)Lkotlin/Pair; + public final fun enabled-RKw8F94 (Lcom/planetscale/jvm/param/ParameterSource;)Lkotlin/Pair; + public static synthetic fun enabled-RKw8F94$default (Lcom/planetscale/jvm/PlanetscaleParameter$EnableBoost$Companion;Lcom/planetscale/jvm/param/ParameterSource;ILjava/lang/Object;)Lkotlin/Pair; + public final fun of-5Oy5_50 (ZLcom/planetscale/jvm/param/ParameterSource;)Lkotlin/Pair; + public static synthetic fun of-5Oy5_50$default (Lcom/planetscale/jvm/PlanetscaleParameter$EnableBoost$Companion;ZLcom/planetscale/jvm/param/ParameterSource;ILjava/lang/Object;)Lkotlin/Pair; +} + +public abstract class com/planetscale/jvm/driver/AbstractPlanetscaleAdapter : com/planetscale/jvm/PlanetscaleAdapter, java/io/Closeable, java/lang/AutoCloseable { + public fun ()V + public fun close ()V + public fun configure (Lcom/planetscale/jvm/PlanetscaleConfig;)V + public fun connect (Ljava/lang/String;Ljava/util/Properties;)Ljava/sql/Connection; + protected fun connectBacking (Lcom/planetscale/jvm/PlanetscaleConfig;Ljava/net/URI;Ljava/util/Properties;)Lcom/planetscale/jvm/PlanetscaleConnection; + protected abstract fun createDriver ()Ljava/sql/Driver; + public fun getMajorVersion ()I + public fun getMinorVersion ()I + public fun getParentLogger ()Ljava/util/logging/Logger; + public fun getPropertyInfo (Ljava/lang/String;Ljava/util/Properties;)[Ljava/sql/DriverPropertyInfo; + protected abstract fun toURI (Lcom/planetscale/jvm/PlanetscaleConfig;)Ljava/net/URI; + public fun validate ()V + protected fun withDriver (Lkotlin/jvm/functions/Function1;)Ljava/lang/Object; +} + +public final class com/planetscale/jvm/driver/CloudProvider : java/lang/Enum { + public static final field AWS Lcom/planetscale/jvm/driver/CloudProvider; + public static final field GCP Lcom/planetscale/jvm/driver/CloudProvider; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lcom/planetscale/jvm/driver/CloudProvider; + public static fun values ()[Lcom/planetscale/jvm/driver/CloudProvider; +} + +public final class com/planetscale/jvm/driver/Constants { + public static final field CONNECT_DOMAIN Ljava/lang/String; + public static final field INSTANCE Lcom/planetscale/jvm/driver/Constants; + public static final field MYSQL_DRIVER Ljava/lang/String; + public static final field MYSQL_PORT I + public static final field PASS_ENV_VAR Ljava/lang/String; + public static final field PASS_VM_PROPERTY Ljava/lang/String; + public static final field USER_ENV_VAR Ljava/lang/String; + public static final field USER_VM_PROPERTY Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class com/planetscale/jvm/driver/Constants$DriverParams { + public static final field AUTO_RECONNECT Ljava/lang/String; + public static final field CACHE_RESULT_SET_METADATA Ljava/lang/String; + public static final field CACHE_SERVER_CONFIG Ljava/lang/String; + public static final field INSTANCE Lcom/planetscale/jvm/driver/Constants$DriverParams; + public static final field ROUND_ROBIN_LOAD_BALANCE Ljava/lang/String; + public static final field SESSION_VARIABLES Ljava/lang/String; + public static final field SSL_MODE Ljava/lang/String; + public static final field SSL_MODE_VERIFY Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class com/planetscale/jvm/driver/Constants$Prefix { + public static final field H2 Ljava/lang/String; + public static final field INSTANCE Lcom/planetscale/jvm/driver/Constants$Prefix; + public static final field MYSQL Ljava/lang/String; + public static final field PLANETSCALE Ljava/lang/String; + public static final field REPLICATION Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class com/planetscale/jvm/driver/Constants$Provider { + public static final field AWS Ljava/lang/String; + public static final field AWS_CREDS_VAR Ljava/lang/String; + public static final field GCP Ljava/lang/String; + public static final field GCP_CREDS_VAR Ljava/lang/String; + public static final field INSTANCE Lcom/planetscale/jvm/driver/Constants$Provider; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class com/planetscale/jvm/driver/Constants$StringValue { + public static final field FALSE Ljava/lang/String; + public static final field INSTANCE Lcom/planetscale/jvm/driver/Constants$StringValue; + public static final field TRUE Ljava/lang/String; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class com/planetscale/jvm/driver/Constants$SymbolicHosts { + public static final field AWS Ljava/lang/String; + public static final field GCP Ljava/lang/String; + public static final field INSTANCE Lcom/planetscale/jvm/driver/Constants$SymbolicHosts; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class com/planetscale/jvm/driver/Constants$UrlTokens { + public static final field HOST_SEPARATOR Ljava/lang/String; + public static final field INSTANCE Lcom/planetscale/jvm/driver/Constants$UrlTokens; + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract class com/planetscale/jvm/driver/PlanetscaleDriver : java/io/Closeable, java/lang/AutoCloseable, java/sql/Driver { + public fun ()V + public fun acceptsURL (Ljava/lang/String;)Z + public fun close ()V + public fun connect (Ljava/lang/String;Ljava/util/Properties;)Ljava/sql/Connection; + public fun getMajorVersion ()I + public fun getMinorVersion ()I + public fun getParentLogger ()Ljava/util/logging/Logger; + public fun getPropertyInfo (Ljava/lang/String;Ljava/util/Properties;)[Ljava/sql/DriverPropertyInfo; + public fun jdbcCompliant ()Z + public static final fun resolveImpl ()Lcom/planetscale/jvm/PlanetscaleAdapter; +} + +public final class com/planetscale/jvm/param/Defaults { + public static final field INSTANCE Lcom/planetscale/jvm/param/Defaults; + public static final field enableBoost Z + public fun equals (Ljava/lang/Object;)Z + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public abstract interface class com/planetscale/jvm/param/Parameter { + public static final field Companion Lcom/planetscale/jvm/param/Parameter$Companion; + public abstract fun getName ()Ljava/lang/String; + public abstract fun getValue ()Ljava/lang/Object; + public static fun literal (Ljava/lang/String;Ljava/lang/Object;)Lcom/planetscale/jvm/param/Parameter; +} + +public abstract class com/planetscale/jvm/param/Parameter$BooleanOptionFactory : com/planetscale/jvm/param/Parameter$ParameterParser { + public fun (Lcom/planetscale/jvm/DriverParameter;)V + public fun envName ()Ljava/lang/String; + public fun getOption ()Lcom/planetscale/jvm/DriverParameter; + public fun parse (Ljava/lang/String;)Ljava/lang/Boolean; + public synthetic fun parse (Ljava/lang/String;)Ljava/lang/Object; + public fun resolve (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;)Ljava/lang/Boolean; + public synthetic fun resolve (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;)Ljava/lang/Object; + public synthetic fun resolveOr (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;Ljava/lang/Object;)Ljava/lang/Object; + public fun resolveOr (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;Z)Ljava/lang/Boolean; + public fun uriName ()Ljava/lang/String; + public fun vmPropName ()Ljava/lang/String; +} + +public final class com/planetscale/jvm/param/Parameter$Companion { + public final fun literal (Ljava/lang/String;Ljava/lang/Object;)Lcom/planetscale/jvm/param/Parameter; +} + +public final class com/planetscale/jvm/param/Parameter$LiteralParameter : com/planetscale/jvm/param/Parameter { + public static final synthetic fun box-impl (Lkotlin/Pair;)Lcom/planetscale/jvm/param/Parameter$LiteralParameter; + public static fun constructor-impl (Lkotlin/Pair;)Lkotlin/Pair; + public fun equals (Ljava/lang/Object;)Z + public static fun equals-impl (Lkotlin/Pair;Ljava/lang/Object;)Z + public static final fun equals-impl0 (Lkotlin/Pair;Lkotlin/Pair;)Z + public fun getName ()Ljava/lang/String; + public static fun getName-impl (Lkotlin/Pair;)Ljava/lang/String; + public fun getValue ()Ljava/lang/Object; + public static fun getValue-impl (Lkotlin/Pair;)Ljava/lang/Object; + public fun hashCode ()I + public static fun hashCode-impl (Lkotlin/Pair;)I + public fun toString ()Ljava/lang/String; + public static fun toString-impl (Lkotlin/Pair;)Ljava/lang/String; + public final synthetic fun unbox-impl ()Lkotlin/Pair; +} + +public abstract interface class com/planetscale/jvm/param/Parameter$ParameterFactory { + public abstract fun parse (Ljava/lang/String;)Ljava/lang/Object; +} + +public abstract interface class com/planetscale/jvm/param/Parameter$ParameterParser : com/planetscale/jvm/param/Parameter$ParameterFactory { + public abstract fun envName ()Ljava/lang/String; + public abstract fun getOption ()Lcom/planetscale/jvm/DriverParameter; + public abstract fun resolve (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;)Ljava/lang/Object; + public abstract fun resolveOr (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;Ljava/lang/Object;)Ljava/lang/Object; + public abstract fun uriName ()Ljava/lang/String; + public abstract fun vmPropName ()Ljava/lang/String; +} + +public final class com/planetscale/jvm/param/Parameter$ParameterParser$DefaultImpls { + public static fun envName (Lcom/planetscale/jvm/param/Parameter$ParameterParser;)Ljava/lang/String; + public static fun resolve (Lcom/planetscale/jvm/param/Parameter$ParameterParser;Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;)Ljava/lang/Object; + public static fun resolveOr (Lcom/planetscale/jvm/param/Parameter$ParameterParser;Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;Ljava/lang/Object;)Ljava/lang/Object; + public static fun uriName (Lcom/planetscale/jvm/param/Parameter$ParameterParser;)Ljava/lang/String; + public static fun vmPropName (Lcom/planetscale/jvm/param/Parameter$ParameterParser;)Ljava/lang/String; +} + +public abstract class com/planetscale/jvm/param/Parameter$StringOptionFactory : com/planetscale/jvm/param/Parameter$ParameterParser { + public fun (Lcom/planetscale/jvm/DriverParameter;)V + public fun envName ()Ljava/lang/String; + public fun getOption ()Lcom/planetscale/jvm/DriverParameter; + public synthetic fun parse (Ljava/lang/String;)Ljava/lang/Object; + public fun parse (Ljava/lang/String;)Ljava/lang/String; + public synthetic fun resolve (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;)Ljava/lang/Object; + public fun resolve (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;)Ljava/lang/String; + public synthetic fun resolveOr (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;Ljava/lang/Object;)Ljava/lang/Object; + public fun resolveOr (Ljava/net/URI;Ljava/util/Map;Ljava/util/Properties;Ljava/lang/String;)Ljava/lang/String; + public fun uriName ()Ljava/lang/String; + public fun vmPropName ()Ljava/lang/String; +} + +public final class com/planetscale/jvm/param/ParameterSource : java/lang/Enum { + public static final field ENVIRONMENT Lcom/planetscale/jvm/param/ParameterSource; + public static final field PROGRAMMATIC Lcom/planetscale/jvm/param/ParameterSource; + public static final field URL Lcom/planetscale/jvm/param/ParameterSource; + public static final field VM_PROPERTY Lcom/planetscale/jvm/param/ParameterSource; + public static fun getEntries ()Lkotlin/enums/EnumEntries; + public static fun valueOf (Ljava/lang/String;)Lcom/planetscale/jvm/param/ParameterSource; + public static fun values ()[Lcom/planetscale/jvm/param/ParameterSource; +} + diff --git a/subprojects/core-api/build.gradle.kts b/subprojects/core-api/build.gradle.kts new file mode 100644 index 0000000..6fa1fb2 --- /dev/null +++ b/subprojects/core-api/build.gradle.kts @@ -0,0 +1,39 @@ +import PlanetscaleBuild.publishable + +plugins { + id("planetscale-connector.klib") + id("planetscale-publishable.klib") + alias(libs.plugins.ksp) + alias(libs.plugins.buildConfig) +} + +buildConfig { + className("BuildConstants") + packageName("com.planetscale.jvm.driver") + useKotlinOutput { + topLevelConstants = true + internalVisibility = true + } + + buildConfigField("String", "VERSION", "\"${version as String}\"") + buildConfigField("String", "DEPENDENCY_MYSQL", "\"${libs.versions.mysql.get()}\"") +} + +dependencies { + api(libs.bundles.slf4j) + api(kotlin("stdlib")) + + testImplementation(libs.bundles.junit5) + testImplementation(libs.bundles.logback) + testImplementation(projects.subprojects.implH2) + testRuntimeOnly(libs.junit.jupiter.engine) +} + +kotlin { + compilerOptions.moduleName = "planetscale.connector" +} + +publishable( + name = PlanetscaleBuild.Library.CORE_API, + description = "Planetscale driver JDBC interfaces", +) diff --git a/subprojects/core-api/gradle.lockfile b/subprojects/core-api/gradle.lockfile new file mode 100644 index 0000000..e3b842c --- /dev/null +++ b/subprojects/core-api/gradle.lockfile @@ -0,0 +1,7 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +org.jetbrains.kotlin:kotlin-stdlib:1.9.20=compileClasspath,runtimeClasspath +org.jetbrains:annotations:13.0=compileClasspath,runtimeClasspath +org.slf4j:slf4j-api:2.0.9=compileClasspath,runtimeClasspath +empty= diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/Driver.kt b/subprojects/core-api/src/main/jvm/com/planetscale/Driver.kt new file mode 100644 index 0000000..cc2b673 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/Driver.kt @@ -0,0 +1,10 @@ +package com.planetscale + +import com.planetscale.jvm.driver.PlanetscaleDriver + +/** + * # Planetscale Connector/J + * + * TBD. + */ +public class Driver : PlanetscaleDriver() diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/DriverParameter.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/DriverParameter.kt new file mode 100644 index 0000000..e22d1a5 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/DriverParameter.kt @@ -0,0 +1,21 @@ +package com.planetscale.jvm + +/** + * TBD. + */ +public enum class DriverParameter ( + public val paramName: String, + internal val uriParam: String, + internal val vmProp: String, + internal val envVar: String? = null, +) { + /** + * TBD. + */ + ENABLE_BOOST( + "boost_cached_queries", + "enableBoost", + "planetscale.enableBoost", + "PLANETSCALE_ENABLE_BOOST", + ), +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleAdapter.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleAdapter.kt new file mode 100644 index 0000000..465c0cc --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleAdapter.kt @@ -0,0 +1,111 @@ +package com.planetscale.jvm + +import com.planetscale.jvm.err.PlanetscaleError +import java.io.Closeable +import java.sql.Connection +import java.sql.DriverPropertyInfo +import java.util.* +import java.util.logging.Logger + +/** + * # Planetscale Adapter + * + * Defines the API surface of internal logic for the Planetscale/J adapter; implementations of this interface must + * support querying on top of a backing database driver, like MySQL/J or H2 (for internal testing). The Planetscale + * adapter then manages the lifecycle of the underlying driver, connections, and so on. + * + *   + * + * ## Usage + * + * An implementation, such as `impl-mysqlj`, or `impl-h2`, must be included on the classpath and module path. The first + * implementation that is found is used through the regular adapter factory; it is an error to have multiple adapters on + * the classpath without declaring the adapter to use. + * + *   + * + * ### Declaring an Adapter + * + * The following methods are supported for declaring a forced implementation: + * + * - `PLANETSCALE_J_ADAPTER` environment variable, which must be set to one of `mysql` or `h2`. + * - `planetscale.adapter` VM property, which must be set to one of `mysql` or `h2`. + * + *   + * + * ### Using from JDBC + * + * For regular adapter users, the adapter is used transparently from JDBC. JDBC URLs with the prefix `planetscale` are + * registered for support through the backing driver implementation. JDBC URLs for this driver are expected to be + * expressed in the following format: + * + * #### JDBC URL Format + * + * - All driver URLs start with `jdbc:planetscale:`. + * - Next, following standard JDBC URL structure, the username and password are provided, as `username:password@`. + * - Next, the URL declares a connection symbol; valid connection symbols are defined in the next section. + * - The database name is provided, after a separating `/` + * - Finally, additional driver parameters are provided, as applicable, in URL param format. + * + *   + * + * #### Connection Symbols + * + * The driver is able to determine the optimal connection string to use based on the current cloud provider and database + * location. Thus, either the location must be provided, or the driver uses a generic connection endpoint. + * + * In addition to fully qualified domains provided within the Planetscale UI, the following special values are supported + * for smart connection management: + * + * - `cloud`: Connects to a generic, globally accelerated endpoint for Planetscale. If a provider can be detected in use + * (such as AWS), the connection string may be customized further by the driver. + * + * - `.`: Provider string (available options are `aws` or `gcp`), and the region of the database; when + * a connection symbol is provided in this format, an endpoint is used which is specific to the provider and region. + * + *   + * + * ### Driver Parameters + * + * This driver exposes several parameters, and allows control of the underlying driver through parameters documented by + * the MySQL Connector/J. The following parameters are supported: + * + * - (TBD). + */ +public interface PlanetscaleAdapter: Closeable, AutoCloseable { + /** + * TBD. + */ + public fun configure(config: PlanetscaleConfig) + + /** + * TBD. + */ + @Throws(PlanetscaleError::class) + public fun validate() + + /** + * TBD. + */ + public fun getMajorVersion(): Int + + /** + * TBD. + */ + public fun getMinorVersion(): Int + + /** + * TBD. + */ + public fun getPropertyInfo(url: String, info: Properties?): Array + + /** + * TBD. + */ + public fun getParentLogger(): Logger + + /** + * TBD. + */ + public fun connect(url: String, info: Properties? = null): Connection +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleConfig.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleConfig.kt new file mode 100644 index 0000000..514fa8d --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleConfig.kt @@ -0,0 +1,158 @@ +@file:Suppress("DataClassPrivateConstructor") + +package com.planetscale.jvm + +import com.planetscale.jvm.param.Defaults +import com.planetscale.jvm.param.ParameterSource +import com.planetscale.jvm.PlanetscaleParameter.EnableBoost +import com.planetscale.jvm.driver.Constants +import java.net.URI +import java.util.Properties +import java.util.SortedMap +import java.util.TreeMap + +/** + * TBD. + */ +public interface PlanetscaleConfig { + public companion object { + /** + * TBD. + */ + @JvmRecord public data class PlanetscaleConfigState internal constructor ( + override val uri: URI, + override val credential: PlanetscaleCredential, + val hosts: List, + val enableBoost: EnableBoost, + val extra: SortedMap, + ) : PlanetscaleConfig { + override val state: PlanetscaleConfigState get() = this + } + + /** + * TBD. + */ + private fun extractParams(uri: URI): Map { + return uri.query + ?.split("&") + ?.map { it.split("=") } + ?.associate { it[0] to it[1] } + ?: emptyMap() + } + + /** + * TBD. + */ + private fun extractHosts(uri: URI): List { + return uri.toString() + .substringAfter("@") + .substringBefore("/") + .trim() + .split(Constants.UrlTokens.HOST_SEPARATOR) + .map { it.trim() } + } + + /** + * TBD. + */ + private fun extraParamsOnly(map: Map): SortedMap { + return map.filterKeys { !PlanetscaleParameter.allKnownParamNames.contains(it) }.toSortedMap() + } + + /** + * TBD. + */ + @JvmStatic public fun parseUri(uri: String): URI { + return if (!uri.startsWith("jdbc:")) error("Cannot parse non-JDBC URIs") else URI.create( + // should be `planetscale://...` + uri.drop("jdbc:".length) + ) + } + + /** + * TBD. + */ + @JvmStatic public fun of( + uri: URI, + credential: PlanetscaleCredential, + source: ParameterSource = ParameterSource.PROGRAMMATIC, + enableBoost: Boolean = Defaults.enableBoost, + extra: SortedMap = TreeMap(), + ): PlanetscaleConfig = PlanetscaleConfigState( + uri, + credential, + hosts = extractHosts(uri), + enableBoost = EnableBoost.of(enableBoost, source), + extra = extra, + ) + + /** @return Set of default configurations for the provided [credential]. */ + @JvmStatic public fun defaults(uri: URI, credential: PlanetscaleCredential): PlanetscaleConfig = + extractParams(uri).let { params -> + PlanetscaleConfigState( + uri, + credential, + hosts = extractHosts(uri), + extra = extraParamsOnly(params), + enableBoost = EnableBoost.of( + EnableBoost.resolveOr(uri, params, null, Defaults.enableBoost) + ), + ) + } + + /** @return Configuration resolved from the provided [uri] and environment or VM property inputs. */ + @JvmStatic public fun resolve( + params: Map, + properties: Properties?, + uri: URI, + ): PlanetscaleConfig = PlanetscaleConfigState( + uri, + requireNotNull(PlanetscaleCredential.resolve(uri)) { "No Planetscale credential found" }, + hosts = extractHosts(uri), + enableBoost = EnableBoost.of(EnableBoost.resolveOr(uri, params, properties, Defaults.enableBoost)), + extra = extraParamsOnly(params), + ) + + /** @return Configuration resolved from provided args and environment or VM property inputs. */ + @JvmStatic public fun resolve(uri: URI, properties: Properties? = null): PlanetscaleConfig = resolve( + extractParams(uri), + properties, + uri, + ) + } + + /** + * TBD. + */ + public val state: PlanetscaleConfigState + + /** + * TBD. + */ + public val uri: URI + + /** + * TBD. + */ + public val credential: PlanetscaleCredential + + /** + * TBD. + */ + public fun enableBoost(): Boolean = state.enableBoost.value + + /** + * TBD. + */ + public fun multiHost(): Boolean = state.hosts.size > 1 + + /** + * TBD. + */ + public fun targetHosts(): List = state.hosts + + /** + * TBD. + */ + public fun extraParams(): SortedMap = state.extra +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleConnection.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleConnection.kt new file mode 100644 index 0000000..16fbe6b --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleConnection.kt @@ -0,0 +1,13 @@ +package com.planetscale.jvm + +import java.sql.Connection + +/** + * # Planetscale Connection + */ +public interface PlanetscaleConnection: Connection { + /** + * TBD. + */ + public val adapter: PlanetscaleAdapter +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleCredential.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleCredential.kt new file mode 100644 index 0000000..5ca701d --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleCredential.kt @@ -0,0 +1,95 @@ +package com.planetscale.jvm + +import com.planetscale.jvm.driver.Constants +import java.net.URI + +/** + * # Planetscale Credential + */ +public sealed interface PlanetscaleCredential { + /** + * TBD. + */ + public val database: String + + /** + * TBD. + */ + public val username: String + + /** + * TBD. + */ + public val password: String + + /** TBD. */ + public companion object { + private fun dbNameFromUri(uri: URI): String { + return uri.toString() + .drop("jdbc:planetscale://".length) + .substringAfter("/") + .substringBefore("?") + .trim() + } + + /** Lightweight wrapper for a validated Planetscale credential. */ + @JvmInline internal value class PlanetscaleUser( + private val credential: PlanetscaleCredentialInfo, + ): PlanetscaleCredential { + companion object { + @JvmStatic internal fun of(db: String, user: String, pass: String): PlanetscaleCredential { + return PlanetscaleUser(PlanetscaleCredentialInfo( + database = db, + username = user, + password = pass, + )) + } + } + + override val database: String get() = credential.database + override val username: String get() = credential.username + override val password: String get() = credential.password + } + + /** + * TBD. + */ + @JvmStatic public fun user(db: String, username: String, password: String): PlanetscaleCredential = + PlanetscaleUser.of(db, username, password) + + /** + * TBD. + */ + @JvmStatic public fun resolve(uri: URI): PlanetscaleCredential? { + val userInfo = uri.toString() + .substringAfter("://") + .substringBefore("@") + .trim() + + return userInfo.ifBlank { null }?.let { + when { + it.contains(":") -> it.split(":").let { split -> + if (split.size == 2) { + val user = split.first().ifEmpty { null } + val pass = split[1].ifEmpty { null } + if (user.isNullOrBlank() || pass.isNullOrBlank()) (null to null) else { + user to pass + } + } else error( + "Invalid user/password specification in database URI" + ) + } + else -> it to null + }.let { (user, pass) -> + ( + user ?: System.getProperty(Constants.USER_VM_PROPERTY, System.getenv(Constants.USER_ENV_VAR)) + ) to ( + pass ?: System.getProperty(Constants.PASS_VM_PROPERTY, System.getenv(Constants.PASS_ENV_VAR)) + ) + } + }?.let { (user, pass) -> + PlanetscaleUser.of(dbNameFromUri(uri), user, pass) + } + } + } +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleCredentialInfo.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleCredentialInfo.kt new file mode 100644 index 0000000..6bfdbd7 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleCredentialInfo.kt @@ -0,0 +1,10 @@ +package com.planetscale.jvm + +/** + * TBD. + */ +@JvmRecord internal data class PlanetscaleCredentialInfo( + val database: String, + val username: String, + val password: String, +) diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleParameter.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleParameter.kt new file mode 100644 index 0000000..f131211 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/PlanetscaleParameter.kt @@ -0,0 +1,69 @@ +package com.planetscale.jvm + +import com.planetscale.jvm.param.Parameter +import com.planetscale.jvm.param.ParameterName +import com.planetscale.jvm.param.ParameterSource +import java.util.SortedSet +import kotlin.reflect.KClass + +/** + * # Planetscale Parameter + */ +public sealed interface PlanetscaleParameter { + /** + * TBD. + */ + public val key: DriverParameter + + /** + * TBD. + */ + public val value: Type + + /** + * TBD. + */ + public val param: Parameter + + /** + * TBD. + */ + public val source: ParameterSource + + public companion object { + // All configured driver options. + private val allDriverOptions: List> = listOf( + EnableBoost.Companion, + ) + + // All parameter names that are specific to this meta-driver. + internal val allKnownParamNames: SortedSet = allDriverOptions.map { it.option.paramName }.toSortedSet() + } + + /** + * Parameter: `enableBoost`. + */ + @JvmInline public value class EnableBoost(private val status: Pair) : + PlanetscaleParameter { + override val key: DriverParameter get() = DriverParameter.ENABLE_BOOST + override val param: Parameter get() = Parameter.literal(key.name, status.second) + override val source: ParameterSource get() = status.first + override val value: Boolean get() = status.second + + public companion object: Parameter.BooleanOptionFactory(DriverParameter.ENABLE_BOOST) { + /** @return "Enable Boost" setting with the provided [enabled] status, and optional [source]. */ + @JvmStatic public fun of( + enabled: Boolean, + source: ParameterSource = ParameterSource.PROGRAMMATIC, + ): EnableBoost = EnableBoost(source to enabled) + + /** @return Enabled Boost setting, with optional [source]. */ + @JvmStatic public fun enabled(source: ParameterSource = ParameterSource.PROGRAMMATIC): EnableBoost = + of(true, source) + + /** @return Disabled Boost setting, with optional [source]. */ + @JvmStatic public fun disabled(source: ParameterSource = ParameterSource.PROGRAMMATIC): EnableBoost = + of(false, source) + } + } +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/AbstractPlanetscaleAdapter.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/AbstractPlanetscaleAdapter.kt new file mode 100644 index 0000000..8da12a8 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/AbstractPlanetscaleAdapter.kt @@ -0,0 +1,87 @@ +package com.planetscale.jvm.driver + +import com.planetscale.jvm.PlanetscaleAdapter +import com.planetscale.jvm.PlanetscaleConfig +import com.planetscale.jvm.PlanetscaleConnection +import java.io.Closeable +import java.net.URI +import java.sql.Connection +import java.sql.Driver +import java.sql.DriverPropertyInfo +import java.util.* +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicReference +import java.util.logging.Logger + +/** + * TBD. + */ +public abstract class AbstractPlanetscaleAdapter : PlanetscaleAdapter, Closeable, AutoCloseable { + private val configuration: AtomicReference = AtomicReference(null) + private val initialized: AtomicBoolean = AtomicBoolean(false) + + private val backing: Driver by lazy { + createDriver() + } + + override fun configure(config: PlanetscaleConfig) { + if (!initialized.get()) { + configuration.set(config) + initialized.compareAndSet(false, true) + } + } + + override fun validate() { + require(configuration.get() != null && initialized.get()) { + "Cannot create Planetscale adapter without configuration" + } + } + + override fun connect(url: String, info: Properties?): Connection { + return PlanetscaleConfig.resolve(PlanetscaleConfig.parseUri(url), info).let { config -> + configure(config) + config.connectBacking(config.toURI(), info) + } + } + + override fun close() { + // nothing at this time + } + + override fun getMajorVersion(): Int = withDriver { it.majorVersion } + override fun getMinorVersion(): Int = withDriver { it.minorVersion } + override fun getParentLogger(): Logger = withDriver { it.parentLogger } + override fun getPropertyInfo(url: String, info: Properties?): Array = withDriver { + it.getPropertyInfo(url, info) + } + + /** + * TBD. + */ + protected open fun withDriver(op: (Driver) -> R): R { + return op(backing) + } + + /** + * TBD. + */ + protected open fun PlanetscaleConfig.connectBacking(uri: URI, info: Properties?): PlanetscaleConnection { + return withDriver { driver -> + driver.connect(toURI().toString(), info).let { connection -> + object: PlanetscaleConnection, Connection by connection { + override val adapter: AbstractPlanetscaleAdapter get() = this@AbstractPlanetscaleAdapter + } + } + } + } + + /** + * TBD. + */ + protected abstract fun createDriver(): Driver + + /** + * TBD. + */ + protected abstract fun PlanetscaleConfig.toURI(): URI +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/CloudProvider.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/CloudProvider.kt new file mode 100644 index 0000000..d59daf1 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/CloudProvider.kt @@ -0,0 +1,9 @@ +package com.planetscale.jvm.driver + +/** + * TBD. + */ +public enum class CloudProvider { + AWS, + GCP +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/Constants.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/Constants.kt new file mode 100644 index 0000000..6bb033f --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/Constants.kt @@ -0,0 +1,52 @@ +package com.planetscale.jvm.driver + +/** + * TBD. + */ +public data object Constants { + public const val MYSQL_PORT: Int = 3306 + public const val MYSQL_DRIVER: String = "com.mysql.cj.jdbc.Driver" + public const val CONNECT_DOMAIN: String = "connect.psdb.cloud" + public const val USER_VM_PROPERTY: String = "planetscale.username" + public const val USER_ENV_VAR: String = "PLANETSCALE_USERNAME" + public const val PASS_VM_PROPERTY: String = "planetscale.password" + public const val PASS_ENV_VAR: String = "PLANETSCALE_PASSWORD" + + public data object DriverParams { + public const val AUTO_RECONNECT: String = "autoReconnect" + public const val CACHE_SERVER_CONFIG: String = "cacheServerConfiguration" + public const val CACHE_RESULT_SET_METADATA: String = "cacheResultSetMetadata" + public const val SSL_MODE: String = "sslMode" + public const val SSL_MODE_VERIFY: String = "VERIFY_IDENTITY" + public const val SESSION_VARIABLES: String = "sessionVariables" + public const val ROUND_ROBIN_LOAD_BALANCE: String = "roundRobinLoadBalance" + } + + public data object UrlTokens { + public const val HOST_SEPARATOR: String = ".." + } + + public data object StringValue { + public const val TRUE: String = "true" + public const val FALSE: String = "false" + } + + public data object Prefix { + public const val MYSQL: String = "jdbc:mysql:" + public const val REPLICATION: String = "replication:" + public const val H2: String = "jdbc:h2:mem" + public const val PLANETSCALE: String = "jdbc:planetscale:" + } + + public data object SymbolicHosts { + public const val AWS: String = Provider.AWS + public const val GCP: String = Provider.GCP + } + + public data object Provider { + public const val AWS: String = "aws" + public const val GCP: String = "gcp" + public const val GCP_CREDS_VAR: String = "GOOGLE_APPLICATION_CREDENTIALS" + public const val AWS_CREDS_VAR: String = "AWS_ACCESS_KEY_ID" + } +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/PlanetscaleDriver.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/PlanetscaleDriver.kt new file mode 100644 index 0000000..7ecd2f8 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/PlanetscaleDriver.kt @@ -0,0 +1,68 @@ +package com.planetscale.jvm.driver + +import com.planetscale.jvm.PlanetscaleAdapter +import java.io.Closeable +import java.sql.Connection +import java.sql.Driver +import java.sql.DriverPropertyInfo +import java.util.* +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicReference +import java.util.logging.Logger +import java.util.stream.Collectors + +/** + * TBD. + */ +public abstract class PlanetscaleDriver: Driver, Closeable, AutoCloseable { + private companion object { + @JvmStatic fun resolveImpl(): PlanetscaleAdapter { + val serviceImpls = ServiceLoader.load(PlanetscaleAdapter::class.java) + .stream() + .collect(Collectors.toUnmodifiableList()) + + require(serviceImpls.size == 1) { + "Expected exactly one Planetscale adapter implementation, but got ${serviceImpls.size}" + } + return serviceImpls.first().get() + } + } + + // Active adapter and state. + private val activeAdapter: AtomicReference = AtomicReference(null) + private val initialized: AtomicBoolean = AtomicBoolean(false) + + private fun obtainOrInitializeDriver() { + if (!initialized.get()) synchronized(this) { + activeAdapter.set(resolveImpl()) + initialized.compareAndSet(false, true) + } + } + + private fun withAdapter(op: PlanetscaleAdapter.() -> R): R { + if (!initialized.get()) { + obtainOrInitializeDriver() + } + return activeAdapter.get().op() + } + + private fun obtainDriver(url: String, info: Properties?): Connection { + obtainOrInitializeDriver() + return withAdapter { + connect(url, info) + } + } + + // -- API: JDBC Driver -- // + + override fun connect(url: String, info: Properties?): Connection = obtainDriver(url, info) + override fun getMajorVersion(): Int = withAdapter { getMajorVersion() } + override fun getMinorVersion(): Int = withAdapter { getMinorVersion() } + override fun jdbcCompliant(): Boolean = true // both H2 and mysql are JDBC compliant + override fun acceptsURL(url: String?): Boolean = url?.startsWith(Constants.Prefix.PLANETSCALE) ?: false + override fun getParentLogger(): Logger = withAdapter { getParentLogger() } + override fun close(): Unit = withAdapter { close() } + override fun getPropertyInfo(url: String, info: Properties?): Array = withAdapter { + getPropertyInfo(url, info) + } +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/package-info.java b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/package-info.java new file mode 100644 index 0000000..27defd7 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/driver/package-info.java @@ -0,0 +1,4 @@ +/** + * Abstract driver implementation; loads the driver and provides a connection factory. + */ +package com.planetscale.jvm.driver; diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/err/PlanetscaleError.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/err/PlanetscaleError.kt new file mode 100644 index 0000000..1c39cb3 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/err/PlanetscaleError.kt @@ -0,0 +1,6 @@ +package com.planetscale.jvm.err + +/** + * TBD. + */ +internal sealed class PlanetscaleError: Throwable() diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/err/package-info.java b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/err/package-info.java new file mode 100644 index 0000000..3ae2341 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/err/package-info.java @@ -0,0 +1,4 @@ +/** + * Defines error handling logic and exception cases for the Planetscale/J driver. + */ +package com.planetscale.jvm.err; diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/Defaults.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/Defaults.kt new file mode 100644 index 0000000..2f23c05 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/Defaults.kt @@ -0,0 +1,11 @@ +package com.planetscale.jvm.param + +/** + * + */ +public data object Defaults { + /** + * + */ + public const val enableBoost: Boolean = false +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/DriverParamTypes.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/DriverParamTypes.kt new file mode 100644 index 0000000..cb796f5 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/DriverParamTypes.kt @@ -0,0 +1,7 @@ +package com.planetscale.jvm.param + + +/** + * TBD. + */ +public typealias ParameterName = String diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/Parameter.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/Parameter.kt new file mode 100644 index 0000000..28a3bb5 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/Parameter.kt @@ -0,0 +1,85 @@ +package com.planetscale.jvm.param + +import com.planetscale.jvm.DriverParameter +import java.net.URI +import java.util.Properties + +/** + * # Driver Parameter + * + */ +public sealed interface Parameter { + /** + * TBD. + */ + public val name: ParameterName + + /** + * TBD. + */ + public val value: V? + + /** Models the concept of a literal value as a driver parameter. */ + @JvmInline public value class LiteralParameter(private val pair: Pair) : Parameter { + override val name: ParameterName get() = pair.first + override val value: V? get() = pair.second + } + + /** + * TBD. + */ + @FunctionalInterface public fun interface ParameterFactory { + /** + * TBD. + */ + public fun parse(optionValue: String): V? + } + + /** + * TBD. + */ + public sealed interface ParameterParser: ParameterFactory { + /** @return Driver parameter controlled by this namer. */ + public val option: DriverParameter + + /** @return URI parameter name for this option. */ + public fun uriName(): String = option.uriParam + + /** @return Environment variable name for this parser. */ + public fun envName(): String? = option.envVar + + /** @return VM property name for this parameter. */ + public fun vmPropName(): String = option.vmProp + + /** @return Resolved value of this parameter, if available, or `null`. */ + public fun resolve(uri: URI, params: Map, properties: Properties?): V? { + return params[uriName()]?.let { parse(it) } + ?: envName()?.let { System.getenv(it) }?.let { parse(it) } + ?: properties?.getProperty(vmPropName())?.let { parse(it) } + ?: System.getProperty(vmPropName())?.let { parse(it) } + } + + /** @return Resolved value of this parameter, if available, or `null`. */ + public fun resolveOr(uri: URI, params: Map, properties: Properties?, default: V): V { + return resolve(uri, params, properties) ?: default + } + } + + /** TBD. */ + public abstract class BooleanOptionFactory (override val option: DriverParameter): ParameterParser { + override fun parse(optionValue: String): Boolean? = optionValue.toBooleanStrictOrNull() + } + + /** TBD. */ + public abstract class StringOptionFactory (override val option: DriverParameter): ParameterParser { + override fun parse(optionValue: String): String? = optionValue.let { it.ifBlank { null } } + } + + public companion object { + /** + * TBD. + */ + @JvmStatic public fun literal(name: ParameterName, value: V?): Parameter = + LiteralParameter(name to value) + } +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/ParameterSource.kt b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/ParameterSource.kt new file mode 100644 index 0000000..a692716 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/ParameterSource.kt @@ -0,0 +1,18 @@ +package com.planetscale.jvm.param + +/** + * TBD. + */ +public enum class ParameterSource { + /** The value originates from the driver URL. */ + URL, + + /** The value originates from environment variables. */ + ENVIRONMENT, + + /** The value originates from VM properties. */ + VM_PROPERTY, + + /** The value is a default or provided programmatically. */ + PROGRAMMATIC, +} diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/package-info.java b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/package-info.java new file mode 100644 index 0000000..4929dc9 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/jvm/param/package-info.java @@ -0,0 +1,4 @@ +/** + * Defines parameter-parsing logic for the Planetscale/J driver. + */ +package com.planetscale.jvm.param; diff --git a/subprojects/core-api/src/main/jvm/com/planetscale/package-info.java b/subprojects/core-api/src/main/jvm/com/planetscale/package-info.java new file mode 100644 index 0000000..4263c8d --- /dev/null +++ b/subprojects/core-api/src/main/jvm/com/planetscale/package-info.java @@ -0,0 +1,4 @@ +/** + * Provides Planetscale-specific JDBC drivers and utilities. + */ +package com.planetscale; diff --git a/subprojects/core-api/src/main/jvm/module-info.java b/subprojects/core-api/src/main/jvm/module-info.java new file mode 100644 index 0000000..2199cf1 --- /dev/null +++ b/subprojects/core-api/src/main/jvm/module-info.java @@ -0,0 +1,16 @@ +/** + * # PlanetScale Connector/J + * + *

Wraps the MySQL Connector for Java with functionality specific to Planetscale, which leverages MySQL-compatible + * cloud databasing via Vitess.

+ */ +module planetscale.connector { + requires java.base; + requires java.sql; + requires kotlin.stdlib; + + exports com.planetscale.jvm; + exports com.planetscale.jvm.driver; + + provides java.sql.Driver with com.planetscale.Driver; +} diff --git a/subprojects/core-api/src/main/resources/META-INF/services/java.sql.Driver b/subprojects/core-api/src/main/resources/META-INF/services/java.sql.Driver new file mode 100644 index 0000000..ae325c9 --- /dev/null +++ b/subprojects/core-api/src/main/resources/META-INF/services/java.sql.Driver @@ -0,0 +1 @@ +com.planetscale.Driver diff --git a/subprojects/core-api/src/main/resources/logback-test.xml b/subprojects/core-api/src/main/resources/logback-test.xml new file mode 100644 index 0000000..203c544 --- /dev/null +++ b/subprojects/core-api/src/main/resources/logback-test.xml @@ -0,0 +1,13 @@ + + + true + + [%cyan(%d{HH:mm:ss.SSS}) %highlight(%5level)] %boldWhite(%logger) %msg%n + + + + + + + + diff --git a/subprojects/core-api/src/test/kotlin/com/planetscale/DriverTest.kt b/subprojects/core-api/src/test/kotlin/com/planetscale/DriverTest.kt new file mode 100644 index 0000000..a1ce466 --- /dev/null +++ b/subprojects/core-api/src/test/kotlin/com/planetscale/DriverTest.kt @@ -0,0 +1,50 @@ +package com.planetscale + +import org.junit.jupiter.api.assertDoesNotThrow +import java.util.ServiceLoader +import kotlin.test.Test +import kotlin.test.assertNotEquals +import kotlin.test.assertNotNull +import kotlin.test.assertTrue + +/** Tests for the main driver facade, at [com.planetscale.Driver]. */ +class DriverTest { + private val testDriver: Driver by lazy { + Driver() + } + + private fun withDriver(op: Driver.() -> Unit) { + assertNotNull(testDriver, "should be able to obtain test driver") + op.invoke(testDriver) + } + + @Test fun testDriverConstruct() { + assertDoesNotThrow { + Driver() + } + } + + @Test fun testDriverAPI() = withDriver { + assertNotNull(majorVersion, "majorVersion should not return `null`") + assertNotNull(minorVersion, "majorVersion should not return `null`") + } + + @Test fun testDriverMajorVersion() = withDriver { + assertNotNull(majorVersion, "majorVersion should not return `null`") + assertNotEquals(0, majorVersion, "majorVersion should not be `0`") + } + + @Test fun testDriverMinorVersion() = withDriver { + assertNotNull(minorVersion, "minorVersion should not return `null`") + assertNotEquals(0, minorVersion, "minorVersion should not be `0`") + } + + @Test fun testDriverServiceLoader() { + val all = ServiceLoader.load(java.sql.Driver::class.java) + .toList() + .map { it::class } + + assertNotEquals(0, all.size, "should have at least one driver") + assertTrue(all.contains(Driver::class), "should contain our driver") + } +} diff --git a/subprojects/core-api/src/test/kotlin/com/planetscale/jvm/PlanetscaleConfigTest.kt b/subprojects/core-api/src/test/kotlin/com/planetscale/jvm/PlanetscaleConfigTest.kt new file mode 100644 index 0000000..3e779ac --- /dev/null +++ b/subprojects/core-api/src/test/kotlin/com/planetscale/jvm/PlanetscaleConfigTest.kt @@ -0,0 +1,128 @@ +package com.planetscale.jvm + +import kotlin.test.* + +/** Tests for Planetscale configuration classes, like [PlanetscaleConfig]. */ +class PlanetscaleConfigTest { + @Test fun testConfigDefaults() { + val cfg = PlanetscaleConfig.defaults( + PlanetscaleConfig.parseUri("jdbc:planetscale://user:pass@us-west-1.aws/dbname"), + PlanetscaleCredential.user("dbname", "user", "pass"), + ) + assertNotNull(cfg, "config should not be null") + assertNotNull(cfg.uri, "URI in config should not be null") + assertNotNull(cfg.credential, "credential in config should not be null") + assertNotNull(cfg.enableBoost(), "`enableBoost` should never return null") + assertNotNull(cfg.multiHost(), "`multiHost` should never return null") + assertNotNull(cfg.targetHosts(), "`targetHosts` should never return null") + assertTrue(cfg.targetHosts().isNotEmpty(), "`targetHosts` should not be empty") + assertEquals(cfg.credential.database, "dbname", "database name should be extracted correctly") + assertEquals(cfg.credential.username, "user", "username should be extracted correctly") + assertEquals(cfg.credential.password, "pass", "password should be extracted correctly") + assertEquals(cfg.targetHosts().size, 1, "should have 1 target host") + assertEquals(cfg.targetHosts().first(), "us-west-1.aws") + assertFalse(cfg.enableBoost(), "boost should default to false") + } + + @Test fun testConfigManual() { + val cfg = PlanetscaleConfig.of( + PlanetscaleConfig.parseUri("jdbc:planetscale://user:pass@us-west-1.aws/dbname"), + PlanetscaleCredential.user("dbname", "user", "pass"), + ) + assertNotNull(cfg, "config should not be null") + assertNotNull(cfg.uri, "URI in config should not be null") + assertNotNull(cfg.credential, "credential in config should not be null") + assertNotNull(cfg.enableBoost(), "`enableBoost` should never return null") + assertNotNull(cfg.multiHost(), "`multiHost` should never return null") + assertNotNull(cfg.targetHosts(), "`targetHosts` should never return null") + assertTrue(cfg.targetHosts().isNotEmpty(), "`targetHosts` should not be empty") + assertEquals(cfg.credential.database, "dbname", "database name should be extracted correctly") + assertEquals(cfg.credential.username, "user", "username should be extracted correctly") + assertEquals(cfg.credential.password, "pass", "password should be extracted correctly") + assertEquals(cfg.targetHosts().size, 1, "should have 1 target host") + assertEquals(cfg.targetHosts().first(), "us-west-1.aws") + assertFalse(cfg.enableBoost(), "boost should default to false") + } + + @Test fun testConfigResolveFromUri() { + val cfg = PlanetscaleConfig.resolve( + PlanetscaleConfig.parseUri("jdbc:planetscale://user:pass@us-west-1.aws/dbname"), + ) + assertNotNull(cfg, "config should not be null") + assertNotNull(cfg.uri, "URI in config should not be null") + assertNotNull(cfg.credential, "credential in config should not be null") + assertNotNull(cfg.enableBoost(), "`enableBoost` should never return null") + assertNotNull(cfg.multiHost(), "`multiHost` should never return null") + assertNotNull(cfg.targetHosts(), "`targetHosts` should never return null") + assertTrue(cfg.targetHosts().isNotEmpty(), "`targetHosts` should not be empty") + assertEquals(cfg.credential.database, "dbname", "database name should be extracted correctly") + assertEquals(cfg.credential.username, "user", "username should be extracted correctly") + assertEquals(cfg.credential.password, "pass", "password should be extracted correctly") + assertEquals(cfg.targetHosts().size, 1, "should have 1 target host") + assertEquals(cfg.targetHosts().first(), "us-west-1.aws") + assertFalse(cfg.enableBoost(), "boost should default to false") + } + + @Test fun testConfigResolveFromUriMultiHost() { + val cfg = PlanetscaleConfig.resolve( + PlanetscaleConfig.parseUri("jdbc:planetscale://user:pass@us-west-1.aws..aws/dbname"), + ) + assertNotNull(cfg, "config should not be null") + assertNotNull(cfg.uri, "URI in config should not be null") + assertNotNull(cfg.credential, "credential in config should not be null") + assertNotNull(cfg.enableBoost(), "`enableBoost` should never return null") + assertNotNull(cfg.multiHost(), "`multiHost` should never return null") + assertNotNull(cfg.targetHosts(), "`targetHosts` should never return null") + assertTrue(cfg.targetHosts().isNotEmpty(), "`targetHosts` should not be empty") + assertEquals(cfg.credential.database, "dbname", "database name should be extracted correctly") + assertEquals(cfg.credential.username, "user", "username should be extracted correctly") + assertEquals(cfg.credential.password, "pass", "password should be extracted correctly") + assertEquals(cfg.targetHosts().size, 2, "should have 2 target hosts") + assertEquals(cfg.targetHosts().first(), "us-west-1.aws") + assertEquals(cfg.targetHosts()[1], "aws") + assertFalse(cfg.enableBoost(), "boost should default to false") + } + + @Test fun testConfigKnownOptions() { + val cfg = PlanetscaleConfig.resolve( + PlanetscaleConfig.parseUri("jdbc:planetscale://user:pass@us-west-1.aws..aws/dbname?enableBoost=true"), + ) + assertNotNull(cfg, "config should not be null") + assertNotNull(cfg.uri, "URI in config should not be null") + assertNotNull(cfg.credential, "credential in config should not be null") + assertNotNull(cfg.enableBoost(), "`enableBoost` should never return null") + assertNotNull(cfg.multiHost(), "`multiHost` should never return null") + assertNotNull(cfg.targetHosts(), "`targetHosts` should never return null") + assertTrue(cfg.targetHosts().isNotEmpty(), "`targetHosts` should not be empty") + assertEquals(cfg.credential.database, "dbname", "database name should be extracted correctly") + assertEquals(cfg.credential.username, "user", "username should be extracted correctly") + assertEquals(cfg.credential.password, "pass", "password should be extracted correctly") + assertEquals(cfg.targetHosts().size, 2, "should have 2 target hosts") + assertEquals(cfg.targetHosts().first(), "us-west-1.aws") + assertEquals(cfg.targetHosts()[1], "aws") + assertTrue(cfg.enableBoost(), "boost should be active") + } + + @Test fun testConfigPassthrough() { + val cfg = PlanetscaleConfig.resolve( + PlanetscaleConfig.parseUri("jdbc:planetscale://user:pass@us-west-1.aws..aws/dbname?someParam=hi"), + ) + assertNotNull(cfg, "config should not be null") + assertNotNull(cfg.uri, "URI in config should not be null") + assertNotNull(cfg.credential, "credential in config should not be null") + assertNotNull(cfg.enableBoost(), "`enableBoost` should never return null") + assertNotNull(cfg.multiHost(), "`multiHost` should never return null") + assertNotNull(cfg.targetHosts(), "`targetHosts` should never return null") + assertTrue(cfg.targetHosts().isNotEmpty(), "`targetHosts` should not be empty") + assertEquals(cfg.credential.database, "dbname", "database name should be extracted correctly") + assertEquals(cfg.credential.username, "user", "username should be extracted correctly") + assertEquals(cfg.credential.password, "pass", "password should be extracted correctly") + assertEquals(cfg.targetHosts().size, 2, "should have 2 target hosts") + assertEquals(cfg.targetHosts().first(), "us-west-1.aws") + assertEquals(cfg.targetHosts()[1], "aws") + assertFalse(cfg.enableBoost(), "boost should default to false") + assertTrue(cfg.extraParams().isNotEmpty(), "should have extra params") + assertTrue(cfg.extraParams().contains("someParam"), "unrecognized param should be in `someParams`") + assertEquals(cfg.extraParams()["someParam"], "hi", "`someParam` should be set to `hi`") + } +} diff --git a/subprojects/driver/api/driver.api b/subprojects/driver/api/driver.api new file mode 100644 index 0000000..e69de29 diff --git a/subprojects/driver/build.gradle.kts b/subprojects/driver/build.gradle.kts new file mode 100644 index 0000000..8677664 --- /dev/null +++ b/subprojects/driver/build.gradle.kts @@ -0,0 +1,16 @@ +import PlanetscaleBuild.publishable + +plugins { + id("common-conventions.kotlin") + id("planetscale-publishable.klib") +} + +dependencies { + api(projects.subprojects.coreApi) + implementation(projects.subprojects.implMysqlj) +} + +publishable( + name = PlanetscaleBuild.Library.DRIVER, + description = "Planetscale JDBC meta-driver", +) diff --git a/subprojects/driver/gradle.lockfile b/subprojects/driver/gradle.lockfile new file mode 100644 index 0000000..496aa7c --- /dev/null +++ b/subprojects/driver/gradle.lockfile @@ -0,0 +1,9 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +com.google.protobuf:protobuf-java:3.21.9=runtimeClasspath +com.mysql:mysql-connector-j:8.2.0=runtimeClasspath +org.jetbrains.kotlin:kotlin-stdlib:1.9.20=compileClasspath,runtimeClasspath +org.jetbrains:annotations:13.0=compileClasspath,runtimeClasspath +org.slf4j:slf4j-api:2.0.9=compileClasspath,runtimeClasspath +empty= diff --git a/subprojects/impl-h2/build.gradle.kts b/subprojects/impl-h2/build.gradle.kts new file mode 100644 index 0000000..e8c5bbd --- /dev/null +++ b/subprojects/impl-h2/build.gradle.kts @@ -0,0 +1,18 @@ +import PlanetscaleBuild.baseline + +plugins { + id("common-conventions.kotlin") + id("planetscale-connector.klib") +} + +// Baseline (non-publishable) project settings +baseline() + +dependencies { + api(projects.subprojects.coreApi) + implementation(libs.bundles.h2) +} + +kotlin { + compilerOptions.moduleName = "planetscale.connector.inmemory" +} diff --git a/subprojects/impl-h2/gradle.lockfile b/subprojects/impl-h2/gradle.lockfile new file mode 100644 index 0000000..22bbebf --- /dev/null +++ b/subprojects/impl-h2/gradle.lockfile @@ -0,0 +1,8 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +com.h2database:h2:2.2.224=compileClasspath,runtimeClasspath +org.jetbrains.kotlin:kotlin-stdlib:1.9.20=compileClasspath,runtimeClasspath +org.jetbrains:annotations:13.0=compileClasspath,runtimeClasspath +org.slf4j:slf4j-api:2.0.9=compileClasspath,runtimeClasspath +empty= diff --git a/subprojects/impl-h2/src/main/jvm/com/planetscale/jvm/h2/PlanetscaleH2Driver.kt b/subprojects/impl-h2/src/main/jvm/com/planetscale/jvm/h2/PlanetscaleH2Driver.kt new file mode 100644 index 0000000..e60fd26 --- /dev/null +++ b/subprojects/impl-h2/src/main/jvm/com/planetscale/jvm/h2/PlanetscaleH2Driver.kt @@ -0,0 +1,35 @@ +package com.planetscale.jvm.h2 + +import com.planetscale.jvm.PlanetscaleConfig +import com.planetscale.jvm.driver.AbstractPlanetscaleAdapter +import com.planetscale.jvm.driver.Constants +import java.net.URI +import java.sql.Connection +import java.sql.Driver +import java.sql.DriverManager +import java.sql.DriverPropertyInfo +import java.util.* +import java.util.logging.Logger + +/** + * TBD. + */ +public class PlanetscaleH2Driver : AbstractPlanetscaleAdapter() { + private companion object { + private const val H2_DRIVER = "org.h2.Driver" + } + + override fun PlanetscaleConfig.toURI(): URI { + return URI.create( + "jdbc:h2:mem:${credential.database};MODE=MySQL;DATABASE_TO_LOWER=TRUE;CASE_INSENSITIVE_IDENTIFIERS=TRUE;" + ) + } + + override fun createDriver(): Driver { + return DriverManager.drivers().filter { + it.javaClass.canonicalName == H2_DRIVER + }.findFirst().orElse(null) ?: error( + "Failed to resolve H2 driver: check your classpath?" + ) + } +} diff --git a/subprojects/impl-h2/src/main/jvm/module-info.java b/subprojects/impl-h2/src/main/jvm/module-info.java new file mode 100644 index 0000000..191a8ee --- /dev/null +++ b/subprojects/impl-h2/src/main/jvm/module-info.java @@ -0,0 +1,9 @@ +/** + * Planetscale/J: H2-based implementation. + */ +module planetscale.connector.inmemory { + requires java.base; + requires java.sql; + requires kotlin.stdlib; + requires planetscale.connector; +} diff --git a/subprojects/impl-h2/src/main/resources/META-INF/native-image/proxy-config.json b/subprojects/impl-h2/src/main/resources/META-INF/native-image/proxy-config.json new file mode 100644 index 0000000..fbfaf87 --- /dev/null +++ b/subprojects/impl-h2/src/main/resources/META-INF/native-image/proxy-config.json @@ -0,0 +1,5 @@ +[ + { + "interfaces":["java.sql.Connection"] + } +] \ No newline at end of file diff --git a/subprojects/impl-h2/src/main/resources/META-INF/native-image/reflect-config.json b/subprojects/impl-h2/src/main/resources/META-INF/native-image/reflect-config.json new file mode 100644 index 0000000..99e9a90 --- /dev/null +++ b/subprojects/impl-h2/src/main/resources/META-INF/native-image/reflect-config.json @@ -0,0 +1,5 @@ +[ + { + "name":"com.planetscale.Driver" + } +] \ No newline at end of file diff --git a/subprojects/impl-h2/src/main/resources/META-INF/native-image/resource-config.json b/subprojects/impl-h2/src/main/resources/META-INF/native-image/resource-config.json new file mode 100644 index 0000000..a271675 --- /dev/null +++ b/subprojects/impl-h2/src/main/resources/META-INF/native-image/resource-config.json @@ -0,0 +1,12 @@ +{ + "resources": { + "includes": [ + { + "pattern": "\\QMETA-INF/services/java.sql.Driver\\E" + }, + { + "pattern": "\\QMETA-INF/services/com.planetscale.jvm.PlanetscaleAdapter\\E" + } + ] + } +} \ No newline at end of file diff --git a/subprojects/impl-h2/src/main/resources/META-INF/services/com.planetscale.jvm.PlanetscaleAdapter b/subprojects/impl-h2/src/main/resources/META-INF/services/com.planetscale.jvm.PlanetscaleAdapter new file mode 100644 index 0000000..a6a0a7c --- /dev/null +++ b/subprojects/impl-h2/src/main/resources/META-INF/services/com.planetscale.jvm.PlanetscaleAdapter @@ -0,0 +1 @@ +com.planetscale.jvm.h2.PlanetscaleH2Driver diff --git a/subprojects/impl-mysqlj/api/impl-mysqlj.api b/subprojects/impl-mysqlj/api/impl-mysqlj.api new file mode 100644 index 0000000..c7d9ef0 --- /dev/null +++ b/subprojects/impl-mysqlj/api/impl-mysqlj.api @@ -0,0 +1,20 @@ +public final class com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriver : com/planetscale/jvm/driver/AbstractPlanetscaleAdapter { + public static final field Companion Lcom/planetscale/jvm/mysqlj/PlanetscaleMysqlDriver$Companion; + public fun ()V + public static final fun awsEndpoint (Ljava/lang/String;)Ljava/lang/String; + public static final fun detectProvider ()Lcom/planetscale/jvm/driver/CloudProvider; + public static final fun gcpEndpoint (Ljava/lang/String;)Ljava/lang/String; + public static final fun qualifiedEndpoint (Ljava/lang/String;)Ljava/lang/String; + public static final fun resolveHostSymbols (Ljava/lang/String;)Ljava/lang/String; +} + +public final class com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriver$Companion { + public final fun awsEndpoint (Ljava/lang/String;)Ljava/lang/String; + public static synthetic fun awsEndpoint$default (Lcom/planetscale/jvm/mysqlj/PlanetscaleMysqlDriver$Companion;Ljava/lang/String;ILjava/lang/Object;)Ljava/lang/String; + public final fun detectProvider ()Lcom/planetscale/jvm/driver/CloudProvider; + public final fun gcpEndpoint (Ljava/lang/String;)Ljava/lang/String; + public static synthetic fun gcpEndpoint$default (Lcom/planetscale/jvm/mysqlj/PlanetscaleMysqlDriver$Companion;Ljava/lang/String;ILjava/lang/Object;)Ljava/lang/String; + public final fun qualifiedEndpoint (Ljava/lang/String;)Ljava/lang/String; + public final fun resolveHostSymbols (Ljava/lang/String;)Ljava/lang/String; +} + diff --git a/subprojects/impl-mysqlj/build.gradle.kts b/subprojects/impl-mysqlj/build.gradle.kts new file mode 100644 index 0000000..61f7f4c --- /dev/null +++ b/subprojects/impl-mysqlj/build.gradle.kts @@ -0,0 +1,21 @@ +import PlanetscaleBuild.publishable + +plugins { + id("common-conventions.kotlin") + id("planetscale-publishable.klib") + id("planetscale-connector.klib") +} + +dependencies { + api(projects.subprojects.coreApi) + implementation(libs.bundles.mysql) +} + +kotlin { + compilerOptions.moduleName = "planetscale.connector.mysqlj" +} + +publishable( + name = PlanetscaleBuild.Library.Implementations.MYSQLJ, + description = "Planetscale driver MySQL/J implementation (internal)", +) diff --git a/subprojects/impl-mysqlj/gradle.lockfile b/subprojects/impl-mysqlj/gradle.lockfile new file mode 100644 index 0000000..82918d5 --- /dev/null +++ b/subprojects/impl-mysqlj/gradle.lockfile @@ -0,0 +1,9 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +com.google.protobuf:protobuf-java:3.21.9=compileClasspath,runtimeClasspath +com.mysql:mysql-connector-j:8.2.0=compileClasspath,runtimeClasspath +org.jetbrains.kotlin:kotlin-stdlib:1.9.20=compileClasspath,runtimeClasspath +org.jetbrains:annotations:13.0=compileClasspath,runtimeClasspath +org.slf4j:slf4j-api:2.0.9=compileClasspath,runtimeClasspath +empty= diff --git a/subprojects/impl-mysqlj/src/main/jvm/com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriver.kt b/subprojects/impl-mysqlj/src/main/jvm/com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriver.kt new file mode 100644 index 0000000..6cf5502 --- /dev/null +++ b/subprojects/impl-mysqlj/src/main/jvm/com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriver.kt @@ -0,0 +1,147 @@ +package com.planetscale.jvm.mysqlj + +import com.planetscale.jvm.PlanetscaleConfig +import com.planetscale.jvm.PlanetscaleCredential +import com.planetscale.jvm.PlanetscaleParameter +import com.planetscale.jvm.driver.AbstractPlanetscaleAdapter +import com.planetscale.jvm.driver.CloudProvider +import com.planetscale.jvm.driver.Constants +import java.net.URI +import java.sql.Driver +import java.sql.DriverManager + +/** + * TBD. + */ +public class PlanetscaleMysqlDriver : AbstractPlanetscaleAdapter() { + public companion object { + private val defaultParams = mapOf( + Constants.DriverParams.AUTO_RECONNECT to Constants.StringValue.TRUE, + Constants.DriverParams.CACHE_SERVER_CONFIG to Constants.StringValue.TRUE, + Constants.DriverParams.CACHE_RESULT_SET_METADATA to Constants.StringValue.TRUE, + Constants.DriverParams.ROUND_ROBIN_LOAD_BALANCE to Constants.StringValue.TRUE, + Constants.DriverParams.SSL_MODE to Constants.DriverParams.SSL_MODE_VERIFY, + ) + + // Return a qualified Planetscale endpoint. + @JvmStatic public fun qualifiedEndpoint(qualifier: String): String = "$qualifier.${Constants.CONNECT_DOMAIN}" + + // Return a qualified Planetscale endpoint for AWS. + @JvmStatic public fun awsEndpoint(qualifier: String? = null): String = when (qualifier?.ifBlank { null }) { + null -> qualifiedEndpoint(Constants.Provider.AWS) + else -> qualifiedEndpoint("$qualifier.${Constants.Provider.AWS}") + } + + // Return a qualified Planetscale endpoint for GCP. + @JvmStatic public fun gcpEndpoint(qualifier: String? = null): String = when (qualifier?.ifBlank { null }) { + null -> qualifiedEndpoint(Constants.Provider.GCP) + else -> qualifiedEndpoint("$qualifier.${Constants.Provider.GCP}") + } + + // Resolve the active cloud provider, if any. + @JvmStatic public fun detectProvider(): CloudProvider? { + return listOf( + Constants.Provider.GCP_CREDS_VAR to CloudProvider.GCP, + Constants.Provider.AWS_CREDS_VAR to CloudProvider.AWS, + ).firstOrNull { + System.getenv(it.first) != null + }?.second + } + + // Resolve symbolic host names to their actual targets. + @JvmStatic public fun resolveHostSymbols(target: String): String { + // safeguard: if it contains more than one period, it's a hostname + return if (target.count { it == '.' } > 1) target else when (target) { + // covers literal `aws` + Constants.SymbolicHosts.AWS -> awsEndpoint() + + // covers literal `gcp` + Constants.SymbolicHosts.GCP -> gcpEndpoint() + + else -> when { + // covers `.aws` + target.endsWith(Constants.SymbolicHosts.AWS) -> awsEndpoint( + target.removeSuffix(Constants.SymbolicHosts.AWS).dropLast(1) + ) + + // covers `.gcp` + target.endsWith(Constants.SymbolicHosts.GCP) -> gcpEndpoint( + target.removeSuffix(Constants.SymbolicHosts.GCP).dropLast(1) + ) + + // otherwise, we don't recognize it, and it should be preserved + else -> target + } + } + } + } + + private fun PlanetscaleCredential.toUriInfo(): StringBuilder = StringBuilder().apply { + append(username) + append(":") + append(password) + } + + private fun StringBuilder.appendHost(host: String) { + append(host) + append(":") + append(Constants.MYSQL_PORT) + } + + private fun PlanetscaleConfig.endpoints(): StringBuilder = StringBuilder().apply { + if (multiHost()) { + append(targetHosts().map { + StringBuilder().appendHost(resolveHostSymbols(it)) + }.joinToString(",")) + } else { + appendHost(targetHosts().first()) + } + } + + private fun PlanetscaleConfig.sessionVariables(): List>? { + return if (!enableBoost()) null else listOf( + PlanetscaleParameter.EnableBoost.option.paramName to Constants.StringValue.TRUE, + ) + } + + private fun PlanetscaleConfig.driverParameters(): List> { + return defaultParams.plus(extraParams().mapNotNull { + if (it.value.isNullOrEmpty() || it.value.isBlank()) { + null + } else { + it.key to it.value + } + }).toSortedMap().toList().plus(when (val sessionVariables = sessionVariables()) { + null -> emptyList() + else -> listOf( + Constants.DriverParams.SESSION_VARIABLES to + sessionVariables.joinToString(separator = ",") { (k, v) -> "$k=$v" } + ) + }) + } + + override fun PlanetscaleConfig.toURI(): URI { + return URI.create(StringBuilder().apply { + append(Constants.Prefix.MYSQL) + if (multiHost()) append(Constants.Prefix.REPLICATION) + append("//") + append(credential.toUriInfo()) + append("@") + append(endpoints()) + append("/") + append(credential.database) + append("?") + driverParameters().joinToString("&") { (k, v) -> + append(k) + append("=") + append(v) + } + }.toString()) + } + + override fun createDriver(): Driver = DriverManager.drivers().filter { + it.javaClass.canonicalName == Constants.MYSQL_DRIVER + }.findFirst().orElse(null) ?: error( + "Failed to resolve MySQL driver: check your classpath?" + ) +} diff --git a/subprojects/impl-mysqlj/src/main/jvm/module-info.java b/subprojects/impl-mysqlj/src/main/jvm/module-info.java new file mode 100644 index 0000000..33c05ed --- /dev/null +++ b/subprojects/impl-mysqlj/src/main/jvm/module-info.java @@ -0,0 +1,9 @@ +/** + * Planetscale/J: MySQL-based implementation. + */ +module planetscale.connector.mysqlj { + requires java.base; + requires java.sql; + requires kotlin.stdlib; + requires planetscale.connector; +} diff --git a/subprojects/impl-mysqlj/src/main/resources/META-INF/services/com.planetscale.jvm.PlanetscaleAdapter b/subprojects/impl-mysqlj/src/main/resources/META-INF/services/com.planetscale.jvm.PlanetscaleAdapter new file mode 100644 index 0000000..d9b37a5 --- /dev/null +++ b/subprojects/impl-mysqlj/src/main/resources/META-INF/services/com.planetscale.jvm.PlanetscaleAdapter @@ -0,0 +1 @@ +com.planetscale.jvm.mysqlj.PlanetscaleMysqlDriver diff --git a/subprojects/impl-mysqlj/src/test/kotlin/com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriverTest.kt b/subprojects/impl-mysqlj/src/test/kotlin/com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriverTest.kt new file mode 100644 index 0000000..76cd8c7 --- /dev/null +++ b/subprojects/impl-mysqlj/src/test/kotlin/com/planetscale/jvm/mysqlj/PlanetscaleMysqlDriverTest.kt @@ -0,0 +1,57 @@ +package com.planetscale.jvm.mysqlj + +import org.junit.jupiter.api.assertDoesNotThrow +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotNull + +/** Tests for the MySQL/J connector for the Planetscale driver. */ +class PlanetscaleMysqlDriverTest { + @Test fun testObtain() { + assertDoesNotThrow { PlanetscaleMysqlDriver() } + } + + @Test fun testAwsEndpoint() { + assertEquals("aws.connect.psdb.cloud", PlanetscaleMysqlDriver.awsEndpoint()) + assertEquals("example.aws.connect.psdb.cloud", PlanetscaleMysqlDriver.awsEndpoint("example")) + } + + @Test fun testGcpEndpoint() { + assertEquals("gcp.connect.psdb.cloud", PlanetscaleMysqlDriver.gcpEndpoint()) + assertEquals("example.gcp.connect.psdb.cloud", PlanetscaleMysqlDriver.gcpEndpoint("example")) + } + + @Test fun testDetectProvider(): Unit = assertDoesNotThrow { + PlanetscaleMysqlDriver.detectProvider() + } + + @Test fun testResolveHostSymbolAws() { + assertNotNull(PlanetscaleMysqlDriver.resolveHostSymbols("aws")) + assertEquals("aws.connect.psdb.cloud", PlanetscaleMysqlDriver.resolveHostSymbols("aws")) + assertNotNull(PlanetscaleMysqlDriver.resolveHostSymbols("us-west-1.aws")) + assertEquals( + "example.aws.connect.psdb.cloud", + PlanetscaleMysqlDriver.resolveHostSymbols("example.aws"), + ) + } + + @Test fun testResolveHostSymbolsGcp() { + assertNotNull(PlanetscaleMysqlDriver.resolveHostSymbols("gcp")) + assertEquals("gcp.connect.psdb.cloud", PlanetscaleMysqlDriver.resolveHostSymbols("gcp")) + assertNotNull(PlanetscaleMysqlDriver.resolveHostSymbols("us-west-1.gcp")) + assertEquals( + "example.gcp.connect.psdb.cloud", + PlanetscaleMysqlDriver.resolveHostSymbols("example.gcp"), + ) + } + + @Test fun testResolveHostSymbolsCustom() { + assertNotNull( + PlanetscaleMysqlDriver.resolveHostSymbols("something-custom.com") + ) + assertEquals( + "something-custom.com", + PlanetscaleMysqlDriver.resolveHostSymbols("something-custom.com"), + ) + } +} diff --git a/subprojects/integration-graalvm/api/integration-graalvm.api b/subprojects/integration-graalvm/api/integration-graalvm.api new file mode 100644 index 0000000..574472c --- /dev/null +++ b/subprojects/integration-graalvm/api/integration-graalvm.api @@ -0,0 +1,4 @@ +public final class com/planetscale/PlanetscaleFeature { + public fun ()V +} + diff --git a/subprojects/integration-graalvm/build.gradle.kts b/subprojects/integration-graalvm/build.gradle.kts new file mode 100644 index 0000000..052e33f --- /dev/null +++ b/subprojects/integration-graalvm/build.gradle.kts @@ -0,0 +1,21 @@ +import PlanetscaleBuild.publishable + +plugins { + id("common-conventions.kotlin") + id("planetscale-publishable.klib") + id("planetscale-connector.klib") + alias(libs.plugins.micronaut.library) +} + +dependencies { + api(projects.subprojects.coreApi) +} + +kotlin { + compilerOptions.moduleName = "planetscale.graalvm" +} + +publishable( + name = PlanetscaleBuild.Library.Integrations.GRAALVM, + description = "Planetscale/GraalVM integration library", +) diff --git a/subprojects/integration-graalvm/gradle.lockfile b/subprojects/integration-graalvm/gradle.lockfile new file mode 100644 index 0000000..8a77958 --- /dev/null +++ b/subprojects/integration-graalvm/gradle.lockfile @@ -0,0 +1,101 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +com.amazonaws:aws-java-sdk-bom:1.12.566=compileClasspath,runtimeClasspath +com.azure:azure-sdk-bom:1.2.14=compileClasspath,runtimeClasspath +com.fasterxml.jackson:jackson-bom:2.15.2=compileClasspath,runtimeClasspath +com.google.protobuf:protobuf-bom:3.23.4=compileClasspath,runtimeClasspath +com.oracle.coherence.ce:coherence-bom:23.03=compileClasspath,runtimeClasspath +io.grpc:grpc-bom:1.56.1=compileClasspath,runtimeClasspath +io.ktor:ktor-bom:2.3.4=compileClasspath,runtimeClasspath +io.micrometer:micrometer-bom:1.11.1=compileClasspath,runtimeClasspath +io.micronaut.acme:micronaut-acme-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.aot:micronaut-aot-bom:2.1.1=compileClasspath,runtimeClasspath +io.micronaut.aws:micronaut-aws-bom:4.0.7=compileClasspath,runtimeClasspath +io.micronaut.azure:micronaut-azure-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.beanvalidation:micronaut-hibernate-validator-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.cache:micronaut-cache-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.cassandra:micronaut-cassandra-bom:6.0.2=compileClasspath,runtimeClasspath +io.micronaut.chatbots:micronaut-chatbots-bom:2.0.0-M6=compileClasspath,runtimeClasspath +io.micronaut.coherence:micronaut-coherence-bom:4.0.0=compileClasspath,runtimeClasspath +io.micronaut.controlpanel:micronaut-control-panel-bom:1.0.1=compileClasspath,runtimeClasspath +io.micronaut.crac:micronaut-crac-bom:2.0.3=compileClasspath,runtimeClasspath +io.micronaut.data:micronaut-data-bom:4.1.4=compileClasspath,runtimeClasspath +io.micronaut.discovery:micronaut-discovery-client-bom:4.0.3=compileClasspath,runtimeClasspath +io.micronaut.elasticsearch:micronaut-elasticsearch-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.email:micronaut-email-bom:2.2.1=compileClasspath,runtimeClasspath +io.micronaut.flyway:micronaut-flyway-bom:6.1.0=compileClasspath,runtimeClasspath +io.micronaut.gcp:micronaut-gcp-bom:5.0.4=compileClasspath,runtimeClasspath +io.micronaut.graphql:micronaut-graphql-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.groovy:micronaut-groovy-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.grpc:micronaut-grpc-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.jaxrs:micronaut-jaxrs-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.jms:micronaut-jms-bom:3.0.1=compileClasspath,runtimeClasspath +io.micronaut.jmx:micronaut-jmx-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.kafka:micronaut-kafka-bom:5.1.2=compileClasspath,runtimeClasspath +io.micronaut.kotlin:micronaut-kotlin-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.kubernetes:micronaut-kubernetes-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.liquibase:micronaut-liquibase-bom:6.0.2=compileClasspath,runtimeClasspath +io.micronaut.logging:micronaut-logging-bom:1.1.2=compileClasspath,runtimeClasspath +io.micronaut.micrometer:micronaut-micrometer-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.microstream:micronaut-microstream-bom:2.0.2=compileClasspath,runtimeClasspath +io.micronaut.mongodb:micronaut-mongo-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.mqtt:micronaut-mqtt-bom:3.0.2=compileClasspath,runtimeClasspath +io.micronaut.multitenancy:micronaut-multitenancy-bom:5.0.3=compileClasspath,runtimeClasspath +io.micronaut.nats:micronaut-nats-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.neo4j:micronaut-neo4j-bom:6.1.0=compileClasspath,runtimeClasspath +io.micronaut.objectstorage:micronaut-object-storage-bom:2.0.4=compileClasspath,runtimeClasspath +io.micronaut.openapi:micronaut-openapi-bom:5.1.1=compileClasspath,runtimeClasspath +io.micronaut.oraclecloud:micronaut-oraclecloud-bom:3.0.6=compileClasspath,runtimeClasspath +io.micronaut.picocli:micronaut-picocli-bom:5.0.2=compileClasspath,runtimeClasspath +io.micronaut.platform:micronaut-platform:4.1.6=compileClasspath,runtimeClasspath +io.micronaut.problem:micronaut-problem-json-bom:3.0.2=compileClasspath,runtimeClasspath +io.micronaut.pulsar:micronaut-pulsar-bom:2.0.1=compileClasspath,runtimeClasspath +io.micronaut.r2dbc:micronaut-r2dbc-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.rabbitmq:micronaut-rabbitmq-bom:4.1.0=compileClasspath,runtimeClasspath +io.micronaut.reactor:micronaut-reactor-bom:3.0.5=compileClasspath,runtimeClasspath +io.micronaut.redis:micronaut-redis-bom:6.0.2=compileClasspath,runtimeClasspath +io.micronaut.rss:micronaut-rss-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.rxjava2:micronaut-rxjava2-bom:2.0.1=compileClasspath,runtimeClasspath +io.micronaut.rxjava3:micronaut-rxjava3-bom:3.0.2=compileClasspath,runtimeClasspath +io.micronaut.security:micronaut-security-bom:4.1.0=compileClasspath,runtimeClasspath +io.micronaut.serde:micronaut-serde-bom:2.2.6=compileClasspath,runtimeClasspath +io.micronaut.servlet:micronaut-servlet-bom:4.1.1=compileClasspath,runtimeClasspath +io.micronaut.session:micronaut-session-bom:4.0.0=compileClasspath,runtimeClasspath +io.micronaut.spring:micronaut-spring-bom:5.0.2=compileClasspath,runtimeClasspath +io.micronaut.sql:micronaut-sql-bom:5.0.3=compileClasspath,runtimeClasspath +io.micronaut.test:micronaut-test-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.testresources:micronaut-test-resources-bom:2.0.0=compileClasspath,runtimeClasspath +io.micronaut.toml:micronaut-toml-bom:2.0.1=compileClasspath,runtimeClasspath +io.micronaut.tracing:micronaut-tracing-bom:5.0.2=compileClasspath,runtimeClasspath +io.micronaut.validation:micronaut-validation-bom:4.0.3=compileClasspath,runtimeClasspath +io.micronaut.views:micronaut-views-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.xml:micronaut-jackson-xml-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut:micronaut-core-bom:4.1.11=compileClasspath,runtimeClasspath +io.micronaut:micronaut-core:4.1.11=compileClasspath,runtimeClasspath +io.micronaut:micronaut-inject:4.1.11=compileClasspath,runtimeClasspath +io.netty:netty-bom:4.1.100.Final=compileClasspath,runtimeClasspath +io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom-alpha:1.26.0-alpha=compileClasspath,runtimeClasspath +io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom:1.26.0=compileClasspath,runtimeClasspath +io.opentelemetry:opentelemetry-bom-alpha:1.26.0-alpha=compileClasspath,runtimeClasspath +io.opentelemetry:opentelemetry-bom:1.26.0=compileClasspath,runtimeClasspath +io.projectreactor:reactor-bom:2022.0.12=compileClasspath,runtimeClasspath +io.rest-assured:rest-assured-bom:5.3.2=compileClasspath,runtimeClasspath +io.zipkin.brave:brave-bom:5.16.0=compileClasspath,runtimeClasspath +io.zipkin.reporter2:zipkin-reporter-bom:2.16.4=compileClasspath,runtimeClasspath +jakarta.annotation:jakarta.annotation-api:2.1.1=compileClasspath,runtimeClasspath +jakarta.inject:jakarta.inject-api:2.0.1=compileClasspath,runtimeClasspath +org.apache.groovy:groovy-bom:4.0.14=compileClasspath,runtimeClasspath +org.apache.logging.log4j:log4j-bom:2.20.0=compileClasspath,runtimeClasspath +org.jdbi:jdbi3-bom:3.39.1=compileClasspath,runtimeClasspath +org.jetbrains.kotlin:kotlin-bom:1.8.21=compileClasspath,runtimeClasspath +org.jetbrains.kotlin:kotlin-stdlib:1.9.20=compileClasspath,runtimeClasspath +org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.7.3=compileClasspath,runtimeClasspath +org.jetbrains:annotations:13.0=compileClasspath,runtimeClasspath +org.junit:junit-bom:5.9.3=compileClasspath,runtimeClasspath +org.slf4j:slf4j-api:2.0.9=compileClasspath,runtimeClasspath +org.spockframework:spock-bom:2.3-groovy-4.0=compileClasspath,runtimeClasspath +org.springframework:spring-framework-bom:6.0.11=compileClasspath,runtimeClasspath +org.testcontainers:testcontainers-bom:1.19.1=compileClasspath,runtimeClasspath +software.amazon.awssdk:bom:2.20.162=compileClasspath,runtimeClasspath +empty= diff --git a/subprojects/integration-graalvm/src/main/jvm/com/planetscale/PlanetscaleFeature.kt b/subprojects/integration-graalvm/src/main/jvm/com/planetscale/PlanetscaleFeature.kt new file mode 100644 index 0000000..ed8adea --- /dev/null +++ b/subprojects/integration-graalvm/src/main/jvm/com/planetscale/PlanetscaleFeature.kt @@ -0,0 +1,8 @@ +package com.planetscale + +/** + * TBD. + */ +public class PlanetscaleFeature { + // Nothing yet +} diff --git a/subprojects/integration-kotlin/api/integration-kotlin.api b/subprojects/integration-kotlin/api/integration-kotlin.api new file mode 100644 index 0000000..e69de29 diff --git a/subprojects/integration-kotlin/build.gradle.kts b/subprojects/integration-kotlin/build.gradle.kts new file mode 100644 index 0000000..0492d3d --- /dev/null +++ b/subprojects/integration-kotlin/build.gradle.kts @@ -0,0 +1,21 @@ +import PlanetscaleBuild.publishable + +plugins { + id("common-conventions.kotlin") + id("planetscale-publishable.klib") + id("planetscale-connector.klib") + alias(libs.plugins.ksp) +} + +dependencies { + api(projects.subprojects.coreApi) +} + +kotlin { + compilerOptions.moduleName = "planetscale.kotlin" +} + +publishable( + name = PlanetscaleBuild.Library.Integrations.KOTLIN, + description = "Planetscale/Kotlin integration library", +) diff --git a/subprojects/integration-kotlin/gradle.lockfile b/subprojects/integration-kotlin/gradle.lockfile new file mode 100644 index 0000000..e3b842c --- /dev/null +++ b/subprojects/integration-kotlin/gradle.lockfile @@ -0,0 +1,7 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +org.jetbrains.kotlin:kotlin-stdlib:1.9.20=compileClasspath,runtimeClasspath +org.jetbrains:annotations:13.0=compileClasspath,runtimeClasspath +org.slf4j:slf4j-api:2.0.9=compileClasspath,runtimeClasspath +empty= diff --git a/subprojects/integration-micronaut/api/integration-micronaut.api b/subprojects/integration-micronaut/api/integration-micronaut.api new file mode 100644 index 0000000..e69de29 diff --git a/subprojects/integration-micronaut/build.gradle.kts b/subprojects/integration-micronaut/build.gradle.kts new file mode 100644 index 0000000..1e8f158 --- /dev/null +++ b/subprojects/integration-micronaut/build.gradle.kts @@ -0,0 +1,23 @@ +import PlanetscaleBuild.publishable + +plugins { + id("common-conventions.kotlin") + id("planetscale-publishable.klib") + id("planetscale-connector.klib") + alias(libs.plugins.ksp) + alias(libs.plugins.micronaut.library) +} + +dependencies { + api(projects.subprojects.coreApi) + ksp(mn.micronaut.inject.kotlin) +} + +kotlin { + compilerOptions.moduleName = "planetscale.micronaut" +} + +publishable( + name = PlanetscaleBuild.Library.Integrations.MICRONAUT, + description = "Planetscale/Micronaut integration library", +) diff --git a/subprojects/integration-micronaut/gradle.lockfile b/subprojects/integration-micronaut/gradle.lockfile new file mode 100644 index 0000000..8a77958 --- /dev/null +++ b/subprojects/integration-micronaut/gradle.lockfile @@ -0,0 +1,101 @@ +# This is a Gradle generated file for dependency locking. +# Manual edits can break the build and are not advised. +# This file is expected to be part of source control. +com.amazonaws:aws-java-sdk-bom:1.12.566=compileClasspath,runtimeClasspath +com.azure:azure-sdk-bom:1.2.14=compileClasspath,runtimeClasspath +com.fasterxml.jackson:jackson-bom:2.15.2=compileClasspath,runtimeClasspath +com.google.protobuf:protobuf-bom:3.23.4=compileClasspath,runtimeClasspath +com.oracle.coherence.ce:coherence-bom:23.03=compileClasspath,runtimeClasspath +io.grpc:grpc-bom:1.56.1=compileClasspath,runtimeClasspath +io.ktor:ktor-bom:2.3.4=compileClasspath,runtimeClasspath +io.micrometer:micrometer-bom:1.11.1=compileClasspath,runtimeClasspath +io.micronaut.acme:micronaut-acme-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.aot:micronaut-aot-bom:2.1.1=compileClasspath,runtimeClasspath +io.micronaut.aws:micronaut-aws-bom:4.0.7=compileClasspath,runtimeClasspath +io.micronaut.azure:micronaut-azure-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.beanvalidation:micronaut-hibernate-validator-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.cache:micronaut-cache-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.cassandra:micronaut-cassandra-bom:6.0.2=compileClasspath,runtimeClasspath +io.micronaut.chatbots:micronaut-chatbots-bom:2.0.0-M6=compileClasspath,runtimeClasspath +io.micronaut.coherence:micronaut-coherence-bom:4.0.0=compileClasspath,runtimeClasspath +io.micronaut.controlpanel:micronaut-control-panel-bom:1.0.1=compileClasspath,runtimeClasspath +io.micronaut.crac:micronaut-crac-bom:2.0.3=compileClasspath,runtimeClasspath +io.micronaut.data:micronaut-data-bom:4.1.4=compileClasspath,runtimeClasspath +io.micronaut.discovery:micronaut-discovery-client-bom:4.0.3=compileClasspath,runtimeClasspath +io.micronaut.elasticsearch:micronaut-elasticsearch-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.email:micronaut-email-bom:2.2.1=compileClasspath,runtimeClasspath +io.micronaut.flyway:micronaut-flyway-bom:6.1.0=compileClasspath,runtimeClasspath +io.micronaut.gcp:micronaut-gcp-bom:5.0.4=compileClasspath,runtimeClasspath +io.micronaut.graphql:micronaut-graphql-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.groovy:micronaut-groovy-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.grpc:micronaut-grpc-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.jaxrs:micronaut-jaxrs-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.jms:micronaut-jms-bom:3.0.1=compileClasspath,runtimeClasspath +io.micronaut.jmx:micronaut-jmx-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.kafka:micronaut-kafka-bom:5.1.2=compileClasspath,runtimeClasspath +io.micronaut.kotlin:micronaut-kotlin-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.kubernetes:micronaut-kubernetes-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.liquibase:micronaut-liquibase-bom:6.0.2=compileClasspath,runtimeClasspath +io.micronaut.logging:micronaut-logging-bom:1.1.2=compileClasspath,runtimeClasspath +io.micronaut.micrometer:micronaut-micrometer-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.microstream:micronaut-microstream-bom:2.0.2=compileClasspath,runtimeClasspath +io.micronaut.mongodb:micronaut-mongo-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.mqtt:micronaut-mqtt-bom:3.0.2=compileClasspath,runtimeClasspath +io.micronaut.multitenancy:micronaut-multitenancy-bom:5.0.3=compileClasspath,runtimeClasspath +io.micronaut.nats:micronaut-nats-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.neo4j:micronaut-neo4j-bom:6.1.0=compileClasspath,runtimeClasspath +io.micronaut.objectstorage:micronaut-object-storage-bom:2.0.4=compileClasspath,runtimeClasspath +io.micronaut.openapi:micronaut-openapi-bom:5.1.1=compileClasspath,runtimeClasspath +io.micronaut.oraclecloud:micronaut-oraclecloud-bom:3.0.6=compileClasspath,runtimeClasspath +io.micronaut.picocli:micronaut-picocli-bom:5.0.2=compileClasspath,runtimeClasspath +io.micronaut.platform:micronaut-platform:4.1.6=compileClasspath,runtimeClasspath +io.micronaut.problem:micronaut-problem-json-bom:3.0.2=compileClasspath,runtimeClasspath +io.micronaut.pulsar:micronaut-pulsar-bom:2.0.1=compileClasspath,runtimeClasspath +io.micronaut.r2dbc:micronaut-r2dbc-bom:5.0.1=compileClasspath,runtimeClasspath +io.micronaut.rabbitmq:micronaut-rabbitmq-bom:4.1.0=compileClasspath,runtimeClasspath +io.micronaut.reactor:micronaut-reactor-bom:3.0.5=compileClasspath,runtimeClasspath +io.micronaut.redis:micronaut-redis-bom:6.0.2=compileClasspath,runtimeClasspath +io.micronaut.rss:micronaut-rss-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.rxjava2:micronaut-rxjava2-bom:2.0.1=compileClasspath,runtimeClasspath +io.micronaut.rxjava3:micronaut-rxjava3-bom:3.0.2=compileClasspath,runtimeClasspath +io.micronaut.security:micronaut-security-bom:4.1.0=compileClasspath,runtimeClasspath +io.micronaut.serde:micronaut-serde-bom:2.2.6=compileClasspath,runtimeClasspath +io.micronaut.servlet:micronaut-servlet-bom:4.1.1=compileClasspath,runtimeClasspath +io.micronaut.session:micronaut-session-bom:4.0.0=compileClasspath,runtimeClasspath +io.micronaut.spring:micronaut-spring-bom:5.0.2=compileClasspath,runtimeClasspath +io.micronaut.sql:micronaut-sql-bom:5.0.3=compileClasspath,runtimeClasspath +io.micronaut.test:micronaut-test-bom:4.0.2=compileClasspath,runtimeClasspath +io.micronaut.testresources:micronaut-test-resources-bom:2.0.0=compileClasspath,runtimeClasspath +io.micronaut.toml:micronaut-toml-bom:2.0.1=compileClasspath,runtimeClasspath +io.micronaut.tracing:micronaut-tracing-bom:5.0.2=compileClasspath,runtimeClasspath +io.micronaut.validation:micronaut-validation-bom:4.0.3=compileClasspath,runtimeClasspath +io.micronaut.views:micronaut-views-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut.xml:micronaut-jackson-xml-bom:4.0.1=compileClasspath,runtimeClasspath +io.micronaut:micronaut-core-bom:4.1.11=compileClasspath,runtimeClasspath +io.micronaut:micronaut-core:4.1.11=compileClasspath,runtimeClasspath +io.micronaut:micronaut-inject:4.1.11=compileClasspath,runtimeClasspath +io.netty:netty-bom:4.1.100.Final=compileClasspath,runtimeClasspath +io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom-alpha:1.26.0-alpha=compileClasspath,runtimeClasspath +io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom:1.26.0=compileClasspath,runtimeClasspath +io.opentelemetry:opentelemetry-bom-alpha:1.26.0-alpha=compileClasspath,runtimeClasspath +io.opentelemetry:opentelemetry-bom:1.26.0=compileClasspath,runtimeClasspath +io.projectreactor:reactor-bom:2022.0.12=compileClasspath,runtimeClasspath +io.rest-assured:rest-assured-bom:5.3.2=compileClasspath,runtimeClasspath +io.zipkin.brave:brave-bom:5.16.0=compileClasspath,runtimeClasspath +io.zipkin.reporter2:zipkin-reporter-bom:2.16.4=compileClasspath,runtimeClasspath +jakarta.annotation:jakarta.annotation-api:2.1.1=compileClasspath,runtimeClasspath +jakarta.inject:jakarta.inject-api:2.0.1=compileClasspath,runtimeClasspath +org.apache.groovy:groovy-bom:4.0.14=compileClasspath,runtimeClasspath +org.apache.logging.log4j:log4j-bom:2.20.0=compileClasspath,runtimeClasspath +org.jdbi:jdbi3-bom:3.39.1=compileClasspath,runtimeClasspath +org.jetbrains.kotlin:kotlin-bom:1.8.21=compileClasspath,runtimeClasspath +org.jetbrains.kotlin:kotlin-stdlib:1.9.20=compileClasspath,runtimeClasspath +org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.7.3=compileClasspath,runtimeClasspath +org.jetbrains:annotations:13.0=compileClasspath,runtimeClasspath +org.junit:junit-bom:5.9.3=compileClasspath,runtimeClasspath +org.slf4j:slf4j-api:2.0.9=compileClasspath,runtimeClasspath +org.spockframework:spock-bom:2.3-groovy-4.0=compileClasspath,runtimeClasspath +org.springframework:spring-framework-bom:6.0.11=compileClasspath,runtimeClasspath +org.testcontainers:testcontainers-bom:1.19.1=compileClasspath,runtimeClasspath +software.amazon.awssdk:bom:2.20.162=compileClasspath,runtimeClasspath +empty=