From 2ffd9dedfc7cb84420d2ccdfda115f6eb9994e58 Mon Sep 17 00:00:00 2001 From: Noah Falk Date: Mon, 15 Mar 2021 05:07:02 -0700 Subject: [PATCH 1/9] Update distributed tracing docs We are about to announce support for OpenTelemetry .NET and there is likely to be an influx of developers reading these docs. They are already the #1 link for "distributed tracing" on bing.com so they are probably getting above average traffic/scrutiny too. - Reorganized the content into a landing page, conceptual docs, instrumentation walkthroughs and collection walkthroughs - Added some more intro and conceptual information assuming that many developers are completely new to distributed tracing and have no frame of reference. - Removed the example of doing distributed tracing with DiagnosticSource We might want to restore this in the future but hopefully it represents a niche usage scenario that we are migrating away from. Without context indicating when to use it it is likely to confuse new developers about recommended patterns. - Updated the examples to ensure they start with copy-pastable code that is fully runnable. - Added links for collecting distributed tracing instrumentation with Application Insights There are many oportunities for further improvement that we may want to triage: - Add examples and pictures of more realistic collected distributed trace information to help developers internalize why it might be useful to them. - Add a diagnostic guide showing how distributed tracing assists in resolving a realistic production issue. - Ensure the getting started guides for collection transfer smoothly to remote pages in the AppInsights and OpenTelemetry docs - There was a spot I wanted to link to supported OpenTelemetry exporters but there is no anchor that goes solely to that information. - Flesh out the instrumentation guidance to answer more questions developers may encounter such as: - naming conventions for Activity - when to use DisplayName - how to log exceptions - how to use links for batch processing systems - how to propagate IDs to and from network protocols - how to migrate pre-existing Activity instrumentation to use ActivitySource - Add performance analysis and guidance to reassure developers that Activity instrumentation + OpenTelemetry are serious about high performance workloads. - Discuss more conceptual topics and/or go into greater depth about some areas: - Hierarchical vs. W3C ID. - Format of a W3C ID - Describe sampling options in ActivityListener - Explain why some activities are uncapturable with ActivityListener and require workarounds with DiagnosticListener. - Roadmap for handling issues around custom propagators, supporting protocol updates, and suppressing undesired automatic Activity creation --- ...ributed-tracing-collection-walkthroughs.md | 326 ++++++++++++++ .../distributed-tracing-concepts.md | 137 ++++++ ...ed-tracing-instrumentation-walkthroughs.md | 412 ++++++++++++++++++ docs/core/diagnostics/distributed-tracing.md | 263 ++--------- .../media/zipkin-nested-activities.jpg | Bin 0 -> 108501 bytes 5 files changed, 917 insertions(+), 221 deletions(-) create mode 100644 docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md create mode 100644 docs/core/diagnostics/distributed-tracing-concepts.md create mode 100644 docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md create mode 100644 docs/core/diagnostics/media/zipkin-nested-activities.jpg diff --git a/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md new file mode 100644 index 0000000000000..649dfbeeebe8d --- /dev/null +++ b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md @@ -0,0 +1,326 @@ +--- +title: Collect a distributed trace - .NET +description: A tutorial to collect distributed traces in .NET applications +ms.topic: tutorial +ms.date: 03/14/2021 +--- + +# Collect a distributed trace + +**This article applies to: ✔️** .NET Core 5.0 and later versions **or** any .NET application using the +[DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/5.0.1) version 5 or later + +.NET applications can be instrumented using the API to produce +distributed tracing telemetry. In this tutorial you will record this instrumented telemetry with different telemetry collection +libraries so that it is available to diagnose application issues. See +[the instrumentation tutorial](distributed-tracing-instrumentation-walkthroughs.md) if you need to add new instrumentation. + +## Collect using OpenTelemetry + +### Prerequisites + +- [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download/dotnet) or a later version + +### Create an example application + +First you will create an example application that has some distributed trace instrumentation but nothing is being collected. + +```dotnetcli +dotnet new console +``` + +Applications that target .NET 5 and later already have the necessary distributed tracing APIs included. For apps targeting older +.NET versions add the [System.Diagnostics.DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/) +version 5.0.1 or greater. +```dotnetcli +dotnet add package System.Diagnostics.DiagnosticSource --version 5.0.1 +``` + +Replace the contents of the generated Program.cs with this example source: +```C# +using System; +using System.Diagnostics; +using System.Net.Http; +using System.Threading.Tasks; + +namespace Sample.DistributedTracing +{ + class Program + { + static ActivitySource s_source = new ActivitySource("Sample.DistributedTracing"); + + static async Task Main(string[] args) + { + await DoSomeWork(); + Console.WriteLine("Example work done"); + } + + static async Task DoSomeWork() + { + using (Activity a = s_source.StartActivity("SomeWork")) + { + await StepOne(); + await StepTwo(); + } + } + + static async Task StepOne() + { + using (Activity a = s_source.StartActivity("StepOne")) + { + await Task.Delay(500); + } + } + + static async Task StepTwo() + { + using (Activity a = s_source.StartActivity("StepTwo")) + { + await Task.Delay(1000); + } + } + } +} +``` + +Running the app does not log anything yet +```dotnetcli +> dotnet run +Example work done +``` + +### Add logging using OpenTelemetry + +Add the [OpenTelemetry](https://www.nuget.org/packages/OpenTelemetry/) and +[OpenTelemetry.Exporter.Console](https://www.nuget.org/packages/OpenTelemetry.Exporter.Console/) NuGet packages. + +```dotnetcli +dotnet add package OpenTelemetry +dotnet add package OpenTelemetry.Exporter.Console +``` + +Update Program.cs with additional using statments: +```C# +using OpenTelemetry; +using OpenTelemetry.Trace; +using System; +using System.Diagnostics; +using System.Threading.Tasks; +``` + +And update Main() to create the OpenTelemetry TracerProvider: +```C# + public static async Task Main() + { + using var tracerProvider = Sdk.CreateTracerProviderBuilder() + .SetSampler(new AlwaysOnSampler()) + // Add more libraries + .AddSource("Sample.DistributedTracing") + // Add more exporters + .AddConsoleExporter() + .Build(); + + await DoSomeWork(); + Console.WriteLine("Example work done"); + } +``` + +Now the app logs distributed trace information to the console: +```dotnetcli +> dotnet run +Activity.Id: 00-35c0e68b0dac3c49be08a9d9cab32579-0b7477e11aa20d40-01 +Activity.ParentId: 00-35c0e68b0dac3c49be08a9d9cab32579-d95f666d24193f40-01 +Activity.DisplayName: StepOne +Activity.Kind: Internal +Activity.StartTime: 2021-03-15T01:58:10.7661575Z +Activity.Duration: 00:00:00.5013965 +Resource associated with Activity: + service.name: unknown_service:temp + +Activity.Id: 00-35c0e68b0dac3c49be08a9d9cab32579-7ba0fc6d480c9841-01 +Activity.ParentId: 00-35c0e68b0dac3c49be08a9d9cab32579-d95f666d24193f40-01 +Activity.DisplayName: StepTwo +Activity.Kind: Internal +Activity.StartTime: 2021-03-15T01:58:11.2894853Z +Activity.Duration: 00:00:01.0188689 +Resource associated with Activity: + service.name: unknown_service:temp + +Activity.Id: 00-35c0e68b0dac3c49be08a9d9cab32579-d95f666d24193f40-01 +Activity.DisplayName: SomeWork +Activity.Kind: Internal +Activity.StartTime: 2021-03-15T01:58:10.7647839Z +Activity.Duration: 00:00:01.5450288 +Resource associated with Activity: + service.name: unknown_service:temp + +Example work done +``` + +The console exporter is helpful for quick examples or local development but in a production deployment +you will probably want to send logs to a central logging store. OpenTelemetry supports a variety +of different logging destinations using different +[exporters](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#exporter-library). +See the [OpenTelemetry getting started](https://github.com/open-telemetry/opentelemetry-dotnet#getting-started) +instructions for more information on configuring OpenTelemetry. + +## Collect using Application Insights + +Distributed tracing telemetry is automatically captured after configuring the Application Insights SDK +([.NET](https://docs.microsoft.com/en-us/azure/azure-monitor/app/asp-net), [.NET Core](https://docs.microsoft.com/en-us/azure/azure-monitor/app/asp-net-core)) +or by enabling [code-less instrumentation](https://docs.microsoft.com/en-us/azure/azure-monitor/app/codeless-overview). + +See the [Application Insights distributed tracing documentation](https://docs.microsoft.com/en-us/azure/azure-monitor/app/distributed-tracing) for more +information. + +> [!NOTE] +> Currently Application Insights only supports collecting specific well-known Activity instrumentation and will ignore new user added Activities. Application +> Insights offers [TrackDependency](https://docs.microsoft.com/en-us/azure/azure-monitor/app/api-custom-events-metrics#trackdependency) as a vendor +> specific API for adding custom distributed tracing information. + + +## Collect using a custom logging implementation + +### Prerequisites + +- [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download/dotnet) or a later version + +### Create an example application + +```dotnetcli +dotnet new console +``` + +Applications that target .NET 5 and later already have the necessary distributed tracing APIs included. For apps targeting older +.NET versions add the [System.Diagnostics.DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/) +version 5.0.1 or greater. +```dotnetcli +dotnet add package System.Diagnostics.DiagnosticSource --version 5.0.1 +``` + +Replace the contents of the generated Program.cs with this example source: +```C# +using System; +using System.Diagnostics; +using System.Net.Http; +using System.Threading.Tasks; + +namespace Sample.DistributedTracing +{ + class Program + { + static ActivitySource s_source = new ActivitySource("Sample.DistributedTracing"); + + static async Task Main(string[] args) + { + await DoSomeWork(); + Console.WriteLine("Example work done"); + } + + static async Task DoSomeWork() + { + using (Activity a = s_source.StartActivity("SomeWork")) + { + await StepOne(); + await StepTwo(); + } + } + + static async Task StepOne() + { + using (Activity a = s_source.StartActivity("StepOne")) + { + await Task.Delay(500); + } + } + + static async Task StepTwo() + { + using (Activity a = s_source.StartActivity("StepTwo")) + { + await Task.Delay(1000); + } + } + } +} +``` + +Running the app does not log anything yet +```dotnetcli +> dotnet run +Example work done +``` + +### Add code to log the Activities + +Update Main() with this code that logs Activities: +```C# + static async Task Main(string[] args) + { + Activity.DefaultIdFormat = ActivityIdFormat.W3C; + Console.WriteLine(" {0,-15} {1,-60} {2,-15}", "OperationName", "Id", "Duration"); + ActivitySource.AddActivityListener(new ActivityListener() + { + ShouldListenTo = (source) => true, + Sample = (ref ActivityCreationOptions options) => ActivitySamplingResult.AllDataAndRecorded, + ActivityStarted = activity => Console.WriteLine("Started: {0,-15} {1,-60}", activity.OperationName, activity.Id), + ActivityStopped = activity => Console.WriteLine("Stopped: {0,-15} {1,-60} {2,-15}", activity.OperationName, activity.Id, activity.Duration) + }); + + await DoSomeWork(); + Console.WriteLine("Example work done"); + } +``` + +The output now includes logging: +```dotnetcli +> dotnet run + OperationName Id Duration +Started: SomeWork 00-bdb5faffc2fc1548b6ba49a31c4a0ae0-c447fb302059784f-01 +Started: StepOne 00-bdb5faffc2fc1548b6ba49a31c4a0ae0-a7c77a4e9a02dc4a-01 +Stopped: StepOne 00-bdb5faffc2fc1548b6ba49a31c4a0ae0-a7c77a4e9a02dc4a-01 00:00:00.5093849 +Started: StepTwo 00-bdb5faffc2fc1548b6ba49a31c4a0ae0-9210ad536cae9e4e-01 +Stopped: StepTwo 00-bdb5faffc2fc1548b6ba49a31c4a0ae0-9210ad536cae9e4e-01 00:00:01.0111847 +Stopped: SomeWork 00-bdb5faffc2fc1548b6ba49a31c4a0ae0-c447fb302059784f-01 00:00:01.5236391 +Example work done +``` + +Setting is optional +but helps ensure the sample produces similar output on different .NET runtime versions. .NET 5.0 uses +the W3C ID format by default but earlier .NET versions default to using + as a precaution +to avoid compatibility issues with older distributed tracing systems. See +[Activity IDs](distributed-tracing-concepts.md#activity-ids) for more details. + + is used to receive callbacks +during the lifetime of an Activity. + - - Each +Activity is associated with an ActivitySource which acts as a namespace for a set of Activities. +This callback is invoked once for each ActivitySource in the process. Returning true indicates +the listener should be notified about Activities associated with this source. + - - By default + does not +create an Activity object unless some ActivityListener indicates it should be sampled. Returning + +indicates that the Activity should be created, + should be set +to true, and +will have the +flag set. IsAllDataRequested can be observed by the instrumented code as a hint that a listener +wants to ensure that auxilliary Activity information such as Tags and Events are populated. +The Recorded flag is encoded in the W3C ID and is a hint to other processes involved in the +distributed trace that this trace should be logged. + - and + are +called when an Activity is started and stopped respectively. These callbacks provide an +oportunity to log any relevant information about the Activity. When an Activity has just +started much of the data may still be incomplete and it will be filled in before the Activity +stops. + +Once an ActivityListener has been created and the callbacks are populated, invoking + +initiates invoking the callbacks. Call + to +stop the flow of callbacks. Beware that in multi-threaded code callback notifications in +progress could be received while Dispose() is running or even very shortly after it has +returned. diff --git a/docs/core/diagnostics/distributed-tracing-concepts.md b/docs/core/diagnostics/distributed-tracing-concepts.md new file mode 100644 index 0000000000000..64141672f1b81 --- /dev/null +++ b/docs/core/diagnostics/distributed-tracing-concepts.md @@ -0,0 +1,137 @@ +--- +title: Distributed tracing concepts - .NET +description: .NET distributed tracing concepts +ms.date: 03/14/2021 +--- + +# Distributed Tracing + +Distributed tracing is a diagnostic technique that helps engineers localize failures and +performance issues within applications, especially those that may be distributed across +multiple machines or processes. See the [Distributed Tracing Overview](distributed-tracing.md) +for general information about where distributed tracing is useful and example code to get +started. + +## Concepts + +### Traces and Activities + +Each time a new request is received by an application a new trace can be initiated. In +application components written in .NET, units of work in a trace are represented by instances of + and the trace as a whole forms +a tree of these Activities, potentially spanning across many distinct processes. The first +Activity created for a new request forms the root of the trace tree and it tracks the overall +duration and success/failure handling the request. Child activities can be optionally created +to sub-divide the work into different steps that can be tracked individually. +For example given an Activity that tracked a specific inbound HTTP request in a web server, +child activites could be created to track each of the database queries that was necessary to +complete the request. This allows the duration and success for each query to be recorded independently. +Activities can record other information for each unit of work such as a name ( +), name-value pairs +called tags ( +), and events ( +). The name identifies +the type of work being performed, tags can record descriptive parameters of the work, and events +are a simple logging mechanism to record timestamped diagnostic messages. + +> [!NOTE] +> Another common industry name for units of work in a distributed trace are 'Spans'. +> .NET adopted the term 'Activity' many years ago, before the name 'Span' was well +> established for this concept. + +### Activity IDs + +Parent-Child relationships between Activities in the distributed trace tree are established +using unique IDs. .NET's implementation of distributed tracing supports two ID schemes, the W3C +standard [TraceContext](https://www.w3.org/TR/trace-context/) which is the default in .NET 5 and +an older .NET convention called 'Hierarchical' that is available for backwards compatibility. + controls which +ID scheme is used. In the W3C TraceContext standard every trace is assigned a globally unique 16 +byte trace-id () and +every Activity within the trace is assigned a unique 8 byte span-id ( +). Each Activity +records the trace-id, its own span-id, and the span-id of its parent ( +). Because +distributed traces can track work across process boundaries parent and child Activities may +not be in the same process. The combination of a trace-id and parent span-id can uniquely +identify the parent Activity globally, regardless of what process it resides in. The + property will also +reference the parent Activity whenever the parent resides in the same process. + +### Starting and stopping Activities + +Each thread in a process may have a corresponding Activity object that is tracking the work +occuring on that thread, accessible via +. The current activity +automatically flows along all synchronous calls on a thread as well as following async calls +that are processed on different threads. If Activity A is the current activity on a thread and +code starts a new Activity B then B becomes the new current activity on that thread. By default +activity B will also treat Activity A as its parent. When Activity B is later stopped activity +A will be restored as the current Activity on the thread. When an Activity is started it +captures the current time as the +. When it +stops is calculated +as the difference between the current time and the start time. + +### Coordinating across process boundaries + +In order to track work across process boundaries Activity parent IDs need to be transmitted across +the network so that the receiving process can create Activities that refer to them. When using +W3C standard Activity IDs () +.NET will also use [W3C standard networking protocols](https://www.w3.org/TR/trace-context/) to +transmit this information. When using the + ID format +.NET uses a custom request-id HTTP header to transmit the ID. Unlike many other language runtimes +.NET in-box libraries natively understand how to decode and encode Activity IDs on HTTP messages +as well as how to flow the ID through sychronous and asynchronous calls. This means that .NET +applications that receive and emit HTTP messages participate in flowing distributed trace IDs +automatically, with no special coding by the app developer nor 3rd party library dependencies. +3rd party libraries may add support for transmitting IDs over non-HTTP message protocols or +supporting custom encoding conventions for HTTP. + +### Logging Activities + +After creating the objects the +app developer typically wants to log the tracing information to a persistant store so it can be +later reviewed by engineers on-demand. There are several telemetry collection libraries that can +do this such as +[Application Insights](https://docs.microsoft.com/en-us/azure/azure-monitor/app/distributed-tracing), +[OpenTelemetry](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/docs/trace/getting-started/README.md), +or a library provided by a 3rd party logging or APM vendor. Alternately developers can author +their own custom Activity logging by using + or +. ActivityListener +supports logging any Activity regardless whether the logging library has any a-priori knowledge +which makes it a simple and flexible general purpose solution. By contrast using DiagnosticListener +is a more complex scenario that requires the Activity creator to opt-in by invoking a specific API, +, and +the logging library needs to know the exact naming information that the Activity creator chose to +use when starting it. Using DiagnosticSource and DiagnosticListener allows the Activity creator +and Activity logger to exchange arbitrary .NET objects and establish customized information passing +conventions. + +### Sampling + +For improved performance in high throughput applications, distributed tracing on .NET supports +sampling only a subset of requests rather than logging all of them. For activites created with +the recommended newer +API, logging libraries can control sampling with the + callback. +The logging library can elect not to create the Activity at all, to create it with minimal +information necessary to propagate distributing tracing IDs, or to populate it with complete +diagnostic information. These choices trade-off increasing performance overhead for +increasing diagnostic utility. Activities that are started using the older pattern of invoking + and + may +also support DiagnosticListener sampling by first calling +. +Even when capturing full diagnostic information the .NET +implementation is designed to be fast - coupled with an efficient logger an Activity can be +created, populated, and logged in about a microsecond on modern hardware. Sampling +can reduce the instrumentation cost to less than 100 nanoseconds for each Activity that isn't +logged. + +## Next steps + +See the [Distributed Tracing Overview](distributed-tracing.md) for example code to get started +using distributed tracing in .NET applications. \ No newline at end of file diff --git a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md new file mode 100644 index 0000000000000..57a8c800c58d7 --- /dev/null +++ b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md @@ -0,0 +1,412 @@ +--- +title: Add distributed tracing instrumentation - .NET +description: A tutorial to instrument distributed traces in .NET applications +ms.topic: tutorial +ms.date: 03/14/2021 +--- + +# Adding distrubuted tracing instrumentation + +**This article applies to: ✔️** .NET Core 5.0 and later versions **or** any .NET application using the +[DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/5.0.1) version 5 or later + +.NET applications can be instrumented using the API to produce +distributed tracing telemetry. Some instrumentation is built-in to standard .NET libraries but you may want to add more to make +your code more easily diagnosable. In this tutorial you will add new custom distributed tracing instrumentation. See +[the collection tutorial](distributed-tracing-instrumentation-walkthroughs.md) to learn more about recording the telemetry +produced by this instrumentation. + +## Prerequisites + +- [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download/dotnet) or a later version + +## An initial app + +First you will create a sample app that records telemetry using OpenTelemetry, but doesn't yet have any instrumentation. + +```dotnetcli +dotnet new console +``` + +Applications that target .NET 5 and later already have the necessary distributed tracing APIs included. For apps targeting older +.NET versions add the [System.Diagnostics.DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/) +version 5.0.1 or greater. +```dotnetcli +dotnet add package System.Diagnostics.DiagnosticSource --version 5.0.1 +``` + +Add the [OpenTelemetry](https://www.nuget.org/packages/OpenTelemetry/) and +[OpenTelemetry.Exporter.Console](https://www.nuget.org/packages/OpenTelemetry.Exporter.Console/) NuGet packages +which will be used to collect the telemetry. + +```dotnetcli +dotnet add package OpenTelemetry +dotnet add package OpenTelemetry.Exporter.Console +``` + +Replace the contents of the generated Program.cs with this example source: +```C# +using OpenTelemetry; +using OpenTelemetry.Trace; +using System; +using System.Threading.Tasks; + +namespace Sample.DistributedTracing +{ + class Program + { + static async Task Main(string[] args) + { + using var tracerProvider = Sdk.CreateTracerProviderBuilder() + .SetSampler(new AlwaysOnSampler()) + // Add more libraries + .AddSource("Sample.DistributedTracing") + // Add more exporters + .AddConsoleExporter() + .Build(); + + await DoSomeWork("banana", 8); + Console.WriteLine("Example work done"); + } + + // All the functions below simulate doing some arbitrary work + static async Task DoSomeWork(string foo, int bar) + { + await StepOne(); + await StepTwo(); + } + + static async Task StepOne() + { + await Task.Delay(500); + } + + static async Task StepTwo() + { + await Task.Delay(1000); + } + } +} +``` + +Running the app does not log anything yet +```dotnetcli +> dotnet run +Example work done +``` + +#### Best Practices + +Only app developers need to reference an optional 3rd party library for exporting the +distributed trace telemetry, such as OpenTelemetry in this example. .NET library +authors can exclusively rely on APIs in System.Diagnostics.DiagnosticSource which is part +of .NET runtime. This ensures that libraries will run in a wide range of .NET apps, regardless +of the app developer's preferences about which library or vendor to use for collecting +telemetry. + +## Adding Basic Instrumentation + +Applications and libraries add distributed tracing instrumentation using the + and + classes. + +### ActivitySource + +First create an instance of ActivitySource. ActivitySource provides APIs to create and +start Activity objects. Add the static ActivitySource variable above Main() and +`using System.Diagnostics;` to the using statements. + +```csharp +using OpenTelemetry; +using OpenTelemetry.Trace; +using System; +using System.Diagnostics; +using System.Threading.Tasks; + +namespace Sample.DistributedTracing +{ + class Program + { + private static ActivitySource source = new ActivitySource("Sample.DistributedTracing", "1.0.0"); + + static async Task Main(string[] args) + { + ... +``` + +#### Best Practices + +- Create the ActivitySource once, store it in a static variable and use that instance as long as needed. +Each library or library sub-component can (and often should) create its own source. Consider creating a new +source rather than re-using an existing one if you anticipate app developers would appreciate being able to +enable and disable the Activity telemetry in the sources independently. + +- The source name passed to the constructor has to be unique to avoid the conflicts with any other sources. +It is recommended to use a hierarchical name that contains the assembly name and optionally a component name if +there are multiple sources within the same assembly. For example, `Microsoft.AspNetCore.Hosting`. If an assembly +is adding instrumentation for code in a 2nd independent assembly, the name should be based on the +assembly that defines the ActivitySource, not the assembly whose code is being instrumented. + +- The version parameter is optional. It is recommended to provide the version in case you release multiple +versions of the library and make changes to the instrumented telemetry. + +> [!NOTE] +> OpenTelemetry uses alternate terms 'Tracer' and 'Span'. In .NET 'ActivitySource' is the implementation +> of Tracer and Activity is the implementation of 'Span'. .NET's Activity type long pre-dates +> the OpenTelemetry specification and the original .NET naming has been preserved for +> consistency within the .NET ecosystem and .NET application compatibility. + +### Activity Creation + +Use the ActivitySource object to Start and Stop Activity objects around meaningful units of work. Update +DoSomeWork() with the code shown here: + +```csharp + static async Task DoSomeWork(string foo, int bar) + { + using (Activity activity = source.StartActivity("SomeWork")) + { + await StepOne(); + await StepTwo(); + } + } +``` + +Running the app now shows the new Activity being logged: +```dotnetcli +> dotnet run +dotnet run +Activity.Id: 00-9a41c8f2144cef45a99b9164db9da0b6-5cbc0f6836635245-01 +Activity.DisplayName: SomeWork +Activity.Kind: Internal +Activity.StartTime: 2021-03-15T08:39:24.7379085Z +Activity.Duration: 00:00:01.5198773 +Resource associated with Activity: + service.name: unknown_service:temp + +Example work done +``` + +#### Notes + +- creates and starts +the activity at the same time. The listed code pattern is using the `using` block which automatically disposes +the created Activity object after executing the block. Disposing the Activity object will stop it so the code +doesn't need to explicitly call . +That simplifies the coding pattern. + +- internally determines if +there are any listeners recording the Activity. If there are no registered listeners or there are listeners which +are not interested, `ActivitySource.StartActivity` will return `null` and avoid creating the Activity object. This +is a performance optimization so that the code pattern can still be used in functions that are called very +frequently. + +## Optional: Populate tags + +Activities support key-value data called Tags, commonly used to store any parameters of the work that +may be useful for diagnostics. Update DoSomeWork() to include them: + +```csharp + static async Task DoSomeWork(string foo, int bar) + { + using (Activity activity = source.StartActivity("SomeWork")) + { + activity?.SetTag("foo", foo); + activity?.SetTag("bar", bar); + await StepOne(); + await StepTwo(); + } + } +``` + +```dotnetcli +> dotnet run +Activity.Id: 00-fd2d1084980a7549bf18a464029e4301-a16b0c92310baf4f-01 +Activity.DisplayName: SomeWork +Activity.Kind: Internal +Activity.StartTime: 2021-03-15T09:24:00.5920611Z +Activity.Duration: 00:00:01.5323726 +Activity.TagObjects: + foo: banana + bar: 8 +Resource associated with Activity: + service.name: unknown_service:temp + +Example work done +``` + +#### Best Practices + +- As mentioned above, `activity` returned by +may be null. The null-coallescing operator ?. in C# is a very convenient short-hand to only invoke + if activity is not null. The behavior is identical to +writing: +```csharp +if(activity != null) +{ + activity.SetTag("foo", foo); +} +``` + +- OpenTelemetry provides a set of recommended +[conventions](https://github.com/open-telemetry/opentelemetry-specification/tree/main/specification/trace/semantic_conventions) +for setting Tags on Activities that represent common types of application work. + +- If you are instrumenting functions with high performance requirements, + is a hint that indicates whether any +of the code logging Activities intends to read auxilliary information such as Tags. If no logger will read it then there +is no need for the instrumented code to spend CPU cycles populating it. For simplicity this sample doesn't apply that +optimization. + +## Optional: Adding Events + +Events are timestamped messages that can attach an arbitrary stream of additional diagnostic data to Activities. Add +some events to the Activity: + +```csharp + static async Task DoSomeWork(string foo, int bar) + { + using (Activity activity = source.StartActivity("SomeWork")) + { + activity?.SetTag("foo", foo); + activity?.SetTag("bar", bar); + await StepOne(); + activity?.AddEvent(new ActivityEvent("Part way there")); + await StepTwo(); + activity?.AddEvent(new ActivityEvent("Done now")); + } + } +``` + +```dotnetcli +> dotnet run +Activity.Id: 00-e10a3a418850ff45804fef674b6ce446-7c51cbc310b93943-01 +Activity.DisplayName: SomeWork +Activity.Kind: Internal +Activity.StartTime: 2021-03-15T09:48:44.2058595Z +Activity.Duration: 00:00:01.5274439 +Activity.TagObjects: + foo: banana + bar: 8 +Activity.Events: + Part way there [3/15/2021 9:48:44 AM +00:00] + Done now [3/15/2021 9:48:45 AM +00:00] +Resource associated with Activity: + service.name: unknown_service:temp + +Example work done +``` + +#### Best Practices + +- Events are stored in an in-memory list until they can be transmitted which makes this mechanism only suitable for +recording a modest number of events. For a large or unbounded volume of events using a logging API focused on this task +such as [ILogger](../../aspnet/core/fundamentals/logging) is a better choice. ILogger also ensures that the logging +information will be available regardless whether the app developer opts to use distributed tracing. ILogger supports +automatically capturing the active Activity IDs so messages logged via that API can still be correlated with the +distributed trace. + +## Optional: Adding Status + +OpenTelemetry allows each Activity to report a +[Status](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#set-status) +that represents the pass/fail result of the work. .NET does not currently have a strongly typed API for this purpose but +there is an established convention using Tags: + +- `otel.status_code` is the Tag name used to store `StatusCode`. Values for the StatusCode tag must be one of the +strings "UNSET", "OK", or "ERROR", which correspond respectively to the enums `Unset`, `Ok`, and `Error` from StatusCode. +- `otel.status_description` is the Tag name used to store the optional `Description` + +Update DoSomeWork() to set status: + +```csharp + static async Task DoSomeWork(string foo, int bar) + { + using (Activity activity = source.StartActivity("SomeWork")) + { + activity?.SetTag("foo", foo); + activity?.SetTag("bar", bar); + await StepOne(); + activity?.AddEvent(new ActivityEvent("Part way there")); + await StepTwo(); + activity?.AddEvent(new ActivityEvent("Done now")); + + // Pretend something went wrong + activity?.SetTag("otel.status_code", "ERROR"); + activity?.SetTag("otel.status_description", "Use this text give more information about the error"); + } + } +``` + +## Optional: Add Additional Activities + +Activities can be nested to describe portions of a larger unit of work. This can be particularly valuable around +portions of code that might not execute quickly or to better localize failures that come from specific external +dependencies. + +Update StepOne and StepTwo to add more tracing around these separate steps: + +```csharp + static async Task StepOne() + { + using (Activity activity = source.StartActivity("StepOne")) + { + await Task.Delay(500); + } + } + + static async Task StepTwo() + { + using (Activity activity = source.StartActivity("StepTwo")) + { + await Task.Delay(1000); + } + } +``` + +```dotnetcli +> dotnet run +Activity.Id: 00-2bdfa9c9c73d2f41a1cdde848d686a04-2cdd7f434ce3774f-01 +Activity.ParentId: 00-2bdfa9c9c73d2f41a1cdde848d686a04-53dfb7fc5b5b3147-01 +Activity.DisplayName: StepOne +Activity.Kind: Internal +Activity.StartTime: 2021-03-15T10:45:32.3626090Z +Activity.Duration: 00:00:00.5147581 +Resource associated with Activity: + service.name: unknown_service:temp + +Activity.Id: 00-2bdfa9c9c73d2f41a1cdde848d686a04-cbb2cc0e664cd846-01 +Activity.ParentId: 00-2bdfa9c9c73d2f41a1cdde848d686a04-53dfb7fc5b5b3147-01 +Activity.DisplayName: StepTwo +Activity.Kind: Internal +Activity.StartTime: 2021-03-15T10:45:32.8894885Z +Activity.Duration: 00:00:01.0094402 +Resource associated with Activity: + service.name: unknown_service:temp + +Activity.Id: 00-2bdfa9c9c73d2f41a1cdde848d686a04-53dfb7fc5b5b3147-01 +Activity.DisplayName: SomeWork +Activity.Kind: Internal +Activity.StartTime: 2021-03-15T10:45:32.3606482Z +Activity.Duration: 00:00:01.5404880 +Activity.TagObjects: + foo: banana + bar: 8 + otel.status_code: ERROR + otel.status_description: Use this text give more information about the error +Activity.Events: + Part way there [3/15/2021 10:45:32 AM +00:00] + Done now [3/15/2021 10:45:33 AM +00:00] +Resource associated with Activity: + service.name: unknown_service:temp + +Example work done +``` + +Notice that both StepOne and StepTwo include a ParentId that refers to SomeWork. The console is +not a great visualization of nested trees of work, but many GUI viewers such as +[Zipkin](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/src/OpenTelemetry.Exporter.Zipkin/README.md) +can show this as a Gantt chart: + +[![Zipkin Gantt chart](media/zipkin-nested-activities.jpg)](media/zipkin-nested-activities.jpg) + diff --git a/docs/core/diagnostics/distributed-tracing.md b/docs/core/diagnostics/distributed-tracing.md index 13590c6680d3a..9abe3a1cfe5b0 100644 --- a/docs/core/diagnostics/distributed-tracing.md +++ b/docs/core/diagnostics/distributed-tracing.md @@ -1,229 +1,50 @@ --- title: Distributed tracing - .NET description: An introduction to .NET distributed tracing. -ms.date: 02/02/2021 +ms.date: 03/15/2021 --- # .NET Distributed Tracing -Distributed tracing is the way to publish and observe tracing data in a distributed system. -.NET Framework and .NET Core has been supporting tracing through the APIs. +Distributed tracing is a diagnostic technique that helps engineers localize failures and +performance issues within applications, especially those that may be distributed across +multiple machines or processes. This technique tracks requests through an application +correlating together work done by different application components and separating it from +other work the application may be doing for concurrent requests. For example a request to a +typical web service might be first received by a load balancer, then forwarded to web server +process, which then makes several queries to a database. Using distributed tracing allows +engineers to distinguish if any of those steps failed, how long each step took, and potentially +logging messages produced by each step as it ran. + +## Getting started for .NET app developers + +Many .NET libraries are instrumented to produce distributed tracing information out of the box +but this information needs to be captured into a log before it will be useful. Typically app +developers will select a telemetry service that stores this logging information for them and +then use a corresponding library to transmit the distributed tracing telemetry to their chosen +service. [OpenTelemetry](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/docs/trace/getting-started/README.md) +is a vendor neutral library that supports several services, +[Application Insights](https://docs.microsoft.com/en-us/azure/azure-monitor/app/distributed-tracing) +is provided by Microsoft, and there are many high quality 3rd party APM vendors that offer +integrated .NET solutions. + + - [Understand distributed tracing concepts](distributed-tracing-concepts.md) + - Guides + - [Collecting Distributed Traces with Application Insights](distributed-tracing-collection-walkthroughs.md#collect-using-application-insights) + - [Collecting Distributed Traces with OpenTelemetry](distributed-tracing-collection-walkthroughs.md#collect-using-opentelemetry) + - [Collecting a custom distributed trace log](distributed-tracing-collection-walkthroughs.md#collect-using-a-custom-logging-implementation) + - [Adding custom distributed trace instrumentation](distributed-tracing-instrumentation-walkthroughs.md) + +For 3rd party telemetry collection services follow the setup instructions provided by the vendor. + +## Getting started for .NET library developers + +.NET libraries don't need to be concerned with how telemetry is ultimately collected, only +with how it is produced. If you believe .NET app developers that use your library would +appreciate seeing the work that it does detailed in a distributed trace then you should add +distributed tracing instrumentation to support it. + + - [Understand distributed tracing concepts](distributed-tracing-concepts.md) + - Guides + - [Adding custom distributed trace instrumentation](distributed-tracing-instrumentation-walkthroughs.md) -- class which allows storing and accessing diagnostics context and consuming it with logging system. -- that allows code to be instrumented for production-time logging of rich data payloads for consumption within the process that was instrumented. -Here is an example that shows how to publish tracing data from the HTTP incoming requests: - -```csharp - public void OnIncomingRequest(DiagnosticListener httpListener, HttpContext context) - { - if (httpListener.IsEnabled("Http_In")) - { - var activity = new Activity("Http_In"); - - //add tags, baggage, etc. - activity.SetParentId(context.Request.headers["Request-id"]) - foreach (var pair in context.Request.Headers["Correlation-Context"]) - { - var baggageItem = NameValueHeaderValue.Parse(pair); - activity.AddBaggage(baggageItem.Key, baggageItem.Value); - } - httpListener.StartActivity(activity, new { context }); - try - { - //process request ... - } - finally - { - //stop activity - httpListener.StopActivity(activity, new {context} ); - } - } - } -``` - -Here is example for how to listen to the Activity events: - -```csharp - DiagnosticListener.AllListeners.Subscribe(delegate (DiagnosticListener listener) - { - if (listener.Name == "MyActivitySource") - { - listener.Subscribe(delegate (KeyValuePair value) - { - if (value.Key.EndsWith("Start", StringComparison.Ordinal)) - LogActivityStart(); - else if (value.Key.EndsWith("Stop", StringComparison.Ordinal)) - LogActivityStop(); - }); - } - } -``` - -.NET 5.0 has extended the capability of the distributed tracing to allow the [OpenTelemetry](https://opentelemetry.io/) tracing scenarios, added Sampling capabilities, simplified the tracing coding pattern, and made listening to the Activity events easier and flexible. - -> [!NOTE] -> To access all added .NET 5.0 capabilities, ensure your project references the [System.Diagnostics.DiagnosticSource](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/) NuGet package version 5.0 or later. This package can be used in libraries and apps targeting any supported version of the .NET Framework, .NET Core, and .NET Standard. If targeting .NET 5.0 or later, there is no need to manually reference the package as it is included in the shared library installed with the .NET Runtime. - -## Getting Started With Tracing - -Applications and libraries can easily publish tracing data by simply using the and the classes. - -### ActivitySource - -The first step to publish tracing data is to create an instance of the ActivitySource class. The ActivitySource is the class that provides APIs to create and start Activity objects and to register ActivityListener objects to listen to the Activity events. - -```csharp - private static ActivitySource source = new ActivitySource("MyCompany.MyComponent.SourceName", "v1"); -``` - -#### Best Practices - -- Create the ActivitySource once and store it in a static variable and use that instance as long as needed. - -- The source name passed to the constructor has to be unique to avoid the conflicts with any other sources. It is recommended to use a hierarchical name contains the company name, the component name, and the source name. For example, `Microsoft.System.HttpClient.HttpInOutRequests`. - -- The version parameter is optional. It is recommended to provide the version in case you plan to release multiple versions of the library or the application and want to distinguish between the sources of different versions. - -### Activity Creation - -Now the created ActivitySource object can be used to create and start Activity objects which are used to log any tracing data in any desired places in the code. - -```csharp - using (Activity activity = source.StartActivity("OperationName")) - { - // Do something - - activity?.AddTag("key", "value"); // log the tracing - } -``` - -This sample code tries to create the Activity object and then logs some tracing tag `key` and `value`. - -#### Notes - -- `ActivitySource.StartActivity` tries to create and start the activity at the same time. The listed code pattern is using the `using` block which automatically disposes the created Activity object after executing the block. Disposing the Activity object will stop this started activity and the code doesn't have to explicitly stop the activity. That simplifies the coding pattern. - -- `ActivitySource.StartActivity` internally figures out if there are any listeners to such events. If there are no registered listeners or there are listeners which are not interested in such an event, `ActivitySource.StartActivity` simply will return `null` and avoid creating the Activity object. That is why the code used the nullable operator `?` in the statement `activity?.AddTag`. In general, inside the `using` block, always use the nullable operator `?` after the activity object name. - -## Listening to the Activity Events - -.NET provides the class which can be used to listen to the Activity events triggered from one or more ActivitySources. -The listener can be used to collect tracing data, sample, or force creating the Activity object. - -The `ActivityListener` class provides a different callbacks to handle different events. - -```csharp -var listener = new ActivityListener -{ - ShouldListenTo = (activitySource) => object.ReferenceEquals(source, activitySource), - ActivityStarted = activity => /* Handle the Activity start event here */ DoSomething(), - ActivityStopped = activity => /* Handle the Activity stop event here */ DoSomething(), - SampleUsingParentId = (ref ActivityCreationOptions activityOptions) => ActivitySamplingResult.AllData, - Sample = (ref ActivityCreationOptions activityOptions) => ActivitySamplingResult.AllData -}; - -// Enable the listener -ActivitySource.AddActivityListener(listener); -``` - -- `ShouldListenTo` enables listening to specific `ActivitySource` objects. In the example, it enables listening to the `ActivitySource` object we have previously created. There is more flexibility to listen to any other `ActivitySource` objects by checking the `Name` and `Version` of the input `ActivitySource`. - -- `ActivityStarted` and `ActivityStopped` enable getting the `Activity` Start and Stop events for all `Activity` objects created by the `ActivitySource` objects which were enabled by the `ShouldListenTo` callback. - -- `Sample` and `SampleUsingParentId` are the main callbacks which intended for sampling. These two callbacks return the `ActivitySamplingResult` enum value which can tell either to sample in or out the current `Activity` creation request. If the callback returns `ActivitySamplingResult.None` and no other enabled listeners return different value, then the Activity will not get created and `ActivitySource.StartActivity` will return `null`. Otherwise, the `Activity` object will get created. - -## .NET 5.0 New Features - -For awhile the `Activity` class has been supporting tracing scenarios. It allowed adding tags which are key-value pairs of tracing data. It has been supporting Baggage which is are key-value pairs intended to be propagated across the wire. - -.NET 5.0 supports more features mainly to enable OpenTelemetry scenarios. - -### ActivityContext - - is the struct carrying the context of the tracing operations (e.g. the trace Id, Span Id, trace flags, and trace state). Now it is possible to create a new `Activity` providing the parent tracing context. Also, it is easy to extract the tracing context from any `Activity` object by calling `Activity.Context` property. - -### ActivityLink - - is the struct containing the tracing context instance which can be linked to casually related `Activity` objects. Links can be added to the `Activity` object by passing the links list to `ActivitySource.StartActivity` method when creating the `Activity`. The `Activity` object attached links can be retrieved using the property `Activity.Links`. - -### ActivityEvent - - represents an event containing a name and a timestamp, as well as an optional list of tags. Events can be added to the `Activity` object by calling `Activity.AddEvent` method. The whole list of the `Activity` object Events can be retrieved using the property `Activity.Events`. - -### ActivityKind - - describes the relationship between the activity, its parents and its children in a trace. Kind can be set to the `Activity` object by passing the kind value to `ActivitySource.StartActivity` method when creating the `Activity`. The `Activity` object kind can be retrieved using the property `Activity.Kind`. - -### IsAllDataRequested - - indicates whether this activity should be populated with all the propagation information, as well as all the other properties, such as links, tags, and events. The value of `IsAllDataRequested` is determined from the result returned from all listeners `Sample` and `SampleUsingParentId` callbacks. The value can be retrieved using `Activity.IsAllDataRequested` property. - -### Activity.Source - - gets the activity source associated with this activity. - -### Activity.DisplayName - - allows getting or setting a display name for the activity. - -### Activity.TagObjects - -`Activity` class has the property `Activity.Tags` which return the a key-value pair list of the tags of type string for the key and value. Such Tags can be added to the `Activity` using the method `AddTag(string, string)`. `Activity` has extended the support of tags by providing the overloaded method `AddTag(string, object)` allowing values of any type. The complete list of such tags can be retrieved using . - -## Sampling - -Sampling is a mechanism to control the noise and overhead by reducing the number of samples of traces collected and sent to the backend. Sampling is an important OpenTelemetry scenario. In .NET 5.0 it is easy to allow sampling. A good practice is to create the new `Activity` objects using `ActivitySource.StartActivity` and try to provide all possible available data (e.g. tags, kind, links, ...etc.) when calling this method. Providing the data will allow the samplers implemented using the `ActivityListener` to have a proper sampling decision. If the performance is critical to avoid creating the data before creating the `Activity` object, the property `ActivitySource.HasListeners` comes in handy to check if there are any listeners before creating the needed data. - -## OpenTelemetry - -OpenTelemetry SDK comes with many features that support end-to-end distributed tracing scenarios. It provides multiple samplers and exporters which you can choose from. It allows creating a custom samplers and exporters too. - -OpenTelemetry supports exporting the collected tracing data to different backends (e.g. Jaeger, Zipkin, New Relic,...etc.). Refer to [OpenTelemetry-dotnet](https://github.com/open-telemetry/opentelemetry-dotnet/) for more details and search Nuget.org for packages starting with `OpenTelemetry.Exporter.` to get the exporter packages list. - -Here is sample code ported from [OpenTelemetry-dotnet getting started](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/getting-started) showing how easy it is to sample and export tracing data to the console. - -```csharp -// -// Copyright The OpenTelemetry Authors -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -// - -using System.Diagnostics; -using OpenTelemetry; -using OpenTelemetry.Trace; - -public class Program -{ - private static readonly ActivitySource MyActivitySource = new ActivitySource( - "MyCompany.MyProduct.MyLibrary"); - - public static void Main() - { - using var tracerProvider = Sdk.CreateTracerProviderBuilder() - .SetSampler(new AlwaysOnSampler()) - .AddSource("MyCompany.MyProduct.MyLibrary") - .AddConsoleExporter() - .Build(); - - using (var activity = MyActivitySource.StartActivity("SayHello")) - { - activity?.SetTag("foo", 1); - activity?.SetTag("bar", "Hello, World!"); - activity?.SetTag("baz", new int[] { 1, 2, 3 }); - } - } -} -``` - -The sample needs to reference the package [OpenTelemetry.Exporter.Console](https://www.nuget.org/packages/OpenTelemetry.Exporter.Console/1.0.0-rc2). diff --git a/docs/core/diagnostics/media/zipkin-nested-activities.jpg b/docs/core/diagnostics/media/zipkin-nested-activities.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e641c514a38f7ab62310853f169e8897584a5a69 GIT binary patch literal 108501 zcmeFZ2UJt-wl*3RrHhDwfPzXBsUk%Xh>B80dKV(nK|q?cKm?>W0RaIaf&x+_C4`zt zm)=1_354DgYJd>_ci0=aLq|hRO-oHhMaw`- zOGi&WsAw)QGSFZ6{rvZr{QmgwPmv$=)Kt{JulT=roc;hXQJ)#3e0!GSCg2Pc#aSkb z(-r_X06=k$Ozm%i|Mx+0<}Bs8^JJ1}>BtwrFOtbWd-e>O*mIPWorlDnJyTZ=F$1iY8@V2Csw9GwOIi<%> zlvPyK)b;cY42_IUOs%YKZ0+nF96da}-gx`?`h~m;4GWKmj7m)UkerhGF)cmk%h%kz z{BH$?!scW?iIaCr2a zFABif|BJ1^arO^155<%3LA0=d$ zHPZ0h)y1*AbRVE)<&~V}!~bUOKREmM7z_R%arQUH{>~Q~K!28kym@Dt06+kNm3vQP z_wwp1;A-l!;D{dKW6BTNd=0uE$L1!S17Qq)?dwT6L6Vpc-bFMA_zP`v>G_?js+gvb z?ZpP*{>lk7b=?6wb#qcIkyU7U4m5j(masp=aro4T^~JJnf2ZxqipUZFzSbDA4(c0( zI|WFzTC;c@IZcKPN{{M*E~kEgT=VA^(s{zNC(v~6vd)A5vrohDP@+Jg&zyOP#(?LP zlF{%c!dE)QaLY}8LchZK@wqq_wR=|qT8@CeoTyuXoT!O@*SrCu*f(?Z&;5f(tJCMw z@4`peZEXQ@%IacT>VTFUIBHg546-a$1etjbol_wS)NY-ehr1H#l8E+a`J+Zp0q+jX zPXV7tOHKhn?vPk+T-F+DmtzEl6V<|hrcW0#BQZ~TlR``pq;nl4Nl24_=_#P!$?z2L zqXyXaR>Ho-m7wK?Ibv|c5ZD9=1E&C*&AL;-!xFPoz?u0|00*Gs{~t8iwI)ezAd|cV zF>c)Lo;)iedwC0rgDh<8Rs zlkO7Yj$4|Ro{hCII)7amdoAJn8lYyw`y%Oii(g7|eqeXtwM-btSW8uE;-tfwTjL8U zPd+X@(0<0KghufhbAjb?A0uiE3U0~hj)4dD65XosvBewtt@DAT9WA@){EwFWU&6mU z`)Z}WB0#PF>A7{*Q07FGACYFWPw?bxAYC60guS|-VZ1W-xW`WPo;9#}k9*d_AM}QB z3YaBAD^Wj$>`+5_Ltew-y`iE!xA5vzJXx=QkqmIX`FTBG9F160sb5yZle3dK3*{22 zfscfC<1X|~TZVc%p)k4!HcQUAJH);=d6n5)^MqyW>&O$++NH1*_?}xpI%;a?I_&95 zJjwxdDexz>QY#z`nPmWKjDVkfksKH|b-bvdP`@EBVfJ2EK*g#`?`^T-E3aj6FEacT z5Nt{6N70=EY#`{I=5`2+ylkltRI^{iBH$)QBba@@YB;2QzPCfT>;^T`lHCfvFV3#5 zGBKO$nA(6q<-!l)IY6nRK;^`mqt;_vNaHi2@9}j=qk?2nU*u>Y+jqhSUbM|?u<{zm zsQu@Gn_hsPd+BOwJ_cj21sH@V0flvAeR8Sm1~$if1gCvg957biYc5lz*+L3em3<2y z;gGVCT`c#UjqX}e?nn3Bgv%$NyC;moC==aJ0S+L7pv*eou?gX5r*&G6pny+p;ks1= z*U+y^$7ic1T#guc8Et4h@Q`;_`;18>Wto88KH#LfUf}pCX_&jrJ4o^xu*EPP)f7Nw zI3(o@n+dz`l=dt}oAZsDd71~E`)W9)+Zc1m*TS)+PhQ?{mOohPVx+#f`d8%K)s8Y6 zc;vU|?hwdm4Rhk@_F^RPVb)Ip_}Z>H;5!mMVF(+$)IwG|!=1@Vu?WiwQpcElSb}Zb zL{}^?rJS$-{B0TW8|Kec22s~e0W;8aqYeLKzQ7)&1ilwhK!D7;Heud1>*6Vo9=~)p zoX_BtQ7!5J613g2-mO!u{TV!w`hz44X?&!3KCm4rdy>OTFq+wl=m)fZOH^y5M>FGr+{Ly^dqTQ* zdap90kCFgV!=-#jDwnx_HT}q6qkK-og`syck&Ww%{MdW2T19{5Dd3vpYl7|eBH2@` zmD#zuF~zAdpZ#`E{_0y*%C|ItPk;-3Gx5R2Qm24$3*q6#K}iua?IBTNt11p;-YDxp zah~hlCFUl&Yte7b5NAq!%w`r4EgLnYRvZReqWNOOX365otMB8L-MUJzSMiDA?~NDA zua>gbp90kJ4burT4WLJH_dOhndtBu=JHf5?-WzC-w~QY>-uqoh&Yy{oF@?UZ{8+p` zQSFA=RqTHLd?~^7!vJZC1ce071O)L9G?5>{_S@o zjhUq?MF&|9p(*YY4|weWo-80G!q_+aBb(TeUn@pOUU`|)seHMeY75g!yc@DRw6#?W z?}Lj&Rnf@9k`l1lFdQ0b7$|u0m#HI%ziBEKipAs8_dp4AO zJqj~|q$QXhD1UE=HXQb>^VgznE^(xnoW0w}^PF1whYMh`wJhcvC)GjRy*@6mIkesM zvZ?F7a%`@tlE3t4)>i&5&09J*Y!g)k?yKmviHqOMpCZ}~i^&U~e0Wvas`oW7=76^R zaPUDY-Rrc&eHZ%bpE~c`uYY2qC06;L0`|!W!-eZp7Xn12fo$ZhqbfdB5bp-~^)8vF z&4r;YmzLelj3*Dbg)MK?yy3Dc@ao%af@aYFu&(Xf_pca5UXQ0=L0-?=F(^-86wzhM zRa^!~bp0HiHAnW-7(SuuvUNt?qD;srB=x6f6=hGMGsPZ|1a8rj$1od+7y*a_a7q23r$Maxn0VfIKMU8Dyv!Y zRf$`>#Qcc;%H{OF#Py0#0oVjWU$)}+ES{lWi1G~@ES&IG!o7RFcU?`^&Q{_4YXG~{ zEtjb?4RiZECtvFC9|N_pS{nrTdAVx%MTKHI{zmSMx;Ms52V;4D+>SUu!H5G_v{{=e zV|d^VpD!AzvzuX}TUibpUdCIZbm~dL_~+lIz9(Ll224~lp%IW*Aaqv~^cv}kL#=YC zb78BuLxIX0&7NB2NRHOqER?cKqV-l+y;k%H%yU%D_f7%Uf}WZ#=8CQy4E#rEZlFer z!=Ua^K<49Vle2*K_zb%Cr$*hC6tJ0V5)7{Gej=HjzA0ngIHlXxvCD(EEE9gtWF;>j zjlGi;V_)OCKOl*@V6u!rvN_m&uc@f1fhgRpF@EYnllvar*hpXZx@+>PQOYt$H}dM( zD>yX^hZ9}ICXW$if%S_YS1-CHteM+ID$1F!i90s6D-TH0#rj!FfAPvc`P}0bDc@6< zm#!IQ-Fz{~-N55VtAZp7y5d@=BQ!-snVl>-6b7~#)!J6%p%t^gO+@ZRRGM{c?mCFf zs$EmNG*JeAuJpmJZeCun?TVpt(6N-toJNMpuE@&+gF)-CeYJ&Xb>J%__;|xj#3gPS z?+n(yOpp3ay2@d$t0&nbfjsu;>D+Al{Vj(={`_y|EBoOah;54CmY)koyeWd*DWP$y zGgfk1Xew>9k35J$&->;#Z@IikQi~Hrc6cHv*`pVg_!ot^Z?7S`%MVQ{mH4~j=hKL`_ z{J&o}0k?GtCP>gygfz}XEy0k|Q>$nm^z`yHH?n4XDR}w_J3e1s9%aIztl9_>3-i9+ z8?#csVcEv%hVL>-U(?OJ)Jd~<@0F!5PizI_FCt1XNmv=;S=0M)37|h@Se}}?1{qrV zzIuPEy>Az>c9bEAOMM)+)xuh3ie5$d@rACLD|zL0P(&HiGT<*~&=;EoS9~Jodp?gE z!wam3LS`H8@MV!!2USIjOI+=cLlzTS@f*AhxXF~8HnAV6?(1Dse&T+V+MZF@Hk^)m zgqzOfFFV(5RBmRbw)kA~*t^C%;UjnIJ6#^iMCSB(V*rKX>vCeD)7NnaVe&SvzF6pmK5Qn3 zl$&Vgg|BFjr>&}bOSfgsOG0An=U5KdTH=Etbi0@^E_Qh8%yZ^7(#^VxeiB!HIMGcw zzx~WcI#y#eVdKl2IA%9W&ac`^-y=e|L9UG?+L7Ipvuzya`$f6@HF+jety0sU4j5e! zc%d`6H0H$zGc1$!G4n1k2dCxy``n9hmsDYBeWu46-l2 zLpwg0m^C{HCvM#C97O+UHGSFu0DqYSQaM5xpdEepJ{ z4I>{yc4392bAc_>lz5|c&CkTAqs~(1Ak$HKHUFFr`%?h3q}aLf#>-5~tIJ2pm02E% z^DN3g0at0ap%YLnIe!AQ2S!&Z%HlGS*?B!!1+H;;kMxm;mz&kMCWgwGu`{&wg;=)@xsV_=^ts9C{d7V}o#b+&=csCu+G?)y=tjQHfUi1?jxkXdk@ z_6zZQix~vol%wCt6r-(u7gU#rte{6@N$J)p;B6=7P%0jbgAy+tG;uR2ULbPdEs~4Y zzEAm#wI(`{cn5k*?ELxi-g{-|iHv;0H(kdQ%m)*HE-PCoqh%rIrE!)5@5aPQesFc8sJ zQsPi#Lte8pV0l82jaA9iTJ2N0jfSIBz)KCUyIS(%3MG>lMz@4q#Cr$xl-;_lGc#4I zSGXKxNUU?6iMyIaqfzzMmBNBQm6@PpW%!r$AaQ4S) zWPfQ z-aW~{GyecysP{86MU7?G4zuZ(r%z)Kx-NyX%8V{+Q(MupUy$D8P4oa890y>)YWVXN zkU8!!2yMOPNrhdW$)R6drtjsHn@!^)IrgH?n>n@dV0+|C-!^HU`{!3QnXOgOed^6*ySPo`;i>TVg5!eIAwH23j|gKMBRDp-laD|rAP0f&QO&TJB$Q#A zuc3ZyuwA6(Z8K+L4@VBy^X<#@FDsGv1E;5@PjbNLz7hOewC(xFbnq|m9vaThydFw& z<9soOKc9vM_Fb#jDGbxQfu>V!N%V z^iG-i)Z3;D#lAha5nk74%T15Ahd@WVPz>@5=mI&1*a*puAYCI;(?;!cX? zJ_KGs#2x5XM0v?{IJPF2>e6o|-iiR-`M@pK{pdB#O|4i=#VLRs1==~=sSnAUIb299 zTCKH~D;Vl&QkZ(Do3cH)DDM4G@BwV0nx6GBFa3-SSeQ_N6$=Jklti)kXc^V_*DK|8 ziweU^K(F4Tl-Biwm4wa|(@EZs-EzeM2&Fo zy05SrZ_-ocfZu88K(euKglF*(#F6|Xo+3g@cqvSqucTS5k-_L5r-obp_&8s;c(j>} zN&3UOzQ|9Nj?cq7nm)t2xyN0VaARZ+9AM$5t})ZSK&n+Pfgut2SY4fT%F2raH<8A~ z7o9J)ZXusbY_Q8-=?NSM%Mh%NZ;?7q0hey#AwL*nP5}VYRi9vIi6!OXxC(3tRzu_1 zA-C#d;KrW4sVvh*7(0kkb*A7@{cWHfq|r`Z1!vWQfgePg&4z_zT^R`B8l!Lqq1MsV zHz~LkZ<(r{kLjy@U1`63(RT~Y%bf(A6e7v#4-cXwA*0x0jhw{rz=O>D ziCWlPylv9lug_JfCa({~pKxW>X1wo_YWr!apW!}1TyKqoT>l0raRMGP!MVxG4?hJA zcuOUjjzYG19D#eM0H;$x&ZhktZkp!2NkY-nc$0K2Mm2Gh51BG)Yy4T1GUjba3SHto zc`PywPma6yWjW6Rd_h)n=_# z)qyrJsjrX+Z0#c3MnLg(gJ8LR6+W%axTqd(u z`9ZH!eAP*%moqn3G!q-k)1-K2KuSa5(VAY3zk-~umuxA|9d-UhwJd{}BE_4ba}S<> ze?AlDcnYWrMEK9%$u{xvXfhQ|;tKJd{pDQzxu!*WOixAfon%rSyG;B0ZnLc_Z?_nz zL|A$k2$k@)L3Vu$eNfeNf)WAl!bmDwohLGqjN>6qfn50fpkgTu%VbZXPnM>TZnSce zs?RL)dwre0F=^y#x7DW~;5PFhHaNdfh+6N0ERS)I%$BvS2>;rC7n2LE4Z4TBoTSA@nKnX)q`FIl@JyX z;U?tLlmoU+n4(vs*#lGQO7TK$= zEa7c;t~j<}gPY~muzQpl$~sqbZrinOrSg-Z#VgcBGooC1zvTe<&bi*q&l>6Pw-a#{|(sDfH`QsEuYk&$HmpwSvc zeGp>3b=GHRhV09{Gy=R0`$e_hNr9N1QbFT4m#3mNDmZW7sH44Noik_uBB}@ev2dpf zSY~Z;gCJ8#K&Xun_1svYIUS|E2Nq1}ed<|KpH%iOeYR&N*Kc&TbGE5I~WrA&OcNBRQ3MCfwbpX>$ zVoqFirO$t7J(5lbMM!6TY703a>6U-G)^$as(q$^jOL#%2y(k&!q8Tu~nN>Al5?R-F z>~#w0fE>I2mA)@oFKBHjm}8RMWk7~%0IrGH)d?| zEA|V!WoO_Jcg4BB^&Oj8{~fpDE=z2Y??SMM)sp~jovK83Y1PDu3go~Jj}X<3kT+Yo zz>QX{GTtjcVwPNy3@)jEmMT7pS)IViiw32VA)?bP!7FTt%Pvirf5#^5aqMKOeb-|X@5Em& zY9%zlS5qMU3jDdevRMd?Q!OOYxw6iw&Mdbf5-^l~$E;kE?N0T}3ucSgv)*11iX@}O zcztq)ozrYenUjt)K)O>z=GoBt%{!(JqXQx3w?@)3*m)DXyEQJU6~eX*K4im(EHqMj z%z8~p4ODcu+D-vKlTHC_b>0Mx#Z7llohN7hGd_{3S2+b-51=B|bCQ#VcE#zVcy40Q zF82}6^+YhM-2Uu_7C~l$q#HQ{JHm|scf%Y>5kmjN;+oMH;_Z`fU^CpuCk&bR+M&6o zXbotV_?PlifH$s~Y;hb2@deAHMpe@QJiIk|uijgFjLF_xi>2jRcH-j~A8l-|2j9CM zeA|^^%NPmS)spuhO9Lm2B=h_i@d7s+l?wB@d;5+{Z%oqXB#w%hg1)Wvcts3^#n)qmNTES(+Gr-`b+vUX4Wdu`v@^Rq3VzGCSN<;{fnaDoax@@ju_O@qXqWOvg z4+9UESx!j1A71Pqe^7;Zm#PJIB#t1Nz;89 zdb>}so8B8YBGTU#wn;=K#qZp!gI6Rj7`{2YX4k4U;nW%kykz!ERr3D%Ih(SRHAe5X zL!&sY`;*<fHx6lAmAdjOK}jK64~;!t%yiIcwK2ke)|6`>E)j zc!O}=+?P%P%UM24rvOSB5YZ+6ANSzFRS}k{|H311_M;*n8C}Wa`$*I-D8dxrF9QEs z!T(f=zhv+~48dPY0*L*~%>1_Ce;H~rdig)WlQ`KYO-$M&QkW!R7|luM&#T$1qeRI8J+kzLXVWBAdguH z3}ldWi@-Cd6%N7a!p^Q*T*t*n?uy8nIX@d0g)`jtH@48rpA?U||4p}5CxX5Aa#kBE z(4O3p`nxOjzno_mV81+OHq)@&=m>=_vw2M(Z?&|=4nWxyFI zXxkD<30Z&8580hM=eMU%;^!+{g5vtnGQ{I2rvUJ8*nRQ^(pL#O=y8L>joLt$z~sC% z(5{5;$#7t6uFqU6qSh8cHI7Z%sKPHFAZ}%3YVh-gNq4dUMQIwZ!#0xeNi9&?z#Cwi zvVJM<@1}$<>}3wF?@+raP?bp)G~iCOXtCbG`!??zhKFvSF43wJiw?hj*>M)Dn|>nY zboiue{sR=ViTbgQnuS)n9_~kz4#_dgvGOSZYLD7VKXl!9IYG&L*^oP%0EFzB_=p2? zf{OvJb@jQA(vS4Q#>)a4!yD@*r5R5%6WDJ0WD; zwTY@a$*HysFLSQK=cs5S3nNWXt&``#o*41&KDkz-H~_&&LYjg0n4Jx_lN}4OZ-FDo z>nCN3VvgJw6wmu)XbruRXZD~El*do%Okf~3oyuG5Q;O^?*z}F6_uD^X>9317cWlEb z@Mrf4_@y6Wgxidf^$J*xYS+Ls4yJbDl|7FZHfGi8?-V#f9n74@dG!sYx4T^Df0{?N z4LyFKQ(NG4tNk!Db?VD*(xAeG)~v(F9sf9|9L+=XTvr2sB)ViIzJT1V`Og-12Y87z z?3daMoq%AUC6}(YDsuS<&Dua?c;T!Awlv7GKvDin&N~+@5f3Y?1`yZJsL3BR0WXmH zA#k?lYXaEEDArkm>GZA2c*6lOUmn4=tifoD2(9 z50@8WVM|?T>veL;fYZyx8i5Xx-NWOul&mN>RE7fL4;v2r8?~@>XP`?T*P7xL9BWyj zB6PM#uMxy*G>d4xcDwCzRugWL$INWA!^zE=f!zI9lM$>{FFg0}%zfu#K`BGT+uGT-@eUND21Qg!h(nq<%4S!ZM z17&95Q77D=Ig#j6)vIJW2(o~6tdBb-MR>AltqfK zqNB|Spt=0Uz6-0;(>JT4ZY{)h=?C{L2Jc@^P;Y=Yz011Usb9pxbGxZL+2D%0>w0^} z!kbd${0Se|=ES3zT*J$$XmG)9136&dU-N4{1TAwD>^3+_0pu5uWLNq((@@L(j$>mi zN|D(Iq=!uHYZ&&7)+maU4&CAP(MkIbILn*#7620?=U*ZN`xSXk(t);SeV52p5$WE; zJ+1gP`n$LDC?$XMjJ_+IS$_CgoANi{X7uA6UdGz){nVTys%r>tSv|Rb_?XZuT`I zZ)*xX#%=5&Lg(I8$OU{Ny_UhHO|sj5aN&*r5QBePvgPho0r7}hBk{pUkESGQJv@i- zs8hhrgE5y_Zl}L1HaQ>kpXx5PW7LLKAF4`CGxu&&(pwe*TWa*xV| zrLL;_5s?jnD9PaS<+d@BA^Z|QvV1R}0?`Sc6st{=|2G$O2si3J(rFWl+yF2x&1Eq6L0@37Uq9iJ@PVX6nasf4=c8gVgTPBgg(H1G*?91$hCgrH-B{CnNap#xV+tksp5*0 zgW~fqn$@PSVak*Na4-yF>!<#9WILw05hO*iYkL4nJ7Fi6$}Zq_IHV12yiW|FX7 zqs2AX^^aCVn_JqCO}i^*eiWqg&LpZyZcQj*#abZax?(|DOysc@hZ?XTRZP7~;e<~J z_Iz26J*(|~`^v-8>!FEGZVudAIv2$aY^N!Bv8giEdAlP*zIEVA6hx!$2He5Dw1=2{ z3OHm9(E9_J;Qsr*kA;)k0_DS7F<0oNAys)H_^qGc(;dKfthmGIgWQYu6FrwlUo)jC zdmxqodn`TVoGUlb2^E3j_UyZ|jA8Nm2|s!Docp4WAO6+#@*PPBm(o`)e3p-u?OlZP z&XrY1T6N4DOib%+!VVM~oW0Q@s9h4V)%M#z5H#tim(lIk%*gD`f zouDSO;4M{kV9{%2IP|QRQ%-ju+3F-TF{Y}pk3horRton2IkGT7o*@ky0$JrLaEo*L z!J2ff7K*q^E`D=%?0a~vq;`EL$Yr1`&!G8Yd;iRs8eR+A3&mwMO0m(tocP4m@WQ7_zS=j3`L2CR93Fa6pWcuKO$f9-Oz!pn zXExeVL2N$cJ#8i*^i-WyVofl~{oQuj0dr6v+31}K z95{l+$lEZ6Z|ySvZU|^V_}5WOb@7HDtMj()M}F}(?_^g~7P?Nw=Qj)ik$aFu0%%v< zAb$e^f5d|Gm5_iozZ(UezU-AABWh`%=L*jAKWMf1LqiM+d=P@zB;DorC+ZYo(i%y zxY3<(_Z#2i6?T_#d4mA|{T5t)SRk{5g*dt4I9zMQ3%bsS5O3cv@=uU|ugYtF{HX0^ z!pE?C2E1nnqk%(96ZpqdfhZBsGHKD_U+BDD8>CVtj7U+kw(s{fRa+peaw0(eXkH1) z%XUfrbyK#QcN+TcI|JFynR#p>fq6fEh-f)?3k-yO_9<%eYuKop`t`8Xgcpd`;g_k@ zkVdN#acP! z9bcu78Kb@zWHe#eJTV-EW0U^MYB88f_yXa+4 z?Z4jo8({fsHU8)>|5}Z|R^#6^4i8SCyDuPfzcVQf7oq@o3=2`A0taeEy%Te~)Mkx0 z@4U)*^mcXW$f(XJnfQV{g;Id?Cbg}_pNKoLtbPFKJh}YOPKsF+P78J@4h;tGU$+My zxdb=()rXU4$i|MJ8K**OVW2t%X!aYy479K>&A7=4(Z+{FI&9Ub;zgn|4jKj{I>`ndKr09-m))$c&1Xn(}D#qg&SCQL*xHWymeQ%Ou%5_}u1`KuTfwB5%|&>*l_OFF->hvh8lI z#9Kz!w4iS&xBz*o*?H?^kCEJHpvUNyw^y-fQ8;?YpM(h5?e{oHNw*Lc8<;)?$aIe! z`>ujRaMAlf?rTKBV|@a!t@arr`xl`Z8#`K%<0$rOf2hSsYlxvL-+KN0Q@s`w-lwI@ zAMJvLmXrw(@pWy`GJy?L9`ONA5#feE+rq}`=LOrhO_MJppw?@>a$ys%4D=+5o4Cb` z{j2VlbLj^iC7l!iPtLkRw!T3KwZK2os{Oek{p+4ZujGlZ)fLRhw>3;@C%Uji-+*=1 z1?2BCoeB|hs6+jPR8p-Ec^tDjW>FIwaWah_;y6R7>uevZk3jRNT{m7V9N{+qAVk6f zeZO+Rt)}_uyUeC4G8|I|#z3p`H*SzST#Z7dG~xl^Cpb{3=dQEf)AZ>H{rHaI(3acQ z1}F0`^`}vR5?$}}$)olA4CLogH!Q+!13t)Cxqle(h!Q1#17V}9ECGd!U87Oaw$Ttukd0k5^bgK16*>&=g)h*!ytHqEdIAhqJ{Rq|kJ z81zEqxxP^O`}`$e2+7WK#yK^?+jr+DXjt?=)cMffxjs)1E&B7as{8{F&(!5hrjL;& zJL*Pz^$YV`Rip0edP|6Wo6RN>KU1ci0h29Ayd?D3SXX1wk2>=UN0RSW-UJ(9)o!pF24&upa6zjAKAi$6h!l9c_ALTGwDp>u32r)f78Z$O z^uh0Z)1Rk3);iXO9Gxc%Bu1M&#p(%h)H($` zn7|yba+5@pYIU`Trecf^^qrkRkT6cnjQP}xhH;IPgDg<`_|Qp&ZO4~q1`+|J0XyTV zNYq{UBE4Ficf=ea79R@NV(yzA$b0H#pN?I)G&)k!bclTQ=Jmu4&APDWb{04}>lApB zTJPkGGipIyA~D&InU2N6z}LKIwwMWT23dWO*|S!MpPFAuYzSOM@ig1 z>V54V#*W%mh|d-0ki(J{H7@58e0icbgpzGco{iCV9i(Ym5g(r60&BIJi7W;>3lpZRcbcy>#k_l%s3yys)PS>^d6ta3Y5s8c4I!!EnyNA% z*G+uY7c3K3&#&#!lldm$P1)`J%^$t5@02*yR(Ns6)*Y<*`*{W`OI|N{sAu}Mgh1|W z3ebuxslV}==zQ{p#I**cMA^Y2Am{6?@_Z7J)+u{t86y?iay#U_}oAVpC5^2|l2Ez}0NfVIp?p41CaIt8>2{L!#{lwsf*hcz^=jQdA*^=iF&-mv7o zK=5##I_}#vkB@>lnK=vW_nt&n#&S1dXyo1UmVvnPdRf;39}iQU!f1lMsgEWSfqDi=d9saHBu{Z)AnM`T+v9_v)Rmmk7=~vl7PoN7*w0TqyuPit zOOMqKy}ywtv@GL#h9S>-I_64f`^4|8(!Z9Op#_2@coK6c{Bmd;jEb&6em>dYgO?Bx z5OWA6xPvUI6mYyuv$NR`&^06%LCXT~9SP=PS&a72SxNV-aOB8K`_{PKJ|BcSFe)=q zpGcj5^5N5qQL6U7aVuj2x!gx-hVN?*xZQNzGA&+>GhbhVJdUby%Gq=7IB@M?VTa$-U*m2)2#kI*4~FCQnzC-6 zd;&W5F@PNg>N!h&hMLpIf@g5vF_IgXrtC%~n<*Euz57D$2Ki4MN_kT5?OdmiDV$I( zEt*BNlVzq7y212$lHl4jEsB$A(qbH+QY$t0K|GQ(IEaMt8kjlxJDG*D-BDrdZV;MV#|ZEOq9_tjc}x3UlHeXl{VRzg|bBy7=2$kS=0)fXgW$xqWN# z6fhs31+*p0wAJiEyrSTQ0~ZH@2e0wtD0y8Xe#0CzYqJ<+$8kGVh;R6PPU*(ya{`O6 zXb+>CQFMVqM9Pym(nX)4Mhj}ZU9@1Rb<*mMv5OoH0@OEyI#e1J@u7XvF)B_Nk zzIW-EC~|>F9mtg*T3MI*d`(W;Wo}rpi|Jz@eRJgFI>hQq*xHfO1P|=3b*dQn)`ew1WPCBf zeWG=_>ZtAWKH{eTH;L6m-&ahmcVC}n?R_@Mv01v8sk9$Xn3@qBs+c&Q3=_@fo!{*x&zbXiNyU$cf0#M1Z3jRRqa zZ-^kwit9&t1>9E4#lR*Yy=Qno{M|^g{FASJUe=?!bkX)hh9=jh73z`=6kn?Tu+U-| zBMm^Q;LvCY6WB7(_@TUDDe+$Qp!1dmKP$$;KhcmsDNnUc*`qQk>VWajOYtYap?84T zBE#n(r6dwHWFK`XT!Wh776soYILwlpB?Fntfpmd_q78Y|6XuS@zV3jRkXhe>G=3C(i+mkX$kl5)n z$nQ8*l&1nuqYRs0O16K=N?(3ziiU~EAeuLc;YN3E+VBv$#3zUo39X@1zbN^DZzVahDWDzozm zjsDrp|AQr6+41i+--2YK_+f-szoyF;AY;3gWQ8`*Dfp9C{-aI=y@|^G*BkMG&At%y zC%OFx*hlf#$NxoO_t(<>H^}cVvH4f|fWO4%|3k6)RwBxQm9U_BA=@@in;1aSeWLMz z3xW?JspmIhjyX$#yN$(0h5zqm)3`kF{&Ujs8E9l66RtF9_C(Bd7;MC_yT+eg)REu# zs;Y?j>IX#TM?^+@=N-g!Ir!YMosUw>^fg~Ev+#beSj9f=x)I5xD6^24l85qjO}vlM ztFgh=6qzQf58TfqTDL;v#$u6t1eI1(stCyjHXYnonSNovumt|>bDdMd>h71Y=XH@r z+;@7n9CysUNi?Sb;UjC{xP@3$y8&_#o+)EqUp+wTmr@>{vd*%fGkO2Opb;%GBTCW1 z8E2G?)IHu?ICKs~Mfy3cA~#WrQ;g&wHLQu?=i)kN?zpYBUUc98xPxb4%YxHBKh!qF zGx$=_R~7Tf%+2-}y5!QD%_^`8^^V*SB#c8Q~O}4uE{$y zevD1xGWg)EB5{Yd=AI#U8Q)_3Odp3s3YSd%_Zqx&N-Viibkv#IG*)r?-WBQb5V@y3 z_diHnEH!dl(=%jB1cI*cC!`EFK^bvH5{CCLR}!`BXIOLKtu@TMwe&XbF z>-=FT#SQO;I@|iLXD30f@(MFnpB*e@%rq42np39P@yu#pXh7PCAn2=<`R;R-d9pT- zjMY)%_uXq0_|uNBKKU|f767#nWPrwn$6#Z|?Hr?BE25vLDah^s85&mVJQOh}aMW%l zm{`S(63rlY-XKl^gO$6Re(}xF2((Nq?A$Lxc=G`i&7t_Ucyx?QuXXX9tO}&*^VX7XdM$urp|t4f4lw$*g*AK zyH3Lo)|^Raf*T87e+7O>zJp|wX7Ph!Q7>Q_Un)A%_WGf!dfw&GnH_|}S`R#aJl+CM zPFxwaW?jLz6M6g&TAUd8dwZ9TIqvtZ%aobuca*D)13&WdI2cUCm7wjs?zbDjh*U#E zi-H!NQ+;y3QBKB6d0;;`Tm4-(*O~j~XJ@*-J=W;KHmFva*XWi0X-zlRFLYX2=N#Vg zE4hDhmtp602xKP1w5PN9_#b^7K1(LJt?-ngW=-b{nN;tHb`DtYku6c}E4z8dqp~7! zzJx^C>xl|c*18p{*`0M*0V1;jQWE@-JoNnz)yDBAd*=LzRDk1<@=(3l`Q*Zq(foYP z{9aKhYHJ#|OU)j#y3U5~(`t#n;0lyj69}gkKxa5CCIyPf;;+YxMcn*8xLd+;(5wlW z!RI~9H=RPGJDYkBy3?0i174S_EegLXF8tm`F~y+ut07=hl{_Y8x%I$rF_PQPVs!~vWmr?>8L2e8M%Cn}t8S(pZ=x{~ z?V$T6dOg)JSTdb1kMr6~9nq~j`qEg6<&1qKj=FlNq%FTt4N^EcX)>{bUzQ8OM3#(j z*w0s8WY4iNVZz@O>ud}&O5Xu-l5dK*NPs~~F$7razFbOCp#zUb)X`A0n~BDKzHYr% z1)PbxdATnWe}9?ij~^7D;*w@j>o(kPk=F@YElRpLA~V5dPQN;(?+LDj<4I=w#EmFE zebrCNOvOrz3At}N4&MUkElX-D$<_BC$0w2&-jZ3QEl3k)X$fW>i@8ktrAR+Wq)l(j zEH<&=ED_wxFsP2(q|O=_P`x&9jY!6}#Ic=MXbs}@c_}rv55F&Bh6)#z++Cj99yGqmMe*BuyI zOJL)<1F$d1v`vqFi0DW*b7%Q%l?0EF^DFKTb54z?fJ(-9@&SeRDSpb|5vhtiL%AcB zyR1WEP-o6!_dCLGZy3GE<-Tx1dHRC9KRNFm?EjFeNkpUh?kX3JuUJo_WD4m#9A1?r zi#x zQ(Ar&nurKUFHvcR5F$-lAQq&G2nYxWQL0Ll8fv0c0qG?YN=WE62_*y);=A@a^PRKz zKIgpe%s1c6_x`bGSU@tfo@71cuGf9t248nnA`;S4euEB1CF(ZsEv#Bwn#NCAsLovN z<$(2pJt1Q|Y*8ChZx-nfXbrUrSp}FG9#5UyWOviis!XssrfK6TT$Dsj zz*J>EL(+!k5#^8OVgzE2cfxLwMj#Lro|np)%clFzWrn^~zSb<~Yq~g(Hz^9y^gyXqufc+o z%M|y<_LuxOP+@Gt+@KEn3biKY^O6R^D!Z}-TZH)1Q|CWkdn7Ma4*Aoan}?CN39{zN z?Y3;99`~-EhKy%^cfQ2%RbOE;e`|876<9^=v{rI-{N#V!~#*LYYMXO~z8i#P>v_9{AHo zuk!z@l&fL5xTZ+oz{$)E00r&bNE2G}v~sMDJc(Dtl)BTZwI63^AM{2{GFT(I@!3Yl z=~T&iuL;43So7$IUF13dqfdWSyPtsa=u!R7=ft?ZF?8#x!!7+&i<>$FZ;LX50=_cC)3(daWeZUDJJ ze1>p@0#cHcbpyMVq+B< zh9^{Ih{um?Tt^g49vL2-WYw7#mz;j%Z+BVLC_VAOMC(PF`Z7`0S%?S{LQRX!21@_U zxCqNaB_6ZhOxp&dcUjEH9xP<%Zs60lU=#Ka)n&btaV>cE73STzPmePSqDVhy1`k^< zErmpaugsfWjZ1x_aE|cp}3lf@@6;pkbosv0LlUBp;&l{UE^m=9$ZUs-#{sZD> zk77^Yx4Fg4Lc5uYmUcq4JpLuk@(zTLj=SyJT>2;5nUr^YU(Q=Uxc{m}$%Em;{HrVh z?7_>hMF6H*&X}`vO%_6#;P%jaecPaNAg zN(3|Hn>RY8;?Bi%f4b=SWQ-G`>tknH*|~I#XK%^N-F;IcmU|2I@L5l`=C<-UFKIrR zv{-$ux~Q+Rlb$Q(v$#{?I2LDf>L8sHDA9#0p1ey5iE zr^vbI)-Cid2I33Uer?P7JgS`GJ3yhh!!_1Uj^~wdnI2Q&tul}{xY17$5f2vZ<^A0m z>%308s2EDt6>dEouYKTdmSAJ}y|d6iAiG(QK1;+4RV@Kl0zwp8q>m{Ag!b@tQOM<1BB%_pXJ zpLs=yHJI4Mjt=3|;Tuhqg3)374a27GEes^91RjWeiIry|Xi?9wiVVLNEkp!M{p(F~ zr$?M=Lmf?u{`!Ov+dtbM=63OV%Mk+Q!-=&%{@>xhv4?O&qVtM3t!k|r!>)#9{x$5u z)b9$;_PPhh{F>AG!WI0m=IgrGL2g74g#?&aI057-GGvXn64flGJ4)KzgK6dI|)gH*Q(aQrlV&TjivBVcS?ClcbCOMTAjgEGS9NWj4+Uh z{$0^RN705eQcCbq>s}S-uj4-EErn)Ir z%8X6o94zOn_pSzhGYiLK*1qQ1LyRX@DFYD(k1(-2O*E_RH5`3%V<`h(iq4;0#_XkZ zOLop(hd~7@yM9O}_O@zUiM#>HVDC2oMruc&PfifnVn|P{CBTCmmt}nsJ3yAfq*)5t z4=u&P^JT}xm^aN+PL+mtzQ0|-`F`Tto&^2l{)YfaJOT3zz+G?$rFJ(18{DU)vv|qI zJ~D|=5-|nOYWvXN=UqA8Ag}*~ap{Vno8`|gbXF;N`psSjg9Cn$Nd77neqks8096b7 z1$q3cYbtNT%Z_Y5vR<<2S`sB2vF7at%Ef~J%8B*gaU}LIe3yu8&@fT9b;|5Ail?7w z)=oL9^A>EJ_p;jc7ENjY^0b*uGRs5mvpalq=OM zitmHU+ft$4NIgO@#^%OnQ9_JT) z;H77$M}SyojYgucEeGFag1m^|#-ulC=PngT>Vd-x8j5tU&A{unHxm@r!l!nW)vNKQ z{I~-y0HVNIPpXL_{P5u?r1n6y*=zR6sJ3jgxbSnRM}}?-CU603jba6N*mxS0_~>wg z-u0zgn;h655cM9K_c5eK8VF^yCU4A41^7KYNv8nIk05v!{~6Arg_5%L4t|U zYnp0ONX7S0Z{rvW&RMzPzX%Jh!i>46aBnRE+?9f^-BQ<0R-$a`<#det;wa@Yu@sfqT{}g3wZI{$* z+L5K|3 zdF1uot`;Ky_9^AnhW{Xkdl`h@)diu;mYn5{?`B!yJOtI=9-Ylg*e< zcaOc8ClRjuM)d@ow-WBYw0Tt;pMsjc+f&*jU!7xfdx;n}*_4+-*r=fo*el~2@fs!7 zp}MDBZUY~Yw2YO-FuI<1!R4({D;~1-`!T-pUPQ(Y} z%V9+qx<$ltkiNdCAL{B?*}@D7QXYg~Nt$6!vfVPQAMoBf4KdGNF{yW`&K_l7lhj}% zJ4I4lV`q*>+;||XeprHP$ouLo(yVD%zb_u(F5~6KKG%#Swr4P97O=wcS9%fMIl>|v z_m51O?34ZSa53wIi4pC!?sW*WaXbtN)zqnClP6~Mk-M@agt-&js~b>Uf-$A6mtlyjemXkCv6u#`z-L=k2Z=# z_>^$H@SAW^6H*_?O>$opnBRR!aSL~fu<}_sKp4AuMm;s7Tqju{evm6JT_)5=Kzi&} zq=xx?2$6Ma@g^z$rqKZQg0th2eaCAA%k;}*w#rL$nsvh0@rm(W^KmEpiDk((zV9S= z<5}MmpWo25F9m zt{crY;eeXBgOvTk60N40#h-H$b-HQaII#7bC8ylz0wte^i=vn=t-T<$ zoLH|_J}pFI`TY&2MK#DJi$9_?vt?<4k;RloHGi0*-ip&mb*6)S`RCG)7)9}sO{s4p z_Yl>D&*NDyppGr{tsb3^Pm|I17`WMMP+Hz_B-LV z)-$;N1#~Cwp<;f{DS@YnRnUvSPc)<%D-owQ2d7pXoQOEZ(GtZMd(i#9zA5M1_;sd+ zM^F^|_#7PY>c_rHh&eI%792(>>YY__Vu%x-W<`(fQyQ-{CwabIZYQY0j%?0A)N?F` z`1y*^834&KAXHvLMFZCoKO<%1nz0vaG5su+&x|Mw{Aj!1Arp76vDM;fTY|~ht-!>} z)3w&F`kQC!JCab-XsyUP<~5cn^-bN(XM~P14bpnEwZ5jrBS*a^%R{TFRI<7pmM(gg z)nN2v^2uuN`dr;nUFCLSC7LAzuG)#zlLW{X!_e$geJ4EGV(ea~3=onG!@@2hDVjm! zbNdNmPsOL)1C=KD9m=RU7T4I)hLs+ZXta3iTIp_0JtkuzaBD}gY0bN2Vt1wmMYZQW z;S}EK$GSC&)C?|Q#ICf2M8)|ha5>!kI%%ww>0Q{BO@%z1b3)Du4+Y$7M0)qI!#PQgtl zg-oSU!MrM$6}#>zR(OJ{r(;$#n^ z6e`p(@?G5p*opsbV8rbVQMYkZcMxxu&p|S7S%9Ak75ClvtRbw-BiItw*y2(r(gtJBY8s zIjBl;VPrJJwi5*)MJL9VGm!RYG%TfrPyNhkx4=LpuQUpC5WD1ZY@$0)qXY&~(~&-o zK^~BV*0Wcr&eg>$rx@YxwLq@r=zg39ZqQrFo#|bK&}H>}F?ou)BHfu}6|7pT^;Tsa z4FbL^8i-FFYV@HlIK8x?u9{85m7U80-lD=VzMf2DxL5X`#Md5I8*lPoLD&npy>-jtjA!7X=YK&)cNa~Lw5|pU>0a5 zM=vud>jN_s0TG`-;H8&U)-WDYS4gEzr7Z2?t-M;mr2WL08aJqaLCeo_9)yXke~P6~ zTyUr}1~OZ(5>I=BB)o&eH!;9Ll`Q&ay+u8v(qSZaVWJRJ_2&Rwq89f$&ao;e=G)bYfMUofI9A#e0g# zHSbRYmEmH5z;yK7E6vW9=S6+G7%>p%(DMicDM_tB;|m0UOBbu%H5K(i6Z+6 zF}q<#>g;LvQ^D;T`#U@r_DPn#eVK*o3!@U1Pa8@ehiFD_fBN*}6C-5kUZtr)*Sei@ zbwJ$<+hZ9rudFXjA+ltoldrTFPFPYsR;$Sl@|~3GxHUe9CWwAL+9GyxRt1G{4E~Hi z`s>;I)MFVZTRFx=k=Ug1SvUgGw6X)=sj@f8=!1<9K+CfCwPeH7wvPYImkEaKSUec!Hb}So>Ou)BWguO(BJu0Pc6oSt)DwRx*}}wV)Ff&uj%Wt3zC68 z)R`aQ=PGIV7#-u1AGuIWNK;lS`bai9SbFw69NXUmBl8R zxYH0z+PLjsTvK6X+A3IamDD=$4EyZothJ`uNYr#^BxtBK+S^53Cv@K z>_q#~HBc}>wZ*$Dhvr1BdIOqZh@;&3i?hu?19R>j&=>e`FV1e_w}lQA7sG~rhM@=z zL-`1{>K*D&9Pv_;0>$frf^C0-vqDfTHOdRz;-x^qZfU@=)t%j#{7`#%6bpa~kT~*# z4^}sd$^*S<$xe;)SPnAFGH_*7%V@k(itjO~TgbEw<^ za-KWxpN9B95BXm{0|Xei+}Z%2?r|qTTmG%JM7;TbdB^J5R;OBU$+$(of9;xVwzhlf z=yu`b41=Q)MYlc(%UzXJT5-d0KSao)}RNzzCp zPz`If2y366NaS3Vz3&W;e^4w$#qatyONSY!0nBgDLdBC>d!nHuQ^n!AMh!}9aT`2=%t^e_) z;Qtuq*)?8<6I=8T=+kDK1VdVa6=nE;_oJe&GXNJCevqK=|t1+M`pshG1CX$H^)!N?L!4o4s`QBanFKurT#a*z_r z10Wkwf7xO~fJeOuP#g8{ac|xlhb2x$8YKBWeWtgItU6(E`IN@$#aH2}4D=t66uuQq zKT!uXBQdqO0*Q83uVKKZ#r;}szCk9&7DbVJDXkhBJ$?ZSPud5swDHa5y?u4w+`#rN zrwrB=Sd$mOk)WFW4?rGLj+c+7$~n$gK=oq|Cy zuYlVmeP+6Wv(8d}LpMQ-E)x75lvq~BS05{e_wzi8)+&E;VB&P3)wx5j7;pe5<4omTeQ%CzRE(9f_Kz1$P5G(971!q za_=+JNj<#nsd{2fG>#Z3SN(W8(sx<$>9S8w# z7uq$<=2RbOD6Mh8-QRKI3z@WICk0t{gh(Xl=xRw6#l;q|yyT%5+dV-oI*h z4&rpfPx8;;#w6(hjEA2agPVT7mi@vq+)K?(S%>A15g)j`S^qDy+RrMTqjA&MV^`MDfmgL7oK35BS4Oh1Zrw`tLaaG;n2Uq~9N>ehm(z!-fwsBk#%jYjINSEnNrQ`J4rUq638`Fl^eC(?HRC8b(|pZycfy|&#@ z#>?1j4(Fh8UWT0KXgtgi)2K2Uo3DbJ<4@hXMEJ{z5F;uw37SjV@brBv`!{;g+2l6zzRh^gS=QV1e z(iW0$ji?`Py-z+I+ll#=W{9teXDfAg?SxzybS&9+(q6_%2QI)A?Y8bF()^kMym||U z78Vu5(hVhDEy-&P^Cp@{nqE8iS}4i#$?5h}e@WG>f_TgX=UdpvO_^Hd-x<5q`^o*N zW<&vsw!E9Ofr@&Hs$5v};fzE|0(hB-smsHSM}j{G#eLUm%P+~#|0EhVYrbq9vo7I%epj1m5Yc>#HDSZ%)Ff4cr1R=e76{Si|qC@V+H{QOw> zqx?Quv4+vNjzh2<0CCt^S5`^@66P&-IUegb6xS#IfHs^Bs))|0AAyFWL_sjD?3Kj9 z?KmfJJCUD#Hb{%TH-=CwsqQ;9wzTQ^m$A8=)ZisoXALQ;8kp#bB7;chr#G=*=@Is*K_M>FQX5;Q_BD}IX)#}-}K{0>t!%LeRpga7h8b9U>hJL}0&iR_))7uR8 z&ostnyq3Fayx4^9%f6h9fnCz{9@x}l8YdauitTcdeDWYj60hFFK+KrEY;^O>ZOIF& zY|$#7I$xd5yltXuactZY^J+vU15|vcynQ`(HT}5L^>c|p4_p*(a#Ty+khPSxm_|l;ZFA+CVx$xvv0Vh)xJsVHlEZo+rex%*kauL5P-{ z-MuAWJ)eyIPPqJBf|BQE_WrGKwyz2V(DpwR^@M@~XE;}D&;m%ik4qstZ`ktAkYzn7 z?1-XdeJvQMUKM}i$oK8K0Fqc@kLfn24dWvylw{Kjo!YH(ys?bcWNPbZ(P&_&*36f3nf#|XX zqsZ`%HeC_qb*2JRj%xi@cG9O5idC(_H4Ht;D^6^#_tNj3&W#axot%9+tk95(iP3Q( zOPn4HV&0`{d?9h*o;Ru>5D0}Gj^BSp-b7X&lK7yc)01t}UFja~H3T!&1PcCH0qkOV zCSmOlh?fD~cbr{CP3M9ur@n-8S7SO*FKvW{dCK(#oYjY%=AK@)vf_75G6EeRq!HJK zs3xSqID|hhKk^a7hBO&y>LWgt`8BAbd2oFsHj+!q;-r*AaJt6eh<#EjOG)aVroKSKsg$IR80?cMvVrQUO z{d`z{_m1Br;9fUKK--v3$ct!_Ul2)87O8_eqKNb@OFbPzd`LVLTRl;jcH^*ANnQVmJ}&%(Ia{7s@3shQXfF7kYm73yv{yjMzf@g zGeSuT;z%tj0EuDT){|rS-5t@<&Gl4S)_5UOEfxJO{al1f&`;SN7x8QDFhf%syNDJ? z=cStc=&_$SZuBT+#9##(iFuauCL9?X+;^XLO!6<$-zFd`}yoMNK|M(RU(1KKjU5wnuzCgtR9Z9)z#cp z8V`9>y&F7j>WTj$Q2|*!5TN{`IzhtT4i*B){bt>~vGK`CVnR9bvn{zc>1w9;P4V8# zClixEWd)7A)224`7yDIg!60Ib1gKG;YGTL;54fbhhJaKJsdZ0!9$T|Ny|p-9S({$) zx@$=Vdi4HfTB_%meyHcWJpgL&Q11T`BZiz~azo8w z0JCnw%Td+!4Q0KvkG~mLO|QWLt=05>{ z<7K^%`eDXAS*5(M`NO%+3LF#T^)T#ZD{f1uAHc6$0vj4=7JZTdX?4EPuUxgOo+WgZ zQZkEice>#CIY7?n56F0>CqV7~>t-fr3~Eskh&D_YK-k8)t7ies!N(fF1%8o^+LggP z{>T%8I9bNh2nR>=BQ_(yr}UNJ$Lx!ekwW#2K05t|<)V*&7sl|%Q%(}>yP;627(O#O;|oeTl zde^+w4XM}b@~^cvf0kCfN&D~mSpDaFjU6+}Yezh&2fI76rD%tGWTSK>NZqS2T%5b2csys>Ew*?CEt!P;T{4ptnX0{Hk?Xi35eaHrF{=YM2BcTL&8cIEsgz$ zvLr32?1EJ5)UPLYk{ri9eeDG-ZtogvJF3`>A3NR}$d=hJ0gkWC-X7k8kut5wM=_~z zGN2R9@oR9IiW(22QK*HnVD9V2#L{_?cYwH&AY46{T@N6X^nSg^!hE;?fV5H0MfJMJ zV`u%96Q&N+3|lkHIF_>2sj0bSrkGn(U4KbHTyV8~&}m79GVfB?`xlIUKB~Q-zc4R| zx2XKjmHhi|Wpxyhl{9;^XqNPmMy#WKc8PR#*BWQfYum{#VJTN6?flOlyFUGI{d5k{ zh&LH2H2JnEp~0Dv@X6_1ue8kx+fD>r)ogzHuXWB30?o_4&ptl5uj2NkfO)J_9#X~v zFZK?`Zj^C_<3)uU%3$}FwG42iFkzF5#^I8H{Rj4K1uH_SzDL*B&t1~)KI5Y*WBTh! zstwQcAqABO`*l?%mZZK&7Nme7L6*rSWj!^1H3w9fhgH9)u9{EozwHhd>}j<~_@Ekm zFR$|Jr%ApKm-y;U0|0Q=j@J&Mmw5=P4F)&kF=3;Vc)#(*Qio>986CkHir9*?NPi=Q z6b5Sz7kyBVO?mkBhhJDe-;*P)7u(3!4kM@ioJ_^?Mt_BQ{a3te#*7{h^67w{mLd6) z+SP5Vmo4@Ui$k4ZF4FI7Q_ja)O39x)K}|`2YW%E%H=XOe%|n=fy*#T5l6k%64+y{Q zQkjEwqZYCRO}+zGbLb2&KLJXJqMJo1v722HCxiU6Za|1C<`~NheO^zDFR}YIYW1Zy zPV>xz$5B6`exSGmqD*Zy+e{ilO@-P|=hSB*$M{rr5)LPDjwQ}Ui$$c6T-5X&Iv4aC z3n}Bt4jbd_sc{ORw*&~UChBE~d4VX!@P)DL7X9FYN~Up;NqaU2BT|QV2623aeU7U8 zs(<*wV1Nm1cgrE~4Lrt2RQ2=+ox2)8IaR)Oa5O1B-xWL$1ji>k_MgQ40o_O{88Jf5 zYWn;EIRY@<{=6dp1Dgx&h~GnPA?OZq6Ee6N9m~(ULIX#y!mIYfxtb1&hu$8wAU=6v zg9*OipCveUGw-9|ceks>YZB~Z^D9g+3qqyW&8*q9vUM0^1${1LUSSBdzhH1Q9tMi+ zy^z>(_##o^`iAi%$JC#D7O`nZYqb#W8N0gn8@qxcU8+`+^-$L66i&4j3@!VOy0!lq z=K|ypthCy5eLU0)&iwlE&${dAZ5rS zK=3u9aE(aK(-HO~aihnuHgtT}k$2$7eHq9PVaeLyV6>`O7~rvXd(F@~nq zo@Y0)&L^Af$6<%;DZ{FMd;Uxx5hd{r6Sc+rTk{TsiyT+RxV(Zb&x&)2V z!F5yzObeWmWDI>bHxHn?T|2HrCq zib2Wm)Zhogx+^Ypjk2p7h}GjmaEM>?9}pbzI|)y38`9zRL|#{pbfKm;2z~NDU+(a{ z2- zUp202tHXL7WiR!eCF$Qq$FoDiMHMxOrcT{TlZqR78a|AU*GH(*@T)6;>07pD3}_*; z4ZULwM>;ZC9j40ET+L)p0*L5JB-@)-+0E26jc-6%b?8B9aqMF|qwY`V9JBmcRJPS>ws1Gf|tki7NP6 zG(jn|)S{y2E}B76DWHg8=AZN_7uV{stRnYclr6XEc8R`iXskVMRurg5F!o z$XLem!{SW6M~_Kg=4!gK{h&71HpBR7?PE0Tt?$vY{Kq-n;kZG;sY!|50-WT0mL&Vw z?w94MLyWIe>WoCx3^*Ds*r=!+QQBxIlfa!)km&lT)+ndCJm$OYz`E<(sFbYE`MVq{ zNG_%%dq{$Z#h=SS-QCYe3e<;3xp1I8r5Lx1$rp2Nhh&+S$<=`E_)uSbZIt+Gt#H3_ z-+Nty0^7osHhx*b4#d`UO1pHjw3%v-OQ`BEjIv;|G`2DA`{)!;cAGz7lbJ}_Bsr=7 zMqOT;aFw5f&xlNgSOLbEYahc9>@^C6snI7<4`pz9D7T=Nn@r9u&KP^3V!56#IBs_0 zX6g;51QK5L{MpE=zh#4|`XI1Sm{Q`5?9z}M)RTp0Is#LPxo^RIXERy4N)-V=^R`$bo}N_3cyu{MSEg_!fqU0a&{F+HW4PX<-gHTtANFN%w`QbjgAG6 zpEYEipOP4>UG99hy|vPJl$Lxwy^gd&tKa#4Zk~eyVI+9 zj^exzXQ<)HW%HD+c^-$@;qaD8A zDj6J@%`@r8johQPRgNAyWyb~swx_55=kP8QV0SiSHJS!>?ywaqX-$;4>a1%4p(Qpp zFE->cb+xZtpNoawimSG>I%V}&GZ~wc6V0pvxQgoMpe2D7P-snD1!oa_8%NIYo+Kcg zwt?@2d%->&KB#5*TCJ$Wj~+qwuFM&CYExvRIh*GyQ}>QMagA|j527xmU%$r`^Y*Kn z5nRC@rl!TPz%vkGA}kyTwM4u$97W`yZw!GeasZaGh^LbeZYA-mAA`kj6m?_&I=-7} zcwD|H2d!F-D@D(3jE*-Hp&+PTwo~Ff_z>6w%&_vL3u{Y)i5A4bo4|7G}jJG<}} z6vso?x=G>Z{9+hsO@l1zK}2c)x(qr3uQ^}BdFU=$=PF@T)aBkTA-puEfY z&;QmKMI6skXyDyl08BEZG6PUhTuLqM;7Jsbi>=-~V4(^axBoB_nB?{w)u&y?B%#_H z3A(bjG)%%4h3D~Jd}N|@&#Tc~^~sSq=ZEK#rof8#OwMwNJqr}Ndeq?B&m}M^odpF@ z1Aps=7101Zs2j*1N3B=|FJ$5Oskj-#zyBimXF-)@jUw>sk6P`fUUZGwH+%b-U3ZhQn%Qari6tiy3(*4?ww!u9{UL zD(o(73TgU_9g{2hF83XFH#xhn1nW&_uCDr$Ri5OmDFL1LO4&9xVEey+yaa~bQ;E&q z6*dDxEBi_02AH36X#(MADp0T4qC+}PGx8z<%Dh3=TXLTDzmA`2|7qP*lC#-Zvk|e` z>iYfrtQ%VtkAk6vVSClD5?UKX43bG)2$B8VpJsCF1o9~bjRD>Ygr;eXfI(NTzXkVi zP?mJ$oXxu=fZ{rog_p12cx>LbX_BH(WD!g#^?->SwSxNlIr_)N+LitSlc?@VSjGF$ zZYakP+~|oOd3LZg(SRx+Z2plFe1`cil-se54*uKI*TzM-hpqx*_6<;^m9Qqx)MZ`Q z6C1@!?-%TPd2RDv=^{*$H`d`ZwXfZ#Eo-H|ioJF{!*{K4+ve9yfdA^R-1p7qma%_p zaVIs1@`ED##)*G7SGjBJ9J1s_z#A#v%F`tiC6zwLzQ*e*;@PB(5Hv6X{S?6l&+a5Gnm;^k)6l zoLvlDBoQQ=^^Ho8_ino2`4S^!?8(%h<_7I_~F} zRXK63p~aBOxj|`d_J;KJ7*f$j;<8rOC&MIJKE+)7TZ3O!Ze^1-y$)a$>f&Y$JBV+H z2V6p(Q1my{5JogKm5}pTV-LQHNy=|Mrej`=9z(fLS?I4^z89o;pPJMVzrDL#IzFlH zz1$9y5L)Y^|9UOKaJw-Zf7fUx@5Z%(lnr1Bk))tf#uC5H6SK?Ey|?8M(jcvBR& z557MnnWSF#EkiBo&;_7dgY2&fFNsTcSmWh_kF`93U@c_OealBKx5BK91S?CyPc@)T zP|e-n{(!OrAv=Hx8_!90&*t1~_%|6E6tj&;j zI=Lkg`o(4c_nT7yNq=ZJ${D{Z56L$=5jMDGjwv8YBws{x}Uy40B-g1p2PNxgFc7iOeS!;MP2>Qd2=5Qn z{G2A*`=Z|Tb-mU6=OlfkQr^LV0aiU{c42iU*}fTcbXBx6pd|+^&or9UO&?eu#T}+uosL zKI~JtqsBfBS$BFu)R+pE5tbXdsWQ#)1Kz9jKYu56M*J%fzxBTGuMou{@gWm9&G2TiK z8BW#q%APEFP<1%J(YyGG(=!j3XU69ad^pg42UV;(H$UsNvx#xZXSiIqx{ocF#~_|N zkmlLmMD1NCbQ$g+7wVtaO_{OM9x@t7^E9l_Y^(Q(D7NlW4RC=z8dX+Hx{A^*F!=E4 z*Tp-M$5It+J}2B_WPbHT31IpHO9=mqz4wl4s_phgu?q@FZ$hLgQdOEtiAWO>5RfiJ zMWlvE?}>sGsR9BDFGT4*Aiai;bmFw*-&^)~_u1#1G436A??2Yi z#adafjJA-Dk(D^b=Og?9So@vNA4)#Jmp**LCXd=Ca4$ZF_-zkE z_wESeHra2z_E;dgk}nKEB5;Fi3-bdQy+1G8-&RoqF0on#VV9*T>5>oG*yTx?RIu^RH0=cwIqwHa{Ro#)nJF$y)Vtc}*fM?ZM! z6>P>y%dkLKsB8d=6N&aRHg-rJoA#`$to2ftVtnmv5ZKneQbB;(?9%rXvX!Y zQ;$PibY!<1<>lhB>kcR91HuM%O-7G%qwY%$hMelQj*%xCTiXNd!eM1 z_{QGtXSHRuY4cn~nI6n)k77?UtHtx|Yq7lh;A8tuyv>9iAR+ zKyVs2*DcGt6Q+9CqOXoppHa0KP=!S@rD<--B#`nLG2m*~O;MQsQ__p_x^s0jm9hi_=cC zH@n9TigyHMpvPYs^=t^(W}uqfU(`?VXZCPKk+`IR{~~pIxBq9nD1HAGUU&sj}~9f zkrc@jv*H2LQk%|`v@{f6K&Yp-sn&baRF16>@Uq}JKokI8!ibE&oTGZ~iXz6$5CiB= z>In#uHV^Sb8+Zod_}(MMss;VOKk9C4JAy+|sn|QTRk}UjEPweZGO6rbnqn=F!lxV6 zFQjYT73bc}e7e2gC^qPhh~N_>8il?upHFHt#u%kcPTh+uylK|+dg$5vk;GU@t|z;Z zxi5r35^z`KUeGck>uxgM9(CviK!2NrNm}aVGr}trY|;+MR=ycQN9x~P(j}s!_{Yhh z=a&iIetJW_81}5}%<&I1H<6F48kuzjw4gLmI17K#5|``H*0Yd_R*fMzn;jqBkg|Y1 z3kjh;ijuWYX*;s;j?gbpbL?^!s2_$&N|D#ZNCviQHEy>rva4{H1^_YR!H1W1L|nIr ztAN7CsBE;t?s_=j?$UX9aMZKf$ag$BGkml;P@{Z~c4@hKYN>juKcs*)KR_JbU8 zJ)p`~Tc@FZ;T=oK3he@qkI&!Ay*3vsA1cd;d#m*C5SGYOZDF=Edg|%pR2oFv)htiy zw>|1A5TuM58Tc~+|CM)(FK19}lE}wo#OyipeFw-cGvGo6QGZe%{Z$_RI|8yl9Q=P1 z^gl)gG!7sl2~g+8|5t{sM$?i|>IB;`f1?0fe1KvMyW?8nQ=t-#j`P6@4SB(gX=llk z1@F&aaTY6~tdf_~la9J15MH&F6iKA>3fuyi5?_k|VBgJ(4IkDIlt7i4uSEA#=kSby zK+Kg%TN`$E0EXi%a-Y6BGug)!Q6SWK!Hr)lRr~&a?r)qK?}Cz(Am6-NqkLOiy^c^( zvMY)q7Ihr!^7tYduDBV_>SxA`%)SKZP=S1ZJk~$%Kt=SmOf>Tzm7>D}XK9|i- z$}p46;!Dkt33-;O>6M2qR6Y1!=QM=5!n%018&%J zwC`BB^IduLz{bz)6?p9l%n_(8s8$XJ<7Y0LDN7g_-8meW-EgklJm!nQO}p|U9@i!_ zT``K5QD{1M$8BxPe6P!2{5T2w1gITUP=r!Dv~GhT>{4wXk>=ec02$ia$X36!xLZ@Fe*A1R5B#a|?>n-F%D?mKvsF3mIWQ|hg6uA`H zdMrl%l8Wb8{L`X=WI+vv;x)z(lL<6CC;U+sDDo*i7VkhGl%ffKVpk#M=hos6p|lz8 zbFp-H-)zvE#`e4AtX znr}#Svg*q4iZ67u_7Ntkx3Y_8^1Y<68;{!4!_v0V)>9`&3(WEwLz(B&m~Q*nLIg%0@V>+Da=I5S{p z;5$zB(8D>^N!IbUn#whbkC=}F+C*}{-s=~Qa8(}`2u2M)^G44>qMUZYoZdOwF|8m% z6p4M&PSX82#V2aBxU##*L&)o-QS=mLPt7i?E0Vbh+!I4g!E?N?_rgg<$uVhtHTSk| zIg;o-E&K7C)#^zozb$8c|C0#ouCAMndsm**Z91>Dqsy));WxB_s$rzK9#tainp@$r zaaoJFtQpPY_8zri4PJe=F)nKpntA4a3yUWt-po~uS9Fn8fQmIKh$}+>=ki4wjBw5- zTrcUsj5MWcmz1yB10qo_Y{pVcmXyZdR*ZerT(rTCj*ltr#>sLsetSSZM49-1n4dxD}&>A?AA;F9B}e1OU2!QFfKBhuQ+B+uQ^F zM9hx1Oiktw%tD#(F}R*6d2?h^fM`JiEj*9~FtQ(6G>3RoB3dJS4UN;AK@5ymQI)8y zf4V`#JEmPKxbXxjg(%qio_LkIrbSq&MCSUK#F7HnRHK|R+S1%gZOm1%w!uV>{dy|Q%= zbc>YVszz8MvmE(Bn9WwVy&Z;uuCTwce>z6|Y!mF;?nQ6^)T|C%+B#9!;I9H;lIWh# z!rmd6;T-qeQEY2zrwNeIxuJ^lo8lX|2EQJQ$+{G=HSf0dKy|bI8}{dVlv)B+PE+fr z$n4b(m2q6z-x9As$;imF@en+HN#ndg^;IA!Tm@izJOX07m7%Rtm&gxD_QY##$+l7F zBB|{5#Z?U&%d0TZQ1N?etg z12KBXVSdrHRV~K~-Azkz^zm^!Q}}cVxpCo5bHcstxhs`$$e0w#%cK=?bPY|9ApBMV z_{e}9)7nNJAnQo!_k^l<3n;)zU({H2F2fv>veeg$?b|wVio21|CGIlUmw?D{F3<0C zUZ)g0H>`1k$F^jJIkZYCpd*)w@>-g{GSoU(aYy-eT64R)DCbcDoY}o>=5&}iBA)igbx6ocW=~LBICh8mSegv3_ucIB&%0OV|H4Sv$mp=I+WQ* zb{QF0##kU>ISCsZ6^JVxHrrM2nGIgKh~0rnF9=o;&ym?!nm8bQyE?E31az1Tgch^x zOCH~U+)SGm;Ai^2eWY7)Bbx?)CG$hGs(-^7_$Ppj{zeBGRNhenmim6H6+*ryfgp|A zhb<5z z?8w1O(Ry1=-fJMN-)N_N#&bdWy`k9w_nv08*OqK2tDEvRYS8_nk;4sAM0GMHpU zOlbw+$tQ^MttF{$20@+NGIw>O-1qe@Dy>H(Hsz-@uDY;WzpvIzx_GY(BnvMFAgFSU za`tF$#7ht@?=9?;xBg<*P+T3dvL#HYy0YTk1Hy*qG?PTLg07d1#+`leU&+8|!rOY^ zy^5gwo*^Z}Vi}{63X5ecN+_uc6#p$XH=Nbgk1m`PY#=I!!2;o`z7$-^x6GMZOEfwG zv60(6y-UvHq8bk8WO-l-Ia}bRRUneh_lt&3lLYn#*m{5?o7A+)vc5ww3$?alL((!yz$LUQk_6TQO%IXa1h-!!bw40-4c`N~8~QGl*cV zHz?_}nS5Z_I3iJTUDh5Y$p@A@!fjx%w@#}+J^xAMeE!+?gWg2MS@#H|GEI4t8yGVy zQy+uckI7WvoQefdU=!{pIU=vw2HZmb^2yb(xc^d&8o-az6W7@-m(`| zUZ9<7^>!cJyK=roKoW=Ci{@5+n|M2~JSON!Io5qUxEk3zH2lCOq4_Kur}c*uQ?nx0 zY5wI+oG5@!{xWzB>D5*cWY<6nP2kg`YJMdwI&66>X@Zz<8^~4YR1PnZ+&6xZdLEI^ z^gh@<6Lc-*r^XjVatwdus;u)LFKBO9jCBHY?05!|DuUq_P>){)jPW> z;vLiC5+mdw=IdKbNwG=>33|u3az`z-#V|OGMc4{wBk89bekSAQVvQjp1sW%BxL!29 zlCbt0F}$&nA)H>%w4ti5zOrsiFj_u=j^%{9jq$y14Y(7zIpp5lWs^||p$~f&y_^X_ z%qk+uF`8s)uV&QIbq*|v5eP*Kj{Kr2FiVZw_d}%iA@J7-1Jd!Rv15-4wBWoRlfOhv z+tHAoTahFB*^WSRfP`(#dXj;fs-WEC?-`<*na*L8a2tgbcLVa}l9cw9yo$|SXhz-L z@D=!rfH2FCBDNg^H!5irwAZJ+oTmE%-U7UJn&3zcS3jVh>H^ZjcmGDXvaO%f2UUPz z520t%GI9a0N7pxF1j|Qw4fL&4qUw~T%PA>j-b_*{(CknB+aLfLv*5)*>pg8wzjID7 zmu2`id+G9xChN7wj-d0X*+Fuh<$X&x{l*a|;Rf{RVl zI1Q@&KO&ccr{I*UDM6lF^IM0X0hzCc6ZWF}t*UO&!ng(oMM341ohJ9l%fPX=0{(wq z^fkski(7zFXX`~)cLo#zBoOu8d4)wSX#fXA3y=$c*~y^4EZ43Z;A*(F|6kCz=CpBo$)nW(Iv>y1Ynt;pfL1M(G!&`)@Cut<@uW zD8C2d@eBpOXaWGmuVantHC0Y>C<>W32x8v8UTil4MFb-mH;$<8&?BnH!8!6>q#BS_ zA8G_db^#yroI9d5Z&&Y#(*tt638uL9i9J!55BeN|@EfZ=Y9$~;<_QfO)AiqkB3CZI$#w~Rig-AMdP;he{zstv zfB64JxB%I5P?^HA$Jorr{~W6!`<+A|^AAxk>y zwj`5wIX-#9bRsHis%R!Px20^d_e=5K^VkpfMEx$^yApW*^ow$lNezz1T#nFSFqxggm1G4{;P%k9TV0ON zG8vUxf+}>kk`yaBbNO}IMp0`dF?7vUY}^GUbde=mNy+^#My%Ie4|Ci^6=<~ZGxL8u ztW-9Y-i4Demy*f6>RDy5-y}Q!F{?edcR@q#)z=D2nIgSUhLx2lX_`I?W7=ga^|s=B z#ktS;TfxzTMQ7T+Xvmj7_$lzg^o@qaunEPTynCiNckiLtfI9?}(ljGL%nAv9USMfC z?V!yuvH4d11bk`31fJ!K3@hvd4n zP<7j%r0iA$A{#aS;_)8653&_-#JVY^r3wIJQ` z-JVK@OK-<{Be?1zHPw*WMa`>n4%7s=@MAOnm=VBOD^M72X0$$&3d z>3Pwr{>p)sD4NCLuFmZ;c=n{K`KZLNz%MXtsL$oK@gi@d`ThJL2Gj1Jm{TkVwm)&eQ2M}70>8VV0t@_2Qh>S- z3xukUF~FFwK=N7Ib-5pTW&pM5ood~qE`R8QiI`qBF|$tPJjohTbw-P)-CjH8v+EYc zi&|8feLLDjX9r60q}DC_^W$JY-SAcKo#XXj?|oCV0pAvFeHyE~-wLJ=%JS&$=aDgw zkBMQE^s8@gbw63U#)=IAmq`q4oO?BnWrQnu510-Y?eRo$uN~{@B*bV{G+t0y4-cV(()w>}%gkuZGWeHI3o}B(byC_EKZ&4LC`)F!#ZX_9UYIy zw2R64I_Qu-a})V`!DFD!P8*OSXjo|J4;d?zAj8Y195s8BjR>jVCi((Se*=}Dl1j0M ziC4Eh_hhQxD`Jd-l)%~;gAh!L`dQ%iK0p1zUGS+HQp>=TuwJxt;-Cb^kyhYX<;Hik zUF7fe0EA*o4C_v@JfW1r1uXT50Z?U*wS9I7b0M^RLlPrXJ%O`>ZdkRmgQwm~I?cxk z+>43hiG(V#jc?S=4e)xe;YZ{V7b|q6?~z)wG&A#OvZe}fjzKnOBCxaq74|}^m-#c_ z3-ma}aNUfW=$U+I@On_z!_RJ-GPb!tG+;YAQCUeDd1CE1G11_mmD8J)Hnv>x@R)RN z9c?`a!9eDgLj37D+ISsRVV9;4&+gCZr;eSW>z_3AzV+aK!h>!38l&(1nl+?T`>Laj zLgWXd^$Iy;b5hsYJb)-KT6u>W5-3|iQqX#R2ZADiA2YchzGRp>1Wrdv(p2$wK~_@%xW6Wgzt;jgFmGj*P}x95yL;e0>wg=wV7 zinD}YL)O8>HdT%SQN4Tpx_L3iYpZw$GAu0#1mxF5?crH#NJjnR1`^|6TKs8y;j=>%LaIc9_DSloMH_Mp{-coir<(>?<{=;7e^ z;a(1QlUOr{#8-~m?=z0oLgb}|N;n&xF1@>hEjK3l5dpIbRF=~M^ify_(*n4A2;o)6 zoOE{0n6t-HZEcC;of*Tj@53A4;>14MT+4Q==B*e7pmR&a9Ke5NH*JlVz%~yst#K$z z4Tvi#GIoT=&ZjxaX-WUYD%8fv{_fi_eTCei`)LV z%bv9Gm0P{lrqhzjB+>4AAeSj=Bbdn1)OcdhT}Klag2v0mK*nStm-IY%fnF=@m?Ctn zmy;3ySq@RlL?i1EQO`>^UXav@L)ckM%!IewKAh-k$6@{|&pNNi$NL)b%rV4*$2#hs zeRpXqtL=5V$qh-fPo*6{t;S~>8hItiQ?=xpO0xTTKlv^{6v6^a@?WdMEHrFnkBuz} z6XS6Q;lREQZ&ARq`8)q8FJ+!~keZ`s^Ow&%f3b_nkLQlZRry|dW_{iVowqIf8`}vP z`vDWg6r5~TC|rqbe0MxrrjlqCH%x-Qh`!+G;<_L#mjB(qLoT}Re(i@ji4l`N>TQxs z`YJoKR7fKW*=or7k+5~V;h6P^pqba#i^fWlCrzGxfKJicYD}F>K)fKa5mP$m=9Zcj z3SjRVMH-P!a8P{nibI;at)V=~Q4j1>B_M%z>L22SZzXcg*=4P7Tr0v(_lP0prwW!( zA5~Beo8=3`h;Tv`uK(Ds9<^uNt_8*~dPmN)P;%UT_b6*79ei@6J)&ScnXE3JT0|j?-@SlRwfl=5VixSkEVC=n91K%9IReI1)fIbIa?cHs!uu0 zP3p&oSB_C+$WTOU5!Ku<+)dA~IBDo8?Rg%29DcI`0M39zq3%8&O42Ihg^CKft+um$ zR-Wjc*(#rk^Lv~T6PV5mPXnQgGsjn4UmC1M%$%U))Z6&rEd_qjSn1J$E;>?0$H>`*oAxqlzNP};2Gp~h4 zQQTvzejc=E`r2!fx~i)qMWJageKeD}=sy}rE7McElrNKXiU$g7YDPV}WF_<-NBcNC zpD8MBs7v;|iIFKf?fUMcnyni1-MrIp+8sVRxB`51e6tcsVowoU@l%%&Hl$zQHD5V= zcyy?260iWRQbbaDz@5qGTHgEX<(qropQAD(LaV5Xgz2K9qBc$K<6Ej%%Ij@ErTmsP z0&0kQws_}kzX}grmXfFFK?u4}Ol?HNa1?9vVVfTvNs>_+Gxe{F^Inh5YCFXB$@W-$ zQ;5AF_K3#FwCnq>63_k}lG_)1UrIvdTdAL9t(>mR>B*kF={{C=19sbr3X_i!x3ygT z>tGVzR?0@5>UiW^DmyWK4T3Q@m_lBfv@nOrBSodN%IXu>BMUDYXlzRt#wK_`3wcB{ z@3iP%?}U#JjXRGIXC=uUK|D8g8+rR&JGJYU(REO%p`oFDFRbMq>;wWo(?EnY*OsRV z4sSwX?oqnhoG3`^_|a+eHszSH6r9`QCSN2yclkQ$ z9n{Y4GAy-M1lLBsznk_}sc-l^`BVGIS?!SimGJiMraFy>&sC1BamW^>bGWm?E;-9` z@vXcIJu{Yi9)3!D)9dRrxB6TZ>W3OfjV^AsiHb&wzPYVONBw@+kSzYg{|>&VMz)5m zz*=cMex!C#dpZtt2eiE7!=ava|Kyg28&ATy9!?rJyhwj$25e#U@ED!n*kwQbTpy*& zV6YOvUT1EZjG<6>T|n%z0bo3$6@AtbPDf;n{t6UIDlbq#o>{Rko>Arf79*+Z6#%>Z z_1fE0IcW!04keS^aohP_NIWXcycbfgjKWK3ANztCNY?E~UcuC1Tl~a^b;YroaT*Y| zdszsBd0md1c`IJ_tvh_Somxci`+JVjOY~_{PJ8Q9J4LN52Z0Xkqv@}toF{`XhNIjk7Dv}#M&oEkB#ryEG7L%wB))vG=(%;h zrANqVt>Q-Oi@A*0VzuSO){{!9#J0%+ zW$U)0P>Qm6Eq^JmY`d!Qp&5&NeCwIUL)8z2#7|3F8s37sa=?ES8>?+^O&$XnaG(cJ ziTA64PHvNTike>O2&Wzo6o#8f_GtDvA50usI(Tn& ztaoeQK@0DZuRF5OUUa1?aAlxl>V*VS?>jLzNcY~WP zM^b$k&63(K$zy~MrLw{wSUEX2ck5ii!1e3+RcIpf29f3UjlAx9^dHda53Ofpb&}x% z8dj(f`(1;`aiaVuJ-6zuunm|!)SZ9F8#>?8ixe@((-*7obl|%g!U&ijL zJ2Baa+2nCrjxc|Vno*U&$-E99-=l#I!0|p{`io}kE95HBBeG}+a*0&sDt6*bl~Mm4 z;QIP&;5q<<-HL_qC;y_U?^!qmeR&Dl)IX#;DNizz_hP6=tpCG^6FI&N-suJ(&+G5s zMl5|q9DGOJ-aqxvAvFJB7M22Lp<)JL7OMZ#ETs9Lc;c7;KRvHVVhS>O33Lm*cMEZe zy6a*4&$%+nDvvmRabiJ}nyrTe%|sVcqCtlXAj-A~&9M`BXAFG2tiS&gu~djS_>u9? zRnq*YIsAt452iOXl=tYONF=v@_`N2X95eYGUjK z8_Eb`Eu9MZK9txC|81I1N%|N=F7+D)F_yL6VnBqOC+4r-bvN`5(ck&PPQ0ussEJJ0 zt$WaSZC?h0tp!5Fc?eQIO_ll+YDdKJ0ffXR1>`1c{`bZI+$31J9N+i9J*J3&Wy!^6 z+jFN($kdG?F0JzM)`z}+swltza66rxsc3QY>Vj}m4~DYz#|Z|Prc)^ZWEVjEw;MRj z>2~%eBFnBtD5?-$X)7${TQO1lNwBX#*p^nEywgDa2;Hvm|g2M`toFu24gbD1BH70AD6P$Z!W@7wP7Qq?<_QnS2c zK?F83uQesfu4GNm$A(os5i>S?{A9YF?hRVXGCrZZj`{{9W~)<w8XtEKbNiPNN_=KvrFf+G2w1%kJM5AJ7A?2Oxp96?)x`e4CuXoCq9lW?- z1-qovgDh%4%k69(@3y$@BawXd$yv@%g-G!d|K@{6VR(-lX&b+KXHs*t2<1-~zj$NB9jYJPFprmd$mA&DJ(Q>dh6_OiIunvKtB0L z08cQKMS|GadU;5WkuL)};E>65_U12|+y0`I&`mgtKlH~QFGz*J9+SRYHH4*iXrI?{ zaI}{Yia5S}{|Zx9+yMVaXo~IT@WIJPJ?01&#LHCGb~GdThI75rEQEJ0*<*BX6P4i| zw`#fzHE{Nx6GysC&;})8`B}l{dXpV!jgkYR%>5hwqn^ zW=8H81&K%+;u+WL@P1K@<`MU)?Qsfd&R;YzmF(;ak1vOnh>23OLhW4hrUP~Z!EEv* zsy||ZomMRT0QD!zLi}Nw^B28bSGN!f6;gdtiK#)mKyn1ATW=|ER&(En6y=U(kg2Pw z7nThTGVY%{HmBFv99_4Gu}kC6>OB9g;f!HVxcwuEbD#QSLmykbt)PU|`yN37n6+jr zmes;ONiIq`s$lKFM2=73(&S9bP~-7gb|x0rV0V&W+>jLV8J7aJ?vHEwC$0xsLLdjW zCtp$Kll}Xr8YEze=*5{d&%tu)lOKrZjF(oFr3uq*$=6!*;&o!QlRmsCDw@C=Ul7_C}~QxbSO<48vxQ0JXiUrnHz;aV<8l^t*vJ*fFp*dqtMTO%kagNnn;F7Fxs$-Je09$bSy%bBi zurHQ5u9O+Q3~$GM@5UeCS11k=-?$#3KS~+plAprzY+WK#`*UX8wU6f?X9Rm_7%|X9 zK95mZ1O3aTG3xEA1QJXwOo@}ocYJq7Ck+Tw`;E+%gzT?)>*C7%HvYPJ5+x?2V$SBoRn$*Y8_%~s=HbuUOChjGBI|$ySA<% z^aNdOjqW{^#=j)o6u)rL*cdr!x6`Yyzp8=igf3yb0Bp zsA#xvwozO!CESkv%us60S(TtXy|8Ype&dADd3I>%!VD2jX6b-x-y>c=q9tsG;?XQI zmn8EF@4a>Q2t#?W)>c+k$IgDx0)0%=e$T8HscgUgeQ<>P1mY z%U*j})aIsH#BYAQ|5{@iGH~^JWpAMx`+LIyVMl+sKXn`K=A$*JMfWnV1sXcD3unF09RQE zn$$M>b3iMGA10`ORQNcIKXE$Zpa(k+%Ggd4?aqUftrs>W+^OV!957T@yviB5k{iBpP6jzD1bj z3a|wjR|y9eZP0=Q#2kZlVt&!^W>9%-X9p;3=nydJ$xlEB!%%&H(Ex~#&_)hY0dc2Q z8AQwp8*WMC7;)Zr;7<7->%$cM3L_MM;F5GjLkJOjA>`Tp5AbvXn9PE1qFy5!t@|QF zsMkoZctEEd_^yY~9JeQn*_*e0&~kq62fic@vW}a^S3_<_Ub+9XHWo*|~ z>}(}=OT(QwoKkMELaKu|z|E1x5W*z*EMmEcd=ntoY=AcIR0iU~8&9sqcDSi1;4-k_APYllvZ0Hl|c$BV_ebNJB)JFH{ zHSdqet}%(pX4Rz8T90xMDR|>PEL_&6xe1-F`A9CwHB30P77e}Bs&J46M#17;-=MPF!5m)eAea4R@}{+KDyiaV)yk^`-nHzcn>3 z^Vv)1D}sLGt>6j4*@H0ZO)}Sz`?NgXGsT0*(pu(SA(>5tMiylAcrlWM!!EENugrW;h)GEaP8dR4qSy|*#g--%;Ej%;GWoauZtk^d zIk-uSh_z2YdPKW~te#`;@N=FFAjTUZaM8*J#O^KkK3&;iXva0Y@a22d zAWRN*Bw`40OaK<|X#tCw*mZD2D(qZnd|eB1{mE(#9#i9u#CjS z`s)3nfrH2*e|YE^uuKZaKLa#@Tn**91HpdaJ^%DQ;6I=4>iv_`BOKIMz!VaKkg;a; zizbz_uABh`*O4yAu}cU-Cx{-sY!U?69>rkN0+7@3r*q$HfA|`3g}^S73c&jH_ws+y z^i%gi`mKn8YRdN=G|4(91iLHN3|Mt0AhK)BU(Op?jt!&$?CVx5z=S~m{J^78#1g`f zF&Bqknu5>!V97T-TVY4PcOPmhh@sxm{L8u3`#;E{KZvpb2lNiQA#~(5c4rgp`oFwd z$`z19>`d$GZP?)fsD{rAh*`S;nU=xcV1nozz=-t!`UjKre@^WmKky%`{(SGUJoz|g zD%uOT)rw*u^ACGG*o7)%AC~XLuP=UXK3HsUYxj*r5Z-%7yl-^$DLn@4*0fU?vi|~|sVjM6KN|dSbg%03!mH}qYJ0=15G_d0u=SRb zCY8=(R)-JY&r>JyV$4zlQD!dG=N#oB*%99p$>rKt%3B%vn;_qtQ8dYW>m7Re0v>#P zzzA#rR0l7I*$=XH4q1G}*&|i^SWJtQCNVp5g%sphyuw_btkbMsF*1Ks+k-{dI_!Nb zlk~vJc&?vr%FJXFB2Y4SfQbjoGSP`bg;uPP)w3o^tp+0~r^Ohst=Dk!Aapn6eM#Oz zf1uHerv7^_gJG>WyXJmJ_R1{Ea9SB$!{MK``Cv45lYS&Vm6z4 zhOqfrcJu4=!k-h9#VgK|^!55`N@mHAX^uuwfBl9wdc!tuSPa@0$=UvV4#rL@xUYQr z+o->upBJ7dhuSm7ZsVolaz)PdQ(Ly5+I4Pmmqi)+og=+)>h)C!gTHldgc8JTv|R6$ zZsYaP?vY~2Mr_uMCiL`mu{w~_DXrXZC+A;baNS?FS!HiZuKzOi$IFQJ>ikp6b1K>Wg-e&A#6~Qvo^Ja z-7)jgUgkBp&Cyakd^qeVb&Cw%8Mg=g0#z$v}hBjTOUA&~aGff0q|TjgtKqch?FlTepT z%TRGPdEdNcRsKeo8-0Onb+T!O2udI)r8@t!;OVz-EZs(o5z&a*BG83KPBZfU386Q{4$MW|?@J{@1TF;)B}ZuV+Xc4+&cvhhNs@Dz_2#YmE$JIt#sJ z+S0Y1UYX)9#rw)nwG#zoFmE$sD>pr_UD%Hy1>=-h@RdP$sY|POExh&g3C?wy6Oae1 z`$-&b+ArbVakh?qGA_3tboNr8ymbq_KGsvRyP}a*;h=|Da2;Oij@xn64I%Wo7$nEY zML}#R_I2Yg2S%o~sdTVe=;g_XI(mnZ>E23$Psg<4iiNQC)1IB1%}tkooO`;;-PtA~*3MAc zbC(p|eLJHTkNhg9vtN`I zzWmyoO!BD&+DidxA`4w0UK`0Vr-{zY>S!UPD|YQ*pI ziio8}{NQLq9BhK9cOYCoNXYlW#Q=mLFkdg9*MaL>j}ctc0YKT=Ki{cIR`hCt?4BWl zD93=LjyCDAvK`-+`Nz*Gu_5bJ0u|fg1##JzK@#*4w3QjG$e%L;Egh=}FGg47?l2|? z(3hi0+SE6Vg1>0cKv;;_O=?1KXjC7Y%y+-Z9NV^ul_Srrn#@dQ+E8nJ7NE2 zzVzr6A!7dv;h-~5vPkATYJJNonJf81`C}`v>Ct` zW&Yinm;<|(n~9IDbaLxLOkXu{qpyNt5Rw_B$_s#B`RM{mp*qmEO|vPDJ04e&mUAvr zW`o{ezNq)d%(P|uerktBSf;kx;r(^Fd6vXtR0pUW9gTK^1tUvG6XS{J+5sbqtb<3h zLP&a@-X6zSp5aQF0mzD#SJYK~K-bQ! z^DXXQl{^I6wygy0@d8XIUNTi`0Wp-Em+d%qcVs+vV#a*BD`#NeA}hq^!=z3Hq~|qb z_pv39eRFHxvO4@BwHwX7S&oQ8mer@7qU4c%h(Jfm%Ld-c{3O78-*ywy`bAYZwmNwm zGhyQSVQiSCQf}eRd9>)aG{Jo(qSPC(4RQiB#}|c%#UQz4EKS-F961EFl??ChZk`QV z>g3(lTy2?U{%>1$PH*YC?&jyG0VtX4frF#N3EX=__G z;SyiBPU*~;)ZUE2=$IH+{BW;JSzG%gzFvs8-;})eL6em!SG<4yHQT+@ak?~Y-4kR4 z0l=-a=!ITdyC4;r@ng6x>RIIu6D4hjlifvbKxFZr#*gE=xy$2tbo5>fo4+fd#hOva z8o5S*@_sp;$(k)Nw&kOcm^{_FGQ9Vmh!E3zpaI6r%+w6#y0vI-$PMB5bU{^%M-l3z z34F|3G)ujqEujYw4yTH(D6>+M7l<68HX{`~DD?sdt=y*@wJ`BR>0Y_8gZ%lz=hE$0 z=QwM6UZR#@Hlj(}m>EysJ#$TL;OprskVgJ+PUR-~V0+lljQX2CBo0w}&{>B%PyGQd z^Y};QGzUg*e>jn`!z%&KPf|4=e=)KlV`@IIA#JJZP*A6JtT=Jd;w)^r=+BS{8nxz@_r?X*TQPB6!v+3-q!bSnpb?`=W1vz)Usl0XU9>sIo z(o$fWRsX@saFH+nCk_T4Jc68n3Ia;f$vp*B+)xwLa}?j--J*8?ekY7@kyEXRStMlp zIrubU{oW76?(`YoJs-xuLGkmEZEcl6>5t6k>a34X{C+?L5Y1ZkH;KvP_;YXljR^6$ zrFZoK9_gR80v<8>WaxcUV`SpE1m85xNwCy<{ZQkjd*;)7`l>U)l9CvmURrq?hlDI4hbpE5&56g8bly=XK7kCZm8u zh7nUKCc)g(f;~~rNVDQA|NaHhrSyj_MD!PpK?L8UGMo9o6J@`OaV@HWTSf^7>g?Q6z@}tV z_Q7m2QY7JX0A8KD4`{n3HH+Z##+nVkJS)N2!AC!6s4>FSsKxABJFh@*0!l|pq=ZO~bZH`l8cGPg1rkaKr1;y;yz^eY=bm$C?#%q|`jaO_Wes@ zaLc?8I|NPRCCv1WFZ1Jz;j@8&iD~M&OsMLa54bSK_yQ_#4r#z~dn-4B%Mc+n?riU7 zKw5|e(8mb1<1p67GzvmJ^1t3gU1B-;;4qU#%q*Pf;%1AGzD zs{OMGMrq<6Q$xBtv)~G6Imez`jEBs+3!n1En$ec_StMOQME3_&02Y>LEt#isEoaAb zex=IG5HRoTrdS%G!%O52iuuGU+k6H1;6!x=k%9Cty0*w^YOeGVYI($b#5|-@RE(pw z(rB;YcH21H{(e9O3xq}E-&A}g&MmLwop~B!Ocsx=QydSqndx<=_kAI^K{tY!@A#1}y|A65Cjczh|c(t5+oLVK%fd9@!}(TcZ=0#BrX zPr{5X1!X}%8aue=l0d^lOFjUgCiqCgz25{F74vWHGhw7 zr@!PGVH4DMJ6UhXXQhCA!`q7cOhe=2l=ONaPK6Y6y?0SXP@fm z_#6}bv`A3*3+a@RkOXH*?F3`CS+5FJTcxZRi>N)IO}`w3TWgmTD#F##02QJ5d!WV#AaO~VKL@0}75MR^+YBOFBxv`25S z^a7>U9AIMc_T0s{W;WUj-T>0Px{F|9p(<_}PEiQs>?^h@=y%M`$&(-M6}84%NkWfnVoUStRw=@>LJwf76uT^# z!M6+yGOu{L0#zNnBj5yAeBGmUC?s;g=#-%Dakj|7Z_|d0gS69FN&2o0G>ti$1|ZM= zs`WbLQ41o?kDYFujLij%9cEh7$$Nj;94-LsFF;FwiS7@DcXu}e0v4ev0YGH3fi(k2 zB7ro4*xT(NnIb^49kR1$0ZuspqTHibf~IL|j6zLDKmdrS(*Zi+t=iFA$Bphmf-3w& zbYIk8LDnRHeHfBwY-t^Hd9jey^bh)ruKb(d@#`pLm3=yg4Mub$37BjkB1bn)G4KGh z0l09XEzq0Sh6}hq?i4WL3y|QS1T8k9=jQ&kQ!>!nz^c2i2R_f94KV2m!trXq+=DS1 zy%uoh|Ng*E0YMYM4s4z=Wo*lk zv-QiqEpIHrMaBolu~PVU<>L{@n2$WZG%wQcP3cra6%fR&=B1WF{q`RWD`UKX@Coo1 zZ4v;1aB-!iUk@v_r+DhYtTaX90Coq&W-l-Cj4j_^BG->U#ftmG*jT%pc++#4T{CVS z*KFQwo-5ht9>(Cwp+#!>#uU!_isT6S@*SGj-T8{1F8)k;A2*AT1E0)pr;B!^F4u6V zc;3H9_a8uw*=(I&fG+Ly)8_;}z?g{qD0%@I$4pUOrFz{BH0Z0L^N;Hg_`b;c@LaY5 z`$+q7T1O_Bhd;k4YQi2;wHFmNN4n$79}NmEE{xMkF*H5jOdH6X>D`ykZy9Qy^qjMt zLtDz}Vc4-0xQXc+<{PgLe94sIyYm*(h#RiP;~K!n7OQ}zQ(^A}`mj^gf>r*aiFT;7 zjaOa*{8G(=m5Ptlccx3D+NNp9r2GItSb6jPB%}f+MsWrD>Oj_l+a%~(qk%5mr9Jk9 zu4YXum27y~HrvdU{+vpnpD)16?4f5m)Is{$j)rfu( zAl?tS3kSUq)dw6O^yqEX>nl&?z_zd66JuEU^tObp*)Xg=y+tWH8l&xSyUZvObB#~D z1sd4#BOU7>Mjf;=O;awc9&T`ZLR=og_>ro;fBQS3#h znv5`cBY&6Q%A~3Mt_Qv@`q{Z)_v2KEW1FKU5+6%PKCcOwnGk|*Ge4hG zIK8N2nas456>n))CK8n-%+-woHb6z-#&yj;as(^tE})<-vFSxJ$ki7ZR9i zMk)9R%?X~j{T7XN+SXZ^`;UItekb}3+yOBI&Q1Tz4+FV`F#G^R%Rh`^iT?RXKvw)k zx-MXW1#Qs*P#-CCQOS~?gMQ6O3m9Xkk;55OF8?afHi3su7TpH&l)qlg;PBUEJm@-l9MeB% z?_a%o|Gf8f#xd%WYV(ANlUm=(cXTALX=l(Du{g zte@ESK5lOt=6`GIxV$u9?8i99PQRf5EYeTmbl#IV-4L)Jz_UGj2gK5<4sI^y)9z?K$Oscr{d+t3KjXZ$ zIl%PR45t5B?%!+ba_b5&L24`H44EpAg~bNxn!qMi^m>!3pF<+GKWI zRU8hMJuf$o)ZkjY)@4R(1t`;8q;Wf%vw5};D(0Tc>G9nc$wP&Dx^AUKV{go!Z9 z3@g+7@&In{?dZQcoyj=!2?L)m#=-Gd(6l&6F4w)y9W9Yih$b# ztbp*o950m4J+ev@=K0PP3v7A6Hf?aBnakf6@pva5Gy}c_VE%vkZPM^xzwWd#8KzWb z_{m=*dM*78kZELX0dj&Wo>ah?ZU(HBWbm)w|Is%f#w7=&u1>l_=Wu0?SDOPe|9_YCja4VzZTE}V75ad(bnB8&3Ic%TLC4c zLAJfaIXCqfpO5o1#_>73m>7BDJAUu8b{xi;h`8Cgc=hwr(>EQjI+e{1M1iP$P$Ua&EoBY#LmAQ@Jog$0?0LLQ3--lMjAPQE^>*kN zcqE8e0_=ThdI8Eb`#sqil?aN_H+c62^cjXUyrCtK;iI+9PI||d5H^d(TipP#BRRB? ze^I&QW#68Wn+CT$l{fi+=2^}G0;UPGKN>HCw((9JSQ4}oX*~Ung@*)YXbjeWXQJ{+ zz&9ET20so)!*qZR0|~IIw{)b_FD`B_OEdk~RSW#bSoO~TUb61L^7B1sR~f1o01q07 zavwDDm-^-C9}Z+F=bbceV=N#pv3{}!0F-h7+$Q=0cuZ#Y!WK*KQz@m>-qhO^(}^OT zCX>y{g&n16mq9tN!x7Y@{zq@vS$)>OYaGh7`!;tI#gyDcf&b8DbIV_>;1K|l=Gaz) zZ!)Ju7}pBkr`Y(J<_RR}-Z@oTy8r9It~!I3ZUQ&HQUO9VgkUm>!fG;L;?Kxyw`xQPAI^V zG=8?H2%q3po2;navZg+MSb^U-c181D+j(Z;1QEl_$>x%K*W5H9?&jpuGN_Y`0V!+l zRBvM12RRd;S_QHRVWSnWmF(H~d$SETxjAARj1eywU#s58u9dZHG4Xk4>g!@OFWB6V zI=%9>{k`T9HoHK$BW{oP?3KEZ+1G8iwYqjl> zc24=$S&=7Un#G8hO2@rBrua*y;2<-~S-{f3hB;IzDDi)jlq}RP$}?N=DqTFdt_fAB z=qZe?YUJH+J!ma)SBY6K#mmh=!yF0dDVmQAT<|JSOJ>crP9Qiec@|Oyi_VQl<4qQQ zN%U+Q$C-g?2KJi5wPI6m7kXW*>&w*@p|Iocb>g;?66`TBzZlcUVh5GR5XWhNq{*&H zc6J9}B%l=|Nz?NjkhiwD6YHO$e{-7S!!4^ld~ZLjSevbQ=;6m%>4`F{>@-yh+||oP z7?se@s@6Psv5mu2Dc63>@DgLbV$!<0&*qg>aO<$4D~qKt;Tjc8yGvOjahg^U8MzZ^ zHis(Nn7uhc5@qkyKa7ozZIi}pi0a%MyN3=CmV>RM?jY+3)z`<0`gG@3RtImPO6%6N z2kN3E%~N_RGDma_F{Y1-{E+?zA=Tcdld9oUT7FIPwn;wZl+}Y4Iq4sor>p!Eyq=2& z-6?%K9A=+#{`Pjs+vj^2AlUU@B@u7g)+Sz7+(>z(*5QOfe!b?|^AEEKj|;D|6V$RwPcdkNuf_1R2F+rs5a0<1C$}w0XB(4ushY>CN1vK7U?a zW`g^;*&U&JHKKYxe#ikzyxFgiap!U}bMD5U@AAXQ~yBlQ>}aiu*jT zR7w4Xv)8k@L?cHHL%lgCz%Al@ExwYG9&UKiN{^`ztwr_*CVIw;CT8-nh3~XrgKPDk z1HGok4YD_rR2~*R3!bY3xM3_5Ddu?iQ(t#qv7;HI-v*Q;&|>DOI2T=wbAtK(s+5Y;t`mp{F23I8%0d^Mi$`sxI8tv8da1#QjpPoZ9N@NaI41uP ztUmD8%j7hiaI9Z}v&cb~e7Hog`CQsc@A=HQj##<4w0!TWRjn@gG6-?|1!P-IBEr*2XDbLI`? z{j*z}(vM^Pqkws4(^V*Mx{z#BG}ieli*)<*ehI6iA!@c*Rj!pnYWg!Ur?b*gnkF$g zCz<^v#HddUSrvZ%8et5xjs(&GNJ*L6JSH^SiL%{W)U zoJFl3L;5-E_IR3nXG&DtDnga%sGy7I;pG4}3R$2Tn$@@Ju2R;6gH)Nr)oXeLOFybx zhvp_po(;{o+XKci5q6c72Va$!BOr)#M#R>aNY8$cNRh#YD!rwu2;bHa8S!%qkB(e& z$}3tano9Oo?UieYs{H)*Hp@$TF4`8(NpqycO>RqnDtw3Rhp{{542@Z6AHzD$%g9zA zTl=u`N_COz@{0%DU-ulXsDxuB@u(&pET&QELJcH@H!<*s*iy*OR>;PZIOHD2rfy($ z^Em!sj3TnLMC}pU?u0|?iB!z=-4}217c}IM>9uR+If+HR;S057`zqJ)!uN9a<01?# z6||;oKiS;VuC|-1N#PjOz(`J$#Gfzhv;s=&#&+Jy^kip=UAq#Nx>}l5crL!Z#2hkl z^5l=|V1h7SGAeP4?92MKgg-M!g}b>qxa2)#KC$3%^$WNCl9s^+puq1 zL~t@X(nNaeB)d)_o^L>SU`k3%gGBw79iy9Rj)cOh}n=lx#TH7Lr)!;m1=|f?Cly|b!k^MSezNU z*dS)lq{wl%3U!}h@VXcML33cMN7}|~c@o#0&2YTtzp@ozniK6&JoQ-uas$9W`GhQ) zDFSe1cECH|jb4>omwD3(4*jhLe2w34VN<`0$6{v%rqFL`NTtYrXe?FT3M=i_Ur>?t{#nCYq=7-zP%@`P5 zN{!k@&GM94?36pqI|(SLC{YYsd{ZnOc~v628a;eY8-SCzb_J@K0w|ihL@@o(52!{i z1uzp2zn_5b@Bna&y*k8q2Vd)>DK_jtg6A7L8-NXnzyY{OJ3o*Kdk_Bsl(-Kh2buE! z7v4p;{bP&ykVsye?G+|NHzGBiU9~ZjXT;Cm$=W-=Gzs z%gQtld4$Ov474se!^?}x{lTU^HK3C_N|ipYyft@?M-|(B)?_u9^+(N5 zGPy!-GQL9i0JKX+-O+_QabTlYZdKaL=y5Ql@-*)ll5G)AGeC`mk(|=E5iiNkCxyAS zS8~t$-CpL{f{39Q=r1ew8DZD|I|IporkVe5y8G{>nOT7F7tsi}%^c8$CR-?o0t-(! zBn?e8kbDVd4LBRn2RiCO5N)hV4^&csT_9P!)$002V$0132>-VIWy%wUCxmgtH0jt<;hb>({=_Kz^k@DI&h+X2051NkF{wkVj zPxGT!&Jp(x67Zy1oro@y5aYBu-kxv5$v#*2A~L_%M$Q(qjGL#d({Nw{UeDir2Sa{KHX5>Y-Rjo>o&zSiWFW8|H&KR(8QEO00Z z?mlkJ_dNcTlsZ@oc9r6n2@@jj3&+FRhFWv%l}?p}Xk&^51dGa#p1%F`qUXA?S3rzSZ=;fzL~LUrj#-x#+ABobn3pl6l~WC=hl{2#>hU;SkPa_oO2$`iw%c4LRz*j4NpgsO_nd1!CE*opfe!8ksg-P$Hn`Hjws^WXsx&D0CPxIq{ZXe#6mu>QI;iq)Ua#{N|F4izB0QAIMjqB#K%rw9fDk~F1r-;vd89kVB#yeyZ)IhM+IpUP4B*^F-Tv?VL)4W#} z+-O``dXKM}p6S5lDqb`+UY}uq`tfrqVoRq%ZANmh$cS{^+^Wz_-PnnPW;=C}^d(iG znsDb`M%V?e{|@7m`{$YKvHA1S@6O}hYR%}t8hGc3TRN2T%5ih~{{N6Ld}bKTVeaK+{b)m&j=K<5f7ct9Fe0q6=f zy)te1;wC(j$^M=(VCu&&z&AKP0+EFm{{qnbrA2=>;m5fA*$e;f zUU+g060pjs1NP;fBEXmVb#i?!rEbADx4?`@N2aL&;Xko#|B9Ob70aeyqx_xev}pIv zB(A-1>}QnQ&u5-q(>Pyzi2Rh2n@5xURt{edKkApaR8=T%wztRpjNRxH{p?VqSJ~I4 z-gU62L~t_rR==^4!?xFTfC6>rf-!RyGW3v9MIzoQGGK0o>O0!T+EnsLEqFR(-~Oz~ zuXk5;O^Yl-rqB^98(jy_xZw|J(oKO3Tk48Sp`GUa$b0)M^r@>(~6es zJh&UBJd@fHmFhI;nC$fAA;$0rROa`%3V&}S{JWnUp0U|l0rLGTa5^AEF!<9^->w$g zU!xynrv6q*!tde&{sHx_e+KO4?>+NZSk6x_tMTvpvYzppP5gYA8q;ibs}DoQj-I-& zEXG&%CJWbpY5#b7;;FA^0dfLOyc_=dBgJ)sFI0QTl9GhKPKcNaC~@W`4JLYkqO-54 zrDXwF4Czb|?VyI-w#DSzw+>&OmRocN+Nxm$tDzzWXkIq7LY(t$|h1uWFdCoD!YIVRKt7 z&J#g|V43K>_90CH!o3Wx#Zs)1n39hW()Ar$DItgs=N)Cv^#;Wyk=}({m4Jb>YdR-a!~&mGCsSupV3|3#U&DJ z_Q*WH_GyQ+#XeuQy{3rc^faZ*-qlm6<(>k^ zacb9I9BXBMnz=20ZsyvzJ0q}0Qu;Dx>N`^eu=0j`Uv92~htc@*y(@5Jc-i3QDM*uv z3i&;GL$e^%>REJmq3aZ|Szh_lR)`hE> zC&63Dn(a(h^0MEmH?kmFDFu;opca-&2 zeeVEu@PC9+sWMkucwd8j&1K+cEXdBukzvSmyS;quy#DKi@|ENbx;(^bOmz6o#N5eS z4qw^Tm+4SwT4Kdg@gieMCBT;gAu}lH6W|wUHrQ1=0ZL}GiD9ESUo*D0ohD0?3{7vA zvJh(+@3O^=LqBR54BQYJYkQ**8)Ec0DsvD9r8;<1Rq5F^0>qYXO=5HLdy+-(peeCy zCHLqv+BKV#0k)Y=`Np-qIx^!!xMhaw=b3D_mlaQHQe_;j=)0pFkV{UCn7B2KRS%!s zdm67DYbCiQZvixa?w;dhlYG-ftmqt+BCHcpV-8;S+!>6nQ2~X^Xgb?jSb0Hh6r_%y z?kj$!R$&@CRx43q!M%M<37Ke+s2Omfyl%c@Wdp5xECq4phJP-! z+KYmywZM*SsD^FlHsX-N5s(&#iT&lPtR|EUF!#bhMHuPMH%)y0BL;Ts8FMzR=OmA3 zduKh2(jOLoja{629&og;*I1GOEb(fH0hE0aLjkw6Y%P~G5;0A_5Zc)V4t1d#lu2{1 z|MN|o+hHJ~hr?neACiJiQV~ijKymRVl`!2Ghm7*>tGP;-9WfaA&Lp~pOhqc8GwSZp zKZ2cbVc-KwXK1=8qI|9x{`RLfS(ZIGgce?CV6^`6kiimoVsGtFDCe) zrvpk(aKHZX*eLIdtT;{2#IBBb$rKFA(7J!4fLc(w96z!)6Olfe%{Nk)ScV$vGi=qN zI>7YmNG_qo#UUCvq!msqMJRz5tCp)|Mw9P^fQ!M6gWO{%92eI)N*whekyXj z*D@(-(%Nfz#v3uK4oH$nGhiKJ^*Lde)_vr zuq`@LkAk}OO+hiwJFx-1mu7`n7_5rMzG)#3np{3)dwcda_Qdf_CB061@1vMqkH?`@ zH<$qhIf)Lg15+#~wKVZ>*Xo6zBON51Yh?V$qP1ZCL6dfKsmZa`b*W$!L<(~0n74I; z0JF+gfqVAydtK2fG+qwWyQ(Ei=*l|Nr5CduAObF&Of1?kM9rIXudyZ))TY>j3|+Od z7vSuLN}LpMt1qM>?wyf6#>7!5JGQsUV&n^oU#0x$=-6q^%Pw~Oc+{7G+ZhAp~sl8yXsr9_lF$TGCm>0iZRq&nARW?y~|PQ zB0S^(KAp>P{2Z}%1Hf>My(K3m3qV8{ch71j-E+>NGKVbBa(oNr*;*r9UDFA}q0r3` zAj`f>>HGo~8Y=Cqv`hm-caeR1f)FbYlebMS738AnuM8s)@1kp2n`Nvh-O^iq8JV5jd*%W}7PfZ2p04L#^aO`ONZh)2I29oHH zYGOa>opJ+MGzGonotLpbZ@dFcw^wq@sP=;Ui-e-iTcrskak_oEpMcH`0A44ax-*pU zdW(ZS(T)C~=ENObs5>j%sJ0gYEuZl}-EwSkpiAO?9A}7GqfqM#t&uvcfEaH`_LT%D z8)y}bsB{8wd|gJTjrdixg_AQb0pgX69(-*WMq{JruEOl7M^#ARrm04(cBWMpZgerq zHUX!hUYO>co#@KZ#&!4`Pm7SdL5sC$!uFmiFd=YiH8TAWO&{-n&)whc?l+m}kR5Wg zH;l88a!NR1wJD!xcp4yZOrFU!EWatCf6wUl&`pE#tayzNZ)FC+?y1FS9!$mZW3zAi z@?Z+6KvTpEqG99NRq#A{oCuf42EyuWiUNQ_5z$-z}3=kXl| zEbl$`-1-UeXAd4uZK-u~RpzynV%5=A+TciZXORBYE5%XZZD}jXdQH7mtmu@^%XE}Z z6ZDyv#U)~5C>(!cP{G)8@)XbQUKs>CMbxOeJWO15z%O>);n*OLp|OJA?oRXU}{9? ztuUPs35g9wr~2gdu#I;()*AIpQ;N+*g`8}~mT&wJl|QSr#WTq{Vh;>{_DktLZ6Is` zDfen&HJwDiDA#%jL{zGV9F-13L5pj{-k#gJQG?x~`%-|)RaS{MogKZ$cOKAF<{H=> zFO%JRidHe|=z6`BUaEuVH=VKd0jzI*fP||CoqDeOLmnb%6HGaeYL;Y%9Sdx!YEEpV zQsE$&$N&J|(f-=fJ}djpqUDh3i;}w6W4BT5r17T1#BgXbPm}fSgZ@Fp=Mauj8u;TU zk~293USyvC$*Wg-`%%$DwQHFXf@OC)zhqsAd(3v@K}_IBCy^)Nj^=V}4oIkJ?o7^3 zL8YkbEV~ z|LrjEzeEuKD6*(XGQ{hI)XC8l`xQhdYejG--(=p@q!g%^?qO0E6}@mcRzRfc_6vFW z0#VWP0&3KUQ;cVZ0MY&E4+dgFc=XO*2tX707$AF=8+9mOiI(a?TS9|<)q)k2vpce! zVhQ z45%pOjH3QGCrPum4q0iF z_~~SyQ%T_p#hq?#Md`l`7PvwJJkJdW@~D8_*ea4$Sy_pk#eJpXYTI7i=dxnu@?6_k z_GaV*+4*^jR-rfFE#fp*EfifU%_^&PZ2WwUO_7Sw*SCaEL*^QZ4>db(#2y=;$qMBT z6A_6;Vjuxu;OsIy{rp9oX6)-`cFJt6E_d&b(O1MdKiDeWr8jV`?Owy)5kt77gWVDz*I(j()e(qFEu-%y(w!$;f&(n!_I;y*0LcvX7R&Pm7A`%hg0Y7v~vXLP% zC}WQ_+LWuHs>Pj}h^F%PSRtD{4WdQPe0p@d&Pb9h{722p%&MdnQA~+i*_he*a(y9C z(C|1g@4hqTRt7o|K@GAH9_JcA{t)}Ri{;jUhGE3B|n$)~@08lqp7ZO4#)?6y{iQVlg zu(HAa2ZMUPx`&LOTw#z${Ks=VO??9ncC4ri4U3-4jY8X|Gt)F{Nd7IT40;8G-~K2C zVh*j)0gaST%k6#8aOFUt2e_MmkUlrQZO8?4pbEegDSM9db+Tt)o<&eBLGa2&&^Rh?E%MUh7`_qv>{GUApMW+Z5c+2rY56THpl{z8nY) z=qqn?cRCwfu70Pv`=$FxL6Pp-%JQO|?7FFrhpVeJLc9;b+LUL4&$=Qy##MNM$_u-u z6QMqZSa!aF{DR!qKlyC4W2^T8pz^Kd$DeE~tL}a;{c_>%o8}{)vw}P9e>8~ZW11g& zeBcJRhK1TI;6!*AeR-BCl^;T#@gnz{q!k`?1iM;r`LPy8z;!SaeyB*Y`b1E=@2fAWMq zJv8UE0!gTr{DZ-}u-*}`x+7kLtV@^03#%{R`Sl37njD{azj<#CORFtZyNHVvw)Xr>fz){2vvf@)97h&7*+a>_9lQI zz(=4%1_>xu@}Yt^fSrCP=|J2Q3p3VImwU6;O!~Kh$mTDr!+FLKK%@T-K(o`gSO8w~ ze66A?4j^ik+`q7PB~p&8PVvcFz-nb#oP3F$PfjQ(7;Y5rTg&p2PpXvrTK_hLBc(bb zbH=cXty_X*{03RM4cbr z6?!iuR@28%PSzigCH&oeM{@P5haW?94Z7-IpS86LPhEwZX3_7>`68ChiR&gr^84J; zh2+iK^xGB1HF=F9b;J?Q<*CEbojhj5@JZ27R9~=$kdK|W#y{u!qU7xId3bwoEb!qz&=u+N|W%#d~ z&0pdAl(rM;AJSAbE*oYz>Q#%w^! zQSPpzoB>M7CLy3rjHCH%Eg*BQ(Y8l*V!iq-Qt2>_jX3xjbU-tM^6=}*_`vLnDK#JA z!I!E*W=!fOCQmNTstczn2k~Xcyu7c%ERx5E{-aU7-+UgISd6#Xf&-hl+*VnKI~W)g zNXTZY0U5-;$dPK$K-Huwj-&I&h8Gf0S$uhq#IsZ1V|vY)8hXy+?;mE`>%|KYX&v@< zYTgN`waM|3FOGkY2qxH3ZxzirEH0f6ad?7axHLELX5Y?tR~=4ZSnJ0R#Xnk9C{<> z-VvBo_{b{O(_Crn>u9s>8J)4#))fr2)Y!N+ceojPa5;?mXvTEvhkZE!Z2%MI59~2N(!zhV{=fK_%!*;6^S{chj-o{E<3VMeGkI7+QN#e>n#Q6r9c`#-hh5E zdjkWM+)tMzSbGEd(=lx?pYJZ#Ud1o&7m#*x2ZGJx%e=;@9=R>iw0I{k?#)8C`mKz=eE*^u2$aqU?{LLH}`x&!5z0**_!F{t&D7fU-UbMA_RF zg*H2IB@)#iOy?_v+hTQ;Ry;+y;Ac~-UxF`Nsyz|)t+N6OmGU(0*c-qhMR`kdz%t z6eNKtw&HzO6~+{6YY^BjRjM|F#0>-aLKea$H=^iG5;&3}q?|hnlOqMqzGq9BtTj}t zs;w*;C|@$QtxUf9u-d^gGRaG$L09v@0o-Y4nfWTYwfkeL=?=yw*n&+K!Q3xEpvPZ% zJ)la)DRaXmj21?JkA8&Xas-tQzCfHK*`l3DhqNfdx!x6xcRx|W;rL-0&F!<5v6|th zL>h1|NO`{dPOq!uz647}eiXd}!P1Ib8z_BRDd!+iU9# z6JN60ygv7K2YwZ6OKk=b@1YN$ODtYA5SMEz(re_MP4Xb|-RqNRE;I?qIukb6*sy7bR|*^HB1rfPV3=-uo&EDT1WsOdHrqZH$@iZG7rygY$ zpJFcGu+pJhF(|&eX(a6tr}-&t#xl(+Xk2+>SKn6syioR#an$ezjp#pDhy1l6Gh*TEFLq-iF1|CFM!}= zI*(bRZ05c&CtMS_uYcFIhJ2=|vIeoWv?WpJWy)NxJ?=?YV&H@;7Z}nMOpZ5SQ}2S| z-O<`kdE@@@?N`d|ug@8|&T5@K@7$?G+H-3CsTC34iaShcwdmXUw0X$yl#XUyT78kE z#Mvmn!2KOhKf2r$!9NChjI9mXR3Syb%ZE)dPB>AyMS4r&WwPD@eX?HEuPdL+df8N)n zHHMf5(p5#^HFH?IgT*+U3f-RfEur8ikeC1&{)3@3MQ8YHkZt0-VwesSe_+}1nQs5m>%yS4d93Yp5xQaSDzFEHQcztFXXlw zt1MGf$II#;9NO4kdE%fMtPFP9AYm0*BXeC8}2T88$Kaot4_}u{M9} zv%EO+#aEz?@S*kF+rc=1WTG|F1MyU@O0m)Y6^_!|K&Be|p=Bfl`Xr1^WcY3ze3>qK znB!oC9?g&{LrH-1j4jHWVULu5O3}1>c9umXm!PwkprIWmN>10R++(CKTXJ~9@bqp17b>!`2jTDY7O%kCg*7QzS6Sr$p z8u#3a(owS2PXs`r8O;%X6azFlCTk9EN`@wfyezcswF#S?)RCy)yw;`2 ze^o5=X=3b{@^k)6uTQW=+z?g9>43j>teS*Cmon(?+n}4xBHbKS7u_G9FxFPy^DR)j zFnzbTjRMa^k?8G6%Uc*{fr>*1;NqTn$IX|!QBiW2uC$&*<^zk>~N*Y7RJ;uW1Bk*Gm^A}mD9AboyqC`pf!Be-vh6MO~*$^ z(NwIm?BPdiSPB=hX-RaXosAU&Yi4FX2Ss_Fp&EB;A5X+(MdodlSpjmTGzL zzAhe5BhV^ek0YF~>duc>7=F_=i??F=Pz@yQ55I*?60moosR0XR=V{vFEou)~P@Yy=LxXvzoU(9DttjbFWRy8b3}ilUb!`NGJ$RM(>^XWr>zf^-{-ditev5 zKaBM=a@0DH>JwYZ31+Emd+tuXc7v-+kVB+Eq79Tu38Z?$&JkG}0h(DXg*5kKvxk_| z;)ml{z^bC`Jm5KRP|;^^*YwQXS&8Ho%$8GMo8~31at3?_V3|r+V9@Z%w9E-=^x-z2 zNyLGAC;ZZwM!UJPRpj zOD{E{AbHF)mjz_nR+rA*zoG7qpJEA*u>H>DwPL>0?g)9JX-ZQl#*Wd2NSx#i;=Vwl z<5H6aAIb2kf=Y20zO6PK(p<6#e)dsRB}gnfxqk`PettQV!=?^j`Q^no&m&H zV~*@c8J(abPz5hi;*AizT{=&*&dVx(wAB<(zck4yd)R@T4Bol5Fy~*WezF1uvAdn| z#HP*d;Ki6)ZeG}0G$j`B$0y>`aEB6h6an^ON3Cx!2zEt`d;Z{NByw|zdPtWtGf@k= zX|BE0%s7t1q>-nzO!H-oIC!d197%-6M6AtA)34^2D;1KY_O-O8)1-kgTo4RIiKZ%2 zlqVn6DH0LE3X)S#&SHcHk=3H-{L;KkIOmRcHN-#YDJa{W+go$F0SpwvHPOMXb!^1) zai+Qu6{1~>xl^kYC3VwTVPPjY1t#Ma-WF;nXYoY#J;&|Xn@=A-ESx&APG=#jQCcUU zL6C#fI_xklWGylAX)$fr2L}tz8X^o;3Qp(T#v_B$Mu*JBtX$OvKJnk@n|KrhVzxWC z>dZf;)GAw7>d0pfwX=;@Es}Riz8H^%!_ns#Ft@W6msgz%a{NQ7CXAuF!}J)X6HdH! zXoUB}Qvs};cL4!r_C?-NUjMmJ{@#7@?a-HeM)@wwlt=pT9Uv6Z8i&%Xo!w(I@a3c z*-GUQdetZxmtbu_X&j%qE_k2s_48d{IE4u}h`o@&)=6HPGV!waE^W-DCBh{2BuK8U z6-(b5!t!?x#I;JX5ZD9RHo(U!#4kaO}36v-CCxr{MXP1jG+a-wAMctWt( zmQ^NOdCTFBEnRP&AHSJV;$?J!xM{oI&yS1t(?loPxfj!TD9AiYuQ|t*K`+E;u+U}0 zM=awLTdb+Wk`GrRA3$b#v(BtRYA7h}@tViOY_Qi@ID8TonT5inB7|A|aU!XBCH++i z2gz8yGN`keA!A=r>Fkb0Be|5=)f$03s)U-ThBMc{cQEOS24KE;(Nb?2cGReuGRMn6 zm)k?lJn@&V2|I+HGm$OQ1YtYyw)w<_rPcu)2Lm+f&Cvoa8>K`^{(tRVXIN9&x(-E9 z5fDL;BA@}K1r!A=nAm7$5LAi*Aruv<8Rp_j_M1186u(c1$zaQEVY1|JXL( z*9f(nNHG8i9)fnFxKs^Fc7UmBNv>+@6m{~IlvA2#&PTvnlo4)eR=h5&*2(>n_Jn&%OL%Te=PsAb+_p0_ zoQ!By@&>3H!faK>-{pwnva}gL=$15C>%w4qS08Po4+aOU?94$P0r3Cw-2*gn${4xT z2Cojd`NHCb@Z$(l?2#>mP$PKtT8?Pw6^$1mVjN6I1cO^TqB^-EU8`4(CHuzQh0==a zp+WGxrgYj2;H_`^(?liTz4Nbn_W*lR{=kkME8)_Oh-R*t7t6fS(=mukg)NRI85D3IW z{H)fN4bZ1GD&PJ&hx*fc)o5T~w`~!?acqE?Qh?l)w@jz~-T)rE6_I`m2@t9|Zh&Y; zBIH0rfH?(-KGHbifIWjJ>|3Q_bgp#F`$-HCI|QPO6h} zo@s)ELyV@{}wefcGaY=iRW3}xfjekj)3>#KmP__ z+QRZg#d0^wTX}aP`UJW3p6?S&183iaNo`0jHZG-4JU8?4xdU0XJ3y&V07+g(eEJ{Q z#Gj}qcq8yHX}Z7S=ls`vCh3sB=WP=|??@(p%*`@UeN+)`L{)^9lBPp2M~?zAzTLTg`+Sj*>PPV7O@->Jt z4aS(du#Z$K_PHlizEaJ9)U4E?%AYSOBEQYAzhFI_cES~#Y&~n`_7uBnSf7aH_0SpI zgs37Gmv6eD<7T?`P7S95N^AYG4Fn$ueLYj&NW~=PjFon#%?&UEY!}LS2 zPS;FZWsy@&1T(pw0c-8nF7s@SbdCAB>Zq=1c+)vzP7}^YnV*!dxm_{Mg=D1Irx^y( zn^9q@gH&h7v{YOcksF6eHgYI>Rcj=Uc9sJ9UJEo-^H1puDJhsrI_HqJG0m+t6WAY! zv9wt-^yl0>P;cSfT;=_$Wp>eEPl=sQzx{dWh>4KH0{|~EUlF@AcIqg!1J*NN_L4gz zues7i)aQCgtypV<>CX1uuL`d-oZ;4o@_D||D`O^~4@@$$I_5*_nat^#;!VK3gPeok z6}G&3TE40H$BXArXR&6UN~SmTa(Dp=4V;q(*PlM0%%NJ5-2EZvw!fTwXW@`596igq8+%b<)WD6VoqNq zk8RoBeyioll&M>~%Rcsb`Pj(DU15qhI#on#=Dc^Bw&Zk)>hDpS@qL24firhYcMYQR zWCd$xAL>7A_(Prs7AY%q_SnOd2AZ?EpnmB>GNE!Bw#79P*#Q|XbPwk0S97q>mVcTnV>PXxT?#5{)kfhlCMl5zfC+l`yS^O__k%O-ANfCDni*6wo5#E zN)YL}JUtGj?5=zo1Cmq(+V=?AjwqL)$q;ISnHj5y^LLMb5NM#2!VU#Mj{KdD?lM zH(6Ek1x0PrEZNu+S|b%yJVa6|Wn=mu%d8@1J8Hvw>>E8!+;UnNSTV4=Nz8-Q67LIh zQ0A*L)heN)rOl48JM=Btlz>&I(wM+1W7#N6oUtJs8>@&tf*mY>hUa8M70Mv)Zo*|` zrmSfesk1Qq?PBUvSR~fQbz^j>10?sgm!w%RJcrWdYeR!jSi0z3oj_87_r024#8urK z=OPia>wNm5VWf%C$0n$g6K^j!pS`1Fs$;^?ty`wT{Iry~^mf(Rh_~u^;i8*dy`|mc z;N0rqTPJ|=GvL=~`nNiM?EXzpf8+~-7UhEFZK#wr<=}bORk8<+6hUF2N6beI!9-xA zrJk>e%i40VB_0a9`;t!HX`|DA5@}zfc3~JMd_gB(;`;Vg@|gEWgd|b>qTG{?F-`V4tv!Da5OQ zEPkI}?E52pV21l{h5s)rSTi=x4*+!K{TrZFg>>BW(;xj!WqJjLV(M?L#}HKawU*$IL&{;kWTTbXE!mH4Ah#it^UM!_Op8Ql>TYR^g@4HhR0oCuQ)!v3Smmi03@ADR0a3)13p=HUh zeE=zI*X)UBXlR#XJzBYlH*Q;6j81Hue^`3{y+Nqq6yzK*r_VsrP0dhq~ z!vpTs2a?m0rd(X0`>~ap`0(>s4PJ>%aHuzYBGGlLPRxQTioxV?If*5Lu1Ew3_vG7*l$#q{RUDKy)F1q z>K?>{i+rJj>eroHfFL zQz7L>_vkqemwomQ-tTXXy-_0(dw~V0%OE(v)#k8uO)JW=*mWmZ{*8=_VxV%_m3^-C z771zZK>o`COD}Q8B3se2%5l`>cbxC6EwX*-;$-?1YrnAgdso%Lo(nJg?T;$(z*x~> zRN@uO$zc?SxX-X^Y>#8z*+UQ4e8TMn?Of|da&>Y`%aBxV4A%R3BpnZ5)TGrxS!t&t zNpTf1d`1O^jzwi&N|KD~S+(+EVGuh_S~q+Ro&q!app62B3bi(R>x38(4VCEH9T zA(@Ogrxj;Gg{MjI4!y&vgmn|LsBhEx;09v8*-6yRZN5Hrn79vK@_Z4pK z)r;LFsOeqH6Bzh9J)a?nMSXPW(i9Oli7FyO6DBRjR*CbpV}b%KPxocTBa9li_BA>& zJ1E1Y8unh-KIe;!$a-uiB%F}hqQcQMu*J9+z(@UWuh`fr)^s@EOXQl69cD?m)4Er> znhwF#n^C1VK<0sO=udl_+*K4A0M5U!xmrw>n4vi2f+>s{Gjp;T^KM|%ttB^38uv8) zhy6pr>-PmX>CsPc#?Ruas`9oYdJdsIYa;$# zjN{`IsZ4m>Bf?O+G2p;?zgc!BcZLIzk9l9T;d=bYJp0Rae_Z|84++`+B@Rg(1*RC@gx=6dPzVZNC|Be>iTkPT*KmfkYL zu%R0s=bLj1KyGbOW-`tiu>J9Ro8#N}{TK93x5O#r%Ws?Tp{5VL;XqtLJNuW%ZQ@>b z@~VhqE;$=3(ISp-dDny1LzxVu^sAwg`n8xThU-xj%}VH~+beiX>!vj?__{Be$uu5m z83`E~z-YBwWEVvdtAt@)OLd)w@So-~2M@Zr%RSV)@zm^+-E6U;{ixnVO>mDzIRP)6 zWa~m|;?-20>N?l%sDRylda6D#t9{S*fj)JUQ02Nr-7~o>n_OGEtP@_m&Qy}nfb@n< zcXGgD*A@EW`@E`Z9;Ov~JW6x)Fk6QykmPREUkuk`nxZ_&(exQxAYuUqgrS*iRDBh6;rk9L9L zTN7dlxZ-$C!hMA;G?%@5t;;wHatn)3ZHgIJ?o-bw!AYnHN{Ps7PSqgb>!u^f+p#=U zU)1oCB_l-*tvgP;6l}L%Mp@)VpD(zl_<;ZFgN}xu21XpsE}nJP*V7YS6qa4TUnW4E zs970ZYNsX4sJJpqw>Xa^iMtfscU zvqT%)GUX!d7`Pmfr>d@6QO##n%=vKJ#N!T>7mo7Xh-8ahLj9+tE^XI6)#ZzqCRE-_W+q7>FrSAmN|pLxxOnwB&e89 z+qKX$E|m;-PfT%At+loS0bP;pn4x48`T4^qCw#{=#&9cYV<&}(G=&r&%me_iB41Ma zAh^YDIgETiLgJ+HG|_jqx>>Kcyua}M+V6Jw-X8vK`o$7q7BTFfhCS?sl&J;nmNKPP z+uX=G(GeU=!9yItug&e!O8rgN59!@y==RjXGrU9tgf3wOvIV_nEpAoB`BPIPny@DBnnU8N z0I=i3#Jf(oJD43$+e`Kg+bXG+6!>2v_hZ|%Y^`}@&B3~ZI@vptLS3gANTpyppOQc9 zZ2(#Wz%Xkv64N$^C%6B5-H_SJwzr2%ax-SQ{*T4aI zZYyCyd9|5yRvCnFfvm50(SO$#_`MH)w?KdvMXP4VRQ7p*TuZf^B4*-2sC?fLxu0%^ znceC_gCO|;Wfp#FATaXM|2FcvLwFcSokTw6Ys%N6hvKRV)URvfQe7Rx7(|r>;&&aX zo4+g1K=Rk}_dHmb8>B|vPmyAA+GZB6O`g0_KjS>*ebs%(iRs=OPdEjD2`QZfglfPr zE&};OX3mEhi5KS&C>#aQ0HLk&zll==lPcB^M8Q!F$^d+E!Xb(vFw@asKhJblR093} zn<^BI^Ou>f=bIFq`HW^xNsh4`S0NuFc`VMcjh#xR+CVumak{$Ys}s!v%Tp3eHH6{M ztAG2ISHfLOxUFpcwf74C$}24!{FMv#qUcuxh&5GDFlGqzvj@|t0&<1=Qrc<_avKu? zy498H%!3!~#R}VLG7S?aSR*oyzG-JLz>ss%NWcrQASwMimwgzI12GjH6wEqT+nCy0qf~ms!6WPb3hY9}5N-3@=qk;}OTrPY-JU$4VIHmZEvCp^( vd=NXn=k`xE8sMGt-;xyQds)A^(EZbSI^S*i-Im|m!1p%rJ8eK@qvyW>xRJLr literal 0 HcmV?d00001 From a83e344f9724c6143188d4f2f6b0aaef65c10e16 Mon Sep 17 00:00:00 2001 From: Noah Falk Date: Wed, 17 Mar 2021 03:07:32 -0700 Subject: [PATCH 2/9] Applying review feedback --- ...ributed-tracing-collection-walkthroughs.md | 152 +++++++++++------- .../distributed-tracing-concepts.md | 112 ++++++------- ...ed-tracing-instrumentation-walkthroughs.md | 98 +++++++---- docs/core/diagnostics/distributed-tracing.md | 34 ++-- 4 files changed, 233 insertions(+), 163 deletions(-) diff --git a/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md index 649dfbeeebe8d..8210d4637e1e8 100644 --- a/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md @@ -1,21 +1,21 @@ --- title: Collect a distributed trace - .NET -description: A tutorial to collect distributed traces in .NET applications +description: Tutorials to collect distributed traces in .NET applications using OpenTelemetry, Application Insights, or ActivityListener ms.topic: tutorial ms.date: 03/14/2021 --- # Collect a distributed trace -**This article applies to: ✔️** .NET Core 5.0 and later versions **or** any .NET application using the -[DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/5.0.1) version 5 or later +**This article applies to: ✔️** .NET Core 2.1 and later versions **and** .NET Framework 4.5 and later versions -.NET applications can be instrumented using the API to produce -distributed tracing telemetry. In this tutorial you will record this instrumented telemetry with different telemetry collection -libraries so that it is available to diagnose application issues. See +Instrumented code can create objects as part of a distributed trace, but the information +in these objects needs to be collected into a centralized persistant store so that the entire trace can be +reviewed later. In this tutorial you will collect the distributed trace telemetry in different ways so that it is +available to diagnose application issues when needed. See [the instrumentation tutorial](distributed-tracing-instrumentation-walkthroughs.md) if you need to add new instrumentation. -## Collect using OpenTelemetry +## Collect traces using OpenTelemetry ### Prerequisites @@ -31,16 +31,17 @@ dotnet new console Applications that target .NET 5 and later already have the necessary distributed tracing APIs included. For apps targeting older .NET versions add the [System.Diagnostics.DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/) -version 5.0.1 or greater. +version 5 or greater. + ```dotnetcli -dotnet add package System.Diagnostics.DiagnosticSource --version 5.0.1 +dotnet add package System.Diagnostics.DiagnosticSource ``` Replace the contents of the generated Program.cs with this example source: + ```C# using System; using System.Diagnostics; -using System.Net.Http; using System.Threading.Tasks; namespace Sample.DistributedTracing @@ -83,15 +84,23 @@ namespace Sample.DistributedTracing } ``` -Running the app does not log anything yet +Running the app does not record any tracing information yet + ```dotnetcli > dotnet run Example work done ``` -### Add logging using OpenTelemetry +### Collect using OpenTelemetry -Add the [OpenTelemetry](https://www.nuget.org/packages/OpenTelemetry/) and +[OpenTelemetry](https://opentelemetry.io/) is a vendor neutral open source project supported by the +[Cloud Native Computing Foundation](https://www.cncf.io/) that aims to standardize generating and collecting telemetry for +cloud-native software. In this example you will collect and display distributed trace information on the console though +OpenTelemetry can be reconfigured to send it elsewhere. See the +[OpenTelemetry getting started guide](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/docs/trace/getting-started/README.md) +for more information. + +Add the [OpenTelemetry](https://www.nuget.org/packages/OpenTelemetry/) and [OpenTelemetry.Exporter.Console](https://www.nuget.org/packages/OpenTelemetry.Exporter.Console/) NuGet packages. ```dotnetcli @@ -99,7 +108,8 @@ dotnet add package OpenTelemetry dotnet add package OpenTelemetry.Exporter.Console ``` -Update Program.cs with additional using statments: +Update Program.cs with additional OpenTelemetry using statments: + ```C# using OpenTelemetry; using OpenTelemetry.Trace; @@ -108,15 +118,13 @@ using System.Diagnostics; using System.Threading.Tasks; ``` -And update Main() to create the OpenTelemetry TracerProvider: +Update Main() to create the OpenTelemetry TracerProvider: + ```C# public static async Task Main() { using var tracerProvider = Sdk.CreateTracerProviderBuilder() - .SetSampler(new AlwaysOnSampler()) - // Add more libraries .AddSource("Sample.DistributedTracing") - // Add more exporters .AddConsoleExporter() .Build(); @@ -125,7 +133,8 @@ And update Main() to create the OpenTelemetry TracerProvider: } ``` -Now the app logs distributed trace information to the console: +Now the app collects distributed trace information and displays it to the console: + ```dotnetcli > dotnet run Activity.Id: 00-35c0e68b0dac3c49be08a9d9cab32579-0b7477e11aa20d40-01 @@ -157,29 +166,45 @@ Resource associated with Activity: Example work done ``` +#### Sources + +In the example code you invoked `AddSource("Sample.DistributedTracing")` so that OpenTelemetry would +capture the Activities produced by the ActivitySource that was already present in the code: + +```csharp + static ActivitySource s_source = new ActivitySource("Sample.DistributedTracing"); +``` + +Telemetry from any ActivitySource can captured by calling AddSource() with the source's name. + +#### Exporters + The console exporter is helpful for quick examples or local development but in a production deployment -you will probably want to send logs to a central logging store. OpenTelemetry supports a variety -of different logging destinations using different +you will probably want to send traces to a centralized store. OpenTelemetry supports a variety +of destinations using different [exporters](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#exporter-library). -See the [OpenTelemetry getting started](https://github.com/open-telemetry/opentelemetry-dotnet#getting-started) -instructions for more information on configuring OpenTelemetry. +See the [OpenTelemetry getting started guide](https://github.com/open-telemetry/opentelemetry-dotnet#getting-started) +for more information on configuring OpenTelemetry. -## Collect using Application Insights +## Collect traces using Application Insights -Distributed tracing telemetry is automatically captured after configuring the Application Insights SDK -([.NET](https://docs.microsoft.com/en-us/azure/azure-monitor/app/asp-net), [.NET Core](https://docs.microsoft.com/en-us/azure/azure-monitor/app/asp-net-core)) -or by enabling [code-less instrumentation](https://docs.microsoft.com/en-us/azure/azure-monitor/app/codeless-overview). +Distributed tracing telemetry is automatically captured after configuring the Application Insights SDK +([ASP.NET](https://docs.microsoft.com/azure/azure-monitor/app/asp-net), [ASP.NET Core](https://docs.microsoft.com/azure/azure-monitor/app/asp-net-core)) +or by enabling [code-less instrumentation](https://docs.microsoft.com/azure/azure-monitor/app/codeless-overview). -See the [Application Insights distributed tracing documentation](https://docs.microsoft.com/en-us/azure/azure-monitor/app/distributed-tracing) for more +See the [Application Insights distributed tracing documentation](https://docs.microsoft.com/azure/azure-monitor/app/distributed-tracing) for more information. > [!NOTE] > Currently Application Insights only supports collecting specific well-known Activity instrumentation and will ignore new user added Activities. Application -> Insights offers [TrackDependency](https://docs.microsoft.com/en-us/azure/azure-monitor/app/api-custom-events-metrics#trackdependency) as a vendor +> Insights offers [TrackDependency](https://docs.microsoft.com/azure/azure-monitor/app/api-custom-events-metrics#trackdependency) as a vendor > specific API for adding custom distributed tracing information. +## Collect traces using custom logic -## Collect using a custom logging implementation +Developers are free to create their own customized collection logic for Activity trace data. This example collects the +telemetry using the API provided by .NET and prints +it to the console. ### Prerequisites @@ -187,22 +212,25 @@ information. ### Create an example application +First you will create an example application that has some distributed trace instrumentation but no trace data is being collected. + ```dotnetcli dotnet new console ``` Applications that target .NET 5 and later already have the necessary distributed tracing APIs included. For apps targeting older .NET versions add the [System.Diagnostics.DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/) -version 5.0.1 or greater. +version 5 or greater. + ```dotnetcli -dotnet add package System.Diagnostics.DiagnosticSource --version 5.0.1 +dotnet add package System.Diagnostics.DiagnosticSource ``` Replace the contents of the generated Program.cs with this example source: + ```C# using System; using System.Diagnostics; -using System.Net.Http; using System.Threading.Tasks; namespace Sample.DistributedTracing @@ -245,19 +273,23 @@ namespace Sample.DistributedTracing } ``` -Running the app does not log anything yet +Running the app does not collect any trace data yet: + ```dotnetcli > dotnet run Example work done ``` -### Add code to log the Activities +### Add code to observe the Activities + +Update Main() with this code: -Update Main() with this code that logs Activities: ```C# static async Task Main(string[] args) { Activity.DefaultIdFormat = ActivityIdFormat.W3C; + Activity.ForceDefaultIdFormat = true; + Console.WriteLine(" {0,-15} {1,-60} {2,-15}", "OperationName", "Id", "Duration"); ActivitySource.AddActivityListener(new ActivityListener() { @@ -273,6 +305,7 @@ Update Main() with this code that logs Activities: ``` The output now includes logging: + ```dotnetcli > dotnet run OperationName Id Duration @@ -285,41 +318,42 @@ Stopped: SomeWork 00-bdb5faffc2fc1548b6ba49a31c4a0ae0-c447fb302059784f-01 Example work done ``` -Setting is optional -but helps ensure the sample produces similar output on different .NET runtime versions. .NET 5.0 uses -the W3C ID format by default but earlier .NET versions default to using - as a precaution -to avoid compatibility issues with older distributed tracing systems. See +Setting and + is optional +but helps ensure the sample produces similar output on different .NET runtime versions. .NET 5 uses +the W3C TraceContext ID format by default but earlier .NET versions default to using + ID format. See [Activity IDs](distributed-tracing-concepts.md#activity-ids) for more details. is used to receive callbacks -during the lifetime of an Activity. - - - Each +during the lifetime of an Activity. + +- - Each Activity is associated with an ActivitySource which acts as a namespace for a set of Activities. This callback is invoked once for each ActivitySource in the process. Returning true indicates the listener should be notified about Activities associated with this source. - - - By default - does not +- - By default + does not create an Activity object unless some ActivityListener indicates it should be sampled. Returning - + indicates that the Activity should be created, - should be set -to true, and -will have the + should be set +to true, and +will have the flag set. IsAllDataRequested can be observed by the instrumented code as a hint that a listener wants to ensure that auxilliary Activity information such as Tags and Events are populated. -The Recorded flag is encoded in the W3C ID and is a hint to other processes involved in the -distributed trace that this trace should be logged. - - and - are +The Recorded flag is encoded in the W3C TraceContext ID and is a hint to other processes +involved in the distributed trace that this trace should be sampled. +- and + are called when an Activity is started and stopped respectively. These callbacks provide an -oportunity to log any relevant information about the Activity. When an Activity has just -started much of the data may still be incomplete and it will be filled in before the Activity -stops. +oportunity to record relevant information about the Activity or potentially to modify it. +When an Activity has just started much of the data may still be incomplete and it will +be populated before the Activity stops. -Once an ActivityListener has been created and the callbacks are populated, invoking - -initiates invoking the callbacks. Call +Once an ActivityListener has been created and the callbacks are populated, calling + +initiates invoking the callbacks. Call to stop the flow of callbacks. Beware that in multi-threaded code callback notifications in progress could be received while Dispose() is running or even very shortly after it has diff --git a/docs/core/diagnostics/distributed-tracing-concepts.md b/docs/core/diagnostics/distributed-tracing-concepts.md index 64141672f1b81..8ffdf64ee1d79 100644 --- a/docs/core/diagnostics/distributed-tracing-concepts.md +++ b/docs/core/diagnostics/distributed-tracing-concepts.md @@ -4,19 +4,17 @@ description: .NET distributed tracing concepts ms.date: 03/14/2021 --- -# Distributed Tracing +# .NET Distributed Tracing Concepts -Distributed tracing is a diagnostic technique that helps engineers localize failures and +Distributed tracing is a diagnostic technique that helps engineers localize failures and performance issues within applications, especially those that may be distributed across multiple machines or processes. See the [Distributed Tracing Overview](distributed-tracing.md) for general information about where distributed tracing is useful and example code to get started. -## Concepts - ### Traces and Activities -Each time a new request is received by an application a new trace can be initiated. In +Each time a new request is received by an application it can be associated with a trace. In application components written in .NET, units of work in a trace are represented by instances of and the trace as a whole forms a tree of these Activities, potentially spanning across many distinct processes. The first @@ -24,15 +22,13 @@ Activity created for a new request forms the root of the trace tree and it track duration and success/failure handling the request. Child activities can be optionally created to sub-divide the work into different steps that can be tracked individually. For example given an Activity that tracked a specific inbound HTTP request in a web server, -child activites could be created to track each of the database queries that was necessary to -complete the request. This allows the duration and success for each query to be recorded independently. -Activities can record other information for each unit of work such as a name ( -), name-value pairs -called tags ( -), and events ( -). The name identifies -the type of work being performed, tags can record descriptive parameters of the work, and events -are a simple logging mechanism to record timestamped diagnostic messages. +child activites could be created to track each of the database queries that were necessary to +complete the request. This allows the duration and success for each query to be recorded independently. +Activities can record other information for each unit of work such as +, name-value pairs +called , and . The +name identifies the type of work being performed, tags can record descriptive parameters of the work, +and events are a simple logging mechanism to record timestamped diagnostic messages. > [!NOTE] > Another common industry name for units of work in a distributed trace are 'Spans'. @@ -45,42 +41,46 @@ Parent-Child relationships between Activities in the distributed trace tree are using unique IDs. .NET's implementation of distributed tracing supports two ID schemes, the W3C standard [TraceContext](https://www.w3.org/TR/trace-context/) which is the default in .NET 5 and an older .NET convention called 'Hierarchical' that is available for backwards compatibility. - controls which + controls which ID scheme is used. In the W3C TraceContext standard every trace is assigned a globally unique 16 -byte trace-id () and -every Activity within the trace is assigned a unique 8 byte span-id ( -). Each Activity -records the trace-id, its own span-id, and the span-id of its parent ( -). Because +byte trace-id () and +every Activity within the trace is assigned a unique 8 byte span-id +(). Each Activity +records the trace-id, its own span-id, and the span-id of its parent +(). Because distributed traces can track work across process boundaries parent and child Activities may not be in the same process. The combination of a trace-id and parent span-id can uniquely -identify the parent Activity globally, regardless of what process it resides in. The - property will also -reference the parent Activity whenever the parent resides in the same process. +identify the parent Activity globally, regardless of what process it resides in. + + controls which +ID format is used for starting new traces, but by default adding a new Activity to an existing +trace uses whatever format the parent Activity is using. +Setting +to true overrides this behavior and creates all new Activities with the DefaultIdFormat, even +when the parent uses a different ID format. ### Starting and stopping Activities Each thread in a process may have a corresponding Activity object that is tracking the work -occuring on that thread, accessible via -. The current activity +occuring on that thread, accessible via +. The current activity automatically flows along all synchronous calls on a thread as well as following async calls that are processed on different threads. If Activity A is the current activity on a thread and code starts a new Activity B then B becomes the new current activity on that thread. By default activity B will also treat Activity A as its parent. When Activity B is later stopped activity A will be restored as the current Activity on the thread. When an Activity is started it -captures the current time as the -. When it -stops is calculated +captures the current time as the +. When it +stops is calculated as the difference between the current time and the start time. ### Coordinating across process boundaries In order to track work across process boundaries Activity parent IDs need to be transmitted across the network so that the receiving process can create Activities that refer to them. When using -W3C standard Activity IDs () -.NET will also use [W3C standard networking protocols](https://www.w3.org/TR/trace-context/) to -transmit this information. When using the - ID format +W3C TraceContext ID format .NET will also use the HTTP headers recommended by +[the standard](https://www.w3.org/TR/trace-context/) to transmit this information. When using the + ID format .NET uses a custom request-id HTTP header to transmit the ID. Unlike many other language runtimes .NET in-box libraries natively understand how to decode and encode Activity IDs on HTTP messages as well as how to flow the ID through sychronous and asynchronous calls. This means that .NET @@ -89,49 +89,49 @@ automatically, with no special coding by the app developer nor 3rd party library 3rd party libraries may add support for transmitting IDs over non-HTTP message protocols or supporting custom encoding conventions for HTTP. -### Logging Activities +### Collecting traces -After creating the objects the -app developer typically wants to log the tracing information to a persistant store so it can be -later reviewed by engineers on-demand. There are several telemetry collection libraries that can -do this such as -[Application Insights](https://docs.microsoft.com/en-us/azure/azure-monitor/app/distributed-tracing), +Instrumented code can create objects +as part of a distributed trace, but the information in these objects needs to be transmitted +and serialized in a centralized persistant store so that the entire trace can be usefully reviewed +later. There are several telemetry collection libraries that can do this task such as +[Application Insights](https://docs.microsoft.com/azure/azure-monitor/app/distributed-tracing), [OpenTelemetry](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/docs/trace/getting-started/README.md), -or a library provided by a 3rd party logging or APM vendor. Alternately developers can author -their own custom Activity logging by using - or +or a library provided by a 3rd party telemetry or APM vendor. Alternately developers can author +their own custom Activity telemetry collection by using + or . ActivityListener -supports logging any Activity regardless whether the logging library has any a-priori knowledge -which makes it a simple and flexible general purpose solution. By contrast using DiagnosticListener -is a more complex scenario that requires the Activity creator to opt-in by invoking a specific API, -, and -the logging library needs to know the exact naming information that the Activity creator chose to -use when starting it. Using DiagnosticSource and DiagnosticListener allows the Activity creator -and Activity logger to exchange arbitrary .NET objects and establish customized information passing +supports observing any Activity regardless whether the developer has any a-priori knowledge about it. +This makes ActivityListener a simple and flexible general purpose solution. By contrast using +DiagnosticListener is a more complex scenario that requires the instrumented code to opt-in by +invoking and +the collection library needs to know the exact naming information that the instrumented code +used when starting it. Using DiagnosticSource and DiagnosticListener allows the creator +and listener to exchange arbitrary .NET objects and establish customized information passing conventions. ### Sampling For improved performance in high throughput applications, distributed tracing on .NET supports -sampling only a subset of requests rather than logging all of them. For activites created with -the recommended newer +sampling only a subset of requests rather than recording all of them. For activites created with +the recommended API, logging libraries can control sampling with the callback. The logging library can elect not to create the Activity at all, to create it with minimal information necessary to propagate distributing tracing IDs, or to populate it with complete diagnostic information. These choices trade-off increasing performance overhead for increasing diagnostic utility. Activities that are started using the older pattern of invoking - and + and may -also support DiagnosticListener sampling by first calling +also support DiagnosticListener sampling by first calling . Even when capturing full diagnostic information the .NET -implementation is designed to be fast - coupled with an efficient logger an Activity can be -created, populated, and logged in about a microsecond on modern hardware. Sampling +implementation is designed to be fast - coupled with an efficient collector an Activity can be +created, populated, and transmitted in about a microsecond on modern hardware. Sampling can reduce the instrumentation cost to less than 100 nanoseconds for each Activity that isn't -logged. +recorded. ## Next steps See the [Distributed Tracing Overview](distributed-tracing.md) for example code to get started -using distributed tracing in .NET applications. \ No newline at end of file +using distributed tracing in .NET applications. diff --git a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md index 57a8c800c58d7..a18df5cc1a523 100644 --- a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md @@ -5,14 +5,13 @@ ms.topic: tutorial ms.date: 03/14/2021 --- -# Adding distrubuted tracing instrumentation +# Adding distributed tracing instrumentation -**This article applies to: ✔️** .NET Core 5.0 and later versions **or** any .NET application using the -[DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/5.0.1) version 5 or later +**This article applies to: ✔️** .NET Core 2.1 and later versions **and** .NET Framework 4.5 and later versions .NET applications can be instrumented using the API to produce distributed tracing telemetry. Some instrumentation is built-in to standard .NET libraries but you may want to add more to make -your code more easily diagnosable. In this tutorial you will add new custom distributed tracing instrumentation. See +your code more easily diagnosable. In this tutorial you will add new custom distributed tracing instrumentation. See [the collection tutorial](distributed-tracing-instrumentation-walkthroughs.md) to learn more about recording the telemetry produced by this instrumentation. @@ -22,7 +21,7 @@ produced by this instrumentation. ## An initial app -First you will create a sample app that records telemetry using OpenTelemetry, but doesn't yet have any instrumentation. +First you will create a sample app that collects telemetry using OpenTelemetry, but doesn't yet have any instrumentation. ```dotnetcli dotnet new console @@ -30,12 +29,13 @@ dotnet new console Applications that target .NET 5 and later already have the necessary distributed tracing APIs included. For apps targeting older .NET versions add the [System.Diagnostics.DiagnosticSource NuGet package](https://www.nuget.org/packages/System.Diagnostics.DiagnosticSource/) -version 5.0.1 or greater. +version 5 or greater. + ```dotnetcli -dotnet add package System.Diagnostics.DiagnosticSource --version 5.0.1 +dotnet add package System.Diagnostics.DiagnosticSource ``` -Add the [OpenTelemetry](https://www.nuget.org/packages/OpenTelemetry/) and +Add the [OpenTelemetry](https://www.nuget.org/packages/OpenTelemetry/) and [OpenTelemetry.Exporter.Console](https://www.nuget.org/packages/OpenTelemetry.Exporter.Console/) NuGet packages which will be used to collect the telemetry. @@ -45,6 +45,7 @@ dotnet add package OpenTelemetry.Exporter.Console ``` Replace the contents of the generated Program.cs with this example source: + ```C# using OpenTelemetry; using OpenTelemetry.Trace; @@ -58,10 +59,7 @@ namespace Sample.DistributedTracing static async Task Main(string[] args) { using var tracerProvider = Sdk.CreateTracerProviderBuilder() - .SetSampler(new AlwaysOnSampler()) - // Add more libraries .AddSource("Sample.DistributedTracing") - // Add more exporters .AddConsoleExporter() .Build(); @@ -89,7 +87,8 @@ namespace Sample.DistributedTracing } ``` -Running the app does not log anything yet +The app has no instrumentation yet so there is no trace information to display: + ```dotnetcli > dotnet run Example work done @@ -97,7 +96,7 @@ Example work done #### Best Practices -Only app developers need to reference an optional 3rd party library for exporting the +Only app developers need to reference an optional 3rd party library for collecting the distributed trace telemetry, such as OpenTelemetry in this example. .NET library authors can exclusively rely on APIs in System.Diagnostics.DiagnosticSource which is part of .NET runtime. This ensures that libraries will run in a wide range of .NET apps, regardless @@ -114,7 +113,7 @@ Applications and libraries add distributed tracing instrumentation using the First create an instance of ActivitySource. ActivitySource provides APIs to create and start Activity objects. Add the static ActivitySource variable above Main() and -`using System.Diagnostics;` to the using statements. +`using System.Diagnostics;` to the using statements. ```csharp using OpenTelemetry; @@ -144,7 +143,7 @@ enable and disable the Activity telemetry in the sources independently. - The source name passed to the constructor has to be unique to avoid the conflicts with any other sources. It is recommended to use a hierarchical name that contains the assembly name and optionally a component name if there are multiple sources within the same assembly. For example, `Microsoft.AspNetCore.Hosting`. If an assembly -is adding instrumentation for code in a 2nd independent assembly, the name should be based on the +is adding instrumentation for code in a 2nd independent assembly, the name should be based on the assembly that defines the ActivitySource, not the assembly whose code is being instrumented. - The version parameter is optional. It is recommended to provide the version in case you release multiple @@ -173,6 +172,7 @@ DoSomeWork() with the code shown here: ``` Running the app now shows the new Activity being logged: + ```dotnetcli > dotnet run dotnet run @@ -189,15 +189,15 @@ Example work done #### Notes -- creates and starts +- creates and starts the activity at the same time. The listed code pattern is using the `using` block which automatically disposes the created Activity object after executing the block. Disposing the Activity object will stop it so the code doesn't need to explicitly call . That simplifies the coding pattern. -- internally determines if +- internally determines if there are any listeners recording the Activity. If there are no registered listeners or there are listeners which -are not interested, `ActivitySource.StartActivity` will return `null` and avoid creating the Activity object. This +are not interested, StartActivity() will return `null` and avoid creating the Activity object. This is a performance optimization so that the code pattern can still be used in functions that are called very frequently. @@ -237,10 +237,11 @@ Example work done #### Best Practices -- As mentioned above, `activity` returned by -may be null. The null-coallescing operator ?. in C# is a very convenient short-hand to only invoke - if activity is not null. The behavior is identical to +- As mentioned above, `activity` returned by +may be null. The null-coallescing operator ?. in C# is a convenient short-hand to only invoke + if activity is not null. The behavior is identical to writing: + ```csharp if(activity != null) { @@ -252,9 +253,9 @@ if(activity != null) [conventions](https://github.com/open-telemetry/opentelemetry-specification/tree/main/specification/trace/semantic_conventions) for setting Tags on Activities that represent common types of application work. -- If you are instrumenting functions with high performance requirements, +- If you are instrumenting functions with high performance requirements, is a hint that indicates whether any -of the code logging Activities intends to read auxilliary information such as Tags. If no logger will read it then there +of the code listening to Activities intends to read auxilliary information such as Tags. If no listener will read it then there is no need for the instrumented code to spend CPU cycles populating it. For simplicity this sample doesn't apply that optimization. @@ -301,14 +302,14 @@ Example work done - Events are stored in an in-memory list until they can be transmitted which makes this mechanism only suitable for recording a modest number of events. For a large or unbounded volume of events using a logging API focused on this task -such as [ILogger](../../aspnet/core/fundamentals/logging) is a better choice. ILogger also ensures that the logging -information will be available regardless whether the app developer opts to use distributed tracing. ILogger supports -automatically capturing the active Activity IDs so messages logged via that API can still be correlated with the -distributed trace. +such as [ILogger](https://docs.microsoft.com/aspnet/core/fundamentals/logging/) is a better choice. ILogger also ensures +that the logging information will be available regardless whether the app developer opts to use distributed tracing. +ILogger supports automatically capturing the active Activity IDs so messages logged via that API can still be correlated +with the distributed trace. ## Optional: Adding Status -OpenTelemetry allows each Activity to report a +OpenTelemetry allows each Activity to report a [Status](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#set-status) that represents the pass/fail result of the work. .NET does not currently have a strongly typed API for this purpose but there is an established convention using Tags: @@ -342,7 +343,9 @@ Update DoSomeWork() to set status: Activities can be nested to describe portions of a larger unit of work. This can be particularly valuable around portions of code that might not execute quickly or to better localize failures that come from specific external -dependencies. +dependencies. Although this sample uses an Activity in every method, that is solely because extra code has been +minimized. In a larger and more realistic project using an Activity in every method would produce extremely +verbose traces so it is not recommended. Update StepOne and StepTwo to add more tracing around these separate steps: @@ -404,9 +407,44 @@ Example work done ``` Notice that both StepOne and StepTwo include a ParentId that refers to SomeWork. The console is -not a great visualization of nested trees of work, but many GUI viewers such as +not a great visualization of nested trees of work, but many GUI viewers such as [Zipkin](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/src/OpenTelemetry.Exporter.Zipkin/README.md) can show this as a Gantt chart: [![Zipkin Gantt chart](media/zipkin-nested-activities.jpg)](media/zipkin-nested-activities.jpg) +### Optional: ActivityKind + +Activities have an property which +describes the relationship between the Activity, its parent and its children. By default all new Activities are +set to which is appropriate for Activities that are an +internal operation within an application with no remote parent or children. Other kinds can be set using the +kind parameter on +. See + for other options. + +### Optional: Links + +When work occurs in batch processing systems a single Activity might represent work on behalf of many +different requests simultaneously, each of which has its own trace-id. Although Activity is restricted +to have a single parent, it can link to additional trace-ids using +. Each ActivityLink is +populated with an that +stores ID information about the Activity being linked to. ActivityContext can be retrieved from in-process +Activity objects using or +it can be parsed from serialized id information using +. + +```csharp +void DoBatchWork(ActivityContext[] requestContexts) +{ + // Assume each context in requestContexts encodes the trace-id that was sent with a request + using(Activity activity = s_source.StartActivity(name: "BigBatchOfWork", + kind: ActivityKind.Internal, + parentContext: null, + links: requestIds.Select(ctx => new ActivityLink(ctx)) + { + // do the batch of work here + } +} +``` diff --git a/docs/core/diagnostics/distributed-tracing.md b/docs/core/diagnostics/distributed-tracing.md index 9abe3a1cfe5b0..05b4ca716ccb8 100644 --- a/docs/core/diagnostics/distributed-tracing.md +++ b/docs/core/diagnostics/distributed-tracing.md @@ -5,7 +5,7 @@ ms.date: 03/15/2021 --- # .NET Distributed Tracing -Distributed tracing is a diagnostic technique that helps engineers localize failures and +Distributed tracing is a diagnostic technique that helps engineers localize failures and performance issues within applications, especially those that may be distributed across multiple machines or processes. This technique tracks requests through an application correlating together work done by different application components and separating it from @@ -17,22 +17,22 @@ logging messages produced by each step as it ran. ## Getting started for .NET app developers -Many .NET libraries are instrumented to produce distributed tracing information out of the box -but this information needs to be captured into a log before it will be useful. Typically app -developers will select a telemetry service that stores this logging information for them and +Key .NET libraries are instrumented to produce distributed tracing information automatically +but this information needs to be collected and stored so that it will be available for review later. +Typically app developers will select a telemetry service that stores this trace information for them and then use a corresponding library to transmit the distributed tracing telemetry to their chosen service. [OpenTelemetry](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/docs/trace/getting-started/README.md) -is a vendor neutral library that supports several services, -[Application Insights](https://docs.microsoft.com/en-us/azure/azure-monitor/app/distributed-tracing) +is a vendor neutral library that supports several services, +[Application Insights](https://docs.microsoft.com/azure/azure-monitor/app/distributed-tracing) is provided by Microsoft, and there are many high quality 3rd party APM vendors that offer integrated .NET solutions. - - [Understand distributed tracing concepts](distributed-tracing-concepts.md) - - Guides - - [Collecting Distributed Traces with Application Insights](distributed-tracing-collection-walkthroughs.md#collect-using-application-insights) - - [Collecting Distributed Traces with OpenTelemetry](distributed-tracing-collection-walkthroughs.md#collect-using-opentelemetry) - - [Collecting a custom distributed trace log](distributed-tracing-collection-walkthroughs.md#collect-using-a-custom-logging-implementation) - - [Adding custom distributed trace instrumentation](distributed-tracing-instrumentation-walkthroughs.md) +- [Understand distributed tracing concepts](distributed-tracing-concepts.md) +- Guides + - [Collect distributed traces with Application Insights](distributed-tracing-collection-walkthroughs.md#collect-traces-using-application-insights) + - [Collect distributed traces with OpenTelemetry](distributed-tracing-collection-walkthroughs.md#collect-traces-using-opentelemetry) + - [Collect distributed traces with custom logic](distributed-tracing-collection-walkthroughs.md#collect-traces-using-custom-logic) + - [Adding custom distributed trace instrumentation](distributed-tracing-instrumentation-walkthroughs.md) For 3rd party telemetry collection services follow the setup instructions provided by the vendor. @@ -41,10 +41,8 @@ For 3rd party telemetry collection services follow the setup instructions provid .NET libraries don't need to be concerned with how telemetry is ultimately collected, only with how it is produced. If you believe .NET app developers that use your library would appreciate seeing the work that it does detailed in a distributed trace then you should add -distributed tracing instrumentation to support it. - - - [Understand distributed tracing concepts](distributed-tracing-concepts.md) - - Guides - - [Adding custom distributed trace instrumentation](distributed-tracing-instrumentation-walkthroughs.md) - +distributed tracing instrumentation to support it. +- [Understand distributed tracing concepts](distributed-tracing-concepts.md) +- Guides + - [Adding custom distributed trace instrumentation](distributed-tracing-instrumentation-walkthroughs.md) From 1170982f0faa90e7ef81a7b610397b8010180814 Mon Sep 17 00:00:00 2001 From: Noah Falk Date: Thu, 18 Mar 2021 03:50:13 -0700 Subject: [PATCH 3/9] Adding OTel resource --- ...ributed-tracing-collection-walkthroughs.md | 33 ++++---- ...ed-tracing-instrumentation-walkthroughs.md | 72 ++++++++++-------- .../media/zipkin-nested-activities.jpg | Bin 108501 -> 92496 bytes 3 files changed, 58 insertions(+), 47 deletions(-) diff --git a/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md index 8210d4637e1e8..612ccf8e6e812 100644 --- a/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md @@ -112,6 +112,7 @@ Update Program.cs with additional OpenTelemetry using statments: ```C# using OpenTelemetry; +using OpenTelemetry.Resources; using OpenTelemetry.Trace; using System; using System.Diagnostics; @@ -124,6 +125,7 @@ Update Main() to create the OpenTelemetry TracerProvider: public static async Task Main() { using var tracerProvider = Sdk.CreateTracerProviderBuilder() + .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("MySample")) .AddSource("Sample.DistributedTracing") .AddConsoleExporter() .Build(); @@ -137,31 +139,34 @@ Now the app collects distributed trace information and displays it to the consol ```dotnetcli > dotnet run -Activity.Id: 00-35c0e68b0dac3c49be08a9d9cab32579-0b7477e11aa20d40-01 -Activity.ParentId: 00-35c0e68b0dac3c49be08a9d9cab32579-d95f666d24193f40-01 +Activity.Id: 00-7759221f2c5599489d455b84fa0f90f4-6081a9b8041cd840-01 +Activity.ParentId: 00-7759221f2c5599489d455b84fa0f90f4-9a52f72c08a9d447-01 Activity.DisplayName: StepOne Activity.Kind: Internal -Activity.StartTime: 2021-03-15T01:58:10.7661575Z -Activity.Duration: 00:00:00.5013965 +Activity.StartTime: 2021-03-18T10:46:46.8649754Z +Activity.Duration: 00:00:00.5069226 Resource associated with Activity: - service.name: unknown_service:temp + service.name: MySample + service.instance.id: 909a4624-3b2e-40e4-a86b-4a2c8003219e -Activity.Id: 00-35c0e68b0dac3c49be08a9d9cab32579-7ba0fc6d480c9841-01 -Activity.ParentId: 00-35c0e68b0dac3c49be08a9d9cab32579-d95f666d24193f40-01 +Activity.Id: 00-7759221f2c5599489d455b84fa0f90f4-d2b283db91cf774c-01 +Activity.ParentId: 00-7759221f2c5599489d455b84fa0f90f4-9a52f72c08a9d447-01 Activity.DisplayName: StepTwo Activity.Kind: Internal -Activity.StartTime: 2021-03-15T01:58:11.2894853Z -Activity.Duration: 00:00:01.0188689 +Activity.StartTime: 2021-03-18T10:46:47.3838737Z +Activity.Duration: 00:00:01.0142278 Resource associated with Activity: - service.name: unknown_service:temp + service.name: MySample + service.instance.id: 909a4624-3b2e-40e4-a86b-4a2c8003219e -Activity.Id: 00-35c0e68b0dac3c49be08a9d9cab32579-d95f666d24193f40-01 +Activity.Id: 00-7759221f2c5599489d455b84fa0f90f4-9a52f72c08a9d447-01 Activity.DisplayName: SomeWork Activity.Kind: Internal -Activity.StartTime: 2021-03-15T01:58:10.7647839Z -Activity.Duration: 00:00:01.5450288 +Activity.StartTime: 2021-03-18T10:46:46.8634510Z +Activity.Duration: 00:00:01.5402045 Resource associated with Activity: - service.name: unknown_service:temp + service.name: MySample + service.instance.id: 909a4624-3b2e-40e4-a86b-4a2c8003219e Example work done ``` diff --git a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md index a18df5cc1a523..b7611ce7fa0d4 100644 --- a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md @@ -48,6 +48,7 @@ Replace the contents of the generated Program.cs with this example source: ```C# using OpenTelemetry; +using OpenTelemetry.Resources; using OpenTelemetry.Trace; using System; using System.Threading.Tasks; @@ -59,6 +60,7 @@ namespace Sample.DistributedTracing static async Task Main(string[] args) { using var tracerProvider = Sdk.CreateTracerProviderBuilder() + .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("MySample")) .AddSource("Sample.DistributedTracing") .AddConsoleExporter() .Build(); @@ -117,6 +119,7 @@ start Activity objects. Add the static ActivitySource variable above Main() and ```csharp using OpenTelemetry; +using OpenTelemetry.Resources; using OpenTelemetry.Trace; using System; using System.Diagnostics; @@ -175,16 +178,14 @@ Running the app now shows the new Activity being logged: ```dotnetcli > dotnet run -dotnet run -Activity.Id: 00-9a41c8f2144cef45a99b9164db9da0b6-5cbc0f6836635245-01 +Activity.Id: 00-f443e487a4998c41a6fd6fe88bae644e-5b7253de08ed474f-01 Activity.DisplayName: SomeWork Activity.Kind: Internal -Activity.StartTime: 2021-03-15T08:39:24.7379085Z -Activity.Duration: 00:00:01.5198773 +Activity.StartTime: 2021-03-18T10:36:51.4720202Z +Activity.Duration: 00:00:01.5025842 Resource associated with Activity: - service.name: unknown_service:temp - -Example work done + service.name: MySample + service.instance.id: 067f4bb5-a5a8-4898-a288-dec569d6dbef ``` #### Notes @@ -221,16 +222,17 @@ may be useful for diagnostics. Update DoSomeWork() to include them: ```dotnetcli > dotnet run -Activity.Id: 00-fd2d1084980a7549bf18a464029e4301-a16b0c92310baf4f-01 +Activity.Id: 00-2b56072db8cb5a4496a4bfb69f46aa06-7bc4acda3b9cce4d-01 Activity.DisplayName: SomeWork Activity.Kind: Internal -Activity.StartTime: 2021-03-15T09:24:00.5920611Z -Activity.Duration: 00:00:01.5323726 +Activity.StartTime: 2021-03-18T10:37:31.4949570Z +Activity.Duration: 00:00:01.5417719 Activity.TagObjects: foo: banana bar: 8 Resource associated with Activity: - service.name: unknown_service:temp + service.name: MySample + service.instance.id: 25bbc1c3-2de5-48d9-9333-062377fea49c Example work done ``` @@ -281,19 +283,20 @@ some events to the Activity: ```dotnetcli > dotnet run -Activity.Id: 00-e10a3a418850ff45804fef674b6ce446-7c51cbc310b93943-01 +Activity.Id: 00-82cf6ea92661b84d9fd881731741d04e-33fff2835a03c041-01 Activity.DisplayName: SomeWork Activity.Kind: Internal -Activity.StartTime: 2021-03-15T09:48:44.2058595Z -Activity.Duration: 00:00:01.5274439 +Activity.StartTime: 2021-03-18T10:39:10.6902609Z +Activity.Duration: 00:00:01.5147582 Activity.TagObjects: foo: banana bar: 8 Activity.Events: - Part way there [3/15/2021 9:48:44 AM +00:00] - Done now [3/15/2021 9:48:45 AM +00:00] + Part way there [3/18/2021 10:39:11 AM +00:00] + Done now [3/18/2021 10:39:12 AM +00:00] Resource associated with Activity: - service.name: unknown_service:temp + service.name: MySample + service.instance.id: ea7f0fcb-3673-48e0-b6ce-e4af5a86ce4f Example work done ``` @@ -369,39 +372,42 @@ Update StepOne and StepTwo to add more tracing around these separate steps: ```dotnetcli > dotnet run -Activity.Id: 00-2bdfa9c9c73d2f41a1cdde848d686a04-2cdd7f434ce3774f-01 -Activity.ParentId: 00-2bdfa9c9c73d2f41a1cdde848d686a04-53dfb7fc5b5b3147-01 +Activity.Id: 00-9d5aa439e0df7e49b4abff8d2d5329a9-39cac574e8fda44b-01 +Activity.ParentId: 00-9d5aa439e0df7e49b4abff8d2d5329a9-f16529d0b7c49e44-01 Activity.DisplayName: StepOne Activity.Kind: Internal -Activity.StartTime: 2021-03-15T10:45:32.3626090Z -Activity.Duration: 00:00:00.5147581 +Activity.StartTime: 2021-03-18T10:40:51.4278822Z +Activity.Duration: 00:00:00.5051364 Resource associated with Activity: - service.name: unknown_service:temp + service.name: MySample + service.instance.id: e0a8c12c-249d-4bdd-8180-8931b9b6e8d0 -Activity.Id: 00-2bdfa9c9c73d2f41a1cdde848d686a04-cbb2cc0e664cd846-01 -Activity.ParentId: 00-2bdfa9c9c73d2f41a1cdde848d686a04-53dfb7fc5b5b3147-01 +Activity.Id: 00-9d5aa439e0df7e49b4abff8d2d5329a9-4ccccb6efdc59546-01 +Activity.ParentId: 00-9d5aa439e0df7e49b4abff8d2d5329a9-f16529d0b7c49e44-01 Activity.DisplayName: StepTwo Activity.Kind: Internal -Activity.StartTime: 2021-03-15T10:45:32.8894885Z -Activity.Duration: 00:00:01.0094402 +Activity.StartTime: 2021-03-18T10:40:51.9441095Z +Activity.Duration: 00:00:01.0052729 Resource associated with Activity: - service.name: unknown_service:temp + service.name: MySample + service.instance.id: e0a8c12c-249d-4bdd-8180-8931b9b6e8d0 -Activity.Id: 00-2bdfa9c9c73d2f41a1cdde848d686a04-53dfb7fc5b5b3147-01 +Activity.Id: 00-9d5aa439e0df7e49b4abff8d2d5329a9-f16529d0b7c49e44-01 Activity.DisplayName: SomeWork Activity.Kind: Internal -Activity.StartTime: 2021-03-15T10:45:32.3606482Z -Activity.Duration: 00:00:01.5404880 +Activity.StartTime: 2021-03-18T10:40:51.4256627Z +Activity.Duration: 00:00:01.5286408 Activity.TagObjects: foo: banana bar: 8 otel.status_code: ERROR otel.status_description: Use this text give more information about the error Activity.Events: - Part way there [3/15/2021 10:45:32 AM +00:00] - Done now [3/15/2021 10:45:33 AM +00:00] + Part way there [3/18/2021 10:40:51 AM +00:00] + Done now [3/18/2021 10:40:52 AM +00:00] Resource associated with Activity: - service.name: unknown_service:temp + service.name: MySample + service.instance.id: e0a8c12c-249d-4bdd-8180-8931b9b6e8d0 Example work done ``` diff --git a/docs/core/diagnostics/media/zipkin-nested-activities.jpg b/docs/core/diagnostics/media/zipkin-nested-activities.jpg index e641c514a38f7ab62310853f169e8897584a5a69..a51180242db44c0d4d029ab4a45d4e7ff507f27c 100644 GIT binary patch literal 92496 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

fhLmadGK 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

>f5Xq(aw*V1c@rWs5VJ*F5?!^T)Z|%Z^kk)4i(T zKz~1Gqh&27+q5t#uqaQkn^zwJ5|1B2@vnPFq$~7X3eM^ygsifb#Td*4j2JDITY21# zF*JF?$=yhC!mBFuE{v06zp-5C>@I5n3;rjT)2}22^75aq2 zn}i7Wz-v)g!~OixGVh;@WhoAd#py}cY3BJll;a8V73kE^*nPK^Ogz-7FNiZ3=*gpLd}%k4j3YgO6R5o+>TO=p932& z+ftQ9P;+OUCycJ9SdZP5MS^m(lyU%(h%P_M;nRP)wqifFuGGzIwLo88)EC<8;T3jM zrsTTGNkcQkij?O`^QGlx_G_hHuy>m{I*;Cmkhw~(5E!d@c36RVA8{k^lJ|+`?Srky zo_!G61)`a|JAe#NtcK|PkxX?<06y9#MFoQ?hGRK2JlR6abuy{Xr-;!7W{8aIDlN6Q zt__sF6p596(e*&L;rJ}l!=%+JYwSq$cu<1g`&Cj~ZraR%x=4XabH<&0UK&s1+#-4k zP}cLMQ$D~R`C%*_y84BFW)R4-k=|Wdt`>3n;!0`v37Cf?ZouDd)_xbEO}$wYIQn``|3mmce(po z=gUOKYr0Xvt9_F?3vFdY(oIJ{_jY#!lKLA9D(_n$~h)3fs5o_DtER**lZu0RYNo_=vO8 z<5f}xuBh{U7sGn*2ZkuYWOVr^nVQt~F|J1#MQTDO=eahsy!gwX3tM)#avoYY5V9Jq z59!=6xUh6RDbPmgl!$}0fttd7b;($Ru;6D?G(^LT_2%zqUhO6NeT{Q(>lQSo|~eoR@ity4gDZl8K^4?AX_Nm*rO% z2TN{YvxerqP&P{@#9jsfZw3aC6&ajNP$^jT2m*~@l@%XCQ)u!elLKJugy@bSEMmXk zs19>n|Ja3~3n&X4qt4`Zi73H+ZMKHGik}`FXN=01kL;qqDfIT|=z`dQdx+lWkySs$ z7i;ccgCvLhoME<~)GT_=qYb4np2vh;*A)+N)c6=3${V66O(vAHc|^{Y3Ro@!2R?w% zqG+C$7uq(P>dx9pFb6fD%xnxOAo_74K~bi_2f~UP6-2VO1GrW==JfPh>FYci0yvEP zI8U_a&5>}0{YTZa;^V^=T1~%J$jh3_wb#y>?aL?01zbsY-PT3OtC+}fCdV2?n)j+G z?w#S+lI*>UG$7nw&gI{4IHCN}VDHaYSq@2EWnpDuk-he{upfVn$WZU!WSpb=Wxkz} z$`P{gsv~qX%;J7CW$=+iA9hed3I)N*H(}J?k;Ml-=$y1V*mmm6)r9+cZ9>%bT2X(7YIGUU(3;ZaWe}3?sWb6c8m4K@`Ua$9*9xS^=d9rpBvpiuA_}Anvyj= zszO;xkIed}pS)NwP4<&-DZD9gIN@c#_&edN&Yt?m8{!;NdmWS!OPDxKw~FpIr9ByQ zB|P4)3m`ndkDzYakDrVEgNFr7L?0B1fX-5>19KGg!VXbZ6q+seT8MYztc<-kbgKHGQy=at3X)Ox@&Ce&8#aDUcJO>KE*GvcK;<0T_8 z)zsoZL76XJ=|#YTQtUJ22gaBrdEcy2shoGGQ>VAJ=; zp=3-wK5o2j+#p%EE38=kD1Ghip>o?MX(T-|v-~$P)-;MFJru;SR_7&|e)hX4TyJ;D zPAXDmx#n*W^00FPW2Aj&yp$Pt%;9ss{P)Y~@w2#rI)#D#)$;X*ERuJ1{5vX*fxp0q z=|XZ8BKUkRQTLN;>c{FUImzRxpv9T2yEA8Z`S_gxv927V`irDzJ3T6G#SY{QPaf#1 zzHljRosTwCglcME&pjDje+2q8Pi(fPFG`{m)$-x`>9|jk4+&&r7*VIraxayQB3W0- zM%A_>r;SdA9UyDgdfg>H=nd#vH!;xh2p01^(m%ns!G3W*FJhdVOCBQ!Rb7Sbu)C?K zv7m@@wc$vA6Vh(2t@Klsgz0Trdqo6{s_up9~+ zf+IKOR4xAgO~j~KCzd&f7%kOr@sv>8fUD7FyMfabM>;{))u?c}z4 z!fq|mFS!Y#4;C}3^NwwcYn3VwK7c;_<|%Q6UiYGDkL-p$%VdU0%%iNF=eOmd_en%= z00(tQR=MYtC3JMi@G@f$}W>c zMe789*?FhijM$~;v(_wl#UbsU{KOuXrP(P0RYG#!Asf?&EVxh2LQ-JWaGse^U-_~@ zKvGChmGNigN1>?6B}K2ce!9Q4#O?io;|9;s-Y&ZIl;_Vj-eO68j~2H-FLWqElZ&yV z*x@zXO@$DtjQ>}#-G4h!9Z=Xmg6ekIyz`r0*X1x&Rf;jVB#rIkCoIpiF=%{uLRfMb zPf-AO`WYhS>8xqv=(JOyja@Jkx06LJzeof3IxZHg;iA2|?>KRUwqK|Jhf1aI#O zpZ7?Dn&JDS19odhOQ(CyL9>0 z)wM*0@#p!0QSylWIGGP#T_WuyD)h{eR}@dP z=(;t(uoj|u(I!yvwan!NA0P8bNqQ;iX-hqm+54(+We#-3j9*(Ov(d%k0zlur^-;FS z!{n7Xc4{cHJ*i`NdF-+D_iD{no|6I*9ft!XcnYID^U()5)bs`Dyv-v+xRGX*uThPb zR45=q{Q_%<^L=rypcF5pUH|e(QIuZb%NPErqrvALD0xS1I3P>-zw+3LHdJ%-FK{}0 z>LNO@r?PlzEiaSYdn{~YEIg9Av$7bkGSGj2{5sxY5bd6^!8%5u$^-_CLR+c92Re#O zRTzl#T`RLn8PohH1F>90l`3DyNZwDBawlRytJ=K|07$+Ma*rNjgpmhAoZS5M1?21XJxvbx2;5>`U+E95Pe$KnWzQV zK~3Yd(c&^7kWq$Im0|3TDFR>R3F@J?YO}MOnk~hV$!FzNp7a`hEch6lb(Syg1fS`7 zpBv$ySX7oQAU(nlD;-HaT?lP%o5oUiVMi>k94}3fzHm92qDm^qJK)#6@zbA|l$e~O zPWMuGy{NNy3gb&u3{(meOHS{38q$5(cd&0`8d&#~DS5>ju3$B1B0oOfs31hz68^OB z){{~{ucsBxO!6wO9XS_@+*tExGD7rab%V}59K}aS-Lg^OR^E|?y=j~^ULc3=p&YF> z8yM6whMSFqJ)^;7Q)8BwY09fbIJco*Us^OFUmltya?#eLm>+@diM53zT`ZK{J-2zx;k*0%^j=R^b6oPA;=i*%YjmMTOVL7rh`JYpg>V^_O2Sf7l=bRfN% zrHb$AB^0(f(-C>&ni?Tr+*)*C!U*Hmq}j{ZD;2&Mn4{iyZ;loxPKFje_k6QaX{Fk= zW5;!?oDK{NfFO4JD0y4G)xGUBOfwIam#gx25=v1M*7zEICgA<<_GIkw6GMrhCaeXS z3@2B?xS+{?a56ps2NRqQz+d{ka3cex$a0vxJq`hvrr~8xq?p$a8U7KZm##CLi=8;j z$w@VTxDAQTNAuZP2jR1R4a~hCb4NP;^bVTeE`6@&RCQ}#LD<6Gr!l*JzO$Y1@Egk= z0xSJErK0z-i|_uNB6Td>&bvQ2XO6zHtsvA^{Apq__s6Y`Uk{;guv>>P4gyDE$M>d7 zTEsNwcKmk&nO{#|8Y3qFMA97I_L3Iao?6A(HKHckS~X!KzRYmS*mcUSnPSD1*;4(~ zN2PY1{quWU9K=6GVd_;eSZuUac zq-ACy&j{Vh*ulIvAMeC3_};%+;z7t@)5+gRLk# zN;>bDYFzf-o}7+AL(UHOdXIoo@)q8_kGQQ#XZCTjAKY;6in7%vb88CJYVBm!R|GcH zFuC8CR>X8nNH5}wgoEG292B$EJ8_rEJm-Aqpm6-!#0?>{qwmWN8=G8#q9DSFld_J;|D{bolJ=3l{I!e$l}n-@Xa!bfV4X9XML zf_n^M5Ekv*3crC28gfDx%*4Arj4W1Td%d#wvWn6giJ?2ej z?kF9A7pQF2Lja-Tg1O>}Vzh6V4F1uvf$ombYZw-F8(_W2Tmj|ZUo?HGmzKPQD}{b@ z#Gv0SD6_9-BWSZMbcqJCH8A#HM!Y%^WvSgF+_F|IZfM#} z^{DnzaysjI7o*oomRN0tt0+(WvVGg48C+g<|KQ>{I=Y|Uk4bAiiJR zvdsvgtpQ~BI@Q+-?P;hisA$llAE7)2oVUBSp_hgqoxRIivo*@Pn=t$mv$Y4ajc!f# zR>&D0Z?8P=5w%<=G}r8kUdz&pj|oW8GhR|nx$)rzw_JGh?Z|zbG9maATGpgG?+sE6 zD9sedd^OAvk3yi#n+AYb??_!Q7{?KVm^&4R5k%Ce21YTo9?7pIM2&IS@4^YT_J<*H zX5+J3W9f$?0-07W(O0ZFWTJ#Q-^;LeQ9w|Jn>0cS5u+Y|E!wStCJ$WF!YT@6KY{BmK_^M22>jBE$J;-Jf$Rp zjUh^xM~EP@wa2(Z$$br@Uwj-=ro`%m3*lV$b}o))=H?QQ>uB|IxwpAh8*XGjnkZEa zg^_i+exhFoecHWi-7Sw%li!}9lY0c^ahhh=dV zmM^d??WVNjG)1emyWQn+y0|!9pQqQ`ute8VNVy-;Y|LCA#42Dq!M)qIV%nJ}JAI7M zV{kxy!s&C_E=e&6U4-815lK5VY4Pr&=RHfze2=!_?jxC(=2VB%0cJXq&eJ>6TSE}= zfpyVOpfjdaK^n$o{>(-4!b{Y>99xQI{nJm58nt%TQ0%>%hoU~!;qO#5g>>uYn7A<= z!3hQHQu+1$+bCbYN;4?RGFblUG6u}gwk9&3E=zhWv^#Q)6gspgepE7Cq1@d)+XGd{ znPP7&(0fQFMoRo4pV>gR$KKW`#;EgqS;ea~Aq;4D&IqQf;D}RkyEwfFC%_=I4G3% z1(16@;{AbdUYq65{_Y8STMIKU=g~BwK4mhA88@FbfU5a>rDFf4z7_wd$Au_}Uv3-x z#`4_V2eA9*JC7_fRLy$}dqe-)#S#9uE{^{ptR{bt>EzFRwneWNyQBalCBTPm?o5|~ zxS@|_&^H##4rof^4M_Uqpe*9FIi}kg?LbiX>HEpC;kq>~q^*nYn{0Q|p{}bmAu`&5 z=K{^fSp5q3yh7J5_(yuti}Q zCgSs$#j1I43&sEiBVXep9y{Hgo9*ax(`J9mtF~=fjNn^trBT`NZZCh!O7myN4U%)> zxp@6DrcOOYM|e1Y=P9d<)=uJO-5fO}xBIGP(0n)_H5|akVi<|glrzYzSM3KuVxeRv z3{V>YmunK3KYr>krix|SWlyHWS`82YE0S>HbVH%Tx3shzzJ4mvrV^{^a;Ne;xh_ zREzouj{)FQ81p=%B#E$>FtS7{RAlUSgQ#M8AjxGO9+`GG7Y-q4U-@u>aiP-@9}E_GM<=;N_Tg<|%+h z!X03m5vUx{hS=If2>l#L))ObbkLjtLm^J zIIzSI0Fsg3Cy+dnz8y|~N^{o6i2c2(`rQjL)2wI>i_llt|E~N0x9gr+4>lz014gpS zpjl6Se?9;G>q8fxoF#mT5pxF3(-;)a+zW*GE#7)GSia_akG*IiBdb{O%DRrX-GPst@nx$eS# z@AM*dn9RiCXthh3Ztu2P+xWNml#eD$@-AR-r;{`EFI{#*Cl~eR#3Mshr83uqDsr>R z=J2ZP>PlrzPqYSBTDkJF_$1Q)>10^L5Lth5LkIeRq)A!=PrLJWg}1f`P?qk@%Y$SA zW@B3rVWkgk+4&!$7XOjD{G-o#{~*Q0f`d}bX38+#D715dy3d!I`L^rU-n)R7+L~-n zbg0WNy&W0t%yX7@dmYO>EC#Yxh8M0W} z1Q#=@@=ltzBdenS5=d53$}d;#lVciq%seYp4KvfTAXN`Ckcr>b)NZ@)YU<*5H8l>l z>;7b>NartV>LpN9{>?C^Iuc0q4CebWn$7|=;e(~0y6C@=2?Qn(%3l#cOF1LHYpK(> zu}m&Gh&m4=Phf$TdejW3ivl)N3K1xj$khfI5$^mKDq86$kP4E%3r-LI)8k+M>+moN z>rt)=pe7&c0IdlJda4Bu^wiE6h^p~jPZdHnaS+f`JaRx!c>;aZfC4H7-YWvxGTP`h z%mZ&v(Yqlshz=}C0xfkS?H4U|6lf{77&zT6^0zMow298RX`Fo29prw8@ zQ}ExsO%c#1u-OQBA!d?!6F^gq4lwNrR9<|oYRze&@6)qdQooxdDuW}9fllY6S!qkw@0-Z(0{if`PL)sKQNysAw}c8XAK$eU zx0VvM8E7deqFn5)hq|R7A0BIDVJu536uHsNtK_(a($+e>T|-*L1ZXL?a~&@I-q!$W zpA7MEu-ebrZs{!6W6$dDUPdaOkk)OKg=KwyJKbsU{8ik{y!)(m>~P4Mkali#*<5k) zT0f<%DNJI{rIoEDi}$jj{Xg5AVgoZZG{)RX`mT|B|DuuFEfv3i`rXH(18*ze_5b=< z27jul>c4}r@?X0@tKtv-QwIGv(1_nRf0Ii3`=7}OSDY5+9h3|4?~ahc(Z$!`%gbDh zHL0zqLx9wL^tyqG0ivn04n}?kd=fy(zy9S7=Pp?|liM4%u@S_i@j}%IAc)~0+(^3h zKv^mq#0_=lpvegsZ4RiAotlw!dJQNo3}N}41hmkIB#`6S7tms!&VS3nWQ6rk3x6Ht z4H@gcWN**1jQ-~~W!B(g?gS2_)FKt=TO|$<; zeD9~&A0m%en4p{LQ@3v{%nHDd_F4bbpSI&f;E|4I`ZvxYnjY_fA-}O)z1hWU7F4y%HGbobthe#5H&$6CZ=W17crNUDz{T5 zQNuTHk|Q*QH03azkr`j0YLDV7Xhi(Bqbqhk3`3i{&G8yZgu9maZ6KHGi(Ovye-LsJ z`V_jq@+D1CpFfy4|Kf#Hch?QIT_?7Flui~Fbbt1ZMZVy{$(7@MsNCYxZd0=*i|c6d zXL=Sc#ytxCcJg;~Ci>kXpI7wI4tLS~LN?MGVtPqz@LOD59>=H6igBZDqK`Thl;`<9 z4px+vRW2(Osp7qZlY{qLspV&QUg7kQTas;y@Iu!3+6+5jBUS0gim7Odm|^GP&^m!) zRe!zC@y{xz%H2`6X)*mUo46fk$QLLl@_4(-gg->y#XF4TBNT2Zt{BUDQ9aCH{tpYu?ecT~SU{xB#t-%o@;aVA6hBqCUdY&*RJo@lXhdhNCr7ej_46@M*j*n%;OaMp5onTYcQGFA zp*|!c{O+=v?=yxZ+^UV9m(y})&6M0wdjftZ95I?!gJnZu_oy&pm~v%3E9|oIj0?7O zxXT5LlCX`iNFfpKE6P?d7n3*BD$=ra1=6O;cry<5BvbLWP~^NgbA`|bEqBhJlpV#f zd%Wfn^zlV=qu`vY(^?|*3l-QZyjcuR^eH^Zl~d((Rcg`)JeNy*MJ@LncYh{NX5%xz z=(ZVH!Q_KVeoPzS+omfGNAB=&HbjTQjGy0YXWS5}&~7x=_9vbA2w}2dDP&8;j218cCgL-mS>PAdFxiXq`YA3BO#4 zSMK(^3NmP) zG6s#Dp<SI1UOEqbO8*t;9L#@z^Un)*p5ozCj|{J-XOc>gB)^vmh^eLm&C`RR~- zNzM7*iuflDHPM2xNPenKRq5G+oJ=IDG)2g@;8WF0EAER;sUM9GI!Eztny8ZrYagj+ zC^dCrXUNDpL?BbKCrtl%=L&+y)L!76O8w+g($jd`kB#-)wb?E9X!7+<|Jn4{pS|v% z?bv}`_={urL#Xk8q+@pi8$x3B5vGu8oTi43lVbyYZl`FU96TIRmRgnGFWw|*d`hIL zNo4yCVZkktIT$3ffyqY3Rl~mM>35fNWm08_7wbWBpKhD3 zyjX0kl)3%& zEiC#?^;Dij4KyCuA|9m?K$^Je??tG=g~JNd{0R1up~xL~s6iu8C}XOw7bAo zwN&|JM3MZbYW}hiHAYvMMxm6%wGdDABZV&u-&pKORB@2ZM}EPM!fUwvgb)E3Q48vP zj)F~bCEmM5XvzF`go;TZ;@I3LO8uJw^FyC<`L7rHO9lg9>@EnWim5<-%eA7%x+-OC zNo-=B8fQix`v^FUaBVjm8ng{hlWTL5!yDQkPJ8WnJNn@e@`09B_1pGxoS;^u`C({a zDGQArvNSPqceiiXU%p~!{M_U!fRPR@tItD&v>bI=S;U9^q_z|mzb_y+gktzjJ#0VrEXfQE+LcBJ)E4*lG_}2pI=T_wX&=P4vb~&rO%FV+ zr4Jh;(8oLjMPjdn5j{|5-8li#b+a>SagT=1JJc(qGE$W?Zm@6bFSB20ZIATLu~9iJ zy4KUw>^`$rys*BMXAm0dHSMcd+3d?ri=r)nQ-0^#pJ;*cM~UJ80+|n^^8lIuV|?ek zMf5*S=8JdcTuSwzNVAWp+ep5$IX*^)M_U3b+Kw>!9^gzNhF8`I@H==0&oJLt(Z_TB z9vlVq2I!3i_##NcTSijP#WTGlX#kATo2>{+5n&p~C|ZKr5s7HD=hoKzYl8@Gi=>)^ z;VDW%;u0o-D-9RQv4V7%LWt{O3NkSMl4(F*snDzKd!-GBEE)Zv+5Fgv4=tiMd+LBO z^|xCmGxxp)eA{D82B^}RJ=e6h|3a&5sHfHIAs23Kxx0emhDQa@5Bu#t#V5~V4a_fP z(((XAA}}jpN*e=Aibxa z4)yMXzbg7{z}9Mv&5sQ`7mQA0WL5WAT`cLw&F4O;Xe^DQ?B|wF^f=ACrSiU>HA~qJ zK}B-gT=HlrVh?d>s4bZ_)Urdxbk9tzTCP=r-?fyDuK}1l3fY+~+Jcu0rJ8-XXzuow ziqx@`shr_>4&f9CHZfSm#URXq*JLBVe< zudZ5VdlWFwltK(A>_*+yssDR%ATGaY57hLlsHo$iEjA{&!KO{Cj9t zeqk54{7t~ui297F-46uv+B48OL4}p&8W~Fua^>0_V_S|X-8D&<{Kj(dZ|Vr-lrGcM zea?I)*m4S?BDYyizZUP*uu8WdIz&yB$g>f*RQQ~NsxRvNDW%0%>S{@GxP#-32;u;- zp!RFS?r$sw=}C{LSy?+bHyrZwD+Y7FXx^D5(fcAvhW>9q3=QXy;<|81Mq+5nEYF> z`9mOu@_toK9gE6kp%J$;yEQU~6y9DcJKr{D4ivvRNHYPemA)Gb&L+qv?F7kmcLSgV zjzA|+Z(3MvzBiUb18YDLU;s`+Oa)-fR29~nG>6JoY_0Wj|DxR8qxkkcf92KiWOQw0 zzMJI1V?|rl#Kv2HK8f6%Wg-@=3d|r2c#H3(D=YBj%nI+srCL)=8v!IP>2;d?*L14-S`f&mZ zrBb#-bTMPlR0z;Afcgj^&c5^IJhCS-y^sLD05&Y$!uImdK*arKeu0Jd>pQz9YX9;4 z_5|>5!T!-CnDH9??=$_+ohLR$oL$~DaXvDpm$Oo^V4`(tMQLT=5`33T!;kv%fkyv- z1nGv0EA5eit`;09ODTOW!$1$Q&Zq^I;&-O0fXDhWOwxVuXe@E(R>7P;t?jn% zmIu0V3xHXNflqEovM_Hxuw*%?X0>mN|NaI^_qQy#EwO7clzd>i9%ml+Afu3!tJKqz z_3hIFBrAW$UKbjTn%xjv&v>Sibty69v zHnO^A>nlZ>L?Wyf9xQ};{92fTiB0kFTUx$EUJS;~&p*?p$alYa-p2RNlsJC=n!uZ(64c~u?RnTod zxqEx(-99(V3yuduCtgXD#wsc=-*=x+0eUFtSi8mAIMV02Nz)QO_9Ja~$cFo<F z`H)o964bCLFw{52>xsg= z8$u?&L|PO?yKg+S{`rD#6{4a7=%0r-$}E}fm>&P4dURF>byFk{-C4UN34P#RcrvY@J0w0SmIef?{>5 zLw&PI4lS9fqqb%X*f-RNi}Ho|(3%c=F2|T-7s;ga5+Qd=PBDWg%e~E8&R1GA^so6s z!~M%vW(_YPWbcMNQ7bB`{B+yeB6*xtC;l05X;8duP0YG`1G9au-zak6GU(2UIu}>B zYd|=~)z&6VSHARg$Il=0m866ft6^k=1b72!r-t-s4r~Nh+dr*=nevfO%06jke{yAe z*Y(Ex@r#f4oDp*5=ryc~F-R9_6nOEh+%txVQTL^7qKZ>5C@8dnoxA-Ti));39LksL z%@j_q3!EEycmtG=d`$O!Gh`np=N6}sru1}93}o=ml@^*NzgEM$?=2@II38Om=EWUV zi&oESQHE2cEdx?Nf;}otff>L1tXQbeUMnhZak83IwRPFZuWmji3SJca;(YJtKy#1O zr56cRMpgxp6^2)ODC3}pAzqJSype@8NAwvkLKgDAYL#X3F79|_S~@O*DTo;m73*Xk zp&Q260?9L|-P^!E9LY*mCBnFN6basXXI`S!eBiyQMmvY|^`>>aQni>z&k=FXeJjvz zsOq$a=9mSl%Is1ApiC0A-<%8!d<(l6LTnOT*{R(8QEqj|;>BKRA(iriJ@QT`D99Cve!3c4-~4 zm#ph?kHrY}-+l`s#5=jZd_7whAtt}H5SjkD|Q6q9ldqN5XHMmv@ z8%pnWk@|#TC?SWW->DUrRC%GCQCxl*2RcFp1tsrE9%}RmiDSAnp)$eBOXZ8= z-Qk4!2~Ll;eNURqTd#E|2aj$sJ9P+$0yr{OK5}%=`)RcxADi1FG{XF~71-VZb0X)l zx?|J9#|Ha}tnbx!jX30*a@HP6$=X_YcQ)`uW}ZueP0H0pNU9#)sVgs9XevKRJ~RwyKMFbB~y%pB_HQxk6AeDyPrK) zE5C5ZBjn}H!Tn7&l8YugFn7(U-&kljh?rL9fe?A44@~tgAGk=*9(&8f`F>5BlIKy) zsl|^@ye|o~YhAZ!w&R^kj1_ZcRllHc^m42TI)R9Zu}kxfE9iRBdX#DbglbA}PN%-7 zy*Df0Qd%|C-!prjnmm@nQ!k_wigwY2k6s`8Kka>YSX1e`FSfBDA|N7NsUl4jL~3j_ zBOo9kH6S9*5Rn#Y6a_>;1Ox;Wl&+KrlF$>8CN&7s5(tFe0tqDq65?Gm`?=?i`+u~P!69CmjuWbw3RDLU})ffj?%3EHgYIS8us$RDyS9*jy+XO|Jc^#BFMX1s3 zsxfHeG0PTMAicOzr^qX--6>VRS(x{7dAZWpuw^MRb|9&DV7YV&IL)x4Kuh!bwK=w5 z6fwQWa0eHv(G}yk2!DXB!&Gw#*i-pb)&pKN99>T`Rq?SvR$q3U{g;n&w!HC#%c>3_!H9@sZ#gsBWGH zku#|7b;DcB4b_&>E@(8Xu@9wTqL}F+GK8PocW&d9WE%1OZP#NGG4@(BAN`^sZqggg zXDW(wMJ@V}K7jf>gaSp7kzb{QtTH-v0wP-!@u8fL?4?S(7i&c)Kq4L$7H8di-B^MV zUvqmGPdMvUCzX^Oj}sg*chYmq(Ln2xgpi!TnO1MW6n1hMuLEDDY{Y6Bl8}4orlS1r z)wFb|tDM+}jMim&bif7|SRzqRF#JkPl7l8r-sAh-aO{)b7kgBVVA(3xV6!5h*#B7(cx|vt53| zK)q$R(S~7!$OUI-`)E=M**_Z)RsxQ$IQCgUh*?f~LBnPN%Y7yJU3LTSNS2*7DZ@A8 zvK;Kwv!nPM%Y*#J)$-EZ>?G+wMrA(E<}jT7*nG$TC0K7-WF7K4W$}O4HMU z5*RCS96?rn3tw8jNx5E5q2)Rk+_dA|qbC}@He0Ok+)G}sED@KvwOpxr#^x$cXoD;D z^jLm(CM9VOvBnK#>OTP)WdRUL7Dz$NN&#*E;HMND# zAm#>RYomuDKFtX@&VvovX^8DNa>16lEfkErv)r%egnw zVTHy^2?>leW7ZB57C1{CL3CRXk8d0o;+Qn5;U^d%8tnBH!f}CnK44_JB=|d< zYTK-4T@5Cf{2s#boz0;pbAM?6#CS%2G5pjDZIt{L<`cKOC5s+sWfOkmCJL%6_(+&( za@?*!{?_Jr`05LdZ6JyDt5MZsN(Mr=d-RR zK<rH4r?5!63Rblyp+XPHNBd*4rW) zsh+$`)|V2&5U^>7sY?kr35bBGI|j8B-mf%EoZ}#zVhhvC}A;h)KWQk^y4wI2%rn?`M*r16-Dv!kj$Dyh{7#H%(G;*K^IT_{V5z^g%XZuBmj zOsBMEtXmK89kR0(-}4)-{rJw{MvpPJu2~)0SCqxQqE(x6SYP3B z@@)I*be8oseh6F^@aF#2_{Y(&u3@+K-$aaELd1HQGYs0YM{4FqMq!B_ot{pYw3}bJ zwzw90tc+q>OK|2+ZOqGz69o6nQdT-8xz_^yvx#7cHZQi~D-?Q5s(+fl)keeQAlF_c zt}+#KJLaw!q0DH}QcEBvqjPc;0(U~eALcXU_ByJ0` z$p6j_qh0nG-v2d}f0lR(Lq(^O2Ft~&W2|$BDibcsZ&o=c^a0B1cWx%&RoiuoWlwzw zh5<#I`qOJj{?LxmeZic*{$t3)^P_u<#y@_jrush;8(6b5)IkpAGIU?9zTJFab-3l; zvp9j^#q_VN)E`>}RE~eW{@+TxA$=_$O@9`JAuH67L!J*$PEKz4Ghv9Pih08D%4p2#9FGqnCfP zC;RLe2IdR05Y|X=`%>WC=5C3J_I8@*K-T~>o+Ki%9kI?c&Y{OI?_!Ch1o}BuR!p^VA5)9H4_d_fOi+r;#&Nw|b}U z4)xBAWE4U`^bOX&D86Uf!fqJB%w`rpV9h|96xqe#G zk`Vur3jS8*jjXrMifvCy=h$7e(kgKLf>1>~6SyK|#oXN}Tn z#D!0oL+X7kkJc*Jcz9V!Uhiy1YoJU$PcMFFi?a=Y!`3r{re<2PZp(DZ!R_o&t%VE~ZE;G{tF&5y zn-x{xf_aV>mdu(Cwqn~$zuA)v>vAT| zILTr)pKj=VEPTFDDq&grqh^cYOxRya42n>U--Q|1YKgZT0O@#Cs;Kfx>Do z(Yu@lh|QGD<>ed{O{Lo)J=|TFygNQ zhj>Ujp^XLOUKcpc?h-&GU!LlQ~%uj-5hbt|~zui(%|NSJtB+4UKGXz*b!z zgyKah#?Z60V(L=tc;y(~8^oA+!HMvZb%t$miL| z<|KOY$MOEN^QhlVlJgF_jui;7gN>I363v}#$a*dtiWyO!a9s29ka(m08S3GFCg((m zMt$0JHpzR8>^{$E7{xCHIPhnvhVSVRlYNmDV`!JLD zW%Gxu0<9F=lpqqWCP0|{n-}dPF24@PW(QCncE)z443!Q(!4v8JNykH~lqSw^37q^_ z0W{eB3DB_g3(alj*S6*VC@|sg{r-V}2+;6g4M1aTek8#f5qwr2nU3nsnZEDg`HceQ zI~iu+cTlv;^3~^tfb%jfIUVLT)ykR4 z-8%K<^xX49`_}p2&6W3llvM8P1~8fte=Q{YFMZCNCHFIQ2q^g4y0E;=153won}>k9 z_j)s8hS%~9=Q&_QaYD461Gyj>QW=5(BEb$76btwN&pJr|6u#oFPuO3)e3pN<^7&a2 z@MkNZG%DghgJ%9~zU$uz0Qq}?Br@@&07gRiH%IS=>-m@>#x zFv;G|nC5=s1&7Ga)vkl)de?zb&4n+6Bb)hX_u=41{4J&?RW#OzKZ~MWlQm@1o|o>l z8ypmJN}&`cW*akXt+P}3LCpRmd!4&Thf+50x1`(SlJe@HnDEc9^38^d2^GbY69{nA zXwO!$F}47in6>=@bAqYx4I@5huU$v?k|#bKgQ_+MnzJ%<<}J|4&>*jXyJ)k|Wh1us zXAC^k?RUq{C~!IIIzH3*oLPZw%H$aunLP)gJQ;yM2Qs(@l;S*O5uDG8QimN}E)pS4 zC+gSKcr+#O#nK{^mCm#65crUmTb`5MSDsRsDT$>hl(g&ix<2l;#Tlxh$n7}9tGkOR zJ5!h88Ot!qiw}aC+5?wAq=D;* zHjT*Y<@V@<)4FYqAuTio`sn-6uh@^G;lWPDc>K`(R?%6>MT>6D!>Nvy$$M`{4G~W_ zixF)!UW}C2IC*)wo0vs^%^65bFg0%1E%yst)GLnzNkamH$2TDpgv;Mtv!1g5y_4|g z@2UMuBA7-u_5R%vOr<2y=An7f^=8f)c^}^PS=9t&?M!o1NjoN+xSi?Tn)#k6*u{6;=Yw`-yZK4N8Tiv{~=0$`K57XmrRDtaj z=vNf(LK{=$X+chtE$EYe5?6SRUFt9{N8GhVbe{s!N{mNF~ z-`Lz(KcD#oQU+;Qews=6&PE`LGQ6nT4`HNO9n6R~57-eV_wk~@i}-6Wp^y3tazV}q zFODYJ-hr#qMCmSLT3|9-fR~x}u zr;*ZgTgJ4emhGL$?`+GJAo`RjflqYp02YuL0E%W4FA%R;{?l0GIZXA^<)=Zkind|& z+SEpf^5AORvCzg*4yM=ff(+I*8!i{ zK>$1d#vE|*-Prq`O(>gjYl8LA@;lqcuqgBX6GrLOvuNXbtB_WS8u?vGkn|F4bPa<5 z-JJjBdiH0(;fG$oeil$u_|3QfNjQNV9k;ay0thMGLr~j5Xa&$LF9MKGs0Vazei3B& z;}!p2eQ}lv+}lr#fLN6{=J@+HkAVcc1+=zvZWDU&PD|SLrD^T-n=DNE_5T4F>HiKr zt{*pH9NieeZbxo=J=$!y+rzed?1qIZ#XZ@?mSD)+RQGwmShDn?1R4H=IrlCK??a|8 z`@jU~Pi${?WT+)-AO`kx%K501fNb~C7BTsz+UH?BwQ;9GyZa&GYng(0AbLCN z=mCmd^AHSCyk@B7)PrJwB>X9n&){?dJWJ=`A)PNiE2UEploCW%?fsar&70Coqiul9 z7MR7Em;a4@oGh~zT}XX5H~qOO2b>;%Kf|ypE@~I%UhX~b#AdYuC;G!T?ZL_I#d93q z678Px>|fezV=`{Nv7Ib6et9T2V9s7Bc?2k!`8I$vae%G7zO0Y?brc%$S-}eJ*tzU;~ziku!P*-5xr-2A9_Hb;#|H1v!Ueyk-P9$@9SSC(xsT6(K>Qc3&YH^IMTmg4wC_5DpvM zc%5+r-a3x&NEpqdy%pNCYhRh^l3jzX0y$<7*7bT^(D;}=ec8O93?iM6b)xD%mn+^~ zA>%1$e-hJkP;F%hPy)Yr;Kqvf-P{sv|6Hg)BlEeI;3W&XWvy=G z%cVEv$x~CE**8_v6S^esSVnge7|mV15B6neA%K5Zu_lc2=o$?NO6`G};IH;47*Y-6 z72gzG29|5DGs*||OrhW94c8y^Pfz!H29BCk80=a;!OeZ(@Q(31Ou7XNi%f}^8Qo%G zNuQsd%sHL)^yJ?n+_Ee42dH{q+>b!^|8_17aH9SfDoU0>YW;s5mnNZ;aW7cq(fAe2 zG44&k-k#h4p=#!#kfLt@BAE=hn&5Q?cUXwI&r5Lk=96@sA#Y`1=wPW zy&KVpL)sGc+I0cr=~e5Xq1EOs!`O9VslV1d_^cakmd7NrD`X>nSUJTaTBsQ!<7C?c zY04}|EfoU@8@?X$+6a*1GOX#yhu96I$=koqZjIv@wSGf264IS;v6$$M?pw& zt*-v3E-JsT6+0)8!gW}Fx=K%^LBf5PkHQhQ(933hMYSs49^8TAsh$#v#FonytqXQaxoM_~4f(oxNunCzzNUU)o|3V1ud7Ti{)7dE z@`ip5-AM=PW4jyZ;*|XQP+7`o3`^Qpha~7l+UC3w!7%$OfvPL3%vhQ~mYPA7y%DAt zKXu^E`?ngeZ%hZ9(mM-nnCHs+G%r(42f%0))&CjUskc^-Dr*6he9P5`sdyC($}^!w zqW^2lR7<{5oM4L#^sPhvEb>^-i{yFv!i}p0g{>i z49eqrJUDsX(n@L&xdiufeCinqVjc_nC0sKfxx>Du9u{t`mE|4&Y3z`?rOf-#o{R%u zgJG(X3cg51t4Ed}yK^cSLNieEFozfH=vaCvJU-peFUH|H9Ek%U3-nUGMp#tfNXipU z#28W#&J0$p3sGNf95`3qaa1)ewusMV@ttB4|DG6bWu?a!0f!wlWM%>P%cx?eES24q z(vO^g@XfN=Dac0LK5MDB-bj0*?JUhO``Q2}tu-eB?l0pl`Sl((A|U3eS%>YZ)z8;W z7fj4TFel$xZOXWk>(+X0PlEA1zD~@tgykF?>i~iW8S2}+W?x`1{`!m}k4_dk+o8IH zh6@sYSb5P~VqaU_$vBOtvg$Gpr`ZdnB`oVf`w{Nxis7QXwTgucqDK@a=s#sBQjbQF zkVoi|jR}T%3rAb7m1gWoF{w-nAD0}T_o~-iQF7dG?)OO=r+H!`?y#`gXA$jQ6)e|0 z=qL*EI8-(6^HDseCKy@l?uRebJlgK8oGzUz)_%-d>h6{Bl#P?7uZqtXy7u~$-9596 zvx20m-6f?)PZ8$=5ZtF>y%x(;?`K1EEK`FGw@a8jloZ=OpH3rV!0le08{b-BJ!{Y1 zhZ-vCnR0>O_AN!fe1EzkU2)?^!NH5pdr6r9kVK>wB3%!QHl>R;FbM!_jh0X}7Aq=wZElH}r~u#}V}EPXW_cII2=}9lu7$$T*#HbfVd&AZ5W+7_4*F zB{K2dWx~&NpdI&_iOi#EsI5Izjd9N?3hYyLWK^(0(Dv&rH+`h9_hhT;3;w5!z} zgB?f-!&6Fv!k5I5s_I*f_sC2Gca){CxS`d$WtzX8VokSi-aFk~z4BmG&)IaWi>sCf z!G1K*1o8?%6^EV%7G!8IVt01pI4s7KCAEM!TzlD(%JVsHJi4`5c{18~K%^gUr~Jj? zW4Pu^L(JefpNv4qm5wZ(?PJ9O){pP7da&!;V#I_gR)vQ>?n2hnQx|@ZEi&^%bhqx* zl(`}d(6bg|zO!|mLS7I7Hm}{yfNtd7P#lD2s0n}p@@m{S1Sre@g{0s=MPX*|LqxqQ zVoG>)$FF4nRmOom^gnAa|J9BLf2l6;kNn;AN9WGWAG`rh?rZ@zfd9u$wp4u6;wx1X zLUVf)y>WVJ)$xo=s#46E32gD*kjxu^m}EOAa~Fc8aY5jS1!8F3c$4`7h-QG^o+$sb z=e#X*qI-Pm_$Eqfs6WZ9|I{CRF>7$v@^DT5kSV)CNnUKc-_jxLr3;OvyH7bB;lD?|GopmUilN(VsfOuxtE_rfEu0zqH%H*x?o4BP0> zTEVmsGZsP)MBxBff#jXP$YTE1+y0dQ`M3ClW($yyDwER|rPnx*ciOZ7!o^I7G~rG% z@nQBtN^-*BEceK=mB7)bc#YJjO%m~Xw0AQr6ZiRqJq8Lvi(C0j7Jy&^>O@q$HtszF zHxAuM$dvuq(Q!Za3jbRjm+fDVyWWpuzTp-oy29Pveq646VAKf(n-dgQH`n`Xw z)*JRftSX0MN3#z@Y@)y5gKiE8MmO(w{C4Q|%|kinu!F((D9ER4 zA%~WP{jY}C>T$O^LbVoUz0{=l?DSOgg}n&xI>yys`&o3zyODEGUW$BIxJY`oVWBO4 zo~t&3wY|)JfK>!Frn`^;uxC?6tXrsyISd$p48KhDX+9&&k6 zL?~@Z@MVYFj2ik@*VQ;l$_q>K*M>PeLd42GNZXtK{(aq3gsV<9)#~ZH7|+dmhYN&P&vkS-n~nF`&Q97J!o# zJUxkHyY(&z@E+XJ#V*9GRKdArmWf8^CWfpxKRAYYetVZmWu*l}qGJVW@z6rjVN^nY zr_{~|dzB{&4dy}sXO@s+`djc7d_N(8ykQR{{IpiD0i>8t_h!LDErd=Dy0XgVWM0IU z47b&w^DPUGut}kCq0FnV=mcHP3Wm+KVa1ERPW?wU{3zq0{Rywh@!WwbkBKepcK zPkY_(tM!wpqH!-2fx0D-`+{<_v-p_x&}qWOq}>i@l>_RLsZS^?^4b23jB!`+8?xz<~@lgk!5k3^@AKw+GuS^DwBg5B2Ec%;!8`C)Y*4ILP zQRV87jpaW(peL^nIX*DbJN8rUnFgBr0Pay%X(j8E4deV8L4WC4VS!!xOZlbU$an=) z-V?fm*>O9fgU5s{%_bm2IO_qds|Sd8(AF*4LWxMQx8?GdRcT4$iiwhcEh7C~=2Sv< z<8_VTqE9NIRbUB(BEpL+t3hBU17V;4#)^4|GU2N3yv;)9y3Q4**j%aoR($bQ_M$^f z!Wp$L?Fk`IwlS(DWZWfEoO=9gdZWPcKD@ES&GcDJ4`c^=GpNF4w~*6$v0Cue?H5cl z5_W&IMu4VLfvvlUa3y7Xh9LD)@3zRaL9(mQhQs`CTrEybHb#2_C>`J!|JBlYdw|RB$iKhw)b9)9#L-=7H6N*wWd8ul`}PL=6R|$zLks5V_83$` zSJ$+w0(2}W$UOeC?ViDsP=4M>yq0D2PT-mj&!$O5G9xc;mwGj}LCbT7HrX9~E7_)2&3PSFxN8rS5;G|!?V0SAh3O~BDr_wBi6Y`QAKi(xuzzVC#t!#4fJ$GlstjY7w_a)1pL{mp zH=S_qPI;Vntp=~>k$3lnEiD1XRNT{Ar2_aVpqnio8F#O93nl{C@_;R3V?!(y%LC!ILT)&IJzN%L4#XrhOUmlis< z#FkJ-luGw&J?NKK-v9nueDkzn`{$~Ivu__mE43|(o;5Om|W3~N!i zwEBgAjTdLku+uAz(yUO2RW_p7zN#m;l1rHDx7ZL#?V2Bgv33YXKK)xy*6xu>`` zasRW=AHr^)m-bGUmR6hK%cR}t@zlJQmV;l8l1gM;?X^r6qqXxk^_A^5xGBdLgCrg> zH-hilwcFp4RkzI2qXH=of82@%6S3KFFm>oi56TMTS{bXW5B1vY=2<}-VfFKPH*Seh@oBv)J9NLs4oN;> z8&Jy$-f0{`l&_)cKAK)&9j}fpMvVIw$Q^jD5$WLaY-s95Y{C0G#7hM`9te%}v4q^Q zJSyyh+xMiyeeJk%Sh%`w6&R|$?6%CA^BH~DckV>63l$tMQL_f5hzGV9$W@V7T?`-D z1%RFson_Yn$njl*`q0S|eG05Er7hXp`6AX`B?~7V_Q`Pxx{9AKl84by=n6nzffgi~ z4m)T|oIkpeRyQf$mMVWDY0@JkfsZuN()H+GSNA=ys>09?0V$-nQixgOrQYk$dbCWt ziTj=UwL9bF^8>hY8W7VIu&P0kE#ny%UcssBYT9mIC*6AkX4p<{%y>>rR?#FXA*-?o<4a}>#O0f zG!->o9r(_gHJh{*4meT$yMr(OzuBPcM|Wbh>5=23vFnWk+Gj$0)bC{T#i_jJCKypR zK36Jgs_m)66lIfo4v9pK>k;+HP`VvMDcG4V#mx6bUQH3HnWyoTtdpSBm{|YPGsUgbTafk)TJAdcrzCNCo8&M!&Yv| zL)v#X_8~wh6P#BoxNajG<-9^X-#h7$-78g{8ICA7ZiK{Xv(wLxd5;TX55V(VLPh&D z^$Ou71idhgx$;i!X(CZJ-NvS1GHm~H=zxb3cY|1qU|W_}6TcSZ6SfSDK~8{2pIBq! zC;I8(q+-Q}>UAVdda!62(<kGCDJqd`1UnngaJetQF`-aC1+L z^ED&}H~}0$9``hHVsUe##!1FcxjU+@6hXd61oI5W;-}D0P4$+!jZ)8hw=IB2jTwQ2 zh1^C1a_DE=n;hzRTL(X z8$f9w0vrK6!O=9`!s6|)RkGt77H-w?@G$hHb#s`S_;C1yo9M^w7YJ8Q`ZbVy1O@kq zrICr3uD?&e6QXDJt#;(lBHVOS!4Z6u^)<(u(8Nj-9L_v-9mk5S(zhF$^TiEGklHZ+!*)z;R)l5 z-`OGp(=Trq=ruw(J-lZ7tNYXXMdZJRes+#-G}S$9WxtpEWW@9yPX0uv%~JL39aC4n z%#|18?kp>U?<+uBD)6>Ay?h-bgNp@j71PL)^!b6?-=Ni6=boM{dh)-NPw?yL6`s%J zv33NI_q%84yN-8>l3F5fx{O|{KzjU(tL93D13u{L+hbLg5u;sUVi9@=1l@vH5JcXO zKhiHt%o!ZV-hg&7X9I67erqF z*x(=dqV`U|v^4YowiNNho7e*V|03-;Anu1&0*EEx7yrk5{`kdzroi&Y82>S=|C`sb z?0@VCY<|^CNRL7f+AaLJV4T!`@XO)Tc1=oOzO(uC^t(i83g*GjbP(qJt`A)@y4rkt zf3f;+_-#@FFYBT03~B<1WDWP;9fRmlz}GeZQ%IiLK$$Vj8PTQ+a=|gAFo4|1&m7ip zID*L|%QC5AXd{MHC^M`ya^djb1i}7WYdpXA`G1<{=HDXc{XYO>!XYTvkej+Qi<B80dKV(nK|q?cKm?>W0RaIaf&x+_C4`zt zm)=1_354DgYJd>_ci0=aLq|hRO-oHhMaw`- zOGi&WsAw)QGSFZ6{rvZr{QmgwPmv$=)Kt{JulT=roc;hXQJ)#3e0!GSCg2Pc#aSkb z(-r_X06=k$Ozm%i|Mx+0<}Bs8^JJ1}>BtwrFOtbWd-e>O*mIPWorlDnJyTZ=F$1iY8@V2Csw9GwOIi<%> zlvPyK)b;cY42_IUOs%YKZ0+nF96da}-gx`?`h~m;4GWKmj7m)UkerhGF)cmk%h%kz z{BH$?!scW?iIaCr2a zFABif|BJ1^arO^155<%3LA0=d$ zHPZ0h)y1*AbRVE)<&~V}!~bUOKREmM7z_R%arQUH{>~Q~K!28kym@Dt06+kNm3vQP z_wwp1;A-l!;D{dKW6BTNd=0uE$L1!S17Qq)?dwT6L6Vpc-bFMA_zP`v>G_?js+gvb z?ZpP*{>lk7b=?6wb#qcIkyU7U4m5j(masp=aro4T^~JJnf2ZxqipUZFzSbDA4(c0( zI|WFzTC;c@IZcKPN{{M*E~kEgT=VA^(s{zNC(v~6vd)A5vrohDP@+Jg&zyOP#(?LP zlF{%c!dE)QaLY}8LchZK@wqq_wR=|qT8@CeoTyuXoT!O@*SrCu*f(?Z&;5f(tJCMw z@4`peZEXQ@%IacT>VTFUIBHg546-a$1etjbol_wS)NY-ehr1H#l8E+a`J+Zp0q+jX zPXV7tOHKhn?vPk+T-F+DmtzEl6V<|hrcW0#BQZ~TlR``pq;nl4Nl24_=_#P!$?z2L zqXyXaR>Ho-m7wK?Ibv|c5ZD9=1E&C*&AL;-!xFPoz?u0|00*Gs{~t8iwI)ezAd|cV zF>c)Lo;)iedwC0rgDh<8Rs zlkO7Yj$4|Ro{hCII)7amdoAJn8lYyw`y%Oii(g7|eqeXtwM-btSW8uE;-tfwTjL8U zPd+X@(0<0KghufhbAjb?A0uiE3U0~hj)4dD65XosvBewtt@DAT9WA@){EwFWU&6mU z`)Z}WB0#PF>A7{*Q07FGACYFWPw?bxAYC60guS|-VZ1W-xW`WPo;9#}k9*d_AM}QB z3YaBAD^Wj$>`+5_Ltew-y`iE!xA5vzJXx=QkqmIX`FTBG9F160sb5yZle3dK3*{22 zfscfC<1X|~TZVc%p)k4!HcQUAJH);=d6n5)^MqyW>&O$++NH1*_?}xpI%;a?I_&95 zJjwxdDexz>QY#z`nPmWKjDVkfksKH|b-bvdP`@EBVfJ2EK*g#`?`^T-E3aj6FEacT z5Nt{6N70=EY#`{I=5`2+ylkltRI^{iBH$)QBba@@YB;2QzPCfT>;^T`lHCfvFV3#5 zGBKO$nA(6q<-!l)IY6nRK;^`mqt;_vNaHi2@9}j=qk?2nU*u>Y+jqhSUbM|?u<{zm zsQu@Gn_hsPd+BOwJ_cj21sH@V0flvAeR8Sm1~$if1gCvg957biYc5lz*+L3em3<2y z;gGVCT`c#UjqX}e?nn3Bgv%$NyC;moC==aJ0S+L7pv*eou?gX5r*&G6pny+p;ks1= z*U+y^$7ic1T#guc8Et4h@Q`;_`;18>Wto88KH#LfUf}pCX_&jrJ4o^xu*EPP)f7Nw zI3(o@n+dz`l=dt}oAZsDd71~E`)W9)+Zc1m*TS)+PhQ?{mOohPVx+#f`d8%K)s8Y6 zc;vU|?hwdm4Rhk@_F^RPVb)Ip_}Z>H;5!mMVF(+$)IwG|!=1@Vu?WiwQpcElSb}Zb zL{}^?rJS$-{B0TW8|Kec22s~e0W;8aqYeLKzQ7)&1ilwhK!D7;Heud1>*6Vo9=~)p zoX_BtQ7!5J613g2-mO!u{TV!w`hz44X?&!3KCm4rdy>OTFq+wl=m)fZOH^y5M>FGr+{Ly^dqTQ* zdap90kCFgV!=-#jDwnx_HT}q6qkK-og`syck&Ww%{MdW2T19{5Dd3vpYl7|eBH2@` zmD#zuF~zAdpZ#`E{_0y*%C|ItPk;-3Gx5R2Qm24$3*q6#K}iua?IBTNt11p;-YDxp zah~hlCFUl&Yte7b5NAq!%w`r4EgLnYRvZReqWNOOX365otMB8L-MUJzSMiDA?~NDA zua>gbp90kJ4burT4WLJH_dOhndtBu=JHf5?-WzC-w~QY>-uqoh&Yy{oF@?UZ{8+p` zQSFA=RqTHLd?~^7!vJZC1ce071O)L9G?5>{_S@o zjhUq?MF&|9p(*YY4|weWo-80G!q_+aBb(TeUn@pOUU`|)seHMeY75g!yc@DRw6#?W z?}Lj&Rnf@9k`l1lFdQ0b7$|u0m#HI%ziBEKipAs8_dp4AO zJqj~|q$QXhD1UE=HXQb>^VgznE^(xnoW0w}^PF1whYMh`wJhcvC)GjRy*@6mIkesM zvZ?F7a%`@tlE3t4)>i&5&09J*Y!g)k?yKmviHqOMpCZ}~i^&U~e0Wvas`oW7=76^R zaPUDY-Rrc&eHZ%bpE~c`uYY2qC06;L0`|!W!-eZp7Xn12fo$ZhqbfdB5bp-~^)8vF z&4r;YmzLelj3*Dbg)MK?yy3Dc@ao%af@aYFu&(Xf_pca5UXQ0=L0-?=F(^-86wzhM zRa^!~bp0HiHAnW-7(SuuvUNt?qD;srB=x6f6=hGMGsPZ|1a8rj$1od+7y*a_a7q23r$Maxn0VfIKMU8Dyv!Y zRf$`>#Qcc;%H{OF#Py0#0oVjWU$)}+ES{lWi1G~@ES&IG!o7RFcU?`^&Q{_4YXG~{ zEtjb?4RiZECtvFC9|N_pS{nrTdAVx%MTKHI{zmSMx;Ms52V;4D+>SUu!H5G_v{{=e zV|d^VpD!AzvzuX}TUibpUdCIZbm~dL_~+lIz9(Ll224~lp%IW*Aaqv~^cv}kL#=YC zb78BuLxIX0&7NB2NRHOqER?cKqV-l+y;k%H%yU%D_f7%Uf}WZ#=8CQy4E#rEZlFer z!=Ua^K<49Vle2*K_zb%Cr$*hC6tJ0V5)7{Gej=HjzA0ngIHlXxvCD(EEE9gtWF;>j zjlGi;V_)OCKOl*@V6u!rvN_m&uc@f1fhgRpF@EYnllvar*hpXZx@+>PQOYt$H}dM( zD>yX^hZ9}ICXW$if%S_YS1-CHteM+ID$1F!i90s6D-TH0#rj!FfAPvc`P}0bDc@6< zm#!IQ-Fz{~-N55VtAZp7y5d@=BQ!-snVl>-6b7~#)!J6%p%t^gO+@ZRRGM{c?mCFf zs$EmNG*JeAuJpmJZeCun?TVpt(6N-toJNMpuE@&+gF)-CeYJ&Xb>J%__;|xj#3gPS z?+n(yOpp3ay2@d$t0&nbfjsu;>D+Al{Vj(={`_y|EBoOah;54CmY)koyeWd*DWP$y zGgfk1Xew>9k35J$&->;#Z@IikQi~Hrc6cHv*`pVg_!ot^Z?7S`%MVQ{mH4~j=hKL`_ z{J&o}0k?GtCP>gygfz}XEy0k|Q>$nm^z`yHH?n4XDR}w_J3e1s9%aIztl9_>3-i9+ z8?#csVcEv%hVL>-U(?OJ)Jd~<@0F!5PizI_FCt1XNmv=;S=0M)37|h@Se}}?1{qrV zzIuPEy>Az>c9bEAOMM)+)xuh3ie5$d@rACLD|zL0P(&HiGT<*~&=;EoS9~Jodp?gE z!wam3LS`H8@MV!!2USIjOI+=cLlzTS@f*AhxXF~8HnAV6?(1Dse&T+V+MZF@Hk^)m zgqzOfFFV(5RBmRbw)kA~*t^C%;UjnIJ6#^iMCSB(V*rKX>vCeD)7NnaVe&SvzF6pmK5Qn3 zl$&Vgg|BFjr>&}bOSfgsOG0An=U5KdTH=Etbi0@^E_Qh8%yZ^7(#^VxeiB!HIMGcw zzx~WcI#y#eVdKl2IA%9W&ac`^-y=e|L9UG?+L7Ipvuzya`$f6@HF+jety0sU4j5e! zc%d`6H0H$zGc1$!G4n1k2dCxy``n9hmsDYBeWu46-l2 zLpwg0m^C{HCvM#C97O+UHGSFu0DqYSQaM5xpdEepJ{ z4I>{yc4392bAc_>lz5|c&CkTAqs~(1Ak$HKHUFFr`%?h3q}aLf#>-5~tIJ2pm02E% z^DN3g0at0ap%YLnIe!AQ2S!&Z%HlGS*?B!!1+H;;kMxm;mz&kMCWgwGu`{&wg;=)@xsV_=^ts9C{d7V}o#b+&=csCu+G?)y=tjQHfUi1?jxkXdk@ z_6zZQix~vol%wCt6r-(u7gU#rte{6@N$J)p;B6=7P%0jbgAy+tG;uR2ULbPdEs~4Y zzEAm#wI(`{cn5k*?ELxi-g{-|iHv;0H(kdQ%m)*HE-PCoqh%rIrE!)5@5aPQesFc8sJ zQsPi#Lte8pV0l82jaA9iTJ2N0jfSIBz)KCUyIS(%3MG>lMz@4q#Cr$xl-;_lGc#4I zSGXKxNUU?6iMyIaqfzzMmBNBQm6@PpW%!r$AaQ4S) zWPfQ z-aW~{GyecysP{86MU7?G4zuZ(r%z)Kx-NyX%8V{+Q(MupUy$D8P4oa890y>)YWVXN zkU8!!2yMOPNrhdW$)R6drtjsHn@!^)IrgH?n>n@dV0+|C-!^HU`{!3QnXOgOed^6*ySPo`;i>TVg5!eIAwH23j|gKMBRDp-laD|rAP0f&QO&TJB$Q#A zuc3ZyuwA6(Z8K+L4@VBy^X<#@FDsGv1E;5@PjbNLz7hOewC(xFbnq|m9vaThydFw& z<9soOKc9vM_Fb#jDGbxQfu>V!N%V z^iG-i)Z3;D#lAha5nk74%T15Ahd@WVPz>@5=mI&1*a*puAYCI;(?;!cX? zJ_KGs#2x5XM0v?{IJPF2>e6o|-iiR-`M@pK{pdB#O|4i=#VLRs1==~=sSnAUIb299 zTCKH~D;Vl&QkZ(Do3cH)DDM4G@BwV0nx6GBFa3-SSeQ_N6$=Jklti)kXc^V_*DK|8 ziweU^K(F4Tl-Biwm4wa|(@EZs-EzeM2&Fo zy05SrZ_-ocfZu88K(euKglF*(#F6|Xo+3g@cqvSqucTS5k-_L5r-obp_&8s;c(j>} zN&3UOzQ|9Nj?cq7nm)t2xyN0VaARZ+9AM$5t})ZSK&n+Pfgut2SY4fT%F2raH<8A~ z7o9J)ZXusbY_Q8-=?NSM%Mh%NZ;?7q0hey#AwL*nP5}VYRi9vIi6!OXxC(3tRzu_1 zA-C#d;KrW4sVvh*7(0kkb*A7@{cWHfq|r`Z1!vWQfgePg&4z_zT^R`B8l!Lqq1MsV zHz~LkZ<(r{kLjy@U1`63(RT~Y%bf(A6e7v#4-cXwA*0x0jhw{rz=O>D ziCWlPylv9lug_JfCa({~pKxW>X1wo_YWr!apW!}1TyKqoT>l0raRMGP!MVxG4?hJA zcuOUjjzYG19D#eM0H;$x&ZhktZkp!2NkY-nc$0K2Mm2Gh51BG)Yy4T1GUjba3SHto zc`PywPma6yWjW6Rd_h)n=_# z)qyrJsjrX+Z0#c3MnLg(gJ8LR6+W%axTqd(u z`9ZH!eAP*%moqn3G!q-k)1-K2KuSa5(VAY3zk-~umuxA|9d-UhwJd{}BE_4ba}S<> ze?AlDcnYWrMEK9%$u{xvXfhQ|;tKJd{pDQzxu!*WOixAfon%rSyG;B0ZnLc_Z?_nz zL|A$k2$k@)L3Vu$eNfeNf)WAl!bmDwohLGqjN>6qfn50fpkgTu%VbZXPnM>TZnSce zs?RL)dwre0F=^y#x7DW~;5PFhHaNdfh+6N0ERS)I%$BvS2>;rC7n2LE4Z4TBoTSA@nKnX)q`FIl@JyX z;U?tLlmoU+n4(vs*#lGQO7TK$= zEa7c;t~j<}gPY~muzQpl$~sqbZrinOrSg-Z#VgcBGooC1zvTe<&bi*q&l>6Pw-a#{|(sDfH`QsEuYk&$HmpwSvc zeGp>3b=GHRhV09{Gy=R0`$e_hNr9N1QbFT4m#3mNDmZW7sH44Noik_uBB}@ev2dpf zSY~Z;gCJ8#K&Xun_1svYIUS|E2Nq1}ed<|KpH%iOeYR&N*Kc&TbGE5I~WrA&OcNBRQ3MCfwbpX>$ zVoqFirO$t7J(5lbMM!6TY703a>6U-G)^$as(q$^jOL#%2y(k&!q8Tu~nN>Al5?R-F z>~#w0fE>I2mA)@oFKBHjm}8RMWk7~%0IrGH)d?| zEA|V!WoO_Jcg4BB^&Oj8{~fpDE=z2Y??SMM)sp~jovK83Y1PDu3go~Jj}X<3kT+Yo zz>QX{GTtjcVwPNy3@)jEmMT7pS)IViiw32VA)?bP!7FTt%Pvirf5#^5aqMKOeb-|X@5Em& zY9%zlS5qMU3jDdevRMd?Q!OOYxw6iw&Mdbf5-^l~$E;kE?N0T}3ucSgv)*11iX@}O zcztq)ozrYenUjt)K)O>z=GoBt%{!(JqXQx3w?@)3*m)DXyEQJU6~eX*K4im(EHqMj z%z8~p4ODcu+D-vKlTHC_b>0Mx#Z7llohN7hGd_{3S2+b-51=B|bCQ#VcE#zVcy40Q zF82}6^+YhM-2Uu_7C~l$q#HQ{JHm|scf%Y>5kmjN;+oMH;_Z`fU^CpuCk&bR+M&6o zXbotV_?PlifH$s~Y;hb2@deAHMpe@QJiIk|uijgFjLF_xi>2jRcH-j~A8l-|2j9CM zeA|^^%NPmS)spuhO9Lm2B=h_i@d7s+l?wB@d;5+{Z%oqXB#w%hg1)Wvcts3^#n)qmNTES(+Gr-`b+vUX4Wdu`v@^Rq3VzGCSN<;{fnaDoax@@ju_O@qXqWOvg z4+9UESx!j1A71Pqe^7;Zm#PJIB#t1Nz;89 zdb>}so8B8YBGTU#wn;=K#qZp!gI6Rj7`{2YX4k4U;nW%kykz!ERr3D%Ih(SRHAe5X zL!&sY`;*<fHx6lAmAdjOK}jK64~;!t%yiIcwK2ke)|6`>E)j zc!O}=+?P%P%UM24rvOSB5YZ+6ANSzFRS}k{|H311_M;*n8C}Wa`$*I-D8dxrF9QEs z!T(f=zhv+~48dPY0*L*~%>1_Ce;H~rdig)WlQ`KYO-$M&QkW!R7|luM&#T$1qeRI8J+kzLXVWBAdguH z3}ldWi@-Cd6%N7a!p^Q*T*t*n?uy8nIX@d0g)`jtH@48rpA?U||4p}5CxX5Aa#kBE z(4O3p`nxOjzno_mV81+OHq)@&=m>=_vw2M(Z?&|=4nWxyFI zXxkD<30Z&8580hM=eMU%;^!+{g5vtnGQ{I2rvUJ8*nRQ^(pL#O=y8L>joLt$z~sC% z(5{5;$#7t6uFqU6qSh8cHI7Z%sKPHFAZ}%3YVh-gNq4dUMQIwZ!#0xeNi9&?z#Cwi zvVJM<@1}$<>}3wF?@+raP?bp)G~iCOXtCbG`!??zhKFvSF43wJiw?hj*>M)Dn|>nY zboiue{sR=ViTbgQnuS)n9_~kz4#_dgvGOSZYLD7VKXl!9IYG&L*^oP%0EFzB_=p2? zf{OvJb@jQA(vS4Q#>)a4!yD@*r5R5%6WDJ0WD; zwTY@a$*HysFLSQK=cs5S3nNWXt&``#o*41&KDkz-H~_&&LYjg0n4Jx_lN}4OZ-FDo z>nCN3VvgJw6wmu)XbruRXZD~El*do%Okf~3oyuG5Q;O^?*z}F6_uD^X>9317cWlEb z@Mrf4_@y6Wgxidf^$J*xYS+Ls4yJbDl|7FZHfGi8?-V#f9n74@dG!sYx4T^Df0{?N z4LyFKQ(NG4tNk!Db?VD*(xAeG)~v(F9sf9|9L+=XTvr2sB)ViIzJT1V`Og-12Y87z z?3daMoq%AUC6}(YDsuS<&Dua?c;T!Awlv7GKvDin&N~+@5f3Y?1`yZJsL3BR0WXmH zA#k?lYXaEEDArkm>GZA2c*6lOUmn4=tifoD2(9 z50@8WVM|?T>veL;fYZyx8i5Xx-NWOul&mN>RE7fL4;v2r8?~@>XP`?T*P7xL9BWyj zB6PM#uMxy*G>d4xcDwCzRugWL$INWA!^zE=f!zI9lM$>{FFg0}%zfu#K`BGT+uGT-@eUND21Qg!h(nq<%4S!ZM z17&95Q77D=Ig#j6)vIJW2(o~6tdBb-MR>AltqfK zqNB|Spt=0Uz6-0;(>JT4ZY{)h=?C{L2Jc@^P;Y=Yz011Usb9pxbGxZL+2D%0>w0^} z!kbd${0Se|=ES3zT*J$$XmG)9136&dU-N4{1TAwD>^3+_0pu5uWLNq((@@L(j$>mi zN|D(Iq=!uHYZ&&7)+maU4&CAP(MkIbILn*#7620?=U*ZN`xSXk(t);SeV52p5$WE; zJ+1gP`n$LDC?$XMjJ_+IS$_CgoANi{X7uA6UdGz){nVTys%r>tSv|Rb_?XZuT`I zZ)*xX#%=5&Lg(I8$OU{Ny_UhHO|sj5aN&*r5QBePvgPho0r7}hBk{pUkESGQJv@i- zs8hhrgE5y_Zl}L1HaQ>kpXx5PW7LLKAF4`CGxu&&(pwe*TWa*xV| zrLL;_5s?jnD9PaS<+d@BA^Z|QvV1R}0?`Sc6st{=|2G$O2si3J(rFWl+yF2x&1Eq6L0@37Uq9iJ@PVX6nasf4=c8gVgTPBgg(H1G*?91$hCgrH-B{CnNap#xV+tksp5*0 zgW~fqn$@PSVak*Na4-yF>!<#9WILw05hO*iYkL4nJ7Fi6$}Zq_IHV12yiW|FX7 zqs2AX^^aCVn_JqCO}i^*eiWqg&LpZyZcQj*#abZax?(|DOysc@hZ?XTRZP7~;e<~J z_Iz26J*(|~`^v-8>!FEGZVudAIv2$aY^N!Bv8giEdAlP*zIEVA6hx!$2He5Dw1=2{ z3OHm9(E9_J;Qsr*kA;)k0_DS7F<0oNAys)H_^qGc(;dKfthmGIgWQYu6FrwlUo)jC zdmxqodn`TVoGUlb2^E3j_UyZ|jA8Nm2|s!Docp4WAO6+#@*PPBm(o`)e3p-u?OlZP z&XrY1T6N4DOib%+!VVM~oW0Q@s9h4V)%M#z5H#tim(lIk%*gD`f zouDSO;4M{kV9{%2IP|QRQ%-ju+3F-TF{Y}pk3horRton2IkGT7o*@ky0$JrLaEo*L z!J2ff7K*q^E`D=%?0a~vq;`EL$Yr1`&!G8Yd;iRs8eR+A3&mwMO0m(tocP4m@WQ7_zS=j3`L2CR93Fa6pWcuKO$f9-Oz!pn zXExeVL2N$cJ#8i*^i-WyVofl~{oQuj0dr6v+31}K z95{l+$lEZ6Z|ySvZU|^V_}5WOb@7HDtMj()M}F}(?_^g~7P?Nw=Qj)ik$aFu0%%v< zAb$e^f5d|Gm5_iozZ(UezU-AABWh`%=L*jAKWMf1LqiM+d=P@zB;DorC+ZYo(i%y zxY3<(_Z#2i6?T_#d4mA|{T5t)SRk{5g*dt4I9zMQ3%bsS5O3cv@=uU|ugYtF{HX0^ z!pE?C2E1nnqk%(96ZpqdfhZBsGHKD_U+BDD8>CVtj7U+kw(s{fRa+peaw0(eXkH1) z%XUfrbyK#QcN+TcI|JFynR#p>fq6fEh-f)?3k-yO_9<%eYuKop`t`8Xgcpd`;g_k@ zkVdN#acP! z9bcu78Kb@zWHe#eJTV-EW0U^MYB88f_yXa+4 z?Z4jo8({fsHU8)>|5}Z|R^#6^4i8SCyDuPfzcVQf7oq@o3=2`A0taeEy%Te~)Mkx0 z@4U)*^mcXW$f(XJnfQV{g;Id?Cbg}_pNKoLtbPFKJh}YOPKsF+P78J@4h;tGU$+My zxdb=()rXU4$i|MJ8K**OVW2t%X!aYy479K>&A7=4(Z+{FI&9Ub;zgn|4jKj{I>`ndKr09-m))$c&1Xn(}D#qg&SCQL*xHWymeQ%Ou%5_}u1`KuTfwB5%|&>*l_OFF->hvh8lI z#9Kz!w4iS&xBz*o*?H?^kCEJHpvUNyw^y-fQ8;?YpM(h5?e{oHNw*Lc8<;)?$aIe! z`>ujRaMAlf?rTKBV|@a!t@arr`xl`Z8#`K%<0$rOf2hSsYlxvL-+KN0Q@s`w-lwI@ zAMJvLmXrw(@pWy`GJy?L9`ONA5#feE+rq}`=LOrhO_MJppw?@>a$ys%4D=+5o4Cb` z{j2VlbLj^iC7l!iPtLkRw!T3KwZK2os{Oek{p+4ZujGlZ)fLRhw>3;@C%Uji-+*=1 z1?2BCoeB|hs6+jPR8p-Ec^tDjW>FIwaWah_;y6R7>uevZk3jRNT{m7V9N{+qAVk6f zeZO+Rt)}_uyUeC4G8|I|#z3p`H*SzST#Z7dG~xl^Cpb{3=dQEf)AZ>H{rHaI(3acQ z1}F0`^`}vR5?$}}$)olA4CLogH!Q+!13t)Cxqle(h!Q1#17V}9ECGd!U87Oaw$Ttukd0k5^bgK16*>&=g)h*!ytHqEdIAhqJ{Rq|kJ z81zEqxxP^O`}`$e2+7WK#yK^?+jr+DXjt?=)cMffxjs)1E&B7as{8{F&(!5hrjL;& zJL*Pz^$YV`Rip0edP|6Wo6RN>KU1ci0h29Ayd?D3SXX1wk2>=UN0RSW-UJ(9)o!pF24&upa6zjAKAi$6h!l9c_ALTGwDp>u32r)f78Z$O z^uh0Z)1Rk3);iXO9Gxc%Bu1M&#p(%h)H($` zn7|yba+5@pYIU`Trecf^^qrkRkT6cnjQP}xhH;IPgDg<`_|Qp&ZO4~q1`+|J0XyTV zNYq{UBE4Ficf=ea79R@NV(yzA$b0H#pN?I)G&)k!bclTQ=Jmu4&APDWb{04}>lApB zTJPkGGipIyA~D&InU2N6z}LKIwwMWT23dWO*|S!MpPFAuYzSOM@ig1 z>V54V#*W%mh|d-0ki(J{H7@58e0icbgpzGco{iCV9i(Ym5g(r60&BIJi7W;>3lpZRcbcy>#k_l%s3yys)PS>^d6ta3Y5s8c4I!!EnyNA% z*G+uY7c3K3&#&#!lldm$P1)`J%^$t5@02*yR(Ns6)*Y<*`*{W`OI|N{sAu}Mgh1|W z3ebuxslV}==zQ{p#I**cMA^Y2Am{6?@_Z7J)+u{t86y?iay#U_}oAVpC5^2|l2Ez}0NfVIp?p41CaIt8>2{L!#{lwsf*hcz^=jQdA*^=iF&-mv7o zK=5##I_}#vkB@>lnK=vW_nt&n#&S1dXyo1UmVvnPdRf;39}iQU!f1lMsgEWSfqDi=d9saHBu{Z)AnM`T+v9_v)Rmmk7=~vl7PoN7*w0TqyuPit zOOMqKy}ywtv@GL#h9S>-I_64f`^4|8(!Z9Op#_2@coK6c{Bmd;jEb&6em>dYgO?Bx z5OWA6xPvUI6mYyuv$NR`&^06%LCXT~9SP=PS&a72SxNV-aOB8K`_{PKJ|BcSFe)=q zpGcj5^5N5qQL6U7aVuj2x!gx-hVN?*xZQNzGA&+>GhbhVJdUby%Gq=7IB@M?VTa$-U*m2)2#kI*4~FCQnzC-6 zd;&W5F@PNg>N!h&hMLpIf@g5vF_IgXrtC%~n<*Euz57D$2Ki4MN_kT5?OdmiDV$I( zEt*BNlVzq7y212$lHl4jEsB$A(qbH+QY$t0K|GQ(IEaMt8kjlxJDG*D-BDrdZV;MV#|ZEOq9_tjc}x3UlHeXl{VRzg|bBy7=2$kS=0)fXgW$xqWN# z6fhs31+*p0wAJiEyrSTQ0~ZH@2e0wtD0y8Xe#0CzYqJ<+$8kGVh;R6PPU*(ya{`O6 zXb+>CQFMVqM9Pym(nX)4Mhj}ZU9@1Rb<*mMv5OoH0@OEyI#e1J@u7XvF)B_Nk zzIW-EC~|>F9mtg*T3MI*d`(W;Wo}rpi|Jz@eRJgFI>hQq*xHfO1P|=3b*dQn)`ew1WPCBf zeWG=_>ZtAWKH{eTH;L6m-&ahmcVC}n?R_@Mv01v8sk9$Xn3@qBs+c&Q3=_@fo!{*x&zbXiNyU$cf0#M1Z3jRRqa zZ-^kwit9&t1>9E4#lR*Yy=Qno{M|^g{FASJUe=?!bkX)hh9=jh73z`=6kn?Tu+U-| zBMm^Q;LvCY6WB7(_@TUDDe+$Qp!1dmKP$$;KhcmsDNnUc*`qQk>VWajOYtYap?84T zBE#n(r6dwHWFK`XT!Wh776soYILwlpB?Fntfpmd_q78Y|6XuS@zV3jRkXhe>G=3C(i+mkX$kl5)n z$nQ8*l&1nuqYRs0O16K=N?(3ziiU~EAeuLc;YN3E+VBv$#3zUo39X@1zbN^DZzVahDWDzozm zjsDrp|AQr6+41i+--2YK_+f-szoyF;AY;3gWQ8`*Dfp9C{-aI=y@|^G*BkMG&At%y zC%OFx*hlf#$NxoO_t(<>H^}cVvH4f|fWO4%|3k6)RwBxQm9U_BA=@@in;1aSeWLMz z3xW?JspmIhjyX$#yN$(0h5zqm)3`kF{&Ujs8E9l66RtF9_C(Bd7;MC_yT+eg)REu# zs;Y?j>IX#TM?^+@=N-g!Ir!YMosUw>^fg~Ev+#beSj9f=x)I5xD6^24l85qjO}vlM ztFgh=6qzQf58TfqTDL;v#$u6t1eI1(stCyjHXYnonSNovumt|>bDdMd>h71Y=XH@r z+;@7n9CysUNi?Sb;UjC{xP@3$y8&_#o+)EqUp+wTmr@>{vd*%fGkO2Opb;%GBTCW1 z8E2G?)IHu?ICKs~Mfy3cA~#WrQ;g&wHLQu?=i)kN?zpYBUUc98xPxb4%YxHBKh!qF zGx$=_R~7Tf%+2-}y5!QD%_^`8^^V*SB#c8Q~O}4uE{$y zevD1xGWg)EB5{Yd=AI#U8Q)_3Odp3s3YSd%_Zqx&N-Viibkv#IG*)r?-WBQb5V@y3 z_diHnEH!dl(=%jB1cI*cC!`EFK^bvH5{CCLR}!`BXIOLKtu@TMwe&XbF z>-=FT#SQO;I@|iLXD30f@(MFnpB*e@%rq42np39P@yu#pXh7PCAn2=<`R;R-d9pT- zjMY)%_uXq0_|uNBKKU|f767#nWPrwn$6#Z|?Hr?BE25vLDah^s85&mVJQOh}aMW%l zm{`S(63rlY-XKl^gO$6Re(}xF2((Nq?A$Lxc=G`i&7t_Ucyx?QuXXX9tO}&*^VX7XdM$urp|t4f4lw$*g*AK zyH3Lo)|^Raf*T87e+7O>zJp|wX7Ph!Q7>Q_Un)A%_WGf!dfw&GnH_|}S`R#aJl+CM zPFxwaW?jLz6M6g&TAUd8dwZ9TIqvtZ%aobuca*D)13&WdI2cUCm7wjs?zbDjh*U#E zi-H!NQ+;y3QBKB6d0;;`Tm4-(*O~j~XJ@*-J=W;KHmFva*XWi0X-zlRFLYX2=N#Vg zE4hDhmtp602xKP1w5PN9_#b^7K1(LJt?-ngW=-b{nN;tHb`DtYku6c}E4z8dqp~7! zzJx^C>xl|c*18p{*`0M*0V1;jQWE@-JoNnz)yDBAd*=LzRDk1<@=(3l`Q*Zq(foYP z{9aKhYHJ#|OU)j#y3U5~(`t#n;0lyj69}gkKxa5CCIyPf;;+YxMcn*8xLd+;(5wlW z!RI~9H=RPGJDYkBy3?0i174S_EegLXF8tm`F~y+ut07=hl{_Y8x%I$rF_PQPVs!~vWmr?>8L2e8M%Cn}t8S(pZ=x{~ z?V$T6dOg)JSTdb1kMr6~9nq~j`qEg6<&1qKj=FlNq%FTt4N^EcX)>{bUzQ8OM3#(j z*w0s8WY4iNVZz@O>ud}&O5Xu-l5dK*NPs~~F$7razFbOCp#zUb)X`A0n~BDKzHYr% z1)PbxdATnWe}9?ij~^7D;*w@j>o(kPk=F@YElRpLA~V5dPQN;(?+LDj<4I=w#EmFE zebrCNOvOrz3At}N4&MUkElX-D$<_BC$0w2&-jZ3QEl3k)X$fW>i@8ktrAR+Wq)l(j zEH<&=ED_wxFsP2(q|O=_P`x&9jY!6}#Ic=MXbs}@c_}rv55F&Bh6)#z++Cj99yGqmMe*BuyI zOJL)<1F$d1v`vqFi0DW*b7%Q%l?0EF^DFKTb54z?fJ(-9@&SeRDSpb|5vhtiL%AcB zyR1WEP-o6!_dCLGZy3GE<-Tx1dHRC9KRNFm?EjFeNkpUh?kX3JuUJo_WD4m#9A1?r zi#x zQ(Ar&nurKUFHvcR5F$-lAQq&G2nYxWQL0Ll8fv0c0qG?YN=WE62_*y);=A@a^PRKz zKIgpe%s1c6_x`bGSU@tfo@71cuGf9t248nnA`;S4euEB1CF(ZsEv#Bwn#NCAsLovN z<$(2pJt1Q|Y*8ChZx-nfXbrUrSp}FG9#5UyWOviis!XssrfK6TT$Dsj zz*J>EL(+!k5#^8OVgzE2cfxLwMj#Lro|np)%clFzWrn^~zSb<~Yq~g(Hz^9y^gyXqufc+o z%M|y<_LuxOP+@Gt+@KEn3biKY^O6R^D!Z}-TZH)1Q|CWkdn7Ma4*Aoan}?CN39{zN z?Y3;99`~-EhKy%^cfQ2%RbOE;e`|876<9^=v{rI-{N#V!~#*LYYMXO~z8i#P>v_9{AHo zuk!z@l&fL5xTZ+oz{$)E00r&bNE2G}v~sMDJc(Dtl)BTZwI63^AM{2{GFT(I@!3Yl z=~T&iuL;43So7$IUF13dqfdWSyPtsa=u!R7=ft?ZF?8#x!!7+&i<>$FZ;LX50=_cC)3(daWeZUDJJ ze1>p@0#cHcbpyMVq+B< zh9^{Ih{um?Tt^g49vL2-WYw7#mz;j%Z+BVLC_VAOMC(PF`Z7`0S%?S{LQRX!21@_U zxCqNaB_6ZhOxp&dcUjEH9xP<%Zs60lU=#Ka)n&btaV>cE73STzPmePSqDVhy1`k^< zErmpaugsfWjZ1x_aE|cp}3lf@@6;pkbosv0LlUBp;&l{UE^m=9$ZUs-#{sZD> zk77^Yx4Fg4Lc5uYmUcq4JpLuk@(zTLj=SyJT>2;5nUr^YU(Q=Uxc{m}$%Em;{HrVh z?7_>hMF6H*&X}`vO%_6#;P%jaecPaNAg zN(3|Hn>RY8;?Bi%f4b=SWQ-G`>tknH*|~I#XK%^N-F;IcmU|2I@L5l`=C<-UFKIrR zv{-$ux~Q+Rlb$Q(v$#{?I2LDf>L8sHDA9#0p1ey5iE zr^vbI)-Cid2I33Uer?P7JgS`GJ3yhh!!_1Uj^~wdnI2Q&tul}{xY17$5f2vZ<^A0m z>%308s2EDt6>dEouYKTdmSAJ}y|d6iAiG(QK1;+4RV@Kl0zwp8q>m{Ag!b@tQOM<1BB%_pXJ zpLs=yHJI4Mjt=3|;Tuhqg3)374a27GEes^91RjWeiIry|Xi?9wiVVLNEkp!M{p(F~ zr$?M=Lmf?u{`!Ov+dtbM=63OV%Mk+Q!-=&%{@>xhv4?O&qVtM3t!k|r!>)#9{x$5u z)b9$;_PPhh{F>AG!WI0m=IgrGL2g74g#?&aI057-GGvXn64flGJ4)KzgK6dI|)gH*Q(aQrlV&TjivBVcS?ClcbCOMTAjgEGS9NWj4+Uh z{$0^RN705eQcCbq>s}S-uj4-EErn)Ir z%8X6o94zOn_pSzhGYiLK*1qQ1LyRX@DFYD(k1(-2O*E_RH5`3%V<`h(iq4;0#_XkZ zOLop(hd~7@yM9O}_O@zUiM#>HVDC2oMruc&PfifnVn|P{CBTCmmt}nsJ3yAfq*)5t z4=u&P^JT}xm^aN+PL+mtzQ0|-`F`Tto&^2l{)YfaJOT3zz+G?$rFJ(18{DU)vv|qI zJ~D|=5-|nOYWvXN=UqA8Ag}*~ap{Vno8`|gbXF;N`psSjg9Cn$Nd77neqks8096b7 z1$q3cYbtNT%Z_Y5vR<<2S`sB2vF7at%Ef~J%8B*gaU}LIe3yu8&@fT9b;|5Ail?7w z)=oL9^A>EJ_p;jc7ENjY^0b*uGRs5mvpalq=OM zitmHU+ft$4NIgO@#^%OnQ9_JT) z;H77$M}SyojYgucEeGFag1m^|#-ulC=PngT>Vd-x8j5tU&A{unHxm@r!l!nW)vNKQ z{I~-y0HVNIPpXL_{P5u?r1n6y*=zR6sJ3jgxbSnRM}}?-CU603jba6N*mxS0_~>wg z-u0zgn;h655cM9K_c5eK8VF^yCU4A41^7KYNv8nIk05v!{~6Arg_5%L4t|U zYnp0ONX7S0Z{rvW&RMzPzX%Jh!i>46aBnRE+?9f^-BQ<0R-$a`<#det;wa@Yu@sfqT{}g3wZI{$* z+L5K|3 zdF1uot`;Ky_9^AnhW{Xkdl`h@)diu;mYn5{?`B!yJOtI=9-Ylg*e< zcaOc8ClRjuM)d@ow-WBYw0Tt;pMsjc+f&*jU!7xfdx;n}*_4+-*r=fo*el~2@fs!7 zp}MDBZUY~Yw2YO-FuI<1!R4({D;~1-`!T-pUPQ(Y} z%V9+qx<$ltkiNdCAL{B?*}@D7QXYg~Nt$6!vfVPQAMoBf4KdGNF{yW`&K_l7lhj}% zJ4I4lV`q*>+;||XeprHP$ouLo(yVD%zb_u(F5~6KKG%#Swr4P97O=wcS9%fMIl>|v z_m51O?34ZSa53wIi4pC!?sW*WaXbtN)zqnClP6~Mk-M@agt-&js~b>Uf-$A6mtlyjemXkCv6u#`z-L=k2Z=# z_>^$H@SAW^6H*_?O>$opnBRR!aSL~fu<}_sKp4AuMm;s7Tqju{evm6JT_)5=Kzi&} zq=xx?2$6Ma@g^z$rqKZQg0th2eaCAA%k;}*w#rL$nsvh0@rm(W^KmEpiDk((zV9S= z<5}MmpWo25F9m zt{crY;eeXBgOvTk60N40#h-H$b-HQaII#7bC8ylz0wte^i=vn=t-T<$ zoLH|_J}pFI`TY&2MK#DJi$9_?vt?<4k;RloHGi0*-ip&mb*6)S`RCG)7)9}sO{s4p z_Yl>D&*NDyppGr{tsb3^Pm|I17`WMMP+Hz_B-LV z)-$;N1#~Cwp<;f{DS@YnRnUvSPc)<%D-owQ2d7pXoQOEZ(GtZMd(i#9zA5M1_;sd+ zM^F^|_#7PY>c_rHh&eI%792(>>YY__Vu%x-W<`(fQyQ-{CwabIZYQY0j%?0A)N?F` z`1y*^834&KAXHvLMFZCoKO<%1nz0vaG5su+&x|Mw{Aj!1Arp76vDM;fTY|~ht-!>} z)3w&F`kQC!JCab-XsyUP<~5cn^-bN(XM~P14bpnEwZ5jrBS*a^%R{TFRI<7pmM(gg z)nN2v^2uuN`dr;nUFCLSC7LAzuG)#zlLW{X!_e$geJ4EGV(ea~3=onG!@@2hDVjm! zbNdNmPsOL)1C=KD9m=RU7T4I)hLs+ZXta3iTIp_0JtkuzaBD}gY0bN2Vt1wmMYZQW z;S}EK$GSC&)C?|Q#ICf2M8)|ha5>!kI%%ww>0Q{BO@%z1b3)Du4+Y$7M0)qI!#PQgtl zg-oSU!MrM$6}#>zR(OJ{r(;$#n^ z6e`p(@?G5p*opsbV8rbVQMYkZcMxxu&p|S7S%9Ak75ClvtRbw-BiItw*y2(r(gtJBY8s zIjBl;VPrJJwi5*)MJL9VGm!RYG%TfrPyNhkx4=LpuQUpC5WD1ZY@$0)qXY&~(~&-o zK^~BV*0Wcr&eg>$rx@YxwLq@r=zg39ZqQrFo#|bK&}H>}F?ou)BHfu}6|7pT^;Tsa z4FbL^8i-FFYV@HlIK8x?u9{85m7U80-lD=VzMf2DxL5X`#Md5I8*lPoLD&npy>-jtjA!7X=YK&)cNa~Lw5|pU>0a5 zM=vud>jN_s0TG`-;H8&U)-WDYS4gEzr7Z2?t-M;mr2WL08aJqaLCeo_9)yXke~P6~ zTyUr}1~OZ(5>I=BB)o&eH!;9Ll`Q&ay+u8v(qSZaVWJRJ_2&Rwq89f$&ao;e=G)bYfMUofI9A#e0g# zHSbRYmEmH5z;yK7E6vW9=S6+G7%>p%(DMicDM_tB;|m0UOBbu%H5K(i6Z+6 zF}q<#>g;LvQ^D;T`#U@r_DPn#eVK*o3!@U1Pa8@ehiFD_fBN*}6C-5kUZtr)*Sei@ zbwJ$<+hZ9rudFXjA+ltoldrTFPFPYsR;$Sl@|~3GxHUe9CWwAL+9GyxRt1G{4E~Hi z`s>;I)MFVZTRFx=k=Ug1SvUgGw6X)=sj@f8=!1<9K+CfCwPeH7wvPYImkEaKSUec!Hb}So>Ou)BWguO(BJu0Pc6oSt)DwRx*}}wV)Ff&uj%Wt3zC68 z)R`aQ=PGIV7#-u1AGuIWNK;lS`bai9SbFw69NXUmBl8R zxYH0z+PLjsTvK6X+A3IamDD=$4EyZothJ`uNYr#^BxtBK+S^53Cv@K z>_q#~HBc}>wZ*$Dhvr1BdIOqZh@;&3i?hu?19R>j&=>e`FV1e_w}lQA7sG~rhM@=z zL-`1{>K*D&9Pv_;0>$frf^C0-vqDfTHOdRz;-x^qZfU@=)t%j#{7`#%6bpa~kT~*# z4^}sd$^*S<$xe;)SPnAFGH_*7%V@k(itjO~TgbEw<^ za-KWxpN9B95BXm{0|Xei+}Z%2?r|qTTmG%JM7;TbdB^J5R;OBU$+$(of9;xVwzhlf z=yu`b41=Q)MYlc(%UzXJT5-d0KSao)}RNzzCp zPz`If2y366NaS3Vz3&W;e^4w$#qatyONSY!0nBgDLdBC>d!nHuQ^n!AMh!}9aT`2=%t^e_) z;Qtuq*)?8<6I=8T=+kDK1VdVa6=nE;_oJe&GXNJCevqK=|t1+M`pshG1CX$H^)!N?L!4o4s`QBanFKurT#a*z_r z10Wkwf7xO~fJeOuP#g8{ac|xlhb2x$8YKBWeWtgItU6(E`IN@$#aH2}4D=t66uuQq zKT!uXBQdqO0*Q83uVKKZ#r;}szCk9&7DbVJDXkhBJ$?ZSPud5swDHa5y?u4w+`#rN zrwrB=Sd$mOk)WFW4?rGLj+c+7$~n$gK=oq|Cy zuYlVmeP+6Wv(8d}LpMQ-E)x75lvq~BS05{e_wzi8)+&E;VB&P3)wx5j7;pe5<4omTeQ%CzRE(9f_Kz1$P5G(971!q za_=+JNj<#nsd{2fG>#Z3SN(W8(sx<$>9S8w# z7uq$<=2RbOD6Mh8-QRKI3z@WICk0t{gh(Xl=xRw6#l;q|yyT%5+dV-oI*h z4&rpfPx8;;#w6(hjEA2agPVT7mi@vq+)K?(S%>A15g)j`S^qDy+RrMTqjA&MV^`MDfmgL7oK35BS4Oh1Zrw`tLaaG;n2Uq~9N>ehm(z!-fwsBk#%jYjINSEnNrQ`J4rUq638`Fl^eC(?HRC8b(|pZycfy|&#@ z#>?1j4(Fh8UWT0KXgtgi)2K2Uo3DbJ<4@hXMEJ{z5F;uw37SjV@brBv`!{;g+2l6zzRh^gS=QV1e z(iW0$ji?`Py-z+I+ll#=W{9teXDfAg?SxzybS&9+(q6_%2QI)A?Y8bF()^kMym||U z78Vu5(hVhDEy-&P^Cp@{nqE8iS}4i#$?5h}e@WG>f_TgX=UdpvO_^Hd-x<5q`^o*N zW<&vsw!E9Ofr@&Hs$5v};fzE|0(hB-smsHSM}j{G#eLUm%P+~#|0EhVYrbq9vo7I%epj1m5Yc>#HDSZ%)Ff4cr1R=e76{Si|qC@V+H{QOw> zqx?Quv4+vNjzh2<0CCt^S5`^@66P&-IUegb6xS#IfHs^Bs))|0AAyFWL_sjD?3Kj9 z?KmfJJCUD#Hb{%TH-=CwsqQ;9wzTQ^m$A8=)ZisoXALQ;8kp#bB7;chr#G=*=@Is*K_M>FQX5;Q_BD}IX)#}-}K{0>t!%LeRpga7h8b9U>hJL}0&iR_))7uR8 z&ostnyq3Fayx4^9%f6h9fnCz{9@x}l8YdauitTcdeDWYj60hFFK+KrEY;^O>ZOIF& zY|$#7I$xd5yltXuactZY^J+vU15|vcynQ`(HT}5L^>c|p4_p*(a#Ty+khPSxm_|l;ZFA+CVx$xvv0Vh)xJsVHlEZo+rex%*kauL5P-{ z-MuAWJ)eyIPPqJBf|BQE_WrGKwyz2V(DpwR^@M@~XE;}D&;m%ik4qstZ`ktAkYzn7 z?1-XdeJvQMUKM}i$oK8K0Fqc@kLfn24dWvylw{Kjo!YH(ys?bcWNPbZ(P&_&*36f3nf#|XX zqsZ`%HeC_qb*2JRj%xi@cG9O5idC(_H4Ht;D^6^#_tNj3&W#axot%9+tk95(iP3Q( zOPn4HV&0`{d?9h*o;Ru>5D0}Gj^BSp-b7X&lK7yc)01t}UFja~H3T!&1PcCH0qkOV zCSmOlh?fD~cbr{CP3M9ur@n-8S7SO*FKvW{dCK(#oYjY%=AK@)vf_75G6EeRq!HJK zs3xSqID|hhKk^a7hBO&y>LWgt`8BAbd2oFsHj+!q;-r*AaJt6eh<#EjOG)aVroKSKsg$IR80?cMvVrQUO z{d`z{_m1Br;9fUKK--v3$ct!_Ul2)87O8_eqKNb@OFbPzd`LVLTRl;jcH^*ANnQVmJ}&%(Ia{7s@3shQXfF7kYm73yv{yjMzf@g zGeSuT;z%tj0EuDT){|rS-5t@<&Gl4S)_5UOEfxJO{al1f&`;SN7x8QDFhf%syNDJ? z=cStc=&_$SZuBT+#9##(iFuauCL9?X+;^XLO!6<$-zFd`}yoMNK|M(RU(1KKjU5wnuzCgtR9Z9)z#cp z8V`9>y&F7j>WTj$Q2|*!5TN{`IzhtT4i*B){bt>~vGK`CVnR9bvn{zc>1w9;P4V8# zClixEWd)7A)224`7yDIg!60Ib1gKG;YGTL;54fbhhJaKJsdZ0!9$T|Ny|p-9S({$) zx@$=Vdi4HfTB_%meyHcWJpgL&Q11T`BZiz~azo8w z0JCnw%Td+!4Q0KvkG~mLO|QWLt=05>{ z<7K^%`eDXAS*5(M`NO%+3LF#T^)T#ZD{f1uAHc6$0vj4=7JZTdX?4EPuUxgOo+WgZ zQZkEice>#CIY7?n56F0>CqV7~>t-fr3~Eskh&D_YK-k8)t7ies!N(fF1%8o^+LggP z{>T%8I9bNh2nR>=BQ_(yr}UNJ$Lx!ekwW#2K05t|<)V*&7sl|%Q%(}>yP;627(O#O;|oeTl zde^+w4XM}b@~^cvf0kCfN&D~mSpDaFjU6+}Yezh&2fI76rD%tGWTSK>NZqS2T%5b2csys>Ew*?CEt!P;T{4ptnX0{Hk?Xi35eaHrF{=YM2BcTL&8cIEsgz$ zvLr32?1EJ5)UPLYk{ri9eeDG-ZtogvJF3`>A3NR}$d=hJ0gkWC-X7k8kut5wM=_~z zGN2R9@oR9IiW(22QK*HnVD9V2#L{_?cYwH&AY46{T@N6X^nSg^!hE;?fV5H0MfJMJ zV`u%96Q&N+3|lkHIF_>2sj0bSrkGn(U4KbHTyV8~&}m79GVfB?`xlIUKB~Q-zc4R| zx2XKjmHhi|Wpxyhl{9;^XqNPmMy#WKc8PR#*BWQfYum{#VJTN6?flOlyFUGI{d5k{ zh&LH2H2JnEp~0Dv@X6_1ue8kx+fD>r)ogzHuXWB30?o_4&ptl5uj2NkfO)J_9#X~v zFZK?`Zj^C_<3)uU%3$}FwG42iFkzF5#^I8H{Rj4K1uH_SzDL*B&t1~)KI5Y*WBTh! zstwQcAqABO`*l?%mZZK&7Nme7L6*rSWj!^1H3w9fhgH9)u9{EozwHhd>}j<~_@Ekm zFR$|Jr%ApKm-y;U0|0Q=j@J&Mmw5=P4F)&kF=3;Vc)#(*Qio>986CkHir9*?NPi=Q z6b5Sz7kyBVO?mkBhhJDe-;*P)7u(3!4kM@ioJ_^?Mt_BQ{a3te#*7{h^67w{mLd6) z+SP5Vmo4@Ui$k4ZF4FI7Q_ja)O39x)K}|`2YW%E%H=XOe%|n=fy*#T5l6k%64+y{Q zQkjEwqZYCRO}+zGbLb2&KLJXJqMJo1v722HCxiU6Za|1C<`~NheO^zDFR}YIYW1Zy zPV>xz$5B6`exSGmqD*Zy+e{ilO@-P|=hSB*$M{rr5)LPDjwQ}Ui$$c6T-5X&Iv4aC z3n}Bt4jbd_sc{ORw*&~UChBE~d4VX!@P)DL7X9FYN~Up;NqaU2BT|QV2623aeU7U8 zs(<*wV1Nm1cgrE~4Lrt2RQ2=+ox2)8IaR)Oa5O1B-xWL$1ji>k_MgQ40o_O{88Jf5 zYWn;EIRY@<{=6dp1Dgx&h~GnPA?OZq6Ee6N9m~(ULIX#y!mIYfxtb1&hu$8wAU=6v zg9*OipCveUGw-9|ceks>YZB~Z^D9g+3qqyW&8*q9vUM0^1${1LUSSBdzhH1Q9tMi+ zy^z>(_##o^`iAi%$JC#D7O`nZYqb#W8N0gn8@qxcU8+`+^-$L66i&4j3@!VOy0!lq z=K|ypthCy5eLU0)&iwlE&${dAZ5rS zK=3u9aE(aK(-HO~aihnuHgtT}k$2$7eHq9PVaeLyV6>`O7~rvXd(F@~nq zo@Y0)&L^Af$6<%;DZ{FMd;Uxx5hd{r6Sc+rTk{TsiyT+RxV(Zb&x&)2V z!F5yzObeWmWDI>bHxHn?T|2HrCq zib2Wm)Zhogx+^Ypjk2p7h}GjmaEM>?9}pbzI|)y38`9zRL|#{pbfKm;2z~NDU+(a{ z2- zUp202tHXL7WiR!eCF$Qq$FoDiMHMxOrcT{TlZqR78a|AU*GH(*@T)6;>07pD3}_*; z4ZULwM>;ZC9j40ET+L)p0*L5JB-@)-+0E26jc-6%b?8B9aqMF|qwY`V9JBmcRJPS>ws1Gf|tki7NP6 zG(jn|)S{y2E}B76DWHg8=AZN_7uV{stRnYclr6XEc8R`iXskVMRurg5F!o z$XLem!{SW6M~_Kg=4!gK{h&71HpBR7?PE0Tt?$vY{Kq-n;kZG;sY!|50-WT0mL&Vw z?w94MLyWIe>WoCx3^*Ds*r=!+QQBxIlfa!)km&lT)+ndCJm$OYz`E<(sFbYE`MVq{ zNG_%%dq{$Z#h=SS-QCYe3e<;3xp1I8r5Lx1$rp2Nhh&+S$<=`E_)uSbZIt+Gt#H3_ z-+Nty0^7osHhx*b4#d`UO1pHjw3%v-OQ`BEjIv;|G`2DA`{)!;cAGz7lbJ}_Bsr=7 zMqOT;aFw5f&xlNgSOLbEYahc9>@^C6snI7<4`pz9D7T=Nn@r9u&KP^3V!56#IBs_0 zX6g;51QK5L{MpE=zh#4|`XI1Sm{Q`5?9z}M)RTp0Is#LPxo^RIXERy4N)-V=^R`$bo}N_3cyu{MSEg_!fqU0a&{F+HW4PX<-gHTtANFN%w`QbjgAG6 zpEYEipOP4>UG99hy|vPJl$Lxwy^gd&tKa#4Zk~eyVI+9 zj^exzXQ<)HW%HD+c^-$@;qaD8A zDj6J@%`@r8johQPRgNAyWyb~swx_55=kP8QV0SiSHJS!>?ywaqX-$;4>a1%4p(Qpp zFE->cb+xZtpNoawimSG>I%V}&GZ~wc6V0pvxQgoMpe2D7P-snD1!oa_8%NIYo+Kcg zwt?@2d%->&KB#5*TCJ$Wj~+qwuFM&CYExvRIh*GyQ}>QMagA|j527xmU%$r`^Y*Kn z5nRC@rl!TPz%vkGA}kyTwM4u$97W`yZw!GeasZaGh^LbeZYA-mAA`kj6m?_&I=-7} zcwD|H2d!F-D@D(3jE*-Hp&+PTwo~Ff_z>6w%&_vL3u{Y)i5A4bo4|7G}jJG<}} z6vso?x=G>Z{9+hsO@l1zK}2c)x(qr3uQ^}BdFU=$=PF@T)aBkTA-puEfY z&;QmKMI6skXyDyl08BEZG6PUhTuLqM;7Jsbi>=-~V4(^axBoB_nB?{w)u&y?B%#_H z3A(bjG)%%4h3D~Jd}N|@&#Tc~^~sSq=ZEK#rof8#OwMwNJqr}Ndeq?B&m}M^odpF@ z1Aps=7101Zs2j*1N3B=|FJ$5Oskj-#zyBimXF-)@jUw>sk6P`fUUZGwH+%b-U3ZhQn%Qari6tiy3(*4?ww!u9{UL zD(o(73TgU_9g{2hF83XFH#xhn1nW&_uCDr$Ri5OmDFL1LO4&9xVEey+yaa~bQ;E&q z6*dDxEBi_02AH36X#(MADp0T4qC+}PGx8z<%Dh3=TXLTDzmA`2|7qP*lC#-Zvk|e` z>iYfrtQ%VtkAk6vVSClD5?UKX43bG)2$B8VpJsCF1o9~bjRD>Ygr;eXfI(NTzXkVi zP?mJ$oXxu=fZ{rog_p12cx>LbX_BH(WD!g#^?->SwSxNlIr_)N+LitSlc?@VSjGF$ zZYakP+~|oOd3LZg(SRx+Z2plFe1`cil-se54*uKI*TzM-hpqx*_6<;^m9Qqx)MZ`Q z6C1@!?-%TPd2RDv=^{*$H`d`ZwXfZ#Eo-H|ioJF{!*{K4+ve9yfdA^R-1p7qma%_p zaVIs1@`ED##)*G7SGjBJ9J1s_z#A#v%F`tiC6zwLzQ*e*;@PB(5Hv6X{S?6l&+a5Gnm;^k)6l zoLvlDBoQQ=^^Ho8_ino2`4S^!?8(%h<_7I_~F} zRXK63p~aBOxj|`d_J;KJ7*f$j;<8rOC&MIJKE+)7TZ3O!Ze^1-y$)a$>f&Y$JBV+H z2V6p(Q1my{5JogKm5}pTV-LQHNy=|Mrej`=9z(fLS?I4^z89o;pPJMVzrDL#IzFlH zz1$9y5L)Y^|9UOKaJw-Zf7fUx@5Z%(lnr1Bk))tf#uC5H6SK?Ey|?8M(jcvBR& z557MnnWSF#EkiBo&;_7dgY2&fFNsTcSmWh_kF`93U@c_OealBKx5BK91S?CyPc@)T zP|e-n{(!OrAv=Hx8_!90&*t1~_%|6E6tj&;j zI=Lkg`o(4c_nT7yNq=ZJ${D{Z56L$=5jMDGjwv8YBws{x}Uy40B-g1p2PNxgFc7iOeS!;MP2>Qd2=5Qn z{G2A*`=Z|Tb-mU6=OlfkQr^LV0aiU{c42iU*}fTcbXBx6pd|+^&or9UO&?eu#T}+uosL zKI~JtqsBfBS$BFu)R+pE5tbXdsWQ#)1Kz9jKYu56M*J%fzxBTGuMou{@gWm9&G2TiK z8BW#q%APEFP<1%J(YyGG(=!j3XU69ad^pg42UV;(H$UsNvx#xZXSiIqx{ocF#~_|N zkmlLmMD1NCbQ$g+7wVtaO_{OM9x@t7^E9l_Y^(Q(D7NlW4RC=z8dX+Hx{A^*F!=E4 z*Tp-M$5It+J}2B_WPbHT31IpHO9=mqz4wl4s_phgu?q@FZ$hLgQdOEtiAWO>5RfiJ zMWlvE?}>sGsR9BDFGT4*Aiai;bmFw*-&^)~_u1#1G436A??2Yi z#adafjJA-Dk(D^b=Og?9So@vNA4)#Jmp**LCXd=Ca4$ZF_-zkE z_wESeHra2z_E;dgk}nKEB5;Fi3-bdQy+1G8-&RoqF0on#VV9*T>5>oG*yTx?RIu^RH0=cwIqwHa{Ro#)nJF$y)Vtc}*fM?ZM! z6>P>y%dkLKsB8d=6N&aRHg-rJoA#`$to2ftVtnmv5ZKneQbB;(?9%rXvX!Y zQ;$PibY!<1<>lhB>kcR91HuM%O-7G%qwY%$hMelQj*%xCTiXNd!eM1 z_{QGtXSHRuY4cn~nI6n)k77?UtHtx|Yq7lh;A8tuyv>9iAR+ zKyVs2*DcGt6Q+9CqOXoppHa0KP=!S@rD<--B#`nLG2m*~O;MQsQ__p_x^s0jm9hi_=cC zH@n9TigyHMpvPYs^=t^(W}uqfU(`?VXZCPKk+`IR{~~pIxBq9nD1HAGUU&sj}~9f zkrc@jv*H2LQk%|`v@{f6K&Yp-sn&baRF16>@Uq}JKokI8!ibE&oTGZ~iXz6$5CiB= z>In#uHV^Sb8+Zod_}(MMss;VOKk9C4JAy+|sn|QTRk}UjEPweZGO6rbnqn=F!lxV6 zFQjYT73bc}e7e2gC^qPhh~N_>8il?upHFHt#u%kcPTh+uylK|+dg$5vk;GU@t|z;Z zxi5r35^z`KUeGck>uxgM9(CviK!2NrNm}aVGr}trY|;+MR=ycQN9x~P(j}s!_{Yhh z=a&iIetJW_81}5}%<&I1H<6F48kuzjw4gLmI17K#5|``H*0Yd_R*fMzn;jqBkg|Y1 z3kjh;ijuWYX*;s;j?gbpbL?^!s2_$&N|D#ZNCviQHEy>rva4{H1^_YR!H1W1L|nIr ztAN7CsBE;t?s_=j?$UX9aMZKf$ag$BGkml;P@{Z~c4@hKYN>juKcs*)KR_JbU8 zJ)p`~Tc@FZ;T=oK3he@qkI&!Ay*3vsA1cd;d#m*C5SGYOZDF=Edg|%pR2oFv)htiy zw>|1A5TuM58Tc~+|CM)(FK19}lE}wo#OyipeFw-cGvGo6QGZe%{Z$_RI|8yl9Q=P1 z^gl)gG!7sl2~g+8|5t{sM$?i|>IB;`f1?0fe1KvMyW?8nQ=t-#j`P6@4SB(gX=llk z1@F&aaTY6~tdf_~la9J15MH&F6iKA>3fuyi5?_k|VBgJ(4IkDIlt7i4uSEA#=kSby zK+Kg%TN`$E0EXi%a-Y6BGug)!Q6SWK!Hr)lRr~&a?r)qK?}Cz(Am6-NqkLOiy^c^( zvMY)q7Ihr!^7tYduDBV_>SxA`%)SKZP=S1ZJk~$%Kt=SmOf>Tzm7>D}XK9|i- z$}p46;!Dkt33-;O>6M2qR6Y1!=QM=5!n%018&%J zwC`BB^IduLz{bz)6?p9l%n_(8s8$XJ<7Y0LDN7g_-8meW-EgklJm!nQO}p|U9@i!_ zT``K5QD{1M$8BxPe6P!2{5T2w1gITUP=r!Dv~GhT>{4wXk>=ec02$ia$X36!xLZ@Fe*A1R5B#a|?>n-F%D?mKvsF3mIWQ|hg6uA`H zdMrl%l8Wb8{L`X=WI+vv;x)z(lL<6CC;U+sDDo*i7VkhGl%ffKVpk#M=hos6p|lz8 zbFp-H-)zvE#`e4AtX znr}#Svg*q4iZ67u_7Ntkx3Y_8^1Y<68;{!4!_v0V)>9`&3(WEwLz(B&m~Q*nLIg%0@V>+Da=I5S{p z;5$zB(8D>^N!IbUn#whbkC=}F+C*}{-s=~Qa8(}`2u2M)^G44>qMUZYoZdOwF|8m% z6p4M&PSX82#V2aBxU##*L&)o-QS=mLPt7i?E0Vbh+!I4g!E?N?_rgg<$uVhtHTSk| zIg;o-E&K7C)#^zozb$8c|C0#ouCAMndsm**Z91>Dqsy));WxB_s$rzK9#tainp@$r zaaoJFtQpPY_8zri4PJe=F)nKpntA4a3yUWt-po~uS9Fn8fQmIKh$}+>=ki4wjBw5- zTrcUsj5MWcmz1yB10qo_Y{pVcmXyZdR*ZerT(rTCj*ltr#>sLsetSSZM49-1n4dxD}&>A?AA;F9B}e1OU2!QFfKBhuQ+B+uQ^F zM9hx1Oiktw%tD#(F}R*6d2?h^fM`JiEj*9~FtQ(6G>3RoB3dJS4UN;AK@5ymQI)8y zf4V`#JEmPKxbXxjg(%qio_LkIrbSq&MCSUK#F7HnRHK|R+S1%gZOm1%w!uV>{dy|Q%= zbc>YVszz8MvmE(Bn9WwVy&Z;uuCTwce>z6|Y!mF;?nQ6^)T|C%+B#9!;I9H;lIWh# z!rmd6;T-qeQEY2zrwNeIxuJ^lo8lX|2EQJQ$+{G=HSf0dKy|bI8}{dVlv)B+PE+fr z$n4b(m2q6z-x9As$;imF@en+HN#ndg^;IA!Tm@izJOX07m7%Rtm&gxD_QY##$+l7F zBB|{5#Z?U&%d0TZQ1N?etg z12KBXVSdrHRV~K~-Azkz^zm^!Q}}cVxpCo5bHcstxhs`$$e0w#%cK=?bPY|9ApBMV z_{e}9)7nNJAnQo!_k^l<3n;)zU({H2F2fv>veeg$?b|wVio21|CGIlUmw?D{F3<0C zUZ)g0H>`1k$F^jJIkZYCpd*)w@>-g{GSoU(aYy-eT64R)DCbcDoY}o>=5&}iBA)igbx6ocW=~LBICh8mSegv3_ucIB&%0OV|H4Sv$mp=I+WQ* zb{QF0##kU>ISCsZ6^JVxHrrM2nGIgKh~0rnF9=o;&ym?!nm8bQyE?E31az1Tgch^x zOCH~U+)SGm;Ai^2eWY7)Bbx?)CG$hGs(-^7_$Ppj{zeBGRNhenmim6H6+*ryfgp|A zhb<5z z?8w1O(Ry1=-fJMN-)N_N#&bdWy`k9w_nv08*OqK2tDEvRYS8_nk;4sAM0GMHpU zOlbw+$tQ^MttF{$20@+NGIw>O-1qe@Dy>H(Hsz-@uDY;WzpvIzx_GY(BnvMFAgFSU za`tF$#7ht@?=9?;xBg<*P+T3dvL#HYy0YTk1Hy*qG?PTLg07d1#+`leU&+8|!rOY^ zy^5gwo*^Z}Vi}{63X5ecN+_uc6#p$XH=Nbgk1m`PY#=I!!2;o`z7$-^x6GMZOEfwG zv60(6y-UvHq8bk8WO-l-Ia}bRRUneh_lt&3lLYn#*m{5?o7A+)vc5ww3$?alL((!yz$LUQk_6TQO%IXa1h-!!bw40-4c`N~8~QGl*cV zHz?_}nS5Z_I3iJTUDh5Y$p@A@!fjx%w@#}+J^xAMeE!+?gWg2MS@#H|GEI4t8yGVy zQy+uckI7WvoQefdU=!{pIU=vw2HZmb^2yb(xc^d&8o-az6W7@-m(`| zUZ9<7^>!cJyK=roKoW=Ci{@5+n|M2~JSON!Io5qUxEk3zH2lCOq4_Kur}c*uQ?nx0 zY5wI+oG5@!{xWzB>D5*cWY<6nP2kg`YJMdwI&66>X@Zz<8^~4YR1PnZ+&6xZdLEI^ z^gh@<6Lc-*r^XjVatwdus;u)LFKBO9jCBHY?05!|DuUq_P>){)jPW> z;vLiC5+mdw=IdKbNwG=>33|u3az`z-#V|OGMc4{wBk89bekSAQVvQjp1sW%BxL!29 zlCbt0F}$&nA)H>%w4ti5zOrsiFj_u=j^%{9jq$y14Y(7zIpp5lWs^||p$~f&y_^X_ z%qk+uF`8s)uV&QIbq*|v5eP*Kj{Kr2FiVZw_d}%iA@J7-1Jd!Rv15-4wBWoRlfOhv z+tHAoTahFB*^WSRfP`(#dXj;fs-WEC?-`<*na*L8a2tgbcLVa}l9cw9yo$|SXhz-L z@D=!rfH2FCBDNg^H!5irwAZJ+oTmE%-U7UJn&3zcS3jVh>H^ZjcmGDXvaO%f2UUPz z520t%GI9a0N7pxF1j|Qw4fL&4qUw~T%PA>j-b_*{(CknB+aLfLv*5)*>pg8wzjID7 zmu2`id+G9xChN7wj-d0X*+Fuh<$X&x{l*a|;Rf{RVl zI1Q@&KO&ccr{I*UDM6lF^IM0X0hzCc6ZWF}t*UO&!ng(oMM341ohJ9l%fPX=0{(wq z^fkski(7zFXX`~)cLo#zBoOu8d4)wSX#fXA3y=$c*~y^4EZ43Z;A*(F|6kCz=CpBo$)nW(Iv>y1Ynt;pfL1M(G!&`)@Cut<@uW zD8C2d@eBpOXaWGmuVantHC0Y>C<>W32x8v8UTil4MFb-mH;$<8&?BnH!8!6>q#BS_ zA8G_db^#yroI9d5Z&&Y#(*tt638uL9i9J!55BeN|@EfZ=Y9$~;<_QfO)AiqkB3CZI$#w~Rig-AMdP;he{zstv zfB64JxB%I5P?^HA$Jorr{~W6!`<+A|^AAxk>y zwj`5wIX-#9bRsHis%R!Px20^d_e=5K^VkpfMEx$^yApW*^ow$lNezz1T#nFSFqxggm1G4{;P%k9TV0ON zG8vUxf+}>kk`yaBbNO}IMp0`dF?7vUY}^GUbde=mNy+^#My%Ie4|Ci^6=<~ZGxL8u ztW-9Y-i4Demy*f6>RDy5-y}Q!F{?edcR@q#)z=D2nIgSUhLx2lX_`I?W7=ga^|s=B z#ktS;TfxzTMQ7T+Xvmj7_$lzg^o@qaunEPTynCiNckiLtfI9?}(ljGL%nAv9USMfC z?V!yuvH4d11bk`31fJ!K3@hvd4n zP<7j%r0iA$A{#aS;_)8653&_-#JVY^r3wIJQ` z-JVK@OK-<{Be?1zHPw*WMa`>n4%7s=@MAOnm=VBOD^M72X0$$&3d z>3Pwr{>p)sD4NCLuFmZ;c=n{K`KZLNz%MXtsL$oK@gi@d`ThJL2Gj1Jm{TkVwm)&eQ2M}70>8VV0t@_2Qh>S- z3xukUF~FFwK=N7Ib-5pTW&pM5ood~qE`R8QiI`qBF|$tPJjohTbw-P)-CjH8v+EYc zi&|8feLLDjX9r60q}DC_^W$JY-SAcKo#XXj?|oCV0pAvFeHyE~-wLJ=%JS&$=aDgw zkBMQE^s8@gbw63U#)=IAmq`q4oO?BnWrQnu510-Y?eRo$uN~{@B*bV{G+t0y4-cV(()w>}%gkuZGWeHI3o}B(byC_EKZ&4LC`)F!#ZX_9UYIy zw2R64I_Qu-a})V`!DFD!P8*OSXjo|J4;d?zAj8Y195s8BjR>jVCi((Se*=}Dl1j0M ziC4Eh_hhQxD`Jd-l)%~;gAh!L`dQ%iK0p1zUGS+HQp>=TuwJxt;-Cb^kyhYX<;Hik zUF7fe0EA*o4C_v@JfW1r1uXT50Z?U*wS9I7b0M^RLlPrXJ%O`>ZdkRmgQwm~I?cxk z+>43hiG(V#jc?S=4e)xe;YZ{V7b|q6?~z)wG&A#OvZe}fjzKnOBCxaq74|}^m-#c_ z3-ma}aNUfW=$U+I@On_z!_RJ-GPb!tG+;YAQCUeDd1CE1G11_mmD8J)Hnv>x@R)RN z9c?`a!9eDgLj37D+ISsRVV9;4&+gCZr;eSW>z_3AzV+aK!h>!38l&(1nl+?T`>Laj zLgWXd^$Iy;b5hsYJb)-KT6u>W5-3|iQqX#R2ZADiA2YchzGRp>1Wrdv(p2$wK~_@%xW6Wgzt;jgFmGj*P}x95yL;e0>wg=wV7 zinD}YL)O8>HdT%SQN4Tpx_L3iYpZw$GAu0#1mxF5?crH#NJjnR1`^|6TKs8y;j=>%LaIc9_DSloMH_Mp{-coir<(>?<{=;7e^ z;a(1QlUOr{#8-~m?=z0oLgb}|N;n&xF1@>hEjK3l5dpIbRF=~M^ify_(*n4A2;o)6 zoOE{0n6t-HZEcC;of*Tj@53A4;>14MT+4Q==B*e7pmR&a9Ke5NH*JlVz%~yst#K$z z4Tvi#GIoT=&ZjxaX-WUYD%8fv{_fi_eTCei`)LV z%bv9Gm0P{lrqhzjB+>4AAeSj=Bbdn1)OcdhT}Klag2v0mK*nStm-IY%fnF=@m?Ctn zmy;3ySq@RlL?i1EQO`>^UXav@L)ckM%!IewKAh-k$6@{|&pNNi$NL)b%rV4*$2#hs zeRpXqtL=5V$qh-fPo*6{t;S~>8hItiQ?=xpO0xTTKlv^{6v6^a@?WdMEHrFnkBuz} z6XS6Q;lREQZ&ARq`8)q8FJ+!~keZ`s^Ow&%f3b_nkLQlZRry|dW_{iVowqIf8`}vP z`vDWg6r5~TC|rqbe0MxrrjlqCH%x-Qh`!+G;<_L#mjB(qLoT}Re(i@ji4l`N>TQxs z`YJoKR7fKW*=or7k+5~V;h6P^pqba#i^fWlCrzGxfKJicYD}F>K)fKa5mP$m=9Zcj z3SjRVMH-P!a8P{nibI;at)V=~Q4j1>B_M%z>L22SZzXcg*=4P7Tr0v(_lP0prwW!( zA5~Beo8=3`h;Tv`uK(Ds9<^uNt_8*~dPmN)P;%UT_b6*79ei@6J)&ScnXE3JT0|j?-@SlRwfl=5VixSkEVC=n91K%9IReI1)fIbIa?cHs!uu0 zP3p&oSB_C+$WTOU5!Ku<+)dA~IBDo8?Rg%29DcI`0M39zq3%8&O42Ihg^CKft+um$ zR-Wjc*(#rk^Lv~T6PV5mPXnQgGsjn4UmC1M%$%U))Z6&rEd_qjSn1J$E;>?0$H>`*oAxqlzNP};2Gp~h4 zQQTvzejc=E`r2!fx~i)qMWJageKeD}=sy}rE7McElrNKXiU$g7YDPV}WF_<-NBcNC zpD8MBs7v;|iIFKf?fUMcnyni1-MrIp+8sVRxB`51e6tcsVowoU@l%%&Hl$zQHD5V= zcyy?260iWRQbbaDz@5qGTHgEX<(qropQAD(LaV5Xgz2K9qBc$K<6Ej%%Ij@ErTmsP z0&0kQws_}kzX}grmXfFFK?u4}Ol?HNa1?9vVVfTvNs>_+Gxe{F^Inh5YCFXB$@W-$ zQ;5AF_K3#FwCnq>63_k}lG_)1UrIvdTdAL9t(>mR>B*kF={{C=19sbr3X_i!x3ygT z>tGVzR?0@5>UiW^DmyWK4T3Q@m_lBfv@nOrBSodN%IXu>BMUDYXlzRt#wK_`3wcB{ z@3iP%?}U#JjXRGIXC=uUK|D8g8+rR&JGJYU(REO%p`oFDFRbMq>;wWo(?EnY*OsRV z4sSwX?oqnhoG3`^_|a+eHszSH6r9`QCSN2yclkQ$ z9n{Y4GAy-M1lLBsznk_}sc-l^`BVGIS?!SimGJiMraFy>&sC1BamW^>bGWm?E;-9` z@vXcIJu{Yi9)3!D)9dRrxB6TZ>W3OfjV^AsiHb&wzPYVONBw@+kSzYg{|>&VMz)5m zz*=cMex!C#dpZtt2eiE7!=ava|Kyg28&ATy9!?rJyhwj$25e#U@ED!n*kwQbTpy*& zV6YOvUT1EZjG<6>T|n%z0bo3$6@AtbPDf;n{t6UIDlbq#o>{Rko>Arf79*+Z6#%>Z z_1fE0IcW!04keS^aohP_NIWXcycbfgjKWK3ANztCNY?E~UcuC1Tl~a^b;YroaT*Y| zdszsBd0md1c`IJ_tvh_Somxci`+JVjOY~_{PJ8Q9J4LN52Z0Xkqv@}toF{`XhNIjk7Dv}#M&oEkB#ryEG7L%wB))vG=(%;h zrANqVt>Q-Oi@A*0VzuSO){{!9#J0%+ zW$U)0P>Qm6Eq^JmY`d!Qp&5&NeCwIUL)8z2#7|3F8s37sa=?ES8>?+^O&$XnaG(cJ ziTA64PHvNTike>O2&Wzo6o#8f_GtDvA50usI(Tn& ztaoeQK@0DZuRF5OUUa1?aAlxl>V*VS?>jLzNcY~WP zM^b$k&63(K$zy~MrLw{wSUEX2ck5ii!1e3+RcIpf29f3UjlAx9^dHda53Ofpb&}x% z8dj(f`(1;`aiaVuJ-6zuunm|!)SZ9F8#>?8ixe@((-*7obl|%g!U&ijL zJ2Baa+2nCrjxc|Vno*U&$-E99-=l#I!0|p{`io}kE95HBBeG}+a*0&sDt6*bl~Mm4 z;QIP&;5q<<-HL_qC;y_U?^!qmeR&Dl)IX#;DNizz_hP6=tpCG^6FI&N-suJ(&+G5s zMl5|q9DGOJ-aqxvAvFJB7M22Lp<)JL7OMZ#ETs9Lc;c7;KRvHVVhS>O33Lm*cMEZe zy6a*4&$%+nDvvmRabiJ}nyrTe%|sVcqCtlXAj-A~&9M`BXAFG2tiS&gu~djS_>u9? zRnq*YIsAt452iOXl=tYONF=v@_`N2X95eYGUjK z8_Eb`Eu9MZK9txC|81I1N%|N=F7+D)F_yL6VnBqOC+4r-bvN`5(ck&PPQ0ussEJJ0 zt$WaSZC?h0tp!5Fc?eQIO_ll+YDdKJ0ffXR1>`1c{`bZI+$31J9N+i9J*J3&Wy!^6 z+jFN($kdG?F0JzM)`z}+swltza66rxsc3QY>Vj}m4~DYz#|Z|Prc)^ZWEVjEw;MRj z>2~%eBFnBtD5?-$X)7${TQO1lNwBX#*p^nEywgDa2;Hvm|g2M`toFu24gbD1BH70AD6P$Z!W@7wP7Qq?<_QnS2c zK?F83uQesfu4GNm$A(os5i>S?{A9YF?hRVXGCrZZj`{{9W~)<w8XtEKbNiPNN_=KvrFf+G2w1%kJM5AJ7A?2Oxp96?)x`e4CuXoCq9lW?- z1-qovgDh%4%k69(@3y$@BawXd$yv@%g-G!d|K@{6VR(-lX&b+KXHs*t2<1-~zj$NB9jYJPFprmd$mA&DJ(Q>dh6_OiIunvKtB0L z08cQKMS|GadU;5WkuL)};E>65_U12|+y0`I&`mgtKlH~QFGz*J9+SRYHH4*iXrI?{ zaI}{Yia5S}{|Zx9+yMVaXo~IT@WIJPJ?01&#LHCGb~GdThI75rEQEJ0*<*BX6P4i| zw`#fzHE{Nx6GysC&;})8`B}l{dXpV!jgkYR%>5hwqn^ zW=8H81&K%+;u+WL@P1K@<`MU)?Qsfd&R;YzmF(;ak1vOnh>23OLhW4hrUP~Z!EEv* zsy||ZomMRT0QD!zLi}Nw^B28bSGN!f6;gdtiK#)mKyn1ATW=|ER&(En6y=U(kg2Pw z7nThTGVY%{HmBFv99_4Gu}kC6>OB9g;f!HVxcwuEbD#QSLmykbt)PU|`yN37n6+jr zmes;ONiIq`s$lKFM2=73(&S9bP~-7gb|x0rV0V&W+>jLV8J7aJ?vHEwC$0xsLLdjW zCtp$Kll}Xr8YEze=*5{d&%tu)lOKrZjF(oFr3uq*$=6!*;&o!QlRmsCDw@C=Ul7_C}~QxbSO<48vxQ0JXiUrnHz;aV<8l^t*vJ*fFp*dqtMTO%kagNnn;F7Fxs$-Je09$bSy%bBi zurHQ5u9O+Q3~$GM@5UeCS11k=-?$#3KS~+plAprzY+WK#`*UX8wU6f?X9Rm_7%|X9 zK95mZ1O3aTG3xEA1QJXwOo@}ocYJq7Ck+Tw`;E+%gzT?)>*C7%HvYPJ5+x?2V$SBoRn$*Y8_%~s=HbuUOChjGBI|$ySA<% z^aNdOjqW{^#=j)o6u)rL*cdr!x6`Yyzp8=igf3yb0Bp zsA#xvwozO!CESkv%us60S(TtXy|8Ype&dADd3I>%!VD2jX6b-x-y>c=q9tsG;?XQI zmn8EF@4a>Q2t#?W)>c+k$IgDx0)0%=e$T8HscgUgeQ<>P1mY z%U*j})aIsH#BYAQ|5{@iGH~^JWpAMx`+LIyVMl+sKXn`K=A$*JMfWnV1sXcD3unF09RQE zn$$M>b3iMGA10`ORQNcIKXE$Zpa(k+%Ggd4?aqUftrs>W+^OV!957T@yviB5k{iBpP6jzD1bj z3a|wjR|y9eZP0=Q#2kZlVt&!^W>9%-X9p;3=nydJ$xlEB!%%&H(Ex~#&_)hY0dc2Q z8AQwp8*WMC7;)Zr;7<7->%$cM3L_MM;F5GjLkJOjA>`Tp5AbvXn9PE1qFy5!t@|QF zsMkoZctEEd_^yY~9JeQn*_*e0&~kq62fic@vW}a^S3_<_Ub+9XHWo*|~ z>}(}=OT(QwoKkMELaKu|z|E1x5W*z*EMmEcd=ntoY=AcIR0iU~8&9sqcDSi1;4-k_APYllvZ0Hl|c$BV_ebNJB)JFH{ zHSdqet}%(pX4Rz8T90xMDR|>PEL_&6xe1-F`A9CwHB30P77e}Bs&J46M#17;-=MPF!5m)eAea4R@}{+KDyiaV)yk^`-nHzcn>3 z^Vv)1D}sLGt>6j4*@H0ZO)}Sz`?NgXGsT0*(pu(SA(>5tMiylAcrlWM!!EENugrW;h)GEaP8dR4qSy|*#g--%;Ej%;GWoauZtk^d zIk-uSh_z2YdPKW~te#`;@N=FFAjTUZaM8*J#O^KkK3&;iXva0Y@a22d zAWRN*Bw`40OaK<|X#tCw*mZD2D(qZnd|eB1{mE(#9#i9u#CjS z`s)3nfrH2*e|YE^uuKZaKLa#@Tn**91HpdaJ^%DQ;6I=4>iv_`BOKIMz!VaKkg;a; zizbz_uABh`*O4yAu}cU-Cx{-sY!U?69>rkN0+7@3r*q$HfA|`3g}^S73c&jH_ws+y z^i%gi`mKn8YRdN=G|4(91iLHN3|Mt0AhK)BU(Op?jt!&$?CVx5z=S~m{J^78#1g`f zF&Bqknu5>!V97T-TVY4PcOPmhh@sxm{L8u3`#;E{KZvpb2lNiQA#~(5c4rgp`oFwd z$`z19>`d$GZP?)fsD{rAh*`S;nU=xcV1nozz=-t!`UjKre@^WmKky%`{(SGUJoz|g zD%uOT)rw*u^ACGG*o7)%AC~XLuP=UXK3HsUYxj*r5Z-%7yl-^$DLn@4*0fU?vi|~|sVjM6KN|dSbg%03!mH}qYJ0=15G_d0u=SRb zCY8=(R)-JY&r>JyV$4zlQD!dG=N#oB*%99p$>rKt%3B%vn;_qtQ8dYW>m7Re0v>#P zzzA#rR0l7I*$=XH4q1G}*&|i^SWJtQCNVp5g%sphyuw_btkbMsF*1Ks+k-{dI_!Nb zlk~vJc&?vr%FJXFB2Y4SfQbjoGSP`bg;uPP)w3o^tp+0~r^Ohst=Dk!Aapn6eM#Oz zf1uHerv7^_gJG>WyXJmJ_R1{Ea9SB$!{MK``Cv45lYS&Vm6z4 zhOqfrcJu4=!k-h9#VgK|^!55`N@mHAX^uuwfBl9wdc!tuSPa@0$=UvV4#rL@xUYQr z+o->upBJ7dhuSm7ZsVolaz)PdQ(Ly5+I4Pmmqi)+og=+)>h)C!gTHldgc8JTv|R6$ zZsYaP?vY~2Mr_uMCiL`mu{w~_DXrXZC+A;baNS?FS!HiZuKzOi$IFQJ>ikp6b1K>Wg-e&A#6~Qvo^Ja z-7)jgUgkBp&Cyakd^qeVb&Cw%8Mg=g0#z$v}hBjTOUA&~aGff0q|TjgtKqch?FlTepT z%TRGPdEdNcRsKeo8-0Onb+T!O2udI)r8@t!;OVz-EZs(o5z&a*BG83KPBZfU386Q{4$MW|?@J{@1TF;)B}ZuV+Xc4+&cvhhNs@Dz_2#YmE$JIt#sJ z+S0Y1UYX)9#rw)nwG#zoFmE$sD>pr_UD%Hy1>=-h@RdP$sY|POExh&g3C?wy6Oae1 z`$-&b+ArbVakh?qGA_3tboNr8ymbq_KGsvRyP}a*;h=|Da2;Oij@xn64I%Wo7$nEY zML}#R_I2Yg2S%o~sdTVe=;g_XI(mnZ>E23$Psg<4iiNQC)1IB1%}tkooO`;;-PtA~*3MAc zbC(p|eLJHTkNhg9vtN`I zzWmyoO!BD&+DidxA`4w0UK`0Vr-{zY>S!UPD|YQ*pI ziio8}{NQLq9BhK9cOYCoNXYlW#Q=mLFkdg9*MaL>j}ctc0YKT=Ki{cIR`hCt?4BWl zD93=LjyCDAvK`-+`Nz*Gu_5bJ0u|fg1##JzK@#*4w3QjG$e%L;Egh=}FGg47?l2|? z(3hi0+SE6Vg1>0cKv;;_O=?1KXjC7Y%y+-Z9NV^ul_Srrn#@dQ+E8nJ7NE2 zzVzr6A!7dv;h-~5vPkATYJJNonJf81`C}`v>Ct` zW&Yinm;<|(n~9IDbaLxLOkXu{qpyNt5Rw_B$_s#B`RM{mp*qmEO|vPDJ04e&mUAvr zW`o{ezNq)d%(P|uerktBSf;kx;r(^Fd6vXtR0pUW9gTK^1tUvG6XS{J+5sbqtb<3h zLP&a@-X6zSp5aQF0mzD#SJYK~K-bQ! z^DXXQl{^I6wygy0@d8XIUNTi`0Wp-Em+d%qcVs+vV#a*BD`#NeA}hq^!=z3Hq~|qb z_pv39eRFHxvO4@BwHwX7S&oQ8mer@7qU4c%h(Jfm%Ld-c{3O78-*ywy`bAYZwmNwm zGhyQSVQiSCQf}eRd9>)aG{Jo(qSPC(4RQiB#}|c%#UQz4EKS-F961EFl??ChZk`QV z>g3(lTy2?U{%>1$PH*YC?&jyG0VtX4frF#N3EX=__G z;SyiBPU*~;)ZUE2=$IH+{BW;JSzG%gzFvs8-;})eL6em!SG<4yHQT+@ak?~Y-4kR4 z0l=-a=!ITdyC4;r@ng6x>RIIu6D4hjlifvbKxFZr#*gE=xy$2tbo5>fo4+fd#hOva z8o5S*@_sp;$(k)Nw&kOcm^{_FGQ9Vmh!E3zpaI6r%+w6#y0vI-$PMB5bU{^%M-l3z z34F|3G)ujqEujYw4yTH(D6>+M7l<68HX{`~DD?sdt=y*@wJ`BR>0Y_8gZ%lz=hE$0 z=QwM6UZR#@Hlj(}m>EysJ#$TL;OprskVgJ+PUR-~V0+lljQX2CBo0w}&{>B%PyGQd z^Y};QGzUg*e>jn`!z%&KPf|4=e=)KlV`@IIA#JJZP*A6JtT=Jd;w)^r=+BS{8nxz@_r?X*TQPB6!v+3-q!bSnpb?`=W1vz)Usl0XU9>sIo z(o$fWRsX@saFH+nCk_T4Jc68n3Ia;f$vp*B+)xwLa}?j--J*8?ekY7@kyEXRStMlp zIrubU{oW76?(`YoJs-xuLGkmEZEcl6>5t6k>a34X{C+?L5Y1ZkH;KvP_;YXljR^6$ zrFZoK9_gR80v<8>WaxcUV`SpE1m85xNwCy<{ZQkjd*;)7`l>U)l9CvmURrq?hlDI4hbpE5&56g8bly=XK7kCZm8u zh7nUKCc)g(f;~~rNVDQA|NaHhrSyj_MD!PpK?L8UGMo9o6J@`OaV@HWTSf^7>g?Q6z@}tV z_Q7m2QY7JX0A8KD4`{n3HH+Z##+nVkJS)N2!AC!6s4>FSsKxABJFh@*0!l|pq=ZO~bZH`l8cGPg1rkaKr1;y;yz^eY=bm$C?#%q|`jaO_Wes@ zaLc?8I|NPRCCv1WFZ1Jz;j@8&iD~M&OsMLa54bSK_yQ_#4r#z~dn-4B%Mc+n?riU7 zKw5|e(8mb1<1p67GzvmJ^1t3gU1B-;;4qU#%q*Pf;%1AGzD zs{OMGMrq<6Q$xBtv)~G6Imez`jEBs+3!n1En$ec_StMOQME3_&02Y>LEt#isEoaAb zex=IG5HRoTrdS%G!%O52iuuGU+k6H1;6!x=k%9Cty0*w^YOeGVYI($b#5|-@RE(pw z(rB;YcH21H{(e9O3xq}E-&A}g&MmLwop~B!Ocsx=QydSqndx<=_kAI^K{tY!@A#1}y|A65Cjczh|c(t5+oLVK%fd9@!}(TcZ=0#BrX zPr{5X1!X}%8aue=l0d^lOFjUgCiqCgz25{F74vWHGhw7 zr@!PGVH4DMJ6UhXXQhCA!`q7cOhe=2l=ONaPK6Y6y?0SXP@fm z_#6}bv`A3*3+a@RkOXH*?F3`CS+5FJTcxZRi>N)IO}`w3TWgmTD#F##02QJ5d!WV#AaO~VKL@0}75MR^+YBOFBxv`25S z^a7>U9AIMc_T0s{W;WUj-T>0Px{F|9p(<_}PEiQs>?^h@=y%M`$&(-M6}84%NkWfnVoUStRw=@>LJwf76uT^# z!M6+yGOu{L0#zNnBj5yAeBGmUC?s;g=#-%Dakj|7Z_|d0gS69FN&2o0G>ti$1|ZM= zs`WbLQ41o?kDYFujLij%9cEh7$$Nj;94-LsFF;FwiS7@DcXu}e0v4ev0YGH3fi(k2 zB7ro4*xT(NnIb^49kR1$0ZuspqTHibf~IL|j6zLDKmdrS(*Zi+t=iFA$Bphmf-3w& zbYIk8LDnRHeHfBwY-t^Hd9jey^bh)ruKb(d@#`pLm3=yg4Mub$37BjkB1bn)G4KGh z0l09XEzq0Sh6}hq?i4WL3y|QS1T8k9=jQ&kQ!>!nz^c2i2R_f94KV2m!trXq+=DS1 zy%uoh|Ng*E0YMYM4s4z=Wo*lk zv-QiqEpIHrMaBolu~PVU<>L{@n2$WZG%wQcP3cra6%fR&=B1WF{q`RWD`UKX@Coo1 zZ4v;1aB-!iUk@v_r+DhYtTaX90Coq&W-l-Cj4j_^BG->U#ftmG*jT%pc++#4T{CVS z*KFQwo-5ht9>(Cwp+#!>#uU!_isT6S@*SGj-T8{1F8)k;A2*AT1E0)pr;B!^F4u6V zc;3H9_a8uw*=(I&fG+Ly)8_;}z?g{qD0%@I$4pUOrFz{BH0Z0L^N;Hg_`b;c@LaY5 z`$+q7T1O_Bhd;k4YQi2;wHFmNN4n$79}NmEE{xMkF*H5jOdH6X>D`ykZy9Qy^qjMt zLtDz}Vc4-0xQXc+<{PgLe94sIyYm*(h#RiP;~K!n7OQ}zQ(^A}`mj^gf>r*aiFT;7 zjaOa*{8G(=m5Ptlccx3D+NNp9r2GItSb6jPB%}f+MsWrD>Oj_l+a%~(qk%5mr9Jk9 zu4YXum27y~HrvdU{+vpnpD)16?4f5m)Is{$j)rfu( zAl?tS3kSUq)dw6O^yqEX>nl&?z_zd66JuEU^tObp*)Xg=y+tWH8l&xSyUZvObB#~D z1sd4#BOU7>Mjf;=O;awc9&T`ZLR=og_>ro;fBQS3#h znv5`cBY&6Q%A~3Mt_Qv@`q{Z)_v2KEW1FKU5+6%PKCcOwnGk|*Ge4hG zIK8N2nas456>n))CK8n-%+-woHb6z-#&yj;as(^tE})<-vFSxJ$ki7ZR9i zMk)9R%?X~j{T7XN+SXZ^`;UItekb}3+yOBI&Q1Tz4+FV`F#G^R%Rh`^iT?RXKvw)k zx-MXW1#Qs*P#-CCQOS~?gMQ6O3m9Xkk;55OF8?afHi3su7TpH&l)qlg;PBUEJm@-l9MeB% z?_a%o|Gf8f#xd%WYV(ANlUm=(cXTALX=l(Du{g zte@ESK5lOt=6`GIxV$u9?8i99PQRf5EYeTmbl#IV-4L)Jz_UGj2gK5<4sI^y)9z?K$Oscr{d+t3KjXZ$ zIl%PR45t5B?%!+ba_b5&L24`H44EpAg~bNxn!qMi^m>!3pF<+GKWI zRU8hMJuf$o)ZkjY)@4R(1t`;8q;Wf%vw5};D(0Tc>G9nc$wP&Dx^AUKV{go!Z9 z3@g+7@&In{?dZQcoyj=!2?L)m#=-Gd(6l&6F4w)y9W9Yih$b# ztbp*o950m4J+ev@=K0PP3v7A6Hf?aBnakf6@pva5Gy}c_VE%vkZPM^xzwWd#8KzWb z_{m=*dM*78kZELX0dj&Wo>ah?ZU(HBWbm)w|Is%f#w7=&u1>l_=Wu0?SDOPe|9_YCja4VzZTE}V75ad(bnB8&3Ic%TLC4c zLAJfaIXCqfpO5o1#_>73m>7BDJAUu8b{xi;h`8Cgc=hwr(>EQjI+e{1M1iP$P$Ua&EoBY#LmAQ@Jog$0?0LLQ3--lMjAPQE^>*kN zcqE8e0_=ThdI8Eb`#sqil?aN_H+c62^cjXUyrCtK;iI+9PI||d5H^d(TipP#BRRB? ze^I&QW#68Wn+CT$l{fi+=2^}G0;UPGKN>HCw((9JSQ4}oX*~Ung@*)YXbjeWXQJ{+ zz&9ET20so)!*qZR0|~IIw{)b_FD`B_OEdk~RSW#bSoO~TUb61L^7B1sR~f1o01q07 zavwDDm-^-C9}Z+F=bbceV=N#pv3{}!0F-h7+$Q=0cuZ#Y!WK*KQz@m>-qhO^(}^OT zCX>y{g&n16mq9tN!x7Y@{zq@vS$)>OYaGh7`!;tI#gyDcf&b8DbIV_>;1K|l=Gaz) zZ!)Ju7}pBkr`Y(J<_RR}-Z@oTy8r9It~!I3ZUQ&HQUO9VgkUm>!fG;L;?Kxyw`xQPAI^V zG=8?H2%q3po2;navZg+MSb^U-c181D+j(Z;1QEl_$>x%K*W5H9?&jpuGN_Y`0V!+l zRBvM12RRd;S_QHRVWSnWmF(H~d$SETxjAARj1eywU#s58u9dZHG4Xk4>g!@OFWB6V zI=%9>{k`T9HoHK$BW{oP?3KEZ+1G8iwYqjl> zc24=$S&=7Un#G8hO2@rBrua*y;2<-~S-{f3hB;IzDDi)jlq}RP$}?N=DqTFdt_fAB z=qZe?YUJH+J!ma)SBY6K#mmh=!yF0dDVmQAT<|JSOJ>crP9Qiec@|Oyi_VQl<4qQQ zN%U+Q$C-g?2KJi5wPI6m7kXW*>&w*@p|Iocb>g;?66`TBzZlcUVh5GR5XWhNq{*&H zc6J9}B%l=|Nz?NjkhiwD6YHO$e{-7S!!4^ld~ZLjSevbQ=;6m%>4`F{>@-yh+||oP z7?se@s@6Psv5mu2Dc63>@DgLbV$!<0&*qg>aO<$4D~qKt;Tjc8yGvOjahg^U8MzZ^ zHis(Nn7uhc5@qkyKa7ozZIi}pi0a%MyN3=CmV>RM?jY+3)z`<0`gG@3RtImPO6%6N z2kN3E%~N_RGDma_F{Y1-{E+?zA=Tcdld9oUT7FIPwn;wZl+}Y4Iq4sor>p!Eyq=2& z-6?%K9A=+#{`Pjs+vj^2AlUU@B@u7g)+Sz7+(>z(*5QOfe!b?|^AEEKj|;D|6V$RwPcdkNuf_1R2F+rs5a0<1C$}w0XB(4ushY>CN1vK7U?a zW`g^;*&U&JHKKYxe#ikzyxFgiap!U}bMD5U@AAXQ~yBlQ>}aiu*jT zR7w4Xv)8k@L?cHHL%lgCz%Al@ExwYG9&UKiN{^`ztwr_*CVIw;CT8-nh3~XrgKPDk z1HGok4YD_rR2~*R3!bY3xM3_5Ddu?iQ(t#qv7;HI-v*Q;&|>DOI2T=wbAtK(s+5Y;t`mp{F23I8%0d^Mi$`sxI8tv8da1#QjpPoZ9N@NaI41uP ztUmD8%j7hiaI9Z}v&cb~e7Hog`CQsc@A=HQj##<4w0!TWRjn@gG6-?|1!P-IBEr*2XDbLI`? z{j*z}(vM^Pqkws4(^V*Mx{z#BG}ieli*)<*ehI6iA!@c*Rj!pnYWg!Ur?b*gnkF$g zCz<^v#HddUSrvZ%8et5xjs(&GNJ*L6JSH^SiL%{W)U zoJFl3L;5-E_IR3nXG&DtDnga%sGy7I;pG4}3R$2Tn$@@Ju2R;6gH)Nr)oXeLOFybx zhvp_po(;{o+XKci5q6c72Va$!BOr)#M#R>aNY8$cNRh#YD!rwu2;bHa8S!%qkB(e& z$}3tano9Oo?UieYs{H)*Hp@$TF4`8(NpqycO>RqnDtw3Rhp{{542@Z6AHzD$%g9zA zTl=u`N_COz@{0%DU-ulXsDxuB@u(&pET&QELJcH@H!<*s*iy*OR>;PZIOHD2rfy($ z^Em!sj3TnLMC}pU?u0|?iB!z=-4}217c}IM>9uR+If+HR;S057`zqJ)!uN9a<01?# z6||;oKiS;VuC|-1N#PjOz(`J$#Gfzhv;s=&#&+Jy^kip=UAq#Nx>}l5crL!Z#2hkl z^5l=|V1h7SGAeP4?92MKgg-M!g}b>qxa2)#KC$3%^$WNCl9s^+puq1 zL~t@X(nNaeB)d)_o^L>SU`k3%gGBw79iy9Rj)cOh}n=lx#TH7Lr)!;m1=|f?Cly|b!k^MSezNU z*dS)lq{wl%3U!}h@VXcML33cMN7}|~c@o#0&2YTtzp@ozniK6&JoQ-uas$9W`GhQ) zDFSe1cECH|jb4>omwD3(4*jhLe2w34VN<`0$6{v%rqFL`NTtYrXe?FT3M=i_Ur>?t{#nCYq=7-zP%@`P5 zN{!k@&GM94?36pqI|(SLC{YYsd{ZnOc~v628a;eY8-SCzb_J@K0w|ihL@@o(52!{i z1uzp2zn_5b@Bna&y*k8q2Vd)>DK_jtg6A7L8-NXnzyY{OJ3o*Kdk_Bsl(-Kh2buE! z7v4p;{bP&ykVsye?G+|NHzGBiU9~ZjXT;Cm$=W-=Gzs z%gQtld4$Ov474se!^?}x{lTU^HK3C_N|ipYyft@?M-|(B)?_u9^+(N5 zGPy!-GQL9i0JKX+-O+_QabTlYZdKaL=y5Ql@-*)ll5G)AGeC`mk(|=E5iiNkCxyAS zS8~t$-CpL{f{39Q=r1ew8DZD|I|IporkVe5y8G{>nOT7F7tsi}%^c8$CR-?o0t-(! zBn?e8kbDVd4LBRn2RiCO5N)hV4^&csT_9P!)$002V$0132>-VIWy%wUCxmgtH0jt<;hb>({=_Kz^k@DI&h+X2051NkF{wkVj zPxGT!&Jp(x67Zy1oro@y5aYBu-kxv5$v#*2A~L_%M$Q(qjGL#d({Nw{UeDir2Sa{KHX5>Y-Rjo>o&zSiWFW8|H&KR(8QEO00Z z?mlkJ_dNcTlsZ@oc9r6n2@@jj3&+FRhFWv%l}?p}Xk&^51dGa#p1%F`qUXA?S3rzSZ=;fzL~LUrj#-x#+ABobn3pl6l~WC=hl{2#>hU;SkPa_oO2$`iw%c4LRz*j4NpgsO_nd1!CE*opfe!8ksg-P$Hn`Hjws^WXsx&D0CPxIq{ZXe#6mu>QI;iq)Ua#{N|F4izB0QAIMjqB#K%rw9fDk~F1r-;vd89kVB#yeyZ)IhM+IpUP4B*^F-Tv?VL)4W#} z+-O``dXKM}p6S5lDqb`+UY}uq`tfrqVoRq%ZANmh$cS{^+^Wz_-PnnPW;=C}^d(iG znsDb`M%V?e{|@7m`{$YKvHA1S@6O}hYR%}t8hGc3TRN2T%5ih~{{N6Ld}bKTVeaK+{b)m&j=K<5f7ct9Fe0q6=f zy)te1;wC(j$^M=(VCu&&z&AKP0+EFm{{qnbrA2=>;m5fA*$e;f zUU+g060pjs1NP;fBEXmVb#i?!rEbADx4?`@N2aL&;Xko#|B9Ob70aeyqx_xev}pIv zB(A-1>}QnQ&u5-q(>Pyzi2Rh2n@5xURt{edKkApaR8=T%wztRpjNRxH{p?VqSJ~I4 z-gU62L~t_rR==^4!?xFTfC6>rf-!RyGW3v9MIzoQGGK0o>O0!T+EnsLEqFR(-~Oz~ zuXk5;O^Yl-rqB^98(jy_xZw|J(oKO3Tk48Sp`GUa$b0)M^r@>(~6es zJh&UBJd@fHmFhI;nC$fAA;$0rROa`%3V&}S{JWnUp0U|l0rLGTa5^AEF!<9^->w$g zU!xynrv6q*!tde&{sHx_e+KO4?>+NZSk6x_tMTvpvYzppP5gYA8q;ibs}DoQj-I-& zEXG&%CJWbpY5#b7;;FA^0dfLOyc_=dBgJ)sFI0QTl9GhKPKcNaC~@W`4JLYkqO-54 zrDXwF4Czb|?VyI-w#DSzw+>&OmRocN+Nxm$tDzzWXkIq7LY(t$|h1uWFdCoD!YIVRKt7 z&J#g|V43K>_90CH!o3Wx#Zs)1n39hW()Ar$DItgs=N)Cv^#;Wyk=}({m4Jb>YdR-a!~&mGCsSupV3|3#U&DJ z_Q*WH_GyQ+#XeuQy{3rc^faZ*-qlm6<(>k^ zacb9I9BXBMnz=20ZsyvzJ0q}0Qu;Dx>N`^eu=0j`Uv92~htc@*y(@5Jc-i3QDM*uv z3i&;GL$e^%>REJmq3aZ|Szh_lR)`hE> zC&63Dn(a(h^0MEmH?kmFDFu;opca-&2 zeeVEu@PC9+sWMkucwd8j&1K+cEXdBukzvSmyS;quy#DKi@|ENbx;(^bOmz6o#N5eS z4qw^Tm+4SwT4Kdg@gieMCBT;gAu}lH6W|wUHrQ1=0ZL}GiD9ESUo*D0ohD0?3{7vA zvJh(+@3O^=LqBR54BQYJYkQ**8)Ec0DsvD9r8;<1Rq5F^0>qYXO=5HLdy+-(peeCy zCHLqv+BKV#0k)Y=`Np-qIx^!!xMhaw=b3D_mlaQHQe_;j=)0pFkV{UCn7B2KRS%!s zdm67DYbCiQZvixa?w;dhlYG-ftmqt+BCHcpV-8;S+!>6nQ2~X^Xgb?jSb0Hh6r_%y z?kj$!R$&@CRx43q!M%M<37Ke+s2Omfyl%c@Wdp5xECq4phJP-! z+KYmywZM*SsD^FlHsX-N5s(&#iT&lPtR|EUF!#bhMHuPMH%)y0BL;Ts8FMzR=OmA3 zduKh2(jOLoja{629&og;*I1GOEb(fH0hE0aLjkw6Y%P~G5;0A_5Zc)V4t1d#lu2{1 z|MN|o+hHJ~hr?neACiJiQV~ijKymRVl`!2Ghm7*>tGP;-9WfaA&Lp~pOhqc8GwSZp zKZ2cbVc-KwXK1=8qI|9x{`RLfS(ZIGgce?CV6^`6kiimoVsGtFDCe) zrvpk(aKHZX*eLIdtT;{2#IBBb$rKFA(7J!4fLc(w96z!)6Olfe%{Nk)ScV$vGi=qN zI>7YmNG_qo#UUCvq!msqMJRz5tCp)|Mw9P^fQ!M6gWO{%92eI)N*whekyXj z*D@(-(%Nfz#v3uK4oH$nGhiKJ^*Lde)_vr zuq`@LkAk}OO+hiwJFx-1mu7`n7_5rMzG)#3np{3)dwcda_Qdf_CB061@1vMqkH?`@ zH<$qhIf)Lg15+#~wKVZ>*Xo6zBON51Yh?V$qP1ZCL6dfKsmZa`b*W$!L<(~0n74I; z0JF+gfqVAydtK2fG+qwWyQ(Ei=*l|Nr5CduAObF&Of1?kM9rIXudyZ))TY>j3|+Od z7vSuLN}LpMt1qM>?wyf6#>7!5JGQsUV&n^oU#0x$=-6q^%Pw~Oc+{7G+ZhAp~sl8yXsr9_lF$TGCm>0iZRq&nARW?y~|PQ zB0S^(KAp>P{2Z}%1Hf>My(K3m3qV8{ch71j-E+>NGKVbBa(oNr*;*r9UDFA}q0r3` zAj`f>>HGo~8Y=Cqv`hm-caeR1f)FbYlebMS738AnuM8s)@1kp2n`Nvh-O^iq8JV5jd*%W}7PfZ2p04L#^aO`ONZh)2I29oHH zYGOa>opJ+MGzGonotLpbZ@dFcw^wq@sP=;Ui-e-iTcrskak_oEpMcH`0A44ax-*pU zdW(ZS(T)C~=ENObs5>j%sJ0gYEuZl}-EwSkpiAO?9A}7GqfqM#t&uvcfEaH`_LT%D z8)y}bsB{8wd|gJTjrdixg_AQb0pgX69(-*WMq{JruEOl7M^#ARrm04(cBWMpZgerq zHUX!hUYO>co#@KZ#&!4`Pm7SdL5sC$!uFmiFd=YiH8TAWO&{-n&)whc?l+m}kR5Wg zH;l88a!NR1wJD!xcp4yZOrFU!EWatCf6wUl&`pE#tayzNZ)FC+?y1FS9!$mZW3zAi z@?Z+6KvTpEqG99NRq#A{oCuf42EyuWiUNQ_5z$-z}3=kXl| zEbl$`-1-UeXAd4uZK-u~RpzynV%5=A+TciZXORBYE5%XZZD}jXdQH7mtmu@^%XE}Z z6ZDyv#U)~5C>(!cP{G)8@)XbQUKs>CMbxOeJWO15z%O>);n*OLp|OJA?oRXU}{9? ztuUPs35g9wr~2gdu#I;()*AIpQ;N+*g`8}~mT&wJl|QSr#WTq{Vh;>{_DktLZ6Is` zDfen&HJwDiDA#%jL{zGV9F-13L5pj{-k#gJQG?x~`%-|)RaS{MogKZ$cOKAF<{H=> zFO%JRidHe|=z6`BUaEuVH=VKd0jzI*fP||CoqDeOLmnb%6HGaeYL;Y%9Sdx!YEEpV zQsE$&$N&J|(f-=fJ}djpqUDh3i;}w6W4BT5r17T1#BgXbPm}fSgZ@Fp=Mauj8u;TU zk~293USyvC$*Wg-`%%$DwQHFXf@OC)zhqsAd(3v@K}_IBCy^)Nj^=V}4oIkJ?o7^3 zL8YkbEV~ z|LrjEzeEuKD6*(XGQ{hI)XC8l`xQhdYejG--(=p@q!g%^?qO0E6}@mcRzRfc_6vFW z0#VWP0&3KUQ;cVZ0MY&E4+dgFc=XO*2tX707$AF=8+9mOiI(a?TS9|<)q)k2vpce! zVhQ z45%pOjH3QGCrPum4q0iF z_~~SyQ%T_p#hq?#Md`l`7PvwJJkJdW@~D8_*ea4$Sy_pk#eJpXYTI7i=dxnu@?6_k z_GaV*+4*^jR-rfFE#fp*EfifU%_^&PZ2WwUO_7Sw*SCaEL*^QZ4>db(#2y=;$qMBT z6A_6;Vjuxu;OsIy{rp9oX6)-`cFJt6E_d&b(O1MdKiDeWr8jV`?Owy)5kt77gWVDz*I(j()e(qFEu-%y(w!$;f&(n!_I;y*0LcvX7R&Pm7A`%hg0Y7v~vXLP% zC}WQ_+LWuHs>Pj}h^F%PSRtD{4WdQPe0p@d&Pb9h{722p%&MdnQA~+i*_he*a(y9C z(C|1g@4hqTRt7o|K@GAH9_JcA{t)}Ri{;jUhGE3B|n$)~@08lqp7ZO4#)?6y{iQVlg zu(HAa2ZMUPx`&LOTw#z${Ks=VO??9ncC4ri4U3-4jY8X|Gt)F{Nd7IT40;8G-~K2C zVh*j)0gaST%k6#8aOFUt2e_MmkUlrQZO8?4pbEegDSM9db+Tt)o<&eBLGa2&&^Rh?E%MUh7`_qv>{GUApMW+Z5c+2rY56THpl{z8nY) z=qqn?cRCwfu70Pv`=$FxL6Pp-%JQO|?7FFrhpVeJLc9;b+LUL4&$=Qy##MNM$_u-u z6QMqZSa!aF{DR!qKlyC4W2^T8pz^Kd$DeE~tL}a;{c_>%o8}{)vw}P9e>8~ZW11g& zeBcJRhK1TI;6!*AeR-BCl^;T#@gnz{q!k`?1iM;r`LPy8z;!SaeyB*Y`b1E=@2fAWMq zJv8UE0!gTr{DZ-}u-*}`x+7kLtV@^03#%{R`Sl37njD{azj<#CORFtZyNHVvw)Xr>fz){2vvf@)97h&7*+a>_9lQI zz(=4%1_>xu@}Yt^fSrCP=|J2Q3p3VImwU6;O!~Kh$mTDr!+FLKK%@T-K(o`gSO8w~ ze66A?4j^ik+`q7PB~p&8PVvcFz-nb#oP3F$PfjQ(7;Y5rTg&p2PpXvrTK_hLBc(bb zbH=cXty_X*{03RM4cbr z6?!iuR@28%PSzigCH&oeM{@P5haW?94Z7-IpS86LPhEwZX3_7>`68ChiR&gr^84J; zh2+iK^xGB1HF=F9b;J?Q<*CEbojhj5@JZ27R9~=$kdK|W#y{u!qU7xId3bwoEb!qz&=u+N|W%#d~ z&0pdAl(rM;AJSAbE*oYz>Q#%w^! zQSPpzoB>M7CLy3rjHCH%Eg*BQ(Y8l*V!iq-Qt2>_jX3xjbU-tM^6=}*_`vLnDK#JA z!I!E*W=!fOCQmNTstczn2k~Xcyu7c%ERx5E{-aU7-+UgISd6#Xf&-hl+*VnKI~W)g zNXTZY0U5-;$dPK$K-Huwj-&I&h8Gf0S$uhq#IsZ1V|vY)8hXy+?;mE`>%|KYX&v@< zYTgN`waM|3FOGkY2qxH3ZxzirEH0f6ad?7axHLELX5Y?tR~=4ZSnJ0R#Xnk9C{<> z-VvBo_{b{O(_Crn>u9s>8J)4#))fr2)Y!N+ceojPa5;?mXvTEvhkZE!Z2%MI59~2N(!zhV{=fK_%!*;6^S{chj-o{E<3VMeGkI7+QN#e>n#Q6r9c`#-hh5E zdjkWM+)tMzSbGEd(=lx?pYJZ#Ud1o&7m#*x2ZGJx%e=;@9=R>iw0I{k?#)8C`mKz=eE*^u2$aqU?{LLH}`x&!5z0**_!F{t&D7fU-UbMA_RF zg*H2IB@)#iOy?_v+hTQ;Ry;+y;Ac~-UxF`Nsyz|)t+N6OmGU(0*c-qhMR`kdz%t z6eNKtw&HzO6~+{6YY^BjRjM|F#0>-aLKea$H=^iG5;&3}q?|hnlOqMqzGq9BtTj}t zs;w*;C|@$QtxUf9u-d^gGRaG$L09v@0o-Y4nfWTYwfkeL=?=yw*n&+K!Q3xEpvPZ% zJ)la)DRaXmj21?JkA8&Xas-tQzCfHK*`l3DhqNfdx!x6xcRx|W;rL-0&F!<5v6|th zL>h1|NO`{dPOq!uz647}eiXd}!P1Ib8z_BRDd!+iU9# z6JN60ygv7K2YwZ6OKk=b@1YN$ODtYA5SMEz(re_MP4Xb|-RqNRE;I?qIukb6*sy7bR|*^HB1rfPV3=-uo&EDT1WsOdHrqZH$@iZG7rygY$ zpJFcGu+pJhF(|&eX(a6tr}-&t#xl(+Xk2+>SKn6syioR#an$ezjp#pDhy1l6Gh*TEFLq-iF1|CFM!}= zI*(bRZ05c&CtMS_uYcFIhJ2=|vIeoWv?WpJWy)NxJ?=?YV&H@;7Z}nMOpZ5SQ}2S| z-O<`kdE@@@?N`d|ug@8|&T5@K@7$?G+H-3CsTC34iaShcwdmXUw0X$yl#XUyT78kE z#Mvmn!2KOhKf2r$!9NChjI9mXR3Syb%ZE)dPB>AyMS4r&WwPD@eX?HEuPdL+df8N)n zHHMf5(p5#^HFH?IgT*+U3f-RfEur8ikeC1&{)3@3MQ8YHkZt0-VwesSe_+}1nQs5m>%yS4d93Yp5xQaSDzFEHQcztFXXlw zt1MGf$II#;9NO4kdE%fMtPFP9AYm0*BXeC8}2T88$Kaot4_}u{M9} zv%EO+#aEz?@S*kF+rc=1WTG|F1MyU@O0m)Y6^_!|K&Be|p=Bfl`Xr1^WcY3ze3>qK znB!oC9?g&{LrH-1j4jHWVULu5O3}1>c9umXm!PwkprIWmN>10R++(CKTXJ~9@bqp17b>!`2jTDY7O%kCg*7QzS6Sr$p z8u#3a(owS2PXs`r8O;%X6azFlCTk9EN`@wfyezcswF#S?)RCy)yw;`2 ze^o5=X=3b{@^k)6uTQW=+z?g9>43j>teS*Cmon(?+n}4xBHbKS7u_G9FxFPy^DR)j zFnzbTjRMa^k?8G6%Uc*{fr>*1;NqTn$IX|!QBiW2uC$&*<^zk>~N*Y7RJ;uW1Bk*Gm^A}mD9AboyqC`pf!Be-vh6MO~*$^ z(NwIm?BPdiSPB=hX-RaXosAU&Yi4FX2Ss_Fp&EB;A5X+(MdodlSpjmTGzL zzAhe5BhV^ek0YF~>duc>7=F_=i??F=Pz@yQ55I*?60moosR0XR=V{vFEou)~P@Yy=LxXvzoU(9DttjbFWRy8b3}ilUb!`NGJ$RM(>^XWr>zf^-{-ditev5 zKaBM=a@0DH>JwYZ31+Emd+tuXc7v-+kVB+Eq79Tu38Z?$&JkG}0h(DXg*5kKvxk_| z;)ml{z^bC`Jm5KRP|;^^*YwQXS&8Ho%$8GMo8~31at3?_V3|r+V9@Z%w9E-=^x-z2 zNyLGAC;ZZwM!UJPRpj zOD{E{AbHF)mjz_nR+rA*zoG7qpJEA*u>H>DwPL>0?g)9JX-ZQl#*Wd2NSx#i;=Vwl z<5H6aAIb2kf=Y20zO6PK(p<6#e)dsRB}gnfxqk`PettQV!=?^j`Q^no&m&H zV~*@c8J(abPz5hi;*AizT{=&*&dVx(wAB<(zck4yd)R@T4Bol5Fy~*WezF1uvAdn| z#HP*d;Ki6)ZeG}0G$j`B$0y>`aEB6h6an^ON3Cx!2zEt`d;Z{NByw|zdPtWtGf@k= zX|BE0%s7t1q>-nzO!H-oIC!d197%-6M6AtA)34^2D;1KY_O-O8)1-kgTo4RIiKZ%2 zlqVn6DH0LE3X)S#&SHcHk=3H-{L;KkIOmRcHN-#YDJa{W+go$F0SpwvHPOMXb!^1) zai+Qu6{1~>xl^kYC3VwTVPPjY1t#Ma-WF;nXYoY#J;&|Xn@=A-ESx&APG=#jQCcUU zL6C#fI_xklWGylAX)$fr2L}tz8X^o;3Qp(T#v_B$Mu*JBtX$OvKJnk@n|KrhVzxWC z>dZf;)GAw7>d0pfwX=;@Es}Riz8H^%!_ns#Ft@W6msgz%a{NQ7CXAuF!}J)X6HdH! zXoUB}Qvs};cL4!r_C?-NUjMmJ{@#7@?a-HeM)@wwlt=pT9Uv6Z8i&%Xo!w(I@a3c z*-GUQdetZxmtbu_X&j%qE_k2s_48d{IE4u}h`o@&)=6HPGV!waE^W-DCBh{2BuK8U z6-(b5!t!?x#I;JX5ZD9RHo(U!#4kaO}36v-CCxr{MXP1jG+a-wAMctWt( zmQ^NOdCTFBEnRP&AHSJV;$?J!xM{oI&yS1t(?loPxfj!TD9AiYuQ|t*K`+E;u+U}0 zM=awLTdb+Wk`GrRA3$b#v(BtRYA7h}@tViOY_Qi@ID8TonT5inB7|A|aU!XBCH++i z2gz8yGN`keA!A=r>Fkb0Be|5=)f$03s)U-ThBMc{cQEOS24KE;(Nb?2cGReuGRMn6 zm)k?lJn@&V2|I+HGm$OQ1YtYyw)w<_rPcu)2Lm+f&Cvoa8>K`^{(tRVXIN9&x(-E9 z5fDL;BA@}K1r!A=nAm7$5LAi*Aruv<8Rp_j_M1186u(c1$zaQEVY1|JXL( z*9f(nNHG8i9)fnFxKs^Fc7UmBNv>+@6m{~IlvA2#&PTvnlo4)eR=h5&*2(>n_Jn&%OL%Te=PsAb+_p0_ zoQ!By@&>3H!faK>-{pwnva}gL=$15C>%w4qS08Po4+aOU?94$P0r3Cw-2*gn${4xT z2Cojd`NHCb@Z$(l?2#>mP$PKtT8?Pw6^$1mVjN6I1cO^TqB^-EU8`4(CHuzQh0==a zp+WGxrgYj2;H_`^(?liTz4Nbn_W*lR{=kkME8)_Oh-R*t7t6fS(=mukg)NRI85D3IW z{H)fN4bZ1GD&PJ&hx*fc)o5T~w`~!?acqE?Qh?l)w@jz~-T)rE6_I`m2@t9|Zh&Y; zBIH0rfH?(-KGHbifIWjJ>|3Q_bgp#F`$-HCI|QPO6h} zo@s)ELyV@{}wefcGaY=iRW3}xfjekj)3>#KmP__ z+QRZg#d0^wTX}aP`UJW3p6?S&183iaNo`0jHZG-4JU8?4xdU0XJ3y&V07+g(eEJ{Q z#Gj}qcq8yHX}Z7S=ls`vCh3sB=WP=|??@(p%*`@UeN+)`L{)^9lBPp2M~?zAzTLTg`+Sj*>PPV7O@->Jt z4aS(du#Z$K_PHlizEaJ9)U4E?%AYSOBEQYAzhFI_cES~#Y&~n`_7uBnSf7aH_0SpI zgs37Gmv6eD<7T?`P7S95N^AYG4Fn$ueLYj&NW~=PjFon#%?&UEY!}LS2 zPS;FZWsy@&1T(pw0c-8nF7s@SbdCAB>Zq=1c+)vzP7}^YnV*!dxm_{Mg=D1Irx^y( zn^9q@gH&h7v{YOcksF6eHgYI>Rcj=Uc9sJ9UJEo-^H1puDJhsrI_HqJG0m+t6WAY! zv9wt-^yl0>P;cSfT;=_$Wp>eEPl=sQzx{dWh>4KH0{|~EUlF@AcIqg!1J*NN_L4gz zues7i)aQCgtypV<>CX1uuL`d-oZ;4o@_D||D`O^~4@@$$I_5*_nat^#;!VK3gPeok z6}G&3TE40H$BXArXR&6UN~SmTa(Dp=4V;q(*PlM0%%NJ5-2EZvw!fTwXW@`596igq8+%b<)WD6VoqNq zk8RoBeyioll&M>~%Rcsb`Pj(DU15qhI#on#=Dc^Bw&Zk)>hDpS@qL24firhYcMYQR zWCd$xAL>7A_(Prs7AY%q_SnOd2AZ?EpnmB>GNE!Bw#79P*#Q|XbPwk0S97q>mVcTnV>PXxT?#5{)kfhlCMl5zfC+l`yS^O__k%O-ANfCDni*6wo5#E zN)YL}JUtGj?5=zo1Cmq(+V=?AjwqL)$q;ISnHj5y^LLMb5NM#2!VU#Mj{KdD?lM zH(6Ek1x0PrEZNu+S|b%yJVa6|Wn=mu%d8@1J8Hvw>>E8!+;UnNSTV4=Nz8-Q67LIh zQ0A*L)heN)rOl48JM=Btlz>&I(wM+1W7#N6oUtJs8>@&tf*mY>hUa8M70Mv)Zo*|` zrmSfesk1Qq?PBUvSR~fQbz^j>10?sgm!w%RJcrWdYeR!jSi0z3oj_87_r024#8urK z=OPia>wNm5VWf%C$0n$g6K^j!pS`1Fs$;^?ty`wT{Iry~^mf(Rh_~u^;i8*dy`|mc z;N0rqTPJ|=GvL=~`nNiM?EXzpf8+~-7UhEFZK#wr<=}bORk8<+6hUF2N6beI!9-xA zrJk>e%i40VB_0a9`;t!HX`|DA5@}zfc3~JMd_gB(;`;Vg@|gEWgd|b>qTG{?F-`V4tv!Da5OQ zEPkI}?E52pV21l{h5s)rSTi=x4*+!K{TrZFg>>BW(;xj!WqJjLV(M?L#}HKawU*$IL&{;kWTTbXE!mH4Ah#it^UM!_Op8Ql>TYR^g@4HhR0oCuQ)!v3Smmi03@ADR0a3)13p=HUh zeE=zI*X)UBXlR#XJzBYlH*Q;6j81Hue^`3{y+Nqq6yzK*r_VsrP0dhq~ z!vpTs2a?m0rd(X0`>~ap`0(>s4PJ>%aHuzYBGGlLPRxQTioxV?If*5Lu1Ew3_vG7*l$#q{RUDKy)F1q z>K?>{i+rJj>eroHfFL zQz7L>_vkqemwomQ-tTXXy-_0(dw~V0%OE(v)#k8uO)JW=*mWmZ{*8=_VxV%_m3^-C z771zZK>o`COD}Q8B3se2%5l`>cbxC6EwX*-;$-?1YrnAgdso%Lo(nJg?T;$(z*x~> zRN@uO$zc?SxX-X^Y>#8z*+UQ4e8TMn?Of|da&>Y`%aBxV4A%R3BpnZ5)TGrxS!t&t zNpTf1d`1O^jzwi&N|KD~S+(+EVGuh_S~q+Ro&q!app62B3bi(R>x38(4VCEH9T zA(@Ogrxj;Gg{MjI4!y&vgmn|LsBhEx;09v8*-6yRZN5Hrn79vK@_Z4pK z)r;LFsOeqH6Bzh9J)a?nMSXPW(i9Oli7FyO6DBRjR*CbpV}b%KPxocTBa9li_BA>& zJ1E1Y8unh-KIe;!$a-uiB%F}hqQcQMu*J9+z(@UWuh`fr)^s@EOXQl69cD?m)4Er> znhwF#n^C1VK<0sO=udl_+*K4A0M5U!xmrw>n4vi2f+>s{Gjp;T^KM|%ttB^38uv8) zhy6pr>-PmX>CsPc#?Ruas`9oYdJdsIYa;$# zjN{`IsZ4m>Bf?O+G2p;?zgc!BcZLIzk9l9T;d=bYJp0Rae_Z|84++`+B@Rg(1*RC@gx=6dPzVZNC|Be>iTkPT*KmfkYL zu%R0s=bLj1KyGbOW-`tiu>J9Ro8#N}{TK93x5O#r%Ws?Tp{5VL;XqtLJNuW%ZQ@>b z@~VhqE;$=3(ISp-dDny1LzxVu^sAwg`n8xThU-xj%}VH~+beiX>!vj?__{Be$uu5m z83`E~z-YBwWEVvdtAt@)OLd)w@So-~2M@Zr%RSV)@zm^+-E6U;{ixnVO>mDzIRP)6 zWa~m|;?-20>N?l%sDRylda6D#t9{S*fj)JUQ02Nr-7~o>n_OGEtP@_m&Qy}nfb@n< zcXGgD*A@EW`@E`Z9;Ov~JW6x)Fk6QykmPREUkuk`nxZ_&(exQxAYuUqgrS*iRDBh6;rk9L9L zTN7dlxZ-$C!hMA;G?%@5t;;wHatn)3ZHgIJ?o-bw!AYnHN{Ps7PSqgb>!u^f+p#=U zU)1oCB_l-*tvgP;6l}L%Mp@)VpD(zl_<;ZFgN}xu21XpsE}nJP*V7YS6qa4TUnW4E zs970ZYNsX4sJJpqw>Xa^iMtfscU zvqT%)GUX!d7`Pmfr>d@6QO##n%=vKJ#N!T>7mo7Xh-8ahLj9+tE^XI6)#ZzqCRE-_W+q7>FrSAmN|pLxxOnwB&e89 z+qKX$E|m;-PfT%At+loS0bP;pn4x48`T4^qCw#{=#&9cYV<&}(G=&r&%me_iB41Ma zAh^YDIgETiLgJ+HG|_jqx>>Kcyua}M+V6Jw-X8vK`o$7q7BTFfhCS?sl&J;nmNKPP z+uX=G(GeU=!9yItug&e!O8rgN59!@y==RjXGrU9tgf3wOvIV_nEpAoB`BPIPny@DBnnU8N z0I=i3#Jf(oJD43$+e`Kg+bXG+6!>2v_hZ|%Y^`}@&B3~ZI@vptLS3gANTpyppOQc9 zZ2(#Wz%Xkv64N$^C%6B5-H_SJwzr2%ax-SQ{*T4aI zZYyCyd9|5yRvCnFfvm50(SO$#_`MH)w?KdvMXP4VRQ7p*TuZf^B4*-2sC?fLxu0%^ znceC_gCO|;Wfp#FATaXM|2FcvLwFcSokTw6Ys%N6hvKRV)URvfQe7Rx7(|r>;&&aX zo4+g1K=Rk}_dHmb8>B|vPmyAA+GZB6O`g0_KjS>*ebs%(iRs=OPdEjD2`QZfglfPr zE&};OX3mEhi5KS&C>#aQ0HLk&zll==lPcB^M8Q!F$^d+E!Xb(vFw@asKhJblR093} zn<^BI^Ou>f=bIFq`HW^xNsh4`S0NuFc`VMcjh#xR+CVumak{$Ys}s!v%Tp3eHH6{M ztAG2ISHfLOxUFpcwf74C$}24!{FMv#qUcuxh&5GDFlGqzvj@|t0&<1=Qrc<_avKu? zy498H%!3!~#R}VLG7S?aSR*oyzG-JLz>ss%NWcrQASwMimwgzI12GjH6wEqT+nCy0qf~ms!6WPb3hY9}5N-3@=qk;}OTrPY-JU$4VIHmZEvCp^( vd=NXn=k`xE8sMGt-;xyQds)A^(EZbSI^S*i-Im|m!1p%rJ8eK@qvyW>xRJLr From bba5da2ba56fd05218607fced63e2026ec5a8c03 Mon Sep 17 00:00:00 2001 From: Noah Falk Date: Thu, 18 Mar 2021 04:13:09 -0700 Subject: [PATCH 4/9] Updating toc --- docs/core/diagnostics/logging-tracing.md | 6 +++++- docs/fundamentals/toc.yml | 10 +++++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/docs/core/diagnostics/logging-tracing.md b/docs/core/diagnostics/logging-tracing.md index bb4ed7494ef2b..c5fa1f5b8edc2 100644 --- a/docs/core/diagnostics/logging-tracing.md +++ b/docs/core/diagnostics/logging-tracing.md @@ -66,7 +66,11 @@ The following APIs are more event oriented. Rather than logging simple strings t ## Distributed Tracing -[Distributed Tracing](./distributed-tracing.md) is the way to publish and observe the tracing data in a distributed system. +[Distributed Tracing](./distributed-tracing.md) is a diagnostic technique that helps engineers +localize failures and performance issues within applications, especially those that may be +distributed across multiple machines or processes. This technique tracks requests through an +application correlating together work done by different application components and separating +it from other work the application may be doing for concurrent requests. ## ILogger and logging frameworks diff --git a/docs/fundamentals/toc.yml b/docs/fundamentals/toc.yml index 826b4ddd3b3aa..7a206537c611c 100644 --- a/docs/fundamentals/toc.yml +++ b/docs/fundamentals/toc.yml @@ -427,7 +427,15 @@ items: - name: Well-known event providers href: ../core/diagnostics/well-known-event-providers.md - name: Distributed Tracing - href: ../core/diagnostics/distributed-tracing.md + items: + - name: Overview + href: ../core/diagnostics/distributed-tracing.md + - name: Concepts + href: ../core/diagnostics/distributed-tracing-concepts.md + - name: Instrumentation + href: ../core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md + - name: Collection + href: ../core/diagnostics/distributed-tracing-collection-walkthroughs.md - name: Symbols href: ../core/diagnostics/symbols.md - name: Runtime events From 269e2481162cae04539e1aafcbd226c5abccbbc5 Mon Sep 17 00:00:00 2001 From: Noah Falk Date: Thu, 18 Mar 2021 04:41:07 -0700 Subject: [PATCH 5/9] Fix xref --- .../distributed-tracing-instrumentation-walkthroughs.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md index b7611ce7fa0d4..a04ab430494c5 100644 --- a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md @@ -434,7 +434,7 @@ kind parameter on When work occurs in batch processing systems a single Activity might represent work on behalf of many different requests simultaneously, each of which has its own trace-id. Although Activity is restricted to have a single parent, it can link to additional trace-ids using -. Each ActivityLink is +. Each ActivityLink is populated with an that stores ID information about the Activity being linked to. ActivityContext can be retrieved from in-process Activity objects using or From 14101c7ae2ba2425e6d55911f21503733b9c32a1 Mon Sep 17 00:00:00 2001 From: Noah Falk Date: Wed, 24 Mar 2021 02:19:28 -0700 Subject: [PATCH 6/9] Addressing more feedback --- ...ributed-tracing-collection-walkthroughs.md | 19 ++++++++++++------- .../distributed-tracing-concepts.md | 15 ++++++++------- ...ed-tracing-instrumentation-walkthroughs.md | 2 +- 3 files changed, 21 insertions(+), 15 deletions(-) diff --git a/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md index 612ccf8e6e812..d2c410e5bb321 100644 --- a/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md @@ -10,7 +10,7 @@ ms.date: 03/14/2021 **This article applies to: ✔️** .NET Core 2.1 and later versions **and** .NET Framework 4.5 and later versions Instrumented code can create objects as part of a distributed trace, but the information -in these objects needs to be collected into a centralized persistant store so that the entire trace can be +in these objects needs to be collected into centralized storage so that the entire trace can be reviewed later. In this tutorial you will collect the distributed trace telemetry in different ways so that it is available to diagnose application issues when needed. See [the instrumentation tutorial](distributed-tracing-instrumentation-walkthroughs.md) if you need to add new instrumentation. @@ -19,11 +19,15 @@ available to diagnose application issues when needed. See ### Prerequisites -- [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download/dotnet) or a later version +- [.NET Core 2.1 SDK](https://dotnet.microsoft.com/download/dotnet) or a later version ### Create an example application -First you will create an example application that has some distributed trace instrumentation but nothing is being collected. +Before any distributed trace telemetry can be collected we need to produce it. Often this instrumentation might be +in libraries but for simplicity you will create a small app that has some example instrumentation using +. At this point no collection is happening yet, +StartActivity() has no side-effect and returns null. See +[the instrumentation tutorial](distributed-tracing-instrumentation-walkthroughs.md) for more details. ```dotnetcli dotnet new console @@ -213,7 +217,7 @@ it to the console. ### Prerequisites -- [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download/dotnet) or a later version +- [.NET Core 2.1 SDK](https://dotnet.microsoft.com/download/dotnet) or a later version ### Create an example application @@ -334,9 +338,10 @@ the W3C TraceContext ID format by default but earlier .NET versions default to u during the lifetime of an Activity. - - Each -Activity is associated with an ActivitySource which acts as a namespace for a set of Activities. -This callback is invoked once for each ActivitySource in the process. Returning true indicates -the listener should be notified about Activities associated with this source. +Activity is associated with an ActivitySource which acts as its namespace and producer. +This callback is invoked once for each ActivitySource in the process. Return true +if you are interested in performing sampling or being notified about start/stop events +for Activities produced by this source. - - By default does not create an Activity object unless some ActivityListener indicates it should be sampled. Returning diff --git a/docs/core/diagnostics/distributed-tracing-concepts.md b/docs/core/diagnostics/distributed-tracing-concepts.md index 8ffdf64ee1d79..e8b83845580b7 100644 --- a/docs/core/diagnostics/distributed-tracing-concepts.md +++ b/docs/core/diagnostics/distributed-tracing-concepts.md @@ -82,12 +82,13 @@ W3C TraceContext ID format .NET will also use the HTTP headers recommended by [the standard](https://www.w3.org/TR/trace-context/) to transmit this information. When using the ID format .NET uses a custom request-id HTTP header to transmit the ID. Unlike many other language runtimes -.NET in-box libraries natively understand how to decode and encode Activity IDs on HTTP messages -as well as how to flow the ID through sychronous and asynchronous calls. This means that .NET -applications that receive and emit HTTP messages participate in flowing distributed trace IDs -automatically, with no special coding by the app developer nor 3rd party library dependencies. -3rd party libraries may add support for transmitting IDs over non-HTTP message protocols or -supporting custom encoding conventions for HTTP. +.NET in-box libraries such as the ASP.NET web server and System.Net.Http natively understand how to +decode and encode Activity IDs on HTTP messages. The runtime also understands how to flow the ID +through sychronous and asynchronous calls. This means that .NET applications that receive and +emit HTTP messages participate in flowing distributed trace IDs automatically, with no special +coding by the app developer nor 3rd party library dependencies. 3rd party libraries may add +support for transmitting IDs over non-HTTP message protocols or supporting custom encoding +conventions for HTTP. ### Collecting traces @@ -115,7 +116,7 @@ conventions. For improved performance in high throughput applications, distributed tracing on .NET supports sampling only a subset of requests rather than recording all of them. For activites created with the recommended -API, logging libraries can control sampling with the +API, telemetry collection libraries can control sampling with the callback. The logging library can elect not to create the Activity at all, to create it with minimal information necessary to propagate distributing tracing IDs, or to populate it with complete diff --git a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md index a04ab430494c5..d57572a2f2016 100644 --- a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md @@ -17,7 +17,7 @@ produced by this instrumentation. ## Prerequisites -- [.NET Core 3.1 SDK](https://dotnet.microsoft.com/download/dotnet) or a later version +- [.NET Core 2.1 SDK](https://dotnet.microsoft.com/download/dotnet) or a later version ## An initial app From 44d5d5e42ebc8c6955094cadad18e199c583449f Mon Sep 17 00:00:00 2001 From: Noah Falk Date: Wed, 24 Mar 2021 02:54:58 -0700 Subject: [PATCH 7/9] More feedback --- .../distributed-tracing-collection-walkthroughs.md | 8 +++----- docs/core/diagnostics/distributed-tracing-concepts.md | 2 +- .../distributed-tracing-instrumentation-walkthroughs.md | 5 ++++- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md index d2c410e5bb321..fcb5001b63814 100644 --- a/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-collection-walkthroughs.md @@ -88,7 +88,7 @@ namespace Sample.DistributedTracing } ``` -Running the app does not record any tracing information yet +Running the app does not collect any trace data yet: ```dotnetcli > dotnet run @@ -104,11 +104,9 @@ OpenTelemetry can be reconfigured to send it elsewhere. See the [OpenTelemetry getting started guide](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/docs/trace/getting-started/README.md) for more information. -Add the [OpenTelemetry](https://www.nuget.org/packages/OpenTelemetry/) and -[OpenTelemetry.Exporter.Console](https://www.nuget.org/packages/OpenTelemetry.Exporter.Console/) NuGet packages. +Add the [OpenTelemetry.Exporter.Console](https://www.nuget.org/packages/OpenTelemetry.Exporter.Console/) NuGet package. ```dotnetcli -dotnet add package OpenTelemetry dotnet add package OpenTelemetry.Exporter.Console ``` @@ -289,7 +287,7 @@ Running the app does not collect any trace data yet: Example work done ``` -### Add code to observe the Activities +### Add code to collect the traces Update Main() with this code: diff --git a/docs/core/diagnostics/distributed-tracing-concepts.md b/docs/core/diagnostics/distributed-tracing-concepts.md index e8b83845580b7..99cdc65383d5a 100644 --- a/docs/core/diagnostics/distributed-tracing-concepts.md +++ b/docs/core/diagnostics/distributed-tracing-concepts.md @@ -114,7 +114,7 @@ conventions. ### Sampling For improved performance in high throughput applications, distributed tracing on .NET supports -sampling only a subset of requests rather than recording all of them. For activites created with +sampling only a subset of traces rather than recording all of them. For activites created with the recommended API, telemetry collection libraries can control sampling with the callback. diff --git a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md index d57572a2f2016..94d14f6783bdd 100644 --- a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md @@ -448,9 +448,12 @@ void DoBatchWork(ActivityContext[] requestContexts) using(Activity activity = s_source.StartActivity(name: "BigBatchOfWork", kind: ActivityKind.Internal, parentContext: null, - links: requestIds.Select(ctx => new ActivityLink(ctx)) + links: requestContexts.Select(ctx => new ActivityLink(ctx)) { // do the batch of work here } } ``` + +Unlike events and Tags that can be added on-demand, links must be added during StartActivity() and +are immutable afterwards. \ No newline at end of file From 982f4b176f775cffcbc1b58ed40881c6ed5201cc Mon Sep 17 00:00:00 2001 From: Noah Falk Date: Wed, 24 Mar 2021 03:01:31 -0700 Subject: [PATCH 8/9] newline --- .../distributed-tracing-instrumentation-walkthroughs.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md index 94d14f6783bdd..f40f548b21bd4 100644 --- a/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md +++ b/docs/core/diagnostics/distributed-tracing-instrumentation-walkthroughs.md @@ -456,4 +456,4 @@ void DoBatchWork(ActivityContext[] requestContexts) ``` Unlike events and Tags that can be added on-demand, links must be added during StartActivity() and -are immutable afterwards. \ No newline at end of file +are immutable afterwards. From 4d7942027da96fa80edabe7b57337e2307bb6bba Mon Sep 17 00:00:00 2001 From: Noah Falk Date: Wed, 24 Mar 2021 03:19:07 -0700 Subject: [PATCH 9/9] last touchups I hope --- docs/core/diagnostics/distributed-tracing.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/core/diagnostics/distributed-tracing.md b/docs/core/diagnostics/distributed-tracing.md index 05b4ca716ccb8..bfc825a180af4 100644 --- a/docs/core/diagnostics/distributed-tracing.md +++ b/docs/core/diagnostics/distributed-tracing.md @@ -10,7 +10,7 @@ performance issues within applications, especially those that may be distributed multiple machines or processes. This technique tracks requests through an application correlating together work done by different application components and separating it from other work the application may be doing for concurrent requests. For example a request to a -typical web service might be first received by a load balancer, then forwarded to web server +typical web service might be first received by a load balancer, then forwarded to a web server process, which then makes several queries to a database. Using distributed tracing allows engineers to distinguish if any of those steps failed, how long each step took, and potentially logging messages produced by each step as it ran. @@ -24,8 +24,8 @@ then use a corresponding library to transmit the distributed tracing telemetry t service. [OpenTelemetry](https://github.com/open-telemetry/opentelemetry-dotnet/blob/main/docs/trace/getting-started/README.md) is a vendor neutral library that supports several services, [Application Insights](https://docs.microsoft.com/azure/azure-monitor/app/distributed-tracing) -is provided by Microsoft, and there are many high quality 3rd party APM vendors that offer -integrated .NET solutions. +is a full featured service provided by Microsoft, and there are many high quality 3rd party APM vendors +that offer integrated .NET solutions. - [Understand distributed tracing concepts](distributed-tracing-concepts.md) - Guides