From 5f9525ea5a70a746932954253218f77884c4713a Mon Sep 17 00:00:00 2001
From: liivw <164842155+liivw@users.noreply.github.com>
Date: Fri, 18 Oct 2024 19:28:25 +0800
Subject: [PATCH 1/6] Quickstarts
---
docs/developer-guides/caching-task-outputs.md | 1 +
docs/getting-started/quickstart-1.md | 487 ++++++++++++++++
docs/getting-started/quickstart-2.md | 520 ++++++++++++++++++
docs/getting-started/quickstart-3.md | 106 ++++
docs/getting-started/quickstart-4.md | 34 ++
docs/getting-started/quickstart-index.md | 220 ++++++++
sidebars.js | 25 +-
...ting_started-failed_task_introspection.png | Bin 0 -> 351026 bytes
.../getting_started-input_introspection.png | Bin 0 -> 355986 bytes
.../getting_started-log_in_page.png | Bin 0 -> 379166 bytes
...getting_started-timeline_introspection.png | Bin 0 -> 222245 bytes
...getting_started-visual_workflow_editor.png | Bin 0 -> 284985 bytes
12 files changed, 1391 insertions(+), 2 deletions(-)
create mode 100644 docs/getting-started/quickstart-1.md
create mode 100644 docs/getting-started/quickstart-2.md
create mode 100644 docs/getting-started/quickstart-3.md
create mode 100644 docs/getting-started/quickstart-4.md
create mode 100644 docs/getting-started/quickstart-index.md
create mode 100644 static/img/getting-started/getting_started-failed_task_introspection.png
create mode 100644 static/img/getting-started/getting_started-input_introspection.png
create mode 100644 static/img/getting-started/getting_started-log_in_page.png
create mode 100644 static/img/getting-started/getting_started-timeline_introspection.png
create mode 100644 static/img/getting-started/getting_started-visual_workflow_editor.png
diff --git a/docs/developer-guides/caching-task-outputs.md b/docs/developer-guides/caching-task-outputs.md
index 1d28301f..72020e81 100644
--- a/docs/developer-guides/caching-task-outputs.md
+++ b/docs/developer-guides/caching-task-outputs.md
@@ -1,6 +1,7 @@
---
slug: "../faqs/task-cache-output"
---
+
# Caching Task Outputs
Some task types support caching, which saves task outputs for reuse in subsequent tasks. This feature can be configured in the task configuration.
diff --git a/docs/getting-started/quickstart-1.md b/docs/getting-started/quickstart-1.md
new file mode 100644
index 00000000..9883e594
--- /dev/null
+++ b/docs/getting-started/quickstart-1.md
@@ -0,0 +1,487 @@
+---
+slug: "../quickstarts/create-first-workflow"
+description: ""
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Quickstart 1: Create Your First Workflow
+
+As you will have learned in [Core Concepts](../core-concepts), Conductor’s core orchestration unit is a workflow. In this quickstart, you will learn how to create your first Conductor workflow.
+
+**Approaches to create workflows**
+
+In Conductor, workflow definitions are stored as JSON. To create a workflow, you can use one of the following ways:
+* **Workflow as code**—Using the Conductor SDKs, define your workflow in your preferred language.
+* **Visual workflow editor**—Using Orkes Platform, define your workflow visually, which is formatted as JSON under the hood.
+
+**Static vs dynamic workflows**
+
+With Conductor, you can define workflows statically (ahead of time) or dynamically (at runtime). This quickstart will teach you how to creating static workflows using your preferred approach. Once you master this, you can dive into creating [dynamic workflows as code](../developer-guides/write-workflows-using-code).
+
+**Tasks in workflows**
+
+A workflow definition consists of a collection of tasks and operators and specifies the order and execution of the defined tasks. Conductor provides a set of system tasks and operators, but you can also write your own custom worker tasks. This is a powerful feature which you will learn more in [Quickstart 2](write-workers).
+
+For this quickstart, let’s begin by using system tasks to create your first workflow.
+
+
+## Quickstart overview
+1. Create a workflow definition consisting of system tasks and operators.
+2. Register the workflow definition to the Conductor server.
+3. Run the workflow.
+
+
+## Before you begin
+
+Ensure that you have [prepared your tools and access](../quickstarts#preparing-your-tools).
+
+
+## A. Workflow as code
+
+Create a project for your workflow client.
+
+
+
+
+**Step 1: Configure access and create workflow**
+
+To define a workflow, you must provide a MetadataClient and a WorkflowExecutor, which requires a Configuration object with the Conductor Server info. Here's an example of how to do that:
+
+``` python
+from conductor.client.configuration.configuration import Configuration
+from conductor.client.configuration.settings.authentication_settings import AuthenticationSettings
+from conductor.client.orkes.orkes_metadata_client import OrkesMetadataClient
+from conductor.client.workflow.conductor_workflow import ConductorWorkflow
+from conductor.client.workflow.executor.workflow_executor import WorkflowExecutor
+
+configuration = Configuration(
+ server_api_url=SERVER_API_URL, // eg: https://play.orkes.io/api
+ debug=False,
+ authentication_settings=AuthenticationSettings(key_id=KEY_ID, key_secret=KEY_SECRET)
+)
+
+metadata_client = OrkesMetadataClient(configuration)
+
+workflow_executor = WorkflowExecutor(configuration)
+workflow = ConductorWorkflow(
+ executor=workflow_executor,
+ name='python_workflow_example_from_code',
+ description='Python workflow example from code'
+)
+```
+
+**Step 2: Add tasks to workflow**
+
+After creating an instance of a ConductorWorkflow, you can add tasks to it. There are two possible ways to do that:
+* method: add
+* operator: >>
+
+``` python
+from conductor.client.workflow.task.simple_task import SimpleTask
+
+simple_task_1 = SimpleTask(
+ task_def_name='python_simple_task_from_code_1',
+ task_reference_name='python_simple_task_from_code_1'
+)
+workflow.add(simple_task_1)
+
+simple_task_2 = SimpleTask(
+ task_def_name='python_simple_task_from_code_2',
+ task_reference_name='python_simple_task_from_code_2'
+)
+workflow >> simple_task_2
+```
+
+You can add input parameters to your workflow:
+
+``` python
+workflow.input_parameters(["a", "b"])
+```
+
+**Step 3: Register workflow**
+
+Register your workflow at the Conductor Server:
+
+``` python
+from conductor.client.http.models.workflow_def import WorkflowDef
+
+workflowDef = workflow.to_workflow_def()
+metadata_client.register_workflow_def(workflowDef, True)
+```
+
+
+**Step 4: Run workflow**
+
+Your first workflow is now created. Give your workflow a test run:
+
+
+``` python
+from conductor.client.http.models import StartWorkflowRequest
+
+request = StartWorkflowRequest()
+request.name = 'python_workflow_example_from_code'
+request.version = 1
+request.input = {'name': 'Orkes'}
+
+workflow_run = workflow_client.execute_workflow(
+ start_workflow_request=request,
+ wait_for_seconds=12)
+
+```
+
+
+
+
+
+
+**Step 1: Create workflow**
+
+Create a ConductorWorkflow Instance.
+``` java
+ConductorWorkflow conductorWorkflow = new WorkflowBuilder(executor)
+ .name("sdk_workflow_example")
+ .version(1)
+ .ownerEmail("hello@example.com")
+ .description("Example Workflow")
+ .timeoutPolicy(WorkflowDef.TimeoutPolicy.TIME_OUT_WF, 100)
+ .add(new SimpleTask("calculate_insurance_premium", "calculate_insurance_premium"))
+ .add(new SimpleTask("send_email", "send_email"))
+ .build();
+```
+
+
+**Step 2: Add tasks to workflow**
+
+After creating an instance of a ConductorWorkflow, you can add tasks to it using the `add` method. The task inputs configured using the `input` method.
+``` java
+builder.add(
+ new SimpleTask("send_email", "send_email")
+ .input("email", "${workflow.input.email}")
+ .input("subject", "Your insurance quote for the amount ${generate_quote.output.amount}")
+);
+```
+
+**Step 3: Register workflow**
+
+``` java
+//Returns true if the workflow is successfully created
+boolean registered = workflow.registerWorkflow();
+```
+
+**Step 4: Run workflow**
+
+Start the execution of the workflow based on the definition registered on the server. Use the register method to register a workflow on the server before executing.
+``` java
+//Returns a completable future
+CompletableFuture execution = conductorWorkflow.execute(input);
+
+//Wait for the workflow to complete -- useful if workflow completes within a reasonable amount of time
+Workflow workflowRun = execution.get();
+
+//Get the workflowId
+String workflowId = workflowRun.getWorkflowId();
+
+//Get the status of workflow execution
+WorkflowStatus status = workflowRun.getStatus();
+
+```
+
+
+
+
+
+**Step 1: Configure access and create workflow**
+``` javascript
+import {
+ OrkesApiConfig,
+ orkesConductorClient,
+ TaskRunner,
+ simpleTask,
+} from "@io-orkes/conductor-javascript";
+
+//API client instance with server address and authentication details
+const clientPromise = orkesConductorClient({
+ keyId: "XXX",
+ keySecret: "XXXX",
+ serverUrl: "SERVER_URL", // eg: https://play.orkes.io/api
+});
+
+const client = await clientPromise;
+
+//Create new workflow executor
+const executor = new WorkflowExecutor(client);
+
+// Using Factory function to create a workflow
+const factoryWf = {
+ name: "my_first_workflow",
+ version: 1,
+ ownerEmail: "user@example.com",
+ tasks: [simpleTask("simple_task_ref", "simple_task", {})],
+ inputParameters: [],
+ outputParameters: {},
+ timeoutSeconds: 0,
+};
+```
+
+**Step 2: Register workflow**
+
+``` javascript
+const workflow = executor.registerWorkflow(true, factoryWf);
+```
+
+
+**Step 3: Run workflow**
+
+Use Workflow Executor to start the previously-registered workflow.
+
+``` javascript
+const executor = new WorkflowExecutor(client);
+const executionId = await executor.startWorkflow({ name, version, input: {} });
+```
+
+
+
+
+
+**Step 1: Configure access and create workflow**
+```csharp
+using Conductor.Client;
+using Conductor.Definition;
+using Conductor.Executor;
+
+ConductorWorkflow GetConductorWorkflow()
+{
+ return new ConductorWorkflow()
+ .WithName("my_first_workflow")
+ .WithVersion(1)
+ .WithOwner("developers@orkes.io")
+ .WithTask(new SimpleTask("simple_task_2", "simple_task_1"))
+ .WithTask(new SimpleTask("simple_task_1", "simple_task_2"));
+}
+
+var configuration = new Configuration();
+
+var conductorWorkflow = GetConductorWorkflow();
+var workflowExecutor = new WorkflowExecutor(configuration);
+```
+
+**Step 2: Register workflow**
+``` csharp
+workflowExecutor.RegisterWorkflow(
+ workflow: conductorWorkflow
+ overwrite: true
+);
+```
+
+**Step 3: Run workflow**
+``` csharp
+var workflowId = workflowExecutor.StartWorkflow(conductorWorkflow);
+```
+
+
+
+
+
+**Step 1: Configure access and create workflow**
+``` go
+// API client instance with server address and authentication details
+apiClient := client.NewAPIClient(
+ settings.NewAuthenticationSettings(
+ KEY,
+ SECRET,
+ ),
+ settings.NewHttpSettings(
+ "https://play.orkes.io/api",
+ ))
+
+// Create new workflow executor
+executor := executor.NewWorkflowExecutor(apiClient)
+
+// Create a new ConductorWorkflow instance
+conductorWorkflow := workflow.NewConductorWorkflow(executor).
+ Name("my_first_workflow").
+ Version(1).
+ OwnerEmail("developers@orkes.io")
+```
+
+**Step 2: Add tasks to workflow**
+``` go
+conductorWorkflow.
+ Add(workflow.NewSimpleTask("simple_task_2", "simple_task_1")).
+ Add(workflow.NewSimpleTask("simple_task_1", "simple_task_2"))
+```
+
+**Step 3: Register workflow**
+``` go
+conductorWorkflow.Register(true) //Overwrite the existing definition with the new one
+```
+
+
+**Step 4: Execute workflow**
+
+Use Workflow Executor to start the previously-registered workflow.
+
+``` go
+//Input can be either a map or a struct that is serializable to a JSON map
+workflowInput := map[string]interface{}{}
+
+workflowId, err := executor.StartWorkflow(&model.StartWorkflowRequest{
+ Name: conductorWorkflow.GetName(),
+ Input: workflowInput,
+})
+```
+
+
+
+
+
+**Step 1: Add tasks**
+
+``` clojure
+(defn create-tasks
+ "Returns workflow tasks"
+ []
+ (vector (sdk/simple-task (:get-user-info constants) (:get-user-info constants) {:userId "${workflow.input.userId}"})
+ (sdk/switch-task "emailorsms" "${workflow.input.notificationPref}" {"email" [(sdk/simple-task (:send-email constants) (:send-email constants) {"email" "${get_user_info.output.email}"})]
+ "sms" [(sdk/simple-task (:send-sms constants) (:send-sms constants) {"phoneNumber" "${get_user_info.output.phoneNumber}"})]} [])))
+```
+
+
+**Step 2: Create workflow**
+
+```clojure
+(defn create-workflow
+ "Returns a workflow with tasks"
+ [tasks]
+ (merge (sdk/workflow (:workflow-name constants) tasks) {:inputParameters ["userId" "notificationPref"]}))
+
+;; creates a workflow with tasks
+(-> (create-tasks) (create-workflow))
+```
+
+
+**Step 3: Register workflow**
+
+```clojure
+(defn
+ register-workflow-def-using-client
+ "Takes a client and a workflow definition in edn, will register a worflow in conductor"
+ ([client workflow overwrite]
+ (client "workflow" :method :post :body workflow :query-params {"overwrite" overwrite}))
+ ([client workflow] (register-workflow-def-using-client client workflow false)))
+```
+
+**Step 4: Run workflow**
+
+```clojure
+(def workflow-request {:name "SomeWFName"
+ :version 1
+ :input {"userId" "jim"
+ "notificationPref" "sms"}})
+
+(wr/start-workflow options workflow-request)
+```
+
+
+
+
+
+## B. Visual workflow editor
+
+Use the visual workflow editor in Orkes Platform to create your workflows.
+
+**To create a workflow:**
+1. Log in to your Orkes cluster or the [Orkes Playground](https://play.orkes.io/).
+2. In the left navigation menu, go to **Definitions** > **Workflow**.
+3. Select **(+) Define workflow**.
+4. Enter a Name and Description for your workflow.
+5. To add tasks to the workflow, select the **(+)** icon in the visual workflow diagram.
+6. To register the workflow, select **Save** > **Confirm**.
+
+
+
+
+Once created, you can run your workflow by going to the **Run** tab and selecting **Run workflow**.
+
+
+## Tutorial — your first workflow:
+
+Follow along to build your first workflow, which is a conditional notification flow based on the user’s location.
+
+1. The first task will retrieve the user information through an HTTP endpoint.
+ 1. Add an HTTP task to the workflow.
+ 2. Enter the task name `get-user` in **Task definition**.
+ 3. Set the **URL** as [https://randomuser.me/api/](https://randomuser.me/api/) with GET as the **Method**.
+2. The next task will evaluate the user information based on a set criteria. In this case, we want the workflow to send a notification only if the user is located in United States.
+ 1. Add a Switch task to the workflow.
+ 2. Enter the task name `user-criteria` in **Task definition**.
+ 3. Set the evaluation criteria to `Value-Param` and enter the evaluation cases in **Switch cases**. In this case, select **Add more switch cases** and enter United States. This creates a new branch, where its tasks are only executed if the evaluation criteria is met. \
+ The parameter to be evaluated will be `switchCaseValue`, which will be wired to a variable input based on the previous `get-user` task output.
+ 4. To do so, in Script params, enter `${get-user_ref.output.response.body.results[0].location.country}` as the value for switchCaseValue. This is a dynamic variable, which is expressed in JSONPath syntax.
+3. The final task will send a notification to the user if they are located in United States.
+ 1. In the United States branch of the Switch task, add a HTTP task.
+ 2. Enter the task name `send-notification` in **Task definition**.
+ 3. Set the **URL** as [https://orkes-api-tester.orkesconductor.com/api](https://orkes-api-tester.orkesconductor.com/api), which will serve as the mock notification endpoint, with POST as the **Method**.
+
+ Alternatively, you can copy the JSON code below into the **Code** tab of the workflow builder.
+
+``` json
+// workflow definition in JSON
+
+{
+ "name": "myFirstWorkflow",
+ "description": "Workflow using a Switch task and HTTP tasks.",
+ "version": 1,
+ "tasks": [
+ {
+ "name": "get-user",
+ "taskReferenceName": "get-user_ref",
+ "inputParameters": {
+ "uri": "https://randomuser.me/api/",
+ "method": "GET",
+ "accept": "application/json",
+ "contentType": "application/json",
+ "encode": true
+ },
+ "type": "HTTP"
+ },
+ {
+ "name": "user-criteria",
+ "taskReferenceName": "user-criteria_ref",
+ "inputParameters": {
+ "switchCaseValue": "${get-user_ref.output.response.body.results[0].location.country}"
+ },
+ "type": "SWITCH",
+ "decisionCases": {
+ "United States": [
+ {
+ "name": "send-notification",
+ "taskReferenceName": "send-notification_ref",
+ "inputParameters": {
+ "uri": "https://orkes-api-tester.orkesconductor.com/api",
+ "method": "POST",
+ "accept": "application/json",
+ "contentType": "application/json",
+ "encode": true
+ },
+ "type": "HTTP"
+ }
+ ]
+ },
+ "defaultCase": []
+ }
+ ],
+ "inputParameters": [],
+ "outputParameters": {},
+ "failureWorkflow": "",
+ "schemaVersion": 2
+}
+```
+
+4. Save and register your workflow.
+
+Your first workflow is now created. Give it a test run.
+
+Now that you have gotten a hang of creating workflows, you can make them more powerful by using Worker tasks, which execute custom logic just like any regular function. Head to the next quickstart to learn more.
\ No newline at end of file
diff --git a/docs/getting-started/quickstart-2.md b/docs/getting-started/quickstart-2.md
new file mode 100644
index 00000000..2aa9d4ab
--- /dev/null
+++ b/docs/getting-started/quickstart-2.md
@@ -0,0 +1,520 @@
+---
+slug: "../quickstarts/write-workers"
+description: ""
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Quickstart 2: Write Workers
+
+In Conductor, tasks are executed using a worker-queue architecture. System tasks are serviced by Conductor workers, while custom tasks are serviced by the workers that you create. In this quickstart, you will learn how to write your own workers that will execute custom tasks.
+
+**Decoupled by design**
+
+The worker code contains your task logic, which is decoupled from both the task definition (number of retries, rate limits) and the workflow-specific task configuration (inputs from other tasks, optionality).
+
+**Worker deployment**
+
+Conductor workers can run in a cloud-native environment or on-premise. Like any other application, workers can be easily deployed in a container, VM, or bare metal.
+
+For the purpose of this quickstart, we will deploy the worker from your own machine.
+
+
+## Quickstart overview
+1. Create task worker(s) that poll for scheduled tasks at regular interval
+2. Create and register task definitions for these workers.
+3. Add the custom task to the workflow definition.
+4. Grant execution permission to the worker.
+
+
+## Before you begin
+
+Ensure that you have [prepared your tools and access](../quickstarts#preparing-your-tools).
+
+
+## Create a worker application
+
+Create a new project for your worker application, keeping it separate from your workflow client.
+
+
+
+
+You can create a worker by writing a Python function and annotating it with a @worker_task decorator.
+
+``` python
+from conductor.client.worker.worker_task import worker_task
+
+@worker_task(task_definition_name='greetings')
+def greetings(name: str) -> str:
+ return f'Hello, {name}'
+```
+
+
+A worker can take inputs which are primitives (str, int, float, bool, and so on) or complex data classes. Here is an example worker that uses `dataclass` as part of the worker input.
+
+
+``` python
+from conductor.client.worker.worker_task import worker_task
+from dataclasses import dataclass
+
+@dataclass
+class OrderInfo:
+ order_id: int
+ sku: str
+ quantity: int
+ sku_price: float
+
+
+@worker_task(task_definition_name='process_order')
+def process_order(order_info: OrderInfo) -> str:
+ return f'order: {order_info.order_id}'
+```
+
+Workers use a polling mechanism (with a long poll) to check for any available tasks from the server periodically. The startup and shutdown of workers are handled by the conductor.client.automator.task_handler.TaskHandler class.
+
+``` python
+from conductor.client.automator.task_handler import TaskHandler
+from conductor.client.configuration.configuration import Configuration
+
+def main():
+ api_config = Configuration()
+
+ task_handler = TaskHandler(
+ workers=[],
+ configuration=api_config,
+ scan_for_annotated_workers=True,
+ import_modules=['greetings'] # import workers from this module - leave empty if all the workers are in the same module
+ )
+
+ # start worker polling
+ task_handler.start_processes()
+
+ # Call to stop the workers when the application is ready to shutdown
+ task_handler.stop_processes()
+
+
+if __name__ == '__main__':
+ main()
+```
+
+
+
+
+
+Create a worker class that implements the `Worker` interface and its methods `getTaskDefName()` and `execute(Task task)`.
+
+``` java
+import com.netflix.conductor.client.worker.Worker;
+import com.netflix.conductor.common.metadata.tasks.Task;
+import com.netflix.conductor.common.metadata.tasks.TaskResult;
+
+public class SimpleWorker implements Worker {
+
+ @Override
+ public String getTaskDefName() {
+ return "simple-java-worker";
+ }
+
+ @Override
+ public TaskResult execute(Task task) {
+ TaskResult taskResult = new TaskResult(task);
+ taskResult.setStatus(TaskResult.Status.COMPLETED);
+ taskResult.getOutputData().put("message", "Hello World!");
+ return taskResult;
+ }
+}
+```
+
+Workers use a polling mechanism as defined by the TaskClient. Here is an example of a Java worker application:
+
+``` java
+package com.netflix.conductor.gettingstarted;
+
+import java.util.List;
+
+import com.netflix.conductor.client.automator.TaskRunnerConfigurer;
+import com.netflix.conductor.client.http.ConductorClient;
+import com.netflix.conductor.client.http.TaskClient;
+import com.netflix.conductor.client.worker.Worker;
+import com.netflix.conductor.common.metadata.tasks.Task;
+import com.netflix.conductor.common.metadata.tasks.TaskResult;
+
+public class HelloWorker implements Worker {
+
+ @Override
+ public TaskResult execute(Task task) {
+ var taskResult = new TaskResult(task);
+ taskResult.setStatus(TaskResult.Status.COMPLETED);
+ taskResult.getOutputData().put("message", "Hello World!");
+ return taskResult;
+ }
+
+ @Override
+ public String getTaskDefName() {
+ return "hello_task";
+ }
+
+ public static void main(String[] args) {
+ var client = new ConductorClient("http://localhost:8080/api");
+ var taskClient = new TaskClient(client);
+ var runnerConfigurer = new TaskRunnerConfigurer
+ .Builder(taskClient, List.of(new HelloWorker()))
+ .withThreadCount(10)
+ .build();
+ runnerConfigurer.init();
+ }
+}
+```
+
+
+
+
+
+
+Create a worker function using the following template:
+
+``` javascript
+import { ConductorWorker, Task } from "@io-orkes/conductor-javascript";
+
+const worker: ConductorWorker = {
+ taskDefName: "task-def-name",
+ execute: async (
+ task: Task
+ ): Promise> => {},
+};
+```
+
+
+Use the `TaskRunner` interface to start the workers, which takes care of polling server for the work, executing worker code, and updating the results back to the server.
+
+``` javascript
+import {
+ OrkesApiConfig,
+ orkesConductorClient,
+ TaskRunner,
+} from "@io-orkes/conductor-javascript";
+
+const clientPromise = orkesConductorClient({
+ keyId: "XXX",
+ keySecret: "XXXX",
+ serverUrl: "SERVER_URL", // eg: https://play.orkes.io/api
+});
+
+const client = await clientPromise;
+
+const taskDefName = "HelloWorldWorker";
+
+const customWorker: ConductorWorker = {
+taskDefName,
+ execute: async ({ inputData, taskId }) => {
+ return {
+ outputData: {
+ greeting: "Hello World",
+ },
+ status: "COMPLETED",
+ };
+ },
+};
+// Worker Options will take precedence over options defined in the manager
+
+const manager = new TaskManager(client, [customWorker], {
+ options: { pollInterval: 100, concurrency: 1 },
+});
+
+manager.startPolling();
+// You can update all worker settings at once using
+manager.updatePollingOptions({ pollInterval: 100, concurrency: 1 });
+
+// You can update a single worker setting using :
+manager.updatePollingOptionForWorker(taskDefName, {
+ pollInterval: 100,
+ concurrency: 1,
+});
+
+manager.isPolling // Will resolve to true
+
+await manager.stopPolling();
+
+manager.isPolling // Will resolve to false
+```
+
+
+
+
+
+Create a worker class that implements the `IWorkflowTask` interface.
+
+``` csharp
+public class SimpleWorker : IWorkflowTask
+{
+ public string TaskType { get; }
+ public WorkflowTaskExecutorConfiguration WorkerSettings { get; }
+
+ public SimpleWorker(string taskType = "test-sdk-csharp-task")
+ {
+ TaskType = taskType;
+ WorkerSettings = new WorkflowTaskExecutorConfiguration();
+ }
+
+ public TaskResult Execute(Task task)
+ {
+ return task.Completed();
+ }
+}
+```
+
+Use `WorkflowTaskHost` to create a worker host, which requires a configuration object and workers.
+
+``` csharp
+using Conductor.Client.Worker;
+using System;
+using System.Threading.Thread;
+
+var host = WorkflowTaskHost.CreateWorkerHost(configuration, new SimpleWorker());
+await host.startAsync();
+Thread.Sleep(TimeSpan.FromSeconds(100));
+```
+
+
+
+
+
+Create a worker function using the following template:
+
+``` go
+type ExecuteTaskFunction func(t *Task) (interface{}, error)
+```
+
+Here is an example worker in Go:
+
+``` go
+func Greet(task *model.Task) (interface{}, error) {
+ return map[string]interface{}{
+ "hello": "Hello, " + fmt.Sprintf("%v", task.InputData["person_to_be_greated"]),
+ }, nil
+}
+```
+
+Use the `TaskRunner` interface to start the workers, which takes care of polling server for the work, executing worker code, and updating the results back to the server.
+
+``` go
+apiClient := client.NewAPIClient(
+ settings.NewAuthenticationSettings(
+ KEY,
+ SECRET,
+ ),
+ settings.NewHttpSettings(
+ "https://play.orkes.io/api",
+))
+
+taskRunner := worker.NewTaskRunnerWithApiClient(apiClient)
+//Start polling for a task by name "simple_task", with a batch size of 1 and 1 second interval
+//Between polls if there are no tasks available to execute
+taskRunner.StartWorker("simple_task", examples.SimpleWorker, 1, time.Second*1)
+//Add more StartWorker calls as needed
+
+//Block
+taskRunner.WaitWorkers()
+```
+
+
+
+
+
+Create a worker function using the following template:
+``` clojure
+(def worker
+ {:name "cool_clj_task_b",
+ :execute (fn [d]
+ [:completed (:inputData d)])})
+```
+
+Use the `TaskRunner` interface to start the workers, which takes care of polling server for the work, executing worker code, and updating the results back to the server.
+
+``` clojure
+(:require
+ [io.orkes.taskrunner :refer :all])
+
+;; Will poll for tasks
+(def shutdown-task-runner (runner-executer-for-workers options [worker]))
+
+;; Stops polling for tasks
+(shutdown-task-runner )
+```
+
+
+
+
+
+## Add worker task to a workflow
+
+All worker tasks need to be registered to the Conductor server before it can be added to a workflow. Let’s add a worker to a workflow and give it a test run:
+1. Register the task by adding its definition in Conductor.
+2. Add a Worker task to a workflow.
+
+### A. Code
+
+
+
+
+Register the task definition to Conductor.
+
+``` python
+from conductor.client.http.models.task_def import TaskDef
+
+taskDef = TaskDef(
+ name="PYTHON_TASK",
+ description="Python Task Example",
+ input_keys=["a", "b"]
+)
+metadata_client.register_task_def(taskDef)
+```
+
+Add the Worker task to your workflow.
+``` python
+workflow >> SimpleTask("simple_task", "simple_task_ref_2")
+updatedWorkflowDef = workflow.to_workflow_def()
+metadata_client.update_workflow_def(updatedWorkflowDef, True)
+```
+
+
+
+
+
+Create and register the task definition to Conductor.
+
+``` java
+TaskDef taskDef = new TaskDef();
+taskDef.setName(your_task_name);
+taskDef.setDescription("task to compress image");
+taskDef3.setOwnerEmail("test@orkes.io");
+taskDef.setRetryCount(3); // Optional
+
+metadataClient.registerTaskDefs(Arrays.asList(taskDef));
+```
+
+Add the Worker task to your workflow.
+``` java
+builder.add(
+ new SimpleTask("send_email", "send_email")
+ .input("email", "${workflow.input.email}")
+ .input("subject", "Your insurance quote for the amount ${generate_quote.output.amount}")
+);
+```
+
+
+
+
+
+Register the task definition to Conductor.
+
+``` javascript
+public registerTask(taskDef: TaskDef): Promise {
+ return tryCatchReThrow(() =>
+ this._client.metadataResource.registerTaskDef([taskDef])
+ );
+ }
+```
+
+Add the Worker task to your workflow.
+
+
+
+
+
+Register the task definition to Conductor.
+``` csharp
+{
+new TaskDef{Description = ExampleConstants.GetEmailDescription, Name = ExampleConstants.GetEmail },
+new TaskDef{Description = ExampleConstants.SendEmailDescription,Name = ExampleConstants.SendEmail}
+};
+
+ _metaDataClient.RegisterTaskDef(taskDefs);
+```
+
+Add the Worker task to your workflow.
+``` csharp
+ _metaDataClient.UpdateWorkflowDefinitions(new List(1) { workflow });
+```
+
+
+
+
+
+Register the task definition to Conductor.
+
+``` go
+client.RegisterTaskDef(ctx, taskDefinitions)
+```
+
+Add the Worker task to your workflow.
+
+
+
+
+
+Register the task definition to Conductor.
+
+``` clojure
+(defn register-tasks-using-client
+ "Given a client instance and a list of tasks,
+ will register the task in consuctor"
+ [client tasks]
+ (client "taskdefs" :method :post :body tasks))
+```
+
+
+
+
+
+
+### B. Orkes Platform
+1. Register the task definition to Conductor.
+ 1. In the left navigation menu, go to **Definitions** > **Task**.
+ 2. Select **(+) Define task**.
+ 3. Enter the **Name** for the task, which must match the task definition name in your worker code.
+ 4. Select **Save** > **Confirm Save**.
+2. Add the Worker task to your workflow.
+ 1. In the left navigation menu, go to **Definitions** > **Workflow** and select the workflow to add the task.
+ 2. In the visual workflow editor, select the **(+)** icon to add a new task. There are two ways to add a worker task:
+ * Search for your task using its task name and select it.
+ * Add a **Worker Task (Simple)** and enter the task name in Task Definition.
+ 3. On the top right, select **Save** > **Confirm**.
+
+
+## Grant execution permission to worker
+
+Finally, your worker application requires programmatic access to the Conductor server. This can be done by creating an application account for your worker application.
+
+**To grant execution permission to worker:**
+1. In Orkes Platform, go to **Access Control **> **Applications** and create a new application.
+2. Enable the **Worker** application role, which allows the application to poll and update tasks.
+3. Generate the application access key and set the Key ID and Key Secret in your project environment variables.
+
+```
+export CONDUCTOR_SERVER_URL= // eg: https://play.orkes.io/api
+export CONDUCTOR_AUTH_KEY=
+export CONDUCTOR_AUTH_SECRET=
+```
+
+4. Grant Execute permission to the application.
+ 1. Under Permissions, select **Add permission**.
+ 2. Select the **Task** tab and then your worker task.
+ 3. Enable the **Execute** toggle.
+ 4. Select **Add Permissions**.
+
+The application account can now execute the worker task.
+
+
+## Launch the worker
+
+Launch the worker to begin polling the Conductor server. The method depends on your language and project configuration.
+
+**Example**
+
+``` python
+python3 main.py
+```
+
+When you run the workflow with the Worker task, the task should run to completion. Learn how to deploy the workflow in the next quickstart.
\ No newline at end of file
diff --git a/docs/getting-started/quickstart-3.md b/docs/getting-started/quickstart-3.md
new file mode 100644
index 00000000..26da2c86
--- /dev/null
+++ b/docs/getting-started/quickstart-3.md
@@ -0,0 +1,106 @@
+---
+slug: "../quickstarts/deploy-workflows"
+description: ""
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Quickstart 3: Deploy Workflows
+
+Your workflow is now ready to be deployed. This can be done in several different ways: via code, via API, or using the Orkes Platform.
+
+In this quickstart, you will learn how to deploy your workflow via code.
+
+
+
+
+``` python
+// synchronous execution - applicable for quick-running workflows (0--30 seconds)
+
+
+from conductor.client.http.models import StartWorkflowRequest
+
+request = StartWorkflowRequest()
+request.name = 'hello'
+request.version = 1
+request.input = {'name': 'Orkes'}
+
+workflow_run = workflow_client.execute_workflow(
+ start_workflow_request=request,
+ wait_for_seconds=12)
+```
+
+
+
+
+
+Use the WorkflowClient interface to start a workflow:
+
+``` java
+import com.netflix.conductor.client.http.ConductorClient;
+import com.netflix.conductor.client.http.WorkflowClient;
+import com.netflix.conductor.common.metadata.workflow.StartWorkflowRequest;
+
+// … other code
+var client = new ConductorClient("http://localhost:8080/api");
+var workflowClient = new WorkflowClient(client);
+var workflowId = workflowClient.startWorkflow(new StartWorkflowRequest()
+ .withName("hello_workflow")
+ .withVersion(1));
+
+System.out.println("Started workflow " + workflowId);
+
+```
+
+
+
+
+
+``` javascript
+const executor = new WorkflowExecutor(client);
+const executionId = await executor.startWorkflow({ name, version, input: {} });
+```
+
+
+
+
+
+``` csharp
+using Conductor.Executor;
+
+var workflowId = workflowExecutor.StartWorkflow(conductorWorkflow);
+```
+
+
+
+
+
+``` go
+//Input can be either a map or a struct that is serializable to a JSON map
+workflowInput := map[string]interface{}{}
+
+workflowId, err := executor.StartWorkflow(&model.StartWorkflowRequest{
+ Name: conductorWorkflow.GetName(),
+ Input: workflowInput,
+})
+```
+
+
+
+
+
+``` clojure
+(defn start-workflow
+ "Takes an option map and a start-request map and starts a workflow.
+ Returns the id of a workflow execution"
+ ([options wf-request]
+ (-> (workflow-client options)
+ (start-workflow-with-client wf-request))))
+```
+
+
+
+
+
+Ready to dive deeper? Learn more about [running workflows](../developer-guides/running-workflows)
\ No newline at end of file
diff --git a/docs/getting-started/quickstart-4.md b/docs/getting-started/quickstart-4.md
new file mode 100644
index 00000000..237840be
--- /dev/null
+++ b/docs/getting-started/quickstart-4.md
@@ -0,0 +1,34 @@
+---
+slug: "../quickstarts/debug-and-monitor-workflows"
+description: ""
+---
+
+# Quickstart 4: Debug and Monitor Workflows
+Orkes Platform provides a dashboard for introspecting each workflow execution, enabling you to debug and monitor while in development or production.
+
+The introspection dashboard can be found in **Executions** > **Workflow**, where each workflow execution is identified by a workflow ID.
+
+## Try it out
+
+Check out the execution of myFirstWorkflow.
+
+If successful, the workflow should have a Completed status, with each task highlighted in green. Otherwise, the workflow diagram will highlight the failed task in red.
+
+
+
+However, a workflow can still run until completion even with the wrong logic. You can check if the data have been correctly passed between tasks by selecting a task and selecting its **Input** or **Output** tab.
+
+For example, the workflow execution below completed successfully. However, the workflow should have flowed through the United States path instead of the defaultCase path, because the user’s location was the United States. Inspecting the Switch task input, we can deduce that the input have not been correctly passed from the get-user task to the Switch task.
+
+
+
+You might also be interested in how long each task took to complete, or to find the bottlenecks in your execution performance. To inspect this, go to **Timeline** in the top navigation bar.
+
+
+
+## What’s next?
+Congratulations! You have successfully created, executed, and debugged a workflow in Conductor. Gain deeper mastery by exploring each topic in detail:
+* Code with Conductor: [SDK Guides](../category/sdks)
+* Build more complex workflows, with LLM chaining, human-in-workflows, eventing, dynamic task inputs, secrets, and more: [Build Workflows](../developer-guides/building-workflows)
+* Execute and deploy production-grade workflows, with CI/CD best practices, version control, testing, and scheduling. [Run Workflows](../developer-guides/running-workflows)
+* Debug and monitor workflows, by exploring both the introspection dashboard and metrics dashboard in detail. [Deploy and Monitor Workflows](../developer-guides/deploying-workflows)
diff --git a/docs/getting-started/quickstart-index.md b/docs/getting-started/quickstart-index.md
new file mode 100644
index 00000000..deba0969
--- /dev/null
+++ b/docs/getting-started/quickstart-index.md
@@ -0,0 +1,220 @@
+---
+slug: "../quickstarts"
+description: ""
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Quickstarts
+
+Orchestration lets you develop distributed systems without worrying about coordinating complexity. Conductor is an orchestration engine that runs sequences of tasks, known as workflows, using a worker-task queue architecture.
+
+In these quickstarts, you will learn the basics of developing with Conductor:
+1. How to create workflows
+2. How to write custom workers
+3. How to deploy workflows to production
+4. How to debug workflow
+
+:::tip
+Familiarize yourself with the [Core Concepts](../core-concepts) in Conductor before diving into our quickstarts.
+:::
+
+With Orkes’ suite of SDKs, APIs, and Orkes Platform, you can mix-and-match our products to develop with Conductor.
+* **Conductor SDKs**—Manage, test, and deploy workflows; write workers; or integrate Conductor into your applications. Available in Python, Java, Javascript, C#, Go, and Clojure.
+* **Conductor APIs**—Manage resources (workflows, tasks, users, etc) programmatically.
+* **Orkes Platform**—Manage resources from a user interface.
+
+
+## Preparing your tools
+
+Before you begin, prepare the following:
+* Get UI access to your Orkes Conductor cluster.
+* Set up your development environment.
+* Configure programmatic access to your Orkes Conductor cluster.
+
+
+### Get UI access
+
+Orkes Platform offers single-tenancy access. If you have an Orkes account, access your cluster and log in using your organization’s SSO provider.
+
+
+
+
+### Set up your development environment
+
+A key part of developing with Conductor involves using our SDKs to write workers, create workflows as code, or develop client applications. Set up your development environment in your preferred language.
+
+
+
+
+:::info Prerequisites
+* [Python 3.9+](https://www.python.org/downloads/) or higher
+:::
+
+In your project directory, create and activate your virtual environment (eg `myProject`).
+
+**Mac:**
+``` bash
+// Using venv
+python -m venv myProject
+source myProject/bin/activate
+
+// Using virtualenv
+virtualenv myProject
+source myProject/bin/activate
+```
+
+**Windows:**
+``` shell
+// Using venv
+python -m venv myProject
+myProject\Scripts\activate
+
+// Using virtualenv
+virtualenv myProject
+myProject\Scripts\activate
+```
+
+In your terminal, run the following command to get the Conductor SDK.
+
+``` bash
+python3 -m pip install conductor-python
+```
+
+
+
+
+
+:::info Prerequisites
+* JDK 17 from v2.1.2 onwards
+* A Gradle or Maven project properly set up
+:::
+
+
+**Gradle:**
+
+In the `build.gradle` file, add the following dependencies.
+
+``` java
+dependencies {
+ implementation 'org.conductoross:conductor-client:4.0.0'
+ implementation 'io.orkes:orkes-conductor-client:4.0.0'
+}
+```
+
+**Maven:**
+
+In the `pom.xml` file, add the following dependencies.
+
+``` xml
+
+ org.conductoross
+ conductor-client
+ 4.0.0
+
+
+ io.orkes
+ orkes-conductor-client
+ 4.0.0
+
+```
+
+
+
+
+
+:::info Prerequisites
+* NodeJS 18 or higher
+:::
+
+Get the Conductor Javascript package using npm or yarn.
+
+**npm:**
+``` shell
+npm i @io-orkes/conductor-javascript
+```
+
+**yarn:**
+``` bash
+yarn add @io-orkes/conductor-javascript
+```
+
+
+
+
+
+:::info Prerequisites
+* .NET Standard 2.0 or higher
+:::
+
+In your terminal, run the following command to get the Conductor SDK.
+
+``` shell
+dotnet add package conductor-csharp
+```
+
+
+
+
+
+:::info Prerequisites
+* Go 1.17 or higher
+:::
+
+Initialize your Go module.
+
+```
+go mod init
+```
+
+Add the Conductor SDK to your module.
+
+```
+go get github.com/conductor-sdk/conductor-go
+```
+
+
+
+
+
+:::info Prerequisites
+* Clojure v1.11.0 or higher
+:::
+
+Get the Conductor Clojure package from [clojars](https://clojars.org/io.orkes/conductor-clojure).
+
+```
+:deps {org.clojure/clojure {:mvn/version "1.11.0"}
+ io.orkes/conductor-clojure {:mvn/version "0.3.0"}}
+```
+
+
+
+
+
+### Configure programmatic access to Conductor
+
+Once your development environment is set up, you need to configure your access to the Conductor server. In Orkes, programmatic access to Conductor is enabled by application-based access keys. To get authenticated, you must first create an application in Orkes Platform, then create an access key for your application.
+
+**To create an application:**
+1. Log in to your Orkes cluster or the [Orkes Playground](https://play.orkes.io/).
+2. In the left navigation menu, go to **Access Control** > **Applications**.
+3. Select **(+) Create application**.
+4. Enter the application name, such as “myFirstWorkflow”. Use this application while following along with the quickstarts.
+5. Select **Save**.
+
+The application has been created. You can proceed to retrieve an access key.
+
+**To retrieve the access key:**
+
+In the Access Keys section, select **(+) Create access key** to generate a unique Key Id and Key Secret.
+
+The Key Secret is shown only once. Make sure to copy and store it securely, so you can use it when following along with the quickstarts.
+
+
+## Ready to start?
+* **[Quickstart 1: Learn how to create your first workflow.]** You can define workflows as code or on Orkes Platform.
+* **Quickstart 2: Learn how to use custom tasks**. Write workers in any language using Conductor SDKs.
+* **Quickstart 3: Learn how to deploy your workflow.** There are many ways to do this, such as creating a client application.
+* **Quickstart 4: Learn how to debug and monitor your workflow.**
\ No newline at end of file
diff --git a/sidebars.js b/sidebars.js
index eef54b90..75c070b3 100644
--- a/sidebars.js
+++ b/sidebars.js
@@ -43,9 +43,30 @@ const sidebars = {
title: 'Getting Started',
description: 'Learn about the most important Orkes Conductor concepts!',
slug: '/category/getting-started',
- keywords: ['getting-started', 'installation']
},
- items: ['getting-started/first-workflow-application', 'getting-started/running-workflows-from-code', 'getting-started/adding-custom-code-worker', 'getting-started/running-an-inline-function', 'getting-started/adding-wait-conditions', 'getting-started/executing-tasks-in-parallel'],
+ items: [
+ {
+ type: 'category',
+ label: 'Quickstarts',
+ link: {
+ type: 'doc',
+ id: 'getting-started/quickstart-index',
+ },
+ className: 'leftMenuHeader',
+ items: [
+ 'getting-started/quickstart-1',
+ 'getting-started/quickstart-2',
+ 'getting-started/quickstart-3',
+ 'getting-started/quickstart-4',
+ ]
+ },
+ 'getting-started/first-workflow-application',
+ 'getting-started/running-workflows-from-code',
+ 'getting-started/adding-custom-code-worker',
+ 'getting-started/running-an-inline-function',
+ 'getting-started/adding-wait-conditions',
+ 'getting-started/executing-tasks-in-parallel'
+ ],
collapsible: true,
collapsed: false,
className: 'leftMenuHeader',
diff --git a/static/img/getting-started/getting_started-failed_task_introspection.png b/static/img/getting-started/getting_started-failed_task_introspection.png
new file mode 100644
index 0000000000000000000000000000000000000000..d1f89d0bf5b0cd434e50c1a0ac87a213f2aa8b27
GIT binary patch
literal 351026
zcmeFZWmFu|wl#{=c#{OT#uGefaA-6^6M}@s3GNV}acd;Fgy0Y)KyY_!+&#E!aCdv1
zbH4k=d-t3l_uPMPjK`>=itb%qU3>4f_F8k!#aC5jIXrA~Y$PNkytnewACQo+ERm4V
zDFGOWSAK8`TOba|P9NmJNF~FRJBUA^CR%Szm6VWJ5a$3SG-Prl^uJ9IyBIRX|9vit
z{1OTEAFrbzAq86?q5YpW%829NpJ>GX_nLnmQGX!+pVo-iexUqUYb?tjsQ-12PWkt;
zMeimi!~x4*{*x0D5;5c79r^7ChGQfo38c5uk{_YS`)Qa4>grR0uGp|x*b+oSQbq!(
zS~NpM5sKcmR2H$Al^ZV
zXpU~1yLB89eekXob=0_2?i(3d=HPt>LjKP;zZ^n&CGC;@L^OHd|9oqE_Cqy{1O+P^
z=|A2Wl8^$m-(n0NzWra^*B8vLhsq#<@*i)}pHW^|GLmsMGXF373K_c^iub>G)M$xV
zEYwo#Q*tZ6Emj_sTVvLN8hF<0L|A8guzeBhxbw-;=nZLaxEa)d4
zT5+%Hc9&;A5cTZrf9|ad=n;OaVExl->fdXAU=SXM<`p>ZE|tGpD0p{E8TLP&t@0pp
z#21p03UmIa$7Vw=l_+R1aM+d^({L7KO~w45F9876{I0!!b`i)3r3A>bCM%quH5~6>
zO!Woj4cmYJpnVXEI49e;43ZbJqV7kjLgS56Y5DWz$p5|FKV7r*J6~|I{M&Nszi;nn
zp?y65s79c_tpe9j5)DWd`0p1jxPNh+A30G<HbYBVb54%UCOe69
zFZN$=MTM-H^D~<}JTrFX`@b999}U1Cs)Y@ySi=E--!4E#CVDNyLu5yBJ8N2QLO!$1V*5!E8MWWE?a^RA*UJ{C`+wkR=VlwaB@$vBuUsU|)@9Yqb
zt}@DO@@F$u7I7lyqf)U+Nv{MJzo_x0t_}+khj_vjuWB#cSGTq<|pya+xzh{
zZB+t_`_Dk&giv+$Lr!zu#p0K`%dyD_S?SFw=ZV#=fK&55xpC&bk5qos%y!XD5s=L$
zRC4(a_wuje$0p{F{p_cE<6w*Ac#h^dGx_E@zZRz9MYg|lPO5P-&TG!(2&+2AQ3B)6uUEev(|_B1n6I&kLq^5uU8r~3tlv(L%Z?N(Xiyp(HtPt&
zJN0?G@blJRZ(H^
z6^Elvf?U8>=hw`=htiVwoz2Zj4~@xYe|*K=VWUD6wdlr1oXYq8{rz_rF((6@t-YH1
zUYn3DQufV1l{F$GfA1U>fhbq9(m&_tVn>PR&L$czYnu0pCKN3XR}K
zv{e7rUINnI*XPXr=Q|VVR~E}HUM7eypMYq8qfU@?wdlIsM<9L=s$&vz*(a^AtqOG7
z8Z7sc5(&Mjw*1YK#jz&XVn0oE_*L|BMk<-l%2cL=Q0Zm=yAy797M6-5*1?ng%8?S@
zTf|$RJ3|QLPn*f=rZ`*g9qn9Zz12kpp2P3gqr{1IR95$U>7%NSUfDHkEtxHe`5$0D
zw|Mvs6Q!JMH7qlYKNVgU)u+QskmuBmAAS7~qx$de8H9~;o==3%roo7aJN?pPBzW6j
z)t01OuCK9Q9o|)+Y*|of%5UZ_-rDL4986(-mwhmJz_3z_JM-br%3dZWdE3ZTz0upe
z%eb#9tEj^%8%EpXT*}E#@o`Zz{3>^IptLY_bHl5`=$R$ack6_dB^_GhtpuD`LIR2j
z3Bz_KQR{i=DVySPQwkG02N)C-u~m!U`38-AwLb&}edPhmA=Tx8sy*
zm&*f+=~$_T$>L1857iSvf6(cQOLQBtiR}vuCBL1wK0S;KzkU`&9JwATd{{=u9)dqC
zw8z#rG(^N^YV1IB`6oLHoA|tgOj;XgRgVGxZIPE|+9jGSZoBX%rBjE-WB;{&<^Xes
z=Lg9b**4AdXT!oHn)&E(^4nlitSkoc82@<^=}!U+_5n>dTPgAFFP^r=pUOqXG`S3u
z<~8fi?OGq067<|H7|SKHWg|998V_S>rGj94bR~|*Pd(y~w7_y{x?Z=(o9%<9m7#9F
z1!UBpyT*eQU7(gyGxA|fU
zQgPIBcPoafS**=?wcr#r@+ZFXcqyQFs=C0_wqdhom&d&9;=L8n|?3jQK+
zv(~a1ke{uu-HviR4
zN?6T6v+-Gu%>%EXQR!tYz(=Aofn;D&fAeiKZwyaFLT2*krw7MkB8!8Gq8eOYqf+%7
zMs9agKVDu>7vg!-Z`yCRW9A5D+iDB3t6K#8n-`oJD|~ty#`^)6O;d0HrGv@mM4E$e
z)iC08r1a9Kha(@GuGafaPNMYHRfwi89>5Nym#^DcL-a{n=yY1&$EL95cDJx%-nMb}
z+@^Ms$$1xzILxkolUP4WTPvp(F$Ojd2s2)C-*oKh%)0y`8Bi3m6+#~wjhMU2mvdH}
zH#>P58`)7}v9Hu}dspBA#nEkhnbvTB^cq%Zu+X0$0SmUQIb#{qD>qpF%uxNWlPl~P
z)SdQ&Kp(@w@Nis;E&K;~<8+c)`YT|?%LMs5mp#7=84_Iv;A9&_6R{{3UE|O)!_kfC
zDTSM|80Ucagxf?}+42WnB>FE>eP-JHP|>$vGc)%L6VZ`}kSU8^e7rfIP#Gvm`}XiI_m6y@8YRv(h;o+}L6#q1uc>S5su#BhtO*A0kxRo
zlEdDhZ&RfQq`Pe;+3S8HWD+@*%!!u|kT_rRII7ldr=S*r8RDjTgqW&`oJij_bvSid
zl~e1h>uWB#?TNuGPPn~pck&J@)$h*d!GmFDKQkoD3b$#To9Ni9eidxzF5epsbqHfl
z$7V>r!5w3U`RXAh`%fXwvwj$^{ONB$gC-G(TATM)H^P#1&d1-rmT*~f{=CUFsi>Ho&*;P
ziz2p0$&I#3ZE`7OXu5c7kN5`OU!`2fK8N}IbG?Zz6%`LL{QJC0UH$LQ(+45bkgtc#
z3W{}Y;@^n|^op%|yhxubLM3K01)T@L7~P8&M9y5RBfbf7a>M2vz|}Sm@uJMhw<<7L
zaVS1rsNtg#SUNZ9h$fS*kt0XGF}L|nt;O@YN7n6ekhlfR4joOl_wwk=kEi?O{KuIs
zws7NYM7)-EdBtHj(KzyJP9Od+)K%;zIbENJ3k|dvI}DHaXDX22c$z^#V@nc!&vK@L
z8mOGE+h)AW)2I|dwg1q0@k
z0J*9o5W6<;oBlbWBEA^v0orokPIL8-q$&Z;IUy{l^ivEmSk~0UMCJt(&jKYlo?e;(
zcTI@zih8Vxsy@){^@7SO?g-DM)ojI2-|Rj0gPb_!ijg-Vr}kpBoz`i&D
zLu#Bk$!HYV3``!!sE;`v3Lbv59$t}L7sbW7L7(#qtzc(ovz0h>`?}z^fkpV`Uk?g|
zExB!{DVILJg-W7Hm9F04(NgYrQ`nsstErDD9WAUaUOm6eRDt$(IM5d{wJ$eNzgqXo
z=n~%6n(KgQl-Yj;1amBRkF(DIGkN&$za<2bOE}^y<=rh03FbGt_5}J0T}u+C4_TsR
zoN9ZsW+4&Gacw?f+tvw;TRd(X{5OUhE^gNL4T|n@>EyBAMsE-)h!I+uM1abh3HOGJ
zDLJtwOz7SCZA0LnK33213IoWI7E8_et!*Ni9ocSOu1)lI?xN6ARV{&?o6_<~emqOC
z3pPw7m8;h1Wv*6~%|fb#c<{k{4&{*Q(gIrn*3udL*_!t^V3UVA;Umo)Rst&qA3?hF
zJj3R+tLx_uUVKCEvgKL9(a?0db1Gb%xuq*f*kb3$;<~yS>{2=l+?bK;ll7lUDg2HT
zN&+(D3?)K|M1apyjhBF2`Vo)@;4~+1dHs`H$y*QvbGR@7xsx=v4wOaeL61
zO5|~j(>zc6_|F-}0o7!~$GTZ%qil6@<~`INMMMy|6%b8u6?e%bG&Hoxpo7T5LKu)^
zpYCu-i+i&gOjGr8*QRP4SI@y-d8H3$T8j|r~>y-?xmY{Z;u06Ri$BH}PJF`Y1gAI^w1(0Ivxuec>RCVbnJ_ekU@
zXUz~l^HBfkR+FOt1zj;B`qlg+wsiF=aJWwD->tuhY#s}_q+K2UHTCR4!|id-lgwdT
zn|_d`qLmWwx?H~c8GD@HlM*>Gkk?v(Y<_6=#_)5fh#-Shi%;I#ni7#>iWH32w-wyI
zeRtGao5A(_lOoD*e+dR0%lzz%FMG<=ZY-nY=&p-$Nn4o_Q@o&aC=k{RVTs
zmpt%ffWSUB4FO0LL3}*^($7|5$o1+3iVT3aKU!!FerlwM|e)Dtv
zw(Rq?=<3O4TX^*Xn*2+X^VsveSSJ}PN(iu;Yq$_yd^Zzx8i`003HlHo)~8
ztS&PtC4ZLNU2gRWyt3Rmc0u(c5aEI6s$|&KUY8qoU{EOI^&ArM#H(Y+NW83lxLOvM
zjyR8uE{CQ`X=#EdsMTd|4-a4{0A(LV3Afh$TmTIkw|rtT%^dw*&pn#OE0
zhM!GUPwP=k6~0HroJGNGQ2ek?kV`mY~@m41Xc0qEl;S
z;GdQvbA*GNN+ByD0BqSuz&*&M^&zzy=NQcfaQ_Mq@JPK!l=;j^#c;MF=o`66q4VLw
z?C?*iVEjw6?95lR5@31NkXSI;t)#q$P6t3ATjdiRcl8}@e!DZqsvZ|ANuv9+O5t=G
zL_k|h`)u_qL6*XFVSJwDWaF_O=ENPm6qViSC>|QcIkks<7GRF6H^jxckWeS?kS2Pw
z5l0v%ylxU|A1@Vz8*{NY4JkE-DoY!$1Y1$ka?wV69K$iaQkYNc$p(Z~nBxIk%bsTu
zIu2b#m(4eq^L7de9J*C^6*eMAl@-c~|DJpBOAD8%-wR3GZz~vB^?W=xB@<^^hP_cF
zx(@~hYsAJ|wo`zUHe>%-3wBCGtFQ;5DdfIwh!h!2j<0g?B
zs83pGL5?E=5S60$+kFRmwi+`vR_wvnd$#2v^C7>~Ex*v8<)EjOfW2dCz7?{STTOlI
z+B5pP*()10y&;86b=s_y{2exF5w~hvb8xxw*`t2rd?fLb)aPAF%LIsoA
zZW~9742;t&OkegxMiHrj}7b}%)h-?QtGW+
zD(2ZZ7n^mQp?=H?fh<8@DNM)rO63V8FeO=>p3hXD{w`AD=CKR=Vy6LFYRys#bVHlJ
zae$k;ofcMKdbvlOF#Mi|nWb`>RfZ>jw@WcNEK6C|eO3LgG@kylfV0OrY*2V+f3xfK
zGV12^Vj-epkdn2iI?2vwz1sTNd$z)?@N_g5xPa?r6KKt`#1xe_yKo$OP&nh2Q52Ij
z5VjGNO)=1Nus8EM?!-80^~r~(r~>5|>zzO>s_PZWOJDe6Mo|qd(Gkt0qBh@4aSlL{
ztl}IfZrd(a-!bA(sd?iU{-uG2+5-9nsyS65ew;(mFMV^*+|KUsxJ@CVgV{XQ)-NO@~5v3`P`NSG#
z?OsvOY>?3048BdWdQsC@zjXLU5ZHnZhG)`$R}g)Edt848nRPshf|lL{kC@XAMNF5}
z4m$JAEeN!-aeh0mdNJE-Lq#^qt`>O|vqLq0SUN1=LwS54bmKlO`^jMZV(?(5-oZxj
zmq%`DgWdPf(_OWL1$-B|=(N%WH)5%Z0YDtR__AwUD@58S0YH5(N*t;WT}7vGSCRU#
zqXSxy{PP;-7ht~Ke6O&cbdXTcaa
z(*`0vU!n)LnWtk18VNE0T0t;B5>TR^2asx&$9xndc@6)imZ#163EtgyKO%f2GTY=<
zDe`bWG1Wm;GGc(i=?q}TmQ?2IsQ%Udc46B)XzxX)1`iKUv0Ssk2y$yp%*M_|l*2u^
zG>agWhZJUH`Bg~lfODMvP!i^@TW%C+gEF=l%cy{MHTD+_^IIXg0(5?Xv+3nR#Xy7m
zse(=$sZPT&2smp2yTm_Ydq~a$rWfcc0>gws#~!YNA^Jxb(2SJwmNTvdX|4=zlTf0p
zwKvPqb-bO~$~=!mlO5=inMoR#6QMWxqb1%i&7uYH_Y+@GtpEXWZb})Bi
z?N^}^-tVHmFK~)TpFmOrh=tV+MDgCn~9W-`4|dCPFZ=R
z*BUHn=s-Pq+;>8*ADxeY$u^Zl_lXJ<{+^oeCY5R%NjSTGeeajqVYk2sKtm7v+DO&
zUXRUj6Ef0Jyk
zD3ZrHASNrH#`LkSqB+<$rbn4*s%J%A1y-}o5c`)(a(~j)RZL_a+TTT%_
zPO>x|H!nvt2Nw9c#(%xH=@VFM89U=2h@jW((-fOlE)f(62x5;($hD6C;*^$FVdf<`
zdcSV+i?D9-%sCy`)AZ|o&7{w;cTY@669RYqU^HbXlb9M05n2*u1vYb9=
zFcJ|7K3=>*!0naOU&>mHhJsfBSxm5;0Hh&4XuMSZAUY25j1~0=YH62~=Tb}i!TK^f
z&|=kdO(@_RfC5^`fXc3=XS{L9B1-)wKRRzlm$>Hc2f{U)Lb%--Vd)t!z>(PX3MzzP
zKNydKsZQfTF@wPU=Y8Z
zs$LL|MDot_Jez0T{9{Huzs$4lI(arkqp(hJYQYe#h*H;WU%Z;!L5^7>sS~E&JRDPG
zoU_LK_OqOL_3M?lI9Y6!S{Q`HBA+Fb0v}#nzn0W~l4>|NMy1OtIY~8msvJ@nP#R_?
z_}n|H$-?=KX-9RYSPGO1#4%!b|Ly4e`V%`qnvQo|sNwflV;UNfjIzL&@9=O$wYcD5
z5^u>U87$9e*=u69kUb}*J3l!Ln*ek&whE)L2Cd#nej%oAu(nd5QF7^>kobmGdgRXc
z`b}G!Lul`ncAcZ$Lvn>r-ATbk0AVWVeiiHPBGWh3)#vo
zH^g3jR`nH~P;23At6bb2l4A}G!ZB?6rrZ4l6t^}&-Q&qD`E0R_&Cc(V1)iC9KFG%S
zbiyaeWx>18eLKySIfaD8YplOzo!DCtRF&IdW3}U^Fzd$8N(jcq`A;X@S}#v~oL4MF
zt`8TBMBIJ%>u2ff$=}l|=eC4DF?`RrdQ4ZD*6PmYu%P#-#)p0m03DWdPW6XvwKTbH
zyd#^>Z06<7lBmYS?a`rMYjk|Vm{Lo8xV69*NDedUbluzhinUi{UIt0&m5!XV6M+!b
z>O22dH|%0L2@kjeH1WZO@zE%+TXK(3&Qs#!83mT0*`RxB5tRDXqO!6`7p@Ri1eaqz
zK+7d7pV!nRLP3nTmZ7FB*frHb0Bt*QhfDV68Dvq0)U`?Cp|BEtqSYa7Dg`Yhkhd4Y
zCrCPNfkGW;k<%K*+9o7DG0WLTqA*XIN@c1Lc}U6
zD~q?;0AZ86lfR5h@c?1KVSN8)sLjD#bxoLg-HI@wSfYwE_X0_soxN@|g25naH(G0X
zv*L?dB!NEtOawiGoUh-#ro$DC7l2VyH&RyWR!&J@Vg?-thcr|U3k@s@*op(S*8=Wn
z3~{B%q~q#Hj&yKX(Kil&x2-R`;;IlT+`_SdRjU)u$C7g-!k5=HBhRTL|Ay
z3qDyliQFSO(((G9E#A~&fQW)M>@j1?v=M0VK>*}mcw0XzsTH#4n;Y-XJWR;3K9Zo&
zM`#Lo+KSX=>bTYURE6$xPurjUP-UgeB<-gizja|CPAi9Mu++2{6cd>nW{$ioN7>v;
za6JS+)3z26w^k?ur|g;=7NC#+oL8aFXJuYkJ3{W7%wha0!Qf*UC4_)Sd}2-8Y~O-}
zP)d6HN`HRe)7Udu9#ZoohG_uJ4gHYxh{})x12NgsgSbVukKri%Fr7mq^xIB49Pd7Y
zCf4@xLTX;Rmw;kWoxiUvUV2&{2B3p8FD=0$(B}^U9aa7!?YR5#x#?8Ox69>m
zs5-g1h|a-OQ;p8&T{uL8V!atF6WDy2^nM_!KFg*T=(fbaZf5tLbs3MXMtn0Qr%DfX
z{RW#x%QBRZmfY{$cF0OSF?;G_zFqBwv;ojUQo<#YkhVT3+A|HpTSd$GWOr^^-yPz!
z#FLf6A=~R5jYTuVKrh3T1oQ;5xpl~Rb2qoSrzG1niBK)nN6Z&1Me(QS8}vw%CXZ>j
zc#GT(Y4>r_qCFJF8QNE!{MfAaNuT_ywx16DhW1^F
zZSE$gt%~LMKGMHzG*jhatr+K~JPX7Wh`uHJg(7y9BDTy87W7=6H3Bo@dwJDgY`J)k
zu+mVpr!2I?AR3-yP3Q=u%Ryv$^BjqdN0_b>Fg{NN*SElifaEp%FKM;k
zJYKI4T%H^@ZhnUp{lH59zVh|e)DaY_vgU<3@)}6BLKS)x4y*=El1p;{oqm_n)IEWg
z{8f>A_&)anSvefhMYLYZnG5g%!Y5a{FweRgi6IxJFvq4=+IN2TJL3wR)&6+__(Jk2
zvd!v}&(J=sD#|F#G3j`-r@f4Z^F~yk&#wcLYo_aM0O;on
z+x%Cl%a2{G`-jE&)0P`!Cxo++LjeLgxO|SER(4jOeCvdUX`HfDS>a||6M5L5n+Pp_
z=C;L!uPY4{iD*Y@|J17}d-m%|(oda*KMGWv((B;;V_jqNvI<7oLnn$h2Fpw
zj)<7X!H|0smok}f11|*A6)P!$t^mKCLV&KK`|APQvAL^!I5ceB0_LM_9QzEG?{OXs
z98hV_qxA1f1#se_%2`GGH(El>Y0NMkAy?gR({6hU?=|-{0o<;`q4S*BVOVd5~?gS&jSj$H^17Qe)cCM9^x@dTT~P=uf`(3
zEOU}^AZTYA<}oT=48Pv>n_vm8s$#DJMlM*0km!nA#)n^f2b8MrC8Lr{GmeAvC86cq
zw=djw2Q?hqY&Uy0BdJtw(=yIX;*h^=Etwh)(~mpeiDuh)TL6cjB2%+~$kU?H
zyaqr)ItVH_eQx=ihl@ryyFS$dOcAUeL!tW
zLDZ?}DpmV^&Ss=n!|K@}tXczFH3Q4GUe5VW=y*rFDOBCs-lc-Y6R
zC6XGc3>p9pKzP5bBa7S$vHG7P805K{5s@=R^cZ69lSe258%0kq1Ofd>^0Zpl;e|xf
zGKi_2Kt&)9!j=MX17?A;*f`q&Jj{Sv4%kV+^fN%+iuzW5c4WoDDiO{ahi+Yu(Hk`8
zl0}cB=0n?0US*Fk$*FUn%>#8y-=!0cWNJL@MhY8V(_DCR#Cw3vjI84
zyNls<_8zxRH@{43+;#%MT>x3SVE#JuBm$L&@dpA=BLtSpmaPIVo-2v9Z_;kiy^+*H
zQ?VhUZpL(*qP{g6h@{K)rkWBfUlV}IBve%Lr{pssXQTW#^ry-QNsvy
zYRm)4OQH?7O*G?kf6{ZgP*}&mv~5~+Byu%lWD+R`LXqu#f8`Z4T6N4O_T`W2&2b08
zK_lK-rx*Fr-C&x)#J}cW>QcUR#RaQ_@7L%J0%5YMT54U|aGyppngrd7izWg`llx#u
zME;Mg1Z=i+c(vbSux^T(_ct8$@I0~)5}F*>qNT#V6*VzdO!pc(G24lP3!5e5L|GXIr|xx|8V2#f@q!xs`!JqcA`Pwu
zY5)Cr{`OE$%X~sjEmabYw*J*(v2bLHzS@MG%P&sO`zk%A#N%L=$vMj=!)7aK>Ek$l
z^JTWZm~CGA8TZGYi_^@L^e+?TO8xj(6chMU%g`Z5ya)KLb3W^iY|-=nk0HDh0O#+C
z_Fru%)bHKLne%k=Ulh=MqZL_qrXh{_PIeYZ%WkrK`IW@NFx9~c)#t6F?@1)l@GaSh
z3eYklrS`pTJW}I&!*ngUcqGD=O*5Zw7_e+gh996vD&yHlY189Z6-9Yi3tS>z#Sj;8LfT8Beqc
zYL_(_k?yNCn)O$TTSv1lYjcpC+kj99TUZN<-hBj)OCXK@6*H}(#PMOmngV_$(vLgv
zo`ZG?$a#Bf$(Arlbice$+GbsTM`+p*HaCZs9+K{L`AKjsguaLir=80S6Ar-w5B(*6
zDvY|Y-5xHctCR3(Fjsle$beYVR)8M#Oky(@PHG>eyLmwr$$omntnqRZppUi9V>{7eC8TtKI
zox}S618$~9lj6w{g}rZW`Ce(O*dJlg!u|V0clIxP>*O#qK3GTRnS7x3E$*aQ)_ix$
zl+YZ;raR3auT`7pw&EIFwyoYrJog?4f1#QY3&8HNU;c~lgI7tyoVouhlU-x>wGTee
zArhCnROLgnFWySDs$mL}EUJ5^&DZ48|9;o=CQan&qsQCVt&|Bg!WZZvlxH==-ER3%rl*pW^VA@TL~4UN7x
zH%Dlq@GtoYAW&BcQtFUOpo=s~WVLriEh)(oVCD7a2X|N;9-xM+L`+~&&~SKHRN<`r
zw=r0leOjzaagTnPli;Q#GjhJ0z0kq}CJs}@@h{wq#Ad5gNrb!%JFV?^kTsah{m9EV
z17m=x?k(zLZ;;au{z^-yQwaa@$8}x1%JAUDPKw%lt=LBDXH@GCd0t(f;$ljb<2jWl
zO?*Aj6>VEEqkEt>d&G39{C?%~=_b~C+OJLktYRqj^0i(@tl`%AfDw<1)`-h$put@g
z&Y-b__g4wD1XI0BuZZg+gqDlq(f+65;sTd%1Xp{JJCoahZ*GOlnZ`{!%q!KZo$b&T
z{H$H}i5S?17xH?a_O`CcN6OCgC(!gMfF7gSv!3
zGg{satPxCU-gp)_ZpWdUVD@RNo{)RXSjN-jQmb}KjLHT-1QyxH;Q~L>b1wR!%9TM0@iS+e#z1{@Sf4rAL`+0Dxd;PJy%evn#D<
zZ(pB7m^Hbc~0o(kW!JYnvThq)oI)d8iqUA-W!
zf!F<@>`^DeaH-=k1lWWK235)nHa2^6vwg9$$8=T*vg9~TCwX6@GFP|w~g
zHvjlb&}s|@3LWQQM!9R5Hrma-fmV4}KbJ;MxVu^%
zCR1ocSilAwe4@<9;Gofb%P?YgmPSoJ&Y4Suc(_JpB2R_0Flz*}`Dy^$^O?5X{Etv>
zRVJ|^uxVGn$mhJDfyX}rt?m(gJPBo`#}m_@7ja*cR`9
z!4!yJhSiuY2PA9D6W2
znr{P*b))OAGFydLIYK}Ea||vDA&-%DTe=v|gKqUFiQU~edNqXSn*%+qc2!HWrb;@@
zDk|Enn&(zpOx<7R8HFN_y(e;&D#PaBO&=NE2l;L0W;mFYk{N=jT(mkDrS{R(;2LE?
zfIb{Qz|!+_j&RI9iW{gVoE``5^>N7to<*=LsNK9CgOGB`0+=FUPgHEkMnr2)T4H`D
z;YE}N5;1-=fmjSKR1ng~JFID9+Id86fN5bMwmx8$ygdOfJP}UDgUGv$oJghZfjf2S
z7S?`es3;-OW{XT==#!rTvLO=fl%ovsus#1*RZp%29GIVXJ0YYT+h>K8%QZyi_Uece
zAuh81Alr(_;OTY|xKk0
zIk!HhwGxVO2vW&n@Q8IwfNYe_Os|HD@t#M5x%xH^JwkT&HT;3RRl2L45e*GlMVrZ_
z>(l04qyYPw!uva#nl0mIi%&7%FA00)l5Uo#$}dDeCXi)n99r)lh-lR*pfs`}vmwEF
zY9n)b7nv#C;_RXNnGd^r@y|B+8Y;mQ`P8RyldW0M$*W*0;`Ra1aIZIM>-G?ms*y4m7H2UBy;0J|Z8(8^%G?y{>Tp
zPqXdC4{RUDrSm!HWu9mgUx$%HAIZ&N#+=@e8&2!wls(L;TJ<0uNBMvdF-8XN5d
zcLYeq)iz`*d);BVrnIO8=|6I_n_!0oB)IL#R<>rBxE)bCh3B7!c98e=Xx7H71lPnD
zUfO}2hrAw_-|lTzzeOg@tyQACS`EYqLbneQDQLgF*fR@$4_C-Bb~%{)tsw(tg4*Jm
zHmIh@#nF$2CIgdIMZ?keXy`~oLJU}_aWqJ70LvIhVu@k;P!UQT5uZSAM9}mI`$L;v
z)@?v=#D++Un
zJB9te`(*%g^L>YgqWJMnC_A-*#~^E+mr^f9wAggO7b*GNc?;gzoSCcLH)R9
z@ZE4q!EwE)I;ID)e`rN-5o%C&RvJFbk3U!KX}}U+kA{E|7JoY45h-CvOCBF@38Zhq
zjfwY*YnNCGuMn#I#VwgLslX8ErGYIR7cA>}6{z}x+Pax|=)`Sawo%++tutE5UZwO?
zW%r{nQs!Gj1U7x-*}rUuQ>t3#b+uRv7JZNcHaXdg26B7(tSqZvFXFTPGYND}FX!TX
z`7#!WAS1fF@&`E@>Ts}8fO
zV_irlKYm&)uGR4#EbhKuuj7p<&TYPdM=lrB6e%n9YG(evI>RvuKWPsb
z^)ox~uhGj`xS>}xVy18Ne`B^(z|L(rW~ye^NI6+wp<3u_@v@U9A~@f^BJo!)K3fmq
z%UqJGP5In$B?Mc793gGW1L%(Cx6f4eV%2W1t-_+Ywp@sSFJmcWOfy0m@vTVRS!
zy!Qbs_HqLS!G}hQ^kuU2R`P^)n!&*Y)Nm^eBDU4Lw)*Zu;&#lIhjk3H2M>u+XT{q7
zrj8+6!cBk@bmERRyw0<+$=g=J?ZJQQ`-#-@Rv!cXieoV(1u0{PHT1KZL%l0|t#a9y
z(hoJu363}#Bb=>jI~P35IvH^5rGhmB8HdfI5G%0-m~d@AqW~!<#7DT|SFzCUv~MrB
zPNUX9xjCMl^s&3soJC&OoYLgMN8CVg(?*y1FgU{19q&YMchF5NQj7L
z?M(p|#ESN4_*Y9FrBqu@XTvxGI=zliIk*-Vj0$(l8N&ps*^x3v?Xgc-q0$Pz_mB@{
zGx)lGUb)&4j3e^n6Ot(PfBi22Nly$1bT)Q&rD3r<>y&Oc{4GhmWk1`d6Ilo+q4QjOO7H9_p7Pi20nnB5zaqovExGw<6SW?`C;*qBQmSPac;BN%)8!tXUN
z+wR-piIeh(z#BvfgEjisH#FWy3g^Oz;+`Y{yL6)8R9@#}z1S9+OJ=kb7195%P%u{B
zU^tZBf8>w8K!2QmaWzfOML>lX?tuk^Y8qB}wtS&b1_H%KLE$?f50VWbM)eDSz0P=1
zd9)GNRv!~RNT|$4*TNip;&zbOyay@OXeEC?_*{R(Eo|U2p@coAQB2q7
z>Y>xngos|g%0i3dbT>{-?ohZq=|aN!td}TDubA!+Qx=QaIhH-Cm`SrI4{IIJx;=I1
zbX-DSQZ#J@|0vqur8X$ojJGZ*GyyP=H3gjuH-$KeC(oUApRm?=^
z(WO;uCRlFY>s094y1V|wd*ybP8DY{I>1@+X@jn*T0ud8i3QCUa{v}K)G^-UH$9VVb3oMX;cWSh
zdY8a?`VsuV2BL&4AH?r=J|<_=D6s6QR#Lx3o`fiLvcZ58ikwQ2`Zu8xh^Usd+*;NS
zlvzO4+o4?6v@?!fYFeGa09>cGcG3Qh+0)H|;$WtbC@%d{S{iUYVujO-6gic@LDUrv
zbi?dX!~QU*eTmhT7e~|;qUi-R1zjb#DA4}#-Dzo2Sma0CwvtH2ph$tEJ_p5v@<{yg
zgy1jvQ)Ga>=Bss3GjChDI*W)xXrHeVVmuftAO8t#S@i=v<@#$fOe+9SY4iQAhye>_
z&UiYs+IJVz`iuMTEH+nqy6(J?oc71EgV}T&Cb>0BE&jYXSVmNHN&*x}!CP=C)gs~p
z!HzeXkzHw+CG@Gru&$t$14JnjOJi;oHH_@d(sSiE@TrM=X}c6YD-EX5_GbL@m_0m#
zE78ukPq)*pMNpox^=xr_-#3IkxTT)A`)|9o%Fn-UgJ6lr=FnxYt4}AiC0064Pz;GS
ze(15m4I-u67hUr@?DX)A(bGIEr)2}d?0_rvSA>U2h#XG;uWI_!Is^H1_&ils`H
zg|0K91s?W=JH@+5moV`xQhrGbn#@oe+jP+@;N
znLxAOhpD9UuV-+al=AYt3hz`U_@{%of6+msthv3ux`4>^5H3P_`9k^qy`0YWnH}TB
z+1t~{?#BxAG5+UEz{j%GvLOD$NJ8~^_lb97UaX_s>r!6=t8Usx=cf4H`&&n{%L%DQ
zX4tmad|Z`#qt8gh;)F
zxqL)a$^(DNp|Z)-MsQzgUCb7qO?XW@AhgBRkHd9=quBn1SWJqmS@%QS_EERvO}zK1
zS5Or`l#-sF&Ay(WYdIZW?bKOHi`u`qt>qQ!&#QIZEKl7j3hY9#cBVUFPXRVOr6tSZ
zB)=eHTCc*Cw8X=|0^Pn=#a;G&V|0TQ_3m)mu_p*{*wWijFm4s95Uk_vwX7%iKSk)V
z`?%Q!ig&#LM
zU2*luUF|W5#slv9qIHI~+hLD{R?T{&>345odylUiRCQ0N%dh>b*&aeaXxtx-oNn|i
z&Qy=_`nF0^{R}n%6XnWJ(&44k6iaG;JH8BIoTgc<
zL-El;wR=kBjPkCOeYDU@pP`?q8Q|@?pEPhfxaZV7d`&&Zl^`h#3i0FvtQ7
zm5D0#N(0UeJZkX))q0N>&6ITzUBMiMdXma&irT)kY>mGDh)sX)15UzuDz_o2<2UCQ
zI%h@C-4>v6d*j?d*$+_)Pew;&!^rUOTg;9)V}l4G9ow;INY`Ege@NutS{A=6nh;*l
z$2PDKj0#}$#^=$K^+h|FXSd)0p@P%cN6y3rPp$^=Lpd#HxS*zBvGyYwtL;>$NH$1~
zBDLqSBn8R|qQ064+T<5)bGp%|ag1VT0C3GUTm(lTM;QPyBqXNFjeFjy(+>NpqCaG-
z007a43-y&m-+!?0Blw6~l;?QNe_YT`W)MDZ#WbG1h5kA9k7Ry4s6~fZJF`E*@ExK|
zmM+8VGD%bxAe*a{V%luI>J?s3Piatup`v5l9bVppMoW%n_C_x}dm9^3%IK}FEV%g%
zy8}c6#)jp0q}nUfru&lcz=S95LxE2#r1rM=xapzi!sz|9AovAJfIMD$$Kr2dJCAiqHYbeMT!vmug*zLM*t!WW((+891lc5h={8CA~Dh%QMJw-U=oamD;EZVLgXO?gZ
zjF{U&mPh61p0uCDw2qfx=q|zSSmdD_tRk!vX>oxeCPlrgr1?ycd=dN^1-@qtPXNVV
zh2Q1SbG95JS`t9bHl&H#LgAtcAzdJv8D^m
z5Hse0E)?3{I#Q^gTsGLfKc51BHv~>b|2StYwh$ZHcwl${4U2A8MwSTB{!M`R?_a;x
zRO)%OF=h$<%9-kI6#v
zZ9(XD+J|UMBePBt(eYnMXL`%Fm)z(lj7lFFw~)s0TGkO>*mf#dE|aL6jOb@2_^om)
zZv~C6e&LyiG+ZEjdkKDq?IjVfe_(CTY)xnK?hC4q3)i1&Fd~DEbLXg{
zx5h0RyC2kN)Gh%S55G$zSYLBI3CP`|NU+OM@Z_)*Jlr)$uHrQ@8
zw+VtdWh-Wje6V1q#s@V}Dg3#ioc54niL_mx*o63`kra1~`xSzq8G`$_;I>Jh#DUFUKfkj9>-%CJ4y=t!Ggl9RBVg_SS>EkD
zXaDXwbhXEtk|S0SfT=@_1*O-N=A~)rkfkrsm55^TjDSYOlD6ob2CTo#M$``x~@Iz=Y=`;;CA-}_%6M-EB
zUb-7@Z{W&7W-5#Scg+w%T~_6mA#~9FU~VvhMIZ$gvKj0|u(*AFUxpt}yM^ILJP}-2
zo2|r8c`(@hI2U-(wz?>c%9jLo`qTFnE2Be^Fq!2mwVj3x82c)2U+1a=Wa+Bxil6neu#oAdt$oARTz;boz
z_9sA`(g^r4=mC9>CK!JI*A>MG+=n#-J0!(QQ5ud|KMcVr<7S!11_(smc
z?Z{tuuqGUm=r+6OJ{jQrj|WEgq%cv6>(P&E-jT7$KQa@~!A%R#fYRzQ41MBL$|ZP?
zsJkh8I5kR$7U+>j$b%!th>WpG`J5uXKI(l&H`>aG)3pQ2%KWhhtBe9K0n~DuD{qi5
zi?fU#X}5@!=tI8@d-yYjHRi)<=kiWh0^5rmr~EjkA&R`t?S+xJ&No32o1oISQF(%y
z{dXa+f{C4~^?Po=1W1{^MbWUmX$HPT0avu7z^*k7jkjE$ft_xrMLn!C_%SJ>TqqIx
z54q#?F88q#uIO}r5A<_nj&af_f1NLW`ggmo5K{_XL7)0HeoyJ%Kk5L%pt`w{epA|l
zmy0E>n|JdqzxcejOXs6ysBxAai3e`9YW~{{67F`+-E*xG_dtm7-FIDCfli+G&
zH-z2A(P9UVl?(3`yQs?*_N9<`2EG#CDk1YuNt#t+9J%T<_L6X#bQ+C4?meO!!>
zw&yR^(ZBpX)|o7RMsk4+Wg_S(BHA`U7~)Y9xfxDT8~e3jm*Ds&-BhGL<0g+yvJOs-fj;R9
z&uaDQ?rtGsRx1H+CZ+xaL(Jn>2n+526}&l8ol5?)Tsb{8I;{3sTFNtJMFQSB@xtBr
zV_w?deS#dL*F`5xsza7v<@tuPkQovv2KyHGx_-NcpL(}1dRANFWJYJCF>?B}ufWf!
zeJPHASPF1@>4rV_9-&Wg8t^?2FA3(=Y=DbuWfU+yt0$FHcl2179-H=p2%I8YSZK^U+0z{T+N5}6S7sJ
z55caVvLeAU-xM`su8mi0N^Luoes&bOZQZ_dZI;P~WL7?$?X_LppIa3aKKFhHcme!<
zE)^LW83kF!jFK*d2ZX&TYiqjZvqh1gpAVB*^%OoV5_Vo|+@F`hn!zJmyIc3{8pt#0
zhBqVG@f%Gx4{Z<7sr=orQ@o6TeUyrecYw>Y@wgf{$LZ)^7d;H7hD;Qrim
zyU1afxruApWEz+Y5+`|U+|cf_GGj~cYrsIj9!it?rYYo5@S9Q3gn!hM56oI18;6ew2Cg*C;2T~Z$Y>O?i2H6Oa{*i;bc$pj>ENMQ|1x2v
zX4F>U;o+w{-_(PR;W##3uWF=zLQ~-;Ce7-2;PPQ8ic`r2oli^xZ>MiWTPTs-F+!*YlL!uv%vQ
z`zY;K>{cW~k*?~=ihsh3EIh;M5=|A^lbQb)NEz}iLq?sjl|x~fz8>`6fbXH)*4
zEVMjwrTDD6#B~KRkNP&D*NCakShbM)2*cdtj+=NQP^}0p^EN#3M(++`y~YAjy+|jV
zzKQpWgtKK_QPDEzHj;7#FsG)PHkiViw`Sg&x1O0D5A^Om@vMV63HS@ue;3N
zaqH0xLQq;)ojQiI%oYA4tgR9p7(kg_56jSTGn2WWSzDg1N+9^J6ZvEu3Z<0^7_M=G
za{geY_;<;+VTsmqwMjbQl`0C=TEMwYCDKssJEdab^%iIdlZpR;HFKW8QEIgPEyE9c
zUt_1yM=^J|*N^-sB$qH_)P*xJ9=6O5{rE*Ja6W1T^RrlKiiXrX=K73e{QLvIQLn_S
zj{Y5_x6E>qqu^?*U2<=AhpF?NXi5_8EUYk}9#)X$x&z1CeCA;Wfr=sU`gALsk^^si
zL_$0$`o5^=qPO(6-qLyJKLw6ng*ZSW$7^W+#kTcsZntVl8y8s&dUshDNuvhGmu
zyLH}JVS&#vL(dceHFi-=6G|DaU158+Or6%Y0k>nbM45EC+Rz`vf*MjI;CGQ-&ZyYz
zSx-5v?6Yucda-#^WYM}ed-OjO1FGVVX7gk-1a{sQpkP`({;~XSWKWr#RSOc1T!YlYyviJ|}r2;pnE49QMd|in*
zXE7P)_CR6HlE{jU
z|2>Cgm(gPma)34ohHQ3{mYL5S1arpg_;2
z@pVaeFmb++j>%_nYV|31;b^|Ru(`SU#?7L??yd!QsntB>d(HX2Ij*h}5^&hxTu&ZM
znd;4Q*bw}Gh!g)MSB$ZO$UM)o4VEfeOp)p%qL|6oAZbaoT4yjevyR(L#vBpOJeJwa
zcn}e#u(#p$&`%F*8o^@a810?c*$e47l5OI^f#cu1O>Y|cv&k{q3eLg-^+d$h$xWnQ14*l2APqXC!{hE
z%Ij0k0=`gK(>deu`lj7v6iU)(U+X^SS6MfUmdCOD{)V&Z-XyckFS-Ak#Som8M&EXx
zPOOI%a*B|JYOoV=w2QgZknL8TT87~(EMTMhM>FbU>s)_qmBjCk&qMZLQBAuS9@KU?m_1a1G
zp;#6=B4&9o=sR{W4;6owNw&X|L&>CRCCXT4v3_S*T0b#1k!Jj69dKR=GjURzOS5o!;`Pw4#*G-Sk06Gt4I!TT%_ZS-yqJzDCQsdq9t*_0cd7%WeLz;ya|vz6;`LZ8Phy$7D+%Uv(O>;EwrFqje@Wke#q{M+
zpoPq(14yDz$8ge3q=8$=n>7^fz%DCkWV)~byiZx_N&Bhn2`aqzKZV+sX=&b2Uwhff
z+X9p<&&rJ4?2UxlXG(?LRRXkCF)>ETZRwKz=zkxp$wyM{w$$m!L^tAG4UHP{#d8l&w*1brP3%slVIgJ6_)M~UvPq>fHV#%Ev@WArJfFW0}Mse3(!>BU+eW?
zQWQD)%g>xrYU1zz-$d4b9WvdMA_kHn_1!jo`yl)CrJq<{Crz9iRlRQP)O5=XOiuq(%g5(!y(ECUpb)!z
zSHjqoy`*OG^%9V09S+CtF;b2pu8j?u6@oh_|Kb{&CHTC`4D}|E6L@omjbdT=NfpyN
z$qoU6fHC787oVRt0uzFoCxgoKf
zyerBg2InXVbJq8Sxac7*tP*PKRTB>x(`aoS9+xFznAK~ONIPvwwTgysQn7rAg&Xyw
z`X9r)j#Bl7^_Pl$tysHk^;E0nwQ-Pv)!vy$qbbL$vfD}4
zDouc$Wx`ET)u`hv>H!Hn70Qr5d&jBidxhDM;TOeDpmW-}u!8I(PX_1PmQqfTNe~~@
z?gqX^=deR2Y8@Ci@vWevilu~Uiiv>QOzvW!kK5Ep_F(1%n}r>}tH@G}uaZfoK1WMH
z03p`XOw~}#b6>_gBjaf1c%09JSeo@oc@w9*D(*2XB2#Js!0blA5pHx=<)YO2ON$~z
zESl6yQ;w8mrNr&bx5;==bQhwe_D4qA(n5j;nS<~A7N-l|!Bg0Npm2Sv7zs0*SjyT)
z>;~q3nEfhYIbD71c8d-|*beJ^^vC=%F>M|**iUS{$g-N#6TbBmhs#i}YjX2n2}R(fjc*zxgk{2&o=ZJv)O
zlw)AyZ6R12Whz1+Qq?WoBvszxmUg~wp?8jXTVL4}@%(=c9shczniU0>e8&Cy1;BFB
z4uGfu)K+w&s%EZ$bicFjPs!IBiMmONcG(GLW$7oamjTQ0I?Xz2z2ub&3dzvwUfs6$
zYooR%j)IJF$K;1NVxJW(0ZGwNy2xar1%>`ZVLD8)NeiJS=_TGIIN?rclHIpOiOoPu
zXT?Ys6)3~!wJB5ylTWtV7Wz|+30)m+GA`(inYGor{i|S6nHPbsx2CAuZQOzitshDw
zTskao88g)6(Q5OIZuIfA5U%NotJWBRbRtKpeCE(lA_B_UEn2&jbzgcqpD|UldEXSu
zmYQPU5FEEUOXEJb;=b0yOrl^_XZ}@XuU0}_rI?K&|8m3Pz&ZhfaQH*CA){dw`ITn59J3`MFIy6NU9{mV#S#_ydKths9Iq1g)n}q1AMAZ|IKlhl6
zm{|co@?Dcg@;>FJU2G=W-f{KVB#*nuz>t1gaQqa(IM6u9VJWe(M@)FbbKRv$r_n05
z)rq#vt`goG7>hZ`_x^Gn&%qX@%5QLpN!Lzz8&UYEjfF0nbyke~k@3!{{4~z_!~f49
zin5QsKS=0rsUT|rC9RhPqd6N|ENiYae%7qSbpmMsqGYfLxM}roxHAIjKD?Blm;x(A
zpeyvp$G}w+(>K5_9EILY?pEnw(0s1?x5~glW6gAl!#K=c&+rL|xwv*T^Jyk|q9g<}
zOOBovq3$$Oa_>jGl4RP+W_X8m6gcV3d&lF
zR9*%ai3*1*q*HGe;+eUiyL%sr?~j$W)|sgcE*Wd}GuxG$?edjg4uNvIXeg>)JTCFN
zW+Exh7Qk{9y$Pl{d~85cYq}j7ef7>blHZ8@qrc1Y@uu&eH(evlXBt`Zp!HagY2?dbdsYvSf7R-+7vNWfgZ~b*Hsl`p4
zS4`KmfFdqlPqubkm|k0-&TZdAtYTrX9eE}q$~4w(O3Vnm%^`m!CVKeAX~3ux=~o%C
zZ@-UfSr814l}u^ZRN{^#upZ&OF{5-FlWlk$SfRVr%ebh3sVDHZr|@vzA77qsiQ
zJI}?^r8tk(2^YaSBQlk?B&#Z8zVL6~hVRDRYe9xy%UJ|($;D*M)#f4o{}59IlwA-(6`1gw=8QQn34HpS1b@9+!Jpg%7uEft!;^md@YTfPv7H9h0f
zYJfAZ@un5d8t2$cR_m4c(^3lG<3-cY#ikzqy5FOHUq?bhkAGW}N@R3!`~aO!Hz(m)
zOs>lhv0Zftj7b`glIIv|qTa<|rV07CmfEjg%Kw$4jM6A@=Fto0E@15g-6q!byDF%#
zIvmFp;@{fllP#kyOagUGGgJC4<2i#)|q5G4~zHsCT*?vb5X=BTwneY==76}%WWs?bAfc}FPFLS4rKCs?-b*CF2oh;xC3e6CT#iHnA_QCh>fN-VHB}G#C6vTfk-e%|mPJ%)uxo
z%#Akh^SSwb#f*5yk
zKUlxMx2RUt;0AFaf8o8(1^dIA@-f#2dv?~l@})~hn_uh6a(Ch4J!
z{Lg#%S2Xx{um1#*9FWRJyKSUy^jSWzAeHGYYUjtx5qvR{IOfI-VogZq`->A
zbl{@ogMCC>+%NiM_A&h5+8?FL6fUFCqXqA_6MyZQdI3Y!r=_&-R_qi4zL+iYUhj|=
z(3pAD+tcl6)pxEWaYF?tk#z{q(E!)(bH$EoNhjdql1^w7)f?_k4;W2d&zXopaBgFf
zVy265K_W-Bs;Q8r>qC``?Iby{R1jf5!53H24|^3PhixSnjq5=Lzd_0F+^9@qjrlLP
z`t-6w^S$cQ_R6)9j)l|8~WQC7N@f1r}E_r<3KD;ae#@1>W~N5NdC)@KkpKS
zvuw04M1vpoEnlu6*$fA~k8~+{4lRE#p+@t-2@BwSWP$P*M~@3s=8JjFqDH0
z+p|*PA=}5>&$LjV1GvBBVXC!4JsSmjc{DtqnEWjC`iL&^Hd0VI@8Rc7v^B8}(Q+*nWK;tsGl_(z`@aO&#vFh-3r;1IrQ-ik0xTJOVla)^ljtT^Z8SM!Q%ixt9q3Vj$HA
z{tEedH35y>dznkgCzb3KIV*T_bH5NTl?gS68@@um*G)-FbH4b@FxJpfito$2QeLTO
zJ;xu)fGYY(jJR0G%LQy5%+(C>uf40nU_+dS6HkYsdF!P=yP*kahOa0>ALI$|-aMWq_lx{HzG4vGFjo0^yB4K4mMSLbro5>r{|(V
zA)*R=8Ml)xFTyILHhBPrxccgYxjD6bBIlDOX3-*%Oap&4Bm+`6>B7k~|90$`xi25Z
zg;15Cz!xG**e^UkLR6Bh3wBuF3i4<TXzJI;_?}dao
zMk_8U0;U#_?A{Z6q>?><)1FjVY9(`#e55~qNsYF=Te(xMSNB?`Q_|IL&E2-F>J1%j
zw`%4S7*n4UGgoIPU8YR)pn1vscd8~0NEw_xWIuE>nYaIpYoVxGfsB3VEj#PZQlL+m^LkB2{Yt?|;5
zd742^bKe3{Paes_|8Qig+hiHdNH{NrS0H^Nks_s#Gr(7B_tg$tg4DMq4iF!MdrpL-
zQi#Kx3!E&=w2)$~rJ#aczkkFOZH(hFdm8cc3MvS6SO5vbu}YX9^9(uNU58y94{%2%
zg#v8g%32#_d-y>*7uejr@X*!;EOnQB7MgJ>`9
z$WsN!-9^YN{}+zAHkGAsLEwFJD(&4gp(WBUVef3rww)VzN99?ihF{5*75GHvudNn>
z{8xt(?p8MxPj=Hl?@vd^THzSSBsd`ek)^P`T>v8)eLc1G*yr3~Ct+LzlkAuIS_AG=
zuQPhU%#QUVyPcgD)?j(!SYC-!9!h)z1n<3mhp+wJHy-*Oj4PvVa^6u{Y2P%=gYc{J
zBNPq43R_xB{9WWS1TMLq5!2d68%k=*naYls@C+~EwBGH&KmJZ+BxG3{EO8DXEox&Q
zptN>(-xzL31Xh)wI^O{)t?T#AJ>o41JQ4iiVi6vZKYb^)85HJ*+0G@B#0GE#-E0i3tsWysdA-JNnp2XvZ1Q;48p8SD#Lqf
ztA8uAa5+u<*EBm<3BDKo-rQrM>9kR@%&`?{!UB?$%>*Zb-icK?5uS3pAJ$6!Y5ipy
zM*P}PgaBE+f-iTSb511=2ul22DP4a$omotqqVjAN0VtxN9*M@Nlz7lmy{q;Fh!fS$HXi|SVkBxt(oFwsz
zRbNP=<>)oCK0dL@z{kFMlJzTe6;@l-{yOT9pl?q1G)oPz$xnNlo5yfcKT+m$4KH{g
zg)dkEFag_0TsL_#j;O&x1J@Qy+JLCG-QBKneq@WEwsITNKD<-KZ_a{U&M#UpB
z$S6W~wr=@8?6X)F5;ps7`-;C(8&pa;gSq5s)f1$va1ut}v|0p>E3>r%l@W;v70ryu
zDh@^p4=IoepZ7R*w0@UE%-0T=?l6{i0-!_ti(glYac(Ii+Wp`b>o^`K7ncN`XF&%~
zy@bHEM!w*YwJ${yPNL87Y!@dvS6eB|yoZOjoUGd`k|~va5v^VNN}0cW_9F1>4aN+S
z)I9^d@oSf?_Vha}m6P{7?=4ZvZSY$b<_NFQ+vSKyv%le`T{y`~Th31Av$^)KbQ6qT
z9wfgXtFc!{D@@4D&SK3McyuAE57ZW84;d1k8{d{^dOHm_;w}7`+X{mEO}{kKAUne;
z>t%A8RI#8Q7;3{5z=L;jW^wHud8N~3UF>i~EM|_;dfL}uXrX<9N=_fsa8gSx_Glbm
zpHozbNeI!SSao?j7QaEc&sfMWx_JXySDX>)fr02E{xNv}LqJV=th&Jd`%u&PLFnbA
z|CA9?JTW3^vYmdnEul&agRWNipVQA56KQV5P^PAz7z@ZE&I89WEb&Fe!hR{&ezS)|CZ@`Tz%2v;V;U6e6Q=i-`%toFK5Vu^}=y
zd|#>pS7f!g7uC!)V;tOLm6AXyJ->1tnq8h%l6l_O|5lz~prFDE&I^pX=+)x@3|z}Z
zqp1!(2V(O7V}t)a7e7FRl9-dDPY9g)_ZRoQyf|fG?4#(1dv_3({FrZ2U#^aEs9E3$
zC)|4#EzTzsF>@g1pQxdi+tCR-Yy&sSwd-Ry+_5OsF0xFi_{Yv-U#b~5`G!3E3a
zc|J&1zuXV7GuuliG8-JKZDj1dNvws-Px;WHj@!j}Z$VI*;5LsV9JjD1ct4{j_X8~s
z^ON?FNtbZ`!tAEts+14m0V&4$!F^{##iw9n1VW?37x&mFN5N^?6_Ucm3?MVg*$+na
zVVKT39wG2TuY10~AKd#)m+1R>wA6dKU3;H%>;r&PdfAo8G4)%lX4k}N^;FmZkllO^
zO$sX26|#v4J_jthhoVkh_ETp^TI0nE3C^%~mBN~l2)4WOf_+@QnmjF9ZS1jswgk!Z
zUU<^(b<#}b!3LSP)%hy2%^;@M7*lRk8?6PtttPD`Q?uI!+>_YGtZT{jKj2%du-?UDMe9x@=Aq8;of&rwUcsjEAVjec(%P~STAFQL3+J#9
zN5H=CW*+7NUK*TD}h<=og6*&0qG4
zSf$VOGm+ynd}HO8qFC>iu_rYP+7yhsuEVU6e~wO9vIa^=&rGFm^o9MjY3i=n$eyay
zkCS+mE^1a()Ux}@U|?^J)p@W0`tt1g$8z4S2uNr^NV8zSu0=R*E6+OE
z94YwCaxB-=FgZI(BAWpgExVj)q!F67I<$k;>nnbEx1_s^vwdgs$r6`TMdl!l213&(
zecoDzg7f$G$S0?Z^?aFvFGZ}!$$3>+Fe3{);XfjY;<&BnleUhVfrUiMmdwUb7*)9D
zo%fM0l~szYN#})xm}iAG2rknUZ+yE0?KGC)G7=%J#>;5a$tXJZm_KSlM`Se^X&1RM
zX1rH?BA^&04pU=0%J%I*@PyLln}fHFhO^C$1ckX*Yx-hXpaJMbkoBXdtWfW9U~N*B
zZ=!t!Br~{HZCr90-#~YS?9y+%dwuR-WQ^*%jEUI6=9sM{qB0F!i%;xK)nZGiZ;#8`
zAy#+8QN24F;AHi1xa;u*9{3Sf3llCkRV;E>CUp>h@Ka(#hd`B*5&?wmXD2qUiOuv1
zm~@G>qmd+)SV?zun3bZhop9_a+ZM9~m(B_P0~PrSK?OLxxTl)cj~b+^jvpR3jy&O;dQ~BRi&6iQW7ci%GFO!Im==L8`aZ&=0W257UgD
z!J~Ks;YaqaB=tTW0eugrWkT~@jvM`^Jq<3=q$jx`2)}{lZTQS^Ypr;~qqnn)-zch>
z(+D8oUAvVBmBM!Zw+;&SVO4k>#4vTEm(_Tyrd#hgYzl#85*RKll`4DqLS|{jUaU9M
z+d3~*)r${IYa;hJuiQee=YCoaZzH)hEG=+>n~MZ_2Stx_jw_3b6M#Gb9bS+ct<`5WA4i6io-%s*de9sqL0@lB1~v-#+~8kV-u&MjPcc4AV8L@Z(6I)=Unhsx=lMxCd=!Fum45^)m5^N#Tq=#;H9B
zX8eSqHXRmh47cPBLPkGUGdf;G>wEsTHg{U9`k@0gA0xe5_
zy=^geitvLY_4t9?{4%6A&du--r9C_6o
zx%^8{=QnkbMB?msJoM~-2FvUg{hD)uFQYHq{_{~rT6$gZArH4!z_7QBGgZh(yAf}T
ziS5qLr`e`P*|cQlGMT36Wf2@o`01gp(_EVqSc$T|Ac}QMzX)0bxyYYN^<`z=_TwZzD1S$@`)GU=FgEF
z#;5t`pXVXjF0U
zh(7C6FO+j!xW%!)q-1qKuy+n{g@x)F{`n4hfLF}i_S#QZr{>9Z0R0eZ5;U*hw2VAm#)?yxPt_t03#)}NyYhTHgW)0|gnpHR&*v2kTfZI?!d4}*j6Rd*BoRkUVHV`khdCzS==mKcypM%~m+|`Kr-80WC1+
zAV~E5&iv*i`cN*LO6=I>)8;DEB#x8pbbq4oPNUAd*y8JejJ;{uGtd}xd~s}2^o%$`
zTNsCr>-frWj}m&;VZ6v-OlR}ril4YUC5^?&sCdvwC99`MV|+nB9smkvER)#9JS}pn
z(8e6gFrk0g+?c?sd|ctwFykGpSxCoPt&8K^yp{|0kQ9O;RC$DeTT
zW0WKzsa%Gh3FLjoj$HnojmQVl+43M|T(YZ*QTxq?RTr{vzqXg?2>@*hLUGY|@_k89
zmlgzy%I)8wyMRT=>y;H0Ui)78Cg0ZOegC
zzG)T#d!axT@e=buqK|*t0?&|(?+FEjRW+J@1fA?bMtFq-OsYVy3&3wDPUrEAM
z4-TyKMoY``V@l|>U-I}@8u0z9+DLJR4i~8m(N4WD_g$_%-e4SDW}HYDRqnBprl%1%
zY3ntodmUxu&jVy*8i1M211R+g1sLaAA*Y1fERpNXO&)le*Tux6M7AiPhAqMgbvHJaBhApyg?!UrptF5qD}!2p&HN+`!@%2#NQVZ;b6NsbB_|E
zu{M8(5h3<&J%`fDK6iMgrj0rFM@!VG1@Ot}jX=%Hi+?WD4kfWPJQZ2G3X^BKPhT9u
zoIyRa9*PPab*8kmZ3(OheBB|S#^zEz(Lb`HQ#u&fQC_&>DN1&mr?e%$=tW>u>Ttg;
zQOM+(%a=rUzn#~Za7t}*&Mp53^ho3l1;*yd0%lal(qXsOw(-iS|Jz4_Z?`=~s4E_6
z1hYc%NTaz%?U)CWQSrdXZG~)(&fun0ZV$cm!~$(OZ$IC9$7{*-!y$4QDpBxESpH7_
z7mG9C(d){mm6q&G-3rQb3vN(Xc1GZnfc2QtWsYm49jK>2#M!AsP$=>8xe@;CzP#}H
zaH6!cI(#OoVN;MNGwIx3#J+G!GCHwIc84SV@E7m
z%)AvCEp?K@9<#rS1e#q)`bLkWJ&!AnoCDq{D_^N3zm=5x_H?t
znM)*{0v&(tm}eeo!&X42IvUdoF;0)^KJj!6I*BQ2{^L1*qQa^c+^@z7Fbi0zICDrp
zoyi+@>~~*`Ne)yTkRuStT(NG1q%Os9na^kQh{{`1@ck_P4FDw
zQ^)alZsJHmQN*qq0`_ujvUfX2N%tHFQ`{ebm=gB8==Fq2vO2NlQg)eNOFf@Uj8Bz%
z?`QBOzfUX>*&KST2_lGT2gfvc>ojDmNzjkLrXNU-4<@o
zt_X}y3%uOfzJhy0(Jw&}Tw?4up+Cfa(o(ZPPXa#be2QETeRPwm<4}M+zNsRq#x9?z
z`1#e9ameko6XO|Acy4ryN1sX(5i|QYrizkh`DFSAk)`jS1S~|83MqKgB}gew&?_z1>-5|66
zNtPGj%g*kM2fmoYG?b}iSR~NO&^{8M+f$GlE+YH11WF*6sT+h!I?-YjYA}?`xG+6_
z)@>Bz?l(NpSon(3uo5vZM^P`0tzfW`sIQ8Ai--oFmkDD%mJPc!>Ul~pqNH$sXUk9X
zOYz)_t;({!@%?q(8Q0GE^K}WXC72(=(H=1r*t{?I+ah3nD|DKx_Efe26k=N&#Vr_h
za{ioqf~383`mRY*I%)@ow*52g$A-JckDb8m_YHk87hh&*jg!{vkK4w4Hv6-)?!!Oh
zWE>4A!a3Q6MGYzHbY|999nmclQB1*L(1aGnyGmz_MXgZG(64O&tK6JLkBqXH;D5BeV6^@)#fjFDC&=#9UpyNkg|v}#5J&1f{X(B5)S8C
zbZ53iXadR~OogRfxF803*(aJo;z*8YXKjzxk`Bugdfg}|4N32RXr?eiE!wIB=Y;2@
z1szkOF2=+)u=oJ1MNna-UAvL|q@1-B;v1^%|qQ(YHKtLLNETEqUub%@h
zALMcQuy(Ubay%kH_9b#sox|SvWg9fgC}3tMDH3}7?89X~{izWMvln`7blA%lE&&Up
zskULew~D!xqglo~Jr)fa@HtS$+J=ReE)rPc&c_FV+ZwpFD?X)B7Pe9h3FXNo6#fIH
z<5z|`wf21&kwAo?W(jG3Fx4H}srw`|@>re*u9Z4ulB$v1UzbTyrV%|s&KF>dSd>0^
z+GixOkkP>|C5uzZ1`!&<{>GqinNw-CdskDa8Mb}*peDCH>|V{$hrmu&_X}J4
zRz4Nuj^7&RsFb~3zY)L2p-6u=a@viEg+^A{u3B*(x7<GZ3TO5
z*|3NzAOxX3V&{F1fcrZLqivFeqE)CyKtkEa{k`1`Z@ra_h*5tn&jvbh)n*==TD5y_
z0yju={AWYw^vF>UHX+AjmY4O#?Vq^LiXGPif
zRE5UP+%ZNR3SGy2=}=L5Fm^n-`~9-k8KNKby_@V~zeW%WA?Z$fKsos)b*#vjzsoVV
zkbttB+KBB7Ua0yL*>vtCm0~r46joTi%yj!<4qNMEK=Pdnc%L%l=oBbsy?`Qn?6%xr
zrO&15xe7$Jt*AzPOf6Sx+@!|rsINpErP5Id}3R^;B)`QBk
z??
z)*9^Ea*^c1VjUW>IXM%+Kb#S~lS+Y}Rcq05F=do1^pR1t&G5
z?>{+cK(ACK{FMW`g&L+?BKL!j2fOJ*Uv>+bsTB<=Fn^TjUKQUJGhCfVe2o?yk9HNM
zpOR2%;3ch+Jd2EW@K2HurS{!2b>l_xfI~agR=6(~
zFLv8|h6=a#K)=gdYHae+M7!I$CFdj9v&SM
zJ^2UCh*my6ZN0oP#)(fA8zYFm$vYUKx-fH{#I^svaHjM)^-N$
ziN*oNqTn_z!?!oc1ndksbWs5{<}>5dC0~*I+ZK0h%X**ErgS3L(<7Q=Er~BYS8uR&
zB*x%kFs}6SW84a2J}dsIHcx&6EdrrmmuJ1i9}V>K34MwU7XTkTS-`=>6Qq!@R-t#<
ziNZGuXrL{cw(q&cBk)-*Kxn?G=v_>8VYyqxi}|K6ltAf19-$S(^m?>JdS&b1
zGdrE1HPZ$)8!RXSksI5+M=iHXfET%uof2mdH}}Ae2&LQ?O2hR0rUoM^EtTVuJ$Idz
z_M5BwFN%~b*eerNu;S^$ynF^T?)|BGlttpxw5nl3H(0+gzoOuhDlzTY<8zg`=oTiZ
zgh^u4cjyX6jB4=mQ~Z73`7BqMDk*XoZo+%=lBmN*$+bPa$8kPxJVFx3kf$KE`uOmy
zX}Tnf436K=w=!>
z%{Kj^4!HH(V27|eq6kF$E@kl0s3Mii=lOAOc0TAV2z`cdt>SE~$&zCZ7OxqYRE1TdCQW^9rQrO)BK12b`p78$
z>No0$cZap&0~#e?>v93oKDj%`?2c_qf{;Qlg`%M$DdaEJ8Z`|iR&fiEqQ?x=ZQXJg
z2)LbzekoMW`fAk>07P}=aKm@4cmL=V1Y8GHBen;VHX0LvC>ZbK))!A9k{Ut^=|r&T
zcEtjEQm>|Lk$e_Znr#p6uo>-FkoWBO5uTeaGSe@mnjF$1!+4@q68vq?dUAns+t?vY
zV%(-<$O{{`sw;qiZ1`x5g5_c~)Un`ywn?vyTWxT#$mThdsKBWY2|uz*czYB!l0P)%
zutE2!K>-^2Pn-O1(Kq`-$c0^U!9RE^-3+kaLc)6XGX{xkd_EZ!nQm==FLg~G^dhlA
z8_G=nQVO#vXcuI-^{iQAf!dK3{{nskG21HrwcS^+bj0nR>hx?FB>nSwUUHMO;sv%a
zJx*LahDoIbu*+K(y4C32BJ%8iFfV3HegjH9xnHAzkM%nkFT%wW*+b6_t0(HV`(Ib!Kn
z215biX$X&6*yoo-6GWR1tnn+}>h^Ej>}HFO!1mS3X_@;%k2A;Koyol7x
zQ~-<>I~qNK7f08zztAS72=HoyA!n%R14$=;4ym3dY9D_UF`pW7z+AKL9?a&!aCt6Tn(Mui_}
z*za}@CQ_1g@6&W;4}uFa^EbPjOS}K7&8=Rmb6;_;9VOc`t8bIKnEG(fH{B#+VkNK?~+5i&lByBxhog`n2~lSm=N$u@YBs
zRquFjx2=5dGH~u_;x*coMdSp0xtlQ#RuQRpPemzyOEnE=hvi-#{)YI+0W##rK{@{f
zk;x`2g(V|uXV~5fhqzG^OQcD2K8}ytrYLnNOBpy??`{jWL!p=_lP4V<9K~=IDpCv%
z)t*k#;+>6|F{f>sj?LKik<9cz^vj+G%$MyxJ!Y-Gt5jh^)MbP;;8xL_?aHB$?4V7$DXkPA{aHZTBVq`cN@#S;~mrU90d+}yb2WXV?##-dggIMmrnL#guBku;}yQ{5ZB)q?mxpjAZSg?Wwv
zr>{BOEhMSUM)o;IN*QzX)QHv#gpP|YczkKBQ9Xl+7LCp4L&l6vtR-4(Vfi(NGqQM>
z=T#1|CtT%@3*&n=3&g?f(~nRZlB
zKV33p3K6C)^DtK~mVT)}hiklhlxmjV=_x4-ckwMxwIiCOZY=?-ve(M2NGk$p0V#duvhGaDA#FNbr+>ni5
zESRial;BGDP>qj?Fk9w^s?TM8=g7i5;old5P^Vr2H>-BubT)QU0f8T`Ujl;zKxl!*
z-Hs&Yuwj3#1~iONPGg*u+Y)og2Q+$u@+~dK5Oh=%TD7NAMlriGUHUY%r>Ys8xHmfZ
z>XHvTX#{A|a<#=}NM;3oQ>TymHej-;C#Xgz-QMuqLlaTtoZ_6w2v3
z0K-tu7Jhsu+{+=&Qcj~p5ySLbmnKB}?Uqn6bJK8)Jqt+_CvEz{;2c}kR%Z~3z5nS(
z5~p!e8gtzZeizzZ(wC;n8!Q>K7Y?cDm1A_8h)9Z4CW9o8^jR-5;jdmZzhScuqT=$}F^v)JX|48w4Ag8I;L9Cm*z@b9n!==&pgh
zF}#UQ2eq9et+E~;2*2G9*NFaW-m?ZZyIMM0|4ce<-0~ZGOHS(`x2>6^mhSXlz-1pf
zXj3X%Wp5jKZ*_nr(8O>e-97Qa94d#3SaqPhE^!A#Lg9x>>ChzAcZ=b-Zl=61jf?p@
zXN$dAF0g+0ajjv6`kJf;v|fKkyZE;|Gz1QzO#jNYol{xa;`i`t={j{0^uX(500>f4IV*J8%
zD)uyVWmLYY1QE)!^T~2tS%?OZdd>tP3a}t2gHV0IMAtm5+>8n>%dxU_($fC>0g139
zY0e1%geL$P%Ce9@)&;OfLg-2czCE~{XD=rvU*reY>z<==H~Yt7sm~)YIqV(Pt>pH{
ze4GfyqzQ}u3T)%@)vJt*4uR^?h-SI$xz=+>p
z_z5aGMOhl01O5F{{;UM9X^!J79xZA)aQ)|efTlnxPd4`*ka^4HaqsZU1>s!&w`82j
zW?vLc_lLap7vPsri;lx-<>;dO-)UQOD_Rqr-?*HeW)w@onhon
za=%euKX{b*Y>5$$oz%!1N`E}}yR8HvcM9259Hlwy$J?`NAl^RGlkyu1-{UFt8eXUY
zm-BHBV53c2JZC;D6v>lScnw%?Pt4bt1BYKG5J$C8naWS=VtZ&W*}ODsIE@Sb7*#h$
z9h2neG7uS|f}8}d27G|sGv9yjNcRFP?k|$t|KOFC0dZ<!*!gO9Jh(cJW}_7o@V#N>!k_e;%x;5B!Ffo}tN)g50WhRe&$C=Z}DZ*N_{a1JaHLWk5vyqKU4>x1G859#NT1z8i
zuzBech|9OLmv`Fi}KephaGvk>3+I-w+^SzAAr4weEg}TwF`9KuR
zR)c4pR+;p??oFKwvW5SBvYhM#^w$~gJ2(uCDL2!(LTfXTsXkZOacr+AC);5
zCvM6=kJ3tRpHy9szigkJ4WY}Ao)77RlmkC`Gok49X{2(-)qvMWB}Sn*5V@hP*7M|A
z&Z2txNz8Q_hL<&am9rre+i@8F2&AY#4*SpKr5+FO#a%y2P(|x#7mk>Lx?B((+VJg-
z;N#g_2{|1Y@;Zy4;<3kZ;Rb(R?fgFIJJ2}u)<81&)j`2+2AQuiMv0?Mc_FIQ)gi%N
zYtydq$`PyyyGiKaCQ)&n7Z@xHCIH)`?6?)qPe}R76Swyh&TKfjq9@@rel`
z*4tiUFYr&`BuBy_;qa4)VA3Beee^*aiG&F40*9Dwr|r1jYKgPsEz~HkajI^gh^+7H
z9&`8k;iRr9$sMo(+iQm>Mk;bHdK0x1fUV8Yh1Wy~Q+)_%E}nry%^gPOXX9;U{g(f{v%dOTc2+M`aqO?Mi
z=SlO$VPQG$w!C!b!G4zV(y`(3cC+5%wVFVrLYR!!5k8`H;aHRQpVtn&aX$P%QFxUQ^X3Ebz)
zy4I(mFciDE2|$4*zk{twdH*vQduK2SJ$D@rYKlC8jP4P?6cbFBHq&oe
zx3sOP=tG4)kNuo1F}XcrX-{2KxWZn#=BeH6ja8b>4TS_fYPPTOy;6}NJuh46TUv-
zH&%WfQvAL1k@e*2+19=HT~toKSi#T^#!(txK03U2p#QJBC;)R#uYf2_!Rob6llU$Y
zt3IB1Iw&#Y(Ey|7RDR{esIi=nZ$3gQWq(cQW|YR>iQz0%LWw(_@mFRyM~t4QCr&_f
zY!qAviCv2NhZ)RuNlIH?g?ynz(Xf8?j7qElO$Kw(XBZwGdd56fB1P~uNHG%ZCyzD$
z9>iVl5*u@#k{tim`vtVtN27~8D?yA49ZC)QxHYxe+;pomXUdFt)a=SYTrC!>T9=S~RM-m>$We)hxDP(s4RVSB`F?3i^Cr1P;W9sv8h7
zu{v^{(xR|O!RAq=mN9|;W5^6&j}6B(l5by%b&CXWampb@B40s$pXCXlObr3&@xXf6
znmjc)^0L2lO=0}`Q5QbEz>1Tl@T>euFgP2eZ}VW@`KCobExmz$FM#Wg$Z
z;ta^c9tDO|X>qxo>@)3EW&BQ$1qmd(>lh}`M-pCv{yjew-b^5gOj1d399a6qQLC0(
z#Fhh=@Z(q^`LKrMk$t4NlX?7oo%L4RSl8fCeUdX_Ch!bDXEL9cCs{(d+a)f$4apKP
z!d`Zv%egf28iF-{fowq{MdIHB*1s4b-)g#_b(fOSHeYK4*}?VGDRYip`|wjdnhPWZ
zZY=JByFmOW#2gsS_=@qx)k*B;Sb<~jk5*G|^-%(`tXoNzqdUEpe+%)1E4AqQVfkhy
z@oM$YT@Mj9en7#=&ZFc6*6{DR6gI`qeHQyEx0s4V?L5aEdSb71&gJhhu6$nG6Kf7E
zMIlp#%H&cLTebFSzlThW|4D~EXM_UPz;-9TQJ}%Up@s>tNL9>J{Fl6u8mgXN0wnmb
zoQT;Gk1v4uLmcLgX5Xk<;opayM2932hgFWwkMyYVugSqo43wZUWD^n~ziEWzIl?E}DffBfjMe(ua1%uQ*=b9y1`Mo2~r`G(v7>BVH#LYF+?;C3gsn(#&+#BNC&3WoCiCZm
zH+-Dnv>*|@vLzaB?ZAUs^hU@N{}~*l#UO$yCe{)vp?Z$$(ZW7{430p7zTk+M>V#F6
zY$df69$`C1j`yq?DN>q0)jKpEJ31Z->57sPTg&U|O3~0JfHXWNAJLG+KMT5@EWQCX
zwotW<=!*~4bRx&x&p&(*hgHB?C`Q~js09ovrAo<4^twY)JLE`W%<@!1
zIO28kKV)_4m`Xju&VWMF#L_gao91#7COj^fCoar7^R`41kdWro01!dZbVBz5vZOq#
z0Mj5<3U%gazzE~muw%||0&bVlRIkXTR5EF{Y^-DRdaLXxo-9xJby6f@hL3N@wf_PE
zVCL8|L>E{FG!DDsrE|}`Exf!h{m#Vfe@qbzwHm0e_GSb4Cp*61oQAB7^OgM}pDAWb
zLgc79lW=fMxG>p_SQ+yXg5Rq$joD4-RW&jlSac|@szyEfr)Zu3E&m&8M)fbDRBsse
zumGHxB;&)knCkK`4fONEDiDiy>@|H|G^SduC1ofo#A_}ZOu-5;g|4=Y&kINb^BExi
zX$zCYal8xSPnK7LIj4lG54?!ps@QT1s-6G6gq%lp8O3!EAZtNqZ^7&v-`R2V8PW0L
zXeTaUetWV_O^V#xugG!jUg>a1PcpW|_((gZPL)d&6{=}ELtRDNJutrbaN1|0%txL3
z#J;dmF&RmF{V}~M^KS}XvA+rx*3iz~7l?jKMcMSJHKrOy>?5kc{*odaDaNoAw|;&2
zLCvtG=iULCmxKrD#9{L@TElTF4&n_1L|uGe6MjFd5EeE^D9HV#&E|fyhUprZdI+p2
z>Sq&4tkLUohV~AMo$+<{yHp2U8Eg8fNvos8F@
zx%;c#u@8D6Hh)I@dEkjYE{uhVD^sfl7U<~LgM08(zp_OxDA)*ZbRvsLlVS!pM6ujf
zec+{mbGP9=w%B052c-67Mw3gy1(tj%!V-Yc;?9)gOPF(kZKr?
z$I|>B`xKp=mMt1fd__Ka0GW)|Ux1L?rJQ5Mr~84qo-Ql)YF0lYX*3mJ#P}WXygh!o
z?d9vxzM$2p&J+#D3qbl&{!>2uhe7MpHU5&_Us{KqH0R`vR~Up$6}=QqSSSzEAsdU3
zW8a^wcOXMHL!1O)oI3C8j!O-*2Zf#+6VC=qY}{siyX{qKFZWq;gJr$nxu5cJ&t-1d
z)iicPng6eM?jQ1P0H?_0Cs`#k?avjM)_6AY_~l9NC{AwhDfsJ?m<6lYMxF}%d45oY
z%ym@dmiJ
z1El7-Y^T52o4;iV-mdeCPy1$L?P}eA-EGPU89v$M++Uig9p`GbIt$?HN_ZI@V%osi
z<}T7aBTkR$?H(mjhXjOTsr0|#cQ!JlRKv%UI;P%hxj&7r%)ojCvWjQ5UrEadzJRDG
zX$r-)u`p015Y5l^oceg^pQGH-crx-0T-!g76RqQZ7;kBw{J|8Dy(0WTDM7=UO`;O4
zfz>Rs*Iyc=(1lI)o_n%PtEu+$&fI4no~3*kpH1DEGBSF6XbM5awr5LpX)=+NTM|so
zBi=g>l#UJ|6dqx6$y-kW|3AKmZ+_!OS}Y}EBT>R-qu$f%v}hJehk}Dr
z*sLiiwL>uJwHGNjy>avxiq)%3mYZEC0T0_IPBIh`f;<5McmPO(+aioiY{nCO=w@!2
zv0ZvBcU}cmf|V;Wzd22-8^da{ST3e_foZ5Q>I!dQjosx;K>(Sp#cjR?MRU^!vIW;Ror21%G3
zkg9j$XEz6i&)~AJvz^;RDM~=kF8G-92DWm=>qRTn2jf}($Sx2U&Z>SGd<@p5vJ|=%
zqO|9b5UhA+lxQ~Ct(%Pl#gjCsgd@OI
zKw0A6ib>fWZohB~mEg06u-``d)G2P+Z9yNQT{8qAG(K@UGGE0F#OGbirwOb)U!w!K
zZve&cUHD%@C=WYoAPtz;j4|J8@L`sg<@S&6~V6GP;NZn0p&;Va=nY(5Cy9NC9G
zXj0^0I1&yK#4|Get!a#`HGUYuS)oIj_v&S_0;6c_So`0`11H00DR`Yin-jx6Y&}N%
zy1*#`jatfn-;5Fi!64N6;Qwnb1(-
zN@vLLG|QULL+x+*=V%Whld0=}S~eiTq^TN}AsY2o!2f0IR{}<^Fa;}H_-VvXWCytU
z>EXp@W?F5Mk!58p&B(|gJ6c^0vv|AD02^!Y6w57tT%W|GU7)x>ai15EJpb!#qxTmM
zgTJ@~TFqkY&qa(s44~nqrjr(Y966>q8dX+P^y1Vd2dn%5nYRA4O{_eFzB54>)gH
z@rt1d)=>Lf8GaC1KmQCvnK7L&A0o*Rbx(qh|7&Qg@lC>jLArUuUbW;u#=n1TrTQ?S
zZ>~o^TsqN
z-#4Xe%?1G%<9Zuf=B6rB)Kgt&kuvp4)15Fj=}5St%q{R&y&i(9&j?xhuq?DI?I_o(
zz>a_52%T;0VPfXKhrM0+6Z(E6JTnA|gT*kiZV;y3skq&rJ~lQ;gi=^(#C7<7z68Uu
z(rGh1EfazqI-d5kMAAH4iM!3|yG`7j>!}S`-`57CtXl)Vrs8I2#jh@q|Z2CU9K8iN22
zlg9jc?MvSl%2_?1`ehFTrrK#*VVtUJhD1eg?vURZ4x|!|#6Hs9T(LT{*?e`u=M;>64|!dCypBT7sj*c*
zH#WgSe1)R6ARdEeS+$cq*|4gr$7d9Q@ufB^>_BOc_5wm^|I&)qXW@nGTTfd2^;qbD
zeM}mKoDXpbD(W>tViBVdirkKY1iF~1HM^mP;d4=kH~*aE{%4EQ2KzR$+$ME7Q@9Uu
zB{^>QR;K727Ah?{egOMnR0cy6=6s$d6#%5`k!ZL*A~wt}`C{vcC~o;z-G*<8njbK0
z9(l6z$UoCw(pBpbV!n7bni6vBLIYl+p$IC{qnz)fv8wWP(Kb4A0oLG>naPv){JigS}9{Vrs}%n
zdItZR#!$$B-l>ftWo@QT12}D)t4*y0u0Gf68#7F;6gVD@t{Q2#h>8G)VQv`&yAiRrwgIM5&bS(@53pDM&;)Xe3nbLisy6)=Orms2k)a9D|a
zqZkSIXBMcgb&)nP+V|`pHYhL>eG=mxjiO;V0`e~dmfL|30Fq(R!P}!j(`QUV%V{|f
zOQoAb&2}CeV-Ro}6Ln1GQt}F^LzHOM%G)SM=i=%|*d=tGzWelJ%PjNJ@Of