From 08092cdd6c2e8a443acf55e650ca0e8a185b02a9 Mon Sep 17 00:00:00 2001 From: Allen Firstenberg Date: Wed, 11 Sep 2024 01:22:33 -0400 Subject: [PATCH] google-common[major]: Media manager (#5835) --- libs/langchain-google-common/.gitignore | 8 + .../langchain.config.js | 2 + libs/langchain-google-common/package.json | 28 +- libs/langchain-google-common/src/auth.ts | 36 +- .../src/chat_models.ts | 87 +- .../langchain-google-common/src/connection.ts | 66 +- .../langchain-google-common/src/embeddings.ts | 7 +- .../src/experimental/media.ts | 803 +++++++++++ .../src/experimental/utils/media_core.ts | 669 +++++++++ libs/langchain-google-common/src/llms.ts | 26 +- .../src/tests/chat_models.test.ts | 207 ++- .../src/tests/utils.test.ts | 482 ++++++- libs/langchain-google-common/src/types.ts | 13 +- .../src/utils/gemini.ts | 1202 +++++++++-------- libs/langchain-google-gauth/src/index.ts | 2 + libs/langchain-google-gauth/src/media.ts | 31 + .../src/tests/chat_models.int.test.ts | 315 +++++ .../src/tests/data/blue-square.png | Bin 0 -> 176 bytes .../src/tests/media.int.test.ts | 137 ++ .../src/tests/chat_models.int.test.ts | 83 ++ libs/langchain-google-webauth/package.json | 3 +- libs/langchain-google-webauth/src/media.ts | 33 + .../src/tests/chat_models.int.test.ts | 247 ++++ .../src/tests/data/blue-square.png | Bin 0 -> 176 bytes .../src/tests/data/rainbow.mp4 | Bin 0 -> 1020253 bytes .../src/tests/media.int.test.ts | 201 +++ yarn.lock | 1 + 27 files changed, 3949 insertions(+), 740 deletions(-) create mode 100644 libs/langchain-google-common/src/experimental/media.ts create mode 100644 libs/langchain-google-common/src/experimental/utils/media_core.ts create mode 100644 libs/langchain-google-gauth/src/media.ts create mode 100644 libs/langchain-google-gauth/src/tests/chat_models.int.test.ts create mode 100644 libs/langchain-google-gauth/src/tests/data/blue-square.png create mode 100644 libs/langchain-google-gauth/src/tests/media.int.test.ts create mode 100644 libs/langchain-google-webauth/src/media.ts create mode 100644 libs/langchain-google-webauth/src/tests/chat_models.int.test.ts create mode 100644 libs/langchain-google-webauth/src/tests/data/blue-square.png create mode 100644 libs/langchain-google-webauth/src/tests/data/rainbow.mp4 create mode 100644 libs/langchain-google-webauth/src/tests/media.int.test.ts diff --git a/libs/langchain-google-common/.gitignore b/libs/langchain-google-common/.gitignore index df014a2d426b..c4537f159680 100644 --- a/libs/langchain-google-common/.gitignore +++ b/libs/langchain-google-common/.gitignore @@ -10,6 +10,14 @@ types.cjs types.js types.d.ts types.d.cts +experimental/media.cjs +experimental/media.js +experimental/media.d.ts +experimental/media.d.cts +experimental/utils/media_core.cjs +experimental/utils/media_core.js +experimental/utils/media_core.d.ts +experimental/utils/media_core.d.cts node_modules dist .yarn diff --git a/libs/langchain-google-common/langchain.config.js b/libs/langchain-google-common/langchain.config.js index df02f88bd793..458e4abdc1a4 100644 --- a/libs/langchain-google-common/langchain.config.js +++ b/libs/langchain-google-common/langchain.config.js @@ -16,6 +16,8 @@ export const config = { index: "index", utils: "utils/index", types: "types", + "experimental/media": "experimental/media", + "experimental/utils/media_core": "experimental/utils/media_core", }, tsConfigPath: resolve("./tsconfig.json"), cjsSource: "./dist-cjs", diff --git a/libs/langchain-google-common/package.json b/libs/langchain-google-common/package.json index 242093637b64..2bafc1cbcc5e 100644 --- a/libs/langchain-google-common/package.json +++ b/libs/langchain-google-common/package.json @@ -92,6 +92,24 @@ "import": "./types.js", "require": "./types.cjs" }, + "./experimental/media": { + "types": { + "import": "./experimental/media.d.ts", + "require": "./experimental/media.d.cts", + "default": "./experimental/media.d.ts" + }, + "import": "./experimental/media.js", + "require": "./experimental/media.cjs" + }, + "./experimental/utils/media_core": { + "types": { + "import": "./experimental/utils/media_core.d.ts", + "require": "./experimental/utils/media_core.d.cts", + "default": "./experimental/utils/media_core.d.ts" + }, + "import": "./experimental/utils/media_core.js", + "require": "./experimental/utils/media_core.cjs" + }, "./package.json": "./package.json" }, "files": [ @@ -107,6 +125,14 @@ "types.cjs", "types.js", "types.d.ts", - "types.d.cts" + "types.d.cts", + "experimental/media.cjs", + "experimental/media.js", + "experimental/media.d.ts", + "experimental/media.d.cts", + "experimental/utils/media_core.cjs", + "experimental/utils/media_core.js", + "experimental/utils/media_core.d.ts", + "experimental/utils/media_core.d.cts" ] } diff --git a/libs/langchain-google-common/src/auth.ts b/libs/langchain-google-common/src/auth.ts index 9e278a9605d2..60e0fab4f998 100644 --- a/libs/langchain-google-common/src/auth.ts +++ b/libs/langchain-google-common/src/auth.ts @@ -1,9 +1,9 @@ import { ReadableJsonStream } from "./utils/stream.js"; import { GooglePlatformType } from "./types.js"; -export type GoogleAbstractedClientOpsMethod = "GET" | "POST"; +export type GoogleAbstractedClientOpsMethod = "GET" | "POST" | "DELETE"; -export type GoogleAbstractedClientOpsResponseType = "json" | "stream"; +export type GoogleAbstractedClientOpsResponseType = "json" | "stream" | "blob"; export type GoogleAbstractedClientOps = { url?: string; @@ -28,6 +28,17 @@ export abstract class GoogleAbstractedFetchClient abstract request(opts: GoogleAbstractedClientOps): unknown; + async _buildData(res: Response, opts: GoogleAbstractedClientOps) { + switch (opts.responseType) { + case "json": + return res.json(); + case "stream": + return new ReadableJsonStream(res.body); + default: + return res.blob(); + } + } + async _request( url: string | undefined, opts: GoogleAbstractedClientOps, @@ -47,7 +58,11 @@ export abstract class GoogleAbstractedFetchClient }, }; if (opts.data !== undefined) { - fetchOptions.body = JSON.stringify(opts.data); + if (typeof opts.data === "string") { + fetchOptions.body = opts.data; + } else { + fetchOptions.body = JSON.stringify(opts.data); + } } const res = await fetch(url, fetchOptions); @@ -57,16 +72,21 @@ export abstract class GoogleAbstractedFetchClient const error = new Error( `Google request failed with status code ${res.status}: ${resText}` ); - // eslint-disable-next-line @typescript-eslint/no-explicit-any + /* eslint-disable @typescript-eslint/no-explicit-any */ (error as any).response = res; + (error as any).details = { + url, + opts, + fetchOptions, + result: res, + }; + /* eslint-enable @typescript-eslint/no-explicit-any */ throw error; } + const data = await this._buildData(res, opts); return { - data: - opts.responseType === "json" - ? await res.json() - : new ReadableJsonStream(res.body), + data, config: {}, status: res.status, statusText: res.statusText, diff --git a/libs/langchain-google-common/src/chat_models.ts b/libs/langchain-google-common/src/chat_models.ts index 2fa539657ec0..4ee4e0f6ed05 100644 --- a/libs/langchain-google-common/src/chat_models.ts +++ b/libs/langchain-google-common/src/chat_models.ts @@ -39,12 +39,7 @@ import { copyAndValidateModelParamsInto, } from "./utils/common.js"; import { AbstractGoogleLLMConnection } from "./connection.js"; -import { - baseMessageToContent, - safeResponseToChatGeneration, - safeResponseToChatResult, - DefaultGeminiSafetyHandler, -} from "./utils/gemini.js"; +import { DefaultGeminiSafetyHandler } from "./utils/gemini.js"; import { ApiKeyGoogleAuth, GoogleAbstractedClient } from "./auth.js"; import { JsonStream } from "./utils/stream.js"; import { ensureParams } from "./utils/failed_handler.js"; @@ -55,6 +50,7 @@ import type { GeminiFunctionDeclaration, GeminiFunctionSchema, GoogleAIToolType, + GeminiAPIConfig, } from "./types.js"; import { zodToGeminiParameters } from "./utils/zod_to_gemini_parameters.js"; @@ -100,61 +96,69 @@ class ChatConnection extends AbstractGoogleLLMConnection< return true; } - formatContents( + async formatContents( input: BaseMessage[], _parameters: GoogleAIModelParams - ): GeminiContent[] { - return input - .map((msg, i) => - baseMessageToContent(msg, input[i - 1], this.useSystemInstruction) + ): Promise { + const inputPromises: Promise[] = input.map((msg, i) => + this.api.baseMessageToContent( + msg, + input[i - 1], + this.useSystemInstruction ) - .reduce((acc, cur) => { - // Filter out the system content - if (cur.every((content) => content.role === "system")) { - return acc; - } - - // Combine adjacent function messages - if ( - cur[0]?.role === "function" && - acc.length > 0 && - acc[acc.length - 1].role === "function" - ) { - acc[acc.length - 1].parts = [ - ...acc[acc.length - 1].parts, - ...cur[0].parts, - ]; - } else { - acc.push(...cur); - } + ); + const inputs = await Promise.all(inputPromises); + return inputs.reduce((acc, cur) => { + // Filter out the system content + if (cur.every((content) => content.role === "system")) { return acc; - }, [] as GeminiContent[]); + } + + // Combine adjacent function messages + if ( + cur[0]?.role === "function" && + acc.length > 0 && + acc[acc.length - 1].role === "function" + ) { + acc[acc.length - 1].parts = [ + ...acc[acc.length - 1].parts, + ...cur[0].parts, + ]; + } else { + acc.push(...cur); + } + + return acc; + }, [] as GeminiContent[]); } - formatSystemInstruction( + async formatSystemInstruction( input: BaseMessage[], _parameters: GoogleAIModelParams - ): GeminiContent { + ): Promise { if (!this.useSystemInstruction) { return {} as GeminiContent; } let ret = {} as GeminiContent; - input.forEach((message, index) => { + for (let index = 0; index < input.length; index += 1) { + const message = input[index]; if (message._getType() === "system") { // For system types, we only want it if it is the first message, // if it appears anywhere else, it should be an error. if (index === 0) { // eslint-disable-next-line prefer-destructuring - ret = baseMessageToContent(message, undefined, true)[0]; + ret = ( + await this.api.baseMessageToContent(message, undefined, true) + )[0]; } else { throw new Error( "System messages are only permitted as the first passed message." ); } } - }); + } return ret; } @@ -168,6 +172,7 @@ export interface ChatGoogleBaseInput GoogleConnectionParams, GoogleAIModelParams, GoogleAISafetyParams, + GeminiAPIConfig, Pick {} /** @@ -338,7 +343,10 @@ export abstract class ChatGoogleBase parameters, options ); - const ret = safeResponseToChatResult(response, this.safetyHandler); + const ret = this.connection.api.safeResponseToChatResult( + response, + this.safetyHandler + ); await runManager?.handleLLMNewToken(ret.generations[0].text); return ret; } @@ -378,7 +386,10 @@ export abstract class ChatGoogleBase } const chunk = output !== null - ? safeResponseToChatGeneration({ data: output }, this.safetyHandler) + ? this.connection.api.safeResponseToChatGeneration( + { data: output }, + this.safetyHandler + ) : new ChatGenerationChunk({ text: "", generationInfo: { finishReason: "stop" }, diff --git a/libs/langchain-google-common/src/connection.ts b/libs/langchain-google-common/src/connection.ts index 4a90e9f795af..7e7da9daa304 100644 --- a/libs/langchain-google-common/src/connection.ts +++ b/libs/langchain-google-common/src/connection.ts @@ -20,6 +20,7 @@ import type { GeminiTool, GeminiFunctionDeclaration, GoogleAIModelRequestParams, + GoogleRawResponse, GoogleAIToolType, } from "./types.js"; import { @@ -28,6 +29,7 @@ import { GoogleAbstractedClientOpsMethod, } from "./auth.js"; import { zodToGeminiParameters } from "./utils/zod_to_gemini_parameters.js"; +import { getGeminiAPI } from "./utils/index.js"; export abstract class GoogleConnection< CallOptions extends AsyncCallerCallOptions, @@ -84,15 +86,23 @@ export abstract class GoogleConnection< return this.constructor.name; } - async _request( + async additionalHeaders(): Promise> { + return {}; + } + + async _buildOpts( data: unknown | undefined, - options: CallOptions - ): Promise { + _options: CallOptions, + requestHeaders: Record = {} + ): Promise { const url = await this.buildUrl(); const method = this.buildMethod(); const infoHeaders = (await this._clientInfoHeaders()) ?? {}; + const additionalHeaders = (await this.additionalHeaders()) ?? {}; const headers = { ...infoHeaders, + ...additionalHeaders, + ...requestHeaders, }; const opts: GoogleAbstractedClientOps = { @@ -108,7 +118,15 @@ export abstract class GoogleConnection< } else { opts.responseType = "json"; } + return opts; + } + async _request( + data: unknown | undefined, + options: CallOptions, + requestHeaders: Record = {} + ): Promise { + const opts = await this._buildOpts(data, options, requestHeaders); const callResponse = await this.caller.callWithOptions( { signal: options?.signal }, async () => this.client.request(opts) @@ -165,6 +183,21 @@ export abstract class GoogleHostConnection< } } +export abstract class GoogleRawConnection< + CallOptions extends AsyncCallerCallOptions, + AuthOptions +> extends GoogleHostConnection { + async _buildOpts( + data: unknown | undefined, + _options: CallOptions, + requestHeaders: Record = {} + ): Promise { + const opts = await super._buildOpts(data, _options, requestHeaders); + opts.responseType = "blob"; + return opts; + } +} + export abstract class GoogleAIConnection< CallOptions extends AsyncCallerCallOptions, InputType, @@ -180,6 +213,9 @@ export abstract class GoogleAIConnection< client: GoogleAbstractedClient; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + api: any; // FIXME: Make this a real type + constructor( fields: GoogleAIBaseLLMInput | undefined, caller: AsyncCaller, @@ -190,6 +226,7 @@ export abstract class GoogleAIConnection< this.client = client; this.modelName = fields?.model ?? fields?.modelName ?? this.model; this.model = this.modelName; + this.api = getGeminiAPI(fields); } get modelFamily(): GoogleLLMModelFamily { @@ -235,14 +272,14 @@ export abstract class GoogleAIConnection< abstract formatData( input: InputType, parameters: GoogleAIModelRequestParams - ): unknown; + ): Promise; async request( input: InputType, parameters: GoogleAIModelRequestParams, options: CallOptions - ): Promise { - const data = this.formatData(input, parameters); + ): Promise { + const data = await this.formatData(input, parameters); const response = await this._request(data, options); return response; } @@ -273,7 +310,7 @@ export abstract class AbstractGoogleLLMConnection< abstract formatContents( input: MessageType, parameters: GoogleAIModelRequestParams - ): GeminiContent[]; + ): Promise; formatGenerationConfig( _input: MessageType, @@ -296,10 +333,10 @@ export abstract class AbstractGoogleLLMConnection< return parameters.safetySettings ?? []; } - formatSystemInstruction( + async formatSystemInstruction( _input: MessageType, _parameters: GoogleAIModelRequestParams - ): GeminiContent { + ): Promise { return {} as GeminiContent; } @@ -362,16 +399,19 @@ export abstract class AbstractGoogleLLMConnection< }; } - formatData( + async formatData( input: MessageType, parameters: GoogleAIModelRequestParams - ): GeminiRequest { - const contents = this.formatContents(input, parameters); + ): Promise { + const contents = await this.formatContents(input, parameters); const generationConfig = this.formatGenerationConfig(input, parameters); const tools = this.formatTools(input, parameters); const toolConfig = this.formatToolConfig(parameters); const safetySettings = this.formatSafetySettings(input, parameters); - const systemInstruction = this.formatSystemInstruction(input, parameters); + const systemInstruction = await this.formatSystemInstruction( + input, + parameters + ); const ret: GeminiRequest = { contents, diff --git a/libs/langchain-google-common/src/embeddings.ts b/libs/langchain-google-common/src/embeddings.ts index 4bf568959efe..d1e2549c631a 100644 --- a/libs/langchain-google-common/src/embeddings.ts +++ b/libs/langchain-google-common/src/embeddings.ts @@ -38,10 +38,10 @@ class EmbeddingsConnection< return "predict"; } - formatData( + async formatData( input: GoogleEmbeddingsInstance[], parameters: GoogleAIModelRequestParams - ): unknown { + ): Promise { return { instances: input, parameters, @@ -172,7 +172,8 @@ export abstract class BaseGoogleEmbeddings ?.map( (response) => response?.data?.predictions?.map( - (result) => result.embeddings.values + // eslint-disable-next-line @typescript-eslint/no-explicit-any + (result: any) => result.embeddings?.values ) ?? [] ) .flat() ?? []; diff --git a/libs/langchain-google-common/src/experimental/media.ts b/libs/langchain-google-common/src/experimental/media.ts new file mode 100644 index 000000000000..89646482ca70 --- /dev/null +++ b/libs/langchain-google-common/src/experimental/media.ts @@ -0,0 +1,803 @@ +import { + AsyncCaller, + AsyncCallerCallOptions, + AsyncCallerParams, +} from "@langchain/core/utils/async_caller"; +import { getEnvironmentVariable } from "@langchain/core/utils/env"; +import { + MediaBlob, + BlobStore, + BlobStoreOptions, + MediaBlobData, +} from "./utils/media_core.js"; +import { + GoogleConnectionParams, + GoogleRawResponse, + GoogleResponse, +} from "../types.js"; +import { GoogleHostConnection, GoogleRawConnection } from "../connection.js"; +import { + ApiKeyGoogleAuth, + GoogleAbstractedClient, + GoogleAbstractedClientOpsMethod, +} from "../auth.js"; + +export interface GoogleUploadConnectionParams + extends GoogleConnectionParams {} + +export abstract class GoogleMultipartUploadConnection< + CallOptions extends AsyncCallerCallOptions, + ResponseType extends GoogleResponse, + AuthOptions +> extends GoogleHostConnection { + constructor( + fields: GoogleConnectionParams | undefined, + caller: AsyncCaller, + client: GoogleAbstractedClient + ) { + super(fields, caller, client); + } + + async _body( + separator: string, + data: MediaBlob, + metadata: Record + ): Promise { + const contentType = data.mimetype; + const { encoded, encoding } = await data.encode(); + const body = [ + `--${separator}`, + "Content-Type: application/json; charset=UTF-8", + "", + JSON.stringify(metadata), + "", + `--${separator}`, + `Content-Type: ${contentType}`, + `Content-Transfer-Encoding: ${encoding}`, + "", + encoded, + `--${separator}--`, + ]; + return body.join("\n"); + } + + async request( + data: MediaBlob, + metadata: Record, + options: CallOptions + ): Promise { + const separator = `separator-${Date.now()}`; + const body = await this._body(separator, data, metadata); + const requestHeaders = { + "Content-Type": `multipart/related; boundary=${separator}`, + "X-Goog-Upload-Protocol": "multipart", + }; + const response = this._request(body, options, requestHeaders); + return response; + } +} + +export abstract class GoogleDownloadConnection< + CallOptions extends AsyncCallerCallOptions, + ResponseType extends GoogleResponse, + AuthOptions +> extends GoogleHostConnection { + async request(options: CallOptions): Promise { + return this._request(undefined, options); + } +} + +export abstract class GoogleDownloadRawConnection< + CallOptions extends AsyncCallerCallOptions, + AuthOptions +> extends GoogleRawConnection { + buildMethod(): GoogleAbstractedClientOpsMethod { + return "GET"; + } + + async request(options: CallOptions): Promise { + return this._request(undefined, options); + } +} + +export interface BlobStoreGoogleParams + extends GoogleConnectionParams, + AsyncCallerParams, + BlobStoreOptions {} + +export abstract class BlobStoreGoogle< + ResponseType extends GoogleResponse, + AuthOptions +> extends BlobStore { + caller: AsyncCaller; + + client: GoogleAbstractedClient; + + constructor(fields?: BlobStoreGoogleParams) { + super(fields); + this.caller = new AsyncCaller(fields ?? {}); + this.client = this.buildClient(fields); + } + + abstract buildClient( + fields?: BlobStoreGoogleParams + ): GoogleAbstractedClient; + + abstract buildSetMetadata([key, blob]: [string, MediaBlob]): Record< + string, + unknown + >; + + abstract buildSetConnection([key, blob]: [ + string, + MediaBlob + ]): GoogleMultipartUploadConnection< + AsyncCallerCallOptions, + ResponseType, + AuthOptions + >; + + async _set(keyValuePair: [string, MediaBlob]): Promise { + const [, blob] = keyValuePair; + const setMetadata = this.buildSetMetadata(keyValuePair); + const metadata = setMetadata; + const options = {}; + const connection = this.buildSetConnection(keyValuePair); + const response = await connection.request(blob, metadata, options); + return response; + } + + async mset(keyValuePairs: [string, MediaBlob][]): Promise { + const ret = keyValuePairs.map((keyValue) => this._set(keyValue)); + await Promise.all(ret); + } + + abstract buildGetMetadataConnection( + key: string + ): GoogleDownloadConnection< + AsyncCallerCallOptions, + ResponseType, + AuthOptions + >; + + async _getMetadata(key: string): Promise> { + const connection = this.buildGetMetadataConnection(key); + const options = {}; + const response = await connection.request(options); + return response.data; + } + + abstract buildGetDataConnection( + key: string + ): GoogleDownloadRawConnection; + + async _getData(key: string): Promise { + const connection = this.buildGetDataConnection(key); + const options = {}; + const response = await connection.request(options); + return response.data; + } + + _getMimetypeFromMetadata(metadata: Record): string { + return metadata.contentType as string; + } + + async _get(key: string): Promise { + const metadata = await this._getMetadata(key); + const data = await this._getData(key); + if (data && metadata) { + const ret = await MediaBlob.fromBlob(data, { metadata, path: key }); + return ret; + } else { + return undefined; + } + } + + async mget(keys: string[]): Promise<(MediaBlob | undefined)[]> { + const ret = keys.map((key) => this._get(key)); + return await Promise.all(ret); + } + + abstract buildDeleteConnection( + key: string + ): GoogleDownloadConnection< + AsyncCallerCallOptions, + GoogleResponse, + AuthOptions + >; + + async _del(key: string): Promise { + const connection = this.buildDeleteConnection(key); + const options = {}; + await connection.request(options); + } + + async mdelete(keys: string[]): Promise { + const ret = keys.map((key) => this._del(key)); + await Promise.all(ret); + } + + // eslint-disable-next-line require-yield + async *yieldKeys(_prefix: string | undefined): AsyncGenerator { + // TODO: Implement. Most have an implementation that uses nextToken. + throw new Error("yieldKeys is not implemented"); + } +} + +/** + * Based on https://cloud.google.com/storage/docs/json_api/v1/objects#resource + */ +export interface GoogleCloudStorageObject extends Record { + id?: string; + name?: string; + contentType?: string; + metadata?: Record; + // This is incomplete. +} + +export interface GoogleCloudStorageResponse extends GoogleResponse { + data: GoogleCloudStorageObject; +} + +export type BucketAndPath = { + bucket: string; + path: string; +}; + +export class GoogleCloudStorageUri { + static uriRegexp = /gs:\/\/([a-z0-9][a-z0-9._-]+[a-z0-9])\/(.*)/; + + bucket: string; + + path: string; + + constructor(uri: string) { + const bucketAndPath = GoogleCloudStorageUri.uriToBucketAndPath(uri); + this.bucket = bucketAndPath.bucket; + this.path = bucketAndPath.path; + } + + get uri() { + return `gs://${this.bucket}/${this.path}`; + } + + get isValid() { + return ( + typeof this.bucket !== "undefined" && typeof this.path !== "undefined" + ); + } + + static uriToBucketAndPath(uri: string): BucketAndPath { + const match = this.uriRegexp.exec(uri); + if (!match) { + throw new Error(`Invalid gs:// URI: ${uri}`); + } + return { + bucket: match[1], + path: match[2], + }; + } + + static isValidUri(uri: string): boolean { + return this.uriRegexp.test(uri); + } +} + +export interface GoogleCloudStorageConnectionParams { + uri: string; +} + +export interface GoogleCloudStorageUploadConnectionParams + extends GoogleUploadConnectionParams, + GoogleCloudStorageConnectionParams {} + +export class GoogleCloudStorageUploadConnection< + AuthOptions +> extends GoogleMultipartUploadConnection< + AsyncCallerCallOptions, + GoogleCloudStorageResponse, + AuthOptions +> { + uri: GoogleCloudStorageUri; + + constructor( + fields: GoogleCloudStorageUploadConnectionParams, + caller: AsyncCaller, + client: GoogleAbstractedClient + ) { + super(fields, caller, client); + this.uri = new GoogleCloudStorageUri(fields.uri); + } + + async buildUrl(): Promise { + return `https://storage.googleapis.com/upload/storage/${this.apiVersion}/b/${this.uri.bucket}/o?uploadType=multipart`; + } +} + +export interface GoogleCloudStorageDownloadConnectionParams + extends GoogleCloudStorageConnectionParams, + GoogleConnectionParams { + method: GoogleAbstractedClientOpsMethod; + alt: "media" | undefined; +} + +export class GoogleCloudStorageDownloadConnection< + ResponseType extends GoogleResponse, + AuthOptions +> extends GoogleDownloadConnection< + AsyncCallerCallOptions, + ResponseType, + AuthOptions +> { + uri: GoogleCloudStorageUri; + + method: GoogleAbstractedClientOpsMethod; + + alt: "media" | undefined; + + constructor( + fields: GoogleCloudStorageDownloadConnectionParams, + caller: AsyncCaller, + client: GoogleAbstractedClient + ) { + super(fields, caller, client); + this.uri = new GoogleCloudStorageUri(fields.uri); + this.method = fields.method; + this.alt = fields.alt; + } + + buildMethod(): GoogleAbstractedClientOpsMethod { + return this.method; + } + + async buildUrl(): Promise { + const path = encodeURIComponent(this.uri.path); + const ret = `https://storage.googleapis.com/storage/${this.apiVersion}/b/${this.uri.bucket}/o/${path}`; + return this.alt ? `${ret}?alt=${this.alt}` : ret; + } +} + +export interface GoogleCloudStorageRawConnectionParams + extends GoogleCloudStorageConnectionParams, + GoogleConnectionParams {} + +export class GoogleCloudStorageRawConnection< + AuthOptions +> extends GoogleDownloadRawConnection { + uri: GoogleCloudStorageUri; + + constructor( + fields: GoogleCloudStorageRawConnectionParams, + caller: AsyncCaller, + client: GoogleAbstractedClient + ) { + super(fields, caller, client); + this.uri = new GoogleCloudStorageUri(fields.uri); + } + + async buildUrl(): Promise { + const path = encodeURIComponent(this.uri.path); + const ret = `https://storage.googleapis.com/storage/${this.apiVersion}/b/${this.uri.bucket}/o/${path}?alt=media`; + return ret; + } +} + +export interface BlobStoreGoogleCloudStorageBaseParams + extends BlobStoreGoogleParams { + uriPrefix: GoogleCloudStorageUri; +} + +export abstract class BlobStoreGoogleCloudStorageBase< + AuthOptions +> extends BlobStoreGoogle { + params: BlobStoreGoogleCloudStorageBaseParams; + + constructor(fields: BlobStoreGoogleCloudStorageBaseParams) { + super(fields); + this.params = fields; + this.defaultStoreOptions = { + ...this.defaultStoreOptions, + pathPrefix: fields.uriPrefix.uri, + }; + } + + buildSetConnection([key, _blob]: [ + string, + MediaBlob + ]): GoogleMultipartUploadConnection< + AsyncCallerCallOptions, + GoogleCloudStorageResponse, + AuthOptions + > { + const params: GoogleCloudStorageUploadConnectionParams = { + ...this.params, + uri: key, + }; + return new GoogleCloudStorageUploadConnection( + params, + this.caller, + this.client + ); + } + + buildSetMetadata([key, blob]: [string, MediaBlob]): Record { + const uri = new GoogleCloudStorageUri(key); + const ret: GoogleCloudStorageObject = { + name: uri.path, + metadata: blob.metadata, + contentType: blob.mimetype, + }; + return ret; + } + + buildGetMetadataConnection( + key: string + ): GoogleDownloadConnection< + AsyncCallerCallOptions, + GoogleCloudStorageResponse, + AuthOptions + > { + const params: GoogleCloudStorageDownloadConnectionParams = { + uri: key, + method: "GET", + alt: undefined, + }; + return new GoogleCloudStorageDownloadConnection< + GoogleCloudStorageResponse, + AuthOptions + >(params, this.caller, this.client); + } + + buildGetDataConnection( + key: string + ): GoogleDownloadRawConnection { + const params: GoogleCloudStorageRawConnectionParams = { + uri: key, + }; + return new GoogleCloudStorageRawConnection( + params, + this.caller, + this.client + ); + } + + buildDeleteConnection( + key: string + ): GoogleDownloadConnection< + AsyncCallerCallOptions, + GoogleResponse, + AuthOptions + > { + const params: GoogleCloudStorageDownloadConnectionParams = { + uri: key, + method: "DELETE", + alt: undefined, + }; + return new GoogleCloudStorageDownloadConnection< + GoogleResponse, + AuthOptions + >(params, this.caller, this.client); + } +} + +export type AIStudioFileState = + | "PROCESSING" + | "ACTIVE" + | "FAILED" + | "STATE_UNSPECIFIED"; + +export type AIStudioFileVideoMetadata = { + videoMetadata: { + videoDuration: string; // Duration in seconds, possibly with fractional, ending in "s" + }; +}; + +export type AIStudioFileMetadata = AIStudioFileVideoMetadata; + +export interface AIStudioFileObject { + name?: string; + displayName?: string; + mimeType?: string; + sizeBytes?: string; // int64 format + createTime?: string; // timestamp format + updateTime?: string; // timestamp format + expirationTime?: string; // timestamp format + sha256Hash?: string; // base64 encoded + uri?: string; + state?: AIStudioFileState; + error?: { + code: number; + message: string; + details: Record[]; + }; + metadata?: AIStudioFileMetadata; +} + +export class AIStudioMediaBlob extends MediaBlob { + _valueAsDate(value: string): Date { + if (!value) { + return new Date(0); + } + return new Date(value); + } + + _metadataFieldAsDate(field: string): Date { + return this._valueAsDate(this.metadata?.[field]); + } + + get createDate(): Date { + return this._metadataFieldAsDate("createTime"); + } + + get updateDate(): Date { + return this._metadataFieldAsDate("updateTime"); + } + + get expirationDate(): Date { + return this._metadataFieldAsDate("expirationTime"); + } + + get isExpired(): boolean { + const now = new Date().toISOString(); + const exp = this.metadata?.expirationTime ?? now; + return exp <= now; + } +} + +export interface AIStudioFileGetResponse extends GoogleResponse { + data: AIStudioFileObject; +} + +export interface AIStudioFileSaveResponse extends GoogleResponse { + data: { + file: AIStudioFileObject; + }; +} + +export interface AIStudioFileListResponse extends GoogleResponse { + data: { + files: AIStudioFileObject[]; + nextPageToken: string; + }; +} + +export type AIStudioFileResponse = + | AIStudioFileGetResponse + | AIStudioFileSaveResponse + | AIStudioFileListResponse; + +export interface AIStudioFileConnectionParams {} + +export interface AIStudioFileUploadConnectionParams + extends GoogleUploadConnectionParams, + AIStudioFileConnectionParams {} + +export class AIStudioFileUploadConnection< + AuthOptions +> extends GoogleMultipartUploadConnection< + AsyncCallerCallOptions, + AIStudioFileSaveResponse, + AuthOptions +> { + apiVersion = "v1beta"; + + async buildUrl(): Promise { + return `https://generativelanguage.googleapis.com/upload/${this.apiVersion}/files`; + } +} + +export interface AIStudioFileDownloadConnectionParams + extends AIStudioFileConnectionParams, + GoogleConnectionParams { + method: GoogleAbstractedClientOpsMethod; + name: string; +} + +export class AIStudioFileDownloadConnection< + ResponseType extends GoogleResponse, + AuthOptions +> extends GoogleDownloadConnection< + AsyncCallerCallOptions, + ResponseType, + AuthOptions +> { + method: GoogleAbstractedClientOpsMethod; + + name: string; + + apiVersion = "v1beta"; + + constructor( + fields: AIStudioFileDownloadConnectionParams, + caller: AsyncCaller, + client: GoogleAbstractedClient + ) { + super(fields, caller, client); + this.method = fields.method; + this.name = fields.name; + } + + buildMethod(): GoogleAbstractedClientOpsMethod { + return this.method; + } + + async buildUrl(): Promise { + return `https://generativelanguage.googleapis.com/${this.apiVersion}/files/${this.name}`; + } +} + +export interface BlobStoreAIStudioFileBaseParams + extends BlobStoreGoogleParams { + retryTime?: number; +} + +export abstract class BlobStoreAIStudioFileBase< + AuthOptions +> extends BlobStoreGoogle { + params?: BlobStoreAIStudioFileBaseParams; + + retryTime: number = 1000; + + constructor(fields?: BlobStoreAIStudioFileBaseParams) { + const params: BlobStoreAIStudioFileBaseParams = { + defaultStoreOptions: { + pathPrefix: "https://generativelanguage.googleapis.com/v1beta/files/", + actionIfInvalid: "removePath", + }, + ...fields, + }; + super(params); + this.params = params; + this.retryTime = params?.retryTime ?? this.retryTime ?? 1000; + } + + _pathToName(path: string): string { + return path.split("/").pop() ?? path; + } + + abstract buildAbstractedClient( + fields?: BlobStoreGoogleParams + ): GoogleAbstractedClient; + + buildApiKeyClient(apiKey: string): GoogleAbstractedClient { + return new ApiKeyGoogleAuth(apiKey); + } + + buildApiKey(fields?: BlobStoreGoogleParams): string | undefined { + return fields?.apiKey ?? getEnvironmentVariable("GOOGLE_API_KEY"); + } + + buildClient( + fields?: BlobStoreGoogleParams + ): GoogleAbstractedClient { + const apiKey = this.buildApiKey(fields); + if (apiKey) { + return this.buildApiKeyClient(apiKey); + } else { + // TODO: Test that you can use OAuth to access + return this.buildAbstractedClient(fields); + } + } + + async _regetMetadata(key: string): Promise { + // Sleep for some time period + // eslint-disable-next-line no-promise-executor-return + await new Promise((resolve) => setTimeout(resolve, this.retryTime)); + + // Fetch the latest metadata + return this._getMetadata(key); + } + + async _set([key, blob]: [ + string, + MediaBlob + ]): Promise { + const response = (await super._set([ + key, + blob, + ])) as AIStudioFileSaveResponse; + + let file = response.data?.file ?? { state: "FAILED" }; + while (file.state === "PROCESSING" && file.uri && this.retryTime > 0) { + file = await this._regetMetadata(file.uri); + } + + // The response should contain the name (and valid URI), so we need to + // update the blob with this. We can't return a new blob, since mset() + // doesn't return anything. + /* eslint-disable no-param-reassign */ + blob.path = file.uri; + blob.metadata = { + ...blob.metadata, + ...file, + }; + /* eslint-enable no-param-reassign */ + + return response; + } + + buildSetConnection([_key, _blob]: [ + string, + MediaBlob + ]): GoogleMultipartUploadConnection< + AsyncCallerCallOptions, + AIStudioFileResponse, + AuthOptions + > { + return new AIStudioFileUploadConnection( + this.params, + this.caller, + this.client + ); + } + + buildSetMetadata([_key, _blob]: [string, MediaBlob]): Record< + string, + unknown + > { + return {}; + } + + buildGetMetadataConnection( + key: string + ): GoogleDownloadConnection< + AsyncCallerCallOptions, + AIStudioFileResponse, + AuthOptions + > { + const params: AIStudioFileDownloadConnectionParams = { + ...this.params, + method: "GET", + name: this._pathToName(key), + }; + return new AIStudioFileDownloadConnection< + AIStudioFileResponse, + AuthOptions + >(params, this.caller, this.client); + } + + buildGetDataConnection( + _key: string + ): GoogleDownloadRawConnection { + throw new Error("AI Studio File API does not provide data"); + } + + async _get(key: string): Promise { + const metadata = await this._getMetadata(key); + if (metadata) { + const contentType = + (metadata?.mimeType as string) ?? "application/octet-stream"; + // TODO - Get the actual data (and other metadata) from an optional backing store + const data: MediaBlobData = { + value: "", + type: contentType, + }; + + return new MediaBlob({ + path: key, + data, + metadata, + }); + } else { + return undefined; + } + } + + buildDeleteConnection( + key: string + ): GoogleDownloadConnection< + AsyncCallerCallOptions, + AIStudioFileResponse, + AuthOptions + > { + const params: AIStudioFileDownloadConnectionParams = { + ...this.params, + method: "DELETE", + name: this._pathToName(key), + }; + return new AIStudioFileDownloadConnection< + AIStudioFileResponse, + AuthOptions + >(params, this.caller, this.client); + } +} diff --git a/libs/langchain-google-common/src/experimental/utils/media_core.ts b/libs/langchain-google-common/src/experimental/utils/media_core.ts new file mode 100644 index 000000000000..f27d5c55ed52 --- /dev/null +++ b/libs/langchain-google-common/src/experimental/utils/media_core.ts @@ -0,0 +1,669 @@ +import { v1, v4 } from "uuid"; // FIXME - it is importing the wrong uuid, so v6 and v7 aren't implemented +import { BaseStore } from "@langchain/core/stores"; +import { Serializable } from "@langchain/core/load/serializable"; + +export type MediaBlobData = { + value: string; // In Base64 encoding + type: string; // The mime type and possibly encoding +}; + +export interface MediaBlobParameters { + data?: MediaBlobData; + + metadata?: Record; + + path?: string; +} + +function bytesToString(dataArray: Uint8Array): string { + // Need to handle the array in smaller chunks to deal with stack size limits + let ret = ""; + const chunkSize = 102400; + for (let i = 0; i < dataArray.length; i += chunkSize) { + const chunk = dataArray.subarray(i, i + chunkSize); + ret += String.fromCharCode(...chunk); + } + + return ret; +} + +/** + * Represents a chunk of data that can be identified by the path where the + * data is (or will be) located, along with optional metadata about the data. + */ +export class MediaBlob extends Serializable implements MediaBlobParameters { + lc_serializable = true; + + lc_namespace = [ + "langchain", + "google_common", + "experimental", + "utils", + "media_core", + ]; + + data: MediaBlobData = { + value: "", + type: "text/plain", + }; + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + metadata?: Record; + + path?: string; + + constructor(params: MediaBlobParameters) { + super(params); + + this.data = params.data ?? this.data; + this.metadata = params.metadata; + this.path = params.path; + } + + get size(): number { + return this.asBytes.length; + } + + get dataType(): string { + return this.data?.type ?? ""; + } + + get encoding(): string { + const charsetEquals = this.dataType.indexOf("charset="); + return charsetEquals === -1 + ? "utf-8" + : this.dataType.substring(charsetEquals + 8); + } + + get mimetype(): string { + const semicolon = this.dataType.indexOf(";"); + return semicolon === -1 + ? this.dataType + : this.dataType.substring(0, semicolon); + } + + get asBytes(): Uint8Array { + if (!this.data) { + return Uint8Array.from([]); + } + const binString = atob(this.data?.value); + const ret = new Uint8Array(binString.length); + for (let co = 0; co < binString.length; co += 1) { + ret[co] = binString.charCodeAt(co); + } + return ret; + } + + async asString(): Promise { + return bytesToString(this.asBytes); + } + + async asBase64(): Promise { + return this.data?.value ?? ""; + } + + async asDataUrl(): Promise { + return `data:${this.mimetype};base64,${await this.asBase64()}`; + } + + async asUri(): Promise { + return this.path ?? (await this.asDataUrl()); + } + + async encode(): Promise<{ encoded: string; encoding: string }> { + const dataUrl = await this.asDataUrl(); + const comma = dataUrl.indexOf(","); + const encoded = dataUrl.substring(comma + 1); + const encoding: string = dataUrl.indexOf("base64") > -1 ? "base64" : "8bit"; + return { + encoded, + encoding, + }; + } + + static fromDataUrl(url: string): MediaBlob { + if (!url.startsWith("data:")) { + throw new Error("Not a data: URL"); + } + const colon = url.indexOf(":"); + const semicolon = url.indexOf(";"); + const mimeType = url.substring(colon + 1, semicolon); + + const comma = url.indexOf(","); + const base64Data = url.substring(comma + 1); + + const data: MediaBlobData = { + type: mimeType, + value: base64Data, + }; + + return new MediaBlob({ + data, + path: url, + }); + } + + static async fromBlob( + blob: Blob, + other?: Omit + ): Promise { + const valueBuffer = await blob.arrayBuffer(); + const valueArray = new Uint8Array(valueBuffer); + const valueStr = bytesToString(valueArray); + const value = btoa(valueStr); + + return new MediaBlob({ + ...other, + data: { + value, + type: blob.type, + }, + }); + } +} + +export type ActionIfInvalidAction = + | "ignore" + | "prefixPath" + | "prefixUuid1" + | "prefixUuid4" + | "prefixUuid6" + | "prefixUuid7" + | "removePath"; + +export interface BlobStoreStoreOptions { + /** + * If the path is missing or invalid in the blob, how should we create + * a new path? + * Subclasses may define their own methods, but the following are supported + * by default: + * - Undefined or an emtpy string: Reject the blob + * - "ignore": Attempt to store it anyway (but this may fail) + * - "prefixPath": Use the default prefix for the BlobStore and get the + * unique portion from the URL. The original path is stored in the metadata + * - "prefixUuid": Use the default prefix for the BlobStore and get the + * unique portion from a generated UUID. The original path is stored + * in the metadata + */ + actionIfInvalid?: ActionIfInvalidAction; + + /** + * The expected prefix for URIs that are stored. + * This may be used to test if a MediaBlob is valid and used to create a new + * path if "prefixPath" or "prefixUuid" is set for actionIfInvalid. + */ + pathPrefix?: string; +} + +export type ActionIfBlobMissingAction = "emptyBlob"; + +export interface BlobStoreFetchOptions { + /** + * If the blob is not found when fetching, what should we do? + * Subclasses may define their own methods, but the following are supported + * by default: + * - Undefined or an empty string: return undefined + * - "emptyBlob": return a new MediaBlob that has the path set, but nothing else. + */ + actionIfBlobMissing?: ActionIfBlobMissingAction; +} + +export interface BlobStoreOptions { + defaultStoreOptions?: BlobStoreStoreOptions; + + defaultFetchOptions?: BlobStoreFetchOptions; +} + +/** + * A specialized Store that is designed to handle MediaBlobs and use the + * key that is included in the blob to determine exactly how it is stored. + * + * The full details of a MediaBlob may be changed when it is stored. + * For example, it may get additional or different Metadata. This should be + * what is returned when the store() method is called. + * + * Although BlobStore extends BaseStore, not all of the methods from + * BaseStore may be implemented (or even possible). Those that are not + * implemented should be documented and throw an Error if called. + */ +export abstract class BlobStore extends BaseStore { + lc_namespace = ["langchain", "google-common"]; // FIXME - What should this be? And why? + + defaultStoreOptions: BlobStoreStoreOptions; + + defaultFetchOptions: BlobStoreFetchOptions; + + constructor(opts?: BlobStoreOptions) { + super(opts); + this.defaultStoreOptions = opts?.defaultStoreOptions ?? {}; + this.defaultFetchOptions = opts?.defaultFetchOptions ?? {}; + } + + protected async _realKey(key: string | MediaBlob): Promise { + return typeof key === "string" ? key : await key.asUri(); + } + + /** + * Is the path supported by this BlobStore? + * + * Although this is async, this is expected to be a relatively fast operation + * (ie - you shouldn't make network calls). + * + * @param path The path to check + * @param opts Any options (if needed) that may be used to determine if it is valid + * @return If the path is supported + */ + hasValidPath( + path: string | undefined, + opts?: BlobStoreStoreOptions + ): Promise { + const prefix = opts?.pathPrefix ?? ""; + const isPrefixed = typeof path !== "undefined" && path.startsWith(prefix); + return Promise.resolve(isPrefixed); + } + + protected _blobPathSuffix(blob: MediaBlob): string { + // Get the path currently set and make sure we treat it as a string + const blobPath = `${blob.path}`; + + // Advance past the first set of / + let pathStart = blobPath.indexOf("/") + 1; + while (blobPath.charAt(pathStart) === "/") { + pathStart += 1; + } + + // We will use the rest as the path for a replacement + return blobPath.substring(pathStart); + } + + protected async _newBlob( + oldBlob: MediaBlob, + newPath?: string + ): Promise { + const oldPath = oldBlob.path; + const metadata = oldBlob?.metadata ?? {}; + metadata.langchainOldPath = oldPath; + const newBlob = new MediaBlob({ + ...oldBlob, + metadata, + }); + if (newPath) { + newBlob.path = newPath; + } else if (newBlob.path) { + delete newBlob.path; + } + return newBlob; + } + + protected async _validBlobPrefixPath( + blob: MediaBlob, + opts?: BlobStoreStoreOptions + ): Promise { + const prefix = opts?.pathPrefix ?? ""; + const suffix = this._blobPathSuffix(blob); + const newPath = `${prefix}${suffix}`; + return this._newBlob(blob, newPath); + } + + protected _validBlobPrefixUuidFunction( + name: ActionIfInvalidAction | string + ): string { + switch (name) { + case "prefixUuid1": + return v1(); + case "prefixUuid4": + return v4(); + // case "prefixUuid6": return v6(); + // case "prefixUuid7": return v7(); + default: + throw new Error(`Unknown uuid function: ${name}`); + } + } + + protected async _validBlobPrefixUuid( + blob: MediaBlob, + opts?: BlobStoreStoreOptions + ): Promise { + const prefix = opts?.pathPrefix ?? ""; + const suffix = this._validBlobPrefixUuidFunction( + opts?.actionIfInvalid ?? "prefixUuid4" + ); + const newPath = `${prefix}${suffix}`; + return this._newBlob(blob, newPath); + } + + protected async _validBlobRemovePath( + blob: MediaBlob, + _opts?: BlobStoreStoreOptions + ): Promise { + return this._newBlob(blob, undefined); + } + + /** + * Based on the blob and options, return a blob that has a valid path + * that can be saved. + * @param blob + * @param opts + */ + protected async _validStoreBlob( + blob: MediaBlob, + opts?: BlobStoreStoreOptions + ): Promise { + if (await this.hasValidPath(blob.path, opts)) { + return blob; + } + switch (opts?.actionIfInvalid) { + case "ignore": + return blob; + case "prefixPath": + return this._validBlobPrefixPath(blob, opts); + case "prefixUuid1": + case "prefixUuid4": + case "prefixUuid6": + case "prefixUuid7": + return this._validBlobPrefixUuid(blob, opts); + case "removePath": + return this._validBlobRemovePath(blob, opts); + default: + return undefined; + } + } + + async store( + blob: MediaBlob, + opts: BlobStoreStoreOptions = {} + ): Promise { + const allOpts: BlobStoreStoreOptions = { + ...this.defaultStoreOptions, + ...opts, + }; + const validBlob = await this._validStoreBlob(blob, allOpts); + if (typeof validBlob !== "undefined") { + const validKey = await validBlob.asUri(); + await this.mset([[validKey, validBlob]]); + const savedKey = await validBlob.asUri(); + return await this.fetch(savedKey); + } + return undefined; + } + + protected async _missingFetchBlobEmpty( + path: string, + _opts?: BlobStoreFetchOptions + ): Promise { + return new MediaBlob({ path }); + } + + protected async _missingFetchBlob( + path: string, + opts?: BlobStoreFetchOptions + ): Promise { + switch (opts?.actionIfBlobMissing) { + case "emptyBlob": + return this._missingFetchBlobEmpty(path, opts); + default: + return undefined; + } + } + + async fetch( + key: string | MediaBlob, + opts: BlobStoreFetchOptions = {} + ): Promise { + const allOpts: BlobStoreFetchOptions = { + ...this.defaultFetchOptions, + ...opts, + }; + const realKey = await this._realKey(key); + const ret = await this.mget([realKey]); + return ret?.[0] ?? (await this._missingFetchBlob(realKey, allOpts)); + } +} + +export interface BackedBlobStoreOptions extends BlobStoreOptions { + backingStore: BaseStore; +} + +export class BackedBlobStore extends BlobStore { + backingStore: BaseStore; + + constructor(opts: BackedBlobStoreOptions) { + super(opts); + this.backingStore = opts.backingStore; + } + + mdelete(keys: string[]): Promise { + return this.backingStore.mdelete(keys); + } + + mget(keys: string[]): Promise<(MediaBlob | undefined)[]> { + return this.backingStore.mget(keys); + } + + mset(keyValuePairs: [string, MediaBlob][]): Promise { + return this.backingStore.mset(keyValuePairs); + } + + yieldKeys(prefix: string | undefined): AsyncGenerator { + return this.backingStore.yieldKeys(prefix); + } +} + +export interface ReadThroughBlobStoreOptions extends BlobStoreOptions { + baseStore: BlobStore; + backingStore: BlobStore; +} + +export class ReadThroughBlobStore extends BlobStore { + baseStore: BlobStore; + + backingStore: BlobStore; + + constructor(opts: ReadThroughBlobStoreOptions) { + super(opts); + this.baseStore = opts.baseStore; + this.backingStore = opts.backingStore; + } + + async store( + blob: MediaBlob, + opts: BlobStoreStoreOptions = {} + ): Promise { + const originalUri = await blob.asUri(); + const newBlob = await this.backingStore.store(blob, opts); + if (newBlob) { + await this.baseStore.mset([[originalUri, newBlob]]); + } + return newBlob; + } + + mdelete(keys: string[]): Promise { + return this.baseStore.mdelete(keys); + } + + mget(keys: string[]): Promise<(MediaBlob | undefined)[]> { + return this.baseStore.mget(keys); + } + + mset(_keyValuePairs: [string, MediaBlob][]): Promise { + throw new Error("Do not call ReadThroughBlobStore.mset directly"); + } + + yieldKeys(prefix: string | undefined): AsyncGenerator { + return this.baseStore.yieldKeys(prefix); + } +} + +export class SimpleWebBlobStore extends BlobStore { + _notImplementedException() { + throw new Error("Not implemented for SimpleWebBlobStore"); + } + + async hasValidPath( + path: string | undefined, + _opts?: BlobStoreStoreOptions + ): Promise { + return ( + (await super.hasValidPath(path, { pathPrefix: "https://" })) || + (await super.hasValidPath(path, { pathPrefix: "http://" })) + ); + } + + async _fetch(url: string): Promise { + const ret = new MediaBlob({ + path: url, + }); + const metadata: Record = {}; + const fetchOptions = { + method: "GET", + }; + const res = await fetch(url, fetchOptions); + metadata.status = res.status; + + const headers: Record = {}; + for (const [key, value] of res.headers.entries()) { + headers[key] = value; + } + metadata.headers = headers; + + metadata.ok = res.ok; + if (res.ok) { + const resMediaBlob = await MediaBlob.fromBlob(await res.blob()); + ret.data = resMediaBlob.data; + } + + ret.metadata = metadata; + return ret; + } + + async mget(keys: string[]): Promise<(MediaBlob | undefined)[]> { + const blobMap = keys.map(this._fetch); + return await Promise.all(blobMap); + } + + async mdelete(_keys: string[]): Promise { + this._notImplementedException(); + } + + async mset(_keyValuePairs: [string, MediaBlob][]): Promise { + this._notImplementedException(); + } + + async *yieldKeys(_prefix: string | undefined): AsyncGenerator { + this._notImplementedException(); + yield ""; + } +} + +/** + * A blob "store" that works with data: URLs that will turn the URL into + * a blob. + */ +export class DataBlobStore extends BlobStore { + _notImplementedException() { + throw new Error("Not implemented for DataBlobStore"); + } + + hasValidPath(path: string, _opts?: BlobStoreStoreOptions): Promise { + return super.hasValidPath(path, { pathPrefix: "data:" }); + } + + _fetch(url: string): MediaBlob { + return MediaBlob.fromDataUrl(url); + } + + async mget(keys: string[]): Promise<(MediaBlob | undefined)[]> { + const blobMap = keys.map(this._fetch); + return blobMap; + } + + async mdelete(_keys: string[]): Promise { + this._notImplementedException(); + } + + async mset(_keyValuePairs: [string, MediaBlob][]): Promise { + this._notImplementedException(); + } + + async *yieldKeys(_prefix: string | undefined): AsyncGenerator { + this._notImplementedException(); + yield ""; + } +} + +export interface MediaManagerConfiguration { + /** + * A store that, given a common URI, returns the corresponding MediaBlob. + * The returned MediaBlob may have a different URI. + * In many cases, this will be a ReadThroughStore or something similar + * that has a cached version of the MediaBlob, but also a way to get + * a new (or refreshed) version. + */ + store: BlobStore; + + /** + * BlobStores that can resolve a URL into the MediaBlob to save + * in the canonical store. This list is evaluated in order. + * If not provided, a default list (which involves a DataBlobStore + * and a SimpleWebBlobStore) will be used. + */ + resolvers?: BlobStore[]; +} + +/** + * Responsible for converting a URI (typically a web URL) into a MediaBlob. + * Allows for aliasing / caching of the requested URI and what it resolves to. + * This MediaBlob is expected to be usable to provide to an LLM, either + * through the Base64 of the media or through a canonical URI that the LLM + * supports. + */ +export class MediaManager { + store: BlobStore; + + resolvers: BlobStore[] | undefined; + + constructor(config: MediaManagerConfiguration) { + this.store = config.store; + this.resolvers = config.resolvers; + } + + defaultResolvers(): BlobStore[] { + return [new DataBlobStore({}), new SimpleWebBlobStore({})]; + } + + async _isInvalid(blob: MediaBlob | undefined): Promise { + return typeof blob === "undefined"; + } + + /** + * Given the public URI, load what is at this URI and save it + * in the store. + * @param uri The URI to resolve using the resolver + * @return A canonical MediaBlob for this URI + */ + async _resolveAndSave(uri: string): Promise { + let resolvedBlob: MediaBlob | undefined; + + const resolvers = this.resolvers || this.defaultResolvers(); + for (let co = 0; co < resolvers.length; co += 1) { + const resolver = resolvers[co]; + if (await resolver.hasValidPath(uri)) { + resolvedBlob = await resolver.fetch(uri); + } + } + + if (resolvedBlob) { + return await this.store.store(resolvedBlob); + } else { + return new MediaBlob({}); + } + } + + async getMediaBlob(uri: string): Promise { + const aliasBlob = await this.store.fetch(uri); + const ret = (await this._isInvalid(aliasBlob)) + ? await this._resolveAndSave(uri) + : (aliasBlob as MediaBlob); + return ret; + } +} diff --git a/libs/langchain-google-common/src/llms.ts b/libs/langchain-google-common/src/llms.ts index 347098177186..e9c267aaaf65 100644 --- a/libs/langchain-google-common/src/llms.ts +++ b/libs/langchain-google-common/src/llms.ts @@ -21,13 +21,7 @@ import { copyAIModelParams, copyAndValidateModelParamsInto, } from "./utils/common.js"; -import { - chunkToString, - messageContentToParts, - safeResponseToBaseMessage, - safeResponseToString, - DefaultGeminiSafetyHandler, -} from "./utils/gemini.js"; +import { DefaultGeminiSafetyHandler } from "./utils/gemini.js"; import { ApiKeyGoogleAuth, GoogleAbstractedClient } from "./auth.js"; import { ensureParams } from "./utils/failed_handler.js"; import { ChatGoogleBase } from "./chat_models.js"; @@ -39,11 +33,11 @@ class GoogleLLMConnection extends AbstractGoogleLLMConnection< MessageContent, AuthOptions > { - formatContents( + async formatContents( input: MessageContent, _parameters: GoogleAIModelParams - ): GeminiContent[] { - const parts = messageContentToParts(input); + ): Promise { + const parts = await this.api.messageContentToParts(input); const contents: GeminiContent[] = [ { role: "user", // Required by Vertex AI @@ -189,7 +183,10 @@ export abstract class GoogleBaseLLM ): Promise { const parameters = copyAIModelParams(this, options); const result = await this.connection.request(prompt, parameters, options); - const ret = safeResponseToString(result, this.safetyHandler); + const ret = this.connection.api.safeResponseToString( + result, + this.safetyHandler + ); return ret; } @@ -234,7 +231,7 @@ export abstract class GoogleBaseLLM const proxyChat = this.createProxyChat(); try { for await (const chunk of proxyChat._streamIterator(input, options)) { - const stringValue = chunkToString(chunk); + const stringValue = this.connection.api.chunkToString(chunk); const generationChunk = new GenerationChunk({ text: stringValue, }); @@ -267,7 +264,10 @@ export abstract class GoogleBaseLLM {}, options as BaseLanguageModelCallOptions ); - const ret = safeResponseToBaseMessage(result, this.safetyHandler); + const ret = this.connection.api.safeResponseToBaseMessage( + result, + this.safetyHandler + ); return ret; } diff --git a/libs/langchain-google-common/src/tests/chat_models.test.ts b/libs/langchain-google-common/src/tests/chat_models.test.ts index dda4b68033ce..9da477df3e0e 100644 --- a/libs/langchain-google-common/src/tests/chat_models.test.ts +++ b/libs/langchain-google-common/src/tests/chat_models.test.ts @@ -9,6 +9,7 @@ import { SystemMessage, ToolMessage, } from "@langchain/core/messages"; +import { InMemoryStore } from "@langchain/core/stores"; import { z } from "zod"; import { zodToJsonSchema } from "zod-to-json-schema"; @@ -17,6 +18,12 @@ import { authOptions, MockClient, MockClientAuthInfo, mockId } from "./mock.js"; import { GeminiTool, GoogleAIBaseLLMInput } from "../types.js"; import { GoogleAbstractedClient } from "../auth.js"; import { GoogleAISafetyError } from "../utils/safety.js"; +import { + BackedBlobStore, + MediaBlob, + MediaManager, + ReadThroughBlobStore, +} from "../experimental/utils/media_core.js"; import { removeAdditionalProperties } from "../utils/zod_to_gemini_parameters.js"; class ChatGoogle extends ChatGoogleBase { @@ -502,10 +509,6 @@ describe("Mock ChatGoogle", () => { expect(caught).toEqual(true); }); - /* - * Images aren't supported (yet) by Gemini, but a one-round with - * image should work ok. - */ test("3. invoke - images", async () => { // eslint-disable-next-line @typescript-eslint/no-explicit-any const record: Record = {}; @@ -517,7 +520,7 @@ describe("Mock ChatGoogle", () => { }; const model = new ChatGoogle({ authOptions, - model: "gemini-pro-vision", + model: "gemini-1.5-flash", }); const message: MessageContentComplex[] = [ @@ -552,6 +555,200 @@ describe("Mock ChatGoogle", () => { expect(result.content).toBe("A blue square."); }); + test("3. invoke - media - invalid", async () => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const record: Record = {}; + const projectId = mockId(); + const authOptions: MockClientAuthInfo = { + record, + projectId, + resultFile: "chat-3-mock.json", + }; + const model = new ChatGoogle({ + authOptions, + model: "gemini-1.5-flash", + }); + + const message: MessageContentComplex[] = [ + { + type: "text", + text: "What is in this image?", + }, + { + type: "media", + fileUri: "mock://example.com/blue-box.png", + }, + ]; + + const messages: BaseMessage[] = [ + new HumanMessageChunk({ content: message }), + ]; + + try { + const result = await model.invoke(messages); + expect(result).toBeUndefined(); + } catch (e) { + expect((e as Error).message).toEqual("Invalid media content"); + } + }); + + test("3. invoke - media - no manager", async () => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const record: Record = {}; + const projectId = mockId(); + const authOptions: MockClientAuthInfo = { + record, + projectId, + resultFile: "chat-3-mock.json", + }; + const model = new ChatGoogle({ + authOptions, + model: "gemini-1.5-flash", + }); + + const message: MessageContentComplex[] = [ + { + type: "text", + text: "What is in this image?", + }, + { + type: "media", + fileUri: "mock://example.com/blue-box.png", + mimeType: "image/png", + }, + ]; + + const messages: BaseMessage[] = [ + new HumanMessageChunk({ content: message }), + ]; + + const result = await model.invoke(messages); + + console.log(JSON.stringify(record.opts, null, 1)); + + expect(record.opts).toHaveProperty("data"); + expect(record.opts.data).toHaveProperty("contents"); + expect(record.opts.data.contents).toHaveLength(1); + expect(record.opts.data.contents[0]).toHaveProperty("parts"); + + const parts = record?.opts?.data?.contents[0]?.parts; + expect(parts).toHaveLength(2); + expect(parts[0]).toHaveProperty("text"); + expect(parts[1]).toHaveProperty("fileData"); + expect(parts[1].fileData).toHaveProperty("mimeType"); + expect(parts[1].fileData).toHaveProperty("fileUri"); + + expect(result.content).toBe("A blue square."); + }); + + test("3. invoke - media - manager", async () => { + class MemStore extends InMemoryStore { + get length() { + return Object.keys(this.store).length; + } + } + + const aliasMemory = new MemStore(); + const aliasStore = new BackedBlobStore({ + backingStore: aliasMemory, + defaultFetchOptions: { + actionIfBlobMissing: undefined, + }, + }); + const canonicalMemory = new MemStore(); + const canonicalStore = new BackedBlobStore({ + backingStore: canonicalMemory, + defaultStoreOptions: { + pathPrefix: "canonical://store/", + actionIfInvalid: "prefixPath", + }, + defaultFetchOptions: { + actionIfBlobMissing: undefined, + }, + }); + const blobStore = new ReadThroughBlobStore({ + baseStore: aliasStore, + backingStore: canonicalStore, + }); + const resolverMemory = new MemStore(); + const resolver = new BackedBlobStore({ + backingStore: resolverMemory, + defaultFetchOptions: { + actionIfBlobMissing: "emptyBlob", + }, + }); + const mediaManager = new MediaManager({ + store: blobStore, + resolvers: [resolver], + }); + + async function store(path: string, text: string): Promise { + const type = path.endsWith(".png") ? "image/png" : "text/plain"; + const blob = new MediaBlob({ + data: { + value: text, + type, + }, + path, + }); + await resolver.store(blob); + } + await store("resolve://host/foo", "fooing"); + await store("resolve://host2/bar/baz", "barbazing"); + await store("resolve://host/foo/blue-box.png", "png"); + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const record: Record = {}; + const projectId = mockId(); + const authOptions: MockClientAuthInfo = { + record, + projectId, + resultFile: "chat-3-mock.json", + }; + const model = new ChatGoogle({ + authOptions, + model: "gemini-1.5-flash", + mediaManager, + }); + + const message: MessageContentComplex[] = [ + { + type: "text", + text: "What is in this image?", + }, + { + type: "media", + fileUri: "resolve://host/foo/blue-box.png", + }, + ]; + + const messages: BaseMessage[] = [ + new HumanMessageChunk({ content: message }), + ]; + + const result = await model.invoke(messages); + + console.log(JSON.stringify(record.opts, null, 1)); + + expect(record.opts).toHaveProperty("data"); + expect(record.opts.data).toHaveProperty("contents"); + expect(record.opts.data.contents).toHaveLength(1); + expect(record.opts.data.contents[0]).toHaveProperty("parts"); + + const parts = record?.opts?.data?.contents[0]?.parts; + expect(parts).toHaveLength(2); + expect(parts[0]).toHaveProperty("text"); + expect(parts[1]).toHaveProperty("fileData"); + expect(parts[1].fileData).toHaveProperty("mimeType"); + expect(parts[1].fileData.mimeType).toEqual("image/png"); + expect(parts[1].fileData).toHaveProperty("fileUri"); + expect(parts[1].fileData.fileUri).toEqual( + "canonical://store/host/foo/blue-box.png" + ); + + expect(result.content).toBe("A blue square."); + }); + test("4. Functions Bind - Gemini format request", async () => { // eslint-disable-next-line @typescript-eslint/no-explicit-any const record: Record = {}; diff --git a/libs/langchain-google-common/src/tests/utils.test.ts b/libs/langchain-google-common/src/tests/utils.test.ts index c0398a218c67..547392c397e7 100644 --- a/libs/langchain-google-common/src/tests/utils.test.ts +++ b/libs/langchain-google-common/src/tests/utils.test.ts @@ -1,85 +1,419 @@ /* eslint-disable @typescript-eslint/no-explicit-any */ -import { expect, test } from "@jest/globals"; +import { beforeEach, expect, test } from "@jest/globals"; +import { InMemoryStore } from "@langchain/core/stores"; +import { SerializedConstructor } from "@langchain/core/load/serializable"; +import { load } from "@langchain/core/load"; import { z } from "zod"; import { zodToGeminiParameters } from "../utils/zod_to_gemini_parameters.js"; +import { + BackedBlobStore, + BlobStore, + MediaBlob, + MediaManager, + ReadThroughBlobStore, + SimpleWebBlobStore, +} from "../experimental/utils/media_core.js"; import { ReadableJsonStream } from "../utils/stream.js"; -test("zodToGeminiParameters can convert zod schema to gemini schema", () => { - const zodSchema = z - .object({ - operation: z - .enum(["add", "subtract", "multiply", "divide"]) - .describe("The type of operation to execute"), - number1: z.number().describe("The first number to operate on."), - number2: z.number().describe("The second number to operate on."), - childObject: z.object({}), - }) - .describe("A simple calculator tool"); - - const convertedSchema = zodToGeminiParameters(zodSchema); - - expect(convertedSchema.type).toBe("object"); - expect(convertedSchema.description).toBe("A simple calculator tool"); - expect((convertedSchema as any).additionalProperties).toBeUndefined(); - expect(convertedSchema.properties).toEqual({ - operation: { - type: "string", - enum: ["add", "subtract", "multiply", "divide"], - description: "The type of operation to execute", - }, - number1: { - type: "number", - description: "The first number to operate on.", - }, - number2: { - type: "number", - description: "The second number to operate on.", - }, - childObject: { - type: "object", - properties: {}, - }, +describe("zodToGeminiParameters", () => { + test("can convert zod schema to gemini schema", () => { + const zodSchema = z + .object({ + operation: z + .enum(["add", "subtract", "multiply", "divide"]) + .describe("The type of operation to execute"), + number1: z.number().describe("The first number to operate on."), + number2: z.number().describe("The second number to operate on."), + childObject: z.object({}), + }) + .describe("A simple calculator tool"); + + const convertedSchema = zodToGeminiParameters(zodSchema); + + expect(convertedSchema.type).toBe("object"); + expect(convertedSchema.description).toBe("A simple calculator tool"); + expect((convertedSchema as any).additionalProperties).toBeUndefined(); + expect(convertedSchema.properties).toEqual({ + operation: { + type: "string", + enum: ["add", "subtract", "multiply", "divide"], + description: "The type of operation to execute", + }, + number1: { + type: "number", + description: "The first number to operate on.", + }, + number2: { + type: "number", + description: "The second number to operate on.", + }, + childObject: { + type: "object", + properties: {}, + }, + }); + expect(convertedSchema.required).toEqual([ + "operation", + "number1", + "number2", + "childObject", + ]); + }); + + test("removes additional properties from arrays", () => { + const zodSchema = z + .object({ + people: z + .object({ + name: z.string().describe("The name of a person"), + }) + .array() + .describe("person elements"), + }) + .describe("A list of people"); + + const convertedSchema = zodToGeminiParameters(zodSchema); + expect(convertedSchema.type).toBe("object"); + expect(convertedSchema.description).toBe("A list of people"); + expect((convertedSchema as any).additionalProperties).toBeUndefined(); + + const peopleSchema = convertedSchema?.properties?.people; + expect(peopleSchema).not.toBeUndefined(); + + if (peopleSchema !== undefined) { + expect(peopleSchema.type).toBe("array"); + expect((peopleSchema as any).additionalProperties).toBeUndefined(); + expect(peopleSchema.description).toBe("person elements"); + } + + const arrayItemsSchema = peopleSchema?.items; + expect(arrayItemsSchema).not.toBeUndefined(); + if (arrayItemsSchema !== undefined) { + expect(arrayItemsSchema.type).toBe("object"); + expect((arrayItemsSchema as any).additionalProperties).toBeUndefined(); + } }); - expect(convertedSchema.required).toEqual([ - "operation", - "number1", - "number2", - "childObject", - ]); }); -test("zodToGeminiParameters removes additional properties from arrays", () => { - const zodSchema = z - .object({ - people: z - .object({ - name: z.string().describe("The name of a person"), - }) - .array() - .describe("person elements"), - }) - .describe("A list of people"); - - const convertedSchema = zodToGeminiParameters(zodSchema); - expect(convertedSchema.type).toBe("object"); - expect(convertedSchema.description).toBe("A list of people"); - expect((convertedSchema as any).additionalProperties).toBeUndefined(); - - const peopleSchema = convertedSchema?.properties?.people; - expect(peopleSchema).not.toBeUndefined(); - - if (peopleSchema !== undefined) { - expect(peopleSchema.type).toBe("array"); - expect((peopleSchema as any).additionalProperties).toBeUndefined(); - expect(peopleSchema.description).toBe("person elements"); - } - - const arrayItemsSchema = peopleSchema?.items; - expect(arrayItemsSchema).not.toBeUndefined(); - if (arrayItemsSchema !== undefined) { - expect(arrayItemsSchema.type).toBe("object"); - expect((arrayItemsSchema as any).additionalProperties).toBeUndefined(); - } +describe("media core", () => { + test("MediaBlob plain", async () => { + const blob = new Blob(["This is a test"], { type: "text/plain" }); + const mblob = await MediaBlob.fromBlob(blob); + expect(mblob.dataType).toEqual("text/plain"); + expect(mblob.mimetype).toEqual("text/plain"); + expect(mblob.encoding).toEqual("utf-8"); + expect(await mblob.asString()).toEqual("This is a test"); + }); + + test("MediaBlob charset", async () => { + const blob = new Blob(["This is a test"], { + type: "text/plain; charset=US-ASCII", + }); + const mblob = await MediaBlob.fromBlob(blob); + expect(mblob.dataType).toEqual("text/plain; charset=us-ascii"); + expect(mblob.mimetype).toEqual("text/plain"); + expect(mblob.encoding).toEqual("us-ascii"); + expect(await mblob.asString()).toEqual("This is a test"); + }); + + test("MediaBlob fromDataUrl", async () => { + const blobData = "This is a test"; + const blobMimeType = "text/plain"; + const blobDataType = `${blobMimeType}; charset=US-ASCII`; + const blob = new Blob([blobData], { + type: blobDataType, + }); + const mblob = await MediaBlob.fromBlob(blob); + const dataUrl = await mblob.asDataUrl(); + const dblob = MediaBlob.fromDataUrl(dataUrl); + expect(await dblob.asString()).toEqual(blobData); + expect(dblob.mimetype).toEqual(blobMimeType); + }); + + test("MediaBlob serialize", async () => { + const blob = new Blob(["This is a test"], { type: "text/plain" }); + const mblob = await MediaBlob.fromBlob(blob); + console.log("serialize mblob", mblob); + const serialized = mblob.toJSON() as SerializedConstructor; + console.log("serialized", serialized); + expect(serialized.kwargs).toHaveProperty("data"); + expect(serialized.kwargs.data.value).toEqual("VGhpcyBpcyBhIHRlc3Q="); + }); + + test("MediaBlob deserialize", async () => { + const serialized: SerializedConstructor = { + lc: 1, + type: "constructor", + id: [ + "langchain", + "google_common", + "experimental", + "utils", + "media_core", + "MediaBlob", + ], + kwargs: { + data: { + value: "VGhpcyBpcyBhIHRlc3Q=", + type: "text/plain", + }, + }, + }; + const mblob: MediaBlob = await load(JSON.stringify(serialized), { + importMap: { + google_common__experimental__utils__media_core: await import( + "../experimental/utils/media_core.js" + ), + }, + }); + console.log("deserialize mblob", mblob); + expect(mblob.dataType).toEqual("text/plain"); + expect(await mblob.asString()).toEqual("This is a test"); + }); + + test("SimpleWebBlobStore fetch", async () => { + const webStore = new SimpleWebBlobStore(); + const exampleBlob = await webStore.fetch("http://example.com/"); + console.log(exampleBlob); + expect(exampleBlob?.mimetype).toEqual("text/html"); + expect(exampleBlob?.encoding).toEqual("utf-8"); + expect(exampleBlob?.size).toBeGreaterThan(0); + expect(exampleBlob?.metadata).toBeDefined(); + expect(exampleBlob?.metadata?.ok).toBeTruthy(); + expect(exampleBlob?.metadata?.status).toEqual(200); + }); + + describe("BackedBlobStore", () => { + test("simple", async () => { + const backingStore = new InMemoryStore(); + const store = new BackedBlobStore({ + backingStore, + }); + const data = new Blob(["This is a test"], { type: "text/plain" }); + const path = "simple://foo"; + const blob = await MediaBlob.fromBlob(data, { path }); + const storedBlob = await store.store(blob); + expect(storedBlob).toBeDefined(); + const fetchedBlob = await store.fetch(path); + expect(fetchedBlob).toBeDefined(); + }); + + test("missing undefined", async () => { + const backingStore = new InMemoryStore(); + const store = new BackedBlobStore({ + backingStore, + }); + const path = "simple://foo"; + const fetchedBlob = await store.fetch(path); + expect(fetchedBlob).toBeUndefined(); + }); + + test("missing emptyBlob defaultConfig", async () => { + const backingStore = new InMemoryStore(); + const store = new BackedBlobStore({ + backingStore, + defaultFetchOptions: { + actionIfBlobMissing: "emptyBlob", + }, + }); + const path = "simple://foo"; + const fetchedBlob = await store.fetch(path); + expect(fetchedBlob).toBeDefined(); + expect(fetchedBlob?.size).toEqual(0); + expect(fetchedBlob?.path).toEqual(path); + }); + + test("missing undefined fetch", async () => { + const backingStore = new InMemoryStore(); + const store = new BackedBlobStore({ + backingStore, + defaultFetchOptions: { + actionIfBlobMissing: "emptyBlob", + }, + }); + const path = "simple://foo"; + const fetchedBlob = await store.fetch(path, { + actionIfBlobMissing: undefined, + }); + expect(fetchedBlob).toBeUndefined(); + }); + + test("invalid undefined", async () => { + const backingStore = new InMemoryStore(); + const store = new BackedBlobStore({ + backingStore, + defaultStoreOptions: { + pathPrefix: "example://bar/", + }, + }); + const path = "simple://foo"; + const data = new Blob(["This is a test"], { type: "text/plain" }); + const blob = await MediaBlob.fromBlob(data, { path }); + const storedBlob = await store.store(blob); + expect(storedBlob).toBeUndefined(); + }); + + test("invalid ignore", async () => { + const backingStore = new InMemoryStore(); + const store = new BackedBlobStore({ + backingStore, + defaultStoreOptions: { + actionIfInvalid: "ignore", + pathPrefix: "example://bar/", + }, + }); + const path = "simple://foo"; + const data = new Blob(["This is a test"], { type: "text/plain" }); + const blob = await MediaBlob.fromBlob(data, { path }); + const storedBlob = await store.store(blob); + expect(storedBlob).toBeDefined(); + expect(storedBlob?.path).toEqual(path); + expect(storedBlob?.metadata).toBeUndefined(); + }); + + test("invalid prefixPath", async () => { + const backingStore = new InMemoryStore(); + const store = new BackedBlobStore({ + backingStore, + defaultStoreOptions: { + actionIfInvalid: "prefixPath", + pathPrefix: "example://bar/", + }, + }); + const path = "simple://foo"; + const data = new Blob(["This is a test"], { type: "text/plain" }); + const blob = await MediaBlob.fromBlob(data, { path }); + const storedBlob = await store.store(blob); + expect(storedBlob?.path).toEqual("example://bar/foo"); + expect(await storedBlob?.asString()).toEqual("This is a test"); + expect(storedBlob?.metadata?.langchainOldPath).toEqual(path); + }); + + test("invalid prefixUuid", async () => { + const backingStore = new InMemoryStore(); + const store = new BackedBlobStore({ + backingStore, + defaultStoreOptions: { + actionIfInvalid: "prefixUuid4", + pathPrefix: "example://bar/", + }, + }); + const path = "simple://foo"; + const data = new Blob(["This is a test"], { type: "text/plain" }); + const metadata = { + alpha: "one", + bravo: "two", + }; + const blob = await MediaBlob.fromBlob(data, { path, metadata }); + const storedBlob = await store.store(blob); + expect(storedBlob?.path).toMatch( + /example:\/\/bar\/[a-f0-9]{8}(-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i + ); + expect(storedBlob?.size).toEqual(14); + expect(await storedBlob?.asString()).toEqual("This is a test"); + expect(storedBlob?.metadata?.alpha).toEqual("one"); + expect(storedBlob?.metadata?.langchainOldPath).toEqual(path); + }); + }); + + describe("MediaManager", () => { + class MemStore extends InMemoryStore { + get length() { + return Object.keys(this.store).length; + } + } + + let mediaManager: MediaManager; + let aliasMemory: MemStore; + let canonicalMemory: MemStore; + let resolverMemory: MemStore; + + async function store( + blobStore: BlobStore, + path: string, + text: string + ): Promise { + const data = new Blob([text], { type: "text/plain" }); + const blob = await MediaBlob.fromBlob(data, { path }); + await blobStore.store(blob); + } + + beforeEach(async () => { + aliasMemory = new MemStore(); + const aliasStore = new BackedBlobStore({ + backingStore: aliasMemory, + defaultFetchOptions: { + actionIfBlobMissing: undefined, + }, + }); + canonicalMemory = new MemStore(); + const canonicalStore = new BackedBlobStore({ + backingStore: canonicalMemory, + defaultStoreOptions: { + pathPrefix: "canonical://store/", + actionIfInvalid: "prefixPath", + }, + defaultFetchOptions: { + actionIfBlobMissing: undefined, + }, + }); + resolverMemory = new MemStore(); + const resolver = new BackedBlobStore({ + backingStore: resolverMemory, + defaultFetchOptions: { + actionIfBlobMissing: "emptyBlob", + }, + }); + const mediaStore = new ReadThroughBlobStore({ + baseStore: aliasStore, + backingStore: canonicalStore, + }); + mediaManager = new MediaManager({ + store: mediaStore, + resolvers: [resolver], + }); + await store(resolver, "resolve://host/foo", "fooing"); + await store(resolver, "resolve://host2/bar/baz", "barbazing"); + }); + + test("environment", async () => { + expect(resolverMemory.length).toEqual(2); + const fooBlob = await mediaManager.resolvers?.[0]?.fetch( + "resolve://host/foo" + ); + expect(await fooBlob?.asString()).toEqual("fooing"); + }); + + test("simple", async () => { + const uri = "resolve://host/foo"; + const curi = "canonical://store/host/foo"; + const blob = await mediaManager.getMediaBlob(uri); + expect(await blob?.asString()).toEqual("fooing"); + expect(blob?.path).toEqual(curi); + + // In the alias store, + // we should be able to fetch it by the resolve uri, but the + // path in the blob itself should be the canonical uri + expect(aliasMemory.length).toEqual(1); + const mediaStore: ReadThroughBlobStore = + mediaManager.store as ReadThroughBlobStore; + const aliasBlob = await mediaStore.baseStore.fetch(uri); + expect(aliasBlob).toBeDefined(); + expect(aliasBlob?.path).toEqual(curi); + expect(await aliasBlob?.asString()).toEqual("fooing"); + + // For the canonical store, + // fetching it by the resolve uri should fail + // but fetching it by the canonical uri should succeed + expect(canonicalMemory.length).toEqual(1); + const canonicalBlobU = await mediaStore.backingStore.fetch(uri); + expect(canonicalBlobU).toBeUndefined(); + const canonicalBlob = await mediaStore.backingStore.fetch(curi); + expect(canonicalBlob).toBeDefined(); + expect(canonicalBlob?.path).toEqual(curi); + expect(await canonicalBlob?.asString()).toEqual("fooing"); + }); + }); }); function toUint8Array(data: string): Uint8Array { diff --git a/libs/langchain-google-common/src/types.ts b/libs/langchain-google-common/src/types.ts index 7721b5136704..4fecd254693b 100644 --- a/libs/langchain-google-common/src/types.ts +++ b/libs/langchain-google-common/src/types.ts @@ -4,6 +4,7 @@ import type { BindToolsInput, } from "@langchain/core/language_models/chat_models"; import type { JsonStream } from "./utils/stream.js"; +import { MediaManager } from "./experimental/utils/media_core.js"; /** * Parameters needed to setup the client connection. @@ -147,7 +148,8 @@ export interface GoogleAIBaseLLMInput extends BaseLLMParams, GoogleConnectionParams, GoogleAIModelParams, - GoogleAISafetyParams {} + GoogleAISafetyParams, + GeminiAPIConfig {} export interface GoogleAIBaseLanguageModelCallOptions extends BaseChatModelCallOptions, @@ -172,6 +174,10 @@ export interface GoogleResponse { data: any; } +export interface GoogleRawResponse extends GoogleResponse { + data: Blob; +} + export interface GeminiPartText { text: string; } @@ -183,7 +189,6 @@ export interface GeminiPartInlineData { }; } -// Vertex AI only export interface GeminiPartFileData { fileData: { mimeType: string; @@ -342,3 +347,7 @@ export interface GeminiJsonSchemaDirty extends GeminiJsonSchema { properties?: Record; additionalProperties?: boolean; } + +export interface GeminiAPIConfig { + mediaManager?: MediaManager; +} diff --git a/libs/langchain-google-common/src/utils/gemini.ts b/libs/langchain-google-common/src/utils/gemini.ts index d230203a85de..aab0699cec56 100644 --- a/libs/langchain-google-common/src/utils/gemini.ts +++ b/libs/langchain-google-common/src/utils/gemini.ts @@ -19,7 +19,6 @@ import { ChatGeneration, ChatGenerationChunk, ChatResult, - Generation, } from "@langchain/core/outputs"; import { ToolCallChunk } from "@langchain/core/messages/tool"; import type { @@ -34,8 +33,32 @@ import type { GenerateContentResponseData, GoogleAISafetyHandler, GeminiPartFunctionCall, + GeminiAPIConfig, } from "../types.js"; import { GoogleAISafetyError } from "./safety.js"; +import { MediaBlob } from "../experimental/utils/media_core.js"; + +export interface FunctionCall { + name: string; + arguments: string; +} + +export interface ToolCall { + id: string; + type: "function"; + function: FunctionCall; +} + +export interface FunctionCallRaw { + name: string; + arguments: object; +} + +export interface ToolCallRaw { + id: string; + type: "function"; + function: FunctionCallRaw; +} const extractMimeType = ( str: string @@ -49,671 +72,686 @@ const extractMimeType = ( return null; }; -function messageContentText( - content: MessageContentText -): GeminiPartText | null { - if (content?.text && content?.text.length > 0) { - return { - text: content.text, - }; - } else { - return null; +export function getGeminiAPI(config?: GeminiAPIConfig) { + function messageContentText( + content: MessageContentText + ): GeminiPartText | null { + if (content?.text && content?.text.length > 0) { + return { + text: content.text, + }; + } else { + return null; + } } -} -function messageContentImageUrl( - content: MessageContentImageUrl -): GeminiPartInlineData | GeminiPartFileData { - const url: string = - typeof content.image_url === "string" - ? content.image_url - : content.image_url.url; - if (!url) { - throw new Error("Missing Image URL"); - } + function messageContentImageUrl( + content: MessageContentImageUrl + ): GeminiPartInlineData | GeminiPartFileData { + const url: string = + typeof content.image_url === "string" + ? content.image_url + : content.image_url.url; + if (!url) { + throw new Error("Missing Image URL"); + } - const mineTypeAndData = extractMimeType(url); - if (mineTypeAndData) { - return { - inlineData: mineTypeAndData, - }; - } else { - // FIXME - need some way to get mime type - return { - fileData: { - mimeType: "image/png", - fileUri: url, - }, - }; + const mineTypeAndData = extractMimeType(url); + if (mineTypeAndData) { + return { + inlineData: mineTypeAndData, + }; + } else { + // FIXME - need some way to get mime type + return { + fileData: { + mimeType: "image/png", + fileUri: url, + }, + }; + } } -} -function messageContentMedia( - // eslint-disable-next-line @typescript-eslint/no-explicit-any - content: Record -): GeminiPartInlineData | GeminiPartFileData { - if ("mimeType" in content && "data" in content) { - return { - inlineData: { - mimeType: content.mimeType, - data: content.data, - }, - }; - } else if ("mimeType" in content && "fileUri" in content) { + async function blobToFileData(blob: MediaBlob): Promise { return { fileData: { - mimeType: content.mimeType, - fileUri: content.fileUri, + fileUri: blob.path!, + mimeType: blob.mimetype, }, }; } - throw new Error("Invalid media content"); -} + async function fileUriContentToBlob( + uri: string + ): Promise { + return config?.mediaManager?.getMediaBlob(uri); + } -export function messageContentToParts(content: MessageContent): GeminiPart[] { - // Convert a string to a text type MessageContent if needed - const messageContent: MessageContent = - typeof content === "string" - ? [ - { - type: "text", - text: content, - }, - ] - : content; - - // eslint-disable-next-line array-callback-return - const parts: GeminiPart[] = messageContent - .map((content) => { - switch (content.type) { - case "text": - if ("text" in content) { - return messageContentText(content as MessageContentText); - } - break; - case "image_url": - if ("image_url" in content) { - // Type guard for MessageContentImageUrl - return messageContentImageUrl(content as MessageContentImageUrl); - } - break; - case "media": - return messageContentMedia(content); - default: - throw new Error( - `Unsupported type received while converting message to message parts` - ); - } - throw new Error( - `Cannot coerce "${content.type}" message part into a string.` - ); - }) - .reduce((acc: GeminiPart[], val: GeminiPart | null | undefined) => { - if (val) { - return [...acc, val]; - } else { - return acc; + async function messageContentMedia( + // eslint-disable-next-line @typescript-eslint/no-explicit-any + content: Record + ): Promise { + if ("mimeType" in content && "data" in content) { + return { + inlineData: { + mimeType: content.mimeType, + data: content.data, + }, + }; + } else if ("mimeType" in content && "fileUri" in content) { + return { + fileData: { + mimeType: content.mimeType, + fileUri: content.fileUri, + }, + }; + } else { + const uri = content.fileUri; + const blob = await fileUriContentToBlob(uri); + if (blob) { + return await blobToFileData(blob); } - }, []); - - return parts; -} + } -function messageToolCallsToParts(toolCalls: ToolCall[]): GeminiPart[] { - if (!toolCalls || toolCalls.length === 0) { - return []; + throw new Error("Invalid media content"); } - return toolCalls.map((tool: ToolCall) => { - let args = {}; - if (tool?.function?.arguments) { - const argStr = tool.function.arguments; - args = JSON.parse(argStr); + async function messageContentComplexToPart( + content: MessageContentComplex + ): Promise { + switch (content.type) { + case "text": + if ("text" in content) { + return messageContentText(content as MessageContentText); + } + break; + case "image_url": + if ("image_url" in content) { + // Type guard for MessageContentImageUrl + return messageContentImageUrl(content as MessageContentImageUrl); + } + break; + case "media": + return await messageContentMedia(content); + default: + throw new Error( + `Unsupported type received while converting message to message parts` + ); } - return { - functionCall: { - name: tool.function.name, - args, - }, - }; - }); -} + throw new Error( + `Cannot coerce "${content.type}" message part into a string.` + ); + } + + async function messageContentComplexToParts( + content: MessageContentComplex[] + ): Promise<(GeminiPart | null)[]> { + const contents = content.map(messageContentComplexToPart); + return Promise.all(contents); + } -function messageKwargsToParts(kwargs: Record): GeminiPart[] { - const ret: GeminiPart[] = []; + async function messageContentToParts( + content: MessageContent + ): Promise { + // Convert a string to a text type MessageContent if needed + const messageContent: MessageContentComplex[] = + typeof content === "string" + ? [ + { + type: "text", + text: content, + }, + ] + : content; + + // Get all of the parts, even those that don't correctly resolve + const allParts = await messageContentComplexToParts(messageContent); + + // Remove any invalid parts + const parts: GeminiPart[] = allParts.reduce( + (acc: GeminiPart[], val: GeminiPart | null | undefined) => { + if (val) { + return [...acc, val]; + } else { + return acc; + } + }, + [] + ); - if (kwargs?.tool_calls) { - ret.push(...messageToolCallsToParts(kwargs.tool_calls as ToolCall[])); + return parts; } - return ret; -} + function messageToolCallsToParts(toolCalls: ToolCall[]): GeminiPart[] { + if (!toolCalls || toolCalls.length === 0) { + return []; + } -function roleMessageToContent( - role: GeminiRole, - message: BaseMessage -): GeminiContent[] { - const contentParts: GeminiPart[] = messageContentToParts(message.content); - let toolParts: GeminiPart[]; - if (isAIMessage(message) && !!message.tool_calls?.length) { - toolParts = message.tool_calls.map( - (toolCall): GeminiPart => ({ + return toolCalls.map((tool: ToolCall) => { + let args = {}; + if (tool?.function?.arguments) { + const argStr = tool.function.arguments; + args = JSON.parse(argStr); + } + return { functionCall: { - name: toolCall.name, - args: toolCall.args, + name: tool.function.name, + args, }, - }) - ); - } else { - toolParts = messageKwargsToParts(message.additional_kwargs); - } - const parts: GeminiPart[] = [...contentParts, ...toolParts]; - return [ - { - role, - parts, - }, - ]; -} + }; + }); + } -function systemMessageToContent( - message: SystemMessage, - useSystemInstruction: boolean -): GeminiContent[] { - return useSystemInstruction - ? roleMessageToContent("system", message) - : [ - ...roleMessageToContent("user", message), - ...roleMessageToContent("model", new AIMessage("Ok")), - ]; -} + function messageKwargsToParts(kwargs: Record): GeminiPart[] { + const ret: GeminiPart[] = []; + + if (kwargs?.tool_calls) { + ret.push(...messageToolCallsToParts(kwargs.tool_calls as ToolCall[])); + } -function toolMessageToContent( - message: ToolMessage, - prevMessage: BaseMessage -): GeminiContent[] { - const contentStr = - typeof message.content === "string" - ? message.content - : message.content.reduce( - (acc: string, content: MessageContentComplex) => { - if (content.type === "text") { - return acc + content.text; - } else { - return acc; - } + return ret; + } + + async function roleMessageToContent( + role: GeminiRole, + message: BaseMessage + ): Promise { + const contentParts: GeminiPart[] = await messageContentToParts( + message.content + ); + let toolParts: GeminiPart[]; + if (isAIMessage(message) && !!message.tool_calls?.length) { + toolParts = message.tool_calls.map( + (toolCall): GeminiPart => ({ + functionCall: { + name: toolCall.name, + args: toolCall.args, }, - "" - ); - // Hacky :( - const responseName = - (isAIMessage(prevMessage) && !!prevMessage.tool_calls?.length - ? prevMessage.tool_calls[0].name - : prevMessage.name) ?? message.tool_call_id; - try { - const content = JSON.parse(contentStr); + }) + ); + } else { + toolParts = messageKwargsToParts(message.additional_kwargs); + } + const parts: GeminiPart[] = [...contentParts, ...toolParts]; return [ { - role: "function", - parts: [ - { - functionResponse: { - name: responseName, - response: { content }, - }, - }, - ], + role, + parts, }, ]; - } catch (_) { - return [ - { - role: "function", - parts: [ - { - functionResponse: { - name: responseName, - response: { content: contentStr }, + } + + async function systemMessageToContent( + message: SystemMessage, + useSystemInstruction: boolean + ): Promise { + return useSystemInstruction + ? roleMessageToContent("system", message) + : [ + ...(await roleMessageToContent("user", message)), + ...(await roleMessageToContent("model", new AIMessage("Ok"))), + ]; + } + + function toolMessageToContent( + message: ToolMessage, + prevMessage: BaseMessage + ): GeminiContent[] { + const contentStr = + typeof message.content === "string" + ? message.content + : message.content.reduce( + (acc: string, content: MessageContentComplex) => { + if (content.type === "text") { + return acc + content.text; + } else { + return acc; + } }, - }, - ], - }, - ]; + "" + ); + // Hacky :( + const responseName = + (isAIMessage(prevMessage) && !!prevMessage.tool_calls?.length + ? prevMessage.tool_calls[0].name + : prevMessage.name) ?? message.tool_call_id; + try { + const content = JSON.parse(contentStr); + return [ + { + role: "function", + parts: [ + { + functionResponse: { + name: responseName, + response: { content }, + }, + }, + ], + }, + ]; + } catch (_) { + return [ + { + role: "function", + parts: [ + { + functionResponse: { + name: responseName, + response: { content: contentStr }, + }, + }, + ], + }, + ]; + } } -} -export function baseMessageToContent( - message: BaseMessage, - prevMessage: BaseMessage | undefined, - useSystemInstruction: boolean -): GeminiContent[] { - const type = message._getType(); - switch (type) { - case "system": - return systemMessageToContent( - message as SystemMessage, - useSystemInstruction - ); - case "human": - return roleMessageToContent("user", message); - case "ai": - return roleMessageToContent("model", message); - case "tool": - if (!prevMessage) { - throw new Error( - "Tool messages cannot be the first message passed to the model." + async function baseMessageToContent( + message: BaseMessage, + prevMessage: BaseMessage | undefined, + useSystemInstruction: boolean + ): Promise { + const type = message._getType(); + switch (type) { + case "system": + return systemMessageToContent( + message as SystemMessage, + useSystemInstruction ); - } - return toolMessageToContent(message as ToolMessage, prevMessage); - default: - console.log(`Unsupported message type: ${type}`); - return []; + case "human": + return roleMessageToContent("user", message); + case "ai": + return roleMessageToContent("model", message); + case "tool": + if (!prevMessage) { + throw new Error( + "Tool messages cannot be the first message passed to the model." + ); + } + return toolMessageToContent(message as ToolMessage, prevMessage); + default: + console.log(`Unsupported message type: ${type}`); + return []; + } } -} -function textPartToMessageContent(part: GeminiPartText): MessageContentText { - return { - type: "text", - text: part.text, - }; -} + function textPartToMessageContent(part: GeminiPartText): MessageContentText { + return { + type: "text", + text: part.text, + }; + } -function inlineDataPartToMessageContent( - part: GeminiPartInlineData -): MessageContentImageUrl { - return { - type: "image_url", - image_url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`, - }; -} + function inlineDataPartToMessageContent( + part: GeminiPartInlineData + ): MessageContentImageUrl { + return { + type: "image_url", + image_url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`, + }; + } -function fileDataPartToMessageContent( - part: GeminiPartFileData -): MessageContentImageUrl { - return { - type: "image_url", - image_url: part.fileData.fileUri, - }; -} + function fileDataPartToMessageContent( + part: GeminiPartFileData + ): MessageContentImageUrl { + return { + type: "image_url", + image_url: part.fileData.fileUri, + }; + } -export function partsToMessageContent(parts: GeminiPart[]): MessageContent { - return parts - .map((part) => { - if (part === undefined || part === null) { - return null; - } else if ("text" in part) { - return textPartToMessageContent(part); - } else if ("inlineData" in part) { - return inlineDataPartToMessageContent(part); - } else if ("fileData" in part) { - return fileDataPartToMessageContent(part); - } else { - return null; - } - }) - .reduce((acc, content) => { - if (content) { - acc.push(content); - } - return acc; - }, [] as MessageContentComplex[]); -} + function partsToMessageContent(parts: GeminiPart[]): MessageContent { + return parts + .map((part) => { + if (part === undefined || part === null) { + return null; + } else if ("text" in part) { + return textPartToMessageContent(part); + } else if ("inlineData" in part) { + return inlineDataPartToMessageContent(part); + } else if ("fileData" in part) { + return fileDataPartToMessageContent(part); + } else { + return null; + } + }) + .reduce((acc, content) => { + if (content) { + acc.push(content); + } + return acc; + }, [] as MessageContentComplex[]); + } -interface FunctionCall { - name: string; - arguments: string; -} + function toolRawToTool(raw: ToolCallRaw): ToolCall { + return { + id: raw.id, + type: raw.type, + function: { + name: raw.function.name, + arguments: JSON.stringify(raw.function.arguments), + }, + }; + } -interface ToolCall { - id: string; - type: "function"; - function: FunctionCall; -} + function functionCallPartToToolRaw( + part: GeminiPartFunctionCall + ): ToolCallRaw { + return { + id: uuidv4().replace(/-/g, ""), + type: "function", + function: { + name: part.functionCall.name, + arguments: part.functionCall.args ?? {}, + }, + }; + } -interface FunctionCallRaw { - name: string; - arguments: object; -} + function partsToToolsRaw(parts: GeminiPart[]): ToolCallRaw[] { + return parts + .map((part: GeminiPart) => { + if (part === undefined || part === null) { + return null; + } else if ("functionCall" in part) { + return functionCallPartToToolRaw(part); + } else { + return null; + } + }) + .reduce((acc, content) => { + if (content) { + acc.push(content); + } + return acc; + }, [] as ToolCallRaw[]); + } -interface ToolCallRaw { - id: string; - type: "function"; - function: FunctionCallRaw; -} + function toolsRawToTools(raws: ToolCallRaw[]): ToolCall[] { + return raws.map((raw) => toolRawToTool(raw)); + } -function toolRawToTool(raw: ToolCallRaw): ToolCall { - return { - id: raw.id, - type: raw.type, - function: { - name: raw.function.name, - arguments: JSON.stringify(raw.function.arguments), - }, - }; -} + function responseToGenerateContentResponseData( + response: GoogleLLMResponse + ): GenerateContentResponseData { + if ("nextChunk" in response.data) { + throw new Error("Cannot convert Stream to GenerateContentResponseData"); + } else if (Array.isArray(response.data)) { + // Collapse the array of response data as if it was a single one + return response.data.reduce( + ( + acc: GenerateContentResponseData, + val: GenerateContentResponseData + ): GenerateContentResponseData => { + // Add all the parts + // FIXME: Handle other candidates? + const valParts = val?.candidates?.[0]?.content?.parts ?? []; + acc.candidates[0].content.parts.push(...valParts); + + // FIXME: Merge promptFeedback and safety settings + acc.promptFeedback = val.promptFeedback; + return acc; + } + ); + } else { + return response.data as GenerateContentResponseData; + } + } -function functionCallPartToToolRaw(part: GeminiPartFunctionCall): ToolCallRaw { - return { - id: uuidv4().replace(/-/g, ""), - type: "function", - function: { - name: part.functionCall.name, - arguments: part.functionCall.args ?? {}, - }, - }; -} + function responseToParts(response: GoogleLLMResponse): GeminiPart[] { + const responseData = responseToGenerateContentResponseData(response); + const parts = responseData?.candidates?.[0]?.content?.parts ?? []; + return parts; + } -export function partsToToolsRaw(parts: GeminiPart[]): ToolCallRaw[] { - return parts - .map((part: GeminiPart) => { - if (part === undefined || part === null) { - return null; - } else if ("functionCall" in part) { - return functionCallPartToToolRaw(part); - } else { - return null; - } - }) - .reduce((acc, content) => { - if (content) { - acc.push(content); - } - return acc; - }, [] as ToolCallRaw[]); -} + function partToText(part: GeminiPart): string { + return "text" in part ? part.text : ""; + } -export function toolsRawToTools(raws: ToolCallRaw[]): ToolCall[] { - return raws.map((raw) => toolRawToTool(raw)); -} + function responseToString(response: GoogleLLMResponse): string { + const parts = responseToParts(response); + const ret: string = parts.reduce((acc, part) => { + const val = partToText(part); + return acc + val; + }, ""); + return ret; + } -export function responseToGenerateContentResponseData( - response: GoogleLLMResponse -): GenerateContentResponseData { - if ("nextChunk" in response.data) { - throw new Error("Cannot convert Stream to GenerateContentResponseData"); - } else if (Array.isArray(response.data)) { - // Collapse the array of response data as if it was a single one - return response.data.reduce( - ( - acc: GenerateContentResponseData, - val: GenerateContentResponseData - ): GenerateContentResponseData => { - // Add all the parts - // FIXME: Handle other candidates? - const valParts = val?.candidates?.[0]?.content?.parts ?? []; - acc.candidates[0].content.parts.push(...valParts); - - // FIXME: Merge promptFeedback and safety settings - acc.promptFeedback = val.promptFeedback; - return acc; + function safeResponseTo( + response: GoogleLLMResponse, + safetyHandler: GoogleAISafetyHandler, + responseTo: (response: GoogleLLMResponse) => RetType + ): RetType { + try { + const safeResponse = safetyHandler.handle(response); + return responseTo(safeResponse); + } catch (xx) { + // eslint-disable-next-line no-instanceof/no-instanceof + if (xx instanceof GoogleAISafetyError) { + const ret = responseTo(xx.response); + xx.reply = ret; } - ); - } else { - return response.data as GenerateContentResponseData; + throw xx; + } } -} -export function responseToParts(response: GoogleLLMResponse): GeminiPart[] { - const responseData = responseToGenerateContentResponseData(response); - const parts = responseData?.candidates?.[0]?.content?.parts ?? []; - return parts; -} - -export function partToText(part: GeminiPart): string { - return "text" in part ? part.text : ""; -} - -export function responseToString(response: GoogleLLMResponse): string { - const parts = responseToParts(response); - const ret: string = parts.reduce((acc, part) => { - const val = partToText(part); - return acc + val; - }, ""); - return ret; -} + function safeResponseToString( + response: GoogleLLMResponse, + safetyHandler: GoogleAISafetyHandler + ): string { + return safeResponseTo(response, safetyHandler, responseToString); + } -function safeResponseTo( - response: GoogleLLMResponse, - safetyHandler: GoogleAISafetyHandler, - responseTo: (response: GoogleLLMResponse) => RetType -): RetType { - try { - const safeResponse = safetyHandler.handle(response); - return responseTo(safeResponse); - } catch (xx) { - // eslint-disable-next-line no-instanceof/no-instanceof - if (xx instanceof GoogleAISafetyError) { - const ret = responseTo(xx.response); - xx.reply = ret; + function responseToGenerationInfo(response: GoogleLLMResponse) { + if (!Array.isArray(response.data)) { + return {}; } - throw xx; + const data = response.data[0]; + return { + usage_metadata: { + prompt_token_count: data.usageMetadata?.promptTokenCount, + candidates_token_count: data.usageMetadata?.candidatesTokenCount, + total_token_count: data.usageMetadata?.totalTokenCount, + }, + safety_ratings: data.candidates[0]?.safetyRatings?.map((rating) => ({ + category: rating.category, + probability: rating.probability, + probability_score: rating.probabilityScore, + severity: rating.severity, + severity_score: rating.severityScore, + })), + finish_reason: data.candidates[0]?.finishReason, + }; } -} - -export function safeResponseToString( - response: GoogleLLMResponse, - safetyHandler: GoogleAISafetyHandler -): string { - return safeResponseTo(response, safetyHandler, responseToString); -} -export function responseToGenerationInfo(response: GoogleLLMResponse) { - if (!Array.isArray(response.data)) { - return {}; + function responseToChatGeneration( + response: GoogleLLMResponse + ): ChatGenerationChunk { + return new ChatGenerationChunk({ + text: responseToString(response), + message: partToMessageChunk(responseToParts(response)[0]), + generationInfo: responseToGenerationInfo(response), + }); } - const data = response.data[0]; - return { - usage_metadata: { - prompt_token_count: data.usageMetadata?.promptTokenCount, - candidates_token_count: data.usageMetadata?.candidatesTokenCount, - total_token_count: data.usageMetadata?.totalTokenCount, - }, - safety_ratings: data.candidates[0]?.safetyRatings?.map((rating) => ({ - category: rating.category, - probability: rating.probability, - probability_score: rating.probabilityScore, - severity: rating.severity, - severity_score: rating.severityScore, - })), - finish_reason: data.candidates[0]?.finishReason, - }; -} - -export function responseToGeneration(response: GoogleLLMResponse): Generation { - return { - text: responseToString(response), - generationInfo: responseToGenerationInfo(response), - }; -} - -export function safeResponseToGeneration( - response: GoogleLLMResponse, - safetyHandler: GoogleAISafetyHandler -): Generation { - return safeResponseTo(response, safetyHandler, responseToGeneration); -} -export function responseToChatGeneration( - response: GoogleLLMResponse -): ChatGenerationChunk { - return new ChatGenerationChunk({ - text: responseToString(response), - message: partToMessageChunk(responseToParts(response)[0]), - generationInfo: responseToGenerationInfo(response), - }); -} - -export function safeResponseToChatGeneration( - response: GoogleLLMResponse, - safetyHandler: GoogleAISafetyHandler -): ChatGenerationChunk { - return safeResponseTo(response, safetyHandler, responseToChatGeneration); -} + function safeResponseToChatGeneration( + response: GoogleLLMResponse, + safetyHandler: GoogleAISafetyHandler + ): ChatGenerationChunk { + return safeResponseTo(response, safetyHandler, responseToChatGeneration); + } -export function chunkToString(chunk: BaseMessageChunk): string { - if (chunk === null) { - return ""; - } else if (typeof chunk.content === "string") { - return chunk.content; - } else if (chunk.content.length === 0) { - return ""; - } else if (chunk.content[0].type === "text") { - return chunk.content[0].text; - } else { - throw new Error(`Unexpected chunk: ${chunk}`); + function chunkToString(chunk: BaseMessageChunk): string { + if (chunk === null) { + return ""; + } else if (typeof chunk.content === "string") { + return chunk.content; + } else if (chunk.content.length === 0) { + return ""; + } else if (chunk.content[0].type === "text") { + return chunk.content[0].text; + } else { + throw new Error(`Unexpected chunk: ${chunk}`); + } } -} -export function partToMessageChunk(part: GeminiPart): BaseMessageChunk { - const fields = partsToBaseMessageChunkFields([part]); - if (typeof fields.content === "string") { + function partToMessageChunk(part: GeminiPart): BaseMessageChunk { + const fields = partsToBaseMessageChunkFields([part]); + if (typeof fields.content === "string") { + return new AIMessageChunk(fields); + } else if (fields.content.every((item) => item.type === "text")) { + const newContent = fields.content + .map((item) => ("text" in item ? item.text : "")) + .join(""); + return new AIMessageChunk({ + ...fields, + content: newContent, + }); + } return new AIMessageChunk(fields); - } else if (fields.content.every((item) => item.type === "text")) { - const newContent = fields.content - .map((item) => ("text" in item ? item.text : "")) - .join(""); - return new AIMessageChunk({ - ...fields, - content: newContent, - }); } - return new AIMessageChunk(fields); -} -export function partToChatGeneration(part: GeminiPart): ChatGeneration { - const message = partToMessageChunk(part); - const text = partToText(part); - return new ChatGenerationChunk({ - text, - message, - }); -} + function partToChatGeneration(part: GeminiPart): ChatGeneration { + const message = partToMessageChunk(part); + const text = partToText(part); + return new ChatGenerationChunk({ + text, + message, + }); + } -export function responseToChatGenerations( - response: GoogleLLMResponse -): ChatGeneration[] { - const parts = responseToParts(response); - let ret = parts.map((part) => partToChatGeneration(part)); - if (ret.every((item) => typeof item.message.content === "string")) { - const combinedContent = ret.map((item) => item.message.content).join(""); - const combinedText = ret.map((item) => item.text).join(""); - const toolCallChunks: ToolCallChunk[] | undefined = ret[ - ret.length - 1 - ]?.message.additional_kwargs?.tool_calls?.map((toolCall, i) => ({ - name: toolCall.function.name, - args: toolCall.function.arguments, - id: toolCall.id, - index: i, - type: "tool_call_chunk", - })); - let usageMetadata: UsageMetadata | undefined; - if ("usageMetadata" in response.data) { - usageMetadata = { - input_tokens: response.data.usageMetadata.promptTokenCount as number, - output_tokens: response.data.usageMetadata - .candidatesTokenCount as number, - total_tokens: response.data.usageMetadata.totalTokenCount as number, - }; - } - ret = [ - new ChatGenerationChunk({ - message: new AIMessageChunk({ - content: combinedContent, - additional_kwargs: ret[ret.length - 1]?.message.additional_kwargs, - tool_call_chunks: toolCallChunks, - usage_metadata: usageMetadata, + function responseToChatGenerations( + response: GoogleLLMResponse + ): ChatGeneration[] { + const parts = responseToParts(response); + let ret = parts.map((part) => partToChatGeneration(part)); + if (ret.every((item) => typeof item.message.content === "string")) { + const combinedContent = ret.map((item) => item.message.content).join(""); + const combinedText = ret.map((item) => item.text).join(""); + const toolCallChunks: ToolCallChunk[] | undefined = ret[ + ret.length - 1 + ]?.message.additional_kwargs?.tool_calls?.map((toolCall, i) => ({ + name: toolCall.function.name, + args: toolCall.function.arguments, + id: toolCall.id, + index: i, + type: "tool_call_chunk", + })); + let usageMetadata: UsageMetadata | undefined; + if ("usageMetadata" in response.data) { + usageMetadata = { + input_tokens: response.data.usageMetadata.promptTokenCount as number, + output_tokens: response.data.usageMetadata + .candidatesTokenCount as number, + total_tokens: response.data.usageMetadata.totalTokenCount as number, + }; + } + ret = [ + new ChatGenerationChunk({ + message: new AIMessageChunk({ + content: combinedContent, + additional_kwargs: ret[ret.length - 1]?.message.additional_kwargs, + tool_call_chunks: toolCallChunks, + usage_metadata: usageMetadata, + }), + text: combinedText, + generationInfo: ret[ret.length - 1].generationInfo, }), - text: combinedText, - generationInfo: ret[ret.length - 1].generationInfo, - }), - ]; + ]; + } + return ret; } - return ret; -} - -export function responseToBaseMessageFields( - response: GoogleLLMResponse -): BaseMessageFields { - const parts = responseToParts(response); - return partsToBaseMessageChunkFields(parts); -} -export function partsToBaseMessageChunkFields( - parts: GeminiPart[] -): AIMessageChunkFields { - const fields: AIMessageChunkFields = { - content: partsToMessageContent(parts), - tool_call_chunks: [], - tool_calls: [], - invalid_tool_calls: [], - }; + function responseToBaseMessageFields( + response: GoogleLLMResponse + ): BaseMessageFields { + const parts = responseToParts(response); + return partsToBaseMessageChunkFields(parts); + } - const rawTools = partsToToolsRaw(parts); - if (rawTools.length > 0) { - const tools = toolsRawToTools(rawTools); - for (const tool of tools) { - fields.tool_call_chunks?.push({ - name: tool.function.name, - args: tool.function.arguments, - id: tool.id, - type: "tool_call_chunk", - }); + function partsToBaseMessageChunkFields( + parts: GeminiPart[] + ): AIMessageChunkFields { + const fields: AIMessageChunkFields = { + content: partsToMessageContent(parts), + tool_call_chunks: [], + tool_calls: [], + invalid_tool_calls: [], + }; - try { - fields.tool_calls?.push({ - name: tool.function.name, - args: JSON.parse(tool.function.arguments), - id: tool.id, - type: "tool_call", - }); - // eslint-disable-next-line @typescript-eslint/no-explicit-any - } catch (e: any) { - fields.invalid_tool_calls?.push({ + const rawTools = partsToToolsRaw(parts); + if (rawTools.length > 0) { + const tools = toolsRawToTools(rawTools); + for (const tool of tools) { + fields.tool_call_chunks?.push({ name: tool.function.name, args: tool.function.arguments, id: tool.id, - error: e.message, - type: "invalid_tool_call", + type: "tool_call_chunk", }); + + try { + fields.tool_calls?.push({ + name: tool.function.name, + args: JSON.parse(tool.function.arguments), + id: tool.id, + }); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } catch (e: any) { + fields.invalid_tool_calls?.push({ + name: tool.function.name, + args: tool.function.arguments, + id: tool.id, + error: e.message, + type: "invalid_tool_call", + }); + } } + fields.additional_kwargs = { + tool_calls: tools, + }; } - fields.additional_kwargs = { - tool_calls: tools, - }; + return fields; } - return fields; -} -export function responseToBaseMessage( - response: GoogleLLMResponse -): BaseMessage { - const fields = responseToBaseMessageFields(response); - return new AIMessage(fields); -} + function responseToBaseMessage(response: GoogleLLMResponse): BaseMessage { + const fields = responseToBaseMessageFields(response); + return new AIMessage(fields); + } -export function safeResponseToBaseMessage( - response: GoogleLLMResponse, - safetyHandler: GoogleAISafetyHandler -): BaseMessage { - return safeResponseTo(response, safetyHandler, responseToBaseMessage); -} + function safeResponseToBaseMessage( + response: GoogleLLMResponse, + safetyHandler: GoogleAISafetyHandler + ): BaseMessage { + return safeResponseTo(response, safetyHandler, responseToBaseMessage); + } + + function responseToChatResult(response: GoogleLLMResponse): ChatResult { + const generations = responseToChatGenerations(response); + return { + generations, + llmOutput: responseToGenerationInfo(response), + }; + } + + function safeResponseToChatResult( + response: GoogleLLMResponse, + safetyHandler: GoogleAISafetyHandler + ): ChatResult { + return safeResponseTo(response, safetyHandler, responseToChatResult); + } -export function responseToChatResult(response: GoogleLLMResponse): ChatResult { - const generations = responseToChatGenerations(response); return { - generations, - llmOutput: responseToGenerationInfo(response), + messageContentToParts, + baseMessageToContent, + safeResponseToString, + safeResponseToChatGeneration, + chunkToString, + safeResponseToBaseMessage, + safeResponseToChatResult, }; } -export function safeResponseToChatResult( - response: GoogleLLMResponse, - safetyHandler: GoogleAISafetyHandler -): ChatResult { - return safeResponseTo(response, safetyHandler, responseToChatResult); -} - export function validateGeminiParams(params: GoogleAIModelParams): void { if (params.maxOutputTokens && params.maxOutputTokens < 0) { throw new Error("`maxOutputTokens` must be a positive integer"); diff --git a/libs/langchain-google-gauth/src/index.ts b/libs/langchain-google-gauth/src/index.ts index 7f420a4ed6d0..4cd6bd0176ab 100644 --- a/libs/langchain-google-gauth/src/index.ts +++ b/libs/langchain-google-gauth/src/index.ts @@ -1,3 +1,5 @@ export * from "./chat_models.js"; export * from "./llms.js"; export * from "./embeddings.js"; + +export * from "./media.js"; diff --git a/libs/langchain-google-gauth/src/media.ts b/libs/langchain-google-gauth/src/media.ts new file mode 100644 index 000000000000..b44aadd0f858 --- /dev/null +++ b/libs/langchain-google-gauth/src/media.ts @@ -0,0 +1,31 @@ +import { GoogleAbstractedClient } from "@langchain/google-common"; +import { + BlobStoreGoogleCloudStorageBase, + BlobStoreGoogleCloudStorageBaseParams, + BlobStoreAIStudioFileBase, + BlobStoreAIStudioFileBaseParams, +} from "@langchain/google-common/experimental/media"; +import { GoogleAuthOptions } from "google-auth-library"; +import { GAuthClient } from "./auth.js"; + +export interface BlobStoreGoogleCloudStorageParams + extends BlobStoreGoogleCloudStorageBaseParams {} + +export class BlobStoreGoogleCloudStorage extends BlobStoreGoogleCloudStorageBase { + buildClient( + fields?: BlobStoreGoogleCloudStorageParams + ): GoogleAbstractedClient { + return new GAuthClient(fields); + } +} + +export interface BlobStoreAIStudioFileParams + extends BlobStoreAIStudioFileBaseParams {} + +export class BlobStoreAIStudioFile extends BlobStoreAIStudioFileBase { + buildAbstractedClient( + fields?: BlobStoreAIStudioFileParams + ): GoogleAbstractedClient { + return new GAuthClient(fields); + } +} diff --git a/libs/langchain-google-gauth/src/tests/chat_models.int.test.ts b/libs/langchain-google-gauth/src/tests/chat_models.int.test.ts new file mode 100644 index 000000000000..5baa6aaf1973 --- /dev/null +++ b/libs/langchain-google-gauth/src/tests/chat_models.int.test.ts @@ -0,0 +1,315 @@ +import { test } from "@jest/globals"; +import { BaseLanguageModelInput } from "@langchain/core/language_models/base"; +import { ChatPromptValue } from "@langchain/core/prompt_values"; +import { + AIMessage, + AIMessageChunk, + BaseMessage, + BaseMessageChunk, + BaseMessageLike, + HumanMessage, + HumanMessageChunk, + MessageContentComplex, + SystemMessage, + ToolMessage, +} from "@langchain/core/messages"; +import { + BackedBlobStore, + MediaBlob, + MediaManager, + ReadThroughBlobStore, + SimpleWebBlobStore, +} from "@langchain/google-common/experimental/utils/media_core"; +import { GoogleCloudStorageUri } from "@langchain/google-common/experimental/media"; +import { InMemoryStore } from "@langchain/core/stores"; +import { GeminiTool } from "../types.js"; +import { ChatGoogle } from "../chat_models.js"; +import { BlobStoreGoogleCloudStorage } from "../media.js"; + +describe("GAuth Chat", () => { + test("invoke", async () => { + const model = new ChatGoogle(); + try { + const res = await model.invoke("What is 1 + 1?"); + expect(res).toBeDefined(); + expect(res._getType()).toEqual("ai"); + + const aiMessage = res as AIMessageChunk; + expect(aiMessage.content).toBeDefined(); + + expect(typeof aiMessage.content).toBe("string"); + const text = aiMessage.content as string; + expect(text).toMatch(/(1 + 1 (equals|is|=) )?2.? ?/); + + /* + expect(aiMessage.content.length).toBeGreaterThan(0); + expect(aiMessage.content[0]).toBeDefined(); + const content = aiMessage.content[0] as MessageContentComplex; + expect(content).toHaveProperty("type"); + expect(content.type).toEqual("text"); + + const textContent = content as MessageContentText; + expect(textContent.text).toBeDefined(); + expect(textContent.text).toEqual("2"); + */ + } catch (e) { + console.error(e); + throw e; + } + }); + + test("generate", async () => { + const model = new ChatGoogle(); + try { + const messages: BaseMessage[] = [ + new SystemMessage( + "You will reply to all requests to flip a coin with either H, indicating heads, or T, indicating tails." + ), + new HumanMessage("Flip it"), + new AIMessage("T"), + new HumanMessage("Flip the coin again"), + ]; + const res = await model.predictMessages(messages); + expect(res).toBeDefined(); + expect(res._getType()).toEqual("ai"); + + const aiMessage = res as AIMessageChunk; + expect(aiMessage.content).toBeDefined(); + + expect(typeof aiMessage.content).toBe("string"); + const text = aiMessage.content as string; + expect(["H", "T"]).toContainEqual(text); + + /* + expect(aiMessage.content.length).toBeGreaterThan(0); + expect(aiMessage.content[0]).toBeDefined(); + + const content = aiMessage.content[0] as MessageContentComplex; + expect(content).toHaveProperty("type"); + expect(content.type).toEqual("text"); + + const textContent = content as MessageContentText; + expect(textContent.text).toBeDefined(); + expect(["H", "T"]).toContainEqual(textContent.text); + */ + } catch (e) { + console.error(e); + throw e; + } + }); + + test("stream", async () => { + const model = new ChatGoogle(); + try { + const input: BaseLanguageModelInput = new ChatPromptValue([ + new SystemMessage( + "You will reply to all requests to flip a coin with either H, indicating heads, or T, indicating tails." + ), + new HumanMessage("Flip it"), + new AIMessage("T"), + new HumanMessage("Flip the coin again"), + ]); + const res = await model.stream(input); + const resArray: BaseMessageChunk[] = []; + for await (const chunk of res) { + resArray.push(chunk); + } + expect(resArray).toBeDefined(); + expect(resArray.length).toBeGreaterThanOrEqual(1); + + const lastChunk = resArray[resArray.length - 1]; + expect(lastChunk).toBeDefined(); + expect(lastChunk._getType()).toEqual("ai"); + const aiChunk = lastChunk as AIMessageChunk; + console.log(aiChunk); + + console.log(JSON.stringify(resArray, null, 2)); + } catch (e) { + console.error(e); + throw e; + } + }); + + test("function", async () => { + const tools: GeminiTool[] = [ + { + functionDeclarations: [ + { + name: "test", + description: + "Run a test with a specific name and get if it passed or failed", + parameters: { + type: "object", + properties: { + testName: { + type: "string", + description: "The name of the test that should be run.", + }, + }, + required: ["testName"], + }, + }, + ], + }, + ]; + const model = new ChatGoogle().bind({ tools }); + const result = await model.invoke("Run a test on the cobalt project"); + expect(result).toHaveProperty("content"); + expect(result.content).toBe(""); + const args = result?.lc_kwargs?.additional_kwargs; + expect(args).toBeDefined(); + expect(args).toHaveProperty("tool_calls"); + expect(Array.isArray(args.tool_calls)).toBeTruthy(); + expect(args.tool_calls).toHaveLength(1); + const call = args.tool_calls[0]; + expect(call).toHaveProperty("type"); + expect(call.type).toBe("function"); + expect(call).toHaveProperty("function"); + const func = call.function; + expect(func).toBeDefined(); + expect(func).toHaveProperty("name"); + expect(func.name).toBe("test"); + expect(func).toHaveProperty("arguments"); + expect(typeof func.arguments).toBe("string"); + expect(func.arguments.replaceAll("\n", "")).toBe('{"testName":"cobalt"}'); + }); + + test("function reply", async () => { + const tools: GeminiTool[] = [ + { + functionDeclarations: [ + { + name: "test", + description: + "Run a test with a specific name and get if it passed or failed", + parameters: { + type: "object", + properties: { + testName: { + type: "string", + description: "The name of the test that should be run.", + }, + }, + required: ["testName"], + }, + }, + ], + }, + ]; + const model = new ChatGoogle().bind({ tools }); + const toolResult = { + testPassed: true, + }; + const messages: BaseMessageLike[] = [ + new HumanMessage("Run a test on the cobalt project."), + new AIMessage("", { + tool_calls: [ + { + id: "test", + type: "function", + function: { + name: "test", + arguments: '{"testName":"cobalt"}', + }, + }, + ], + }), + new ToolMessage(JSON.stringify(toolResult), "test"), + ]; + const res = await model.stream(messages); + const resArray: BaseMessageChunk[] = []; + for await (const chunk of res) { + resArray.push(chunk); + } + console.log(JSON.stringify(resArray, null, 2)); + }); + + test("withStructuredOutput", async () => { + const tool = { + name: "get_weather", + description: + "Get the weather of a specific location and return the temperature in Celsius.", + parameters: { + type: "object", + properties: { + location: { + type: "string", + description: "The name of city to get the weather for.", + }, + }, + required: ["location"], + }, + }; + const model = new ChatGoogle().withStructuredOutput(tool); + const result = await model.invoke("What is the weather in Paris?"); + expect(result).toHaveProperty("location"); + }); + + test("media - fileData", async () => { + class MemStore extends InMemoryStore { + get length() { + return Object.keys(this.store).length; + } + } + const aliasMemory = new MemStore(); + const aliasStore = new BackedBlobStore({ + backingStore: aliasMemory, + defaultFetchOptions: { + actionIfBlobMissing: undefined, + }, + }); + const canonicalStore = new BlobStoreGoogleCloudStorage({ + uriPrefix: new GoogleCloudStorageUri("gs://test-langchainjs/mediatest/"), + defaultStoreOptions: { + actionIfInvalid: "prefixPath", + }, + }); + const blobStore = new ReadThroughBlobStore({ + baseStore: aliasStore, + backingStore: canonicalStore, + }); + const resolver = new SimpleWebBlobStore(); + const mediaManager = new MediaManager({ + store: blobStore, + resolvers: [resolver], + }); + const model = new ChatGoogle({ + modelName: "gemini-1.5-flash", + mediaManager, + }); + + const message: MessageContentComplex[] = [ + { + type: "text", + text: "What is in this image?", + }, + { + type: "media", + fileUri: "https://js.langchain.com/v0.2/img/brand/wordmark.png", + }, + ]; + + const messages: BaseMessage[] = [ + new HumanMessageChunk({ content: message }), + ]; + + try { + const res = await model.invoke(messages); + + console.log(res); + + expect(res).toBeDefined(); + expect(res._getType()).toEqual("ai"); + + const aiMessage = res as AIMessageChunk; + expect(aiMessage.content).toBeDefined(); + + expect(typeof aiMessage.content).toBe("string"); + const text = aiMessage.content as string; + expect(text).toMatch(/LangChain/); + } catch (e) { + console.error(e); + throw e; + } + }); +}); diff --git a/libs/langchain-google-gauth/src/tests/data/blue-square.png b/libs/langchain-google-gauth/src/tests/data/blue-square.png new file mode 100644 index 0000000000000000000000000000000000000000..c64355dc335b834aaa2a97d25ed2c02195cb8400 GIT binary patch literal 176 zcmeAS@N?(olHy`uVBq!ia0vp^AT}2V6Od#Ih`sf3npoC79rQ=8##bNvY8S|xv6<2KrRD=b5UwyNotBhd1gt5g1e`0K#E=} zJ5XHB)5S4F;&Sqz|Nrfo^9~$o5Z~aSvA#C`g330_j{?_hCtT_g`6 { + test("save text no-metadata", async () => { + const uriPrefix = new GoogleCloudStorageUri("gs://test-langchainjs/"); + const uri = `gs://test-langchainjs/text/test-${Date.now()}-nm`; + const content = "This is a test"; + const blob = await MediaBlob.fromBlob( + new Blob([content], { type: "text/plain" }), + { + path: uri, + } + ); + const config: BlobStoreGoogleCloudStorageParams = { + uriPrefix, + }; + const blobStore = new BlobStoreGoogleCloudStorage(config); + const storedBlob = await blobStore.store(blob); + // console.log(storedBlob); + expect(storedBlob?.path).toEqual(uri); + expect(await storedBlob?.asString()).toEqual(content); + expect(storedBlob?.mimetype).toEqual("text/plain"); + expect(storedBlob?.metadata).not.toHaveProperty("metadata"); + expect(storedBlob?.size).toEqual(content.length); + expect(storedBlob?.metadata?.kind).toEqual("storage#object"); + }); + + test("save text with-metadata", async () => { + const uriPrefix = new GoogleCloudStorageUri("gs://test-langchainjs/"); + const uri = `gs://test-langchainjs/text/test-${Date.now()}-wm`; + const content = "This is a test"; + const blob = await MediaBlob.fromBlob( + new Blob([content], { type: "text/plain" }), + { + path: uri, + metadata: { + alpha: "one", + bravo: "two", + }, + } + ); + const config: BlobStoreGoogleCloudStorageParams = { + uriPrefix, + }; + const blobStore = new BlobStoreGoogleCloudStorage(config); + const storedBlob = await blobStore.store(blob); + // console.log(storedBlob); + expect(storedBlob?.path).toEqual(uri); + expect(await storedBlob?.asString()).toEqual(content); + expect(storedBlob?.mimetype).toEqual("text/plain"); + expect(storedBlob?.metadata).toHaveProperty("metadata"); + expect(storedBlob?.metadata?.metadata?.alpha).toEqual("one"); + expect(storedBlob?.metadata?.metadata?.bravo).toEqual("two"); + expect(storedBlob?.size).toEqual(content.length); + expect(storedBlob?.metadata?.kind).toEqual("storage#object"); + }); + + test("save image no-metadata", async () => { + const filename = `src/tests/data/blue-square.png`; + const dataBuffer = await fs.readFile(filename); + const data = new Blob([dataBuffer], { type: "image/png" }); + + const uriPrefix = new GoogleCloudStorageUri("gs://test-langchainjs/"); + const uri = `gs://test-langchainjs/image/test-${Date.now()}-nm`; + const blob = await MediaBlob.fromBlob(data, { + path: uri, + }); + const config: BlobStoreGoogleCloudStorageParams = { + uriPrefix, + }; + const blobStore = new BlobStoreGoogleCloudStorage(config); + const storedBlob = await blobStore.store(blob); + // console.log(storedBlob); + expect(storedBlob?.path).toEqual(uri); + expect(storedBlob?.size).toEqual(176); + expect(storedBlob?.mimetype).toEqual("image/png"); + expect(storedBlob?.metadata?.kind).toEqual("storage#object"); + }); + + test("get text no-metadata", async () => { + const uriPrefix = new GoogleCloudStorageUri("gs://test-langchainjs/"); + const uri: string = "gs://test-langchainjs/text/test-nm"; + const config: BlobStoreGoogleCloudStorageParams = { + uriPrefix, + }; + const blobStore = new BlobStoreGoogleCloudStorage(config); + const blob = await blobStore.fetch(uri); + // console.log(blob); + expect(blob?.path).toEqual(uri); + expect(await blob?.asString()).toEqual("This is a test"); + expect(blob?.mimetype).toEqual("text/plain"); + expect(blob?.metadata).not.toHaveProperty("metadata"); + expect(blob?.size).toEqual(14); + expect(blob?.metadata?.kind).toEqual("storage#object"); + }); + + test("get text with-metadata", async () => { + const uriPrefix = new GoogleCloudStorageUri("gs://test-langchainjs/"); + const uri: string = "gs://test-langchainjs/text/test-wm"; + const config: BlobStoreGoogleCloudStorageParams = { + uriPrefix, + }; + const blobStore = new BlobStoreGoogleCloudStorage(config); + const blob = await blobStore.fetch(uri); + // console.log(blob); + expect(blob?.path).toEqual(uri); + expect(await blob?.asString()).toEqual("This is a test"); + expect(blob?.mimetype).toEqual("text/plain"); + expect(blob?.metadata).toHaveProperty("metadata"); + expect(blob?.metadata?.metadata?.alpha).toEqual("one"); + expect(blob?.metadata?.metadata?.bravo).toEqual("two"); + expect(blob?.size).toEqual(14); + expect(blob?.metadata?.kind).toEqual("storage#object"); + }); + + test("get image no-metadata", async () => { + const uriPrefix = new GoogleCloudStorageUri("gs://test-langchainjs/"); + const uri: string = "gs://test-langchainjs/image/test-nm"; + const config: BlobStoreGoogleCloudStorageParams = { + uriPrefix, + }; + const blobStore = new BlobStoreGoogleCloudStorage(config); + const blob = await blobStore.fetch(uri); + // console.log(storedBlob); + expect(blob?.path).toEqual(uri); + expect(blob?.size).toEqual(176); + expect(blob?.mimetype).toEqual("image/png"); + expect(blob?.metadata?.kind).toEqual("storage#object"); + }); +}); diff --git a/libs/langchain-google-vertexai/src/tests/chat_models.int.test.ts b/libs/langchain-google-vertexai/src/tests/chat_models.int.test.ts index a5b9b1001218..8eeed770fee2 100644 --- a/libs/langchain-google-vertexai/src/tests/chat_models.int.test.ts +++ b/libs/langchain-google-vertexai/src/tests/chat_models.int.test.ts @@ -9,16 +9,31 @@ import { BaseMessageChunk, BaseMessageLike, HumanMessage, + HumanMessageChunk, + MessageContentComplex, SystemMessage, ToolMessage, } from "@langchain/core/messages"; +import { + BlobStoreGoogleCloudStorage, + ChatGoogle, +} from "@langchain/google-gauth"; import { tool } from "@langchain/core/tools"; import { z } from "zod"; import { concat } from "@langchain/core/utils/stream"; +import { + BackedBlobStore, + MediaBlob, + MediaManager, + ReadThroughBlobStore, + SimpleWebBlobStore, +} from "@langchain/google-common/experimental/utils/media_core"; +import { GoogleCloudStorageUri } from "@langchain/google-common/experimental/media"; import { ChatPromptTemplate, MessagesPlaceholder, } from "@langchain/core/prompts"; +import { InMemoryStore } from "@langchain/core/stores"; import { GeminiTool } from "../types.js"; import { ChatVertexAI } from "../chat_models.js"; @@ -196,6 +211,74 @@ describe("GAuth Chat", () => { const result = await model.invoke("What is the weather in Paris?"); expect(result).toHaveProperty("location"); }); + + test("media - fileData", async () => { + class MemStore extends InMemoryStore { + get length() { + return Object.keys(this.store).length; + } + } + const aliasMemory = new MemStore(); + const aliasStore = new BackedBlobStore({ + backingStore: aliasMemory, + defaultFetchOptions: { + actionIfBlobMissing: undefined, + }, + }); + const canonicalStore = new BlobStoreGoogleCloudStorage({ + uriPrefix: new GoogleCloudStorageUri("gs://test-langchainjs/mediatest/"), + defaultStoreOptions: { + actionIfInvalid: "prefixPath", + }, + }); + const blobStore = new ReadThroughBlobStore({ + baseStore: aliasStore, + backingStore: canonicalStore, + }); + const resolver = new SimpleWebBlobStore(); + const mediaManager = new MediaManager({ + store: blobStore, + resolvers: [resolver], + }); + const model = new ChatGoogle({ + modelName: "gemini-1.5-flash", + mediaManager, + }); + + const message: MessageContentComplex[] = [ + { + type: "text", + text: "What is in this image?", + }, + { + type: "media", + fileUri: "https://js.langchain.com/v0.2/img/brand/wordmark.png", + }, + ]; + + const messages: BaseMessage[] = [ + new HumanMessageChunk({ content: message }), + ]; + + try { + const res = await model.invoke(messages); + + console.log(res); + + expect(res).toBeDefined(); + expect(res._getType()).toEqual("ai"); + + const aiMessage = res as AIMessageChunk; + expect(aiMessage.content).toBeDefined(); + + expect(typeof aiMessage.content).toBe("string"); + const text = aiMessage.content as string; + expect(text).toMatch(/LangChain/); + } catch (e) { + console.error(e); + throw e; + } + }); }); test("Stream token count usage_metadata", async () => { diff --git a/libs/langchain-google-webauth/package.json b/libs/langchain-google-webauth/package.json index 320f731a088b..a6830b7eac5d 100644 --- a/libs/langchain-google-webauth/package.json +++ b/libs/langchain-google-webauth/package.json @@ -58,7 +58,8 @@ "release-it": "^17.6.0", "rollup": "^4.5.2", "ts-jest": "^29.1.0", - "typescript": "<5.2.0" + "typescript": "<5.2.0", + "zod": "^3.23.8" }, "publishConfig": { "access": "public" diff --git a/libs/langchain-google-webauth/src/media.ts b/libs/langchain-google-webauth/src/media.ts new file mode 100644 index 000000000000..4b631b519d31 --- /dev/null +++ b/libs/langchain-google-webauth/src/media.ts @@ -0,0 +1,33 @@ +import { + GoogleAbstractedClient, + GoogleBaseLLMInput, +} from "@langchain/google-common"; +import { + BlobStoreAIStudioFileBase, + BlobStoreAIStudioFileBaseParams, + BlobStoreGoogleCloudStorageBase, + BlobStoreGoogleCloudStorageBaseParams, +} from "@langchain/google-common/experimental/media"; +import { WebGoogleAuth, WebGoogleAuthOptions } from "./auth.js"; + +export interface BlobStoreGoogleCloudStorageParams + extends BlobStoreGoogleCloudStorageBaseParams {} + +export class BlobStoreGoogleCloudStorage extends BlobStoreGoogleCloudStorageBase { + buildClient( + fields?: GoogleBaseLLMInput + ): GoogleAbstractedClient { + return new WebGoogleAuth(fields); + } +} + +export interface BlobStoreAIStudioFileParams + extends BlobStoreAIStudioFileBaseParams {} + +export class BlobStoreAIStudioFile extends BlobStoreAIStudioFileBase { + buildAbstractedClient( + fields?: BlobStoreAIStudioFileParams + ): GoogleAbstractedClient { + return new WebGoogleAuth(fields); + } +} diff --git a/libs/langchain-google-webauth/src/tests/chat_models.int.test.ts b/libs/langchain-google-webauth/src/tests/chat_models.int.test.ts new file mode 100644 index 000000000000..60fcba032d18 --- /dev/null +++ b/libs/langchain-google-webauth/src/tests/chat_models.int.test.ts @@ -0,0 +1,247 @@ +/* eslint-disable import/no-extraneous-dependencies */ +import { StructuredTool } from "@langchain/core/tools"; +import { z } from "zod"; +import { test } from "@jest/globals"; +import { + AIMessage, + AIMessageChunk, + BaseMessage, + BaseMessageChunk, + HumanMessage, + HumanMessageChunk, + MessageContentComplex, + SystemMessage, + ToolMessage, +} from "@langchain/core/messages"; +import { BaseLanguageModelInput } from "@langchain/core/language_models/base"; +import { ChatPromptValue } from "@langchain/core/prompt_values"; +import { + MediaManager, + SimpleWebBlobStore, +} from "@langchain/google-common/experimental/utils/media_core"; +import { ChatGoogle } from "../chat_models.js"; +import { BlobStoreAIStudioFile } from "../media.js"; + +class WeatherTool extends StructuredTool { + schema = z.object({ + locations: z + .array(z.object({ name: z.string() })) + .describe("The name of cities to get the weather for."), + }); + + description = + "Get the weather of a specific location and return the temperature in Celsius."; + + name = "get_weather"; + + async _call(input: z.infer) { + console.log(`WeatherTool called with input: ${input}`); + return `The weather in ${JSON.stringify(input.locations)} is 25°C`; + } +} + +describe("Google APIKey Chat", () => { + test("invoke", async () => { + const model = new ChatGoogle(); + try { + const res = await model.invoke("What is 1 + 1?"); + console.log(res); + expect(res).toBeDefined(); + expect(res._getType()).toEqual("ai"); + + const aiMessage = res as AIMessageChunk; + console.log(aiMessage); + expect(aiMessage.content).toBeDefined(); + expect(aiMessage.content.length).toBeGreaterThan(0); + expect(aiMessage.content[0]).toBeDefined(); + + // const content = aiMessage.content[0] as MessageContentComplex; + // expect(content).toHaveProperty("type"); + // expect(content.type).toEqual("text"); + + // const textContent = content as MessageContentText; + // expect(textContent.text).toBeDefined(); + // expect(textContent.text).toEqual("2"); + } catch (e) { + console.error(e); + throw e; + } + }); + + test("generate", async () => { + const model = new ChatGoogle(); + try { + const messages: BaseMessage[] = [ + new SystemMessage( + "You will reply to all requests to flip a coin with either H, indicating heads, or T, indicating tails." + ), + new HumanMessage("Flip it"), + new AIMessage("T"), + new HumanMessage("Flip the coin again"), + ]; + const res = await model.predictMessages(messages); + expect(res).toBeDefined(); + expect(res._getType()).toEqual("ai"); + + const aiMessage = res as AIMessageChunk; + expect(aiMessage.content).toBeDefined(); + expect(aiMessage.content.length).toBeGreaterThan(0); + expect(aiMessage.content[0]).toBeDefined(); + console.log(aiMessage); + + // const content = aiMessage.content[0] as MessageContentComplex; + // expect(content).toHaveProperty("type"); + // expect(content.type).toEqual("text"); + + // const textContent = content as MessageContentText; + // expect(textContent.text).toBeDefined(); + // expect(["H", "T"]).toContainEqual(textContent.text); + } catch (e) { + console.error(e); + throw e; + } + }); + + test("stream", async () => { + const model = new ChatGoogle(); + try { + const input: BaseLanguageModelInput = new ChatPromptValue([ + new SystemMessage( + "You will reply to all requests to flip a coin with either H, indicating heads, or T, indicating tails." + ), + new HumanMessage("Flip it"), + new AIMessage("T"), + new HumanMessage("Flip the coin again"), + ]); + const res = await model.stream(input); + const resArray: BaseMessageChunk[] = []; + for await (const chunk of res) { + resArray.push(chunk); + } + expect(resArray).toBeDefined(); + expect(resArray.length).toBeGreaterThanOrEqual(1); + + const lastChunk = resArray[resArray.length - 1]; + expect(lastChunk).toBeDefined(); + expect(lastChunk._getType()).toEqual("ai"); + const aiChunk = lastChunk as AIMessageChunk; + console.log(aiChunk); + + console.log(JSON.stringify(resArray, null, 2)); + } catch (e) { + console.error(e); + throw e; + } + }); + + test.skip("Tool call", async () => { + const chat = new ChatGoogle().bindTools([new WeatherTool()]); + const res = await chat.invoke("What is the weather in SF and LA"); + console.log(res); + expect(res.tool_calls?.length).toEqual(1); + expect(res.tool_calls?.[0].args).toEqual( + JSON.parse(res.additional_kwargs.tool_calls?.[0].function.arguments ?? "") + ); + }); + + test.skip("Few shotting with tool calls", async () => { + const chat = new ChatGoogle().bindTools([new WeatherTool()]); + const res = await chat.invoke("What is the weather in SF"); + console.log(res); + const res2 = await chat.invoke([ + new HumanMessage("What is the weather in SF?"), + new AIMessage({ + content: "", + tool_calls: [ + { + id: "12345", + name: "get_current_weather", + args: { + location: "SF", + }, + }, + ], + }), + new ToolMessage({ + tool_call_id: "12345", + content: "It is currently 24 degrees with hail in SF.", + }), + new AIMessage("It is currently 24 degrees in SF with hail in SF."), + new HumanMessage("What did you say the weather was?"), + ]); + console.log(res2); + expect(res2.content).toContain("24"); + }); + + test.skip("withStructuredOutput", async () => { + const tool = { + name: "get_weather", + description: + "Get the weather of a specific location and return the temperature in Celsius.", + parameters: { + type: "object", + properties: { + location: { + type: "string", + description: "The name of city to get the weather for.", + }, + }, + required: ["location"], + }, + }; + const model = new ChatGoogle().withStructuredOutput(tool); + const result = await model.invoke("What is the weather in Paris?"); + expect(result).toHaveProperty("location"); + }); + + test("media - fileData", async () => { + const canonicalStore = new BlobStoreAIStudioFile({}); + const resolver = new SimpleWebBlobStore(); + const mediaManager = new MediaManager({ + store: canonicalStore, + resolvers: [resolver], + }); + const model = new ChatGoogle({ + modelName: "gemini-1.5-flash", + apiVersion: "v1beta", + mediaManager, + }); + + const message: MessageContentComplex[] = [ + { + type: "text", + text: "What is in this image?", + }, + { + type: "media", + fileUri: "https://js.langchain.com/v0.2/img/brand/wordmark.png", + }, + ]; + + const messages: BaseMessage[] = [ + new HumanMessageChunk({ content: message }), + ]; + + try { + const res = await model.invoke(messages); + + // console.log(res); + + expect(res).toBeDefined(); + expect(res._getType()).toEqual("ai"); + + const aiMessage = res as AIMessageChunk; + expect(aiMessage.content).toBeDefined(); + + expect(typeof aiMessage.content).toBe("string"); + const text = aiMessage.content as string; + expect(text).toMatch(/LangChain/); + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } catch (e: any) { + console.error(e); + console.error(JSON.stringify(e.details, null, 1)); + throw e; + } + }); +}); diff --git a/libs/langchain-google-webauth/src/tests/data/blue-square.png b/libs/langchain-google-webauth/src/tests/data/blue-square.png new file mode 100644 index 0000000000000000000000000000000000000000..c64355dc335b834aaa2a97d25ed2c02195cb8400 GIT binary patch literal 176 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ª?<6!C5X;px>3mn_Tte` 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 z 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

Y=oMoh&vBXrT*I0V*)?h?TB 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

($(1kXs;4A(Q|^N*2_1x$UZLO$Y-i5y@+Tr z-0rP0@V3^}G7>)DR4g9#y`S$&EJ&oF8h9c>D*P93IqPQWF^lTixuvcP^n!kcGCcqBD5JF(D`F(fS-l$?g9A{)-kE+jxQJw3M0Vhh#CgY|p%)f!OcI)M z6`u9smKf9)dPWpJil5^-%e*-hG+zz}_Z+f&`GU3-CDs%Dp6nPnyDYN!*+T5g1H3 zR4`zCRxXOMOYc1#7kr!=HkRX~N42)XHlt@TAhsF&ccKL+Q`X z>>3!4Ie^5=GJ234II`{}bO=mj;+bYJ`nsYpRrcck5fq6^Yg8_>SyfK|LN&JRK@HbLdWHLOqhVJFnZjlfJ z{K)=&9n~~4SN1M4Oa(~xAnRi!7g^3YK?D~*uX>s!jqYm!sq2bQwjk^Djk6RF9}0#; zb0vk9h`S4b{{w+UwKueA9MApTJglK;t4=WQnkv8x$659w z_O&9QFU8kdHyQ&ZOib2~$ZzxfrcfAigF?u&_6I^b?fslSElPA3m#q4QwnoNiCc(|x zXn!@o=}LJ<(a^Ee*Di7t7LZQCo)HM*5ME{Y^L-Iy9Q~IUK+m5~Un)H_+kX2cR|~%L zktL!9_0TWBu;=stT0u2d@`hIAwnAUwCFP&&(x|BAp!sR3MeBOx1p%j&%)Pks45_KEj3Y(ZmOl481 z=C|GrE0k~%hvM3Qyv@soiWKz=nfd(flTL*0d5U<3hCZa|4BTs@HQc`2OzkK* zk+XCStF~S0Jk3y5yX1aW+~1Um$ggMQq=Z`!@uzq`v1UNVl;p@|zLsiS1^yoAv69V> zO3XwU$d~;gco=zOds-&GOPCi$l)iRlo!Hqnc)H>*Y0nq{O`pZHafl`FlTQViO+JU1 z#0TF|$CNgS`ki<_HB3a(moi8V000KHL7Sp)03|!fP{K6P?nHAkC8!z@IU~kBs5a-% z7@K*e`rrjSl1)`pg-EM#r&p97Gz*%LjUC`;(1WQmz%_q!sAOE>vKgn{o($d}CB@j| zBC6_wGZ?8fZSb8&OoOE5U}Dk+)ez%SMVJ+WfiH*9jn}>dEB3ewc_DQ-Kby z)<0k3Bwha6bS01TmFne69 zP+wq(eSCZ8hm;T5fJF&PV`lMnv>C|fN#H4Y2|wEb3fKgplMt*X#s0(9I9SZ zn^U=p(kM8-y(#6qK1XNe^_(F3bLYb170teAowDXHDsur!^rCgX6AlbMPH~|RlD|dU zI-aZY7tyntp&fgry|7zwY`4I9lFAEW&0Z7&?~sA7-phV?R518|)y&6Lrgds{hR!~X zJEYsB9>lj-HL?7QZh>MzX820JJQR~vi1*blUGgAANp*=@TVunC7)7dfJF){wn^kkp#Kc zo7gzxn21hG?TeeJ2+-Fmgwi_q)Hg3n^);sv>bs5{p%@<@AVN~#QL{p&!yBdja-Ln@ z&tie+s0(`902#4NCNp>#gi+c5o=vM(!%1K2}W=_+Ez#XC*JYq{(1B1oTug`iOnAD`d@@IO^Hp-EX zlSuvjj4|#;4?`3cjl`=-#MAb3)ph=bbbKI9faFNN!KQBg{@?jBvi#hB0{*W5uBjeRX!*L!_Xf!| z4LJ+ilLo!vbxG%y53} zOD3s>Q3;Ic9l{wQ*?DJRMG=qAFdUy$tD}p>A#4H(YCE*Yf*$)MZK-wiqSWcXZe@O;R$-AadVTH9KdAR-y@>pSdc!k-Rykzaic zg0d?^ftlMwq?16*kPxa=nS3C*(7_+3o~8lL*JBQ_h3QtcOi|1($2mOluGBIYs1_B5GzB|lpUab2|H8K<7O)+xqM17LEa zWB81%j`_u=iGIbWkO@_lt5%2KxLR0KxzLbbGl39Km^pY&8}&;G|GG=mZv}#a5|#RC z;k4=b4quLeVxd~K-?!6ZI1OB{R#y#N3#K|zS||BrPO`eaR|Fy+8mDEIfG$!y^p zP6?+Ko$F4aM_mnRLcC5cu9#CO;hB*X7AhC2h3MGg1FM5fqTy25hZ})64^${tbTbs$ zN0KGe%Gdefxr|@r(uP^lltWPo=u~!Vis>15Q;||YELm6-$*@bfVh>h^xxdBX6s;b~ zIgfYE;>`*CSw&mQcaBJ5SoUuIj}!YTsFfnFRYWiYd3ZH$g}9?N1%C5%ca?gQx&KKV zp%Iv!!4z(7^H8%jAXQ<(P2-b0v;xRw=V9|(=iAwrrJFb3{ZVlt-0J$X6jP#}+uKAQ z513oe#0tYpPi)MSu+&%y3vdjh2`Tj;{w7eCVD@yadK2kZa}P=g&Xy4xV1W6!b?S-S z0qRWt9GZ4#cl~8zilSZ@1?|(Su;BvDJtJ@dWVJUhy{|w!YL5O03(Q&q3BwtS)ORjY zv<)C5_%-H|1f2dDBokJS9T}%UbkkP|G9-PhiQ6j&uz`yJF$+RsLNzDyINM?r>Z)Pb z37xE>bZ6pz=3#I7S7R|MM$jXQS zWe~bg7Ck|ODP5#9<~eHH1WX#}U;z#oDMJCUk7=N(3GR-XPnwz{i$UOJxv`$a)om;< zvxSnbr;4w@(SAn*P|6k(E5bmD2Uo9{Izx;F?S}IDSmpHDr&PpYGOVP%-Bq>&y*2Lc z=ELWOjH@Vcc2qWHWnD;2QktCQ>>xp2hP!XfBjo%1;VZ zJ3amVRs((WI6sDP;MzYe7iPJH?JbxsG0Xm?6K4@=--ifB-=C4HVsta^l`@f%>pzGK z-|4sPVWWbKu7xjRHDBc9@9}3e>4yCv*D9xiWo!7R2A@3-k+-@b)O=fY1c?%8pDWTl zIE1he2LfQc8xObR@q`7foZ8>o00@-0Tx!}nb1@>?zjD40f)qSpPWZKZq@wkzHfqr9J92>m!+A#@B*^iUqvC5%NCUxHeZ3bw-i zrRBADk+IEvzG)~tsD+&|@7Tfd5x>;0;JOZxB+5ASuJ6(TvD9Ei360+P%-$ZYfiLLw zj?)}eo+al4l4j`6H*s*-;K|``vg|XOj{3GteV+k%pFDeQflh$Y6zR=(mq+N;oY^Ra zS)la2eu(elaACXOV?;Bdh%v{H(-p{*jTZ!Ux#@mKo@ zKm)G|4-}&^>SEA{@9f)srk5O|Q7Te^JWbX#suKDAW?EwHZ41nM#+sxBvTf4fy6HE< zmP=lZ*>%8o_sB<&6wX4W=%Bnp^$q~()DgXsa1R{8Q=!(@g+YQYzhnd2Ku409KiNU7 z3WG#m)jL3FFUE{IJyBwO%81neK`TSKKL1i{BlY^`V9@H625>3Dc3!^#Tdn?EUlWxoMRM>XU%RbYtcj3 zjw(s9BMkSOB7)*K%=!>WL8ts|MghE&iHqgbBm0Vk)*U`uQRPEkQo*B0<9rj8MX@zZ znJ9NK#eR}-csF!&Vn*99_4`T#Fy&*TqICO*?YXqs%JJjOPd|i7zOOdI8I@5 zX$Ud`9OaZEdi$9L>V}T*4NUUhT*DrRJ;<(huQUqrf^+PG)vM& zmJgEX0I?#7IYRG`?ii7%AiA}z@|7fJV$KB@k0G)pHt%&_4y-60RO3dG%~l~7Er5fq zK_&)L3L=Ag(U!*ib|)^k=KicniDzHEk{5(v+|ng`=1VF`QkDNBM>VFJpFiuZhw@3( zvLh>Zt|}!LjCN7O0>s0`3iZa`i8Z3@1~0(SKLic2Orbvh^`VS+RQ7zrkK@F&{vrhu z7=^8_%IKJ8Sxnv$s&v;W^Dw#JUT%f4)+6hcANuDjCwQCZ)?CbRTcHcCn;)wHfsk~9 zi7f31p*tijoegzY0^^=@qCD{Nv{T7gB&d<`3xg{U|MUrQJw>V^LjW1_#+rE(H~c3> z9RL{+z{5M&T$$ERi`0g^+r5EaR>(0c^{h+dD0XprYD9 zfRyMxw-VtR7qxzg+kI47e>)b;enG&W9G!WkqeV z9){{U??UA{`fRI2S^Hm60~2?+pV*tLwAH%L8NAe=LzsSREH9bY5M9G*6^Ks+0X#-9 zWB1KX5l~Ra{$rCx28Pq{omMirny93x;XQtiz$S2jj3g1(S-CLTTsxKpz6~<;^&%b= ztoJ|?n}<7HI4f#kCqPR^AJb;#EJQ(z;Ms~YdLJ^!*W!=X{+1~!1OkA{v;|S$T5{eX zibT39h+Mcfx&K|}C5kT2weX%74qWATy*qlM0g*4gT}t^9`Pj=(1=J4>5L zmrSnLlapa?49-?6v5jROs9ZnPclz$9D$1#$fXP|gy&yBc;eqk49sW-cZ++`xHb85N zb#p+&!L{@e4v42%{7@AIPc9kDqs6q%^j=p*=QdMeqZFBpb+=xs*C_MSP`b;icf_I< zgN>F!e*6&t*B$#%Nu;N7e24F_dEJhFolGzl=Jo%({sV;>>5mp`#QtB=5Z(Qb{=#Zn zg~&vCf=dfg|W3CY03)JV%9?QaUT(+F)IYa6*q)H(kJ9z)+WUghRZeU@=r zNB|2siKPa?Z?9Dvg=XP>=)+=jKw8}JQM|0nLI_n~S6+aQnZ2I5#H}a3b#;XuO=EOf z9+RYuZbue7zhf}Cxih!DzU%OyKR=Sk^S!g9Eh!^--q84E5mU_>^#^^DTr*7JSsS@Y zsP+ESIsUHLy0t36mN#{hz7ej^m(I$0l?IzJI+p$O?7&2+`FxzNnVJ^qC5qzaE_G>F zQMMzQvpiL4mk&3vG~!B`kdq zJDE4Jo2QB1a*0P@0Axk<1x8cqc4)e8%$nO*jDSU;qsQ2L^s!r+C_oL^zzWnHh1Wdy zt};Z5ILqSwM%44+SVNJNmGX7M_q(}>_i){nLT|6XWMno2UkBh499}2(>uIB5qfbZ_ z$~CX1`a=#4rm{5ec^M>19DLt)s+Z#vkpI=ZPjED5>82@(i^;~#hQ(D=KRrU}S}*G) z`oba*-Z5>NDzLDF8@7Nq63OG@1`4T=yFEa&!T4m<%p8fa&e#fFBB%EkZI~E%QUbtn z6Qg!_Mc^=!)xLUl^y^FU`6D2lx9YA<4=c~VHB|=1dE-`oN%{82 zf*GI*v-(8I1NX1K4(uGH=nt7^g}2*;Hh@J%v;`2%e6;j!%)s+z3?ha}dnWN{m?`{ho-N z_{+!FZm*ZR ziEK0;j7k`R4h4TekgVYeJG=t%d^lc`$nPZfUHf|@3Q3<8>N2T28){oine9ZLK?qGY z3Sn*5n060cAiv={^;f>ErlHnqSM@-f?GW}4dYh&zBhieEs7@s@1H+R`bt%vF4gsx$ zJcLG7({W_rYvf7JLRFe=!g0;vP7xI&WcQXzndua!0m-QDH448vdNfz!XJR8}C| z&(#UHU-uZB{00wk)M+;6B=a7`%0juyV#oTfneRaz$)Z8f|rP3jE4&V|qqYGC%XB1S-ZF?? z*1^xG+`swd78>h_H?Ejta94(hgduKgObwl!ZWxw~7sZMFhi3PfxRg|;M-#7rtlah! z-PKYN!|CDVl=-k8FpX;G2y!~SBt~ZHh~mqZAH(s`%R5d|m;u?QMvJ#%&V)p6{~cGp z2D~0e)gH}T3#A6|{T)EP`C8ntqI1n~>*k>eR6wB+oKTgJsf~>p2-L&=w?`n%1XOR; z?|r9EzGLMgPc>829lYR&UkFYL1df#Pw7+yaK0t|ST|{oq7cxh8 z&@UXV+7d+gXY^L3xP4j!&ah}HI3Ccz)CBT;6%aIuz)A>$B%0lqBf9~3?Li$I;;^_TQ54A^%-G5D(=m1H##^(o*LL>C$8>P`T<%b|na{)b2 zCx_M{`uM@AC8EQQU&Biw0obJm-W_UYlXE~Dd&k4Ws)9HVFBo3#gD=+l<{_*sz3i%2 z?L-G@<@^>NWR@&nxEf{&d2KjASp`N4cJ0q7PCU~IJWW%*M#<;<7C*&+VmHIRyt%`f zK^X7;N#>S`G3ff@va6v^7}GWj(k66C31GT_MbUj1s3d((k<>lUpedD&8SPwFax+a+ z1U+!r?DS`jO-&St0%@RFq1f$heb%lnf>Uh5JuxNb^@YH<3zU@>1Lz;K2((+ISGxHF3^^a}iZftCcE1tnp++@{+Uuq(P{CwzHC&iv5xihY2+>+b)kXl-9nU%#uaZ)%UqR0+4H3S^xk=`sbL@uI{&aLy0=>&RgN8N2TP5nOBJo)eEJ4UzvtAjSq#1AZd2?3= z3m>Yd){`2An-iuLj4>l0{g2W?``X*t`H3{=F>2b!PL0<;S*|L_0I^NVR+KjTPQ3h{ zLS)YW*k=}1lMtc_nJ&&wHjQ+%ZRU46)SiS;gTwpX&)8_U^0R_}B{ z+VlH8-nf+4^XCfax``pAug98A3uYV9qk+&o43lJY&^0+`n$++SVE(i*7%L6tr}Go1 zYI&wYKQa3@Zv6ukzfq7go@etiJ-Merr|YC&i2XMwz2IV@7=nDy)f}fw<8n?yaFh&n zhE^$*HiK50h5|vLEo?_>v~hY;U)j{2iToFy&?u9afhIb?W zF&R#|i$E0@xii|Zoq4HbuB5isz!p;Ad-sAoHCegA;J8h6eOU@pe9@{qbG2mjn5p~- zanMAXW2{xP5t`PPPg1vEHS3dhgQp3sK+7$=xBhVG`9Hli9g^=*o=+J+zE<^{pJPuX z+kb^RF2Ms4l2xSO+~$=+G-q*JhnfK8IlDQY>go}D_~P@G23_z)$e0aR1u&WfO`ubQ zszFp%$-jwQOb`*?1$F?-E*WYlwbX6 zhReMmP_&W@v^jW&{F6FHVjunmNs!g?Trk9D(nEamWYBy5|CLg!Az;$axvk`~OJG{E zfa(-tjX@0X(bx4`$d2a9Jyt=1s5deWIka{Kn%V|KWr#9+fF>1v532;#T}8}(n)n)P zBCpvJcMhO0e{5kGU$&@3-!b81QZRT1M z-3Vg*SJl{&Np0%d;Oh;3%@(<<)?r&YB0X{qY~xex1=jis+Z`nUF1Ntoa?Plk6o>&T z=44UtcgH_9&OC`rg3WexFl3jawYp(VLxhzXkm)^1f>Ck9&zj9ER9O66P7|1MycQU3D6maGcL_IEs@?kF2cBCg;JEdHWa=XU2_t3H-xNtWYs#-0P0q>dVK0% zD};D7?{364a`zuG5Vw{7(5n}B`skTJzkGB*M-MOk2n;0SA54d_&cP0U$}XI9jg5ik z5GF*n%z$${bzYdPV)d)qAD-u zWaq(*ns;bGRl)O|BzC{bM=^?J#m+t6QvPYt#mPU>(_qK1D*;Clm15xf~>Q zGubpH+(S2P>fNv{T^SVn?(q7nnZ1Mpu%I49-9>{wPIB%J8z+R;(JSL@OZTeZjb2;m zj!F|f3YyoM#F*wsv(VC+?qvO2$fQPj1*V7!|6)oQ%1wZ>n!R0_lSl(*6<3o?Afvx= zd?ecKMWa_jO3uaZ4Z1ZTY}JcYGajV15qNYqGk^e&#ueWqlcpfe)4n@Givi03sgF|B zizRw;&d9-TcOodNBZ@$Kb4M1#z`?qv|6m`!%feIrz%glZw2*4w*N;8ZX}9gi8m&>s zwNAA-U}8#M_rJw`JqMd2I_mpz*fbpy;P{I`(jZIi{%Q507#BBiADyq0#}ah z?OfO37fHKC$qU5tyfHRsd+Q>!Y&DfEDh$|9nOlKvl8njTJ{Lyzz6j!}HHcnd+r(=| z9^rMuSbQKNzY!bvKs+p5W}y#} z-jK;c7Mw=S2H#!sn>YL90El{#ZUmfjFanS5@V8rh*VTCpr$83ayT3|zq?e>WE*X#$ zPI@n8)_J*m==x(3Ac(v2hQDpYopbb6KPn)6!Wf!thw<>!(8`_QQH6`wjCygdC*Hdn zj=r_#lUj~n91b{$A+(^;PXWmqCvf84&jZsgnG!4OSTiG-6GEnB}AvFO`3^j`;Q_8*q*`|RCc*Cl_%E-4XfG3>gwsv+bM8vj! z+1x+3Dz`F`$st3fFc;F{>3<|`(w&L@pI$7BsrzFq3!@qYr&o0LB!Y%n4s#4 zp4uJh{dKORFruPV$4kcgaq5wpq^2gNUAKhDq^a%Z#RY#P6yHYm&ye*3YIAkV46#%3 z)tc!>cZ7e!Y#4F=ehO0(0>@^JADC=%XIH=kS*h%A;M9JL%TRRFB7%w6Wnq!VxHrk4CTVmJgE7_~)_Z zpdfI&3A+BMbUaj=ucZ6;7?mUXTQ~UJ+TKKEkJMwJY7%A^jMA}M>gG|SY019N9hjxl zKEv-COO2B7a)eQ?_zsR`}m-y*;uq!^SOS#bLmWrf9%B~>RF#p9;gn5 z|B&LAssfpMcpZl(SYv7n0nEhMS2DK4l}d>DpLmw`NRB?d)sm~@4?XY}8u#0wQa=EL ztW|C^R4xFL=d|2mwsjdyJLgs$Nup>;<~+hks3f4+a|8%fen`W#-m38L7<1*3yQ;0D znN=lt10V^k{FQxcDIBLF#IUBu&P-gyrpT02y?Z)q0j7g|%C=MwZ4GjNe*gnJg78Fc zMt*J607HT1tb^99i7hbYi&S9}qGn9C9B_}Oo@y&Hu~}2?iXdmKF#d8lJ&^Eoa;sI} zBs8vj{x-Tp7yPUF{A}Vu1TXvGtxYceX!zRZx!}sW*d@p!*_N08g#^e^9OL;++LncT z;jYF77}Kk~TbzmOAyAkjX=gK-+D@I%^}dU#B63ypAu*hR+)G1l2ZCdZxq84Bs?*&<)SXG9wk){tg7#jicsb(!*?$P=)w zW)>qAiF`~Zf)tA6Zn@*yRgp;$PR0XexxKsZp#RUas-jEx)8DM=Tz;A{&7d0yoXvEjQqAM5P&PDxWi7ZbB)7yv&9~O=fQ4Ce*o^y z{%hZzB&%luTE6Im!v!;OCooQxI9vvNqpu%s$T%=D{Kfxq5~vmP2Smx+0DU@={cUZN z>|aA@bFWGgqG%8(U-O<(CT{*rPRun;9yomGT%hY7Y}~q>g<6 znQrlT9s8QpGglI|_eeTqMvOA?5t<&{@)lK8>g59WfXjHnx2 zlqrX+#Dl-vVX{xJ4#_q22SaIfSzgDNlGlKsCqYmmtF0!rep8fSTa(7 z+;?7GONaO~BHn7C-@GJ^0$2$&)dTM^n~P>_Njj=iGMu95puvY*Auc%?5PrQ{4cqXg z6C7MeTC#c;<8*6z;+I+g-`X*`4I4h^9$pmj-TDeQ^eaN7pH12&*Dj1jv7-ka+W6^d z0{drDac7^0sc9KNcOq{`nzL1<#*_?>HimHlJj5&n?k{`Elb{mRgWe3%jpA3nsZKpR zZUs(rh1$T7-}KlnWn}X)ursI0(v8R|reL??#uYnylI@eGnKXg0odY@p4jIr}CO}sS zvVIADV6pcJL2;30TGJ=W*)?MEE^g#4=5tq^`3}(Xk({?zu~a1t*OH-uM0||=RRBW% zVCxsPB7*IEhWAcN-6xuW^t#(z))*5S0l>4Vr+BtBVEbNo(ld9*emStdCHcarp^vvQ zgaw>8hizRhy}v_RD8;71WJlSAP<|w`#Hff3Xu#og>69I8{jYyonB+BzLFEGr6sku{5R_r zKna@&9pbh}}@{CQMxduYM0$(AI(IdjNh`iZq>F=m`5eAB>WPWmcDctSpo5^~LYOF&|MqLWq{=iwTlk=+~gUeV2G+)&0l%?R*e*diN z?v)6bab8!f%c=F)%FgUA%Fq+U)5)67ows6NCb2WQ*l11OL@?$_0B^M1nOo8g*QB4f z#rj?22?cC!22zxU-y`ert*Yhs;@C14(~8ci_eH%L9-OvK1jc|WPU9kK(~Yl$0l3w_ z`i#lnT~p~Z3R33iZ~bjz%$^>3O?cChTpe&OXxH-@f%}V1%rbV=llJGrf{=q~(-?HT zKWdTE{TWv?n?KBXJ3@1td2b&`lUOLToh=EQVG@u&e)QnJ16{ZOxjQ81`Mr{}#ZySpEDJS;Rt{YBEctRoGm zX&TdNSYZVbK*Tx$Jcv);g~{nxCA!9o)-cZjThBa8aRAyMjnUbaBIu)_mBK4Kaliwb zJ)*J3xxoAWM!p&8rQv#FT5CJ$|}-D@;oDJ+0~TWiYl7#%hK-{ zJmznvIgo;)ni#2`fq7(+I1W2|(g@r0z%goEr6lRMGS7Q{L->u$i7RYUWfIiTE95tM zQy%OormaA035l||k8-Z=(~Fou>Vm|cZTkO=DmT+qIOM_#TSCG~qKa&(U<+rk25Z8( z13qwMN}favBz*q_s$Sca1O_o_KG`p8!)xp^cCy}4Im2GFVL6z0IoxW}nJE}c&J z{)+n~zoFR+@e}_TQHxiI{X=0veQY|_`FO-h@kdTnz^sK@`!e?Wa{wt#CfNNpk|VEq zrum}`02;UJWi@YsMEr{-E8cZJBvc;iSDPT=t#IXCbCULwA^OAmt_FL{5QhSa+C){zae6R=Bp*#kA zyfegip6rKwMgqmp^nt;pQGal%x_COp&O6Krp_KcG#ouBs@4^j*EoQ=BP!_lw!W|zc z08tn1#MYHjocrPo^s8??$d3C=L{1ZfU9l+*{YWKS@9AG31gE16iS((U0TE)0fd*oY z2Et8Sn3v*%CSY%PYT)I(eONLV(ai-ie|5B(M^@}k(a*>AYI%majfvpv3O@<@sw0aj zU0YhWj})?U@c9EH&9?c2+@H#78Jt)va~h@q00pW+o8nIZp-#O-rl!I?S}<>DCK{Yt z`}{D7I2&>|IR5!DF?qNRp4h4o+#ks05wLyLG}pe$-5re`iYT~rFG%x)WZ3O}W<=JW zjK^!e;yl<_)|iZC9bjTkf*F7tanC8~dYb8KXU{WM_4-*zetl&nT9&5eN&UfUimq2T z?rS+=X%Z6jUuS*k2BIdnuJJpS85s&`zy6;+juyAeZ#V3$^_Lxh=z_q4`N*N+2ZhnF zhbWq1cKw64*c4=HvF%mOYpO2;Jp6q2t9gDZ*nbM9VtcY@Yfa2J0b?E3yKM|J0qq&= zIzrGoQ48omkdOebs5|Dbwve2K_Q9UeZrD@I6rWfi*1?dQMXiT}u z`|PsUzvCJ%GEDla36mflOnW@5urtcid=fLhW^@K-{YX-lrPj0_Vs+bmpZl4Wh8w6x zZSY1cQhOhp8Glo3{`dW%=*x=#3*8)i=u`Pi!VY$Vd-1@9h>j+D!->F#k5As_UR5>l zW(MIh6kd~r?sEY>a*`gfO%-YY%jxF%kCvgH7~{^>1VGyI-a)H3JE4XHj~4lQ{^(;( z278xo+y92Kitr|h0JvQaPLJuUj7=xrU?r+9g7D{0G6tp?ph8U!(j^Y&I5B8CIQO>|{3A*CZqy z0GBUkl_$K|K3_sst*|%zur5T(A*OUWeL*>qrR10f&L-_lbH66Y?Yj5%wx4@nT~lZi z0JY>UL{`TPMsOfd$@F>C?qpC0A8vibgpenF+vmE?L!*tUv{?XSp#cSI5h1mpx)q8uOm)>>EYcK>G%;pYUq*9}eg-LP%#0a|0*SN! zy!m@@Os?RQYwZ4K%xXi&$LNo*Z9|Xkn9Ji*Zci{Rp&Dt1Jl_ue$ylVr?{39O7ZI}r z6?IPdPV?3!*6=4|ec_A5P>XaU9;y}LZ|Z7RjB zXB+daC>1=P{pZawN%`@l1B6i{$Pnu3&07`#QzalI{@0|cQ8bQ@**sShPV7>9eBodq79Q3urjB;&PYWFUo))<)T9u5MBzrQj#+1c9`ZR7?bNpX2xR%$vHxuR~7zkX~2M>WL=Hab#*z z6pm8s?0RmMA&dY+8WpuR|6JT=);oflpk=YxhqYaJz}OP|N$S8F6NcznleMyu6B*|p zaKf$<%K7rUEr&%8!&MCr<%Tg0KCaevK$&S@Ved*1BO_*%2+C3Er@SKgYdIF*~*HLR%cOqdA%-dp^`qthNQu zBcJ~K9u>sJa(|($moQ_NPQS$5bv}%TGt=IVN?jY!#VtX)KxHR|UwWTSNW00PFMqrL zQd74L9?2c>$QDnF4egwi<+NtzYgUTDT*)QgpcVOL^{|uir-6v^B)VGsL)jh;boE5yXJJF5*IpzX7H(Q!Y?~pW%<)NH&U>(#=Ijx z`-O*BbAsxn30uQT@vOFj=FFNIDk2>Gc70KtZTmeh1ht|6|=>s z*|$)mTgU>X(;PX{fsUe7Am61}zHq-5h4rjAY}#6o)4)~>)YmtOjhiRep@P5X1SCE- z?$}9_SHlW4tRyiyL};eRgP7}}7ux|?Vg;;@FiB8NGBKJ6{G={an3gh<{qa`pS8OWI z5xP}|A%ZI%@;%M3a8rpm+#g4y==H$0nbqEGH%b?Sd7PnF*a)keetE6H?!QV4s$j&%90#0oe$-a*6f=C&& z^*B9w|ZAc<>(vkk#4e7I2WT{EI zC2@;z(L&0W1|~~SkAQ@pHL^S+W;a~pvarFzCgo{YCxGZdCIdtkl7 z)_>V1^}a9j4xX?Nkvse_G~KK}t)!I4UJ{fdqWiBebX?Lt16PHPcIg`BE~GO$R5&|C zcKxv2jt|(DNoN56Cs0Ugq1Jq1RPF1NV--q2@Id@$ftib+CA{1VE}^Ve6v~P#J|5^V z$d=B8tN5CO_$JmAmUGg)2UUwIeb%SBrne=ITrg22LQD9f2YHs$sgeOj9oFtK%aP~vL_eIQDX{ID$dEJsb7cy?om^*I@bK!lw&;%xzl*^of4*yCc_SdKIUiB@iE{q6O?YHo_YDd7 z%sYt}dX-J*8%eZWgq){Jaqs;V3#+YEC}bZHd<&*z+~qfodae7k z%5`y@jFYV`X#3r*!T(Xpw^Dk&wWS51$!R%!d4=&o4w zWm5Eqtj2jN4`G9+W5zQkMI(;H4F+(LNH#f@kQqPSX&|D|a+{|XSt?W}G8+;pIlUzE zs9qfH{*KX_@|h5?5*$5i$&JIXh@b3Y5t3EVq%RFcm3q`=BtH%x6xPaqs3*xT|6rVeyc;M5w^ii=@i_vF{@XGetyl08mNPH8Ang#BkjX?`j%bB7#ocxO%UHxJ zorm+INfi!+zG)*q_QgzR9kqCzrc+)=xQ+;aHTyxxA3|8r7d;ztbh4v0;q3U>?ZkeJ z7b9L0cyYkSJVWfP;fygn!ag;co=5vce84=fdt;gma$>H4yzRTLV2}LK#iJ+?Oispb3zr^gsJl**HHrv$KleW^SDEwz(`1){X~Jj~?F^4FK02W@uffEp|A!E4hmP znY=y=)OeFL_z-yCbIYCrQ6Y6oe+%uO%1)3o>qJLV$GaI}0{W#ePtNLeitt+rfCjg{ zd-~ja&{GD3cuv24G06evZqM-48$vo?`jOy2;4EwAwS#vDX6mTM6ll2>$kSBHIrukB zC_8B4DpgI;M&C`;mCqOJy;L7ucqF(y&VJ@}&?uVSb*&)r>N60JtHyJX+*Yb^)LwPu zx`D0skcfZjLgfLa)==dTcJf+Ms##$88rK52-1~)q!c}4I#jT`2WQK+hFEWtH;LaTrc_6QJB=yn&FZ(T3rzi0@X3ba;3Y%DK?49Y$y;* z*MKM{Elrg5G7p$BdgvS8?B^t+j*yW=xJ97qv7ue}zY+I)Y)}E~{bQ{qBjDWWGHnMV z_08%Z{~$nihfEw=K{eY(E7wf9T{#;xoEs{W&VEbiRF2qJJ0}HYmR)c9!%RGIr_*T- zZB$MmomgCV%+X*%+Jvl|VJupTM?vU(8S>Swq+JC%@D*AszXp8M*aT2cPIRmP;t&e3 zynw{o$L+{nvutKR+6Jn6Zj$)`2=BqNLD42y3tm(R)H*U2Z~x(`{5k+!Ka&V7>5tQB z^`2z=&OP`SF~F5mQK&kMj%Vk0zf+6;5a1zz#Mcd+=IM%|a2WjP*T(whYlWS6mLCo! zpXMY`=Y;tEpopO|!w!Fwq{iX8k@cn(?_w7PUyW^2ARL$#Iw&r;RR@_vYzm|7`&sn@ z8MR}d{3o}lZ1=JWE$8FE6GClBM1lZX-R!m?}{ye6G^xQknpGw za$J~(1Pg~H(aU$l-Yz=}#q-yDTRf3X@#*^=HMJ$mm$tCeQrasYc0f;DPzK?3B|*9EG+y5j7`Q*O^D5DKat1TDKnf%BLN*-!8#*%#kPZ%ELFk;F z(g$vub2^7CuG1WnOAqAPklU8j>JneK8|0eRHKoQ)JDtYTs}2$iudQuBa$F_g$g{h&O{I;+4cjm;ojYu36=$__xXb_Uz{ZpSJ#jR|nh3NDn*L3KXvW6A#>!yr5C(e173 zPd^)^JzlAYYKWe}hr;?yN% z*dhKQ?Jec`C;dx2ZPt+D!adKgfSWO2n9p`TZGj;X0rBhnMk-^@2C3v)(W$N{rQ@4u zETIR*ZuxQ9RK%0If}K|{IEoOtFVvPw?8L$gxV#B2;-&=DAP_>N;|b{Nm)jbVIZM~^ zKr!Qg0#K~hPEoN^=tM_+cTbSWqhcXFl{ny^M?K_Yf-p^ox8ck320Q7rW4QseC1)x0 z=l{-}%VY?&Y@|O_7I=@y{jTzaU*872q0Ba9P?o6aZN=-)z5`fZM{V||CQ50wQk)-_ z8c{fL9X2wo;*)t{7KbKe9a>2-{ufgkDKxp8(19$Uq((zLBDrRyVDf-`jvCW|tj?>b5QscCMRU4|VV53h=4Ew<-_0mraZHMP&g}m$M3{ zcE^hj8Otq~k@+&pdpXy}>IXrF%V3HzKcVSoeqqrr*xP$8FQ_^BAA511IPdVW?qH%Q z%OG2X_$ZY2_`kUM=vNB zdd<9#dggJVay--rdY_%{x%?+0NV8cWpcjh z)8)7>o%r?h-Cb0TZXydLg^+P+;fUuF+iv+zg5tdn39ltAT^aFdKcAUub&YpeifA(y zYpk%3Ze(-GHU~ddX$Hkc>4Fa$D!6o2?o zhNp2fmxx&1iZko{_+WRp)IU(08|yQDsm3`>z#c>i$s^t3ln;Id0RtRHu7BVBL^<5b zcPdXSO(1N*S}%Vajm~gT_jJpx-=B1GsPYDL_Ur~GN7j0r zt&ou0oJ6&OehcLst8ir3eG|8@cW#lHfQopjC1<=7k zvJ26KxlbE>&bn1+=1B}j{I@~Zh5jgM7S9root~#aWcSTwad`QE#>odeK3ThbK6;9LXvjz9>n;x8w zs5@R3&g;ep`)dhFAvxWzuAHli#UQ{vwBRAZ*1lfn>!Fxj5mwk0Rku5fE4Yq;&+wCw z8TD-wa|u=~@noY1WPh9UOr7uWNVq7KfE7S%uEP93S9UiOAxz-=(;)}|Aa(Awc_GzF zzbSDiT%8E3x6wi=n0l70lFl z7<)3aPy}VkNtN7K%*6a2vm|5|LN4#35RM07y_}&S=8)7$l&s$ z{@fGC)1KmkD3X%ezF)o{|A?X_Luy0O_-}S4s1`76HpfhZAoC-8uh)GnT5Hjv_fTy? z_V}O`c*Ude#b2K{M|KQ<)@tmTL14iVGB*^PiSP5!-IM}pD0aEJ!SpZov}h>KVCK%G zVI(|#tfQNCmN6U+ypQtw$;Mm8rpMPj?`<8b!4W5c$3jKR&46>&m1IKf@qw%pWiF*0 zCK?*>#pKD;bw4+81~Bn`&S(w<(C z&Jdhun(9{efUsaAEEmS^m`J*uv1k!tA-fR4nw*R?2<+X%gS zf-*(w?1qrBa~1hqBA~XMd;d-|f{ISg(Au|rp3R1=;w2L7Mi+{{km;vgGBxRKX=TCK0~m(j z{3X?41-~;G`Sl-__UQM?3Z%MKnL)vZHu!tqewNO_70=&ls0Z>ky(mUfneJ0CjaCqw zAeB%dtsUyC8{%|-FIKRhGzbX{w!89ebVxoscodg>5X`8yn6yRT09=R*D-YcaT^+Os z!+k8O%>e?L2aNQ9d7nYMs|=JAP$bVCtiYwXugtT zH~}qeK_!J+f|kZRp`@xe$r3t9>jtqCtR-&bXL~fh6P2f^w)ohwj4VzQm#8YKuzpGK zk(2I@*Qfh5q7VEuk5NZ@LnG8B8{_;})!;vY`PrEL!^ImeJw`SteVsiwk^EK4vTIAp za2W3^qov*nNrNJ5(xAw|#r-_rB6OoTN0WvHmx$8i_tu-u@rwo7*5i0c4qwTa8L_3~NYi-*lc7 z0#~6@6TFzGs4%4-Q<8q+&r(}f2e@W)1v9rV3n|7{j2^^e05Qd{Tjbe$r(7{>?O~Ux ziWiiPqeS^slpvgcB=Tf|f6wG4 zoCcr1^C)#nTM4@Db<#ZeNgasVO*}yK{p3NNf|#8%zbXN(;oHL3z_t76e7Xlm$9xF-@V8g9WN=DK8iS6*H=`d zlDesqh?HoNfb))Y;!SAhk?N=G0_?8)5QAbHtU?+1&t77#U6~^1={bdzzxlxbd-cigoJZ$vl zlRizm^W$`fx>KP)h?5wznIjkYlJa1+OCDF*pjcP4HIpGD`_9v&+mHX_%W!ra$$BA= z1AP57x*+HzD*?*3gyjiW698rJJ^tcy(j&c$g-2S824vVIBW_3ip#uzp)5t zF!KhUb6hKM6kGX{zMVqN7I7I;G2rUb)EFy8OJc{3l3rP=-?Liu)TrKh8KrxsqNKcj+2m36}+JIBA2 zyI=V~bbA@zh>h|ca9t?>OJL*&l;?2E)!})AT)9V61|?IfjHY`y+I0^iu0&uMHQMYXi!JU)5g=yo`B*=+f z2V5_c{|_4xprQ36a+ZLuzA?Ysp0lWi0dCgI@<)cq?6zKTGvT-2#UiOmTJdY>qQ{6(t-G($JdhleZL zSC?Mb8})Fh#^SJjH}XCe%Ka?wDKbbZ{5#74&;pQ|K=OSXbaJ(IbXdK?%zYfSep65K!8sXMS1 zAH|eN-@4;(ic#xY&ay~j|8{0dHVNq;sH^z6Z$fIOeAWU1QL$GtfkLV~x1{GBn_+E% z|2-2HF()>U>XN8|=9B@)M)h}h08n%R{AaI??r{BQ+z{j9yg(3~v*1mc|ArF_`3DXZ zB_L)hdKS?pxBQef0n1Fs%?xO2qyPftDB#+<>V*R&mi34*wqi>Uxu-U+L+$yUPy&F1 z4`YYDWNEWfFuJ)sdOozbnv0#G4?pJv$I|AM%Xi7Jpqzq6 zi6XMWc$n0%U?^%idq_Q~5BjgG4nJu9kLeA*{pS`x(NFAC0G%AtnWBel*#RaP@#rnc zPrkTfWu&}$rm5P3`-^N!82z@)nR#C;*=e2oVYyB%a?><8!XL>WK>DjLnEG_jIVC+- zHrpESwmIT~F`|x^w#*|(#+AGL)C3K((#YR$4W0Qw6y#Y>pvaxujSVAdI-u^12>A#H zK-dCb?OiI|k!nE8+bJJJC}~!(0&a`H^ebEoowL(I81fDqX@+3CyUM`5i9LEL_}c8R z%kvgxu~RP0SgfMUi&w)4vK1jO(!YAbsfk;lzOi0g`EsRu;gXm@u{Qy_Ij?%hyAA>p z0q_8k^bU*->hFqq!l+qbrq(`XCy_#0_3rKo=*{LR%XNalhO^n?a06;+X=5b1{pK_o zP#=FdzR1#@KGC~;kE)_G=Z)HuD@a;!X?cD?vd>P7C?jLp=~1f zRYBk8A-~~s%};uD`#7fIttt#6gx=N2*#{>yfvrmgPba*c&YwJe4t8OV^`Dc?Yv zqFcP5x}hZ}E=EHhvA;#$?hI3RGfbCc8U_rButQtNgSw7s0tC#W(aY!a=H}7vM#NnN zF(>~ZB?}&A6jE|CP%E5;qoh?AE`aTf=L|a1rkkfiAmDjIwB$vDWL8x76RN zEv^!D-$Ap+8l;&q2kOlU@a39nIE|c%T&nXXc$nGWT#Pg%JCs_+;ESaV4*cH?o(74; zrF0y83|~L})9bKYLoX<7t2E9F+I8X9(`0VM_*bz0Jh4b#>38&boF6_>!e%jJR%7Ex zx1dBHX5o2dg7ovH1QMtIz^4i#E%*s_{psi}HDagl3T|1}dPLqu@D4iJtTzd-rn2X=skQgRrI`aI< z?KkwV9ohX*UAEx)5*Q2ouLce~yPjPcA4-e8f$=1D;bjpCRu#}ZYFR;_bJN67pS#}mgI$%FJHuA|Ka^Pi!*Y75#-_5o_1xPY>cC#Cw(*2ViHS=Oc2z5(rIa zfcm@@dASAS9IS|KxKO&2H4_+skOv0|bf^t^!}+bdVj!(g6&W5RL5@T7b;S6w`NJNe zh~u1~bS(^`qMv4k`67Q9Tnr8TkGvZtQOBUIwioV{gmY&=gi#rH#k2}!8t=#Fe-RS( zrej>Wv1Cu{VCzohlGARK6RM*&X^Si%a3l!K0gW#kJf+__WoZ0}q;7GeIw{X_`c20d zd>>~;M|~aWE^qdMNejJ(56mL2i?>f<)H-OL)o-W8&*|~EPcjnh968G3&f9$ncMzQx>|74srWkf9vM3xX=hYr=6(Z{BHE$22wJ@E{&+#6w1)ryAuvIR zh~Ew&y?PB7(JU$@A0af>pSlt1qWM3(9V7gG+pxDooo$!H7F?32d zhvZxwn6+@n0K=mJU&V4QMIIV)7Sg|*6KRj$TL73y8B{W1ulvKO|8N2!r{S=U^vuaw z-Wy2haGMU}tE{{?>%%tJz_U4!LL=b_1TKG#s$R}=oIpVmB~(Fc$mr9zp9WI;Bs)vO z)9)q1ZIf{)b&jGA>Z^KvF;6&F_~-y-c&aD+qI`RR5$w~)-wv`iy6Uj*__=yT*K>Xf zs2c5>pyo+9P5zzvH=`5&PMl0pG_Afdw8XCxCL9nZT z6&`lNiFyBu2Sr^Gp66ByNlPKSge4Z9iWV*UZ9Vgg>RXr1Zsy;4Ci?0_n!*wKbU~R; zKp--&huE&ws7Ql~&Z6!O_)ns0rV+<4T*+ecJ_NUmXWQ`d8ib*I0`o2v@Pk22FJ?$5 zhHpL~>@jBZHGOU+Yx9Wf!1$hXIT*De4|RGPHb>7dsazGC`GAw1(EBQ@1Q^*T@WX}X zP!RuUupSYVOg|MW_#@3gjO$P8yMOf0O1V7C4eJ5#lw_=nMtqkR~&w?KLv04 zFCv$)o5kXIy#5kZe>#>%Fz`5n;aP-$Gba1WfEAlR7HBxyRk>*DxB0`0*=~Bg7_IJS z?uu{Lz>u!o{oy@X9kxf6Ccmepr}V(?`p4@~*OLmKEM=QvIQ_Oc8vdv@QFz$gY`)Q$ zPN5phNXSJtcnFGDuH=u@4vXqcvRG9=mq0wP`^o4GA63hT9A;vT2%P#+vnPC?PG>Yg z?6>AATbwK(13PeSnCn<0w2*J}((n=V)HR>4>!#owx97Ay?I zy7luZVOu3WY2c{Lf8_Iglh%sN4nhdvzTN%lXMw3M{*f=UW|iWN?G^h{GlL2}|`KVkGyB&?k&PL3fP z;L&3Oj?uG|9Tg|W6qpw$7B_iyl-d7-W|q2Vo)9|M$>wc+s12c*-h>6ZHW-~G#GQ*X zfu|m~oPxg_K@l`L1 znGMwRp?|5czFK8PbLbO`BK-i|?5iHgvmsTMfoB5StTHPvAVThgb`Y4Vk8;TTdi&LA z1HsbDPFz(|BIHF2Y&v5^jgAVqA05n{gEbXF*=ZD_ zWGc+wjU+;0iMa zT}G5lta2CL%5FlAJ5Je|2L26LLY^=?ytT4@>zM}Uf#)^efIVl%;7x{41!uZwe&S%v z8i;s4SkuqTauC=zo5dke(;{IR&Sa5#P`qh5G6WQJImuv$`(RHsIL5uQXaYB;A|{ZThqkcZ+fn2S&m!=S0lnT@pOs_61nywaW z?ESeZ61vx>QJw)QVGHf3D@_>6MV{!RkNa>iu>N8EOR;@s zC0usmGS;&E+pcHVg6kdOOR-?g!6F~6@6{1V`_x$&P*y|Gb0w{-pV7aXq)?gt7AG7pt4ig z$UTXb6^M}u(ZJp0oP?f^G?Q%ltWViN6LW5plvOxpT+^bZ|0nJSiI@<2$?hk0)L zoIGzMB;}v6sgeq)67k&Cy&@P#R<<&O-F;*YkC5ZpAM)Pz1y$^6U>?9W;VQdNx`gYV zp5*;Z9B-5;5y2~Q@FQ{0X3gHQ5Dfv&B3^D6`J9HEu-`OQW5l23tBrdQx-|53$4^Y6 z0`?ku=J)G{CK5AfCfXzCQQ$kDe3~>$NrQAT$|yV&-O215GFZG~BSgk$c^2jXwMN&# z$9rL!!xZSKS_O{ZL0^XVi@4eEHL0ntpu{fSSpUT2;+?B~8GqsM>Aj%fqAMH|>m;cg z;nZq7M8fzEm8`TBN&{EWbz{c}ZpvJa-NpiT|8AtOe2zgD^(zpE^r&=}0a+{Nh0#N;>?DC||YWifb9twfL)uAp2~}A!q1a`8wGGm(z^4WsO$S zIbJUCP9MkgeZKc0QSCl(Oj$Q{v(%&xbd5o@T#yzimHa4h+19bQ?-^S8((u;nk4 zTCpdLed5?LSmNYiN5WcOXwNzA6M3f1>YtnAdhfnj>L?Q7l-lN`D^()|`dx6M#+z!Z zKm+ZFQ~kGE!@Ztj#or7;5#3C`lW9=zME-Y?V0^>aC$ZqWed;3jO&VB$15}W5!(;QQ zC@MoO_-)*=yE@6TX{r!iYsgN(JSN{9e7FFc>LZxPaDI3hpO^nX_1-tvf?h zxm!p8`*eW5|MpwBHQT@~E>;{xC&gKZRco||o#ACG<0w(a$g!jkD!u}(S5PyA)V8_Q zfb3@Kux{#o=W5=51R&c`%c3ZJxZM*(C?hq^``4{YU2419Ieler;90V)mrNe3?Vr$L zf>duM2wJasn{&2FEIiwfq|76bdPMEj%leE@P%)Ukpq*nRwQv&Cc3p6QK3~lwM3c0_ zMy0142F8A()+jupsuk6&l9X`yaeelJR7qb zE;Ne8xaULI$>_TwCAW-J!Vr4r%YbW%9fchaXqrb=4G<0BMpf zjB-HmnU}1C?Sr}9O`&+>d5k8cWTM)%^`ur_y)0(p2)}u`k>fU3@TX|X+pVg;jH*Cu zz}~x%!13zGBf7ISs`!}nSF9e-bX3}u)0RkpF^(uu?Bv;bm+h`j3kwqY(MA|>yi2Wp zM4yFYHRRlY=>T`X-pN+Aax|&J#(@#S1v4O=T5lf@iJC8LxT3aia6ACNizxn~xg=TO zy>avG*9){cq41v8jwqK3;y68#At8l6yK0x86E{=ZdxgqrIZW$b-R}G&Z{=bGY)e>x z9z2V1VArW4S3;3N&Ns*;;w-T8Y2Js(E&A!Ekfnc-0PSMIfRu3pec<_F0q8;i0swPW z5QUFMFGb27*AVIpwQMg;w$t3bcA)#406lzM7H|=e1IkAFfv1=7!-bCEySxRkJYY*JNaEyeQRaa_4R0TOr@knb`HPNV5Q??hMjh*&Qbfh4Q1P0^nL+#`gUEd4VfeH_~1`De>myhCHPdw-{MoSdS zYU?A-POM&a@y`5gabwRJDRH}o*0Xu!JG`D4i3%f^ut^J;Ct<>>0MY|@@K>__*Lt40 z)Hw}?l0MqER3$(`S6&MsDNw#$mL*%`p@zVWCZKOTt5}udz@1FKmAYD zZiP8NOyu*(1R_`en$mVNJxr}}zR@u$mQmwz(nYb4F!8JU^qBX$j2LM$G<~O%Q~aR8 zwQ)-SLyro0gF6VR8FfQLzZ?V0e!wlnAkVHoF`#l6I?Rw*?Nr1?`|=)Ts!2RGsOr%$1NRvL5oLk=)}`QGk+D7%5p%Bnb}{@M zR|wc05xuWGGhu(>lpY@(sW~soEc`UWo06717GF2#eP*r(@fa1`?V<6!ZqnRK?=xz3BJ5^(+q;6_2qQ#BQ5lZ|WS5<_R=n#Z zA?};OIDjW)Pnm%%d^Nk=%u})H!XlM3iWH8&QR+1FR&BU^6sVR)UhC0bqrS)6%SAr# zRo8Yy0JGiF6voac8B=Y$Xb&l0t0UmK?Hvvc)r*q3LdLP85Mu(&+K!)ArH(pIOh7o{ zyTLP`!*#W5>c#P?pHCo36(NsqjVhAL6z-P2>lK)Ct~Tt1V?^Bn66f?jpT}SRyR&9E z9lj81<@FompzPaE(zf07?ga@XOWu%pD&CKf+=NDbxV(Vv6|{?YN~1h0fV2;%k_|q7 zr6^GP_HsI3An-GssLK|10K$L+lgJfqlVs5C!g8==#U!01ECK~QT^ae^oSQ1nHp!N4 z`af`%COmXSDO7idB0jql7l+bB^}sSNwUEL=}NAeT1oaP z>()$`@Z^{39M2ugPaN~YEK7G@^FU)Bh(Y9hQ~y#7;8W2IScABstN8;QMwAh^frBM! z){`JwKUsWd)diuv=pzAx-QCoVySFo!j3g-^$pbxWO~;yKQCI@ssqET99!4CYXqMT< z_#h0P5PDMeecPsm`_?7ShtXD5Uo6ch3d{eoBMO<=_kCgsanfY{4=W0&?XQ$IIwWsGGZBWsUaCuxd;G-9}_1jI+1;>t{_`e^FGz!$h3;9KRsmh11ICm#VQ`olrEey?l zrv>8HWL#B5r9w1X3Ya!lbcRHao#x16ew|fENViGm$4glSoG*d@FVt zCS*G|ngVZ6H4XK%gE1wopNLc)24T|_NY+JBsNDVWXgu4b8}{91Mn>Z%!^l(Nykk#tDQfJsbJv2b zfoO|zBOc7L?yROYSp&bBhRZ4q5aS*=w(;v`Dn)qnpt|iGY|STeFL^)uIb1yn=NhBT zDgc(-V*;49YFejJ_Pt>qt}tDn3-c*#l3ayqdJJHL%au13ahu!&?+x8wKnke758-KJ z0)RCVTe)(ZPKD$+OB!YverCOVSXai9?c&6oOH;IHoo|JLCS<>o;V&y@%J4_g#Y=~= z;V(u7R2eab|047;%x4xGytBV&b-dP%#REv<=H}u`)#F&W7{f$P!?=6yRG&OHKf$6_1Ia{6vMX_(vr1eaVU zTn43%35%PL=(1mNQWzFq-d#?o@q#|k;GgLP>WwdUyQt>*`Qe?#x{lVmD7L7bUEH_huH{&u@FQ@S?XYpAp z;`i{UA1@~R#4AC-V?DZFoeo-!;&{H5UNg|H3v}X7YOfl#|ZN9&NMR8~p zViZfOT&xMo(NWLGURAg$NnCfVOk8{u5fleIEsB95_^fY(lkudb> zX;i2KSv#!f;+wK5%p(!Hpa8W=JHt*)jV!P_dmGt>CKDj!d7Q`K>?@wB49Lt4XFZjo zBGI$$&h~1Tt~Az$#|;3eld;!4V0D9bpSLe%Rpk8sgUr^Im3VN)#NW!~8lBrGjbiUA zrmE_`2ktKx+nj^G37wWWsv1|q2z=(uYQ8Ml*?TC{F?0xnE&PJZY)-;&Ho<()BjAz4 zph?5CV(64bTdeO+n0Q5-L@8g)cT8VGNcd!_N|LpzhmMsj)m2difzDKWASm+jDzHUXWB-rV&X-Vr-td;5 ze}J5XOlHLC-$+XfHK`8_Hqmh1X2A!H!5(A`%jm?nm?Yg=^|~(*o~Z@*NUTP}ZGih} zI)IkgpH9Fc;nt^b=xj8OX>xoAg5r(@x~nB$=6TMT*C*`)G9dzRuZi)5`9OW?=3zJG zZ%BbOOT=#*PQ^Yz4NjYW016>$7W)*bZZp2yg!<1#L>?WQ@j!qy-JD?s5*RI)=uDQM zM$1o>PXchDH*cU44;F4Cd0%c5Zndzjksrb0Q*#SPrkjX8RlQ@nDG_^H|qW7v<6r z9A0@PhjIUy_22;5O^W+y0|So{ON^%+xjQwX3qg~;_rtCxxb{sfO7XCZ$N-Ny*$Jjz z!feHLZq~ue#O$sz1qelyWeXO(9RG$s+idjf2*sf?X+V9x3%Q*^BD7L!5cA&{U`U*C zK3@6bVS>E*8Vsa25kV;FL@}t}=;NPf{(3~^fKiG1AbWhc41&H@{>Uj;(7@ndrPY= zR_J|AVRs3Gt*p^-HLy>oRp>3*ZBU$ITO&XsXAqAEK0`}M@ znVAl@@OT$0N|*V5@oY(?)n?W>R+2eLMxHo1zB+%SqX3jZ3<*^QAmFKmR6uX(ks8pb z(2Xr3GO{U5L|bk1%NY5V=>xqCv0OVZaCgCyoR9YU;^zj~de+v%5J(GhnZK%}6*5SK z%X1mW?jE~DASPoY-_)!Q1Fuy|Y|0NXBH6PREiFtXV^Jst&12+z{bfLn@}w~A9=kb# z*%m@re;8hv>nNXWxPy^vshBPr<&rMqFc8+mk#h{zal^x(Qoa!?-*upGIJ&?Sx=FnM=Fde&Gs-2>0^$&9R<$KC6;{S z8~{w-`fm(3H#cT_$m%}my}4D*4&riw`78H8y&Asn<;CPe!XKVp4|i|#9p0E{V(`Ih z4%y9NluJ%kQhJ=xYfCd}p@1L)WpqRbR2F>J4QZgyLs>5e`|qRvlW-z2SWFKG+MuFh z@Dtb8syTqKmKgVBEXRkNbpuOPPhu+<$HZ_^>;M|*JhI4Gb~5bs^O0xni-L5HUPUJp zI=26PeX;IiP5V{PfikS#Cn*=PSBL=LI_u)8qh^zn-=U|H3k^}grV*3)9hL>OGnSVQ zbfj&5@S%Ik_MVovrT5P!$)-y9`?wz5>>8AVGW`_Nb)EiNH$@ zuceW*jua_7rb2ekhtzZ?`Pzbz*@mD|3zsFRz_X**fDZ(xg>(!9!O{i08YPhFM|jD! z$I~9#(e#?(oYuBxYP$yZSC@xT)BP?>I0C5rvZk5ixfJt*O^R=RJB|ChpG2rMx%YGi zl7ibfh)EXWDj6^`Hx>Phvzk^%VA6Q8Tt$A5o3T;?D_l*gX)v~DBg$n3A3qkh4Uj-( zE9V^sNUzm+5k7t-cA5{hkN55$UeHn^t!)a4khVS%kP6e|OBO~Pmw^A9`aAu(Zbz86s+~C%Y}}T!x01ZPaYBN z@`6D6CcjY*CyS+0g5x$=MPpPcmR||D^wVVpVrXMsk~+Ec$t;9L?5zz11?QelYeMWa zPq`|mg>0Dgn5`r)TgkS_nO%Rndc)bI;^Gla=^D zJnuZ;X#z}gc=zaWhbD$igAD9+EkBsW2I`3_40`|bnt?^+24p%1-za1Ir!er>9V98# z)warq;Y26Fukk7MroQ1UGESK808yBH&4Sgx#3**K7`@5Lr55-vAj8G0T&VwocXtz~DuP{gg& z8T|@^+JsV}A{>@FtK&={bF{^3#}R1+L;1i)lOP*e@~}I#6RZi^<$*YMi{OVR@+~!+ zt6x1vz$rzjY=vu=V+2Xc#susH8he6#ED`Yp9BB@t(o9Ejox}G19wOKbz%j%3j&NV* z*Sk=Ngz*GAO5dFfS?jh^fO|+K!hQt(k)% z2O9jp-{-vbT3n_Xh-Z?*g^YG7Ru}1iJQqVJjT-qN zKWk1k$IC*WL^5^l@fT_3pG!6swM;o^A7nu(1vCLIphCi+;SG~IYAvGrks|AfNEL+Z zHYg=9(w`Y<;mQMsiXMV6>B+cX?nd*s}#td3f@8h}PzyaYrbvTXj* z3Y>)1zOm3c?%~gD`5u*4e7qYLBqmu~MWg#oh@0pJ1@Pfw0=Ga{AZo|{&tO*-TFDAx z&^HMDl0e0R6@M5v;DliAGEF2-N<0l?qhYf>BP{$W=+q>sI_L+KQb~)aAnr7A z#dQKOd$-9C^MCq zMr3PFM$Uw?%M{!qEV@o7gBA-PyS9b4iP&E>D}W4J`ijPpm&Bc;0Kq)C^DLSJ*=-IM z8V0>4BGj1&>fvRgG=%noZt?PPL~EqtunHKS*3$d%4fCIS4OcY@SygMW9NmSv!H2cQ z62Mc4;`-SjM<2_Mj3HoC+d3f7g2Zm&IK=pUWfudKa=DnJh+4Ms$VY0!v)0C~7tO9{ zAHant>Oq_~z!iR!=}3zk8}Z*oZtflo75{(E#SzCT1Ld)XHUKl9hsAc0ds_1JroOJY zVQ&)^95kPXxMh-)(|O^;T>Sj7=O%lJvWB?YnFT;Ebky7+c(S$cya_ZuIZFP7>zAL$ zwP1$IoKOLAy*nqHX+Qc}jL!T+2LjKe zNH2ac`y+!nA5YX{1-8%>Bis@Ow4$nVYV%%Ar3Zn2n`R!~&rZ3!f1~t#AFK5v(R#Zy z1RfcCC_;}Hi>*thMtmDcT~VZZowaHBDQl8ksqB;wda(bBHK(!vNv1kcQ-&4?t;|uC zGX?fM@1sA*kU}D$e>E{q;nTArT_!Q*4Rd9;KMNf#L6ueTPaQzv^7>b0+-%`e-VQh} zqE4K9hI<$Mm`_n$!M~{X=!iW^M~@TJbwxFk^G@k+{VUhfFyw#;q}z`vCxX~__`6y@ z>@~rtR4!e2>2qBaJv;2S&J!cJmY?5fSX#Y{Zi1nXdc^4BB)PUh;Y`>HCF3Zs8UYze$R=9Z6d0kBw-=la4nq20a5&m{=l@`tw5dOnF zKALAn^GojfL^)tS7cz(8MuAUhes{6To>J3urLZeIDW9livnXuIDFI9|a)&W| zcGoyDmu0qOzq%9`tr$z~gecF{E1C=s!rz~0>`l;v3j7M?UPy)~6;Afemc?hAXj6uq zm6NPT-G|^`P-vh3DE#lt6%n()q6d%!bS;mv5|lqom~HcIcXv`aL>*XqT2|`Mn+Kqm zq>#B}^(igd=fzz(2hbj*x%@3~Pt=f-Y7S;^Vt%O?dRq1v`Hx0f+D7|hGGAglBI355 zFQeKzj9VGeUn>Q!#*_Z7k@9Wb=2~yj}eKnJijz|^uVPO!dJMukqn%( z<$n)0JvDX;{ji1W5~gLa(U7o#4Ph~Qw!;v4!dqG||wtGw5)kIne zD5m52tNI?3n$_DDD@n%l$S=({368GnKXssf5oy64B|-jm|G2MPzIYboFAgqo79?Wc zR!#{b4(up#j&yoC>^D%sBmzAEdE4bb#_}voM+%Fw;cb$+cppJsXP^ix-g&>r9A(}St^ZmvMmFXU5jcK()A*gkEq;WclK4%PvK9Zy4$9E(I_t5M zTDc>yMx9=Tp;A>1k5RRLsDEylk94wLLW|i=He1&Rj%DL0IML7tgXy1;@|^QWoubB^ zDP*wb)N17#kGFhyES&-%fwOIMF~Q~Xh}Yh#1Yt+6W(OS0PhOJia!;HIGJ=u;NpV!U z>6vTen%uZ{czUM4+E1JkgAxGOR5m$-3rVPn=q{9|Fu6+a4YiEook0y@nHuo>v}Wd< zFXV}OcMG9s5s6JQ`X2s5o{)e@!VBk|wMui^1)hc9VovRy@KMFM`|dUl zP>J#>IMd|P-LDz;>j7ZH;isYfGP!SsbgRhZZV}kzX+zIL zkCj5!l#-!}8-OT3TOs?9lbMGQ1v_O|-##R|?{Mcg4r-33#Kn~{lkOAuRkg>=O?J3- zwXRc6`z^3@-sVZ(UGtZu61zk986V{y=C{u8Ndg7&0!39G)AU?P{r)=sd+bh1&oy$^ z#O+UAp~{slZ)AVzn-$6RRr$7-Rp!%3&%b9JK1X9^#cY89XIw3OH#WDd@*pAr3%wux z4xy-kek40QOiBmxO&(Wt$Z};l$tVD924>HbVst2xB`(A>xC|~fWVUSXalDnG2CeLp zur;Roo0YKHv#v}$`k2b!xL#yc=hCl*^Fc`O@1`O-$RG2?3I@(hh;}o!@kJy8Ql<;x z-8SMO_R&WjCC&pPv>^(Nz0d!@!6j>B2#}&87_@NrNj_D5b`Z6#p9AkRt5T*ETC>mXExfiLJ)CQ2S&NbPRgw97;}%@lys|7WwmDQ-BLfyS-dB9r5nChT;EN)dvB5THngBq0pD;)*NnBG*@-(zR%m z%1RCFmogqir#kvCmmhgg9d#<=_-#1atEn`zUS_-iQsmwmCGVUj1sd#FdD$tUVkWI( zLVzwh!o+2E?zp0(x>&r7mx5bS43qN2k`A_oOEiR-IFg>+HVrTd4dUmmpLQutASeMt z-X z8qGlX6KLb1wgGjtmLq|W@@%XAbf#d_apYlM#pm_%z^rys8*`G~RmN&C^E_)+inTm- z^K#6P>YyRZ9*FyMcd{Gy6S299HZRH884X!+=+W1{EK!BVxdpe3e9C)mj?&j@m5iJ1 zjRYkvEOapx#704p3CL2p0N`tSyyC^H3&BQ{K%KrvBkx$ZzO>+>D6e<5t+m=ayThu|rZA@smMrRa zAsWBf|8+`2zj8`tpaDn*XL4e->;=qp;@da*uwmNFN2rNVx@}dwgu4%8j3F;(XQ4=D zG*EENs>NWlguGpxQ&Cfxpk()Bgo#-*jjH1G&Ap-K{Q}J8msFF_Dv^kw6&4NJZJMX> zVbLM-5qK%mQ92TJ7&?$i?FvBhtnUT3U2yCC8!?>&z`{qO(x!82y0B7{gHb4u%MRsxVG z0_}G(Uwf*EMWE*zRM6fk13KRGcWGOQ&+_Bc!k>4+e~F{Cnz z?Ti{nqu}f_iVUxzFwx;c1<}vaxFFAQa?oRB>G&a`+;kxdjd$1gzkwlXfw4s>A|QzZ zM^eW%?pZ-cn+saO0M85}SXDT@N>LXjW`^ev<5?1m5d(?IRNsBP-EGvFL~I&a=E<(#N*l=*h(IjgO?Jkrz6QfpbN$FKUG*8z^pjl`PU)`Ms8%^N*};E1y6o z2u#O7h@vWiqfENtccDSz2j`*6gISsN(1;s3uzcVwVIA{A&b!Mes(O{z(pspt^SR;7 zgoPOaS8#vIvoowrZKtalV$x?FAFh_CSS5-Uir1!H%48~0807)B%X{%2FIJawC#M8Fmo)WE( zs)}tpR>=(`EuP80HPu(Uo8qam1 zYmJUJl1$qCUr@&l~oH7b0 zUUHI*5g`O9A|Z&3nywN(=%8F^XmqQJyj=i+QDUjY!G}0^S1`V+{B4b|fciF3wTV%P zoBhwsK26Sl?EO5jPC}o`m0X@>xC9?Sh;KZUy@$${C?b{TqCFk@tqMTa4U(y( z3)*$1Jqfzh0}^Rt4zIh~0iH^ucf953waCH&Jeg&~vF>PW2lBxH>|WH#=NeT_Oi6{u z8#%qqko8}Cb8JWBR>n@Zf#Dt@3W$H#|My`dY+@1&WcMnC8)ZNT40RU;)sznEqC*#8 z=GZJosmeLV;Own|!+S0LF)q1sLvkG>1(k-5{gt+RBAh~5W*G2NZ0>`E!GDO8fv}DE zdV2N4to`OU)NLSk)5eocc*fn#YNG1qS&RT!Fz-YAFpl+~N*cSYAb2I%ZUhxm0sRd9 zkPLFfo}V6)4WR*m3CtXld^i5Bj6v{F`c{t9sf?(ZA00qX#UujOrO*U@r640fh>$`g zFoZj*J;MBZR$l`u__gna?^oLBOeE0|mVUtr?)zmzt#dajI%H+0Zj=QG=DSVocIWwT z^DBek0o_fwlGC*AS44!Uev9w}n1OF&;Sr*!@+Wsfj|ka^wxScTBU#RwW>~@$e&U>e ze!Dr&5(#{LI0(K)X~#el#cKkWt=S*(Cab=(p+|igZWv*DP1crDYw z)sUqO)7%>Y$&bVnLp-zHU?2O%dlBpWd5q*Ug=d zB%1&Mdr#$JL)1R$q(mZ&eL?_DV(AN#H-}E6dQ5MjAf|DB%3v>~8viS8b>GuF3tftEht*>tea*wciIJ3XHw?|M$TiX@a7J z$PpR@jt6w-cntxfG&BHeK$X8-n^?;okAW&wK{FyS#W|Cbu6qmbcx;*uFsMhcvRf4H zChNsE2SX9{vRe-Yn)Uk(RPMT#JHonkx!?nm=}T8tl63(Wt!57eRUx#uIQ>0q z?6`Y5^%K_EQkJWmqks&3K%y}d4a~GDGI&fb_!S0v}z`piRINaVeaTh}Zhan1$ z``3T}K`myZF;L|pdS+ENW`HHFaI(M@E)6RjWyk&LU~0*57ybL3Y#%SqEmPlIS-Vxo zqbDkr-&*bICvN7L+GDX?%4o@V-v|a#!^nI2{76^jY`(t$0-(C2eeD1MLW*wA7oN|w zsk1~>_07x}04Kr6r%XIt;C1T96)}`=LNPEfOQe*TUZSS!L4Fc?sQ9~|{Ad!g1SwCW zI);UwJ;qt&*4eN$2uOyIoD(mL(Ij|I7Rak)sUj60o; zK0f4Mme|5$r9~zHFKtu3Xem8|J6+v0_?KN^QSOjZ4YKK~&sx|5FHJh#H0op)Y!KGj z6a|Uyp>qkZ5(udWn$G5Vt?dy~c=6_S6>(g)g_Q4#xmtprYuU`%%EQ8L<#%NQLW3fe zmRfdakCdEphXI#UzLEbS3XQ-2|Gz;oW~4B{C^iWZ0#7rI88cu3!CKa8*<)A-A=-+2 z%;B`P7jp+-XB-iq?*gVKB)TWmJ%s%;(Ta&1t*-sWv{%o5Qu|7 zN3JZq<@qdTB{GtK&0qwJ;_?#Mz`W3W@wk&H)|@?*S^z8ZTF~Up&OPW>hM4rqLok}v zQY%#P)FH_2ay^b4>gV7_PJjY}gmztZ=8|ZlVy~HJ6ZfnM*;fKPp-FHAO@?$@B`k1u zN*K^XLmLsNxG-tgZE9x_y?1z6Y5T&9gOx+bESUU7x=>~6wEBNn*Fqno2;IT_?h8z2&>$#-5Oai z(8H4$pkmB|(nv?-8>X7`ri<>*;ebLhnJC9se0#d>KaQmgp1o3{JjU;ixm!y`G=r4*}e4m1@_9Lf_mrdkw+ zqaq=Tu-!7Eh-&uX$2!uScf*#bV>rf$K4F7Watjg4@n6aZPRRB7g_;|Y+ziP~+9GOI zEE)#Y3nA>OK}oCdK>|@5B4wniXkvGJh_k`0{mw>7CaS`jk90nv(onf%3;-_nmp+b< zgmKdjxU?$S5bIj7V#Ql)EX?MnqmlSE>CM$?J#YV@ClHSE3o^Pl2v+$A$WZdp`T~b2 zl~ne+otv#h%kK1UWRlolC%(J_y1d;n32NU2S=`?TAqt6q|KIVnl!_7}C`J2h}~0v=p319SM#kvZW?9igH0{XM%@LSYho zKkPp#KG&`3OxKFOp4S#XPI68Xx}64&zK&v#rT~N(9cKWXSE-wG%=lV6r9t>yX|Jtz zYMQLjEhth*93d!dOIcv7gh3esMnI5)H-SJ72)i`0wgF4!>lSLY!&(@X0z(2GJOS?MWAUH4Eqv>MT|vPB4w;Qf*yzCEDXymO*!!oiA;f_*$mzoK z?qZFP{a@rExKFz2LA6muusgsJSWKg75AsBFWB8- zYS?GZu0Vcu!c1$ng9L0>#v{mE!nY1dzam>$3~%nmZcTrK&mI4IX59 z0S*xvmCh1VD^~Nq7}|CNH1x6uWnCzvGYn~3Tng5pu0&<-d7OWZ=GOP^rInMfVgqMA zklREKDLko(nnxxE)8ivpT#&`J@2Z=WzV{dCO=~ArqclXk^hQ&KLO)%9(aY7DI5*&Sa0x$rKEw01>(!a)c+p4~``0&tB9{~+6 zfKM|O!0*FHs?bY?gMz3ArC@TcBr9!_n~B`)$FZ3_P0fg$#kQrmeQ_CUg|L)a8$Raq zd5a_+ii8oN6-Yq}T|taxD+_APA;8e0!JQTO7aoV0+TNI>7MZQf%%`0GSt%Tg-2qfW zalKJB-x5_on-e9B16sYgb@?js1x!>hRa;Q)PQZ$oqr7TcDArq+5=UL@^;G7nNC504~O@aFU1v{UW#q zz5niA;@(KjRK>$E#vfeQx$iH0R0gsVNqoXNT^s7Mj2h&Dbb#`lh>A@QjZCq&B4XZ< z>eCr!g&D*y0J5QS=adTNemXsSEyZ1ZkYnKUp>^pDcvC_ziVw{?-Wu=XYoagv`~VBN z_ul%f@Tu9^=wVgcj)P2a!c_^JBbe3#9d6;FBzAGUA^;S=pcW2z31(=7otY{jK#?Xx%uCpUPU919`< z3)8S?!BrE@8qUB~T&Gw>ki-x!%2zIb9&azT$+2CE6!l!Uk)!zGT%V`g(0cwK>Z-Aa za+q*^{#_M&XShe|LkA%Wi|^O}z2PfqqA?7JF%k@#8Zm~zEYMp*3j(jsWHkMgL)#G! z>HZCsed??4!}nXsx22m3^Kjwuht1ufm=bl@VCQ^-R$5t&Ca5P*jq6jFNY{tl+{0SG z??7Jp1&Qf4$SnHe;$5rWLRPR|#ZeXF`Q?F9)vAht0ffg=URP@7AAjojl*?2}B&Y>| zp?X%Y9ghY`7H-8MmaxF!>kyg5^)n4_B?Wxw0(b-ZvIs zUZG5p4U+&L6tv2?dwDCJgYdQraUs%$s=VoJll`(t(W^9bK?H=NEq=fL)B-zq()0lc zBJRCkdPX83J|PN?|L=ePK`m*bF#srGSshcL@YoEp?2Zi!5E&}d-09BE>?bFZEn)&C z#`E~-0B%pKKB>=yR?)?dp(0G`iAB6FqoUIIAdv*(MsAYY1lL)`-3<6=lmP>)AnK$Z zRER0)>eY7EKQ%YU3_L3&A$&Kv@W`z>M+~aBSaMPe+#SE)rB_ul{&u<~-sD0@aY+~% zG%0KO59`UDxzd>&S(SfbBu18X!(Ue;%hs7rZK6)n%OoI($Y6{vp& z{enVg>;{|qjG=vU?uh-FiWnHRfmnb)B?021?J%xanlEy98u~MJ?+5?}l$8D3?(;i6 zyTpVd+sBtmkiQK5)I+8edF2*w$>k1c7TcJ)uuRO?h)ACKqWLn8Dl2}HY%Wn&E(a8G zHEWGSBvu%IAqteGqKb{6Bf zja66MAAq%3cC7;6Sb&3_gJ|-whlKw)q4o5C`D;I_C!-a4)riD>kZ7y`V(icoBmg?H zaD1ZKP;qFM#sjSI_b%BP6UWU@>+rV$QrxzmHn@-tL%V-RpP~!@WRQ`Fo+YojFk#Ts z!-G&OHe?}v_8O__#p~I=OKC7l!<`#l0&~lNuf4AECM#W)S-a;sKo9MnW2QR*@a*1N z(#b)X&?0jp8NC&D=X);&+e1*Y)X)jR>c|ofwAEMCXI8DWB6>LLibJD~P#YXf5CRJQ z+=vCk2ELl9q6UUqnop8QPp+DIgKg-fNy785(DGg0t`R5vKGCVt_*;_=oq6+cmxD*& zSNzw8cZcE1F$EtC^6<}JnW=2-e+peEdDl0HP&jwu(OVTnh0~-AKH3!CQt54%3O8+W zP7tAFS+Hk;c%~&<0w$aw&8jtQ8Djh)8jb(w|G&X4Y+@n=L@_BL8dh&OM`G1t#l*Bg z1|Jani<(mh0o3}(|6YNKzV%MAgXz;2r@vQ_9CrZs>hYEn8Oy)ICEXV$Ph|Qbe{jiI zT+~3%TxFrSev|M0U&_e*<`P^DRFuzN8^LyYrAIS-q%{Aa*L~#~(`~UxNTs@P%XXOr zm$i3TDBUlNu#`%ITKaiH?XuPZCkc5*mn_S>QPfTI#i<^s>yQf+tnFOfQ{}>qybJN9O0-^nPZs&{U&}LJJAQ z^M_?l9xb1awhFVD#)E)jh^S)Q8o7BcNZG#6P8jSDn|Gz;cX`-;nf`Tf}^3xdD0_<^O^FRZi21$;f z*x~FB{c=!SZAGz5E(v`$<*|ojcZP*HPOtItj`>$c)qYNxiG;XIrR7+Y z-v?%eRZqVN3fA^F9thsEtq7jmBA4xm-->HDix$M7N@m9;1PMDGAVkGP2#_RXI9Afn zae?eX#`+UofC{7uPJuI@zPYx!BGP^A441J(WZ`K+%xn*}X?;jVDK`)6R}I>)D&B;7 zpyH~6dXx*ZX1?fdsq=;Lz7+OJdgsQ1^nBedd&#p$o^mS|5}_>6QbLL= zYElXFI!Ie|{LLx3+Y{(@ZX%bTw@)~L>HQU_RbRoi1yNfN9gbJ=K67qbY4XOm%@&x;} zaAx42oDEZvj@X%esHoAh6i~w%0BBc9OguQ0c^T+3=&Y5ul0J;Qr_GaW8{EUGok(Ij zH1+%@iBEW2ljsSUqx?Xt)j;2CY?krF>bvZ@Q{unVtU0AyQHU3sIM4F-QwIow9d)$P z%*<(+SXqiA6#nvH-GeU|;lj}0cZa=w7E0+|SbgbOaIeKfl-jjRftl9UqiatGj zucdp()(alIpxPnHn*_Xf*o!;#VGNj=v>Jx}>#Z|X(O947vDu67#_Vg7YUj{PBL6*a zXQCrepCuZ^eM9OB+$A$|u45nneH*X5lp4#}$He4kZT%0txn?*1$8}%5Flkzg?Z)Oyns=q2V)A{Sc+)QexZ#<5{B)!)*E1UW=?57MbnFe^odi#x|RboCA=! zqyX{hQqnKzr72{yB&(a3gA|O1@z|3j|2A;JaMD`EQd?<(Y@=qd3o30UBQ2NTVv%;b z>;KhW@Y;Zq#23bbgz?wlRwFHu*%POFXtCpvXN1s~*S-hyZ$W$pl>4|^Z_0gS6oKaE zP3ZWJo-jrkZ)*>}x@j~gEj@dL%>ok7Cf^0_@y443Urjd!YgSIf>B!Zct&-k%ahoJo zVNkeb#f-&9ywcT0DSVR;2_M1lCAwsG59t3NGsy{H8i?+rcsT@w(M;@ zKEh$n>jzU6$+EVwSx)v|Tu2DFp5ezJlvXqfRvVbdOi=^e<<{VSsmvQ`c+2v1V0t zk4szS`9E3UkCS8y_K|}8d)KKjkMVKW2 zHs^Yl@muhe@F$Tw>p#1oKaVB_(){ZvuN~_vb6zzS;Y~(XU!nnUfv&JHLt@#=Z zG+*Eu9WSmo`c7zEKOO4)V%AfK0COaIb46YsCyh0=-XKFFEYc{;@ddCN5O9c*#Hd0- z3s!cv64w}WUzeVzWW^}*SMGkCt86||a5NvMGbK=pDUCZmQ5CLTfc%&xQoVvf^{%PN zPGtpNvSA9n_7UmfVQe8ZeJ@BGHrbF^@w1$6S+n=cZ?Jb=TJ`h9g2c)plJgEc&dima z#tjNyNARRwn8kn|$rx^bYN_rXvCe+R)U73k$<1OJ4)8&7yQ;G-4x@s#cpn}L%Dj9l&1Md6z_5eVdH4ZC2nBl7}yvMQ)C|cudi2 zyy#fOvSwdE2j^KP=nZ}#p4Q)shwoWHi{NuA`Q-^~(-OjXlFRRn>StK5wUtcs@j;=i zq|bT&j}#%t40q>{J&rsU500RTvzTkVqFj$}glKLSl?t)bb(*k$ik^EjLnMw$h|;15 zVQQCEEk<<)vY3tk$5ymY`@Ar$e%Qpe25@R8vg1f1dr5G7+OfOR>+je0f;|nQS+6}s zhTvfRuhQ3WwYvRkR7Og3I zM=<~Z2I)bXf^Wnh5?G1A5OpO5X^DPELmYK$O*FCMg0c+)|9TE$F`-^&<;z{^^=j{Q zZ2+WYww)s5qR2i`TYJm?v<(K1bg(p$6alwlHVTD=6mtcT1_G3+>Iu=S`!ZL-)dE4$ zP$dD_99*@Dtn7@}R1d95*(d6^+Yh<8UhU<>apTjzkL#aSUpT3X;LFR`G_&TFKiH+6 zU%K+hAi7>2O+|HtyN^Hx&zTt{Vb!+)!rqI9Ce<|@`nYB=?i7R5IabiCe)j%PZ`4uR zsx;<3rNN)-k9R`cvN8%^3{Oxet^L>gj32P^)}1qv9B!?W9A`po?AKiY`cc zW2mcPUMCUUa8&FI+@kFz5vc-$MXvdAP>16m|A|2fvY;WTd}Phjd>+bXi#41sF|*l# zq8n5$r`U$Rj_+&JxnLp|5AOg7ZqD!lwYNbcw`p9zGztV2cH??QrgqJxDD}H|yH4@c zYR~FT)g8mN)sxO>gI`W}+yF2lh#w<2@7jP`0?m|@IOd$1s3q{JRNFi3DM zVN2ew<+y%DrK>no$y*Ke`~MR{a%x!8M&8_2-Ulq!E{Q9 z>F?2RVdWu5oTIDk^X=6!HLCAXak}D3K|xT7yZx3{=z(OLHQm&fr?R=_*Nw8y9 zt8)Yi(NL4Jm|#q5VAYQL3(OsFGfGGzR*`)s^`&$pN;_3RhQZn{PgH0nv#J<7j@Z+Yd@ry2 zwFb6?;3$yYCLpiYvc15!;_Yvh+R1Ql-MN@%1Vx;Pl4m|_r zqZgC{Y>v==!4jSGyn>Jz(NcBAXkJOJa3|c6J;!}>e+!z_^A)HA+y~qOs{V_5{{A&d zd#1|&GBI@khVo}3m~U;RqAYbr5=Ynb0Am}r^8DE5{9y=8Ns~$~1<^8Q>hz>O+bB1$ z_F$hZ17PY(D~{7F@O7fCSJSUXH|V3u4u>uBAlF8zZ#c&F+n&W@Sp=?bT#MQl4jM5y z1AUOucu}-OFewA}>!X&8d7MK2)4`L_;dQI(FAG!^PZFk{q&#((FUF`q3OnC2=JLze zvtRg`MH*{j1;@Euh{{#NE9zZ>yzr4+pl(|OO67>*R6DzveYLUbkDF}ht!B!5=Vo{c zI|}^&f~T-wWbuo^fhmADg{QHe6i89+FKk^3HQMi%*D*P$-GJzyciUvRh)x=Qx5po& zpQ5pshl4fGgi>r%A05U~YP!OEIf|T&U+~6oKH?z9#l6 z$~88@*Pp0s6>R1;0U?8jJhJ`{o`I6$pj!EmcNK4EO)4%MjlRyEwVN093*y{gbadDZ z^9X6ab2NPbd-_ir_dpOD0@klY+_skoiu?3t9t8Zt<4{VM?rfB@<|ufj#OIlc#m88t zyMYxZ-njJu00vt@nxantLE7X4u&(_h&BwRunq+=7Cjv3{kt{h7V^i_bQN+u?_^$pf zyixHZq{l=?%X% zG_5unvLl(BH&=iBE?ADlfexex!&GY!7*{%q1Sksa^)dX~DBY(VHy4`v4g#cU9jF;x zFmUBPCaDS7+IA*G)bQ6| zC1p)B0A{8t!=SSRg2#R2(J zYjrmv8+>gX;yW~*BZKO&v_4%s%6KE^VBEZ7m#SBG&IhrJM;%b@ko7RPjYmbLgR?A>QgTDAx!J~bnh5a zLNf;{iqJ34>rM&hdVyPn1*LSWkbr2fnx_d}`yGHN>~qQ*CMsx9mP$B38L^3;uT9Xd zeA2?n#C`X5qoSF};yV8hXBNwmYV~*W0!m#^-+<>1UG=PrBZ$8^u^`;UC2zvE!T(O| zpvf~xbJwh}vJ61lsZUnls#*v|^FqOofmu<}C3;IBhbv0y(Yl4X`|TJt4$y5X6kx zOVwySwo{`9N6F)=>-aJH%UL{Dxe@b@sAlZLgj6Z7Je{?7S63w`GIU?-HqA#5KJC|(k#_OxK7KsOuyI2X<0t411I&JAZQgD2H?I`ZeC#Z-13(f@`H zC6&Jt1Vg^W5*7yA-(iX3;xk`-Bh^*2ulKpLbR=l{gT{4Gto6oAw* z^dPcOZJ}{VhJe`4VXJXuYL#lP3jg*{TrmH{s|73SaXVp=ZQz8%e-592`y+o~F2aZO z<|ZmF1qp6Aa*{i#c)_pZOtfSr?TeM7L%V;kcBBl2Ihu*ifa545)NJ%vsDg#4JpmOv zbRpEsozcMfV3lClr3E`T49&O z;qo2Q3*iQ)wt@2&k|-KD^2h(Ii2UqFxdK|U7ox3Y)~v~WCsi`3a1EvX`&095;!FK9 zX!+WL+u*$Sg-%3Bl>be;{DCMemWpJLuhZ$ND?wqy1AnQ@JlYrq>MUvl!Z_sI?iITt zJ??TJ#wK!yQwS9?g4TH4!cKHfvcCRpE&YNQvT=?E*90pfG`xZZnj8a{t-RdwAiMqaxRnxF<|)SJEk%GqJq!O2E~wgJ+)Q@`ew_8I9iCVmE! zp@Eyvf00Ye8Pl!%1JzD$v5Ju$*ZwjzW{l`9G`lWVTG7};%ZP|V3P$IbEjAwGzy-yS z_LIl%`-*uBIES#G@aMa=tNz++Pb_;J#N^IDcjnYO#rqDmYWp$#`yMH^?2P+Y*f}UI zNXZL zn8VHaOO;v0y&UnXu1bln-`SmtS)K7|^m=~5{XtHC%9eQjEo9IeBeTITdx-L*f1(DJ zUA&=!_M>$A`ZD90$<{?;KP--p8M3+Dn`QV^8Bx+nyp)>q>CTd_#7%8L_SJh)qU6!U zmMVy(A?_!%E&jL~`xj2vaH;zTp9_rUWKjPdF4u{IGg<$m6^*HCt2%W*=?8K05v<}1=E=AFsKpCG0wQO zbwRDLK_Vjpll7nm$V%=v1D42;c(X&IVPNH;=_h*f+e>#G$@DMz!%Rc-+GEDp=Z;FE zC0|)EI}66ra}kTQ<$Ob)xGH)C_zcw-?vE!y;dTaRL5Bqu;ly24X#9q9GAmcWN$lQ0d`*O!S;PR^lzc*1;Dt(z>ov<46r}Qj^W4u38 z{3cuh1F5TMV=(aY#+Mnaa>g927zG8xF^Qsi3v;tS^ZIGz{Q{_(FtR!%GnYsE?(9QG zl5~#JLhcx(T&?92+S}hn!-<&(={93_MgKq;s6^&^t-!+&96s>pI@{!0DeWe>e zt2`-0u*}*k^JE~=BHOE)Vc~nib+9Xd>ImguZM(l*bWmn=L>Cqcmi?ih!h^*&fGRxr zX3clncod9wYB)L;b9_Wz9;n9<`gBHc~ukmE=^rs;Vt3n=$*^62FgWEDJ%q6EfVpJ@!$qn9xUKqTi9bG-4q zR4=9`^Q`YL1Y)DYB0g6{@C0Vy&t7VO#U7dC4;AwGZj6va4SaT{ps>#05m39q(XPTU zAvvO~r`PkLo%5ur?(a7q6XIYd#%m@L@^Rznx2TZb?2+-V&+A`6 znEZrcRA|3!t3&F-pz&M^b^Qtd&XY`!6Vk4Rp!}OR^IJC^5%ws{;`mv2P_z^$V+b`A zdKqCguSYT3Zat{&cBR88_pq)P_42 z+@B&H2`ifTbQ^ooz=}+{;wJq2Kvp z_9y<>n^JxzDQxo4Prz{U*Q2?XGMwoPS#r%t$KIHC1Y&Tlxuc9r>f+{X=Pw~V)GAC8 z(oOeC%P)!F3Rq4yb?|1eQ-plVAjN_r$k{f+7Q@XZFD&zz&go zXxl44W$jGYBQ0!)zHCZyqWTWA;+2Bp({Lujen5wry000e%zQn#R ze>qH!E3we@{15f6l3AfiFL*MuaLi?6H8Y}JD@b!7y}On0%2VO*OJ-jld5?s(=4QLF zm3TLSh+EgrHq2@x=X}nz;W?Q{;ZWMu{@NXXFR1H64qY*DY}KPD9j41_>wJK+qnX5= z{}e+4CO_N}U-49G&MOb9ka=3C9%p{z_iBt#BUhmb+-h0W;Qo2rWkW(UZ5rfHFk>?| zmPOeyy$?WW_q)~B>|{OhYezjoUzE~Dnnzm#xe3&pBUDo(ycKFP!$;1A8~N=J!JG_A za{#Sx*%7Hqm^c)1E26#usmR=|`S}jyEWFrWF3y^HXaMT?o29A`mxNqpW4xSwy$g{m zw}@W}HTZ_>75qz!_5%>)b|$%>OgTZL{3f2r;j(2p3jSz6r>%l6^yfW5h}mj z?s$fwqG2xN0!fW??|zH8+Rq;3|#OOs^cpBVsunUuybK(U^Dy=;$>*8nxYOW@>*7 z=UQ@5-8eqJ{8DUn*OlGymI%Tl6jametO4JDfgK|8wI>7~tMwDoH0qsqDu{6;s}V@( zLU_ZJrlKebvxz9~?Z{MCifkhK1z0AFTgJq4^t(Wpm=YUodL zDX=pW3jAc6P*L-Y_T@Tq6InYy$3h}1z}*G_zY%jc9i;o&exN6UNe+2 zomCLEY{@q>?iK^X<^&o4AqO#EOVGZS~zriKZunY4kU z`{?;j3~>L%ys8g4T+W|km`uMm5K_8&8K@Mr;i&KblszIWImkLAR4aB$JXxK%L#lv- zlfp?@vVkk)#hBrl@=P(wQ1dl$2bHYXNkT)kKvV9I45EOhwG z+abD3E`{qhM`a+p)boa;ybqV%@&dMD|IltE?ry#u?Q3>1_{ypY822oiABKgdtbUoLxU&b~nJcj}*I%%D3U%Fd!v2+1GXJHYrOHg zm+r^E+}v~^VaT|(^5W$mL2fkpvN`N8F;1hf!0)itAXW(#2Bi}$PG4CHVFjr4T<?&3^&|I?PNxJG(Iz^Gw~j)86k zw9Zg!RmhJM*)P8KJ(10Wo`fYf&)tm^e>$=q;+#M{eFo?bE)xf#TdZLsuDQFPN$*Bu zYyUO*Y>sBhq-2=E_r>eJG6BDit>2o3bAQ49f!Wcd7gRiC>E#I`P@Pd}Qb9*b=i7=D z`=;a}gXHu4QIF@NhYLSv1niMXfQPac;^z$kA$A2CM@v&S^dX_0$7i&)uNas&KL!Yy z;ZDl9Yhn?RcSvIW^}STOy4=rZrA)8>uj?m->z}UGCSBVLJ zXi+M!7|yT{r^UBT8D`4K-JEDReXWEe&dnxRQ`^OPmn)YKv`Kw9zG6dmGZa!ZhB_=` zVX7I`;x6nRl7Mgj>@x9Xfb`oP6=wh&)2y1J%rh;q-|;barKAKtXRISnoCRwCrzl!2 zAdyuA?W5mJ{O>lEzQ)~DJIdlPWgTZ?gKV%I#}EK*sGz6n7KVL`^(r|3DXMx zm5H^mwV>8I8Axx_D{`PfAVmyBL9CV)*-ihs1d%e$qI3oaiB)4*OK`XH*C8ldWg>+2 z!?c&$ElHCQ+d9i4`9alVsJ1rq5wf^TQM>@kjc@epx%d0Ur#6u|W{!2^i#zHI>$#ga zL4!?rv*D=adsL0)-&*MD~p#bzv}ni8lz51_92QY(qIWEnE-5Ax&k=6 z{nTxdYA7=&q0sJlMAA(65n}kzRQTl?VhA4o14Wk#@~XQ$enMyrB>1{ zxf@2FIZYhsvuk9R-r4p`*>KM?`wxQeI9x$%rU)%6Zh-xlY?$WKI6|oR0Hl=^+s+lj zW{ibFiYGr9fI<$QM79o9{A z1}tF%T-3tZRua|GGK+e!y>N$b)ziP(jy#Qn{HijeeH?2RAezaJ#NN~ZB+=KHwE^tV+kNB_MR9ztle zV#OGsU&maC5W3oe!Lrx&x~y{?*X=S(_kOv(>V2Z4in-bFf53y*ywx_@`(%c!rw}q z`sZeZbRu#+gz*7~-vY4`z;<%%PfPvW`b}mtGRD=CG>J0r8Po0DFl#j$&0Fk$LrX~I zTe}DDIMA@-nW0&QdxlYm90(Z>H0gm84dlA&L0a|jeD2vork@~$Dl;!xZ}NTj%6K#da-4Ktv7b)&@;q62y)-nF*t`;SHn`Z!nLQjvSgEmSdJyltZ?aKpT^he#m5!p?o zhdOYGbJn5xDCXkTf9bb~_)0)uff$00=&=Pyu)XKDd&X}*dO1drN7i?_gjXxTLDfw9 zp|1{*?>GCwuS%O9vh-G9_)eYmAwKyCEOP?pl7T`hK12y-Y+7`v!GCJph}Q({1J5b9 z#$pyzqJ}FVqZ5)aUYQe)Pl&s1kQJ37{{aU0S;aia3D#y`B$ze$e6P<24M}=< zT)s=&P-}ipjJOoRa(nZeG3~yLod)^tTZP}W;c;4{i4-gC$DCx7?9tU@KLAV{v#Lyj z$mzyHn`Lw%kHkOjhTeoRUxK~^#_OmkdW#cKYH$Tckj4c`Fs?1!A44Qw`zB%8vxc|y zARuZ%GXg_oR1v_63R!EadhM_rit_z>INHZ<$EB!tpzG5kn9dD#DLfKT#n|z428mTP z3v*~7mx3}OKrqZ5x+~znU9-u955h0P?o-iE`|5VW{^zj{cKUT$Cfm>}YSC8ixdq4m zhHxf_(0bq6VlZXbP$J2E_m6Urd-ysLK>wDr>|c3saF8>>@B)guwaXG{EnNY0MG2{6Q@oGHM8rKwt4mw@PPZ zXu0N7*Ol&Y2J6=w8QZ03*Ld=-{1B(Icw}0WcK5;9Z^B%upTi6_f?(O846X!m?VovM zHFvKb_vS9y^b}{qy#Y-%M1aS%harF&^hXZNDzQd_tB)a%l@X#Tz40DY06};>-Ds6g z-NP+hGL_cb6rOmphVL7tl0@<11g7)K@q30{Yv;V>3?Pf% zU)lZdv>BXd79h#O^sU2)_l-Zd!0%9XziGG^sk65xPkl)=y&7|{f!-tu*siEmTS;mN zhq&qh*IAhQESwl2$6kE+lAu8K)vi8BR)VYw+MPI*fj*G7s~Owo z8wI=o+~}>F46eP6);WhQ2n-gEel9Gt_+zruqR_wtPn{GtSgn{!s_~_#4#V63Y3U|r z2HHHEXEu$R9CIQ3Pg3vR205U_W%*>Ev4QxV;=1PbUr!R}GYP7Y5I#M@z~tH9sE2lV z?z6z>hqW-CcEr4Z2S&a-@q;|N70Gs!;W6HeQjCcVn_o;QNI3ChB?dc{lR|pA@w*ot zK;yGX;GIHUy=2qw+-jpmxQ5|KOQt#GcGhi(5l&d^ui zl_TGp(jvJrVk;6|1zB#4A)iYfHBvA_YYeeBWWA%K=2RhPZ^X{c zr{&tj3PEeueuwc(-tX@Y{~L`I-tlxZz2gyzVu4a3{3i&*uBEQ!f;JP)lt(eeZ9rPn zz;Ec9gaP-MmMiuPZFAS}dIRqN75(MdY(}&bn@7|m5J!OIQus0Lu=*2$ntdM>kJmG= zI)LD$24jElF@HU6;nev2b}QAjPd&_Xrp+jgtCz@#*~>E)p0_6d|2CvDNM2O#ZA%Vc{q9}>;uL@#z}Ijbu4{&9G4aQwsL34s#OoBT^KKhPg5T*Z`Z%O{}o? z^e|n51M+5FZX~=y+<=-8V>(B}ynDuHE`eQ@I)mXg;x+q7q_ej%Uc-hxTPKHnHLVOAU zr$W@or5q0%P*=bKL%K%-dh%+60{Ur@?NrG-^?o^CTVt|G9SeC4evuuulKYzvp)a7` z0o?Z=ZZw{MSXCexzT7`Pg+oN9K=Gt&QvN&u>L2)c-;rBp|4Lqps&tbFpuQUrh|nr& zfj0K)E$G)e8R_!86PQCb1-}~-H2{NpF)d>_Cm{2b%=R!Nhhw_4*X2OrECuadgXqcQ z>+~s13O9mXtOetsJMf)t8orNnctQSXApl80w!b4pWzz~L1o+KrB)u9)|ICf>t8jI| z&XTmm-OC{RRcD^m`xcX@i&E4@G*C_HJTGsOe*On}qp0H_P?@fIMeuk|-K17LB>$Zf zlYuSbd2g&FugGNSZ$Ab|6`FZMd-$#=ZG$zepRRSgwqZdm zC(HKSOI<9gNZp~7%iVL!%Gu#L+$wzlEc{jHx3-S`YWdm{yM$JLA@WKhCG_`9>z$@P z@}2G~2m){@V6fwY2&8y9khueI0<_I-4RdD&^^}x0IwSkO>~;e%t{V1gBn;AZL6t~MNOWUvKjwg?@8dn9Qc z5`TdL_=fO~CEl_+*m85wy}l|vahiWYm!9(Hz(Y0SuBjG`q55*%d}d4<@NKJWxU6Do zoBWh2!|LjH+00iqPNgI)`LD|)_Orzm8ax?U11u2V2*>z8Txg6{Rsqs?`AAo7x#(Vf zqI{4~v*>K2@BJaPzGU=iC%1bFK*4-t#P9H*sP81Y0Oe-|h-4JWnQL48JJ^% z`NKlV{${mo4P62;P&D!IDrxhxSbvT#|&lhzFb_1^uc6@F&_Cx?a7{ryvHm+~zXaXVJzl;%hJ_dKHy`(vLP zLDgQVxfP0-whHvq%!&4cUp~xYea)FO|0uzw@^F25p{p%O+7f-EifG3Gs$+Pz#iunR zPKX||{R3Z++oTE0z~1Bp9}86bBD*fsBo=^5+tno|2=6kFrnq!T6<(n-*05oQ5*g$}v8w+@n+Qt0hLy4vvY!gQyRHudrEKsv@YZ>N>pBt4n4= zbVM0Je*p3B!W7*Y)E}LL9-&3X{F};=?&0e?XZFsQ2A61Rq4(DN_-Ebr8uVwH^}TM| zGwGb2?v#jUsDJ+#mz|SEO2P_au|T`bC%z6%u#|(I3eB))wp&?z-b9SNa(nv0n;q<| z25g2kh`W6oh6K>t#v`i6QQ;Et|Ex);a5*KD?Uk(pKe9N9UB4h(8j?~(9h}4K%iZg4 z4DV^@n(aT$raixnhTO~hS%{%%BFAlJgVpPL-zKDPY+!ax7oG-%U8&i_Fw~Rod)}R) z!L~kxdKM&Dm+rfAVcZxEo1yA*;EC)Xmnu5N?R$d$2hVB6EQG;#*D2JLAc?$$d+l+67a%oD54`1~@+zwFLcY+EYh^WvupyK_+ebEVj%O;y1tU*2VdC zs%7=pzyZU(|p zZq>mES8^@Gwbn8OO+^J zLX@hBn?H(zYR)=+(~@JJ@Q~-0W02Yml?t#TW3h?pHCzH8V(exh-p3){uZVKK9oX8? zazQCC=_ML;d}9*Pon!;=XV@wYt%>_B2B0ASmZqoWcprvB%K~)>S3z` z?6H-37{+o{JJinoDn|s-u#fQaZC98CxT*ar#p-g6qoC<*xHh0?YQ^;3&8-VN#wS=- zGt86)bS=7!*5@9@HOo8vpDcjG(K1Q;~|v(*38-DG#Ks0W)F?DBXnXo-}N4} zmMA3*5b>P~vB2>XuNCsJnuAi@dy-^v^B;Lu3J40Kj6$N)8LXTh+=LX1Rk`rWPqZ3; zu3O&V6sOot;jC-u;WR<;Iu14(f}yqO9pOr%v2nyLNiRQg$V4zVt_Vh@*a`q0{+u$)hy8SfbR+$b5md)1rc z@C72-l1{+R6a+d^=oYF&AeRUNsfn97Y&uCh1d9fWQT!?0aXX5I+9H&kbOHpuqz1Me zy@e6>Xy~^~16C6TPD!%kZNAV*NpJ}+X7LUR_Yy^+zP+A>vcGz z&o4tr<5d5p{i7AruxJD2-4+yfc(&|9y!!TS&5AKVqrprXsjI}Qt;Ay2!1a6k&bhb~ z>V5cIM!^b*`qW+?RPLnu+wZawZWxgU-%k(myybRkZSj7H^<5L*{{pi7iVHjp)Of}| zCDr(MeXy!oSqBsyX<#{tK+MLt8}_d%ASR{x5{93i^h`PN4BP&}0G%?~AW(g2cm$z9E#2$qW8w^tSfonli*}v;bgO>S9(Tb)hHX{C zkr@n-h=XOr)&^}K?k|K){qHY&A@nFZ`TDih%fs=zcC^X`*O6QEZpPB$Deog)hQ`Taobr=KbGGNnCZWM{~?gLOR zSEZT>b)7(fBQu0x1IlrXAqF-VFmr&RLY+^lrJe_%#DBj_!Eb}E*UmriB7i;9gfv|zwkep-QbofUeZ;6?4K=f@68Kzc2 z&h6jb?p!f!zF@kUSB`>LVXp;U+L~4{Hw(8z3`>#HoJ)_&X%t5s?;+u(PF%cKlt0Z1 zXC+1rDjra_p1);NTGhAj3te*@NS;F0eZy=M9Mju>Ib-5%2-Ni;`#n@~u|ddxP`E!g zh*2uD=RWhHx4(j=ecs3qd}i>YR2ef7=^&Aevmh;j3LaZeWo``v7lLuS(Zm#P|AEA zK?tLYKEb@J>_+|Vf(*y^w&8Zdidpx&6R_&3QJ&T8%QG(!0Ja(8-%#}I1-G%iV1gb! zOU3US8%X#TnfzG?3j@f@bM`%}rI<#^{$i=ytja$Hf9jr_omz zmb}&Pb>J>XxABh<5qO!I#(!RGaMq%i6)J5#i>Xj8!4{7?Tx{$P6YYyG8_Jo_y7Hq( zv`9mVF-i)Ip6mbihuU;q6?`!dz=GswDI;uOx;Gf+$GBm<$YmU9Rca-`Wz?0mn4c}@Y&>}A7l!JsbH%B zXUsVeY;Tq%2#NFdug!occ6S zs`n3sbIN{)*ncn09WSDVR_rgmU6||loJn;>H*i$6Gc>c^P8mO%z%)PFgDfd9Z+!u@ z6M$!d@lC{6 z-S=kNFvI!F@CF@NLy9ev7=@0KjJn&2QU|{B+*_m4Fsu3thKC5EiAxKo!;Szcli9Fd z?NP9VY7YiE%6=p1)O2HMVGl@wVM}*Wh{)`|rKSKH&I!-$=*<+7NV2;?<96-c&m^;? z&%;x+4`E#ZG_#L3Lo+xpGLg`otf?sLWT2c2E2f=g9j#!1#QfpRLftj^|I9GtD2Ef z1+5Ql!i>BxI`Hy)-%{9oo{Yb`JfCru8~owd>!u*O%Ve}wM725hXMRF1+CNVUtf4TB zTj10qfxFnLom+kTHfljGUkXm%m;LXcR>tQ-!;S$rf3PVrJmJh7OlA<@@8)vK`PVz zzZ>A7gsK}goSZatZ=J!}-{JLG#g|m|2yEhu_kvYD^ygdcOqkLqwe;_%Q5V0Lt^)GV z!`c;Cq*1=lrf0r1YK&n4s_j{enX9zrTuKqH`)s)QQ5J_AvPZ+yB9m*41+ITaae%1o z*SWyT-jojH(oZF z#BrvIk|n;V@!;K#&0rm^DP;w}%w7;b(+7Q{kI@XYA>!$-zT)?@t(l^2FP^pry%yfh zzuv9GWW(?uw%f5`%L6cEgU^Dpq;jM@mMcV91HwHyhNDU~@gSOikbZ)jf#jjSU2bY# z$uG2gIdN=Le4fv%jUg({SFZ=UOt!1HxHYwYVb%3EoXnnw+5MtK+YBcUuI5yBJ_fbE z$wb8Tg!r~(YlhNeg|Qk6&sJ;z04NMWh{OMYF~t8QTV?!UMxjqUmmU8%o z2Gd9E+#iM!K4n$xq-CLqPp_5f@g` zfNI3~Tx@gnM2bSNvQf*uX$UKd{|N`d2{<652CX}rLNiF_o7qUWf!JrRvO0(1*925} zt}5MbDxTA}TCbt2pXJ;nO-m*cg$&v6D+SWQLtmv;#CIRy=Y~OA-sEXSV>;Tu|ICNs z{rb4FZFyi%ll%Xj2hp{r;K}iunfGn+qKCa-U|kt z$=XNegL{0;y|W`PFW?V|o{Ey#a~n_Be{5U>4+zNR6_SIZM-C9cZ5Expdlf7IR7!TY z|6NiuL8o&ks+{W{2QiE)zRw!nwycb z|K(k6%)!fhE*lS)#UWL!D(Y!PJ_Hav2obwBXwz&gv}!UD+r!K1-NGGO;Lg!zqy4#Q z6OvRvkxbuG+2VC|@N=Kbv5s+t4_3^O>c8I7_ekbT1o4`9XV!6#GmeiV(l-HxwQM%H zYkpvZ0OFGg8~GJ-YPBku=zd~@LaF!~lm3KjTZk)+9*#FUMoi&m5d(l><8W)`ai9Ys zUbC~|mhNv9s(}WBeQ)Y3V>uQV)r1%^KD8T>hD9Wtv`II)E>47Wem2_v$6z>5Dc_UI z4X9um-n3SQHyJG^cs^_*#vItBJ?|0$NHIiv4mzTPM|wyNQ>(OX^i2%ew4o8y0LR7A zkxzTKO`r-x;hQUqw5iePy$t=#tPYxANcM>G{YUV~zp2FJVyOH!A0^gEz8aUh-GP)v zKke&opp_j+$se^kW|bYQIQ_;j#aSt4LV`!IJuH3sHwzkp^&@|J0ki4N#) zbwXlPFRrWEev+qL!{Rked(JF1b!IJM36P_3u-o~Megcf&U|@|h>=dJ zdFGQ(j~8k(2F&aH$NnEyREnZTssY$DDFM%IkxI$0n0+`748p8m+V14G#~Nzyr3}2+ zYs+jrTV@Uht7OvK=o{?s5hQ~>or7>%wnSI=Nr(4w(^V}QPW-FWTUevMP-*GUK&Q6g zAdre{>7!pMhA~HoBVibwnns)zLpaq3Gjo1^6Q_+lw5SJl6n2PylV@NV?}#IM&aqp<-33UP}lC2C!DDDtQqLL;F5d zlAgRE>Q1k+S9y8GD&uXdVJ9^XNlVitDe{cJjaHl_h+Fj?H< zrjW#Z9c@R~3<#0F_Z#j6t7ztau$QM##L`I#YsYS?n=8b1p$;gQSrIk{dcaFq@`YQJ zuFMWB#y?fDN{j`-GlH6k==Z_FwpJ7@u|hFSsYrr1S9 znkA~P_f^e>>y2)O{)cGbZ8xiAuWI)Z0i;MO5_lOeNTl88SWza9^AeiT0Jg+>J*35l zK&;}>&0{Lg2x?&f<9~V_dBaDjtUT(zctI?AcRmi#yRshtzB&(ja&s|CcW{Poo90oI zmsfwDWdD8k@=MeF2f*M$sa9xtdzvsR;VLqc)ud?J+^;G_e({;ml)JeskG~Gp-@amv zT1E58f2Gk%F537%wbnr8xzQmys^?=%G05dJk&q@#RB}Y* zR82>L10-EF4F*84>)}m-jqHfaZN`1ICQj;ad%ptlQh7YRzJe5w+9)jeYVmnW>ull+ z2oK-JUh1cOEYsoZQ*)_UcWit=<|9{kSAl^y5RWw42|`ZN2*rsvGWaoA**3Dz^5x6& zq9OEBV{kuygCcLwW)+%@s)!01_5y)EL;w)EInrY5+>vojX$FueGn=vL^7f#`%oh=n zjb6(TqqC`rVCJj?8LW(=rK&tgBOrRy40_aRpa5%py?V=qKSRkn8=Y|%l`f2%vbg9cn^1}S*o5h;aIuRhd7bxD#_azjL?1E6YhmC z&}M`O7$0D^)X@5vgZtiVn|UMK>yVLm*6WDQIdlZJkv>Rn-}38_i%oD>5(IL;hANv%gj zoqfPcIyERiWl2Q8at3GOJaaKVSd1iZfyhYSHx8XKf5P&M4@Nd|3}@2vti(2L zh~qx;YzyKQ8n;|Fqem^aLhD*{i{$0Z$C9@or{v1rL`=@O!aP)Xiz7$E=$6*KzP?P? z2&-^~(mkdu!+ou4^E)Eq%GTY<+HlCY-)h&L@UjZGzQZw%t_D^R}p5>{8N}Gs3{0=>!sq1}`A5+C(p>_yey%n~emLpzQN_)SO`tzWbOeOEsFPfUOkS zOr1rBXCXThB{@KHu;;LyI-x40bp|gilS|@Sy#_z(y6=#0LO~k#?1KB%f*31Afaqf& z+-moaV20Z|7X31UoOQON@_9i%T~6Bq?1zP>SOT_tKpKN6`h;^Ez?(p>B zKqTC@%<%S-z;}xGkOb zR*$=me4KCQgqg>bepx4R<2CifRR4Y{^S$+BvWpj-@CR^RB1F+u1bn9&`ldldV|KRm z3;5S@qGLSw-JW1PfBBF?oY;%e0p;qA{SYB+G=<60V$ox{JDO+WkJ`1Q?x*F-5i*RN zk4ezQMGXrfe*i~Wd6Yk|T^%DcSc<2_Ou1XGkMylo0j$zf34D1gM!fP%Ri(P4>OGIe zp$6dKC+6@Od}9XM-2vb7K0>f35}+T1L1QAfD77_DLo))Cw@XJ6>5 z+{^f-A9*ss?ae`dw7mse&}iICbPf4+8N=ylE8v^$59G=&ev=vD81Xz)rE*Rhk1-Fz zGC}eEuK$wd*0G8EY_=XGYwYu4o9+nvhGYa~Uy)u&vt_G6j{piA4 zI2&3^6`si(tPM_RVJrwB#9|U89ZuS3x>)r`A`)Nc%oWG}R>|%6(__qnr|WU_h;M_T ze1k}O?@t}cy$Y#`3jTOuDVeMe^EWPf59UqACOjm1&Vf)$H;iLyzSs#Gbi3@=w^zmX z^sX%=h}yRO{TbsG+Bp6Ct{aZbL7BE2FgUSjGKBb0&HS9Q+_?Aj155kvB|p@)*QF|y zHAs*a)*D+e50?mmQ|-0noao}Kz+a!UO|j1~Q?ku?llgCu%aPTc2+gD1j{-hs0ds<# z18_y_kep<;!&$YOX5LVVakrdWQY9?QA`>6p+L>MvFzeV4>}CZMAe=?`S_z9}r7gd6 zsK1S*=!%T=fd0gV#Ze+0J7h!-yOn-+mYCfU6DW%y&;w5$wpvkI=AVD8Bj`;DiNn7J&B z+Hzr4$-T?T3Z?DB9ZUqW!~7GkTA&%hb^GICMlE`y`yN;bOxNAr$uHGRPYBVQK}zs7 z-au9~nmvjR(w}Qn0%xL`dNd7CMU~pwnlp`X>kfJ%$s6t$ui+7fi>>|2o#W~N9Dt!G+i$kZ-HaU^*17B$$J?Nw;fWgL zxjBJWao$xJl@2rStPYTu0Xx|6;*C-yDEv=?C41R!YY+l5E*ik+0Ql{)WeEF6c{cfL zA~0iz)iVe#eRzQnsC5C zAio^DGi=f6C>*F#_q8Z*#BWxN>90ZdxG;u7z}!SLsp#p=+>gSrIhN)-OsVH5)y>=!S&TR6c;r(+9bo3d}_R z$sTf_hqEkH^>~*lQxA#A6gLCxJg%1?EaY6h&)VorrG=&D9BHz8{LVGRryNRhCb8ko zvX+mx&1{G2dPA0P8^6*}&iWuvw zX;QL`0m_Ce5^)?j2@$fO!kt}FjuIC8>0d{M;%J9eJ&u0=IO3#a@zPt6`Um}}9l~Tz zf6LIB3x5p)9&3ae5&KtH5%2_~KNk|dn%u=!AJDbezIERYaF5MgmB@%0SC@C$W+2ZP zADzkzjs{e{2iV1qoL;7iEVLGgW=)+6ZhNN*;6n?9^T`bGo_L-^Dj1)g z(tNTQ5>*m>FPAV>Gv zcPXwnT&aySPvpsWO=*);k1KOgz8;n`)ZL4`LV}&5Pz*TA@X+L7-@B{^gdXI<7^YSo zEmrt`UMG5ONS>q04-<06Kx%t=^-bF!xli${@kQ!%-<)V99`1*qYr~8q`u?0?@cz`3 z!H+QFc@8|Yf}GKx(r46{2EM%QzX;+kkFUpYi}kaczRdUfKF0k)r?mwxGYYlrgThX% zHfu7X0Sr0+%pcNEU3=7|BxUNFBr&&uO4_7)@i{}Npuztk2&Rey9=ZkOPWw{Nc=CdT z=0R~buqyKVzu%n4=fzZ#rK#;6{lS$&PvO%v-Y>2I>t0ee@%6mt&^ z*x@qyl)1Ok#FmA#L*u!73u~3*`UPP1-uv~tea}Ebw`j-&BJ=BEWrv5b?sP>CAZAfc zDnkOrbbF-4{f7{hw+V;R2cMw>Z_nw29JJ;d@{le4)LHNS!socjiRXUcbRFf1ssBrl zd#Rhkn~NA{CSFhFe5cLhK@z`w5mIR-xJv~CQTwK1Nz?tv@EMYi8QCV$&wV_sGcl5)o#&3S z`s7301rX!*7FC`0h0D9qCK!3iSQ!5{kkalX%z9(p-kQK{FLUZm&{!N^uq-h{&LK;< z&t2n4n&nw(@B#f}9myP>)U=~{Fk+`p+hHVp)a*~a@IRj9=fr-f*P>k9jXcMROBoJ| zJc}dfcG!9qkkiveD$%sKtnFnp`Bv^*y1=Ce@E^z{r=$Ah4hQiEMkb^_7LaD9Kp#Pa z9u|L?cQldbiU|@4c6(X_=QG2C8hkQ3A78>jde9ju#OC0 zG~O%k7I8AvaoB!EVe5%Sa|Rr^JE*z1SJ27{3}II-irE>w%5j@*^2&!){o;))yLpQt z2Z(o9$s+S)AXQhJH} z%N8?qNNH>uCud_hNF0;W#wz>)u}Ix_sf*cnh9?lJy@7#SLp!=uUr)AW6OXU)6Y%%d zMc3(zVn9caw-*#hPYQ-HezHz5_AK&1-CDT&dxC=SqoJt^Cc3ltReev?Lud*43!$Q^P{nQiI<5EHL(Ci|88L| zU?w)=t-giH|5@$#Nc6t?+z zJfyJ@Ui_9^NSzh=sALAq(?ukJt=ENvtRnGP(dZ4%=C%TH7qFIhZxMhUP0)VhibVzg z*3pqFoYV;TXc}l4>yaeZ^-?xpIp(vK#i@#QaW)`>8oJV1vb4x$M|qOTl(p7ljbn8H zcR5k=s=(3sLlc=`G=XE85)RKi#Xg#;R9cr0Ff=WuU0NhzqMrk zOvA-?Ye*4gO!K_D*J&$kM~2?xc{B`vw3rKbud>&QrvicDFFaMCNzb{f$T9MsbN3Q}*<8^Wis05Nzq^E23(wgn#TG*$No+lrg~oq0 zT%6WqpB>}(lRnCbf&*+XC%!)m^I`L}g|h0w?_+TMM@4OV`5!AADH*`n9lGDEI{4W~^G2fEe6xa*1SKJBib$xtdDU~5 zQbkB^H(1~!RLr1!=^d`y{)>Y0AP>@9(U0E~EVJ@x>QDF{j!`^{WVfomXC5@v)Y5`29$Mi-5bixVor$8$rDg$g5UDoxFf#@DjEAj%W}m z6X1g;LCJ8tHeNxr*unvRBw0Mu-8he+fnTQz7R<8t$8chr^4~S7xDFe?s={q-@4vGN z3aF}Ws)uFyYG3@ix9TZ10B3#1$GeUi=Nyly?B|~_zA_j);K4)%)&c6f+pR7ZXSL`7I=(@DYl_K@}o9PegX=Df!v+%2lWZbSs(P2 z=w^TP+Clb$82P&|NY1_XfMF5llin~UNRlpmO%vfw8b|k)Z|tC0w%qPFi>pp=6ASp8 z(W-(p?69uLEcdXIOC-=ZQCfNbbAjHJwvfTy!i{icKncRhXe-zk&?FtIR}Em_!KCRl zSqT=mThFMdwVYSKcm|Rvz@2D@u1H<=HqtZ|gDoe(3mn7Z53?eVF>tFQ7_F_Z?jVpf zO~(_>yl=MI3S>(A_sb8&S32L}!cVLJh{gRr{Vg%|*kyOpPn}3Zsx#$g7!DlI&IIW@fy1rG! z$bQN8sYvZM6D;3@m|~mvD$6r+<}D^0#h`~FZMAPQbfzwz%wZp{ki(GKo}9s%I@l3= zMC&@u!Lv1=n%YodL8?kkj zV`0{mOUz8;R8oCaL4ik7_l6EwL{lrcQoLAu`UpranrocIiSCUF(61_b;r z1|1$lR1=F5RQ0vqzz*q9Xo~hocZ(}Zvi!9t_%D$nB7C{y__Fjfdr&N?~!qABX4MM*bXxIA4We}K7!bt-`;YL zi`MBmJ9P=<;q4<1HT2W$2`j8(L?L@lRc)iyi7dNe_Q0MDVJYc&fMCw4+-Sr(j4A)A zlB{X{gCPBjcQ%*rR@q#AH0+dU@2Lr%VCY%?2KT9dEWpFOMn6JU1vYa`t~^9?eoBE+ zBYk@_6s2d^c-s+wP0+deThoO%p**2J;?2O{9Af2)R_Xa5|9Kc&F3mPm3ET+;1V;*Z zQl9}Wmv+cS@VJlEn5E$goG8kc;Qm1$GeH z4o|5&BC!hu8LgWCK7)R>0?ixJU2%UxY>WXoOY&;$&n=69URjdDc?c_=O_T<-1mE`b zQt@9Si9Y@8O1_?P(Y8D5B$rMqQN1?oUV#ZPdF%K$=0`q$twj;lV-b@h1hf+GWyjHF zdh_d8zc|ggh4F_^{|Q>whA8Dv)*vyB`9OErR&h<-uz6*%=I;g(HDM;AMU8cAza;#= zOQ5Di!v=g@`P%a-R{jt85A3Wem*%-e;q0_QPBa#tIW0JE`6|gD87vaPg+Q>-hiyb| zkqxuOM(>;nLR1U{kiRMjhe$E5EL)vEN#KcxugeZ4%i09T1Ps|u_nAYihM6n>pVkg6 z(^&P7);cenfu#VCs3BaKULO~ub= zZ1DAzP>`@y8VxL7SIxg~D)|cK!t(GwNSa4@*CTh3y8u!tNF`b8(b|jxqzgAnin6zR zf__!{k>ej{X=x4V)r9JIjV|Za2-b>t@)#o+A=zuiA3ru1Y_7QEtbaRgQR_Id_~1K1 zf;i~gXq^%RZ{aQ^?x1bjCify2)?1kR%a9|N^VrP@5Ig3}vx7>ipMVPBV+Pl$6~u-C zsOzYHYRc;lU*s(!epaqW(ditQ4}qFd)4Q?<=*VUg{el-(JeLbKr$==BvuPr8G=;@D z+R`o7O6}H!y$fj@Rk5gX+$y2?U&QZ$K2G7bV@jg&?SH&;Jx{0+X<_W?OD~?TXRw-D+dXo)Z-5`FDI*C!aF@)B5hD*mZ=9NN zDk9hPi83NeW>^SBd>AVqxle-$QR=StcFoVamhc#dja?eM%E*5aEbNIP7TKZdL43@X z3A1xv$~mu590m0R2h1AwXem@IP!G4(kF^n?)a>-jt(D+iQ^W3>4D{4B-~Lfr$4wTB zk*N$mIelEWuCE;~9h?n5;0l+}MeRU~wS1xVLECzt;W~DZ4?(MCDWBw2PB#;0PJId0 zE0%t_BY>PVU{;oL|wmJK-9J~XlyC4uI7Z}^zyrw|kV@6lMm)vEwC(aQZ-WtUWr8-V6UCJed z4yrRwG3{UVedj0v@eL!#Grb_4Ndu&~(=Ed0=rVYJGc-)aMh7rbg}h;yocX)Q7xl>5 zP_tS}(n3q55KUJDUrS7GHp58Y)Woy=&%iFO6@0e2jN_<20DkE@HoS^1~z?*pZY%79sLvZ{Vh&y$m83bzqZHQFNH{omg%HlL^Pz z5tM0~Xxu?JoJMJqQBrw97>%{7zuj_C`(+>T8qD@D=PA0ruFdn*a_tH2CkT}s;Ki3J zkfx@wZp&Hs+HOhEeAPV7XGRtIA$?`3qt{j*U212h3R=LaIK*a+;^ z$!hytti1umfVF&xRDV9&&xLbe!;q?3xKdl$2RoZJSKowaO~r!OnAvJiEv3)PQ_rJv zy5YC^JU=iA7@O5iV3WE1Bq`<;)r@r09^D<*C0y7w8Ln^`FF82m(#tw@V|gLf4d8f) zE_WdQQJjB@J=N%V+h!+Z;)d})yo6M$Amz49xDwrQW$&kRqwT$~|+?uDbMGIbGW0Qx&1-Eo~#ZIT{X; zf2}w|@f1Ig5pAAom$$`v0$quKYd^UW^Fr+MfiIW$`7RIKBitA8CcXjOd0uo{9G>Lm zi!6D?$}%2?+Np3Lz(ub8c{!Sak~!s4mI%3vB}H`5-+X7I(_M2cb5uHgVit7k0l~oe zl>&RP=yt9ji0w)({2i%U4|zA{*pSdPZ|sV)Y5nfrLbLlD0-I|$+zDTv)2Mkgv@zEU z$YkA;K=Fmxx%Vl{nXR+sQNik8@lpr<;p{1#QfJ+B>@Ik(q07dJ&wZgh;=+tk<`}E7 zn&talOHiP?m*CR z{d+-`qIX;!FJmph;L;{H^8;IIi^<)5bPNRQD=VT*Fv92vPD8M!j zqY>paftW6bIP0sa>IuN2tLmqE1PrRU(TV33ZoauLF zf=MNN{$KjQ1<_*zNG^jkBkj%p!ev}Qs!)|I$H%Vf z%(925JxfiD>Z`#DU<(9>AUJlECCz&1-Ah-e1>J{kbQ-q1(r;NhzcR?gs2b_~n03fU zQ0)3HGsQ2#-Se~zmGUM2p%cfzm%j45)qEDtmi)ne?(GOWr>@EOFWju9F!5Yx%1bzi z+m-$6wMfaM{du8aU#&*Jw-APT8aK>eHL=(&FmVPUSw|Y$Sk{2AdI<3*?fbHle_^no z79s^v#E*Y15lFlvBngbgSD#|mCl_O9=}?$bI`EkQ#3Ex>kXUke6#Yht`+X2$MD@6l zL?Ofl5@&S)w~s0?FdZ0)EDS?asfaiiRg&`&VY6tZE@Tdj53lT2Gl+hH_>Q`b9>ojR zO1XV~-D?Z!U;ImZX*I>Kc*|Up@4S|f-w?J=1(;7xlN3NdHd#uo@GCESAOP8q{V zcUUWSl>vY^cz0^w%1xMOx#hfRFMUOg!?QKGYS2L}JX^Vwv*OT(>Snc4YRZP#c6BE9 z%_Z^&%X!7XP44>d`2ckM?=dme$zdRvXjRe5#g7Q+mu>kbr)lSpLRmgnQy!>WkaYt@ z;}kNStL6kX&~2c|H7=?sa>(iVC)5SPb7K1GamaetfJ|83#NP?wRRtR~aUud3JebA* z(LyHR3xZkeZJ@}4fXP>Ho`|k-M^9I!ZM^U4Ni)^);^A4OW2sMbm8>zIiR9FNTI%NA zuj5D0D<$f=ScegyKEc>Id2lUFq%zs|auWzABlGad2n2u#u?QKed4FUj5 z!K>Q3!OwC3a(-$!$W8R+ha;1F`Jzz4E$_QPND06&*3awh%zcU*iwakRcA;-#TEv^G zGuHh-jUKhdWb=;le9Ll6LP2iR{bpKa_#n(F5&<$09Wd{I#k|B5~d?G zzVzJ2G9m)*D~uTridizaBrgmd(zY~9!>7l2ko8jz6d55AJm9NmCnWx8 zC=c}#r)(x30#**?vsB{=LwXg{g`^q@%0_pPfnQI?ZM}Ixg@4R5-wam2hpipNIFZ^m zZ8kG`v_PYf;;SExPkU0C?3K9WJC2lVf1_w7e9&hwSNOB)7?CdMABqHRt$Y@3sSZnV zq)P=%j?dM>v2_+!6yjMSSGMo`S-x!0M?lE<7dfiN^}JmCxsjWnILVOq;n^0+*7vdf zFQV6&@XlVev+B9bW=J3C33CMkUcou2z(3;5BFwMIw4>oWT*2_>!TJpmoDnl_pVK?4 zJIm5@L-LD(bMb_eJRGar#0QZFgWsUmyrkR^Mq_cw$Wz=j>mg$bE z1v?#G777*Q#Mf+D9VvVk6p3db>*U(&4^5NYCJg^!N*h1bn&2yT}3e9pM(VprW1v6*) z1aJ`AI1b1pf6VfLNe_U+#OTYw0WC8eJ#$TX9H7CUo2*%AH}OObWqTzMeq|sGX#MBU z2xAZKk6B5z!iq1ovLkbh9^ApzM`2W`fl42tsI0;<_jl7Hc6T>80ma{4<}xM}5?td* za;on}16+x7DbNELylPAz6@0w^_CJ7#@l|qo4j_-Z^=S_Ga=>@B2p@&nQJ5)rq*GF` zgqyDbLqNR0d@~{$#kxF_?@__4gz1j>igoLra9cHa>gNa=aAq>Wx|g}0>o-rBSrC)Y zDmrwQ12{;qHM4&K;lZr+D~xE4&6|l^mz^vg7?0^i?8blmg^P(eH5=bW!9(H4;uAE3 z%>#M@I8^<$5B^6%HtJ<_p&mL_qqni7V+Dnmyi&`9}pN{Oue(c#d#HjpPP|mmq`YDSA0pyY4?n%Nx zUTsIaobN^h{}xb>iie~Qw?0itmd7l*wy%-)9Tr0E7RtDH?4{fST9o!!W_q}Y+kpr) zugCi@mv>p>6mBH=m;3kPrxy_Z7}`YJk!teiByvE}%}Y~KKVrVIHJb&j zkXt#ROmLl~EY})}nNIcq042B`GcWlvhohq|l(2B~>rSP+O0;xx%j`xb!Bi*Z+L01l zAFMaYuG9)w*IwTQ;{U8fe47Mr-BW`#V;&jX)p5%A#d%~A9x(0&?tZ~EvXN9`KzkV8 zkQjZi%2`!i47s6G{}En)H&h^}q<_E>bsWnR1T4F1uM4%l^K=|tn}t`6CcjCjcuFly zuYv2e9t6OJ&d!`PA6tBrzjDSOziof^?kj5FA%Abhs*)!j@4B>p6rD8zES4WH2vk#> zVQwFgW6QjR{qa>I!KVv<$^RG-r#0QO<=V7tFylbmVje}xmOyj9gk=m4^}~Uft}+z? zqx{b0den?eN?zc86P$_1&7?JLA+wOF6h+6?zxk-ex~faaI>Eh;Wl%5`Q zB@fU)_VjNklpdWz3Jk-f9`YDm1x{JkC6`+PYM`uGhPZI`vMzg}A)u35&Yf|Jk+wI+ zb@ui@cw!4JYsLs)>7E+ME4u$vO;3Eh3vVbm*AyFeR7D@D9o_` zGjJw9SZgQjcIfn!avbRrK>XXu5Qq+Ta&1~tez6h7W5bnv?=a$uhhprc2nxw(c^$k;?|>i~>#+eX_{kVo4H>s?dxPa1ulk80?z~=h%GcVkTfHQ| zvRGaPOH3{Cacg2);61;c(;Rtne7Yf=CS}aw`b}WYaoQ4p&G%cb!aGr z6;++OG2R|earTfJRHq=&&zkJlOIIgq@kBd@n7hT9jW0^g{Moo89N-kv@Fpdv4-)~C z;DJ?mJX`bl;g(<;zCEV<5?w>fR-=~N0*<~5{B!FAHu&48HMz(XAJ?3I5wu}dG*PJw84+SE1Yo(2f&ek8U{XVkJCn& z%!4JX#o)-#YOVpk$y-eiR;M8_mZ>NJY!3-(KP9aL(d$9?v;t4jGk%q!C|&wu&OP01 z+);c40Gz#;8&uJ&zBMV?W768w7mlxTU$EVWyj=@Z@ZL`fqXFZ}iXJLUPK<_4}JecY|bGv>D#14HS&m!XbW&B88z2bgw9> z_KX7b*%8RL5%Qa6eXy(74beV-;dSR7V_Yv=)m|vLC&96TM3icZOFMLU%t6j13DdZ$ z$@+amvaz{K8-`qr&-Tv|%F7KvWLv@{n1@Zoar&fezqJ{M zNyl3_=gj-FfFyJsrW^jWvX6@jY3O9J5LaZ|sl}ps+Wn^QA9@RDSTy=@BWhUORZ^ar zK)!i2@gTeppt1~Ne6TGLGXHHw_z-`(H8KM#g+3+fa}PiTkHOr?8wk~ANZ`0zGyX)b3wf9|UZw9fD(&*~-MLr1O&E_XNC_PkO>t5EayQzSrv ze~4sH+?|t*A^Kt}RB827GaWE(KoeSWjyV)EkJr2t{}Rb*8&8_0bSZN!+FZz~PQLHj zykgWmeo`UUsjG&YNj056lo3% z=Rxu}Q5!iA3h0`XAfhvL_;d8Mv)=J8_HT@J04(iH42l)suQB)_9HEMZJ5U-istXu+ zk>^+O)Fp`xjB>$2&g!M?bU`y+!H+k3EWuTr%`aHn23 zRp*xtp+)(H!3^7xO2F3>hxwFueMDUW<9sGy@!%S?gu#aUAi^2Laz(DiS@R=snUlVhyqn&*H_xUl$7(7VTM&~wfpdfKZHI)=b<2k(lFG~;S zjw==eN%fHwjoJB%^g|Tiasm!b>EfKe5GDAp!iCL`D~J;dN=UA`U=VM$Y>gzc**zZU zqQg$Jp+_@mv4B{j^&JKCi2$sr+3lYAbn@y&8neJ=JiZ&yGyS!$qx2CNht%3c@TBrI z65?-G2LX0|t5{#)`1*I-9|-~!JpJ=tzTKVjA-GD~o~6@?esX$G`3t(&7yxJ(iK9e4 zkpvG~o`H-v-623WL*2w7hfg*g{6*^FB%!erJ84BzS5)^r518Rt`4`z2a~8(XFnDYb0~>Yaaw1=NHn{!xlrAd`*TW{K-L9_4zQR)ccs}`TXX7@pDaT z?U^o@kg>`$v%ooGA%Tlv1p%zHi;jg*5bx7K>Z&EHw5CBMxbEjvX{vfiLFdK0~qWWf6FC*bX#CIcJyA}ag$%LHZ zJP2R5*OB)b^|dT{_Xl1Kjir7O-Vugwo}GFCRZdB&re@F_8t#_^6tl?eV!11K=4L`D z6YRLemwE!=v!~nknz9O4~z#bK7un|GzF5Knxor z5ndWwY=vH^swS}S?wB5t!Jx?=Ik0VA%w3DO$lQ58yXAqi>q%+!WIhN7AT0(Rgj`gh%2U^O6D|eI4`P5v+42RsRf3FX%#WEg1Q-p zQJSGan=(iElv~z^_kV5-Ig^o2GNqwlSdZOMuB<#dB`nkkCWVSR4KrB}Vp)DKht#}n zpe-LxZiV)$;^>Cl^RiP@s@8GvOTdE$x+)%N#apF*f0PybF!SM_Kj`F(g=de-bE1@} zcFFks!&VIK%n^kScyccz9XsOmMf z$UGp_kz>i2%{yhqXs&L4K4`Zw4^u3my5^&KIkcS`5@yvWoH&EpkcChp{iOI#p=5f$ zWA6;fc|E7L&qQuYWU1mgAF3kKsp zq$;Ps#u4D&^@>t+`}qCzyM7<#c5Z0$_D4%g2jmgeU9CGc6h^{jSPmMHvLwux#As1K zi@U=n(p9dNHhc-(qAMRP-3e+BLhx{TP5jAT5WSJONROo4hc#=nmaV-++bR>%+gNik zG+OthiCqjh{4_rB(6RpSjl=xdW+}nkrem!LdT;hd)D^k+0UOF;(6* z%V)j>4yAZN8#($k4sqFTtR}0oa`Noh3IH&WoKP+WT<({jU?NAmmtMLPkN_3}TlTFW z%H7^p1)%c5$#xl*u`!5|y@;>~nL()j^7CcLvGi|}r0C5B`5rV-j~Qi%DCx&}1fm)> z@9ePM&s#~YER__3AX$U(Nq&m~qv*Z!nz1Qo`}pFyF%9fHbPE!!MO^VsVRXLrOl8O+ zPLU}B!G4{PybY+!VPOcRX{n_tbS0-ZvQ9PY| z>!Fmm?S{1TT=BCY{my=0T*iF4>#4!A^U}|Eijk2s4}t;tJuJyX;m1xM5HX7|!&{O+ zLY6g*Mdc+3g55-5k2>=CCCi4?%AUWjxe$EuC`#fg#t{G{lr8F}=?z-*-jd{+Ea|gTooXJn^t>16DI+|W*3tYwX;CyvVFi*z&15=@OaMG!-}yJAq6}Se zM#gAM5f5Dm6HjOUU=yoR55Fk$`RHn5{j)<{HB!;t#scB*(p#EjWg_d(cFenLrT4*J zBKu5|$z3*Is4>r~!}7-+iPKxl@J+cfy13aUydSSAJZMCw#?6 z!6tTxPyhLy9`@^@94SXMpL#OYr66eRTnG{05wMM&iyZIgZzQO$(w3=ZXk27}J_tz| z?1FQrRY_QHxw1@*u0?L5zQ=#z*!vA1N*rn*(pdd&UPP`Rq+yN{DkOzi7P#gc^NyXSqm`ExLb0EwAtH43h+d31NnRq89zr+K`mDWRPMf))$Y*L z(b5mR&3iN0F{eHOxukDYhmnuTS$h{`Ud?XlcpXjqs?g@*$VrUwrNX7gV&{Trs~C6o zw`z)9_sfR5dei)E;6OSS-DSPZ3>d+kA_fP6wf2WYC|cedD(^Y89ZischI`e^zG0i?vJ89sMrY+YS+YE^{ZpAvjn26BBcN`u`5)h6XnmZN;# zI+jPHLl%PDhtkyR#K%qO>EFMSf32-N$)03$^k+e$>Lt4-$}Zw<8S@;w@lGs6QFjkE zg(}BOWBLq@!SL0}e^{Hs;zd6jm46%2d(fRfGW2QcA>rmOTeg@pABG^Q!=z?!LPx1R zE=a6McCY;QU9b2erK*>KHRw22+HA?shmQ~fcFJQza21*jGO$h7Mt`t)8Q|o0sEO3x zKIZ?=+Nm4S>&^J#MOU6$XH|uy3aHED{2{Pt?1~--m^%@n(2Kj?!J4X)y~KPpTrF5ow#1vnhaxsG(e1eq2M zD#f&tK=PNNar%_Yfq%76Q}WqX&5LLP)tE=9o@sYtV&p+3=3Ew0-Lu=XL)##aIo6tn z!y-OvML5;>pX!d*9Og0(;XBb_@1RLrh%sFB(CJc_^ewvzjb&%2xab1M8f)VZnKCwt zT{&g>5L;OlYx+?r6fNrQ#@uMTlbQmPED96>9y0G-)52C{^+w-USdd6)F4Rh%!FP z-gS~a=2|CT9YwKSaWT#tBXETs$A~Ut2MR&F3e=tQmM}X#4)5KZe_s7Tm&Z+Wxv^_|z`goJ39hh^y=Cv8)9?s`Le8rD z3*hvXaGL+B0AWEx9=F*#^HXxbBgi)7%ZtVg5ucnaeAzCs!MUl7bdY5zzFJfaAs-R$ zdIH*vM8-eeYh^sQXum3YS>^Z;%U}Jo%p$NXPFsdy_TjCH&*Ex4jhxYC6&!F%@_t^{WGX zUcLJZ`aIykc*{8pAY@^T=14)`%ng)=&iOR9932-pybO3!i^5C)<^#lAEnSSELzf$vDG|8f%TL!@{iRFNCqMm)0cE;>$M>gki5cI6; z-_TM_jEA{7zyb~QjQz3N@~gUu{vf2cM-cv-fCVx|7~1H9FczM)Pu1BE;5XNu zj`9YaJBQ2z;5`!=8>yb5N}MS9x^6HkKZ_f_D?CW7AhxyO!`{j znMvP@O8(wo?YvK(*=h6kZKG8JGlHOiX`k$L^*k$eD)Vl-IT1ejTp`x9Af((TWfeZ7 z1BsKdrBo@BKP!pgjTQe3b;I_`Ho;?Cl>iGZo>UCt#ixRZ2d=e(5nIjp9x`Tsei{9dTcBNHb zPoe(Yo6v4tu4OWib2}k!^D+7(yfWc{TJinj%cU)E)pH|OI`qbx?2#AL(=r@tm7;)S z6&*cTctNlFr8C4K+w5bZ3c?{gI+dT*vFqvvA8sU|W4ZM4!36!t&zNmvQYto`SpIZ*NG#_gvYT5lM^_)&EVa=)3V5)H#?WG8K>%V}bWK&FVG-IeDZw2|6y~UAKc)0nYfResA!X zBzV&(i{ux`RxXp7COjcVhZI3_tt!V_QMKYZ+9`7za-rUAx$3$nlN#0)PY|jX6Ztn}9zRdq zf4Cs`C#7OT(0l{Dlg30eu6a^LsH>31OE37F1|+#C-C9a%l8S5oQ4!Lg%~F=7vG?Vv zmdVLx7ughRly8w>NW-^Vu987%1OIye@|5!)C^Enb#dV^Sh-oR78O8o`PPlV9vfoVa zfau)TD0cqv+N%L%nE3_Dn!3)r)XXQC(m{=aX73IegO+w1yAaB7BwILeZ9rU*DX!m| zY-Mp=OhSRxm4;B;L0wqtCo&K@DGnz$2IbX_y28H)b~r70zzI0jo#3lcXJTP4QUM2OX33T@Jy=E3Apa*H<<>X z=!}m{;V$q^KAbr@Fb`Z=<8Rahf2o}mTx~2J(9ys?CnSaMJ0l(PgF5Yadn532Z9QlC ztWCcSJxS%A90j*yqk1?Dp-$g`WYgI-AKXohnWOSy3d?ilWB;ur03YrSMT)jYHyAPp zJ?W(F%2mPPmTue!euRcxCMdA0H82QsD!fHU3UgdkyCu20?HNCUTOvqiBipFC^kT z>3-R9iY$6iA0Hu_lPEjGoIp)HJx>gFaaGsE!uyq90@CJDNZH#)TDup4RXkgfh(vW_ z6pbVo21U5q3gKV{Rwk}JUM;`Up>G!Xp@b}HT{obRkQ<@C&_vk|U11Uj?o25TGix6~ zO~Oclr~!Mzas1Oh7ew23TNj;Qv(Lvh7aE>_7+0cb`utIM`JeW_JD7d^&>_fr#nP~( zqpfpF!R*_5L5P1a1=ne>EkFl^P`bf-n`8bAAJw&;7JO zhHRh!IC;*bTF$@eh*V;NIR$TTKWD|5dnVYfriUAo(D!7Nb?xH*uaG`80m+&`b6+II z#jRA}Ky!E#+%{Sx`}}>-yF#F@ARScz&mGCVYN_4QcUnx1%oOn10iyI6Bgx-5B7;V( zVs)kg5+BkouE<8w^vIypo=R(j&FS|5t)6VITgpuT8{d9ceEn*xh-@BdCfDbF%ggka zi^!yI?e%e3zTd*&U_1`)$Go+TYtxm|T(%}I7{n=bKgCEUur%5Px#Y&Gm$Xy|_!_gT zknPCG5TpGfNpMpx+4z{DUc_YXCmsG2d&+Rc^zTl*$s+c@-b{ zlTTddl%)R!wxdYnF~{GA(|@1GS(@4WNWU@If7aa{FFBwOKU+(jmt zgZL448+Y%R%psQ#f*B96uklpID7=+}gdwHkzSrxdjaF<+7K$?09?gpMbS>>ykTO z#TUt0LBJv@V~QRo@o6A3V`}U>eOX<_7me{ixhGOmZFB3tov$>=K3hV9w#mSwnzr@@ zT?fa5ygtbIZBC zqd2S_v<3(03jnB8-uU5kYJ8{QW*oKr%q^?;wQKeR1U%IYnG%Zw@p8FdIauN2c@nXk zU}1~;qf4ECo28K)hh#haCJ-zA$6a#@yY@%!U#}zXvn8dd&()1|i+H2*4lh9r5>UQ_ zmQ{*Pe6BYV9ZX3&2g{SeM_cP}>OK>alK8`7HONT1h6)hKg5tY_O%f=vy7K{HZvGec z4RXfoHFd^iKSA2l>a9pIsqLV~#czX5k%cc~u^#d_7kIxy&Y;gWY6kuKQ1x?ZwBEL^ zemcY~bRIXlsGwbe5sqz10Vw@(mzv@jh8Wo11P+d@(-R$0|Gj(4Kp#MZzY1r7-vr<3 z3Zj6#i4Jxy$o^B^gkb^O1;edn&ca-hcMSFDO_#ULrj3G2ul0z!&?0E8WdTh;tH$S` zG>i^YQkcSYx4rL-(U&Iw?k^Y_I9g^gDo`EX7MLIcL%zooL-zDRc$#H7eM&Bg#HI?N zb~RY!+kcf!0%)3cK);oB*8@UC4)g{%vwiqdXTZAja_5Z^ULlYoIw^XvG4t9}K_ z`pFA=$u^{HUvDG@ls_{C-j2xE%W#XQmW`(d8AS1(jCO)5@y&X%u-*q-No=O=mLU?F zT&tF-deoxgCzAL>tZyASvJ}jkFhO2mPiQ!3Q@DkxZjT()&a=Q*^wfqDOkoSOfpA7#V*mhhb4j zX$6)Y<;DyH9{GB7te#MB$C_a2llSrq#!)3BY^u1guDOd|GIRq4GhGt-GOgZ>((Dem zU$pbF+oT&d_uUj0b*?Vtt!SQA-t;C!A5KV%3Hu4U zel24jG|FvOO2|+*%lNSq0$}jo84zS$#Rp1Y^QE{V$9axfK)RcxSWtOoAe)%;2*N-> z7D#g#hq=}>1@pEU=qUASm0Q-LFuggU$lCkwjbK3PZpC>7cV}}BM11*zM`AP8I%)Qa z-RP}#-&ZQ}pe{Hk^LOZi_rWf>MP~;G|OYB8gH(K{sW$t&m`0@Uq z{dsdY813e_S@|L&F{!n~52=S9AFvp{Fn!K_>GIr)P(=fx0U7n-%{u*t_vdxju4zG_ zWw%XI2KGQ0Q(G6?SD8%W1Qec-(w#8NnilMcLP5o}eX*9AMf+nVW^ zV%T2>gQXysT}&gZmaNisIiF`~3x!~SFhJw?bP>NF^{4wYdROQ1^UYCR2}NlmMPdi{ zcMm~B)ymr14#UU$8N}*}?*R91v35jnP-s8{v?7?ew6t-~!Y-KplL+Ro> z-%LVEpFTZl&I7k1TIY1?n&)_#;x6%@NSfeM6LkAewLD!2l8HhQRy7Nd;eA?9<+8V# zH9j)tA_`jKWxFlX_Z=(4ObtJME!CR?ybyWH4IcOQ zas`+)We7RFUb;lzYj)Y7Ia}GG*nWUa;p!x6dJ2*mNwmPOHxQQ!8(v=MtPp*!vOD7~ zUnzxrgR!95*9X}b3d5Ygre9AKP6G2AvLS1dj}9fA;IswWA)gdiGKQyoirQP{L)v*D zq9g{#+%|Qq-&|bFX3Aqt`{jJ+l`U>HY|pbgiYPo*uW-KQzp=&bT&`Ze&wc^SUujP7 z;8GTV18Bl-wVZ=bzlV|RJw@{uKMn2>jt3D8WXdBnJDSAjv4~Me%3=_-t!uO|4q3_I zX<+-OYT+UiLArp_MOiU97G~rS0vS(SC_t7;TeOB+z1ON00Dekgaar-- zQ+pD(@@^a30o+q?A{xtA6%m)w90YN!$Gb0ii164G7}xVmk^*~4C+QkIhXVJM*Azq7 z12~s~&o!aMWdkkIcn_QcI|R~joZ5Du*o$*-j?5${V=e`uF@G9ub)3KbF=UOw>Te)=8K-=IFPe6fDy1s|_$i36Nlg?NW%a1drP9M(O zWqxd9IoNDtu?@^23^i4|dya$%Yq7V>cmowLk5g!=+xShe%#s#_+2n8B&72!&PHbsQ zHYUeWzN||Leji~VMuI0z3Dn97?cUiS(c$dm7ZU!;6>q9K?l0YL4-2r{K z(+QPLClEe>mKfopcS7YE&xf{Ht>Jz{c%*^p_%Rxa5${7d4UMM~3aq26u+urg-xCl% zZq%c^&=A|2t)6{wdWjL-J(4Zz)s$Zo-f}&g@^k{<-mYUN=d<-73dlkOvVnXuP@kJd zwSu3|Ezth7LJ=bW3`5~BVV+R9R7)w`mRLF4vEJ=9lVY(;YSyPS5^B_+{;(@v=3n$Y zq=gx@)VGgj@)kh<=Iu5Y7F&a*QFHMl1z*(WEKFtC6vxaq|G1cyfT$FQ4iChbU443s z+(t`HLZSmTa^U~~2CPAvVov~HbC@$jRI@t$A7d&R2%FT-^A2O^454E$rN0)U*~GT> z@uYHu2D!n12OV(PTk`ue>?ebgJJ!*)1YVddp}`<4TCsw?x3kgko~)hIUx00S!rug$ zq9F3!kn&=SyKnP5ja-U%jKy2GT?ufmn$iZ7`l^P(L4PGVn`kd-W`kh#s)qD+$o3WU zI!$rv3ccF*pX)Xt51ZgfeO{A+M$Vy2QYVmp;QrVp7bKmjreKe_zGGLh9L&b=gy%o> zF00Yfg9&B>a|@-pnL1JOv@1U5lE1>J%QubvL}f-D4Ex-mH?Q-|zK?4Eqbu7ZW?@k{wvXD^*)SQoXoen-_HiOgmBaz*yhW7L7~hWP_SNGYrA+& z*^J-Az@rOx;v$6ujJL0e*}0uA`ady8{)A@mJ@rU0S6rdMWNgB?W|?@e7L|4Gb&t2$ zAL-mTBK`gLj()FNkXAllpbaR~3#PQQ|vDl}$cJRAnD7b;xt$vAcVWZUVz zk@Sa*Pq7(f-beVq+Lt?xRoFyCAGUAK;LC89s!)jN|skO{&i=&XkyCKC+%4)Z0Y3`+P| z2h$h8MjNY98K5j6!jXF|+hu1fa(8tiu%Rv2D(JwSQ`Fvs@LdLg_j}H@4RKM5-9}pi zlJeX_ET83$==){Wr{r=wHMEF!jlgUifY&b$>z0hYsQ>fh84qmdTa82Q2UA?EfY^^P zA&=w|Lce9krNFej{#c`rTODdXtwVbsMl?mh>%Sd;#wM09+^ zW!6URsY4!|=f*C9QoO_GP{Xp#llbzrXlQ60t6v>Sj|UlGZL{vrw39QnVD{PM zjYCexw8x3-X(YkY0zWX%F78{!JvlEsO=gx@@?(F1!vMQEerB{4!5S%?XhuycZ7$Y- zAFu#9pz&m8789U|&$u`k{iEz|wY}F%rolL2aA^On7BP2yu#M*<2I7f{EmXIYUiH>Z@Hnk0)9$=Dw3E&=Fqw9r6 zXhwk(F`n<`y4@5jY6KSISNAHk9YC5rVq|6jdG)g&-!Iv913y5Pl13B0kmXX>3v=Ssr4U5Ay^z**og?o8 zEY2>+>2lPktb_yp*}C~{>GsT|jBN#UVB(4T_19hEfbv8jBkPe2=O-&$-NxAH7+$L5 zN_7v97v}&grV@pgn^B|QIbHmqOcri>#W$$Lth5^!#5CfD>4#VWdC_^N2Lk%gk)l}Z zYi&#->Qr_)|6&BXF$h$eJAGF~XFa%GBxOCc9HjZ&wM98kAEbfFr{NBR@fv1~K~dq5 z%E0WyfiF^Tr>F+m?znTa{05A%`}s54XCj6yfS*(Ey!1A_N3~y%Pc@*sceE_4d+Kc8 zTS_DW_MKt=o~J8Mx5!etp?6MX4X)jiqoADpsb?d#&v$DXAW;d8s}Gv9_$IeOd1po!{lZ$u9l($NFE!6dV-4 zr64?-;f19@=*4lC$T$kbQY%nBMR*$mVaV<`Wi51r+W+g2>*E8*gi z@;HW^WMWW{@ps3ItA5RwYhkF{1U<8WGpE-pd~!_gqOByn3NlhRiEJHl@}>-7`>^|< zD38;FvQMEDSkIAnlXcWozn*noZ!?7{iQi}0AEoefeK{(ujqMRw_U(cbo4IKAWdBR~ zg!dD#q%B!G`#{Av?o5pu?Ltq4l)JC27-6FrR#FFu9>;Nf*!T4)`05;oW%DDrq7hbp(GR3uJ!PzB(iJ9#Y2KL)Bo5*&~3`THp*K=e?nyZHnEJrqXl zo1d+D$J|9wyQx97a3JPs#j6qZFhH~yB#;+pHC!>h0woju5|#9iqXk~b#djfR^5Nr!lUd-#uH`mh1)9KU7`RSsy6BgB_HECzM zAdUIQv5b5gHXdFpPbZjMtyp&b2Ad`R-v4QkIejyUAY?`SEJx8y8wHwa-jqhj?{8>< zS~%w=vzD|YRo=ZMnv&aRn)V}!0YV<_9{ac^sm!~#ju1nGfX8#+RgJX$GKEsa!h0e=rqp4$z zy11H27gqn(OBl2{=dw8tX}ihUN?*&!M@&*xAe$RTElrs(uqPJYlC1_;zVs1BtZh2Y zT5edw$`5(aG^gua5R$8|g0Ve_iZMmqbNx+kPi_UMm*vFDW6nAA51oZCcqLmR{4%$z zY(oDW9eTL%;LsY19c{!aSdi8xTxK3?xJVyGAZhBdklf}$7Jq;yF5KES#O$d5tEl*3 z^c=j@wI5tDxxAK8C93NlD2{J={vFMoI)Klgs7Xizy0#1Bzw?5or-srTYnKYD9v^x% zdQjP)LOJw3s?X_y*IPPOW7IU4?v7s{LY;aMTw+>!kb(G(C<$CzzyTE|bxDaUsAwk@ zZz=N7>U^9&=Ff#IR0C?IK@XL}{l|H`VUPA7fltA7Jy65E9lz@>D{fNq2bdd3z^>ct zN+~eL3E9%cYx7Nn86-S;i)IY`o8aV`tm(&!Zb`8-QY=^1W0`ur>8BMX)*s}w3)dF@ zkCL$CoLje0_Fw^oIxpqX@Io=kpbQINyVkkZ{kUn*9{l2wBD8o z5;XLTgH#cE>GzyV)g-9k`nsO@@_bt=YR&hSq=*@DqS%%iV#*c1rp*}z$U=N9AT`EB zjOPue&751jS3G#X{;U8x-(NX3qN2D@V9U>D_;`F(99v!KpbYZou~~Q6m3*^D!TP!y zt~ZeFk^w2S4@Kl7`F=2IF+xGKy~ZIbPL<1Qfs@rM=&UKvLpXjr-i_CoqXq8tzH@&1 zViFf>KifEMm^ zByA!F7HGDqltI+t9O}yOs^66rD1OeuMv1a*9Qsh@K>x`W1+LFBNBrxEz=`cyhUKmr2p$V@tFVs1~fsMqHh2_UKu!! z9oeqhjo1$6D>R_xQm!E;etYPWoJ@863AUaAH`zK+B|XnEJq{|vGhYNH_eQ_DOFLm2 z9}-w(nY#)*rJ+vjur9as&{f8msD}?W&_lRX8=X0;iVqy@q&Ig0zJd+Y#j>RiTW2*e zHl>tH62P=-x(A^5D|N2-5x$~|C@vKgf_$dXtMW>nw7Se)qLzJwi-BVi=}v$z?J)WD zr4u1LrZ@8@T4kSxu7Uy#Ylj5euRpzrP6XRJ{jC}AK;%v%6pVMKMx;5m4(!bgEr8Pd z#P>rq_4~<8W@?Lb$ep^f^7xA{TX^uLH`y$QjWnxV!DZ_f#ep{#^TOF_*_{>3gu0yC z5VW@Jb@j3_vZocM_gJTDM_Li*Nde2)R6RV-tD{I-%Lj3(zqaxWv^JvDJrLb1<>Bm$ zlUUuqkVJU50@_F7qNJB6Mq(BDhBb|&!GYSv`p#!GJyu2=sH_c*?9~gTqH)d5fVR1_ z;woZ|Y^qg^@KS*&K->5;SQb6hLY%+fs>#>aaBJmkQosh;Bgqxbu4=PRvvZfCW15&K zty`th%rqDp@jYS*TnjAA0@$P;D?F?3jC;QLcd$daeteN85=0F47K){#?R2+0){uvB zgCb@3>FpGM;{&gI4(!(`dx$(>7vLwNSlwbf8@@dgCAN{HJ77ZhyILrY+12inPg_R< ze78g|7wx;m)~xT8ULPzK^@`??(2H&ZyP%|u3i>stM(iH5;K?&O;n1=q?D4({_hUDr@V{gg2a%1cipc&LLiafxh<1r!`7T zL1X;>3NY0BoVJFWg+VZJ2`F5?gmkLZT(5}bg2k|H2Cj9B^y#sSXEcF>3E7ze7p{Z0 zK3lh;fRXcpSYJKtG#Ck!krYT$@b2OZdhCI`FceB)GV`9yel6Z1|CYvBn^D&e(Fwto z?1A=7R~y4Dq@x`qYo$1UvnIORhd7R(1O)}#xmbE(EVlNL^XqmtE)POQa>^#I?jcOz zZoGxZwxqz|XgbzigFouNe8b*kfBo=7f_MG_aR^ftD5osK?p5@pZWe;2Hsem-!p-}5 zY93S9Ya?$&+>A<2_~e)tk>KhD zWct4JUz(icTbsS&E@HoMyC1F?*u=a+>ew#P7c$0+!SnV|?IGpFP%#WXMD}wtFOYHR z%B2)C5pDD-7AK41K*7^;l#EWu-3OcgmkAoECq?$7xb%+Mqo$0Y`~#GJPYrFTmw7 z(@`wkgv|yQ^q z6mH)=kkRL1>jztgN-K7ep8Re1n7EzW+Kp_*!Ee+uSS&oqa4-{b8XXmWL(=~(u3Vw| zk>?YK+E+ln`BKRrCGQ;`o`RS0Sl|q5sJElk9^h)f7{}5)XT&8#x)phn7dj=I3$(=N z=zHrj1}oI>jt>{-$$&GV=OC>VXSsUl=3CP*8N-EO;eEqxT>U+Fb^K3qnCtprmC<3Z zS9*HnZ&!af+-|lW&7XxDh$Z-367_FS;hw zC|>P!I<}WkHG<~jv%aYWu{VRWZSH;3fau!Yl6&v;E$BUE)WS+Kxu6eVi}LCMS&~~@ zb^y_%UC%jpy~L(_o7^qF#fXwG z2OT;v5@L7G8njti@Xyi%rY51JE^JAVWR@4tLC&(bK8_NU<4urvH2_7^eiqKD0N&WPDrN^MORQ=VTE95MBJ)$Y%r(`Z~bn%#CP|jqV)= zH(Y5cN=Q=+N(tRid<~d4`0k?~nf(tfA;Jd(volwvsHnXT_RRe5cEpckISGLJaAydK z(%HrXL^;Z4hZP(=T^HRwF;JD<;j^iS4+Kn4&-uL+<1HhZD@>j+V(24d2<;&Nmyl|3 ziadXr6+>)Y-&Z+;vxky4l*A>0BVo6&a@1p&m)5e?OP7txhP-1}y;~vz$PWB(CudUg zbhC!t&r|=@f&5PCfEUkX+8QRq*~~S6l9{Tw1&dY1Bl{LQm@y>IB(NO-S)l$q>D)iM zJvYa_)kiDl1NZy}VMs(0?P{Lpg-+8M@kw3K*~!BQ`uOSH%HQcmzmbfYr!u0OMr1mJ z5XahsH)*LoSBa^*edu^8W;yTVQG)U>0YTGjq)_*W1aL(ZXT?pDC13auV90SM-}BU< z@k2d%1}l(U@3n1hLXi%9iv@NEney_sxyU6^Dk%dr*dY&vSl`ddBU9yu{E<9rM*QLH z?X>H=WF^A7fGWyhmCPtY9_0`$YrdMARVsESqBrS4w$@XlpP&YM0U-9O$_Y}(N8_1Y zHt5Gw0m?`!Y$|iNkO8IRhLuGsUAf9|lg@2uA|T4r`^7XnGqrec^biYeJp;$$lRD7? zdUr}Vcaf!G7NGSQ%y3&tuCG|w@8|jIiE%;c_O@Vw7WiqmG5V?@NMf65aPG%*y@Cm0 zQ$Fw)90ff+JvJc0+zcE(2KMThb?1UlPk256XF!<0le+qf;2i3GLa~Qo52)W>Vk?e{ zDv8Acr`R)~;(sYiN*8KEhS)RjsC^0HUn~uSvQY{1Jj|XM%ZS2x3?_|!aNyIoFo;mJ zmQk+ZSi0-?`Tb|kk&wGio0!8^D^L~f!vn#Mh9Yi~2^y9aSrEH4&I8-N2QRiA?;dQ? z&f*f`MufkR?~T5Zj2{Me*ZT0^5)noI>J0`NwvP~G`Qi1mn#dSL$(vS=(a}ab!!CX) zs$vMVt6qVuNP_~8^LJVZ@C?JInFa})V1}H&gs}fg8rHF|*$(T;0@M$PZb0>C?o;g>WuMGF%{^)_Z!C$I*T14xi}RIu7$C5xW4y zEtw!Pg7c*_QZ#!8%2PSXpe|) z?&IH)_88UUmPVT}PHlYZWp^`i17&25xC4T92vh3WQ@{HFyW|Q7-u@1HnXz z@fl)}*BUy|5_P~Z*z$g*GV(8Qjs;gYPqYOZ`r=c!rtrAF|af(W2oR;Eo;2v0)i~ScBOs+yA?mwGTyCc1to@7$2BZ0A1Gr# zL~P_u(V9)*tMR2t4V){V)|2f300rPdn&M9YOE$1nS&PX zBt)tTS< z&cGf$AHq0P8)CR66H7|&_kiO?CL5AFc+0*C^hauZl+b>b{xbq zR}^#f@zWetsyeYk-c->d@T=M}=;cbTt%H0QJoTZgv36}%?h@uK*Sc&n1%gXrxMPb4 zjePxu46r$THM?B7%Xbcg%zkjsIYTH?eL+k?XOabF-WGlYnrf1va=_^#gmnZ80NQAM z%W?dwUtK!&}D-s4k$IUAkJZz z_xS?3sw_W;rT=<%ay&J?m#ay}M*4W$?{Kl0PsYx#osDSd%r2T7k)e+ZOFJRuQN~gR z8V?~0%9e?IbvKV+sriuD!UiVMFzrO?(gQ!P0vt-N;G#~3L}yV?JfuA*;-N;|Kn!t; zzl(cB%1s_B`M$n)Ow+WGLp1}hcB*NibhgobNpkb<38VaaafbKMNyjM$iJy{l4U%5^ zd}S;&A?1N;-sAcT_DT0;xq_icwAt65uXvtAHqi!ES(pbB>=N^dA}dX zZE*pA3lpKtN?aE8H+WSIdL$|Q+MX`EnKWv)Lr(~nM4uBGPKn&M^)RTgy(cL>H{UU; z=xG9-3PHJw@%w6yX=q=<9=#Xvk%hzCQU@F~@o(U`&UGUu8I~9j&g=sV zzlo*2`YZ>o@P5jP(;F9%wBMzx#_%&H$BLYA$}oSv{y#F|zC-bf^95f}g_Dttf=N6P zvCB`>Rj#lBO}?&dls^i<)0NEgREbUKg7lB79GvELYS5r)r2ts<@v^Z=5C~_UtnV$v z9*p$F1$r!^xGL{wwY086J{9xf!9^CetxNQD5x1`BO6B7S9W7F{u=TBizbaP-Pxwaw!VuzZ7o-DL9&e;?IM-Tgxzi>i@ELl>3#9u`^An$Ne+ zE;+kN#H98mLC@jSs!87WHXTlRTqxtfTIG;72R{_UyREXtZH{I`1M6pwz|sJ3q)Bfq z@T)bpEOv@d{pQc-r~gYZ#~ScSz)i?V9hER|5!2NNioHMaicE3HaMv1j-aPS=*imKM zte;jqtLGso3$;NK2p!LZH|r<21tkh$Xzw?J6$ClS+I&>>vT97y`*P{lgq6vtaL3gH z@c;xtGtNoR2E;Lx`+gm6bJj1gDicT%Nv`~DMWNYB;ZuE|zIJk6(g6?SrI4`y0zZ; zHh_u9r`6u;QQ^7_(3XB=38)z@9YiBV#KBsz82Jrm(JUqctZ;GQj4}!bkAB4fv9WebHZuAnmJ$0H12NaU$#8Rw+oZpZl?!dJ& za`_Un-lIwHMm`tF`f{14tOz=kLv7OAn2=zE3O8KVEVP}aamurtfDo#f z(?*)D1WywLS{!o*qCfy}8+SJo$k^?>a4qqy%tbl{LR3R=fXaN=^jb%OFXP+J@p!E+ z3Lzi#f(%;j^CTne-Iqa z6ax_t!|1mf>V~#dAC-(EdXN%B)<#L)h~`BNVnKe9bzlq45@rP#U`Vvv;IxA1RRHqQ zG~kbAuknzApZw~r>eTz&iTVA0|(6HPW7v{ed+-P&@o&)?|+u?2*m@d%Ncbu8qx zs&u0S5|wz~_^U8fNR7~7Y^tTH$KaIP>s8+Rn#(NgV!1fgZm1Ky;PWwCqng$(`wd#0 z#gnxxpl`D#JK;o##EQ1);C(gM>pwR%v~8ud|w zI*vQCuyur1Z<$Nb@mHyhql;+$zs-i&yt16-x|TVidW& zovDzJA)!QgWxI~#YcBW(lE%Ar$XhE;AQAxQC!!E~h>$;ZAcJoe^sFf<#K%DjB$M1! z1;NbCQ8&O1Q@ym*Rg61Sm7_g`D-0@p?iZUH6@Id_u}|66w#$w6tvABPY&=B*V7NxN ziFIDj zujqHKmt9eM#)8;v2QppqfNeh8PQ#krX$$}&Rcmdswp?{9q6B;SJSSfVAqtIu@4x>+ zCu)KsghU|`Ft#a~lmrI@R%(|icoeQ!`&|kv5nNZ7WHr5?>#`0@+*I$;@ntth@l5@X z2PW+{Cl?_c>91137P{F}lr)1J9oV|}r~%o(S}3ZEP}t1fPnx8-bz=9#@;iFchWBT_ zfwq%IVmN3?%>7TVb(7QEx>M>+!BW`Jo0O6k@9VuAIrJkxoA_ zp1ek;tL^DpbV>w@yokF595)y(ZJ0_}p$M^Z2#8@ZW4=R`tz8DJ>X2b{IR$`BOv5t2 z=eObW>9-ZA_jLqMegYV+?|}S+n{imnjRo8auive4C<%$KwX(oNQa7K0vlp*tvzJ2T@O4lKdzr!CMH+eJcxq?U_O;K+E zoK&8kFG2IXf;P-0j^|Jg-A}*viv6VN*`{Y@F_i)Y$H*6dpob*8f3%exIJ)?TW`h8q zEx{pnvfSJhQ7he6RN_6Y?6HAv)wS8P6v;Yd?aj0aDd;?nm5horpoByr5*cUBR+ZS8 zFNC7()I?Yei9;H(cN_K&(sb;{ZT_7vHdXij)j{AvOFZoa5z%$$nS8FD{3%QPHnysd z6QO+vEaHa4XK}EfFVO!*SZ^DqwRq!Ag%!O^ygBs0Fa$Y8*a62h3~A<#Lhgw~c^2cP zhL^me5g9`U&`Sbyy0R;zrsTDwQUKl^n-?OhVGZ1=I3Sf2$2P+*ljWHNz8DK;fsB`3 zmwzD|l+~sRiZKxpiuTl2JIVodD%Oq?#<3d)VbcyLr*z*bdeo#1F~z$T#m$(H)8a52 zZ4m;;)Y(CB)(}Rkf?dh@9h^nu76U$ScEvqV7aq=GH_PjXL0+IuwCOgIjDRE=y|Cdi)(98(v!3Yk|0didb(a>rV0n=>2_76+syNei%C z4z)*_?Rrw#UQ3?KsWX%yZ)5z(&+N~yo>2+d=;E)v&hm`OS3yxKaHg`~eh{lvj+n~;O!^yH@iwYjBOR{k&VsopnM z3D%TH^6kt2%i}BRqYlLHTSSRZkVHr925rxgEKdxL^3&vMW{vE87e?dJsa~TX=Rl)f zeFLwWk#b=}8mE+D{visKg{laO5g|y3aNC|6>o<%Qm&gNQgK8E_t+vn6n? zgLK2l34d%z!%46-wDn+-EnmtjUF5Qhr-ksztT(Hd@%7FxXPx&I2@lhAQUCyER(PHk z>qm+gWnEPqIEFT^oH#2bz6x&OOA}G`Q%VJ|FH@-7UiFU};;oCONpSbP=e%~a zc{>~(6eB?rkVGU9giX1)>}(w%)tVL{2J}UUPlo$Nv%t05#INL}>x?)oY@g(T1L|w7 z6ZtI`V^QfnXUR2RAA3hv0$Jo-F|$xvoO9KpE>4j3c-3o(4N}+@EP_H|nI=zHhEJK^ z+YaCqOvLK|Em0w2<|a0Wiw{rj?#EC8k$KXv7Htx2$iWg0Eo)7$3bVPz^%xzCAV*xC z@-~T@{GD(qE>K@ocl|X_2;(6dh+qHz|A8fEqOl05F%k%vA}l%VrUJE21-LAL1i1)Q z|3z{%JK*6Ot1n~WSme>xxH2D=$|P?Id@co}+WJ7jcJp!+-l%0Phg0blLUan3b%x9t z)(~5R8;3^=Z=nF)h3KdUQKc!4fbFM7B=XpxB z0X0DOa5Qg5+&8K^#yX`@|0HHsz7zmTg>1!vX>>x=e=tuI@{GSs z#AI|BH1Bv;0d`8&u4$Ioyb1HV2nfITq75m7`}UBV%M4p9CDII*qonLZpI)DmLBfcw z@_7ulU^!pk$9M zzv(v3svwk+NS&AWxTCd9dO4Zg+r&r&X$%5`f<^n}UswDtAcKCy>q(psI}d8c^O|3D zH0}nA%2JqMo3B=a^Uo?^7(XEzi2eWUKY=G}VTn-WLl=f!(RDrN#ukj*ewv zBS@$cFumT#f>jO*(|WfWym0Ol0$hMQ6%2jzBkV|&#koYP6>?{N1uk8Iz3l$Z^Q6+4 zOEvBHNS!QpGdkJFH?iIMci(<$dW1Ek>mq1@>o!{k(f;pN6@k@Tlhrt%ugTt)UyHKAqte0nvjYkAcQEAqPeIyMT}QVO=u(lTpa~P z%ERa2U0~S~9@6q0an<;WO7~RDC*3}J8r$V=-@s>F@KBDJ!ZeIi&$T9^)m(C<_P$T0 zog#BoayQCxRwt{t+9(=aDgXxqe*DGNUuRSKhp)cuPx3D}gK7v#p733)eYdW-8i5Vg z)U@uMwR^4AiDB;3o+3;7{oDY#5}{ zp#nbqLd=}vm@ffMy$x=034v7Vp#fP%!P-sohCXUJ^ zk4DT-O!6S&pkR_Uo>vPc2rabN=Jlek;;h){xCOl_%VR6Ms|IL9Ule?Nz!G1~g4&yh z6nC40;sU~f4~&(~;Fp@oAAdfBz;i2Rwviwc!8>Yd+VtXT;FSH|(l}aWmx1TVoCrfg z6nEZ2x^t^RknO~|Fi(JMUn;PQ7$@DR{9SkN>}$-0v(27rTlOIel)a)5BSHw!Bts${ zYSo@AU_p6p9S*a6DQ$r*G0T9EcQg^vh4l^X8R{Ox(Y=4&g1UBeHrx)DhKu&Zvm`H+ zsc}o3rjjTcMwGm+u67&l7c}O&C@7Pj;)EC+FbyQ2{i{`eqBml96 z)?z4Jb6xi2Gkn<@eH#b8l$Vo|2nL5G#H!I-F0DWr&k5QdGJ*@KMW9T#9&2Je(&{~JlT zCOB?6J8g@*`g4PC>pu0`3?jy2!s#z{RNo<2bgt-Vp8`2C13I&3hi&ed%%&=kBXu?Z z9sL!bxd}gl4*9F#0__O1>1Ezc)^Zv>wWB?~Of~{{o{JPZs%-WXyOrT;>Oy$azyd+h zEL0rIHZJ;5y)eVZA`z)CHXl#(1gnhNlkuemxKt(N zx(X>$zDY68H5XG1;hK^jYYw;VK^luU-9ZTP0Q3vJ<^?yVlAAd=8`7{2pWv zgtp;Si~a+AyPd|_=z|bYG!{AO;S045F|M^sTJ^E0Pum_pKhBxuIWS)24oD{D1~#Y| zl!_W0Y@ybMB999aK!sL|Ju-^gd+iJ2=^;yr+xb34Vge0ud%?5NX4>TSynXy@P!A$Z zxfHR%YrIN+vK)ssK<#^eyT+VNF$606-(8 zRdhVFY}eLBf$gMnr|3 zOUD|+Wacak@Q3_qWSBV@BAqtEC=fD5K8ES(f1V|$h4F*Pf zRD;KB3n^_P*0R78c4ff}`9dI8Q~0fwteAAwJ}*&$eo-(s5M z6$G{fw8BuOtDVd-zN7)f%Du+b=AQR!QvFv?&)obteW3DPw)k%N|dwWJSaLuoF2aN#+#(p-!M0a6PG89`ZsBvHyo{sET4lsq@yue1#5mnfwk8a z2g?pm7qCZUSJN-#c^;^u2d`Tsu=El)Uygj6cl+y-*kOukG|Mn1fmcQk}4!<}1~Fggnkjl=iNme>P)rq+&~04NgeSzZ{QZ%D}2E*`zQ5G8k< z=I=X_5$oZJzTwd=)xp`N`U^t54;))ZAqtK^zrOz=CuoEs1VsRt=W757b!)oSvrN?j z1Cq%Aof}!BMaB2_i>lxrM}N#0mTb()>W?T9b7@g^jKh}vrqi;R@=iDxF14sdy{|wN zWK`&v$XC19hpzL+Bn@w3Ad)(uWs<#;yWIyqyFg;BBPII!C;Rw#6OFKgVV<;K9;xH<_G6e&j7+b^2GHbZkqZ<=P#^#h z@Se9rJ>Kg>0|b1mFh9?sa~geAs}*xd0zx3jQ6*4q%UA=#n*tDB0hooy%np>q01gg? zF1Ebctlh~agUA46!C)gkaeICXWZt&xX~PB?8Z!W3T3ogTDji-XdbXDYRs7Bv1d3B7 z!lfnc7!n@4{*zZ=t8`uk;M?vzIV&dfejy5!rJ9VyLXGzf_hhVoU@DN6!foEHQj z6n>#VKRcT#)sN~J zj-a2{8|C<&TnKbz+6#(!*YW2$ zXStL2?lVLHz?ItQIlNJS!}Q-RCHFn1j;tMaVL3`#*Ox@YiO?md{bu?%$%|S?KQ%#X zz`HlHPLj3Uf-4n_XdZq&7$<8AQMtS>J^s6Pt%D3#<(R=s6)L89SaESX_aO?2|F8f3 z(JyI)A&9~f5TiukR`l?7uoZ0;Z4g1@1Cov7%&vY{qQO-Ew_(UUXRKpbq>V9p0@YTw zqeGc4Ry}#inME|ywd1lz)=8j?2_sqxngLnkLgeXdlvC}+9^HA$y8Ep#1a@PY zL?h+D?ccSMy&R)yi%SlU!a|scLLv~A2H;Uj0gWO-a4xFAj(>G`QlLeqV=7Y#V_Tac ztkcbB4fyXm`pRJ;k?OOF=%q8heC774?Mf*%&e;ODD{jO^W|_RTD3V-3(&c7_vEGj- z8?Oww%fkZv^}mGZf7oi@%lZMo572x{rduC?;6#MXk5pM5I%7wi4W(ev?!77qV_e3d zR(1Es%3qve%BKK?sZ9UR%MF(v2jtW0|9MG7Car94ce&9w@7Fl!s;cmexB`$yo2Y&v z3X4D6|Np@)WTm1>NFo}9gr!|hU;w&Y7r|+suj%2xwB_!qIKucGhLTBmUN3rIayQ5)$cQGn-JOX5 zCYK;KN!iy!se$yPZZQl@047`mM&!A=H9@DHc(mWJUfzT0p=>#w5nP%kXB1U@!zzBt z`K94*OZFAlh_5InIoz)xZqGIEM!V{uiy~;@#xr?S1JF1kVZs(BDD1OR3`j>8?aRXk z0UZt@V$4bnKmE4)4E9bjKcDUSgf+|xRl>{DHz6-8L0&&4UoFT9QGz>;bNy;PoU*u8skzFnLcb!JwoH{a2o zm9B=?ES<;up^lMuH?lNQ`cnZU>Nnmi+28q84>xPeFx98f+OssD<(E+|=uFUYvr-TT zAqtemij>7gkx)c5BG-AgM>Qd3(}*t4Fh#Zyul5o{Rqc_| z*R#7Y%OH(WKu?eywjk-05|COC3fR$-9AvX*C>i#jmHaG$qd^Y`$5AED+M_3E13GR)O+P>}e$Tda2~#*6@l z@+(|s?)?-{fja`o={sz_A@EV33FtI$r@9 zTeG7O57>E@h{Ng8P7~w;1&H^H+;zL#m6>I5)*5amuaivE!s{yo!67RgHWj#7t2nAt z&4@AKv?4Am$c3ip{LWnUxcfY$ku)W@+FvJy_N+s?rr1`)(VJYhCh{05@ld6%r0$!=&9(r^?1P>A1UlvIF(Oc7{;AycB|E&d{6 z&WC{_jKnlJnJb&#g;E+=yQ{Kj*Z`6&b4PJ=+dmF5HCIc#pdWk|Eu#9Z)nC+uH}PoI zOk4soH=b#t8HMs*fW$>&APQM-?xsfMjbsjTTq`V62}F@bE!#XC;t<4wp3Ror)r!jGzlyR2q`Q^Y^NfRbq+au z3iKO4TCutw%8Ux9_0N8b(*k>mrR;Qa8wm_!K?smSA{q#Ug9L+ zvkoUAiz)i8Ud>XhVA-N)_HDJWm+@*Nbu(4;BSXCF@~64SsRl=7!L;hM^{kBXN?qgy zu)^n-E~$HN>WsN|4RMXDi$ZsO^k*A+V>1cQF0n@7vH$X6eW%ampCS9M+RLb8KvcAf zk|GK%^UYdVt-%m9F9KH?S5rbTHZh~m$v3X;X}j6U4U7*81*y1Iu7y?JtMwrYl$D|m zi4i0i#os$9EDcqq*{O|T0n49Agc;S{C&Mf#%|~e4Iqz0zOiQ$BeEN@j%9x%*E;Ww) zrzV9aX~-Zj6OnqG7%*}0)k<*<9b5s#s$c5-bXqVqntz0$)F7_(i_4#p*S^btq~;6G z9v-@`u<|WSvfKG2PRz8EUKC?z!Q()q)Nw>^SIWn=V1%R865h18k;a5aLe!M`H3^?L z#7iQcL7?U*=J@+a+G&pH9=Sv-k1K=X}RScekVFL01{nA2vb>EPa;6NAHQz8T{2%8MM4#7 zfQ*aIXY&96DicA7%m08e#Q!B^;Ku`ab!BTj$TeLXxm#1HO2=f@sx8P|j?5f7fGL-w zA3jwkz5Wg79U~fCl=cZS<%kH85fy6>cCO$Bi*l!uxkp|O7t+7l{MU|@KhF&&Bop3YwLLx&KBo{2KRxd)KzF$3kqbu=JA z)4RO#$kSLatgHQlFx}44Vu6RW?~bf!k!)$5MsEc0S3F9;Ti~<4)Z>Nr0fZeDUnxQb z2uH{n2$4f&$kNwc$5lA4Ivi}6aiA&PAh@q&R9GTATcXQV^V9l!`5(J#f?B+Bx~2Dg zHbYmlKn%dbu&OQ@sRN1jH%aYwmW z4FJ1d@gWaYD7#Ylv*N>;v&=OYOID&I)t{X?-ZBRV0#fz{URvX84xL0eO;k+saW4`V zg|>6igR;A6a6w~BLWf#WE^CAiuutQ2cr#U=wT5AA6CnQK#rWWQ_&?8uTR@szZmk}P z0`dP-btcIc56S8<5iMt&c{mF|s1Qsu%Ty=F+G7 zt5Fiw;sMLAa*(oxt&FWCGGBqQGrL(+pydm&!;iC-+h2}@-^`p|m4Uu!CABXxfB(S_ zvVHDBN}Omb^_9t1QyD7ttKGDij_o&Wn0(}9|tcPJl^jGg^dZPexxE;g2{(j-`9Gb_1r z{n&ecT}apKOR4?y&e1gqFJzoJPm%NK?@mvlG$hQpJw?lEKq4XPfX%fN_5f>T@6Bw1 zXcS(Js`rA56QrH`#M}A0$Mkb&n_wZrUiVx8m?sg^Uufui!_aM$^D$HBOYDs^aINML zKe(*oQTRjaAe~Z?%Is0;rr!OytfIf$awVDkr!+iYb0-3q`g87*mVDa&*!Q7ld@%u_ zIvmRbjLN&HuWL>v!pR?(pTSyKp36M3hBu(9Nt-S}q=m&FEw8(4ZEotsB>FkJF4?LK zth4-cPxCOtf-3$&tpxMuPabQ@^x9$s8T=DBUtLLPLh6i7sx~NO|KKAd1 z;o>4T?+^loA_SFbBO`NcZFE~jJrlCV^gPL7IeFU<6X{iYI;m6rm2cXc+kU!h3YG{; z=T%VyzJ?K3rseqEFr%YycXVi?Y$qJJKuNvytmMVE2mvzGT0ev5eYi6;FEN$uEUYQAatjBD(4@%so|$3afl~q%DI%F zPnY&fHFcsZyR1EtjtmGgl9lwO=af^b&TW1Gq<{I)99GO;I>u7+fs7T0#;$P0t?*xb zd5hR0MU%Hv-QxjN&{TPi;2us0=#pQ4&|a;Rbhh%9Io`-j<`5xM5p=zWzRk2}C;}hw zp{KkDEsi3$Bi~PjCV>(vVQ3_2fvsi(o9bNxtvX#(bS- zgT13xc&1SO*s6qB_T!=X7EE|6O$|&Y}$Zi7>*xvkQORCM>u;AZVO}wQ1Zbh z5nU>pH(|yn3!gtZpS;!7tT8$GQlhmnLs*9(W7RaJ@LwpM4ci%wNW?EBC7b$65Vmir ziDSNrDnc=xPGvZFc{`mro3Zz4D|-nnFAMyFR~E@*(5#h}Inl&u3bZLXtc+Pbpt;Rh z^>UD$^_j<#X`P{BXm|YO2WDPnW={x3?WGXb?uYK5#}6XetYoY0I6l!z?T`(gipw>^dPo}38rPvBa{IGRYxT~^tIW$Knu(WzH_v?G0;gmKQIE*uc zgYitM$xfz=SKwZPBm>zQJ_Ui?GJT4Fy0|Ezj8fhe?dNJ5p41YRSLPsn^Bq)vJJZ|V z1^i1Ma=1k*NGUKtVg2ld-XQ}_z^whVM)57YCb_XfV+sTXF>O0pSojON7it@OcIb4N zE>mTy`Ng8fvc}UiM@Q^&_xWnMhEj04*IZ+vi{HU<~CRzlo#t1sqyIk4pz!g;}96Ac+I2aX%v5fE#FG%xp zU(`19Y8m&pj|g7vlky;EdIl#hSR(?&$xL*pm7{5qudZ7c@8dO>Oc`%EF#hoRN`i>L zO~DUxl7F0RzEM)Te@Vm_N2xHG3uVJ=TP;T{guh3#1lmdBOZwf?{DzrAT9kaN`yDnd zUEC-B$(A5)U^1bDXbDCj+UigWop_3RmUEr_nhrb`mR-7Niz*tci80sIg+z;Vj&C6^OjIHTA<&`So#n~YXajYP&yHGSP$TSyQ;1yKj2x+o7X z+B?|Esg5<@7WVq?guM#gjWv47oEf<8Mx0%W&cu}!n}%V7{ROb~rECSIZ8@Ef?O3uX zKCS9k#si3OHKqpu#x8iIEm}051+Gc@p45li5d{5=#Ujht4Lx~` z8SVy8&UF;<1bKYAje<5yZ0p4OGe{kXcI923a$1;I6GkeDi{c4tUb$SX?uEK912g~1 zb%wB%&stm$35kx#0BqH`ITACoL-IMqb`grGQHsT-PZ`CyJ19zc2hIJ;EE~6ZU`fa; zOKVjz<;tsz`)uZ{!`AZzUqbsxA1AY~>t{Tw3VmMBBh?PeXW2yu8nfN_YAiMJKImh= zWoiy(MX{q2&O|^$-0Q{6@5?2$ts9VR8wqNxL#08hbA__GQQSuM9b18&N4`QxMRr6b z;(C)<5EGhOmco)%ANJGQ`#&d+LP9<_j!iwC4Wsfc_DPR=H+=~|!bN6@M5lfb@M{7^ zv)Aqp)StI>Z4kut=&AJ@!wXpsWrH;^@A|`xvVOY3NmGq{A97bf5{1M15IYI0ZX2O| z1JLTNz8HHCb>jcmgEN@#4VK2bq3tHJGC2$W{Gv{4*bz-A^r0jaxinnUWE8)o;xYz4=>Y<7-5V>^bgFfe;D^$E`yxZjhSa#Ee* zr;IuEr~GU_yB)w4q4aX0Z-sZ9GaTkG97xL-Wiyy<$B36>^*vvh>Th}&h?I3U)MUR1 z>P`uE`Y*Yf>6ABTXgIN^8iFNY1krnP_+5{`{BIw}lXyUML2?IGi~10wEulVSZo6cc zat#HYyX<2H9XW{&UJ26IhJm;y!}hB#{&?Uz6WR5hv0$xSR2?bJdO3H|@v}&HrGvyTrxzPieh3Q?;Vra!ZDNl2CRy1W9Q@36MZ3@#({I6K)p4i3H z(WsQ3K7aZOb3eir>$?g(-&tPxNU=QAs>P_R9&yI>zsx#j*@bKxA;Z86B_f!{nt`3; zj5MgVg7pgq73q5C?Ll?d^r^=J2Kt2&TwD(MuVP0HHT@K+Kps&=>N;mcg*-F?G%(s} z_+G&$oRqT;`m~}FLJki}-N`UvjGWsQQvcLI;!ZuUpGM+!%QQogGFQdYxzH4&+vbBu6MAxO{*AII3@iI^q= zI)G7&VxYUha!Z9_Ikei4bp(n{`%7rUCKBEFoa_zv5%GIAc6?a=T}yO%enpb3v3-Yf ztvEi}zckp#Zec`i!J{DpLPF=vvc2Kw@sSQe1ZZ4~RKN1AlSDsGx7VrwC;CXRUEJ#H zFG(*Ar(=BC057cELcciLf|VcTZ_K>ZL4-f?-LlRF!k&Z-3+zl^`B&?m$5!I->b#Ff0!1p~qH8rz6(oV%asR zPu#yK+GyO6+~POFoDGGZzi$5MHlB=TPC3puQ+%QR(}E&~Qvw$-uaG@?b~N9I)s%5o z)$I=FpP2>*FKf7tuc~sncBxQhGMXZP>TIJ{F>L!ck^nW8KfAL)ebv|&OqV37iiHP; z)%@%IN|dsZzlkeGk6Xe`QVW?2Wckv%G^ChM%cv3U+`HktP(6g;B7-3d;6Gr4Pq8EE z+=uJ!sb;i<;*RK6nA3w)>^q}9dBe5=2}NM7IV=Q~xH6`I*R@b#E){P|Dk`QJcbB}1 zHxNrPP06<9?c^=&79puomoDYFbG={qC95#jS==!52rv2gwwSMfPezOo;JY0C8UEMx zmZOe+t1!nxS{B0nnF0twLE>!{Kj6BeNkoJlyQnAWKZPq)1cKj);r-2V9Oiz52qaF~ z-fM0++x;_Q+({z^|L8MjLJr%fr(@aTH_lpRbY`f&#?k~8SXh6nK2A}1jMXOq4nMTm zN4FsTPxW0%Uvnz4AeSCbLoL^+2z{X({y?vEtGYt^&0g>|&DiTI-m-YTc_~>GHDpqf zt9wnN|3_83m#0=$?CvQi;s+Zj^1Evf6E|(-JY-&S)IOPVT%BWq6@&j3eZpmcY!9uMr$Hp1D1PBrRPc0Sb8=IePim-gHu@!wTQG#@Koh z9ngpOj~2i76t`B5<_#H8DrpvQBgB44ZAW zX?=@Ck{EQvirIf{2XRkdB+`Wmt1LOO?D50wBQTPHUSc%ni=6@>J9$hmrBZW^t;Tg& z@oj~%-d^vM>VKol#Ok2TkIIIACGK0hqSE?GH3o(9?F-$G_Ok;%IDyJ)+G<^M5RILFz%q9ncAotgnU)(q0d(Bn z6JiHks+<*0XI-Q>aAJ#(l9tC6D?emBeZ~W44gC|hzb7C?qdM#1q%&v*Ao`53wP5nX zDgV_aFX)>GNWe;f%jJ(Gb7Knn(V^MgSw;!@2(~E_d0lSnwDH*~L=NM%Rc7+fO3c|I zGCg!%jFc6ym#;+aMccyk69P@h4yjr7>@DU9$QpV#rq5r2iB;3A7Q87siLt_oS2CLL z8dRMeIgLit%3IOqP^0E4nr8SrCOCgdc9Ib!`9ta@!v5q=121cRmu`ij?gEB34+_)@ zkhREJR^?g5Q#LC!(v4>8pbVF4%LJMkD)%^FuLuzsBT`9t$9@}yIXOOcEKd@qWircD zu(D>;TXLc8l(gSr$xdw|R7P3Ku7<-Q!1_HD53Bq_mG|Kin-0#UJ$aYq(+9z4gy*nBLv0{0SR0_Mo?DFqv5KxdbG(_z1@p z$;7JVk_~Q+wV!trM_;WK*zq6M=!Ma7BAH{dOHqMr;m`bl6bK^JWgOQhEnKf7olk>G{X*1gnKN& z;y9b(MQ!M~2jYYZD}Or7E%O8ZZv>VqUKS7!8y}2I(FTQ)`W)x&lwf1oEkPvEilP^b7p zc*nZlQsZ~ffsaIC%uAk#g8jJZ5!5dSGa6)|yHDv6p}bfxyh~j3u}w_O=aDs3h%6c6 zF<+#g*J(*lNzI!JkKZ9W8V#1b_}ACk>v3%Lo&tAwkCJPe4CIVD{_zYwU|QQ&!yU+8uQV)U%4}fnhNQ?o^2m?quDh74F zNu(C~fYvxs=_5)A8Q=HqVAS6gca1%DGJ9SKDZkn_4D>ur$v)_P9&;95#pWj)F71cS3bUbxB2$d*&HH zm*~C!{GAkfqyITic?4kKz&l-oy#CX$r$Mn~S!+AU9b39C#R%t~fyPFjjs*VsNkxg6 zSM7xIb824c>T>GHINlU?10SX0T->8!z5{+a%0d z|AV#!VGnIr87Mgop;b~{reh%(l3S#q%1Vy|KBJHt4(cEnLhHWqez`<=Pcf`!s{dS3p(ISGxF}ymDu0mMOZ_>*Xz=zXVR_=1II- zt#2VUd##BhRTr)8V1Xses{SYLuzVAb+aEis3rE?~ScE_crZ_Tt$I^L|O#)?Fj&rm! zA>?7sKf%XK%x(azH=+6||9<|2h8+N0aTgi};7P0FA4YArM2$oJ{};QGz~sy6#(3tv z7X}~(1jnWvO!2qYR=$qT%$Y(KL`El@p@|XT?g(?Vid?}Mx)kZQI1rG8maNTeS53*b zw#N&Kx5&xNjAi&w+KQvL%(cL@CFu~n9Zp4Nso@BSefkMCl{yskN+JRBJ4D?@q)W%P zBhX4`PEJ)Sb-`2nU{7~Igf+HFyYjnqy*E)Z$K`j}a@qIWE)|Rs)aH@_`yVQ68@{~} zQ}dEmjlnSdHTW};_!puvViVB6w?#_jubBNFtn(I?zo)ut{d7~*PsizWVJC_&gzkz2 z_p2=p+6o-`}3f7jiV);t`VbM64ny8KJiG)xhX~rGq@}Dq-Rz)@ygD1d~+FW zFmrA2-L>bm(%YKC>wb^Gi3Puy2iu#HRPfgSfPzaKeP#8WN|6+Bok(XQ90O!_J7>rkTgtjlq`j6_^fY>7+tGmX?=L4_q$&& z|B*k_7%WTMidQwK+uXPnpk0+j5J_htVuM_UsB|MFq|2c%fe4azJq-wQpKq9QgNVww z0MYm;eiU;N?OH=v78N{>tM+W^>R_yq&Xbxv*OS^>Sy_JqOLMrIlZOA@Ty>7CQ=E<* zjb>899(qI@61{79KwS-XNirb)(dFtVR`<2}l|F~d<C{jE>geHaM#Tk2Co3V__S^ga_jqX%pvI%YZfZiN6%4UDrbd zZu1IG{Hfy0^|Te$Wg>DhES+}Njy4aDvxf=MmQBjI7p%>m^0OFhq9;$if)JLu0!fHc za}v7ln@(ZSOT^l2?aE!F@8=g3OM9O!=VB z(?uG#EwNNYDUByiz^Qa&OsqIM7p{h{%YwFi*su>PH<|Sfvp(0BUSI(n;h}GS$6Nj` zVwy|cWBu#M-@0q3u9H7;i}hAad;AliyKdaJU}4fKNJ6Myq~|pLea4F$M?9++l=iF=#@4MQm;ri*S8C|R!4vo#wz`#kN$x9e zgVfqYBkiIX7*w)I5nj(L``=yrQAna493Pe5MIv+E2(Rh4d}cT_XdP{bDkY@$e33p9 zP)3)S-VZPJ0Y+NmtC{l7+l)$)Up!E33lx;(@u4rZ$s&W}|2IOBp&Y_OMy97fr%Y5>WsBZk?Z&kjn^jGFZSh&fbqsIHy#;!(s%gX<=^(brL~BKY`d`o zN)wv=hcXAE(R$0yV~9eTx$seCeF=^5b&-ufG=#9(-2DusU#k~rGT8wzE?fZ{);|T3 zCBMRFfAs&5-`J;?zXkIDJRimZ&igzmhxA_NT0?qJqN566-0kR5;Yp6o+8+X1x*)SS ziq8W+I(Puw~na2l0%^t{R+c6j{Ty*Wg~lfzP;ab zCja5b=0>UI5%XbU(p|QL;U_GZquTkCoG4qLN8cPgzJemiz1_P6YjdJ-u+`$IR8z`|K<+-m6Igq;u4GBXy<>x`g}qZJ-ol9bmDZQz&-+oH_idX_~l>n6s{arKW! zMUma?Qwqbcy@Cd}>qu*!SnP&o;>f%H0e*SE#@do&${}rp77ot_6#VBxrms(z=Je9Z zGt7`^_Mb+D=R75u<0b+>Wnx;fIcc9I=lkD{0F5^jTOsT-;Us$3;6(}w-G8PALQ*TK zrn>LFxZb>r_HQ>U{E2Ep8C>K7lq_vg#3fHAtp-tMG8!N5fo;FuR?ZK0nLq3c-E0{y zo&EtA-pZyuXGwiXe;%ai7*2X~OwM<3fEQBC^pXSTRjSs#nd(tf*Aw^3{+sD`Mt!Ac zXN-)gFEUuKpu)idVT&8$hn%V6z%px^IhPbfj_I`43l>U zC+7SN;S#kZmUB!4V%t2V_)?l9da45Ofx;e z16?eekv9m`_IqZgKfe+@M%;3jfud)GSHgnC2cL~7tr5K|D zEuGzi*|$J)dRdTp8&0(DCN}J0C@?&wkK_T90#3jcWN|iB)JJ*yCQI&@Vd{|TTK|S` zoS5Z|?k^1~VY_a>G?^vGBz=thGlK$!0i}Pj7(UDfQ={U|Jj}-6Gn*P8m&wZr{34P8 zQPjbHq6ea?)yB7Pu!jr3=8f$Q!4yfgz~luhXB;Ixy$#r%vyc3T^jZ!I*gvB@q&kQ9 z#d$`X(F7-?M9$J2qIe?#EUVc6=8-1%CX^UKz!Kqhur3LcZzr(l5_qO(@_3;>H%L3! z2Cg8^3qctOHeWZ+(baXE1FK~w7=~bZ5>?4zo{NZZ znUuddQIC+mzI4!{3k3hKJ6Z#^@xAd_rvUnCUT_gxY9GZwB4}bDfG-sWfBGhTieb}~ zG=UKEP;%;5)U@QbDM;6REv4d%z53SaW1YHT1f{mbMP+s0NTT6WrYMe%AtnlsHArS^ zl1g3ZqU4%X{WuL?*+n#&su%J5so84`hD&y}EJmg-Qn6{TjLhQGv`yDm^& zsr(J^!#b7af5;rwFZ+~1D(t>zyD-p7)Z0-B@U8xqzN-Vr`Uvy*iYJ!V|LA@Wn=S|NBw{vzmO~m>A~@W;@ODoM-1k+09Zd2ga~`Z* zVhMgvHAIj*7Wr;pRALe8Jf|!lt%RRCmK$XDDUNwjLU^Z;fmPiV+O{xL5kS4=#MY%T zcSEJMDD-IGbr%l7K|x3UNrfeyC-dTeL*PN{Ksm&Ow82pKD+Icg)U7Q^-}I^va(yMm*kMU)S_dfGCB*Lu6H~gz!E2 zTRUY7YVM*NwbWwZxSjc+xBiQG8ndLd$G+NwhifEa8LXIcO&BPQ@`r54i_OdMR){Ie zG$Q(b2-7S$ncH3bl7q>EXwT`DiEDIxzce_S8B~j3{8sqreNFp69V;4a{ihragWt8K zZ+b+>Ix*6vqYO9n2P?0R0c87=7L6r!W+tg#8xy+Li;Vye4P>a z%#A9BqTCSWM$ZXqfJ$oBmvKfS_6Q@&X%+b@ z436!s#Wyff8;g`UO*))s!x!M=IP`U9_dUdkpdGQ(4lDzaL0x6+*5ojugpIWz!DYTUYMuaC zd<**IShl}m=((RXVE*~G%Hbd;b}30o&;%yItPHp`P0)J>k&5rukv*xpaz&Zzk|a4X z6-|I3QXnooF3kAly^I1ZVDWdKtSsUDiqchET%r5XdTvASZEBbA9W&YirzlLEy(0oA)3sUfogTMNZ}cknUOQ+>u+2Uiv4hxMS>%`G@J#q8uIB znXr9p&k};hG4AWNdQy0aEGWF`^7Q}!28uzOLT?!mM~S`W&GmqssnCfhpq&!bn8YeR zJ*te9!XP3UBdp(ucYPXt<%Nlu98(j1c1RoLtR-Ulmj{Z8*|#3R`HuICj5;s8$KI>=oemuI4< zaJ{RiD%;l<3zY&&~Kt=C?^Fp+TQfMqgI()>zx+*T{0(=#lmdW*(g*Mbra(?7f2bY);VvH@hQF#`pDhq(Y z(#J>Ij+6V&dkaRyX0E@idOtB-<)BHfJlG0)e(3PW>_9`og+#ZU;`PAksV(qK!xY7Z z3dTynJj<=**eACf4dGkD_AX7*Y`w333WpZ0gVPh^e;#ZS1-a^4lm@y$2*8)9P0k^v zZyNumn_{DXU7pko%A=ER_(1qbNjKI%4LY)5TYq_1XQUagLUFI@*ts9 z$3If2Z;i4b@Z&KWbUOteKWgi@gNPNfa$%w;mL0m zNzwS65=^cBtXDFg0+~;lc2uTXyrJP5u=mZbumhkwI2?gw%r^E)Mu}`N7r)Q0iujaH zbrIm4ay&#Yu4Re&Yzo&To=%R{o>|v7PTbuO<#*`Q@0AcTsZu;c9>=0u884qCAZ|xy6 zweLHzJM)>hx6fED*!#D*H<1Q-=PK8JOlLGqs?z;OMiqpT3+%G$h{)bn57}n40S{7p z6{l0#IX+RuLKy(23{Z?z)I2e;O+Y{A_4|G~d<%Uwh`d=%+3p{O3b z5ml{BFj;)QXI|Q*%B-R9@LbvwytM7#M_1RNM{Rv{jf`t1xb8E?Y+j*+nDjUO(~xkY z*9`!R9XPuM-%2_jQ9`{@mrZ+A|jZ{sX(4H2J6#^Ql76>dFZ;ukF3?oTrqNF)Vu6#gkAFy`)qIB*Oul&Yg{0Lx76dMfu=ir(&;Ej&rnCG4$#-aD{ za`QT>)^mxzbWEu=yMeWtgyVc+gg?P^Bg$Q4o%KZkib~pCeXSf7#`nqbwKE}hr~>;h zp&QoR4SAzLXi!TbdX*eU`em0mx>#KKbZP{ztyoj#d}TXQ1{BZ!_-^M?p@0qO(CT}f zNclD>bZAdePtuXHhbEPz+;2t}R@ZJA_o25eIPDNvqH05i$hn+V#l<&_P24_dVv zU{^h_G4W8(Mp19;F3F4TRcb$8?LkcPEwr$$b0RX+%2VNW`K7wS>C}EmgUE2~HatUx zzyrcNW_EX#Cq^a*2O0Z~^KQwl*;y|&hT*Va3FkPfgYAtvo~7?S(DB+6V=Kyllc(`9 z$G2Ueu?1>*S~v#CPnVHuTAP)EmB8|Vk8!wNguY~;b8cX=SP_vINPyB4w_4I>;=5Uf zGuzSjRN@5jQ1;Vh9FjLghez&fh`8m}a~s0YP_L=wDLjxjrFDR> z!LDA8Q;EfG4a_a;M4oq%fmjeEnN2t8E4~;1$&^O!6kLi6qvYCuk32>jXGh(wyR%%o zu1~zI`|{tQHyM?#0ilx24|udCRs4Y0K*X1a&S;DfDr+`YK6TPnyKpwXC>Dt59gm=% z4e{L84p`59Wj_k>kK2R#fgOt8>mMOO#bQ^zg=qCTqKnEcXH2I8kXdqsrepxCoNdb6 zX4F_)B$04Pw&f|e$VGAS1VVn9#aG+A%uyYWPJ;};o@?D=*F<9*pW%?}Ku6UWNY`=1 z{Hkntq@BKcNQD?P->vGOlU`sCdBHADKXqvu8V#^KrGyrV^LODTVo@hrVTtRH6>8tB-OPsy92Il`#xxk{ULKv zttOR>kpw^_`pX*@IJLat&(>`&+th`Zm_{Zm-QOaP;S$V?<;cX~$ZwugfrXjZeLC|Q zO=d>%z_&Lkb6W~?E)V4z&sG|qcgI#o-LTSzulnIRCK?4H6Fdrgaq^BW2J2;iAFfE* z6b0^B-f2e3j9Bn8p-S>v2) zIo{Fgj9y|F4$84mne#t$oseli-(#fbya9?gl36?5~fDJ^-NMP4_K{np3 z8Y$fC)}e-C_JYfg*OYb(*4?U^d$t%X-n`s2F=|%%#GJ`pU zQm1DS1dJ+sD4v^00)zgz!bxrTut~HnPNg=0;ITc2uvTuc(EJBNwO#adq?xVhgXk7v zGSW*@OMPp~@FpX1n+fX0`6m5;PEOWyrP$IN6K_7M3lwQeQ`#uH;p4>PGG!Se zx+b*m&|H#AIXUDCFuMYogovchY91llFH227{y(x!r{9e&Wi*4r^NnqYA^!0&XfG8n z2ZN)`)C}&1NKUd0{MH;Gy%*UYM9|ez&%=YP*m4>kvI7gx2dit(a=feVGwR^nr(qJC zwisrfrWDM(681M=N-{$O+r6tR{CR0yO_Jr~%_R_im;6G|^54BW`+Wz)0tb^=WpAY#$cEtYd`R930ukFpCC};f+(wDwIVC!`7T;cC zBz9#a^C|!w$7Ev;?KG-eo))7CzSVLl5(o2$GRhAa7CA*Cp1>uTNI55gB;Y^$&3RlZ zEhC{v0louoh#QwgOx!c8Wp(O0uSsq~mH28enbAZjtkWbM_*Yx^(SqmkR|6Ld4|H=N zC^w*+Mx(JUh?vCh@>;szdKwYpL3VZhU9s95bLQ=~a??h< zp<%iYWUWY@nWYGy(FKfB!9!rl96}4?S8%J7>1`v3YoQrdR1(*fa@%n!o6{y3CYMc6 z=SX&*yKoDeDc!tGxfVq*ub$1`mfO?Ck_aRlZJ(DL<;jt{1d=|hA{Y6VFN zuHQN2(_K7wGcl-lD4=t|000LpL7Re40O@pjJL3v-8)mohAd%F@Z+UBjY@g@ELFl=T z2AFZ$kZKZ}2Nq&>cN#wBmk>ahamqS1#s?!;*)uwp9wA^W!hLW{Nj1f4chfi)gis6_ z*lz&QX3My;puCiO^xp&I%{3{zqW_G*F8nLDYl}W-Xp{XH#AW<17V$C9yn7#sna8jw>aQP&=>c9XC}%MTcbb z<*z+ql@M2ny3JTR+Y{^%TCdyCft({yqUz6LD=cuW2Qp9wH(eOkr%2ZvlK-N2xOu?# z3DjQKZ8_Yon#t{;MixvL^+_qUv?87BjdmSZApZV7Iiqlg)QPtipj5^-+!+{Q`yUEb zn6RUxM4lR{I{AQrp@O?^k`u|RnUvE4rTk>K>BF_OQH;6 zn76mWK2#@QebG_aS8X+P>vQ(%L(-UE94dqvmLwaodKyisHsrT;9c<@^{y)ccZRvVe zw8v5>!TVs!%KC!nKVU;gD|s~mt5jh@qL}~r-QeE-z<3x&^}_lE=H`v$5{~_WkFk9Y zhMq;(a;5f#G}TaFLS?&AGizgKz83I%=XKd6DUl7&C|06|?bK(qpV1%OUqRY5mw=sT z#opj{7p*d_eiydyXJ|S}o)S)Aw6x<|aUk*c;Sg*8mr0~`HKfFGaFfBrxL3+r#A$Kj zV#RGFUg5bwy-u~5J6Gr0ATj0`m;w4qYOGWS5m-U$J4nZ4ayQ(3gZ8|0*ffvWbTA_XtgBvhobn z>XqwB!4aMc6`Z`6Z_cn*Ir3Nn0#`JfZQ zEYz`F$WGO&A3EXShs(mE7Wr68r4aIA@cDl%9ketQ8mks2V($T2SCj(@Mk1Fu8GNo1 z490Vii_O$CLZ){tR;biEAS-&;IFH6ByrfCA4Nt^Ki=uq*?LaGZn>VHUios?=SCf^` z`-14TY=`?Kcn4>T9{jdX-;vXER`Gu&O&FueeQ~sgFY@P4VePHPXYhrCFJiopz_a^@ zY%lZ5a$MB-O95-==q~n9N3Y7hSrjs`r+MXH%Hq*Wd;MsW1Y#nC(bMiK`A)M&gIwFh zR;z9Y2&3?p)>CnOlBJWy-9bDN1DXG>b{@C{sh5mOE^dx}V%S5#*8STLy?3c=m!Rv} z+B5B-=B2zd9bDPQ5VUDQ`8p`FCfp5BMRS^SfVY>aZz0t9BY4?gd?{dH4AJV*EYSpf zW)?ntSIR^ma$Gy?UF6Xb5R5buxD48UnlDdo9%md9=~>jNM_ScBaO@ERdv@mww%n#L@@;-3oKYR4i-E z@wWm@0!}}S9yWN{;V4pqMq_p@rraYwwQ&&gkUx3Ya@u>tP-&_8*DruPV?VjCGZ{jl z{u&Na{ZhR98H@_xswJ^54@#g+$fUquZxyy+!$)LNDjdpg3R`Ht8gBtdY$TKGfu2o0 z$NVSMr-I=yo{pp`BwZ6K2qO}wANS_E$(z%%^h3PeaZqN!ha+TRf=k)i*uhJZ_!oyI z@i$~z;`R$uOeN?TA_lEAaO=(B+xt@BTL^DqGZGm*OU!n4_jefZ;l_foEx%X%Lf!8i zb2kC@{hniNpsCI?h?FR@IIQP*yGmGiqFK`h-_T8spcureo;hP-82-a1*BV~aiEenb zn&ER{KnQ{!Y6TCSnu#m`12~59(3ZK*xi|m{{dTZB-OYm=3)tP_D+}uHcUfyC;)gd0 zUT6-$F8>&Rs;YrO1W201&Uh}MgVuZFY+D98c-lIBW$7C-001Z-L5S=Bf7Pr0Zh}3- zZF%aDn)8s1{i3&1uNaFuy&EcD0Ec8c+I+(P5&Uy z=o~G|2~RBe0@}!9Qrx?YF4fR~h=dl_OUto@Q;a;B)Tq}VWC=(9xQLE7Ms~Q@)Ar{C z&LkHdyGEVVTD+Yg$a$DYjyM$$8B`Kmy9MZr;59M6N%JYBw2e7l6NBYr3$Jof8jlZx zk;l}zs{B?*{t#%1q0gP1J&VzuP@c2cBC_V5W;bQ=mG0J^n!qbVvtM%#vR9r2#b?Ig zxMrU8PAsM^jE4sXKgk@tRtw^ISyZ)wV3r%l0V4zJJg-IS=Ilwd?~v0I`F`Ds24y|) z^78Q{r^bU(_@q|L6!ehKs?6L4J~*)!)QH@JHm&H7S7r$c1bqt%z#l1S=6-+TFq1sm z15k3IsYKW=u2jk|szSH@h2fv+B8aSXv-)S#vB1;eq(qnK!t-k(-;Fwu_&pilD;bOL z;BP)#!-Z{L4zGr^6rcfu3^(a0R?1Mx-XyX0Nk#m#9QltYvUnAK$}ROd_8zU;vVf&{ zL|i-go15fD40cvxanW&T_pT6V_KwesG`mqX5&%wE^DC{GBHtZZLtT|*2*$hUiJCix zAt^-uQ6;hvTQ$dg5MD&T3<@i7_xv8Iz^9#3k+w~)swyB70EAMjF2n6*gu#Os;i?H0 zc=8nw2|&jKjWuG{+5G$$nh>MVcEb)rG(r=5rMMdQL?F`NurM>o7FH+c${CRn5rk&u zQV>LtMA1a68jYVx_$+YkRFS*zatqTFZN$umRIRyZsvv9O2=D5tm5K+R8ryW#BrFN- z?dC(o;Js&ZLP1v}9U0PsAWmEOOMQ#Qgi-C{`nGh)fO2lCJ>d0J=QS3KJL(fX>YR1V zVRaR&Y2(P7<&zu9^>K7;wyfDMWu+c9)i`?RO)IP`5E;7n`?reNLo0}Vb>GB{fq*yD zAJ@G^68F9@@7=?$TN}$?IaC2S4y&u0Zv>G-|8?l2ej)_38B+6NUH2g4Q3KERy{Tjq zi?Ek^`nRb!gJc*mbuD0}?;U_N+NN>kePY3Dt@oV>w6ctZLs;tr8q&dYM6p;+xV~GQ z$#V|DOzqGw`2NMO!Z$M3u3r}IJ(hkr)2bncDZIwJP?zgRN`4OUkH9^hx5wZ(Q`!Lh zZqE$MB5=IJn8^rw-+zEBg?)bJ<~8>mNgi$V3kyBhL zM?UDl>ry&H zX&y2If}1DkxJa0^_CjPqU!XjB3CFA;WBpJD`~N08v*(c=9KBH9-4{wt1rGg7<+_zB zB-zx2&?k5q^mjxulsmKPDPYvwWP8fLMtimu-9(>JK1HbF8p4O2hLwTNn?yD2N&)wg z=TWtG2RMp8H0m#DknbJzAkD46_>F$lBhR)a&rg5uNV>&n;#PUu$7ASYvrO2cIyP?ml`cM0M2j3~$Kvb%-KKmdw3*?ow;NN+k9*R+Ha}f==X77lFut$C z2WTo=vwp-paUM!s*!^F~bhdz=HtG*4uB#3HC~S}oHp+U_mM+sAgWb#Z06oujGzGST zHjSaDn1hGGCaKPob1}_B4PsjgPGK` zoH+bfiXL3!Dh`1a{sHG|j~57*GeC-KiK3gm5M3a zx_lLEDfTr`#!`Zc{%CNQT-o&9?AAIY?&XcXa^3Ed zJwPp#nH1@1QX+)^GVpQvpX`=ApsLTmGwkXZp|sWp*jrzF331N+2gtJyS`Nu#(82~6 z-hBA!j>JYR*fFLHcira`zsdwmb7iN|d_>qh-g%9Xu!e%o1FNk-ao{p?=F!*}jQGxeQ&c}_=J&Ml3$bNI-0?VyF4#i|NL5@K+s*^g7`l0C&V zZ%z|B)cd=KYTBa>@odI99ed0c5l>^dG4Xia57#YHz7Cp;p!irG9xF_C&d3s;wRiT3 zbU2!%n136-$aPF#YP=i8UvxfYJuU|=GWtJUdT54;YGE%EuabSAv9#?@Z&joi|#LSBJbt$oGsXD1fx-9TUFFos_!+fX`~2<(*}->c=im9={0*yc-4T3s!uU^zFb?YA1(r z&0*7?qB=@lLLa54$o3@_Yv@v@GPv`QN`^$vGvADTn9@dZ;w%1`^3#I>DpOIIUIyON z@<8B(0El~46o2^}ngdPH2ZXbqZn9G(2!Y)vnafL_H?Cj|OAmH4*N(*Y8GfM@ff_>x zLlv%w<}vu0_3~C?$sNWE*#E}O)HX9^n5kSms*FT*#J4VZte4_E{(4hU=<@}*uZS7^ zcmPytKOgxE+ZpRjzqHPvbp>WW&Ll~ym7ua}3WnrS_dC>fG6U}d9w{|%2_%m`KM@g4 zGP;-42N<^yM@HPzvxxT+1zCfWAz0z?o^a!BZF^2jXKYglCc;u0PXL!6~s7*VrEa0XrP3Z;AN*Qcf2w3Dhsi{m9=(S z%eaD&-|iOyq`V7HKE)LMa;S9_y=i|JLe&m4yLceZ4m>P+ZrKj!hckr?sP(q?m0>RC zdMe78Y4{1tt9c9P(RH0OHO%TGY)GevK?<1r7~bEHw-e*Uv(oxY9(H+vN05$+YYkby zAN?HERkqa5Wti0oz=Hcv#wa%q)>z@WDN@V!$wFCt|Ur^j(a6ijVd5 zVgPd~r4;AKrBQ2v0GldlHiVR|5SduFb6bE*KZ24JC2%XLB4bZ}e)U@Le*eL~kL_zj zgWzmOt?NPr2P|6FrQ$7xwC+iM3j3T&JUKmF6zY+MDV?&S*_zLi^H*4{FyY*(t0m&~ zR1*dAeze4ob_PgW9VB{(28^Wyg}OxaliwAb6UIk=*0(j6jbuAAD9Y_n>t_vRWl}E= zXMpvA6NIm;JBbt^3PDt?JkCC4zbV3!=_!&0S0If8ll>qWCCv&wP_ZQF+yWvu7&uMs zBrHj{8M}E`G-hD__M{6cMG21}c$IF*7S+Kom z?8?5qwQg>G&yy+``oqsZZsa?dfZSrU{6&Cd?jQc10d5Zo{r=LsSq+>!=;_sfXE>u( zJt>)Fl~<~-P*rE~#AgAx$1#hom5ZA;B`EniOF zcd1sv;rXVy^Jkg+5r4evs3Q0s%#P4u&-|y^84I8Bm$n&T^x3vV_{t(^%JkVEbs)9D~M&j@0stbQxFwndeqF2o%6oF%cG(q56_N!m5s&ho6B6L zDx|<7)kI6NrLYm%qw8XPnliDX(y?vdfk-zj0Ku@`AsA{bhc@Cc)*GPTEWrW_=<4U*uKZ3#fGU%)`<6-ihgG8 zZJalmS6_1USe*mYs+d%H1A^%n7_pz#VqONFPt#{c^yx&SBJw6-e;{5J|2e?TzSX1l zpeP&nhH%B!A0MTbohZa|xo67LP^S@wi35kOJf|S*OvJqLm&MdsDjP92Gm1vGYSI}<-0qJ9zU_MpTWH5r2?OKLwk^GaaGm6 zTjxR%HB%Est9PJ{>q*JUu-xDlm2DK+e0P*)Xw7My8;f_>4t;I+Id=e(6{buTh|RSR zM7WG1S&!k&ymOSyo1BD!Wj{R;M{~aK+O9;`a(U~Unp0+v$>?gKToWjW8Yng_?wT<+ z0B8Ah4|7DQSN%^cx>9CV6hN2Lbch&p0GwUxg)6QL`v>>xmQ@mc9I!Ixg7Zu9o1P~) z;(>JF74Q=~DwID4(@(Lh8c=_JQ{ThNmu88r)6@Z;i z`;E_0VfervQmO{P#_VHxy_m3nh-|;(00!Ybu3gMV8iKR+Efjx#l#&YG^f$cz-tqjm zT6q8BQGB%prdA4}j1N`)tV&ryP)fIDZ4(-JqDeg%0c=5l#m3dnzl2z;@;nknh{djV zKE4fObZ}#(ztHs3&ZyHFZrV6tS)t|!hc{tGx`?e6cjgK=G__BDVEZ6n$RJTPVhrNI zT6GIKV*(d9X;rkZuhGc1<*cDyTG}IQu8k9MsP7DKg{;DueYV8mc)3*_7SU%ie<;$z zmslos(8rUaxl@&a2}Z<^?=$d^b@>WtX?i0mfmn8bF z4)c)4s-T2BCcaunIm6eV zMY>>YHkqq?!^2^k*et0ODvlK$OQL_>FBKjLa*ZI%=uV6uY!jrB?D_c&&8gAV;qd%g z%OYp5pq;lRPVLUxoF}M5n%!Tt$`g)%N-BeK*^srbpp0C5nG&Dx2w6Y!%Ku~kn^2I- z1Aq9jQS&q0%Sej>#(f(cKch7mce!SAr~_M#?+S&5knmnu64OJ%+nMxvHBK+4S@yG1 zMMtC^GtgQo$)#omCH}B~L6uXSACRAF5W0dVCoD;6D6vYPTMdiljp*rZAF&>}QkvMO zW3oyA_%uT_AOIgjXHOE{so^$%2uED<;hGsZNU1z55Xli+gJmLh1dZ~!qRAzZ2I$}! zb?hp0Qn9u-SPEQ@;649K0#Cs12mW~IkefHb3cF8JZEr2!ml*EssC}te=9|NlO4B|| z_||Va5FG?W#RY3eSjl1Us^W&HdoYsl`@XxMRLQNZe$c2f&0{%=kN`O9%tOAXK`GGTHE8Gra2jcXH`q8)n;&higP2CrOu4eN7Mb1*g%V4PJVe2?Iz8#}E{FK8*QqnJj(u?_0*6+EVcW z>lZ?8))yY#wD)Z_q2*ze5A%^USta*xtmXY$5oPNlkgno)D2So@S-8P3;iq^VXI^5E zG^#L_k;R``DKh8?g-z4HMx4jXa*AoveSfE&@qEGpS3(0qqvl$EigC6Cd$Y}>d!5#` zp(u6Mf{ANWX7oOw;exVZ6v_b2_z0OB6n0`CeJPy(#Q5gY8@GKt_OY}zB>_VMdVuf2 zy#M#m6A)Pt-Qrh9K^4A2{G_2{k|RMDXN0|3i_2_{;U+v*^-abKb4b_M(V}eyJ(zt1 zL&o18w%LYlwAf!it+HHu`xx=?+A=^hOBKBgNj@ajF<`G(~*)|_q z5FoPx(7QwXr{A*CTO_E6i*M<6z{4SkhW{ic!mrDm4!}~}vi18TfNAeE_83DaGWOfo` z3LaE*C*Ru(Y$&OP8&Xh#`M0)dR4ri(zMc@_*EKep#HFDC2g73)g$-Bt!SAIdSlBp=N~>X$MCHmEa9vjW8)ERD?sk|#AWLW zLVYVR@RLl_aeycBI9hY^SQpF}k_?Z^5P~-P-3aBM`fep384t;WQRJ)ecHAV=3heK}7%tMzfrnMX3J>!xmT(NN~Qsd8RxZQXv6ww-voV>WsYAD^~V6OsJ&LVN63 zOsayqjlYwfk}j2w2dc2U)n)n8Tkvc$H!Euhec8f&RFn%)Km2@8atMW5M|n6BvNE!z z$hv(z5uMv*;)1w6`^9d^#{=I1RjfR`qL{{SzexQoyyQ37bvP{cmzsCQDJ5+#eZy_Wd z82LGYySKpnZp6Nvzh_lHp4t{^)23&bL!dm|XpCGomP&8k2No*bkUhGe&!W?fPznPn z3BH-xPu2qr*Sp-)v<+Inqp6MI(G*#mBjV_u8JIh}N^b)1hrgBD3KFOVUQd76$-)xu z9S`BAlb|)5NfeP4$|Hz!<{P1r{1$wtmefmLJ%|5c^Qhaq92qbCDuM!qA3GK{ceUy2 zlr@=VO{DV9uWq${Rq_tDNuDWx0JZPW&2z6QLZ(RmNO1*`^#hLo57nn#B&-=;LCmVP z%(ZEA2YY$jJuqLcVw?t2PLFSYsCdBvd+7?zj6DX4R(-qBzEyS4)U)plQ_dRJpH2C0 ztc{l6TiplW|Jel{8J`JdpB9DB;h;$A?eubGiSY})w6D@*D^^D53Q^KxaXpCh;1dgD zjTpf);Sc{KGg&RCaGhcF3wai zfkEB(UpeVLw4y6(uMB^_cl8ij6-5JwhrOG(p+}402l~S7h7kg7GQ~h#6(oy5@ZbKd zIENvM1x!GCbURT#VU8hr8U&)5!|@2~!P`0*27F9gXQpwQQ z8JOhPh+ev@%je%rdK=CyLNkx)mv%^xsF*vQG(?@!okm~{V6>4Tf7Fk6cwwI-=Zpv!8Sz&i^Sb%7S^Cd!!y+r@(Z2qopt14-BeH$$KTt z(u3#{-cX$d-j=e3+k=LMMWhK=9%+VyU+-#DRSQePH+Xq#XhR-ZNF~|sDF_)sgY0X? zqdnU%X0<~qq;cv@QS#2P5Rr+#iNM0(Xbip}qB353r*qZK>I!I8mWb;kZk5U2*Ch%# za6rbz3nrwNvCcPaDDsX2G)s9%T<#Ph02eEFpH!X@z?es$f(wcIr5y|*Z{tE#sE?L% z=U5cvRWT~v=-P!N#70|zXQ-IlFyaak#SKB;Wr8+`nUqN+U!#Ihm@9YB6KSN)6pwkP zm#*$s`EtnnllQ)TI@$2HgquqG8wZOuQ?iEc%}CA@o|05YY^`KhpyHZC<@p#zfq2kjaO z76~V4sVB@dDIt^Wk0hBpSXv&VWOVIDfslQ0)^1@U6_%QbpEEU%W3) zg}NO(hj*4qgf3LW$)130@0+$*KQH5f<*{;B>5mERTi&DdHW@&LL|YXg9lMP?*z9N5 z>QNPAc!`us77p=%;>fPdlGf{RrAw(!F-eA`LwxcNp{yc9Ihu@_Q@|ha8}MvYIGMCy zW;rJVS3(0eNhtV7H?1>=x#{xn2ESD}5}ehh-XkvZA_hA>hH0p!S^(R)a`heHlxOfW9_z}wfSig2#$ zE}$>|XrdJkY1ABqL3DCCu6E>HMwuxV)&>sWk&}e$d5cqbEUC&kMx$9VPM!b7s7I`O zz!8IkuSBZPvm*x!%`XWegx8n(A2^#>}E%7?2$%RflGk6+HP` zRBk3!9-G`ahPD7IPW<$^^idPLYJ({Bw7<3y6}>EKZS-?a1f$)bKArFLS^_(Zj_1U` zcu>F~OwvSup@*8ktNb^+>*i7p(+KDAGa0aSRxD*YZ5asmVq1x$ycK!x2eR8!#<0w8j5mQS5)@P-xC z5-fKO5ZEUMc`G$%g*qkqlTLYM9G~ruK>PbXry{>@8S4X8Lg>_-SbbjBU{F&PmXi5f z$CK~eYd}Uk=x%+37>2kjRIs&7P07WaDrmjbZ18d4jn^@HK=6iS;>dWeTn1|hAR3hM zvcn_ou{L~FYG_V2{Jso+(45ULem4ZXI?&5HQY^0%sXw8CJ0SqqL7IeJe%z=vn`Ye4 zm{el-9{LrZa3!}id@_jO?>OWaU3*y95+xKp616~|`}D%R#dY7mfAdrpCwJ=SB@S^+ z;fLC3*CtfCbKGQRXO8R!PMe`5y#C0QZ%gJHfyR~7L>L@?;=C@Qe!V>qd`J@4p+h5c z{qkLWYl@UQ_MF}-|05JcUsuAwn90f^8?{z3`a6w$wVGGW~ zQ+Zaq&bSn@l%XqP!8SbLgXB8EajE3$7Co#8g7#{m>Fk7-^H$+XOzu7Uh#VF&Dpebr z;dOc2*MG;AhIVA~P`W%r*$!NIyd?dg4+V6B-YtNTXnsnj-G%MU=W4SP3jk7+Q#iTz9@gMn})$}0#X(D^Jn6SINs zS0uz8D>)i+-6C$VucMyyJLXLs^7~lo^kjD9ujFsH}k9igsNhJLY5kDPUO1|CJG*^oz=7>*Vb9BcI&k zQV>mdqkh5r+pDA@49!xC8iRv`Gre9hC@cxXGNRP9xYCu1e(HVAu)sE>%(?DER(VWE zirtql`UnCQ;eqJMDmpCSBGDlI#AghtlWK5tKdBU$IK*>^{jkq>ip@kQGhLKGpULZ~ zF0_X2Ne`tSHmUPD*c~`}5`VO}u+5RsN`IIoZ*{CmoEW2D=WK;$hs|?Bm)UER>Bd9w z@L_d6i+e>8@PaY~WrVN~$jlbeks`(Q>mB8m5*)@CT7oup_Ladcj&x3T>U&6y6;#Q2 z=_@j}Urz01o8eJ+aGeVCA1uC<%qT0Q;lMh|X73{R3%{m0hjGku_)UuxQ%*cR7Mn6V z5{+O*jiYID0NoK73azsY?6$>QcmXX2>i4tm+vrJtH6s5@6-7Ca%)TM;`-zWawfXSt!scPiwDeg?rd2lXX}4XZ=cw%VyMMu01O z(WLnm9~ts>7%v?@_-LHrQd4o*u_)#<(rNapbvg@r3x~x|=<@@jk3@R(xH^#BQNfl< zAZT#{1;Ek905Q|m)d=l53DQ@^Qnb(y83#x@aMWY(h|XN^Z0W?LD+1EUy**}2ynfC4K!ECk7`me+`M?#ov z-mJ@lIPHZK9CLOkFAveBpQxOh000H0L7T!)4j)SR8)q1;pJmr+Jf&ALY)6QaW1uLD z#jR4>^}phIT_3H-4rwRHTsUEz2oj_{g%gp8veI>cbQnqW3moyL0kCd*TC(8lfseJr zsyGPg(tH{!gSo~I3hdc`Wo!>^ApV1%Tsl_ZzDWI)dqUWv+WsKH&*{g~-1-Y^&M&=2 z(@2DGP#9LHkt@{O6ScG}p?m?-?Nlc_StQf@iXC0`MCnsh-J7)`=`D{tb?Bn1MyODR z5RCf$YEdGQO|c&Ue6nB4KRt@UYFXiCXAIL$u)voKgi<$atN;8gJ0R7pq+#0X!hy7& z83#OFbPOT(Y4QD!iBo@KQ)vMaYC(S?>VY~;2`NLa6sg6%80r9j*RsRpn7bv(_M4ZE z`M?3kcXnN-kRjN^T}k~!c{Z80&sSQU42HHYk&_V*mGMn|n>LPjGwX3X0|OB<=Z!DU zXC9hnsFfNKy$9(4fIi#osZaX|hCRhKT>@*tX*KPV+NK+G41mMF2to_~@uLaM3=}3a zZ$RQs5YV(uClU5Hy`|yUWCJJNBo@^h#Bw2R*t`Lyv6&HrVka(NXL;HhO|gH$`LN?- zVdUt;qCZkz2g8@7SBY{?zv>ME@U*bJ^>%a6)j(+VPM&S3&Fy(w{3+&70Kc$t5tY zt?K@EJ0ir$y{Tqjd2y>?Ridly?x<{lg_%?PkmQ-8B;^EvaO7Wy7fCZDyZ2ASe#HG@ zC^_UrYq&8m3oYu~NCgU%TmfR;j;>rz+g^q5P^bISwrRe))w4lp(oclcze;^Ch-_FB zB$Xziesnzv7)rgEJtUlUJ(@Fja8GDj=UB$yT$Ur}XlUYQ7YrPy19r8EyMO2_d+KE=omtO-Ov$G# zkj=H5@HlCWDbSZy?#7nhhu$FjNy`q)>)G*e$>IvZDQ-NWmp%^8VrBq9s&cNN0k`S|2sSwzOLbizPIU18JIN6yT@!Dsgha zgCTEebpfV_Hp=|GVWz6IhPjLGo6%nW*cWC^k)Fxr@^C%m5v>iwjBM+NIJGl2PimVrX96ZW_%^5K8A zzcvQs))=37jEI$+Dgv2kOE%PJ)EH7C{8)a{xpZk20Bt^kb0PNt zwh-#rL93*nSs1AP>{8osq?p!VL>X#sG^fry$)!43!7Zw!?A2}plJF-$9lpZLnTKQ* zA-Tj5nLI|#tFt0}Kl~c&N>9;9yj;dH7?kCP%U{&ev8%F_sH9p?aP^!)|Lb&K|NcGX z7RQJ2jgk1ZiUyAxj(Xz7w4Mt;d|WRRJ`>r*6L1~QO*x1ylZZY2&ZiLD7C*wsGn`CF zC#MR~cL^a%H{mfVhac;4JU<|gCqHmx&MLfz6XwdKY;koP?jrL8K$MmjFt_55GmZ^p zi{6j0*Xr9kv5Bz?!7%v2md_ZV;e_%T8cEwLrU$cq#We%`fNz?o<#d`5p0=~E+Q(aG z-ohr(rWrQL+IZgD0c~F%e?y>$i^YCG01vaCV^!4#2k4-e@uR2fo=3MvORCBDxhgyN z-|zVnqhMwST9>%BKmY(JTtSHY|9~ul{{>cPRyz5YkdWZ{i6v07c&64GBD0{Lp6Ph3 zwpJCDt0DArJAMq?7effq-KPVOVh+V>hLV6I>TC{98f7F8x_mvdE4nLeqL;FSZ}OQH zV{G`#(sDc!Pa=@|A+7G2ZR5SP(c6VKxX~A^KATf@upmhqkY>E<^X#XDlH6Xo2VE(SmXXWa~bnr1~CLGDl%es1`h0Om3f9 z*^mw+>Go4K@z?$RVb+08*7C<8@bS@{#*VJ@?5h>xZ)~jmy4K&quk<1IyY$O6h*{<* z{EMTiRNjFm?#Fjz=$4cX4X z0C*!|s%4NR<7<05ezGVdGjiyYb)8ajgVlgs8W{=BK@!b?KVbQ`H4IIa zvl;OvE4e3H8=802!R8p*@cmBCG&Bl({)Wpyqpp~nr{Jpdz;+xYdwglf0;D|n4$U5m zgV`Q;aWj*2j3TAoXjt5j)Bg0TsfoBYG6JR=Xk=d;SC?)@>J_Sn>vqC`Xh7*A zv7r6tM2tH_+W8u14@rI%5?YP+n0fH@44`syQOW~P`ndD&VcBp!k!c^CVsWy4fQU4e zML|q*lGEcK3y`n7?&T!x(>MZN&ndo3joDO5kXCi!psM~;Ps7vw&D^4FHvky7d@H8+ zuI9<*y@KbY9-UWm2g9>EtyYkVx;>mV4Gzuu2z{L<)K&rD2IrGjtCci0Yp8@vG@IRO z-?3%5{L1TLBUk#TrUlLZkn6Y;9>+!+9a%zVp#Y0 z^{~#IeK}ewg3~+_-Oc_h#?jg!wpK1OWjx4HR`CRW`;nS(O%H@%^NR7TUlpeER+OR8 z%h9e`iX_QqD<00DXw^n3wA6+R84$u2#@flZ`^6Iie*F%_)K=&Dn1gvD3-&Bnq7)9h zaE}cW;4$ZWz&5ahdkNjoBFpU2_ZVtLTWFZyRBDnOMT&z(b{&dPGv&su)j;q9H!Qey z3CpH!5+e71qg63Z0EKyo<2lobWol+XF$pykGkwKbTvvxCIQEzSdzO?#5E-$n@~ zjO>&|8bea^U$`TYMd2}fARPZq-Ei3%kHvQa?mk2HC#NIntR{MO)gmIJD|X_^rk<Ze1O066_>Pzd z)+f!EtHuc$hFd8JjaR5$mX=lLME4dAup=HZ4E=44WBiDUy}&&cMnrpfdiGShtCex$ zdTv#UF;E2NMaa>G4B2aa%!53P$7b~*)4FVM7=x($ zu*==mafbf8q66{lsh)TjqJYpUJx0zbjqA&As-735=g@ODRp-?5MbqT3EoxL@vn+LS zgRV;x>5 z7ZrR15Hw^`XnC7NTBa3B87l^*%cabMLbq)pWz$nVOtiLoLNLu77bjv9I>A=Ml}j-r zf@c*j6a48|CMT+u2jUEoSYg?#(lJ$w;;lGm!70%lfJa`R)~%Pc2%5w^x=$7**{4Sg^uId)D58d>)J%N8hwf$r?Awmh{C3#;GZ0P z)#~z-Mb6k0N{eS&%|TH*Rn(*2)1e!ehW2iFr^?L@EMXLyv`pWHdf9=!bzP{AOlp@9 zV<~=~asa7{rQU}+*T(E4OY@#S^$QO3RTG10idEqv)fyTWgkW?K0<=$+ebJFU79VU% zlaxiDwBHY#5v#%VXcweqsup6;sy0H5&9q%y{FBDS=h^-r*C3Dee(HAt2S2;7Hip-= zUAKwW10aupKYCz&cUBHYu9@~pq1F$BNVb_`y_EGxLCjM_?>3xh&0!P=^p`^+)uar4 z@hR?&B7SX3pqixJ{5m=|{WNm5T2inoMmd&k>uk${SFrE^FrRi@09&$$|IWM$j;iXf zWrRyXWLW9SM6ngfIpbRze99nA7PrQm(UN0kSaCe=O#~BF;|JD?&AuuW^-NMooMgG% zMPrr&y^!uz)L!)>6pNj=SD3M_yUjg9TI~n$9tL_tcx^9BN|8r7xckDj#B920!x2Pi zj?5i(4LyrB);FDDmjMA{6~&)*YwV!|+^4Om+9*^LL%9nA>*V;%VUUfwZ2xj#XONrG z7y$&|y6cJqVggcM%c*M0>6SKw>=XCjwNIf}IfGX2i3=9Yr1do)j1==+WqycZZ1Gpw zZJ6mIG#)%cHhZQC1K|?I2Qk*~moo1v>811WbA(b$@X&WdMDHo6+{m4m&N@ySMi?kg ztcI(ub7`3(;S@d|#R2CrU5!q`Bi6cZaYvHy15d~VxiwG_q#lIXiZ_TY%?l-qam)(P zaveVh)Q$4=^Y3T2fW?|*dj3Fckl0iTbE?hq>I>)6QtI})gEIflvIV_-s;)F`R*Xx$ z#cb~3`N2TgrCjxa_ati+^Ut^L1azT1ub>9>eA#`$#UTv&?XLv?*N$t_%= z1OsqgEKALoZ#FG}by_r+)}X=(|fR8*^mH?R-@{<|5DA{P{66O}%8^ zk6ddolqoN+*sjCJHh1TU&kjw_c42xVdwd3}`75ke$J}QWRXBUPmnX|)YOCBqJ``XWGGZW(U+Z#bZOfovgd*lfSgLflAw;to6XH)!?uWKwE zoz48|?%4>{l|E)_ueJ-R%Vgu#mU}1#IB+S(2oVKTR%g!mo)t&azn~yowSqOLfRFAr zQGmx}gNamekkOjxcSl;uVBrmj(UC$bj8|SJTx&QYvF&%zl9NGZ^FjLYZb@nPL`S*F z9fR)cF867r0mWbz?400i{yQ&L=gM<~I<0@VRB;Za8yc~usxuSd()JlT=Q!yBcUg4s zM0-Y3ihp4s85G&#qRrP@fHDW$7R0Cjok0K$iL#R55pV%%(U_q+YKC8CNeP(;NY15- z#3VMnu}PM8kX|yr2D~&~L*F1pJk>K;3oC zrB;L-(DI>)SZ~CiWO7D_4k>!P2Qyv^!#_yYHizu_hs{_->-Zj6Cv=-8^FI*n_lvcf zRXH8}#u}{O-y3Tq%w?gH$95cGFk)E!<=E=9Zl23dgGq*1XlTXIY_E0DrhZZH<|uWn zDcJnFZi~@Cw$-8(2TtMY(E9cTDYNI2r|T?@TuCC&c$Ou$j`y754{#W<6sn_M2;F@K zqH$#6C(d?QZzq1jOg7WjIN<55ZX^)dM!cjDwklqO5rINI2AR~P57p|4_zY`~(b)|r zv@(Wq&M%NsI7~FSb5pUnYN1f*c$7EEFKZU1Bibqky9twI{OIr(&VCnU7|kb++&M`v zU1JqndaEC-3YL;aeYku}f^(IQ_y4nf{N&*^gJW~IP7sBkw38KTtd0f7$Ijb|iWC?d z66|Wos`F#b^e}(p;!*+Sl^BrQFTSwcNL2s{>wdFn1(`}PKI(iwc{?M~mp3s9j1hjY zNde^`h;7ZTj9|EYp@BoRzM@4AvNshcv=uCOD*;o2Bzr_ZZ!|r*dQ-tTDvs9T?f`~+ z7j>=CWVX+Te z#mJS`e&2XtI(nH0I*hrfeUSJD=Nw6!T3;-wyA(xh_cyuT%XsBus`oME7S6(vy0Ky^aeTg6B?9=KJeBf)|0i4lOW`=2+gz3ye)s7igf%RXi;8B6FC1*CD=?NS6ZxPAODU88Cj!f zLkv}B6#Z%!x)n`to0jp)#oIkT7jNrc01`}IRk5~~1Mr|CYx`>Fa>?C%t|->{fr(*C z)>%it7cs)ozP+g&k0blIXxqv38$Z@05QWqL6VF+$8C(@b!8LkN61BEo!Jg0THwg$ zx}0Yr{ziqaSEIV-H)fx7S#50^Yq+ofYVtq->bZKh-W?ydL zsa>EFJzo(<2afx#kjmmnjynMg;VJgUox}K?pf^nIKs&K_2&b!=@auJM>+Z~Bc;`ZL zI`aO#l~1zn6%SLbU~vXn&IDk+S*_N&m@r*N=@J-qkvp+IPq=$o&VI?2qL?o+w3hO{ z_S9veY7qHy1>D#-2Zr$VH5&DCEUhuX;6U-@~U#|ZC zOTBQ56Xtj%fp3W&%5ga*RaL<*rTKJbpvh6`X!+)C2kneb#ptqyPl(dY0f#AhHcSO*e*et{xMsDlhl zZDXtz+Fvh=e0(wmOO(w!HgJM+@CZvrLCP3j(n%sJ1Y>sQ|MAKDsCmbi%U=tYq`Ml_ zN-6?RMxkye{K>{KuhfY!&7lzapPe4W=m_5eL`b92Sz*7u3>vpNSo)9UW;|&?l&$0x zMYv|o;$;pMtK*sF*35$E%yzbz?o;n9Lxo&4<0Z#4lD`1#XXNCa5=x*UQ^O#HlkXyM z3G3Y@CP_@%=kTLZc1;xzv`&%_51YIGpUDzL{I^L)d2D*xxay{PQrZf@;y%su?tsWA z%AxoP0e5>Qhs{UH8O{vMaOyHP+t97o&^bn6+!vNg29=wR;m7JFxm-IablzMJec)2p zO}It$AM4U;&agFQMXn+5L#`dS6^-;*d<+~w0mq}@>BnmtmKG0y!u-7k3Rs-&!FcQF zYCB5A9**-`N~UiS93Etk1HK9QHP!Fw2O#)K95kKT*jxJNXTNw9N>e7P3=R0sOj@4@ zkBq)@5{L-Zxq8Xyb=|Ea<609G4>NINP)^`sI6Y@%p4TvV`3CIw&W=6(Zb&IDIaH-xnML{STc;aLwuq(_;5`T*bpbOZ)~{J zE@sEt>fq3FW?TXjSlla#`cc^DaE+im|3f;JBZtjSKrbXKFc~kLu1@F3T$;1xa*lBjC1lbU@M@bMnX=y^2_RXFdq0<}p|K;x*WkW+0U>i z85C_p%BhF~TK~*@lh9%cR=afBGS>r1>oqi2NwOZ+v@U_tJE%NLKv$5bJsS*K2E=Xe zr}RWfP=e{Y0IoPt7MoY;Pe5~A0?TpSRqz7mymE{a(Kl%@1UY;t)1DSDE(|4PaOxeT zQL{4q)25hJtw|9QX&>~PWGP3NEN4t;alWEF;!4J<`ZvhQ+}MXMSwLPdWS(qQBzMT5UW!k@^ zNWPp3(m&E~-&jLa;JwkHIWHTj?U*{XcWMn<@iR%nK^R%t+j4CE6b=BC=M}Xc!ADH> zQe^y_;{k`+#X&~(%_`{LQi#U1mu8i8Lv<>4apye7JSx;QZe06tLFZpM z#u_7%{O;ve29O=H624|9sbXX&rj!&6r&6_ac2FGrq`aj zDSXaXf&b(^ikF3;3h0lV@z!VoRpD;{iXO?GG2Vi=UxHlyGaeXRvbP+e*VYo{gAlMi zLmhRjG#(~qcE<$C0;`n)g7URc5LTLP$s@~ej24b5GIQ*sv=PO0W zPw=pT7yP;6g>iFR+uImFHD&KC(a{HgG28oTLBHX20zI!aH~we!$u)siaX{FM#xUs0BC1# zt$FNSD>|M2irA-ddY%t~qZR6p0b@M;u!S8+&XYWkVmMhmJ2s)=grb$FCMw8VF{gvG z-87>V)3)dLV7hIrX^Ur6JlM5W$FEvulubU4A;aHbA1$R%WbXwNii*k~;*rHMCAD|= zQlIOdq|-rp{BDk=I{5rzg*OM?$drZ3)n3w^61Qh7Mz}@8B@4XaCClGS^cIP01ipP6 zQ!a>+V2G~h^l~CL_HCjkzq^B#u=4U5yy|t;%Cj^F+T&A0u2>ra)VU&>u+z740S;%y zwEQ?h!@=gZJ9{%QBWj~63^6JxQ@+y{ETl&&NFp1H)roFGwh8lyKfAFm|1{Ic@wH{Y zcfJjN9^F_5c4PQFpu1->Xz?PRy&&~V(OvBF|NQw?p=ZK~goUJKXFAJT5q~DQtuW(G zOlnz<5;RD*{n_&*?$yPoAVPi_oVxGQYtBFdR9Yb~y3BYr`x~tuB9ZsekKlz0)STH> zQbEqPobEA^@uVKLhu{2IRv%N$IIW)w06u_gREGmU3S zW8yW8ITnB^;Q7SNPj= zZtT%<;=`VRFbXCb`LkTGO8Y^*O7hVSYB1=05ihD-n_HZz9yTmLfAw!)=NkigVFVtFu}van>^yL87vX|bEOEVw{Z*a(~Ql9!`%lcEO{{9c+! zrmLmI;V{GKV{bV^MSk24%APdJ(LBUNqGSg?ld(|}h$%o192Me*ucMD64XOhFsxPbL z)t|+&uHEKS0F^wIn5!6N$Nvjhx_KH$08@|!(FqnIira#h`}5}~a|W-IU%06H^8I0@1=GA8*Q5E5%7yyNbP$TDMl6+Ff+XO9m!H*bUjIp?uCfgJ8=yVMt}8!iW)! zq0JV`QstZTE=TBr(VndR{UV}VNs1>?N_D6pVmv5bjI!7zvM)cf+z^2F9EAZIlggAq zx1|+aGKT8H|V~mavd1($}#{N_V@h9TFHYV)Jl*$*Z6GP zk~dtSw0pi6v|Qo!3hGI;a>p*}QoK8~aD+9BWKHeovKkvR;|Pvxkp|`Qf#Bdg&x>)P z^z8pn84n-e2egL!lI%CB7|w9q8R;Cf2$a;ne;R^(7<9eD zi;Lc@RL%3GMI{dy(5MH4-qzhq;aGI7@9Q5^e8H0~7K02ug*e~8lP*Q8CA}RsI#P){ z1OxPv^T8d)KbD%v-Yeg04uR}6-386~XDoktq1_0T>|fLIn9(C4<4_wJ-_~Wog(|x` zz!vVRzV)>g`TU?E+G*g4&aQmI63}+_D-TSWmgXwqv#`(Bwy5vv?SP41K}RoWs2_!2Hgv zb->Cs6c;@T5J(!Q^+7$TJGGa*_F8nCYNgOd368Tj0JGy@3hkTwF&lL_Kx@q>QIG8y zmH~rYA)B(P+UGD11Q_Grvq=x70vd#Vpx4Jyy&wsOd;0Qi<2iwdl_YNg^+b5T{U9uc=uB~q$tUqCS zCmiW_U&x27Q|`Y|93pJZ8I4m1E$;cCumG=>^qFGTCk20X>*6V%<=|Vh@(7nHL2;Nv z?KNhwlshaf)@&is7sw6gNcIV{o?6NX!nBiuU&@z|AJWO2T>aa+TtdC6DgnGvkuu{h zH(WUpJvO{$SSFFKo&c+O7D@X6PnQ~#ZjRgG`UesYYN6k{^<^A+nhlgkG81-kyK2&9 z3it0;7S!CA0o8WChkpKNH`Bkj;G=T6M?JS#V&Jcsa{8>~hq)6!TAUkaEF8BUE>{X# z^vp`_c5HxhUV@$)A*{v(XJT^2*0fmp%~emJ*L~2n>T%&VCvq`KCT*LyE(b1JJ;%^h zAw=T`D+19-0@on`fE6lnil*;doX!W0kHJUk$1%)p?JFVaNnn_54yB~hB`yC9eUXbt zZ3Q^8yJe6E_R3Mbh9tw+wlvxQ4v$1uaJcn=DCJ+EA%Bzf*40{Ygp@`vD3OkxS52c?F#LK`xW=?vH zmU@nbDEvUJ`dEllK_dbvi~lYQuCXl6KpWQqEYpCu;wZ#ak@=o?4xf!0kwJTu#y|hY z_UTDfg3y1&w!E9y!4Iu~AW6TsZR-CbZ>0jHF%4c25atkY_8j@1thZ`C7kty_3nf@& zzWuh2jU>-L(3a*8r@#AlZ1(T#q+VgZjCB2i!u}+ey`r&-s6uZ@#<_E;tq~7&Lr&91 z$?X$-q+Rn_yNRXjmVN?7YwM7s&=C{7LOPCqC#7&#bR?Rt4vE@fx^@TN*+`9&1W@8> z%h)*(Vih~qN?LM##?XL1y30#c3SS3(c7i_YryqZZIFG9MLadZHn%wYbd@6@0F-A;j z!Oa>&+Z_JP4Rm4OVB|39bp@%g6(eUSI^?cR5jzd_YB@9>!p0cNfzBU9CE_XuG?#{) z=`OVk$e%<%PcpHY*G4m2TBglCSHdf$pUzn+8z)_HRqk_x!DVeoH}qX{lh)1 zvc(Tps`-f|LdFwi3&_jSx2}@a^geEHK~=IxuQ@x;&ZIL+^8WEI zC<1o{y~;!%Z02r{N*HYY-o2kd)a&h!t0Ti0$Idnp{CxzwK7Sy1@7K4UT;=i(D>$$MkooxGD?MParN$?k@gqtrfkiQ zy}jZ-jjEw8=KdC0=G1lwA8Z-k4I9qra_w`tSAz|$L~zE^D9eSOMG760bi4^clM<5Q zlpRs03r=oB#3u^_jgf(<0K}(Hh0tVW-_*Cm&@-G0rIH&(=bw?PnET}FKgZ(Y?Zy@^ zU5@U!11z3S8V~~jFo%QcE)EL>+Ek-trS@GsJH`XQdtigRj^wbHZpyGWZ%kY(in>Sk z)bjd^p>E+>gAS`c6{w9w0s>LR6%A*D*}t(hb`A{i;UKM=@K+{yDm3oHh>xf{d(q_q(LHY)E~mzhuJ71W1xrvJ9}Q93dS9`z zF;RqM|Nq+Gtu7>MF%a4+q+bo0!Z&ex-7ejhY#nh$G(3ky@s#&E`-5+UHdfB|t6TdB zbRG?15oPf%{@Zh4v3Xi%rvnu3?O*k<9N+3&dP4b%(}Q?+p{bEx8;Ew6l8 z<-c{@_k1DD&aYjSZ@ziw4qvG31d1`57lvga zPn1^@e%sgL1grp}FQ8!jqOI>F_f9Ub>6^sE0m61#wn^lGr~IsZnLtHg6*VX?Fd93* zkyx)mYKU6iUC^l@F~!aOo&hz2$jf*lS*6q)GWxyg9sI+yL47VD2@?il{$AeRkk1Q( zw4npLdk?f!t~&c2sH>;7o|#7iw9A4sj!4U*71B)FkL=MVDD!rLLg7WQqSBu2NV9Yl zjU~86o4o!tB)P&ZLU8qcR;sQTFdmEs6se__`+$-jrgcUB>_&P0z%mlC6oQfaIKGA3 z;K9ROn4tV8r`sC-3H$%{%HVx4E%kbtf$P790#~z*W2FqxDWbJ$ICY;M_!iwTJ3@4i zEP4QsOiSr(G5l2CPq+sQ-iRf@?zh9a(it3=7y0n=`~m}cS47w290-3Voy}+|*n%M6 znZYRm3ASm3y9_hMcz(}aPBDqW9}GGdD_+ygNKLj!+a+flfo%4lARLr8Kf^uNzO650lLV1w zX&(*TLZ~u+>#o+G3eXKJgg2K#B%IK__D7LB3Suh8a|(Zz+}_UW0v0O3oa{Q0J>(DE zKLjQByVha`Y8Xf`E0T2e;Gr{NZ4X5^_P$z(@I~Y6w^V3XG2DrbpPIi!eGR{~WJdvx z0bLX~60x6@J%*vkUh%%Axo0sV>Oj@VILYGQ-DIS$gD~}zu2DajAGQZcXcGrN2yd2p z2QL@bWqDq~7|)lWaw-Zna+&@BHbBY0_cs&Xo8Ob-`g#eY&@OX-jjR_FY5e&JykhGZ zdwOTq1J?im1(`vb0&fJ1?S7$bdcQ^JFAYwvig1^F3k3Q0RjA*Ps|*B(f^@Cn37uDv zrZ6W0z!SZPFj^GlxLiov0HGp#v?!+s;cmc>(s18QZ(O0FwFGKk0U%C$7GR-!4x}Qa z>X7frG|>QC(oXgVzi7v#V$Zccft=iv>C11x=#+8^tXr#YVB28s&<4nxy(thp74_5^ zBs%!_5T!a;>>dJYIAj)ZLgHgO*kmPE@E-9|pZ*Fc8^<_+t?w#On1aNatwl8dHuJ?B z6Xk&~dcWtw(z;RUu@t#*C@|%*;^l>ibz8a?>wJbYnYYTW=?gP7$KB=UDTM+inH?l4 z&sL9FVzWTXh$AG+@4x=+Kq{_2agg7Ke@_|h4 zuq_?&+BbDqNAX{N{y_=IpeWjfm&zdl`s6)^zCHjp#&~B)*rH#seJvsFQR9Dl^?0OU zpdrlJGHnCWI%=-Q|>YdKdyU1-GT`_t&WF#roeO7Q%3ZFj!o*+YD zYnBPooxC8pC{o^?VZXPLfIp;0NiKfZ)6QdOPu{7_hfIrpv71}K9)H%?rvBqeE1%88+PS|%Smbi~)5ZmWR zr#cihk($w&SuBpZohI-8drw=uIOojC=NN+>xBpIBYLD(z6#rF$<(D}NZbwjf(toQu zU_{S24^i7XG5z+R0hN}~0YZDR@^vqxV{V7VM@el2N!rvM($TKm6?(c1X>0Y8*rXwc zUX28m<;z|+X$r*W&uoUwC`8o2pmAiCoW(>Q<}ZOD)%5O+=6j66v+;K zV%7511tOU;X98_ZE!8or+!Zv)^qI&#j_xz0SYNh-0};)I+i_$8u(XMJ%g=2isn~w* zL>o9v;-$bj33uNHn%Z_2Rb93>7444{)C7hfUWsPru2d?^2;jCSpSWz*Q^@*&241%15AL?O zKT#rHCS;cM&hJF(P9yu5miWOcgSiEM?R2Mmi1yNCG*_(&(LSpOcPJTEq#zQLYC!ly$UK_)u9koMld-%Tas&ARP$T@_lXgFWnIMqjyelO zg;Ojeq<3oCX8>US7-US^O>m=4gM=0ZyZTcg`lec<>hwhkoD*Z~~S0v)u zo(;w>7!5@lARgQ85?bI;BW6f|QP!)vNrG zcs;(=_Lg}wr15e0H$YnVMcnT*eNPL3$-@BuZzzGmxC1Aa(per|<0u}>c>11ai|x%J zU}|i8`vKxxmrpwl$J57J75x7Q*06aWDpzB`59T)0*FSg&E$PBfogKNi$%I#nE$A1z zZ&ROu(kF>je@T1hAfQB}R0*%Luf}VdY8#6)uuDkpo5IMt{4}ihxwEJ}dhi2hJ0fmU z2-i@zvbh9xnVok@R#Wh9X@;X|xd@D`AjmCM<2qkTpx|QP!-d2m@tj1_S z+wpG-^cr)08bPaFmL+o}X!rxR>ORe)4Laa+@xAGDJT|aOGRTS~v=qClu~F?06h)i! zXU?zbE1=<69fMM!yr1GZLu*EVPSrU~0ll$1n(lK{ow!S(No#7F8D6~F~K=Jq{dtAQOr3cjc?K-{d3MG8aPeO$a|yA<1{hbNcXiw|oaj zrr=l^%ZbCcX&!a`g3jv*gyh7Q#Q`iZZ@~E2j5+YK?qTK00E}TZ6_Oy|oyCKwLZWG8ToWt+|6qc(Jlsl z6snVHDeW4TMM+&odc3;6&*55`U9X~vsX-#oE3?&=PhqRc7VuvK41ACzg%n4>CtqG_ zk7M@H6(zl%xjGDaEt*1^do=hjFaE(prm|IHYohTL&qB-{3Y8 zs9@Sx8JBse^6uiV3xenR@;Ib1{reHR$aQ-?S<4Vrl{32(jYj8%aU(1mAmO^oFM{S? z2jQ6dSCB~OpPIl_BQ9UbCZxeL8h*szU!YM!)-qtzB-~Nx zdGfQFPX&VS8S`Y{_?ZmjbV*~x0MYLTxkf;~Lp9zP*7fbUoeLw3X6As+adp+$3j%+ROmF^q1Cd$KQ&pd7SfNM61|yN5YEE^H z;^bJCmiSlnHVsxAg4+j z3}w~GtLGtG0#W!K>gzMAyK&Pd*1L|LXK4kbA+)gbyO-CS_5z` z(2Aq5JUc=|ge#*`bf3?VKRtU+k#JS>IIT*70Q5B|zq~)P@?RM7v8Z?l+kb?ogGy&C zSK6aS0wZdc3I&RmHh84^m4blgHbYM6%L6PHN9kZ0vU$4_uC)rFpvIt@x)jM-hq}A* ztUbLxG*qL*@#%_lovWo1?ZN2u!F4&&(nYRbZO7;}tiBCqQAOFELSb+5Rf-f> zJ#r-OdvIzRBjAe=8Ho2S&38HHJ0@dw_00W|s}c9%dyHdv6*0{HBa+z)Y*Lu#*Wh7- zt(7gPks1p~dV@F-)`M{o^PkP^(p|Iy^Nal*y&8@-m*7N(k5KDQ)!op5;y?ZqUqE zI4X8O>o@c^0&|!$1=J@Gr_O6I>&L{Tr1Pk?5!#{e2UWQS#os1)uP0WGYBoWv)$AW1 z`@&WC_F%isQpx+}mC}!cDFV?qvVvjY1>MAb_I-&Unp^Mibac$YMX$%WouR9n@FBfN zT01IUjiDq=6%GsDBqQPWZWd~fG<3&fG!<=VH1)YSR(@k^7TYYfbIW{cRJz?baKDLK zQ|4b_kO4v`;gLSX!xwSl_(gEoDU9KcicB^TO(o^YS_)~V*{K1BIzmaPI_uv~WJM>~ zp@l31l?~#!oXe+ZyR+AU4O0S`fg-OaEi~qmp!LCu6nYFf%^0klM&!qU4W7V><6B3x zH8!dMxkWGE-e8KzB>M&5k@MjF<& zL;_7=^fqmB+s`%|zAfvgibZgkretR)OJSUYxgjL>Sq@hMt?d!v=<|Pp&YBI~B%mLq zImkIH4SljZHQ!!}&mw8kK;}KV4juvO;RFlm}L@%D&^u>+0)P!S|C?X zq;ORt;fj!IU4RpEwcZiGtM023gVqimkdSP^hI4vYnvfBpi667@oiNgN>mNMXGH46G z;r4r2!CJr9`8Iq!EWCOEFZ7X~vOTm;38l!nKXT=o@bk%e&+Az8urBO~+?@Pc^^XqK zH$GA91Bc^4d94=xSiw#=OyuWA+)`5cU?&w*;8h>qTrqFKfzBzh5lEGh?JI$;88sT; z+bce1X8WzK2Z(K)(#q13wGYrfrXAD{22gYtX^(=n^Aci|1up+>Gt3SDxL}!$gW5Kk zRmXU6F4%pcd5Xk#urjaG4U{RISZ>)GcC(hYtgOou{{cRhEbW8!6n-dKYCgL|HIgnDy5N!Ph-CAOs3{-J z@5!ttnn(tYFLjsd9W-h)t)!BLY^f@?4Yci*lNiXno~2 z>n?P8P%da}6b<2ihz88E6@+D90nc|_2Uos#-qUh$b~z$|?FSIZ!mfk#oh-B3oGu=f zd^V$S4*B&y%Xuda^>ZNR_(1jX_;i$%IjVdC>=7wqvhW;hJA3rucOYUnsOZ_25htn0QHb3LG>65bQH*w*|vv zO%^IS$5S52jb|Y{ti;F%7YRz3UN@gN$2XFYWspubc_v;E_EW=@aY$R67l2#mo8x@@ zRJ|tkDdi?u7K!1iac;&Tn2WY;w79ld5|$hBs}h?lg_Tq^vJbqp3q=sYh~dL`}SOB%F_EOAMmA`$Zhu zeTjXh_au0?)kP_WI9jI-4Wuq-*6ivISus)7p_aXOpcOh*k>4_wr@AHC$QT*8Xh7hr zIAFl)M`#GDSw#>RiYW(^-BxBbb=%MRQUT;WwqJq?8H2FdL|ZpP)I$x)DK0cX708m2 zmdsp@!x)~y!Ht1vCtDEU$%{=XaSmb9e{h}QZ&d8r`U^G@n{*Tl^8PyM$XNTBDJ%^RLnytUY-qmU7Gs9 z0EFsHLgx?^Y6WBtqSh!Dt5R?GTN0x5_?K9Fu+2p7%bE?mmT-Ro#ZVrBISOhK!di78 z1+CKp_-;Uw1$RgbU;=P`dPgnuKME`PG?+e~vt4o34YE83fBG^oalaFm)%0ouw_-h^ z0fK`He`)-urR1Ci8mP_t{)b&m-=s1w2a$QY(R)|^$xsn)q#|%zJ&D-^(zrQRG<*+$ zDuq`cL!`6+-{=LX5GzZ=8ir5T1)^=DI)ZB|-)#q4P;u9?(vFL>KFkRq_5miTdQ)Xu zyy{i{*$GOLsOTpt{981FKl?l5nE7cSjV0npGBbG{&a^lKX71 zpD%9;DN)0>H%khJ(K1c7C#J|1(!c-2mtW~7{-XFhT=*Jsrv)+g z;QtrgGlZ&qZ}35u`H6|`=VakW9a^qDdKWP{23OxaOEf2z<`jQVAt2+%>!G@WNM4Ir zjtmlS^C7dVsm}XR`NjM9(^`4XdQ^B#Tk8tIwhX%o%{v=YPq7bH$j$ zOSv^@)NduvXnPJ5AumI%yQ4Ojh(+B-KOa8=KIKsk%hn@En6u-5jNs*Ii1V*M*7+1> zF@#dXzM+jffh)w1d?>CS27ALFGx#gXi`x2~#>_;)9KIInrkhT+NieL-@JX$5cKJ#G z<6iUF$o{a$_W}SyHP!}l4TJa#A<`uPUUl@t zWV*4$u$y>$4ixcsXE+5&VKbJlkLwfN5inbd;X-RfVp?oTD#oTq(7Vj99{}!$6v}9*kz)a2*~A!LI~k5QNEH6Em*!)mmi|z>Ewt}zZ#2v$=CS$wJk>q@ z>O$AL0h5e}3)LEk?)ql4B`;-)+L_jGy0F?qy*9{UdN)57aKi_VM4X$RL7)G}mn0fiZf z<?=rob#s%;=(7eIU$s2RFTy+=3>j1y(m(lyA&SmX5|e6~sH-;SG> za%c&@bKqmI^{ig?1yBavtqj~tq@BBZD4J&#VXk7$K`b>ts=OGmG{81=8f2>Z5Ow;E zs@2;0nS877{Nxww-8<|DNtg>hWJ^WA^r~@thyMCmqrn_s6h~5su!J%=0Z%HnwSd5Z z$9Et2qccwneSOg$(t+2rCcx4jm%NULxJv1+>dd`Kz6OY(EBCcr|0u%t=~4(F9;hcS?m*$Z92wn`; z{lDo^3x!SL=^k3UqsQw_d4wD{s3dhg?qlTZk}2jITRoxAXGuJ-f(SwNMQy1UtOB}% zuL&nEuM*(qEx>QXq}XS=oagxtYIYcG9mi@l<&!3o^|)N7q8hE(b?44ib@*5=K(FD( zTOEOgg9o)%%O4{)49+HI!jJ2L$vx&zCjn?D?KC!Tk#3A~aD%=|q0};gaarZ>x?X*! z3ED_|e@I5UHjqKf@;j8nUp+SEgM0{i^_)SZFHwK2NUG$5+l#p=j$J zU;Mw(l)i_FeLnBQzSODpEKn-|b~6Q1>)6CaJM6qG%k5HiE^JOyGQjqFYjk~U zOtOE2A_gY1NgtUV>w-N70#*G&!D9rc&|2><21ck$05QkRtz zInD6pJDV`*yvpk~_Tn0;vj_$0Xn_=E;05)BYJfSby>z`85T=b+Mz#KXxkd`9 zsVa5#CG}HoAigj8axjOehlSOf^$_42*hd_Pb@O~P#j!3eGfW9F;l%3n9imEI$;Jt= z%}kbc_-0I9CmDg6M-e%;Aa4w1P>R!D!DgywTId`v8>H2C}t5;g2zBSbO855&rOFXTQ#^E5_!cwUY2X_+44=_*_jG zJ(%bQ!0e)hAHl;gKd3pNp3>4_yJuocZf;isPEt{@AB>TZlAX(iU|v;IM$*>Wq4pc) z_B01a>OFF0s}uhKM_-`_{VDu1uJ-(FN(guu#mdjSr-J}-6-|-?@Z`H2XsEP6G$WZf z9EN85ajWyiW>-=RDJ+z)C?M^A_llk_NULodO2QEL2KO3`~2E)?uB zhQAZU+_#0rhg6DtU|=^bq4EE)!oFgO7mJia)~}EHU#4`$(t``uOLy@8U?UOfTHfn| z?yJgWg+w?M<#0EH0q|1J>Z-=gyz=>XKs$^hIC?2@K{ZrW0(pwaxT0+Y$EWF)n$^tPM7rayU zwAJW?7@*wpUsBW^#9a59EpZ8mkYfF>&6tU1Uz|Krmp+ze%etu4#KEE)8!Ha5O;&K* zK3k3FUgp%1!hFvxM*9l%~lj5DP)${-A1W%{f z1ySB2qNthSS%>WDQj@Yd7<@ig@KPU&O;H`*$S0j4*jHOXW&h1%%YEw$#sO?dL^6Ix zc02KRu5N-}GP)!Gk?i3l-+z=~Kv)(u-LW6%j8;1V9Mey~B*jXWzq_pnd3;v9x7~{I z*)&6RS=f1El~MhThU?s8I=K7+UCEmDKpdeUnX&duWbuS_Opkk(6(5`=fSm-#&EoWU zW2^I6F+$L})ZfpUuTwXaOw;WB+Zq{$3R2NWg7_ki8RQ7GMQOa8aJC-^*bDmZ-YFdB zFf_EuB28niPgd4BR5Qhlkv6y8pw0LTj2)E5$YH`HX!9;PLs$aR;TNSKQEUSUxhoZT z_;@lZfQth%K8~E#P%h(Lw0|1HBcLsRIfNnVJpU%jQOuR zrm4UX{HvP7B@e*~!r*GakYqZIqbgz_<+Tim?oL;6Z*Qa}1o{JL6*yS#8NBDzvWIfc zhUDwcz$Y!rVbSyLl1$XM`l?nkT)2}iliUbZsERcC;A%;_@4nITh^H2M*vG3qDg*y6 zx-<21y1abIB*USj3OEUIttHdM9?33-`Dk?dxsvi#(M8>%!|sky9a471@k;F$s5RjI z)2hDE_ue;}@hIk&EQdvcsE>u9s6`j!B?%%e*JMST3$(u_Ml6ac5;`5(@(+dmLPH9J z9tFG(P?@8=onS9%!bw);>ki?L_-n3f4(FzPS<4mefMapbWD!BF-euPC*%b35KVB%{ zMXB=^J24GvXoNL6^oC_+zu?y_F5z7gvt-V`!8FMJJoe^1=cxYeDEl%nbpxbRo22Be z7V*jw_Mn@>3V-}3i6%JE&p!zR!0snW?y z^Yz*{o6H;xaX`Z6xQz*ONZ6IS1(036pC+gFDN?u<5(#1o;g;G*|LCNjeg+yT{=F<2 z#um3f`us?fwdBrhk%cj7@+$w6WxxJ5od#Xh@+On>%oS}Ni_u6bayNzYYaOJ|>`;9X zPq#ogikGempl#zoIa_I+bIQ4|qd;$49|ZM%bdo!mrVdQ5)d_V_i52 z^L)-9^^LQ9FP*{2I=B>R@QXNw1;crDD!IprN6DW|AFV}@0214Sz5a@)j5GX^reY8BqZx6dvVkW@6r%g84K%@#D zHQ6!{Aqa<8?1Y#Jn>v+%0GIiFzXLU(lxZUTck}Mtns>`Si)5Vi?SD+uaz14@tVzp^ z`Ztp!gk7*e?sz4s{_8UaFf0C4_FRs|L}GB6MwSVD+jr}gMh})#9={NOOtS96lVtWX z?}6YnF8}qa;T;UYYb!+4b*Qe)`-)Wg1ijuh&-aGxq7w&S1Azbwl&e3FLAia>1#=jA;10`+G3t1xTo+2zT)3d&K{)&^11!PaK%E=t7Q?82c991WKB(lL97 zfJ?a7%N8?m-^d>3@wtwzu)QuGn5zb?=?#?E80>my*uOdwyOAGb$n9!oluGZSycwMyDdl8lTV&0(`nxIu%x+ zSrf0P_Ev(sv59^MzvX4Sa4pj2lut_`HH#5mQC%W3tvGD--oLvHzt%h^AX zzIvC|Aig(BoV(K)6wJ<^)}iL4l~007V`;xd@*`zjo9e8E634n7#NOSggu?(;5ZZ;h zlJCg7pz4ha`5j2k?`1}mD8DGl`Z$dF&qtxHBG_c|MZ^mr15+y;D0=qbj;6k&Mfv{q z$(lvridc)?BQVfh24a&hl@Di-UK`>DdT357Tm5BJ*r%0p^OcgvS;R&k$F(tjDGsDd z#^ra50N>&ma6ay{gI%v6c{;*8i=BCB$C$cS>N@b3$ZkKiiXQj@&wjZv4~E#FU`_1^ z{ZA?%8ejJ}J?a0Cl8(>0z?)ppc9Kny4X=k>r%E1|CiR+2G?XkEY!H;mnsh~zR!w|% zKko)rER$c6m(d>3vO>Qdj!%MX>wrd()K>Nq#nQD2NkgE1yN@X&6VCPtbV!6+h?#pb z3%fOvls&~@M>z|J6ss;0-<40s5b-)|XQt|Ja~o&u)wo03p_1N0w77$<%ez!mgno0# z(&LClixzk24B=Dhot(l4(bSRGYZ_Ayjz2^1bS0?=`wc0nB~zj*zcw$~%o%0Hb=Y6D&Q&>J=BwCngtnA+kz*JK6bycX0wr0IK1e*pAhrf`LvCqO9e>a#D@kc;|03jTpx7&PR)3w$e_; zr~r;ZI7Kczo;3mqfQR=sT(1hzYR)o|!X2T&x!Q(+_(kJ4G7rK6%V62i9QKrJvxzN~ z4PD1gpuY(_M;laq$s1=4r5ewgzW&Z3@!;H`Y)h&B6cS4pgX!k%WAo*(a5DSra(C`=`i1?}nJRN0o8r~gd9V6| z(o62KFc)Pn#oisa^GrdG&~#mdWLmWtyah}ZpA;%Ey#42>=11;2+r8R5M1$o7BFWiG z|E8l8mqlwFxEFr11QkFyLsFV7F%nvmVjzm8yL;6?j^Yjrkfpj*#VmVBwx_KezYF$jgXZ!9P4s;_wLMRV5=Y2Y+8?{NDb z7gVa|5ld`(x?8`ykv}O`mn(qwaA_pkRF6pKiwt&K1IzA&8u1!$h-;+aQBAtoK#OHj zOXUQ(>D7c`94Iu9sP*YsLyNy6qCRSeE)O@16iW@d%2odz-*?`%{}Jq)?dH0u)wa5f zQug63XLG{2TF7p7#>&~jwwx|o*+rQ@w1|{9#6z)Ueu37Q(?K8K=C0+C=@D)w81wud z?w%z?(j!qp4>&x+VOr4wzM!DZ`i`rb4UI!0=^`ukh0U_s=mEU76V+U?=>ExUj4~%u z{c-zOQcCTK*0x_Rd1{xaDPP~KtWSA;F^NEib$fuJg$jScdzq}VIKh68PITlBX6Q-Fu$;Rc%NFHkTJ*S%9gfitxNUTcewQIsIc&+oXd3^`DoEOFYiDt>MJ@b z2#|4XShRTn00pl>nnEN04y;4{hI+DTf6RqmxUi_MY>5w2q0L)03!sFOezI-FVAy6L zg1RVRES}!UxXSY6y`|S7Sy8n+?{=_Z^@-y|bo7=eQIsbqKTiX09D-k^YB__8n*QbQ z!dtcnrul8axgOXll8mY$b?K_{TyLN3%4y&Um*hYDDrV-Y3#Ql;d3!*c2#?pbP+W!% zB&|eg6+O4i*1sd56WqVd$4@(k#gd4FxY++J)c1_KxH%->OmNBcT+Y%fI^$cqbJwcP z(@fx=9A*0}V2}Y{+P+hOX$`dH36t}(3rG=UFmc_Jq|47}N$jHQ6|!bBp==4Dwb#3g zmaC;>uGJCBr7b*A*n+B?7}d!>;l9wskxjV$kx!T})x+4)%sHeMjQT2Pyl?)sDxRp(UTw1I9yoEeA@&kQ^rS*{Jlq(R5q$jh3EU``Ys~^}o7@39cpi zeCfj6Z(z6+y0EB(KHKnOMjJ99jfHR8B2zgNFW{W+m%3GZ_8p~A2K|L|Y#36u-F^+W zAr5=$9p_j>+L1JfSu`g{Q2x?3G3oYeX)?Zo0ml0kon{{aRwyvv=zQ7_@ z@YULXUg}-T8823e(t7*GN?$ksYuRykI2;T^1=Fi@h5xS(MS+W{Se)- znPwrR)fnYy;r!<&7lNTF^hVEvW8o^YB8rE5BtU7Ih{jEZ^W&?A_f9O^fUorG+A53Y z@CW*U2Im58WC`srAYD!kjB>1XcG!k&ZE~3tY0ODoHa0hI77@S7+Z-i;CIcwc(;oP2 zXac+wc$_FR?`|aznQDdbW_t|pzFeY|g~>9w1s^b?uFtbDoM$2)jJnIYxk@Z0!9+ub z<~Q%dGK|7lcHoyk@yn0v2ZzKmDO%N2eFzOOjjx;d-ZyBQwu8xCHdHxj4vkMk!<5Og zmjdwH(PDhyr|GETM2}s>`1+HVV7E;3SO6C#?H2A~D)z)e&LPnN`A~cqpAtfx0K%my zVFZWRc@q98W7dA(HyWt|uR!Cv5~cof*Hf8agp1BZxIy_Kq2;^FI4bN%(W7Xl82cyT z9)k4NSDPL7*IcxRv|76?_%rpNL$a72xd?1v1{JkBllXY$YE*?{10xeV&I>|;fNWoA zXHH6YOb1~a#&SDjt3$)Crwc|df|?l>Wy2LXvsma7+uw`0ho8!Hh()59c%a{qzNDQ|w93n;j;S0I4jZtQnmr2B;9JIF`Eh(YF{Oj+D?>=MB*NEKETXpX;wqW zaTD1wqrQJjT$kwKvM$Go^X9b|&HRzjB zWWP~IA06`C6@dT%DR4oEoBw~25Asc$w>Knnrvvd}CJyY@dS(4@CtDzgtfFTfLWiQZ zfRArwXwlNAHFvF=9%T|oC^dvDHy$B*6@P=S)?E2tO<9se|56{>zC(SpXcP1*b9WHt zE|4BmqaZ**Rsi{ZUTodKJ9`M-DDF%nC;Ciw3j{8f7-qO!2Jb3r!2Cd09y(lmj|H28 zK59N&+D2C{O4_HNa$J}qk3_BNziaHztt{^$>TCe9Tx*YvF%(UaHCP2iEy&qc4hCUE zZ$>ykV!Mr1ZNw%xD$v;neN4fgBAw$z+W66c;h2~MHFcI3W&r*h-?p||u%HC0 z5%bxDo1`$J6xHz7(t>URIsk?^i3{$0rw0P7xywl;u9I`-&5mzdh+n2D#dfHj{*1g`{2$ckC8>cD9Mk%J;}LOra>;@u2xKBkL`@ z2|@Wk`N9)arD5ix$CNu3E)PVs>;F#ZC4OGu;tiHyCuQpf!Qeeh5(GV6vSROj7(iSG zBz_>!gZ+oVGAo^3K(ID1GF54J+G{G{Bt~y0NUR>!mmMXFqmqvVU7} z5ksnA?NYT_dw(DnIQxK(>H%-FItE5Q8kYZg$Vg=#fxDwt=Qo5sbRea5+O*CwfhG%J z(w)K{;T(kH z8x;e6%_DYl70%-kJsOhiIhrRi7){gu%^o^%)*9om8d1j7!dzn$p8cG6HT|po(X;2@ z#ZqR&AoW46jkyOvn!bw+B8*L{#`HWVz$H^!uOCS2!wj@yRK%!k1TGwDz6E10CXgj` zB@az~SaN&aK|DVx#Yav8r-U!Z57%mW1d-oIJ2#MdT z75h_|p+n7tZt=$e4qPwSJ6Q5nT%4iX$!4EyMpU;TYW%fIz4lupE;`H7Vs%dY!3`rv z79+*vG73Oqj~`+53`O?Ha@j2h?hiZWkPxYz^-8k3pt=NUD)DB$)SFfc!@5b#9U>bz=j{_Uk8qTTFv_ z_b7nhy+x*MeNx6k3xENdk_r4FRhJAiE^Y>m|gOv42{`7Nl*C63C-Oac~FoX2()A%T*W)x{^ z4(yA}c%uE|LKd@_{Yk_R#i6UUoSY*NeoLEi!Cznn!?s6iPs=qApS8JDGL5J!_uxr^V!!z#^=LPEGx2k#Hlx zEO>hZg4h+~&(7HzB-nPwMeDGDAP&SMObiHR_gXCEChj2nSX zC%1KJFG`d4QnPxWO@Bfi9yg{;%@S~4pVI#+Ibx_7U^gmEBK<0xa;6Q6;L zCb(&OnS%T&HRI<8(%#_nk@;4~36r7E&UMGWjF_pC@&0i~cIPkMNd;2S&K@Tm9#Ne$ z4D=AjQ76!Bc_7#)Vy?VW7{y|ZXbVljLnq1Qpc{zUqE_Hi`6I?AG)wv)lv_=vLB?lz zS>xP{V1tJjB%u3@rcv<212;2`Hd^mBI9qpjSR{+8d~O8C7Oke@<$Pljh>x#((0g>6 z?(!-7y<##i7#_R+rje}lVT)Evvbr8cBLXrXvX4)NPF46*gM%iqiPt`<`_WF@((vo( zTJZWJIOo?B%BWZ!(}ze6DQbsm3m8~0H~!%Fpn9p{uXK#+YzoP7ivi z7$>M-yxUNB!vxJ9Q;#g5O+54u;q+5^3*>CSFgCA!I3>N0AngjJ4;82B>olf849miK z`uY#mu1Z-g*EnLBSUy%&4P{e2WpR?h=ssd3;7{>|II3SbIX}{ddjrB-mG8I9xfB15 zqP|^|9T)i^wyBPm=T>du9?t+)S!a#MSxd-EaO(iL<%=>i0qmgd;_EcZa1B1&{Z2YT zI+R4YB0HWq7fP`;(o5|nfgH0%t-thf8ky08?uG76Zh0|3RbRc)Ef@w$khMaScxJ#9 zbfgPi#QRD4&wdCzn2MqwmKXHt_~6SYF*D+SxX5h;=8pdfnLU$BEqB=@qy+h&E!9d= za{)2DOpbM{<%6{1sq{%$6AU1tK}HE#V#y_*(a=ihdd;EmPa|Wfp#N340i_~6w65fH zb1eI7ql&k#u~Z>t{qE!xyaB83*u;7*|6mju_q9iZ-e75A3|a{~X=dzSt_A`Y zTTOD8r13>Z&jvY7FA5(1NuxQ)BlvMU5C2|?=cowMS}OUJTGidS{|m^tVba|Uw%a7e zi1l6#t)TvPP(mHgL*u{FnL-xN@hpIxyzjgfHz+8h%nD!iq#SB`FRmNlGvQmphaPGG zhmpORPxkXa49Bzf!fi(W<6X>b#fOJ5tuVQXGsK-FoVy)ab@Z|^a<`%YhGhSJlJnF@ z6hKaGz<)jzOehbONI9}Ug9Wjw9>I#RC3Ebqw$7nti`lkXbn3YGH`~COvm99_-mChl}Np!ocuCN8_ z+LM~EieloSNJEb6BJMUxf-4M@SiT!Q}JO9Y72@@J>os_!~AOzr32<3 zic$tX8r3`qE`wSPy(aPvL|I)ZuK-U(d%( z?hju4JvWqb_*soL>tFs~Fe1+fD&a=aUfO*)Zc;c0edD~68iE1_)lqrPdLfiVinaw( z%mee;1^_jv}V(?RKiNj_vowyD;WDx z{0rneI;H_eQFKQ(z!D%eG6bZUl=H8F^=7`Yk3&E+Z3C=Zp}>$7 zJDVyPIh$i~T@Z5>vCWY(#_93n%;NM_dSF*{t(GW=alvAzuK}~wLPc(WD%0*_t^bxG z=@?JeJ|@V=k{;QaF(;NIWBMBwf_v3SnLl(}zbgPeK*GQ8Z@f@#Mib9nJX-^HuhGI; zOg?&{2lIqBxCJ2~S>3x&*^^5j?p;T>4`U}8j9leNDhqc@3VFgop?)leQIsEi1$I8> z4$X{qkk7S{W4_RK+lQ(Q+^aicsS6vgT03>?J_#{38)uO-5;1ekqbzfhw(U{JUL}c2xp-)=ALOL2wgH5u8jX>ZQdG(Gub*m59u zGY8j!-xcj!pGwM04pYsyNe69LA7|`%?ZSe6GaTlcKE4m(k`F1GsrV)L-yBlyg>wv) zRd%4ilEynMCNi2xbanmQd@eQ+kY;~QbRx@a_&C<3#Iipps4a@Q@>ao3;`=0}To;bv-KG?ZBpKx2w5LUG*{ z)OrQr1VO9_y(*CXQ+@bjm?E>ly|^i}HC(Xo1@@8M-1+V7OS63NdKq%0o>UcnauGX{ zuWSghdTi$*{FL%HJh{yQIaJZ{IZn&C8#8txPc- z7=*3=3IaHP!2#Ig0c>IQULrPc;n-bs@OU$^64dQj_Zh#}gW)9~AV;=iGM<{X93wBo zoO|c{{mV+Q7*Gx8GTux1{Qlp!Slm+^Y~9awv=Dw~!*?|Yz`mg!#^5_Gym%25JfXJ4 z*2Oa^9_|2lv<r zi$LoIZH`;BpQ_@=d-HI5Pb-<1z-m_S8#1^NnJWf&@Gq8QD8WcwWpE@?DU9Lq4Hkd? zqWMymU47K;2O{>u7_Mm{->XG?(bA@m%iS3r*`b0CqHM~^6zIWP0b^INy6tb%17Bb1 z<9m5~|nMzrA^AGd5<6;}~~l6Ec9RfmMebzF=h1Z?IN4VA_O}RRWuv zy_uQIy_{1_sRtNu8}OL;a-z4XaR9>9h==k2$k_HIL>+tr?6L|J` z#tY)rkMWVD6*y8x-w=r*ICciGxZkQ$>;;KOAPR9GO@WQk?23c*x}rph5`KRop9Cz~Jch9E?Cue8ZPKkBcn*4}ed1Ion1U35BcvZ^f)Ymzpbg6{asWAtIIzzin8HJ{L!PmAWEd48aG8sa@h~#;~ zd}Vm@@!SZY6z-Kpk(g#&j*mxy>DvH|c}!&g*;cou|6q55viKU(U&aNh&oZk0`4~4A zzW@QYl~1F=x9mpC5N&PcmBh#tbGXm%B!6co#g6@w$X>T02)O)ogtP^0V+zD`2c?OP zfqKSidq1tr3fb;1I#^g5+q?hV+qUweVLsS4bdVUA-zRR2Xu`DMYvZs9k275XyV#Va zSDZ6fXzirK`iu(3e{TXD5TMvorUd;R*t7=Orxx6oKz3r42qgPyoQvVqXF(j4Y7CIG z6V(epK7NN~%aMpj7Dv;;`O%+^>>e=FTREKS$pn)>bGE|Bq+2rCifi}6{L}Cl#*IRW zQAE}D$>wOf?<1-L5?)pNhO^{OQdNrwDv0N0Y}*r}tcpF80V@g)CbuN!m{9_)I>3Qk z)KKg&Ti?dt%QWbQq7U~X^3`cQ^e%C_X1G^}eQO_x+6ExxpCF%~o_G-po2W8zwC+b8uD=X~h?Vq#a}59oMvZ?g$@ z)A7{93GKm(H+ml&$o%O5jAI)0O?&vP;Z=p~%YlvvCiVf>gR&e5?zJ)^Rh6W|1hGFn zx5H~-*kc=C_F4A{`AJ7=lEuJO6v}D?H9_8l0lbj;I>l@BCf2h8RrR1w!7#_1?g=`s zDgUTygLcgeYsi6$CzpntYaD)D5wp^+rsyX}4^f~3>11nqSv^-%75?!PgSoaCw=*MI;S=^Scpo+Y3y=mRzOagUqdlA7I-Sa@hs#8o@3x|hofZ`wU4 zJTm0Z3Nb?h_M^|W35TN1c#ruaICudM+@pE9T_n)Na^uj!-H~KT^cx@`dl0jI zF`7vE-Nx3JbMW}9(WTo|_i25^7Ux7EF1QxnIpJ_r4gcOK36yvpk!53Rq9FMrE6QiQ zZ&?-`-^11u`%$q3&{Lt>BFyuaUqwF9jRfFW)?z#SX=0dvu4w-5e7RXe&TNM_{wSbm zyV;+4N=HQs|GjBq^GJR4#lGlo_s$pe$G;gH(>ppW%CME&AHI}T%#!S}6SMPn1Yp+Q zW_L`F+kC4q_AHuu6&~qp!&|0dWm%6pn>s;1*)M5@mKD#cdeFxC(W||;TD+mwpnuRy_7QHL?x(%m~t&R!%ImHbqh7CGwjx#pSQz_o1WQS#% z(%lzzF?*;%qQDCf3nE%R$G_`f(63Z~a|O&_M4trUK-;EsUxQ)!L-e|BWnit4R zc!h?1vOdHtVoA1PZu4$8$REYqZJb#2fkVw2nZxo%^)S7JMO7g(MFi0uUJI9mHO9qL z5q*~o`*83)VmopK3BL5Q2Rq)KH6dzRyKScv#DNe*?iP;6O3<`1^?X)8?HHQn5)r>NTZOf0=yaI%bny$#?-C zg3qw0H6tJWK#EjG8|AeTd0n3@+`!r!{A^4l1Zx9 zl3^qLxRr42@CiX4j)Qa@IYU}(RDY@`k>n=5EwU7nU?4*!fpW*X71=c-~LU_f6lL^gY?6A5xJ4gQNcBfY-+xzt{B(YWfXiWt;Wak1D8gDc_x4apBNE$`$>#)MqVku5ZQp1{7t;YuN7 z_p*Ozq5`lcjjMn`C>uy7Ev7~jqYHV4iSyNuih_BK)zFw^U%A|S8r~`-bSs)qc(w=d z)Kc#A0wbd$c1DRlD0Z)TqO(Azz9&>CdN;P~`nHAa^o4m&}&5b)uuVTzj(lY&9eO^mS@)b4tVU%2(MF+h* zH2&C2{&tjcJ?>ozB)?K+q02wx*8^Pl^>ueyce>A9;My1P9Tjd1R;BisEQ8I3^pQ<9 z0uhQGlNtJ>>eV1Okt=H*En}60?T~9+AbB$m6~F0oV}Eyk+DFe$^mAV@_?=vkN+b75 zlEOJv59cHec7hfsd2+uVhwY7B|4RkH=r zfalYkZ(?1pHsZ^fHpKy5)y)R!7*P0p5YT!nC(&(z#WtT>Ubr9!B z2L-Y0<6Idm(i-(9(U*jU;ae0(kB!RS_A=PwIO?h?x^k;^{#{n7ox1BFC*Rpc7G&wk z2y#j$XXR5G0!x+Rf&ua;Zl(uk!5$@T(mIDkJI1lCWoR)|s1*k|GN&qkkcEcz$snEN ztgI`3{t1cIQ?~ereU=TL;=knlDMSSg_dQsRW{K~AAG85lLw@b9MMbAYoY8RVVi$g9 zz*W--e&QB!LLPW6%K*@G=$V|lr)Y!*G5#1Z@UJP9tu`oTl;rv z68qA0aiqHJV}B9}C^v_);y~~{$t}N#A~BuQc(9vtMOfQOHm2Wg`M=*#r<9waa(Um* z5pu!?LN)U;yAwp-yeUu~rY)P~-HC=z8kI??tziuf?j_)>~z-?u4O>R`Y;sg#Nun z6~-pLn8%rz^-a>L_>$dyUI3ECu>#ucwz7$-|J=yc|9s#|OnuS%oG?`6^}u;eUL`Pd zGh7OK7TG%bg+tHk%6iq%taG2LlA?*O%xxeh(iD8MEcq2_lkQ=LHxr+~II^uQpR4)t z^I>5|!7%1uvowDwP^b!dxy@SsYe4j;HzA~t6Eb6=oWaI61GbCFZlSz=Mz8bsJ)i?KUf=-l6)cIM}t1T7K>gyNzIeSC) z7NGjG!al|>(K=G+zFc>`?y^{j z?OmiC&G5ZX)&G|cD?O$4D{akt5*TmOQ}(G}y--dW$ryHb#|S8wWpDxV6{j{~9>hJ* z9p2&hh$YI!QlFMHI%7KZEYZvA1MZm)!iBYoXT*k zp{WBhD^^@DIkLi31ogQJbMvf;A}LlfIE*v(i_+bNq=t80o3Vx@g%kW+B)O2wdpg~8 zMaPlSCSeYQCwYq5cUXE{p272sUYo`z0sgVGv#L7}4c{L~8GKhu$@+H&@*K~_7%<1N zF}sD8ImiF8a#!-(iN%$wkpvf+l1JTXZQx&^G?JHdEWeGK-l)QcN{Ib?YMp$4PwVvozPOQd1WtoQtMBm{y-2d{n%e=-^b@~KAMj4bd z)^}@i=~qd`!PKso|G$|feJhZgVPc16w_Xw|(!u0!?Ii|L4arm%roem0$u3qQ*FSqO zSPx?vwt2C-3%6{Den5-9x4MoQW*1LIOwsz-Mt&U@ktyMZFLUN z*oq6|UimYP=fpidnCXr&F30THNQ)Ern9E19`1_jaqbc>=rT(b>cD1`?{=z=|GhUvTOl=gxkh&N(9wJj7{ zA+!4db0Dkb~_yyo)rRKSgW#gPLD=C5c}DJ-(d z_MoL-q=1261v+L*eKM@t%b$4U+r~NbEe#BP9$&*ha)M1$EJy7UcX)s}GQ)sr#>)J3 zI7~zyy^0tKk)?kSy%v7!KM`LPgOML0OXGeQpD!@ZgC5Em$O%rk(ocEVd7GJ<<4(zNHU$hCWnQrN)p9u)`ORbXyH19 z);nC3ZLacOy^#Qphi%ggs_knRfClYn7M~Skbx+$vu~g<>hmllyWo{+HHsOP)T^wS9 z{>BKhexYu%sC|BB+^|mB@4h^!*MCoNn*8{B^hObDPPDpKlfny%GExJm7ZG)S*3JS9+;4SqDeinCSi-gMtJ;NyPTr>Fa0gq(3z-_!vau(OqUF7O&oP4?8K#GN#v>G7t9Sa7SCS)tq)RVv8&-%6Sny`5 zUhjHqX?7sY9~14P5t>I{cqsQGxYZm)$H2&AdHc;RqZ)Q<5py z!a=KK-a>Vfep&CXyOBFFWVTcwCq!ZvpM6gubfI{7mJFBGZ4r4ZahHfNJ#3ZGNAXN{ z3BHh*9u$4cQ{4zCKmj?KRU|`e(-eKU-~U*(^5C8$y>ZJW3nz=KH=Yj*+5&^STr