From f9ce24841665ba7d22e0d12a63b6568e0a0c08cf Mon Sep 17 00:00:00 2001
From: sergiyvamz <75754709+sergiyvamz@users.noreply.github.com>
Date: Wed, 11 Dec 2024 17:54:17 -0800
Subject: [PATCH] feat: Configuration profiles (#338)

---
 .../authentication/aws_credentials_manager.ts |  31 +-
 common/lib/aws_client.ts                      |  50 ++-
 common/lib/connection_plugin_chain_builder.ts | 107 +++--
 .../database_dialect_manager.ts               |  41 +-
 common/lib/plugin_manager.ts                  |  10 +-
 common/lib/plugin_service.ts                  |   3 +-
 common/lib/profile/configuration_profile.ts   | 130 ++++++
 .../profile/configuration_profile_builder.ts  | 115 +++++
 .../profile/configuration_profile_codes.ts    |  38 ++
 .../profile/driver_configuration_profiles.ts  | 416 ++++++++++++++++++
 common/lib/utils/locales/en.json              |  13 +-
 common/lib/wrapper_property.ts                |  21 +-
 docs/files/configuration-profile-presets.pdf  | Bin 0 -> 141176 bytes
 docs/images/configuration-presets.png         | Bin 0 -> 135055 bytes
 .../ConfigurationPresets.md                   |  50 +++
 .../DatabaseDialects.md                       |  12 +-
 .../UsingTheNodejsWrapper.md                  |  88 +++-
 .../AwsCredentialsConfiguration.md            |  27 ++
 .../UsingTheAwsSecretsManagerPlugin.md        |   2 +-
 .../UsingTheIamAuthenticationPlugin.md        |   2 +
 mysql/lib/dialect/mysql2_driver_dialect.ts    |  17 +-
 .../dialect/node_postgres_driver_dialect.ts   |  22 +-
 .../tests/iam_authentication.test.ts          |   2 +
 .../aws_client_get_plugin_instance.test.ts    |   2 +-
 tests/unit/database_dialect.test.ts           |   3 +-
 25 files changed, 1078 insertions(+), 124 deletions(-)
 create mode 100644 common/lib/profile/configuration_profile.ts
 create mode 100644 common/lib/profile/configuration_profile_builder.ts
 create mode 100644 common/lib/profile/configuration_profile_codes.ts
 create mode 100644 common/lib/profile/driver_configuration_profiles.ts
 create mode 100644 docs/files/configuration-profile-presets.pdf
 create mode 100644 docs/images/configuration-presets.png
 create mode 100644 docs/using-the-nodejs-wrapper/ConfigurationPresets.md
 create mode 100644 docs/using-the-nodejs-wrapper/custom-configuration/AwsCredentialsConfiguration.md

diff --git a/common/lib/authentication/aws_credentials_manager.ts b/common/lib/authentication/aws_credentials_manager.ts
index c7f2a9b2..09059953 100644
--- a/common/lib/authentication/aws_credentials_manager.ts
+++ b/common/lib/authentication/aws_credentials_manager.ts
@@ -17,29 +17,34 @@
 import { HostInfo } from "../host_info";
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
 import { AwsCredentialIdentityProvider } from "@smithy/types/dist-types/identity/awsCredentialIdentity";
+import { WrapperProperties } from "../wrapper_property";
+import { AwsWrapperError } from "../utils/errors";
+import { Messages } from "../utils/messages";
 
 interface AwsCredentialsProviderHandler {
   getAwsCredentialsProvider(hostInfo: HostInfo, properties: Map<string, any>): AwsCredentialIdentityProvider;
 }
 
 export class AwsCredentialsManager {
-  private static handler?: AwsCredentialsProviderHandler;
-
-  static setCustomHandler(customHandler: AwsCredentialsProviderHandler) {
-    AwsCredentialsManager.handler = customHandler;
-  }
-
   static getProvider(hostInfo: HostInfo, props: Map<string, any>): AwsCredentialIdentityProvider {
-    return AwsCredentialsManager.handler === undefined
-      ? AwsCredentialsManager.getDefaultProvider()
-      : AwsCredentialsManager.handler.getAwsCredentialsProvider(hostInfo, props);
-  }
+    const awsCredentialProviderHandler = WrapperProperties.CUSTOM_AWS_CREDENTIAL_PROVIDER_HANDLER.get(props);
+    if (awsCredentialProviderHandler && !AwsCredentialsManager.isAwsCredentialsProviderHandler(awsCredentialProviderHandler)) {
+      throw new AwsWrapperError(Messages.get("AwsCredentialsManager.wrongHandler"));
+    }
 
-  static resetCustomHandler() {
-    AwsCredentialsManager.handler = undefined;
+    return !awsCredentialProviderHandler
+      ? AwsCredentialsManager.getDefaultProvider(WrapperProperties.AWS_PROFILE.get(props))
+      : awsCredentialProviderHandler.getAwsCredentialsProvider(hostInfo, props);
   }
 
-  private static getDefaultProvider() {
+  private static getDefaultProvider(profileName: string | null) {
+    if (profileName) {
+      return fromNodeProviderChain({ profile: profileName });
+    }
     return fromNodeProviderChain();
   }
+
+  private static isAwsCredentialsProviderHandler(arg: any): arg is AwsCredentialsProviderHandler {
+    return arg.getAwsCredentialsProvider !== undefined;
+  }
 }
diff --git a/common/lib/aws_client.ts b/common/lib/aws_client.ts
index ce124077..6fb9fe72 100644
--- a/common/lib/aws_client.ts
+++ b/common/lib/aws_client.ts
@@ -31,6 +31,10 @@ import { DefaultTelemetryFactory } from "./utils/telemetry/default_telemetry_fac
 import { TelemetryFactory } from "./utils/telemetry/telemetry_factory";
 import { DriverDialect } from "./driver_dialect/driver_dialect";
 import { WrapperProperties } from "./wrapper_property";
+import { DriverConfigurationProfiles } from "./profile/driver_configuration_profiles";
+import { ConfigurationProfile } from "./profile/configuration_profile";
+import { AwsWrapperError } from "./utils/errors";
+import { Messages } from "./utils/messages";
 
 export abstract class AwsClient extends EventEmitter {
   private _defaultPort: number = -1;
@@ -41,6 +45,7 @@ export abstract class AwsClient extends EventEmitter {
   protected _isReadOnly: boolean = false;
   protected _isolationLevel: number = 0;
   protected _connectionUrlParser: ConnectionUrlParser;
+  protected _configurationProfile: ConfigurationProfile | null = null;
   readonly properties: Map<string, any>;
   config: any;
   targetClient?: ClientWrapper;
@@ -58,9 +63,50 @@ export abstract class AwsClient extends EventEmitter {
 
     this.properties = new Map<string, any>(Object.entries(config));
 
+    const profileName = WrapperProperties.PROFILE_NAME.get(this.properties);
+    if (profileName && profileName.length > 0) {
+      this._configurationProfile = DriverConfigurationProfiles.getProfileConfiguration(profileName);
+      if (this._configurationProfile) {
+        const profileProperties = this._configurationProfile.getProperties();
+        if (profileProperties) {
+          for (const key of profileProperties.keys()) {
+            if (this.properties.has(key)) {
+              // Setting defined by a user has priority over property in configuration profile.
+              continue;
+            }
+            this.properties.set(key, profileProperties.get(key));
+          }
+
+          const connectionProvider = WrapperProperties.CONNECTION_PROVIDER.get(this.properties);
+          if (!connectionProvider) {
+            WrapperProperties.CONNECTION_PROVIDER.set(this.properties, this._configurationProfile.getAwsCredentialProvider());
+          }
+
+          const customAwsCredentialProvider = WrapperProperties.CUSTOM_AWS_CREDENTIAL_PROVIDER_HANDLER.get(this.properties);
+          if (!customAwsCredentialProvider) {
+            WrapperProperties.CUSTOM_AWS_CREDENTIAL_PROVIDER_HANDLER.set(this.properties, this._configurationProfile.getAwsCredentialProvider());
+          }
+
+          const customDatabaseDialect = WrapperProperties.CUSTOM_DATABASE_DIALECT.get(this.properties);
+          if (!customDatabaseDialect) {
+            WrapperProperties.CUSTOM_DATABASE_DIALECT.set(this.properties, this._configurationProfile.getDatabaseDialect());
+          }
+        }
+      } else {
+        throw new AwsWrapperError(Messages.get("AwsClient.configurationProfileNotFound", profileName));
+      }
+    }
+
     this.telemetryFactory = new DefaultTelemetryFactory(this.properties);
     const container = new PluginServiceManagerContainer();
-    this.pluginService = new PluginService(container, this, dbType, knownDialectsByCode, this.properties, driverDialect);
+    this.pluginService = new PluginService(
+      container,
+      this,
+      dbType,
+      knownDialectsByCode,
+      this.properties,
+      this._configurationProfile?.getDriverDialect() ?? driverDialect
+    );
     this.pluginManager = new PluginManager(
       container,
       this.properties,
@@ -71,7 +117,7 @@ export abstract class AwsClient extends EventEmitter {
 
   private async setup() {
     await this.telemetryFactory.init();
-    await this.pluginManager.init();
+    await this.pluginManager.init(this._configurationProfile);
   }
 
   protected async internalConnect() {
diff --git a/common/lib/connection_plugin_chain_builder.ts b/common/lib/connection_plugin_chain_builder.ts
index 745ed224..7a8817c6 100644
--- a/common/lib/connection_plugin_chain_builder.ts
+++ b/common/lib/connection_plugin_chain_builder.ts
@@ -38,6 +38,7 @@ import { DeveloperConnectionPluginFactory } from "./plugins/dev/developer_connec
 import { ConnectionPluginFactory } from "./plugin_factory";
 import { LimitlessConnectionPluginFactory } from "./plugins/limitless/limitless_connection_plugin_factory";
 import { FastestResponseStrategyPluginFactory } from "./plugins/strategy/fastest_response/fastest_respose_strategy_plugin_factory";
+import { ConfigurationProfile } from "./profile/configuration_profile";
 
 /*
   Type alias used for plugin factory sorting. It holds a reference to a plugin
@@ -69,58 +70,90 @@ export class ConnectionPluginChainBuilder {
     ["executeTime", { factory: ExecuteTimePluginFactory, weight: ConnectionPluginChainBuilder.WEIGHT_RELATIVE_TO_PRIOR_PLUGIN }]
   ]);
 
+  static readonly PLUGIN_WEIGHTS = new Map<typeof ConnectionPluginFactory, number>([
+    [AuroraInitialConnectionStrategyFactory, 390],
+    [AuroraConnectionTrackerPluginFactory, 400],
+    [StaleDnsPluginFactory, 500],
+    [ReadWriteSplittingPluginFactory, 600],
+    [FailoverPluginFactory, 700],
+    [HostMonitoringPluginFactory, 800],
+    [LimitlessConnectionPluginFactory, 950],
+    [IamAuthenticationPluginFactory, 1000],
+    [AwsSecretsManagerPluginFactory, 1100],
+    [FederatedAuthPluginFactory, 1200],
+    [OktaAuthPluginFactory, 1300],
+    [DeveloperConnectionPluginFactory, 1400],
+    [ConnectTimePluginFactory, ConnectionPluginChainBuilder.WEIGHT_RELATIVE_TO_PRIOR_PLUGIN],
+    [ExecuteTimePluginFactory, ConnectionPluginChainBuilder.WEIGHT_RELATIVE_TO_PRIOR_PLUGIN]
+  ]);
+
   static async getPlugins(
     pluginService: PluginService,
     props: Map<string, any>,
-    connectionProviderManager: ConnectionProviderManager
+    connectionProviderManager: ConnectionProviderManager,
+    configurationProfile: ConfigurationProfile | null
   ): Promise<ConnectionPlugin[]> {
+    let pluginFactoryInfoList: PluginFactoryInfo[] = [];
     const plugins: ConnectionPlugin[] = [];
-    let pluginCodes: string = props.get(WrapperProperties.PLUGINS.name);
-    if (pluginCodes == null) {
-      pluginCodes = WrapperProperties.DEFAULT_PLUGINS;
-    }
-
-    const usingDefault = pluginCodes === WrapperProperties.DEFAULT_PLUGINS;
+    let usingDefault: boolean = false;
 
-    pluginCodes = pluginCodes.trim();
-
-    if (pluginCodes !== "") {
-      const pluginCodeList = pluginCodes.split(",").map((pluginCode) => pluginCode.trim());
-      let pluginFactoryInfoList: PluginFactoryInfo[] = [];
-      let lastWeight = 0;
-      pluginCodeList.forEach((p) => {
-        if (!ConnectionPluginChainBuilder.PLUGIN_FACTORIES.has(p)) {
-          throw new AwsWrapperError(Messages.get("PluginManager.unknownPluginCode", p));
-        }
-
-        const factoryInfo = ConnectionPluginChainBuilder.PLUGIN_FACTORIES.get(p);
-        if (factoryInfo) {
-          if (factoryInfo.weight === ConnectionPluginChainBuilder.WEIGHT_RELATIVE_TO_PRIOR_PLUGIN) {
-            lastWeight++;
-          } else {
-            lastWeight = factoryInfo.weight;
+    if (configurationProfile) {
+      const profilePluginFactories = configurationProfile.getPluginFactories();
+      if (profilePluginFactories) {
+        for (const factory of profilePluginFactories) {
+          const weight = ConnectionPluginChainBuilder.PLUGIN_WEIGHTS.get(factory);
+          if (!weight) {
+            throw new AwsWrapperError(Messages.get("PluginManager.unknownPluginWeight", factory.prototype.constructor.name));
           }
-          pluginFactoryInfoList.push({ factory: factoryInfo.factory, weight: lastWeight });
+          pluginFactoryInfoList.push({ factory: factory, weight: weight });
         }
-      });
+        usingDefault = true; // We assume that plugin factories in configuration profile is presorted.
+      }
+    } else {
+      let pluginCodes: string = props.get(WrapperProperties.PLUGINS.name);
+      if (pluginCodes == null) {
+        pluginCodes = WrapperProperties.DEFAULT_PLUGINS;
+      }
+      usingDefault = pluginCodes === WrapperProperties.DEFAULT_PLUGINS;
 
-      if (!usingDefault && pluginFactoryInfoList.length > 1 && WrapperProperties.AUTO_SORT_PLUGIN_ORDER.get(props)) {
-        pluginFactoryInfoList = pluginFactoryInfoList.sort((a, b) => a.weight - b.weight);
+      pluginCodes = pluginCodes.trim();
+      if (pluginCodes !== "") {
+        const pluginCodeList = pluginCodes.split(",").map((pluginCode) => pluginCode.trim());
+        let lastWeight = 0;
+        pluginCodeList.forEach((p) => {
+          if (!ConnectionPluginChainBuilder.PLUGIN_FACTORIES.has(p)) {
+            throw new AwsWrapperError(Messages.get("PluginManager.unknownPluginCode", p));
+          }
 
-        if (!usingDefault) {
-          logger.info(
-            "Plugins order has been rearranged. The following order is in effect: " +
-              pluginFactoryInfoList.map((pluginFactoryInfo) => pluginFactoryInfo.factory.name.split("Factory")[0]).join(", ")
-          );
-        }
+          const factoryInfo = ConnectionPluginChainBuilder.PLUGIN_FACTORIES.get(p);
+          if (factoryInfo) {
+            if (factoryInfo.weight === ConnectionPluginChainBuilder.WEIGHT_RELATIVE_TO_PRIOR_PLUGIN) {
+              lastWeight++;
+            } else {
+              lastWeight = factoryInfo.weight;
+            }
+            pluginFactoryInfoList.push({ factory: factoryInfo.factory, weight: lastWeight });
+          }
+        });
       }
+    }
+
+    if (!usingDefault && pluginFactoryInfoList.length > 1 && WrapperProperties.AUTO_SORT_PLUGIN_ORDER.get(props)) {
+      pluginFactoryInfoList = pluginFactoryInfoList.sort((a, b) => a.weight - b.weight);
 
-      for (const pluginFactoryInfo of pluginFactoryInfoList) {
-        const factoryObj = new pluginFactoryInfo.factory();
-        plugins.push(await factoryObj.getInstance(pluginService, props));
+      if (!usingDefault) {
+        logger.info(
+          "Plugins order has been rearranged. The following order is in effect: " +
+            pluginFactoryInfoList.map((pluginFactoryInfo) => pluginFactoryInfo.factory.name.split("Factory")[0]).join(", ")
+        );
       }
     }
 
+    for (const pluginFactoryInfo of pluginFactoryInfoList) {
+      const factoryObj = new pluginFactoryInfo.factory();
+      plugins.push(await factoryObj.getInstance(pluginService, props));
+    }
+
     plugins.push(new DefaultPlugin(pluginService, connectionProviderManager));
 
     return plugins;
diff --git a/common/lib/database_dialect/database_dialect_manager.ts b/common/lib/database_dialect/database_dialect_manager.ts
index f8bcf26a..e8127f2a 100644
--- a/common/lib/database_dialect/database_dialect_manager.ts
+++ b/common/lib/database_dialect/database_dialect_manager.ts
@@ -34,33 +34,36 @@ export class DatabaseDialectManager implements DatabaseDialectProvider {
    */
   private static readonly ENDPOINT_CACHE_EXPIRATION_MS = 86_400_000_000_000; // 24 hours
   protected static readonly knownEndpointDialects: CacheMap<string, string> = new CacheMap();
-  protected readonly knownDialectsByCode: Map<string, DatabaseDialect>;
 
-  private static customDialect: DatabaseDialect | null = null;
-  private readonly rdsHelper: RdsUtils = new RdsUtils();
-  private readonly dbType;
-  private canUpdate: boolean = false;
-  private dialect: DatabaseDialect;
-  private dialectCode: string = "";
+  protected readonly knownDialectsByCode: Map<string, DatabaseDialect>;
+  protected readonly customDialect: DatabaseDialect | null;
+  protected readonly rdsHelper: RdsUtils = new RdsUtils();
+  protected readonly dbType: DatabaseType;
+  protected canUpdate: boolean = false;
+  protected dialect: DatabaseDialect;
+  protected dialectCode: string = "";
 
   constructor(knownDialectsByCode: any, dbType: DatabaseType, props: Map<string, any>) {
     this.knownDialectsByCode = knownDialectsByCode;
     this.dbType = dbType;
-    this.dialect = this.getDialect(props);
-  }
 
-  static setCustomDialect(dialect: DatabaseDialect) {
-    DatabaseDialectManager.customDialect = dialect;
-  }
+    const dialectSetting = WrapperProperties.CUSTOM_DATABASE_DIALECT.get(props);
+    if (dialectSetting && !this.isDatabaseDialect(dialectSetting)) {
+      throw new AwsWrapperError(Messages.get("DatabaseDialectManager.wrongCustomDialect"));
+    }
+    this.customDialect = dialectSetting;
 
-  static resetCustomDialect() {
-    DatabaseDialectManager.customDialect = null;
+    this.dialect = this.getDialect(props);
   }
 
   static resetEndpointCache() {
     DatabaseDialectManager.knownEndpointDialects.clear();
   }
 
+  protected isDatabaseDialect(arg: any): arg is DatabaseDialect {
+    return arg.getDialectName !== undefined;
+  }
+
   getDialect(props: Map<string, any>): DatabaseDialect {
     if (this.dialect) {
       return this.dialect;
@@ -68,9 +71,9 @@ export class DatabaseDialectManager implements DatabaseDialectProvider {
 
     this.canUpdate = false;
 
-    if (DatabaseDialectManager.customDialect) {
+    if (this.customDialect) {
       this.dialectCode = DatabaseDialectCodes.CUSTOM;
-      this.dialect = DatabaseDialectManager.customDialect;
+      this.dialect = this.customDialect;
       this.logCurrentDialect();
       return this.dialect;
     }
@@ -87,7 +90,7 @@ export class DatabaseDialectManager implements DatabaseDialectProvider {
         this.logCurrentDialect();
         return userDialect;
       }
-      throw new AwsWrapperError(Messages.get("DialectManager.unknownDialectCode", dialectCode));
+      throw new AwsWrapperError(Messages.get("DatabaseDialectManager.unknownDialectCode", dialectCode));
     }
 
     if (this.dbType === DatabaseType.MYSQL) {
@@ -148,7 +151,7 @@ export class DatabaseDialectManager implements DatabaseDialectProvider {
       return this.dialect;
     }
 
-    throw new AwsWrapperError(Messages.get("DialectManager.getDialectError"));
+    throw new AwsWrapperError(Messages.get("DatabaseDialectManager.getDialectError"));
   }
 
   async getDialectForUpdate(targetClient: ClientWrapper, originalHost: string, newHost: string): Promise<DatabaseDialect> {
@@ -161,7 +164,7 @@ export class DatabaseDialectManager implements DatabaseDialectProvider {
       for (const dialectCandidateCode of dialectCandidates) {
         const dialectCandidate = this.knownDialectsByCode.get(dialectCandidateCode);
         if (!dialectCandidate) {
-          throw new AwsWrapperError(Messages.get("DialectManager.unknownDialectCode", dialectCandidateCode));
+          throw new AwsWrapperError(Messages.get("DatabaseDialectManager.unknownDialectCode", dialectCandidateCode));
         }
 
         const isDialect = await dialectCandidate.isDialect(targetClient);
diff --git a/common/lib/plugin_manager.ts b/common/lib/plugin_manager.ts
index 51317cb7..9409dad3 100644
--- a/common/lib/plugin_manager.ts
+++ b/common/lib/plugin_manager.ts
@@ -31,6 +31,7 @@ import { TelemetryFactory } from "./utils/telemetry/telemetry_factory";
 import { TelemetryTraceLevel } from "./utils/telemetry/telemetry_trace_level";
 import { ConnectionProvider } from "./connection_provider";
 import { ConnectionPluginFactory } from "./plugin_factory";
+import { ConfigurationProfile } from "./profile/configuration_profile";
 
 type PluginFunc<T> = (plugin: ConnectionPlugin, targetFunc: () => Promise<T>) => Promise<T>;
 
@@ -91,9 +92,9 @@ export class PluginManager {
     this.telemetryFactory = telemetryFactory;
   }
 
-  async init(): Promise<void>;
-  async init(plugins: ConnectionPlugin[]): Promise<void>;
-  async init(plugins?: ConnectionPlugin[]) {
+  async init(configurationProfile?: ConfigurationProfile | null): Promise<void>;
+  async init(configurationProfile: ConfigurationProfile | null, plugins: ConnectionPlugin[]): Promise<void>;
+  async init(configurationProfile: ConfigurationProfile | null, plugins?: ConnectionPlugin[]) {
     if (this.pluginServiceManagerContainer.pluginService != null) {
       if (plugins) {
         this._plugins = plugins;
@@ -101,7 +102,8 @@ export class PluginManager {
         this._plugins = await ConnectionPluginChainBuilder.getPlugins(
           this.pluginServiceManagerContainer.pluginService,
           this.props,
-          this.connectionProviderManager
+          this.connectionProviderManager,
+          configurationProfile
         );
       }
     }
diff --git a/common/lib/plugin_service.ts b/common/lib/plugin_service.ts
index 32716414..8284c1f1 100644
--- a/common/lib/plugin_service.ts
+++ b/common/lib/plugin_service.ts
@@ -43,6 +43,7 @@ import { DatabaseDialectCodes } from "./database_dialect/database_dialect_codes"
 import { getWriter } from "./utils/utils";
 import { TelemetryFactory } from "./utils/telemetry/telemetry_factory";
 import { DriverDialect } from "./driver_dialect/driver_dialect";
+import { ConfigurationProfile } from "./profile/configuration_profile";
 
 export class PluginService implements ErrorHandler, HostListProviderService {
   private readonly _currentClient: AwsClient;
@@ -77,7 +78,7 @@ export class PluginService implements ErrorHandler, HostListProviderService {
     this.sessionStateService = new SessionStateServiceImpl(this, this.props);
     container.pluginService = this;
 
-    this.dialect = this.dbDialectProvider.getDialect(this.props);
+    this.dialect = WrapperProperties.CUSTOM_DATABASE_DIALECT.get(this.props) ?? this.dbDialectProvider.getDialect(this.props);
   }
 
   isInTransaction(): boolean {
diff --git a/common/lib/profile/configuration_profile.ts b/common/lib/profile/configuration_profile.ts
new file mode 100644
index 00000000..9a52d355
--- /dev/null
+++ b/common/lib/profile/configuration_profile.ts
@@ -0,0 +1,130 @@
+/*
+  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ 
+  Licensed under the Apache License, Version 2.0 (the "License").
+  You may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+ 
+  http://www.apache.org/licenses/LICENSE-2.0
+ 
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { ConnectionPluginFactory } from "../plugin_factory";
+import { DatabaseDialect } from "../database_dialect/database_dialect";
+import { DriverDialect } from "../driver_dialect/driver_dialect";
+import { ConnectionProvider } from "../connection_provider";
+
+export class ConfigurationProfile {
+  protected readonly name: string;
+  protected readonly pluginFactories: (typeof ConnectionPluginFactory)[];
+  protected readonly properties: Map<string, any>;
+  protected readonly databaseDialect: DatabaseDialect | (() => DatabaseDialect) | null;
+  protected readonly driverDialect: DriverDialect | (() => DriverDialect) | null;
+  protected readonly awsCredentialProvider: any | null; //AwsCredentialsProviderHandler
+  protected readonly connectionProvider: ConnectionProvider | (() => ConnectionProvider) | null;
+
+  // Initialized objects
+  protected databaseDialectObj: DatabaseDialect | null = null;
+  protected driverDialectObj: DriverDialect | null = null;
+  protected awsCredentialProviderObj: any | null = null; //AwsCredentialsProviderHandler
+  protected connectionProviderObj: ConnectionProvider | null = null;
+
+  constructor(
+    name: string,
+    pluginFactories: (typeof ConnectionPluginFactory)[], // Factories should be presorted by weights!
+    properties: Map<string, any>,
+    databaseDialect: DatabaseDialect | (() => DatabaseDialect) | null,
+    driverDialect: DriverDialect | (() => DriverDialect) | null,
+    awsCredentialProvider: any,
+    connectionProvider: ConnectionProvider | (() => ConnectionProvider) | null
+  ) {
+    this.name = name;
+    this.pluginFactories = pluginFactories;
+    this.properties = properties;
+    this.databaseDialect = databaseDialect;
+    this.driverDialect = driverDialect;
+    this.awsCredentialProvider = awsCredentialProvider;
+    this.connectionProvider = connectionProvider;
+  }
+
+  public getName(): string {
+    return this.name;
+  }
+
+  public getProperties(): Map<string, any> {
+    return this.properties;
+  }
+
+  public getPluginFactories(): (typeof ConnectionPluginFactory)[] {
+    return this.pluginFactories;
+  }
+
+  public getDatabaseDialect(): DatabaseDialect | null {
+    if (this.databaseDialectObj) {
+      return this.databaseDialectObj;
+    }
+    if (!this.databaseDialect) {
+      return null;
+    }
+
+    if (typeof this.driverDialect === "function") {
+      this.databaseDialectObj = (this.databaseDialect as () => DatabaseDialect)();
+    } else {
+      this.databaseDialectObj = this.databaseDialect as DatabaseDialect;
+    }
+    return this.databaseDialectObj;
+  }
+
+  public getDriverDialect(): DriverDialect | null {
+    if (this.driverDialectObj) {
+      return this.driverDialectObj;
+    }
+    if (!this.driverDialect) {
+      return null;
+    }
+
+    if (typeof this.driverDialect === "function") {
+      this.driverDialectObj = (this.driverDialect as () => DriverDialect)();
+    } else {
+      this.driverDialectObj = this.driverDialect as DriverDialect;
+    }
+    return this.driverDialectObj;
+  }
+
+  public getConnectionProvider(): ConnectionProvider | null {
+    if (this.connectionProviderObj) {
+      return this.connectionProviderObj;
+    }
+    if (!this.connectionProvider) {
+      return null;
+    }
+
+    if (typeof this.connectionProvider === "function") {
+      this.connectionProviderObj = (this.connectionProvider as () => ConnectionProvider)();
+    } else {
+      this.connectionProviderObj = this.connectionProvider as ConnectionProvider;
+    }
+    return this.connectionProviderObj;
+  }
+
+  public getAwsCredentialProvider(): any | null {
+    if (this.awsCredentialProviderObj) {
+      return this.awsCredentialProviderObj;
+    }
+    if (!this.awsCredentialProvider) {
+      return null;
+    }
+
+    if (typeof this.awsCredentialProvider === "function") {
+      this.awsCredentialProviderObj = (this.awsCredentialProvider as () => any)();
+    } else {
+      this.awsCredentialProviderObj = this.awsCredentialProvider;
+    }
+    return this.awsCredentialProviderObj;
+  }
+}
diff --git a/common/lib/profile/configuration_profile_builder.ts b/common/lib/profile/configuration_profile_builder.ts
new file mode 100644
index 00000000..8868db2f
--- /dev/null
+++ b/common/lib/profile/configuration_profile_builder.ts
@@ -0,0 +1,115 @@
+/*
+  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ 
+  Licensed under the Apache License, Version 2.0 (the "License").
+  You may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+ 
+  http://www.apache.org/licenses/LICENSE-2.0
+ 
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { ConnectionPluginFactory } from "../plugin_factory";
+import { DatabaseDialect } from "../database_dialect/database_dialect";
+import { DriverDialect } from "../driver_dialect/driver_dialect";
+import { ConnectionProvider } from "../connection_provider";
+import { AwsWrapperError } from "../utils/errors";
+import { Messages } from "../utils/messages";
+import { ConfigurationProfile } from "./configuration_profile";
+import { ConfigurationProfilePresetCodes } from "./configuration_profile_codes";
+import { DriverConfigurationProfiles } from "./driver_configuration_profiles";
+
+export class ConfigurationProfileBuilder {
+  protected name: string = null;
+  protected pluginFactories: (typeof ConnectionPluginFactory)[] = null;
+  protected properties: Map<string, any> = null;
+  protected databaseDialect: DatabaseDialect | (() => DatabaseDialect) = null;
+  protected driverDialect: DriverDialect | (() => DriverDialect) = null;
+  protected awsCredentialProvider: any | null = null; //AwsCredentialsProviderHandler
+  protected connectionProvider: ConnectionProvider | (() => ConnectionProvider) = null;
+
+  private constructor() {}
+
+  public static get(): ConfigurationProfileBuilder {
+    return new ConfigurationProfileBuilder();
+  }
+
+  public withName(name: string): ConfigurationProfileBuilder {
+    this.name = name;
+    return this;
+  }
+
+  public withProperties(properties: Map<string, any>): ConfigurationProfileBuilder {
+    this.properties = properties;
+    return this;
+  }
+
+  public withPluginsFactories(pluginFactories: (typeof ConnectionPluginFactory)[]): ConfigurationProfileBuilder {
+    this.pluginFactories = pluginFactories;
+    return this;
+  }
+
+  public withDatabaseDialect(databaseDialect: DatabaseDialect): ConfigurationProfileBuilder {
+    this.databaseDialect = databaseDialect;
+    return this;
+  }
+
+  public withDriverDialect(driverDialect: DriverDialect): ConfigurationProfileBuilder {
+    this.driverDialect = driverDialect;
+    return this;
+  }
+
+  public withConnectionProvider(connectionProvider: ConnectionProvider): ConfigurationProfileBuilder {
+    this.connectionProvider = connectionProvider;
+    return this;
+  }
+
+  public withAwsCredentialProvider(awsCredentialProvider: any): ConfigurationProfileBuilder {
+    this.awsCredentialProvider = awsCredentialProvider;
+    return this;
+  }
+
+  public from(presetProfileName: string): ConfigurationProfileBuilder {
+    const configurationProfile = DriverConfigurationProfiles.getProfileConfiguration(presetProfileName);
+    if (!configurationProfile) {
+      throw new AwsWrapperError(Messages.get("ConfigurationProfileBuilder.notFound", presetProfileName));
+    }
+
+    this.name = configurationProfile.getName();
+    this.properties = configurationProfile.getProperties();
+    this.databaseDialect = configurationProfile.getDatabaseDialect();
+    this.driverDialect = configurationProfile.getDriverDialect();
+    this.awsCredentialProvider = configurationProfile.getAwsCredentialProvider();
+    this.connectionProvider = configurationProfile.getConnectionProvider();
+    this.pluginFactories = configurationProfile.getPluginFactories();
+
+    return this;
+  }
+
+  public build(): ConfigurationProfile {
+    if (!this.name || this.name.length === 0) {
+      throw new AwsWrapperError(Messages.get("ConfigurationProfileBuilder.profileNameRequired", this.name));
+    }
+    if (ConfigurationProfilePresetCodes.isKnownPreset(this.name)) {
+      throw new AwsWrapperError(Messages.get("ConfigurationProfileBuilder.canNotUpdateKnownPreset", this.name));
+    }
+    return new ConfigurationProfile(
+      this.name,
+      this.pluginFactories,
+      this.properties,
+      this.databaseDialect,
+      this.driverDialect,
+      this.awsCredentialProvider,
+      this.connectionProvider
+    );
+  }
+
+  public buildAndSet() {
+    DriverConfigurationProfiles.addOrReplaceProfile(this.name, this.build());
+  }
+}
diff --git a/common/lib/profile/configuration_profile_codes.ts b/common/lib/profile/configuration_profile_codes.ts
new file mode 100644
index 00000000..ddc34ea8
--- /dev/null
+++ b/common/lib/profile/configuration_profile_codes.ts
@@ -0,0 +1,38 @@
+/*
+  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ 
+  Licensed under the Apache License, Version 2.0 (the "License").
+  You may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+ 
+  http://www.apache.org/licenses/LICENSE-2.0
+ 
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+export class ConfigurationProfilePresetCodes {
+  public static readonly A0 = "A0"; // Normal
+  public static readonly A1 = "A1"; // Easy
+  public static readonly A2 = "A2"; // Aggressive
+  public static readonly B = "B"; // Normal
+  public static readonly C0 = "C0"; // Normal
+  public static readonly C1 = "C1"; // Aggressive
+  public static readonly D0 = "D0"; // Normal
+  public static readonly D1 = "D1"; // Easy
+  public static readonly E = "E"; // Normal
+  public static readonly F0 = "F0"; // Normal
+  public static readonly F1 = "F1"; // Aggressive
+  public static readonly G0 = "G0"; // Normal
+  public static readonly G1 = "G1"; // Easy
+  public static readonly H = "H"; // Normal
+  public static readonly I0 = "I0"; // Normal
+  public static readonly I1 = "I1"; // Aggressive
+
+  public static isKnownPreset(name: string): boolean {
+    return Object.prototype.hasOwnProperty.call(ConfigurationProfilePresetCodes, name);
+  }
+}
diff --git a/common/lib/profile/driver_configuration_profiles.ts b/common/lib/profile/driver_configuration_profiles.ts
new file mode 100644
index 00000000..f00030ec
--- /dev/null
+++ b/common/lib/profile/driver_configuration_profiles.ts
@@ -0,0 +1,416 @@
+/*
+  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ 
+  Licensed under the Apache License, Version 2.0 (the "License").
+  You may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+ 
+  http://www.apache.org/licenses/LICENSE-2.0
+ 
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { ConfigurationProfile } from "./configuration_profile";
+import { ConfigurationProfilePresetCodes } from "./configuration_profile_codes";
+import { WrapperProperties } from "../wrapper_property";
+import { HostMonitoringPluginFactory } from "../plugins/efm/host_monitoring_plugin_factory";
+import { AuroraInitialConnectionStrategyFactory } from "../plugins/aurora_initial_connection_strategy_plugin_factory";
+import { AuroraConnectionTrackerPluginFactory } from "../plugins/connection_tracker/aurora_connection_tracker_plugin_factory";
+import { ReadWriteSplittingPluginFactory } from "../plugins/read_write_splitting_plugin_factory";
+import { FailoverPluginFactory } from "../plugins/failover/failover_plugin_factory";
+import { InternalPooledConnectionProvider } from "../internal_pooled_connection_provider";
+import { AwsPoolConfig } from "../aws_pool_config";
+import { StaleDnsPluginFactory } from "../plugins/stale_dns/stale_dns_plugin_factory";
+
+export class DriverConfigurationProfiles {
+  private static readonly MONITORING_CONNECTION_PREFIX = "monitoring-";
+  private static readonly activeProfiles: Map<string, ConfigurationProfile> = new Map<string, ConfigurationProfile>();
+  private static readonly presets: Map<string, ConfigurationProfile> = new Map<string, ConfigurationProfile>([
+    [
+      ConfigurationProfilePresetCodes.A0,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.A0,
+        [],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 5000],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.A1,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.A1,
+        [],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 30000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 30000],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.A2,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.A2,
+        [],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 3000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 3000],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.B,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.B,
+        [],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 0],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: true }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.C0,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.C0,
+        [HostMonitoringPluginFactory], // Factories should be presorted by weights!
+        new Map<string, any>([
+          [WrapperProperties.FAILURE_DETECTION_TIME_MS.name, 60000],
+          [WrapperProperties.FAILURE_DETECTION_COUNT.name, 5],
+          [WrapperProperties.FAILURE_DETECTION_INTERVAL_MS.name, 15000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 5000],
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 0],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.C1,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.C1,
+        [HostMonitoringPluginFactory], // Factories should be presorted by weights!
+        new Map<string, any>([
+          [WrapperProperties.FAILURE_DETECTION_TIME_MS.name, 30000],
+          [WrapperProperties.FAILURE_DETECTION_COUNT.name, 3],
+          [WrapperProperties.FAILURE_DETECTION_INTERVAL_MS.name, 5000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 3000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 3000],
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 0],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.D0,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.D0,
+        // Factories should be presorted by weights!
+        [AuroraInitialConnectionStrategyFactory, AuroraConnectionTrackerPluginFactory, ReadWriteSplittingPluginFactory, FailoverPluginFactory],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 5000],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        () => {
+          return new InternalPooledConnectionProvider(
+            new AwsPoolConfig({
+              maxConnections: 30,
+              maxIdleConnections: 2,
+              minConnections: 2,
+              idleTimeoutMillis: 15 * 60000, // 15min
+              allowExitOnIdle: true
+            })
+          );
+        }
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.D1,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.D1,
+        // Factories should be presorted by weights!
+        [AuroraInitialConnectionStrategyFactory, AuroraConnectionTrackerPluginFactory, ReadWriteSplittingPluginFactory, FailoverPluginFactory],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 30000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 30000],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        () => {
+          return new InternalPooledConnectionProvider(
+            new AwsPoolConfig({
+              maxConnections: 30,
+              maxIdleConnections: 2,
+              minConnections: 2,
+              idleTimeoutMillis: 15 * 60000, // 15min
+              allowExitOnIdle: true
+            })
+          );
+        }
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.E,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.E,
+        // Factories should be presorted by weights!
+        [AuroraInitialConnectionStrategyFactory, AuroraConnectionTrackerPluginFactory, ReadWriteSplittingPluginFactory, FailoverPluginFactory],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 0],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: true }]
+        ]),
+        null,
+        null,
+        null,
+        () => {
+          return new InternalPooledConnectionProvider(
+            new AwsPoolConfig({
+              maxConnections: 30,
+              maxIdleConnections: 2,
+              minConnections: 2,
+              idleTimeoutMillis: 15 * 60000, // 15min
+              allowExitOnIdle: true
+            })
+          );
+        }
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.F0,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.F0,
+        // Factories should be presorted by weights!
+        [
+          AuroraInitialConnectionStrategyFactory,
+          AuroraConnectionTrackerPluginFactory,
+          ReadWriteSplittingPluginFactory,
+          FailoverPluginFactory,
+          HostMonitoringPluginFactory
+        ],
+        new Map<string, any>([
+          [WrapperProperties.FAILURE_DETECTION_TIME_MS.name, 60000],
+          [WrapperProperties.FAILURE_DETECTION_COUNT.name, 5],
+          [WrapperProperties.FAILURE_DETECTION_INTERVAL_MS.name, 15000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 5000],
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 0],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        () => {
+          return new InternalPooledConnectionProvider(
+            new AwsPoolConfig({
+              maxConnections: 30,
+              maxIdleConnections: 2,
+              minConnections: 2,
+              idleTimeoutMillis: 15 * 60000, // 15min
+              allowExitOnIdle: true
+            })
+          );
+        }
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.F1,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.F1,
+        // Factories should be presorted by weights!
+        [
+          AuroraInitialConnectionStrategyFactory,
+          AuroraConnectionTrackerPluginFactory,
+          ReadWriteSplittingPluginFactory,
+          FailoverPluginFactory,
+          HostMonitoringPluginFactory
+        ],
+        new Map<string, any>([
+          [WrapperProperties.FAILURE_DETECTION_TIME_MS.name, 30000],
+          [WrapperProperties.FAILURE_DETECTION_COUNT.name, 3],
+          [WrapperProperties.FAILURE_DETECTION_INTERVAL_MS.name, 5000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 3000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 3000],
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 0],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        () => {
+          return new InternalPooledConnectionProvider(
+            new AwsPoolConfig({
+              maxConnections: 30,
+              maxIdleConnections: 2,
+              minConnections: 2,
+              idleTimeoutMillis: 15 * 60000, // 15min
+              allowExitOnIdle: true
+            })
+          );
+        }
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.G0,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.G0,
+        // Factories should be presorted by weights!
+        [AuroraConnectionTrackerPluginFactory, StaleDnsPluginFactory, FailoverPluginFactory],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 5000],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.G1,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.G1,
+        // Factories should be presorted by weights!
+        [AuroraConnectionTrackerPluginFactory, StaleDnsPluginFactory, FailoverPluginFactory],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 30000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 30000],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.H,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.H,
+        // Factories should be presorted by weights!
+        [AuroraConnectionTrackerPluginFactory, StaleDnsPluginFactory, FailoverPluginFactory],
+        new Map<string, any>([
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 0],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: true }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.I0,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.I0,
+        // Factories should be presorted by weights!
+        [AuroraConnectionTrackerPluginFactory, StaleDnsPluginFactory, FailoverPluginFactory, HostMonitoringPluginFactory],
+        new Map<string, any>([
+          [WrapperProperties.FAILURE_DETECTION_TIME_MS.name, 60000],
+          [WrapperProperties.FAILURE_DETECTION_COUNT.name, 5],
+          [WrapperProperties.FAILURE_DETECTION_INTERVAL_MS.name, 15000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 5000],
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 0],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: true }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ],
+    [
+      ConfigurationProfilePresetCodes.I1,
+      new ConfigurationProfile(
+        ConfigurationProfilePresetCodes.I1,
+        // Factories should be presorted by weights!
+        [AuroraConnectionTrackerPluginFactory, StaleDnsPluginFactory, FailoverPluginFactory, HostMonitoringPluginFactory],
+        new Map<string, any>([
+          [WrapperProperties.FAILURE_DETECTION_TIME_MS.name, 30000],
+          [WrapperProperties.FAILURE_DETECTION_COUNT.name, 3],
+          [WrapperProperties.FAILURE_DETECTION_INTERVAL_MS.name, 5000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 3000],
+          [DriverConfigurationProfiles.MONITORING_CONNECTION_PREFIX + WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 3000],
+          [WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name, 10000],
+          [WrapperProperties.WRAPPER_QUERY_TIMEOUT.name, 0],
+          [WrapperProperties.KEEPALIVE_PROPERTIES.name, { keepAlive: false }]
+        ]),
+        null,
+        null,
+        null,
+        null
+      )
+    ]
+  ]);
+
+  public static clear() {
+    DriverConfigurationProfiles.clear();
+  }
+
+  public static addOrReplaceProfile(profileName: string, configurationProfile: ConfigurationProfile) {
+    DriverConfigurationProfiles.activeProfiles.set(profileName, configurationProfile);
+  }
+
+  public static remove(profileName: string) {
+    DriverConfigurationProfiles.activeProfiles.delete(profileName);
+  }
+
+  public static contains(profileName: string): boolean {
+    return DriverConfigurationProfiles.activeProfiles.has(profileName);
+  }
+
+  public static getProfileConfiguration(profileName: string): ConfigurationProfile {
+    const profile: ConfigurationProfile = DriverConfigurationProfiles.activeProfiles.get(profileName);
+    if (profile) {
+      return profile;
+    }
+    return DriverConfigurationProfiles.presets.get(profileName);
+  }
+}
diff --git a/common/lib/utils/locales/en.json b/common/lib/utils/locales/en.json
index b7e25320..1dd52e36 100644
--- a/common/lib/utils/locales/en.json
+++ b/common/lib/utils/locales/en.json
@@ -1,13 +1,15 @@
 {
   "PluginManager.unknownPluginCode": "Unknown plugin code: '%s'",
+  "PluginManager.unknownPluginWeight": "Unknown plugin weight for %s.",
   "PluginManager.pipelineNone": "A pipeline was requested but the created pipeline evaluated to undefined.",
   "PluginManager.unableToRetrievePlugin": "Unable to retrieve plugin instance.",
   "ConnectionProvider.unsupportedHostSelectorStrategy": "Unsupported host selection strategy '%s' specified for this connection provider '%s'. Please visit the documentation for all supported strategies.",
   "ConnectionPluginChainBuilder.errorImportingPlugin": "The plugin could not be imported due to error '%s'. Please ensure the required dependencies have been installed. Plugin: '%s'",
   "ClientUtils.queryTaskTimeout": "Client query task timed out, if a network error did not occur, please review the usage of the 'mysqlQueryTimeout' connection parameter.",
   "ClientUtils.connectTimeout": "Client connect timed out.",
-  "DialectManager.unknownDialectCode": "Unknown dialect code: '%s'.",
-  "DialectManager.getDialectError": "Was not able to get a database dialect.",
+  "DatabaseDialectManager.unknownDialectCode": "Unknown dialect code: '%s'.",
+  "DatabaseDialectManager.getDialectError": "Was not able to get a database dialect.",
+  "DatabaseDialectManager.wrongCustomDialect": "Provided custom database dialect should implement DatabaseDialect.",
   "DefaultPlugin.executingMethod": "Executing method: %s",
   "DefaultConnectionPlugin.unknownRoleRequested": "A HostInfo with a role of HostRole.UNKNOWN was requested via getHostInfoByStrategy. The requested role must be either HostRole.WRITER or HostRole.READER",
   "DefaultConnectionPlugin.noHostsAvailable": "The default connection plugin received an empty host list from the plugin service.",
@@ -181,10 +183,15 @@
   "LimitlessRouterServiceImpl.getLimitlessRoutersException": "Exception encountered getting Limitless Routers. %s",
   "LimitlessRouterServiceImpl.fetchedEmptyRouterList": "Empty router list was fetched.",
   "LimitlessRouterServiceImpl.errorStartingMonitor": "An error occurred while starting Limitless Router Monitor. %s",
+  "AwsCredentialsManager.wrongHandler": "Provided AWS credential provider handler should implement AwsCredentialsProviderHandler.",
   "HostResponseTimeMonitor.stopped": "Host Response Time Monitor task stopped on instance '%s'.",
   "HostResponseTimeMonitor.responseTime": "Response time for '%s': '%s' ms.",
   "HostResponseTimeMonitor.interruptedErrorDuringMonitoring": "Response time task for host '%s' was interrupted.",
   "HostResponseTimeMonitor.openingConnection": "Opening a Response time connection to '%s'.",
   "HostResponseTimeMonitor.openedConnection": "Opened Response time connection: '%s'.",
-  "FastestResponseStrategyPlugin.unsupportedHostSelectorStrategy": "Unsupported host selector strategy: '%s'. To use the fastest response strategy plugin, please ensure the property 'readerHostSelectorStrategy' is set to 'fastestResponse'."
+  "FastestResponseStrategyPlugin.unsupportedHostSelectorStrategy": "Unsupported host selector strategy: '%s'. To use the fastest response strategy plugin, please ensure the property 'readerHostSelectorStrategy' is set to 'fastestResponse'.",
+  "ConfigurationProfileBuilder.notFound": "Configuration profile '%s' not found.",
+  "ConfigurationProfileBuilder.profileNameRequired": "Profile name is required.",
+  "ConfigurationProfileBuilder.canNotUpdateKnownPreset": "Can't add or update a built-in preset configuration profile '%s'.",
+  "AwsClient.configurationProfileNotFound": "Configuration profile '%s' not found."
 }
diff --git a/common/lib/wrapper_property.ts b/common/lib/wrapper_property.ts
index 9cf54b87..1ee6d04d 100644
--- a/common/lib/wrapper_property.ts
+++ b/common/lib/wrapper_property.ts
@@ -15,6 +15,7 @@
 */
 
 import { ConnectionProvider } from "./connection_provider";
+import { DatabaseDialect } from "./database_dialect/database_dialect";
 
 export class WrapperProperty<T> {
   name: string;
@@ -356,7 +357,23 @@ export class WrapperProperties {
     null
   );
 
-  static removeWrapperProperties(props: Map<string, any>): any {
+  static readonly CUSTOM_DATABASE_DIALECT = new WrapperProperty<DatabaseDialect>(
+    "customDatabaseDialect",
+    "A reference to a custom database dialect object.",
+    null
+  );
+
+  static readonly CUSTOM_AWS_CREDENTIAL_PROVIDER_HANDLER = new WrapperProperty<any>(
+    "customAwsCredentialProviderHandler",
+    "A reference to a custom AwsCredentialsProviderHandler object.",
+    null
+  );
+
+  static readonly AWS_PROFILE = new WrapperProperty<string>("awsProfile", "Name of the AWS Profile to use for IAM or SecretsManager auth.", null);
+
+  static readonly PROFILE_NAME = new WrapperProperty<string>("profileName", "Driver configuration profile name", null);
+
+  static removeWrapperProperties(props: Map<string, any>): Map<string, any> {
     const persistingProperties = [
       WrapperProperties.USER.name,
       WrapperProperties.PASSWORD.name,
@@ -384,6 +401,6 @@ export class WrapperProperties {
       }
     });
 
-    return Object.fromEntries(copy.entries());
+    return copy;
   }
 }
diff --git a/docs/files/configuration-profile-presets.pdf b/docs/files/configuration-profile-presets.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..2f06cff5963bd51bf300c0406f67444dce38bfaa
GIT binary patch
literal 141176
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%0Axn_=}s
z)uqU{(mN%EtMG)iBP;#c*g^S;_1!q=pO!_9x<$Rph)Iu&OUGb7pQk8VC9&o%L9YHX
zBVWx#Xc?#TiHp3ICBHk4aNO!<s9$J2q*ww@SaCJl|EFEMK!u1E6QOg9z6A_C&5l@A
z{6Pk#2Yr_*zI~w~m_oC#ddL0a?TyUQxj_$F7_d}v;|=2UEM#oU=A1GrqmaWkzdV*{
zF8o5^O?&0ZgTw|p&YK~eWf&(_cv7$=O}U9QKJVPgf!Edr3-6Sre4UiEbo%x}7<eqk
zY6rVqt#Ba@Ys_}&n@r@EH=kprXbffDK!$x?|7ZC8vbwcG8foGW!!k9&?5Yzzv$3(e
zte;O%!Sj%UR~s*}krPmh4Y-?p10x*u=(qGj#fgMj>S#F4Z!foNBjyH!2k2X+vPYLV
zX}^-<vJS5TNSIH4UBt#W2cKcUTQ2KbAwu%MCK9%Bg6y^FIj4pf@aPk&x(PIMj}{}=
z^bs!d4s15H>rNJ(OKBEs^4rjZ%w`7*wZ5OHGpD3+B$$&42bdaKDr<Z8CY?^f^_B<n
zxJ;&nZlLZZ|0L44BaQ}i9}avgjGIJPxp*%}xZdTV?VF3UgF|;&%MM$9_N!YneA(u<
zq!c6c-PwHfp+r2_H{qR9CC@f>2mDM5)K7_=GD6<9ZN3}t?v7y$K0d4)^o)EpUL;P>
zI%E=_yzqS<p!4-W_2re|=Mm&UGyfQB4jz}OAKwsWD~j6AR`oxBKDa(UCldO}G90s|
zK(@d^!KpXNKFww+seUrJE%9v=XDBU^+KMpflYDAqE>_>Xul-JX{})9<-w|~5%zD$c
z-P6D>9tVw#!}C)FyyzkWSL4-EX*?WlX8%z<I&&7amsu!WpZYyF_e{4w|LQ`%Okk0j
z*^~vM#kP0aPTx$I^<VVuDHWO~EwZ2(lVmzmPvPHgd=h^4J8=}o@c1>NmvO(-cHT&1
z0{zck^)9-f7{KcVS=5kC>jWqHy4l+?PHLVv&iii-YNS%g;uBVhRd&!h{Lb(bwao~d
zcLjWN+<vII8ENVD5T}2(+FAPawWSnJ8)piqkE+;%zD2E@gOSzB-N;^9!s+%`N-}-;
zcHjwaGy!XgBUr*(Z;ZBi+7hRbcc&X?FoQ^e7j#>yzj~+kGs3GI#rdPx#aqb+QbD39
zWg5cxGA-k|o0lF!ZDLnsa}jqH21;kiJEz_mJ8o8|lB${AR(8GHiCWCw`=37^tFtap
zJG?GLBNEDIlnkm@)JGH2^{aLs8LT#y_hQ2F)t+IBYW$t{YOY8Zl+$!^9?dX#NQxTK
zgM)gO$vBJ=DhDH8Q^N^<7v=If#1=)$A!72g?Di{1&k+8o6wx{u+nO@lqdep8B?@!m
zKA0-7O)pPGL|5edYZzC)mav@OVt#XZQmnR{RBN0&FTPa8H+y|BJixAtW+G#HK0SiG
zOBn*rEXs-^0Vac^rb=bZ3_U(;7RxxngAhbkN$+S;7y2Xh^Qb&U+OLDma)|M0$e9tJ
z8~mg#m1^<TY&mvby-c5_T_+2eG@1Hlv(@$c)H=8*I)W#IwvEJef}XOB^%$IT*|w0S
zNt?s2cIn&jvZ8ufjha%NP(#p>BhS|Ur&6|MVP^<#-CjW04b~D@Is1^1i#zxJO&ie#
zDi*AAOk5Z>VoY3-eoj%)1StKB#lR;s`6?>1WS($`A<F2Q^WQ~aHqKa?JW6WUv~D>z
z+0x|FRTt{n>e%n#Z)>yG3`gMAsMlgQM%>Q=6Dj9vnuF<IKt$Zz4{i<~0+azumn)Kx
zvsp1ffW~@0OH7)|0fiU27%@^^Xy{8H3J;~Lro%LuVXd;;lM*e6O5MwGEPs8jS+o4`
z{lRE7EUmH}*{CEb1W9@)E4~?AjuMe)q5kk^QQj~3u<#fxfJ)!q@#AfYJKnm<p-N^!
zl2loZi{qArc50UT50Jj-HR}0iC>nR3Q*f+ww5b3M?-(nhM%NK;iyo$h<?pG(Nn~;c
z@@5dM>f=_oY&2YrTClg87U0-3#>AnF)@UbUJpIDZeA7x^s<um4z`>RtyNj3cTA(0)
zZ7u_~5c@(Y^6!?TWiGEZeOs<n@a_P(uS{;M>)X$a<oEUPXVy+PmdtCPe06V;rtA)8
zJFgNq#NPKT*1-#!M)JmUyJvtwsqA}`8Vjn;u_F82^S5M|G+|tMNLvji61UownXgfD
zq*DvhxF*)u3pYJY#*41i1ZLxVK7F(~Ek9ZLB{TiKBzO9XZ1Vb(lhK<xjc~*V$V9?A
z7Z=IZxo-LGrWbms^h+kKkhrgu@9RB4XbsQ3vI270)g6!6&Ey~fyh)Y1Q4ydIEw_iS
zD+CsR+%shZaZ#LVxP?@W%lAJ*5TtLZQ)P3|#lm43vC7^`>JS`vr;H|Eri{W=QbVYj
zzxKZ?lg*%kOZfa{GXW=k3TNZ~YCN7B46jGleh#iWmd5h}e>3zdYi|B-w(ll<15SPB
zd4GCAw#WZPh_i;X`utS~&Y=3Md0E)4B|Bbpg9JWKB~%Jd<=kU=Io!1prlRdYdt&R*
z?Uo{D-q4OH!xB8(1lr2Ybv&IMjIQK^ZlYejPWixR!t{k>YgmnOfIL^(wU^fbaOAx0
z5drOTM!wIK?Ga%ScPDb>Y+<4ny;=~uUUv=mVn3bp1u3O}2JD+-<is)#2hmbotgx;;
zIS`;=tUz|7;rTXO%hrxqKBZB-+t@sR+QziAT=C~y&L)(3LfI~T-{-#}jFn3$4c;Yk
z;Q<wNTG=Q<$SsqD{dCLbukK&$M0GXmdz~yI@sFXoM&8RdlT5KG8Hl`yz^mGLi|>_f
z3y}~gI{g$5`vDfNP*C5?x^V3LB>b0VjJJDy;I0^InOtYfOEGoBtWHH3bV@8_+(sku
z${01hJUR4zGJKv!p?Dp)(xuHR15B8>=R{_w4ZrfoeYMIKi3M*)HbS)h?-Q-$E*!pY
zTi@1pJH368HsfsDoARL|@~cIAj=NFKY)LG<LA+?JGUGTy{=B)c;N22~avY~tDwiH8
zcoh5aHt@T*4muCj1WX%CFuoY}caA0?@XTjpb|wV!5FP6w=$s`aBfUlo2nm2gI_|W%
zQ@zItV<(OS=)Ag~9W4K8cU$J;aKPx(a^B=~uxY-u;1LGDzGa-06Ni0k_yUd4sVpN=
z7`}xsz$O{h=qIbM=&eIBiX242=Y-k}cJYStN}!J-0A0fnQY9rZDzt0p%=vo0zUUod
zI0#z=)^!8PXaw?m9%0R0^g61wM0G@CSJZR>4c-u~TvoxtT*Stx)bOfLa}d9%Jkk%z
zS`N8OQPN#i7^CmZyI3E$Fh|u3zM;d=8)wCl@WZyvd|&jOCtb<!L$pj9X;dsLz$d9B
z$?j*_tg~g;oxPt7$zh+dzK!+^|3c|!-z8@npNY+6I9#OpPW#QfcV4<&j@f3r)45kk
zL042qcFC{jw;%WeEO5X7j>;^01%Z5A8sfe$zTXcvk=PoBvn)4jR4I|hM4I|tL6r3~
zq-VH!!nr#lUgm9K3rZE2@+dhB2jZoY=&7q4r82Cm{M3i;2{i_d)%6Og3hq2}usC>{
z#4><bp~%>4ZI3o2Th09IUUW(x>$#O}s4nm>yka^$8$Uu$k-VP9{!=-c)C|UTciV{j
z+)YDZYal1H)aNQ2hSZRZC4p{+(AG^aJCM~9yB3U{E4&Ui>eq_5Bco=<aDf*68Pc>p
zunM7Op$LPhjlS<jtYy5vdN-oE6dcYdlL_1f)qK0@JQ+wNU8X<K;iI{h=Wk+67(TjR
z8E(OGOTW9q&Ob+Z*oiF+I8S!n2m%TV`q`RO@O!#mZHIF8)tDD%3B!0^vc)hHg~@%|
z(2d#2c+tq*(1;xNvH^9LQYOm(P?vj{BWXo@=cuoX62}t9!kqq{u_OO!yzlv8O2!vf
zR@^99xrGeFwD#jr3k7VpJ>E}_=+>3oeL|cGMJ+R7pJf!RLe5JE&;k*wUB`%b#J~dV
zJ?$?9{AJJvl;qOsargBk7)8`FGSztV74Y>e?xLwLC0L$Kmjo(0%E-t%XddDXFuu#`
zu&^dwdZ5>0O9(x$a1BBGt^Ba0K;q?}H5ofIUaX-tJc+cqgjBg#jo`4H@h<D<#61RJ
zITL_1O?n_)=atSMryBlarsJ?!@ofzD+ZgCqgc$nQPS2%&bljZ!VP{uXC{o3nYQj5?
zTFhyT(&~59V_+$LsUvWGn-Zx)2OHmR<YdwX0bJ+>EuY-r$v)e8o|FA$h2GqWb$H5}
zXEkmW)HsB9fn)dk9W7|Gr_i%5B^92%AZDb@Kv9-{QN3z!=we^lE7+ZoRdNM3-{PJr
z#(Xj!VcX(O>RD4G49pPGOGUXs(!IlnAGY0ZY!$(^@ejpkpse!?=zm`jfCZC?X!&7p
zbt)NIu-i*H2I<RVdjCH{?jblACQ1WvY$rFiZQHhQY}>YN+qP}nwrzaLP3GUsc4pUI
zbvC`}>Qnum=LiPo9ElQ%(#q+;@Fqw6GP+HVxn~$^7)QvrO07KW*;nmhq!~b3g-j=l
zvErY<?|^n#I0vc_&u)t|XGuy7m(GZW%3yQ((i#RAn5TBF?h3i(_A}~WBd0G-Mee90
zD|4wh?l6@4Ru$Y^y<UF@U1Uor5=SG)-YR^)zyl&ab=5|Rhg{8b=?=aWddoLDJWSL%
zSCWFWL*6Vy!;}FpU9EpF-(cro)$oVV2)L;Md?E<dF-HRGAcEo*MwlzsjDqeMtv-&5
z)z9@T3kjL6VH-&!V8J$8+7p$V%YTWyn<`OA+yn(TnNb<!S5M|;OvW{hJERhdbMXLj
z-5*M`4ya+=a0K@GKH2BT_lkH_o|1yLS-jf1Z?Q{F8SjD@@Y?<UZ+8)4EbVFVsfUjP
zEjqPXeJjr(*byg|-~Hs-TYH%&k3aUd(sMYoKCWg;%Vu*B*rw<$F96XH{QX=!2?GiA
zA*Pe6J&^gLtTEX$ihYCp#e@w?@jRsDlRF>ciR(all0nw9F+T~$-Mp(fUM(q=V4;LQ
zTb6a(;z(h`J7gv;Qd9*S8c*Gd3b&-e>bp6w09~G*((W4}or;Z>XbqfCc#Z)Z^nE?9
zCNudqerEQqKS3kV#GjazsN|;kP>pY0pL+H8pz|B5^1-ES`^(4a$@810WGQ=|^%bCM
zavHC^vy&BBMu+y}dqV&<mIOo5<d*fp#2&i5=0XZGY-KnZBNcs{{h1;@Kl8Uw+R+%|
zt65qG6|7ci?qCD{Pe9O0*hfS@c+>Yj5W1zwD{KUYH#!puFqG(2ihSlEXyS10jQEDw
zhml?+Bki;(g{Js%#==UmT;7Pw4ix3d-<d}|^NQ<OF1|aA<JS`W{L$fr+TnoXeU`$t
zI)|oFDh#>h6*Q`LHqYW*_L%_bpMpa8+)a;W5%Qm^9KW~}?c_ukd70|HOi2$lV&ST!
zLbB>s=1EE_;gYA2#p;XnULklX$yC`>3^$&u)at>0i{QH{OieC$^&b@d(FlK3CW9}A
z2~3t9j$5{%lwVc7DNgbj;@6N0^76+_+<tyeT($Lz(b1MG)!L>hwOHBhyjW8_<|l~{
zcgajTJUhEpCaV{lQ|DJfFN(EWc%Uj$m@+2@sDM8xIV&JiqX|Q^?T_A%`hxYrfNEzV
zWl#rhoN}ao0?XX7wDVNzoq(TkU^ZD6tQT>J*#TWV<&D}o6QkWi%ax4w@3Gh;0%!lF
z*wfwNJ32d^L$?m5Fo$mF?U&j8lhYUwy3H8r78`E?^$@a|9<=YJN3%RC)CeZM+n?}I
z@`H<u4a)rx_+g`QA_LR9C+GsjW5BOBi;wLe7~E-gHa0Ni%QCA2Mc?p)+C0q%8n29(
z!*{FULJP&ze<xW(i>;AyUuAK1YM<Sxy4y0AWVJ<NDXsR;fo;3zZK8YIOO0ilsuxyT
z1kMwwMvcmP7T1rj_ooo|SP$&sUBX(`+teJ*5aH`*jsL~@=j{NgTiI@{C)q5FX&t|3
z+hD@@qQa7pPpYYEQ>#AU+aOCNjBkp1Q5O|w<QPKaR;wo?tlSCdjbbwSO)1CK<y;-F
zbP8$Kt16ng94A#wge6By;onhV%r*M$3$9RO)#x8lYF>N<;Y69X`CFKHw6yO_WeK~;
ztV%I-htFg-G2WZZ^bP+STLY)^)e84os1ohkIBadD>7%U{_wjrmY0HhYgS9`WSW63}
z6l$qd7duc9J{LA8NjmvxlAYY03!WIJVJZ*t1l_rik~<#O1-E`b0WB%NVmFKebf<#2
zuaVpgJ6q*cDEq=(q|l;?Ws6SCL-qV1?~rGur&lW~9sKOBY-)Jf07-pTbH6I|*@zGW
zan^F?vmvR*#?}t@w&%^>%{^oNJ#@-<_RCVzI<=||xb&^I=^XlU7Ernx*{O&~`wTwu
z&_Pr6GXZwjj~khC?o;t@J;Rp_tz*HPpDSoP|HX3yycDt!D9K3ZCrl@>PIIU8jVQha
z7t$sgq-$1o_RIHpOZ|~CB<P511QKIO%+}LO(9oG*yIVl~3THb2M$-nGs=(LNN(8I%
z=q?FY9x8SISd4!lpv?bl^;*~RLu4Y+pd#DrSglVCgtpWG7w4JZ@88iThh`i04s!Hx
zaW-ht-awNYrz75DJD+(pj)1xw%Ua2LdJD5vTd16!ZQVcW)}_p!jJ>O3(GK-em+~}<
zYEAU)9v~U$z+@C(nO|)D&+okOG@4zf=*G`H*zsl@FJWpQ-M(tyb&9t69(ia>lF&I9
zjBFd<UKaiOUJ>4?!ZO7<Wb0>|7knA(of}42+zns1EnK%uK8Vmg)00i^=UZd0B-T@s
z-S--)B(!36Xt>1s#PEc##AKC;#ohn3gEq^kX@p6k1J<<iWxPwG2hJ)}4q4;y=at1J
zZ<_T!72e6);F}l{V~hQh-BZ?xHoW8~ggF?Fe(~wv<%-vylK6Su?xl4V*Q^hdX!k{*
zFTGC@1BSXPLN!+drd)ZTym;MLcu}NQ#<W~()%y&-m$1o%&DWQ?M~X3{{ct2JHipry
z7WrZ=+9Fc0TBk9mw<W(hzPd$Wmv(C(uKe=RdKQmT(lRyb-AL0(PryP2-zT3rQ1}O#
zihIe|f+TU@VIf;^3X#F|7)`kN*Qj!%=6S0)3N;srS$N#7Aj4R5TR`BHXu8CUm;W5<
z-3v9GV)7L&OxB6j3fF*9G}P83@IkIV`8yHqL_l867SUExchDf8h~v#2Z>i(!B3FNC
zLb#PWX2-x!&x&RZV&$8{>8WXx>MaW_xn{%;csTXH1pP%$zQqgZK$z87E<FwYyaw7I
zW>dJWTwv7R?|Syzj}w5P*EXs#==iqfUW#_+dv-eq1*~B%cL%Mpd|7txUDoEFo(?qa
ztDD6f&(?x}_2xt73^RSFQ&FYqyrlHu90Z}2Silw;(sD>5T$D!l7IrKR$b2NUxga;V
zgYzM>99Xlc9<jl<K|-Nvh$4!nWyXfE!94OlA!AU(Sb69m^GA+*(EP~0N%WWiu~R9o
z%Ar$bqR_N5$w$D8f~WN=cep+{)9|a+2cwt8v&9GCOerI?Uk^`XTIM%jFU!4+INn++
z6}bN^+cRzCqqM;NtUax5@h<Q2Cj?}J0hffdX$?NyJ5C<o`nu=c{teg1P2xz`=lH+w
zmBaAjt5MRfWxJNiV#F$4>VARdL_E0a-$y&Y+Y665z$=coeY5kN-+o*YSCeRY_Puc)
zL|`!vx5}wVgBbmS6orU@Eq04M8`jLt%PnHVkt+Wnhm1_a+OE6+vLh?6GplbZ{-2Wj
z8^?3`2e$3J&7KYir!YAF7cEg?00vVhJbHiTXHp6WnZ8jCRXvAgF`^YKsmFCdyN^p~
zKLgP5jk^tgtR^jTwU6y#YLHY$<Z2A(Ta*DL1Ur8h6S>NStRG={S+;$29Ed1+g7L(z
zN@2nrPPoHKg&gGI^9oEZeY-I>m^Eut4T}UGcSj`QJqXd-%GyyDKMz=qW<+Zc+j;49
zhwS7ul}xx$k1KwN_JZpWF|beH9Hgzra?d$f827kFFb*~<JX40`%b+4NRO6O1Q}%_0
z7f;0I)DAO)O6(?-xa?;TvTw^SiNAEi{5ht!6GBB`t2w(ixAu@YSDdumWC4bUmi@gG
zeS=)YW6-p6nF;l^1q9RH(}WQdzN0#6QiNk`JzodupHujFyBHLs%9KRuz}7xjLCOX)
z&qUt1ip28-^YT2es{!YP(rAkDv8e0zVGT%D$gZIm);2N*I__x5fn(B%=Q$lKZttrT
z=N*=ShRXg6o{oQ{CbF(+-R&*iEqU5{S4EYKi3!7!ovpIMeyC#l`%oVro+^RnPu%l{
z>4KKh7R)8pWb}LEXCXpd{1PY?xe{PqV1`|Yv><h4r9zn0mE9J(9$J5DAdWL_<)8&u
z@_B-In>Qnr#0yYlm=)vq+I@{|3z+)cH>#V4AUysm<rJT=R;v7((mhq_fYtlNDj(Aj
zV8y*;VirU*hicloSZb?W)Sn?oW`?oz4=vLtF2Y*u>!Fs|wt$$;2`1p90;i6t*=Rew
z3JYmbs`BCBZ(@S_!=mk^!2x025Kuw2#ec9R<kn7%RSFOC9fgk9jbie}^jE0awQ9$n
zEHOc&CBlay+d=hRTs>bL3#!wfcNk1+8F8AZ1A&Qn{DBe7x(`wP<Awe&UNqPG&Gu*=
zNH%q{(pnA_2a4*$2^9Pp&0PrwV&f_C&tXucx+K)mE*Oy5NUV<qqbFeCeL5BxSVKvm
zq2MdwvC@T`r!dsbIe2$ZMkL@}toh(lxpRT1kcmo2ovF2&bL~7l&ABAuHq=WpwKGmR
zg(X$cVR_Yp#c=sRORJ(>B*t_9R-1eBV<D|Mt3LwZsfp^QbsJ12-WJwmz&ISn1>u}`
z!C=PdjeocA(sbjtPu%#?Ag(;|7YW#ZvOG{HUxc6Ub%JC&A3NOb;lE!zb5FV#lkIui
z`G>cL<jWlde8}Mh#PP>r$owOIc++py{g18S1jtcGI|a)Y)iby=ok>U<=u;|ZrB#gp
zvxJ&VAx$#vDJXi@z-Un4XwgT3*_Y0S-`0%MYrl^Cc`{pQqV$*3jghu8tv{ehbg!am
zZElr3ifqD-8Lr*QxX%KEGmrczbBp*AtP@ryAKy+VFmH4r!nlGM8ubpsn-=n->JFwA
zfw$o1V2lE*If?~QmM<e@O_|0r<a+S>z5G=@ddHZebA;93<Ds=m-v}9*DkzJChOi*%
zT+M?9(K6)Dtzf}_%VnKm^Od=IOX4AJS~5l~N+k=Mud+}szG!8>N7CIUOyXMRvz?|+
z=T`Dr+J|HuxKX0guKCVF@{tk;z`A-sjEaEq8<Qu-%frHp#|h<C5*H`*ka&9>BBKH%
z;sk1+Ps%7?FqZb>c9`m-wn(Mk@WZlNdK)6OA@yJ0#d5hW*u6SkDj_U(Z3m7fE#TL-
zI;I4kx{B>$pzR|c=?=)z9Z6uhkl-hDHWeAKlcsey4JfZca8+9im|bx)_2<;Z_D+`0
z3fzIwE{}fxM%iqgfdS0d{KwJgi1wU5LHe7af_vac{1JT?7?*fX9XtS(7hYj<_>^~@
zE<ObcprgIj2bDa|s1j?MmD3;9YR#u#6Zqi2zVJdhX$yOjn(o@`i;LJ+E_iqG7erNg
zLMtFA0Lmr-20SdO5j+H~0TUVCy*|XSNsPESvI897&$n*Rgfcg@v5wdWu}X$R%kzKE
z1nW9hf;IFL%?;2$SOMkA{)9jR6=>_g=&dVq>|~`?K>Ll8Z?ml%gIU*hF%be;f79qv
zwz&`j&ClHl@k2AuH$Hukwf>k59Sbp|qRQ@fv4Z%v>rKMR7l-n)sn0oE*0rh;gwANf
ziiHHG3i44<6RGh7J?Q$#PN_KkVJ@nZyV*rK9jn<<W02S><BagL6++kRau4+%AW1)9
zw8W^Cr3c+{2(CjjqQ+6F1{2?|P8DR5vfg<#qp1Nix~ESphea=7s{KVS4Z$H#U5T$^
z>tFoY%*xjiiry$RrdcF_g^K=5_?s`z&$PN}i60Ug7yTobZQ^~p(3c%P^Ueq5xIXzd
zIdgF64<r@#@7>Y6)B8^9E<m!L9?l8Z!;xwGy+G_Pyfv2eoZ3<b5maj~x>}0AKfcmx
zvpXcCqVR)TfU;_SX|Iz@Kc)zAEGHvW)4UcG=z3~BeGO4l2HHtaQ^u0Ew*a(nsh4Jx
zU!X)o7St=2zW2}1u=EzWj|NFE`5*lYzP*X@+E#MJPV|<tz-wX8<KpZhW-duq8})by
zOyR_(b$qSf7AQhaqe|XLf8<}TrARnpV@l=RcLHV75s&Ed4EjFR5j?S$k8J{$ibSDI
zg7|_r<Q2}KxbMR(1hxxB(ef2Tm|Qy<*q?GY`jeQKo`ql{K8yL*v?3#tsu7O99Cw7r
z-Im7LV%>EK2_exL4hqA3ly7bT_U{PCChg~HEJj)M#ce&G_vKq&x;JAHq}tBaQ?|Li
z!Q88awJtv)v{x@7U5!2%2yky<*Lw-NsfnRR0hjhQ`~^IrpdgD)uRRRK`rm&2I1T^d
z{tAt|HEU*V0^L9OD@<7~H|eFtG()xF{eCBR{d-s%ohWe*JzO`?rtN%9%&KmM=&5y2
zw}*cE(F%Mz2HHMZ>~+>lHwzKu?57Z@T0SzwW;YJ-dmJchlcsvTv*A(>`uAsVc_h}#
zd*1+Z4R3Z+M!3=KHUQr?08*hQPI*c4RAHxqD#w`?hdHc?#kvSOX2m1N&6L{M;MnIB
zUvg;rgCPL{2_r^Vax=WVaaJWlC+=nNshQS5M7`~$oICtBq#Oqy7n=@2ws`tErCju%
zQuU)1<LrN}ua5dPXY8ZG2~tiJB0-m4HCW}+<yc;aeIr(R85inkMqynstjyEy`@esC
zZM!6L)S7pHn2gAW<X+n9tlB=hy3@a`)c}Hp@vuu}0mI0w%CJ{2hr#nUkqcI}vX%}P
zH#PD#>=mz-e>&OjQbd?M&TzEjdma>pE^XmsS6Awv#+rnkMm@?*=c7`Fc4zMU`Uysq
z>k}Xo(VR4F8ED~)DpjFK-?YhZiByj5DxCDP;?aA3eV*p*?@l-bp;a6lzK-yGeeU*l
zKdB6RsdQ)YA2qDrWR7!_dsp+Sx%TLm?#6zc>5|71y6yVn{gQA+T_RvFYjb%E$NPdc
zk@4EV$(1f5qdk+G^gBM+XV%T<Gc+F*qVFWu1~MS7uy2y^^8NR-=G3aUxz+2f>i4<)
za+C+Yz^o-xw6p;-wp@WkFPuNaTP?3?R8jqROUrApb*$cj$*mf#_uw<v33FAesuM1h
za>cBnQ%EV~f{IPxc7u1Q>Qpv^XX7m5bjhvm82b^uFLX0bN~!#bXcsq(PaLa!1%$NV
zg$cWPC_w;uft&(KqA7^VE=ENgUV^fm^z-iMT;IjC9}7$M6$659KUT@O{ch0sDBu&{
zl>4sO8+x*tt}8($y1Z0ob<PvpVzoSSeHRrL{Q@Ay%AMK0jk2x?m9v6jEM~<~ity&^
zv~tzJr-1<fe~-ZCc=ED;aw%?L_cKj>&mS6ycJ5%^0c^KC1T^cf1dIv7_!Z1ZOM(-(
zJy?P_(jHBqv1y*YW>#KupuGs0J^x%IR(J(hbvxKH1O^E9GUXO_=g3!pzjh{UZH90a
zfiSfL#SZNH<dA@1Ir;PiqQ#@}4$UXx2e6(tQPpNVD~m3e)H%?#am4Mg=ZiXr1uS;R
zI#<xR7yWzyBa8O9c9)!fpCgU-JIl(Mi>2aSS^>)o6dJB)>TKDI?e~6%iAMAPmf!dO
z-G)c+zANP4aWycb<8mtk%`YAt0CSeBa!C*x#Kt;H*O^tZm%E&)J4^qYDvakYcge1|
z$WhS>`6)e1325HAxxce;UppN@JNd%;2^>u1+#mMR|8pakndBgEDMQ}LTO?9X@Ne#~
z{9yzab@r9_+I|J}=$)X1qBg(xp@rT1R0)V1i{I*YzE)#!Jj>jpBZO!JJJCVGu!AsR
zNQq&&_W5-=&k%wzR&}kwSo{0zD7xP*osYNvU-Iy@Jfx2VeJ1n%+uU)I1zg}A3x<6x
z5D(L_{EZ{+wi*GDA;fau#)smkU2Ln1=eiRc771YD&)V0BWBsaT5ck@eIhY4@$nK$e
zfxCJwTy<cXH8>-6MFeX3L*|^IUJvZNoS?XqN}rAiYL_`bJbUJ<F%P)6k9u`mc-QUt
zd21;KGaZjh6hjTD$e1JxIk#4NG;ngWJj+LywiZoOxAH`CXgGq0u^F@({hr&zObra|
zbkIsW^}y&-v|`k`drus1$eLaP&uVmASL4R$y%dho03X-Cd$Ek7aIw9a;PM$>GO4p7
zuvxBVOuW@oRWDI)EqHl|hJnlrKW6QraOkhnoKcY%N@Rup<z-3_Iv9SU0=!d*m+`S-
zsSP7MTbz~llRUrodN$}TNAm8V2KOg!eEdmU6J#%NM200Uoc&#!yC>@a?kSonyuOvQ
zaE;KgC*;_W0Y@g1#HP-`5S~-jrd$!4Fz&xAdfdDh8kjL%79(eik#cU$JGhM7!}8TU
zN&5?_{ncnjE8L;N=Zu;=T8(oR$=Q5b5)+oLVo%rLaTDefA`_?+`hJj>gGLizP0-q5
zE+mkRdsOy{&PQ<iVu~4PUtJVkY%rl^-a(Z4;!_j{LeFbGuaf%HWqiIr?M9&XwK0L?
zTQAu+c}H9BfGKk{hoglNKA3B0<-WWD4ASLh9;yQ>FrV7n)oQ`~V@FOmI$76V;M!_s
zs83NDL|emW<kj7zz_7z^vMA^imJG=vhjD|;vV+aqwZs<TE}7%`Pu^Og-bw0FGS-s9
z70KaRDI2X`j%rsL*|D<S{Qbs%k#vuvQ_$+|^5pdxXjUS+(?wo*+cz<787zZhAJ-jh
zU%lO21X32>o8LdFjbl<xn@J!EK*O{9hViK9iRvdTL1}vGl_s`ABcR>D7;w(=>khJB
zoY^&RVQ^2@2T2YF3=HTkpqgjaK8gu>Qo3@LRumRu0weBFN=rkLz1oZ6eDc+Nt6B@X
zLtuM(pK7?Ab&!VTVkeK1IxL7U+AI1VHIfvba99%T`Z}Atx!4NNTTB+FDw0$1_)V_C
z$2(`UMXWqf7;SOWL7}=wQ;A8b%foub6^gahgHzZwmB1x+>erU*Rk>~(6q(x4)m;r_
zQ#0-O4mE?J=Dw%i8cpB=H_0+3#Eldc?GUm}VQoD6o%J`?Ko*v)kN0zP*pIGsnJ$r&
zC1b>AbO&L-!`uVun&JpXv;bZxk<kpq?if|m6iFbg+yBt<k?z!nA*{CTVVI4((d?n!
z9A-H1>e|R<kRA$OQ!0I)yDm4pycg1#vBBVQpoYq^=fFGMo?m>YRhno>Y@ni*Ju={@
zE_>d7PB^9AB}OP^aw0!i*+)uEx|(x6D8#zpq_XtaiJF5z)=&+iU>%NeN89TYhg*y+
zPPP>yea~f^&oqoCYpOm6?>}oZ*CNfl=>G-#0N~5s|B<}e%CuC4Y<Ze%Ak%xP%kYec
zC7PFUbO>mGfts)<zPK@Fz@wxrjd_(Oo1lg3<sarxWx_rU9>UXJGTOWk%YxB(5=8wC
zw+@V>?#~ti7`6FC{8B6sTLXc)x(iFASFg58bMVNUt)AbJAJpyxOv5~{5{E3FnODGU
zHqk?O2MCy-F4lr#$A;cnIVd<hM%B6Qs_&QLGC0M$B5%F)>FpUL2F3~xy8il5ddP>R
z=53g%L$4Sk=qmI`Rm#1!LEw@HhH<L$m)$fKfRvSof37~^s6E@zMl~^_ua4Ngf~&b?
z-c186o7gL{ok}H0jwqQen;3w-(8M<}2OBp>)F;(S(JIkr?&1=U+YTq(cp){Uw+fzb
z3f5M2a%@_+GD+5%miB;T6nOH*2~w3^hrJ6mHP&7g0>L@Yq2Q8pujcE}bvK|_sBhP@
z@v1kmlw<Ij;JubLYpn&%YkW_?=&gnQS~{z1d<{eBPmses?jKQ-u)CTQ@ditBjvyE$
zjC%XNTvFNZ)kcE5n#qDkf3pBNNs`Yqb$_rNEtfREExnbKn@i=7MZQ9x0D&&h?zB8U
zMUT&(fc6N=rrq57*U8;j&UC$)rvZTTM~Xl{U{IY^mGJey7zV{)70HAFTfBM~?(&9+
z3U~U%Y37*tGi#DNI6$|hGrx}9*+IK#^8;{mraXP>Nl-zKcLX>Lf~Rt@H7>#%rclZu
zrM^$1_P2LdVW=jixsMv5gxB#y${TrANxUF%$Yh%X9GSuRr=?WCJmK`KUSbBBxJd8R
zyH1HU=*vp0&CC!bLw}(aCnbTE0$n==x%#5i(8T3b=2o1J;fusXV8EW1GLd)?LS$u*
zwVi#EOgi%6N$}!lWsT9Fol52*ym?!s*6OoqlUi$X>?B&L_8~ydf7VtC?+xS+w{GkU
zmA$Se!RYOFWv#N_tlDf;dWr{WX`?RIi2OGPPZP3}1}(-ct_s-8R$j@G5zo4DdfNOA
zVmYf2STYg3<X{FuLrI^aY$<+1Axl0g(Ww_^D4ws7b3&$1Qc7K4NC*L5Ox-D|-2o@l
z)#nOV0JiCwc)Oa6s!*ktm?8YS&3wwDYIel#rl_Boo{jTEExjy<h#)d4P!G%Hi;FfV
zz;{N(n4<;!ZE(V%pKwzjZt_c+Wxcr$>5SK-8N=V9!J~&n5tsE*EhC{>HyP96&1sq%
ztv}fRV@bT}Fh^Xe!*)3;T?_*sE$hU4{CG*qY0NzHP1m+slO*}Vj~YZYy8*ia_UXUz
zg>u0jM>BY3x5FWLL>@pccti{pKnj&aOqO^=v~)(6kVL!P2%m%m4GTsHghn^+$jp+t
z=^J^=iO&<4%+bbyb>GbLNHpnYAr*Nm>KGTho*Ahh7kf;aycx@fH6Hoz=!P7*x4){}
zQ87h)GW$k$FG$}?RZZg;pz#l&yQ+IDdh4*?a9y&}VI1srBNej#!BHUriPJ)B&9R3b
zNqO@Qh=1EDreqRp$=)Z2Qjiz<^;Oc;E9wXhj_$e9?9{LJTThht+}`4w4R;GGcW3=F
zkDGO&p%q%|Z{96s%y1c&fEZ5?*U`UlbMIL3<JdMV^)FGXZqaMshkIAWGrkq?UNlw3
zi~(3I*tllZ>_+Zwn|M_Z9@<!e+|@zc%}J_GM0+XTlnnjh6X6S_kgha`c&!*LT?oN<
zCTOj*iqchxkns^zz`sO01FO#S-M_Nqtd;z<)F<JnmdLln?`hk|iVl;dQ~FK?4xQXS
zv0$4F`sxm=yKDa8=<IB*tgIg0ylrXMN|~u2i;hfKI%#yVb|KDGp1L4~fgT<(d@j#B
zvpAZ_VA(S>-M+K6Y=kg2i0pkix6JN<7E^kcg0<Q$$irWujCt=5d7lDk-zuFIE{t{0
zAHEJG{32UM)<CY^B#F5J(a;oI5sM62hA@h4V>ZtCs_oypx6Yr1;{^4oCns&62$q@g
z;P!SyK=3-&OVeX0$+izxX<%pb`;Ff;QZaN$)+*bxTV&B{Mb0v^@pzYZ{<SrGoLWU#
z7^NVSz7W~1crMx5iggWC<as?QkiXYzox=Jxmy_TjP*dB~{0~t0U3fa}6#@%;m2w|B
zvPx;AfE3?bHn+y_F?9E6`eV;>`jB;^?=q(A)-OiI@s)Mciw~g4c{#pajPuO|UXapu
zW-(21s!FiaTRdt7KXx-$Sh%x8_4q`3$x=rX7oiwJ;^BQP(XDUy=BSuQ$V${LPK>tm
zANtBkfAgXX>^F;_x^GUQ-nLGRBiWgG=vGVJ?`FcXR#o-94*N;i?fYz4TgHKcb7c!Y
zR^I4+Y<z<xfSN<E?>L%(@=m*q+Wf~3Kl{CP>JpNp)hTWG*22kJ&>p|X(Z{}hwx4~&
z@_xtK5yak5N)DJ_fknZIDxOG&09_i0y^R#|UARv3rOt8{F!7?yu%@<hB8Bn`_O?0q
zIq#f0_CL-3yX-cfGfJZnuE?-pRH?aSvyk1IWX-A-3*d87sUBXmO1obabeq85UN^pN
zp(1Vh=oGKks!71YJ&Rz$wAj;0qki<QQ<mOc$A#h^e(cl>S1nuEe$4YkzoPS!vk?Kc
zK+z4h!&WZxT?tPlz^dR;!oe=(58_^sznT*YZK)NZzO^vcDt`#~PxQt2=4exMvDcsL
zzsEoRkZ3ieLiHDZ&52U4+!%}>i^uOt=2Kt89PzjB0f_J0`SsJ&<E|uT(mi4S^aH+y
zzk|jx4*Fk)#xY1y_$BHsQ$VFV%^$Y(oE1q_IBk9_z00=G^7XRwc$uf#zHZ{w%U3tM
z&bRO-(l2Y2pS>pRUD&CG`HQQS4xhZxZ2+3(JQgYueRqzPH(L)L<!a=~m#JEObY*mb
zfoTJp?ZX$hc6NAemE2i7JhQPp!-<g@y2OsYJI5M0cv|rqrY-jLnX)Mp8zs$Ie;`=!
z;p@x#Wd)%0*rJFjz9DvEvlCEcC8D!l{F={1x0T+jIw|R$=IPbHEoUJJ_hc9fmJx;Z
zU0DM|Kelal=`m|@<@Az^j^s)HMbe}GOKx%%^*W}zo0SOhX(e&()^@wSAO7bCLE8uK
zgQUl2J}->+Or8)|LBU_{&}+GR3O!k`*D$J_*^zfu>R7%rk;&NM^1(K>dRRF4HgQ+@
z2BYRuEDMYrrAoxJi}&C@3gV~dr;0ieuZ;t_Ubs-3R8~3BHmfYBy;<L)c$hp+yA-UC
zEfP#|gl}_o2+UVrz;yLEC?0w?vY_-Py1y9cQNTh#nbtZoyKgi{V(%a`m#(<F#)}Tw
zK4por7A5A@xwsv&dj71<qZ?GA1==>(M9-I4!IO1^FJRE<Cdyq4`o$fCv3|bBYr8U_
zZ_m1e)zUFLm6jXHzsF1f^dnO7Pc*vEC=+|7#B<2KWpw5YJPp2t;~BO;-Jop<w`~gY
zAud!-Z;m?mU?huEo;dHq$j6{=S!Y-XQSti$91T^=as~1~oT#7`SRDEN?}{W}tcHyt
zZ#qp4qD8zH|Ew4(#`c4ZR`Uvsp^nAR$IA}DMTYQkuQStlxv!o&dk9}+q*85bIPZt(
zOv89obVDFBACu+=_LIUnIqxT7b%*`n^$l`1xx-yY?q3u?DB7V#<#`EB)c^=<l0_vl
z)}O@)8PYM}WWIXsYJ`lLZAe)*Go7@<P~hdeYj>?+y$E^F?gX}u86^c1%ku-aUUn45
z&0{-r4oPfCS=3QqqRzdtU+_G;aYUdcfmC4*pvkb}MBmI_PCX|`{<Wp3V=~Ojz;cBr
zUe|mVO7D*U0Et{|8w<s^4_x9{3WD#NQ;QoVIjNp8aQtp)nbQH|Zuj(Qnq=}~m;W+i
zeCc>aF>RlBgCf1`?|C?GnIeT1B3l<tqB}Y_hH6uEIyZ$Fn4hN6+7bLG;_<cF#@ElS
zjgaSjdSuAm?<w11Eeq3-YV4!WeZ_XQi<ung$osjK6Q9mueOpqMuyonmD`{S-=rkqD
zp<4Co+BWjOt^{nKTDuUj#Y$6(Mdr4%4>ahLaP-S(=hkxF1oR2fCCs3(st5tD(ScLD
z7B5&U61%TxI7TAW*ATCn6p7Rx5|E!(4U^n^$o<P(6n1=79V+%+DzYHzO)?m9+U=Y9
z)mD6z2=C}cTbHi<ajsDojs7oT{O@%L=`a<kQYUi;@#CmZ@G);++7O7Ny1hh@k{ZOQ
zGB-c;;q6=<&OYV=p7tj8D^)8NY6#}RVkB!<Y-!}pvla+&qaxm0v&^Mhn<rL`)ne4S
zRh5fIELq<oq;cFby@Y;1u0;z}Cyt*D;x6!7r8MW>6IDJHMC)%@RO{*br1Qo3JpOl(
zYK0!}X%3atB}Yb1I^w;AD%v}HVW&6{Y*w*m9BzCY#rUg&Z3fnDT_Z+Ra9{}G+H~nr
z$<h78i^|Y8lB7W*(BsMiR<=r!t?EW1=9iG8u}Hmb`3c?~^oIj}%J+#ZfjwOFd9>k&
z-Jh|KdmH3X^;telt24a|h+W0#YlN@_cUY1xS*K>qc9Wn&*72xbtk6TD72OQjwwrA0
z5^~1D<_8U*h<v?tc2@-n6!*{z3=8eRqx>t5OA9w!1@iox3$)f@Om|EXcUjr1Z9QEP
zPdVn}@7rq0bZCkzl!-7r27|f6w=*z!Ku&1HlffU`#)WNm<yoGJ)aqHj^5ye22F%2Z
z%*BkYQ8<>BI_6Ba|GAj*MxpXjy*5o31E5SOsXov6X{B)!YA6u%r30KV`IGDFXLH0H
zuh@BFgL%Eo(ZanyB~n;Q)a(`hVT+T+a3_4yjU@F9@$x2X2h)GptIlL84b4U<{+NmT
z=;e{H{37#Kru;ZV+giPQZPCJb{jxcn6F7Vfk!v~a-=a)mK6wS9gC|QGjOo<cic5bB
z0nDX4YzOn3y}unJac!i^)RnXLDO;40=@Mn`{RN3JL<+?}5%OG1_sZ-c5waJ7;tcn=
z$&#sN9DW~6nx*Wlb_)18DwH#_p2R!Z85kJH7w%x&HA!}}@-Htcv$iU4hQxO1v2YzA
zWm`U??5Q%s+SJ?Ui;{3lF)TYL@7*A=si14utHlbU=9gMF3zHX|g8iOx#o%dLoDwyy
zISw7+ndTGC$x|gmu^*Qs=J}}-Sw6%zHS|wJ>Z&^8x^z889GfWt5Wk|wXZwb{#0;-`
zkHdd>{S_W)b;0Jnzs$|u;b!LEY=25SeC_Rh(0=Usp*?=qyZcKLJ;41rAUX+QN;#0C
zV_xtSXhv(_sCF@-t|5PQG2g(8YkBkj;y@}2l%cJ$W8kz<Q)W-C-oB6PST%NW$?yFo
zxo;TFUR@a;a%PyZy%KK~t+G@6bt7N6UbEWm4K&D?sD4d=`Yd(VFYlw7LfLW%k@b&S
zc&jW=?IKi67Z=RB+gZy9sr(3}Tk#b#L}-{5YThBYzp}HwcA8L|qt8$GKAyV1cB-lv
zc4EuZQJcO@XM-2asuFtc)}(o-SFh#>^M9Oy?EQS70e+Mb%zUL)WCgbpe0h-ym5+JI
zg6l-KKKKIt4HUY(AK{kJb|y5#kh%aR)>YxbxoL_V$v$7@4%IAcz9J(~y6!~F1ZHDW
zUKD_#dr3qGSZO2KTLv;SZj}+@+<>*LFo<TAv0DsHMa&=ek*;R79<lmK=zvfq+&P*>
z{tz6w3O$Q!f!MMxCzXR5b-UNwF<AVJ%3EA+Z^N|XYBTB4KNa+oa&+0cDHQJ%HHB-k
zn`qdWoy6j2@7ks)nZaNnxH7s!seG+854rrFDcWW(MpU>D-}g=VsP9ZZBR*0-DDde{
z`zy@aeRL#8oxscaNi-|WQ)Vhmz#}A~Q<YHH3X?8lwH9$avRE<aN(Cn%;E8KQ*CET1
zP%RO&?2+L4m>`NmdoRLqN7PA7Q--fCel4~`HaF8`e#+j<wZrWk&8G{Ky@i#gk!^mI
zSfRkjMTomBY8ulz%UD`Ek)q>d>QL_{C9><f)|OsI4K-dGd)xK7-mJ~xG(XndUR~#`
zW1&FGLSEo?lXjyGHjw+=tlhXmx`hsRBj}{}zGkd=dko%+C1Q{;Tz$Io`C<JoLBi-8
ze)!f6NWXS;8|&us|Fj4GvOV_?d0wV{ukF{KmzHh$T%&&rd(TWSYSMaf@PBtz7gra9
zm$Q3wAKow4#l_Kc2gaY<b_D!HJMBKliy7zU(y2<&t_k^q=kN5O6Zpqk@5idlj2|F{
z?wq-Ib#ePaVO{A-;tp)=!9rd==O*4gA18ECV8<@f>RYP7M6N%W?njFm8%iGFwO-mU
z^#AD>moX_v^2<6P2V}osjQ)asmQO_O^Zp|P$Q-pR5?t}Du9dk7GBQ?(MJ0DVNcAHO
z4DoOG3iW$0J=J&w?~w*-tmf6*=L}nWz_&7(ct75?r*>xGJF&>T^_>E~d^Dcgs_Q)B
zRkkb8uv(OZm2aP1ySnNkGLqI?M|$L}N`<P}B2r=x6t>+z>iT?{$fb3h_3g}?_3GFf
z*C=U{C2`=d*7!8s>;GkLEl?&;Y*eJOS)V!utK;+dAdXWQ6Z`np&Aclm?GyU!i}s7&
zqyC~c6+b{Xnt|F~tj0QVS*iZ!YSv)znQ_6-TwS`;bTj5xXBoVx&Mqe^MeWCA?yVPm
z?%UJ6dYx|f_2mIs7xEXdMci9j_if+4132`TELO1r(+5h7VqcdGOxTawf{T`UL-q^y
zC~~>TPpS-)`E<^V!cX%s=VEq4i_XG%jgkH^pXbvb_$253F%$B0FM4MP3obN^twVLs
zc8UtQqG=ZpuP@8o-NL(XHOQ*pDPMmb-<z-CXTES4^c&KhH|?cKPd(LWVS4Htp@-Lc
zb252EnL8^S*Y{|4<uqJ#{mMu_7q1og?(bPW_}nU`VU#Y<cmM~I8tWF>LIjw%QL*5!
zFX6K6u^R`sua#``zSm*#1ee}-qrQkYD_QW;9mq)+Ei2<*byzl!@cOHZ?zai!0!|U<
z?_VMN7*M}|0nsr*6W7(G_mG}=6rc6To)3JWtpWSExUB6%xdD^a%G8<Y+4Za5>bK67
zswnGN4Z#qkgG(1f+7CE@uDy$rhxSEU2Dc#53E=QVazC}=?^IM?F)ACFX_wCn{ixAC
zyY_ur<D%^B+nAok>#GOp5&NhVv;J|MHmXsE-*vF%0%n;Qr-&6(cONKw+!`CS?9~_O
zRB`EL=2$Q1E8e{7Q*R~@Uv%;QNfq(nVec>izcL~0>l9V6&|;6!KL^EdH1Y9E#Fo8H
z>Gn41Y<X+JUW(rG(j2?b&u9L-ImRal&$*}#jvwY0gVi24Idc6OnH&B+LedL{vEahh
z$8=h|_EQ=6U3~lf+z(G5ckP<`>3;Jn`zm|H=bJlgJcR67DS?v)x{~hm8Njt4&J+Jy
z>!)<h^(W9pz<nv9A-d;d&n%)4o11}<9Z&Vx%GSIzm{s+03H8+sd2)*ti>->nS>P#4
zMoImyhr0&tPY{)#1?Lu*L&G{fcMl*k)GZF%A+DWn3=yFro38E0I#Ph}2e@-_AX2=8
z%*(Vv$!bxnMRLpI4Rnqtw`G~iinDrzwR0}Yid6GoAY#=wGRP59%*i%Z&lhN=A%WwH
z!G^3MNadFcJbc$IhaL;&1NwBml6Y{SV;hGvS{L!{&2F7rvkC*(VhkVpJ%ge^*Hg+a
zJ`-@Pf)~=$1$zYn95!(s%R~*!u$&C-#yhz9=Po9B>!G($-pcd6_vTP9%S5;BE>76f
z4;vePwhvV>*xryc`cjq}F~zV2XZ!8##wLnDL$#-ECcM>Nxvj;5vT`$QxKcQJI=^R0
zyMX)e(2LU1`RKZno_6^YoZj-+Ubbmd_lBZ&^K##3&t8RwjP2uTcYXIEY9^li(J>dI
z+&9q(8;^X(>A<a2tys{XVj->Rcc-OynZvOdORE7s)lkg3aJNTXn0@Mld*YYXIBe(D
zQHl$Wf4#na`d?mO-#>kNk}t1-OaH~IS1sy>PrPrLU%}#aYxe!Jm5=md*e}x(@iPXX
z+<HQ2WgzH~fZf%0dLL9(2D_ns8p1Oq;=QwhViHg%-r$x2!Xy;XWj_r@#=B|sRdKNh
zNE&Qlny%?1gfU~H27)oX$AC@Vc&2>+kkg8hVo)p4eR6jabrNekcBzK=fQdxF&$;ZZ
zGF|b@W<)BZ^pYM%8i9beIpMzl4U6hp(W?pB?zM51=wDAiAXIXv_7^wr{B%GUckq$<
zfB4esIKFEem)w)W4g<%Qb`4p7c6#8|w>Ctox{URFzuZ&#4t{CnXj5hZeyi7vbbNL@
z5N}bT9U9+hqBe<nML5x}Am4Y28V;i?cf*;OgEpCkUO`TIChYxi%>0T)Pk<R_UC-`b
z2BFH>+F1s3Hy-=#GfJi^agnz1qgnqkw{`SxNuNgPdW8wv>K2|ei`7~s;}`A<a;bc2
zQs&l7His1)1ibIoX%bsg+U&2T)23~gc<@|l2{ZSH$jE$RBj$H2j+jD6iTQxd%0ab1
zYlWcI`ri&uhrHF}1Q8`Xrxl-%LCsmA(Q9OhZ%v1Nx#itHyxu<aaq)R4#=b8acKZ&Z
z9i|-yz~)^l^sho>LZE2xWMhs4K=w%k61>Y`CWMI;La$V8y=J4p&j+RO0OIv(@(cm*
z&dy6kX8iKJWq;*Ia@wL5ezBRI)}6`f;6$E3p3DcbkY?x}N&5#0<dbn!eQ7cxNFaDX
z)#IaY1k=W`jdd!M$=Tc+)ojexb91vy2EA^ho2Em8>Zh}k&Fc2z9;@v4Z&^wdW~TJp
zMO@tMI<);fj}2?>WRE$uskPjmIonbZxqI*n=_XxzJXiu~>yc}fh9ri^X~|3(@!GF$
z*uAapDUrA`U+whlcq*OP<41Y9-5!D6bzCU9gg8Y3B!t-1?^A>O+Xt^}+(*=IcwJ6T
zVc*;rEdL!)KOg^wiL&PqoiuoqM@nME(y*xaF1w`n$Zi}EdNqEer}Nlb&Hd24gj-f2
z!;yCp{hj`*sQ4-?ZYC9#z^saA4dir|r&dj4_)e`-x_XNfU$L{eHsOI{<lI7$NBcDF
z<Jgy-QHoi8@@sbLOl><OvoXy!J`&T*eG9y_cnR42&w6%s7DQ==68ptPI2r_&YKoOw
zHq2GJRj$s+#OswD+bcq!Kzg=mEOo+HcX?_2l5rD4goX*lzy`4(*RqWbez84|ev+#X
z(u#us<Vq?=sDGh-ZBV|`K+mr*5|-FLvf#Hl7&|?9(p7)GlzktZhXf$*hU95CJs`Xt
zax_n7Xcz<3H2P^+?LiJfHPQA!ebpXJQD5vJSo?s4&7lq?3ok3Y>frWPhzHz3eSLfw
zgQlR|Q_==DpZR0@A>nXcyYP^J0V3Alutjz7dTd>eAw!Rmf~z5<EwH?%eUsl<V8O(R
z6ED9TDTkmRt%H}hXVec{<oVy70_?%2S{MtaRttvUFZe?rOv{}Wp9cKihu8tn-u=g#
zZ~xK2Zz>E}-;~e;H^LUHZ5!-Cabe-x-dkcVQrS?u4Q#y{p%d*>@-0zTMBZhC%g)y0
z@f=_7d3W6%00%@rUKiP$@y+X9=Y6w-{U`lV!`sX24#=b3{kI<!_x@it_sZcuke@od
zZ?8X6$rt~lM8NvBgXM-{{ct|}OZ#v2!ft=_Z{iQ?zxkJ6vjBWWI83Mwh#gR&fVn^g
zc%QHVseonI3K6_3#c=NLUl<-bp#N@({%N3xLf!qnS8cd%&~AaAFAQ8b1UP<#hv!0)
z|1DlAMEL)gAMRn=R}TbuNI%x)yHNepvHIfci6~(=vIRt3VLiq4sJ__>ER?ifK?>0c
zVlN>1=pq0$e!9RH9v`i!xJWi1t+1e@?vEDS#-;d2OYnaNopfZ}guYn{)ryK`N6S{R
zqUh(#*eOi#K%pn`NtyU(%V<ei`3K9aD1UK2Sc7NON6N({P1T+(nM!7Tv_LEo^V5p_
ztV0y06Bb`M^V3LjU&Z-r3(Tf%sg$x`&G>7D#jiztwCGH0%0F8mMmOg{$x<W{MzBT*
zPL^|WI$0^q>1QW1Wt^SPmj3UpRcz>g2Xl7v18b~66;pz|3SB{yE*4W2<Wdd!4OfDm
z3L{bz^mLLHmcmy4ix$QrLJ2xh1eQWq{D)J6v=i;Stl*7_lU_)U4Lf`VB&B45dnE(d
zhH8K*J}wz8njHAqaiCjVYevv2Q*mhM7k7mVVI9V{!8EJ50=9oqf9|ya$x;9s^GPv1
z)Gc`dVXQGC?!mP_U<W4UsM%Ujzj0=sH>DgJF*AC}Ib$MF%$u+u$lSp)NwP3a0zo0}
zJcX>bW^hw%sGe}wwWCc?daYm$B@r9;l%~W6Mh-|$liSisH*KOdUnifKP1)kl)`+qm
zu|!(AWW{vS6Y-)YwgqyF#vy1v1MnZqjwUE&O!A!)Xo^c_0;!LF7!3zBr*Bdz9NPM8
zR)Z1EWJSbdZiG%($<zq^sDXWu5|)rMkVNn^4)}3XJ!RZAl*34C78y=0(iAf(8nL2s
z=%UnN#h_cqSjh&-hcXY{5@>}S+Ncrgr~tOfZJIUBJO&J{zu>%B#QD4mrs&e@Qq{O~
z#EGh*AUj5R4@0l;LT$LWSVn9cDC!>5qpG#SyQD4p#GSN@tp@8kGac%jd}f|~PNHqF
zC1#;VR&fn0cEszBIs}0}885q5wg9L$wV*@J#9{1xnd(zIP5rcXlNo{XbdW}fL2(t)
z^$n+IQ#(%V^iOWFiQO4v24IYwu(;IL6jJse?*S`#{h;%|VA4q?|HS(KJ+R|jjf49f
z?PUgkqi_#s#~Qpk4lF<`YWMf*{2s086T8qNUyrcjQC*iVX*0a!PWRNFPq#L*Ijbjx
z0;r4>e(il4ita*xO?n<k6`LZyOU}VRo@uvaYKSE$X@E}#-$;P2!G=bj*R<p_+S{Q@
z;!(f;lB0*bI^jw?_H)Zx47#aAvx!&?ps89xeY7<%5;s2c9_A(oIpD2b5fOXNec@6h
zosp_gTWeR)eME`v<sat}5Hk<FKJ}=ne%<jVTBp5Z;ijSGD?Isei}lE6IZP<E3tk|#
z^r#t={lLum!C<7|(mx}0(JBnYqREJsk@<-p0Vvk(Dt6}75jf|&<WE{80n2X8+UHzy
z$$4o+zERho7*qKA!?Ems6$BNH2e*yRtlx!AwRZ$N5%W*RZjlytjb=AHQ$nUCJJK5d
zsqhB!oO&Hl!VjsTPOMF$W5=|QB$LrjQ=58CV^y5~3CHoc8aiIFFBo$Ibcv00vtQ^4
zh;^And%s8QQ=X5s^_ehkh2bUD#Ib*l?w5LU8Z|Uf{WFg|k%|z6rdrkUh_j@UUQkes
z>T3P$tQ8*YA7QDE%Gae*63Ms5wd91c(iWH>C3ZTY;-3L@eJlg-dr|EbqEH}g{qq+t
znZ>}{E#TuN0l}^*wV&dY$1kLs@EDCIA4(-gyXn}6VAVYzl;La~+IL)|RhXg69OmFu
zeROly=AOObQ1jq^FUUtQ^y*q?ue2LX<{F;-2uE5IiJH7pA852>k<`WC>i%yM3u1qT
zrG|LYw6oq{WqkB?Pmb?t3;%oL$tFYfO4=lsKOS|3zUbU?B5on5PFhr6)fILL=&<vv
zb}l1Z+28L9YxiUme${H2Pvi=F!R~|TrefCohZ>S377Qby+-*GMW+o`8{guqyNj8n>
ztyPU}z+Ht6NkbD*u1$6Qdn?0<C+-o8A;mD6Vu=KBt)<iLQ>~Wph?~AjEL$t1Nz$Zn
z()kDaN*M!TeG-?PEL#;7MCLSNtA64{^51L}Hji}r!+6fQJ~1v7$zB{bLmpTR*O6me
zd{?tc43c=}l{dR#&c<B%ik=#2U(oU@$o%`8vE36fHeE_50}9P7%8d>~*Mr>$Vk?lL
z4~|6f$qgKK@Qx5B9cqaQ$du+o5j3YWkQ0d_HwYPj1=D!`JF*-e>G1;R%C^E7CxQe>
z+;W0|sLu|jkre)UT?k+~09KzTs*cz;2BeKknMKG!LFkh7JMQWA;m@#Q6TuT_Z@Pz2
zU9V+FRCjpB!MJGLk|(A4H13)*n~)Y7Wp<Db$V2?Ic{tEJ*kJhO_-%aRi%aGlQ{EC0
zF-Z*8F)l<DxfDYBUHJar3J!@a0%Bh06?s(ru>;=mY05&NcHA@1(<{SI+=F=oJVO9E
zFtrXmGFA+#74;KN*#6%F+~a*%^Yck4CQywyB>D4*7je%_Lputox}iVim4-v`Y1C=J
zKRy7o?|tnw-5^{pEflp4D^vG`ocfic51ga;VNoX*(s4`UjFYp-x`$1q`f0F3W9w?j
zNV2#jEs>Dp&Zf{9<m=N4jGAO?<FY7}I=-51D=n~UGloS8PTHZ*e?4UkDX?h(q(ta4
z>$;t%QO4uGPkUDkt<L@!q~Bn3<j&0w#z@4ci!zCgISUB}o>V>Blc>&NGB-|*iF24q
zW$twNW|2&|Y)OXtlqefwHQ7ILrD;P~k1N7Nt#flHDx06jpJ+Upym{I*jhQ=6UWvLh
zr|}pMe`v>WZ;g6C$|*+3lQO?yc=BfG&(PxqFaLC=((?4RsgB&v)R#otlwr>w>ICj4
z>rIqkBx9x7BVU~qD79s1)6kY_%HDZ3B^a$Y$y9=9Ye_Y#pg!N2crm5Yl>s)5s7K4x
zF_dLwD#_S~Q~#?tG9t<yze!|IQ!X{(R)IsLV7Uwx#%@nE(Qpnx+LAJh4k%6FpTU=}
zD`Oeoe08x5rK_V$VWw(J2zFcEG$n+oN>i?OFm;0lQ=BM+8D->AGD0j*Ds2_6nm|_`
z5bFZ7r9~I9ab$yb(v>|Uie>n#JDsxRDVV9NE%&Fuj7g0cD$1rW0o2yO3fP-GS=(Gg
zu*1fSEnkPW@sd`1=zkb{$KcMwrcFGVIGNbCZQHhO+jcUsZQHhO+qRS6ggft3yZcAI
zwYB}>RNtqn`}E!4PUE^7!6)~T_8DPpPvDwhE=+^ct;>@;D?ri9;)(}p=1S|vYss3%
zHbz(#D8<>)^wC0eB!1C{x*$rkr0AHgJ+@=^xBn&`d7e?|Nd^gvHB3#Up)g3XhQXdY
zlxhSDDS<v{6ud#$G<iE_l7<jq(RhAvFelgFjh(U{)~6y#Q>vO6M4X0EwBF!K6TI})
z=}rehG+C-J@^G?U$fE%lNV?t?qEpwROnKxcN_csBxvzB4#i$gQ8hh$E5n}3d;%U_2
z%AQJ%^jVqSG-{N9cIc5Z9%=F6O9DR{I2*h!*v68$;phT4QyB!0ifUj$6YMEb`J*d^
z{$wzmt@ISilC2v;MG24%qEZfBaj5`3M~g+S1x*5V47@pp7CL0GBXl9WGk}q{jw(T5
zn=p2;h14fz0pilqm!z*%QEY{aDQ$|%V6Fdwe(9jmh~mfH?-WyY?RTKG>c|Csh3lkG
zg}xA-r3eN8Lkr#h9s&AkX#w^Q=0*;-?Vaj$wIM^-p+en5LQYjrX8^Grj%;1R;}KMX
zVurk?DQWuHf&{h)`Z}dL1}&M?+nA^)kyan4GzT&f?%Y0Rkm#uxz8-3VXfb0twJW3$
zl-Cxj!q%P3mpEINx;WubTaPo)0lD0r`$i3{K+g!X2+xptgL~ixca0CgN@^c%t53I|
z2A0=gna^X|-~Q8XtxJk#8q=gwW!~TvSxgMPM-YUf16B%~s0rN=4zmw%Ko6X4|IK5J
z8C)$;<iMGw4HTX>A|#1qPP@Kw;v5Jig%;H@;)1j_reue>t=5`+>|@0RlK5a8&AQ#_
z+}-xA7NF29!b4ORZhM8O9~D(KO*@>0U8=|NudtruWNWMgX4f2qCP6-k6IRbJk3ZT+
zNfiHy#h{`?h>NB`UwtsEJsjGd0u+vD(49VL$CW1UtoKq_?1YP#dCUb%Zz(kVE@k(E
z#B*p@uQvXRkuu1D62dQe-pSaifdoTiBz6Fhwpe_0voFKb5zn1kiRIGNfpp81EiC`E
zliq~#t>Oq42L)4+nVVH@)EtmSpW2_km|ysK?o0{1|INlXIXe?QgO4K>-H7abZDVxW
zKRkX8d4-)B+)Y1>mz|EEx4}Or6f->k{7L9$7LA+9H>}6W$ctnoUY98wJv-CD4CQ8I
z<>q9BGD%h%PW~1rBXei^*6+H+%+M+?AP-vn#7tusFV4!y6`mj)Ll!nh$lYvi<Ye@%
z@CP?5J#Um_4Cn%Zn>#r@4`Y{~GugoWjoi%qRIK1Hq5wB9BX4Senpl}w*_q*bP8gHh
zGmy!8$3ww{<l^$YUp}AUId*OaZ*uxNH{V?BoJ?%A&_S+ZzKzA)F~u4R11k?F3nQwL
zcvxxJYiweb8IW|4%25S32cJ}Aeh(plorj;1Ic5VRHzQYGfDKfK>~t#a-+i%R8-ybw
zIBDV=hJWXe9fnYwK_a!=c_j}8iO#HAfL88*es?TD(-Id6Ck0r;>FelnR`+HTCP$|w
zlq?^Rh|nLHF#0R|J{0zPJa~_{{(FvTcPqsIynsdX&w%}w^L`PHekT(1MJ($5)3B1Y
zhR$S#&IEd~jLv)+h50fP{o@gZ34O2w3GiME`i8cB6MwQtCYXfpn<G5v36A=T5b;Zi
z4B}e0PSe(}8GX43r*G?3i@IW_{&y}LdJ#>N?bDOL)MxvGg;mfW-j2H8LM2kt2mJ{?
zE{71rj)&FkPhl;<cntdGlb?yu2_CkO+6<F@0r~E%Fwv8r-3J!T7g#GcH<)1`!2N|M
zT9l`(_3Tf9OIl!)oa^)pPyxg$JyKCsVR*?KKdHE;XuXVhiP8U2{-eE}F(%yd<Nukx
z!7iOZ!Y#TntHA_aqEuWc;XRsLEs2FBT#~$6H6QlcQ+y-F+K9G5wZoQ}OtDayId$hd
z%OKYF(X+RQ|MtL(U;4C>mp6Cz;@QVPHocwor!>FfT#N--557oyLB|DMD?m?RN)gcu
zpH?)l$n;$M5#<?%Gem@}EGgOGHvILB-0}<N(`6qY@_Do09(0+lpC1aq8?XlfAP(R|
z1Skjc;{xCZb?NTWf&4M=`GLOC`}ck~%pFsbAl*~{>SMdddOa(XNj<>-{W%n{_X~g<
zu!jmj|K-ncKL+%}wZ8}aNgntEeV+#64|4Ah`fZmSQkf53PIvDdxCaL)`}Kpf4-fin
zv9AyFY1!`&WP~301Aea#{KLF&5Bx3Xf*uj1M*u4#N+R2w%z{Kq9P`UheE$vT8)zT?
zZce_7Vu&9U02{c61t16hq1hk9C%b=xOA7GEzBdQ?x$F0b2V4dA!DvQL5-OH+-D?B)
zf!xmleTVkrLw_>%=l%M`jCVo-&;$Rw*bne$9bp;nj)c&HN+MBbN-^ALSU*2BU<~BP
zWj_z%Q?MT&<g=o`uZW+2Ni@u#;vO6L2V?&Y^j{=#;NQ0W{zw3rfIcKZR{TbOYR9>N
z3Em`_AH=>s&?j|(KkWS-(DzsWKQ~1CeK4Od{d=)tNfPHyiAY$m*;Nv17SIlMBr~9X
z`1|k>-yHjUke`_S{*Zt<;2+riKKReNz#n0MzgY`RKiGYI*w3cGe{rq-`jOk81Nr9e
z*N6YS`9oap!)EpS)2+V`5}^LeAN*b)=$mNYAMz8n{|A$mBtemVk-!CS0!LRO6Y{eu
zfFA*H6o~&UzX|q99?%B_um|?1z3&75rnjKfgrg;fCzU6B8YjHZlsgTk)d||N1n<cb
zR99_Tf&T*!X)sT)tEmaapOW*NYA|0kIclFO&R`x9yr`)Wr8YNPE&<X{<co-?P-7c5
zp}ex0CH9X%C|x&Na0tVAVQ!S5AjWd;2OBuDVLfyxEJ80dK6D<Gy-@tJ?^kDOX=P>d
zd0|a!Yb)#|Go}Z6$uO#TD$?37C;M;_wBS&N^^`&>#c~9AG)O!Pl@Kv&Wz^+W=s#iw
zA6nhISYVAr4%v`Ix~TNOLjOD>wlJ^(2QSX#8+@|y`3bhMXzAG6hDa!Ek!>l_CWSB<
zW=qTonEso}AYfTdBL|Qk5Kuk40Hg1^%2WML{v$!5qH1XpB36;qOe9zn)qi=OY{w-k
z6oNRj{3<vUqb(vbXA9aq7hh`BFE50NQpgEps*FgMGN7Qcyt<0VE=NI<qzKN+&7GAl
zheuCB0;(1-C~R6BC=NQ}@nr;zXShFsw2<GpDDdwc`p^|mO?5Oek%C^d`XxPVx7?gB
zd2j^Nx_=7zq=8h)La^$Fqy&hQNpaw$L{XXWClUh(WUz8%iqXL*0VEsI@1SUwbe0gw
zu@CYvk|J25;Gu)z158I21YlhSO0<Z>^kqA;(6OHsu6I_o4ShV`20h<;1gwv6gtclC
z1YC*BmuJy=X=UyQ&Coxf;X{NHTYhR#4I6+SrhzGSsrw&IG8v@F<nfSssOS)}1jx{N
zsB>`oNfRQOQZ9^6MFby05`xe{A;P3ECMaEmJ{hiI8{a>zJ~j^+%0_bix%;FSMhPMm
zhklGcvKchq_6g;k<>PC)<?5T($|m>si7Lq(RXB>|Nij?(m;3J;?rA@ugS39ApoJZU
zVX+_bRFzYa#eYJ4)@8<<z|@sVV1W%PCm^Yq(R5@I#YofxXqE8{C(#`vIZP`8F$r4;
zTe>0jK*JU+A#>;?Mp}@@3JYk$R6ufEsHD;~Rv#gWs??QI99^)a%=@{b42>JgA)}~J
zQSqe~FC1G!ss+HmwyI4M6wpMeXcXm}-wK-)xWv`8Qiux6awmIw)TB0VWXH%u|Gf4C
zljQ_0dXtb1-dTo>)^m~B2?IXmf|A9X)i;=lxTb|IDK!xB<elK%2?<MRGF()D4+VPb
z{`xHx8&+?L6I)4T5{U4Z2r)FW@x0yFxB&qzD%e7(U$(Q20r(fA8P}vyq#!21J`E#|
z$>vD^P?P@1R`YlA2$FlsL6jPJ2jDqE&@6{RiV?BoO{{>jyWUr*r@XVXoNyrb&mn48
z*TY&KSz7rPc3>$7g>)}nA#ClK`GZ1?s&RXZA)_K%mmUCd&=|6fFj<fSNopVvD|5d-
zKb!Zu5ZusE-U5M)z&Mm*T4s;HFh)wc#KeJhfB+RCRfw>LVuPJEpDEu-rKaW|IdWu$
zQQ`_(@bs{w4cDaEVYPe&UEZNn@xL8oT7t*>A1HH{1aw-(FpOu&mvYFgN#uSi=~PUG
z^JotpW+H}8epVQZFVqRL0-Fp;ViL+Xk#$;XNsIUm<*fENVuC}B#pl|xMAuSgZ$Lou
zx@=1hQ=$#>Lj#*oVl$owaGXV)1t$22!1?d>PT<zo$}bYiB)HC@2yfB|c;VbwhjSK8
zRir`_<U$i>M7F9m@K_?7{9$M`=#AgWGl}C!Xcf}YV;SwO_f>oYc++rMJE1PbqKhYV
zpo%U-o;Z0*V(RF%R1{k)Bc+1b?c{nQA}b9NLG^Nw0TM0sSe2_oZvTkMG<#}Xh0m?K
z_S)~&@>MJR3QSvZCe_N1RvtD%ZHIx6-9~SsFQb`Om{bc__@MTZ5g8jkeTmQ}8Wh<e
z%&XEaD)m5Zh>GD3q|HlIXy|BZsV>K;slB~JYJm9L%cBw<6(Ll@5X6GVhEzzyp&h9(
zC>$ZfW1UPu*I!heWDtikiZo~loJuCaQ4!7{6*SV$#nf@aBOOdyX2K5`FdlSMi~=Qa
z;IWb|KUoQj@Oa-QwTB4{a5R0RFmRFyf0}E%Y9iLZ5(Qi~w?ycH37uL=%9_<rM7q;Z
z>mz~{ZOwCvZK?Pg<rK37TAE<rkb8t6N~CASd6mrf%S?3^+e=B$jD2neu5C7O=9$Aq
z4kdQZ_NH=#$8(0nIB+~g@N$>#`%#@jp$b6}Q4XR227MgYcE##WOzsYIhJ`q(XyZZh
z60Pj_g3VfxdPz&7$!R%~-Dc=Q)j++NUhYHkP$37$4$T1}{BZV7GAd#uPk}Ph5+<)L
z8?Xg;gXr>Z(tqw-F?|)!W$;dZmn+vP+c()Zfsx|}asOjGZB*HQa$ctpuZ6>L#qLY}
zN!FjBKS_It0))DTx)yT5fr!a)<T6dn#-9mTrU&I-T*3xWE+Y}zLWa#H3=<&~z#tNr
z4CC@e@W&MG%?fcq3s7!QHU8rn{PhMrd_Y-Coq-ldEgTy-*+3FxH<%;7rhFJb6y*(O
zS$F6m!iQPQ2qoe-h;g`XjJ>C_9Fs-MNkt`|w8Q8F=LZ*p3tv_WM1t2K3b>DiFT{=z
zF5cn2vx{%9%H>S6BS^r3O1Wx-BqD<_rTXj+m16uQvKfmKbsvDkLxzjgo9Geb@|ywg
zGh5<rM}o*`-hlWL^s>ST7`yFkkr2v*iM*%rHf2~4T^~gMFg*&}Yy0>OM@sn6!;!G0
zBwHW#P(UG+K%8je#g@tE8U*7HPq0j>Bs-Sldcoi^)1NZVj6Tvs|0t5bp&?+e+gEf+
z+wuc<xI{g^(Ji<{!b8z5<ijFi7}oN!&+u$yd?)7Byer&P*Ll(iz6B!w_f-w>->RuD
zH4Vtpi|ca6u`+H_-&Em?k{gm(RfLp*A%!|@qs59b#}g#1R6(9g8e%NTL1daq3R11y
zY#_|3l8SqElqwLW`vWN+?3CFa{^<U13wZG9u`<ReC*J2paidYoP0=oi$$2=(>L}~b
zyC&onUIvoM*cwQGJ=iir5+$V20yM_2NjQ(?xxbTv=!TDrn<-G+)ezE;HBmB=EK|AF
zp|AtQF{G+DcBjxFLczpB!yQo>J$VvpMe;80(6R7N$5w`yA5c;k^Y#6TbE|?a5B{2v
zuJroE<tz9jzfs)HL)x}M!KI%XaNbf(gEyUOX+Kogdm@}nh%^j4|3G6x7$5w#A#Du4
z0<8sRlR;YgorQoB=s)RJ*j3b8^zpo)<1B8C3}cgAGC@JNmd*WpDe1SwR~m>@nvWW$
zw2-SQIYtT5F^LLrpbHu$lxPAma&vD<+@CJaZ<09zeoD@TzlZS=d^6(V7*KI^e?8Qv
zyLczhUy5$nC|+K(79VadjVfQ%;)GFF=sTLBA9oz%PET2FveYjhCKumCoC6vedUw*Y
z{mx>#Q>#v?V(ygL8fo@+?F<~*RVnjiyYI71OPlI_Mkza*tZHMR>Xy{xa%vj&Po^h6
zVnI;yDD+?a=-yZ*D7D6xFJeoQlxGU>vc`06GqH8ff*gX&?SD7_?jBN#wN-1Gh^?z#
ztT@5%IxBm*=lPktt|OzKqRL$E-BknJFFeIgNbE)iFrJ`oFvk{?HK@-$%%fAcT~Rr)
zy_=_(`>r1Grh6X`Y_E5nXO(GbQ-#5e6D1g8<4Oo+Fc7QAfRw5T=N1Yn+Wp31ow~Yi
z%OEA!wHmCht;6@7eE3aB2+JEuRZ66?+H~#1<E#W)<+>erj_)aE9##E_!T{eLfM$wy
z8pLTXKkFuwJO7lxw>KW2$G3=%h!awl`Qp>*lab+q`JhUIhA3hQEn3gX0)8z`l@eQ+
zT(OQaUBMokkZAk!${Z{L@tyEfa6%yib%rZ8K)Sv}lJT(QM{-2faNHm+LQD7Q&~?fC
z_IIs36&T%_7@pUEMnVL7jzXh|Ptp5rbehbUNypJMrYU!2d+v^lAGd~BoF40pNsrli
zX4~A#4USfi-gDD(S-fj+GyJso@pjy&)<MR!T-Mz1dSzzp)FRayoN+Ct;c&!<@8Z^=
z#qFKg@9TuV(!A3jqc-;M&_6(dOAF7Jl-1DO8#*v$sjSgWQ)RKL%jLdKUxuWX*D3cT
zU$d?CIXwzkja{C_)1yva<h0$pd{%Hht=nXMAA{Q^XI=Xp>XkZMto_DiHfzYI!L)qQ
zvR@6VFi-gJcY55J`ZA2VwygkJ2zfc{#@FRLb%=`8I&YVs+r?}E!3ac&Dr&V8O+;7_
zsyDUqNaS9r%P3iA&kb3%M#FXWz!5syPu)7SuuZ$klJ&&t$6xC%2r#5P+VIekK8<10
z=nU3T5a~d{`eclzUJA6Ay8D;oq#v>${F;S#*tD0Zb8R;$WAKRZr;&uKm_C25_+G!W
zVrhtfkoVJK+UZty$Ubr0r70nLe`*w{3HCCdYe}B2;3LI8wA9+{G~~SVbt3|;iV9ZE
zr80x<rH4`kD{7>=s&k)+cm~Isvz<(gW<%Fn4KlJL&$IN?ZWJ^f-HrXUFpX>6s!kQF
z;-u}DMG5J!Z+UlKYsKbUE<Px~y}GLUtaDx^`}7*g+^;S&nZ@3C{WQKD|6zlyW$w^Q
z2U8<qEGW80GH2uYh)m{`;^k|z&Zc}Y+sXgE@`SbKU%OVC-}C{jWDbO~wl%WMH}dDi
zQrNahtT{5>br<yEbGpxbtzOn6J|Xkp4~F3WrIosN?^%_AWJV%qWFK;HCU%`x#w>R!
zOEjHU6^)t8wCa_0cHfTydz*Zc*P&9H>^D2y0HH95f|DD?>2Si(KGdRE(%CU{qGfdE
zky2%1YU^jH?MR@9Z+dQcd}C{9erRB6U}@XWxTg`z$O1f6w*&8<o~oq+_kPLbE2rxh
zVZZn-J`Aj`cA^W#?P|$wKD?3Lr=d~t7-1TM3DV^oD=<Q0tkt1^8wF`*8So5(dQGMG
zYhvK2naJcH@w?4igZ&7jD`G%Es0%IFK|=}qZO$H(AVtorH0MtD9;nrxb^3?xD_WoB
zwbk*V_<pi2H?8#WSTMa9I*Lw7JDz^x>VbHK5mgo`?bN2ffB}=|9`_N?EOwcckvl;0
z?)*i}NK5Sy>`Cl6nx%V*SZ@%fGF2y=`>`?UV6>jXxhlN4G<UJ5+^v;W;xSus(`xgH
z`aT$rq5r+C4`xxkp5-=2CQtoaJID6>)+aY3>r6=NHh<X(c29bW1D3U62vzLXg~zCO
z)35By<_y(~Qnw@06dMaO*en@i=4iG}v+?PC;AMatc8DJ>&#w29qkYlb>ktgSWg?3i
zE;MrRw-h&Q^Q3l5T!S;eT7!E@k4_`Ih3jm&c)_NwHNG3Vt{nczb)z!fv;rTQRPATH
ziic6^H|PqCoHf{ld+*K`x7)b!Nph*IX4K0XJ)U#542Q1=vaosOU7oieHp|Rm5c%HA
zLh_zxR+ntvi5G4*f{(I7P8NQ*sq1*>_|Z(bp9!yWRRiM3&hHj;meHD7UR8(v$;r!{
zTnOVcmEYOd&hlr$>#gZi-&SUK?&Dn9cWkeV!!@-V*D-5{XFilLI%i)d`eKfrR-%Ao
zuLMgi>)W&@4T~wHvm$$Uu{3>C6!)0FK3*BDH`(Sd@eqIWmh5Vj?a}E3b?M<`byD5^
zdvDhloK^Iz{qZ%feTJ_u>SNrZZksjawo4W3V~}%9ehS)GNy3FTub*#*n3Y&P`8j~O
zI0E63$on7FG;Ji;{a*6q>-9o7O&QzZ<^R^~ti$6L3W2jag&PEakTR7Rfnj1vUYGji
z?PO!(!HpspW1}D(U*VqA-PH3~IeM5VsQk9uX0)D0YTD1#)-+%<*q-SSS^hOt^wUNB
z%)jwgogKf8E}z{R7Y)OPtK|P;DlB>Wo3~9_bxx)1iuxa=@A2)jvSRvcfctYe9yd5=
z87yw!m&@oc8vwq<eO8LPw$eGY{s|?fEoF)pD%$(iYpXxB3OibzjaJ>lHp`cQTtV(f
zjqDz7RfaoSPKUD_kLgd_5Mdt}ACnK)#Fx!uj@Xc7DL8qOuKCPyHxc%aMx!e=T5GK_
zUF(~-kF3`&cFr?k)>{fUTKcwtd5+s|#!0AD1`fl3foR|2z3QWRnDV2qhLg#lk%^ho
zTK0-Y5WQ1+D5e2TahR+{&#RW5vTuEu_$s=zKd`IN=`D(}%75yCOm{wh3e|td7p`W}
z_2K+mjJC62=C<XI+(0bW09q+Zcx3!OE}Hk}<N}F(4+|Ov`kWq9xtP)0XOI9zUa)@n
zcZ99nb|k4C64g|m%wgOUi-bK+DG8qDoYNlT+sXjWUhwWuCr=WJv0TNm%mkl{)ny}R
z-nmricY4+^C5Q2Tcq6$9H%Z*r-Q38c&8Ku}J0&?zP<XVk!yuU<vMJ85yB}w=(J@BB
z#Y=xrys!>6nLUN(03OHXrnWQr8V@B@W@D^OYpfO*KML^+k(HJdZMrNzjCOw3<+Dc{
zr4bif(za>yh9kY%S$<~oG_M};Odlrw`Q8V)DU9c@DQj(w<wsdL`mJpUUT5BhFV&?|
zQuxr&x}{A^GwTWawwUF$7{G(*r&PQp)mzFpQ=x$C`|iv@^*C;tv&}1LX7Y5r{i`N}
z8mV#7>w20C>yv%THsyj2caemfr*nwzn^x*#6gJJ>jBOkpydS%-u~0<HLLtc79%{8w
zoc`Z_UZpc$H){R;J_A0k^b#8XJNT36xz;|2=?P{=>-Sc+4yUlQtR6&5LUP+uJ^+&Q
zSG!g9+#mQ4_qh7v8il70%QDQ$l;u%6=GnU3_%%R{=}Kr=uy|25ojko}CA)(M%a)tj
z<)UX283p?BNlp%$MlNfwHbxQgHajGY2eaQkQOl!mCzm@}H>+3H&qT!{K(MC6;qpE~
z?p^OGlb0XIFSp}u_58jn0$i~f_^!yc_D+t9<-R?=YnYCdeDlLcBX;rNYK*)M_V<r-
zu;+M3Ejsh0@{1j~&Q4W>T|WNA?D6zAZJPcCiynvf)LVCd@O%Hj@{P&nhHwzF=LUCL
z74L4ZoMlIC#$QD-jn~g*!?h;<>W&iSC%L7U)7rOLSAE5wdz9D8$Na}N!x{0#s&?Ye
z6X{d>@*Fmnve&MS-iFd9l^}a6TmZ6k;h2%6N}irNLEj7B0rWUOKR8M4kGf0)XP6}0
z@t+?v;a6TnhXLFBX+~=7h$ReBkq!*JuRQ(+l7#O|Zi)6gg21}~UiZQq@8ZJFi;B(q
zBgx1mn!0BF?4l%Azw`0^wx{h_{nCeJidl7}NRG_8>R@Sz)y6Fkb|y>nDO<e4$?b<X
z<zu7I)seD?7vb4!=iMi_heB_9x2`;6O!OR2pXqZKny2Za9B2E7m2!KK!oBo49KQML
z3(%n&F8jlh(3X+X;}dc;ca;#gXubHNN6W<&uH3x|27c;)o9g;tNgqdkS2iAUY2NJw
zr}0mJ$U3Yyq^N64HhcjK1}yT5)|q7o-|OR@fkpJ3^p&=@IrX+LM=57&WbnQ=d0CzJ
zvXNI<Ew4CD9d)g-jGVTNWyguWX@9?X8g*|wn72G1-d>?&_~qZWOO08p$H}JY2filp
zLY0M|S5<sEh2(ahSE_Dir>`n3ub@S^6o<N1VCmJcFdoB9*JUtOanriKnmczBjDcx)
zwWKd$bKbma{5fq7d~wk~GDgtN;#SDpc4BhuUlr;IjS2>%C8-~|65fN7ib?9o3k5yZ
z!}-!r7EO|h?$zcx1YRD8ImXmOMH3oa6J+1%Yvm_t{yGTzz9y|?X_aysi_6*gEimz4
zMFTcA0@6Y+BB-^kwRAJH#c>pwczjG$^Y354@dMX5n^@z_?lc{ILkkYZR_BR^Xh*e2
zHM`JO>vGbSrn9vk_vb;I%5n9FxWG1@qf^ix-LD(nTQr{j_1J^+?y|lu&o+W2HwZD`
zF0EF}q<qb(0kds=4*tHgPib?c!o{e`k|?ocFplJWr2N2+=XdHqhsmaS9z?QYN$uL?
zpS3bMdV4;_(cbFxBS=}~j&=Zj1>L4H(=HP3pT6&NkPkFBS{t<s;RtlI15-P>_6|`d
zJ3F$|FxfOm=c6BP_BZ^^xIv^QhkrbvMqH`sVWf6Ra*33f(mF9QH#e~%l^UN*#;N-4
zcT5<X3gzx5(e}ekOCyQ}>l~IKB-2VuI@%x^kpSYrVRWSKKlCILz5Pfa4W_*MH4kZi
z1LG>%N9yoKfj1N3OqV=H%QAOsVqllIW_LIWcU`>BpR=lOMjYBOUp+E0H{4M~cmIG4
zI@w-fuU6BqlHzdBA-xX0b=NKx-i3ZxwbgC2kJ+kHn|N<?Go!r1ZvZjOciCUe?E|@X
zTt;u!T?OHII`bL{W>1ebdovMkK^i@9C92_VVl}(Z6-FGEi{seXC{OTsMNV#Qbl<(}
zF5<7_4aC7`93NJU!Gou!*FG)pNfy#$Bt>V3jPA8szL3~%oe$B1S2^amkLFCUOU$Jc
zTMb*7l&o5!r<L?uQZkjNcieY2LsX_a6uhpT58FrN!K-r)*+b0wR{5#%9~1dc9S;^a
z`O(hK%4p%C_#G&!EU{AD(XlMe@>o?Yv;nk}S+5;_(m`H;eAQU-LhP}aXMTldhf;Z`
zgs{8v=VNq#7njzm<7=k!K3|Hj*^kg(IM}BP@70YZwfWmcr!;Fy{ioO7`PXI_ijz&4
za3;^8x4Ewwt;N1$nsv>n<ztynt~TN?gryNlM&)u>2u#Jqu8(<*G1N@8lDF5pxyYE6
zuiIwftKql_ufe$wt~v;PCrSUmb{zsWB^zAKVk;$GWb*b8k89?=QS80OFj>K)*@(t9
z$rV}p-5Pk8T{E}0dUF@GYoSf9&Y&REu15SE^-g2o99o_ZhK956J56a`a_&wjF?}7}
zUVPH$D4*ssY6mOx^Q7$NbjpcQu3a;-h1nyC6y%Z=k)*c(eePQQAI|!_o`maRqiw+R
zpLEGnCzCx7;K*K#Eb6#_6YYb~?^H_d2AfK`xKiBOs)*c#R%dC|_&a*|R$&wdeoU$y
zI`Y%R-o^9xX?xzUfGhu63iEb_AA9%K@MrI{P5!@TQb>^&lw~u`Iw&J_>xaJeC7yYE
z=Jb`P=e)})F}H2BM`Iy<{@5?oD;^zcSLdaV6|<&xW)QArstaSZuijLr&E@OG%NrH(
z_Aqf`hKf_77jQ-PE_k+jO9}erjn3FyUWdV<ThzJLer`v`_k|eYR%<!~iNqvbG&@HS
zer3L_<Gfndvwx=ievBh~e|n!_f^F1rts8AIdmh&borX(UUD;CD;v(;SCZp2$IrQ((
zyAOx)hc0RFTIZtp^6V-S4AZW;0p32nnUj?sSEHnTdu4Vvjee{(BU@hy=&q;VVp*bv
ziOx1Ldp^4KpS#O}KGt+EIuBGYQ)Rr0@4~;oJ)8{s9xK#QA><&@6L_5yCBhtd7Vfl(
zvDhP6AQQn67Pmk7y%Bz1ux*(#b^cULN+s^Rg%LvMNIRG7fE~h*p{2KUg#M+Fj`H+Z
zB$+Y#%&KvVDHP8IL$eHw)hY{)wfnkAfLfbOX817p`8)K|M3>gCE4E|5F30b!`%~f}
zZn5&%X&HzpSL>{0*9l6qv&7{;WKR30#0it?AT2OfSTf{8Hk;Krv**0N68CxuFI!P&
zY!h>f>ARkXj>tnu21Oao&ZvaJQu=^FW^QG8>ZR$o(&3C%-WeK~aTggKvQd0wm}bpJ
zN5D_ROpzh_*Gz&xkI^5p3Xl^+<}8uxc-fpEO{ytgLmhos`P9Oqnz2>tup)h{kK@_b
zBIWJAL^*>?)_GVLr+xGybVe0Q!>PzeqwE_$b_2^jXlKqXR?6GrDoH^Hd0QCQ!Ce_V
z0;usE1!O_f?dXT=+qb&H@N_#(&8}65HKdYjl#Ym5BOd<%L7O-$!$O<dnK-*RnHt*u
zN3}Pyf`w+}Bw!%;kH*78FJ@`uV(LUMW@G4LDq?DEZ(>R>V`^vaVnM*f#LmYD3;n;W
zJ+gJ<Wvzx8euuvCg{Cfz?3-wDWg$=~Lu)>Vm+}S}Q&$uu#2nH%eN5V=3xTnX-}xSD
zzAy5+9V4H!!?liq7Lkv&hosOB1|*TIs_%EpdaK)UXO%bif3=cib7KWtVa?wW(M7Ox
z@U%1R$1K)e$MecM0J@(S->jqeIEYEhRknhL6v27307hn@y7k6qB5#)5&`)Q8b)vzF
z=NEenY#h1;4HIGH%F;xu0?$M%)WnanyJdz=`k}+#KHjJgm)g5XZ~r-+?_Jhp-3(Is
z4MC_xVvoVAOrt*;lV=dn4fYKGZMK*g{;#sd&cev_KQqTjz{bSJ#_|76-i<Gmhl*<I
zPsd%)rjmC_YcWAZ;kb~VOehKoC1kOX5(boXz<N@?C9+aN2rG$U+DP2GL4V&A<ahXY
zrz_5;WA8%}dj5?-*Ki3gyB03amgQGmyUfuqE9#qdnu?!}H&wxW%P!Z^Ik)$3xm(Y(
z+^%ltS>CtZ%6Z!Wpa9eiP;Il3Q(Y*#{>ci$<;>G*_>^T{3~!8p>JcyLt;W?_PR(0Y
zpsP0{-*Q{mx<2E{>@8qBN>BzLKi{=N(>N6r5+JtWhF;f&Mc1_-66<*whcykLr-Rtn
zRgUiWZ#x`sG-*o+s_dj4#ccmyt7C37SGryAvSYLw{;&o&&eH15En$bGut45%z&f5*
znpc~(pYDrhM&87)Z}ir8w!ZRwpVG~3Fjq}!ZFJWDPaS{P--fAyI$w0Dy}Xc}4Pjf?
zmcDg&Zgk<TPtt(icR}XW73BrFFKFN3x%m5LwH~<dF9Hu6oa5{Z=G1B5c70Cy{p&O!
zqK7nC1AwR;vcGqo%b7oBKhMg-Yd~yD5%1|rGWYKeeuBa%LF)w}HyNk@6+<$_maj?M
z46F2-#F0lSeJ_=LFl*6qykZQNA(0XZ?0_F*L6Go|pcnAdS@-V3DbnS8YB;%g($Zhv
zpqJ@_42Ruj@GdDOGJmzl^_=OeM1@>9DEuDGxyKEp1BLfjc9w=0oLa*q=ShmDg!pe|
z?1!Tn_x{U%3moqMFR^_j7P%;F7P%x4eYV`+Iu^MhTYUo^@;*I|$7A~T+4E1XV}96x
zFk}DEtC)}5;ke-cDMwqOc>RyITm1w7Cwb^Y-GnRuX|>%4<OR19KWw(yg8V1MF?V3E
zeRs0|F5EGFT2O?IJq@=*X4t&7AkY?pAO9~eo24Mk(SDjg!tS}u2?9NsztArulq1|#
zyqG;M^sT^=j~o$peL?cL*wkp7&4H#cB)$($OeoF1R-8yvZ%sO|2<9r#Y%$~ib-8|}
zUY>7z40Urhna@;bIjY{IELD}Mic*)!RiyJ!D(R_lISRF#_&AoIM+$Wq==kZ`&93jK
z2k>)SKU3(Ng{>XAaW3JyWvv*oVJ`jl%26YZ_!TI0sM@^}(=Z|><{D)Ly$WjUH^TCf
zq)7;d(<?B43m=|YEAgtt()jDbHL|JK5vcG)Hd3v(dCEp~y1^H#f1t_dJDuocU*18?
zT4y3}4Fhsh?<L3Hevnbh%+;7+UpWNlvjaNo-dwDTzjpmn5&ym-vkIl$zSxxE!Htuu
zfM-6$N3SR`rIL+RcXnJDD55}mI$QSL7Nj)#5(_LF#K21%82#o|l9NKA;CRa74=gDg
zb_mMhrwZW(wBw9W61^W7u3Pmd6XTx|bO_@IxoC^-6CoLXMPjV`w~voA*3BUbrlPB4
z^HVlBjHSxpl^e@)pwfUq7GkStl|W?|ScD~&LC^t|EEa-*-RJ{n1!v=C8nr@hEd|I`
zgYA0KFQF*|Ba5?fvVKEKO5GF{Vien!Lgkoycd7+7FgE}MbojeF+@^tHluabWQOz0~
zl@YZY1`s3p>Oy{WWtDyal@DraDjdJ=E!ODy;a_9iZ@=oLUfS_sR+k0(#WC(pZHvtK
zR0G&n%u4JwurQxUkUYi_I%>0PGrgZ$`Rh1O?yu&}y}p^c?cmc`3s{9%$$inK4`V?e
zY&kS-o)|jG^UuZxn{KLEH1f`(l{y>Ec8!^y)trh?_~$K@r88h1TpfIz32-uDOnXfk
zS-owkooL$Ew>t~-+FO%a!`^q}C~J!X5XO%KE1aHu##O{<T@OO8*r0Uhi**5kiTI2D
z?{5s&2G-csDl+3Cu#bz}`w7sS3bjJmYhYL#*!!4;)y&djstrS6Trq7etIW(_mz~Dy
zqG?UC$|%ooOPH>lk;<)Lxr40*)X-O_tfN*w)83-xcG*sgSKJX!x?i5G4@P<4^OAX3
zMV)^KIy<b;T#7ZMgF6F5pQz(>lfE{p#k+fnDdgeh>@V)}@Sf%G>@VzbWo$Gtp0|R&
zK**H+)vHJ5-1r2)4siKQ-)G52Ru=`y4v3a~viR!cB=fvsb#pJiW7S^j%YTDU`T~0^
zSIU3kTg%-tPkT&zch0@rlFzdt=SuMXxOjE{KCIYRwmEUhDkN2BKjgD8=A6Q~jr+^d
z5qFEyKuNyJ$&X1eJ!&#I?`&_U6qN+}%LV=hBYIG%nnL@Ot<sgB=J_VvLSnSVx`0-=
z0&Q)j*;Kmn<nun2pf;t=?mKV%BH{10Jv`TE0zwo&x82dC0?0c+w4;z-p3dFN^&ee*
zV&Xn>MKamZ!#@BU6SnwKQ27Zz?fD-ig@%d9(oV;5^@ZcMjRz0n^)j{6E^zsUw4ga8
zFSnqj(s=05_6odv8dLGkbIP&Nr-`Gumo}0n>tgK*7=m3#&%OFM+CR5{m%rV_<GldC
zxEB-2U1wc7(|mwi#-hnagyxJ#oPrpe*VK2;$Ce=6uXM-&#@}$A>ydpWVYnc&y$P2C
z!wsoeUe^T^%~A9jtK%#4dfC?geqr_lzxy1`l_AX9kZ1+qKan3=Y}!~@$cj{MrEiJe
zYpcqs(cALkj4J2w#oB5Q3OE0FUW6j_pFTc$_Z28+(3O=cU8zs@Cai2qXVyuvf`|>;
z_eFxE-sL&%iE`=el~)crn-tme_Q->#vmuadoxzDry#9s3g5Lo8+``6sgApmW%UES$
zK-<EC{|j6wL#;rox)_<KmLI!s^8v<tb;peYwmzsuT59mpD)>vLO#TA085X*7HgyrI
zJV`}2`C>T^{aeF)2Gs%b)8tYxIBohKJ~1+xfsi!0I7C5;LJBIBav&M0IGLan6zMBn
z5^6LYlYa_e9{rR0AdjK$oon(5GP-B*xfb0w3Q!!4WBC4cG{^W&b2P{B&2l8q_zij_
z9L+!2ZnXh)^ntNA0e~C*!0gL-;2UjY>dknNjkY)OAv}7CUSqN=;CU{0K|(i-b@}C~
z^3Jenz#zWMbNU+Xb+Q+4+dgo!<sdvd^%MDc$vU3uN~qoWYa{W*ZZGj9tBcuNom006
zjaJOfm%Q;6uB@)-s5B)5llS&z1vAi9qjGT^)`a$0m`yW$4ryHOcS6fYRV7h)xr4#w
zvV==~^#*>%FiO?iTzUeEm35Mkr>D|5ei<}Gw;q?pieFbSr5F71nX>4eU!1t=H9J<u
zyfXo9OsfmN1IKdN2omRO`Lq7{Bjf1TB00pgn@tkmy1mPy;NlpBk1<h-s@Vlf>mHSF
zSU1N6zgdCTUBCibg-^81P-cqC0Ix>Ka6@n(F8NZL2)s;%TAp!+W(owf@Z}P7Bwv}x
zPKVPm`<N)FS9d)H67Q|BtFW6JXq)x&mk$F*#P>fs&GApqAf7v0!B=WA=VJs!24UYI
zpIe(uAG18MZxrp^&wrB+{x=hUx?@pseD-e+A8Zn%+r-U93+s$n_<U62@pp*F{liV?
z=wM&DUYp{wZ^v=lqEuot<x0AU$=xI$Z@Na!ltUY4vJg9ZW3G2a%Xr)j)aCp@*~f&j
z!Tw%fSw0dnrKntwtsTN`=kcOt34O31suZ6K<Wcm6Xy25PykljG%rNk<l940%{+h`j
zg*AOYe=-+l6F(k@d43V*_eRU{y~QLG-^t6*!?!^?J`5#GYV|V6Be>ftes^8IG*ISA
zOq(OaYhk9Qc5?0`d3!6F;JzPWw<CKTl}+rfkaw-JBJ^sgj~m}=uo-efPOb4x{Pf$q
z`v{rkOI#E8F{QJwm||TxN#Ab_(=A0xGwhbuzD5$Jqi|A<Axj!J(b;uE0*0X^H3f*S
zNK6_srE<~C87C+xM`kLugGWKKF+o8t+@d3Ir~)U7MRVxM|K`w>cH!`YS}>l(NRS^@
z3O_m1;2U-Vk3!R4bSPz64-_TYJg3N}V4q9OGpCKG4Q+IlnP+0Nn3-$^G}YW=V8+qo
z#DyPv_^`$wo}(?QI#de;KpSCW<8HCO<~Ag*n6YCnMw8XZ*&~t0K>ab8T#21rjoh`V
z(xB|6{6|WjMWDgEksB}G%+-`bSawcaG^3|mx?%d1j+?lI^O!Ig85H>$xgFVnYE1Qs
zs)^bQZ68`SsAyQjpkhHi3|(Fh&yFyn2;mC5l<X2T_jf6|UWc9H{fv^-DaWY1uhcOh
z{%0vfOLRT<O)!|qc8oe7xX+2Ez0@(@Wd1bEC!8THf4ODbMLLNlPVMkncp`N{RtgH$
z4tpmAA7A>Es&}8|uhKI^n8XVGILO})#u9?nN|aG8D-Gp4f`w5o2uZE#CRERQv-tBB
zFBqwT%wy1C6Qq^YF)l@2IqwE9%Br-=o!Q{$=h}CWDmqq$)PwHl5`nEGxaViRQq2dd
z6pZ7k-`EWE0c&$vYGvmSNu9mlSftE<Qq1d>B2kqcHi7ob!hi#rXdA6-EvuapDiFv~
zHOLGo2apDpLP`*#prS%VhlL8A4<i5$pEjRO0Q;l7VgA^>XnzEM;_oYf^+VAE@dNtd
z+(=#wKe9j9x5{S(K;bh1FaQwn(f2X;5%1>rbMB_^W$oqcrR-(wWzfT~i_t#x7h|Cl
zTvEsX1(b=rFV+juP05FZRGvBP9g#)v5OClavDfg;;KT8Es+u?=DYFlvNg)fMU{ly<
zE#(6+?fb;?V<5dq3jOAagq+V)c_Yb_uCETEt-qHh^G3a>5)S;B`(Z!03-395QTZlx
z$*$W2<CdhY5S?mme9t+v{aoS*bAj)c#uJ^R8-b4p@&lG1j9~yl>(`mN%3M=igKRUr
z5YMCE7agrgvo?gS4p*aLC)=_!Vf?k)8qIqru!CC<vgd=&3C&!9e(3Py;AX{Si;x>S
zvhGecy971Y-vg+Xtp{COqKgLWf{ciB3=_q8`&Wf1fOQ+1zaJXPJKQ>|$Ff7<8~X%e
zknTdx69kbF$4>2+(LKBO@Ic4=w(q`@7if(9m~dQ-<FoD8pb5X)w@Qb7xrY+_^Phi^
zqpr9bkGNeZcQQLE9>^zy>{TfELtbv*cEzP2_D5NXwZ^Qp@2ewU59U`(wIg>@T!D4G
z`ZLh$z>nb{j*s~J`3}s?m9me!WHaNw;E1?!T)>6^D0T9II)kEwa<R*&Kog_(?}#9a
z-8M~e8?HXNd04VtZiCg?#n9v1(>A>eKWe1FN$0+59DSML{B%At_rs7yhls6{<wVwt
zEu0upRaH@SnXJ+c=hNn5-W>$m!bqZb?K<v}wNUL1ZdZaInfXXA#mzrUc~M&DpIjg|
zC@&NdgnwzpK`~Xr;*!hnpbQ9CG<h|Te>2VG9#B1E&_3()KPZQ_VxPSX9F$x8l4+*M
zIW0*qh1#(@ddHYCEk)De6bFHaT41JZXNVXxSmU~d3nvHkqCS&NMvt?ZDv6$&3H?C_
z`)rJoHDPdkFI$%qD}yKN{o_?nxMQ<)I3$*3t7X$<+Xzp_SF$j8b_Stf3qSFw4XEHz
zBH|`$#7WE=di-dHOG$x)w>ma+sqg6EL}-?$fU$BVk#KqnvP<K&fJbg4*U=Ii+`RQ~
zme_qZeCsxho1(qA`+{e}Xtg?#c?9%D%Dem&x9m^*S$a8cz2)*?uUvCp-9%L9lJrI)
z+DmqmZ`^MMz={pcT0CgcVxF*O8kFvDl{g}&jkHWzGzIPWSOUHO8J*_&J`A}0OTO^y
zl565sDZFRdkluB@OVwUDbT<gvmyGJUz-BR;kD2^}s8Wd|`a74Vz|^NfW_~L|(AFWE
z!SPp!G>@UTMm7f_JBQenQ|AzANuq7t^4G%A7}V$10-ELBZcmmQ|9uiJ`_EIbeA08$
zQ1LOJ;a7(HZRbHCdoBjYBg+iXwAX>*M4%rV?l0t8N4yuMvqf#-MbN04sBi2JVp-{!
zHKn7LWe;0?vOROFN6GSK%V?Sz)g<Zb1O;XlJW5I^RW+re3||*bodcz5kGT7Kp0=md
z9`BNUTiFH1!=V19AD>%is8~8(^8z+sen*|Gu!b>ulZ%da$x`TcX&$?_G8SbDYFRtX
z9H2rp5Ji$>)QGL@S_4hhRDYfK>KN1{yLCtRr}QkYMrYYl_b~Ten{>S+`e~=j;|~8N
zv0evLO&nwKjhoqypXU8=5&@mzZeE@1`b_4VA^F@a#%|ALiU|v5S^c%0r~*Vbpg&7V
z-1PjJwF?$4gFu8{AXt^k&2XQ+QPRP1Teu`hT$pevAq><vhFxQ**%aHI>|dUbZHc$j
zcX^)Qo(SWD4|o%a*)=p=YTO8m2r&!>q|W26Cin?#N$3#>BQwOJ4^QntSX{mU31=uM
zR`xoczhY04u8%-yP7d^r*Qj@dW#KK&^Wz6^?6Qz&@PjRi@;z}FOFn#S7_>H>u?X0h
zMD&OW^ZN0BX<oI2oOsyI$kdllD_t#Z`L;0H&Y6NhsHCN+h7us{3gdkmi$h9@dbx30
z#Y;m54<1J96K~s<ww*3>i?Zlit{k>xQ62Xzh2Acnv6963eeSvsykGE=iV^R4#Z2n<
z@>ei!?5HyUjUG$K+*nd(opU}UC8pD~3GOX9JAb_IPd8UidZChxLXF_X_Ca$e#Tn6~
z<Kg^~YZzWNUq%o@={_T0kt~38N_%Z6NmQlQB(EFfy=1%;7bO-1>}pJavW(O8tXneO
z1J4H~4*3d08RF&}P8~3avC_+7jyELxg^Mnsk~f}yaZx_c-yi-Eb(qYp_L$@M=4tHt
z8v&ZqARy$E*d=#m2Pc>0ka~YWGd_=}Fx=nWr~d8XjM@cQG#kWv<akthv;i8@5n2i@
zNIH9Md?oZN&|eg#1#9%GHbg-O3|0z6Qw|WYL~b}GL1g7w)HVB2=M6bRE#VVt560r|
zQugl;aPM-i3i^-`LUM=2jd-UB(NE*|dgaT417`qY2aE~x?$CwjuaLje@3n%W7Mnax
z+0D);5Z~Z;v^0aJED?tzVr?&CMwD-go_cN_HQ~hnRr~(<(O<~1%h1YEZSQ_AxHSiU
zVmxt>XN>XlfhrlD3)I)E6;`C&OxLCqs)^UgK1%=Vv*6OMCV0D;NQet@6$T5o(EEy6
z*VEVc?uQ#?-;}FPqk&Bd9r8UeK8U)Ai~D*j`Y0z4pIi9bs*t1*A+jne$%7IpLP#fK
zi<Ew|9sxg#IZJgqfI&xz?<A1gO!cy2*9p{gT7IkFrXNKd*^JF+U41N2b%DL#5*DY6
zNTP29eOsLCHmlBzUp*uFP8U>Qj#sUSFYUB=Ji?g4_UxUjLa<26s~ws}%-beyvM+OQ
zb3D^Qe=c;LpX*r)|I+&oYTxy21EDVpX5V`om;bSQ8-o9aarEVoA=@Ue9-6Wk0;%I?
zydP9Pb598FMRHHL;##Yz?b5~XLZYjgI$^x{XoMvcE)isz*EM0d7(s^9&Qz6$Eq>K)
zj&NG|t$R6}LACfHe0i_0{V+s|>v01(rPb2c^)W4N@3)JhSGmhwypx?=y%hW<eQ3HP
zz9};vL|Om)8?CJ^Ylr>0abjkOH&`8^Q?g`{sXKad8!k<`U5DA$^=u#7Ji;a15IrYq
zR|ARmayN_0aDTW0gS~sK`I(f<Yv3TYm^jGzar^mjX_b9CZ!g~+Ge)jwhp(p7D^u6L
z-g}$g<>k3{o^)l#)^^4%YsT6o_rpC$HHo{V|0aR@i3P2PmDlGha>gB3N3A)(*Xy%<
zakY0t8r;oR%h7lJh88OMq(i5p1Xw<H<#JKOr&XYsfVhYNX?%8>W9Aj-BK5AP)9IwH
zR&MEH(FRjb`#R9N){`Kt&JpuEt1E1;_d|Th-t7YM0<W&+#eJ(a&q~t03m0zaBS=vH
z8-DKFY-kidcT2lg7FndiY++NB6{}2Vjk(WxN97~B7Q4#~L(V+5@9M1Y^49C*{?_4P
zQ{&~vnM5{>hf{&o%*n9S^ERg;leJy`>LIC8?}@nInoi)?g@+?d#}Jsw$dnLah9{jg
z1_mERN}e4E;lpMJdUM-_zTpqG&=-)O7t}!v&0&h9Lp%n--_3!huF$q{_+0OklY^~^
zsxv)?OL<>HnfcH2X=aWU93F&ooOd6#F^uw{6o)lZ=7#G*mNydRV9E5y%gr>>raPvY
z*a&1$uFW7$g8^rDn6<pr#)y&<(+QUTBf;Syeh#xrh6E}{WkaL=XHzS>ldG%nryIMt
zoqYADfm(O07&_k538Lg~wyaF}O0BlSwlkfowHV8K%eDT*4d0rQqEYoVdI~MK``Vdw
z@C&sb(Ij<B?`<$;Css9FvzndjWfQY9r-9QZ3mrA<SaOBTE2oo`3dSWqyEbf{Q5eny
z!y-+mmpZjtpBHxUe~VUbWo_A;y*KVPYIWo}rxNH;pXYXoqKDwEudfwXTxV~~6LPRq
zzoGi1ET`W1-Udct`#fLqCttu1p34teSsS>|GMQn><0_zKQkhv6v$v{@t)qsz;QJO=
zzN+%}MtaXUlUT4<{gFjn^ds1OpuU2T$>p*+91n*h{waH;NYVfMko_%GE}{X5nSas`
z9j>M?2%|69In1yRDh8+*{;Q)~lKjWc1=B0x|Lx+x%%5`#-G8_wrUnKc(*FF6{g>ze
z$Ls(4RyN013nEZ7Df~ho24w_6ec!!=DeNR036*um?wkqk5;~LS+%Ys6cEEScScYVV
z02+m)CJ@Xg6J-?f^CF}sh@J;Ar8Ob49H}X;3$nD*sxUB(#H5%7fp%h}<|nWxDW&%8
z)sh&%sMyVFxuF!%3nqm%D#ND8&1#jI6W27{j5{fZ_`NH=uksqNV9vn!jbUSKw`7*n
zOC;|a@lj*-$B#^Zzy!_z3o`44_>?_nK1=C!E(~=Zb}An=b<jy8yd|_gHoX8B&G^fg
z27U8Pn4T}~=)Jj+j_wu_Vpx25tR4pmJ_^2{|6ns!fH68;DcMYryxFi1bw2pS3+F1_
zicK5+sHXfv#F7)mP#Sf%4<+wOp$(F&z9xKS^I;>l=YO#F*1?VN%AROol1zAl6NX6~
zX2uCK$6;n>X2uCKGcz+YGfkM8nUl?T&f9zLt@mE-KWj^+?v}dMa=Bz%ZT(uAC`y0o
z`AH)nZ>8qmtQqFnquvcutpjXmO248^HW%G1D&kD6b0A6yEyr^k$$lDBI1-=TowP0+
zO@g+LC33~kVgpc|hc}amu=r@#NuzhKcw|}XjQu-FH)F6m&Q+<O>s)A^_&Z^Ru0lWu
zO-2<NJ4e6`2YQdtcqvV~F0NUX@$cE<KpJx?#JYS~&ohIVyDWUZyv=^9d&bYjZF{t^
z)|0PHsS4Jm>OCIEgLn?`tF}L1ZG~5=!i2nV!&dDc5^2tsQgD_N)AP7htqmESYZP<w
z9&1@R%m~wn(AEpa@i{0A6F72%J5mm2MKvi_N)ZFS7u6hV+;E2KbvvR5BqliSCrX+$
zPWVX2%9yFdEr)6GYna7kOfOmPjL^mko(zd(hNukXe?Q;{PdO!Km}$_kwwd)UMVtpN
z?^+ZJ6`vZlERQKwp1;v_q(hZ7edcJ!iR^*g3*Hwbb<j3^9>0}V+0K{iW>)ENo{uq9
z-RG8@8K2hv8d0oLa79~HF8eELb{^QEaG1lLRJ;B>WUs)Tl1Qq2(0f+$K9ds8Fo9=w
z$&YU8Xi1x1UP0v#yl?s|w(2!A@>Q2drIpDguxJ;=l*NJ3BGt~6ZoK*eGJ6zfGZ9Ku
z#(77flhMf$a_wC5-oETvA3x1^C6Z{xM@_j)HT(?c>n|23`9J+K9mf<(+=P^^b3R8e
z9sq$KDHR=K3ypgoceMPw@Hd~JpAM9;|KHJ6`u`nGRVScRCtzV>(Ig<CXJ)5YCt#za
z*Cfy+_)nagf#E-685mf;7$&-Z)c^ftV4x>pq+|S7{YS#UO!q~ze6|0mG1IaB*U0})
z|8MPox6G{ngu<B_83|bEnF*NK*a(=I|B?J-?O#^Dg1<~(m5rJCA6E%jSQrSH=~)R_
zSQ!bJnHc{ynu+a;XZn(}uoAGb|4;k>=9s=_VP^QU&+w)7Ps`5s<>^<;O8+mOf$^Vl
zOkZ>SL$R{|do(ix>%V&c(O_g^Ctzg%S}!B>zb$-u$NG=QU!F5DGyabkjq%IY|2eqN
z#Kug|{$KHGdPW9%dY1ngus-vI@=zF9`QSXXkXSYVLaX*#)e?h(1xU*hOJGTf6NIHr
zBg>OPmdFWqtAIr4wJ4SU?eJ?=<@G~DZPU9{9x!ilLmTTjx%Z2{Ou4-X2q5|Re0+Ug
z-?ZM`W1nKY9B(%^njBA86@!ERWw)i5JG$eSTPyMsr6#!(VI_E7h59pHE!k-X-jP^K
zP22!lGC6(q^MLgA5`g?ON6GO1tu%0RIzk3%VvLBvx#G8diTi7>GZfN#<BwyJQ}oHq
zt`j29?=xULG2F&Z@5_#taMC!u4l=a4q{xT!N(*nN5K~_LVZ!Y__FL7Pn?i%M{H?3$
z&k{);9nE_j`CY`Rj5S_-jtk)s9r~j4uAz_@Y1$1Ix|b=c{xLjI`|G#nNlG0pAMbNw
z9v?)r_r?knRhDjc%6OsJ!ASQKYRx($vr42DeBPr5&w*j)KS{<Xk0k4N_}4DXWA$}M
z((c|hX)BU3InPK>EQm~_JUVs&Bi1}~6+<7MP*_BrHQSk}d{{L(nSltgf6-cWKRZ3K
ze|6ITYN(q`%O`b&SQkc66Xr1EAWK@*i-+3n#Ikb)MmGD68!%R}>IVoa8@(&4<;6tQ
ztJD>ml4vrX=lrhVEM8?7hSk|6X<HAt{%gI%qGCN$yGE>LnAtgjL*y<VT9_<QfmF3+
zyD5zK;!OucQp8>Ogts)yTI@PY{+)RI`02zx;h<N;QD4NlG*g7%QMr%1VsPPl$8}qx
z@ZNTj&|^DZSG=;vV}Wx~6eCiW=gn7xdy&HTm~r)<O4hfMApOj3d1iBoPygywlp^Vn
z_VH_i$4ra*!147d0(Wl6Vo0!c!r}J<K9cov&dW~P?hwD%8j@|+A;(H)-crLCI4NaR
zrg3Z3iC5V=?!`UR5Ir+6qw}%aHkmgsO06ip)uH*2qxC-E(%EO0y3ceN=_ARc+N;N!
zNBNyP)hYK;-Uv(d^j=lLww~)0thCzW`}awa<xzykRhc=NJ-n4)qxEaNDUD5JbM;6s
zgVA`xDWvk7b_byer?RAAk7QgocnpcAmxNgjoQ5ZDCez#Zh?nNWO<JbcEEOLWEZO5P
zdC&Kp9R2KOm=f?6*4|x2E3wXZ#!llmIV!c<E3mk`C&vnI^&AIK94`$}WE}$Iv}Eh^
z(=*QV?s?(tzOxnj^j({;=Qp)*E3Ws}3BbZlNz8*pqO2S*^!sV+f^d`wBB@nDp_N00
zst8t>_(guA0qK)MO%d*fs$wmLTTbL-H+ugQDWL2FEck#h_dF7h|Es+3Q#@B~WMitv
zi}SpMy3l$9^WF>h`Li|ixH)p$=aEtXwS_J$cA8UO2$zu-;M_86(6~I)($%Q-!n;n>
z@=?{#`MXW;{^6XN&NGr1t>$;C&kDOPL%pAxxrn(EUe+C-)Qp-^jEIlNmpHCYJ%`(J
zBG(Ie+m!jsBK>Lhd&WBHgd}(a&VuWo4zD&eoVn>vkJpF6F7XtgpPw?C=SHKPxmM8k
zJiX3-`@QIm)$cV%E6=YVt3xxAuc4o-K~_01o>ZEJ>#!Q)NhKb(tmc-8Z@^=QIgeIJ
z>ug8fz=z5l%6jZ$rivKx`nlnJQhsmolER(MN6dd#rT+IHlY##a`LJny!dS>~&tBJY
zsglJQaRdK$nR|0vc&*BK$IkeM$@u@$_(%CXiqUpF%MS5>+WL>#4~#i<`8PR__0PP=
z;=FB<Yux+K1)Kbajn^y-iT^SGe{}x4SO1m<m)~#mv_j}|63z)6^?IL+u0^88dvT}q
zW3jbAF<=AE<N3IY5%0f#KKhB9Fl7kaA6u;OK8AUjcFevMz>9N|TdJt}a`v9v&^oX-
zW3QL3CmD8r!S1eL{n;wCI6?a(8}ePh<d3v<*z`}NAcEej#_yC!y12i7{0dpj;+OJL
z@UFinAFrWhTUV>#mh$h^az8S+ekiK@t$9nn@_BqBqwG!fIf(E{U8H*?C0Be1!3#Z+
z%^1nZ0lQjL88uTiSGAyge0cKPv*x16MZBlkknqGtkXqPUI?t|@cN{BKK*FSCTCm(E
zL}5nJ;U|hvU^30g0N4z{Br4^=zz(u)Ni+W%LE|4>y&@N3F7sI_lA0j{boSgR4Dy?P
zmD-T32=q6PC+$3bHQ4uaiik*SjX4wVRejbMU9t<<<IVd0cbjlF65e}NHJX{4SFd;@
z9D1xPTxTw?JZ<mxV^Sr_-xDZ^6eqprQ6IGB+&4<)svQm^J3_EO)9JfD?p*B;$1BS!
zQkd-r?@WP|qwk%yBXQ!S(il7!^ELXyQCO<-8VV|Oy=gpe@w%j0Oib3pTYN2^ZjUFK
z3Ck04+u~y3_Wdh)zlbc9!j|*R{oK&p#VOW(%SV04#~95NtWzEodgK-+<uGmf6lZHB
zyERQw?VYKPg+^NY#NAr*n=0~cnuBMmH#*h^@SL~ye?_$kDa60zETOrMuKRWb;Tf9%
z6Jx50VlpGKE_UMCg)V%G9ezTIPo~c)Xs8CbOvuFqX7;WOZ*&y1Gr%ywP)x7aRjWGS
z)4=68(*7<{B}&uWV97Q{S6=u=lK2u9mVSJ^9~1=>p#mzQ+iliwH<e&nD6uxt;l!l5
zvXiZvz&^vAnObW4;iDBOF6CwmoLk}5kj@S+BAeEKHYPu^v&>E^DrSq`<*TlVTd^Vl
zJCF<>TE9cdxz6m^bhuLp<Vutrk|8cQ(_5t@)HdZ`o#wxz<<@N6k42}Q;QuwPa&lOo
zX2kBlH!(quXp+ES96Ty^Gm<WxFsIZp8%Kk$Xlr=%I?hh+JE(fG(Lwhz=uFZXbBS=I
znow7IC|X%+d4q~}-JI|YzVYk3wPJDAz=Ws0TxThAMlxk^&OH9`Jrx|W8%#3@j@2{V
zf%F5mBL4zdXdq~5Il=<W9{SG_r<SlZim+y1hQy-zt_;Zf3sbx!Co4Q&@DhziqG*kf
z;8?}Ay{Zz}W{M2v<Sa+4E=KMx>Y=Ly_qT@q8**11Up#l4Hiz9vVd}f{>e<rjvliyL
zg9mfz4vpW`Y-@mK7nmTzKHnij;(ZiqjDrVQ(h|L9iQ)hS+#P}(WAw;a)z)$~w$T)=
z%t@zo5_SPg24hHzb3OJg6LXZ!!(^%5*;+pCwSfkqbF9CF#q9Ilvh{gQz&L%RR(i9)
zd%HLVwRe)`8c$3C^cpwhh0WkhGv|-<Zlm1E0vn-T%dG5+gSWVx%Z!cnz1Cdk(^TZA
z(K~Nk(hy|0%M>|idI*VoYzz9#vqTXN>UQ(G%Xx~8B8_DwC50(>lI#f?6TLqUdL>4|
zQS3&!eO1{r9hN6II#MlBGqjXcLmJfl&L@HL`#oW$`6Z<V4Yo?ax~0|n>Snu1F_oWE
znKR5%nIj*%(s|c$Z<HBh`yIQc<rwN;cxPB>Oz!<c1ru7fGkY+fPEawgxeVU2C~CTf
ze6IGad(Ta6*I;z*sdwT<lFf$v!l?lP6J(cb7XULRJE@>PQRSxZ3?3}|C<^PjHB&vT
zqYPGi1JISN1O4n;iYwo;B0M8BTHTB5;n@*VZt1p#_=QQ-8Am`Lgi||MtOHop>dZ0Z
zk70Um=|+XWui#Lh^)81e$H6&=nOH<#aWrAakOYde<mTToH$G3>sg`RJtVMBNaL$8k
z2YTBx5q8=Ng@TzT2a?;<1z-IpcUl^LZp!tL1{$`kag$-%qiy~o;OZmKb`8oKNIc@r
zFKQ(Cu}>cT;c+}=+$Ho<k^KBibxU_ls;OkwKLUetP)54PTq=ohow}mJ@Z&Bi!+mV7
zCb19{?SoekLCfl3oSuwTJ{S2S#&__9Vj1D)*-+E`;ONAzTmtQfkTBG*AB4Y9K>_07
z9CjT!^2`Tn2}98~`llvTi1CNRX)lL~*ry9f*>ah2V2M<brjxO(qtw=a9`9IL@XPOq
z#~WgQO|zt)8AqXrt(B)kjbKG2D!WH3Y91f3GhmvhXrsqSKg{b*u^KL5g*XH;h&f42
zh1ZHe{(2!G=q!jlA$r8IFKlQ}$F|O241(F(h~!08i(jxJ6F{Tm7{;Pr^}B2^DWz%!
z29aClh-Di7<uJ^P5LGgOI!nnbyK>rnk-KuaQ7}wf`<BN~?^Lry;f@z!JCry*>lSr*
zcIOn-A<+50_eON+<f=ep&9R1*oI2N*bZ%3%Zo|sFd?r%Wy=z$4RI@$LP`0lQN=2GZ
zzqvMWqj-!tR~|7%uY$40H0aM7l1T3B9~rqHcTq{6R4~04I;iC|&Y!DE_?*h($I33P
zM2;kW-Dd$aevzC$mq-=UtxH#jm_;~^*0Q8mIc^VmLeHp(^enh0Wfgo#9Mz7IAR?}?
zL)btKE9pJX(PDyCw*H}-eD+;Mepz9bII4I-F-I46o!mxPIyhS8Cs-VmuYogI1j>5C
z{)IS>lu!u|_j>5Ucc-Q8^pld<D!<URtWdN;xq?zLY1>}0f;G(QodE@9#Z$2%Y+?du
z0zA)UVW7!!bY02F94g(SB{U3?2YTYViP)1?@@`3Kg2)kvt6wGaNn&=(;L)(jq#oj;
z9rfCvir!ZB{X}fi35hFjmR5>?Oo;g(Ydb{CUUV*8Yeb;ZeY|*k=^ploCD#cBsXRu&
z41;1MuLj*OAo?DFK%J4N$hDREHhSnuE4nYxQdpthB9@0v4vl{C3;fy+Os$B^V01D}
z49%-S=9s~qDQGE7bw9pg9kgN`-;GQ7eWtb)$W2!X8Fh^ST~XE86yb&_Wv?e0bv!i2
zhflBSF6|z4GhD!py@N<D<DTWQ;=bkFeHrv*d8NL^+GFjb4b=td1@^}FM1PgHM-=w}
z3jb{sq(f=}#2L&Q%!mUw=9^GXXSU$E7zLP_PeJ#B52hi$$VNs8*>HtsGvJp{cn^37
zZ|H3Tn@p%MU{X;p0huyEC8wWVoJx7e0+2{<n}}>oF_Yad4@e}d5e*F#r;^=)0~}Dw
zRrMc>j|258k?rG?D+Du;8^q_y<SP290HyK83VMaejPc2p{Y-#D3b`D?7Gy7gG*Isk
z@^8Rsd~$g|F+e;axw!uuV33ktIuw|IQPz(E5T>LT4~-FzCzC4|j6n_*M<t`@hps|?
z7Kc;bK?MYn+twnJlG7`Mash(K=v6}b#Nib5e30K0j*0}e0d@&Td4kpeH}aS~K^cG>
z*^FlB7pzA7utIJcG9G{-UR1faB0wUvQaqo0MhLnHxkTJS>6cKbv^X(kOuk?)GPHO<
zB~np<K&T2pFTR=*sX{OwIYwNNOc&T&8XyE+hfD%+05AapkWrCy6+`{Sab$Ot0S}Zl
zGNIm-*I~$?@;k-=FZmr2z(+|xPy7>K=w-r_bf|U0-?DyIagU1r&4efMP}+p2G-PeE
z>lWlJ^6L_0Z^a!HzysNJ4KhCYbq=z(+zvQkLwScAu%Wnv3)oQFp$2Ry?7#!Gly{f`
zT8cYp04K`pT4Y-C>s(}7vg>x_De~)b<SDZ2dgQiv7x7Tiguf;I2!Kr49a{h%a7PY+
zC%2;uXr!FU?Pmet$?KINtH=K>7nBV(0)UBg759UGB~<Pw0kBZmW+8hk?Pvim<aVq8
z7xFvOfD73jCx8`D&mXyo!Zr+<mC`m2nU%uUANe$)Su6B3zF8^MJib{iv@HH94q2JP
zHV`?9(l!P8t3x4FBHl!PM-M<FuUCO=9<Ndn!13_i@eJwYFVTFBNU?sD>=0f~BsV{<
z`~RsUEJ5}VKWCDMKf^nK<MX@Y2hzzK(fqSW@om)q&5r-LbN=0N1?i-oXx>z$crH@5
z2scNXlRv{Lfa5%*cS642<R@esg7fw`&ROa=jx69IL|f)Jv%UEi$ud99JU&YH2ESvR
z!hK0&s5xPuM2I;UK4bcfk@;>{3HF8nQ+m#yUm{-E6m+_b9-#xq1;z}#GkLhwA*Li#
zggJ}CR-L3@veZRp$)zb@5WDn>3=;;aJ@<w7W>|9yg)oJ7Bs_DblE7pSNkhrF6cYLb
z1}THoZl+9AoVgN7{glCP8F_qpDZ&sL`n*Ib;(n7g**n>{3bIH*LLlg2#Fm>@p+_Za
z`Y~#uuEvc)VO;ZzY#~=6p`?Ebq;0jYBsiP6ccGW0C%Xy_5WjLMt>h;V0Vq?5C%K+d
z%kF><BpEsz+|wQ1nm(4asyx&?8I2#D4;&eZ$CAWFJQ<HimdpS->5m_uBrX(mBB2{#
z9I(ywCr`|vmvkyLnGDnWWAJB-3p*}h1o?~$$pFEL1|lWd!O1KgS<)cd#E`=T6$y&%
zo^sBs&@=tfTKc{Bj<zr>#S5k|-q#DRP!jSz4*03_;(P2q`5Fn_WH>i`3A*hxdg0{k
z(tC+LwwBbkiJ4-*$1M82Kd+tgTX&_;6`#?we-bg}qxTMU?p0%tTe@THPP%%|G`q<^
zqtItV&n+&)nyzE=4r{JVV-Kxx{mdif7*O~#MQiKV6eIW0q;X27u3M_<&pDvRjhOV;
z?c<)iZ-?BIcNm=bhHe4Jx`pSG)Eai!MR<BEqxFHN_H^v{sBk1Q5X_7a$#@2CKF3~#
zQj*vy7qBGyUFhBiWRDE%eXh=o>jMs?bGVXCjO&B-zQ;-kPOu^^DaRy}Z867?h4+$6
z_JOBtj?{C^lFIfQia7f+lFD`)Xp%{cnuGO`$MQ6;&_$`qG)Ao<rqpw(I`U{Hj&!Ez
zNBo7beqxT<w<(jbB+tANJ;WA+J8L?#I@1(|2^yXdOPs-`u5=}k4lK&rgAV9(DU$G#
z5-Eu`M*|w3NOQe9^2{cnP@Mh}lg6dS92ur~a~hSb!KN%t<&kAe3=1|RW`(MfijoPE
zj44JoMMd^wh4fPU(#keRcAYU<$4piisGTuUdGYj8MydS@Sdw>sB#<ckxFp|D_V4iU
zCEG!mXp;Y8J5c<@9AhF$4zc&em?)8xBwAKQmehctKp?4vK!ZS;f<S{r!RCYLc|xB4
zPC^U(J$I$UwQ;$FDh&@inBXsM#6gZhS~MtI*silCIvuT(j?ct~p$v-E?+Ts*`EA$D
z_r-q1tA}m5rn85wg~dMQ#pZs)BUnq49jBZWh={P5L7qk)M$U*qDpG<S7p!k&Gwy(J
za6m>=SgAo9Q34wmN1jk(KTVGtkL)lG;t0cG<QJO~n~a=-oV?S*kE3i;&6r3YG%|@g
z0my4MAm$`WwvbdJflXqv7enE6B#98Ci)mtZN|e~qv1mBuwTL)XK6>x|y|sDu4z}6l
zljWP`gTMVrdWE?6?sNCp?cCket@YFe+9|xT8S?@2g#3hkB{XiabVzTnkp-Fs<_+=N
z*BbFje~V~KApaBW1H=X21<_^6tMwGuoo8uvtLf~%lJ#7*lGSG^N4xH@Sqnl7)QRZR
z@JXw7%DLnFJJ{Xr^wjcUOJ>8ABe#CmuG`A*)dpC{EdF*<-wdB7N2p2}kSOpdAzC|b
ztd76;qIbwkeKQi8tG?(u*l&oS>M>0au4&t_U=zF`E_5drOW<;2nvWtCHkN<Xj#n@m
zMji35jJLG5@V2bBDvLKNIeVNzn(`(sx8UW9+N=UQAzqBONRF_PP9gi%qEwdpoN;Za
zZQyN~ZP2br=i894D?@NDTe<A~PHTskD;;B;TWBKMhZ@wT95jm$TWEf`R^EC>bl$SC
zyiDF#+*PbJ&;D$X7p!oo#A&-pPrz38s-DHR4%OIJzu+|9wcA|otn(OS$=r8WQ5SGr
zF}tMOOu@$XC=BWkDu929g4fgcCo}uui5(ye9|`H~kJmBZ^tZ`iR}Y^$v$@&UR;T88
zuX~3(j9HE9m%5s>h1S`b8rVaniiLAL)eZF(^;&bcv+%mdCKr>9)rQ4pdPJS4qbqag
zN(6J~NxN!iX}kF5c>8fDCU((l;lAQip;h@+!r`-LQO;X@J42SWeu}l7R*CiOp!{Y)
z`*r8_Rn!>vDW~JE%4TxAT;~k7$g}W4!qcA_*OQ&2or_#f1Mop-K8ay+m=}(YN$$zZ
z3=%uYbk1})4~tSt#Z#nJRaEICDs+e6O}G0Q_kZJ+<(aI-qqG1u8Cu78wndj5Dah>^
zZg=E41|qebsxq;j5_rl=dNy82_Fa6!+L|Mo<*|Q>k<#|WXa96bAe)Q+v?3H`<86gE
zYz!e*4*f`u=GihPA*{@<O|PM5No8WuNn>Lspn)-vPE@uw73#K=^YK6fzEALLC|SKp
z@)O8?$cDyfby(pRpoPQdOFcl{!(-3Fj1EC!6+F1XuTwDRh`LUO1K=g>-Zp?_Rx)dk
zwr;a1k;*t~7UdxkmJti>H6|Vw;grI0NsAck*mKsRV&&_GOM3+im89<HSHmBMA~IBz
zp%HdMrk!ua&~mA)6kXN**b8meBS`OSRIek>ld2rxNthCe2N;{831N^a<1t##9R}pH
zH)TDdz)9PPFkd4YUuwn4f}yH=@AZECb)QeK-K;&#nNm$r<`szU=WbVCA{&}&7!~Mp
zkV())aAWW>pE@5#Uq~JD>TfFFsJ@|t7=zsUx@|e=;L-g|1|Nq!@lnf$EQT}!RpbTG
zp(KM!LKT7nePOb3uE2{xfgt#@kdlxjpatE6I$(5o7*Odj;Shr$dA@SpqS@cbApiLA
zXM<pXy7+qNu-U-S!LeboL1Vz|feQHabQ9<h(19Ew-hsb>weaF+vrfYfgSvrn`&{s{
zL_-*Wt%D#&gXV)<bwfBn%=*yypol_nfRpo*5@3pgA^UzKzzYG#;idWk{@2%p04C(y
zFA!`U2r3^;x(JhjuYct5f(SB${kHwV2J!}T2K4~?3F!s;0r3X+_U-Na8_E;Z75EkR
z748*v_0K2BC#)yVE3_-X73&u4mi-pv7I3Soo3tBm>t8$47Hv0F_iML%cUw1S_iDF#
zcUm`g_i49zcUd=Ox7C*67GO(g3u4Q4i+xLV3v<g<=jRpb6>&AnUr;VkE(9(}E*LH_
zE;tJ)H6P1vfo>%o*lNu0|JrJPxPUa{|NUn1?E?G*ZVh$~d<}jLVhwr?bPZt*(gMT^
z!V1(1(hAJ#n-$0+_!9UM=n~ixh%&e`s5e;Uw@MHiC>roZ&?K-V5UK8gZlP{99r)^0
zGhrr}a&O;z+UgI8#jfs`pDLeVr`kI2u>b!;bnw66-yT4Gxp{REfBau1|7&hf-v-+1
z2Z+Va?v<Y^uVCidI_I$EU&2q3%f8Qjr4JF-t*$kbkys}vMpJS|;~z2i=(+yNj!&Km
zp-fSUvP7MW(;TgTGP4m)&^19CGFhhA?~GxlrQI?&*e_^5-=sNR8eM-2ovse^Lkm{C
zsy*VhW1G+q)!%9aD)^0f4$qyKyg$%wHbGUHIpSE<^aJzdmMS|CE_nug7d>6}f30(<
z6gD(W*9b@8mp9>fTy1d&NAQs=PAjAe&y~cMPJ2JEvf0x!6al#>iWtM^F^AJ4%yH!z
z<zQCBau5^Lcwv19>f^DFBt57Dw2;L|+J%H$eJ6XD7&y`r=h*B0l!7XaF*DJIRju-q
zK+BFaxKeJ9JOs#%rXU;$D+Yn;5<h1KhNLvt3R91eTT!Q;8Cu_x-86&e(VkjkKLVa@
zm^B5KX77`Kvd&5cyH+v2u})JvP#%Pjw?SsA!vpN`3ye)Dxp@(11qM}=^ygg!=bPs-
z^_zd_SA%i4XKRMJzD=58S12B}ov8zhi^jHix-=sg1$N0Kw0vT50<-+XYj3J!n!!AE
zJc~urTL+Im39Vn{*fW(QhNRAg4}^&T3)>s|$L7aI<=v|`33(I?=hNj@%nt6K)Ru;<
z7{{DP(yg#lJ9z&rXnp!|x<h64aYlG0ph}>%L(j|Sf;CgaCzV_@%@j6sPoO?R4es;$
zCh}kt=LTw(YxP*y?Hl8s?TT;4ftUyRl>QYr(#-{fN4i&RCcj$Z&OGBCl~eK0BO$j?
zt(>Bm6-$jQffGfyjE!vP0NfMi7nmjRyV7UIKRHNGPoH#y&m^gQj304rtJ_A>1;i`U
zFA}G!6<tSp#nSQHAT7``rm&iSWX{gL(qx;-X77~6^QkL%PUpJU5!<aZ?XMmdFZZk!
z@HBF}A~mH+Dd7ujnKCP3%O|gS#GTURV~>ez9L?qBVk(;MZPR&~>~`Vwi3njjYDgwJ
zshOEK>nx)UGw@hjh3+<Dtu=$^Tt9rH5Y8sKuVyx$a$4MlE`qZ>?m~Bi*KGytp*(I5
zNZ-Fc@<K}<EbogshU+T4qODYwtA_T+UN%BrJgST|m7@sApV>>=?41q|&L;Vi(>vcs
zg*4pKefu#c%%tjF7+y^LYwI8pF{ZtnSxj^iNr{9RJ;0$5F)I;|HWlYk5{#Qk=J>te
zmtZ`5LBkqH<9G~xTFlKXa@X}1Tl4!L@e+@dxtQ%$vY5)O8jg(88eXIQ!fWmaFfY}2
zXJcdMcD`T>>%X8u*-m{C$LU``bR(CwO-eVt8?4w})x22WUqsW4YE{%)3mq<8?Ou+^
zYoHN;3VuX1%SI7VVHa9V=iRCKGz`K?`NWZqIygadbFEYLqv@iU@j~7)yPX-W4PGsP
z6+-Fz`T#*CiPJ~*T!P&AkbtW~@r2`O<u=<0mdcHbUqGYBKgheSuC)x_;gNr&M?`N0
zSA=TGQ*&`=R{S$bxvE?oWa>#dep|}7Po3qxy}do<2-w>f$wZwpF(EKm`RH4JHiN#u
z{7FB~Y4VnioLfaB%wzN}x5lsYOh-j4rj|s=-P$%JAyp42O{^$7rEeuAqBOty(Gyh?
zw~$wqhGo$kb8KfwBAASh^Q4!Fm$G#nn}|ti@yn#vdGg}qA_YsIL&SqBlMAqnsXtpW
zgS4~fKPB>)Nb&%~xRx9PO@Gc&-D18K{4hGZbn#MZ=AbfpZqQ?6El_&0C&bDr#CGeF
zbqMQi!l<oh(<+kXX>0<cF@5Nok3C3Ukfs2bc!VaIY~dz&m(Mq^d}kV&><9gEpamWC
z8cNR;+2pLN##&TVAF?)ae+;ckox7Cy5-{Q~Nu7Im@WO}WxzA%UpGRVJUx@?FP8>>~
z=u|fsi<(+therx<TG*>k?9>0VINm6DIc_gp<#v5z8&~CdzSi!F29QouWnIp-pnoT&
zN~JT@oQURIP?p4P%6HHy|H_PMZJ*yiMEo%9l(_!fH_`O|vQ<y)EMqLmZ|0$w6cBQ@
zcDBRJshocMw}q(Iu8zu9bKiQx`WJ&{q$fe9hC>Gqy|tQGtEgy?3xJJI1v(U?B)|m@
z$PY6}wvAN5)0n7$H#0vSf@Q(_WXzshl7l4W`3?V>h%R@gCt2P&Y}kw?N$z9gtr5v1
zu0(tDc=7-PPX8|PC0V|X3bR~94o<zZ24a{{d}<gAmDT3T$00nzkzjBPg*157;W@so
zv+H%M>Fev_5i!H%`^~{@1^Cakrh}dXv`1>Z(si55k2aE)TB$?hHtDwAv3vU_Ew+QD
z=Isbhdf>FZCxqKZ7+&<dmGlI{MBJHdRjokBD8fAj=X}{2I`t$rQp}dLO`d%Tb?-p~
zt5GPf>dpdHOoHJt)u-=}Rw}$%qm6e>f|PbW#`+|)QmB91y7puy6%nrjw~<C|<jTY3
zAl+XHY6jlw4P-3HfMj-kHxn>N9C&@mf+1Xzd$dB)w)1X9JDqxtv~?qvUAyUDek|p<
zz;AahQh(243S+J(U9b^jsW(zEF2n0^(|>Ls#s0`Tsm41q4znNK)ZUzLm7(o(F`R=K
zbWug&-%a>|RTVJp0tgtSBxKTp#;B@zU^+=P5{hCWC3a}654lKV6z3d+C%bDLUPoiC
zUoR#e&Q(8^V-Y~#khhK>WSM(VV#}Q}n^VrqP0IOP^mn0Cx|^BSQqSdN1`y2zA(7L!
zw;{J?*X5NX7|Z)H((H5}Dzz<G3=Z7+;Dj?>G+pUeN#{~5Us^tAkT|$i$4TdG0E-_{
zPq+i!WO6p<`c%MUDmWVfp|&xRVuOWW*ZL5o-X?-jG=WixoIPp0u~)0ebDU!=BE$vG
zC+V3c5)DFQB*Lqbmy~F399`K7;Keg41Geut&92%lM)n2bQE&~c4D%bqvhG9z=Mi6w
z{N%+^{+ZZu48kGtP)?Izr&_%WFZ)fwkA+UjBY2x)6jjybUl$=4{ecf3`GR4JA$tbz
zKh5>NHZjU&x9YT$VrqIKAt!})9a{%+87W6nmGf&T(y(>gMH)LSb)1-$6>#Gw?vh4b
zwrb#5R7hj$xXoW6C$0&%jer@yNkP=W-~1btHEA&}RI!|#C;Y|EZ=Dq<<BwLY%3}+5
z4O-`~dSi_iBNBU3H#DnuIIE!<0c>gKRC_^egr=gR0zT1=R1o6XfwPH|4o8xlbEe3g
zwqmgDo3OGgvrDXT(%MDw_@>&vB9t)aywGCt&XX<5wPzSuM}l2h4xWxvEgYMVJe!Z7
zABUp!Vuf`7E<Ktz$^4uaseO5~3WNHzXd1>m1-OOV>H}h}Hg@Pi;oW}`Nz!*l*(FqM
z9eDi7%QsC}$-3uXrFG$wIxDwua(Rx)k}W6xdJ}k`urx|HA)lO>Nl+D*@3^k6IR@z*
zNh@au879ybQtC=7pJZ<)OdtQi7Y~s=JE=3J3^3335*<*Vr|&HM<0KNaRt6(TSOC?+
z4GL$Y1x7o3)w+X}WDyELj%E)B&uucmfAb)P&Au2Sqz6F-eWXq94<Xuu4#6-G<)C0~
ztw68hliowgAKhb0)euIDx$NnwZ@d8^L3^;wJOQcdejK~fr%2;8STAY7{`-tscRy<@
zJQ9sMoZ!>Xt;Y3f;Of&Lbe1$UOscuBl+e4y6#5&4Dxy!VniMJNyLp4~$k~x1Wk>1E
z>FV^^7b9%olvG<vfiQu0*l-1{fw5F`^<4uwIO&LPsaDr8fkjePH^3i5fW^<Kb8xig
zo54(~5WGu?P)}hldC%Q#+C(7$?&KGBs4VpFl0LIIsdXLL*Z0CV7MV1Eg6}Oo6Sr0!
z?Y%5#aBUel8%O0)OIK{eKOvhI&Su8k!+jP@)352S&2HwTQbb;8K3mubyU?!5sSPhE
zdCD{Xvf*LBJrG<o=~xo%SHrzU-YwwV2aShe@{&Bm^fpd>w=@WtX5w$v4RGii4l|O>
zN5lI{`3FXUmSo_O6yTa9xTk>}V=p%7oB<&y9jba=8@GbQlipT46Iid`&K4|V!q-Wi
zhEz|)z>_-qk1#JklD9lBpg_+0j{9!(n)dB2bFy={3a9Jy%~P{(8@rQ<`@I0(FsDI#
zt?sqv9%(10O5=Bp?%Bv=rpukb_d4ARqW4EpnwQPgO~Pa5dh6k`JEYRar)Pf;@0l0q
zxFeKOkSF~9A_z5nLSm4(#9UfpA?p_%L{MuZZNf{+lnopzy)K^v->~ncF2eYk-j`5h
zk_yoW%wT}80f;FFsE}jlY%kP-HLrcE%0iO$A8=jjVq2C61cZAKc6@4Exr*vusp+Ou
zHf<N)_?~mt8P-YZ@1kkH-rQ8IgWlvwMQzTfS5Zjwf?y8DsyXXeTn(yCB!tCeLI=dN
zEE|K!_o|>g)DKG~XnB5%WCk0;^3@6DtrjFu`K8lt3OKM;;EZGw713bO{ipCt{8Jco
zalG6mFBMBE34c%#@s)z|3&RuIe*jEM_qePkL!q{Csu$r*416niL19-4$QxQgbwwlS
z@;R;Dp;xG(ztYpgp%+TD@Z{2jO9at^p<^_}7DSjo;8|9<8svghyMMfYgy)nuv_BR~
z_LEJ0-s+W~*EF-Qq^Yf*m120_(8_Q*A%R`UXk&7CIkeWc^c68bg(_RWd~lD6T)3O9
zW*T2W9KHGm{1%6pR*w1tN8?p;IxcO7WT%q?ueSr|R{*bf181@auU<;2WqPWk8sJ;?
zBa*JAC+&%k(-{?GIoN8{5lKLhU7wpX<;rNR2XUBi3#O8{<AY;YW^!nc))y4WDi`l7
ztOGMS3Z#~Sl?P(H{a}g%kOL%@VwQB~Eo@_QTg1Y8EC$U5wq=WD1&U4dyA5x#6z9Ew
zhNq*2X|P8S%z-(D6N}!rH`QI9nzKN4O!|w3;ag=6Wffp3)Mt%-?mGNz7|u7=AAilw
zhU7meyQp%pY(z0jv{+ip@+?nv^5jq~wY1_sExW}w64tGBk31Gv>%sO?GRxTQz_!|d
zMtvo0JwL%_RFj==5<9Sn8($+aOko)*x3m`&;=q!@4tHV6JmB5ON9<SSL|k3bjcq!0
zxPoS?5m;Kz`emk5$YUt-cDD>vI$j{_%v`i{LDw&v+|exu1@7e3|G8z_f;UAAGiGnr
z7le+&YKEL#gM)TU(^O*7gJk6WQ{An}j-bRgbJR>z<WC6cR&ylrH0W_;S?u@v^i3N2
zq=OOcqyf&!U6}WMRA*?w2To0-pz=_FQ88IG7hOTfTU1Ue4h8qM>-R>ZdHG0gu1^<J
zC|cWVVubUzoxWA;6_#|9m5;5_qrbd$zJ=domFP=V4qf!$|EQ^Z><y+_;fQT<T0Ol9
zuAN<9^EEA(7<(XfmFWuQ>be4@avk?CdU95UDI1iU_y(>axr-Zcy^88uxmCK_*)vTr
zm*G!IsY7nMKyJrL8SWT8u-HNlv)7Gv)@{}a@n@MYPU`AxGH2XW#Mujq@t^_+IEUM(
zgd7jEBV=Z!xl6Os1KIGhXfywy^s9dt3n~2oTL>D0b-=+9Yant(Rg5e)YQ0<dHOe~1
z9^6Avs;-m13HJOBqO&Szp%lK1O=*i5j)#XK#q}c*Z<w3=N6gi0ktu?N|IT*_>@5^t
zdZR>1-Tz*^{!I6*oWw&f&`uSiWy2bpsIXdO4H1_&5>IDD2}{6Ksk#uNVju7&QcS$u
z!fC;b0n(3omttBxIXm5(f#qcIH-BP0JKkS|a)-^d{K35Uft#GO8*W>7UbEWO^ZPs%
z+>M2`diS{c`2{MipkdFv-!>qr(7Pi;(P6u{u%WkDp0H}Skzn!UchQvE{e~*+<!yMO
z=$LK;8LtQ`f{V)A6A&TR``RUGmC|1f{><&}-1+7W4Gvv@J&s)Fy$W40qbmJ<QIYIm
zYKLE5kg@Ps(@cZd1We0yi<ZaisRRy|hHX9j53f$pP`wx<tx5L@;#<MZ<S+b2aS%%B
z6Vf?C>p5H0T#qp+Af^P)5h6Pv=Gm+KYFPE1i6U{$2Kn^7c-BF|rG9{@At3&u=PDL3
z_G^v`hBEw}{@Cq5iq&3=RRy<|;MK0%?D1E-;+Mp}RChSAdvyyxo~a<1yF$~$(pPvY
z3Ll-=VB4eyfW9K=L|R}U-?Anb95mV`;K6HVVTflPC?IjrCA6zCyo-Q=0rt4t9HW5Y
zPZPXUOmNKr<{Vq!bLsHx*i4nbO(1f>wD;MGLx}_2Z2X(O%~UFJSS*}?PK?!}<aq2_
zDh3^Ch?NFmV1pY%^_c_%`X*StKK-Yz9WWj=Z~rY*NrfNJMhgwh(G!J?m7mYp^~p1F
zfwSmt)nK)M<#*!lo!A=I?vyqNp;A`;u@^O7x0?WzTJ`p0;4_O}1%8;HFf8##b&@LC
zwY=yK;4_ZUk+6!@BtB06`HrrD=^Ku8S5WlsDtRJeTe+83Rcu@q$p_lzibc?FfvV8O
zBMf?PzwWOrpeY72DW57WPpopUcKREK%ZvM{e+zHCYLF#gI(s~uM07HYJ<0))B(791
z(gbu@ak;mvq(s-R>X-!Ol0hBT3@0D!kk-c^wiVXa)-spm4I5OW1h$jph$N-I4Xn8}
zyPePt6b#%k;sWyM8~c<eJb>xx5;wF`5ykTP(-iJoxQjvG_6&?b_69z#=*x#m>6zI_
z(XxSh|Ga@U#<9msLhEDzip+eZ(|{*OQPNw`((!4!39K`VlG)xqZrSzFTLhB*2d2BB
zeJ9U~*1%zxZe(NcbKUL9>Rtxwo6s2UGz_UL6_-eTVM6({{CJ8Tvh*fSC6uWL>~&{R
zVQWxvNpjz*G~H@WGIyqcjE_S`F#m&T(R1w9o-BAlw`B?8#!oX0mv=ExCY5|$Ab>0J
zg$_Qg9cWc{j%)oxdSh|jelPw9_NjR-Iq&mCF@MRm!{dYiTFuOR2em#m5;JvDjJBPd
zrB-mxp*`(}?W@f1%_4gjORuVp!I5=P<-SFcK~^4y6q{#FrbC}`wA?KQUeNhU^??OS
z@R)!bCS6I&uSHDczvo(*=iH(E%u#{&mYbFwJ^Kl<yck%J>1`UA(!S>Yh<Mo+ur|E@
z&U110W@WHo8~}y?*Umx;V!QK^bZA8|$`RM|;OeSF9h<gGk?~&W2>a=oY3o)|rwkT`
z@kvKGaA=EO2WC|}Tj{OSjp6M#ca#LzLu~O6A_Xk|#;)(8s9xH#GP649vw-Y347KVY
zJ%zi3rEQGw+<AIrSFCZHA=ZWpHuv9fc>Z{!T;Y|XsH7nc^&OqLbtqC!eFn@d!=)<@
z?S1;rsLl*mdhxcy3m*(AWyg%Lu`zTA6x8Y?w4MDLQZ1Iq6dP*{1hdvvQImF(16gt@
zmH=xt<MS2sj;}N)*;q8Yg}O3L4fNMJegn4ymuwMcx0w>ENPJW5j?0QUEr;xY_jpLK
zv#qwf5z#98>E*P2qQ0lDfFq$lN4DFnp@!!bj1*>a7-DE@nDMDu2FF#Ja3z5gp&qXD
zJH2>=#`XJ)a5_B!|KOI6g3@OjnA!Aq_3`f!>ZQ7Aas2lWepNaf)H&$4bNQXVw^MPn
z#Y@xS$#yWnFb|1AGBQgkCu66(3#kTplq~Gh71R%bp5Q0QI*}n)<#HVAw(|jZcPM<9
z>%~a!GOTd%8!dlLQfJ7F3D)23Mz=)jr{g4FN9<6VqipNX(0Oq)t8k@f9aH%2=S7Hc
zscTmL>NnKcK7>?36+)f&bys1Ti9RqN>EDgWvtYVGa+*m32}USr+@2JkQL%sQ4mX(U
z=e!(h@)JLxBaUbfOLe#55yd$ZCQQNJ>(W}^W9&a!W8?)lxk=ec%wSC&V#5yYW&L5x
z>h6+fOB4=y^hZjq_EE9c)iDrXN5z7@qQ(JvITa9k{^&K9>y`oeEpd$!?OixPg!N%W
z2X#>|?er6=w-dY<St_8}FYprlQ9G#O=jA0S%cO!*Y7!umM2*)o`&W1}CJ-6Ll-Vd!
z@>wBW{|}{_+B~G=Wj}4d&IkVws*WQp0N!j;l>81Ka-VJV;6)tvo03R(ZsI<ow*IMR
z{o>iS<!^tmc#%JEtk>`L=_Ia@<NV0eDt>J@BG1eu!%N#dV8&uDiAttyiXR8<{FQQ)
z1xKQ9$SS@=W<r!01f3Z7sL5QZDD#VcD+nDqnYmlbabOLOS|&wF)61dSC-tsP^mLys
zx`DH3Aof{rV%z$fof+F_x%dV^f<M%KRsmT$g}n-x2ZvW>rhziJKqaLYvxF;Jgxduv
zrBuayMyBJn!Z;i`1=HOZ16Ykk@ZrN~wU|Yk&h~5%+QkmQ#+_Vi(=u_I9voiSLY{HR
z8+Sa9p4}0e!H1mRjC;9KQzrDaUt8}O<rM==RGpG_ihdX~UDVKfQdBLK7^TV0^!^mu
zROi+$Z_leZ^|gR<i`4!#n$0uIl_*N05aVW9u=c&9?1KGM6eue0J+RacHhgJsQJzfP
z{&xk1r#C2!X|kG-)Jn)n$v_@+@<gH_8vCW>jb+xkk+W!$HxUEIpe>j&TX2eV?+o6~
znXq(bR3+FQ=3Cx90_^49kyF;tIY8k(%FxsE-LsQYCMi;}a^LZ}dwMCDs7xtB_{up(
zk0^NIr>|wp3;F`|4d{Fxqs`isj&Lrtr1DRfAd1?De5WvPgr&@AOKo02v_p9YQoVY%
zLpg-d-ot59B<HHt>qn2jv6ZD2&&|94s}W*>jN7Y~YR3z2*XA6e7NSu{z-i>?{npLo
z)Z5YD?Ib*v4cD{hS7jbzrXpu<CWk&E&a{;x{2;jRE@#3%I;2}YV?yYXSr9Y+;P{=G
z&Ec?JlyNmZkCJg`jq=M)(ZPng(X9sM<WHGCG|%Szw5T)5^84ZKHBLJpCA)z(NISL-
zU2}6T0xQm?9Sf+8-rHqT9n4BQ&P2{@KgM`ePLNY|QO1g17}D5NsJiCXr)gjGaPQ%+
zgnmfqVaquwxitTH+lLs}g7>Blza{%i#?<I4f$Nc@vK43F;wKJUTT49QcRDV&hj)vP
zuH`1~vvgBpKjZrKHu9D*sRfCWCDPcdH#Uj*!%0VfM9Ilub2aXpdwJL6roB#Wi6!;1
z8K!jxQPpJRc`8W*RFoLChIa6J7#c$O#BjM`q{TUJb{tyaRZI&-Kz=Way8Nc~-uuT<
z8#Q&c2tT&{h3(1=%qCupo`nK>PBMaKbfFhN?>jSLYk{L+%Tj78)yU&kI!c~=PGifD
z;03809$B|(k+kNeZ#D&_&zS_8ZS^)-TKsI(i|pt+v9W5w9vW6K9A{c_u{aBmrK@I5
z=&~Ro$(FmCtO}f`wagEr*~(4ABX2zl>sek;w-sZ%O5osrNF~$79|{|ob^B0Z#ZNU$
zm?s-6kYxlJqv{!vZ#-!UE(4o54F_HN5j~p-7acF?wwPOa_?#3g1sT&*L1qFCSfp>~
z@RH#C2^<xojam*)UnhXPPY2TOa0`&VAUmyCQaTC`AamKCT*IRD@q#kMa_SAy;f-3T
zvi9H>-r{t_I=j7hze&Yo4#kbwJv%6fZCgyo4n>f$YaKa+g@5=Ylv1>@GAkQlugzRE
z?3%lenlIsw#v?k<n@qpL2+J)pq<=4>eEO5waJuxMu(jRU;g9ClCQvk+;vifkw|&Ps
zVJMYTo2XLFHPcW+-O*7cY20Y0h*QPrGdglmpW+8?T;D)}6Y5+UY`Xz^wE%Oq--9JL
z-c1Hl1T>;90B3)Q_mppuLPnYDxW$?OLC)!+FU)&6ZXR+MED=(nCiUURf7!6IChYpb
zpEFFb;nPXtjdrKinRj&GXNNG4=@hBk?@6L9@W%D+mzrAnF;@VnpgyB+x?)hF1MuNl
zHk~41NA(FZ{^lU>>R#M+Po0|8)A2TF$e9`J>4v3>@8WVLTC(!;ZWJDG<Cul+N#DJz
z*;7^TWP3H_7%Z^)=Bcnm8ozi(8Kvz{0OC-4cP*{|)J5Nm9CM^9h{FflX`M?vItm%X
zta!ozyJ4c31`rXMOkPuP1mc+5_|GM6>~7+ZoM;?pl!E$zwNAUtf*b8Za?9@B2W(8_
zC=?$gvhd$Ub7h4XNzGEyeX&z1=VtX07dJ~Ij^Yi(1KTQn3y3B`exGUmp!xh1dgAEj
zm6b-j_D`#(hK%Oh3w&K!_Y+75Oha|>z<uC?7g_d15~wT>W%w|bKMZmeO4PkrhhQXn
zle)MIQPPhMIB0+3b}<o~yLt2Y6?EI@-1a{n30yKY9{uN`D?a2Oi2kPncu7m$(Vs$Z
zzVW9W(!nxQ(U-ejfPF|4G<ZG<rJ0(3C}o3kr<lO_q%NVz;`ys`HQVRa9r}VAb)SY4
z-y(dlMRA>1!Fb3J!({ldA1Z2?O(Z)kSKUlkBDOB*V%9i=Zv2Feb`<?sYrr6R4(kYj
z9t$1_h%Nyp%5uJR{=?TLD6xgN!BINKuDaTOjl`hb1e+Tt>JnP}HUXo8GiQp0OR|I+
zYkQHqe8{Td&%}gdBCn#U{P=hIvCN`)$nHb|HMN9K%d!aNF;U+5D;agFXU=`u7~n0}
zhxyx(Xc71x$7jGqP*t!RZbc2|t(XpWvB*aF-7p@#xH_+Eg^}e|lN%Tpq<xZ~qs(=^
z*B=^5|G%6gS$)@in6e&aY~bQ2N#-EFB)*EeSE}VYHwVTl!q_)0ek2f%DNnR?pl=A;
zvP8gb#KSOpC>}|;KO974hNah8BZ^EyrWHof?n{~zG2}NQWRIP}2fiY!7gkXXaTI|C
ziH6s{YR!Ifus><d9AzD=GWtGa7j?F)(fd^4Ds6QlW;rzT>N)e})T&IV$nGQT1Gp^r
zsHSuqTGeuom(_5}2F%UNRz?qP=!Cou`aFM+J{u`&kByyy1P;Ksf6tM|#@_7kYOhY%
z)^K=tkzbL)fVwq*Z|1I0QoT|evj;ny3g%#fO-5t|W=~NZrtvG{uin&xyzc7*IAL{{
zW^7}s=6*;!Is*F1<Va%(kKqFSNQsPC7*QF9<0o~ST9~B}5$@Nx6qZ{b@tg1&mZ)SJ
zElw(Q_sjkC&d&4H%~(C143DrM9i<!FmdZ_57kcZcr0ULA6r8KwCDff-Y5!`r<xV2h
zrfL{3sAaHp&B@lBT#ec%jw+}=in^0t&E$29@Fbmo9onLwG0nE|&C9u+7A)krnKl$_
z)pERHt9E!Hc=K4Y3T;RF7DHWt1Zjo$Hk1@2Si+ISn?e}LFD|)~V`hWb&gJ}eZ=y;2
z7EEdYPPPvsq7pl>&VHMS-;{;48mQA(&;KKBR7X8J9<o3GTe+oJqCsKx@d_$HxP^b9
z+s247SDi;jl8X-S{QLr8?A|GECZ~u`^ZOr-4zAg(5kZzsM)c>%5+|l}Qz_>_PDIE0
zN~`Lfs!LAy`ZQSP#C77I_Y5r-syR<BH*K|sUh6lUU2RpTkt67yuI^l)N5d+&{S|bu
zRS+x>(X@Jwe-V*HY_c8oY`b>LW`7T{8f^vD02(Jc8*JLn7FY)?>jNk%B28@~?j4=g
zN+z4Z?b+z{kBGdr!IyZ^PT)|Bj#2)A4$tPY-vtcicW@l$Q&X5OT6${!;H2xuoBSTs
ziFNY`c4mO?l<U)xj*1HYOH&~AeipmRG$wrpme?GTP``ZQy-Yt1FQwFc_5CRINY)s)
zDjT{(4ckg<q4|@=+O3_PJ@rqm4ej!#t&+4QJjea9y3BdoX^OuTM_SYphRYXXOoYpn
zhw<6u!VK>`Ei0Q)*=$$ry5D)<WZsF<X;2RK_T{V+E1Yg5``b>5jf?*^l^0SRxKWw-
zDvO|fo11)ue}teTO9lX|E@C-z9{YMk5)ngBt;Gq%KDx7<#Qc8&UO=J0g?1zR5I|vq
z$fXkEI{f&!RIfs*DE`X%^A|XARmZa{niF>QXdB&)1eVoh36?~?Po~}wK>use4OpRg
z2hxg+3hse$3~v%mCBzkZ5Ix4ls#lE6r3F5+FEf846q3j=wY2$73!G%OfG{Mwi!@QU
z^xWUS_SSx%LJ#T;w~?___tdoB+9gNwh(WIMYg@*a*#nixSL$GLC@J}BRjM5M3VODw
ze++pxEqs2tsls3})@*rfds$b#PfgbM_qJ^L+@>op!xc-o$)3;-tnUo0UUlW3!Wrt{
z2*O>TDN7AhYd9MhcDn*@(Z_z|W0TIRXRSd8Lc`G?+>&G%M@L2bo|QE+Mx{|pGmD-D
z7}$^fC&Iw!^7I;r0e2{E-upBW#-=b9Ai#`mA%xS@X7E_9JWC7#3S0vq;a)zalI`fV
z<<|G4$_C4b>ZWuPQPxz}RA2RmcO(Ns96j4Rz-47wR1TKnASKnv7o<Jtx_9EQ>PjFH
zL_M#!<%IP;+A?<;fi>xx04`APBUNt*p#NTYgVTa^2UJ8ZL_tcdt(Q_B{|47D-Zo6n
zGDff6?&mdh{^%nA`(pF{-*@}R@ISta(OZ4I6%ZkfHvbg9i&dhnJtU)6;D5@i7h_=A
zs@NyNz~x`#pHiw7B*~~0EU(Kyl@D?z5f`#&WV^7#;x~e3u>IQyNeGNg!yx=_#Kp8K
z(UKShkNw8bS{O{t`%}Y%!$kFDdXgBP9G=`T_Ilr;%mz4f6?+B}d`{Dn0a1mTtsLmc
z$-9ww1ppB*g#{8##INoobQj{f=g(izo#PN5Y}#S>Fo8|#CIJXg|A)q27r-6%pj)T~
zaE}%~CxE+D!rOqHS2-Z>$O+(9NCyMRh%dwkj1fh*5+;-6Q>ZzZOJG1r0;w;wkb7J=
zc8CVEvFe69Mn*n89DNOP4^H=5L$@X1Fv(?dnq)MNaNOQAk#_CZ>M4bq*>A0EFN?HS
zSzXl%8KGy@!DYqZQ3&*<X#s#|&=e(S?48l}UBgvXqqnbG&u}(Fz>|0F-k?w_WEx)Y
z@~PD-CfI-TX8Z$B0Mz14U-MXl-4X9DUp5ri=&hyD5mSV*G?@VCETf?+wh`pw$7MUQ
z5SGNgk2tA2)r70;NytQ#a4$^~?(<4Q4wHnGCJ9prhQ-889g`AtOiIu(iJiuz1RaC4
z2ax`5RWfX+H06-6@O^;RQl~TnD30V1=}9g6){e+}(#k?Z9=4nj_&yD6J0qaRP%c2E
zXMy%z$}GW5pD)IXF#>tEfqb0d97gyJx}HaGn7DT=65ssbhQT}2jL{95kK)OWPj{vO
z&jGxr&D)ah4qFQ}XaB(Hz?~;H?>&38r>lcd74{}y=>iOA^PzO-9aDhubkqRrjsxpH
z3K)MBtHs_#)-8|Kr|NgrlLp8U4IcQ_7K66}?xL%J)~$eMuRz=%FpZ0|ozZVZ3Har*
zS;!%4DTyFa5)VRutI(@R{wZj0ueaibBh&*F@hpY^jKV3(5qmk*$G^EzGp!*siZ>kt
zl2kSS-64@`{yHiWBFNU!Hm0<Xs(3;86zU@sdl~Rf4gaQqX>=MwOKKd7HwA~tgdoXB
zY=6AC&ibJ<2>czcN4{XlN5j@DCtcmsL+Q!h7|W<=k^r%*esp(w*EjbxHt&97;>L$J
zRz67{*x$0Q)khFS*xP^0XqCxkVl-C0+Ms1sR^HHhaPHvV@7><jdGnW78}2w>m7QvU
z*)VwZ1L7FShRxV#kz!)jL4t{hrCs9j_5y#mO9bC80oM+H#I?FSICu4DX}ylavq5F9
zzQ-2IRcAa|T?Qq<IOIRkbBT9E4w--(9nxIAGADp5t3x?Kx)!Cfc<P!}+R_kJT)3H!
zOX3<Waf||Cg)zCx?7>=(=0&+mA=7JLgaQ%|64Pxu9pu}$`7=BF{Oti)L~9KejZC3Z
z@QI<u&0^%Z{QE+JAx&bq7+?RH(K5A`HP~Sk2m;>F2rM;)-6HO+n<+0h1!9mjCY9@^
z;s1OvWHKeUz|5e+I$M*<-P7wR*$!BZ7&rBecDr(YJyngl&P;7KkkMuLmKHV0P=(s&
zTmtdM#D%!Hs0Ej~&xpNkLfzQ}*k7M3Cx9M18*@UTPubpu)ebW0M-@FZ{qZbqk$Av|
z6iIX=2oSJH>WawqFmP}TrJxmw>KaSyiYo4VVk-FFV#kz^9UHeTOO#nOB+hUi8+@;<
zFVh>|eD_%7pUtqSYH8~VcO2?$UA=6nqKbNsB!Tm+wZjb`>dlSg$5xe548thpN>=&T
zDlp`4`99eJOpiT*y^Z{R{P?aXpr2<CZP?JaW&$4VGVDr4RgfGg`aFHRz~c}$M>x{%
zx?@KUJ&}1lcW?Lf#G%}=%%`&3vuiS4*_28drK&a1O^pLG@N%Xal-wgZYYzf~6zN4o
z#KjfZgv1yTK}e!!aVv+k0mAb{=HAD10=(0)Lpfpby&5$rEi?{P!`r1*0=%JhBqxAd
zB9ut^L4-?OT;0VNITkMhU{RTD`q-HAeki=eE#gIbVPbw*aDAu))zh|1^$;p{02Q-_
zLJP0}DG`JeP<|&6_PTn)i~$zt2zyF^Ju|?b{wWX?C{FuS0eg92F$x2j9X%E8CMAdu
zO10eNiP-v@@$-w2LHIU}-!&@YNO290HW!hp5Tz~!^}LA8x}k=NYms>^N>{<&wF(LZ
z9fQXSBGi`YF)2<{&jK`V68EUi^z`^f0x<qov1SNA_e!7Mr^k|sDtT^g&q!u4m+JPL
zW4UCeEbGX!C>TqSf)V*#;v9rj0xcd(IC89&=LFa`HJB4%>trk^6x;Lj_(&D<SHV$#
zlb5~or>SS5;oZRSEia0p;>C~YuH!*)HrinVoRXC3JPtWD;3qcxrulP{4`>=>fSuUm
z$Onl;1Kcceab~T{)d7RR$(@xA;N|o{PsfzOs)H=uw5@MLcQ`lF)6kI{$h2fDGghfK
zoR9giEPN>;E*V0X=#f8WKo{FkA2tDYG7`=Spc_z12qhiysnRgNp!Qp$`v1h?UJ@2)
zTJ(aEF&Arp<djbu<$Lb$Uvq2LYyF6d|C5GxQB08hCQpO8^RTG;%zXB<6UQfE^qw9W
zX&o4Y8GPd5iCPrJTiMnL@R*K5t<vc}xOe(^=7HRi?#Z#~+`-I^+41Z^#$romgV}1}
znlrXOuDd5ED+F&Smw#C3zBX{Xj%SWMkP~3%2d8tw!tQObe-N$V9b`Q@K~{{`(oITY
z_2SU{*JYspwixXt@=Ju|p8NaO9P0PV^`bz^SM^r6-r5NO0lz+qC_!bz-xQXQQ~Xk4
z_&Nk65Ra9Lzcn61cJKjt8eqzRtrGV!p6J5P5;tK=%njnesv!?Vlc~PCVkk3^Ywqz>
z<m$Du`b;QmMU(&hOS)VEBNyVoe&_s!pF%{Khce9rIRRW>Uy&2E=|T%Q%g@_hiWWS+
zXm<;F9gbU|x0>KyNAk479CkUw7Nyb>cDll5h5jSF(6hbMToJG<X^H@@;A}xhS0lmL
ztkh2&A=pF6;Rsq43TyCE%}3c&%${<EQl;ZLkAsmjAU@l9(W0_<kVOw+C(%4zv7+)8
zXvdj~@d^RZs$Hj*72uI{!%%x@T_wtU9WBXQGFq9eV{dMvXI*A>uD83=lgxEw64`>W
zi+K+O)|Uz<FQ{-oMe|Y&xoJP>Dh>LY*qakzZ@sH?0_?9NnG=dVF35zSq3xyX_Q^-M
zhgu>hUh6a2I|@sw&n(DiXjbKS{IxmcE=-{^D@v8!z@?Rb;8Gc(R5N;O$llciTxz>+
zmwwoEQD2ipm+&}>%d!g~pY9UB-#ydW8EefvjbFr8VkRPl(O3XP=GcxHGe-!gxfpn?
z^v@B)X@_<F>XplKlRcT0x%HXl+15;XmJYD4EZd897glwP#b+@HqY(T~{6Y!inOv3=
zKsW1G=7eiI;^%uRRHjS)go0@asr3`&S#k(E3~Hdf&&vDEPy_uQKFuoS2BfrV>HJ*<
zw-RzjRb5wY{_EMcE-YnR*=~6D^1m&ieJYj|SwDW-l`^dZ%;86{Uy3WwcM-zu{Tntk
z?P!MiHWQ7SgQ#L|5}F=53w(SOQ^BljK45MFkBkz!H;4^qGe=djyL%6JyK{Sbc4W5Z
zR(ChYGP&VQd$ukc%y2~tRh-(XltiQEGcIuT!kjB^)(uNt?{Vh@*!k+MIRSP*oXH6b
zZXi;t;!IC{gtY#N)9KRFz9f||0-M|+H~4Jxa6mI3z=4g4aJcS#>Ry;m#T;H2Hfza3
z4#!tQIUYdKq||5t6nC+zrRDffRN*WL5dcVwbNP};6%j^$1H_CK*ftb1+-`rj66S*y
zRzJ)K#$+Pa-)+dHdi-MXW6j74NuZc-&le+rslPjA0M$;9|Npc0CE#&fWrFqU>Z7W=
zs;}z%zPr`k>eemG>XvLvt=pFE*hwte4t5fpwk<_=65<@>BFSW6u;avJ0t*?K3Ht$K
z%aLu7kRABez=Yr|VIUAlGU3}<63EvJEIT9|Y43Zlst?JMV_+?-OI2O<s_Os$_rL%C
ztI7^O-&PZ<m&nt9srXEN;jfsvSWdS8mEy3%ZT}t4&0FOf2L;XM&CMCFm&0&7vn!M7
z*^hOYTX!}iK)MGCJvT!@UO%|Acx`!fpgGu69w@etHbAsK`D$R56&MIygR-LfZXUQE
z0vL@ldTqIc#u?}-ml{U0EuCe54#5BNdByyDb@EX1<gxsflLsO!)*t}e|3A)-6$}ot
zR`V<R%h(?ID3(79!$@V}_XdMR>)yTm!1fjbaau{_$B}c$vU99ZY$<kkOR2JJaG2oB
zQjx{Z1%yP1t$bcyEg>GyBQzST=|b~6@c@oeZ3I`UTtZ_=e7S^2u_*|Yhe<At7+L`}
zjRxK-az4-<1@>KH&>h@A93JrSDvDy&jM|Lszb!riJg!C_YN&Yp9HmYhg}2&^QrKlt
z!INl>=!s{f!94{xm0rc<D}%q$Li|d#e#$F~mq|NS^)k5wqF%#>N9M*!y^Iz1EjY_Q
zNqiUcr`}%2II@$UiSF2;E9sFm>zHtS<UTaT61x352mFcNO=OeNj}%MAxw-81<*kF`
z#bUW*;6A55TFw^zqvp{EAp+)A)c}}WU7XF!T4sX>@lrK2q>Q}v`f>@4-2oRmJbE@-
zF3IDo&<#$PRJACXTwT1a=HSqOrZl?}j{iK=vu|lcFGSYBo`UCc(k-&<N7sAcq+H?#
z0LMdv$lxE;A^Om;Dzh7Z0qFxJE};>SZ;~;JKgaZ8hV;SG*ES;b@^f`^MPk`DJ@w$W
zxL&Uuh8N(&A6lJ;P)2QA<x%Qk>R*XoVw~6sB+Q{L#?&D4DGsW6_~8>xV05r0zj*OI
z<b=s9-bA>4^DO!*ubO~=7IcCUj7~Udp_yt?sgUnW#2%Zk7j*ECREx^#RJEjN<mD-}
zA~(-=bc^ji5ni@E5iW3W8y1>XROj$d_|0!yEW0|XU-T3czW!G`hp&CrH=!ir<#8-r
z`4!n^k!-nu+&flCg($_{01t{6lJI}B`hi6+JT5={lM-*SY<|0h2JfMMQ9{Fa_P<){
z9QIxNY6;##N!!cIL2=@@Y7PuYAXSMw5@n%!Bw3ZZB30e11NpbxJE~r8$qLmb&>E=)
z%Aq9TNHnUals)QUlW<Sam7DtLc*lpFMr&XDJL_g9)2%oC)9n5yu4@wgSzk7j3wuMY
zJMI~c4|;)UFjOjgr<w;d*1gweiy7<Yotu8)i`z8!-!ihd*GU};dPCbX<F{>Ya!bav
zCzvL+q<`(zYkFt4X2XT6Tm8MAEq428)7o8;@KpcU?OReBwZHP49XI$ohhkS>@9ikQ
zKi!=t)%H|8X6ak!ZtlfCXh<KQroKb0g_6&M*i)DDY((6I(Cdi-<k8f{+{9$(P_B2Q
zhYt3kE>)@F5x6-M9JRf}$Y_(j3x<{!konnp%p-85fv(}o6uNYwlo}4Aiwl}kaFnsV
zQ(_dP$i4zNLVcZH8h+olBz=;!)~5KSzU7Y6Q>E;OHn*GA6iKtlC^Yop^@ZL2zWDIq
zV6^IPjt_1aj90x$mpGim`=8j=#2GC*K{WHo=5Ml_9BcQE?u~bagt7ZhUN`sbeS?PZ
zn)rT=90aeayo+7X`3?8(=`qIFWzkyt1e7X2$IKErxgyp=z7-_u<r5Y6XG2{@rOqN;
zZ>=5<1psi!C(R-6G>0A29Qsa66i^{TPXe2Q&!vV#12y9>oIxO?lp&OZ7_m41nS?!s
zZN8dP?Q~ffHGY6;ce(M8`rH!h+a2rWHPNK1MlBA0a_E}Nn_e436|2@%l6c_aAHXIi
zLs$qu@w8l#F*p%C7^Ea6+IC5m5EI_MxvZLqTs`DDa+Yurmeq>?DPXriP@dI#3-C(R
z7;nKY4q+I+Qcfy9c_kh~E@Ns(C!HzDXF<??E7`nK3aJT+hlo=^76E#f!^YIKraOs#
zYtW(YSIMwYf#&W+ybJ!ybORN%uQg<{g7+4*$^%w2S(OJ_Ig|C0TQ}Sh5-UYPvaM3+
z9gsp>iD&TIz~|dRJPWb~BN)prUi=;gRaOao$fA%>9&d5zL-si`N(2aAfheyKFt31|
zS3u4qqIF2A6oG&(6R#BDnAnhOpr&$THTygy*NljL`nfl&u%B`kxW=<>%IQ~}2&<H&
zyrZt--oG3=V2fIb5!2{UjMxF)%1UXSbXQg+tGI&@wGf+Xbwv;2x}q!B5v|fAl&TSq
z2dX%(*AX4~%Me|ER{5!z??FDl5qL13okmnW6xaTZ;0i2JTz+L{5)52g=T)v!)ld)i
zmo+}+@kpprpC>2Rox~L=aq&sau8;<OZX>Gwv$6Nma=Y@dmz3pw4!j2$rU=;6Bf}va
zk=8fdJCN!eN{!kZsHL&+Uzbu>3`(X-At1!{aDOuA{0L%v3#F0aK0KPfv~;*CIVl;Q
zmt%#i@kWc1xu6gn^F5hGn$+f|_35rT?9D<tq13c4-F2wOF;R-E<Q7$<e>c>5_4;Np
zwP|E9wC$E5Z=H7ryO#0JOOMp&^Q~Ja9GSjYc74JGnd)eD{ef7|5sMh>f{b<ap)5tq
zF}q5oUld^P;ZQW1ydojlPF|q!+62Eprz}c%mC>e#6ZX(h6<tWGtF21ax`Yabob&R+
z#FZMZkxir@h>xY<Uwvt+0s6$)2P{oXfC+)P3$08jX8sKbMU+YW0*0e29|tibh#OG-
zrU(xrY7kL@1TOuvLN&`bSFC1<gey-*3$zVoGJQ+SWIju3QC+ul0x>oN(P>9rL51Pq
zA|RCr9~4KgfHhMqemPbBC#N!lg_1CgQkltG1kaVEGE;AK&wb_Qga3G-y=(5vb8y@7
z&(7X`6Ht`$JM;S{iu>04!2de%)sKzz-?eZv+z!L-9YgnC*VVf7-m&3(cXzc;-;1F4
zMCCa3LkK;T)iGbq>hQO(P^VbtgY|;NNDQ*b2^~1K1J}Qkb30bd=ok_wR?X<Rd_o7j
z@`DmORv^386FQDf$JX~1LJjn1wm6Nd_~_WC6pB6iXG;rC=opBuzkOZr)g2D-i(9^S
z-=G+14OV)qT$}zyRkZv_qBm|Cz5nFl4fpKnF+tg~^7os!_w2a?%kRgr{Enb|PUh?o
zyk0JerfE{kSCe5dJ5Hkb(FD;V6Jm=(pe+hNZ&3)hML|Fdjvuvzhq$##FD<4Kd>q4_
zD1KBNLxTUx@uSu7(du=MG>#K;42zvOd=y{1Bz&}<&UxiBz6Q;7uUS<K=gNKP=+4-{
zhQS2t$zWbdq^~SgAqy_VyMjVBj&!LM|DSRosT`hDlj6yzaqgHLBQw(mB7#D;f&wg|
zO1^?Z*8(D6V?*&fM8|{!QgyhXNe)K@i*Lv>N+?Si7JZU+d3`>KPt=y`XWEoiYFQ-X
zO8gKLCQCj|vKqD8>JC}#&28Pm<=imb*WKmT`9p4=rT}%F<S}S88nrn++VTFWOZnk_
z?dzigrPgXSdQ@X$)5S9R5`@VR5M{YBGm;;f7`c1o<OtJH-tu=!SxZc4eJIt)w5;qU
zE_VrDD|qD^m$<qmB3q@zB?<>coYDC#_#G~0twkavU%+A|+>OBT^887j<kPQrXx}kx
zH0(0W7$~`v<xf$)$zkbjnIY7QSSlqfr%>U*h7y(y(taV_k$$~o(7sb545Gnjp!Aed
z#`34QhUG9Ly<KG$wE~tX4)-sqVM)H!GJWrO^R^Aml9om_DwFxEIuq-2&S+ud)=h<I
zeDcU-sMsC1s3<6HYFSO7eJGPC#4WMH<kroFD9~>xK`OD@%^|PJA*!4{r!m+bj<m+S
zfn@JhJ#D*(ns}o{<ONAY)t)4~WC}LBqHQr>Aknjhkg>_^XATm_h~LVUGCIL)#9m?t
zgn1t^1KwN+#Z5;ZK(@th!7l9Y+uLUn1XJH$dh8xz>`2jDK0MI5W8c8YJChqHcTLVr
zQt8R`<hGU<BKwB7y*)7YfKav<A4axDjl60#rYeZY;M0YT{XaNwlr23*IUG@Z1C_Lp
z6J}eF6c2mLCHY2^BM>u_;-qg9Vg}!9U&{+6c(;LVZ<pZx>_WL@FKQmf)<=!9<}J-x
zNE&3BuQ7pa#moe9Ile5H#cxA?%PQtaW<N=*cyA0_i#<mKBdWo9yFJ|>kF9HV1l?*1
z6$l8l4L2hB@+6YlcvG)EX_TzZJMP;udB>K-&rwCss)1TDKpG?i#|c#vWMk$+b|79D
zcKJLjP)GOWX{&qph6u~rijn?<o0g<Y)QylRd;VACe)=m!H}Np$pK-zvOes7erSOWB
z!YfkBB9v12Y6?3ath!V=Saj>k)?&79vMyghjI%|_TDWi?rxC)T%O!ZOwP4kiOV*+)
z+h~GLI>Zb4C6(?jF)^=#HFCdN^u^QGfjtHHT{6z@tg2jZA&(n`cE_MK<T9%n4YSnT
zE5rIShFT0G`j5<Q#2(@}mXRj=`f__((97G$U6CA-3&0=U_VGQ%>1nnlGG5+Z>_FZV
zZE>t=)K!$q?4Tm_AUi%XuS3Y3SFHCJlxR$BwilEkwvU%f+l%rjx{^E$E0s&^U{wM_
z=6W;|;%Q3_?aFezitp_5DL+*pQ{BPh{-MA+6gQ9EEXihUMSnr|t$e4tTvd_{U|k&t
z)VX?CJvN&gxmAMj8=WkE!>UL^b-o~0s9!M|G6KFx5QK^hlm7)Z;KIjWgB0B-dy7wJ
z`b4C?Cq15|fVd=2wI%zCVzRuZt!PF9Q+P}xC)`|sybok>m=H3PVvOkEscp$}X-%Q6
z7&c=e37?OJBpjWEV?-LO{$Dwizvz*wiFB3B6++VK_|u6$A6^O-zfAuaE*<}*z(o(?
zaymJ_9miDZ`gJb&L$oEg5aY$Z;+i$SVsnu!Zr3NvZABxRsNu044HF#E^7$#*9d#bL
z4r}>r3h3<eFho%-k{nfR+pb4|gkUr(U{vi`GW`)rizs7eCI6FjNzTkl5Um%nGpxiX
z=$F+7*%O%eRQehKPEsnt6I&VN;9sh~C!E!0)W6j}So17i>-LL!tpfE1WEji_oldtJ
zIsmAaBCcFqnct{(L4NZI;w6l!>kh3$n3}#Pij4pLhx<hbLRlnoZ)8({TSSr~ZT*`V
z;>PJC2aX)LQCog!@SftK;<~6~x_l$bTBc8Lhgun+&-9Gda&%<;<z%Zg#2n&C^7`K3
zQmkUqfd_s_TQ1dxzHz!-y0N%@5TkPYSPvTiY)QF+oTHkQU5a_77~_>>`K&y3u6RN<
zpugsQRPCY}4Xd(XKcH8r<p~-6vS+cW0h=m=Ke_^Ss73z=(gyee@<@jJ0=f^*G+JfS
zUg2DBBp%FGvD;DMi0o#}5f@~R$dFZz$o9dRzfZO!pZ4}nU`Dtvw@<%sYHFXJa*m@Y
zkp3*PbDj=6H=}jOx@W97+FQ&PlSyA^b0^t3K{(6dB8^ypMG+Mh29TH6dc-*~4PoLz
zlrz5v59KM<$09n#PRI^A!xKc<SuTZ(78-K_OH~rA^MG1Z!Jm))D`3cAZzGBg-c>km
z9mV82w-rZ_pvst;2C}I$6)L?-l)&YXxH?B~3^RauJdScwsjt;6hTeQD;G#$?iz2No
ziYk{!u`wYkVk0j2{aIPR^(vB_SCQo4_C2f-qd$-+=dG&9UPbTo;>dVYYADJv_My-s
zVCspfjg6^lYMN|W&?pz^L)frTPe)x=9kZ5=x~xi6dq+Jl_0uY&+hTPa*s;g4X|U?R
zw`PjXy+<~v%w81lp{ZF6Z{0fHbHl^ek%6jO{Qm!)*tsseeJgpm(W?@;_y_6;gklrW
zDV0DkzE`j!1G^X3Jr8?<NB+YDBn284WoxdR-SO5~>$P$5*M$z$sKWpv1`riNi~)fd
zJg_zZLIL1Mf9Cxl<Oe={)CWR75EZ~Je&9!`lp2Gj==VW=*^lbUYoL(rM>())58=y?
z#^+H>vDlEGa}05#)e=4!_C#_DTNab@e^g~&=_H9NuP2>n2tN=Rd?OCts5XXN>n91P
zo5Gw`wYE?VmY!-=BM(U(0VG9MF5vo4o|s)vS6-qS)St-e4w^J{g{J;UYE6Ep)niam
zpQSZgUiGK{it0VlYQ2`)#v3&hq<a#6Xx?}5Jo$4}!-!OK2rq3H|G?Z2@v;GAWxNbt
z{CZ(61VSeYg@|{84zvxYLBtOtJ`nMOhzCU6AnF1!8pJ8ky#}o525VBFrwNEY3m6j>
zCnVYyw2=Ho9~?mxl*4FS;E_299TxhA@OcRAd2vEKDBdm7V!<dC#g?J)Q1>UBKok0|
z30XEolT^H+>DDH413YRS#q#415zME~=kpgJ%w^2f3;)Zd|K)!eB?WiikRW<RbSs*d
z?^D1x+Smjrd=n$QNu;U0i6kMZ((-K}#(s#B`jb1+ouK?VJtbS|*c$4pwW;JnUMpa+
z;ZNp%nyI`?>8vr2H(}?g=SlJ;rE|nR-YDFw{2uZ)D4)6lQ1E<}B)?5+jBw6*jcW2o
zBzT3?nEVc#8(~^y7V3B=Kd#ZdKUc@PU{+~3h;)?>B3+|_NJqgrsCS&Lx<{(DkOJax
zW{yA#$PizUDIg1>U_jaOh_j^;Pg|1)HaHi~qDoLUU{$!6R6QgC4Vozl<hw)H^bnvk
z2--Qo`H*`A;hE#I&GDfiXK)W0YAz7DQ$wcKr2$PGdG4T|dyS_rDF;?9W=XAB46LCP
z*gCZ->h%OI9R1@T(VQjVa)%8-18kLd)xZ?>xr1gcec^kw*5Gxz!$wk5`F)e##4{AC
zo3*#{Br4g*@FqPt2cFiObTq|kRh4-#!J@uuoLQ($BfeHSPTc{a7n1uCe3fuQNVFlI
z<OFdiuwi$i4Mg<qdNQg34rHe5b^v=P0;?T(hwNI@kamQgAVw579_rzcl-UVlE2s=m
z<4KBh4uQf?$&lzUp%#RZ)>_Ft6E?d@W)<0T8=K8Jd<K%eLnBg^e^HAek0)T(FaS{R
zv4()p6*91uGopdv&3e#98@1F9i%ri^YC-pYnta8?F=$OhUW@hQH^~CyBvM2-@wZr_
zQCYed!Bq<cii2DPR~Otu_%WZ)X*udkgXVN0O{UXY=VP(ijz_hJs5!+tj&l6V23(!B
zF)$|V3qMwZ7pE;pOGH{s|2j?a6uds>e5@3k)pk5u!eb~_a;1(}y^eZd)f!%P(^F#!
zFS6kD_#NS??xvA;Z)~KrZi~*_5()RDJZha$zh=+c^;2Drk4?tbM2xwnrhJI}pFGd$
zn!|CaDW6DhNJ&9w!lg4>3_+L4?6JAq$1)$~C7%?HhN2KwB?zm}uqGlxbPzi*thC<d
z=fF1PFav*6Fc2oMR^N0gFl*nhpKF<C4prSVU0q7iS_~9)R-oxrNj{HhnJ>XJtIn9N
zWr^m?S9X~iREm$#BD-S9&!9>lu3S20a|T37&#<DyY<7rD?&_ApHJy%6=)Ad5cpwuS
zj0baGk$QJvc4Ja21#LaN4h0TTE(X=>gddd`QsK<Tee1*P+kEl%=hG=~>pD0e5S7>%
zJJC!`DqR}Fi|~yFt>uI}@F`)IdZH=zY1N^|4#T)5LqT#|PL$k2;8P`GwuyS8)TD}i
zx}-X^q!|P5OHspUgV~ss(Td-gw2`zbaLt;J{Y`S@#$IzW7O`?Hg(j~`8_W9#M@NQ}
zeGyKjg8FBx&ZyJc{EvTpVs0eFat4D|Z`5;Uqn7qtckSMFtvjeOpp2;^e5>181Dxe;
za;^B&8hhJwU^^7_Q{dr(Xz=d0YpB>MX*TyH-$3hKa^21<Hql8^>{Lmb<#SJ#_(p<O
z+&=7;7Y%_#e7oImkOVffyQlx!E{CsgXFfX_QwbQO>_f4^SP1G~yeAh44W-HdkTKYo
z$z~=#+%qsYk&Hw@no-jfTrrr+=5*TEx-J+RX!9rA(0m_+?|cBx_b`zr?!a-+X{a+i
zxZpGxoRLMatzadbrsI0OCVkY0N^;oZ$9%Jz$83kH9Uf+D?a^xi&IPaDbi4$wq0?}h
z)4)l=>wNKJCEu(~^H|AtXh{d)#y$zP`W=#G2@%w*caR4hrpi%cygwVs=loi&S|3Pe
zJA98l79GB6{Qy)G9;7#{54MI(BuzN%(X|PQ6L^!uW!Li>=GbEcv*U@_z;wG|V8j}0
z^&r_OM7{`~WnDx&aTT`G8jXZrS_In*hD0Qwe!TfW;DmG{anLoVKZv#avK-d^o7{Oh
z9N65fe!SFtAQ3oGN=WcmJ`=0yjSlCU<xpBF%b~p<=?k7EX_jJ>R-_9Z=Jh)6R#xvc
zTOhK>Imn;Jt=Zw6HEYo@B=c{2qn6b1&V;+u=5pIAd5C%%;U9d%=62cIJ0{y4YK>ZF
zCMY5S-X-_KIom^w64w$xm;D`^z<MG^7{Mfwgu>zGbJ-;P2|L#=g3YH@#28{`PGSqV
zst^m)$GZ;3HXScmHd;ta@u-kiQSETi=Xqb@X#1>h8`yTV-~&EX`cBOieYX(#<WzZ9
zrV*&RmS34FcPYi&e()Nq(Ipq{`Wdc~S;%(L$4l@AmQBY?ghhn6;Q8Xw628lu_%7{*
zqa}17NK!taqZ)2x!(z5l3kKdQDSm4z*;UJ`zkGyi`y~Oc@K<$dfGf)?d*oi7X2huX
z_g>ZJ?KEn25#OWf(N<S*=-^24`aVxn)a460BzvHDTZ=1WIm>a+cXv4BPF;7aE9umw
z+cFOZZ6oWG-9dr=sa-N9ZRujpq2sky(P$%C(h}(m#MZUCrAV7E*5}b>9KkhKsVkW&
zwm4bF_SxnRgF9+&ZWZ03%07>Wq@7VI=o4%{+zW(!k-Q78ND5z`j~NjLT?7ZoSs+}7
zm{mWYoDJ-^&M|Y<u*t5*0_yOLq<+3sJEs~e*|o%7ji7V6SV{6OmFP5^;DXc987#&b
zdG%qdt5Euy=I%{7iTsZmwRRQ<GpWjB)&0ixClL$vZtjAdYB!vxB=bicCs~lGR{}qQ
zFGs*vL}|i~1-m$d-|LNfO?wo+=r~)l7w}i`bsR4tx-ebx>>UjOjQ`094omfkEe?Uv
z1)9_TK)Tsqe`eCgs#%hRALkMtPdwrEDDdA6;onMJjh?WNBeLKT)ByuNqC^D287Nn2
z!6NE|fg<~6T>A}GOelzuJ7M5Txs7Ku#QxQU0cr&Vbkt-2R3=FxcdLvpNpcx9%=edL
zVS&~f9XLEgqyNH-oVo!Wsmi~tfQrDYtd^zF8>`L6Q<Zm&g8atBZ{Zs^L~L$b(2D!<
zTU8@A_segvBHVww{JHASQNOoB+te@NN;N<nz_i^Sgv-<EbdLe8&@N&Cu2p8Oe!g$k
zH{Uhe(;m;w#OJIH&{g8*GC%8r{}F(#eUQ@oX1jdzrKJ}vi;TMr-7nuq#3P4gNwr+H
zU&0qNp%-jz^R0`qg2QBS3aVUNpuaXT?7^TlH=P~YYIC+^GPdsVta<gxv3#Gj@$g@N
zOS&WDirBf(+R09Z5|2P=H7R`*LWVjg&=W5GspxFT>YJ$oNRCuPd;o(+AJv~KHJs59
zmv$Lw)ZZTQfFlT@CitrDox#Ca6$tjA-=5pmvSu>7Wd0AKS2}*lE8&-cbAJPrQl5fu
zV}f#u(izJP9!5Papj@WW+8-BYgP)S+>xRx)g8gwQW-`G~RR!t~4*zN=pNdc1T%4F0
z3PeW_j}IRh3V&P(uT3Y`#>{9tzLk1+-OOYvI=X*w-N8*w@sa&QvB5Tvt97s`G0^Is
zMo(J;?~$K@PmA<|>tw5NvlfBhg7pG3VL?iPwmIXa8Rv|6xTYGQxS(>QY9PsaLH*Q5
z?EszK_(sb^wQ9JyR6EE|uXQvfV%91FGI~i2I9hi1)U|_RDmD-cwIJ<aaCRc8F}cl^
z_ZigbfQ6Dr8BI@!qHJ?!;wG#eBwL?PrIB_3<!Jc+w=3_DyI!1ja~-lAodFLOOeU@)
z>ZbL<nZzmEZ0nQyL(E}Wl+NS8wVEg`RnM~}PL*u4`qn2)_*_|<&MysAt0p%t3!;)N
zs^#Le%xK^g+}>8Wy3^tB+tq7NHKkpwAQ}92S)lgoIjAWjfm*1(Gf+cSNRg?rt|Wut
z%S$C{JoCWISc4wG^-u#2LO_Bv@6eu)&ISaFXT~yDkAM2jdAVAtE~-6Ws(*h4QBU%8
zlN%F)m!Ueus5!x65TN`aHF6ePA`&#|{gMjG@837r^eTpBI9tqJ`Qp;~Ht3C6)wG(`
zqk8cD<TpVXzC~WHWA{~}3v4;#Yw|Vm_C>I@;3oLQ(KoZd&XU>oWA-j4JgYtWb;I`z
zq(M5y9BS-JF}1WUMIoF`94*PM`@-$VO88oX_9zZGg51);NXHZkmka#i<`h#a#}~D?
zwbpj&C3+%+NI8_hy3MyH?d4gDQPEm=tUa9SP4o`s<G!v<IZsQ}!7=a~hLu7YZw?CU
z!}$btYqCFO;{<`XT689!5sgA1>hfEyu|iw4Cn;%oofdv$;2E8$i#t3)n-s=<3xg0|
zCz+>+oUBDWLj=81gmuv*aNdK_6L#)|>0t5+mCU0q;1u8Uzxn15u~uyH9yCQyl<cO0
zi91m;9aJTsP?TaExKXW9f)%3W`oa>O0;$L77&yslC68a&wPl>+IDU*(w8cl@9`}eZ
z;fSy_%aD{P**G;z@0bP=q%Yjbs2Q4uA9rGH;(upz0?ipQO@EWTi!nnTQSOhY3Ch#i
zjaCywP(#IMtTVn-HKn*#npbX-pq#+_PBo~*HF0LCHr(K}ke2u?$h+)8qgBT=?`>JL
zDJ!v1!Zh1Owxi2mj8~VMn);i=O9vQb<;lxd{&jFDlLDpcK71!H`CX_FnTe><+rsFF
zqT)jfCcoMbC5vkcoXY3->l`z>Ibud$B7r^QupvFS*4v`?y}UpwB`u)vRkadBU4E&N
znDm;Rf|{bArL^XN%N4X}spl9*Bf89z%g9p4Na`U{Ejk%9l(Tq2SJA6cHm;gega5-D
zcs0ZsdYhdl6L?CcW-0g{P2_i}{|?_{9dR4ZyYTt5QYK?g!Ivp;ezS3nS*=>T)|^MS
zJA=yHK9gB%rkt@E=Uny8<knxcHW#?HMYYdGwQH)d{JO>-V9Q@Ry88P!{7KyfNm518
zU!c?`zr*RbXvhPA+)HW9XwR&r{(+`c28Y?|GN{OpkmM~uCE6_(yPl;!N|HANwLu0G
zC+Hi%w3p{APu78^7r7eHcpf|@6M&knOmWH{n!Pb7Ep3G`%n)<3bP)gxgpCNn)moFb
z!5_lP@r&SZ7bGsjX&1pcs7?8TTzn?TG42^dO^Cu^{AL4@)U;eI(KnvoVC)8xvVcdG
zezUC|rf5U~n^h6%RVs2L14N(0<}s<s+wP<^P_lRUMD{D6XMx~z*xd#-b!d)K3r>r}
zE0FAG$#*ooiYDQ7e(^=f=5UxV;45k!Jjkk;=l>gxtU@ZC=8tGLfOpC3Aq4!g<qOI2
zXP;54wbn)O@EO14(@5q;@JNBzO0F4;MwrpuOx>agj!Rp<$Xs6AaF(rR%2pc0b#zd5
zOMXLFk8vuQu(}06kG-Y>dXK{f^%nX#`7x3;xNSC%02orxakN^eohK#1%+sWb=PHLu
z@NtzEPASeLBI%2u&f$DIj^K${wIAZ_0;{1=)xI|_$V$nAhAQAHe2zCR)UC^M`Wo0&
zO;@X&q%SDhX_a|2Htho=%mYiuz7>zXXW7_$RvCMwsjD-Q?CMNb&M@JQWW1vjj(wgW
zf%f9>z-!Dj6cXb^7{|gfVdt2L3h=y+idmgy!UepKl-So_Y7~8_NG%I*sc;LPhx(tz
z;xeiXKy3-SoI#6Pud&Cx-ndPpvBkaKm|X)7SL4H}XL%#fu#nOGvCE%ya-1{i_owU}
zXHOx>mM@mUNqQ%K!cKXfNaP;EM_9<Nvz(ZK&--BlKCF1YDubUz2MbQr!N`G*FHv7x
zS9|EkRFH-xr^o^WYYMrX0h3CjkwR`)#H!I)BQAGH(ttKp!<vF0<V9Z8G7Km1fAYDb
zHjcAJ-R_uOtF^}<T_-AUfH~q#!b!L>m*=c5Li_>Bo_>Zaz`r4%b6ilI=PIRDX@{xy
zD05I6GCa)aOm>sOss;1|oGs+AhpgP+d0W#d`%8%Mkh=|-KI-%#9o7f$dE(-`-~hZQ
zN5tiRRP5r#ub)LN?={pYk%v^0{04deO@TsAFXjFXL~<b0+mlAW`v)`W4e%H7s10C&
zOp|K~$a&;?>ME{G6S%`JqB)u?mrw_knk`ix4L6ZY8x56dBm4*cL9K(5?C+x<ZzSSj
z4UUT!p>DMvj(dSrQ8&XC{gd!c4^*B8zhxdFf<#Wvo2QU_kV4_;l!)4~Qx-4x0Fg(5
zP1p(RJdO5kc^rqtLQ&gjt+n$>Q#gxUW@6x1JEwMD%K*LGZgiM<s(rH4<?Whm0dN77
ztS*scu6v<!^(#NBT=ODt;26l<nd@Kv@$0j*uf6*H8)%lLSgnX)aXWm%x8M`{iFNWU
zG|DjqMkTryZO@=5HKH~j$bCsTwDJ=tbIK#51Ii;K+*iGf?Z&oNvc`QSBY4Zzxv8Dv
zO%9{Otpm)C>FH^j6kS$}%b+H2I854SU;pvT*E4FCWH<x=9q{yzUI9<Ppb@q3X<7P0
zWdc6${TBuBEqVb$v{|-XiQsbtOE};s<X0qh8UmC+fnvXT<!89Z-8|g4Wg6jWUJ;((
z7#$uRqIDjd(Qe|Xrv8*<OZO+Bn&7ZNPD<0C_<ZGyC+90)`bVun%OI}5<;y3Z*)g?n
z>PuUoOiVFaRAb|I_;k<Wr_0IE^nyE2TLj`c(nuHy2JQ$BEq*-saH9Nt@PIAz0l@Q6
z;8|-^e-p_WA-X*}Ko1WUM`=oMTj9#DCKLT>8~E9dXHI?@J`4mOe8w+;tL9IF?Vs1^
zwG0I{nk`>CwE$`Kfr~Vx$hS$Bx{H{C`?tgWxA6Ym#1wpkN2u#T7t{<bgcHwlMjV9m
z49zj7AP!dNSe;*1b$<|02{xnAu2)&L7QfX7We`Aptd=hGKX59nM((Q#??L`OzDJEe
zJ0pYWM)?al%%7bFypQ<vh1|;bTY5yYkoU2o)o8Q{tW|494`9}S%7aUeHAj{|5&El=
zU3yH!Yv0a`Wx9=SS=#$^0QdeJz`Z}E)4~oY-AeP!&P#iLN(&`n2TGWePM6^KSKRxv
zt>?&dcinsLmJYPNXYrPf)1lGZHjm9s#6qLDZXP={5hG3ezx}CeCLjIw;S$;&`}W=2
zPRtZ~ZaTJY+vBrv`zX%EAaL)`UZNyZVF&opnOH8C<DHA-;Aw*QEdt`1?rx@i5v)1g
zbd9tK?DNd-hEC&+-4DCb*=I`d^d@xvLaFH*23-N)Z1<%d$1lxlsQH!aO(Ri%Kv`;`
z_HDTHD>rmqzp2fvWl&l|xPR|({-*!O-j{&4Rh)~?IokK#I+iT!cwZt*-tE|qZN-+i
zc#G}W*%MioZ6&fKBss<u0%7R_w9r>VTT0)9_T9G70!>0nC`&KJg;EMFEw829Yq|7t
zdwZdjZs`_t|Cw`+Bs)$Be7*18-YfsfIWu$qnfbT*XXc!l(MVO{w#z4-p0Z+79^-V-
z`3kK{Vm7U|74#KHKNYGwefZPSW}SsGmlf!9^$I4>%65nPJNC8bizH%O39V;Yxhc<7
zT)ui-ENb+>A8WMlt=C0Quh*!LXw*kEYUMO)-B6=eL8I1pq*2k+HR1b?9=m6zqI%)J
zqu1OMtoS0cCA58D-s@o6$UUDnhIx%HJcTv-^`kpK8trH~^pTzX9W)vQjowZ)dc|6e
z;$OGyJB_p^6Vvzz)rwrG1(a1-C~@s((ptqz)#F73Yc%^HWFjg(87^!A9X}K%`S5RA
zrj<*6OaO9T=ui#rh1dnvdwb6{C&F#vi3UBMB+FGYWo2)uuPe6QUAFzo$t^oeiF&ul
zbxMiZxauhCua15uy7}b%-O(0fE~C*HYzCv<AkWRub#9#>Xg|>5RIgR9gl_QP2-=+k
z?f!VZcAJQHn}~L`+;8=2H~g($t?*mD+IRF@y`mp)j^7(y_;k3TC3bHN-|sK)oo?w4
zb`_TOPPgJa%^Z9F)<N&}&)$6O`CA4%um9$4$xj|EZ#i`PUbt7Z9=aX0>woJF5d+%Y
z%AMDW-w=H!rQH@zyUk}PeW%*h{?9Bcam_G);<&hoVo3&lm~H>(Fv%ie{v@!Lq0^0j
zr?m9^CJXTb{$O<x<4fEzSv}cRrICusgiu+wd9-fp!A|GR@3oZ|IrY#f*{Ij>1|qRS
ztysNGW3@Sqdv6UiP?J+P?DeP&W~IttGwH2bnIXr(Hjh*t+%1xb7$@~`o?WiDnP5nx
zSbdEWQPif97-)C&tzU^o#I>ZyXcxxIji6nYwsb1g_OpiBl0U9fY^T~_KN~j8N=p8?
zflkF2)agj&-rElOA`@Fm4HbKCJ3Rm4-4*xQ8n-ugjCzdrhV4xq+ua7*_?~avI#STF
zfB7SmS3Yy=$iPkCxG`~8z}+4`J_YxxE#c#!*E!H@Ri<8BL9dndmE<>Rn>oF<5WTwF
zUxBvgo?(9fc6xQUaC$9le<e(^NSNPWvR*gx#YC}uYprTsxWnIepr=xW7kl6{>I>WU
zcw6>uEzaLM+vlvQD8i~`@Q-{b$cZDXdu`q2`)@r^O-)SRu*ah{n-yw<&8*AO$jpp6
zw|;xGr>8nsEEeUk)EQ7MDBWN;Dpr3*)0;+PseV>cfXt{I4RD&Z&>qmNllGiMO4}Jq
zc~XbZlUJUQO!E3&d70~(boeQ>+;Ith4lQ@`f-To_eplOZ^s%e1Jbk2j%h5-#z6$Oq
zD@T$8J1-w7s2ELbo4R~k0e$TF@4j$g@}9GIf9&i72PW@5dzbpwZyakK`oLqC@po?D
zqv()C3pzd`wB41Ij%!nG*VU<TxBnI^Y&*DD70=5>)J*cILCwD<YTk~$vMR;myVA5Y
z-GWK4+i_^bqs2p4=y#RnUBTXq^t%QpTf*R;m-;kxy_@w`t4eLkGehSqx8^a0U55tR
z_iu5EN$0C8U=>E<oo}aUifWjCztH=Fo=s>Ir6O~o+;ztvlnBQkRN-Z%B|3WOU=@{d
zumL_L#Ee&vn_0ZZnZcn)=ql_4xD9_SKV@P0-RLa8j2!O2z;ni8yrzP#>QpFMRE;{3
z2p<^GsldN`q#RMwh^%ndk%LEQe5eZEDGUK6QdYU_oE?^A*dbnvxfvfRhL>RKU*4B_
zGQ}pcCNX`6f?Y7wlD9Kduv2k{or*<IdltTU?26CMZmJG{@tXI*{fk=rrnaH#9f!8$
z<a>jC%{#V~GYa~~<9|5epStJlUALVj_b>SGII^QDcl72*!ykV3nwH|O{qY+R8A-e@
zx*hDb9sQMPK~vU5l{J#%Cqz^yp5kG_cT!FKF3Kjn<X#2yzoswK22>70DTmZ@d<;*y
zcBD31dv&d-)`7L;z*=&US*-(W$nj;m4k0Lom*#15a*yc@K8ymNSp_2&V&krs-?8{t
zO(m{%O=BO|Ha1cE@9`VkSN6U5A_-#gk|nVFQll7GrvZjBzr(+0suGdX&TBGcd-dD3
znztXzH0s{TScbZ5{!`HwLoTBQ&uBE@!HmPkcF&~-GwJ5S4`yIi)<>_<Ka~6nEfY&%
zR{II^ZefL<ko*u*lzhrTdVmT@V~}FxQ+7hiUXo(MDWug^&_ARH$*3sxwf7YH+Itdz
z?R`?WT=b;m%JaVVJ{i_6ONyQh!y~~^OWtNIME|gC?5fEf?-?yE-;VDiWgoG5x?Q!t
zN|U|1dsA)qCgY>fv2JddJAPpI@k1?*bH{_@(Jn_>-@F&@d8K{x<lPKVJVAGWeeM-T
zy2pgE5cNW*4rvP?$1|7jS1mD5@RXl7XX!Mx6h4k;ELDx)4_7Tom?u)4tevY|lK%N`
zzw|`ac%rAs+fb^84h^rRkmXi%c*?wP#=NPwuC(4})R}Uqgj6XLYc;DsGP#+ad0$~o
z=X6(*Tx(D&wHBSmq><^2T3umdIa}@2%8fbHkku^LTD1=LL7H;5?!YoQxcUGUp#P8X
z76HHGI7;4eT!Y_nP@g|#ajLFI9V_XV94B!C)3L(68OAHKgcsp!UveC5ZE0&3Q!2)y
zv*;9bQA3fzSX^H~$u(AkF;^|3A3E~qYp?suGTy90gEwzKdhELH?(2_T-9bx4*ye${
zoj~1QLS4P^j^ikK$3fjk-f>)WN@r7Y<l&bb#HLQ-6pp@<^jnVlrp87XY-YaY*lR3m
zC=@AlIocdXC2HNgxs|5XjLDFrl~RQb#ip-zUw7<iJ5WaBy);++>H2H`d<1VuqD2zA
z<LYDAgUvU;^(GypZ%^BNr_qe^mHJ#N_W|A2&LXPl0m-#sH<!Ub%JamFPw+PXKv;LR
zr09V#JiOHLKOHRWIo#JjztvgLeYk(*aHs8NeL-VMQGJ2l1bmd&IW<)8(9vDB?y0Lr
z`>)(x-?-<B{^qF`M_%)IbN8MGOMdG(NVFCxHqq}x&D>t#hfxi6_32_)u?yzw)TvGe
zsh#yy{b%#@C3+Ys++T5(Gl$B#H^l@t|I60de}4UE!+>Amxj$TSl_clh6jv9WtCy}Z
z|C}|}Z>rc9>a6s-^Au7_B9$tvr7cy?`qG@fe)ndpL1!{k6Do~bz4|AUN8h&3Tlhl#
zc#Bh^(I~A9SiMxOQ)}#%j@o*;&P>55ka0NdH&Ik>bszS3&GhATP~rg3WrjiF`yizj
zQcMys6>%<3L3%Wcc8m9jhmj2FkQF&WyB^epI#4efK~v}ennO{vgs!FriOwUV^Wlkb
z^W|5zU0EJWx{~a{nc^9F-=KOBb#{xp_0{#}`tX&>nZfS*`tHG*<dtDr-p;*D-a!1w
z@R6-o9PK$;dnnQvvF+ZUzu!1EnKMbZv`gESm2R#3$kE9D$#%E9eR6-~=n+}z>~vu%
z@;v8x&cJU?<#)_q{6gUz#&?nfE4KOF(brju7?16pl1N%WQDH-UU2PeEH}Q8Xe;1z1
z*2UM~*FTr#tc{nfD_^Kj^kQ{=ef4ela<;CfuBI4=R-0<!@4mX4nmT$6U(eZa0)1Ty
z_uT!}^|iIdR84(-4fQmBxVjf#&tmM`a7c7JT&f|q`u)1Pnx8_1`X~e@acS>?3-ws7
zr{P>5gpOBN*V8PIv?_zZFL1UW)K}NLApo|TM?XiuDEU`fDnCVbvhJq8Mt@22YgEVY
z?MF;0UemAFjMN;c`Du;FUSqGRC|EI`q2GI|Vnxm^WZ;f6p*-xpWpHH8&L-GqW@ct)
zW@<CrWoBk(W@ct?GrP^q%<ML`*==TAznA8IvlF{}XCvm<S5ZHdO6f^SnI}%E&Piph
z)5NQ6JGR->X9bc4r?pX^6y|<js(MxM!CN5sE+Mk7mFnS~#4J$!p%&yXHYXrk6b(fQ
zKd3|76uhFEU8{%1rOOW2)vT(;0R=q+<u&qk-Xc1%`uw6X<-%nxRO)8)K$jmTYLx}H
zha?cC0!Y8K0mXEzjnAGLxpXHyzdKI4pks7PRgQL2--uqoUS!8+gwPR)h`N&oXAsxC
zA&n1G-f-8R?-7vUJ~C_AY2q~+3g<8fX(q8=LQ%lKwk}+*s^1-j%PeA#NnzS!UP}Rb
z4Y|3OtGs3aU-k3H&1>iDUJkW9W5hqzd^Ie(r^Kf)lM`pSvIQon>``mFL2p^<-isH`
z30Vasm_+m9Zg{<u_(`701_|V^f0JF;UR~Qo_(pCQOnfE`3PAFH1P<mAUT@v4h`El{
z5`K`zebV|QkN&m_&xV(fkD^cO1maV};}-1x-gW~$HCym2oH`+~{X{yXhPTYP1orMT
zU-jqSAo#7UZ{PJ9Lw9W4>aaBBw{lp};5lwIHM271pUAGr%JnBb8JeD*H83m=QR3sp
z^NaXE@p-fmpP9%$jcuMy%{EQTh86f0RvWrj9#e&?Y)_$4Yk#IFE*&mCJ}<m3Ha32<
zSinLjxZ7=<w~SX5=r5#ldFSbL6{a(xaiAVoZv)mI>qY2h1U>-9$`RVsE15#z%7j5C
z#6e}@I(LFu7C=}}t!(88MeLSGCwrND*l;p8+biWl*g82i)9ufqS+Yt2II$^ur)k_t
zP_Q99q&qGRkkR?-)}cr|X}e8>nVMH=-1bymW&W_qtpo{sY9de~6c_twqoU^0zgI%)
zoi(XngQ{&_Z<@qIMk^Z1Ri_&)C9LwAo2GR)S2VR7T-=Jf`gE$4#+??`QrfyI>iaa+
zvebEJm58~UJyy`mbQo4nonUpqGh}L&Tb4J*Z)_|@ECyPJU*?8++op?E4%0iDkyDBa
z7S&ECL(F182zi)BZKFpoEDYt92|HdRx_om+=fP)s=$|o;NwiwolAv*#Qj<&*&^fRb
zg;!IeaFz!AbDqOBe)i|fG|j2?)s8_^S3QfT99L;q&>K%h%Mp1VN+!sdHLl}PM?`;=
zNYW)*CEuy*=hF8VI3dh$Bx|;PFE*u3KNNn^sE07+RC;D9hP&cNMJq&JlvUeCtwrTp
zv@8OF<S~({hPlS%KzXNL8lu^CfsFPS>J&Qdu+R`Xt;F`ruT&+kD9TGysPGOQTaX^o
zQrEL7Itb+rb*P|(Dk(+-?;xYt&M&4g%`5xNU!pOWB2LQX4(O4M{0$EGj*=lPvtU?q
z7rSH!bl<rWbX|*Lb8x6ZZr%kseBL2P<*3e@F1``TIz7{rzqE(Jm#KYac6Hpe*n%7y
zW;L7>_$UR(8wG1T`E2@rE)kfwu>NNq!px2fa7*MhF@3@3)u~+lyw|oC2Vo@(`;KX3
znf|=<t5i_$xh)OG=XUTCSs+^5JoQOO3+ti76U<5&dSm>jbosmzmAqMoAVo%ya&BHR
zZe0QDv1o}3JZ1>1thYv{yKgGpm4f}RO7Ra~xXHW_Z^i8h_23%%6MuqJ@Caezei$fq
zzbmtbX>fYKQf)%dgzsQZz*r+$GG<F>j?N8bzb(Zp&6?)bO+0B<e(Lwc(EdnV04j7P
zA)5~}xs5v3qd=dbus=IyQ8T!$g{Bg(_?Z>`?2aVdJ!iZkeUi5;-}yvC{SHASdP?#R
z>~6z+_*EVt-#d6cWQ9Bk6(-q}C$*H{Niyl^eqB?z-vcuvD*Xv0k)1bjHThR6AuvkV
z3mbb@*D9sPdlYExe&dOWW6l<=iuAP9(jjl<QfX-UJQuWIv#$nmT6nK{dG9F&*z>#@
zSgaaB;fn*X?mpFum0F&rPo7+i`$oVA{8}s4HWXIK+F}tdVXo#Jq7l$?E=jh~o&_9O
zX`cot7dA<?uOY%)BqEIoQRdLgXZ$pMJl*q08|d*u@7b#auSYQa{7j*mE!|y2#U{(*
zbduPTl(&c&+$!dlS_)+kZrBaV2_Dh!@G%U%+NGZ9h#muyNw%{qr9}Da9-8r0hrVX1
z%5wP1ppEP+<<8=1<CXD`l)#fpxx6A(1%Xn^jNJO2`{d_Re44DvG=7qono099Hh4-|
zOR#rnMhHK`yJ@Gm$SW(ddKK7R3gwgSMvZ*Pfwt{g>>^o;lpk=|@t^|zf?Bhn3BeT?
zuxuWV(rwR3mJs7%CyQ`p&KH}));eux=a*u-phvq^KflT$rtRwJh2DD1U}&64oh_6~
zehLHe8I;dWGqz*g4UtR1-g;-PO`4lLhnhBS8LDknPc$B2_okd$qj$+t6n#dnl#as6
zg?jcBZK(EidAr2b^(Fd7)PHYoD_z34$$u@cICE6eL$pqf&KOOHJ`5BK99g=>e=JpY
zgn2N&<U7!o{9}yBTNA=bhY822KD|9b2<t!nN^V@c{@%SsArMvj==YI&UqtM%^DWvg
z_w}@UWA~-mWq@#=C;l3LTm-GNJF=t|3@aX_6imvPQa3?rNsI=46QYtuqPrG`M33su
z)!&Fp6AA`kCEg9tJ98nOK4*(fy_0(-|E<}HBTdnWb<wQu<;B-V;AmYjj)hNKO~V>F
z(+uHlQfXH#b6KL@2+&&RomEg88CCnVq$-EdeR9CD6y4hNd{DlCUj$vqQbzN@1K%uT
z^tgycGtO^yV(>G4Y8EnN1Z=1StS$QKv3&J-VD)FJj}0KL2&IkiY(*fP8Le)pMdPz<
z^q|UaSvKXkHy5;9ET+WiF&lFz!f<_)3SnW<!5s@dnWJeM5bJ59mbk>b25J)EDXU}0
zJ54)rR)LWl&iM263U2R~7(){ei5pqs=I$s-<<U~hZ=JkGpe+G-@5<A-DK`v9su&q+
z1oBW9648pHV=y@FG~?VAQA>_q4lW-)T;j80F;b+Sb2~qJbyEn2`ohb^02|_exTi3S
zhtVX~5iJeUUE#f!7nH&r$j(O<eE)!F%1?ch+~y8V^Wmdl(jT#m_lD6#o29{6ATy3x
zGILhTIo~vlJkQG4Tf)M;>h<*Q#t^6&+|U?<=Or`jGvz42ZLLtC@&UP!kY9TyUnXL$
zmk5?9BYRLmA(0Eo%d6p$F5@E!>CUUc?XFtE!FQIt_dqAP17DV{E-|S_Q;X;`Wj^Zr
zcJtGxKA|Boz?|S-x(~0aWeH(v!@4=Bd69(*BVZ<TXE^-_9Gn3>zL2b-2AP7IPBC&d
z4qz`2i(*mlTNqOOe70a(d_AWYCh1B^s_9C}@I>JjamrYN(HKYhvDS%|Mai5&GdIzV
z4O7X)%#_P<$s%5%mU%gPCuvdAyj!F#hNSbeTBn?xXitU0-g|-+SaZ7+jKK>TFKx*X
z^jcfliD?F~-DS|#$}xLq<#*DR{d@Bh0k+g{8uKRG&6U`3tuZQCUGlgjmy%=DkS}Y>
z206vYNG}?w;>a&NKa5Zw=<QySoe4I))*j}<XHL%BtgTs3ow`T%ZrV>fOWJW))LPTb
zPmbWdiQ7xKyv=rYC<<++!Y+9`A5Z5BGsj5yylU|2YBIEmX-240FVHT7=2V8D5MZNo
z`S2dxNy)Mxb;yvT1Xo~!>8Ec?uzjh1?j&uGH$3o>%WNsxF?m&zr-E<#xX6{`ep+he
zc1$!1Aj_mSam9E>CA1T9xZT4p>>bD5rOmo%nR!X6XyyR=e`7g1gKs_X1(84-(X&~%
zEG~A+EQDy43da6924eIV5sjrCovS1bK0Qv02SvLU^+RyLo7#YGoc!gPZ*`W7o>lFl
z_qgms*TQAwU?gc$q-;cMOTD&utTLCGVB}@R*AW{NryX^<a)Hg;#MaZvFw2bD|7h{1
zioGSBCFZ5bc9U(t5l*{hE9o$_ADnIY@+z2_;rl>({0duIO@D9d9wW*?J*)XfJf=O5
zvZ}PKX%Uo=tu~y@o(6Y`^~iIEnX~+(sGT--NiVB1<ACOeR;FvyAq}f#!l1FqlBUaw
zewcb`qXK%+S5<}yXGpDYo>r1?ILT3qqxQnG0>T1dO%*48q5%6;aBT*UF*0AVGKFM0
zJlJKw9pyIgtnVZ1aN(Y3U-dmA?-RHE?dEgiEBud845)}{uk9MHVZ`Pxo30+y?2Zm3
zeT~MP09L0&M`<QMXO|kbNstovOHOjzPq7sPO7g?_9WTV!F3k$=y+c5#y$$k*u<WBj
z6feN--*}&fLIk}*cQ!2I-w;kxVcji_;$y~!e<MFD<5J?w1vNy5m9Yb>{ybfZ3V7)S
z+daxWf#n<vSZ)K-E?Fqvp$t$y+i?K8)AhGn&{x2=9ragd2j6G+Ka%xw2gn9_gon-8
zfue^T&;vPca&go`oPEFm6`A2nid-1An4NDo`Y~LB!{ct@^dj8o>0>>Ff$34dY0N=P
zhwWK0fRcqtU(#+&3V8@UTVYZkWTm6>()n8v1gI~Ipd|sx>)Tf@>?C+xOa-5QeC>Rx
z`~*1J+3-QQJg_bzTwNK#WAks=Tk^5GvSwseW^F7Fn7ZC3;RsF8RsV#ZJ+ye;#u-RW
zr9)`OXxU!dJ$|x3a>=pt?D&R%-`#fquC;x9dg58JvGUHPS9TeYyO~?*nbYNVFZm%L
zsFNoEqw$2(J0^3iemg6&)8Gb_cm6pUYVWE~3ij!=0|#sd@v9xtx^m5RYa3J-U7s;K
z&<>KZi2@7(hLJZu&<|0+m<o&lP2X7=`WK@9tGe=)HMFiaguvRzDL?``7XY*Wavik)
zB|MiHSc3{{y4wSN{`9obzr}Nr>nxWl>q#Dm^z^Maj6#6l<MB6N5(POyZbg=5j;FyX
zgfhcr)y7(82(2*@jK*lcpH^#7nBPWoT-bg`?4{Z{{`z|k-~P9+O@n5&wwFP#gRg<F
zx>LgF4e@{1c<Kn<Hu+2QAFN$Fkk<{Rt9t2RKjfX>RJOXbUdMk4|5NBo-W|f;2>qiG
zWQ_|ThOuXKWFNnrgo?yvA}Vc2?C2S$_9n(pD?GF}@?6IWA`ysrEpTmMA>Iy)hxD0&
zFrirTo033{P|cN&KyBWw<Vw|C>4A#BN<5`O;Km?EjT+;4vCv+wt?o4;@n~~6jEc1J
z*I1YZsgdsf0P!GW&%wYREH0GNQN>doD~V31rc<>yAeNRZZ)X6ycm{8OK+2Leq*ge~
zvFy1HTf<RcG>nZ|@uKXh4xO#x^INilAsC`r^57FAg&F<iSO$!f<6-|7p4_xHATwe5
zAB^nmwtw%(rW^POM{siNhN%DXwVf7w5w?H`RTv0WLNVF@vyl?YLI*Lj2(#^lhzzs<
z(s2NV0UD&v9CrS2mX}vL9)Nfu)XNXNg4Mg2&krdpB85l?Gz^)H9?VQW%M4X-jwq!Y
z>WCp3V*ojYBn5aP0LwNRrCIDNHLnqOL8O))%8ZX%ybMD&^q&y!^8Epkh9nr~u?ZAD
zB|`1n4tYnW^d=+d8GeP>O~}_M3jd^XjA)NaUhYdA(#-34AnGBfp)^6v3y0_nc0w=o
zi&Ihqv<i!u4SoJdavkv$BD2m}m{c!#v^nKB0&+B=rayOmve{_L0Tr^nMq(}@HyjXM
z;KRK4&XHt3F(?-bVF-P{Y`8tL)b(!ICro@$QT+ah{HeZ&PFTLEb_Kzey~YHhR-i)S
zF%i(4tO%!!c_fO4zORUV&OX^tN+v0<gNrz%1dy;r@M0pN=P89|MhL2PT$E@al#*@y
zidgv7;25z`6){lBi-*?`cGUHWFddA7T>2=*urgLaGMEyLx@q8dYFVHfCUN)O^-w~s
z*ayaXY-_07&I7{=^lvK&_Y{(}!p?N7Y!oat=yGvLxwVuDe^~oul(WZ>Qr8bi2}bS>
z!aF24rWQ@HsB8j~>tue{jsBdM@qk&z*rmg|ojD<ss}ic4Bb;Mv*#t!5#13=eQvlV|
zJk2Ndf|V7JP|-a{#O$Eg)rB(j-Gcff3zQ4=u3VD;GKoEg7U0^}YtA0IC$-}WJm3(f
zYW{}Naz|S36bc}&Ik1<4I7#*B&dc8a!=2hcoH}8_3;ZNx$n$CUR?U3o@M+6?L8yQ%
zcu<_8dNrf5C|yPT_3RXQu(yHln>6U=;6zO`E{B~RJ|qLmYX%8=@O=Ypc`Mu$vS!^@
z6&;(5c`s@)Q}7LY!yIV+E#_`cQeZrSl?z4!?~z4nL^0PGsq#8{9as<Ijt__J0X;ED
zG{$~4@q+wFxHd_r-;Na2jf22tQqW*gFk~36%R(@`(8L*A>Tf6e2NVGY6ZWB?vqWB?
z6`D!J4D#n+VODwCT{S9vXIwj-$H)oF{!L{u#w~+R*u->nGV7=-H#2E`(*yUk2mX5X
z!+{+1IYql$<Lr$-_FX&^k28{mZM~Vkj(iX&x(<9g)mZHQT)XbO;xK`=(PiTJEX9{G
zhyr^(gk{-(o>u^9M+k*)Df^Ky42ci@&t+KiaUt&8{V73A1B0)6tKwV?_`7UL^g8B5
z1<{H_yw`3-y3?zbR^dIcH@uJ}utMWj)$3xc`xLuaq|vp@uWk2q1>QM&kjMgEqT;AT
zg+5iP0>uVUQ%HV;e79F7_<$oGny2Ng2lSIUf59o9lN|bb4*lEZ6eh~#K5nIDZ^(I0
zJ}9+;7`c9LhQyYOsC)ZBRo&LKflM6P=4{bnK=1;G8JJKv{j`;YdsheKj6?S$(lFX)
zt9k57qy9*?&d}2}yt+tobjN$Je4o-A<<>;)quD1=`*+DvdG`^=uj4U%L+vVoe5>$?
znoJ)uh?ueE5jTEYbk^At@piZ5LD;ApkD8Mkg~qSp)3@;^=Pp66;&^eaa9@&-`ubcj
zW}pQxU(?N|;0Kjx$+lA<J0A=8pTo}d2fH&42pbxIppieY=gkc`s>q{g271dkr_Y;|
zGVD4Z@3Q3*R+DBI3Yo81*__OmWUdW3X`4Q<TG?>ZMUWAXgt(PU6mS4Y8>Qu#`(U9>
zN6}U?QYVOdA&u|w#-g5#rf+8u;e+vOO=2(}MIsdU9N6()B)$_6-7#m}vJ~X4j+RwT
zr4V)pE-bOmJP!NRd;(*~l(otu(!|8ix2ZXQOg?UD`p@><6A^fD2YM2+gLNHXN}hzV
zqIVu+@@51BIEr0Gq_Fg(Z)YaLOH02CEJC>Rd?y%5VFF(<2)`ueuYss1jWyc%=7%}n
z@8M%kQ9b}s5`!|yr1XGT4Bx*svcHR~6W;)`$GIupNvOWf_<QdV@!dObRFNC##5!`I
zS>-+n8*Dt3kRANs@mju1!Bv0?VIl79l4y4qHHVM4M3<OEo0+~5h7y~UDZ3ryqR5{^
z?(`8km&-B?3W4t`dw)oRvX`yHLzjz}Hc#>cY8k224v}ywC2cf6P9Z5(4`Wjzz){<m
zfj5VcZxHhLIeB(0%E_~PhJh`FB<&PhSvh?_Tq<>{5Jzy>j-Q>BtI_ZAIp$Qwb<H)|
zgd+>uSOEsVKg5YRL`-rxI;8AE&LMg2?mDqZ{L3rcVzhG-b)CWc*U2Gwh-U{sFshO&
zjYxx#Yxt`+WHdo5O&R9JTa|*3c-&?47%*sE7!sgLt$0;$L!^dnZtd7$WM>%o20wQ=
zLN~KGIIsu?XAd6hnwQw7&J`#T<H!peC0l5)<HYtqj481l8h_cR<H1Z#QJ|ay7?Gk0
zpr%{deELq@?IZ9az(`Og>Ir#{^<wGC*X*6?QT0LQRvmGV^c}{QT&$_O+1gf_{5aWX
z9-c`8%y$@z;YE)~the`MfLB<U2&C$ECml_T99*r;xpASN259w2c0>!5*pYOiAp&X1
z-NpzI8ln<1^s{BBA=U~$pj;VIA;ppV)Yy?=8~Q>{b|z))L*bmt&t({q!ov*H`IJUv
z7*7yFP%h~GI9c%!cDdiqg;Ak{J>L>QlaUdo8X7-B6x=g(pvjKb2KStqagFyCe{i5?
zfE0dX!_xN8PQXGG<VB9A*tGUb%z=AJin`VhjDZM<Qb0b1B-OSy>_c#bdon^C)<8!e
z7*l|ajHaar-S^LcB$ot&Vn>e)WM^zv@Z`kRF+37#wKgX@L?B&L2$nU}05ORNbB`9(
znbUCPW|e?Gq?Q6_kQY9j-ObNBSfiD$gZUU`#sPq)I650$iwTZ82wWi}kkyF>eSo<#
zg;oY29}$uvwFA#4De50XnvTr`0;9LK*Ik1izB>@oV!FkF9ib0=xR2Lp23Kg+@v+JT
zhSx!3Z#6etiRMMWngzmqJQ++vC|Zm&9|`U;W#fheza}U!?&531CcmPf<%_j&;Kz_3
zC5-{1MjD%%e(NIMv;l1;X~&8k?R~7iHBiK7$A~9F;j?vOUQv7p9+p;51w;?^6EWhx
zO-@}z(gzNvu8A=gkg}^~M}r}KTOtplcO_2_4*+t4ju{fUV*N%b)cPtE)AuAynGw8K
zng*pF$QAgb*S64sh%w5_K4*q!wQtgp@TC9H9rUK%9=`y1c4pq2k}*$c4Os;{60|=`
z|JCBO2&pdlMgeSvmU*@yI7)G%nYhkn){7Vm0gN*Um736%GI>dgQ~^IwGhbF;9eIS#
zjJzEcO5&Zxs^sWM6f70&-2cU1p9u?ufe~fU+A#ZBpR+}+a3`(TmCLy*9?^p0w%|ko
z`ITY{G@ch{s2VJ3GHQKD?iEGQiZ$^DH4u5+Lkm)TQ@UWF0ANr4+f8EM2_N_N+ab`e
zG8KQ%2#t7l|ERT9DBIti-2+CjhS8UXOazg@@&MM^)c&2-@Ya=fN!oF?SfwJYp>fIh
zVG!>i$iR3Q85~lUeM7VTojZG!fKW~dUL&laD#4=ooEW*F#wh)Qr-&l-^Yi((UeITh
z2y?>UBM(d{aQ+jKr0>}Ra3Mm>2d#r_n+^M&WgoU+1?HjdB60{gdq@INNi367Ls>Yb
zy6(8}0XdE?`we^A@?dQ7;=x?b2736JLyv?=->s1_r6!ZWVZ`Ja_J*^1BRW&Qh2iV-
zA`Q}WW5YP$-v<^u!r@o^#)f0C5FVWOcHSlC-7~GjjQhqUq|_^e>P=a2puiZ93QKD<
zqW{K1G=HVZiSj5f5eLe`z4@IrA`A9tQpB6(kT%3GIep~4&)Hsf;@*rAdt`|sQD25g
zL9ybfE&ZFl*V%3TJ_#R+@-HTWjj!5ju`x0aZm;cY%$J;l6WZr0pQ78Nu~6uY!<_>t
z9jgiW%RHS?Tgw8Qe++$iBu2dV_s>T$Hw0L@S1*H_K6Y#R@V4Fuy3W-`Ie3BJJq4OX
zDV+_2htO`s?q7!;3`Dx?Yxu)Ge?A~Q$e%mb^Sz@Cv`*qvE>6UHj*!1}xWamltj^&X
z6_M=o|LDev#JeE4zzWjz7U|xFI(7^rin*5+4#vB@g@;e9=;ZN#VG`C`89lD4|M=An
z)naE{w*e8M<s+Ekc9tJk37vk5efNOSwrYDB|8qscF-DNe2sEb5wqiyiF`u8|?JV<{
z0BhLVIR;ifT4)hWJ65*1LGC{8RlCZq$`2Q&*vuL<a%3+Um!ueRl;eC~s;|&=#T-<@
z-g~5#L00<b3=gD9%>HD?sO?mVb3t*>-6W{lJENn+D@y%DBLRH_0sXH4>o4MCpI@7D
z?DKpis%It+Bm1F&fbn17Wv|<FiRfkmCeRaO0pq`a-;Q463s4^fd$+Y<JsH-I;||^6
z2rF<eY7@2~FkVrjq82To?agmX_N-Vj^AH^+pSbb*{Qf9i-+M+g_?{?T!+}RLXtb$#
zCqZ2e6>=c`5+fpiGJM(=tPw|K4YH<0(AJ=;2(w*@S{G#dV~#*+gRfE#d2y<#FiEFB
z=~lRPtlLDu2O8@QmfQVJ?&&j7>zyOA6tSd8B{|oS5=T|^>#zwGt|h4$C7;C}3^#In
zHdDVhztoQH4MS+j30X>&+>Jx=5}gQ96ZsO^dE$aZ-mR~Dr|6IZ5l_l6V|Z2~rSZ&a
zgB=^O^!JbLqc*xUCYGM<&(FM-%WTs_t{JY!?AwprnMbebg|43&kuUk($1=|F*kD{p
zIdP>$FtfDIOqmesUbAS&2CN{}qAYV!$KrQxcZe^bDFwB2j!kgY{mHW|>EQg>IR3Bt
zrBBAzocKX&yOQZJU(YxDIP`_w+1VlN1`V%Q0L)cq6?Pi+&7WXrhWa}2RcpQNcmM?8
zGfDmGkoBzI7f^tfe+o#IWp4#Um3S{VE+8jh2?p>Uz=jOK0J7q)GX*(Q)89fUA?fwR
z1~7n};pzK;S6wP#h2|e%5&)Y0m%ag}0+xUP5+Icnb#kD~i26F;sw8_e!K=>v={~j8
zO3Q(*?DX-zRhjl$B2?}BFJS-%0@&~YECDVsbr&GZMZKP2fJ=}w8vXacNs;I8wCf0f
zYX2oHKv%#L0iej=1*wi6Vp&^%3#_WAe`}%F6Ah3DYz0&2E2geLZVp}=V`>;Q8<P&^
z3F!p7?9j^%2OtSx0|G1rut5M|{9Q2W@V}{H)#-vSYxTZB0=8#A9^q&t5}Fa}uz}AQ
z^<99}2=w8Ampyu^ftF=^+aUln{`bsv>_ApH$e_`U3bOimpjGgHp^5~!5Y?4_JLA@$
z0$C>3=L4$3@V{rTV+XdvY5%4ygkj_}=RElhKo{_3`UprRLtQAynXtYr&@x<aI~qXR
zzZn-W19V2F-vv~~;C~O38`F3tt_|iFbM~$B`e&850N8SOFE=Pa;#(z8ogB!ry}k};
z6^*|O#3miY@<#7^xQtlaC~Ol#9Xzlajs89OGUY!e69#|)WQA6z3$!fJ`+|NylzxmW
zgBQ~eo_`x)19S*ql@!2+2{-~dQ_|Ogsq*Oc{04{vvSO?I1+<LO`vUdY_xxn6jThJV
zx+mF+-wpb+mt)7amm3IB24uxqNB@$l`s@a#W}}by1?2C7UN;PK=BU2~TJ`FGPg}<?
zL|(wj45kX92BV+zt?FtuvOfs69UOr0%?hsW*H_Wk-WQ}LAU&4Bm;BsSL}zMKxGMbK
zQ-ms}-c0DKEPoe{I(+bDOZ_gWD*1qWJWoioLS}6^x)F#X)mA=FaDuR}@(|ywkn5xZ
zT-da$A(r`iJ&^%3z-MUsKA=^XKi(q;LJ3q=MMTO(BZ3D+xvI>mpd_)U3<_}N8d=d2
zn=%IcGfls?OWtGwj|nNl2c3U+hM1r9*6=kgO|~39|6zV;uK-_LScs@(`&Glt<ly0t
zh6WavGZB4?oP#sOlu~)}Y1V|=4+BM2>vn2osmH0C8PY$&6&WA6<oyQC&<7D0^v#Vt
zk#fWij?Anoss~p{@B*so)VMYr>$becL{y|2GRZ@>hl7$OcdORv6<;MVh6FVx%`H#o
z?tI{vK(Xik6qQtyVvQIO;({BjSWA$Z4;l`cn7$;<>C<`04=pW9{{|Q4h83O4BBg>k
zF!MFyMu#xD_T|fhkH8oC*o)mIR9w)nKS(Nqn=+g*8{Dn4PaZOle*|7I6-#0kZVs3d
zT!no;hiu2GaG9n>M=@Y3QIeN0h#wLIXj4&<`4EcV2hr9BVarpMbzt?n$fFWDtP<Mu
z@F0f-C*`|>7X?6cAc9=XjZMeWD`BV*OXBLrih#ui5#HS1p4=A}nA2Kbn}-PQ;;{8g
zH4MqAq{;1lYOyu=Rf*G&@1`Xk{8k&)h^M0Qu9TX^S3f5W01a}Jj8h^j>lnuV{4A8}
z+y0R_A=+lGq?k(EMtcG+mquR>{W)n`5g1@ElqP^|YGx*&K%N%hD3pOW|GSX#=S1wM
z{Ce@*55PkXyTwZVYdxoiABmjWPfm@TJ(cX!xTUd?e6ccap%mvf<y=P}N1nT}lrxm&
zCapY$<3)<JDEl^CQ9NcgGB0B&8$L)C?bv3Jt*#(8)xDNdCE$eOmU(hJvV)g%`sVrC
z*Wqz(^t(jrl}gqW%dyic%Yz$*8bR>#-kM%px*Qh5AoRA*o4`P}lN0H*(pfUAFk|XI
z)*ly|LUwlwy!5IN2ti{yYd{b5$>+A@V3&nQ5`VtUvC`x0Hf*T!AWxAcP*5=0Kv$S~
zF@l)Dj#J_WPe`;$C1<C(L28OB1)8!bvfsfNPGt-k74X7$UVSHv*7OLjNVMagH*b&Z
z(;qYyR28Sq3TY^Z%a0*N@qi5;Iag}NYcg&`DF-7i5ZdJM0S32Og*Qp!B_A(R**4I`
zkGyHGmTPFE)KZ9CoM#fuJ#pY^Kg|}Y@J^0>O_BKFTW&a_QvR963}WK;J*T*aO5k2y
z)h7QfVU5cn@FMO4{)w_ufg7Bt(E~E;()h@jBfZ!Wp%{X=HdIPpo=U!eDm*vLuyfiR
zJRKIc4>LKH33bRHZb%WlQ3y)HL#80`D&!9DR5&+35@<NTNuC*#GA;$GTm%^J<`R{5
zlmN7EpO|;n?<WLpz)+d&*I)A5T3*kB4=pMQE93<!>9iI_>Sfi+_cnK)&RjsxTb{Eq
z$~*(E)T+jAsx8+~l=6~?47U&hQ+g!YAlzE?#dqQel5K&T7=o9)-8LiV+(~?txfi+f
z9h(eKodhj75roY6IO)IX`dCQss;F{aD(6e}NqFVb?0(D-P`HsoSgkAgJ;1{YPw8=~
zu3}xG@ru^4h!Y<N&ImszXQJr@Z|xF0<L!^|_nQ%Vk4v;?2gA8YCOb;5%A@rBdGKP`
zWl`j}Ifm!hEuz#j(D)z|C>Y&4wqJO&dx9buddl&=S&1!-F7gJGD8LQwUiw3YS3}GJ
z*$SQKil!<3Rp@G(Fd4FI1jxh^H!tkU1K8a@zX9Kv#}Nw3Xf?sr8-D!g6m%4#31+rn
zymOhgZQ%R7=1EE+Zs~wg`-II+^NX#`ll8Iue6!p49}in{Ahqhk&(zFt8RFdr-3Fyr
zr8EZ{(p=J9$nbelH_yz>1dim!R2k43z+4%{l}+)zcAW$G<C>6sgk2+JTi<(Mqe|Cz
zzU#ys#EQ<qPlEpj4P!^e*`;Ysq~@c4E)(@&uu&clyb?K`Q!DwpP06rG`HyO-=E6~}
zdaLrNcEn1+UeO^Y`Nu%FIx^(DHjI;Of9*Wegq^p?s8}}PeAlc;InYy>5CxTS_!+cz
zT`rMKkB~&_yV52~j9{xHj#Q@rB+)mf1V%}%pe>m=Ai*`>Ggc8?4xPat<Ldf6HJ7}t
zBl3!^bCJ!XKPxd0Z$`oc&#nR*^bPzv+Qe*y8UksdYaHU6IcI^Rue<P{JFe%o%o}EV
z?ytIBss#%EhJiJW6MC(9No)CmMZn{KxZmMxg75fVDi$uyM^K!(bNywx@T)1?pt!4h
zkH+~B(v|l?y+wP~#gh}dozWAB=k;1ZTi`5@5bYI#<S`=1-;pweAHsOrAt5yg%_XRJ
z)&xuA$H$->@Cwv_=1~8fbKB^!Yns@AVkA`eF7O8lQdL=6UglU?Sy59}RbbeqWHra2
zECOBvuLiF+J>xEV;ktLK7+G9aGtD0Rfv5s`e8M`KY2wo0IocdwNtl<YIy(Nf2a8%^
zUhL4--o?~!O&iN!0pzEus)~xr7)2%R)7diVygy=-&U!p`ap1HnqzfHGN)l_iOSsH3
zVp++g;nFY^XSn~XY7x(za>_d)SUd@mr_k>K#SBfv=Xr%FQUxI}zHyC%s>r6^=-%k~
z^?1z*&)czO2kc;Qp*(JsN<dX{MFk8@GUpHExYN6bBxq{BHaY>XuvwB2z`{LeF;aoE
z&oShw0xU{xMIc(HMfIR?3Sjx;<D>cmPf~D+p*%2|QaVtb)JH&6ECe}}n#q_s+&D)v
zB8J+bJc=5ya`>{oUJ=U<9YG`5M*R~f7g=@N_$B_=QuEs=zOY^x00#9mcQdszY~oB9
zi1vk3ZF`mr)WtQfvUpiE9!bJxr^=R@Y0GVdQy=2AQ;zQjoLHqLxC$(z5>_C29+*wo
zDbR5;syd79jqPnWe&j$UI2d3B2n$w$^nKHW8wD*4Hjsi&gdkyZKsD-zH6}&-p23VY
zE|^hestUfEn}6X(+Ddwyb*Cy(c$%RzY~1hZU|BAD);6G&GmLzdNI5Tx4k)EYQgr_e
z@caaW$wa|gci6Jaee+~>u^~WVT=;HIfP!Q}>Kq-HVML0HhJtG=>c_nLos*o9{U%Rq
z)~Mjl{VMJO{i(Ly+x!n)u&5VZ6c6VV+n*rh@!=b?bt-!+s6l?Dyq$)0kz@y%qzFVH
z+Fyw1tK!VCB3RG5gYNy`cVm~;@RVTcOK&+}@Qx{8Scn!W(5=g5j;Wl76;>QJtbHvk
zpPwj@ZoQUkGk$-n5pZQN%w3U_Mk@z{ZYRYVQHGXh^r23)Rj0q#*L&G6pwLq!x0}Kk
zU=g9uFAVx%(y~pCNEeIW<wN7L{VMkNXzV8zF)AV!s|aRxNva;sMZ`r#Lc=1RCu;h^
z!`qxI@CF_GJ#Mz-)PXJL!t=5&T;Hg6)j!<4psa|mU_ndLSQ3CVAUZ%hh(4%78HpAt
zdei4;VhS86v2?p+|LPD+3}WctS&VXmi7xBIygfFdaeRKjq-}i4JGmNN$I8)y8X+SF
z0_npQzl;#j`Fq=rkknj245UZ~G%cSRa`VUl8CA@c`_y+5KiPfRAa8Xios@3v&kDaB
zi{AMuOYkP!>wO9PwZ{aJylqvpaK=%dDp%*6r4jtZ9lf!6CxgM#PTIMx43$r-sb$I|
z$!%{JgYe>5F-L&A>lTa2mIHTGvp|e)AB&&w2a$Z!O`xa4O@Yf{o2~Kv)4SAA<~}}y
zM`E-2WU;Q67uuhWy-kt(R8Ngwoe~5COPD(u?XyW8o!XhFrtzBdljJLKH&N7KZ_|7$
zM8u44uar<#-}xaJ&-;%KhOg%suS1{G9}xRuW|p~@zMQo;r}u;0`+a*ML?jhcHzSvm
z@mI>^UXOOlehc!db;O(_fZLqzr_<yd^)gaz;k>P79i4@r68ND(I5tW7+I5ggv*1aV
zG%TJ>iv(esFHdNG+4i1!ulL`hlIC|`bE3?lEY4V1!*z?>yFJdPpy=m1$vb9X_|xF2
zYU(Iei8{-{+oS7)d3I9;sJFSM>i3O$1DKq;Uoq{S-7#I<%ttts4&nZ2id&+ch=D3*
z3ZfV?M}hc`88;{<GlgQxwz{T5(N4WE2$;zrd{q_Z;2S}<T=a%uq=a&Hj&SO}mB?0#
zXiFEMbX9w<yv6uH+<HgcSlwSqOz-cI=N$X)kuc8aY<hk;b)8iAGZZGSxcx*+#^bT!
z{!b0KcONW|8${0LB9$Af%{k6Het3w+Bu-ZDhIleBwE0+9WkZL$Ugh#laD!?G#hJ=k
zutQo*9pXsO#*v9#{o;P;=R3(ITV%H{yG+EV4<PU(L}v*jj{RBAd*9dFd1)bm{W*FU
z+w+kiXFGR7>*XWqI<>&+$?c;2KK;|MZt2WKfM=>}zTXqq)4ltwe%wacmcZKYLbcMx
z&;;SJZP~-8HSAZ|)GC1#?E{}Ho%_Q4?ner2QgT6KZgY5wvjo(LH}zS$V%Pa_inJ3<
zV!ukQn$C}1RTN}&XvOn3Vbn_R++UgT=g)66ctg}^)x%+wsdu%5&?1KUn<p-4XF-7>
zx&{SzkBa&R<qX7;$NKEih$6*=gjo|o8g2>U@9KvuigBM}?*if^CpRSTG^>>yiPwA^
z;4eRizQ^!)ZKcv}?Krw?#pu1v?wXQwTkY|aT`Z^Mhap?C#_b<z>*h|sUu6`$n^Ij`
z^^68`6tI`UvEt*Lb{iS5L9p}luCo+L+7u1xI5fE}h7Z3_Yxh^b4O$YbD>Uw$hk2ZN
z(RDWM0hY0*l?;-m>7!Ph<k<#^FD4kab#HGxwO_~OU*AjEO?po7(=&W-oGm2}1J1-m
zYTW%=p5EU!o8_Im*{9)ZHTpFWH}biE-Je<&ue(gLw+!u5N$DZ`)%Y^s@6Nlea8w-E
ztY1?$yFK4Kd8{92Fx2oYEoYjXwPm*Cp7x+|x%Z!GOa0Eb7^@vjFrKIvXZx6#HWv*P
zLq6Cw{f1`S&VI;*+ccr<5Mr<D<YRg&=2wZKCn7J~qwQmTxeMKlYY42m6$Dgo{z}=e
zQ7n3Opao-e&N%}`?9`u3&Ab$vo{1DZ>ij)FoiWb>30L3RmTh5kb#qb1nwGthl?@(Q
zD_j^@MwV_;1h@w(pe8{mjxR%<)XNhAXZccLu*T`O{@xD{*blRyu<&S35%D)LH#l05
zKh^t-;wLkCC>Dw#Hz+t|upj|2JPkC_>@xwxade;`izqEoK6y=Op&k}yfcMdKE2s#P
z8pD=WlAMRyS=<IU|An~nS=z11igB&LL(b}NRXp}ckLrffYay+Rrh8w$!BFPXM$Lg?
z_mk`RuAi}8gWh)t8^<GS61e6*F)~x*IyI^jI(k19Cn8pLR?jBq6c>KMG3h1z^t`Eq
zMyM|IJyMxjkydfjVkJ0M?`r>y{f+hr+k_utUbd0xof8~K7bi2u;qxqgqA(NDU6q)N
zwX_}(b_9j5E06hu**)l1ZUJ=zt|e&`{j}_7+K*g~kMsqnw-X{|v4tvAyVYhL?Cw6s
zQ<sAP43p_DD>F}0f}3UBX6iCVVRQ?HCChxREz->?1`nTr9;UOt^C<%=uv8A>;6Ku}
zKGmFwHe)tF6&Yp}x9OxSeaNV`&la{7_v6pzTbtVB(m3MIos{|BPsTen-b)(A&-q0>
zVZF!aa8RBOj$HUgGVwBx1ulk<w+Ab`GdHQOH!d)J*)I&o>aUiloKlC*Jrtj~E@KZ}
zDqHd!ky^4xBB;n-<Lr3akM}|&Hc-e{-dHUUO}f-=mQ#p7!U|f1LIw)o_$2UM$8pnU
z^c;vSZeCdmCV*{i#>%Uve?(xr=$R%isoZp@hnr{rX*qii1zR%79)Cc(grCG2=H|RM
z%&Q#vWs;*+dLNn{6Z_h1chfmfv+xpw%dfGYdlxq=^)pAr4gp}mQdBdyX%X{q%@zoT
zyrG_QKMV$IopLs!?p7D|q_zsWS_jpcXb0TsuiH3zvRZrp4z(NyU&ec}9&mE@3lprs
z$8$GdT#=ygk%Oa6#}Et)K4E0)W6QxwSOpbSKHe7a9iT60T{r9NdtUV;y>8W=x)o&r
z(y3p@*wR28AY{*hHYdgsNd0jcJNx-nRR;Pnd9&l7-PPW(RWk3@1OY#H8n5=U?Xw>b
zF7AWcPkY_NV)6qZyt+^Jn)&#WYpdadw~RlUAqV@02j$oDqlzh~`bH=tVIf<$Qp;%B
zZ|#u7PNX?{9i1=5vd8_jzB*rf`)qSuej20Ag(dPd5)V^L;3B<|{w{Ra2BUVbseL4r
zo*evje)w4ik+(mFe`b1;lsK(fhKSuysy$cdMTUW={JudG=BQ46Fjy~}<yJdku1MGu
z6Bc?c<^33%#^Y`|uAIj!TIopYMk&jCZ+$LiJvX}~oO*ZO`KhLRqF&1AvXeN6(`&AO
zUG`DDxQYg{7v6#<rO9X28L?}2X6yA#!gPp=sE4Kd5-jSRRHdC5KB;$C0Q&kZtW28P
z+p3ZgGrxybIA!S1D#};QK)m4Z(+MMozh#I$$jWOv<@fA3<_KS}zcsh?J$mS#mGQ3Y
zBDV7F=%tm3vibVe2F^W)ypBv}y?xa;L6&hJ=K$jXekkxB@qTSe_<U|_t;~Ee<VG7m
zf$P&U5V0rIhNK9A6MEauj-Y~<@TmRV^}w{Q&g|+m<i0TWIC^Gy#rS%?Ou&~`(-4`*
zO*2@~<}w5&N{xW2?PXy(Iy^&y+<*;Vm~Cd02g((J9FHcmQ}L{uJ+tK!u$hJC5<@a8
zfS(PRGE%E`_L)6jx}9$AvLfKq;d;f^_#i!lvpQCKd(P~8e--od-F~2?UlBb4c@?^I
zfQy@|?Dt?gi$evx<63%qcHTr~EJ!?zYY^c+`&V1M)T^<228^11hwXV0Ynoaq;cfOR
za|f!-w8K4lpEnvxTtF8wwdQ%gc{1!CD6G_F^7KPIiX8%z&kKDxET_@?(BV7Exwj)q
zl8y=Ee{W^2c6}Q(%PML-Ja5Eyy7ze-<HLqxf#_Oqw}|JmDma{MWama|Pc;3&Dl)>r
zlP2)9*7iQ$ebA{#m*AC~S^Bit0q(vJj&4)d!Ci_=OGS@^tDbgxk{Uis(DFnkn!)wW
zEYRpG$<xi*za^T9>vE}PYuB`sipAnwZSL7##6Z#e)0)-sym|Gb!8iz@7AJsyoU=(v
z#c}n~Y}_L2*%#=qM+~#*n!U+V@m%(UVM6u@*Sd$Jn_J}5`um#c9}@vE1NLDtWi<ki
z;>Rb2>$YCKz0M5vKeD`!CTJMLf9R&R8TD=t*G(*MU*Xuch9V~OQkiy)KPnfUJXiEi
zqj@^65q^dunA@vx`#HD(?vq9_cp4eP!F^Qu`D{GjSG&RP^FnR0EcO;?-m2DH7=nXy
z1iz=V@caZmn4Gv%^Y{D2jHi897p|ug8pU&*_1lZzk_RPTWgjdJ4oUG|s4I>l{<`#M
z@&Kf(d5`eX>pYCBJiSK`?0%7oOU!F}1Z@(9+{<srS$Y&_2V8e}xF6mXN4X@l_2dJ8
zjuW8+rgIE-RRxxAvxdqXHHMbdRuo(k22z|$p7Kp3H9p>tP;DGupP#F+(k^XoxJOwk
zDBIh-Mgu@?=VIWLr=P8u^TKG|O}Pzr<VEr>4%~HVUAWJ+^eh5rws|T`$O}!L?gDk~
zbYj`VgC4}dH3t8TBB(HR8~&`h-_>cEZ$7yWu?@<l&KXtLawncRTsjI9DXln-%`tCf
zBP!i3+YQ??UF2Zns*!AKJKia5>gKSKX7<i2iIZOPR%Ub_FPcOehL|MJ<G0?h^(;aC
zNyP<dQp<MsV6nKHHrm7HivmJZOAwOojQyx;=!x^SoZ2XIUmr*CopM2uGc~5;p<jr?
z+bJ`6vZ@X!a2JeSGM|WwAhSX+Ke^n*o5#%OdF?LPFcmln0_s-3+q9uj!OvuE5cuUy
zWw1VL^@333qdMF{OKT%`L9iVr`DQ!jnVNdvb-MqtSRr`O*1h2nLn0S39XC#6h>UHR
z`_SVyPxg3MsjQh~TT*3>dnSIq*>S47-_%*y!ZSpKFy5Gi!KP#9=y%F)UY5BVn-e86
zMloSF{EUa2>1i}Svmj5;%Idv^s%X%<Zr;3A=Wy_t#$BTBIFjA1dCbY``W`mA%(-h!
z!lw6mk7F~EQSzZn`^U#EYGea$Xhi4c=(o0QEB(~*I!~7VrT0hBpIWcmw_PX6yc&!j
zMz8_!2-k%@8vEg^ejT+R7RqYgdl5|du@TI8e#&N^n|}4T(Z`9t?OaT%-EE3JLU?Hc
z?Av@(e|la@5T5AV={T)cL?Q?b4$Um3?3`FoTiT$4DRv9$rnuhBHa55K2&74m6q7KR
z6B{Fb(-M2grX|SO6LW=Nu5sapJ}|$Qja23T==BgpM@K?LA;9FDF;=q%HCR~!5>G!%
zhi*<_g1rA(SI)rnJf~-v=yyVgFLle^9gDGfUm}W9@DPVTD7;;acF5{JVwI^~9tZd5
zXGBlI$a`;d8$1rWUMz-jD#U9B=30x|pmyYU3jwAZtjo>tq#{>4E2s`M_l7(%gBCk`
z%fmf1`dt3|z~+cFwykE(Dm*orA2c7xAG4`8%;pOyS=}M(2o?;J4W3uL$5lzP+JU}N
z>w9<^^;9(5%dmsm;CY%gp4P9nrTWSXRq~B8%SQ<KT%6twTKV)Gw2qe3p%PSfCY4&+
zp_?{1it47<)Q-IYBVypPUx#fcM>)bZIt^2ATy5LW*Pf}RTk@Lo+jtwSr|NB1xvO?6
ztG*)e^1I)v$)C6%jTtVqfoDof{laeg#fD7}JHf?C=A&l3I6Y90<|?xc?_5_<ZCt#*
zir8J{eBSX|nPx6_uYKO>)MwPu*SA6KO))7`ISb!3DcAAnC4H8q3x)%Ck;gDu^E$vW
z`?1UVFf(DT0i%%yAiH&0k_QFFwd~eeN^{uDeaA8x5V!zGu$lDLWAqW>bL{FZv6hl{
zC0f~1WlLME76H$pUsK_n_b7-JTRN!Lx<y8Q@p06t?RdPU^tsteT~7MCmKzB=vkA)9
zo(uuDouRKQXC*I<hXPbDi!FO(dEQ9ug+F4<4Wl(&E`Pm+_p-64vCH3Kx+P{W))Ll)
zmFxD?c<GLf&U9G*d`-pp&LNx0GdHlLacJ+l5NN?W&-Nzmt?Qv7I(XiQa#&79=AMfo
zi8&M;T#q24NbK?c>G|~*b}dN9HqMxQO>v-nSa@6O_xz_}n90J9K@2LC$YwsM_X`YW
zQN(q6OVDmRl?9(ME#00b1&UXXE!bC6;_tg;z;mMgJbsK8PXj$EJMTvVc500A=bvf0
zf41&_QU`DUnSzCid<uTW+=S=qWN|N^>Law-s$jt((3{Rgujtq|S=-wPx>y$_>}UCD
z4eW<?I}yG5({Lpp$K)jFvJ87Ly=J?|SL*37&$*3b1#JCCOGd1Rdi#0lt3#fATgQdX
zoL5=V-O_PfRxHD9sFvC?`=%ZhHBL%r>w|tm${|QK2=Ynr_Y|Og22mfh`}&6{X~6ld
zv(!X!pw9|5Y$Y9yj+Xo~+avabPsd~G0mPDmYLRq-Ivu}{;vbLNk(f0PuSRcM>l{AE
z<8?a8>x<i$-z%762cNdxKYBbZZFa*>OH+<NR%raR4!mwvF803B<*q5=5^46s>L7ER
zW-L|lom|mgiCscqkjq%D*z|bn%pbV~fU*SdOMYIk8Agx-<Xe}5QV%OW*Mgqnw#}7i
zix~<EC?$O#aY89!f2j_jme2NZvXg{nWM*h)X34)N5zD_v&IoM9np2gWu=721H_$WR
zb>F+i$t0`Yj4z{krT&EX&|1R2VEQ<jONIDVUWNAJ`#37R{XxV0Vw;|PZXQpzim&3j
zisaYN$I!izyK~lIWp9@@kDi5Wv*o|(!nQE-N)aIt-8M4v(qqZh!M+k-Z=--J!m@hw
z$dNiSkn949u<={WsPs~4?e$K7IG~G)qb3ByhTk{#puqs|bE^%@>Cd1<GHaAXEq{US
z0sm8o7cz3U)fT*Bcs2V25{s@a+0wCwCi3Qsl@91av0nA3{em>P{iIRDIAdevR6^Ju
z{fviSeb{|=^!6bS8haF<Z7CFc#}BiXx0bot`I(Eu><AVK(vFkg+FCuYwhlWTk9x_c
z)2zR*L?T0w3iFFGL7xRqRGy&WpiOLzotzy_3~c^J+8J8HK{K-wG7|oc;^k#f@vt{x
zkTr2OFg9>DU{H23bpDG0kd<MOF|jpsHYa3Z=Hle%hlBnn3a@~>y@8RHi8G<0iJ65h
zAMs^J4>6&IF(0uyn=GTOy@-jq#dl9f6J<|16(dh8BQ9fN0e)V0Zg(4do3CLA-EFLG
zow(ikhz*SG3{AMd=)c$u#Dsqnakk<kW}#=I<6vYW=7;8WG&bc{5*7c4(pQU**xcFK
zo|}Qe&CQM8jfLLM(TstKi;Ihak(q&+neI!1&dI~p*}$F7)`{ew2%;uVMvfNt&K7pI
zgnuC#7}~iw^AQsh{sY(k-*9c6=>KLIy^);_!&e6b6Fm#VUqD|px5C%y94<yCj{LlT
zb^TlOua>llhnt<FvC}^~|E>AgnEz(OKm7VP&VRM)?-BZf{0h=Py#1f8a{rfE4F4hc
zKU_98`WLpni=*}5;%IEdU}9}zV`A&<^aaoKH?NJ2xScJWtxfp<HWfnF&VMJYE&jsc
zwl=Ue<0E#bGd3|baItnK{&M{<bF3}?LHtdg;eTL!QAS^D(b?`Rf`17rn>hRv?|)YP
zTi0Kz|5Es(jsM3){{J-Szaaf@#_(%J|0{_9WrExd?7srY__qLl32}@3-Ded$JL@ku
z|8JasF-$}aoK5(d8JSt=n3(98*j1R=xtUnFS(xY;Ik_1b|4sGplDvOu%Gw!Qn0oww
z(fl{bzt7XZt-$}cHTjQa^EIHX?EkaVHa7qCTUM4^)XvD|uLUJ3%J1T0Va(0W#l*zM
z$ihq~CL}6M$0{n$NGB{TE=I@B%qYsnEFvx@&LQ?UH~*{dUygopByF9X4Q!1}{&&#+
zP4|D{JmLR=5A^?mF$n*AkpC#k{~fOX4%dGaf&WPOzgO3PhwDFzz<(tC->d6C3)kOo
z`(N3_U%$crnU3)Pk96iMQ{p3b`$|^+*GUuGza>q|3{nQJ2Fia+Dj1}c8Jx{6oapTx
zE&i`|?B^wlFbv@M!dz@YkPxg>FNvUDX6BuDW@jplWL;9MWY;nf!BxlDSa)Mw%eti=
z>fS*j2%$q=f}rl|p<|~`-XrLL5PQdMb$2G{6hVCFu<Snj{&?Qc`@YNjZmrQT{YJDF
z_RAo?GwCLqH!iQO^3C!}xH>y%4GAIRMvHTzqin9N>}fYb#%&ZkO8RXj^Oe;H)$(I~
z;F^xl>mts=yk1!fZ-lkAg>rNnn5pQj9^D>4jl>7jR*{Ylg0>EhFN$}I;j&q(JPCyi
z%$ZqX3nk>7FpKqiLx0c-n&Y+Qx^S9r^RrhR=~}k!1^LmjYXwW?<KtfYX>a7uC3O3R
zO0^M2W}&JN$oX)wz7)2ur?xHQlv}sc^;e7YnT?~P^H1Lh!+3UoYwGe|?_%%v!h})U
zmp#KhqlZT6;_KZPZ!c{fbnSfE9Qsh~`gCFPdEF?TJu^QcGn3=rHr~14cfTH7o&WK%
zZ)?~n-Mh0n`1$>a<sMqwFZVJ#4KaPrFf!48-_dW^%6b$ocV{i(So-zk5uWQhu86<+
z_1Jo<<44p^Vz$)g$(XN~Nh0Pby&MuT&(;_F&Y1E8nTiD})t+nHdNFm@bsaBN*Hw19
zt{zsZuIr~`Ih7il>&sL*&&pZJ_B^T5G3BRYIWL)?QqoC|O({3ko+~Yt9IuY~NoQ9&
zL81@avMno7&bE}}C+1hjluG0h$C7iTW3H2!OC9qZy~A2_)QHNJY8Z8A^?x|W8`81<
z_AYGhvvSmEu5X=Dpq%dPz`)q8LU*>c==GZa2f3M3QTR|aQ!?XUsZwJl{;17TX}dW~
zCwZK9h6e!z5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{
z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL
zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~
a0R#|0009ILKmY**5I_I{1Q7VY1bzbem#At0

literal 0
HcmV?d00001

diff --git a/docs/images/configuration-presets.png b/docs/images/configuration-presets.png
new file mode 100644
index 0000000000000000000000000000000000000000..38ad73165b246677f525f3d539ad627acee666a9
GIT binary patch
literal 135055
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

literal 0
HcmV?d00001

diff --git a/docs/using-the-nodejs-wrapper/ConfigurationPresets.md b/docs/using-the-nodejs-wrapper/ConfigurationPresets.md
new file mode 100644
index 00000000..85962853
--- /dev/null
+++ b/docs/using-the-nodejs-wrapper/ConfigurationPresets.md
@@ -0,0 +1,50 @@
+# Configuration Presets
+
+## What is a Configuration Preset?
+
+A Configuration Preset is a [configuration profile](./UsingTheNodejsWrapper.md#configuration-profiles) that has already been set up by the AWS Advanced NodeJS Wrapper team. Preset configuration profiles are optimized, profiled, verified and can be used right away. If the existing presets do not cover an exact use case, users can also create their own configuration profiles based on the built-in presets.
+
+## Using Configuration Presets
+
+The Configuration Preset name should be specified with the [`profileName`](./UsingTheNodejsWrapper.md#connection-plugin-manager-parameters) parameter.
+
+```typescript
+const client = new AwsMySQLClient({
+  ...
+  profileName: "A2"
+});
+```
+
+Users can create their own custom configuration profiles based on built-in configuration presets.
+
+Users can not delete built-in configuration presets.
+
+```typescript
+// Create a new configuration profile "myNewProfile" based on "A2" configuration preset
+ConfigurationProfileBuilder.get()
+  .from("A2")
+  .withName("myNewProfile")
+  .withDatabaseDialect(new CustomDatabaseDialect())
+  .buildAndSet();
+
+const client = new AwsMySQLClient({
+  ...
+  profileName: "myNewProfile"
+});
+```
+
+## Existing Configuration Presets
+
+Configuration Presets are optimized for 3 main user scenarios. They are:
+
+- **No connection pool** preset family: `A`, `B`, `C`
+- AWS Advanced NodeJS Wrapper **Internal connection pool** preset family: `D`, `E`, `F`
+- **External connection pool** preset family: `G`, `H`, `I`
+
+Some preset names may include a number, like `A0`, `A1`, `A2`, `D0`, `D1`, etc. Usually, the number represent sensitivity or timing variations for the same preset. For example, `A0` is optimized for normal network outage sensitivity and normal response time, while `A1` is less sensitive. Please take into account that more aggressive presets tend to cause more false positive failure detections. More details can be found in this file: [configuration_profile_codes.ts](./../../common/lib/profile/configuration_profile_codes.ts)
+
+Choosing the right configuration preset for your application can be a challenging task. Many presets could potentially fit the needs of your application. Various user application requirements and goals are presented in the following table and organized to help you identify the most suitable presets for your application.
+
+PDF version of the following table can be found [here](./../files/configuration-profile-presets.pdf).
+
+<div style="text-align:center"><img src="../images/configuration-presets.png" /></div>
diff --git a/docs/using-the-nodejs-wrapper/DatabaseDialects.md b/docs/using-the-nodejs-wrapper/DatabaseDialects.md
index 3b87a867..683e8369 100644
--- a/docs/using-the-nodejs-wrapper/DatabaseDialects.md
+++ b/docs/using-the-nodejs-wrapper/DatabaseDialects.md
@@ -33,7 +33,7 @@ Dialect codes specify what kind of database any connections will be made to.
 
 If you are interested in using the AWS Advanced NodeJS Wrapper but your desired database type is not currently supported, it is possible to create a custom dialect.
 
-To create a custom dialect, implement the [`Dialect`](../../common/lib/database_dialect/database_dialect.ts) interface. For databases clusters that are aware of their topology, the [`TopologyAwareDatabaseDialect`](../../common/lib/topology_aware_database_dialect.ts) interface should also be implemented. For database clusters that use an [Aurora Limitless Database](../../docs/using-the-nodejs-wrapper/using-plugins/UsingTheLimitlessConnectionPlugin.md#what-is-amazon-aurora-limitless-database) then [`LimitlessDatabaseDialect`](../../common/lib/database_dialect/limitless_database_dialect.ts) should be implemented.
+To create a custom dialect, implement the [`DatabaseDialect`](../../common/lib/database_dialect/database_dialect.ts) interface. For databases clusters that are aware of their topology, the [`TopologyAwareDatabaseDialect`](../../common/lib/topology_aware_database_dialect.ts) interface should also be implemented. For database clusters that use an [Aurora Limitless Database](../../docs/using-the-nodejs-wrapper/using-plugins/UsingTheLimitlessConnectionPlugin.md#what-is-amazon-aurora-limitless-database) then [`LimitlessDatabaseDialect`](../../common/lib/database_dialect/limitless_database_dialect.ts) should be implemented.
 
 See the following classes for examples:
 
@@ -46,9 +46,15 @@ See the following classes for examples:
 - [AuroraMySQLDatabaseDialect](../../mysql/lib/dialect/aurora_mysql_database_dialect.ts)
   - This dialect is an extension of MySQLDatabaseDialect, but also implements the `TopologyAwareDatabaseDialect` interface.
 
-Once the custom dialect class has been created, tell the AWS Advanced NodeJS Wrapper to use it with the `setCustomDialect` method in the `DialectManager` class. It is not necessary to set the `dialect` parameter. See below for an example:
+Once the custom dialect class has been created, tell the AWS Advanced NodeJS Wrapper to use it by setting the `customDatabaseDialect` parameter. It is not necessary to set the `dialect` parameter in this case. See below for an example:
 
 ```typescript
 myDialect: DatabaseDialect = new CustomDialect();
-DialectManager.setCustomDialect(myDialect);
+
+const client = new AwsPGClient({
+  ...
+  customDatabaseDialect: myDialect
+  ...
+});
+
 ```
diff --git a/docs/using-the-nodejs-wrapper/UsingTheNodejsWrapper.md b/docs/using-the-nodejs-wrapper/UsingTheNodejsWrapper.md
index 607fa2e8..452d4cff 100644
--- a/docs/using-the-nodejs-wrapper/UsingTheNodejsWrapper.md
+++ b/docs/using-the-nodejs-wrapper/UsingTheNodejsWrapper.md
@@ -40,20 +40,24 @@ To enable logging when using the AWS Advanced NodeJS Wrapper, use the `LOG_LEVEL
 
 These parameters are applicable to any instance of the AWS Advanced NodeJS Wrapper.
 
-| Parameter                      | Value              | Required                                                                         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Default Value                                                                                                                                                                | Version Supported |
-| ------------------------------ | ------------------ | -------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- |
-| `host`                         | `string`           | No                                                                               | Database host.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `null`                                                                                                                                                                       | `latest`          |
-| `database`                     | `string`           | No                                                                               | Database name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `null`                                                                                                                                                                       | `latest`          |
-| `user`                         | `string`           | No                                                                               | Database username.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `null`                                                                                                                                                                       | `latest`          |
-| `password`                     | `string`           | No                                                                               | Database password.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `null`                                                                                                                                                                       | `latest`          |
-| `transferSessionStateOnSwitch` | `boolean`          | No                                                                               | Enables transferring the session state to a new connection.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `true`                                                                                                                                                                       | `latest`          |
-| `resetSessionStateOnClose`     | `boolean`          | No                                                                               | Enables resetting the session state before closing connection.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `true`                                                                                                                                                                       | `latest`          |
-| `enableGreenHostReplacement`   | `boolean`          | No                                                                               | Enables replacing a green node host name with the original host name when the green host DNS doesn't exist anymore after a blue/green switchover. Refer to [Overview of Amazon RDS Blue/Green Deployments](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments-overview.html) for more details about green and blue nodes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `false`                                                                                                                                                                      | `latest`          |
-| `clusterInstanceHostPattern`   | `string`           | If connecting using an IP address or custom domain URL: Yes<br><br>Otherwise: No | This parameter is not required unless connecting to an AWS RDS cluster via an IP address or custom domain URL. In those cases, this parameter specifies the cluster instance DNS pattern that will be used to build a complete instance endpoint. A "?" character in this pattern should be used as a placeholder for the DB instance identifiers of the instances in the cluster. See [here](#host-pattern) for more information. <br/><br/>Example: `?.my-domain.com`, `any-subdomain.?.my-domain.com`<br/><br/>Use case Example: If your cluster instance endpoints follow this pattern:`instanceIdentifier1.customHost`, `instanceIdentifier2.customHost`, etc. and you want your initial connection to be to `customHost:1234`, then your client configuration should look like this: `{ host: "customHost", port: 1234, database: "test", clusterInstanceHostPattern: "?.customHost" }` | If the provided host is not an IP address or custom domain, the NodeJS Wrapper will automatically acquire the cluster instance host pattern from the customer-provided host. | `latest`          |
-| ~~`mysqlQueryTimeout`~~        | `number`           | No                                                                               | This parameter has been deprecated since version 1.1.0, applications should use the `wrapperQueryTimeout` parameter instead. <br/><br/> Query timeout in milliseconds. This is only applicable when using the AwsMySQLClient. To set query timeout for the AwsPGClient, please use the built-in `query_timeout` parameter. See the `node-postgres` [documentation](https://node-postgres.com/apis/client) for more details.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 20000                                                                                                                                                                        | `1.0.0`           |
-| `wrapperConnectTimeout`        | `number`           | No                                                                               | Connect timeout in milliseconds. This parameter will apply the provided timeout value to the underlying driver's built-in connect timeout parameter, if there is one available.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 20000                                                                                                                                                                        | `latest`          |
-| `wrapperQueryTimeout`          | `number`           | No                                                                               | Query timeout in milliseconds. This parameter will apply the provided timeout value to the underlying driver's built-in query timeout parameter, if there is one available. The wrapper will also use this value for its own query timeout implementation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 20000                                                                                                                                                                        | `latest`          |
-| `wrapperKeepAliveProperties`   | `Map<string, any>` | No                                                                               | If the underlying target driver has keepAlive properties available, properties within this map will be applied to the underlying target driver's client configuration. For example, the node-postgres driver's `keepAlive` and `keepAliveInitialDelayMillis` properties can be configured by setting this property in the client configuration: `{ wrapperKeepAliveProperties: new Map<string, any>([["keepAlive", true], ["keepAliveInitialDelayMillis", 1234]]) }`. <br/><br/> Currently supported drivers: node-postgres                                                                                                                                                                                                                                                                                                                                                                   | `null`                                                                                                                                                                       |
+| Parameter                            | Value              | Required                                                                         | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Default Value                                                                                                                                                                | Version Supported |
+| ------------------------------------ | ------------------ | -------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- |
+| `host`                               | `string`           | No                                                                               | Database host.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `null`                                                                                                                                                                       | `latest`          |
+| `database`                           | `string`           | No                                                                               | Database name.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `null`                                                                                                                                                                       | `latest`          |
+| `user`                               | `string`           | No                                                                               | Database username.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `null`                                                                                                                                                                       | `latest`          |
+| `password`                           | `string`           | No                                                                               | Database password.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `null`                                                                                                                                                                       | `latest`          |
+| `transferSessionStateOnSwitch`       | `boolean`          | No                                                                               | Enables transferring the session state to a new connection.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `true`                                                                                                                                                                       | `latest`          |
+| `resetSessionStateOnClose`           | `boolean`          | No                                                                               | Enables resetting the session state before closing connection.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | `true`                                                                                                                                                                       | `latest`          |
+| `enableGreenHostReplacement`         | `boolean`          | No                                                                               | Enables replacing a green node host name with the original host name when the green host DNS doesn't exist anymore after a blue/green switchover. Refer to [Overview of Amazon RDS Blue/Green Deployments](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/blue-green-deployments-overview.html) for more details about green and blue nodes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `false`                                                                                                                                                                      | `latest`          |
+| `clusterInstanceHostPattern`         | `string`           | If connecting using an IP address or custom domain URL: Yes<br><br>Otherwise: No | This parameter is not required unless connecting to an AWS RDS cluster via an IP address or custom domain URL. In those cases, this parameter specifies the cluster instance DNS pattern that will be used to build a complete instance endpoint. A "?" character in this pattern should be used as a placeholder for the DB instance identifiers of the instances in the cluster. See [here](#host-pattern) for more information. <br/><br/>Example: `?.my-domain.com`, `any-subdomain.?.my-domain.com`<br/><br/>Use case Example: If your cluster instance endpoints follow this pattern:`instanceIdentifier1.customHost`, `instanceIdentifier2.customHost`, etc. and you want your initial connection to be to `customHost:1234`, then your client configuration should look like this: `{ host: "customHost", port: 1234, database: "test", clusterInstanceHostPattern: "?.customHost" }` | If the provided host is not an IP address or custom domain, the NodeJS Wrapper will automatically acquire the cluster instance host pattern from the customer-provided host. | `latest`          |
+| ~~`mysqlQueryTimeout`~~              | `number`           | No                                                                               | This parameter has been deprecated since version 1.1.0, applications should use the `wrapperQueryTimeout` parameter instead. <br/><br/> Query timeout in milliseconds. This is only applicable when using the AwsMySQLClient. To set query timeout for the AwsPGClient, please use the built-in `query_timeout` parameter. See the `node-postgres` [documentation](https://node-postgres.com/apis/client) for more details.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 20000                                                                                                                                                                        | `1.0.0`           |
+| `wrapperConnectTimeout`              | `number`           | No                                                                               | Connect timeout in milliseconds. This parameter will apply the provided timeout value to the underlying driver's built-in connect timeout parameter, if there is one available.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 20000                                                                                                                                                                        | `latest`          |
+| `wrapperQueryTimeout`                | `number`           | No                                                                               | Query timeout in milliseconds. This parameter will apply the provided timeout value to the underlying driver's built-in query timeout parameter, if there is one available. The wrapper will also use this value for its own query timeout implementation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 20000                                                                                                                                                                        | `latest`          |
+| `wrapperKeepAliveProperties`         | `Map<string, any>` | No                                                                               | If the underlying target driver has keepAlive properties available, properties within this map will be applied to the underlying target driver's client configuration. For example, the node-postgres driver's `keepAlive` and `keepAliveInitialDelayMillis` properties can be configured by setting this property in the client configuration: `{ wrapperKeepAliveProperties: new Map<string, any>([["keepAlive", true], ["keepAliveInitialDelayMillis", 1234]]) }`. <br/><br/> Currently supported drivers: node-postgres                                                                                                                                                                                                                                                                                                                                                                   | `null`                                                                                                                                                                       |
+| `awsProfile`                         | `string`           | No                                                                               | Allows users to specify a profile name for AWS credentials. This parameter is used by plugins that require AWS credentials, like the [AWS IAM Authentication Plugin](./using-plugins/UsingTheIamAuthenticationPlugin.md) and the [AWS Secrets Manager Plugin](./using-plugins/UsingTheAwsSecretsManagerPlugin.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `null`                                                                                                                                                                       |
+| `connectionProvider`                 | `object`           | No                                                                               | Allows users to specify a connection provider used to create connections. Provided value should be an object that implements `ConnectionProvider` interface.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `null`                                                                                                                                                                       |
+| `customDatabaseDialect`              | `object`           | No                                                                               | Allows users to specify a custom database dialect. Provided value should be an object that implements `DatabaseDialect` interface.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | `null`                                                                                                                                                                       |
+| `customAwsCredentialProviderHandler` | `object`           | No                                                                               | Allows users to specify a custom AWS credentials provider. This parameter is used by plugins that require AWS credentials, like the [AWS IAM Authentication Plugin](./using-plugins/UsingTheIamAuthenticationPlugin.md) and the [AWS Secrets Manager Plugin](./using-plugins/UsingTheAwsSecretsManagerPlugin.md). For more information see [AWS Credentials Provider Configuration](./custom-configuration/AwsCredentialsConfiguration.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                   | `null`                                                                                                                                                                       |
 
 ## Host Pattern
 
@@ -72,10 +76,11 @@ Plugins are loaded and managed through the Connection Plugin Manager and may be
 
 ### Connection Plugin Manager Parameters
 
-| Parameter                    | Value     | Required | Description                                                                                                                                                     | Default Value                          |
-| ---------------------------- | --------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------- |
-| `plugins`                    | `String`  | No       | Comma separated list of connection plugin codes. <br><br>Example: `failover,efm`                                                                                | `auroraConnectionTracker,failover,efm` |
-| `autoSortWrapperPluginOrder` | `Boolean` | No       | Allows the AWS Advanced NodeJS Wrapper to sort connection plugins to prevent plugin misconfiguration. Allows a user to provide a custom plugin order if needed. | `true`                                 |
+| Parameter                    | Value     | Required | Description                                                                                                                                                                                   | Default Value                          |
+| ---------------------------- | --------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------- |
+| `plugins`                    | `String`  | No       | Comma separated list of connection plugin codes. <br><br>Example: `failover,efm`                                                                                                              | `auroraConnectionTracker,failover,efm` |
+| `autoSortWrapperPluginOrder` | `Boolean` | No       | Allows the AWS Advanced NodeJS Wrapper to sort connection plugins to prevent plugin misconfiguration. Allows a user to provide a custom plugin order if needed.                               | `true`                                 |
+| `profileName`                | `String`  | No       | Driver configuration profile name. Instead of listing plugin codes with `plugins`, the driver profile can be set with this parameter. <br><br> Example: See [below](#configuration-profiles). | `null`                                 |
 
 To use a built-in plugin, specify its relevant plugin code for the `plugins` .
 The default value for `plugins` is `failover`. These plugins are enabled by default. To read more about these plugins, see the [List of Available Plugins](#list-of-available-plugins) section.
@@ -130,3 +135,50 @@ The AWS Advanced NodeJS Wrapper has several built-in plugins that are available
 
 In addition to the built-in plugins, you can also create custom plugins more suitable for your needs.
 For more information, see [Custom Plugins](../development-guide/LoadablePlugins.md#using-custom-plugins).
+
+### Configuration Profiles
+
+An alternative way of loading plugins and providing configuration parameters is to use a configuration profile. You can create custom configuration profiles that specify which plugins the AWS Advanced NodeJS Wrapper should load. After creating the profile, set the [`profileName`](#connection-plugin-manager-parameters) parameter to the name of the created profile.
+This method of loading plugins will most often be used by those who require custom plugins that cannot be loaded with the [`plugins`](#connection-plugin-manager-parameters) parameter, or by those who are using preset configurations.
+
+Besides a list of plugins to load and configuration properties, configuration profiles may also include the following items:
+
+- [Database Dialect](./DatabaseDialects.md#database-dialects)
+- [Driver Dialect](../../common/lib/driver_dialect/driver_dialect.ts)
+- a custom exception handler
+- a custom connection provider
+
+The following example creates and sets a configuration profile:
+
+```typescript
+// Create a new configuration profile with name "testProfile"
+ConfigurationProfileBuilder.get()
+  .withName("testProfile")
+  .withPluginsFactories([FailoverPluginFactory, HostMonitoringPluginFactory, CustomConnectionPluginFactory])
+  .buildAndSet();
+
+// Use the configuration profile "testProfile"
+const client = new AwsMySQLClient({
+  user: "user",
+  password: "password",
+  host: "host",
+  database: "database",
+  profileName: "testProfile"
+});
+```
+
+Configuration profiles can be created based on other existing configuration profiles. Profile names are case sensitive and should be unique.
+
+```typescript
+// Create a new configuration profile with name "newProfile" based on "existingProfileName"
+ConfigurationProfileBuilder.get()
+  .from("existingProfileName")
+  .withName("newProfileName")
+  .withDatabaseDialect(new CustomDatabaseDialect())
+  .buildAndSet();
+
+// Delete configuration profile "testProfile"
+DriverConfigurationProfiles.remove("testProfile");
+```
+
+The AWS Advanced NodeJS Wrapper team has gathered and analyzed various user scenarios to create commonly used configuration profiles, or presets, for users. These preset configuration profiles are optimized, profiled, verified and can be used right away. Users can create their own configuration profiles based on the built-in presets as shown above. More details could be found at the [Configuration Presets](./ConfigurationPresets.md) page.
diff --git a/docs/using-the-nodejs-wrapper/custom-configuration/AwsCredentialsConfiguration.md b/docs/using-the-nodejs-wrapper/custom-configuration/AwsCredentialsConfiguration.md
new file mode 100644
index 00000000..e6d2eec3
--- /dev/null
+++ b/docs/using-the-nodejs-wrapper/custom-configuration/AwsCredentialsConfiguration.md
@@ -0,0 +1,27 @@
+# AWS Credentials Provider Configuration
+
+### Applicable plugins: AWS IAM Authentication Plugin, AWS Secrets Manager Plugin
+
+The [AWS IAM Authentication Plugin](../using-plugins/UsingTheIamAuthenticationPlugin.md) and [AWS Secrets Manager Plugin](../using-plugins/UsingTheAwsSecretsManagerPlugin.md) both require authentication via AWS credentials to provide the functionality they offer. In the plugin logic, the mechanism to locate your credentials is defined by passing in an `AwsCredentialsProvider` object to the applicable AWS SDK client. By default, an instance of `DefaultCredentialsProvider` will be passed, which locates your credentials using the default credential provider chain described [in this doc](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/). If AWS credentials are provided by the `credentials` and `config` files ([Default credentials provider chain](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/#fromini)), then it's possible to specify a profile name using the `awsProfile` configuration parameter. If no profile name is specified, a `[default]` profile is used.
+
+If you would like to define your own mechanism for providing AWS credentials, you can do so using `customAwsCredentialProviderHandler` parameter for a new connection and passing an object that implements `AwsCredentialsProviderHandler`. See below for an example:
+
+```typescript
+import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
+
+class MyCustomAwsCredentialProvider implements AwsCredentialsProviderHandler {
+  getAwsCredentialsProvider(hostInfo: HostInfo, properties: Map<string, any>): AwsCredentialIdentityProvider {
+    // Initialize AWS Credential Provider here and return it.
+    // The following code is just an example.
+    return fromNodeProviderChain();
+  }
+}
+myProvider: MyCustomAwsCredentialProvider = new MyCustomAwsCredentialProvider();
+
+const client = new AwsPGClient({
+  ...
+  customAwsCredentialProviderHandler: myProvider
+  ...
+});
+
+```
diff --git a/docs/using-the-nodejs-wrapper/using-plugins/UsingTheAwsSecretsManagerPlugin.md b/docs/using-the-nodejs-wrapper/using-plugins/UsingTheAwsSecretsManagerPlugin.md
index 76fb0466..f4753345 100644
--- a/docs/using-the-nodejs-wrapper/using-plugins/UsingTheAwsSecretsManagerPlugin.md
+++ b/docs/using-the-nodejs-wrapper/using-plugins/UsingTheAwsSecretsManagerPlugin.md
@@ -11,7 +11,7 @@ The AWS Advanced NodeJS Wrapper supports usage of database credentials stored as
 
 To enable the AWS Secrets Manager Connection Plugin, add the plugin code `secretsManager` to the [`plugins`](../UsingTheNodejsWrapper.md#connection-plugin-manager-parameters) connection parameter.
 
-This plugin requires a valid set of AWS credentials to retrieve the database credentials from AWS Secrets Manager. The AWS credentials must be located in [one of these locations](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/#fromNodeProviderChain) supported by the AWS SDK's default credentials provider.
+This plugin requires a valid set of AWS credentials to retrieve the database credentials from AWS Secrets Manager. The AWS credentials must be located in [one of these locations](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/#fromNodeProviderChain) supported by the AWS SDK's default credentials provider. See also at [AWS Credentials Configuration](../custom-configuration/AwsCredentialsConfiguration.md)
 
 ## AWS Secrets Manager Connection Plugin Parameters
 
diff --git a/docs/using-the-nodejs-wrapper/using-plugins/UsingTheIamAuthenticationPlugin.md b/docs/using-the-nodejs-wrapper/using-plugins/UsingTheIamAuthenticationPlugin.md
index 979c41c5..da8b2057 100644
--- a/docs/using-the-nodejs-wrapper/using-plugins/UsingTheIamAuthenticationPlugin.md
+++ b/docs/using-the-nodejs-wrapper/using-plugins/UsingTheIamAuthenticationPlugin.md
@@ -36,6 +36,8 @@ The AWS Advanced NodeJS Wrapper supports Amazon AWS Identity and Access Manageme
 | `iamRegion`          | `String` |                    No                     | This property will override the default region that is used to generate the IAM token. If the property is not set, the wrapper will attempt to parse the region from the host provided in the configuration parameters.                    | `null`                                           | `us-east-2`                                         |
 | `iamTokenExpiration` | `Number` |                    No                     | This property determines how long an IAM token is kept in the driver cache before a new one is generated. The default expiration time is set to be 15 minutes. Note that IAM database authentication tokens have a lifetime of 15 minutes. | `900`                                            | `600`                                               |
 
+This plugin requires a valid set of AWS credentials to retrieve the database credentials from AWS Secrets Manager. The AWS credentials must be located in [one of these locations](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-credential-providers/#fromNodeProviderChain) supported by the AWS SDK's default credentials provider. See also at [AWS Credentials Configuration](../custom-configuration/AwsCredentialsConfiguration.md)
+
 ## Using the IAM Authentication Plugin with Custom Endpoints
 
 When using AWS IAM database authentication with a custom domain or an IP address, in addition to the `clusterInstanceHostPattern` variable, the `iamHost` must be specified and must point to a valid Amazon endpoint, i.e. `db-identifier.cluster-XYZ.us-east-2.rds.amazonaws.com`.
diff --git a/mysql/lib/dialect/mysql2_driver_dialect.ts b/mysql/lib/dialect/mysql2_driver_dialect.ts
index 302094f6..7ba6323a 100644
--- a/mysql/lib/dialect/mysql2_driver_dialect.ts
+++ b/mysql/lib/dialect/mysql2_driver_dialect.ts
@@ -26,9 +26,10 @@ import { HostInfo } from "../../../common/lib/host_info";
 import { UnsupportedMethodError } from "../../../common/lib/utils/errors";
 
 export class MySQL2DriverDialect implements DriverDialect {
-  static readonly connectTimeoutPropertyName = "connectTimeout";
-  static readonly queryTimeoutPropertyName = "timeout";
   protected dialectName: string = this.constructor.name;
+  private static readonly CONNECT_TIMEOUT_PROPERTY_NAME = "connectTimeout";
+  private static readonly QUERY_TIMEOUT_PROPERTY_NAME = "timeout";
+  private static readonly KEEP_ALIVE_PROPERTY_NAME = "keepAlive";
 
   getDialectName(): string {
     return this.dialectName;
@@ -36,10 +37,10 @@ export class MySQL2DriverDialect implements DriverDialect {
 
   async connect(hostInfo: HostInfo, props: Map<string, any>): Promise<ClientWrapper> {
     const driverProperties = WrapperProperties.removeWrapperProperties(props);
-    // MySQL2 does not support keep alive, explicitly check and throw an exception if this value is set.
+    // MySQL2 does not support keep alive, explicitly check and throw an exception if this value is set to true.
     this.setKeepAliveProperties(driverProperties, props.get(WrapperProperties.KEEPALIVE_PROPERTIES.name));
     this.setConnectTimeout(driverProperties, props.get(WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name));
-    const targetClient = await createConnection(driverProperties);
+    const targetClient = await createConnection(Object.fromEntries(driverProperties.entries()));
     return Promise.resolve(new MySQLClientWrapper(targetClient, hostInfo, props, this));
   }
 
@@ -63,19 +64,19 @@ export class MySQL2DriverDialect implements DriverDialect {
   setConnectTimeout(props: Map<string, any>, wrapperConnectTimeout?: any) {
     const timeout = wrapperConnectTimeout ?? props.get(WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name);
     if (timeout) {
-      props.set(MySQL2DriverDialect.connectTimeoutPropertyName, timeout);
+      props.set(MySQL2DriverDialect.CONNECT_TIMEOUT_PROPERTY_NAME, timeout);
     }
   }
 
   setQueryTimeout(props: Map<string, any>, sql?: any, wrapperConnectTimeout?: any) {
     const timeout = wrapperConnectTimeout ?? props.get(WrapperProperties.WRAPPER_QUERY_TIMEOUT.name);
-    if (timeout && !sql[MySQL2DriverDialect.queryTimeoutPropertyName]) {
-      sql[MySQL2DriverDialect.queryTimeoutPropertyName] = timeout;
+    if (timeout && !sql[MySQL2DriverDialect.QUERY_TIMEOUT_PROPERTY_NAME]) {
+      sql[MySQL2DriverDialect.QUERY_TIMEOUT_PROPERTY_NAME] = timeout;
     }
   }
 
   setKeepAliveProperties(props: Map<string, any>, keepAliveProps: any) {
-    if (keepAliveProps) {
+    if (keepAliveProps && keepAliveProps.get(MySQL2DriverDialect.KEEP_ALIVE_PROPERTY_NAME)) {
       throw new UnsupportedMethodError("Keep alive configuration is not supported for MySQL2.");
     }
   }
diff --git a/pg/lib/dialect/node_postgres_driver_dialect.ts b/pg/lib/dialect/node_postgres_driver_dialect.ts
index 6f10f1e5..15656d75 100644
--- a/pg/lib/dialect/node_postgres_driver_dialect.ts
+++ b/pg/lib/dialect/node_postgres_driver_dialect.ts
@@ -27,11 +27,11 @@ import { PgClientWrapper } from "../../../common/lib/pg_client_wrapper";
 import { HostInfo } from "../../../common/lib/host_info";
 
 export class NodePostgresDriverDialect implements DriverDialect {
-  static readonly connectTimeoutPropertyName = "connectionTimeoutMillis";
-  static readonly queryTimeoutPropertyName = "query_timeout";
   protected dialectName: string = this.constructor.name;
-  private static keepAlivePropertyName = "keepAlive";
-  private static keepAliveInitialDelayMillisPropertyName = "keepAliveInitialDelayMillis";
+  private static readonly CONNECT_TIMEOUT_PROPERTY_NAME = "connectionTimeoutMillis";
+  private static readonly QUERY_TIMEOUT_PROPERTY_NAME = "query_timeout";
+  private static readonly KEEP_ALIVE_PROPERTY_NAME = "keepAlive";
+  private static readonly KEEP_ALIVE_INITIAL_DELAY_MILLIS_PROPERTY_NAME = "keepAliveInitialDelayMillis";
 
   getDialectName(): string {
     return this.dialectName;
@@ -42,7 +42,7 @@ export class NodePostgresDriverDialect implements DriverDialect {
     this.setKeepAliveProperties(driverProperties, props.get(WrapperProperties.KEEPALIVE_PROPERTIES.name));
     this.setConnectTimeout(driverProperties, props.get(WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name));
     this.setQueryTimeout(driverProperties, props.get(WrapperProperties.WRAPPER_QUERY_TIMEOUT.name));
-    const targetClient = new pkgPg.Client(driverProperties);
+    const targetClient = new pkgPg.Client(Object.fromEntries(driverProperties.entries()));
     await targetClient.connect();
     return Promise.resolve(new PgClientWrapper(targetClient, hostInfo, props));
   }
@@ -67,14 +67,14 @@ export class NodePostgresDriverDialect implements DriverDialect {
   setConnectTimeout(props: Map<string, any>, wrapperConnectTimeout?: any) {
     const timeout = wrapperConnectTimeout ?? props.get(WrapperProperties.WRAPPER_CONNECT_TIMEOUT.name);
     if (timeout) {
-      props.set(NodePostgresDriverDialect.connectTimeoutPropertyName, timeout);
+      props.set(NodePostgresDriverDialect.CONNECT_TIMEOUT_PROPERTY_NAME, timeout);
     }
   }
 
   setQueryTimeout(props: Map<string, any>, sql?: any, wrapperQueryTimeout?: any) {
     const timeout = wrapperQueryTimeout ?? props.get(WrapperProperties.WRAPPER_QUERY_TIMEOUT.name);
     if (timeout) {
-      props.set(NodePostgresDriverDialect.queryTimeoutPropertyName, timeout);
+      props.set(NodePostgresDriverDialect.QUERY_TIMEOUT_PROPERTY_NAME, timeout);
     }
   }
 
@@ -83,14 +83,14 @@ export class NodePostgresDriverDialect implements DriverDialect {
       return;
     }
 
-    const keepAlive = keepAliveProps.get(NodePostgresDriverDialect.keepAlivePropertyName);
-    const keepAliveInitialDelayMillis = keepAliveProps.get(NodePostgresDriverDialect.keepAliveInitialDelayMillisPropertyName);
+    const keepAlive = keepAliveProps.get(NodePostgresDriverDialect.KEEP_ALIVE_PROPERTY_NAME);
+    const keepAliveInitialDelayMillis = keepAliveProps.get(NodePostgresDriverDialect.KEEP_ALIVE_INITIAL_DELAY_MILLIS_PROPERTY_NAME);
 
     if (keepAlive) {
-      props.set(NodePostgresDriverDialect.keepAlivePropertyName, keepAlive);
+      props.set(NodePostgresDriverDialect.KEEP_ALIVE_PROPERTY_NAME, keepAlive);
     }
     if (keepAliveInitialDelayMillis) {
-      props.set(NodePostgresDriverDialect.keepAliveInitialDelayMillisPropertyName, keepAliveInitialDelayMillis);
+      props.set(NodePostgresDriverDialect.KEEP_ALIVE_INITIAL_DELAY_MILLIS_PROPERTY_NAME, keepAliveInitialDelayMillis);
     }
   }
 }
diff --git a/tests/integration/container/tests/iam_authentication.test.ts b/tests/integration/container/tests/iam_authentication.test.ts
index 94540e95..62d57cf5 100644
--- a/tests/integration/container/tests/iam_authentication.test.ts
+++ b/tests/integration/container/tests/iam_authentication.test.ts
@@ -27,6 +27,7 @@ import { logger } from "../../../../common/logutils";
 import { TestEnvironmentFeatures } from "./utils/test_environment_features";
 import { features } from "./config";
 import { PluginManager } from "../../../../common/lib";
+import { jest } from "@jest/globals";
 
 const itIf =
   !features.includes(TestEnvironmentFeatures.PERFORMANCE) &&
@@ -83,6 +84,7 @@ async function validateConnection(client: AwsPGClient | AwsMySQLClient) {
 describe("iam authentication", () => {
   beforeEach(async () => {
     logger.info(`Test started: ${expect.getState().currentTestName}`);
+    jest.useFakeTimers();
     env = await TestEnvironment.getCurrent();
     driver = DriverHelper.getDriverForDatabaseEngine(env.engine);
     initClientFunc = DriverHelper.getClient(driver);
diff --git a/tests/unit/aws_client_get_plugin_instance.test.ts b/tests/unit/aws_client_get_plugin_instance.test.ts
index b8a32b86..fc7272b4 100644
--- a/tests/unit/aws_client_get_plugin_instance.test.ts
+++ b/tests/unit/aws_client_get_plugin_instance.test.ts
@@ -29,7 +29,7 @@ class DevPluginTest extends DeveloperConnectionPlugin {
 
 class TestClient extends AwsPGClient {
   setManager() {
-    this.pluginManager.init([plugin]);
+    this.pluginManager.init(null, [plugin]);
   }
 }
 
diff --git a/tests/unit/database_dialect.test.ts b/tests/unit/database_dialect.test.ts
index 4b631dc0..17084135 100644
--- a/tests/unit/database_dialect.test.ts
+++ b/tests/unit/database_dialect.test.ts
@@ -278,7 +278,8 @@ describe("test database dialects", () => {
       databaseType,
       expectedDialect!.dialects,
       props,
-      mockDriverDialect
+      mockDriverDialect,
+      null
     );
     await pluginService.updateDialect(mockClientWrapper);
     expect(pluginService.getDialect()).toBe(expectedDialectClass);