From 3730342a59d40bb2bbdec46ac60133f0ab38fe70 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Tue, 16 Sep 2025 13:03:27 +0100 Subject: [PATCH 1/5] fix(sdk): prevent uncaught errors thrown onSuccess, onComplete, and onFailure hooks to fail attempts & in some cases runs --- .changeset/tiny-carrots-rest.md | 5 + docs/tasks/overview.mdx | 202 +++++++++++------- packages/core/src/v3/workers/taskExecutor.ts | 36 +--- packages/core/test/taskExecutor.test.ts | 42 ++++ references/hello-world/src/trigger/example.ts | 69 ++++++ 5 files changed, 244 insertions(+), 110 deletions(-) create mode 100644 .changeset/tiny-carrots-rest.md diff --git a/.changeset/tiny-carrots-rest.md b/.changeset/tiny-carrots-rest.md new file mode 100644 index 0000000000..d98cca6719 --- /dev/null +++ b/.changeset/tiny-carrots-rest.md @@ -0,0 +1,5 @@ +--- +"@trigger.dev/sdk": patch +--- + +Prevent onSuccess, onComplete, and onFailure lifecycle hooks from failing attempts/runs diff --git a/docs/tasks/overview.mdx b/docs/tasks/overview.mdx index 2b3452c87a..cffa930ae5 100644 --- a/docs/tasks/overview.mdx +++ b/docs/tasks/overview.mdx @@ -174,63 +174,14 @@ tasks.onStart(({ ctx, payload, task }) => { ![Lifecycle functions](/images/lifecycle-functions.png) -### `init` function - -This function is called before a run attempt: - -```ts /trigger/init.ts -export const taskWithInit = task({ - id: "task-with-init", - init: async ({ payload, ctx }) => { - //... - }, - run: async (payload: any, { ctx }) => { - //... - }, -}); -``` - -You can also return data from the `init` function that will be available in the params of the `run`, `cleanup`, `onSuccess`, and `onFailure` functions. - -```ts /trigger/init-return.ts -export const taskWithInitReturn = task({ - id: "task-with-init-return", - init: async ({ payload, ctx }) => { - return { someData: "someValue" }; - }, - run: async (payload: any, { ctx, init }) => { - console.log(init.someData); // "someValue" - }, -}); -``` - -Errors thrown in the `init` function are ignored. - -### `cleanup` function - -This function is called after the `run` function is executed, regardless of whether the run was successful or not. It's useful for cleaning up resources, logging, or other side effects. - -```ts /trigger/cleanup.ts -export const taskWithCleanup = task({ - id: "task-with-cleanup", - cleanup: async ({ payload, ctx }) => { - //... - }, - run: async (payload: any, { ctx }) => { - //... - }, -}); -``` - -Errors thrown in the `cleanup` function will fail the attempt. - ### `middleware` and `locals` functions Our task middleware system runs at the top level, executing before and after all lifecycle hooks. This allows you to wrap the entire task execution lifecycle with custom logic. An error thrown in `middleware` is just like an uncaught error in the run function: it will - propagate through to `catchError()` function and then will fail the attempt (causing a retry). + propagate through to `catchError()` function and then will fail the attempt (either causing a + retry or failing the run). The `locals` API allows you to share data between middleware and hooks. @@ -298,7 +249,12 @@ export const myTask = task({ ### `onStart` function -When a task run starts, the `onStart` function is called. It's useful for sending notifications, logging, and other side effects. This function will only be called one per run (not per retry). If you want to run code before each retry, use the `init` function. +When a task run starts, the `onStart` function is called. It's useful for sending notifications, logging, and other side effects. + + + This function will only be called once per run (not per attempt). If you want to run code before + each attempt, use a middleware function. + ```ts /trigger/on-start.ts export const taskWithOnStart = task({ @@ -312,20 +268,17 @@ export const taskWithOnStart = task({ }); ``` -You can also define an `onStart` function in your `trigger.config.ts` file to get notified when any task starts. +You can also define a global `onStart` function using `tasks.onStart()`. -```ts trigger.config.ts -import { defineConfig } from "@trigger.dev/sdk"; +```ts init.ts +import { tasks } from "@trigger.dev/sdk"; -export default defineConfig({ - project: "proj_1234", - onStart: async ({ payload, ctx }) => { - console.log("Task started", ctx.task.id); - }, +tasks.onStart(({ ctx, payload, task }) => { + console.log(`Run ${ctx.run.id} started on task ${task}`, ctx.run); }); ``` -Errors thrown in the `onStart` function are ignored. +Errors thrown in the `onStart` function will cause the attempt to fail. ### `onWait` and `onResume` functions @@ -350,6 +303,20 @@ export const myTask = task({ }); ``` +You can also define global `onWait` and `onResume` functions using `tasks.onWait()` and `tasks.onResume()`: + +```ts init.ts +import { tasks } from "@trigger.dev/sdk"; + +tasks.onWait(({ ctx, payload, wait, task }) => { + console.log("Run paused", ctx.run, wait); +}); + +tasks.onResume(({ ctx, payload, wait, task }) => { + console.log("Run resumed", ctx.run, wait); +}); +``` + ### `onSuccess` function When a task run succeeds, the `onSuccess` function is called. It's useful for sending notifications, logging, syncing state to your database, or other side effects. @@ -366,20 +333,20 @@ export const taskWithOnSuccess = task({ }); ``` -You can also define an `onSuccess` function in your `trigger.config.ts` file to get notified when any task succeeds. +You can also define a global `onSuccess` function using `tasks.onSuccess()`. -```ts trigger.config.ts -import { defineConfig } from "@trigger.dev/sdk"; +```ts init.ts +import { tasks } from "@trigger.dev/sdk"; -export default defineConfig({ - project: "proj_1234", - onSuccess: async ({ payload, output, ctx }) => { - console.log("Task succeeded", ctx.task.id); - }, +tasks.onSuccess(({ ctx, payload, output }) => { + console.log("Task succeeded", ctx.task.id); }); ``` -Errors thrown in the `onSuccess` function are ignored. + + Errors thrown in the `onSuccess` function will be ignored, but you will still be able to see them + in the dashboard. + ### `onComplete` function @@ -397,6 +364,21 @@ export const taskWithOnComplete = task({ }); ``` +You can also define a global `onComplete` function using `tasks.onComplete()`. + +```ts init.ts +import { tasks } from "@trigger.dev/sdk"; + +tasks.onComplete(({ ctx, payload, output }) => { + console.log("Task completed", ctx.task.id); +}); +``` + + + Errors thrown in the `onComplete` function will be ignored, but you will still be able to see them + in the dashboard. + + ### `onFailure` function When a task run fails, the `onFailure` function is called. It's useful for sending notifications, logging, or other side effects. It will only be executed once the task run has exhausted all its retries. @@ -413,20 +395,20 @@ export const taskWithOnFailure = task({ }); ``` -You can also define an `onFailure` function in your `trigger.config.ts` file to get notified when any task fails. +You can also define a global `onFailure` function using `tasks.onFailure()`. -```ts trigger.config.ts -import { defineConfig } from "@trigger.dev/sdk"; +```ts init.ts +import { tasks } from "@trigger.dev/sdk"; -export default defineConfig({ - project: "proj_1234", - onFailure: async ({ payload, error, ctx }) => { - console.log("Task failed", ctx.task.id); - }, +tasks.onFailure(({ ctx, payload, error }) => { + console.log("Task failed", ctx.task.id); }); ``` -Errors thrown in the `onFailure` function are ignored. + + Errors thrown in the `onFailure` function will be ignored, but you will still be able to see them + in the dashboard. + `onFailure` doesn’t fire for some of the run statuses like `Crashed`, `System failures`, and @@ -441,7 +423,7 @@ Read more about `catchError` in our [Errors and Retrying guide](/errors-retrying Uncaught errors will throw a special internal error of the type `HANDLE_ERROR_ERROR`. -### onCancel +### `onCancel` function You can define an `onCancel` hook that is called when a run is cancelled. This is useful if you want to clean up any resources that were allocated for the run. @@ -540,6 +522,66 @@ export const cancelExampleTask = task({ point the process will be killed. +### `init` function (deprecated) + + + The `init` hook is deprecated and will be removed in the future. Use + [middleware](/tasks/overview#middleware-and-locals-functions) instead. + + +This function is called before a run attempt: + +```ts /trigger/init.ts +export const taskWithInit = task({ + id: "task-with-init", + init: async ({ payload, ctx }) => { + //... + }, + run: async (payload: any, { ctx }) => { + //... + }, +}); +``` + +You can also return data from the `init` function that will be available in the params of the `run`, `cleanup`, `onSuccess`, and `onFailure` functions. + +```ts /trigger/init-return.ts +export const taskWithInitReturn = task({ + id: "task-with-init-return", + init: async ({ payload, ctx }) => { + return { someData: "someValue" }; + }, + run: async (payload: any, { ctx, init }) => { + console.log(init.someData); // "someValue" + }, +}); +``` + +Errors thrown in the `init` function will cause the attempt to fail. + +### `cleanup` function (deprecated) + + + The `cleanup` hook is deprecated and will be removed in the future. Use + [middleware](/tasks/overview#middleware-and-locals-functions) instead. + + +This function is called after the `run` function is executed, regardless of whether the run was successful or not. It's useful for cleaning up resources, logging, or other side effects. + +```ts /trigger/cleanup.ts +export const taskWithCleanup = task({ + id: "task-with-cleanup", + cleanup: async ({ payload, ctx }) => { + //... + }, + run: async (payload: any, { ctx }) => { + //... + }, +}); +``` + +Errors thrown in the `cleanup` function will cause the attempt to fail. + ## Next steps diff --git a/packages/core/src/v3/workers/taskExecutor.ts b/packages/core/src/v3/workers/taskExecutor.ts index 38e7d7c19a..eeac559674 100644 --- a/packages/core/src/v3/workers/taskExecutor.ts +++ b/packages/core/src/v3/workers/taskExecutor.ts @@ -795,7 +795,7 @@ export class TaskExecutor { return await runTimelineMetrics.measureMetric("trigger.dev/execution", "success", async () => { for (const hook of globalSuccessHooks) { - const [hookError] = await tryCatch( + await tryCatch( this._tracer.startActiveSpan( "onSuccess()", async (span) => { @@ -817,14 +817,10 @@ export class TaskExecutor { } ) ); - - if (hookError) { - throw hookError; - } } if (taskSuccessHook) { - const [hookError] = await tryCatch( + await tryCatch( this._tracer.startActiveSpan( "onSuccess()", async (span) => { @@ -846,10 +842,6 @@ export class TaskExecutor { } ) ); - - if (hookError) { - throw hookError; - } } }); } @@ -870,7 +862,7 @@ export class TaskExecutor { return await runTimelineMetrics.measureMetric("trigger.dev/execution", "failure", async () => { for (const hook of globalFailureHooks) { - const [hookError] = await tryCatch( + await tryCatch( this._tracer.startActiveSpan( "onFailure()", async (span) => { @@ -892,14 +884,10 @@ export class TaskExecutor { } ) ); - - if (hookError) { - throw hookError; - } } if (taskFailureHook) { - const [hookError] = await tryCatch( + await tryCatch( this._tracer.startActiveSpan( "onFailure()", async (span) => { @@ -921,10 +909,6 @@ export class TaskExecutor { } ) ); - - if (hookError) { - throw hookError; - } } }); } @@ -1315,7 +1299,7 @@ export class TaskExecutor { return await runTimelineMetrics.measureMetric("trigger.dev/execution", "complete", async () => { for (const hook of globalCompleteHooks) { - const [hookError] = await tryCatch( + await tryCatch( this._tracer.startActiveSpan( "onComplete()", async (span) => { @@ -1337,14 +1321,10 @@ export class TaskExecutor { } ) ); - - if (hookError) { - throw hookError; - } } if (taskCompleteHook) { - const [hookError] = await tryCatch( + await tryCatch( this._tracer.startActiveSpan( "onComplete()", async (span) => { @@ -1366,10 +1346,6 @@ export class TaskExecutor { } ) ); - - if (hookError) { - throw hookError; - } } }); } diff --git a/packages/core/test/taskExecutor.test.ts b/packages/core/test/taskExecutor.test.ts index 229a952fff..2a5b0b2423 100644 --- a/packages/core/test/taskExecutor.test.ts +++ b/packages/core/test/taskExecutor.test.ts @@ -1246,6 +1246,48 @@ describe("TaskExecutor", () => { }); }); + test("should NOT propagate errors from onSuccess hooks", async () => { + const executionOrder: string[] = []; + const expectedError = new Error("On success hook error"); + + // Register global on success hook that throws an error + lifecycleHooks.registerGlobalSuccessHook({ + id: "global-success", + fn: async () => { + executionOrder.push("global-success"); + throw expectedError; + }, + }); + + const task = { + id: "test-task", + fns: { + run: async (payload: any, params: RunFnParams) => { + executionOrder.push("run"); + return { + output: "test-output", + }; + }, + }, + }; + + // Expect that this does not throw an error + const result = await executeTask(task, { test: "data" }, undefined); + + // Verify that run was called and on success hook was called + expect(executionOrder).toEqual(["run", "global-success"]); + + // Verify the error result + expect(result).toEqual({ + result: { + ok: true, + id: "test-run-id", + output: '{"json":{"output":"test-output"}}', + outputType: "application/super+json", + }, + }); + }); + test("should call cleanup hooks in correct order after other hooks but before middleware completion", async () => { const executionOrder: string[] = []; diff --git a/references/hello-world/src/trigger/example.ts b/references/hello-world/src/trigger/example.ts index 14fdd0faad..d5fc96ecad 100644 --- a/references/hello-world/src/trigger/example.ts +++ b/references/hello-world/src/trigger/example.ts @@ -438,3 +438,72 @@ export const lotsOfLogsTask = task({ } }, }); + +export const throwErrorInOnSuccessHookTask = task({ + id: "throw-error-in-on-success-hook", + run: async (payload: { message: string }, { ctx }) => { + logger.info("Hello, world from the throw error in on success hook task", { + message: payload.message, + }); + }, + onSuccess: async ({ payload, output, ctx }) => { + logger.info("Hello, world from the on success hook", { payload, output }); + throw new Error("Forced error to cause a retry"); + }, +}); + +export const throwErrorInOnStartHookTask = task({ + id: "throw-error-in-on-start-hook", + run: async (payload: { message: string }, { ctx }) => { + logger.info("Hello, world from the throw error in on start hook task", { + message: payload.message, + }); + }, + onStart: async ({ payload, ctx }) => { + logger.info("Hello, world from the on start hook", { payload }); + throw new Error("Forced error to cause a retry"); + }, +}); + +export const throwErrorInOnCompleteHookTask = task({ + id: "throw-error-in-on-complete-hook", + run: async (payload: { message: string }, { ctx }) => { + logger.info("Hello, world from the throw error in on complete hook task", { + message: payload.message, + }); + }, + onComplete: async ({ payload, result, ctx }) => { + logger.info("Hello, world from the on complete hook", { payload, result }); + throw new Error("Forced error to cause a retry"); + }, +}); + +export const throwErrorInOnFailureHookTask = task({ + id: "throw-error-in-on-failure-hook", + retry: { + maxAttempts: 1, + }, + run: async (payload: { message: string }, { ctx }) => { + logger.info("Hello, world from the throw error in on failure hook task", { + message: payload.message, + }); + throw new Error("Forced error to cause a retry"); + }, + onFailure: async ({ payload, error, ctx }) => { + logger.info("Hello, world from the on failure hook", { payload, error }); + throw new Error("Forced error to cause a retry in on failure hook"); + }, +}); + +export const throwErrorInInitHookTask = task({ + id: "throw-error-in-init-hook", + run: async (payload: { message: string }, { ctx }) => { + logger.info("Hello, world from the throw error in init hook task", { + message: payload.message, + }); + }, + init: async ({ payload, ctx }) => { + logger.info("Hello, world from the init hook", { payload }); + throw new Error("Forced error to cause a retry"); + }, +}); From 4ab164b77b6eddc5ed03b59dc691b90ea0781fa5 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Tue, 16 Sep 2025 14:26:20 +0100 Subject: [PATCH 2/5] Add onStartAttempt hook and deprecate onSuccess --- .../webapp/app/components/runs/v3/RunIcon.tsx | 1 + docs/tasks/overview.mdx | 74 +++++++++++++--- packages/core/src/v3/lifecycleHooks/index.ts | 22 +++++ .../core/src/v3/lifecycleHooks/manager.ts | 57 +++++++++++++ packages/core/src/v3/lifecycleHooks/types.ts | 24 ++++++ packages/core/src/v3/types/tasks.ts | 18 ++++ packages/core/src/v3/workers/taskExecutor.ts | 66 ++++++++++++++ packages/core/test/taskExecutor.test.ts | 85 +++++++++++++++++++ packages/trigger-sdk/src/v3/hooks.ts | 13 +++ packages/trigger-sdk/src/v3/shared.ts | 7 ++ packages/trigger-sdk/src/v3/tasks.ts | 3 + 11 files changed, 357 insertions(+), 13 deletions(-) diff --git a/apps/webapp/app/components/runs/v3/RunIcon.tsx b/apps/webapp/app/components/runs/v3/RunIcon.tsx index fd277997af..b14aa5f576 100644 --- a/apps/webapp/app/components/runs/v3/RunIcon.tsx +++ b/apps/webapp/app/components/runs/v3/RunIcon.tsx @@ -97,6 +97,7 @@ export function RunIcon({ name, className, spanName }: TaskIconProps) { return ; case "task-hook-init": case "task-hook-onStart": + case "task-hook-onStartAttempt": case "task-hook-onSuccess": case "task-hook-onWait": case "task-hook-onResume": diff --git a/docs/tasks/overview.mdx b/docs/tasks/overview.mdx index cffa930ae5..fe2e7ce5c7 100644 --- a/docs/tasks/overview.mdx +++ b/docs/tasks/overview.mdx @@ -247,19 +247,16 @@ export const myTask = task({ }); ``` -### `onStart` function +### `onStartAttempt` function -When a task run starts, the `onStart` function is called. It's useful for sending notifications, logging, and other side effects. +The `onStartAttempt` function was introduced in v4.1.0 - - This function will only be called once per run (not per attempt). If you want to run code before - each attempt, use a middleware function. - +Before a task run attempt starts, the `onStartAttempt` function is called. It's useful for sending notifications, logging, and other side effects. ```ts /trigger/on-start.ts -export const taskWithOnStart = task({ - id: "task-with-on-start", - onStart: async ({ payload, ctx }) => { +export const taskWithOnStartAttempt = task({ + id: "task-with-on-start-attempt", + onStartAttempt: async ({ payload, ctx }) => { //... }, run: async (payload: any, { ctx }) => { @@ -268,17 +265,33 @@ export const taskWithOnStart = task({ }); ``` -You can also define a global `onStart` function using `tasks.onStart()`. +You can also define a global `onStartAttempt` function using `tasks.onStartAttempt()`. ```ts init.ts import { tasks } from "@trigger.dev/sdk"; -tasks.onStart(({ ctx, payload, task }) => { - console.log(`Run ${ctx.run.id} started on task ${task}`, ctx.run); +tasks.onStartAttempt(({ ctx, payload, task }) => { + console.log( + `Run ${ctx.run.id} started on task ${task} attempt ${ctx.run.attempt.number}`, + ctx.run + ); }); ``` -Errors thrown in the `onStart` function will cause the attempt to fail. +Errors thrown in the `onStartAttempt` function will cause the attempt to fail. + +If you want to execute code before just the first attempt, you can use the `onStartAttempt` function and check `ctx.run.attempt.number === 1`: + +```ts /trigger/on-start-attempt.ts +export const taskWithOnStartAttempt = task({ + id: "task-with-on-start-attempt", + onStartAttempt: async ({ payload, ctx }) => { + if (ctx.run.attempt.number === 1) { + console.log("Run started on attempt 1", ctx.run); + } + }, +}); +``` ### `onWait` and `onResume` functions @@ -522,6 +535,41 @@ export const cancelExampleTask = task({ point the process will be killed. +### `onStart` function (deprecated) + +The `onStart` function was deprecated in v4.1.0. Use `onStartAttempt` instead. + +When a task run starts, the `onStart` function is called. It's useful for sending notifications, logging, and other side effects. + + + This function will only be called once per run (not per attempt). If you want to run code before + each attempt, use a middleware function or the `onStartAttempt` function. + + +```ts /trigger/on-start.ts +export const taskWithOnStart = task({ + id: "task-with-on-start", + onStart: async ({ payload, ctx }) => { + //... + }, + run: async (payload: any, { ctx }) => { + //... + }, +}); +``` + +You can also define a global `onStart` function using `tasks.onStart()`. + +```ts init.ts +import { tasks } from "@trigger.dev/sdk"; + +tasks.onStart(({ ctx, payload, task }) => { + console.log(`Run ${ctx.run.id} started on task ${task}`, ctx.run); +}); +``` + +Errors thrown in the `onStart` function will cause the attempt to fail. + ### `init` function (deprecated) diff --git a/packages/core/src/v3/lifecycleHooks/index.ts b/packages/core/src/v3/lifecycleHooks/index.ts index 99ed47ae60..0011bd5d5a 100644 --- a/packages/core/src/v3/lifecycleHooks/index.ts +++ b/packages/core/src/v3/lifecycleHooks/index.ts @@ -18,6 +18,7 @@ import { RegisterHookFunctionParams, TaskWait, type LifecycleHooksManager, + AnyOnStartAttemptHookFunction, } from "./types.js"; const NOOP_LIFECYCLE_HOOKS_MANAGER = new NoopLifecycleHooksManager(); @@ -81,6 +82,27 @@ export class LifecycleHooksAPI { return this.#getManager().getGlobalStartHooks(); } + public registerTaskStartAttemptHook( + taskId: string, + hook: RegisterHookFunctionParams + ): void { + this.#getManager().registerTaskStartAttemptHook(taskId, hook); + } + + public registerGlobalStartAttemptHook( + hook: RegisterHookFunctionParams + ): void { + this.#getManager().registerGlobalStartAttemptHook(hook); + } + + public getTaskStartAttemptHook(taskId: string): AnyOnStartAttemptHookFunction | undefined { + return this.#getManager().getTaskStartAttemptHook(taskId); + } + + public getGlobalStartAttemptHooks(): RegisteredHookFunction[] { + return this.#getManager().getGlobalStartAttemptHooks(); + } + public registerGlobalFailureHook( hook: RegisterHookFunctionParams ): void { diff --git a/packages/core/src/v3/lifecycleHooks/manager.ts b/packages/core/src/v3/lifecycleHooks/manager.ts index 282d2fe16c..e755e66d3f 100644 --- a/packages/core/src/v3/lifecycleHooks/manager.ts +++ b/packages/core/src/v3/lifecycleHooks/manager.ts @@ -14,6 +14,7 @@ import { AnyOnCleanupHookFunction, TaskWait, AnyOnCancelHookFunction, + AnyOnStartAttemptHookFunction, } from "./types.js"; export class StandardLifecycleHooksManager implements LifecycleHooksManager { @@ -23,6 +24,15 @@ export class StandardLifecycleHooksManager implements LifecycleHooksManager { private globalStartHooks: Map> = new Map(); private taskStartHooks: Map> = new Map(); + private globalStartAttemptHooks: Map< + string, + RegisteredHookFunction + > = new Map(); + private taskStartAttemptHooks: Map< + string, + RegisteredHookFunction + > = new Map(); + private globalFailureHooks: Map> = new Map(); private taskFailureHooks: Map> = @@ -129,6 +139,37 @@ export class StandardLifecycleHooksManager implements LifecycleHooksManager { return Array.from(this.globalStartHooks.values()); } + registerGlobalStartAttemptHook( + hook: RegisterHookFunctionParams + ): void { + const id = generateHookId(hook); + this.globalStartAttemptHooks.set(id, { + id, + name: hook.id, + fn: hook.fn, + }); + } + + registerTaskStartAttemptHook( + taskId: string, + hook: RegisterHookFunctionParams + ): void { + const id = generateHookId(hook); + this.taskStartAttemptHooks.set(taskId, { + id, + name: hook.id, + fn: hook.fn, + }); + } + + getTaskStartAttemptHook(taskId: string): AnyOnStartAttemptHookFunction | undefined { + return this.taskStartAttemptHooks.get(taskId)?.fn; + } + + getGlobalStartAttemptHooks(): RegisteredHookFunction[] { + return Array.from(this.globalStartAttemptHooks.values()); + } + registerGlobalInitHook(hook: RegisterHookFunctionParams): void { // if there is no id, lets generate one based on the contents of the function const id = generateHookId(hook); @@ -527,6 +568,22 @@ export class NoopLifecycleHooksManager implements LifecycleHooksManager { return []; } + registerGlobalStartAttemptHook(): void { + // Noop + } + + registerTaskStartAttemptHook(): void { + // Noop + } + + getTaskStartAttemptHook(): undefined { + return undefined; + } + + getGlobalStartAttemptHooks(): RegisteredHookFunction[] { + return []; + } + registerGlobalFailureHook(hook: RegisterHookFunctionParams): void { // Noop } diff --git a/packages/core/src/v3/lifecycleHooks/types.ts b/packages/core/src/v3/lifecycleHooks/types.ts index 9501216546..51518a165a 100644 --- a/packages/core/src/v3/lifecycleHooks/types.ts +++ b/packages/core/src/v3/lifecycleHooks/types.ts @@ -33,6 +33,19 @@ export type OnStartHookFunction; +export type TaskStartAttemptHookParams = { + ctx: TaskRunContext; + payload: TPayload; + task: string; + signal: AbortSignal; +}; + +export type OnStartAttemptHookFunction = ( + params: TaskStartAttemptHookParams +) => undefined | void | Promise; + +export type AnyOnStartAttemptHookFunction = OnStartAttemptHookFunction; + export type TaskWait = | { type: "duration"; @@ -268,6 +281,17 @@ export interface LifecycleHooksManager { ): void; getTaskStartHook(taskId: string): AnyOnStartHookFunction | undefined; getGlobalStartHooks(): RegisteredHookFunction[]; + + registerGlobalStartAttemptHook( + hook: RegisterHookFunctionParams + ): void; + registerTaskStartAttemptHook( + taskId: string, + hook: RegisterHookFunctionParams + ): void; + getTaskStartAttemptHook(taskId: string): AnyOnStartAttemptHookFunction | undefined; + getGlobalStartAttemptHooks(): RegisteredHookFunction[]; + registerGlobalFailureHook(hook: RegisterHookFunctionParams): void; registerTaskFailureHook( taskId: string, diff --git a/packages/core/src/v3/types/tasks.ts b/packages/core/src/v3/types/tasks.ts index 67c80d40b4..ace6c462ba 100644 --- a/packages/core/src/v3/types/tasks.ts +++ b/packages/core/src/v3/types/tasks.ts @@ -13,6 +13,7 @@ import { OnSuccessHookFunction, OnWaitHookFunction, OnCancelHookFunction, + OnStartAttemptHookFunction, } from "../lifecycleHooks/types.js"; import { RunTags } from "../schemas/api.js"; import { @@ -114,6 +115,13 @@ export type StartFnParams = Prettify<{ signal: AbortSignal; }>; +export type StartAttemptFnParams = Prettify<{ + ctx: Context; + init?: InitOutput; + /** Abort signal that is aborted when a task run exceeds it's maxDuration or if the task run is cancelled. Can be used to automatically cancel downstream requests */ + signal: AbortSignal; +}>; + export type CancelFnParams = Prettify<{ ctx: Context; /** Abort signal that is aborted when a task run exceeds it's maxDuration or if the task run is cancelled. Can be used to automatically cancel downstream requests */ @@ -328,9 +336,18 @@ type CommonTaskOptions< /** * onStart is called the first time a task is executed in a run (not before every retry) + * + * @deprecated Use onStartAttempt instead */ onStart?: OnStartHookFunction; + /** + * onStartAttempt is called before each attempt of a task is executed. + * + * You can detect the first attempt by checking `ctx.attempt.number === 1`. + */ + onStartAttempt?: OnStartAttemptHookFunction; + /** * onSuccess is called after the run function has successfully completed. */ @@ -912,6 +929,7 @@ export type TaskMetadataWithFunctions = TaskMetadata & { onSuccess?: (payload: any, output: any, params: SuccessFnParams) => Promise; onFailure?: (payload: any, error: unknown, params: FailureFnParams) => Promise; onStart?: (payload: any, params: StartFnParams) => Promise; + onStartAttempt?: (payload: any, params: StartAttemptFnParams) => Promise; parsePayload?: AnySchemaParseFn; }; schema?: TaskSchema; diff --git a/packages/core/src/v3/workers/taskExecutor.ts b/packages/core/src/v3/workers/taskExecutor.ts index eeac559674..78d7c6bdf2 100644 --- a/packages/core/src/v3/workers/taskExecutor.ts +++ b/packages/core/src/v3/workers/taskExecutor.ts @@ -183,6 +183,8 @@ export class TaskExecutor { await this.#callOnStartFunctions(payload, ctx, initOutput, signal); } + await this.#callOnStartAttemptFunctions(payload, ctx, signal); + try { return await this.#callRun(payload, ctx, initOutput, signal); } catch (error) { @@ -991,6 +993,70 @@ export class TaskExecutor { }); } + async #callOnStartAttemptFunctions(payload: unknown, ctx: TaskRunContext, signal: AbortSignal) { + const globalStartHooks = lifecycleHooks.getGlobalStartAttemptHooks(); + const taskStartHook = lifecycleHooks.getTaskStartAttemptHook(this.task.id); + + if (globalStartHooks.length === 0 && !taskStartHook) { + return; + } + + return await runTimelineMetrics.measureMetric( + "trigger.dev/execution", + "startAttempt", + async () => { + for (const hook of globalStartHooks) { + const [hookError] = await tryCatch( + this._tracer.startActiveSpan( + "onStartAttempt()", + async (span) => { + await hook.fn({ payload, ctx, signal, task: this.task.id }); + }, + { + attributes: { + [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onStartAttempt", + [SemanticInternalAttributes.COLLAPSED]: true, + ...this.#lifecycleHookAccessoryAttributes(hook.name), + }, + } + ) + ); + + if (hookError) { + throw hookError; + } + } + + if (taskStartHook) { + const [hookError] = await tryCatch( + this._tracer.startActiveSpan( + "onStart()", + async (span) => { + await taskStartHook({ + payload, + ctx, + signal, + task: this.task.id, + }); + }, + { + attributes: { + [SemanticInternalAttributes.STYLE_ICON]: "task-hook-onStartAttempt", + [SemanticInternalAttributes.COLLAPSED]: true, + ...this.#lifecycleHookAccessoryAttributes("task"), + }, + } + ) + ); + + if (hookError) { + throw hookError; + } + } + } + ); + } + async #cleanupAndWaitUntil( payload: unknown, ctx: TaskRunContext, diff --git a/packages/core/test/taskExecutor.test.ts b/packages/core/test/taskExecutor.test.ts index 2a5b0b2423..34b36076fe 100644 --- a/packages/core/test/taskExecutor.test.ts +++ b/packages/core/test/taskExecutor.test.ts @@ -269,6 +269,91 @@ describe("TaskExecutor", () => { }); }); + test("should call onStartAttempt hooks in correct order with proper data", async () => { + const globalStartOrder: string[] = []; + const startPayloads: any[] = []; + + // Register global init hook to provide init data + lifecycleHooks.registerGlobalInitHook({ + id: "test-init", + fn: async () => { + return { + foo: "bar", + }; + }, + }); + + // Register two global start hooks + lifecycleHooks.registerGlobalStartAttemptHook({ + id: "global-start-1", + fn: async ({ payload, ctx }) => { + console.log("Executing global start hook 1"); + globalStartOrder.push("global-1"); + startPayloads.push(payload); + }, + }); + + lifecycleHooks.registerGlobalStartAttemptHook({ + id: "global-start-2", + fn: async ({ payload, ctx }) => { + console.log("Executing global start hook 2"); + globalStartOrder.push("global-2"); + startPayloads.push(payload); + }, + }); + + // Register task-specific start hook + lifecycleHooks.registerTaskStartAttemptHook("test-task", { + id: "task-start", + fn: async ({ payload, ctx }) => { + console.log("Executing task start hook"); + globalStartOrder.push("task"); + startPayloads.push(payload); + }, + }); + + // Verify hooks are registered + const globalHooks = lifecycleHooks.getGlobalStartAttemptHooks(); + console.log( + "Registered global hooks:", + globalHooks.map((h) => h.id) + ); + const taskHook = lifecycleHooks.getTaskStartAttemptHook("test-task"); + console.log("Registered task hook:", taskHook ? "yes" : "no"); + + const task = { + id: "test-task", + fns: { + run: async (payload: any, params: RunFnParams) => { + return { + output: "test-output", + init: params.init, + }; + }, + }, + }; + + const result = await executeTask(task, { test: "data" }, undefined); + + // Verify hooks were called in correct order + expect(globalStartOrder).toEqual(["global-1", "global-2", "task"]); + + // Verify each hook received the correct payload + startPayloads.forEach((payload) => { + expect(payload).toEqual({ test: "data" }); + }); + + // Verify the final result + expect(result).toEqual({ + result: { + ok: true, + id: "test-run-id", + output: '{"json":{"output":"test-output","init":{"foo":"bar"}}}', + outputType: "application/super+json", + }, + }); + }); + test("should call onFailure hooks with error when task fails", async () => { const globalFailureOrder: string[] = []; const failurePayloads: any[] = []; diff --git a/packages/trigger-sdk/src/v3/hooks.ts b/packages/trigger-sdk/src/v3/hooks.ts index b4e9cd0988..49822b709f 100644 --- a/packages/trigger-sdk/src/v3/hooks.ts +++ b/packages/trigger-sdk/src/v3/hooks.ts @@ -13,6 +13,7 @@ import { type AnyOnMiddlewareHookFunction, type AnyOnCancelHookFunction, } from "@trigger.dev/core/v3"; +import { AnyOnStartAttemptHookFunction } from "../../../core/src/v3/lifecycleHooks/types.js"; export type { AnyOnStartHookFunction, @@ -41,6 +42,18 @@ export function onStart( }); } +export function onStartAttempt(name: string, fn: AnyOnStartHookFunction): void; +export function onStartAttempt(fn: AnyOnStartHookFunction): void; +export function onStartAttempt( + fnOrName: string | AnyOnStartAttemptHookFunction, + fn?: AnyOnStartAttemptHookFunction +): void { + lifecycleHooks.registerGlobalStartAttemptHook({ + id: typeof fnOrName === "string" ? fnOrName : fnOrName.name ? fnOrName.name : undefined, + fn: typeof fnOrName === "function" ? fnOrName : fn!, + }); +} + export function onFailure(name: string, fn: AnyOnFailureHookFunction): void; export function onFailure(fn: AnyOnFailureHookFunction): void; export function onFailure( diff --git a/packages/trigger-sdk/src/v3/shared.ts b/packages/trigger-sdk/src/v3/shared.ts index 11b92c2f43..c37dbb2ffc 100644 --- a/packages/trigger-sdk/src/v3/shared.ts +++ b/packages/trigger-sdk/src/v3/shared.ts @@ -91,6 +91,7 @@ import type { TriggerApiRequestOptions, TriggerOptions, } from "@trigger.dev/core/v3"; +import { AnyOnStartAttemptHookFunction } from "../../../core/src/v3/lifecycleHooks/types.js"; export type { AnyRunHandle, @@ -1587,6 +1588,12 @@ function registerTaskLifecycleHooks< }); } + if (params.onStartAttempt) { + lifecycleHooks.registerTaskStartAttemptHook(taskId, { + fn: params.onStartAttempt as AnyOnStartAttemptHookFunction, + }); + } + if (params.onFailure) { lifecycleHooks.registerTaskFailureHook(taskId, { fn: params.onFailure as AnyOnFailureHookFunction, diff --git a/packages/trigger-sdk/src/v3/tasks.ts b/packages/trigger-sdk/src/v3/tasks.ts index 078666dc68..c8b3fbd4fe 100644 --- a/packages/trigger-sdk/src/v3/tasks.ts +++ b/packages/trigger-sdk/src/v3/tasks.ts @@ -1,5 +1,6 @@ import { onStart, + onStartAttempt, onFailure, onSuccess, onComplete, @@ -88,7 +89,9 @@ export const tasks = { batchTrigger, triggerAndWait, batchTriggerAndWait, + /** @deprecated Use onStartAttempt instead */ onStart, + onStartAttempt, onFailure, onSuccess, onComplete, From 7b475aec1388224d9d1e5013a20f06b729c73a1d Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Tue, 16 Sep 2025 14:59:12 +0100 Subject: [PATCH 3/5] Add onStartAttempt hook and deprecate onStart hook --- .changeset/tiny-carrots-rest.md | 40 ++++++++++++++++++- packages/cli-v3/package.json | 2 +- packages/core/src/v3/lifecycle-hooks-api.ts | 1 + packages/core/src/v3/workers/taskExecutor.ts | 2 +- packages/trigger-sdk/src/v3/hooks.ts | 2 +- packages/trigger-sdk/src/v3/shared.ts | 2 +- references/hello-world/src/trigger/example.ts | 21 ++++++++++ 7 files changed, 64 insertions(+), 6 deletions(-) diff --git a/.changeset/tiny-carrots-rest.md b/.changeset/tiny-carrots-rest.md index d98cca6719..5c1c7b8942 100644 --- a/.changeset/tiny-carrots-rest.md +++ b/.changeset/tiny-carrots-rest.md @@ -1,5 +1,41 @@ --- -"@trigger.dev/sdk": patch +"@trigger.dev/sdk": minor --- -Prevent onSuccess, onComplete, and onFailure lifecycle hooks from failing attempts/runs +Prevent uncaught errors in the `onSuccess`, `onComplete`, and `onFailure` lifecycle hooks from failing attempts/runs. + +Deprecated the `onStart` lifecycle hook (which only fires before the `run` function on the first attempt). Replaced with `onStartAttempt` that fires before the run function on every attempt: + +```ts +export const taskWithOnStartAttempt = task({ + id: "task-with-on-start-attempt", + onStartAttempt: async ({ payload, ctx }) => { + //... + }, + run: async (payload: any, { ctx }) => { + //... + }, +}); + +// Default a global lifecycle hook using tasks +tasks.onStartAttempt(({ ctx, payload, task }) => { + console.log( + `Run ${ctx.run.id} started on task ${task} attempt ${ctx.run.attempt.number}`, + ctx.run + ); +}); +``` + +If you want to execute code before just the first attempt, you can use the `onStartAttempt` function and check `ctx.run.attempt.number === 1`: + +```ts /trigger/on-start-attempt.ts +export const taskWithOnStartAttempt = task({ + id: "task-with-on-start-attempt", + onStartAttempt: async ({ payload, ctx }) => { + if (ctx.run.attempt.number === 1) { + console.log("Run started on attempt 1", ctx.run); + } + }, +}); +``` + diff --git a/packages/cli-v3/package.json b/packages/cli-v3/package.json index b978f0c85a..da68cb1377 100644 --- a/packages/cli-v3/package.json +++ b/packages/cli-v3/package.json @@ -155,4 +155,4 @@ } } } -} \ No newline at end of file +} diff --git a/packages/core/src/v3/lifecycle-hooks-api.ts b/packages/core/src/v3/lifecycle-hooks-api.ts index 3c74f719cb..e08bd66671 100644 --- a/packages/core/src/v3/lifecycle-hooks-api.ts +++ b/packages/core/src/v3/lifecycle-hooks-api.ts @@ -35,4 +35,5 @@ export type { TaskCancelHookParams, OnCancelHookFunction, AnyOnCancelHookFunction, + AnyOnStartAttemptHookFunction, } from "./lifecycleHooks/types.js"; diff --git a/packages/core/src/v3/workers/taskExecutor.ts b/packages/core/src/v3/workers/taskExecutor.ts index 78d7c6bdf2..2f6f08592a 100644 --- a/packages/core/src/v3/workers/taskExecutor.ts +++ b/packages/core/src/v3/workers/taskExecutor.ts @@ -1030,7 +1030,7 @@ export class TaskExecutor { if (taskStartHook) { const [hookError] = await tryCatch( this._tracer.startActiveSpan( - "onStart()", + "onStartAttempt()", async (span) => { await taskStartHook({ payload, diff --git a/packages/trigger-sdk/src/v3/hooks.ts b/packages/trigger-sdk/src/v3/hooks.ts index 49822b709f..60e733847f 100644 --- a/packages/trigger-sdk/src/v3/hooks.ts +++ b/packages/trigger-sdk/src/v3/hooks.ts @@ -12,8 +12,8 @@ import { type AnyOnCatchErrorHookFunction, type AnyOnMiddlewareHookFunction, type AnyOnCancelHookFunction, + type AnyOnStartAttemptHookFunction, } from "@trigger.dev/core/v3"; -import { AnyOnStartAttemptHookFunction } from "../../../core/src/v3/lifecycleHooks/types.js"; export type { AnyOnStartHookFunction, diff --git a/packages/trigger-sdk/src/v3/shared.ts b/packages/trigger-sdk/src/v3/shared.ts index c37dbb2ffc..16db25867e 100644 --- a/packages/trigger-sdk/src/v3/shared.ts +++ b/packages/trigger-sdk/src/v3/shared.ts @@ -90,8 +90,8 @@ import type { TriggerAndWaitOptions, TriggerApiRequestOptions, TriggerOptions, + AnyOnStartAttemptHookFunction, } from "@trigger.dev/core/v3"; -import { AnyOnStartAttemptHookFunction } from "../../../core/src/v3/lifecycleHooks/types.js"; export type { AnyRunHandle, diff --git a/references/hello-world/src/trigger/example.ts b/references/hello-world/src/trigger/example.ts index d5fc96ecad..ac8917798a 100644 --- a/references/hello-world/src/trigger/example.ts +++ b/references/hello-world/src/trigger/example.ts @@ -507,3 +507,24 @@ export const throwErrorInInitHookTask = task({ throw new Error("Forced error to cause a retry"); }, }); + +export const testStartAttemptHookTask = task({ + id: "test-start-attempt-hook", + retry: { + maxAttempts: 3, + }, + run: async (payload: { message: string }, { ctx }) => { + logger.info("Hello, world from the test start attempt hook task", { message: payload.message }); + + if (ctx.attempt.number === 1) { + throw new Error("Forced error to cause a retry so we can test the onStartAttempt hook"); + } + }, + onStartAttempt: async ({ payload, ctx }) => { + console.log(`onStartAttempt hook called ${ctx.attempt.number}`); + }, +}); + +tasks.onStartAttempt(({ payload, ctx }) => { + console.log(`global onStartAttempt hook called ${ctx.attempt.number}`); +}); From 83d4e8a3d3cb369dc510513ab5d70c38cac76296 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Tue, 16 Sep 2025 15:41:57 +0100 Subject: [PATCH 4/5] Fix onStartAttempt overload types --- packages/trigger-sdk/src/v3/hooks.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/trigger-sdk/src/v3/hooks.ts b/packages/trigger-sdk/src/v3/hooks.ts index 60e733847f..c6811ca6e9 100644 --- a/packages/trigger-sdk/src/v3/hooks.ts +++ b/packages/trigger-sdk/src/v3/hooks.ts @@ -42,8 +42,8 @@ export function onStart( }); } -export function onStartAttempt(name: string, fn: AnyOnStartHookFunction): void; -export function onStartAttempt(fn: AnyOnStartHookFunction): void; +export function onStartAttempt(name: string, fn: AnyOnStartAttemptHookFunction): void; +export function onStartAttempt(fn: AnyOnStartAttemptHookFunction): void; export function onStartAttempt( fnOrName: string | AnyOnStartAttemptHookFunction, fn?: AnyOnStartAttemptHookFunction From 6984903142e2c43a571c746eb3b71947db250079 Mon Sep 17 00:00:00 2001 From: Eric Allam Date: Thu, 18 Sep 2025 16:54:43 +0100 Subject: [PATCH 5/5] Update lifecycle functions diagram --- docs/images/lifecycle-functions.png | Bin 41477 -> 28982 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/docs/images/lifecycle-functions.png b/docs/images/lifecycle-functions.png index d27936600d5f08a20434b9224493b9fc529f329a..7aafd3faece97231bd472403ad724a1246f455cb 100644 GIT binary patch literal 28982 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 z

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 literal 41477 zcmeFZ2T+r3*e>`Y0ulr)APQ3aRH`6KQ+g2)F!bILX`xH+O+=Jp1?e3^XwpTRfC_^2 zgkD8zfY3`q;5_j=|DN5QJv;xL**QDAb24LjOP+c^ce(ECPPC@FGA)c520;+5%EJfR z5Ja8}{#2cz1a~SN2uk1|YPW|*9uP!xk@SZQN>05DZjyOuE6YQrJy(~(#c4Y^xEutP z$I~2HQ9w{uvdRNFU0<@*$pE*s-L%ESGJyow3)CuK6AJ3duG`^HRW)22ycVhA-J&Nd zGPw~opB{#Cc%bp?(FdC$PYsIk+(9YR)zTH&u%%?OOW#~#lcK-t%T?Hv)BL(ILg6G} zeH)!`_vy~Ex>!w^+q*xnin~&Ka{}iVCH>PqWESr)E)h}UHxE-6ga0h<2c}QYJCtAb z4`@CfRbiI4ulZajZjwaYN9_(K){s8#=t;kCt@G}ksF08|>Fdy+?A3cBB8*Rd>dejg7u5!B zW{(RP*R8A)xTb=nB%Sp+8ngFTTl8T!(q*nqEdf zPm1KuaR8T$+GVg=5TqM{PY6EFekE;=9w^rjQZ?CKcn=Q>aPoXFNRkT($!yaD#+iZP z_=5L&g;4HQPYYU%*jHyJJ%ljmfiVP=Swrik>PKcH{ym(o(qisIe;*-hl9n9?=M=e0 zh#}6-cj}jS3J3q41i$^C$(XW2dIuaDol8b~S(E17B4_b;V*x!58^PHf+j{YG<7z644 zYuNv4;QxzjkUa@O@Eq&S$0iNF(fsBW-^Rwq&OYq=Q|ICB@^s*bva&M*F#tg?6gVhC zIs3-O5M2`WPRkWGqWAAuU9{^N+1aTgbLgLb;<%9Cv3UDShkAy%&75`45&RUiaP9Re z*@(f&lgJE0;09rN(>*0A=?;f8EW;megHVwW7caiPEr#!pYQFLQ6jad{#Q-sm2Wc4J(PKe_niW>`oSG z=~cbOhbk)S(l0el8eLGA@LYPGSCUMCL3N~qC97au>yk!$)`=#3a%ALVY+M|rT(81Z zx>Wtz!RDMks>Fn9^;`7Cnt*+BeH9{+m^8fRaniK@#Ver(vBn4eQFvzt2H?h^glj$t z<8YhuTNJI|{1Lks74rH1L7^sQa?+Vz=IG%@WjgmQz8E@MS_-+U1S?&UpJfeCIWEp% zu^%DB5zp49fmTB9kfQ@675UPHsL6PM>nBSC%E6fj?jeNt=v5H-81ut=;{%6F(~LwKQ0MizX>r@mwUd{g4K01qvn~qi<8I#- zd@30FLzWh3bbD@?LgdhcxVX4(5j`)MY5%!`{6b@wQnC<9H_Nj5g;m-a#})z+_;>iGNYp8 zepG_+)t8J)jF+RL_Kga4U#0Av)ud?toILfJ$gOPpdDqyMes|1Zt$v7AEWA7+%K^&N zBw3i`uP+(-R-d!De6ntj8+9yeOt?3R-^H%|es#NMF+HH?M|*q8d7c}LgRWa0Z#pT& zTx*Jq<>@mc_Z+J4)@&baUZlWz@UM<&S>!O0+na(GWzCG60_)7YFnS(Lvs@bKRbo@V zZGsuCOX*SpBrzterw*>%bD3_MEN$58Y#1Ek!`x7Eq?tofYLGL>#xz)d$QCTlFB~=x zSTp6&i?uY>8Gnp)aKGL^=gm86diiUsBCvbtG!xfGj7!tu0>}I3Jdf5U>xa$#m-AA$ z9i?5hjd0bWA4c>ewIT(p;tQx_00< z^Oa9uWyKXm7TIu!O0G6oh7syg{K&Are`{ zWD&??ACCHz-{&=K=0lOOnEffQU$xe$u5D#d{M~MfI8rLo(U`mlefU6@Y6Tu5p=UMz2Q8 z8(ya@R2|&hay$Md6hM=%F?*b3mrfnrJfC1v+|SLhymP<;2rbwwsKjGRAsFl{)1gEDj0 zXId16ky8cewk05I>9vI}=%TVFX0#I4a0O%Eu05;T+oEguYN&(9la`*IDoBzhNb*st zT?Q+id}4S4{?YRkBw`d6XB>P#K7d-MW2jQIjUdE=qUvI95o@?5C9l-}C`*^jXM5o{ zdw;fd*<6M%lJASb=)n?FFNI20rCv^=qdB}Fu~lmzR039FT$3;dzY-Lrj_p_L ziZ5-e<#9>TlfaJijM0fiz!9(_*@Dokd*3cuGLQW7$;2WthrslBs-Xhz)RnFy|X7&_twSv-B7>}_C36@B$sqPBxXb)z`l@zPa@`+cc3@)`y7=g+k}kFFtzc$Vg1-lEnT`OV?=0TF-n})fw?NCjW4QLN>EPv(@}SM{OcBYy zMmgKDixk==?Zfjj)xGK+4#bU>of^N<&XmRTZ?j!@dI;I>sSdbAc?&>k}*nt&g7Ar~~ z=W?=wNn~tjcuaMfHE#0Y*9;}yx0HSFPX+3Q9aVJcQw5p5x+5LjiO3otO0iU* za6_5pq;)E9aDCFmnZ@>y&&csg{-?`y1yj@8=>hBIVPRxNr`fFxhhXU->`O=3MgyHZ-$`vq!{PLe77s3?^`zN-x-kwx1$i;7z^Dj zK^}YF_q>vYwq+N{HxDwE*t~N@BKsF(hF)zTzpKP|{8Y{|7k0hbBm+S&zh^2zp@zrz z&a>-s$KjtoFW^sx*;w*9L&&fF%LWW&SX&$#pd6K zu<_%R)nEByz2`1fOVyll&%IUDb)6=7y4>1MaAiBq$3+N|B@TF<1ujZxDlkcifc2qLaWBH~*Y*P1>2u3}7eru_<()=25%iTJ} zgWUmf#v1m(jTTEIyrg*Yr(l`piTUj*zN#UeUejG7zm56f53wez$bqMfO4YbnV~MfJ zN!DlmEiH2Oz%%!-(q&Me4kjS=#(u=ItbH(`GZaBS7jqef4FgyFg-CV~VXu2q5DL9< z7I7NtPz%$&UG{z3xa$T?Tty^DV0bavLQb<4tJ}w2Rff1${c6^MQMK)wCSegffWu3o z`sSG`f~Th+^LX;z<9kpL`UPB>P+sTGN^VR?g?^!N7g znWmzn-a&A_CukB#fM@LVCCc>uaB}bJ)@GP`}c>yKF9( zXi@88_DRbBb_0L^{1QqG_P!0|!6YcDLXE`gCQ(P}DcD6uSP z9Xo!t!KJw|#6>z%qh#2LQwZ*J&e*Qj)kCnC6s8>$*gLM4&CUop*CtaJ(U(SPTl|Q= z*dB4nAj@dasM^@;(zLjXfOt>wgmMFCE|gOLm0WD7Dhi#cgzDF^*FNb-ewK?x%jj6y zkJp41Yvyv~k2Slo>xNih`v`2S3>{UgpS_g)`t&mON*;gQr>1qa7&yK`+xKTYTe@m? zroB>3q#SpZI^4}O4feyhiJd7@170SG(qu~)UBArBz;`u@yckKp z+|fZJoJINigx?_x0`owx8xhYY zbwN0Qm8kcM9K*Sy$BPkHa#X@R(Sw`r^6uBwz+S;(QPHv5_t0Ab{zIn;Uco5~Vu`FQ zEVQSVkM`$MsJTR}q}^sL`xvf3FG=1^kl>HH|UXH^q7a`cugN{K%iRmn09NkPjeOQ6}P z6ftrBA=)C*n9K)J^z5DY2V5>h8e=XaG;{4U)I{?56O(@<4(Eq{Us7woS=w8&SDVV& z16>jzdGcTqN~p%Qnqxm4pK0NbGV}(ry@>n852=M4214VXoAMBNmiZvjIs9uxhOnxO z$TwC#=LkfQ2WIG$?1jJM|0FD5EF-U29Rdr%-xm}-_pI&B8=}V`entk-Qv@YA=9*%P zQItA^{+VZGY`>qZk)a)#81>t_hQzC{I_FI7L#Tc)#*fvKjb&a-KxFevhH~_)_=Afj zU*P8~vqgRa`KbmTvgk+7hB9!(NbtfZ%Sb8_?bjau8oe`ThuwIEQPT@QV#O#2iTQsao&@q!zKy>147+n>jagTzzKnVqwO;6uwGG2t zJq6=sYYI!N{=Y^6f^79@JTRqIzpBD#)fR)y#q4y z)ern-Z^`!1#Ml@BR(O^*!-kO`O3MEMSc%?o9|DjWqv;a)u9Mb+t8PdU!j=vSy-tG8 zSXfx}cHep3GLnb$ti&C2GGSeXwh0H9t8<`GCsMm^LW6^Qv$thFd0f0$<2hQ9NnM6t zA#)gjlu(RjUjqH|IYU~d@f(SvX@@4jCn^S5AFW1~=gy$UD*E7~m$%nwb{w6f>moz^ z&La)@Xp)efQ=q4?y)hjmd$m*_%8W*aOmVS?IDw^z4dtx=?=A`HLGFJF5Po*{?AeiH z;`OAA@v{ILX9CzA3`!58vvX8x0$gw*OeD`S!wtA`G)`~cXxaG-o9%qHw5MV?ZrG#e);QH zS*OcV{yRuADD*eU&!!2NU!Iw{ZiM4`zqh~7B;1^j#g3=$PR-14Sb-h7OTsE?p0oX| z06?S>Zg+n=UF`je2b>82lk2~>_E;c@o3$52fw#DiQ~TUJ%;-~qYD^akGQF(V%}r`y ztJJwU`@f6XNy1kGd}2kCMg;#C|9>n!QUw<8epOA)*xS4=r_HxFYwY{~addFFBOITU zbVb5vJvHrqP$vmhhamKYFb3!~5`gvfGeQ|6iha?Qc56G|9-Oo6lk|*`6Jt%_H*o>@ z{OVx5OigrjB_$-wPujWigj*)IOr{%GBm(eNa5(%*@;ev7B?6|Xq@-J#P}e)U#Fa6! zJcv#>1)<`lf&c6Wk^m(|*i#Z7D-2eiWc@xRxQ6X;n($_zEm5%`DEesUXOIY2e?)@+ zt*rWeq($yKFa_?BdaNeNlaa1a&6CaFmYFQK9xdJ#yDl910S{W&gufStLT{}laoknx zUJ73zs)|(H1v#z~0tRUs#B&*ajiA5#iwl~PO>42~ zz{*K~Y{~tCx}&YG2#3PjTGG;TYr9Xd`3+1o2(0h zcj5J9(CZ2k+zH^GYa|V2?6;hkxY{i?eOBIrpF0MXpi`amy;vtqw;F{Vp0>Q*e5CDG z4Ak7EzawSnGY{NUEXp&cl)$)6xwX-@;39|O#6>3cxb-p{0eA;QJv3h)Y!Nz@a@VNQ zf45=3jmSC2jb7d*otJX!b|=E#T1%)5%1;-mSF$+OxEbaOoa1s_QG&1on?*+b!S7d# zH8RF21b|JAjJr0o)~BYpeBn7L6f{zeEw0f*>lzZ0U1e_o2mN!ZS0R&$J_8L%x>~o9I9%v6hfD2bNk1J<%cq=()`Q%@@r@9UL**GzU>V-oF}dN z_6$%*q0c>5Mc!0Zd zwkdBmxbpj!ph?kUJ~&V`pfL!=eU)QQX^~&|CZ!UX_7rK_$bT>kcu38_+%NA#CzbM6 za0M7LImw6ATj*uSxOnvFVSn?SC|{%pXN{iz??D~iF@PvbeKmjqZK!?QtXyX zMHY>mmGDvQDh?NK*3)&n`Kr?i5K76i8lhot-k6p9g|$=uMUzjv__x#FB)^J_K2?a% zmfrql4h~t;zgzcOZ^`b1ukOoMy8-d)Bl+R1Wc9k`{FDV+&G)WXV7agaSd~8`vnu1` z`NPEwyJrB^8g!@wx&5Sf?b9OQL}giK$@8k4_Jq*6kO0E>yqXV(7Pf_3B$h29zX^%tNu zHQ~|!H?!vzkKk}4HMLh(R*ufj)jvHJ&qARHlGUt8z3=g3Y;2r5kH*x|BqfbxJ5ezt z2<@(r6zl0Xima^9BMYUrCo`lx#F6||P-ZeoEBHwh4{|aSbh|~%KUF?=> zNd{>;n>s+yf>!s)NI?d$Y-%OI)O-?L;`}yX(-n?OAJYP+iDdcisAotsK6^_eO)zrI zNU!<%QzfP6D8SbCN1r6xz>uie7`@ld9&CT{q8%+1YE0rFT;TZ_xG|+-^2O6g)1$`s z=LJd$#N96~nf;y`vGL#A04eXM?dW&`oV-?&&4N45{fMoxZtt1d z2iev!0GZK*Tjz1dNFV;uk(=>)1~dsw8TdD{gDcBMLi>bd5y#cpDE9K69`&Nrz|XvW zRjCaNT;Icg8}s$e0G99Z`t%1_9-C5tzdvx{{HvtFV%#ICD+it%>i}peN-8D!o1%Q} zLnS7at;mFC=W$v618@rdZDy_G&Gl`3+;c+0CCBzS)}%w%RDu{#G@%23dnwb-^0c(% z5RD<>Qo!%pB#9k`T$ZQX#+%}O234T6X_74lLG;k$@9O6E8c=Fvul#*SA^yo|BO$DK zA5U=YWl`O&%cmJ{4Dhk_BY@cJecU3DgG&q{>h_=ON~5~lqUd{5qy=J7wj@%H?BSSz zdEH8Hd%F^ly2!^hNzSiI%<8?@rHG~NEv8R@-t@pNU&)!3&bccr{3Kximen#rUhBQAK^J`gudz>d-eVX|9 z!i)R$)(AjTeueifU*GsLJ8MO9-}N4l61vS#H)hDNtE(_dG5_PkMQ67SQZ$0eVjf7~ z^Dj%k?{{Pdt|2H>U*EGV`=`KPL1ZOaiT_OaM2dd6721D)ukqcyVAAj;y1Kgh%1ZD5 znGJ$uBH1t%V-pi+Kf6SJvzlL=T%1n7e_csQPZveA2N{$krBGxvFa0ACwDLYSK6cBD z3|cuwvh2bXsWdYChco+wb8~>MWsS7>Kd?b2gLYOBAS%j;27vz z0?0|qeG!LuGVGOw&8(FkGK3D!kiBwve1;HYe;TZ_$Y$P<`uIRiYZJPnA#<70wE0O_ z#PW$BmMMHcSa7?L=(ci^aJ-{T33Vg-T`la@#LN;74@blEU5$p=9u*D0jcvZvAhtP2 z@AR7sH$KYFCI%txK)ZUogc7DPvAc4@6E|vgEnMrqHcbVG1zFohO5O2#YYEFNymf3` z%indn|Fd!5W3RwNnijP#iQQF+(>jn>(frG)B0F`qkYOnE?aPw${E_(N3e9^M%Y3Fye5l5vJKZ+pU9xa%Qab-A7LJ&Yc0PPXwd zjvwD`83gsc(2ekG$tWp7TxP_43HIJd<~TSdE0y(AAoQhHb8j=ExoSmDST$@1Ecn`O z&XAU`$`Ern<*k*YcYH-`4{{hn$8RrJY=)eOoeeylDWItU%lwBy$x(|h`2kUl-LYA6 zgbvIemctb2=-l0g)S1>Uu^1ml4;5R3RY+Kaf*d&7BmQv>r?%1n448^G*uUe-Z{3K9ll&$67<_R?>t<>1?n6!1? z=iLdDy@Gc#wGusz&eKWa=6#YOcXnS{`giYBEgqY2qScMcmq6?FAj}ERJnWIcfwo7= zt-ZIq#l`_G<4hhLHMjEW7Hz?C{Pn$`&BQWMyn*XjyUz)7=5R?3mN^6t=F0&a=e^y8 z-|X945lI?rlS$EaAt&vH`$AURIFFtjK|HZAe&M*}5GZKI-J5F&2cgVMHBO_C6D@-4 zNc@bcV8UAJV7jE=02|2YaKw-pAbqCB3AHBeiH;{96NRpaxEAc605hf|!%kx!scA7V zH2>=CU-u!C+X7)miYsFA$LOf&EMaCP5B`F4dC%-K4Gqk^^fc!RGYe&nUyuTdDc`x+ zI=_C&0sCWd;_(%5PVVq2H%jp_%6gDitTWMA6&rsg#&>+L&JWifIgl%e?;USCcdLNG z!pRIFTkXehmt}>P+WsZfq9L+v*3?kd?2cx~hz=zuFZaY~*ftgf7dt0j3SM`quj&HY zowPLC>YoVS<7M--c`8;r`{M#tG7cs-dHBaPVGNk+U?M(qxdfqX0SGGD3wpGL=CB;} zThaJEH3ZA5x)ecOQ-OKNyI2DVCkChGRU-f;0;|JN=XobH9EW2%Lp# zo)5?v7{*X4Su9TaOtYTu0wJ2Ty*wZ6CB4*+<~d=He#y$gW`{iA!}-L;oowN9`g4eGIVt<^YZdC zva{QsQkiP-t4zE1MvB>`Fz8;}TX~1-R^&ISeB1fX4e z_hNIB;q;$wH=CNSAp>?X1`(XiO~tuhA}A84?d#W?d?`C~pUE$NI7XJ!Y9iyVp23$f z9*Syye;y4;0>a(bzCzxj+m9amXP$2 z{g}Yvm0c z1KV&PnK=d$ubS_kcj|D%5&1w!d>+$QDHA&S;_st4Bo>w zW==0PbC*sp$rm(hOa=})K6&!Y5{5n(!Ay1s&ER8c`IRmB;C!n+qXU%lS&-LXX4*s5 zeJV?#d-Bht>YVCx!$8pr+*}TvxjvUL{$y-;Fou$f-2tUfjoH`~3wbhkLU{8ic5!+H zXdLb{$T}pY5a_Ey##m>NdCWFP6SWnRRsHhRfIKbFxhzh}{ppj?-JP9p!KE}Oq;%$N zTU11SL3f{BnWoBYIfF{h@^e2AbJr=8($8!0*!@Vnj(Umpoh=cn(!J|O*+F(G(TKDi zWA2yE>nP)%4M~!^VVm7bk|AU~CS)UwgV^$db3XXS*-z|=4IVxvaYt$M9m~v^PWLW# za}rImfE!tuNq;|d1+4!ySdL0{_LtY%EmeKE4Lb|GLOMvks{FeyPsUBNgqP3Xp5I~dIz-r}v;d?yJhAqcRtXY+U%4x!k?Wau zravH29lcCm{t>A~(KqgjqgN8lt4kVnm#~}f*iG#x+3AK}9)668P`AWAs)0rFD}|JL zIfn@VWDxgW{g}1MsH29OVP@i#djDMEchZ|?dVI2NcXOcD#*0MNk4J~C_1CgfdQ!yp zzf)>NYE$S#7!ZmD&)1B*q%bMz$@0V?41It3JL0Q8tVrnKIG<~=e|;#Dg*lVw+Wo$1 z(w+|E)&J zv)N~n9RxKXIrR8Vy6<%SQ=NTE6QpIn+NP}Rkm822q;#yIN*-l>Mo-LmNGjfPir^ma z4bpzqsc(m5%u=LZJd77hX*}9GIFBIS&%$g0k|L!{S=~aBK5SY#avUK&Mp-SSCl9x7 z(quk8xVg$%&HTn^bC_2Qny$+TdP0-bc>+=c33|sx_m3xiaDvbW09>yIvY#)=uY=`$ z!~v6R%<~)Xw&34mug%S0eS1m6?sIwH>QP-9$|2@?FCZOyt@q!;Yytiel?;FbJKrL# zcYoe%?3;J5_{IE^&ppmV@zV~@C<{+g@W#uTQQK&Y$8NqPLZ@XFfIH=D%`#zFWXSS4BE93axc&|v7dEYQmaF->PC9+ocqD=5~ zetQ=SU#8JndU_LAoUuvm`q5JBm$1gyO0OspVa(dMe1Re|I?2L_C*6;T{mMOS}$80B(~Cv|yVBv#t6?{I%kxiV;@ zg=+B>Ae)MvZqX#C;At4j28qj@rd(s!I}t1-G^(W+5KcP!Ox5S9-`Cy1ynilJwzI9o z6}%NTD=8%-_GpnST?3}8-^JKy(3>iGTuMgshLZbW-DlsXu|R9@OzvS&*<7vD2mT8G z{nE5bnU4o73iJQcX};4AX*;r+GScmy)am!$VZ?X?cSH(#r;)H;zpY-j@XfzasrsWa zM%8c%V`ECLI~^He!OwS(7p>%|3Ka7jFQSSAx&2KokC}K%bCD+idbQKnF`N9HZ$htm zburzAC~?R5hG{7Y$Ks%gutU@k?rN^yD={*#k4=^3Rz*^FJvz? z!g3HRCRo9jV>|^3y4fOma?SlATBE@^+Uwq;MNH-$F4-(Dtu&c|JJ-I44~>tf?Bamt zV}|9NcRg{yMk?;#EV+q^Lr8=f>wLbIdmAb55fUO3G?bE>e&x#_$H|+!H@#qa#y@oP zFI5r;dS33aFk<4AGMrx;eK9II$(brJlQAe=?V0$x;7j%a(3LM$t*@`P!~hQXWA2GL zFLS~{8SpG+jdj&haGU(7MvQQE>3797z3e@$?qDVxdFQ+~1t5w*$Tz_ZC_`e(5>?i%QF>e z7?QggHCi;{!wR|l^%0H3Q>P4l8ID%gu4G)4@oRR8cq$cb&VKG;SSQfC+~XPPgt|r% z9d@7L=?bAeCY@$M2&tSAyhxjJ@Dy4GU;y_x5t zY$HIeke4F|WYUiOx(Tj`AdtO^ePHFbQ#MuXcLLwF#=Q6fZta3hN#<{cb0;$sAvEda z#&Efkr9XEl1yA*TVmK$m>|4E(GlA0I8GLlk2D%RI=5NtgoC-ZF^>m(|^Y}+_^P0zA zYz<>g=Ov>&?j`9r)LGLR_&zAJpC^X*y#Of`9QQQZXy{iJFv;3qrH^NU(APn*g3`7} ztF`Pn@-vMLo811SU8p4N`|Fo*{32OjAOrKRw&2>q7E>|s^NV#+=cRyKEMZ_5pF|eQ z4ZfRvCcH4n-i+UQFE2rzppAV>c-%EGgJB#Dn3+uS@SfmYElC>O8``--X!*spbDrW8 zhp(Ws(Ui-pU_xcmaO6<1N+O7)9r(KzEWQ+8(k=Vh%u1`&D@Ay>zkD5*X$3+i^n3Zd z)_MATnV-Oy0VP_J zuWPERE;GMts*n5r%Gt>iAXyJDlAwq8AWP?sM;CJRW!~ZM4D`X%VUC!gP*R)-DU#Cv zA}N2<{|@B+KGlZPMhp9!cM!^C&@zZApqHXTQqJthTjUaAcdXPB`Dv0jP#XWNyrUG< zE?F9w?-CN3xVQ(ZYpRxi`J4f8#uxyzE^xn(3&uyMF|$|plnR)j`>od282EPW{Slo# zsrRh`<4^9LBLuBb7yuGN1(N;ue@*{?{|_kXf7OS98o4z};b;=ZTIKL=cdxV>@Wg9C zcws04pkdLMVE05F_8I{Q``#*4ad=}fLYvq>%82%ro^OzZWnP7y<6V`2<% zIvh%Puci|Aqc3tf{fiXFX4Th^1K0LVUC92<&IkZ%i|o1eE@Q;2oQx`MV_C(~?Qka! zO1O8wu(*T-NLtM-kyT&Fw$k+v2ms)waNN>vcx!g6^$t;6u?<(j%hy(?1XMYqmi81|YcZR=Pm%io2#kw&x%A3wvf82u&iNDmZ9go@@*d zBg%n{hb&0gpAB~~tjiKMxD5P=uh6&aud@r0z4kX197+Yn?^a9$jB!rOLVcH|M3=jp zNoiREb_2Y!tjqiUf)YrLnuCs>X=O^D))vlt`fp}_!N7(4X3Qx7j%GW2U{%jw0b3W zJiTYZIKG?oH@@VoH@y5d8MmMS3OFriA0nDk=&cyIS;H7;l*<1iv|n3woc@mb+Uv)1 zJi>n`XZRULOPXBZY3*D04*zlxpg%OEJ9mLydj0m_JD+nkRWDQUMzuFtwrnZ49z67) zKJ4)!4TIyA%!LK9;JFL+fDN(Qm!+`hdfc6HK`9JIN)`UqMjIqh7%VXY1pj|;kdkEJ z^PjI*1KJ3D{(n~7sk76`N96=qIMEsO|FVl(JpD^dN1Z=xY_!FXGzGOiZ!IyZ{jq^_;3^jQBWI_BQJFP0UAT`&DbK?89}naZG4cC;#}n^;06YXWDqmUF#T=> zmMT;5^niGtgnD~CyBIp&Rv;BnDG`9n+rFznoW+xM#L61m;qmzJ{PQcg{?XA7nBkco ziQ4&81D{U-M7THX`55F;JTjyRtDji!xmiw0BE~MJF9Lz8vFly`*7_*u8mWNpGqylp zgUg72f4Ly)B`<{8SA<8?u}Rveh&sd8zy2&WTO@q5p9U3psdaq&y1(yM1y81Vj0reT zuTRzs5vuMUn2i@ZO92hyb`>2{s5wU2&4+gZ{hvExn-bs;!48GZ&@J`nC@=6UY#06P zp}8INq{O5PyJp6+S{Z^H3;ww;wL}p8&yZ{^db+5_6%-cM5qak&K!JDrF8MHh>n=I-`3Ppr6~=$Gqw5`l|9NDb zPAR1+b205I=KTXMCSrRCAYwfxkS{&R>J^U7$4H8o9}vXLFCo^(rZW4`fn$_1JhmD_ zuVrpBpG5h)935R^)5-sqgj~Tkf*mZFtA%aI`;F_ zq-M+(x8+3>2(I+&cM%d^6`0Lo4zl2X=mu4c+u`kIT=pkyJ538et3y;mE{eywPiNFv z?@6rCB!?bOM^6oxqid8MWU42Vl?Uym*Af?YakAqu2zj-Xy>-xy_!Z2IS|r!&2QGPS zy!N(7!ODZF`eZBd^UHbf-W})Q#;WEGDqI|^9FFgp{pOmN= zTH`tguLp^?AxYyQ9SvFvpUtWUc^ZW@H_v}`WfE1z?D}g!$xon|WW((dvB~a1cityy z#?RT`jlLrW7u`sk5p!v9pW2^k*Y&y7M##j;jh8vcr!2lvri|#-yXVmK_?Ywe0qfLK zIXb{NKB34t8q1O+QPb~?_Q@m;Ob>*Sv(Q4CS4?GeDTnDzWit1W*UY|p{zHFa$CM_# z^Kxo!AR3+>8ND=(*vr0{tR5E$ix)R=_(H=ZP4;pqXMrudwTf-&^3p&5tbfF_E^e5q z1ksE4sB9l_ToO-8RP)ia8x~;*xJ9hj$-1BnfBL&diz0RJXNnOxLNvql%X4_L?q{-J zLKQVGsQa|+K#(S&^(#fl%Z4kQdESKFqn1w^YBQPYDy#jBd0MGif`Ff2$})?gmc!@ z=$2me+lk9jZxVNi0rk5+jZeD`Zue#*a?h{5t-+-Hct%KA`j(~()v0W648wCQ)h*Anh-cwT zetO5DOZTLU>(is{$g+50?skBRC*v;QOwEvpebR*!DlEr9QN``7$_vGAa^Nr{0%0ziol$*XrUVCu;rF%D3zIcnkHge}aGarTyAS>lux@N>9m^s=7t& zqvmgrZY-m6;+k}ZN5sXh-$PNq#9O{#685JvD4ktbGfKppB0mk3yH`?t)m)`EpAO*( zxi}Ua;_KyUhJS>8jFy1x>3}(68>SC6`fn)3_l;mO@uc@Anv9jwX{WIcme05+iQ5Z2 z;sO}yQUB(vCG9E4!fjt5s5=@PCEY}4}A5D(u8#%K7(LKDPwcr!@MP2bI_FcDJ>Q; zm$S!HM>yjUvH5}BRluvgP%lto4XQhy{}^(yH^gg9jgC4*M8t#NQ?Wk_iw+7(aengT z8yzSrZx9m|72o&s@u>w2hF0FJ%1S;%Hce-|#9%A~acvzGo@`73Z1ikLlU-rhlT6)tYe8&27PHQocerN#F zR6tC69{E0%l>~MFdY!-?(jqB{W@>pZ`IfUBuSGKfk9TNr&>B=>Q6ICq7|7hacMn&p z3;Y4+v8tcIoL)vFS01>}d?gFOFK77yRL#PoPv${&DI%q;-b}n@b*fPUyN;3`+^V9* zo5JtvE-5DZ0srPSR_zN-aj(cpshNbeh9&8j1CnQ|jWU#nOX`2|Hq7mDv9Fcw^%K}{ ztVM0-bN5P1m~PzZ=2|E8doRV+Bzq_>6PSXO#igaBD%<6J(29ho)`ls`q zmMPV-Jq6oyA6?n2a0p}XjhPn9fNJx8A9ARpx9jSMN`xwlKr`{GfcW%E>QxuA`9-G> z?UR#yl|9qELY{H)d_sX~v-9o0`?SxLu)R<5m?ztutEV@UCWVtoZ3V z@Cq)bcwRD5n$ND#ZvR@A@|3mgvo(AET|*m$>1bkAhRS^1gEF!Q?Ue)D4{A$Z`@tHg z1{Oh#^^4!fA`I-Wk@viIW=gl88pgOHB$iy?d-_HErlAUjo zIQ26PU4IL%J^R`GizC2KTnLV@zrKpy^z+KrnjV!OPE+%h@w^)+z~}Gu1UMYOyxD31 z&L=Zso1xKuYdBEFQyWbYy)b-?CG_KrYha2*X<^~_BJnj^+0$(#`m~pzh@K8Qap% zv&|p(wi`R~OB6MoyPxGO8rU5_OJWW!Y$7@nax03PPikg7079#_?Z66i=&w+iPwKqy zY*LjvxEozcpFLhYe@MG#Z&cQ+I|L{Kn}r3>!~NRY)w=pNwPjz4#>YwQjkZ^E)o8fz z%=D8l3u& zSum-{_Xb+xGRnPcD_p3p2aDd#TFI|E4L<0>m}irlMiazpscafM(VuC&KPus>=~y9+I%@R{0YpoTG^F)xK2 zKN-JVYF4j}tt_5HI`_G&!gBG1VfUGQeC08sxE4-LHophnO=u$142unY;9M|14p6=toJt>(i-|iWj+YN%QAyqDEfp!W` z$Ni_hznj;@*B#ZwDev|nQfp#L>lkIs|m~h4Cu71mn ze!&$i=4o|2Z*I=pJyuAQh1Vcw(L3!OMp%2%p5jN~(eqCW(F40-31v_3kHOS*DZhO% z;w9G;_4A?Ax{n)XaNqWw(Szp=?)W?Sx!b(&B*^a%*4`}TDYu}y`C<3_#+Iam%v`4j zt3@;Ai>Xih*mt9jFIg6+_J=gYMcuEBEk-9yqx6Qo6$uv|$I(v4N6BiuevNvLW9Dl` zVnT6Soph7m|@@O_vom&GPp_u_x(JJz0w#O^9QOQOo(JOk+Vi@(Bf6i zUGrL8d!Ds5Y~xUG$)mCYg-4yA)*&jCl-n2Zl?<&o;e{3Z(s!jp|Ao8vj%un6+kArx zDv0 zymRK8@03|<&deXP*5MzQu#@baU7qK;@9X+qH@A87zTI>i#N}348(JG$U5_zR*xe{B zBgAyqtc=6jGRv-g)cQStP5oh`|FC?Dvr(b4Ic=WS0#}}2=z9zIeDQnF_f38d!<{p` z_>c8m?#a!pu=@?;5>x>k4jZttPI1gHxKdbepvevyYWK|TGsoVurwaP)HFAtJs%Z}% zdTWhVY@&!|LDgqUGm>JFxysE-lrp~xr^+|rhZNIGDXW6UKEk4Gy?!$eLg&AD>^UO{ z-dtB8Gw+{-@mip+^YS*J7^QQZ?JE}l_K3|qlWv<$>6lZG!k8E{LSTFbsK>4Dy}X>j zB-Z$2l1lZ!aRZj4zueRy5;*E@{&GwwozA{k=)#T+bXey51~jkuUIRo?(*C10tK9b$ z=uo>&cWmWnl069*sHxRtdA35H`>?dOVk!G~DE}+WiQ^SIkhpyI;<$o768NgEsp|Cjo1NSD`A*pp4IwytAF?m6Q^Bqi1^8#*~BJPBl0L%sD|N z6$~F^i`aj)y{OvK&(o>0nECep4>Efe@TO7?#O#E%DP{GRcAojXM84s$@*=~=pa^QW z!c11c^qOB3w>I~m3GSd0+j19Si0UwSbcbMc(DEW5IJDjGA7Qiey`RiAe}4uPxAZG9 zG4yeT_U&Pk;=w5Get$!a^7glFLZ#PU9b8UPDV4x7(Fy3}_D&V^wQAp(R|uRIb&ptZjnj(>kOT9f+`PZfA8(8Gj8P`YmEtN^<+K(=iV5*K#Nam z$!O)<4T~FIxgzhGD4&>+gGEprJLXCrO*>h|EDF_dysesLNSsI$SBt{`bL36n`HiY+ zxaxbGq!jz*-fQd+D*<^mgORm&3)BE)rx>7n)26qfkb11XR%8W|*QYXSlvV2cm%l|u z(Wdy!>)IIFmek9;=XhQaE@T-6ie}%15{UZ95u#lHTIw^t*mp)TDrU1J?#U|T=_1{n zR~X~p$nlygZ^9o#5QF6UIB_E|7R6bdSA%`C6Smwww>P~WiZauMbGNN?@;lwC&?|fN z1Ho$LKN6v%#u^EWTvzZPQL7yX=PJLK+DzN zbCmXv7yO2z7xrfR`z3?3nD%tsHbg7jbie;2xi`BhW`*RYimLaRhKqUiJUr@aQI|~v zY7gN@v8BD~Pb}qA(QZ%s`3wgReI7tNvKYcwB;O~kya<+7ZuZ0= z3zwPoa#Xn`7J5`@9-(CCu>#!73Qk;{8nlx;UifOY7x>bd#LIt8%CJ@UJS1CZjmM5RIH z(c{Al;nQ=4mrs`WRzEng`!<6y*|POKQSOyWX%>t!IF4N%Cd8!a>#1?;^;fvi zZIV%_vRZ!d_ixP>wsj%CvrRRC1v-$~F%q5hPKeu&4gYD+W<3Lyl+sy$nAf_|MW%bMX-`}U@8)$Vcs zgGSTj0Iv~JsSY+gEiAjhMUpzJQWHrH9?X@<#MZ_9dxiA-YvC>*u42>baqd47q%k4G_&D1_gpX{u`gD8Kg>V`Xqe>%Yd zV@E)lF`DGi%}A%9WjPs*l6msv_gN@S-n(`4aLN`{sTGQibL>w}D@pmw+flx$ zCAeC^ygjD+NIKCYvs!{)0PADXaIk1sAPFJBt0kEKc4=Bs$%@GL6;Ai<6j&-@)h*jn zZSp%VDGw}!*4syAy-+q@C?z=8xO5L^T#GkC54aODw2=%RaooJ)zk6u)n8w;(nM3CC_9&j8$4-Jov(nXVPaq?(r`~`DiDZP|ql^T(C-4 zPu&3Jn90gpZx z?s%wF@P5dkg=Q{gr9PyA(Z_5=bZE z3OQ?W%#Lr%;K5Qw>$QlNMF{o6nGiG^N!!=?Q-c2L_4M zv_FYkyX#4hrN!((Lw(>h(fYfYB8_*g%kp;3DpTE#tWf`rkOR%y93qKidf6?`(A34fXa zQFKOX*BUJb>_TL6aNTG})TZmtfO^g}SN2bzSR1a0_>}-E2OedosMD63eBn>M{x$Zk zYfU9vXS?ow`tmTdNfjNI-ulp2hC+l7dOZA;f%L)FW zdzowm1rS2Ul#9nE#%yQ7PWr%`Os-5MMtokV8n-qI>AHh`2%46(AY zN5U=u>hD*oW;dRJO8G@$3DYPr&}+-krrgbbj1Tz0M}H?hn2`3pbkxxm*s0JuJ14$R zd!-liavY;wBudUl*pK=qIQo(1R~RlMXu1#xlatYpBhQ#HH=FoO=tAj9%fvu>lv^=HIWJ)M#Y!q~@b zPuC_8@Dic{!RODA?Na2;VMft14vI zzHLz9By^%b+We?`%_3k{0(Tp5&*&a52s_(*s3DkVei)cSy;beh4vHn52Wx1U?=y7L z1#Z^$yupcCNpj!1EKyi0HTz-|S?2L(`-i|MqxMz@Skra<`sGzd$(bu0C9k%b3F(+t$l!>OTc>C@T-EbeL6;0!R?8Mu+@ zOQ$HwGJJ$u6&TWTOvXm#7R_+%*c;I|hUS7IYR4;#&nvK4F1UlsXLd!nn`gY^^NB~X z-vO?j(LQ4+tsbPg-0`>Mm8(}&7@e~B>?_ONMrH-6=TU#=(;bL>IkyV%Z|Mq$Ijakg zZ)6yWYC_@RZ52gIbg=t1yS*$geYT;?|Ad^RYX<|X5{uNexs!xi=3p?%o3_Jf@MUp<2 zW-p{roYQ=6nQ2wh)qvmGdk$Nu*KCL`!729))o?csC^s37Qv7}(MOnk;ma!vEF6I}V zTXgT8ampTfXUWe~k~9nm1YaK~S=~f`pHY1p--Jdz8smP--`(?PaXd+$z<8HeYpju^SnDcY?hT+?HSW752-n`NM zxV3ls$*{|H-Kmx^>ifUsjqm5VKQOvZYjOYOZ#xNgvRXJ(&vc0yo{C>yFJd2%miIbK zw>&*j=n_%r#u%PS1!g`^h4S7sbjMpJAeM68k4^5d!YZ3FglyT3 zF4^HO_6t<1IirW%L(o9D1&{WduXH}l$9+dw_18GbF_#Z9cv$&nYXyiqknX}2MWc@g z_9d@$wljiCMFq7xJ1(a!Tk5CQD3mC~f$fUYTr!N86MI38%=DzYmzoQ7rB*b3q07&T zdV+@}lxHO3afn`$%ytX!WH?kJ2b|OEh7cJ&n#&qDgZ}*3 zoHqzDgQ6m(bHX+k1o=bF{Dl8TU1A|yyyrsS_OfZ#fxEiJS*4vh9EyW!tv_3E+x?k2 zrw%hM#t^P%A9VAxW&b|9b2D4CPy6e9QsxTb%&(~TcsM5;r#63|eBT& zZJZhoYoMQUhkRewQF))GGif~_l&}XGdtns7-xzjse><9;`VxOgVmrPcx_J~Eb?-wg zgEN&e^b}FZ{_cUapjV(7Bs)XI-7HDDAP#5Sqb~Zv_vx)RSwIq``{0YC>2{*kE;i1b zD%DMuhgdS1hS@%PId2&GM|BL~{a$u|9GBT`l;MGBl4#4F=3+`8#unCu5h`dc0)C9! zlj}p}tx6;vuBR*xFD^=cu?pED1fe3QjZU{?>0Ip*HGlCJvwY}MxWvyEC|T(3t{ztt zS74D7acAt)L|F@)d?zdF=#e=)E9(c}g+vB3n~lsHk~Q0f>jU$9%TwRGGX41o4|hIK z2>v;b)_su3U;x)*TJxeL;f5b&@ME%-m;#E1@U7mvE010@cF1pJA77?-x{9Sr(Hp9r zUWd_Wp<&zRAuIw(sEM4u}?Y~eq((Km=(nbZE_ z`zjutu)|qXXwRLYt!XlL0@IV#amoGCRn1C2{i{X!R%r7>E%>)5?Fsru<)O51CDZ!h29b%|C z22{9J`LVLKZ35`t5x#lq%`sTh^iwxhHlwk@`Y(}V43AliVzk(cuKBjonwRm^TnTga z$^Ox;8COx1Wf$kNQ^rXfK~AlCiLdVf+a>ghH(nUgm>=kQKQ!19_T}fEcVlurn$$X3 z-?u8Xw97wy-I4wi{o)1_TMj1oRbE5}OwM_v0$xE+oRgeXT{Vnv3O&o>1g2ez7ZvGT z_dQ^XP<#)NX)~h}msWV8>+U(ulzsh}cVtHc^?d#nbyWS~tP$Zvt<7w`cm0zUlQ+xJ z_=YVn8Lg|-6zq3Ajk*Khnk!)e=^*w}#$#sg2`9T}3C-~NY3QcsUm*jer1N$bdOj0+ z$v&C|LGc2EM6R#mS8~oPmDgIo~&=&oc`dEe37+K?fpGt-u!nGlHF#2%i#yB(|YS z)^SzZe||-E9E`}&NZAO*q%Y*!0?H6ZCWf|mUtOO0iY5yFqc)ywC@E(c%l|Q!J1o`i zp`>+^`w}^f+|aT}e2UVc4;%i+v9q#7_Vq!)kg!d#AqvYL* zCYMilxwjPDVdniME_eDXA_WLnIgwMt(TJ-u^)>jFuGR!Y`8o3`%0FjgtdnQ?{+=AN zfEKo4hHV!;4h{{5hXb;ey^Dh8Q^diwlDhz7R>Z|%^{kDz(q`2C4yyn1*)k?kZW711 zayB>5j^SC*Sc#`;j`-i)v}LY@UY0O%)9TMBok#H@F!0F1#TRF(G3QO*%b%Y)yl{lF z%I(yoPyYg|I(~bdyK3@KQ9F3XOi$-{q8ZN8Q9yxC+sFxuxZk1fj4~BaDz=6~!S=~; znHpV9X*&6A?h55!Wp5XeiSl&kf5!md_W-Kg;yUH;ih82IP_RhZTJ%jhCvtX+y1vrN z;LdyYR~9znR&V!ghJ89mnBnXjgV~ID-RS4gD@GZl<qob72rr3s#< zTqHFqQKXQcJX4xi@RG(pSqb&vSezzBbzawlDwX5)T@RfjUkUIKAj zNUpc>9!+L>x>*N)u>z zuxx0|XxD!&Y^T{ndq2TxhD`V{v=)%RniQ04&B=tYy&0C1nSp-Bz{|2Z>`+_o`Ic*R z=lJLFLnEa!nZZT&iF^Tl2X9+h^=kHV8?^n9tTP1YVi&e-L}_ zz0xhWGsotFw70Tly8<|<-}{4qeU(T3Y1ZRib`qD&4(&ih=8jSG2jOzMt`P z6lhWwMu|~dfnts85uA2V!X~1Nl@n}c!dB1yrWBNN%a5d5W#k6*~d6x5~_}1;6`p_oaiUgjhYZqj` z9Fe+=0%eFEWgm33{d&(3I?WV=YH=fYX4ixg7xT9!yy+PW!D(^U8Q21o|F(!f3LEiC zfpqeo_y~?N%hLqmQ=J(|5<~AwjRJncv~a#PpQAJD@S)%yqmGL(`d^{6UnJ9wgzM?4 zV9ZVG_aAotgl9gNeQB-d$w%R2tIbWsQQi3axMFZ>g=MNnK1vw4>^A&kNey4G+ZI^{ zBoGzyE!iX>5P^QQS@X_G|DA1R5HUbvmA_7?sh2x z`o+L9T@4V~iVJ=+z?Lbode5eOWdElw^>m^BPb9OGbFvHQjFYYYts*9Yh-ZQk^iEtq z{sLtxan@=Y9U)obzZI+hEm0ld=l};k*X2H-7NihtFAbO*!~oO2J((&tu^01`?v^FC zMzoGa(fdbmv}j6#)mrkOOqC+aI_0i{q%b}*6i zsV%Q5%Y4bGEsm^j$ldo7HEXGSuh%e)0n3XjD#3KUCGI+{&fWNfbr& zPkd-1S=moC$l^~H0gK>&g~1II+jOoywmli#?`iV4FPn8@MVlaBuFPJi)Y|oe4ASUW z(Bjmal!mhSt&>cSM#R^nn2!TH;Y^CxWF+0L)nvn(Fdg5d-T#(qK zsEL0wMl%XkL6FXwfmmC13Q3_MefPyvTkPgW{eLLHpY9qp`c9@cu@HZz7Nw)E0`)oE zKvo0yKvgrIPSteejDuZ@|F#1+dq(&B zZNvXlRJ|qeY2@P7(_+v6(#6Fv@awa@Tu85! z{_nuVd>x?3)ao`XedXNnDYnq9nZW*Ew#5F+PmEArFMfRbi~kSooBu_bxOfLZr7^X# z%JmBfFp~hlIJ8Jiix(7N(flfLp-b6ni!DtBEScc&lP$w`d76yp?KF%pdA$BJOVJ*v zDH#dSL$&1(ldH^Iy|+963wrS*7NF9k3!wvWVR;L7?Ooe|_4;psMTP6!j00#v_v!oC ziPOZ7Q`+J=+LsOvC5CUh99zD9q31Y$7y zjwA=DnWt+-CWI1>;;BZH%hs$$GO)B`N3(ErJ)iN~_sRZ_?7M-g>V8 zuAR5cA!3=Kh-^L@vjynN8ak)|^e7_@{Io2^@JX`sYjfIu^Zc=H$G{(!F}jVFudeW( zaw)~LUp;mD56)vu{-h2YtBS`&u3fuEgmP060G`dyN7IwwGu!6(9S7JtR-(8{fwRvR z(FM>;fy3P0&nxOd{)-;@3#(}4V$qO&TX*`o8;kx$OT~Y z{RL&GtEVuXw+uxuEsb!R((I+n5d?@c=LKLn`yAGt{j zW_5f{Eq2;wBCwif$S=5~#+&f73_sWUk~{4jHcv9hLvRJ^XBtp>h2P`z{-#Yod?WEuoXEt!7c8D-=zpkBM zw7!Q=dy*t3Q4D;D=~1IQfU~fI{XxjT8a;uGMFfwK6Wc30!y7*`AvE3A&olv34~UwJ zouNjYo0FN-Nj;VO0`yzW+Q}RDAy+4}e~!3mKn5!4=NfK77-t!h$4PkCy^Sx&B7=7B zsrQjb*&8?(2B3MZ;`^N%-UM;x2RrhejplSquRUpZn}N?BW9dMpABr+X8p_hNru)u2 zFqRsNA)eTY)r46iPY512uZx^_rZM`FW|K+(6wu4v5FL~E5D0TpSlPKYmO{_5M4N#t}Tbe(egtp?- zClYpIaq>+G6$opSuNMj>c7QSMoZc-a2?ty;w*V-)iVEPP*^qsrgJ57tyTov6KK!2^ zsAx?9UN7)icjzn$uQ6@-Resk!`{&3}ipgc*a+Cl(NqL}C(mmje>kq~?p~-I837U#j zfMV`8(=u!swEV4u#G**rVsFBQ1z6Q)0W2~$K@SWZGJy#PP=pa902eOL22cu4tinGk)8- zEkD2HO)-4lHVr16;ocp~=)cv7eG~374fp~@N{jV+RM0`E64{$_axV2vgMbKv2t2&E z0OQT(!7g6nvol|X+df9p^((b6F)HIx{6xMT;9la~w9?Sf7#a%(NM}LeOa=1ar%wt8 zp}v);saPTUw_c*5RDmU2{*{>fgD2NvqQ?OXquBP|W?<4Vb_Sr`iKiSNALk7giu|$) zoR9gt&|c%wAV(O}nfNA8F9!^%20Q6z616L=S9q!o&YnH%e?o2e{yVM0I*;Jg{-rtK z&NcVT=V>%>tjatS-NsU|OI5~{ZJMD(RX~9}0h3OcPCJd$YBJ8(M%Pg9y>4ewWJ!Qs zV#;n!t%4X>P40xnb}y{0t#$aV@kLpJQ%T+90o6Jcij_FIgsxI$CmtJviK_O;ley;p zo0I>vJ@h=r^_{4^XK9v&1USPvjwvHJX?ybVe(Rft@EUM)0??Ilg2pl{j_&A4JbB{S z-A!4UGtSe!W!V1}l{f2;2F}Q^d@6kmz0sjFvyWR;mzFPkY^;5=Qf^tX7Bd{y2_Rg2 zaPL+|A15m-sZ-V>f0CN7ls^Y#dDh#3fgdxQyaEFQ-KE_!Cwu@sfa!O)$7&d^bALj6 zw6O2Dn?=nEkVbhZjmF?$tDd!Qk;ZRyQVhf@24M+1q+8RhF|f6^K@XI^kpMYFr)A>! z-kOXXev|PtywcWeWADgA_K391OeS=acgINO>n!lHyR@Lfj{tjE^J$|yJ>M{>AfhPV z*JDA7GWX|}xC+I@In1JEwSpjM$1Zz8iuMeq=|R;AAcn4*fI)^A^H&DSoq%v2U2FZX zx=J>?s-Ga(|Ho zk%`21t zwUzEiGagN)MLM%RJ8Z*RoxYD5Ct^o4CbSEp)eYMUeje3;d09H9s6(#yvwb@Ma2=;a z(O<)4h-yn-TzKZe)zU)UB^8XGag@iRYM6RS%g8i-t%g@W-&+HOs@7i-VCWx_p{3K_ z&uXwO1WqALN57u8g43?B~w)=Q6*dw?LF~+f~Dp z0YQ4ygM!@impNW$xx2cKZG0p?G}aN3>~lKY5Y2e)3wy+40nsOL231v0RNS(7d2KcH z2&V*jPf*XPuE@(|f_D@;b&6IUR|EdMSD?I4WvIE%5Vz1!S+BO!=4gts<;|BBE)l0- z-Uu+yr-D0eNyTu}m_UF(u~n32S?>&puu4t?&n|1hg6{%ixx|0d%T6ZV8KaY3a_sXw z%TV#6@Yev$$9%xaP-hm%+WJlk2L3w^it0Qvt2B(-jFAGq=?nP$>5dZbz4T$l`*lJo8uDNJSZ7};q*z4 zyapv!c|e3(=!Qa1LDO}&IAr|qV=?q4VPC3^Otdm35xO)dePS`R9-^?L1ZOySJUFT1 zMTr8ji+eTyd%zg0Xtm0H<57%qlM?j`Lzxp`Cv>c>eqw2B<`H`G#aZ3&NTbS*XeU%_ z+}>I*DFY`?y8!ty2uAJ)WqQojjUCD-T=W(>8C$<-9ja6X>qPRv`;r{h5Piwd1gyvJ zWK-7j5Z`@qX@9-JmG{Y{ty5LG!o z(zHU^Ce-Bs`cuHmL}dr!H*gY6#w@hP3k83a+e?^N%v?}WvAp2i)|D9G#b#riKXx`w zWDa_^`>nGU^5UCmI$>USb_3oDRi7v01%lsxGKxUAs#LkAnb)AO!D&{;ulgVD5PQ9m zld3bxWJsC4Il3bA%(82MNZa~9l0%=?Jd}7BjhutXnZp?0BJ#I0<2%zXHFhaIgRs&W7SO0$T8zw`5wtG72z~Q`j9bT)bNZEYj>dGNbezFdv?|;X zG2*$k?AmYOA2=4mWiK0{(yWAYVUr{2+6Z^*5Ex7aOnj^Vx?UC6U+N>A>O+g5y1VTRKk%#q%=(_N`ibA-8o z#6>bTAOACJYEU&{4CExWe%50dGYBb7(wO0VlwG^8=cwCYBr!bH0XAx+m~L!mOAk>v zpJ0q?^5fA81edqatx6TmN^WgV?ikEH373C~)`NbR5I_(6wPwYYO33IViA2mrt!aNw zRu;N>+~P;cxl0+Cm3H(x?*^dz6@Vzp)>1gJD(fgHgP)v-?qJ0wt4SeOV6Fk+PN5ka z&eC!WBLW;75R1PRsao@6nfrqG*5zoEvDKNJ*@p9q-wm;P3QD-BayOmd@7$xvDk`ca zd4LICw485^?RCUlp>GPvx0N%1E=T<<{#jEkG4-u zEOkU&vCeU)O6IqXuE3@#UoUE)gieYnat1-@#I_q)UpkRn^Uw@unxF1l>+t%Lx*BdZ zmQXM;ro9WGgmQ%{3{tseh+0Z^h5|=mRg?(5Wr1Hg$ABNFPH(9E??idy)<7URjh2#$ zWBXHM9O@c-525mwVs2}BKmi8?h8PyJdUr0O4BM)O>>`vcDja7mHF`m+rA_~7<_^rN zZGeE*t@WnFO0aMJh@$w5#Lc01`kJ-{F;OIzu|KN3mCjP~A9F#5XUpvCh6#sxD$c29 zm$FO!y80Wdyv}Ycv8f4Q@>F!CzdN)0e(4`qU8ru~rl*f8j7$%$EnHiLA3c!BT;DX8 z_fR9WxRG#o6A}g?q}jBFPs3g#yL$S|p;0&Q>OL3>FdTUF-U~ezbDFuqm0R9N`{7KC z^9SF^oC_wG1DE#AKvtsq*VZ+xFXr@RQ@eC191M49n$=UL%D3yZ7yu0^u7#6L?>dy<+yhp*$M}K{6*+yOP%Eg+jL1veXA`fRquAG1 zg6dGlMb0Nt;mqb|vw(tKcUL{Ie32;Z@5<#aOZuwyD@;;@|4#NxKkvSAB@2GJ{%e=t zgx#JPJVhVA3i!RGvsx^d=cmWkVww`) z^GnlN+Ey+W$W#m7^8Way;>tR$o$rH^S0tq#A`s4I#@kD%?9(e2ijfqk+J_Me!9CT} zNTW~sdHTYEdI*i#($b~3h?L_5c7g|8|92Oh!R4|_y&GdVL5!hF(1psSw_99-P!yA( zq@P?~E|4TJ(2-e61{_ew9NUF|iyoBM-{z>5NIZ{FN8Kj-eIj;qqY6j{PqBk6#)n)e zZ;g)FF*BJIWeOC_xFw_Gw$I~sMtb*vvv;ildNh!&W#1}YN_in|?pW%%o0OeV#W#FW zZk>fOo?Zi9MQ=asMv%#T5kT9RJ#Q>0d6&_n#1SKLA&Ke6Cm7S5LpM&HyqZDG#2l@d ze=l5Q=QqcjYx$JnW87`&^lq^-f|yZ>qXHj{%I%pQ9}5m1{VD?j8I8)ChM$)9maET- z8>O%2KMJmbVp*7yh9{oW8^RgA@Ij2Ps<+01#~%rp7dtCRAeP!x1XI9*LFiF=4XMGa-rrO)QfvF zuCNh6g{CBAKLEDLNedQ>6t^%5xWVUe!<0k4gL%-5Qmp5|3K zi5Zv+gA;uL=5n8aWQ3n}xvk#SG@(=d6MBqjceMCOY@5NYtv`Y%}Gm+<8j^U4Df1oW=DdbzNQb#fERXBpUqD{|JmEW5 z4I#1H8V6x69;GYXc;KHT-hQCX*2u$GVR2W$G3fKNA^-6_TA15yVU-Hv&sS|cU|~LW z;`65?n@#lZ@UNb;eSp0m{Sj7|C%p39(KzCq;R~fJTTSn2os0PH)b?IS`(}Qbyz+oc zdo^UHhr#xGpiuvfVqQwCP?Z1H2*+Xb{Lael>8#LV=7IF zlwQ0DE$!|XHfWD}Zl&G;EHdzlTU6oj{Sl5PYFrD|ym+0=q!DsdJr^Rohm&6V|8|C^i_T`#Aw`0!PeZ$ zd1A0px;oe_2RT{ND2TqC)A;`DKzwkwP4Qrp(IQz{7F*Nr6jHdkF_we}{ZWY}3w><9qn8!+(Ix{gPZCR<|iz|71 z9`)=1fy=^uxL%da8Az%(j5<<$&?s{?!-s^i#xWv_UWyQrqfYx>$Yr zi)}9U(@)E@(JmmP_lm(erDt_l6SX}I?}xuV)tc7LbU(a&SgWSf%iTfDo0@`8f7YH& zBsQm9%#D)&@o2Wz<8jrY=rtW%_Tzicj9A~eXwJx^)}rx%iqQ@X(^u+h6sti$6qTa6z=(5sxs+E zn~r-}$9-ga?7n3S`%18%i(U^M%@Do6g0+*vNUuJX;SP+yIp84Ro)csy<+VVl_po=u zMHvYBJPbe0>@`eHwKUAoMlhTZTv63#sT{$v!n~`*Z;{khLfu>^h3F07CzH`0m{|i= zR$d%ZX8WMe{JEoterKXr7W+i(M@e`^>-LjF)o^_yW!Bu)Etl+RL0732({f_nO}lI+ zIbSle=^Splz_ku-UeVO}i!fWBKQ%x2z`=PMw zT^2B$k|~3cV04o(;f7tNOG9=jHXU>R&w1kv*5yvI-sYO2m~$uiSs;BY<6GzC1Ge-4 zISwJCI1%|lR-dZTpM+t(#D2XdDLmvDpQ|uBrSIXh(iH6Bj<6rBojIrXWUy#z;2w8u zqX_o#roHv%)CqhBvG>xcw;7u7r0R*AbUV8j8e{N`f z5Fl?)*ozAf4EN!g^_Y&XQRNCMyr|tM|@+Ze+ z6vC?*UoD9Kw31d5HT2gBAM!@0E9lKqlD7PC^t(+oD}3jtJv+W3HZ~adD&%D2(MYI} z&7D#E?5UbcpD}xjbP?ph-lOo;q~(cKm6RZ$iS-y)k3B@n69y1ItD5~yDA5}myU6G0 zd-XFM@w$oOa{f>@U)g$5Q`IH~Tu(4vsYL+pm}F*L4AAB9QZ-wXUO_$_XdruP zgYWGMWVAh-L5fK+yw#2`(aZmfWbZ2F(3|nwbfGeRmZaVvDNZ*1@u`pjxx$OIW#SNG zL#`CwTu`mm8i=g7a4?+p_R22TZzt=Q03npKPcxrRSd)NArYu7XwmXr3$ykpktMX%& zICjh==G>?0GR-C-N+43WJ%i!cX4L4S=hjw#=oDPGJ`1dbJYET#1pgx!!tU|JWqK6t zt$|m2!sf5-aK^nDyOp*2_d5j%pl;>#pZC$4giVBShBVs@)gkw#Fs7EcdIjpb%z%_} zC&|Gc(Xf3V*gEPds(ErTyqgh~b~r}Gv=O%L(ZM7I-0+$l6HxK$T)AP7HZCYxJx7{z z`yCQCDK&5+wsnGwI5uiKp)+ALP>b~AVePy4w(KoI-R}Vpw7G3O#49(vB9dOY1l7dmD^?t$zn;slenGveJ64`z8AFQxC0>T8|V_3M!TG+A0{Q-{)iM@6q^# zEJ5w_N#`F&*&|O9rRFgs}r*ux>{S|AcU2QFB2CWOFvnAhCh5bCd|~ z+toG<=Gb_+IZK>2CuO*Vl~qP}G>0_v*aQLloCb=Q>j7n9&gofO{FZYqGiu5lTnXzq zml~|#)IPOvOofoC-MOs}M z^ODGwo*12QKD(pya_IiK%!pJ~j}{M&TDIjI`@Iiu!WjKBT~v)V3~^B$zV|nRaGi-k zS^bXq<9@lUpp%IZ2s&HYuV^k_dXt0HuFV20GpuJzIf;e6$;HiOSAe^9u&CjyWtrNt z?o&ms#?=u65wtVERGIyRmWN7fI854theN(;CG>l7e1fgYMWu^9Wlu z+YRGeS)vC;3-B!O6KD9X7lzV3k8sW8yFaKTj8$7|aVyd87V$NcN=1{DXrR=wR$50pBbVSiSNyGHt7UP2FZ;H>n8mJ1CP7Gg*{`I zgs`7;_UT(*9Qu)(p1&Wdl!5KZ(pu&<#L03A4yKI9kwvjD|$xU>e3w;$;^N2r4w9~R>d%GXMN!SF$JT{P{QIQlClT$D6Y_e-)S~` zTqe~%m%bfp-l824DjT|U<&OB$nN~|jlvdDHwvFdLVfG&e*bW~3dbMRC8M)_s?T>|K zQI&s0ay&LV>rhb1X(H2Uy93W)C%?|~7~5CNLnweJ1ZB9n1bj-yG<@{q7$(Ak!o~)Y zub0p9qT2^J;{8=+8hx_;pZqz#d+?eZUBZD3-o)eP=G8}}bS8`k=WD&Juyx3KF*jWO zc|XNQ6T$(CP&Kw&^PT*Q-9y$#w!S7Pd?h|9boh(y<4qI0j5!~D#8N2^-!}6hzWo#B z6Q1jae*$($8Z@MlWbwB{ugCkP-NQ&e);-BtSVNHf;;o6*is*bk=3PUY4HOipy?JU26_tJ*_8gi`>LO5Ld{b6eoj*~!-bD8#4s`8XoeJ-C5BZHt{SN$4fox4Ym`Uf=;cQp43A zL~cxn>h)LoCsvp0M^+vww6h&-$a6b=39}tWpjT8iDxu&G#173E0~51dk9-GKM$4 zbj=d1z5cQTzu>(WV;e(wp$w+!>3w;KZ3WZ}4s&`DKC^)v!pkRp973W4Irl*K`!|L7 zGvg_Lm^_4Qr!^sg8dAGy3eJL*O6@c2^oN~E3inTfSH2X}pX+dPNf$XGF0Je}rbB5X zcApS2C*?20*0${Sve_9bjjo+6b@6?IlfU6(2pYF6c*>48Gu!{d@k^=RKR2J#-t##T zH8(&0`!S%8itu{o$87yU&n=knm#KF@d|H?9WNMJv#BC4W@fUFvzt=lMG4S(+jE)Y_ zlNZyuC0J)q{D|4h>18M+Z&DA^=UPqL;<7;`;WkMR_qDTjMixKeyc8Dl<~j{?+Fl(1 z`uEGgtJY!_d)u0V@IaO#2r$9?U)~4M)U8FIQoI!T|CRXt$94DL|LFh6OCDNSe{5gL zaOnkFc1U0zX$t6-%zwGzSNfORu+>5U<5Lt^<#__H`}OpeohDHD!y-8YLW>Wnz@J5P z4}NTEdUB*i57&fK*){)GMFZFW4JJ*0(^3D;mZLu0=|bSJ*LYh5z;+5QetM9x+}Q0H z0s#T{%GJnZ2_O-Uf&@TjK%|~|J}h>aQ^r3lNCf+b419OHz!x=o^{N78YA|d3rDVP@ zX&a5yn*mzs4l%>`Pl)J%T$V6EjsYlcP4RG2CobCu=SZ0wiD?7o%quI1`94GppqerP z&>O2UUNIv;8wa!?y^?(hiO~_y|7oikVH~``WAy0Q6C7OKs z_J=c|Z@s|rv#MMK093$Lct0}P&(`GLzq`MD_Y)g2#*a6@f%wggQ#McsP=!S#lzytO zmOWg$W;a^gueqwiB!6H%)lS+5KDe^OK#hMcP7^^x}9 zyR^QFR0^DUd+Q&j{K*wS$nK`rLl)kgu{hk`bXl%(2nWL-`@lM$gcN{4-;^&Fy8Kvq zSLTgfO5JlARWRfFdgOIDw)ENi^}_4OYT!XRBunhyycZt4w_J}K8~*oB1br(NpRzc6 zRRtjpF%3e;G9VF|$2L+A2=x!tS93C-=yIjYS{`@PhU<$=*8U&uU1>Pm*&5Gnb!K$) zj8s)y+tX?7O9@H@HB(#dAw^5Zw03HXB8V!gi_$5g5s}f_BB(vJ_LjDWB$n8hG8dsi z#0XMLxJU1E?}vMz``mj!%(wgbfBx?|&v}>gd(U|n&t=5cGH4zEfxHyA7{2RdMkW|J zw8GZ+=)XTi9ztaR1JmHM!0Qq#n)02bLLi#T37D*LqpJKJDu;$Yn4ux*!dxb7IrJA8 z3iLrrtfC0Zd3lJUW&?H4azHgXS;;=%vFzuZgg{bF<=okm+My27x2M;^$pTDRmxkTG z)~A~N?MrBX^wF|IoIn*O1Bld#zuSO+QN;hW!Cy)#{}<|>tn(8cug2Dk=j+kGHvarJ zzu!HETgSwJfJRH8ErZr_$vSeLYgf@*j+-kf#y4;)iLysY8z5ZMMou^}Z*&dtU5BV% zX#wI66tg|B9725j-u9FR$a+SDtFPiCGg+EB_Sj+fNS%c6=RSGSMf-_+s7Hde+f31Tq$tU{{b$p`Rg249Wc@2i3=-zV0A*eE?~v^A;xI=nU)<>YRk*Y0A5}*>kdf z*bpX9RLk!f@xqIjx={C$qyi@%Yd{at=1sCgtYeU(XHT}C)Sgl>-lQ}L8*5{?`pLJk z`NBc8a8O%bZLnPTX!?X&w1!8B#*^=?UW3n{)#Zm!yvZjm50|E^# zanZA;rNRN-6UyL6w?xM9-Rfy~oM0Anlvf(M)<)Y)HO!vV_kk4Zd}}e>Ad)w=Nt*I& zvoh@gC6nnO9o+uT^28`66)GAkN}X}+=uBPviWuQV0^!5{rKzL%Mw=i}=k~eBBA-0p zsyNfv42aR%Xxz}@kkSV;crF6B6NMx&>*s!s35MQZtdcE2nfH4--Q)i>AV<8Zr8s*K zVscG{6`{_=KvTt^is!Jb^~CRrTLdUFF*A;dXgn#zr5#nDe>@=ci269N!pxg{#}tFB5M(pIO7cFSV!@Yr9}>0PycV{W|B+@4s{H&2>Ox0Y%WdBU9y+MBpJ zqki1UaqGyZp&B6G8*e4&-Z3UoQwTfa{=kN4D<+!pn;zQ7QmBmeo6eC5>(7l;!?3iM zUUy$>h~=*r>eR*6uo^2pZvv@r5G`07u}bd6iKl4|beR@>{jn!*Ih@HWPJu-SR#a~% zdb@HyD@Y8pKYbh3FkpgERP-kQq+}B`J~%w4Dg_kcNCHNhDzGiOhyP7W@znWQug2m$ ztbZrdD4^Jqk~t?xR@JzPGi$0TtRHl_D1FB`AdU-A3U?dZ(g91Ty<=EsU+43YaXlRY zg!rU^j@!Jr)=hhj#)t>_q_?3Hi7qLcmQiP6-oDZSwUH$RHzh_(w(zLiP$4WV)fU!=M+YvR4}NL zz_V8oHK-E}a)zsJ^`;nIl2jCs*WK<1P^w!Qm#aOM5K+4_H5Dw%vq+s3@f&O{|qD}=bM5`vjWbFqRr1xQ+~)4 zz&%uw$zi&j^!J4g%QZb|v}bUuUr+o12&;%Vx_rec^UXZ|80ZT^8?*+8KmY>&15RJ+ z#N!%;uA$K*hszGZz4bDA-K{7v=ZOOxWkEU8SZSCv=JcbQg`9A4lnj8wsbrJJE`-r` zM%WCaCll1pqu!W&sn^q79vd|03(jc=3w`PYI@iEsH)_tDT~D9^NFr{whnZs+5rCVq zk2?--Fr9PN;rbtw9J3rz#AXF!1mBLn?V}6hIfDtZFg0JDRncb81joK<4xRpCGf{8S zp#omlums#HlWf)~s`SMk|4AhNP5eyV90I%V?*No_;U5UlWdg zmuc!FA)bI?ce6tJ-h1zXP3Ed&vgOKs(HgEhRuR?~dMggo<{`Gv>k>CKT?Ur`sN@Z%O3u%XTQZxA*s75bUn@lH)lHKKG%A!RqwPIBjntU88mOnONq-u)Z@2 zwqPv8B^8s`6xv_3il?=%vmbU+;A5V!3tLRgdkNXk$pkHalY)=!?lv?$f31!Tt}?vm zK(FlT{pH9>-Nay*tM=b8r=OgmzkBy?hC@>%om#hrUktn~T2$QCnVzT2J{J!4xOlzm z`VsKYQB4PL^m8?+21B@2&Z*`I#H6u1?92VT2mLh*tG*+`o`OLT%PY1&RG9vF@2}#9 B*5d#G